Copy disabled (too large)
Download .txt
Showing preview only (22,562K chars total). Download the full file to get everything.
Repository: shantanu1109/Coursera-DeepLearning.AI-Stanford-University-Machine-Learning-Specialization
Branch: main
Commit: d9b9e6c8efa8
Files: 194
Total size: 63.6 MB
Directory structure:
gitextract_0npo72x2/
├── CODE_OF_CONDUCT.md
├── Course-1-Supervised-Machine-Learning-Regression-and-Classification/
│ ├── Course-1-Week-1/
│ │ ├── Course-1-Week-1-Lecture-Slides/
│ │ │ └── Course-1-Week-1-Lecture-Slides.md
│ │ ├── Course-1-Week-1-Optional-Labs/
│ │ │ ├── Course-1-Week-1-Optional-Labs-1-Python-and-Jupyter-Notebook.ipynb
│ │ │ ├── Course-1-Week-1-Optional-Labs-3-Model-Representation.ipynb
│ │ │ ├── Course-1-Week-1-Optional-Labs-4-Cost-function.ipynb
│ │ │ ├── Course-1-Week-1-Optional-Labs-5-Gradient-Descent.ipynb
│ │ │ ├── Course-1-Week-1-Optional-Labs.md
│ │ │ ├── data/
│ │ │ │ ├── Course-1-Week-1-Optional-Labs-data.md
│ │ │ │ └── data.txt
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-1-Week-1-Optional-Labs-images.md
│ │ │ ├── lab_utils_common.py
│ │ │ └── lab_utils_uni.py
│ │ ├── Course-1-Week-1-Practice-Quiz/
│ │ │ └── Course-1-Week-1-Practice-Quiz.md
│ │ └── Course-1-Week-1.md
│ ├── Course-1-Week-2/
│ │ ├── Course-1-Week-2-Lecture-Slides/
│ │ │ └── Course-1-Week-2-Lecture-Slides.md
│ │ ├── Course-1-Week-2-Optional-Labs/
│ │ │ ├── Course-1-Week-2-Optional-Labs-1-Python-Numpy-Vectorization.ipynb
│ │ │ ├── Course-1-Week-2-Optional-Labs-2-Multiple-Linear-Regression.ipynb
│ │ │ ├── Course-1-Week-2-Optional-Labs-3-Feature-Scaling-and-Learning-Rate.ipynb
│ │ │ ├── Course-1-Week-2-Optional-Labs-4-Feature-Engineering-and-Polynomial-Regression.ipynb
│ │ │ ├── Course-1-Week-2-Optional-Labs-5-Linear-Regression-with-Scikit-Learn.ipynb
│ │ │ ├── Course-1-Week-2-Optional-Labs-6-Sklearn-Normalization.ipynb
│ │ │ ├── Course-1-Week-2-Optional-Labs.md
│ │ │ ├── data/
│ │ │ │ ├── Course-1-Week-2-Optional-Labs-data.md
│ │ │ │ └── houses.txt
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-1-Week-2-Optional-Labs-images.md
│ │ │ ├── lab_utils_common.py
│ │ │ └── lab_utils_multi.py
│ │ ├── Course-1-Week-2-Practice-Labs/
│ │ │ ├── Course-1-Week-2-Practice-Labs-1-Linear-Regression.ipynb
│ │ │ ├── Course-1-Week-2-Practice-Labs.md
│ │ │ ├── data/
│ │ │ │ ├── Course-1-Week-2-Practice-Labs-data.md
│ │ │ │ ├── ex1data1.txt
│ │ │ │ └── ex1data2.txt
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Course-1-Week-2-Practice-Quiz/
│ │ │ └── Course-1-Week-2-Practice-Quiz.md
│ │ └── Course-1-Week-2.md
│ ├── Course-1-Week-3/
│ │ ├── Course-1-Week-3-Lecture-Slides/
│ │ │ └── Course-1-Week-3-Lecture-Slides.md
│ │ ├── Course-1-Week-3-Optional-Labs/
│ │ │ ├── Course-1-Week-3-Optional-Labs-1-Classification.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-2-Sigmoid-function-and-Logistic-Regression.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-3-Decision-Boundary.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-4-Logistic-Loss.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-5-Cost-Function-for-Logistic-Regression.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-6-Gradient-Descent-for-Logistic-Regression.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-7-Logistic-Regression-with-Scikit-Learn.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-8-Overfitting.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs-9-Regularization.ipynb
│ │ │ ├── Course-1-Week-3-Optional-Labs.md
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-1-Week-3-Optional-Labs-images.md
│ │ │ ├── lab_utils_common.py
│ │ │ ├── plt_logistic_loss.py
│ │ │ ├── plt_one_addpt_onclick.py
│ │ │ ├── plt_overfit.py
│ │ │ └── plt_quad_logistic.py
│ │ ├── Course-1-Week-3-Practice-Labs/
│ │ │ ├── Course-1-Week-3-Practice-Labs-1-Logistic-Regression.ipynb
│ │ │ ├── Course-1-Week-3-Practice-Labs.md
│ │ │ ├── data/
│ │ │ │ ├── Course-1-Week-3-Optional-Labs-data.md
│ │ │ │ ├── ex2data1.txt
│ │ │ │ └── ex2data2.txt
│ │ │ ├── images/
│ │ │ │ └── Course-1-Week-3-Practice-Labs-images.md
│ │ │ ├── public_tests.py
│ │ │ ├── test_utils.py
│ │ │ └── utils.py
│ │ ├── Course-1-Week-3-Practice-Quiz/
│ │ │ └── Course-1-Week-3-Practice-Quiz.md
│ │ └── Course-1-Week-3.md
│ └── Course-1.md
├── Course-2-Advanced-Learning-Algorithms/
│ ├── Course-2-Week-1/
│ │ ├── Course-2-Week-1-Lecture-Slides/
│ │ │ └── Course-2-Week-1-Lecture-Slides.md
│ │ ├── Course-2-Week-1-Optional-Labs/
│ │ │ ├── Course-2-Week-1-Optional-Labs-1-Neurons-and-Layers.ipynb
│ │ │ ├── Course-2-Week-1-Optional-Labs-2-Coffee-Roasting-in-Tensorflow.ipynb
│ │ │ ├── Course-2-Week-1-Optional-Labs-3-Coffee-Roasting-Numpy.ipynb
│ │ │ ├── Course-2-Week-1-Optional-Labs.md
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-2-Week-1-Optional-Labs-images.md
│ │ │ ├── lab_coffee_utils.py
│ │ │ ├── lab_neurons_utils.py
│ │ │ ├── lab_utils_common.py
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Course-2-Week-1-Practice-Labs/
│ │ │ ├── Course-2-Week-1-Practice-Labs-1-Neural-Networks-for-Binary-Classification.ipynb
│ │ │ ├── Course-2-Week-1-Practice-Labs.md
│ │ │ ├── autils.py
│ │ │ ├── data/
│ │ │ │ ├── Course-2-Week-1-Practice-Labs-data.md
│ │ │ │ ├── X.npy
│ │ │ │ └── y.npy
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-2-Week-1-Practice-Labs-images.md
│ │ │ ├── lab_neurons_utils.py
│ │ │ ├── lab_utils_common.py
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Course-2-Week-1-Practice-Quiz/
│ │ │ └── Course-2-Week-1-Practice-Quiz.md
│ │ └── Course-2-Week-1.md
│ ├── Course-2-Week-2/
│ │ ├── Course-2-Week-2-Lecture-Slides/
│ │ │ └── Course-2-Week-2-Lecture-Slides.md
│ │ ├── Course-2-Week-2-Optional-Labs/
│ │ │ ├── Course-2-Week-2-Optional-Labs-1-Relu-Activation.ipynb
│ │ │ ├── Course-2-Week-2-Optional-Labs-2-SoftMax.ipynb
│ │ │ ├── Course-2-Week-2-Optional-Labs-3-Multiclass.ipynb
│ │ │ ├── Course-2-Week-2-Optional-Labs.md
│ │ │ ├── autils.py
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-2-Week-2-Optional-Labs-images.md
│ │ │ ├── lab_utils_common.py
│ │ │ ├── lab_utils_multiclass.py
│ │ │ ├── lab_utils_multiclass_TF.py
│ │ │ ├── lab_utils_relu.py
│ │ │ └── lab_utils_softmax.py
│ │ ├── Course-2-Week-2-Practice-Labs/
│ │ │ ├── Course-2-Week-2-Practice-Labs-1-Neural-Networks-for-Multiclass-Classification.ipynb
│ │ │ ├── Course-2-Week-2-Practice-Labs.md
│ │ │ ├── autils.py
│ │ │ ├── data/
│ │ │ │ ├── Course-2-Week-2-Practice-Labs-data.md
│ │ │ │ ├── X.npy
│ │ │ │ └── y.npy
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-2-Week-2-Practice-Labs-images.md
│ │ │ ├── lab_utils_common.py
│ │ │ ├── lab_utils_softmax.py
│ │ │ └── public_tests.py
│ │ ├── Course-2-Week-2-Practice-Quiz/
│ │ │ └── Course-2-Week-2-Practice-Quiz.md
│ │ └── Course-2-Week-2.md
│ ├── Course-2-Week-3/
│ │ ├── Course-2-Week-3-Lecture-Slides/
│ │ │ └── Course-2-Week-3-Lecture-Slides.md
│ │ ├── Course-2-Week-3-Practice-Labs/
│ │ │ ├── Course-2-Week-3-Practice-Labs-1-Advice-for-Applying-Machine-Learning.ipynb
│ │ │ ├── Course-2-Week-3-Practice-Labs.md
│ │ │ ├── assigment_utils.py
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── Course-2-Week-3-Practice-Labs-images.md
│ │ │ ├── public_tests_a1.py
│ │ │ └── utils.py
│ │ ├── Course-2-Week-3-Practice-Quiz/
│ │ │ └── Course-2-Week-3-Practice-Quiz.md
│ │ └── Course-2-Week-3.md
│ ├── Course-2-Week-4/
│ │ ├── Course-2-Week-4-Lecture-Slides/
│ │ │ └── Course-2-Week-4-Lecture-Slides.md
│ │ ├── Course-2-Week-4-Practice-Labs/
│ │ │ ├── Course-2-Week-4-Practice-Labs-1-Decision-Tree-with-Markdown.ipynb
│ │ │ ├── Course-2-Week-4-Practice-Labs.md
│ │ │ └── public_tests.py
│ │ ├── Course-2-Week-4-Practice-Quiz/
│ │ │ └── Course-2-Week-4-Practice-Quiz.md
│ │ └── Course-2-Week-4.md
│ └── Course-2.md
├── Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/
│ ├── Course-3-Week-1/
│ │ ├── Course-3-Week-1-Lecture-Slides/
│ │ │ └── Course-3-Week-1-Lecture-Slides.md
│ │ ├── Course-3-Week-1-Practice-Labs/
│ │ │ ├── Course-3-Week-1-Practice-Labs-1-KMeans.ipynb
│ │ │ ├── Course-3-Week-1-Practice-Labs-2-Anomaly_Detection.ipynb
│ │ │ ├── Course-3-Week-1-Practice-Labs.md
│ │ │ ├── data/
│ │ │ │ ├── Course-3-Week-1-Practice-Labs-data.md
│ │ │ │ ├── X_part1.npy
│ │ │ │ ├── X_part2.npy
│ │ │ │ ├── X_val_part1.npy
│ │ │ │ ├── X_val_part2.npy
│ │ │ │ ├── ex7_X.npy
│ │ │ │ ├── y_val_part1.npy
│ │ │ │ └── y_val_part2.npy
│ │ │ ├── images/
│ │ │ │ └── Course-3-Week-1-Practice-Labs-images.md
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Course-3-Week-1-Practice-Quiz/
│ │ │ └── Course-3-Week-1-Practice-Quiz.md
│ │ └── Course-3-Week-1.md
│ ├── Course-3-Week-2/
│ │ ├── Course-3-Week-2-Lecture-Slides/
│ │ │ └── Course-3-Week-2-Lecture-Slides.md
│ │ ├── Course-3-Week-2-Practice-Labs/
│ │ │ ├── Course-3-Week-1-Practice-Labs-1-Collaborative-Filtering-Recommender-Systems.ipynb
│ │ │ ├── Course-3-Week-2-Practice-Labs-2-Deep-Learning-For-Content-Based-Filtering.ipynb
│ │ │ ├── Course-3-Week-2-Practice-Labs.md
│ │ │ ├── data/
│ │ │ │ ├── Course-3-Week-2-Practice-Labs-data.md
│ │ │ │ ├── content_item_train.csv
│ │ │ │ ├── content_item_train_header.txt
│ │ │ │ ├── content_item_vecs.csv
│ │ │ │ ├── content_movie_list.csv
│ │ │ │ ├── content_user_to_genre.pickle
│ │ │ │ ├── content_user_train.csv
│ │ │ │ ├── content_user_train_header.txt
│ │ │ │ ├── content_y_train.csv
│ │ │ │ ├── small_movie_list.csv
│ │ │ │ ├── small_movies_R.csv
│ │ │ │ ├── small_movies_W.csv
│ │ │ │ ├── small_movies_X.csv
│ │ │ │ ├── small_movies_Y.csv
│ │ │ │ └── small_movies_b.csv
│ │ │ ├── images/
│ │ │ │ └── Course-3-Week-2-Practice-Labs-images.md
│ │ │ ├── public_tests.py
│ │ │ ├── recsysNN_utils.py
│ │ │ └── recsys_utils.py
│ │ ├── Course-3-Week-2-Practice-Quiz/
│ │ │ └── Course-3-Week-2-Practice-Quiz.md
│ │ └── Course-3-Week-2.md
│ ├── Course-3-Week-3/
│ │ ├── Course-3-Week-3-Optional-Labs/
│ │ │ ├── Course-3-Week-3-Optional-Labs-1-State-Action-Value-Function.ipynb
│ │ │ ├── Course-3-Week-3-Optional-Labs.md
│ │ │ └── utils.py
│ │ ├── Course-3-Week-3-Practice-Labs/
│ │ │ ├── Course-3-Week-3-Practice-Labs-1-Reinforcement-Learning.ipynb
│ │ │ ├── Course-3-Week-3-Practice-Labs.md
│ │ │ ├── images/
│ │ │ │ └── Course-3-Week-3-Practice-Labs-images.md
│ │ │ ├── lunar_lander_model.h5
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Course-3-Week-3-Practice-Quiz/
│ │ │ └── Course-3-Week-3-Practice-Quiz.md
│ │ └── Course-3-Week-3.md
│ └── Course-3.md
├── Course-Certificates/
│ └── Course-Certificates.md
├── LICENSE
└── README.md
================================================
FILE CONTENTS
================================================
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.
## Our Standards
Examples of behavior that contributes to a positive environment for our
community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.
Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.
## Scope
This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
.
All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the
reporter of any incident.
## Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:
### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.
### 2. Warning
**Community Impact**: A violation through a single incident or series
of actions.
**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.
### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.
### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior, harassment of an
individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within
the community.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.0, available at
https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by [Mozilla's code of conduct
enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at
https://www.contributor-covenant.org/translations.
================================================
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Lecture-Slides/Course-1-Week-1-Lecture-Slides.md
================================================
================================================
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-1-Python-and-Jupyter-Notebook.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Optional Lab: Brief Introduction to Python and Jupyter Notebooks\n",
"Welcome to the first optional lab! \n",
"Optional labs are available to:\n",
"- provide information - like this notebook\n",
"- reinforce lecture material with hands-on examples\n",
"- provide working examples of routines used in the graded labs"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Goals\n",
"In this lab, you will:\n",
"- Get a brief introduction to Jupyter notebooks\n",
"- Take a tour of Jupyter notebooks\n",
"- Learn the difference between markdown cells and code cells\n",
"- Practice some basic python\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The easiest way to become familiar with Jupyter notebooks is to take the tour available above in the Help menu:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<figure>\n",
" <center> <img src=\"./images/C1W1L1_Tour.PNG\" alt='missing' width=\"400\" ><center/>\n",
"<figure/>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jupyter notebooks have two types of cells that are used in this course. Cells such as this which contain documentation called `Markdown Cells`. The name is derived from the simple formatting language used in the cells. You will not be required to produce markdown cells. Its useful to understand the `cell pulldown` shown in graphic below. Occasionally, a cell will end up in the wrong mode and you may need to restore it to the right state:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<figure>\n",
" <img src=\"./images/C1W1L1_Markdown.PNG\" alt='missing' width=\"400\" >\n",
"<figure/>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The other type of cell is the `code cell` where you will write your code:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is code cell\n"
]
}
],
"source": [
"#This is a 'Code' Cell\n",
"print(\"This is code cell\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Python\n",
"You can write your code in the code cells. \n",
"To run the code, select the cell and either\n",
"- hold the shift-key down and hit 'enter' or 'return'\n",
"- click the 'run' arrow above\n",
"<figure>\n",
" <img src=\"./images/C1W1L1_Run.PNG\" width=\"400\" >\n",
"<figure/>\n",
"\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Print statement\n",
"Print statements will generally use the python f-string style. \n",
"Try creating your own print in the following cell. \n",
"Try both methods of running the cell."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"f strings allow you to embed variables right in the strings!\n"
]
}
],
"source": [
"# print statements\n",
"variable = \"right in the strings!\"\n",
"print(f\"f strings allow you to embed variables {variable}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Congratulations!\n",
"You now know how to find your way around a Jupyter Notebook."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.6"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
================================================
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-3-Model-Representation.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Optional Lab: Model Representation\n",
"\n",
"<figure>\n",
" <img src=\"./images/C1_W1_L3_S1_Lecture_b.png\" style=\"width:600px;height:200px;\">\n",
"</figure>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Goals\n",
"In this lab you will:\n",
"- Learn to implement the model $f_{w,b}$ for linear regression with one variable"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Notation\n",
"Here is a summary of some of the notation you will encounter. \n",
"\n",
"|General <img width=70/> <br /> Notation <img width=70/> | Description<img width=350/>| Python (if applicable) |\n",
"|: ------------|: ------------------------------------------------------------||\n",
"| $a$ | scalar, non bold ||\n",
"| $\\mathbf{a}$ | vector, bold ||\n",
"| **Regression** | | | |\n",
"| $\\mathbf{x}$ | Training Example feature values (in this lab - Size (1000 sqft)) | `x_train` | \n",
"| $\\mathbf{y}$ | Training Example targets (in this lab Price (1000s of dollars)). | `y_train` \n",
"| $x^{(i)}$, $y^{(i)}$ | $i_{th}$Training Example | `x_i`, `y_i`|\n",
"| m | Number of training examples | `m`|\n",
"| $w$ | parameter: weight, | `w` |\n",
"| $b$ | parameter: bias | `b` | \n",
"| $f_{w,b}(x^{(i)})$ | The result of the model evaluation at $x^{(i)}$ parameterized by $w,b$: $f_{w,b}(x^{(i)}) = wx^{(i)}+b$ | `f_wb` | \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tools\n",
"In this lab you will make use of: \n",
"- NumPy, a popular library for scientific computing\n",
"- Matplotlib, a popular library for plotting data"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"plt.style.use('./deeplearning.mplstyle')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Problem Statement\n",
"<img align=\"left\" src=\"./images/C1_W1_L3_S1_trainingdata.png\" style=\" width:380px; padding: 10px; \" /> \n",
"\n",
"As in the lecture, you will use the motivating example of housing price prediction. \n",
"This lab will use a simple data set with only two data points - a house with 1000 square feet(sqft) sold for \\\\$300,000 and a house with 2000 square feet sold for \\\\$500,000. These two points will constitute our *data or training set*. In this lab, the units of size are 1000 sqft and the units of price are 1000s of dollars.\n",
"\n",
"| Size (1000 sqft) | Price (1000s of dollars) |\n",
"| -------------------| ------------------------ |\n",
"| 1.0 | 300 |\n",
"| 2.0 | 500 |\n",
"\n",
"You would like to fit a linear regression model (shown above as the blue straight line) through these two points, so you can then predict price for other houses - say, a house with 1200 sqft.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Please run the following code cell to create your `x_train` and `y_train` variables. The data is stored in one-dimensional NumPy arrays."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x_train = [1. 2.]\n",
"y_train = [300. 500.]\n"
]
}
],
"source": [
"# x_train is the input variable (size in 1000 square feet)\n",
"# y_train is the target (price in 1000s of dollars)\n",
"x_train = np.array([1.0, 2.0])\n",
"y_train = np.array([300.0, 500.0])\n",
"print(f\"x_train = {x_train}\")\n",
"print(f\"y_train = {y_train}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Note**: The course will frequently utilize the python 'f-string' output formatting described [here](https://docs.python.org/3/tutorial/inputoutput.html) when printing. The content between the curly braces is evaluated when producing the output."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Number of training examples `m`\n",
"You will use `m` to denote the number of training examples. Numpy arrays have a `.shape` parameter. `x_train.shape` returns a python tuple with an entry for each dimension. `x_train.shape[0]` is the length of the array and number of examples as shown below."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x_train.shape: (2,)\n",
"Number of training examples is: 2\n"
]
}
],
"source": [
"# m is the number of training examples\n",
"print(f\"x_train.shape: {x_train.shape}\")\n",
"m = x_train.shape[0]\n",
"print(f\"Number of training examples is: {m}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One can also use the Python `len()` function as shown below."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Number of training examples is: 2\n"
]
}
],
"source": [
"# m is the number of training examples\n",
"m = len(x_train)\n",
"print(f\"Number of training examples is: {m}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Training example `x_i, y_i`\n",
"\n",
"You will use (x$^{(i)}$, y$^{(i)}$) to denote the $i^{th}$ training example. Since Python is zero indexed, (x$^{(0)}$, y$^{(0)}$) is (1.0, 300.0) and (x$^{(1)}$, y$^{(1)}$) is (2.0, 500.0). \n",
"\n",
"To access a value in a Numpy array, one indexes the array with the desired offset. For example the syntax to access location zero of `x_train` is `x_train[0]`.\n",
"Run the next code block below to get the $i^{th}$ training example."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(x^(0), y^(0)) = (1.0, 300.0)\n"
]
}
],
"source": [
"i = 0 # Change this to 1 to see (x^1, y^1)\n",
"\n",
"x_i = x_train[i]\n",
"y_i = y_train[i]\n",
"print(f\"(x^({i}), y^({i})) = ({x_i}, {y_i})\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Plotting the data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can plot these two points using the `scatter()` function in the `matplotlib` library, as shown in the cell below. \n",
"- The function arguments `marker` and `c` show the points as red crosses (the default is blue dots).\n",
"\n",
"You can use other functions in the `matplotlib` library to set the title and labels to display"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Plot the data points\n",
"plt.scatter(x_train, y_train, marker='x', c='r')\n",
"# Set the title\n",
"plt.title(\"Housing Prices\")\n",
"# Set the y-axis label\n",
"plt.ylabel('Price (in 1000s of dollars)')\n",
"# Set the x-axis label\n",
"plt.xlabel('Size (1000 sqft)')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Model function\n",
"\n",
"<img align=\"left\" src=\"./images/C1_W1_L3_S1_model.png\" style=\" width:380px; padding: 10px; \" > As described in lecture, the model function for linear regression (which is a function that maps from `x` to `y`) is represented as \n",
"\n",
"$$ f_{w,b}(x^{(i)}) = wx^{(i)} + b \\tag{1}$$\n",
"\n",
"The formula above is how you can represent straight lines - different values of $w$ and $b$ give you different straight lines on the plot. <br/> <br/> <br/> <br/> <br/> \n",
"\n",
"Let's try to get a better intuition for this through the code blocks below. Let's start with $w = 100$ and $b = 100$. \n",
"\n",
"**Note: You can come back to this cell to adjust the model's w and b parameters**"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"w: 100\n",
"b: 100\n"
]
}
],
"source": [
"w = 100\n",
"b = 100\n",
"print(f\"w: {w}\")\n",
"print(f\"b: {b}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, let's compute the value of $f_{w,b}(x^{(i)})$ for your two data points. You can explicitly write this out for each data point as - \n",
"\n",
"for $x^{(0)}$, `f_wb = w * x[0] + b`\n",
"\n",
"for $x^{(1)}$, `f_wb = w * x[1] + b`\n",
"\n",
"For a large number of data points, this can get unwieldy and repetitive. So instead, you can calculate the function output in a `for` loop as shown in the `compute_model_output` function below.\n",
"> **Note**: The argument description `(ndarray (m,))` describes a Numpy n-dimensional array of shape (m,). `(scalar)` describes an argument without dimensions, just a magnitude. \n",
"> **Note**: `np.zero(n)` will return a one-dimensional numpy array with $n$ entries \n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def compute_model_output(x, w, b):\n",
" \"\"\"\n",
" Computes the prediction of a linear model\n",
" Args:\n",
" x (ndarray (m,)): Data, m examples \n",
" w,b (scalar) : model parameters \n",
" Returns\n",
" y (ndarray (m,)): target values\n",
" \"\"\"\n",
" m = x.shape[0]\n",
" f_wb = np.zeros(m)\n",
" for i in range(m):\n",
" f_wb[i] = w * x[i] + b\n",
" \n",
" return f_wb"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now let's call the `compute_model_output` function and plot the output.."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"tmp_f_wb = compute_model_output(x_train, w, b,)\n",
"\n",
"# Plot our model prediction\n",
"plt.plot(x_train, tmp_f_wb, c='b',label='Our Prediction')\n",
"\n",
"# Plot the data points\n",
"plt.scatter(x_train, y_train, marker='x', c='r',label='Actual Values')\n",
"\n",
"# Set the title\n",
"plt.title(\"Housing Prices\")\n",
"# Set the y-axis label\n",
"plt.ylabel('Price (in 1000s of dollars)')\n",
"# Set the x-axis label\n",
"plt.xlabel('Size (1000 sqft)')\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you can see, setting $w = 100$ and $b = 100$ does *not* result in a line that fits our data. \n",
"\n",
"### Challenge\n",
"Try experimenting with different values of $w$ and $b$. What should the values be for a line that fits our data?\n",
"\n",
"#### Tip:\n",
"You can use your mouse to click on the triangle to the left of the green \"Hints\" below to reveal some hints for choosing b and w."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details>\n",
"<summary>\n",
" <font size='3', color='darkgreen'><b>Hints</b></font>\n",
"</summary>\n",
" <p>\n",
" <ul>\n",
" <li>Try $w = 200$ and $b = 100$ </li>\n",
" </ul>\n",
" </p>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Prediction\n",
"Now that we have a model, we can use it to make our original prediction. Let's predict the price of a house with 1200 sqft. Since the units of $x$ are in 1000's of sqft, $x$ is 1.2.\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"$340 thousand dollars\n"
]
}
],
"source": [
"w = 200 \n",
"b = 100 \n",
"x_i = 1.2\n",
"cost_1200sqft = w * x_i + b \n",
"\n",
"print(f\"${cost_1200sqft:.0f} thousand dollars\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Congratulations!\n",
"In this lab you have learned:\n",
" - Linear regression builds a model which establishes a relationship between features and targets\n",
" - In the example above, the feature was house size and the target was house price\n",
" - for simple linear regression, the model has two parameters $w$ and $b$ whose values are 'fit' using *training data*.\n",
" - once a model's parameters have been determined, the model can be used to make predictions on novel data."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.6"
},
"toc-autonumbering": false
},
"nbformat": 4,
"nbformat_minor": 5
}
================================================
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-4-Cost-function.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Optional Lab: Cost Function \n",
"<figure>\n",
" <center> <img src=\"./images/C1_W1_L3_S2_Lecture_b.png\" style=\"width:1000px;height:200px;\" ></center>\n",
"</figure>\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Goals\n",
"In this lab you will:\n",
"- you will implement and explore the `cost` function for linear regression with one variable. \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tools\n",
"In this lab we will make use of: \n",
"- NumPy, a popular library for scientific computing\n",
"- Matplotlib, a popular library for plotting data\n",
"- local plotting routines in the lab_utils_uni.py file in the local directory"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"%matplotlib widget\n",
"import matplotlib.pyplot as plt\n",
"from lab_utils_uni import plt_intuition, plt_stationary, plt_update_onclick, soup_bowl\n",
"plt.style.use('./deeplearning.mplstyle')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Problem Statement\n",
"\n",
"You would like a model which can predict housing prices given the size of the house. \n",
"Let's use the same two data points as before the previous lab- a house with 1000 square feet sold for \\\\$300,000 and a house with 2000 square feet sold for \\\\$500,000.\n",
"\n",
"\n",
"| Size (1000 sqft) | Price (1000s of dollars) |\n",
"| -------------------| ------------------------ |\n",
"| 1 | 300 |\n",
"| 2 | 500 |\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"x_train = np.array([1.0, 2.0]) #(size in 1000 square feet)\n",
"y_train = np.array([300.0, 500.0]) #(price in 1000s of dollars)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Computing Cost\n",
"The term 'cost' in this assignment might be a little confusing since the data is housing cost. Here, cost is a measure how well our model is predicting the target price of the house. The term 'price' is used for housing data.\n",
"\n",
"The equation for cost with one variable is:\n",
" $$J(w,b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (f_{w,b}(x^{(i)}) - y^{(i)})^2 \\tag{1}$$ \n",
" \n",
"where \n",
" $$f_{w,b}(x^{(i)}) = wx^{(i)} + b \\tag{2}$$\n",
" \n",
"- $f_{w,b}(x^{(i)})$ is our prediction for example $i$ using parameters $w,b$. \n",
"- $(f_{w,b}(x^{(i)}) -y^{(i)})^2$ is the squared difference between the target value and the prediction. \n",
"- These differences are summed over all the $m$ examples and divided by `2m` to produce the cost, $J(w,b)$. \n",
">Note, in lecture summation ranges are typically from 1 to m, while code will be from 0 to m-1.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The code below calculates cost by looping over each example. In each loop:\n",
"- `f_wb`, a prediction is calculated\n",
"- the difference between the target and the prediction is calculated and squared.\n",
"- this is added to the total cost."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def compute_cost(x, y, w, b): \n",
" \"\"\"\n",
" Computes the cost function for linear regression.\n",
" \n",
" Args:\n",
" x (ndarray (m,)): Data, m examples \n",
" y (ndarray (m,)): target values\n",
" w,b (scalar) : model parameters \n",
" \n",
" Returns\n",
" total_cost (float): The cost of using w,b as the parameters for linear regression\n",
" to fit the data points in x and y\n",
" \"\"\"\n",
" # number of training examples\n",
" m = x.shape[0] \n",
" \n",
" cost_sum = 0 \n",
" for i in range(m): \n",
" f_wb = w * x[i] + b \n",
" cost = (f_wb - y[i]) ** 2 \n",
" cost_sum = cost_sum + cost \n",
" total_cost = (1 / (2 * m)) * cost_sum \n",
"\n",
" return total_cost"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Cost Function Intuition"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img align=\"left\" src=\"./images/C1_W1_Lab02_GoalOfRegression.PNG\" style=\" width:380px; padding: 10px; \" /> Your goal is to find a model $f_{w,b}(x) = wx + b$, with parameters $w,b$, which will accurately predict house values given an input $x$. The cost is a measure of how accurate the model is on the training data.\n",
"\n",
"The cost equation (1) above shows that if $w$ and $b$ can be selected such that the predictions $f_{w,b}(x)$ match the target data $y$, the $(f_{w,b}(x^{(i)}) - y^{(i)})^2 $ term will be zero and the cost minimized. In this simple two point example, you can achieve this!\n",
"\n",
"In the previous lab, you determined that $b=100$ provided an optimal solution so let's set $b$ to 100 and focus on $w$.\n",
"\n",
"<br/>\n",
"Below, use the slider control to select the value of $w$ that minimizes cost. It can take a few seconds for the plot to update."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "f2385414941e465893543c12c9eb6aad",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"interactive(children=(IntSlider(value=150, description='w', max=400, step=10), Output()), _dom_classes=('widge…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt_intuition(x_train,y_train)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The plot contains a few points that are worth mentioning.\n",
"- cost is minimized when $w = 200$, which matches results from the previous lab\n",
"- Because the difference between the target and pediction is squared in the cost equation, the cost increases rapidly when $w$ is either too large or too small.\n",
"- Using the `w` and `b` selected by minimizing cost results in a line which is a perfect fit to the data."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Cost Function Visualization- 3D\n",
"\n",
"You can see how cost varies with respect to *both* `w` and `b` by plotting in 3D or using a contour plot. \n",
"It is worth noting that some of the plotting in this course can become quite involved. The plotting routines are provided and while it can be instructive to read through the code to become familiar with the methods, it is not needed to complete the course successfully. The routines are in lab_utils_uni.py in the local directory."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Larger Data Set\n",
"It's use instructive to view a scenario with a few more data points. This data set includes data points that do not fall on the same line. What does that mean for the cost equation? Can we find $w$, and $b$ that will give us a cost of 0? "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"x_train = np.array([1.0, 1.7, 2.0, 2.5, 3.0, 3.2])\n",
"y_train = np.array([250, 300, 480, 430, 630, 730,])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the contour plot, click on a point to select `w` and `b` to achieve the lowest cost. Use the contours to guide your selections. Note, it can take a few seconds to update the graph. "
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "3220529fafc8489681534a5e969f41b7",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.close('all') \n",
"fig, ax, dyn_items = plt_stationary(x_train, y_train)\n",
"updater = plt_update_onclick(fig, ax, x_train, y_train, dyn_items)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Above, note the dashed lines in the left plot. These represent the portion of the cost contributed by each example in your training set. In this case, values of approximately $w=209$ and $b=2.4$ provide low cost. Note that, because our training examples are not on a line, the minimum cost is not zero."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Convex Cost surface\n",
"The fact that the cost function squares the loss ensures that the 'error surface' is convex like a soup bowl. It will always have a minimum that can be reached by following the gradient in all dimensions. In the previous plot, because the $w$ and $b$ dimensions scale differently, this is not easy to recognize. The following plot, where $w$ and $b$ are symmetric, was shown in lecture:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "ccc5618f20524df5bf9dc8737b0e8111",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"soup_bowl()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Congratulations!\n",
"You have learned the following:\n",
" - The cost equation provides a measure of how well your predictions match your training data.\n",
" - Minimizing the cost can provide optimal values of $w$, $b$."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.6"
},
"toc-autonumbering": false
},
"nbformat": 4,
"nbformat_minor": 5
}
================================================
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-5-Gradient-Descent.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Optional Lab: Gradient Descent for Linear Regression\n",
"\n",
"<figure>\n",
" <center> <img src=\"./images/C1_W1_L4_S1_Lecture_GD.png\" style=\"width:800px;height:200px;\" ></center>\n",
"</figure>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Goals\n",
"In this lab, you will:\n",
"- automate the process of optimizing $w$ and $b$ using gradient descent."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tools\n",
"In this lab, we will make use of: \n",
"- NumPy, a popular library for scientific computing\n",
"- Matplotlib, a popular library for plotting data\n",
"- plotting routines in the lab_utils.py file in the local directory"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import math, copy\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"plt.style.use('./deeplearning.mplstyle')\n",
"from lab_utils_uni import plt_house_x, plt_contour_wgrad, plt_divergence, plt_gradients"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"toc_40291_2\"></a>\n",
"# Problem Statement\n",
"\n",
"Let's use the same two data points as before - a house with 1000 square feet sold for \\\\$300,000 and a house with 2000 square feet sold for \\\\$500,000.\n",
"\n",
"| Size (1000 sqft) | Price (1000s of dollars) |\n",
"| ----------------| ------------------------ |\n",
"| 1 | 300 |\n",
"| 2 | 500 |\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# Load our data set\n",
"x_train = np.array([1.0, 2.0]) #features\n",
"y_train = np.array([300.0, 500.0]) #target value"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"toc_40291_2.0.1\"></a>\n",
"### Compute_Cost\n",
"This was developed in the last lab. We'll need it again here."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"#Function to calculate the cost\n",
"def compute_cost(x, y, w, b):\n",
" \n",
" m = x.shape[0] \n",
" cost = 0\n",
" \n",
" for i in range(m):\n",
" f_wb = w * x[i] + b\n",
" cost = cost + (f_wb - y[i])**2\n",
" total_cost = 1 / (2 * m) * cost\n",
"\n",
" return total_cost"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"toc_40291_2.1\"></a>\n",
"## Gradient descent summary\n",
"So far in this course, you have developed a linear model that predicts $f_{w,b}(x^{(i)})$:\n",
"$$f_{w,b}(x^{(i)}) = wx^{(i)} + b \\tag{1}$$\n",
"In linear regression, you utilize input training data to fit the parameters $w$,$b$ by minimizing a measure of the error between our predictions $f_{w,b}(x^{(i)})$ and the actual data $y^{(i)}$. The measure is called the $cost$, $J(w,b)$. In training you measure the cost over all of our training samples $x^{(i)},y^{(i)}$\n",
"$$J(w,b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (f_{w,b}(x^{(i)}) - y^{(i)})^2\\tag{2}$$ "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"In lecture, *gradient descent* was described as:\n",
"\n",
"$$\\begin{align*} \\text{repeat}&\\text{ until convergence:} \\; \\lbrace \\newline\n",
"\\; w &= w - \\alpha \\frac{\\partial J(w,b)}{\\partial w} \\tag{3} \\; \\newline \n",
" b &= b - \\alpha \\frac{\\partial J(w,b)}{\\partial b} \\newline \\rbrace\n",
"\\end{align*}$$\n",
"where, parameters $w$, $b$ are updated simultaneously. \n",
"The gradient is defined as:\n",
"$$\n",
"\\begin{align}\n",
"\\frac{\\partial J(w,b)}{\\partial w} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{w,b}(x^{(i)}) - y^{(i)})x^{(i)} \\tag{4}\\\\\n",
" \\frac{\\partial J(w,b)}{\\partial b} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{w,b}(x^{(i)}) - y^{(i)}) \\tag{5}\\\\\n",
"\\end{align}\n",
"$$\n",
"\n",
"Here *simultaniously* means that you calculate the partial derivatives for all the parameters before updating any of the parameters."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"toc_40291_2.2\"></a>\n",
"## Implement Gradient Descent\n",
"You will implement gradient descent algorithm for one feature. You will need three functions. \n",
"- `compute_gradient` implementing equation (4) and (5) above\n",
"- `compute_cost` implementing equation (2) above (code from previous lab)\n",
"- `gradient_descent`, utilizing compute_gradient and compute_cost\n",
"\n",
"Conventions:\n",
"- The naming of python variables containing partial derivatives follows this pattern,$\\frac{\\partial J(w,b)}{\\partial b}$ will be `dj_db`.\n",
"- w.r.t is With Respect To, as in partial derivative of $J(wb)$ With Respect To $b$.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"toc_40291_2.3\"></a>\n",
"### compute_gradient\n",
"<a name='ex-01'></a>\n",
"`compute_gradient` implements (4) and (5) above and returns $\\frac{\\partial J(w,b)}{\\partial w}$,$\\frac{\\partial J(w,b)}{\\partial b}$. The embedded comments describe the operations."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def compute_gradient(x, y, w, b): \n",
" \"\"\"\n",
" Computes the gradient for linear regression \n",
" Args:\n",
" x (ndarray (m,)): Data, m examples \n",
" y (ndarray (m,)): target values\n",
" w,b (scalar) : model parameters \n",
" Returns\n",
" dj_dw (scalar): The gradient of the cost w.r.t. the parameters w\n",
" dj_db (scalar): The gradient of the cost w.r.t. the parameter b \n",
" \"\"\"\n",
" \n",
" # Number of training examples\n",
" m = x.shape[0] \n",
" dj_dw = 0\n",
" dj_db = 0\n",
" \n",
" for i in range(m): \n",
" f_wb = w * x[i] + b \n",
" dj_dw_i = (f_wb - y[i]) * x[i] \n",
" dj_db_i = f_wb - y[i] \n",
" dj_db += dj_db_i\n",
" dj_dw += dj_dw_i \n",
" dj_dw = dj_dw / m \n",
" dj_db = dj_db / m \n",
" \n",
" return dj_dw, dj_db"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<br/>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img align=\"left\" src=\"./images/C1_W1_Lab03_lecture_slopes.PNG\" style=\"width:340px;\" > The lectures described how gradient descent utilizes the partial derivative of the cost with respect to a parameter at a point to update that parameter. \n",
"Let's use our `compute_gradient` function to find and plot some partial derivatives of our cost function relative to one of the parameters, $w_0$.\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 864x288 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt_gradients(x_train,y_train, compute_cost, compute_gradient)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Above, the left plot shows $\\frac{\\partial J(w,b)}{\\partial w}$ or the slope of the cost curve relative to $w$ at three points. On the right side of the plot, the derivative is positive, while on the left it is negative. Due to the 'bowl shape', the derivatives will always lead gradient descent toward the bottom where the gradient is zero.\n",
" \n",
"The left plot has fixed $b=100$. Gradient descent will utilize both $\\frac{\\partial J(w,b)}{\\partial w}$ and $\\frac{\\partial J(w,b)}{\\partial b}$ to update parameters. The 'quiver plot' on the right provides a means of viewing the gradient of both parameters. The arrow sizes reflect the magnitude of the gradient at that point. The direction and slope of the arrow reflects the ratio of $\\frac{\\partial J(w,b)}{\\partial w}$ and $\\frac{\\partial J(w,b)}{\\partial b}$ at that point.\n",
"Note that the gradient points *away* from the minimum. Review equation (3) above. The scaled gradient is *subtracted* from the current value of $w$ or $b$. This moves the parameter in a direction that will reduce cost."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"toc_40291_2.5\"></a>\n",
"### Gradient Descent\n",
"Now that gradients can be computed, gradient descent, described in equation (3) above can be implemented below in `gradient_descent`. The details of the implementation are described in the comments. Below, you will utilize this function to find optimal values of $w$ and $b$ on the training data."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"def gradient_descent(x, y, w_in, b_in, alpha, num_iters, cost_function, gradient_function): \n",
" \"\"\"\n",
" Performs gradient descent to fit w,b. Updates w,b by taking \n",
" num_iters gradient steps with learning rate alpha\n",
" \n",
" Args:\n",
" x (ndarray (m,)) : Data, m examples \n",
" y (ndarray (m,)) : target values\n",
" w_in,b_in (scalar): initial values of model parameters \n",
" alpha (float): Learning rate\n",
" num_iters (int): number of iterations to run gradient descent\n",
" cost_function: function to call to produce cost\n",
" gradient_function: function to call to produce gradient\n",
" \n",
" Returns:\n",
" w (scalar): Updated value of parameter after running gradient descent\n",
" b (scalar): Updated value of parameter after running gradient descent\n",
" J_history (List): History of cost values\n",
" p_history (list): History of parameters [w,b] \n",
" \"\"\"\n",
" \n",
" w = copy.deepcopy(w_in) # avoid modifying global w_in\n",
" # An array to store cost J and w's at each iteration primarily for graphing later\n",
" J_history = []\n",
" p_history = []\n",
" b = b_in\n",
" w = w_in\n",
" \n",
" for i in range(num_iters):\n",
" # Calculate the gradient and update the parameters using gradient_function\n",
" dj_dw, dj_db = gradient_function(x, y, w , b) \n",
"\n",
" # Update Parameters using equation (3) above\n",
" b = b - alpha * dj_db \n",
" w = w - alpha * dj_dw \n",
"\n",
" # Save cost J at each iteration\n",
" if i<100000: # prevent resource exhaustion \n",
" J_history.append( cost_function(x, y, w , b))\n",
" p_history.append([w,b])\n",
" # Print cost every at intervals 10 times or as many iterations if < 10\n",
" if i% math.ceil(num_iters/10) == 0:\n",
" print(f\"Iteration {i:4}: Cost {J_history[-1]:0.2e} \",\n",
" f\"dj_dw: {dj_dw: 0.3e}, dj_db: {dj_db: 0.3e} \",\n",
" f\"w: {w: 0.3e}, b:{b: 0.5e}\")\n",
" \n",
" return w, b, J_history, p_history #return w and J,w history for graphing"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Iteration 0: Cost 7.93e+04 dj_dw: -6.500e+02, dj_db: -4.000e+02 w: 6.500e+00, b: 4.00000e+00\n",
"Iteration 1000: Cost 3.41e+00 dj_dw: -3.712e-01, dj_db: 6.007e-01 w: 1.949e+02, b: 1.08228e+02\n",
"Iteration 2000: Cost 7.93e-01 dj_dw: -1.789e-01, dj_db: 2.895e-01 w: 1.975e+02, b: 1.03966e+02\n",
"Iteration 3000: Cost 1.84e-01 dj_dw: -8.625e-02, dj_db: 1.396e-01 w: 1.988e+02, b: 1.01912e+02\n",
"Iteration 4000: Cost 4.28e-02 dj_dw: -4.158e-02, dj_db: 6.727e-02 w: 1.994e+02, b: 1.00922e+02\n",
"Iteration 5000: Cost 9.95e-03 dj_dw: -2.004e-02, dj_db: 3.243e-02 w: 1.997e+02, b: 1.00444e+02\n",
"Iteration 6000: Cost 2.31e-03 dj_dw: -9.660e-03, dj_db: 1.563e-02 w: 1.999e+02, b: 1.00214e+02\n",
"Iteration 7000: Cost 5.37e-04 dj_dw: -4.657e-03, dj_db: 7.535e-03 w: 1.999e+02, b: 1.00103e+02\n",
"Iteration 8000: Cost 1.25e-04 dj_dw: -2.245e-03, dj_db: 3.632e-03 w: 2.000e+02, b: 1.00050e+02\n",
"Iteration 9000: Cost 2.90e-05 dj_dw: -1.082e-03, dj_db: 1.751e-03 w: 2.000e+02, b: 1.00024e+02\n",
"(w,b) found by gradient descent: (199.9929,100.0116)\n"
]
}
],
"source": [
"# initialize parameters\n",
"w_init = 0\n",
"b_init = 0\n",
"# some gradient descent settings\n",
"iterations = 10000\n",
"tmp_alpha = 1.0e-2\n",
"# run gradient descent\n",
"w_final, b_final, J_hist, p_hist = gradient_descent(x_train ,y_train, w_init, b_init, tmp_alpha, \n",
" iterations, compute_cost, compute_gradient)\n",
"print(f\"(w,b) found by gradient descent: ({w_final:8.4f},{b_final:8.4f})\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img align=\"left\" src=\"./images/C1_W1_Lab03_lecture_learningrate.PNG\" style=\"width:340px; padding: 15px; \" > \n",
"Take a moment and note some characteristics of the gradient descent process printed above. \n",
"\n",
"- The cost starts large and rapidly declines as described in the slide from the lecture.\n",
"- The partial derivatives, `dj_dw`, and `dj_db` also get smaller, rapidly at first and then more slowly. As shown in the diagram from the lecture, as the process nears the 'bottom of the bowl' progress is slower due to the smaller value of the derivative at that point.\n",
"- progress slows though the learning rate, alpha, remains fixed"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Cost versus iterations of gradient descent \n",
"A plot of cost versus iterations is a useful measure of progress in gradient descent. Cost should always decrease in successful runs. The change in cost is so rapid initially, it is useful to plot the initial decent on a different scale than the final descent. In the plots below, note the scale of cost on the axes and the iteration step."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAA2gAAAEoCAYAAAAt0dJ4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXhU5d3/8Xc2spFkEnZiggsgIglWxZBNAibiwlIVKzUi9an4qBVFLfJ7irEgtKRS7WIpYLWKFlDcQKxFDDtKCCAQIyoqIsYgJCYhAUKWyfn9MWWSMwl7Jmcm+byuqxdzf88snwQv7n7n3Oc+PoZhGIiIiIiIiIjlfK0OICIiIiIiIg5q0ERERERERDyEGjQREREREREPoQZNRERERETEQ6hBExERERER8RBq0ERERERERDyEGjTxes899xwDBgwgNDSUXr16cffdd1NUVHTW73f++eeTm5vbgglPbuHChdx0000A7N27l6CgILd91rRp07j33ntNtUsvvZQtW7ac83sfPnyY/v37c/To0ZM+Ly0tjVdfffWsP2ft2rX069fPVPvFL37B8uXLz/o9RURam+au0+fOucvVq6++yv3339/i73vvvfcybdo0AF566SUeffTRFv8MaTvUoIlXmzlzJtOnT+fpp5+mtLSUgoICBg4cyMaNG62OdtoyMzN5++23W+S96urqzvg1n376KYMGDTrnz54zZw633HILISEh5/xeJ1JbW9ts/dFHH+XJJ5902+eKiLQkzV1mVs5drmbMmMEjjzzS4u/bWGZmJm+99RYlJSVu/RzxYoaIlyorKzOCg4ONZcuWnfA5O3fuNBITE42IiAgjMTHR2Llzp2EYhmG3243777/f6NSpkxEeHm4kJCQYNTU1xi9/+UvDx8fHCA4ONkJDQ4033njD9H7r1683+vTpY6r9+te/Nh599FHDMAxj+vTpRrdu3YywsDBj4MCBRlFR0Sl/jhdffNEYPny4YRiG0adPHwMwQkNDjdDQUOPAgQNGXV2d8cQTTxixsbFGt27djEceecSora01DMMwfvvb3xq333678dOf/tQICQkxNmzYYCxbtswYMGCA0bFjR6Nv377G22+/bRiGYaxZs8YICAgw/P39jdDQUOOnP/2pYRiG0atXL2PTpk2GYRjGjz/+aNx6661GVFSU0adPH+O1115z5hwyZIgxffp044orrjDCw8ONsWPHGtXV1c7jffr0MT799FPnuLnfxZNPPmn4+voagYGBRmhoqPH0008bdrvduOmmm4wuXboYkZGRxtixY43y8nLDMAzjm2++MQIDA42//e1vRo8ePYy7777bCAoKMnx8fIzQ0FCjU6dOzs+75JJLnH+/IiKeSnOXZ81djX344YfGoEGDTLW1a9cal19+uREREWEMGTLE+OqrrwzDaJifnnvuOaN79+5G9+7djVdeecX5uh9++MHIyMgwOnbsaNx4443G7bffbvz2t791Hr/vvvuMv/zlL6f8PUv7pAZNvNZ7771n+Pv7G3V1dc0er66uNnr16mXMnz/fqKmpMf7+978bvXr1Mqqrq43//Oc/xpVXXmlUVFQYdXV1xqZNm5zv0/gffVf19fVGz549je3btztr559/vrF582bjs88+M2JiYowDBw4Ydrvd2Llzp7PROJnGk9zxf/Abe+qpp4z09HSjuLjYKC8vN9LS0oy//vWvhmE4JrnAwEBj5cqVht1uN44dO2asWbPG+Pzzzw273W4sXbrU6Nixo1FcXOx8/v/+7/+a3r/xzzt27Fhj/PjxRlVVlZGbm2uEh4cbu3btMgzDMckNGDDA+Pbbb42ysjKjf//+xssvv2wYhmHs2bPHiIqKcr7nyX4XQ4YMMRYvXux8rt1uN1555RXjyJEjRmlpqTF06FBjypQpzt+Hj4+Pce+99xpVVVXG0aNHjTVr1hgXX3xxk9/jPffcYzz11FOn/H2LiFhJc5fnzF2unnjiCeORRx5xjvft22d06dLF2LBhg1FXV2c8++yzxhVXXGHU19c756dHH33UqK6uNt5//30jLCzMOHLkiGEYhnHLLbcYd999t1FVVWX85z//MTp06GBq0BYtWmTccMMNp/w9S/ukJY7itX788Uc6d+6Mn59fs8dzc3Px9/fnnnvuISAggPvuuw8/Pz9yc3MJCAigsrKS3bt34+vry+DBg0/4Po35+PgwZswYlixZAsDmzZsBuOqqq/D396e6uprPPvsMwzCIj48nIiLinH/OF154gd/97nd07tyZiIgIHn30Ud544w3n8WHDhpGRkYGvry+BgYGkpaVx8cUX4+vry+jRo+nduzc7duw45efY7XbefPNNZs6cSVBQEAkJCdxyyy28/vrrzudMmDCB2NhYbDYbN954Izt37gQcS0369OnjfN6Z/C58fX254447CAkJITIykoceesi0zMcwDKZPn05QUBDBwcEnzN+vXz/y8/NP+XOKiFhJc5eDJ8xdrlznsoULFzJmzBhSUlLw8/PjgQce4Ntvv2Xv3r2AY37KysqiQ4cOXHvttQQFBbFnzx7q6upYtmwZ06ZNIygoiOuuu46UlBTTZ2nOkpNRgyZeq1OnTpSUlGC325s9XlRURExMjKkWGxvL/v37ueaaa5gwYQLjx48nOjraeeHu6bjtttuc//AvWbKEn/3sZwD07t2bp556ismTJ9OtWzcefPBBqqurz+6Ha2Tfvn1kZGRgs9mw2WxkZmZSXFzsPO76M27cuJGkpCSioqKw2Wx88skn/Pjjj6f8nOLiYux2O9HR0c5ar1692L9/v3PctWtX5+OQkBAOHz4MwKFDh+jYsaPz2Jn8Lurq6pg0aRK9evUiPDyczMxMU94OHTqYPvdEwsLCOHTo0CmfJyJiJc1dDp4wd7lyncv27dvHiy++6PwZbDYbR44ccW7mEhgYaGpmj793SUkJ9fX19OzZ03ksNjbW9Fmas+Rk1KCJ10pMTMTf35/33nuv2eM9e/aksLDQVNu3bx89evQAHBtLFBQUsH79el544QU++OADwPFN46k+t7q6mo8//pg33njDOckBjB8/nry8PD755BM2btzIyy+/fEY/U3OfHR0dzfr16ykvL6e8vJxDhw6xa9euE75m3Lhx/PKXv+TAgQOUl5cTFxeHYRin/Nm6dOmCr68v33//vbPW+Pd1MhEREU0mvBP9LlwzLFy4kA0bNrBp0yYqKipYuHChM29zzz/Rz1BZWdki3/qKiLiT5q7mX2PF3OXKdS6Ljo7m3nvvdf4M5eXlHD16lOTk5JO+T+fOnfHx8TE1id99953pOZqz5GTUoInXstlsTJ06lfvvv58PPviAmpoajhw5wty5c1myZAmDBw+mpqaG559/nrq6OubPn09dXR2DBw9m69atbNu2DbvdTnh4OP7+/s5lIl27dmXPnj0n/NzjS0UmT55MQEAAV1xxBQBffPEF69evp6amho4dOxIYGHhaS08a69y5MzU1Naatlu+66y7+7//+j/3792MYBnv37mXdunUnfI/Kykrn8pnFixdTUFDgPNa1a1e++eYbUwN0nJ+fHzfffDNPPPEEx44dIy8vjzfffJMxY8acMndcXBxfffWVc3yy34Xr77eyspKgoCAiIyM5ePAgzzzzzEk/q2vXrhw4cKDJdv5ffPEFcXFxp8wqImIlzV3Ns2LuchUXF8eXX37pHP/85z/ntddeY/369dTX11NZWWlapnki/v7+jBo1iunTp1NdXc0HH3zAhg0bTM/RnCUnowZNvNrjjz/O448/zqRJk4iMjOSSSy5h+/btpKam0qFDB5YtW8bzzz9Pp06dePHFF1m2bBkdOnTg0KFDjB8/noiICOLj4/n5z3/OsGHDAPj1r3/N5MmTsdlsvPXWW81+7m233cbq1au59dZbnbXq6moeeeQROnXqxAUXXMCAAQMYN24c4Lj/ies9XJoTGhrK5MmTiY+Px2azcfDgQR577DESExNJTk4mIiKCkSNHNvkmrrFnn32W++67j06dOvHhhx+SmJjoPHbzzTdTXl5OZGRks5PXnDlzqKiooGfPnmRmZjJ37lz69+9/yty9evWic+fOfPbZZ6f8XfzqV7/i+eefx2az8ec//5k777yTsLAwunTpwtChQ7nxxhtP+lmXXHIJN9xwA+eddx7du3d31jds2MDw4cNPmVVExGqau5qyYu5yNXz4cNM10BdeeCGLFy/mscceIyoqin79+rF06dLTeq85c+bw9ddf07lzZ/785z83ya05S07Gx2ju6wgRkTM0e/ZsKisrLbkfWUFBAePHj2fbtm2t/tkiItJ2DBgwgGXLlnHRRRe57TPq6uro06cPeXl5dOnSxW2fI95LZ9BEpEXcd999vPnmm02WHraGp59+mt/+9ret/rkiItK2ZGVl8fTTT7v1MxYuXMhNN92k5kxOSGfQREREREREPITOoImIiIiIiHgINWgiIiIiIiIewt/qAC1BN/oTERHAa+4rpHlLRESg+XlLZ9BEREREREQ8hBo0ERERERERD9Emljg25i3LW0REpGVYuVywoKCAe+65Bz8/P3r37s0///lPfHx8AJg2bRpvv/02kZGRjBo1ikceeaTZ99C8JSLSvpxq3mpzDZqIiEhrufjii/noo48AuOuuu9i6dSuDBg1yHn/66adJT0+3Kp6IiHghLXEUERE5SwEBAc7HgYGBxMTEmI5PmTKF9PR0duzY0drRRETES6lBExEROQfvvPMOAwYM4ODBg3Tq1MlZf/DBB9m2bRtz585l4sSJFiYUERFv4rYG7ejRo9x4442kpaUxevRoqqurmT17NikpKWRmZlJbWwvAwoULSUpKYsSIEVRUVACwevVqEhMTGTp0KIWFhYBjnX9KSgrJycnk5+e7K7aIiMgZGTVqFAUFBURHR/Puu+8661FRUQD06dPHqmgiIuKF3NagrVixgoSEBNauXctVV13Fq6++ypo1a9i4cSPx8fEsXbqU2tpa5s2bx/r16xk3bhzz588HYMaMGaxcuZLs7GxmzZoFQFZWFosXL2bJkiVkZWW5K7aIiMhpq66udj4ODw8nODjYOT7+pWNJSQl1dXWtnk1ERLyT2xq0iy66yDlxlZeXs3fvXtLS0gBIT08nNzeX3bt3ExcXh7+/v7N29OhRgoODCQsLIyEhgV27dgFQWlpKTEwM0dHRusGniIh4hBUrVjBkyBCGDBnCgQMHuPbaa53LGSdPnkxycjIjR44kOzvb4qQiIuIt3LaLY58+fdi8eTOXXnopXbt25e6776ayshJwbClcVlZGeXk54eHhplpZWZmzBmC32wGor6931ho/FhERscro0aMZPXq0qfbss88COFeFiIiInAm3nUFbsGABw4cP59NPP+XGG2+krq7OudyjoqICm82GzWZrUouMjHTWAHx9fU1/uj5uKfZ62F4Mf8mHSRtb/O1FRERajL0e9lXCuiJY8Dks/tLqRCIi0lLcdgbNMAznBdKdO3dm79695OXl8dhjj5GTk8PgwYPp27cvBQUF2O12Zy0kJISqqioOHz7Mrl276N+/P+C42LqwsBBfX98Wv6lnVR30XADlNQ21rCuhU1CLfoyIiEiL2FoMg99qGMdFwc+1F4mISJvgtgbt9ttv57bbbuOVV14hICCA1157jX/84x+kpKQQGxvLpEmTCAgIYMKECaSmphIZGcmiRYsAmDp1KhkZGQQFBbFgwQIApk+fztixYzEMgzlz5rRo1mB/6BUG5T821D7cD6MuaNGPERERaREXhJnH31SCYYCPjzV5RESk5fgYhmFYHeJcNd405GzPrk3cAH8raBj/eiDMTjrXZCIi4m4tMQe0tnPNbBjQ8Xk42mhzyOJfQOfgE75EREQ8xKnmAN2o+r+u7mker99vTQ4REZFT8fGB813Oou2ttCaLiIi0LDVo/5Xawzz+uAQO11qTRURE5FQuCDePv1GDJiLSJqhB+6/uIdCn0RnGunrIPWBdHhERkZNpch1aRfPPExER76IGrRHXs2gbiqzJISIicipa4igi0japQWukSYOm69BERMRDNVniqDNoIiJtghq0Rlw3Ctl0AGrs1mQRERE5mea22hcREe+nBq2RC8KgZ2jD+JgdthVbl0dEROREznc5g/btf++FJiIi3k0NWiM+PnC1ljmKiIgXiAyEiA4N42N2+OGodXlERKRlqEFz4Xodmu6HJiIinkpb7YuItD1q0Fy4Nmgb94O93posIiIiJ9NkJ0dtFCIi4vXUoLm4NMqxbOS4QzVQUGpdHhERkRPRRiEiIm2PGjQXvj6Q0t1cW6f7oYmIiAfSVvsiIm2PGrRmpEWbx6u/tyaHiIjIybgucdQZNBER76cGrRnDXBq0tUW6Dk1ERDyP6xLHvWrQRES8nhq0ZsR3giiX69B2/GhdHhERkea43gtt32F9oSgi4u3UoDXD1weGui5zLLQmi4iIyIl0DIAuQQ3junooPGJdHhEROXdq0E6gSYOm69BERMQDuW4UskcbhYiIeDU1aCfgeh3ahv1QY7cmi4iIyIlc5NKgfXXImhwiItIy1KCdQD8bdA9pGB+pgy0HrcsjIiLSnN4R5vHXOoMmIuLV3NagrVixgrS0NNLS0ujRowdLly5l9uzZpKSkkJmZSW1tLQALFy4kKSmJESNGUFHhmFVWr15NYmIiQ4cOpbDQcfFXQUEBKSkpJCcnk5+f767YTj4+Tc+iaZmjiIh4GtcGTWfQRES8m9satOuuu461a9eydu1aYmNjueKKK1izZg0bN24kPj6epUuXUltby7x581i/fj3jxo1j/vz5AMyYMYOVK1eSnZ3NrFmzAMjKymLx4sUsWbKErKwsd8U2GdrTPF6jBk1ERBopKCggKSmJ1NRU7rrrLgzDcB4rKipi2LBhJCUlkZOT47YMatBERNoWty9x3LNnD926dSM/P5+0tDQA0tPTyc3NZffu3cTFxeHv7++sHT16lODgYMLCwkhISGDXrl0AlJaWEhMTQ3R0NIcOtc7sM+w88/ijA1BV1yofLSIiXuDiiy/mo48+YsOGDQBs3brVeSw7O5uZM2eycuVKZs6c6bYMvZu5Bq1RnygiIl7G7Q3aW2+9xU033UR5eTnh4Y5ZJCIigrKysmZrZWVlzhqA3e7YmaO+vuHGLo0fu9MFYdCr0U1Aq+2w6YdW+WgREfECAQEBzseBgYHExMQ4x/n5+SQmJtKxY0fCwsKorHTPXaS7BENYQwyO1MGBKrd8lIiItAK3N2jLly9n1KhR2Gw25zVmFRUV2Gy2ZmuRkZHOGoCvr6/pT9fH7qTr0ERE5FTeeecdBgwYwMGDB+nUqZOzbrfb8fHxARq+hHQHHx8tcxQRaUvc2un88MMPdOjQgU6dOjFo0CDWrVsHQE5ODoMHD6Zv374UFBRgt9udtZCQEKqqqjh8+DB5eXn0798fgKioKAoLCykqKiIiIuJkH9uiXBu0VWrQRESkkVGjRlFQUEB0dDTvvvuus+7n5+d8fPxLSHdRgyYi0nb4u/PNly1bxujRowHo2rUrV199NSkpKcTGxjJp0iQCAgKYMGECqampREZGsmjRIgCmTp1KRkYGQUFBLFiwAIDp06czduxYDMNgzpw57oxt4rpRyJaDUF4NtsBWiyAiIh6qurqawEDHhBAeHk5wcLDzWHx8PJs2bSI+Pp6KigrT8v2WpnuhiYi0HT6G4f2XEjfeNMQdZ9cufRV2NVqZ8uZwuPnCFv8YERE5C+6eA05m2bJlPPPMMwD06dOH5557joceeohnn32WwsJC7rzzTqqqqpg+fTrXXnut2zK/8BncvbZhPLY3LM4457cVERE3ONUcoAbtNDz8Ify50a3X7ukP84e0+MeIiMhZsLJBO1stnXldEaQtaxhf2QW2jDnntxURETc41RzQOrtteLnhMebx+99pC2MREfEcrlvtf6mt9kVEvJYatNNwdQ8IbLjWm28rHZOfiIiIJ+gRCsGNrio/VAOl1dblERGRs6cG7TSEBEBqD3Pt/e+sySIiIuLK10cbhYiItBVq0E6T6zLHlWrQRETEg2irfRGRtkEN2mm61qVBW/M91NitySIiIuLK9To0NWgiIt5JDdppiouCHiEN4yN18NEP1uURERFp7CLXM2gV1uQQEZFzowbtNPn4ND2LpuvQRETEU/RxadB2l1uTQ0REzo0atDNw7XnmsRo0ERHxFBfbzOPPy7XVvoiIN1KDdgYyYsCn0Xh7CRw8alkcERERp+hQCG201X5FDRyosi6PiIicHTVoZ6BLMFzexVxbWWhNFhERkcZ8fJo5i1ZmTRYRETl7atDOkOt2++99a00OERERV64N2he6Dk1ExOuoQTtDN/Yyj/+zD+rqrckiIiLSWL9I81gNmoiI91GDdoYSukKnoIZxeY222xcREc/Q3EYhIiLiXdSgnSE/X7g+1lz7t5Y5ioiIB9ASRxER76cG7SyMcFnm+K4aNBER8QB9Xe6F9k0FHKuzJouIiJwdNWhnYXgM+DXab39XmWMSFBERsVJIAMR2bBgbwFeHLIsjIiJnQQ3aWbAFQkoPc03LHEVExBNooxAREe+mBu0saZmjiIh4Im0UIiLi3dSgnSXX7fbXfA+Ha63JIiIicpw2ChER8W5ubdBefvllrrnmGtLS0vj++++ZPXs2KSkpZGZmUlvr6GYWLlxIUlISI0aMoKLCcSHX6tWrSUxMZOjQoRQWFgJQUFBASkoKycnJ5OfnuzP2aelngwvDG8Y19bCq0Lo8IiIi4JifGlODJiLiXdzWoH3//fesW7eOVatWsXbtWjp06MCaNWvYuHEj8fHxLF26lNraWubNm8f69esZN24c8+fPB2DGjBmsXLmS7OxsZs2aBUBWVhaLFy9myZIlZGVluSv2afPx0TJHERHxPM0tcTQMa7KIiMiZc1uD9v7772O327nmmmuYOHEieXl5pKWlAZCenk5ubi67d+8mLi4Of39/Z+3o0aMEBwcTFhZGQkICu3btAqC0tJSYmBiio6M5dMgztqRqrkGr1yQoIiIWig6FUP+GcUUN/HDUujwiInJm3NagHThwgJqaGlatWkVISAjl5eWEhzvWBEZERFBWVtZsrayszFkDsNvtANTX1ztrjR9b6eqe0DGgYfzDUcg7YF0eERERH5+mZ9E+K7Mmi4iInDm3NWgREREMGTIEgGHDhrF3717nNWYVFRXYbDZsNluTWmRkpLMG4Ovra/rT9bGVAv3ghlhz7a1vrMkiIiJy3KVR5nFBqTU5RETkzLmt00lKSnJu5rFjxw5iYmJYt24dADk5OQwePJi+fftSUFCA3W531kJCQqiqquLw4cPk5eXRv39/AKKioigsLKSoqIiIiAh3xT5jN11gHr/9jdb6i4i0F5s3byYpKYnU1FQefvhh07Fp06YxcOBA0tLSeOaZZ1o1l2uD9qnOoImIeA3/Uz/l7Fx22WUEBweTlpZG586dWbRoEfv37yclJYXY2FgmTZpEQEAAEyZMIDU1lcjISBYtWgTA1KlTycjIICgoiAULFgAwffp0xo4di2EYzJkzx12xz9gNvaCDr2MXR4CvDsGnpTCgk7W5RETE/Xr16sXq1asJCgoiMzOTTz75hLi4OOfxp59+mvT09FbPNcC1QdMZNBERr+FjGN5/vqfxpiFWnF274d/wn30N4ycHQdaVrR5DRKRdsnoOOG78+PFMmTLFufJj2rRpLF++nMjISP74xz9y2WWXOZ/r7sx7K+CChQ1jWwco/R/H9WkiImKtU80BnnExl5drbpmjiIi0H/n5+ZSUlDibM4AHH3yQbdu2MXfuXCZOnNiqeWLDzDs5ltdA0ZFWjSAiImdJDVoLGHU+NP5ScnuJ49tLERFp+0pLS3nggQd44YUXTPWoKMc6wz59+rR6Jl8fXYcmIuKt1KC1gG4hkNzdXFuqs2giIm1eXV0dd9xxB7Nnz6Z7d/NEcHxH4pKSEurq6lo9W5MGTdehiYh4BTVoLeSmC81jLXMUEWn7Xn/9dbZs2cKUKVNIS0tj06ZNzuWMkydPJjk5mZEjR5Kdnd3q2S6NNI/VoImIeAdtEtJCvqmACxtdkO0D/DAeuoZYEkdEpN3whDngTLVG5hX74Pp/N4wTukLuLW75KBEROQPaJKSVXBAOl3VuGBvAsr1WpRERkfbOdav9XWW6T6eIiDdQg9aCXHdzXPK1NTlERESiQyG8Q8O4sha+O2xdHhEROT1q0FrQrReZx6u/h+Iqa7KIiEj75uOj69BERLyRGrQWdEkkxDVaUlJvwJt7rMsjIiLtm+syxwI1aCIiHk8NWgu7rbd5/NpX1uQQERFx3WpfDZqIiOdTg9bCXBu0dUWw/4g1WUREpH1zPYOWrwZNRMTjqUFrYb0j4HKX3Rzf0DJHERGxwMBO5vGnpVBjtyaLiIicHjVobqBljiIi4gk6Bzt2czyuth4+L7cuj4iInJoaNDf4mctujh/+oK2NRUTEGo3v0Qmwo8SaHCIicnrUoLnB+eGQ0NVce133RBMREQu4LnPc+aM1OURE5PSoQXMTLXMUERFP4Nqg6QyaiIhnU4PmJmNcljnmHYQvte5fRERamesSx50/gmFYk0VERE5NDZqbxHSE1B7m2r92W5NFRETar4vCIcS/YfzjMfhet38REfFYatDc6M6+5vG/vtS3liIi0rr8fCFe16GJiHgNtzVoe/fupVu3bqSlpXHttdcCMHv2bFJSUsjMzKS2thaAhQsXkpSUxIgRI6ioqABg9erVJCYmMnToUAoLCwEoKCggJSWF5ORk8vPz3RW7RY25CAL9GsZ7KuCjH6zLIyIi7ZOuQxMR8R5uPYOWkZHB2rVrWblyJcXFxaxZs4aNGzcSHx/P0qVLqa2tZd68eaxfv55x48Yxf/58AGbMmMHKlSvJzs5m1qxZAGRlZbF48WKWLFlCVlaWO2O3GFsgjDrfXHtZyxxFRKSVaSdHERHv4dYGbc2aNaSmpvKnP/2JvLw80tLSAEhPTyc3N5fdu3cTFxeHv7+/s3b06FGCg4MJCwsjISGBXbt2AVBaWkpMTAzR0dEcOnTInbFblOsyxyVfwbE6a7KIiEj7pHuhiYh4D/9TP+Xs9NN6WYkAACAASURBVOjRg927dxMYGMjo0aOpqKigW7duAERERFBWVkZ5eTnh4eGmWllZmbMGYLfbAaivr3fWGj/2dMNjoEsQFB9zjMtr4N/fwi0Xnfx1IiIiLSWuE/gAxy+D/uoQHK6FjgFWphIRkea47QxaYGAgoaGh+Pv7M2LECHr37u28xqyiogKbzYbNZmtSi4yMdNYAfH19TX+6PvZ0AX4wto+59oqWOYqISCvqGAC9IxrGBrBTZ9FERDyS2zqdyspK5+MPP/yQ3r17s27dOgBycnIYPHgwffv2paCgALvd7qyFhIRQVVXF4cOHycvLo3///gBERUVRWFhIUVERERERzX6mpxrnsszx3/ugpMqaLCIi0j5d0cU83lpsTQ4RETk5ty1x3LBhA1lZWQQGBpKSkkJCQgJXX301KSkpxMbGMmnSJAICApgwYQKpqalERkayaNEiAKZOnUpGRgZBQUEsWLAAgOnTpzN27FgMw2DOnDnuiu0WV3aBfjb4/L83qq6rh1e/ggfirM0lIiLtx5VdHHPPcWrQREQ8k49heP+duRpvGuKpZ9d+vw2m5jWMf9IZPr7VujwiIm2FN8wBrqzIvL4IhixrGPezwWc/b5WPFhGRRk41B3jPxVxebtzF4OvTMN5eAh/r20sREWklP+ns2CjkuC/KoaLGsjgiInICatBaSUxHuC7GXHv+M2uyiIhI+xPWAfpFNowN9EWhiIgnUoPWiu6+xDxe+CUcqbUmi4iInLvNmzeTlJREamoqDz/8sOlYUVERw4YNIykpiZycHIsSml2pjUJERDyeGrRWNKIXdAtuGFfUwBtfW5dHRETOTa9evVi9ejUbNmzg4MGDfPLJJ85j2dnZzJw5k5UrVzJz5kwLUzZQgyYi4vnUoLWiAD/4RT9zTcscRUS8V/fu3QkKCgLA398fPz8/57H8/HwSExPp2LEjYWFhptvPWGVQV/N460FrcoiIyImpQWtlv3Rp0Db+AJ+XWZNFRERaRn5+PiUlJc57dwLY7XZ8fBzbckRERFBWZv0/9gM7gV+jnUK+roCyauvyiIhIU2rQWlkfGwzpaa69oLNoIiJeq7S0lAceeIAXXnjBVG98Nq2iogKbzdba0ZoICYBLo8y1bVrmKCLiUdSgWcB1s5AFX0C13ZosIiJy9urq6rjjjjuYPXs23bt3Nx2Lj49n06ZNHDlyhIqKCsLDwy1KadbkOjQtcxQR8Shq0Cxwy4UQ0aFhXHwM3tRmISIiXuf1119ny5YtTJkyhbS0NDZt2sTEiRMBeOyxx5g6dSrp6en85je/sThpA9fr0DarQRMR8Sg+hmEYVoc4V6e6G7cnemgj/LVhsy+SusOHN1mXR0TEW3njHGBl5o+L4Yo3GsbdgmH/ePDxOfFrRESk5ZxqDtAZNIvcf6l5/NEPsF3XAYiIiJvFd4IQ/4bxgSrYa/0GkyIi8l9q0CxycSSkn2euzSmwJouIiLQf/r5wlcsyx00/WJNFRESaUoNmoV8NMI8XfaXtjkVExP0Su5nHHx2wJoeIiDSlBs1CI3pBbMeGcVUdvPi5dXlERKR9SDRvOKkzaCIiHkQNmoX8feFel2vR/l4A9V6/bYuIiHiywS5n0Hb+CEdqrckiIiJmatAsdvcl0KHR38LXFfD+PuvyiIhI29clGHo32jjMbsBWbVQlIuIRTqtBGzJkyGnV5Mx1CYaf9TbX/vJJ888VERH3aI/zXJLLWTQtcxQR8Qz+JztYWlpKcXExJSUlfPnllxy/ZVpFRQUHDuiK4pbywAD41+6G8fvfQcGPMKCTdZlERNqD9jzPJXaHlxvNPR+pQRMR8QgnbdCWL1/OSy+9xL59+/jf//1f58TVsWNHZsyY0SoB24OEbo4bVTeeHJ/Jh38OtS6TiEh70J7nOdedHDcdAMPQDatFRKzmYxyfjU5i+fLljBw5sjXynJVT3Y3bG7y1B255v2Ec4Avf3gE9Qq3LJCLiDVpiDmjtec4T5i17Pdj+CYcbbQ7yxc+hr82SOCIi7cap5oDTugZt9+7dVFZWUl9fz//8z/9w+eWX8957751WgGeeeYaUlBQAZs+eTUpKCpmZmdTWOmaEhQsXkpSUxIgRI6ioqABg9erVJCYmMnToUAoLCwEoKCggJSWF5ORk8vPzT+uzvcno8+Gi8IZxbT38TTeuFhFpFecyz3krP9+mZ9HWFVmTRUREGpxWg/avf/2LsLAw3nvvPY4cOcKbb77J448/fsrXVVdXs3PnTgCKi4tZs2YNGzduJD4+nqVLl1JbW8u8efNYv34948aNY/78+QDMmDGDlStXkp2dzaxZswDIyspi8eLFLFmyhKysrLP9eT2Wny9MijfX5n6qbY9FRFrD2c5z3u7qnuaxGjQREeudVoN27NgxAN555x3GjRvHBRdcQH19/Slf9/zzzzN+/HgA8vLySEtLAyA9PZ3c3Fx2795NXFwc/v7+ztrRo0cJDg4mLCyMhIQEdu3aBTgu5I6JiSE6Otp0WrAtuasfRAY2jMuq4aUvrMsjItJenO085+2G9DCP1xU5rkMTERHrnFaDNnLkSC688EI2b97M8OHDKS4upkOHDid9TW1tLevWrWPYsGEAlJeXEx7uWMMXERFBWVlZs7WysjJnDcButwOYJsq2OmmGBsC9/c21P+10XCcgIiLuczbzXFtwVTcI8msYFx6BvZXW5RERkdNs0J566im2bdvG9u3bCQgIIDQ0lHfeeeekr3nllVe4/fbbnWObzea8xqyiogKbzdZsLTIy0lkD8PX1Nf3p+riteSDOsUHIcV9XwJt7rMsjItIenM081xYE+sFgXYcmIuJRTqvTKS4uZsqUKcTFxXHppZfy8MMP4+fnd9LXfPHFF8ydO5frrruOTz/9lK1bt7Ju3ToAcnJyGDx4MH379qWgoAC73e6shYSEUFVVxeHDh8nLy6N/f8cppaioKAoLCykqKvLanRpPR89QyOxjrv3uYy05ERFxp7OZ59qKIboOTUTEo5zWNvvXX389o0aN4o477gAcOy8uXbqUFStWnNaHpKSksHHjRv7whz+wfPlyYmNjeemll+jQoQOvvPIKc+fOJTIykkWLFhEREUFOTg5ZWVkEBQWxYMECYmNjyc/P5/7778cwDObMmcNll13mfH9P2K64JX1RBpe8Co3/Yt65Hkaeb1UiERHP1RJzwLnOc2fKk+atNd/DsEYnCy8Igz13WJdHRKStO9UccFoN2sCBA527MZ6sZhVPmuhaym0rYcnXDeOErrDpZt1AVETEVUvMAa09z3nSvHW01nE/tNpG1zvvGwcxHa3LJCLSlrXIfdDOO+88nn32WUpKSvjxxx/529/+RnR0dMullCZ+c7l5vPkgrPremiwiIm1de57nQgLgqq7mmpY5iohY56QN2rFjxyguLmbBggV8/vnnZGRkkJ6ezo4dO3juuedaK2O7NLAzjOhlrv1umzVZRETaKs1zDq7Xoa3RF4IiIpY5aYP2wAMPkJubS+fOnZkzZw7bt29n+/btDB8+nCeffLK1MrZbU13Ooq0tgo9+sCaLiEhbpHnOYajLycKcQm1OJSJilZM2aLm5uYwcObJJ/dZbb2XTpk1uCyUOg7vDNS6T5rQt1mQREWmLNM85JHd3bLl/3L7D8OWhEz9fRETc56QNWnV19QmPHTt2rMXDSFNTrzCPPyiE9bo2QESkRWiecwj2h9Qe5toHhdZkERFp707aoPXv359XX321SX3JkiX069fPbaGkQVrPptcGPJ6npSciIi1B81yDjPPM4w++syaHiEh7d9Jt9r/77jtGjx5NVFSU875jO3bsoLS0lKVLlxIbG9tqQU/Gk7YrdoeN+yF1qbm2cgRkxFiTR0TEk5zLHHCu81xRUREjRoxg165dHD58GH9/f+exadOm8fbbbxMZGcmoUaN45JFHWiSzu2wvhsvfaBiHd4Af7wL/09rvWURETleL3Aftgw8+4LPPPgPgkksuIT09HR8PuiGXJ050Le36d2FFo28zB3WFzbovmohIi8wBZzvPHTt2jKqqKm666SZycnKaNGgpKSmkp6e7JXNLqzeg+0tQ3Ghl54c3QVJ3yyKJiLRJp5oD/JtUmpGRkUFGRkbLpZIzNuMqc4O25SAs3wujLrAskohIm3G281xQUBBBQUEnPD5lyhQiIyP54x//6DxD56l8feCa8+DVrxpqH3ynBk1EpLVp4YKXuLIr/NSlGcva4vjGU0REPM+DDz7Itm3bmDt3LhMnTrQ6zmlpch2aNgoREWl1atC8yJODoPGCm/wfYdGXlsUREZGTiIqKAqBPnz4WJzl9rtc25x6AQyfe6FJERNxADZoXiesEY3uba7/ZDFV11uQREZETq6ioAKCkpIS6Ou/4hzqmI/SzNYzths6iiYi0NjVoXmZmAgQ0+lv77jD8Jd+6PCIi7VltbS3p6ens3LmT4cOHs3nzZudyxsmTJ5OcnMzIkSPJzs62OOnpu6GXefzut9bkEBFpr05rF0dP54m7YbnTox/BMzsbxmEB8HUmdAm2LpOIiFW8cQ7w5Mxrvodh7zSMuwTB/vHgp690RURaxKnmAP1z64WmXg62Dg3jylqYvtW6PCIi0nakdHfcA+244mOOnYNFRKR1qEHzQlFBkHWluTZ/F3xRZk0eERFpOwL84DqXzUL+vc+aLCIi7ZEaNC/1qwFwQVjDuK4efr3JujwiItJ2jNB1aCIillGD5qUC/WDWYHPt3W/h35pERUTkHF0fa76ty44SKDxsWRwRkXZFDZoX+9lFkNTdXHtoIxzzjt2cRUTEQ3UOhkSX+UVfAIqItA41aF7Mxwf+lmL+lvPrCvMOjyIiImfDdZnj0m+sySEi0t64rUErKCggKSmJ1NRU7rrrLgzDYPbs2aSkpJCZmUltbS0ACxcuJCkpiREjRjhv6rl69WoSExMZOnQohYWFzvdLSUkhOTmZ/Hzd+Ou4n3SBey8112Z+DPsqrckjIiJtw0iXBm3V91BebU0WEZH2xG0N2sUXX8xHH33Ehg0bANi6dStr1qxh48aNxMfHs3TpUmpra5k3bx7r169n3LhxzJ8/H4AZM2awcuVKsrOzmTVrFgBZWVksXryYJUuWkJWV5a7YXmnmVdApqGFcVacNQ0RE5NxcGgV9G92ep7Yelu+1LI6ISLvhtgYtICDA+TgwMJDdu3eTlpYGQHp6Orm5uezevZu4uDj8/f2dtaNHjxIcHExYWBgJCQns2rULgNLSUmJiYoiOjjbd3E0c2+7/PsFce/1rWKFtkUVE5Cz5+MCYi8y1N/ZYk0VEpD1x6zVo77zzDgMGDODgwYPU1dURHh4OOO6YXVZWRnl5eZNaWVmZswZgt9sBqK+vd9YaPxaHX/aDK7qYa/ethyO11uQRERHvd8uF5vH730FljTVZRETaC7c2aKNGjaKgoIDo6Gj8/f2d15hVVFRgs9mw2WxNapGRkc4agK+vr+lP18fi4OcLc682bxiytxKe2GJZJBER8XI/6Wy+52a1Xbs5ioi4m9s6nerqhiuJw8PDsdvtrFu3DoCcnBwGDx5M3759KSgowG63O2shISFUVVVx+PBh8vLy6N+/PwBRUVEUFhZSVFREREREs5/Z3g3qCg/GmWt/zoetB63JIyIi3s3Hp+lZtDe1zFFExK383fXGK1as4JlnngGgT58+zJgxg/3795OSkkJsbCyTJk0iICCACRMmkJqaSmRkJIsWLQJg6tSpZGRkEBQUxIIFCwCYPn06Y8eOxTAM5syZ467YXm9mArz9Dez77w1F6w2YsA7yboYAP2uziYiI9xlzEfyx0e1b3tvnWD4fGnDi14iIyNnzMQzDsDrEuWq8aYjOrsF738KN75lr2YNhyk+sySMi4k7eOAd4U+Z6A3q9AoVHGmqL02FsH+syiYh4s1PNAbqYqw26oReM7W2uPZEHn5Zak0dERLyXrw/8zGVOWfilNVlERNoDNWht1F+SISqwYVxTD3euglq7dZlERMQ73eFytmzFd1BcZU0WEZG2Tg1aG9U1BOakmmsfl8DMbdbkERER73VZZ+gf2TCuq4clX1uXR0SkLVOD1obd1htudbnJ6O8+1q6OIiJyZnx84I6+5tq/dluTRUSkrVOD1ob5+MDfU6FbcEPNbsCdq6GqzrpcIiLifW53WeaYewC+OtT8c0VE5OypQWvjOgfDP9LMtc/K4JEPLYkjIiJeqlcYpPYw1xbqLJqISItTg9YOjDwf7upnrs3bBW/q+gERETkDrsscX/rCsQ2/iIi0HDVo7cSfk+GicHPt7rXwbaUlcURExAvdehEE+TWM91ZCTqF1eURE2iI1aO1EeAd4NQMCGv2Nl9fA7TmO3bhEREROJTIQxrhsPvWPXdZkERFpq9SgtSNXdoXswebaRz84bmItIiJyOiZcYh4v2wsHj1oSRUSkTVKD1s5MiocbYs21Wdth2TfW5BER8WZFRUVcfvnlBAUFUVdX1+TYsGHDSEpKIicnx6KELS+1B/SNaBjX1sOCL6zLIyLS1qhBa2d8feClYdAjxFy/czXsLrcmk4iIt4qKimLVqlUMHjy4ybHs7GxmzpzJypUrmTlzpgXp3MPHB+52OYv2/GdgaLMQEZEWoQatHeoSDK9lgH+jv/2KGrh5BRyptS6XiIi3CQoKIjIystlj+fn5JCYm0rFjR8LCwqisbDu7Mo2/2HxN8+5DsOZ76/KIiLQlatDaqdSe8MdEc+3TMsfOjvoWVETk3Nntdnx8fACIiIigrKzM4kQtp2sI/PQCc+2vn1iTRUSkrVGD1o49GAc/722uvfoV/GG7NXlERNoSP7+G/egrKiqw2WwWpml5Dwwwj9/ZC18fsiSKiEibogatHfPxgX+kwYAoc/3/NsNbeyyJJCLSZsTHx7Np0yaOHDlCRUUF4eHhp36RF0ntAZd1bhgbwN8KLIsjItJmqEFr50ID4K3hYOtgro9bBR8XW5NJRMRb1NbWkp6ezs6dOxk+fDibN29m4sSJADz22GNMnTqV9PR0fvOb31ictOX5+MBDcebaPz+Hyhpr8oiItBU+huH9VxwdOtSwpiIiIuIkz5QTWVUI1/3bfNPqnqGQdzNEd7Qul4jIqXjjHOCNmZtzrA56/QsOVjXU/poCE+NO/BoRkfbuVHOAzqAJANecB39PNdeKjsCI/zh2eBQREXEV5A/39jfX/rTT/GWfiIicGbc1aJs3byYpKYnU1FQefvhhAGbPnk1KSgqZmZnU1jr2c1+4cCFJSUmMGDGCiooKAFavXk1iYiJDhw6lsLAQgIKCAlJSUkhOTiY/P99dsdu1Cf3h4XhzbUcJ3LQCqu3WZBIREc923wDo0Oj/TXxTCa99ZV0eERFv57YGrVevXqxevZoNGzZw8OBBNmzYwJo1a9i4cSPx8fEsXbqU2tpa5s2bx/r16xk3bhzz588HYMaMGaxcuZLs7GxmzZoFQFZWFosXL2bJkiVkZWW5K3a7NzsRRvQy11Z/D3eugnqvXwwrIiItrXuI475ojf3+Y80ZIiJny20NWvfu3QkKCgLA39+f/Px80tLSAEhPTyc3N5fdu3cTFxeHv7+/s3b06FGCg4MJCwsjISGBXbt2AVBaWkpMTAzR0dGmdZvSsvx84dUMSOhqri/5Gh7+UPdIExGRpqb8BHx9Gsa7yhzb7ouIyJlz+zVo+fn5lJSUYLPZnFsMH79hZ3l5eZNaWVmZaStiu92xtq6+vmFBe+PH0vJCA+DdG+Bil1v2/PUTmL7VmkwiIuK5LoqAsS731fzdNn2pJyJyNtzaoJWWlvLAAw/wwgsvYLPZnNeYHb9hZ3O1yMhIZw3A19fX9KfrY3GPzsHw/gjoEWKuT98Ksz62JpOIiHiu//uJeby1GN7/zposIiLezG2dTl1dHXfccQezZ8+me/fuDBo0iHXr1gGQk5PD4MGD6du3LwUFBdjtdmctJCSEqqoqDh8+TF5eHv37O7aHioqKorCwkKKiIq/ektib9AqDFSMgwuUeab/ZDH/eaU0mERHxTAM6wejzzbXH83QWTUTkTPm7641ff/11tmzZwpQpUwCYNWsWV199NSkpKcTGxjJp0iQCAgKYMGECqampREZGsmjRIgCmTp1KRkYGQUFBLFiwAIDp06czduxYDMNgzpw57ootLuI7Oc6kpS+Hw7UN9Yc/ggA/+NUA67KJiIhnyboSlu1tGG8rhjf3wJiLLIskIuJ1dKNqOS0bihw3sj5aZ64/kwQPD7Qmk4gIeOcc4I2ZT9eY9x1N2XEX26DgNvDX1QkiIoBuVC0tJLUnvHM9BPqZ6498BL/fZk0mERHxPDOuMu/o+EU5vPyFdXlERLyNGjQ5bdecB0uva9qkTc2DxzfrOgMREYFLIpveF+23W+BobfPPFxERMzVockaui4V/3wAhLlcv/u5jeGAD2HUHBBGRdm/aldCh0f/DKDwCf9huXR4REW+iBk3O2DXnOTYOCQsw1//+KfxsJRyra/51IiLSPsSGwYNx5tpTO+DbSmvyiIh4EzVoclZSekDOSLC5bMH/1jcw/F0or7Yml4iIeIbHr4CuwQ3jY3b49UfW5RER8RZq0OSsXdUNNvwUokPN9fX7Iflt2FPR/OtERKTtiwiEWQnm2ht7YM331uQREfEWatDknAzoBJtudlwU3tiuMkh407E9v4iItE+/6AdXdjHX7l2npfAiIiejBk3OWUxH2PhTSO5urpccg2uWw0ufW5NLRESs5esDf00x13Yfghm6PYuIyAmpQZMWERUEH4yEsb3N9dp6uGsNPLQRauzWZBMREeskdod7+ptrT+2AnSXW5BER8XRq0KTFBPvDonTH9squ/voJDHsHio60fi4REbHWU4OhZ6Prlevq4ZdrHX+KiIiZGjRpUT4+8NtB8GoGBLnc0PrDH+Dy12GdrksTEWlXIgLh76nm2rZimPWxNXlERDyZGjRxi9t6w8aboFeYuX6gynEmbdoWfXMqItKejL4Axlxork3fCpt+sCaPiIinUoMmbnNFF9h6C2ScZ67XG45Jedg78N1ha7KJiEjrm5Nqvjea3YDMHKiosS6TiIinUYMmbtU5GP5zI0y9vOmxDfth4BJ47avWzyUiIq2vawi8ONRc+6YSHtgAhmFNJhERT6MGTdzOzxdmJsCKG83fnAKUVcPYDxz/+/GYNflERKT13NALHhhgrr2yG57bZU0eERFPowZNWs3wWNj5s6ZLHsFxFm3Aa/DON62fS0TkbD388MOkpqby0EMPmerTpk1j4MCBpKWl8cwzz1iUznM9lQiXRpprEzdCrq5HExFRgyatq3sIrBjh2HK5g8t/fT8chdEr4Nb3Yb+24xcRD/fxxx9z5MgRNmzYQE1NDVu2bDEdf/rpp1m7di2PPPKIRQk9V7A/LLkWQv0barX1cMtKx1wgItKeqUGTVufrA5N/AtvGwE86Nz3+xh645FWY/6ljQxEREU+0adMm0tPTAUhPTyc3N9d0fMqUKaSnp7Njxw4r4nm8/lHw0jBzregI/PQ/cLTWmkwiIp5ADZpYZkAnyL0ZnrgC/HzMxw7VwL3rYfBbkHfAmnwiIidTXl5OeHg4ABEREZSVlTmPPfjgg2zbto25c+cyceJEqyJ6vDEXwWOXmWubD0LmKrDrViwi0k6pQRNLdfCD6VfB1jFwZZemx7cchIS34O41cFDLXkTEg9hsNioqKgCoqKjAZrM5j0VFRQHQp08fS7J5k98lNL02eek38PBH2tlRRNontzVoRUVFXH755QQFBVFXVwfA7NmzSUlJITMzk9pax/qFhQsXkpSUxIgRI5wT3erVq0lMTGTo0KEUFhYCUFBQQEpKCsnJyeTn57srtljkss6Os2l/SjJfk3DcC59Dn8Uw62Ooqmv9fCIirhITE1m1ahUAOTk5DB482Hns+HxWUlLinAOlef6+8Pq1EBdlrj/7iePffBGR9sZtDVpUVBSrVq1yTljFxcWsWbOGjRs3Eh8fz9KlS6mtrWXevHmsX7+ecePGMX/+fABmzJjBypUryc7OZtasWQBkZWWxePFilixZQlZWlrtii4X8fGHSQNg1Fm65sOnxihr4zWbouwgWfK7lLyJireNfQqampuLr68tVV13lXM44efJkkpOTGTlyJNnZ2RYn9XwRgfDejRAdaq5PzYM/6hI+EWlnmjlX0TKCgoIICgpyjvPy8khLSwMcF1MvWrSI/v37ExcXh7+/P+np6dxzzz0cPXqU4OBgwsLCSEhI4P/9v/8HQGlpKTExMQAcOnTIXbHFA8SGwRvD4YPv4MGN8Hm5+XjhEfjFGnhqBzw5CG660LHxiIhIa/vLX/5iGj/77LMAzi8c5fSd19HRpKUudXwhd9zkTY5dfx+Mty6biEhrarVr0Jq7mLq5WllZmbMGYLfbAaivbzhd0vixtF0ZMY77pj2TBJGBTY/vKoMxK+GKNxz3T9OOjyIi3i2+E/z7Bghx+fr4oQ9h9nZrMomItLZWa9Cau5i6uVpkZKSzBuDr62v60/WxtG0d/ODhgfB1Jjw6sOm90wB2lDjun3bZElj8pZY+ioh4s5QejiYt2KVJeywXHtukjUNEpO1rtU5n0KBBrFu3Dmi4mLpv374UFBRgt9udtZCQEKqqqjh8+DB5eXn0798fcFzTVlhYSFFREREREa0VWzxEZCD8MQk+/znc2bf5JY2flMLtOdDvVZhboPvoiIh4q7RoWHYdBPqZ67N3wC/XQq3dklgiIq3CxzDc811UbW0t119/Pdu2bePyyy/n97//PWvXrmX58uXExsby0ksv0aFDB1555RXmzp1LZGQkixYtIiIigpycHLKysggKCmLBggXExsaSn5/P/fffj2EYzJkzh8sua7hxSuNr0tS8tQ+flcG0LbDk6xM/p1MQ3Hcp3H8p9Ag98fNExLt54xzgjZmtsLrQsULisMsXbmk9HTs/dg62JpeIvDK6/QAAFYFJREFUyLk41RzgtgatNWmia7/yf4TffwxLvoIT/Yfs7+vYFfJXlzqWzvhoQxGRNsUb5wBvzGyVbcVw/btQfMxcvyAMll0PcZ2sySUicrbUoEm7sLsc/rAdXt4NdSe5Bi0uCu7pD5l9m994RES8jzfOAd6Y2Uq7y2H4u7C30lwP9Ye5V8O4i63JJSJyNtSgSbvy/WH4WwHM+xTKa078vEA/x1m1/+nnWCrjp31nRLyWN84B3pjZasVVMOZ9WL+/6bFxfWFOKoR1aP1cIiJnSg2atEuHa+HFz2FOAXxRfvLnRodCZh/HBD9AS2VEvI43zgHemNkT1Ngd98ecv6vpsd4R8NJQSO7R+rlERM6EGjRp1wwDVn3vaNTe2Xvqe6UNiIKfXQS39Ya+tlaJKCLnyBvnAG/M/P/bu/vgqMp7D+Df3Wwg5HUToolQKhW1FDSJYWLemwg7ooDSTjtwoTR62zrVUqVIp51x7pTCwL1UOly4tgPe0RlJlcFO9ap3ClcBBV9IhIgaCDbUNgHW8Jpkydtm3/K7fzz7mt0kG5Jw9iTfz8yZ87pnn32yOb/9nfOc58SS/z4NrPkQ6O3Xm6MBwOq7gH8v5NU0IopdTNCIvKxdwO5G4MUvgKbOobfPmQp89xtqyJnKzkWIYpUeY4AeyxxrTrUC/3IAaGgPXzcjGfivMmDpTB67iSj2MEEj6qdPgPe+Usna6/8Eut1Dv+YbKcBDM4HFtwIV08KfzUNE2tFjDNBjmWNRjwtYdxTYFaHJIwDMnw78Z6k6yUZEFCuYoBENossFvNEEvHwGOGgFPFH8NySZgAVfA+6fASycoe57ICLt6DEG6LHMsexdK/DYEeCfHeHrjAbgX78J/Ns8YGbqjS8bEVF/TNCIonTVDrzeBLz6JXC4Zej71XxuS1VnaedPB+6bDmQnjm05iSiUHmOAHssc63pcwPrjwLb6yMdvkxF49JvAM/nAN5ioEZGGmKARXYcrduB/m4H/aQIOWAGHZ8iX+H3TDHz7FqDcO9yawnsgiMaSHmOAHsusF6dagaePqmN3JCYjsHwWsCYHKLj5xpaNiAhggkY0Yl0u4JAV+OtZ4K/ngJbu4b3+lkSgJBsozgKKsoB7MoHE+LEpK9FEpMcYoMcy64kIsO+cuj9tsEetFGcBT90NfPc23ltMRDcOEzSiUSQCfN4KHDgPvH0e+OAC4Owb3j7iDKo7/4KbgfxMIP8mdQP7FNPYlJlovNNjDNBjmfXI3Qe8cgbYdAL48trA22VMBlbcoZpAzruJrR6IaGwxQSMaQz0u4KOLqlfId78C6q5E19FIf3EG1TQyd6pK1nKmqiRuRjJ/KBANRY8xQI9l1jN3H7Dn78DmT4AzgyRqADAnXT0P87u3AXdn8BhMRKOPCRrRDdTpBGouAe+3qKtrxy6HP0h1OFLi1Y+FuRnAbDMwOx34VjowM0XdR0FE+owBeizzeNAnwP+dA3acBN45P/T2s1LVszCXzFTNISexGSQRjQImaEQacnpUk8iai0DtJeD4lcGb2UTLZARuSwHuNAN3pAGz0tQPidvTgK8n80cETSx6jAF6LPN480U7sLNBNYFscwy9fZJJPQfT8jU1zM1QXfgTEQ0XEzSiGNPWq5pCfnIFOHEF+PQq8I8Iz+65XkYDMD1JXWWbmaJ6kbw1Gfh6ikrevpYMJLOTEhpH9BgD9Fjm8crhUZ1A7W5U42ibqZsnAYVZ6spacTZQeDOQNnlsy0pE4wMTNCIduOYATrYB9a3qitvJVqChHehwjs37mSepRG1akkrmpiUCtySpHidvSVTPcsuawt4mSR/0GAP0WOaJwPeIldebVGdQw+kEygDVmiF3amDImcpHrRBROCZoRDolAli7gYY24G/twBc2Nf6bDbhsvzFlSI5XiVpWInBTAnDzFOCmKUBmQmCYGjSkTmKTH7rx9BgD9FjmiabDCew/p66qHbQCF3qubz8p8aopuq9Jun8wq94jmbwRTTxM0IjGoQ4n8PdrwBmbah755TXgH9fU9PX+iBgNRgOQPln96Ej3DubJQPokNU6bpAbfdKpviAdSJqkfMrx/joZLjzFAj2WeyESA0+0qUTtgBT68AFwbhRYOSSbVmmGGb0gKTGclek+KJQDxPC4SjStM0IgmmF43cLYTaOpU43NdajjbCVi71FU51zCf3XYjTTIGkrXkeDVOilc/ZJKDphNNodOJJvUsuSnB03GBZQne6clxvMo33ugxBuixzBTQJ6pFQ80l1QFUzUWVwI3VD6r0yYFWDL6WDBmTAye7zJNV03X/tHd5Qhyv0BHFIiZoRBSiT1QTyZZu4KvuwPhCD3CxJzC+bI/tRG4k4o3qh0tCnErYEkzAZKOa9g2T4tSySb5577RvHG9U0/FB8/0Hk0Gd+Q6eN/mmg+bjDIH5uAjL4wzeIXjaoBJN/vjSNgasXbsWdXV1yM/Px44dO/zLW1pasGrVKvT29mLjxo2wWCwhr2PcGn+6XcCpoHuJP78K1LeN3b3E0Yg3ek9i9TuxlWgKPbnlWzbFpI5r/Y+BIcuC54OWBx+/4gY4hpmMPGYRAUPHANONLMxIDRQIiSh6RoPqBCQ7Eci/aeDtRIB2B3DJrm6cvxw0vtqrhit21T11a68aut037nOMhKtPDZ0urUsyckZDaNLmS+KMQUlcyDTC14UMiLzM0G+9b96AwNjQb1sDgtYHbRO8fEYy8B9F2tTdSJ04cQLd3d344IMP8MQTT+D48eMoKCgAAGzZsgWbNm1CTk4OlixZEpag0fiTFK96dSzMCiwTUSe8fE3S/34tMPyjA7CP8THT1QfYnGqIFQaEJ22Rxv2PHZGOM8PaBoMfm4K3Cc4h+yeUhgGm+2872LrR2s+w1kVbFibQQ7onE3g6d2zfQzcJ2mCBkIhGn8EAZCSo4Vvp0b3G6VFJXZtDPU7A5gRsjsD4WtC4wwl0uNT4mlM95LvTFX0X16T0iRr0mmvenaHfBK2mpsafeFksFtTW1vrjUn19PXbs2AGDwYCUlBR0dnYiJSVFy+KSBgwGbw+5ScC3p4WuE1HHSmsXcD546FbLgk+IjafDosB7kkzrghBdJ5uDCZrfYIGQiGLDpDh1Y3tW4vW9XkSdUe5yAV3ecadTXZnrcqkmRF0uoMetlnW7ALsH6PEu63EH5u0etS+7G+j1BMa9ntH9zDQyej5ba7PZMGvWLACqiUpDQ4N/ncfjgcH74dLS0tDe3s4EjUIYDIEecHMzB97O06daKFy2A1e848v28JNeNmdg3ndibLw2Uyca73SToA0WCIlofDAY1L0SifHAzWP0HiLqwbQOb7LmCB76VCcrzr7Q5a6+wDJXn7pS6PSOfc0lfdsEz7v7jwVweV/jETXvW+cR9UPMP+1d5/Yu9y0LXjce6Dg/g9lsRkeHesp8R0cHzGazf11cXKDbvf7riIYjzgjcnKiG4RBRx6Ru30mtoJNb/ee7XWrs8KjjmsMTOOb5x0HLnd7jpTPoOBl8bAoe958moqHpJkEbLBASEUXLYFCdgiSYAL13zeBr3uhL7voQmswFr/dN+7YJmfbuS7zbSr99i4Ru0xe0XoK2F4Rv239dyBiq5zm9Ki4uxvPPP49ly5bh4MGDePTRR/3rcnJyUFNTg5ycHHR0dCA1NVW7gtKEZDAEOj3K0LowXhJ0XHEHnajy9IUvCzl+DHCcibh8ONsMsP/g8oaUP9p1ET73aO9n1NYNUhaKbHrS2L+HbhK0wQIhEdFE5OvEwwQAfE7SDZefn4+EhASUl5cjNzcX9957L5588kk899xz+NWvfoWqqirY7XZs2LBB66ISxQSDrzMj8JmXRIPRVTf7a9aswYkTJ5Cbm4s//OEP/uXsrpiIaOLSYwzQY5mJiGh0jKtu9tm1PhERERERjWdGrQtAREREREREChM0IiIiIiKiGMEEjYiIiIiIKEYwQSMiIiIiIooRuuokJBrBvaIQERHFOsYtIiIKxitoREREREREMYIJGhERERERUYzQ1YOqiYiIiIiIxjNeQSMiIiIiIooRTNCCrF27FuXl5VizZo3WRdHcxx9/jJKSEpSXl2Pt2rUAgK1bt6KsrAw/+MEP4HK5NC6htrZt24aysjIArJdg1dXVWLBgASorK/HVV1+xbrx6enqwePFiVFZWYunSpXA4HBO+blpaWpCfn4+EhAS43W4Akf+XXnnlFZSUlGDJkiXo6OjQssgUJNoYEenv9+6776K4uBj33XcfrFarZp9BS0PFENZbqGhiC+ssVLRxh/WmjCQmRaqvU6dOoaysDKWlpaivrx9+gYREROSTTz6Rxx57TEREHn/8cTl27JjGJdLWhQsXxG63i4jIypUr5f3335cHH3xQRES2bNkif/7zn7UsnqZ6e3ulqqpKSktL5fLly6wXL6vVKj/60Y/886ybgNdee002bNggIiKbNm2Sl156acLXjd1ul7a2NqmoqBCXyxXx++J0OqWsrExcLpfs3btXnn32WY1LTT7RxIiB/n6VlZXS0dEhtbW18rOf/Uyzz6CVoWII6y1UNLGFdRYumrjDegsYSUyKVF/f+c535Ny5c2K1WuXhhx8ednl4Bc2rpqYGFosFAGCxWFBbW6txibSVnZ2NhIQEAIDJZEJ9fT0qKysBsH5eeOEFPPLIIwCAY8eOsV683n77bXg8HixYsABPPvkk6ybIrFmz4HA4AAA2mw3Nzc0Tvm4SEhKQnp7un4/0fTlz5gzuvvtumEymCVtPsSqaGBHp79fT04MpU6YgJSUFhYWFOH36tIafQhtDxRDWW6hoYgvrLFw0cYf1FnC9MWmg+mpra8OMGTMwffr063qUChM0L5vNhtTUVABAWloa2tvbNS5RbKivr8fVq1dhNptZPwBcLheOHDmC+fPnA+D3JtilS5fgdDpx6NAhJCYmsm6C3HHHHfj4448xd+5c1NXV4fbbb2fd9BPp+8LvUOwbLEZE+vu1t7f7lwGAx+PRpNxaiSaGsN5CRRNbWGfhook7rLeBjfR71tfX518WPB0tJmheZrPZ35a0o6MDZrNZ4xJpr62tDT//+c/x4osvsn68/vSnP2HlypX+edZLQFpaGioqKgAA8+fPR3NzM+vGa/fu3Vi4cCEaGhqwePFiuN1u1k0/kf6X+P8V24aKEZGWpaenh9xLaDROrJ8h0cQQ1luoaGIL6yxcNHGH9Tawkf5vBtfb9dThxKz1CIqLi3Ho0CEAwMGDB1FUVKRxibTldruxatUqbN26FdnZ2SgoKMCRI0cATOz6aWxsxM6dO/HAAw+goaEBdXV1rBevkpIS/42wn332GWbMmMG68RIRZGRkAAAyMzPR3NzMuukn0jHmzjvvxKlTp+DxeFhPMSaaGBHp75eYmAi73Y6uri4cO3YMc+bM0fiT3FjRxBDWW6hoYgvrLFw0cYf1NrCRHtMyMjJgtVrR0tKCtLS04RdgtG6uGw+eeuopKSsrk9WrV2tdFM3t2bNHMjMzpaKiQioqKuTo0aOyZcsWKS0tlRUrVojD4dC6iJorLS0VEWG9BFm3bp1UVFTI9773PXE4HKwbr/b2drn//vuloqJCLBaLtLa2Tvi6cTqdsmDBAjGbzTJ//nypra2NWCfV1dVSXFwsixYtEpvNpnGpySfaGBHp73fgwAEpKiqSyspKOXv2rJYfQ1ODxRDWW6hoYgvrLFS0cYf1powkJkWqr88//1xKS0ulpKREPv3002GXhw+qJiIiIiIiihFs4khERERERBQjmKARERERERHFCCZoREREREREMYIJGhERERERUYxggkZERERERBQjmKARjZKWlhZUVVUBAA4fPoy6urpR2/f27dvhdrvD3me0vfHGG/jyyy/HZN9ERBRbGLeIYhMTNKJRMm3aNFRXVwO4vkDn8XgGXBcc6ILfZ7Qx0BERTRyMW0SxiQka0Shpbm5GUVERWlpasGvXLmzevBl5eXlobGxEY2MjLBYL5s2bh0WLFqG1tRUAMHPmTGzcuBFFRUU4fvw41q9fj4KCAtx111345S9/CQDYtWsXWlpaUFhYiOXLl/vfBwCuXLmCRYsWIScnBwsXLsSlS5cAAJWVlfj1r3+NefPmIT8/H+fPnw8r7/bt2zF79mzk5ubiF7/4Berq6vDWW29h9erVyMvLQ2dnJ2pqalBWVob8/HysWLECvb29AICsrCw8/vjjmDNnDn74wx/6gzAREekH4xZRjBqtJ3ATTXRNTU1SWFgoIiLr16+XnTt3+tdZLBY5d+6ciIjs3r1b1q1bJyIit956q+zatcu/XWtrq4iIeDweWbp0qdTW1vq3s9vtYe/zxBNPyPbt20VE5I9//KP85Cc/ERGRiooK2bhxo4iI/P73v5dnnnkmrLyZmZnS09MjIiI2m01ERB555BHZv3+/iIg4HA4pLy+X9vZ2ERHZsGGDPPfccyIiAkD27dsnIiJVVVVSXV19XXVGRETaYdwiik28gkY0xjo7O3H06FE89NBDyMvLw9atW0PODH7/+9/3Tx86dAj33nsv8vLyUFtbi9OnTw+676NHj2LFihUAgFWrVuHDDz/0r3v44YcBAPfccw/Onj0b9tr8/HxUVVXh1VdfxeTJk8PWNzY24uTJk6isrEReXh727t2L5uZmAEBiYiIefPBBf/k/+uijKGuDiIhiHeMWkbZMWheAaLwTEUyfPh2fffZZxPVJSUkAgN7eXjz99NM4fvw4srOzsW7dOjgcjiH3bTAYIq7zBS+j0RixKce+ffvw3nvv4S9/+Qt27tyJw4cPh+27oKAA77zzTthr+7/nQGUgIiL9Ydwi0havoBGNgeTkZHR2dgIAUlNTkZ6e7g8YDocDjY2NYa/p7e2F0WjE1KlTYbPZ8Oabb0bcX7DS0lLs3bsXALBnzx6UlZVFVb6+vj5YrVZYLBZs27YNX3zxRdj7zJ49G01NTTh58iQAdUa1qakJANDd3Y39+/cDAF577TWUlJRE9b5ERBSbGLeIYgcTNKIxsGTJElRXV/tvtn755Zfxu9/9Drm5uZg3b17Es5JmsxmrVq3C3LlzsWzZMv8N1QDw4x//GOXl5Vi+fHnIa377299i3759yMnJweuvv45NmzZFVT6Px4OVK1ciJycHhYWF2Lx5MwBg2bJl+M1vfoO8vDw4HA7s2bMHP/3pT5Gbm4vy8nJ/k5OsrCwcOHAAubm5cLvd/uYqRESkT4xbRLHDICKidSGISF+ys7Nx8eJFrYtBREQUFcYt0hNeQSMiIiIiIooRvIJGREREREQUI3gFjYiIiIiIKEYwQSMiIiIiIooRTNCIiIiIiIhiBBM0IiIiIiKiGMEEjYiIiIiIKEYwQSMiIiIiIooR/w9X9Ub2gawEPAAAAABJRU5ErkJggg==\n",
"text/plain": [
"<Figure size 864x288 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# plot cost versus iteration \n",
"fig, (ax1, ax2) = plt.subplots(1, 2, constrained_layout=True, figsize=(12,4))\n",
"ax1.plot(J_hist[:100])\n",
"ax2.plot(1000 + np.arange(len(J_hist[1000:])), J_hist[1000:])\n",
"ax1.set_title(\"Cost vs. iteration(start)\"); ax2.set_title(\"Cost vs. iteration (end)\")\n",
"ax1.set_ylabel('Cost') ; ax2.set_ylabel('Cost') \n",
"ax1.set_xlabel('iteration step') ; ax2.set_xlabel('iteration step') \n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Predictions\n",
"Now that you have discovered the optimal values for the parameters $w$ and $b$, you can now use the model to predict housing values based on our learned parameters. As expected, the predicted values are nearly the same as the training values for the same housing. Further, the value not in the prediction is in line with the expected value."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1000 sqft house prediction 300.0 Thousand dollars\n",
"1200 sqft house prediction 340.0 Thousand dollars\n",
"2000 sqft house prediction 500.0 Thousand dollars\n"
]
}
],
"source": [
"print(f\"1000 sqft house prediction {w_final*1.0 + b_final:0.1f} Thousand dollars\")\n",
"print(f\"1200 sqft house prediction {w_final*1.2 + b_final:0.1f} Thousand dollars\")\n",
"print(f\"2000 sqft house prediction {w_final*2.0 + b_final:0.1f} Thousand dollars\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"toc_40291_2.6\"></a>\n",
"## Plotting\n",
"You can show the progress of gradient descent during its execution by plotting the cost over iterations on a contour plot of the cost(w,b). "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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
gitextract_0npo72x2/ ├── CODE_OF_CONDUCT.md ├── Course-1-Supervised-Machine-Learning-Regression-and-Classification/ │ ├── Course-1-Week-1/ │ │ ├── Course-1-Week-1-Lecture-Slides/ │ │ │ └── Course-1-Week-1-Lecture-Slides.md │ │ ├── Course-1-Week-1-Optional-Labs/ │ │ │ ├── Course-1-Week-1-Optional-Labs-1-Python-and-Jupyter-Notebook.ipynb │ │ │ ├── Course-1-Week-1-Optional-Labs-3-Model-Representation.ipynb │ │ │ ├── Course-1-Week-1-Optional-Labs-4-Cost-function.ipynb │ │ │ ├── Course-1-Week-1-Optional-Labs-5-Gradient-Descent.ipynb │ │ │ ├── Course-1-Week-1-Optional-Labs.md │ │ │ ├── data/ │ │ │ │ ├── Course-1-Week-1-Optional-Labs-data.md │ │ │ │ └── data.txt │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-1-Week-1-Optional-Labs-images.md │ │ │ ├── lab_utils_common.py │ │ │ └── lab_utils_uni.py │ │ ├── Course-1-Week-1-Practice-Quiz/ │ │ │ └── Course-1-Week-1-Practice-Quiz.md │ │ └── Course-1-Week-1.md │ ├── Course-1-Week-2/ │ │ ├── Course-1-Week-2-Lecture-Slides/ │ │ │ └── Course-1-Week-2-Lecture-Slides.md │ │ ├── Course-1-Week-2-Optional-Labs/ │ │ │ ├── Course-1-Week-2-Optional-Labs-1-Python-Numpy-Vectorization.ipynb │ │ │ ├── Course-1-Week-2-Optional-Labs-2-Multiple-Linear-Regression.ipynb │ │ │ ├── Course-1-Week-2-Optional-Labs-3-Feature-Scaling-and-Learning-Rate.ipynb │ │ │ ├── Course-1-Week-2-Optional-Labs-4-Feature-Engineering-and-Polynomial-Regression.ipynb │ │ │ ├── Course-1-Week-2-Optional-Labs-5-Linear-Regression-with-Scikit-Learn.ipynb │ │ │ ├── Course-1-Week-2-Optional-Labs-6-Sklearn-Normalization.ipynb │ │ │ ├── Course-1-Week-2-Optional-Labs.md │ │ │ ├── data/ │ │ │ │ ├── Course-1-Week-2-Optional-Labs-data.md │ │ │ │ └── houses.txt │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-1-Week-2-Optional-Labs-images.md │ │ │ ├── lab_utils_common.py │ │ │ └── lab_utils_multi.py │ │ ├── Course-1-Week-2-Practice-Labs/ │ │ │ ├── Course-1-Week-2-Practice-Labs-1-Linear-Regression.ipynb │ │ │ ├── Course-1-Week-2-Practice-Labs.md │ │ │ ├── data/ │ │ │ │ ├── Course-1-Week-2-Practice-Labs-data.md │ │ │ │ ├── ex1data1.txt │ │ │ │ └── ex1data2.txt │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Course-1-Week-2-Practice-Quiz/ │ │ │ └── Course-1-Week-2-Practice-Quiz.md │ │ └── Course-1-Week-2.md │ ├── Course-1-Week-3/ │ │ ├── Course-1-Week-3-Lecture-Slides/ │ │ │ └── Course-1-Week-3-Lecture-Slides.md │ │ ├── Course-1-Week-3-Optional-Labs/ │ │ │ ├── Course-1-Week-3-Optional-Labs-1-Classification.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-2-Sigmoid-function-and-Logistic-Regression.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-3-Decision-Boundary.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-4-Logistic-Loss.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-5-Cost-Function-for-Logistic-Regression.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-6-Gradient-Descent-for-Logistic-Regression.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-7-Logistic-Regression-with-Scikit-Learn.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-8-Overfitting.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs-9-Regularization.ipynb │ │ │ ├── Course-1-Week-3-Optional-Labs.md │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-1-Week-3-Optional-Labs-images.md │ │ │ ├── lab_utils_common.py │ │ │ ├── plt_logistic_loss.py │ │ │ ├── plt_one_addpt_onclick.py │ │ │ ├── plt_overfit.py │ │ │ └── plt_quad_logistic.py │ │ ├── Course-1-Week-3-Practice-Labs/ │ │ │ ├── Course-1-Week-3-Practice-Labs-1-Logistic-Regression.ipynb │ │ │ ├── Course-1-Week-3-Practice-Labs.md │ │ │ ├── data/ │ │ │ │ ├── Course-1-Week-3-Optional-Labs-data.md │ │ │ │ ├── ex2data1.txt │ │ │ │ └── ex2data2.txt │ │ │ ├── images/ │ │ │ │ └── Course-1-Week-3-Practice-Labs-images.md │ │ │ ├── public_tests.py │ │ │ ├── test_utils.py │ │ │ └── utils.py │ │ ├── Course-1-Week-3-Practice-Quiz/ │ │ │ └── Course-1-Week-3-Practice-Quiz.md │ │ └── Course-1-Week-3.md │ └── Course-1.md ├── Course-2-Advanced-Learning-Algorithms/ │ ├── Course-2-Week-1/ │ │ ├── Course-2-Week-1-Lecture-Slides/ │ │ │ └── Course-2-Week-1-Lecture-Slides.md │ │ ├── Course-2-Week-1-Optional-Labs/ │ │ │ ├── Course-2-Week-1-Optional-Labs-1-Neurons-and-Layers.ipynb │ │ │ ├── Course-2-Week-1-Optional-Labs-2-Coffee-Roasting-in-Tensorflow.ipynb │ │ │ ├── Course-2-Week-1-Optional-Labs-3-Coffee-Roasting-Numpy.ipynb │ │ │ ├── Course-2-Week-1-Optional-Labs.md │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-2-Week-1-Optional-Labs-images.md │ │ │ ├── lab_coffee_utils.py │ │ │ ├── lab_neurons_utils.py │ │ │ ├── lab_utils_common.py │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Course-2-Week-1-Practice-Labs/ │ │ │ ├── Course-2-Week-1-Practice-Labs-1-Neural-Networks-for-Binary-Classification.ipynb │ │ │ ├── Course-2-Week-1-Practice-Labs.md │ │ │ ├── autils.py │ │ │ ├── data/ │ │ │ │ ├── Course-2-Week-1-Practice-Labs-data.md │ │ │ │ ├── X.npy │ │ │ │ └── y.npy │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-2-Week-1-Practice-Labs-images.md │ │ │ ├── lab_neurons_utils.py │ │ │ ├── lab_utils_common.py │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Course-2-Week-1-Practice-Quiz/ │ │ │ └── Course-2-Week-1-Practice-Quiz.md │ │ └── Course-2-Week-1.md │ ├── Course-2-Week-2/ │ │ ├── Course-2-Week-2-Lecture-Slides/ │ │ │ └── Course-2-Week-2-Lecture-Slides.md │ │ ├── Course-2-Week-2-Optional-Labs/ │ │ │ ├── Course-2-Week-2-Optional-Labs-1-Relu-Activation.ipynb │ │ │ ├── Course-2-Week-2-Optional-Labs-2-SoftMax.ipynb │ │ │ ├── Course-2-Week-2-Optional-Labs-3-Multiclass.ipynb │ │ │ ├── Course-2-Week-2-Optional-Labs.md │ │ │ ├── autils.py │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-2-Week-2-Optional-Labs-images.md │ │ │ ├── lab_utils_common.py │ │ │ ├── lab_utils_multiclass.py │ │ │ ├── lab_utils_multiclass_TF.py │ │ │ ├── lab_utils_relu.py │ │ │ └── lab_utils_softmax.py │ │ ├── Course-2-Week-2-Practice-Labs/ │ │ │ ├── Course-2-Week-2-Practice-Labs-1-Neural-Networks-for-Multiclass-Classification.ipynb │ │ │ ├── Course-2-Week-2-Practice-Labs.md │ │ │ ├── autils.py │ │ │ ├── data/ │ │ │ │ ├── Course-2-Week-2-Practice-Labs-data.md │ │ │ │ ├── X.npy │ │ │ │ └── y.npy │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-2-Week-2-Practice-Labs-images.md │ │ │ ├── lab_utils_common.py │ │ │ ├── lab_utils_softmax.py │ │ │ └── public_tests.py │ │ ├── Course-2-Week-2-Practice-Quiz/ │ │ │ └── Course-2-Week-2-Practice-Quiz.md │ │ └── Course-2-Week-2.md │ ├── Course-2-Week-3/ │ │ ├── Course-2-Week-3-Lecture-Slides/ │ │ │ └── Course-2-Week-3-Lecture-Slides.md │ │ ├── Course-2-Week-3-Practice-Labs/ │ │ │ ├── Course-2-Week-3-Practice-Labs-1-Advice-for-Applying-Machine-Learning.ipynb │ │ │ ├── Course-2-Week-3-Practice-Labs.md │ │ │ ├── assigment_utils.py │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── Course-2-Week-3-Practice-Labs-images.md │ │ │ ├── public_tests_a1.py │ │ │ └── utils.py │ │ ├── Course-2-Week-3-Practice-Quiz/ │ │ │ └── Course-2-Week-3-Practice-Quiz.md │ │ └── Course-2-Week-3.md │ ├── Course-2-Week-4/ │ │ ├── Course-2-Week-4-Lecture-Slides/ │ │ │ └── Course-2-Week-4-Lecture-Slides.md │ │ ├── Course-2-Week-4-Practice-Labs/ │ │ │ ├── Course-2-Week-4-Practice-Labs-1-Decision-Tree-with-Markdown.ipynb │ │ │ ├── Course-2-Week-4-Practice-Labs.md │ │ │ └── public_tests.py │ │ ├── Course-2-Week-4-Practice-Quiz/ │ │ │ └── Course-2-Week-4-Practice-Quiz.md │ │ └── Course-2-Week-4.md │ └── Course-2.md ├── Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/ │ ├── Course-3-Week-1/ │ │ ├── Course-3-Week-1-Lecture-Slides/ │ │ │ └── Course-3-Week-1-Lecture-Slides.md │ │ ├── Course-3-Week-1-Practice-Labs/ │ │ │ ├── Course-3-Week-1-Practice-Labs-1-KMeans.ipynb │ │ │ ├── Course-3-Week-1-Practice-Labs-2-Anomaly_Detection.ipynb │ │ │ ├── Course-3-Week-1-Practice-Labs.md │ │ │ ├── data/ │ │ │ │ ├── Course-3-Week-1-Practice-Labs-data.md │ │ │ │ ├── X_part1.npy │ │ │ │ ├── X_part2.npy │ │ │ │ ├── X_val_part1.npy │ │ │ │ ├── X_val_part2.npy │ │ │ │ ├── ex7_X.npy │ │ │ │ ├── y_val_part1.npy │ │ │ │ └── y_val_part2.npy │ │ │ ├── images/ │ │ │ │ └── Course-3-Week-1-Practice-Labs-images.md │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Course-3-Week-1-Practice-Quiz/ │ │ │ └── Course-3-Week-1-Practice-Quiz.md │ │ └── Course-3-Week-1.md │ ├── Course-3-Week-2/ │ │ ├── Course-3-Week-2-Lecture-Slides/ │ │ │ └── Course-3-Week-2-Lecture-Slides.md │ │ ├── Course-3-Week-2-Practice-Labs/ │ │ │ ├── Course-3-Week-1-Practice-Labs-1-Collaborative-Filtering-Recommender-Systems.ipynb │ │ │ ├── Course-3-Week-2-Practice-Labs-2-Deep-Learning-For-Content-Based-Filtering.ipynb │ │ │ ├── Course-3-Week-2-Practice-Labs.md │ │ │ ├── data/ │ │ │ │ ├── Course-3-Week-2-Practice-Labs-data.md │ │ │ │ ├── content_item_train.csv │ │ │ │ ├── content_item_train_header.txt │ │ │ │ ├── content_item_vecs.csv │ │ │ │ ├── content_movie_list.csv │ │ │ │ ├── content_user_to_genre.pickle │ │ │ │ ├── content_user_train.csv │ │ │ │ ├── content_user_train_header.txt │ │ │ │ ├── content_y_train.csv │ │ │ │ ├── small_movie_list.csv │ │ │ │ ├── small_movies_R.csv │ │ │ │ ├── small_movies_W.csv │ │ │ │ ├── small_movies_X.csv │ │ │ │ ├── small_movies_Y.csv │ │ │ │ └── small_movies_b.csv │ │ │ ├── images/ │ │ │ │ └── Course-3-Week-2-Practice-Labs-images.md │ │ │ ├── public_tests.py │ │ │ ├── recsysNN_utils.py │ │ │ └── recsys_utils.py │ │ ├── Course-3-Week-2-Practice-Quiz/ │ │ │ └── Course-3-Week-2-Practice-Quiz.md │ │ └── Course-3-Week-2.md │ ├── Course-3-Week-3/ │ │ ├── Course-3-Week-3-Optional-Labs/ │ │ │ ├── Course-3-Week-3-Optional-Labs-1-State-Action-Value-Function.ipynb │ │ │ ├── Course-3-Week-3-Optional-Labs.md │ │ │ └── utils.py │ │ ├── Course-3-Week-3-Practice-Labs/ │ │ │ ├── Course-3-Week-3-Practice-Labs-1-Reinforcement-Learning.ipynb │ │ │ ├── Course-3-Week-3-Practice-Labs.md │ │ │ ├── images/ │ │ │ │ └── Course-3-Week-3-Practice-Labs-images.md │ │ │ ├── lunar_lander_model.h5 │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Course-3-Week-3-Practice-Quiz/ │ │ │ └── Course-3-Week-3-Practice-Quiz.md │ │ └── Course-3-Week-3.md │ └── Course-3.md ├── Course-Certificates/ │ └── Course-Certificates.md ├── LICENSE └── README.md
SYMBOL INDEX (355 symbols across 46 files)
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/lab_utils_common.py
function compute_cost_matrix (line 20) | def compute_cost_matrix(X, y, w, b, verbose=False):
function compute_gradient_matrix (line 44) | def compute_gradient_matrix(X, y, w, b):
function compute_cost (line 68) | def compute_cost(X, y, w, b):
function compute_gradient (line 87) | def compute_gradient(X, y, w, b):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/lab_utils_uni.py
function plt_house_x (line 23) | def plt_house_x(X, y,f_wb=None, ax=None):
function mk_cost_lines (line 37) | def mk_cost_lines(x,y,w,b, ax):
function plt_intuition (line 66) | def plt_intuition(x_train, y_train):
function plt_stationary (line 100) | def plt_stationary(x_train, y_train):
class plt_update_onclick (line 162) | class plt_update_onclick:
method __init__ (line 163) | def __init__(self, fig, ax, x_train,y_train, dyn_items):
method __call__ (line 171) | def __call__(self, event):
function soup_bowl (line 200) | def soup_bowl():
function inbounds (line 239) | def inbounds(a,b,xlim,ylim):
function plt_contour_wgrad (line 249) | def plt_contour_wgrad(x, y, hist, ax, w_range=[-100, 500, 5], b_range=[-...
function plt_divergence (line 279) | def plt_divergence(p_hist, J_hist, x_train,y_train):
function add_line (line 341) | def add_line(dj_dx, x1, y1, d, ax):
function plt_gradients (line 353) | def plt_gradients(x_train,y_train, f_compute_cost, f_compute_gradient):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/lab_utils_common.py
function compute_cost_matrix (line 20) | def compute_cost_matrix(X, y, w, b, verbose=False):
function compute_gradient_matrix (line 44) | def compute_gradient_matrix(X, y, w, b):
function compute_cost (line 68) | def compute_cost(X, y, w, b):
function compute_gradient (line 87) | def compute_gradient(X, y, w, b):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/lab_utils_multi.py
function load_data_multi (line 11) | def load_data_multi():
function plt_house_x (line 21) | def plt_house_x(X, y,f_wb=None, ax=None):
function mk_cost_lines (line 35) | def mk_cost_lines(x,y,w,b, ax):
function inbounds (line 56) | def inbounds(a,b,xlim,ylim):
function plt_contour_wgrad (line 68) | def plt_contour_wgrad(x, y, hist, ax, w_range=[-100, 500, 5], b_range=[-...
function plt_contour_multi (line 100) | def plt_contour_multi(x, y, w, b, ax, prange, p1, p2, title="", xlabel="...
function plt_equal_scale (line 122) | def plt_equal_scale(X_train, X_norm, y_train):
function plt_divergence (line 151) | def plt_divergence(p_hist, J_hist, x_train,y_train):
function add_line (line 213) | def add_line(dj_dx, x1, y1, d, ax):
function plt_gradients (line 225) | def plt_gradients(x_train,y_train, f_compute_cost, f_compute_gradient):
function norm_plot (line 272) | def norm_plot(ax, data):
function plot_cost_i_w (line 287) | def plot_cost_i_w(X,y,hist):
function compute_gradient_matrix (line 306) | def compute_gradient_matrix(X, y, w, b):
function compute_cost_matrix (line 329) | def compute_cost_matrix(X, y, w, b, verbose=False):
function compute_cost (line 354) | def compute_cost(X, y, w, b):
function compute_gradient (line 372) | def compute_gradient(X, y, w, b):
function gradient_descent_houses (line 399) | def gradient_descent_houses(X, y, w_in, b_in, cost_function, gradient_fu...
function run_gradient_descent (line 458) | def run_gradient_descent(X,y,iterations=1000, alpha = 1e-6):
function run_gradient_descent_feng (line 479) | def run_gradient_descent_feng(X,y,iterations=1000, alpha = 1e-6):
function gradient_descent (line 491) | def gradient_descent(X, y, w_in, b_in, cost_function, gradient_function,...
function load_house_data (line 546) | def load_house_data():
function zscore_normalize_features (line 552) | def zscore_normalize_features(X,rtn_ms=False):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/public_tests.py
function compute_cost_test (line 3) | def compute_cost_test(target):
function compute_gradient_test (line 43) | def compute_gradient_test(target):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/utils.py
function load_data (line 3) | def load_data():
function load_data_multi (line 9) | def load_data_multi():
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/lab_utils_common.py
function sigmoid (line 23) | def sigmoid(z):
function predict_logistic (line 46) | def predict_logistic(X, w, b):
function predict_linear (line 50) | def predict_linear(X, w, b):
function compute_cost_logistic (line 54) | def compute_cost_logistic(X, y, w, b, lambda_=0, safe=False):
function log_1pexp (line 89) | def log_1pexp(x, maximum=20):
function compute_cost_matrix (line 106) | def compute_cost_matrix(X, y, w, b, logistic=False, lambda_=0, safe=True):
function compute_gradient_matrix (line 140) | def compute_gradient_matrix(X, y, w, b, logistic=False, lambda_=0):
function gradient_descent (line 168) | def gradient_descent(X, y, w_in, b_in, alpha, num_iters, logistic=False,...
function zscore_normalize_features (line 213) | def zscore_normalize_features(X):
function plot_data (line 243) | def plot_data(X, y, ax, pos_label="y=1", neg_label="y=0", s=80, loc='bes...
function plt_tumor_data (line 260) | def plt_tumor_data(x, y, ax):
function draw_vthresh (line 277) | def draw_vthresh(ax,x):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_logistic_loss.py
function compute_cost_logistic_sq_err (line 8) | def compute_cost_logistic_sq_err(X, y, w, b):
function plt_logistic_squared_error (line 27) | def plt_logistic_squared_error(X,y):
function plt_logistic_cost (line 55) | def plt_logistic_cost(X,y):
function soup_bowl (line 98) | def soup_bowl():
function plt_simple_example (line 142) | def plt_simple_example(x, y):
function plt_two_logistic_loss_curves (line 161) | def plt_two_logistic_loss_curves():
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_one_addpt_onclick.py
class plt_one_addpt_onclick (line 12) | class plt_one_addpt_onclick:
method __init__ (line 14) | def __init__(self, x, y, w, b, logistic=True):
method add_data (line 69) | def add_data(self, event):
method calc_linear (line 85) | def calc_linear(self, event):
method calc_logistic (line 104) | def calc_logistic(self, event):
method thresh (line 130) | def thresh(self, event):
method draw_thresh (line 138) | def draw_thresh(self):
method remove_thresh (line 164) | def remove_thresh(self):
method resize_sq (line 170) | def resize_sq(self, bcid):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_overfit.py
function map_one_feature (line 12) | def map_one_feature(X1, degree):
function map_feature (line 28) | def map_feature(X1, X2, degree):
function munge (line 46) | def munge(base, exp):
function plot_decision_boundary (line 53) | def plot_decision_boundary(ax, x0r,x1r, predict, w, b, scaler = False, ...
function plot_decision_boundary_sklearn (line 82) | def plot_decision_boundary_sklearn(x0r, x1r, predict, degree, scaler = ...
class button_manager (line 119) | class button_manager:
method __init__ (line 129) | def __init__(self,fig, dim, labels, init, call_on_click):
method reinit (line 145) | def reinit(self):
method button_click (line 150) | def button_click(self, event):
class overfit_example (line 161) | class overfit_example():
method __init__ (line 167) | def __init__(self, regularize=False):
method updt_lambda (line 212) | def updt_lambda(self, idx, firsttime=False):
method toggle_type (line 216) | def toggle_type(self, idx, firsttime=False):
method logistic_data (line 227) | def logistic_data(self,redraw=False):
method linear_data (line 249) | def linear_data(self,redraw=False):
method add_data (line 279) | def add_data(self, event):
method add_data_logistic (line 286) | def add_data_logistic(self, event):
method add_data_linear (line 301) | def add_data_linear(self, event):
method fitdata_clicked (line 321) | def fitdata_clicked(self,event):
method linear_regression (line 327) | def linear_regression(self):
method logistic_regression (line 351) | def logistic_regression(self):
method update_equation (line 375) | def update_equation(self, idx, firsttime=False):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_quad_logistic.py
class plt_quad_logistic (line 19) | class plt_quad_logistic:
method __init__ (line 25) | def __init__(self, x_train,y_train, w_range, b_range):
method click_contour (line 61) | def click_contour(self, event):
method calc_logistic (line 75) | def calc_logistic(self, event):
class data_plot (line 91) | class data_plot:
method __init__ (line 95) | def __init__(self, ax, x_train, y_train, w, b):
method plt_tumor_data (line 109) | def plt_tumor_data(self):
method update (line 122) | def update(self, w, b):
method draw_logistic_lines (line 128) | def draw_logistic_lines(self, firsttime=False):
method mk_cost_lines (line 144) | def mk_cost_lines(self, firsttime=False):
class contour_and_surface_plot (line 176) | class contour_and_surface_plot:
method __init__ (line 180) | def __init__(self, axc, axs, x_train, y_train, w_range, b_range, w, b):
method update_contour_wb_lines (line 229) | def update_contour_wb_lines(self, w, b, firsttime=False):
class cost_plot (line 250) | class cost_plot:
method __init__ (line 254) | def __init__(self,ax):
method re_init (line 261) | def re_init(self):
method add_cost (line 265) | def add_cost(self,J_hist):
class path (line 270) | class path:
method __init__ (line 274) | def __init__(self, w, b, ax):
method re_init (line 281) | def re_init(self, w, b):
method add_path_item (line 288) | def add_path_item(self, w, b):
function truncate_colormap (line 302) | def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
function plt_prob (line 309) | def plt_prob(ax, w_out,b_out):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/public_tests.py
function sigmoid_test (line 4) | def sigmoid_test(target):
function compute_cost_test (line 11) | def compute_cost_test(target):
function compute_gradient_test (line 45) | def compute_gradient_test(target):
function predict_test (line 59) | def predict_test(target):
function compute_cost_reg_test (line 84) | def compute_cost_reg_test(target):
function compute_gradient_reg_test (line 114) | def compute_gradient_reg_test(target):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/test_utils.py
function datatype_check (line 5) | def datatype_check(expected_output, target_output, error):
function equation_output_check (line 44) | def equation_output_check(expected_output, target_output, error):
function shape_check (line 79) | def shape_check(expected_output, target_output, error):
function single_test (line 110) | def single_test(test_cases, target):
function multiple_test (line 138) | def multiple_test(test_cases, target):
FILE: Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/utils.py
function load_data (line 4) | def load_data(filename):
function sig (line 10) | def sig(z):
function map_feature (line 14) | def map_feature(X1, X2):
function plot_data (line 28) | def plot_data(X, y, pos_label="y=1", neg_label="y=0"):
function plot_decision_boundary (line 37) | def plot_decision_boundary(w, b, X, y):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/lab_coffee_utils.py
function load_coffee_data (line 10) | def load_coffee_data():
function plt_roast (line 32) | def plt_roast(X,Y):
function plt_prob (line 49) | def plt_prob(ax,fwb):
function truncate_colormap (line 71) | def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
function plt_layer (line 78) | def plt_layer(X,Y,W1,b1,norm_l):
function plt_network (line 96) | def plt_network(X,Y,netf):
function plt_output_unit (line 125) | def plt_output_unit(W,b):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/lab_neurons_utils.py
function plt_prob_1d (line 8) | def plt_prob_1d(ax,fwb):
function truncate_colormap (line 27) | def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
function sigmoidnp (line 35) | def sigmoidnp(z):
function plt_linear (line 54) | def plt_linear(X_train, Y_train, prediction_tf, prediction_np):
function plt_logistic (line 74) | def plt_logistic(X_train, Y_train, model, set_w, set_b, pos, neg):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/lab_utils_common.py
function sigmoid (line 24) | def sigmoid(z):
function predict_logistic (line 47) | def predict_logistic(X, w, b):
function predict_linear (line 51) | def predict_linear(X, w, b):
function compute_cost_logistic (line 55) | def compute_cost_logistic(X, y, w, b, lambda_=0, safe=False):
function log_1pexp (line 90) | def log_1pexp(x, maximum=20):
function compute_cost_matrix (line 107) | def compute_cost_matrix(X, y, w, b, logistic=False, lambda_=0, safe=True):
function compute_gradient_matrix (line 141) | def compute_gradient_matrix(X, y, w, b, logistic=False, lambda_=0):
function gradient_descent (line 169) | def gradient_descent(X, y, w_in, b_in, alpha, num_iters, logistic=False,...
function zscore_normalize_features (line 222) | def zscore_normalize_features(X):
function plot_data (line 252) | def plot_data(X, y, ax, pos_label="y=1", neg_label="y=0", s=80, loc='bes...
function plt_tumor_data (line 269) | def plt_tumor_data(x, y, ax):
function draw_vthresh (line 286) | def draw_vthresh(ax,x):
class button_manager (line 312) | class button_manager:
method __init__ (line 322) | def __init__(self,fig, dim, labels, init, call_on_click):
method reinit (line 338) | def reinit(self):
method button_click (line 343) | def button_click(self, event):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/public_tests.py
function test_c1 (line 7) | def test_c1(target):
function test_c2 (line 28) | def test_c2(target):
function test_c3 (line 57) | def test_c3(target):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/utils.py
function sigmoid (line 6) | def sigmoid(x):
function plot_mc_data (line 10) | def plot_mc_data(X, y, class_labels=None, legend=False,size=40):
function plot_cat_decision_boundary (line 22) | def plot_cat_decision_boundary(X,predict , class_labels=None, legend=Fal...
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/autils.py
function load_data (line 3) | def load_data():
function load_weights (line 10) | def load_weights():
function sigmoid (line 17) | def sigmoid(x):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/lab_neurons_utils.py
function plt_prob_1d (line 8) | def plt_prob_1d(ax,fwb):
function truncate_colormap (line 27) | def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
function sigmoidnp (line 35) | def sigmoidnp(z):
function plt_linear (line 54) | def plt_linear(X_train, Y_train, prediction_tf, prediction_np):
function plt_logistic (line 74) | def plt_logistic(X_train, Y_train, model, set_w, set_b, pos, neg):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/lab_utils_common.py
function sigmoid (line 24) | def sigmoid(z):
function predict_logistic (line 47) | def predict_logistic(X, w, b):
function predict_linear (line 51) | def predict_linear(X, w, b):
function compute_cost_logistic (line 55) | def compute_cost_logistic(X, y, w, b, lambda_=0, safe=False):
function log_1pexp (line 90) | def log_1pexp(x, maximum=20):
function compute_cost_matrix (line 107) | def compute_cost_matrix(X, y, w, b, logistic=False, lambda_=0, safe=True):
function compute_gradient_matrix (line 141) | def compute_gradient_matrix(X, y, w, b, logistic=False, lambda_=0):
function gradient_descent (line 169) | def gradient_descent(X, y, w_in, b_in, alpha, num_iters, logistic=False,...
function zscore_normalize_features (line 222) | def zscore_normalize_features(X):
function plot_data (line 252) | def plot_data(X, y, ax, pos_label="y=1", neg_label="y=0", s=80, loc='bes...
function plt_tumor_data (line 269) | def plt_tumor_data(x, y, ax):
function draw_vthresh (line 286) | def draw_vthresh(ax,x):
class button_manager (line 312) | class button_manager:
method __init__ (line 322) | def __init__(self,fig, dim, labels, init, call_on_click):
method reinit (line 338) | def reinit(self):
method button_click (line 343) | def button_click(self, event):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/public_tests.py
function test_c1 (line 7) | def test_c1(target):
function test_c2 (line 28) | def test_c2(target):
function test_c3 (line 57) | def test_c3(target):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/utils.py
function sigmoid (line 6) | def sigmoid(x):
function plot_mc_data (line 10) | def plot_mc_data(X, y, class_labels=None, legend=False,size=40):
function plot_cat_decision_boundary (line 22) | def plot_cat_decision_boundary(X,predict , class_labels=None, legend=Fal...
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/autils.py
function load_data (line 14) | def load_data():
function plt_act_trio (line 19) | def plt_act_trio():
function widgvis (line 39) | def widgvis(fig):
function plt_ex1 (line 44) | def plt_ex1():
function plt_ex2 (line 58) | def plt_ex2():
function gen_data (line 72) | def gen_data():
function plt_dual (line 78) | def plt_dual(X,y,yhat):
function plt_act1 (line 93) | def plt_act1(X,y,z,a):
function plt_add_notation (line 117) | def plt_add_notation(ax):
function compile_fit (line 128) | def compile_fit(model,X,y):
function plt_model (line 145) | def plt_model(X,y,yhat_pre, yhat_post):
function display_errors (line 165) | def display_errors(model,X,y):
function display_digit (line 196) | def display_digit(X):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_common.py
function sigmoid (line 24) | def sigmoid(z):
function predict_logistic (line 47) | def predict_logistic(X, w, b):
function predict_linear (line 51) | def predict_linear(X, w, b):
function compute_cost_logistic (line 55) | def compute_cost_logistic(X, y, w, b, lambda_=0, safe=False):
function log_1pexp (line 90) | def log_1pexp(x, maximum=20):
function compute_cost_matrix (line 107) | def compute_cost_matrix(X, y, w, b, logistic=False, lambda_=0, safe=True):
function compute_gradient_matrix (line 141) | def compute_gradient_matrix(X, y, w, b, logistic=False, lambda_=0):
function gradient_descent (line 169) | def gradient_descent(X, y, w_in, b_in, alpha, num_iters, logistic=False,...
function zscore_normalize_features (line 222) | def zscore_normalize_features(X):
function plot_data (line 252) | def plot_data(X, y, ax, pos_label="y=1", neg_label="y=0", s=80, loc='bes...
function plt_tumor_data (line 269) | def plt_tumor_data(x, y, ax):
function draw_vthresh (line 286) | def draw_vthresh(ax,x):
class button_manager (line 312) | class button_manager:
method __init__ (line 322) | def __init__(self,fig, dim, labels, init, call_on_click):
method reinit (line 338) | def reinit(self):
method button_click (line 343) | def button_click(self, event):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_multiclass.py
function sigmoid (line 6) | def sigmoid(x):
function plot_mc_data (line 10) | def plot_mc_data(X, y, class_labels=None, legend=False,size=40):
function plot_cat_decision_boundary (line 22) | def plot_cat_decision_boundary(X,predict , class_labels=None, legend=Fal...
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_multiclass_TF.py
function plot_cat_decision_boundary_mc (line 26) | def plot_cat_decision_boundary_mc(ax, X, predict , class_labels=None, le...
function plt_mc_data (line 52) | def plt_mc_data(ax, X, y, classes, class_labels=None, map=plt.cm.Paired,
function plt_mc (line 69) | def plt_mc(X_train,y_train,classes, centers, std):
function plt_cat_mc (line 84) | def plt_cat_mc(X_train, y_train, model, classes):
function plt_prob_z (line 104) | def plt_prob_z(ax,fwb, x0_rng=(-8,8), x1_rng=(-5,4)):
function truncate_colormap (line 134) | def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
function plt_layer_relu (line 142) | def plt_layer_relu(X, Y, W1, b1, classes):
function plt_output_layer_linear (line 161) | def plt_output_layer_linear(X, Y, W, b, classes, x0_rng=None, x1_rng=None):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_relu.py
function widgvis (line 8) | def widgvis(fig):
function plt_base (line 14) | def plt_base(ax):
function plt_yhat (line 31) | def plt_yhat(ax, X, w00, b00, w01, b01, w02, b02):
function plt_unit (line 38) | def plt_unit(ax, X, w, b):
function plt_relu_ex (line 50) | def plt_relu_ex():
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_softmax.py
function plt_softmax (line 10) | def plt_softmax(my_softmax):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/autils.py
function load_data (line 14) | def load_data():
function plt_act_trio (line 19) | def plt_act_trio():
function widgvis (line 39) | def widgvis(fig):
function plt_ex1 (line 44) | def plt_ex1():
function plt_ex2 (line 58) | def plt_ex2():
function gen_data (line 72) | def gen_data():
function plt_dual (line 78) | def plt_dual(X,y,yhat):
function plt_act1 (line 93) | def plt_act1(X,y,z,a):
function plt_add_notation (line 117) | def plt_add_notation(ax):
function compile_fit (line 128) | def compile_fit(model,X,y):
function plt_model (line 145) | def plt_model(X,y,yhat_pre, yhat_post):
function display_errors (line 165) | def display_errors(model,X,y):
function display_digit (line 196) | def display_digit(X):
function plot_loss_tf (line 206) | def plot_loss_tf(history):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/lab_utils_common.py
function sigmoid (line 24) | def sigmoid(z):
function predict_logistic (line 47) | def predict_logistic(X, w, b):
function predict_linear (line 51) | def predict_linear(X, w, b):
function compute_cost_logistic (line 55) | def compute_cost_logistic(X, y, w, b, lambda_=0, safe=False):
function log_1pexp (line 90) | def log_1pexp(x, maximum=20):
function compute_cost_matrix (line 107) | def compute_cost_matrix(X, y, w, b, logistic=False, lambda_=0, safe=True):
function compute_gradient_matrix (line 141) | def compute_gradient_matrix(X, y, w, b, logistic=False, lambda_=0):
function gradient_descent (line 169) | def gradient_descent(X, y, w_in, b_in, alpha, num_iters, logistic=False,...
function zscore_normalize_features (line 222) | def zscore_normalize_features(X):
function plot_data (line 252) | def plot_data(X, y, ax, pos_label="y=1", neg_label="y=0", s=80, loc='bes...
function plt_tumor_data (line 269) | def plt_tumor_data(x, y, ax):
function draw_vthresh (line 286) | def draw_vthresh(ax,x):
class button_manager (line 312) | class button_manager:
method __init__ (line 322) | def __init__(self,fig, dim, labels, init, call_on_click):
method reinit (line 338) | def reinit(self):
method button_click (line 343) | def button_click(self, event):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/lab_utils_softmax.py
function plt_softmax (line 10) | def plt_softmax(my_softmax):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/public_tests.py
function test_my_softmax (line 7) | def test_my_softmax(target):
function test_model (line 22) | def test_model(target, classes, input_size):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/assigment_utils.py
function gen_data (line 28) | def gen_data(m, seed=1, scale=0.7):
function gen_blobs (line 38) | def gen_blobs():
class lin_model (line 46) | class lin_model:
method __init__ (line 47) | def __init__(self, degree, regularization = False, lambda_=0):
method fit (line 55) | def fit(self, X_train,y_train):
method predict (line 61) | def predict(self, X):
method mse (line 67) | def mse(self, y, yhat):
function plt_train_test (line 71) | def plt_train_test(X_train, y_train, X_test, y_test, x, y_pred, x_ideal,...
function plt_optimal_degree (line 91) | def plt_optimal_degree(X_train, y_train, X_cv, y_cv, x, y_pred, x_ideal,...
function plt_tune_regularization (line 128) | def plt_tune_regularization(X_train, y_train, X_cv, y_cv, x, y_pred, err...
function tune_m (line 165) | def tune_m():
function plt_tune_m (line 190) | def plt_tune_m(X_train, y_train, X_cv, y_cv, x, y_pred, err_train, err_c...
function plt_mc_data (line 227) | def plt_mc_data(ax, X, y, classes, class_labels=None, map=plt.cm.Paired...
function plot_cat_decision_boundary (line 241) | def plot_cat_decision_boundary(ax, X,predict , class_labels=None, legend...
function recat (line 265) | def recat(pt, origins):
function plt_train_eq_dist (line 279) | def plt_train_eq_dist(X_train,y_train,classes, X_cv, y_cv, centers, std):
function plt_nn (line 304) | def plt_nn(model_predict,X_train,y_train, classes, X_cv, y_cv, suptitle=...
function eval_cat_err (line 326) | def eval_cat_err(y, yhat):
function plot_iterate (line 343) | def plot_iterate(lambdas, models, X_train, y_train, X_cv, y_cv):
function err_all_equal (line 368) | def err_all_equal(X_train,X_cv,X_test, y_train,y_cv,y_test, centers):
function plt_compare (line 378) | def plt_compare(X,y, classes, simple, regularized, centers):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/public_tests_a1.py
function test_eval_mse (line 10) | def test_eval_mse(target):
function test_eval_cat_err (line 34) | def test_eval_cat_err(target):
function model_test (line 57) | def model_test(target, classes, input_size):
function model_s_test (line 88) | def model_s_test(target, classes, input_size):
function model_r_test (line 118) | def model_r_test(target, classes, input_size):
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/utils.py
function load_data (line 5) | def load_data():
FILE: Course-2-Advanced-Learning-Algorithms/Course-2-Week-4/Course-2-Week-4-Practice-Labs/public_tests.py
function compute_entropy_test (line 3) | def compute_entropy_test(target):
function split_dataset_test (line 25) | def split_dataset_test(target):
function compute_information_gain_test (line 77) | def compute_information_gain_test(target):
function get_best_split_test (line 110) | def get_best_split_test(target):
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/public_tests.py
function compute_centroids_test (line 3) | def compute_centroids_test(target):
function find_closest_centroids_test (line 32) | def find_closest_centroids_test(target):
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/utils.py
function load_data (line 4) | def load_data():
function draw_line (line 8) | def draw_line(p1, p2, style="-k", linewidth=1):
function plot_data_points (line 11) | def plot_data_points(X, idx):
function plot_progress_kMeans (line 16) | def plot_progress_kMeans(X, centroids, previous_centroids, idx, K, i):
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/public_tests.py
function test_tower (line 6) | def test_tower(target):
function test_sq_dist (line 26) | def test_sq_dist(target):
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/recsysNN_utils.py
function load_data (line 15) | def load_data():
function pprint_train (line 46) | def pprint_train(x_train, features, vs, u_s, maxcount = 5, user=True):
function pprint_data (line 76) | def pprint_data(y_p, user_train, item_train, printfull=False):
function split_str (line 101) | def split_str(ifeatures, smax):
function pprint_data_tab (line 111) | def pprint_data_tab(y_p, user_train, item_train, uvs, ivs, user_features...
function print_pred_movies (line 142) | def print_pred_movies(y_p, user, item, movie_dict, maxcount=10):
function gen_user_vecs (line 163) | def gen_user_vecs(user_vec, num_items):
function predict_uservec (line 170) | def predict_uservec(user_vecs, item_vecs, model, u_s, i_s, scaler, Scale...
function print_pred_debug (line 192) | def print_pred_debug(y_p, y, user, item, maxcount=10, onlyrating=False, ...
function get_user_vecs (line 221) | def get_user_vecs(user_id, user_train, item_vecs, user_to_genre):
function get_item_genre (line 252) | def get_item_genre(item, ivs, item_features):
function print_existing_user (line 258) | def print_existing_user(y_p, y, user, items, item_features, ivs, uvs, mo...
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/recsys_utils.py
function normalizeRatings (line 5) | def normalizeRatings(Y, R):
function load_precalc_params_small (line 17) | def load_precalc_params_small():
function load_ratings_small (line 32) | def load_ratings_small():
function load_Movie_List_pd (line 40) | def load_Movie_List_pd():
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Optional-Labs/utils.py
function generate_rewards (line 4) | def generate_rewards(num_states, each_step_reward, terminal_left_reward,...
function generate_transition_prob (line 12) | def generate_transition_prob(num_states, num_actions, misstep_prob = 0):
function calculate_Q_value (line 32) | def calculate_Q_value(num_states, rewards, transition_prob, gamma, V_sta...
function evaluate_policy (line 36) | def evaluate_policy(num_states, rewards, transition_prob, gamma, policy):
function improve_policy (line 54) | def improve_policy(num_states, num_actions, rewards, transition_prob, ga...
function get_optimal_policy (line 69) | def get_optimal_policy(num_states, num_actions, rewards, transition_prob...
function calculate_Q_values (line 84) | def calculate_Q_values(num_states, rewards, transition_prob, gamma, opti...
function plot_optimal_policy_return (line 100) | def plot_optimal_policy_return(num_states, optimal_policy, rewards, V):
function plot_q_values (line 120) | def plot_q_values(num_states, q_left_star, q_right_star, rewards):
function generate_visualization (line 137) | def generate_visualization(terminal_left_reward, terminal_right_reward, ...
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Labs/public_tests.py
function test_network (line 7) | def test_network(target):
function test_optimizer (line 29) | def test_optimizer(target, ALPHA):
function test_compute_loss (line 35) | def test_compute_loss(target):
FILE: Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Labs/utils.py
function get_experiences (line 25) | def get_experiences(memory_buffer):
function check_update_conditions (line 36) | def check_update_conditions(t, num_steps_upd, memory_buffer):
function get_new_eps (line 43) | def get_new_eps(epsilon):
function get_action (line 47) | def get_action(q_values, epsilon=0):
function update_target_network (line 54) | def update_target_network(q_network, target_q_network):
function plot_history (line 59) | def plot_history(reward_history, rolling_window=20, lower_limit=None,
function display_table (line 94) | def display_table(initial_state, action, next_state, reward, done):
function embed_mp4 (line 115) | def embed_mp4(filename):
function create_video (line 127) | def create_video(filename, env, q_network, fps=30):
Copy disabled (too large)
Download .json
Condensed preview — 194 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (22,859K chars).
[
{
"path": "CODE_OF_CONDUCT.md",
"chars": 5202,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nWe as members, contributors, and leaders pledge to make participa"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Lecture-Slides/Course-1-Week-1-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-1-Python-and-Jupyter-Notebook.ipynb",
"chars": 4082,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Brief Introduction"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-3-Model-Representation.ipynb",
"chars": 45863,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Model Representatio"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-4-Cost-function.ipynb",
"chars": 11162,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Cost Function \\n\","
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs-5-Gradient-Descent.ipynb",
"chars": 337848,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Gradient Descent fo"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/Course-1-Week-1-Optional-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/data/Course-1-Week-1-Optional-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/data/data.txt",
"chars": 702,
"preview": "2104,3,399900\r\n1600,3,329900\r\n2400,3,369000\r\n1416,2,232000\r\n3000,4,539900\r\n1985,4,299900\r\n1534,3,314900\r\n1427,3,198999\r\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/images/Course-1-Week-1-Optional-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/lab_utils_common.py",
"chars": 3258,
"preview": "\"\"\" \nlab_utils_common.py\n functions common to all optional labs, Course 1, Week 2 \n\"\"\"\n\nimport numpy as np\nimport mat"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Optional-Labs/lab_utils_uni.py",
"chars": 14544,
"preview": "\"\"\" \nlab_utils_uni.py\n routines used in Course 1, Week2, labs1-3 dealing with single variables (univariate)\n\"\"\"\nimpor"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1-Practice-Quiz/Course-1-Week-1-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-1/Course-1-Week-1.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Lecture-Slides/Course-1-Week-2-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/Course-1-Week-2-Optional-Labs-1-Python-Numpy-Vectorization.ipynb",
"chars": 30186,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Python, NumPy and V"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/Course-1-Week-2-Optional-Labs-2-Multiple-Linear-Regression.ipynb",
"chars": 59996,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Multiple Variable L"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/Course-1-Week-2-Optional-Labs-3-Feature-Scaling-and-Learning-Rate.ipynb",
"chars": 469269,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Feature scaling and"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/Course-1-Week-2-Optional-Labs-4-Feature-Engineering-and-Polynomial-Regression.ipynb",
"chars": 160419,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Feature Engineering"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/Course-1-Week-2-Optional-Labs-5-Linear-Regression-with-Scikit-Learn.ipynb",
"chars": 53008,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Linear Regression u"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/Course-1-Week-2-Optional-Labs-6-Sklearn-Normalization.ipynb",
"chars": 6883,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Linear Regression u"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/Course-1-Week-2-Optional-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/data/Course-1-Week-2-Optional-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/data/houses.txt",
"chars": 12500,
"preview": "9.520000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,6.500000000000000000e+01,2.715000000000000000"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/deeplearning.mplstyle",
"chars": 4890,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/images/Course-1-Week-2-Optional-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/lab_utils_common.py",
"chars": 3258,
"preview": "\"\"\" \nlab_utils_common.py\n functions common to all optional labs, Course 1, Week 2 \n\"\"\"\n\nimport numpy as np\nimport mat"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Optional-Labs/lab_utils_multi.py",
"chars": 21312,
"preview": "import numpy as np\nimport copy\nimport math\nfrom scipy.stats import norm\nimport matplotlib.pyplot as plt\nfrom mpl_toolkit"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/Course-1-Week-2-Practice-Labs-1-Linear-Regression.ipynb",
"chars": 72923,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Linear Regression\\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/Course-1-Week-2-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/data/Course-1-Week-2-Practice-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/data/ex1data1.txt",
"chars": 1359,
"preview": "6.1101,17.592\n5.5277,9.1302\n8.5186,13.662\n7.0032,11.854\n5.8598,6.8233\n8.3829,11.886\n7.4764,4.3483\n8.5781,12\n6.4862,6.598"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/data/ex1data2.txt",
"chars": 657,
"preview": "2104,3,399900\n1600,3,329900\n2400,3,369000\n1416,2,232000\n3000,4,539900\n1985,4,299900\n1534,3,314900\n1427,3,198999\n1380,3,2"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/public_tests.py",
"chars": 2297,
"preview": "import numpy as np\n\ndef compute_cost_test(target):\n # print(\"Using X with shape (4, 1)\")\n # Case 1\n x = np.arra"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Labs/utils.py",
"chars": 282,
"preview": "import numpy as np\n\ndef load_data():\n data = np.loadtxt(\"data/ex1data1.txt\", delimiter=',')\n X = data[:,0]\n y ="
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2-Practice-Quiz/Course-1-Week-2-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-2/Course-1-Week-2.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Lecture-Slides/Course-1-Week-3-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-1-Classification.ipynb",
"chars": 6948,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Classification\\n\",\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-2-Sigmoid-function-and-Logistic-Regression.ipynb",
"chars": 10348,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Logistic Regression"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-3-Decision-Boundary.ipynb",
"chars": 9006,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Logistic Regression"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-4-Logistic-Loss.ipynb",
"chars": 11546,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Logistic Regression"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-5-Cost-Function-for-Logistic-Regression.ipynb",
"chars": 9672,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Cost Function for L"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-6-Gradient-Descent-for-Logistic-Regression.ipynb",
"chars": 16350,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Gradient Descent fo"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-7-Logistic-Regression-with-Scikit-Learn.ipynb",
"chars": 3477,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Ungraded Lab: Logistic Regressio"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-8-Overfitting.ipynb",
"chars": 4211,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Ungraded Lab: Overfitting \\n\",\n "
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs-9-Regularization.ipynb",
"chars": 155115,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/Course-1-Week-3-Optional-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/images/Course-1-Week-3-Optional-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/lab_utils_common.py",
"chars": 11572,
"preview": "\"\"\"\nlab_utils_common\n contains common routines and variable definitions\n used by all the labs in this week.\n by co"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_logistic_loss.py",
"chars": 7177,
"preview": "\"\"\"----------------------------------------------------------------\n logistic_loss plotting routines and support\n\"\"\"\n\nfr"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_one_addpt_onclick.py",
"chars": 8029,
"preview": "import time\nimport copy\nfrom ipywidgets import Output\nfrom matplotlib.widgets import Button, CheckButtons\nfrom matplotli"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_overfit.py",
"chars": 15733,
"preview": "\"\"\"\nplot_overfit\n class and assocaited routines that plot an interactive example of overfitting and its solutions\n\"\"\""
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Optional-Labs/plt_quad_logistic.py",
"chars": 13008,
"preview": "\"\"\"\nplt_quad_logistic.py\n interactive plot and supporting routines showing logistic regression\n\"\"\"\n\nimport time\nfrom "
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/Course-1-Week-3-Practice-Labs-1-Logistic-Regression.ipynb",
"chars": 135929,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Logistic Regression\\n\",\n \"\\n\","
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/Course-1-Week-3-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/data/Course-1-Week-3-Optional-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/data/ex2data1.txt",
"chars": 3775,
"preview": "34.62365962451697,78.0246928153624,0\n30.28671076822607,43.89499752400101,0\n35.84740876993872,72.90219802708364,0\n60.1825"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/data/ex2data2.txt",
"chars": 2233,
"preview": "0.051267,0.69956,1\n-0.092742,0.68494,1\n-0.21371,0.69225,1\n-0.375,0.50219,1\n-0.51325,0.46564,1\n-0.52477,0.2098,1\n-0.39804"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/images/Course-1-Week-3-Practice-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/public_tests.py",
"chars": 5201,
"preview": "import numpy as np\nimport math\n\ndef sigmoid_test(target):\n assert np.isclose(target(3.0), 0.9525741268224334), \"Faile"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/test_utils.py",
"chars": 6899,
"preview": "import numpy as np\nfrom copy import deepcopy\n\n\ndef datatype_check(expected_output, target_output, error):\n success = "
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Labs/utils.py",
"chars": 1641,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\n\ndef load_data(filename):\n data = np.loadtxt(filename, delimiter='"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3-Practice-Quiz/Course-1-Week-3-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1-Week-3/Course-1-Week-3.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-1-Supervised-Machine-Learning-Regression-and-Classification/Course-1.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Lecture-Slides/Course-2-Week-1-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/Course-2-Week-1-Optional-Labs-1-Neurons-and-Layers.ipynb",
"chars": 114019,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/Course-2-Week-1-Optional-Labs-2-Coffee-Roasting-in-Tensorflow.ipynb",
"chars": 551386,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/Course-2-Week-1-Optional-Labs-3-Coffee-Roasting-Numpy.ipynb",
"chars": 262063,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/Course-2-Week-1-Optional-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/images/Course-2-Week-1-Optional-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/lab_coffee_utils.py",
"chars": 6081,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('./deeplearning.mplstyle')\nimport tensorflow as tf\nfrom"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/lab_neurons_utils.py",
"chars": 3842,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('./deeplearning.mplstyle')\nfrom matplotlib import cm\nim"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/lab_utils_common.py",
"chars": 13892,
"preview": "\"\"\"\nlab_utils_common\n contains common routines and variable definitions\n used by all the labs in this week.\n by co"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/public_tests.py",
"chars": 3958,
"preview": "# UNIT TESTS\nfrom tensorflow.keras.activations import sigmoid\nfrom tensorflow.keras.layers import Dense\n\nimport numpy as"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Optional-Labs/utils.py",
"chars": 1543,
"preview": "# C2_W1 Utilities\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import make_blobs\n\ndef sigmoi"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/Course-2-Week-1-Practice-Labs-1-Neural-Networks-for-Binary-Classification.ipynb",
"chars": 586066,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Neural Networks for"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/Course-2-Week-1-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/autils.py",
"chars": 375,
"preview": "import numpy as np\n\ndef load_data():\n X = np.load(\"data/X.npy\")\n y = np.load(\"data/y.npy\")\n X = X[0:1000]\n y"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/data/Course-2-Week-1-Practice-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/images/Course-2-Week-1-Practice-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/lab_neurons_utils.py",
"chars": 3842,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('./deeplearning.mplstyle')\nfrom matplotlib import cm\nim"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/lab_utils_common.py",
"chars": 13892,
"preview": "\"\"\"\nlab_utils_common\n contains common routines and variable definitions\n used by all the labs in this week.\n by co"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/public_tests.py",
"chars": 3958,
"preview": "# UNIT TESTS\nfrom tensorflow.keras.activations import sigmoid\nfrom tensorflow.keras.layers import Dense\n\nimport numpy as"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Labs/utils.py",
"chars": 1543,
"preview": "# C2_W1 Utilities\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import make_blobs\n\ndef sigmoi"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1-Practice-Quiz/Course-2-Week-1-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-1/Course-2-Week-1.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Lecture-Slides/Course-2-Week-2-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/Course-2-Week-2-Optional-Labs-1-Relu-Activation.ipynb",
"chars": 7161,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - ReLU activation\"\n "
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/Course-2-Week-2-Optional-Labs-2-SoftMax.ipynb",
"chars": 18315,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/Course-2-Week-2-Optional-Labs-3-Multiclass.ipynb",
"chars": 35093,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - Multi-class Classi"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/Course-2-Week-2-Optional-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/autils.py",
"chars": 6271,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nfrom tensorflow.keras.models import Sequentia"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/images/Course-2-Week-2-Optional-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_common.py",
"chars": 13934,
"preview": "\"\"\"\nlab_utils_common\n contains common routines and variable definitions\n used by all the labs in this week.\n by co"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_multiclass.py",
"chars": 1609,
"preview": "# C2_W1 Utilities\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import make_blobs\n\ndef sigmoi"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_multiclass_TF.py",
"chars": 6992,
"preview": "import matplotlib.pyplot as plt\nimport numpy as np\nimport matplotlib as mpl\nimport warnings\nfrom matplotlib import cm\nfr"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_relu.py",
"chars": 3779,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec\nplt.style.use('./deeplearnin"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Optional-Labs/lab_utils_softmax.py",
"chars": 1887,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('./deeplearning.mplstyle')\nimport tensorflow as tf\nfrom"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/Course-2-Week-2-Practice-Labs-1-Neural-Networks-for-Multiclass-Classification.ipynb",
"chars": 43216,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Neural Networks for"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/Course-2-Week-2-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/autils.py",
"chars": 6557,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nfrom tensorflow.keras.models import Sequentia"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/data/Course-2-Week-2-Practice-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/images/Course-2-Week-2-Practice-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/lab_utils_common.py",
"chars": 13934,
"preview": "\"\"\"\nlab_utils_common\n contains common routines and variable definitions\n used by all the labs in this week.\n by co"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/lab_utils_softmax.py",
"chars": 1887,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('./deeplearning.mplstyle')\nimport tensorflow as tf\nfrom"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Labs/public_tests.py",
"chars": 1708,
"preview": "import numpy as np\nimport tensorflow as tf\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers i"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2-Practice-Quiz/Course-2-Week-2-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-2/Course-2-Week-2.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Lecture-Slides/Course-2-Week-3-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/Course-2-Week-3-Practice-Labs-1-Advice-for-Applying-Machine-Learning.ipynb",
"chars": 1110325,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Advice for Applying"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/Course-2-Week-3-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/assigment_utils.py",
"chars": 17541,
"preview": "\"\"\"\nassignment_utils.py\ncontains routines used by C2_W3 Assignments \n\"\"\"\nimport copy\nimport math\nimport numpy as np\nimpo"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/images/Course-2-Week-3-Practice-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/public_tests_a1.py",
"chars": 7775,
"preview": "import tensorflow as tf\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Dense\nfrom te"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Labs/utils.py",
"chars": 255,
"preview": "import numpy as np\nfrom sklearn import datasets\n\n\ndef load_data():\n iris = datasets.load_iris()\n X = iris.data[:, "
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3-Practice-Quiz/Course-2-Week-3-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-3/Course-2-Week-3.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-4/Course-2-Week-4-Lecture-Slides/Course-2-Week-4-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-4/Course-2-Week-4-Practice-Labs/Course-2-Week-4-Practice-Labs-1-Decision-Tree-with-Markdown.ipynb",
"chars": 40111,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Decision Trees\\n\",\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-4/Course-2-Week-4-Practice-Labs/Course-2-Week-4-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-4/Course-2-Week-4-Practice-Labs/public_tests.py",
"chars": 6081,
"preview": "import numpy as np\n\ndef compute_entropy_test(target):\n y = np.array([1] * 10)\n result = target(y)\n \n assert "
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-4/Course-2-Week-4-Practice-Quiz/Course-2-Week-4-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2-Week-4/Course-2-Week-4.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-2-Advanced-Learning-Algorithms/Course-2.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Lecture-Slides/Course-3-Week-1-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/Course-3-Week-1-Practice-Labs-1-KMeans.ipynb",
"chars": 359142,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# K-means Clustering \\n\",\n \"\\n\","
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/Course-3-Week-1-Practice-Labs-2-Anomaly_Detection.ipynb",
"chars": 147186,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Anomaly Detection\\n\",\n \"\\n\",\n "
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/Course-3-Week-1-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/data/Course-3-Week-1-Practice-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/images/Course-3-Week-1-Practice-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/public_tests.py",
"chars": 2918,
"preview": "import numpy as np\n\ndef compute_centroids_test(target):\n # With 3 centroids\n X = np.array([[-1, -1], [-1.5, -1.5],"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Labs/utils.py",
"chars": 886,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\n\ndef load_data():\n X = np.load(\"data/ex7_X.npy\")\n return X\n\ndef"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1-Practice-Quiz/Course-3-Week-1-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-1/Course-3-Week-1.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Lecture-Slides/Course-3-Week-2-Lecture-Slides.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/Course-3-Week-1-Practice-Labs-1-Collaborative-Filtering-Recommender-Systems.ipynb",
"chars": 45597,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"id\": \"Lzk7iX_CodX6\",\n \"tags\": []\n },\n \"source"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/Course-3-Week-2-Practice-Labs-2-Deep-Learning-For-Content-Based-Filtering.ipynb",
"chars": 102119,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"id\": \"Lzk7iX_CodX6\",\n \"tags\": []\n },\n \"source"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/Course-3-Week-2-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/Course-3-Week-2-Practice-Labs-data.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/content_item_train.csv",
"chars": 3173087,
"preview": "6874,2003,3.9618320610687023,1,0,0,0,0,0,0,0,0,0,0,0,0,0\n6874,2003,3.9618320610687023,0,0,0,0,0,1,0,0,0,0,0,0,0,0\n6874,2"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/content_item_train_header.txt",
"chars": 139,
"preview": "movie id,year,ave rating,Action,Adventure,Animation,Children,Comedy,Crime,Documentary,Drama,Fantasy,Horror,Mystery,Roman"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/content_item_vecs.csv",
"chars": 101065,
"preview": "4054,2001,2.84375,0,0,0,0,0,0,0,1,0,0,0,0,0,0\n4054,2001,2.84375,0,0,0,0,0,0,0,0,0,0,0,1,0,0\n4069,2001,2.909090909090909,"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/content_movie_list.csv",
"chars": 36763,
"preview": "movieId,title,genres\r\n4054,Save the Last Dance (2001),Drama|Romance\r\n4069,\"Wedding Planner, The (2001)\",Comedy|Romance\r\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/content_user_train_header.txt",
"chars": 146,
"preview": "user id,rating count,rating ave,Action,Adventure,Animation,Children,Comedy,Crime,Documentary,Drama,Fantasy,Horror,Myster"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/content_y_train.csv",
"chars": 232748,
"preview": "4.0\n4.0\n4.0\n3.5\n3.5\n3.5\n3.5\n4.0\n4.0\n4.0\n4.0\n4.0\n5.0\n3.0\n3.0\n3.0\n4.0\n4.0\n4.0\n3.0\n3.0\n4.5\n4.5\n4.5\n5.0\n5.0\n2.5\n2.5\n5.0\n5.0\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/small_movie_list.csv",
"chars": 198919,
"preview": ",mean rating,number of ratings,title\n0,3.4,5,\"Yards, The (2000)\"\n1,3.25,6,Next Friday (2000)\n2,2.0,4,Supernova (2000)\n3,"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/small_movies_R.csv",
"chars": 4233308,
"preview": "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/small_movies_W.csv",
"chars": 50550,
"preview": "0.47935075,0.4766997,0.48794055,-0.11980432,-0.32864022,0.4232462,-0.3951074,-0.2383076,-0.36121953,-0.18090296\n0.036048"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/small_movies_X.csv",
"chars": 521589,
"preview": "-0.033286825,1.1667464,-0.5064895,0.1250965,1.5347596,-0.21013564,0.10417578,-0.349303,0.75385165,-0.20810875\n0.40405777"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/small_movies_Y.csv",
"chars": 8466616,
"preview": "0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/data/small_movies_b.csv",
"chars": 5034,
"preview": "0.23609531,0.35653394,0.12819964,0.3155024,0.23636407,-0.22917777,-0.14401537,0.075727165,-0.37003124,-0.021354377,-0.01"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/images/Course-3-Week-2-Practice-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/public_tests.py",
"chars": 1694,
"preview": "from tensorflow.keras.activations import relu, linear\nfrom tensorflow.keras.layers import Dense\n\nimport numpy as np\n\ndef"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/recsysNN_utils.py",
"chars": 11840,
"preview": "import pickle5 as pickle\nimport numpy as np\nfrom numpy import genfromtxt\nfrom collections import defaultdict\nimport pand"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Labs/recsys_utils.py",
"chars": 1513,
"preview": "import numpy as np\nimport pandas as pd\nfrom numpy import loadtxt\n\ndef normalizeRatings(Y, R):\n \"\"\"\n Preprocess dat"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2-Practice-Quiz/Course-3-Week-2-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-2/Course-3-Week-2.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Optional-Labs/Course-3-Week-3-Optional-Labs-1-State-Action-Value-Function.ipynb",
"chars": 29309,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# State Action Value Function Examp"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Optional-Labs/Course-3-Week-3-Optional-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Optional-Labs/utils.py",
"chars": 5553,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\n\ndef generate_rewards(num_states, each_step_reward, terminal_left_rew"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Labs/Course-3-Week-3-Practice-Labs-1-Reinforcement-Learning.ipynb",
"chars": 52311,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Deep Q-Learning - Lunar Lander\\n\""
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Labs/Course-3-Week-3-Practice-Labs.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Labs/images/Course-3-Week-3-Practice-Labs-images.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Labs/public_tests.py",
"chars": 3562,
"preview": "from tensorflow.keras.activations import relu, linear\nfrom tensorflow.keras.layers import Dense\nfrom tensorflow.keras.op"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Labs/utils.py",
"chars": 4912,
"preview": "import base64\nimport random\nfrom itertools import zip_longest\n\nimport imageio\nimport IPython\nimport matplotlib.pyplot as"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3-Practice-Quiz/Course-3-Week-3-Practice-Quiz.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3-Week-3/Course-3-Week-3.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-3-Unsupervised-Learning-Recommenders-Reinforcement-Learning/Course-3.md",
"chars": 1,
"preview": "\n"
},
{
"path": "Course-Certificates/Course-Certificates.md",
"chars": 1,
"preview": "\n"
},
{
"path": "LICENSE",
"chars": 1072,
"preview": "MIT License\n\nCopyright (c) 2022 Shantanu Umrani\n\nPermission is hereby granted, free of charge, to any person obtaining a"
},
{
"path": "README.md",
"chars": 8243,
"preview": "-------------------------------------------------------------------------------------------\n\n<p align=\"center\"><img widt"
}
]
// ... and 14 more files (download for full content)
About this extraction
This page contains the full source code of the shantanu1109/Coursera-DeepLearning.AI-Stanford-University-Machine-Learning-Specialization GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 194 files (63.6 MB), approximately 5.6M tokens, and a symbol index with 355 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.