Copy disabled (too large)
Download .txt
Showing preview only (29,051K chars total). Download the full file to get everything.
Repository: greyhatguy007/Machine-Learning-Specialization-Coursera
Branch: main
Commit: d5c95ffb5b15
Files: 213
Total size: 69.8 MB
Directory structure:
gitextract_zzi5ix77/
├── .github/
│ └── ISSUE_TEMPLATE/
│ └── error-report.md
├── C1 - Supervised Machine Learning - Regression and Classification/
│ ├── README.md
│ ├── week1/
│ │ ├── Optional Labs/
│ │ │ ├── C1_W1_Lab01_Python_Jupyter_Soln.ipynb
│ │ │ ├── C1_W1_Lab03_Model_Representation_Soln.ipynb
│ │ │ ├── C1_W1_Lab04_Cost_function_Soln.ipynb
│ │ │ ├── C1_W1_Lab05_Gradient_Descent_Soln.ipynb
│ │ │ ├── data.txt
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── lab_utils_common.py
│ │ │ └── lab_utils_uni.py
│ │ ├── Practice quiz - Regression/
│ │ │ └── README.md
│ │ ├── Practice quiz - Supervised vs unsupervised learning/
│ │ │ └── README.md
│ │ ├── Practice quiz - Train the model with gradient descent/
│ │ │ └── README.md
│ │ └── README.md
│ ├── week2/
│ │ ├── C1W2A1/
│ │ │ ├── C1_W2_Linear_Regression.ipynb
│ │ │ ├── data/
│ │ │ │ ├── ex1data1.txt
│ │ │ │ └── ex1data2.txt
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Optional Labs/
│ │ │ ├── C1_W2_Lab01_Python_Numpy_Vectorization_Soln.ipynb
│ │ │ ├── C1_W2_Lab02_Multiple_Variable_Soln.ipynb
│ │ │ ├── C1_W2_Lab03_Feature_Scaling_and_Learning_Rate_Soln.ipynb
│ │ │ ├── C1_W2_Lab04_FeatEng_PolyReg_Soln.ipynb
│ │ │ ├── C1_W2_Lab05_Sklearn_GD_Soln.ipynb
│ │ │ ├── C1_W2_Lab06_Sklearn_Normal_Soln.ipynb
│ │ │ ├── data/
│ │ │ │ └── houses.txt
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── images/
│ │ │ │ └── C1_W2_Lab04_Figures And animations.pptx
│ │ │ ├── lab_utils_common.py
│ │ │ └── lab_utils_multi.py
│ │ ├── Practice quiz - Gradient descent in practice/
│ │ │ └── README.md
│ │ ├── Practice quiz - Multiple linear regression/
│ │ │ └── README.md
│ │ └── README.md
│ └── week3/
│ ├── C1W3A1/
│ │ ├── C1_W3_Logistic_Regression.ipynb
│ │ ├── archive/
│ │ │ ├── .ipynb_checkpoints/
│ │ │ │ └── C1_W3_Logistic_Regression-Copy1-checkpoint.ipynb
│ │ │ └── C1_W3_Logistic_Regression-Copy1.ipynb
│ │ ├── data/
│ │ │ ├── ex2data1.txt
│ │ │ └── ex2data2.txt
│ │ ├── public_tests.py
│ │ ├── test_utils.py
│ │ └── utils.py
│ ├── Optional Labs/
│ │ ├── C1_W3_Lab01_Classification_Soln.ipynb
│ │ ├── C1_W3_Lab02_Sigmoid_function_Soln.ipynb
│ │ ├── C1_W3_Lab03_Decision_Boundary_Soln.ipynb
│ │ ├── C1_W3_Lab04_LogisticLoss_Soln.ipynb
│ │ ├── C1_W3_Lab05_Cost_Function_Soln.ipynb
│ │ ├── C1_W3_Lab06_Gradient_Descent_Soln.ipynb
│ │ ├── C1_W3_Lab07_Scikit_Learn_Soln.ipynb
│ │ ├── C1_W3_Lab08_Overfitting_Soln.ipynb
│ │ ├── C1_W3_Lab09_Regularization_Soln.ipynb
│ │ ├── archive/
│ │ │ ├── .ipynb_checkpoints/
│ │ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy1-checkpoint.ipynb
│ │ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy2-checkpoint.ipynb
│ │ │ │ └── C1_W3_Lab09_Regularization_Soln-Copy1-checkpoint.ipynb
│ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy1.ipynb
│ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy2.ipynb
│ │ │ └── C1_W3_Lab09_Regularization_Soln-Copy1.ipynb
│ │ ├── deeplearning.mplstyle
│ │ ├── lab_utils_common.py
│ │ ├── plt_logistic_loss.py
│ │ ├── plt_one_addpt_onclick.py
│ │ ├── plt_overfit.py
│ │ └── plt_quad_logistic.py
│ ├── Practice quiz - Cost function for logistic regression/
│ │ └── Readme.md
│ ├── Practice quiz - Gradient descent for logistic regression/
│ │ └── Readme.md
│ └── Readme.md
├── C2 - Advanced Learning Algorithms/
│ ├── Readme.md
│ ├── week1/
│ │ ├── C2W1A1/
│ │ │ ├── .ipynb_checkpoints/
│ │ │ │ └── C2_W1_Assignment-checkpoint.ipynb
│ │ │ ├── C2_W1_Assignment.ipynb
│ │ │ ├── archive/
│ │ │ │ ├── .ipynb_checkpoints/
│ │ │ │ │ └── C2_W1_Assignment-Copy1-checkpoint.ipynb
│ │ │ │ └── C2_W1_Assignment-Copy1.ipynb
│ │ │ ├── autils.py
│ │ │ ├── data/
│ │ │ │ ├── X.npy
│ │ │ │ └── y.npy
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Practice quiz - Neural network model/
│ │ │ └── Readme.md
│ │ ├── Practice quiz - Neural networks intuition/
│ │ │ └── Readme.md
│ │ ├── Practice quiz - TensorFlow implementation/
│ │ │ └── Readme.md
│ │ ├── Practice-Quiz-Neural-Networks-Implementation-in-python/
│ │ │ └── Readme.md
│ │ ├── Readme.md
│ │ └── optional-labs/
│ │ ├── .ipynb_checkpoints/
│ │ │ ├── C2_W1_Lab01_Neurons_and_Layers-checkpoint.ipynb
│ │ │ ├── C2_W1_Lab02_CoffeeRoasting_TF-checkpoint.ipynb
│ │ │ └── C2_W1_Lab03_CoffeeRoasting_Numpy-checkpoint.ipynb
│ │ ├── C2_W1_Lab01_Neurons_and_Layers.ipynb
│ │ ├── C2_W1_Lab02_CoffeeRoasting_TF.ipynb
│ │ ├── C2_W1_Lab03_CoffeeRoasting_Numpy.ipynb
│ │ ├── deeplearning.mplstyle
│ │ ├── lab_coffee_utils.py
│ │ ├── lab_neurons_utils.py
│ │ └── lab_utils_common.py
│ ├── week2/
│ │ ├── C2W2A1/
│ │ │ ├── .ipynb_checkpoints/
│ │ │ │ └── C2_W2_Assignment-checkpoint.ipynb
│ │ │ ├── C2_W2_Assignment.ipynb
│ │ │ ├── autils.py
│ │ │ ├── data/
│ │ │ │ ├── X.npy
│ │ │ │ └── y.npy
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── lab_utils_common.py
│ │ │ ├── lab_utils_softmax.py
│ │ │ ├── logs/
│ │ │ │ └── train/
│ │ │ │ ├── events.out.tfevents.1645828646.ed92f2b0de47.31.186.v2
│ │ │ │ ├── events.out.tfevents.1645828646.ed92f2b0de47.profile-empty
│ │ │ │ ├── events.out.tfevents.1647805546.30f1e0ee4ffd.31.186.v2
│ │ │ │ └── plugins/
│ │ │ │ └── profile/
│ │ │ │ ├── 2022-02-25_22-37-26/
│ │ │ │ │ └── local.trace
│ │ │ │ └── 2022-03-20_19-45-46/
│ │ │ │ └── local.trace
│ │ │ └── public_tests.py
│ │ ├── Practice-Quiz-Activation-Functions/
│ │ │ └── Readme.md
│ │ ├── Practice-Quiz-Additional-Neural-Network-Concepts/
│ │ │ └── Readme.md
│ │ ├── Practice-Quiz-Neural-Network-Training/
│ │ │ └── Readme.md
│ │ ├── Practice-quiz-Multiclass-Classification/
│ │ │ └── Readme.md
│ │ ├── Readme.md
│ │ └── optional-labs/
│ │ ├── .ipynb_checkpoints/
│ │ │ ├── C2_W2_Multiclass_TF-checkpoint.ipynb
│ │ │ ├── C2_W2_Relu-checkpoint.ipynb
│ │ │ └── C2_W2_SoftMax-checkpoint.ipynb
│ │ ├── C2_W2_Multiclass_TF.ipynb
│ │ ├── C2_W2_Relu.ipynb
│ │ ├── C2_W2_SoftMax.ipynb
│ │ ├── archive/
│ │ │ ├── .ipynb_checkpoints/
│ │ │ │ ├── C2_W2_SoftMax-Copy1-checkpoint.ipynb
│ │ │ │ └── C2_W2_SoftMax-Copy2-checkpoint.ipynb
│ │ │ ├── C2_W2_SoftMax-Copy1.ipynb
│ │ │ └── C2_W2_SoftMax-Copy2.ipynb
│ │ ├── autils.py
│ │ ├── backprop/
│ │ │ ├── C2_W2_Backprop.ipynb
│ │ │ ├── C2_W2_Derivatives.ipynb
│ │ │ └── lab_utils_backprop.py
│ │ ├── deeplearning.mplstyle
│ │ ├── lab_utils_common.py
│ │ ├── lab_utils_multiclass.py
│ │ ├── lab_utils_multiclass_TF.py
│ │ ├── lab_utils_relu.py
│ │ └── lab_utils_softmax.py
│ ├── week3/
│ │ ├── C2W3A1/
│ │ │ ├── .ipynb_checkpoints/
│ │ │ │ └── C2_W3_Assignment-checkpoint.ipynb
│ │ │ ├── C2_W3_Assignment.ipynb
│ │ │ ├── assigment_utils.py
│ │ │ ├── deeplearning.mplstyle
│ │ │ ├── public_tests_a1.py
│ │ │ └── utils.py
│ │ ├── Practice-Quiz-Advice-for-applying-machine-learning/
│ │ │ └── Readme.md
│ │ ├── Readme.md
│ │ ├── practice-quiz-bias-and-variance/
│ │ │ └── Readme.md
│ │ └── practice-quiz-machine-learning-development-process/
│ │ └── Readme.md
│ └── week4/
│ ├── C2W4A1/
│ │ ├── .ipynb_checkpoints/
│ │ │ └── C2_W4_Decision_Tree_with_Markdown-checkpoint.ipynb
│ │ ├── C2_W4_Decision_Tree_with_Markdown.ipynb
│ │ └── public_tests.py
│ ├── Readme.md
│ ├── optional labs/
│ │ ├── .ipynb_checkpoints/
│ │ │ ├── C2_W4_Lab_01_Decision_Trees-checkpoint.ipynb
│ │ │ ├── C2_W4_Lab_02_Tree_Ensemble-checkpoint (2).ipynb
│ │ │ └── C2_W4_Lab_02_Tree_Ensemble-checkpoint.ipynb
│ │ ├── C2_W4_Lab_01_Decision_Trees.ipynb
│ │ ├── C2_W4_Lab_02_Tree_Ensemble.ipynb
│ │ ├── deeplearning (2).mplstyle
│ │ ├── deeplearning.mplstyle
│ │ ├── heart.csv
│ │ └── utils.py
│ ├── practice-quiz-decision-tree-learning/
│ │ └── Readme.md
│ ├── practice-quiz-decision-trees/
│ │ └── Readme.md
│ └── practice-quiz-tree-ensembles/
│ └── Readme.md
├── C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/
│ ├── Readme.md
│ ├── week1/
│ │ ├── C3W1A/
│ │ │ ├── C3W1A1/
│ │ │ │ ├── .ipynb_checkpoints/
│ │ │ │ │ └── C3_W1_KMeans_Assignment-checkpoint.ipynb
│ │ │ │ ├── C3_W1_KMeans_Assignment.ipynb
│ │ │ │ ├── data/
│ │ │ │ │ └── ex7_X.npy
│ │ │ │ ├── public_tests.py
│ │ │ │ └── utils.py
│ │ │ └── C3W1A2/
│ │ │ ├── C3_W1_Anomaly_Detection.ipynb
│ │ │ ├── data/
│ │ │ │ ├── X_part1.npy
│ │ │ │ ├── X_part2.npy
│ │ │ │ ├── X_val_part1.npy
│ │ │ │ ├── X_val_part2.npy
│ │ │ │ ├── y_val_part1.npy
│ │ │ │ └── y_val_part2.npy
│ │ │ ├── public_tests.py
│ │ │ └── utils.py
│ │ ├── Practice Quiz - Anomaly Detection/
│ │ │ └── Readme.md
│ │ ├── Practice Quiz - Clustering/
│ │ │ └── Readme.md
│ │ └── Readme.md
│ ├── week2/
│ │ ├── C3W2/
│ │ │ ├── C3W2A1/
│ │ │ │ ├── C3_W2_Collaborative_RecSys_Assignment.ipynb
│ │ │ │ ├── data/
│ │ │ │ │ ├── small_movie_list.csv
│ │ │ │ │ ├── small_movies_R.csv
│ │ │ │ │ ├── small_movies_W.csv
│ │ │ │ │ ├── small_movies_X.csv
│ │ │ │ │ ├── small_movies_Y.csv
│ │ │ │ │ └── small_movies_b.csv
│ │ │ │ ├── public_tests.py
│ │ │ │ └── recsys_utils.py
│ │ │ └── C3W2A2/
│ │ │ ├── C3_W2_RecSysNN_Assignment.ipynb
│ │ │ ├── data/
│ │ │ │ ├── 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
│ │ │ ├── public_tests.py
│ │ │ └── recsysNN_utils.py
│ │ ├── Practice Quiz - Collaborative Filtering/
│ │ │ └── Readme.md
│ │ ├── Practice Quiz - Content-based filtering/
│ │ │ └── Readme.md
│ │ ├── Practice Quiz - Recommender systems implementation/
│ │ │ └── Readme.md
│ │ └── Readme.md
│ └── week3/
│ ├── C3W3A1/
│ │ ├── C3_W3_A1_Assignment.ipynb
│ │ ├── lunar_lander_model.h5
│ │ ├── public_tests.py
│ │ ├── utils.py
│ │ └── videos/
│ │ └── rl_formalism.m4v
│ ├── Practice Quiz - Continuous state spaces/
│ │ └── Readme.md
│ ├── Practice Quiz - Reinforcement learning introduction/
│ │ └── Readme.md
│ ├── Practice Quiz - State-action value function/
│ │ └── Readme.md
│ ├── Readme.md
│ └── optional-labs/
│ ├── .ipynb_checkpoints/
│ │ └── State-action value function example-checkpoint.ipynb
│ ├── State-action value function example.ipynb
│ └── utils.py
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
└── README.md
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/ISSUE_TEMPLATE/error-report.md
================================================
---
name: Error report
about: 'Create a report to help us improve '
title: ''
labels: ''
assignees: ''
---
**Describe the Error**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Desktop (please complete the following information):**
- OS: [e.g. iOS]
- Browser [e.g. chrome, safari]
- Version [e.g. 22]
**Smartphone (please complete the following information):**
- Device: [e.g. iPhone6]
- OS: [e.g. iOS8.1]
- Browser [e.g. stock browser, safari]
- Version [e.g. 22]
**Additional context**
Add any other context about the problem here.
================================================
FILE: C1 - Supervised Machine Learning - Regression and Classification/README.md
================================================
## Supervised Machine Learning : Regression and Classification
- [Week 1](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1)
- [Practice quiz: Regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1/Practice%20quiz%20-%20Regression)
- [Practice quiz: Supervised vs unsupervised learning](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1/Practice%20quiz%20-%20Supervised%20vs%20unsupervised%20learning)
- [Practice quiz: Train the model with gradient descent](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1/Practice%20quiz%20-%20Train%20the%20model%20with%20gradient%20descent)
- [Optional Labs](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1/Optional%20Labs)
- [Model Representation](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1/Optional%20Labs/C1_W1_Lab03_Model_Representation_Soln.ipynb)
- [Cost Function](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1/Optional%20Labs/C1_W1_Lab04_Cost_function_Soln.ipynb)
- [Gradient Descent](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week1/Optional%20Labs/C1_W1_Lab05_Gradient_Descent_Soln.ipynb)
<br/>
- [Week 2](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2)
- [Practice quiz: Gradient descent in practice](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Practice%20quiz%20-%20Gradient%20descent%20in%20practice)
- [Practice quiz: Multiple linear regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Practice%20quiz%20-%20Multiple%20linear%20regression)
- [Optional Labs](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Optional%20Labs)
- [Numpy Vectorization](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Optional%20Labs/C1_W2_Lab01_Python_Numpy_Vectorization_Soln.ipynb)
- [Multi Variate Regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Optional%20Labs/C1_W2_Lab02_Multiple_Variable_Soln.ipynb)
- [Feature Scaling](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Optional%20Labs/C1_W2_Lab03_Feature_Scaling_and_Learning_Rate_Soln.ipynb)
- [Feature Engineering](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Optional%20Labs/C1_W2_Lab04_FeatEng_PolyReg_Soln.ipynb)
- [Sklearn Gradient Descent](/C1%20-%20Supervised%20Machine%20Learning%3A%20Regression%20and%20Classification/week2/Optional%20Labs/C1_W2_Lab05_Sklearn_GD_Soln.ipynb)
- [Sklearn Normal Method](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Optional%20Labs/C1_W2_Lab05_Sklearn_GD_Soln.ipynb)
- [Programming Assignment](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/C1W2A1)
- [Linear Regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/C1W2A1/C1_W2_Linear_Regression.ipynb)
<br/>
- [Week 3](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3)
- [Practice quiz: Cost function for logistic regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Practice%20quiz%20-%20Cost%20function%20for%20logistic%20regression)
- [Practice quiz: Gradient descent for logistic regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Practice%20quiz%20-%20Gradient%20descent%20for%20logistic%20regression)
- [Optional Labs](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs)
- [Classification](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab01_Classification_Soln.ipynb)
- [Sigmoid Function](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab02_Sigmoid_function_Soln.ipynb)
- [Decision Boundary](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab03_Decision_Boundary_Soln.ipynb)
- [Logistic Loss](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab04_LogisticLoss_Soln.ipynb)
- [Cost Function](/C1%20-%20Supervised%20Machine%20Learning:%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab05_Cost_Function_Soln.ipynb)
- [Gradient Descent](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab06_Gradient_Descent_Soln.ipynb)
- [Scikit Learn - Logistic Regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab07_Scikit_Learn_Soln.ipynb)
- [Overfitting](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab08_Overfitting_Soln.ipynb)
- [Regularization](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/Optional%20Labs/C1_W3_Lab09_Regularization_Soln.ipynb)
- [Programming Assignment](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/tree/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/C1W3A1)
- [Logistic Regression](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/main/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week3/C1W3A1/C1_W3_Logistic_Regression.ipynb)
#### [Certificate Of Completion](https://coursera.org/share/195768f3c1a83e42298d3f61dae99d01)
<br/>
================================================
FILE: C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/C1_W1_Lab01_Python_Jupyter_Soln.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"<figure>\n",
" <center> <img src=\"./images/C1W1L1_Tour.PNG\" alt='missing' width=\"400\" ><center/>\n",
"<figure/>"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"<figure>\n",
" <img src=\"./images/C1W1L1_Markdown.PNG\" alt='missing' width=\"400\" >\n",
"<figure/>"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"The other type of cell is the `code cell` where you will write your code:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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: C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/C1_W1_Lab03_Model_Representation_Soln.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"plt.style.use('./deeplearning.mplstyle')"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"One can also use the Python `len()` function as shown below."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"### Plotting the data"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Now let's call the `compute_model_output` function and plot the output.."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%%\n"
}
},
"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: C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/C1_W1_Lab04_Cost_function_Soln.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": 2,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": 3,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": 4,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"## Cost Function Intuition"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": 5,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"text/plain": "interactive(children=(IntSlider(value=150, description='w', max=400, step=10), Output()), _dom_classes=('widge…",
"application/vnd.jupyter.widget-view+json": {
"version_major": 2,
"version_minor": 0,
"model_id": "edfdeb101ed24a93bfe261e6233f0071"
}
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt_intuition(x_train,y_train)"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": 6,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"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": {
"pycharm": {
"name": "#%% md\n"
}
},
"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": 7,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
"image/png": "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
gitextract_zzi5ix77/ ├── .github/ │ └── ISSUE_TEMPLATE/ │ └── error-report.md ├── C1 - Supervised Machine Learning - Regression and Classification/ │ ├── README.md │ ├── week1/ │ │ ├── Optional Labs/ │ │ │ ├── C1_W1_Lab01_Python_Jupyter_Soln.ipynb │ │ │ ├── C1_W1_Lab03_Model_Representation_Soln.ipynb │ │ │ ├── C1_W1_Lab04_Cost_function_Soln.ipynb │ │ │ ├── C1_W1_Lab05_Gradient_Descent_Soln.ipynb │ │ │ ├── data.txt │ │ │ ├── deeplearning.mplstyle │ │ │ ├── lab_utils_common.py │ │ │ └── lab_utils_uni.py │ │ ├── Practice quiz - Regression/ │ │ │ └── README.md │ │ ├── Practice quiz - Supervised vs unsupervised learning/ │ │ │ └── README.md │ │ ├── Practice quiz - Train the model with gradient descent/ │ │ │ └── README.md │ │ └── README.md │ ├── week2/ │ │ ├── C1W2A1/ │ │ │ ├── C1_W2_Linear_Regression.ipynb │ │ │ ├── data/ │ │ │ │ ├── ex1data1.txt │ │ │ │ └── ex1data2.txt │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Optional Labs/ │ │ │ ├── C1_W2_Lab01_Python_Numpy_Vectorization_Soln.ipynb │ │ │ ├── C1_W2_Lab02_Multiple_Variable_Soln.ipynb │ │ │ ├── C1_W2_Lab03_Feature_Scaling_and_Learning_Rate_Soln.ipynb │ │ │ ├── C1_W2_Lab04_FeatEng_PolyReg_Soln.ipynb │ │ │ ├── C1_W2_Lab05_Sklearn_GD_Soln.ipynb │ │ │ ├── C1_W2_Lab06_Sklearn_Normal_Soln.ipynb │ │ │ ├── data/ │ │ │ │ └── houses.txt │ │ │ ├── deeplearning.mplstyle │ │ │ ├── images/ │ │ │ │ └── C1_W2_Lab04_Figures And animations.pptx │ │ │ ├── lab_utils_common.py │ │ │ └── lab_utils_multi.py │ │ ├── Practice quiz - Gradient descent in practice/ │ │ │ └── README.md │ │ ├── Practice quiz - Multiple linear regression/ │ │ │ └── README.md │ │ └── README.md │ └── week3/ │ ├── C1W3A1/ │ │ ├── C1_W3_Logistic_Regression.ipynb │ │ ├── archive/ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ └── C1_W3_Logistic_Regression-Copy1-checkpoint.ipynb │ │ │ └── C1_W3_Logistic_Regression-Copy1.ipynb │ │ ├── data/ │ │ │ ├── ex2data1.txt │ │ │ └── ex2data2.txt │ │ ├── public_tests.py │ │ ├── test_utils.py │ │ └── utils.py │ ├── Optional Labs/ │ │ ├── C1_W3_Lab01_Classification_Soln.ipynb │ │ ├── C1_W3_Lab02_Sigmoid_function_Soln.ipynb │ │ ├── C1_W3_Lab03_Decision_Boundary_Soln.ipynb │ │ ├── C1_W3_Lab04_LogisticLoss_Soln.ipynb │ │ ├── C1_W3_Lab05_Cost_Function_Soln.ipynb │ │ ├── C1_W3_Lab06_Gradient_Descent_Soln.ipynb │ │ ├── C1_W3_Lab07_Scikit_Learn_Soln.ipynb │ │ ├── C1_W3_Lab08_Overfitting_Soln.ipynb │ │ ├── C1_W3_Lab09_Regularization_Soln.ipynb │ │ ├── archive/ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy1-checkpoint.ipynb │ │ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy2-checkpoint.ipynb │ │ │ │ └── C1_W3_Lab09_Regularization_Soln-Copy1-checkpoint.ipynb │ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy1.ipynb │ │ │ ├── C1_W3_Lab05_Cost_Function_Soln-Copy2.ipynb │ │ │ └── C1_W3_Lab09_Regularization_Soln-Copy1.ipynb │ │ ├── deeplearning.mplstyle │ │ ├── lab_utils_common.py │ │ ├── plt_logistic_loss.py │ │ ├── plt_one_addpt_onclick.py │ │ ├── plt_overfit.py │ │ └── plt_quad_logistic.py │ ├── Practice quiz - Cost function for logistic regression/ │ │ └── Readme.md │ ├── Practice quiz - Gradient descent for logistic regression/ │ │ └── Readme.md │ └── Readme.md ├── C2 - Advanced Learning Algorithms/ │ ├── Readme.md │ ├── week1/ │ │ ├── C2W1A1/ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ └── C2_W1_Assignment-checkpoint.ipynb │ │ │ ├── C2_W1_Assignment.ipynb │ │ │ ├── archive/ │ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ │ └── C2_W1_Assignment-Copy1-checkpoint.ipynb │ │ │ │ └── C2_W1_Assignment-Copy1.ipynb │ │ │ ├── autils.py │ │ │ ├── data/ │ │ │ │ ├── X.npy │ │ │ │ └── y.npy │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Practice quiz - Neural network model/ │ │ │ └── Readme.md │ │ ├── Practice quiz - Neural networks intuition/ │ │ │ └── Readme.md │ │ ├── Practice quiz - TensorFlow implementation/ │ │ │ └── Readme.md │ │ ├── Practice-Quiz-Neural-Networks-Implementation-in-python/ │ │ │ └── Readme.md │ │ ├── Readme.md │ │ └── optional-labs/ │ │ ├── .ipynb_checkpoints/ │ │ │ ├── C2_W1_Lab01_Neurons_and_Layers-checkpoint.ipynb │ │ │ ├── C2_W1_Lab02_CoffeeRoasting_TF-checkpoint.ipynb │ │ │ └── C2_W1_Lab03_CoffeeRoasting_Numpy-checkpoint.ipynb │ │ ├── C2_W1_Lab01_Neurons_and_Layers.ipynb │ │ ├── C2_W1_Lab02_CoffeeRoasting_TF.ipynb │ │ ├── C2_W1_Lab03_CoffeeRoasting_Numpy.ipynb │ │ ├── deeplearning.mplstyle │ │ ├── lab_coffee_utils.py │ │ ├── lab_neurons_utils.py │ │ └── lab_utils_common.py │ ├── week2/ │ │ ├── C2W2A1/ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ └── C2_W2_Assignment-checkpoint.ipynb │ │ │ ├── C2_W2_Assignment.ipynb │ │ │ ├── autils.py │ │ │ ├── data/ │ │ │ │ ├── X.npy │ │ │ │ └── y.npy │ │ │ ├── deeplearning.mplstyle │ │ │ ├── lab_utils_common.py │ │ │ ├── lab_utils_softmax.py │ │ │ ├── logs/ │ │ │ │ └── train/ │ │ │ │ ├── events.out.tfevents.1645828646.ed92f2b0de47.31.186.v2 │ │ │ │ ├── events.out.tfevents.1645828646.ed92f2b0de47.profile-empty │ │ │ │ ├── events.out.tfevents.1647805546.30f1e0ee4ffd.31.186.v2 │ │ │ │ └── plugins/ │ │ │ │ └── profile/ │ │ │ │ ├── 2022-02-25_22-37-26/ │ │ │ │ │ └── local.trace │ │ │ │ └── 2022-03-20_19-45-46/ │ │ │ │ └── local.trace │ │ │ └── public_tests.py │ │ ├── Practice-Quiz-Activation-Functions/ │ │ │ └── Readme.md │ │ ├── Practice-Quiz-Additional-Neural-Network-Concepts/ │ │ │ └── Readme.md │ │ ├── Practice-Quiz-Neural-Network-Training/ │ │ │ └── Readme.md │ │ ├── Practice-quiz-Multiclass-Classification/ │ │ │ └── Readme.md │ │ ├── Readme.md │ │ └── optional-labs/ │ │ ├── .ipynb_checkpoints/ │ │ │ ├── C2_W2_Multiclass_TF-checkpoint.ipynb │ │ │ ├── C2_W2_Relu-checkpoint.ipynb │ │ │ └── C2_W2_SoftMax-checkpoint.ipynb │ │ ├── C2_W2_Multiclass_TF.ipynb │ │ ├── C2_W2_Relu.ipynb │ │ ├── C2_W2_SoftMax.ipynb │ │ ├── archive/ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ ├── C2_W2_SoftMax-Copy1-checkpoint.ipynb │ │ │ │ └── C2_W2_SoftMax-Copy2-checkpoint.ipynb │ │ │ ├── C2_W2_SoftMax-Copy1.ipynb │ │ │ └── C2_W2_SoftMax-Copy2.ipynb │ │ ├── autils.py │ │ ├── backprop/ │ │ │ ├── C2_W2_Backprop.ipynb │ │ │ ├── C2_W2_Derivatives.ipynb │ │ │ └── lab_utils_backprop.py │ │ ├── deeplearning.mplstyle │ │ ├── lab_utils_common.py │ │ ├── lab_utils_multiclass.py │ │ ├── lab_utils_multiclass_TF.py │ │ ├── lab_utils_relu.py │ │ └── lab_utils_softmax.py │ ├── week3/ │ │ ├── C2W3A1/ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ └── C2_W3_Assignment-checkpoint.ipynb │ │ │ ├── C2_W3_Assignment.ipynb │ │ │ ├── assigment_utils.py │ │ │ ├── deeplearning.mplstyle │ │ │ ├── public_tests_a1.py │ │ │ └── utils.py │ │ ├── Practice-Quiz-Advice-for-applying-machine-learning/ │ │ │ └── Readme.md │ │ ├── Readme.md │ │ ├── practice-quiz-bias-and-variance/ │ │ │ └── Readme.md │ │ └── practice-quiz-machine-learning-development-process/ │ │ └── Readme.md │ └── week4/ │ ├── C2W4A1/ │ │ ├── .ipynb_checkpoints/ │ │ │ └── C2_W4_Decision_Tree_with_Markdown-checkpoint.ipynb │ │ ├── C2_W4_Decision_Tree_with_Markdown.ipynb │ │ └── public_tests.py │ ├── Readme.md │ ├── optional labs/ │ │ ├── .ipynb_checkpoints/ │ │ │ ├── C2_W4_Lab_01_Decision_Trees-checkpoint.ipynb │ │ │ ├── C2_W4_Lab_02_Tree_Ensemble-checkpoint (2).ipynb │ │ │ └── C2_W4_Lab_02_Tree_Ensemble-checkpoint.ipynb │ │ ├── C2_W4_Lab_01_Decision_Trees.ipynb │ │ ├── C2_W4_Lab_02_Tree_Ensemble.ipynb │ │ ├── deeplearning (2).mplstyle │ │ ├── deeplearning.mplstyle │ │ ├── heart.csv │ │ └── utils.py │ ├── practice-quiz-decision-tree-learning/ │ │ └── Readme.md │ ├── practice-quiz-decision-trees/ │ │ └── Readme.md │ └── practice-quiz-tree-ensembles/ │ └── Readme.md ├── C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/ │ ├── Readme.md │ ├── week1/ │ │ ├── C3W1A/ │ │ │ ├── C3W1A1/ │ │ │ │ ├── .ipynb_checkpoints/ │ │ │ │ │ └── C3_W1_KMeans_Assignment-checkpoint.ipynb │ │ │ │ ├── C3_W1_KMeans_Assignment.ipynb │ │ │ │ ├── data/ │ │ │ │ │ └── ex7_X.npy │ │ │ │ ├── public_tests.py │ │ │ │ └── utils.py │ │ │ └── C3W1A2/ │ │ │ ├── C3_W1_Anomaly_Detection.ipynb │ │ │ ├── data/ │ │ │ │ ├── X_part1.npy │ │ │ │ ├── X_part2.npy │ │ │ │ ├── X_val_part1.npy │ │ │ │ ├── X_val_part2.npy │ │ │ │ ├── y_val_part1.npy │ │ │ │ └── y_val_part2.npy │ │ │ ├── public_tests.py │ │ │ └── utils.py │ │ ├── Practice Quiz - Anomaly Detection/ │ │ │ └── Readme.md │ │ ├── Practice Quiz - Clustering/ │ │ │ └── Readme.md │ │ └── Readme.md │ ├── week2/ │ │ ├── C3W2/ │ │ │ ├── C3W2A1/ │ │ │ │ ├── C3_W2_Collaborative_RecSys_Assignment.ipynb │ │ │ │ ├── data/ │ │ │ │ │ ├── small_movie_list.csv │ │ │ │ │ ├── small_movies_R.csv │ │ │ │ │ ├── small_movies_W.csv │ │ │ │ │ ├── small_movies_X.csv │ │ │ │ │ ├── small_movies_Y.csv │ │ │ │ │ └── small_movies_b.csv │ │ │ │ ├── public_tests.py │ │ │ │ └── recsys_utils.py │ │ │ └── C3W2A2/ │ │ │ ├── C3_W2_RecSysNN_Assignment.ipynb │ │ │ ├── data/ │ │ │ │ ├── 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 │ │ │ ├── public_tests.py │ │ │ └── recsysNN_utils.py │ │ ├── Practice Quiz - Collaborative Filtering/ │ │ │ └── Readme.md │ │ ├── Practice Quiz - Content-based filtering/ │ │ │ └── Readme.md │ │ ├── Practice Quiz - Recommender systems implementation/ │ │ │ └── Readme.md │ │ └── Readme.md │ └── week3/ │ ├── C3W3A1/ │ │ ├── C3_W3_A1_Assignment.ipynb │ │ ├── lunar_lander_model.h5 │ │ ├── public_tests.py │ │ ├── utils.py │ │ └── videos/ │ │ └── rl_formalism.m4v │ ├── Practice Quiz - Continuous state spaces/ │ │ └── Readme.md │ ├── Practice Quiz - Reinforcement learning introduction/ │ │ └── Readme.md │ ├── Practice Quiz - State-action value function/ │ │ └── Readme.md │ ├── Readme.md │ └── optional-labs/ │ ├── .ipynb_checkpoints/ │ │ └── State-action value function example-checkpoint.ipynb │ ├── State-action value function example.ipynb │ └── utils.py ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE └── README.md
SYMBOL INDEX (371 symbols across 47 files)
FILE: C1 - Supervised Machine Learning - Regression and Classification/week1/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: C1 - Supervised Machine Learning - Regression and Classification/week1/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 343) | def add_line(dj_dx, x1, y1, d, ax):
function plt_gradients (line 355) | def plt_gradients(x_train,y_train, f_compute_cost, f_compute_gradient):
FILE: C1 - Supervised Machine Learning - Regression and Classification/week2/C1W2A1/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: C1 - Supervised Machine Learning - Regression and Classification/week2/C1W2A1/utils.py
function load_data (line 3) | def load_data():
function load_data_multi (line 9) | def load_data_multi():
FILE: C1 - Supervised Machine Learning - Regression and Classification/week2/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: C1 - Supervised Machine Learning - Regression and Classification/week2/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: C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/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: C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/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: C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/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: C1 - Supervised Machine Learning - Regression and Classification/week3/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: C1 - Supervised Machine Learning - Regression and Classification/week3/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: C1 - Supervised Machine Learning - Regression and Classification/week3/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: C1 - Supervised Machine Learning - Regression and Classification/week3/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: C1 - Supervised Machine Learning - Regression and Classification/week3/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: C2 - Advanced Learning Algorithms/week1/C2W1A1/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: C2 - Advanced Learning Algorithms/week1/C2W1A1/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: C2 - Advanced Learning Algorithms/week1/C2W1A1/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: C2 - Advanced Learning Algorithms/week1/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: C2 - Advanced Learning Algorithms/week1/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: C2 - Advanced Learning Algorithms/week1/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: C2 - Advanced Learning Algorithms/week2/C2W2A1/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: C2 - Advanced Learning Algorithms/week2/C2W2A1/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: C2 - Advanced Learning Algorithms/week2/C2W2A1/lab_utils_softmax.py
function plt_softmax (line 10) | def plt_softmax(my_softmax):
FILE: C2 - Advanced Learning Algorithms/week2/C2W2A1/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: C2 - Advanced Learning Algorithms/week2/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: C2 - Advanced Learning Algorithms/week2/optional-labs/backprop/lab_utils_backprop.py
function widgvis (line 10) | def widgvis(fig):
function between (line 15) | def between(a, b, x):
function near (line 22) | def near(pt, alist, dist=15):
function inboxes (line 31) | def inboxes(pt, boxlist):
class avalue (line 41) | class avalue():
method __init__ (line 43) | def __init__(self, value, pt, cl):
method add_anote (line 48) | def add_anote(self, ax):
class astring (line 52) | class astring():
method __init__ (line 54) | def __init__(self, ax, string, pt, cl):
method astring_visible (line 61) | def astring_visible(self):
method astring_invisible (line 64) | def astring_invisible(self):
class abox (line 68) | class abox():
method __init__ (line 70) | def __init__(self, ax, value, left, bottom, right, top, anpt, cl, adj_...
method inbox (line 82) | def inbox(self, pt):
method update_val (line 90) | def update_val(self, value, cl=None):
method show_secondary (line 97) | def show_secondary(self):
method clear_secondary (line 101) | def clear_secondary(self):
class plt_network (line 111) | class plt_network():
method __init__ (line 113) | def __init__(self, fn, image, out=None):
method sizefig (line 138) | def sizefig(self,img):
method updateval (line 148) | def updateval(self, event):
method onclick (line 174) | def onclick(self, event):
method reveal_values (line 194) | def reveal_values(self, event):
method hide_values (line 200) | def hide_values(self, event):
function config_nw0 (line 209) | def config_nw0(ax):
function config_nw1 (line 234) | def config_nw1(ax):
function config_nw2 (line 283) | def config_nw2():
FILE: C2 - Advanced Learning Algorithms/week2/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: C2 - Advanced Learning Algorithms/week2/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: C2 - Advanced Learning Algorithms/week2/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: C2 - Advanced Learning Algorithms/week2/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: C2 - Advanced Learning Algorithms/week2/optional-labs/lab_utils_softmax.py
function plt_softmax (line 10) | def plt_softmax(my_softmax):
FILE: C2 - Advanced Learning Algorithms/week3/C2W3A1/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: C2 - Advanced Learning Algorithms/week3/C2W3A1/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: C2 - Advanced Learning Algorithms/week3/C2W3A1/utils.py
function load_data (line 5) | def load_data():
FILE: C2 - Advanced Learning Algorithms/week4/C2W4A1/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: C2 - Advanced Learning Algorithms/week4/optional labs/utils.py
function compute_entropy (line 9) | def compute_entropy(y):
function split_dataset (line 22) | def split_dataset(X, node_indices, feature):
function compute_information_gain (line 37) | def compute_information_gain(X, y, node_indices, feature):
function get_best_split (line 57) | def get_best_split(X, y, node_indices):
function build_tree_recursive (line 73) | def build_tree_recursive(X, y, node_indices, branch_name, max_depth, cur...
function generate_node_image (line 94) | def generate_node_image(node_indices):
function generate_split_viz (line 114) | def generate_split_viz(node_indices, left_indices, right_indices, feature):
function generate_tree_viz (line 151) | def generate_tree_viz(root_indices, y, tree):
function plot_entropy (line 211) | def plot_entropy():
FILE: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A1/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: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A1/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: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A2/public_tests.py
function select_threshold_test (line 4) | def select_threshold_test(target):
function estimate_gaussian_test (line 31) | def estimate_gaussian_test(target):
FILE: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A2/utils.py
function load_data (line 4) | def load_data():
function load_data_multi (line 10) | def load_data_multi():
function multivariate_gaussian (line 17) | def multivariate_gaussian(X, mu, var):
function visualize_fit (line 38) | def visualize_fit(X, mu, var):
FILE: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/public_tests.py
function test_cofi_cost_func (line 3) | def test_cofi_cost_func(target):
FILE: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/public_tests.py
function test_tower (line 6) | def test_tower(target):
function test_sq_dist (line 26) | def test_sq_dist(target):
FILE: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/C3W3A1/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: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/C3W3A1/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):
FILE: C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/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, ...
Copy disabled (too large)
Download .json
Condensed preview — 213 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (29,451K chars).
[
{
"path": ".github/ISSUE_TEMPLATE/error-report.md",
"chars": 841,
"preview": "---\nname: Error report\nabout: 'Create a report to help us improve '\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe "
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/README.md",
"chars": 8724,
"preview": "## Supervised Machine Learning : Regression and Classification\n\n\n\n- [Week 1](https://github.com/greyhatguy007/Machine-Le"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/C1_W1_Lab01_Python_Jupyter_Soln.ipynb",
"chars": 4687,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/C1_W1_Lab03_Model_Representation_Soln.ipynb",
"chars": 47359,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/C1_W1_Lab04_Cost_function_Soln.ipynb",
"chars": 1328013,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/C1_W1_Lab05_Gradient_Descent_Soln.ipynb",
"chars": 332592,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/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": "C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/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": "C1 - Supervised Machine Learning - Regression and Classification/week1/Optional Labs/lab_utils_uni.py",
"chars": 14639,
"preview": "\"\"\" \nlab_utils_uni.py\n routines used in Course 1, Week2, labs1-3 dealing with single variables (univariate)\n\"\"\"\nimpor"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Practice quiz - Regression/README.md",
"chars": 128,
"preview": "![](/C1%20-%20Supervised%20Machine%20Learning:%20Regression%20and%20Classification/week1/Practice%20quiz:%20Regression/s"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Practice quiz - Supervised vs unsupervised learning/README.md",
"chars": 162,
"preview": "![](/C1%20-%20Supervised%20Machine%20Learning%3A%20Regression%20and%20Classification/week1/Practice%20quiz%3A%20Supervis"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/Practice quiz - Train the model with gradient descent/README.md",
"chars": 168,
"preview": "![](/C1%20-%20Supervised%20Machine%20Learning%3A%20Regression%20and%20Classification/week1/Practice%20quiz%3A%20Train%20"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week1/README.md",
"chars": 1828,
"preview": "### Week 1 Solutions \n\n<br></br>\n\n- [Practice quiz: Regression](https://github.com/greyhatguy007/Machine-Learning-Specia"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/C1W2A1/C1_W2_Linear_Regression.ipynb",
"chars": 72960,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Linear Regression\\n"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/C1W2A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week2/C1W2A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week2/C1W2A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week2/C1W2A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/C1_W2_Lab01_Python_Numpy_Vectorization_Soln.ipynb",
"chars": 33172,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/C1_W2_Lab02_Multiple_Variable_Soln.ipynb",
"chars": 62553,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"id\": \"a8397a98\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% m"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/C1_W2_Lab03_Feature_Scaling_and_Learning_Rate_Soln.ipynb",
"chars": 466546,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"id\": \"c8d25fe2\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% m"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/C1_W2_Lab04_FeatEng_PolyReg_Soln.ipynb",
"chars": 161155,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/C1_W2_Lab05_Sklearn_GD_Soln.ipynb",
"chars": 53318,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/C1_W2_Lab06_Sklearn_Normal_Soln.ipynb",
"chars": 9157,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/data/houses.txt",
"chars": 12500,
"preview": "9.520000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,6.500000000000000000e+01,2.715000000000000000"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Optional Labs/deeplearning.mplstyle",
"chars": 4890,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/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": "C1 - Supervised Machine Learning - Regression and Classification/week2/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": "C1 - Supervised Machine Learning - Regression and Classification/week2/Practice quiz - Gradient descent in practice/README.md",
"chars": 373,
"preview": "![Gradient Descent in Practice](/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/Practice quiz - Multiple linear regression/README.md",
"chars": 180,
"preview": "![Multiple linear regression](/C1%20-%20Supervised%20Machine%20Learning%20-%20Regression%20and%20Classification/week2/Pr"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week2/README.md",
"chars": 2688,
"preview": "### Week 2 Solutions\n\n<br></br>\n\n- [Practice quiz: Gradient descent in practice](https://github.com/greyhatguy007/Machin"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/C1_W3_Logistic_Regression.ipynb",
"chars": 136029,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Logistic Regression\\n\",\n \"\\n\","
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/archive/.ipynb_checkpoints/C1_W3_Logistic_Regression-Copy1-checkpoint.ipynb",
"chars": 67683,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Logistic Regression\\n\",\n \"\\n\","
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/archive/C1_W3_Logistic_Regression-Copy1.ipynb",
"chars": 67683,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Logistic Regression\\n\",\n \"\\n\","
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/data/ex2data1.txt",
"chars": 3775,
"preview": "34.62365962451697,78.0246928153624,0\n30.28671076822607,43.89499752400101,0\n35.84740876993872,72.90219802708364,0\n60.1825"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week3/C1W3A1/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": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab01_Classification_Soln.ipynb",
"chars": 131263,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab02_Sigmoid_function_Soln.ipynb",
"chars": 123159,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab03_Decision_Boundary_Soln.ipynb",
"chars": 118839,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"id\": \"f1cc65d6\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% m"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab04_LogisticLoss_Soln.ipynb",
"chars": 1131354,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab05_Cost_Function_Soln.ipynb",
"chars": 95762,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab06_Gradient_Descent_Soln.ipynb",
"chars": 501767,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab07_Scikit_Learn_Soln.ipynb",
"chars": 3605,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab08_Overfitting_Soln.ipynb",
"chars": 128902,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/C1_W3_Lab09_Regularization_Soln.ipynb",
"chars": 155115,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/archive/.ipynb_checkpoints/C1_W3_Lab05_Cost_Function_Soln-Copy1-checkpoint.ipynb",
"chars": 8510,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Cost Function for L"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/archive/.ipynb_checkpoints/C1_W3_Lab05_Cost_Function_Soln-Copy2-checkpoint.ipynb",
"chars": 8528,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Cost Function for L"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/archive/.ipynb_checkpoints/C1_W3_Lab09_Regularization_Soln-Copy1-checkpoint.ipynb",
"chars": 18386,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - Regularized Cost a"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/archive/C1_W3_Lab05_Cost_Function_Soln-Copy1.ipynb",
"chars": 8510,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Cost Function for L"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/archive/C1_W3_Lab05_Cost_Function_Soln-Copy2.ipynb",
"chars": 8528,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab: Cost Function for L"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/archive/C1_W3_Lab09_Regularization_Soln-Copy1.ipynb",
"chars": 18386,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - Regularized Cost a"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/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": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/plt_logistic_loss.py",
"chars": 7177,
"preview": "\"\"\"----------------------------------------------------------------\n logistic_loss plotting routines and support\n\"\"\"\n\nfr"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Optional Labs/plt_one_addpt_onclick.py",
"chars": 8504,
"preview": "import time\nimport copy\nfrom ipywidgets import Output\nfrom matplotlib.widgets import Button, CheckButtons\nfrom matplotli"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/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": "C1 - Supervised Machine Learning - Regression and Classification/week3/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": "C1 - Supervised Machine Learning - Regression and Classification/week3/Practice quiz - Cost function for logistic regression/Readme.md",
"chars": 163,
"preview": "![](/C1%20-%20Supervised%20Machine%20Learning:%20Regression%20and%20Classification/week3/Practice%20quiz:%20Cost%20funct"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Practice quiz - Gradient descent for logistic regression/Readme.md",
"chars": 166,
"preview": "![](/C1%20-%20Supervised%20Machine%20Learning:%20Regression%20and%20Classification/week3/Practice%20quiz:%20Gradient%20d"
},
{
"path": "C1 - Supervised Machine Learning - Regression and Classification/week3/Readme.md",
"chars": 3444,
"preview": "### Week 3 Solutions\n\n<br></br>\n\n\n- [Practice quiz: Cost function for logistic regression](https://github.com/greyhatguy"
},
{
"path": "C2 - Advanced Learning Algorithms/Readme.md",
"chars": 7675,
"preview": "## Advanced Learning Algorithms\n\n- [Week 1](/C2%20-%20Advanced%20Learning%20Algorithms/week1)\n - [Practice quiz: Neur"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/C2W1A1/.ipynb_checkpoints/C2_W1_Assignment-checkpoint.ipynb",
"chars": 570857,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Neural Networks for"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/C2W1A1/C2_W1_Assignment.ipynb",
"chars": 570857,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Neural Networks for"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/C2W1A1/archive/.ipynb_checkpoints/C2_W1_Assignment-Copy1-checkpoint.ipynb",
"chars": 41553,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Neural Networks for Handwritten D"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/C2W1A1/archive/C2_W1_Assignment-Copy1.ipynb",
"chars": 41553,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Neural Networks for Handwritten D"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/C2W1A1/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": "C2 - Advanced Learning Algorithms/week1/C2W1A1/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": "C2 - Advanced Learning Algorithms/week1/C2W1A1/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": "C2 - Advanced Learning Algorithms/week1/Practice quiz - Neural network model/Readme.md",
"chars": 211,
"preview": "\n![](/C2%20-%20"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/Practice quiz - Neural networks intuition/Readme.md",
"chars": 110,
"preview": ""
},
{
"path": "C2 - Advanced Learning Algorithms/week1/Practice quiz - TensorFlow implementation/Readme.md",
"chars": 217,
"preview": "\n![](/C2%20-"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/Practice-Quiz-Neural-Networks-Implementation-in-python/Readme.md",
"chars": 707,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/e5d6103f4bdf732390bd85aeb453002f276d8"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/Readme.md",
"chars": 2392,
"preview": "### C2 - Week 1 Solutions \n\n<br/>\n\n- [Practice quiz: Neural networks intuition](https://github.com/greyhatguy007/Machine"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/optional-labs/.ipynb_checkpoints/C2_W1_Lab01_Neurons_and_Layers-checkpoint.ipynb",
"chars": 114134,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/optional-labs/.ipynb_checkpoints/C2_W1_Lab02_CoffeeRoasting_TF-checkpoint.ipynb",
"chars": 551386,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/optional-labs/.ipynb_checkpoints/C2_W1_Lab03_CoffeeRoasting_Numpy-checkpoint.ipynb",
"chars": 262063,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/optional-labs/C2_W1_Lab01_Neurons_and_Layers.ipynb",
"chars": 114134,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/optional-labs/C2_W1_Lab02_CoffeeRoasting_TF.ipynb",
"chars": 551386,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/optional-labs/C2_W1_Lab03_CoffeeRoasting_Numpy.ipynb",
"chars": 262063,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/optional-labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C2 - Advanced Learning Algorithms/week1/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": "C2 - Advanced Learning Algorithms/week1/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": "C2 - Advanced Learning Algorithms/week1/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": "C2 - Advanced Learning Algorithms/week2/C2W2A1/.ipynb_checkpoints/C2_W2_Assignment-checkpoint.ipynb",
"chars": 38407,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Neural Networks for"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/C2W2A1/C2_W2_Assignment.ipynb",
"chars": 41178,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C2 - Advanced Learning Algorithms/week2/C2W2A1/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": "C2 - Advanced Learning Algorithms/week2/C2W2A1/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/C2W2A1/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": "C2 - Advanced Learning Algorithms/week2/C2W2A1/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": "C2 - Advanced Learning Algorithms/week2/C2W2A1/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": "C2 - Advanced Learning Algorithms/week2/Practice-Quiz-Activation-Functions/Readme.md",
"chars": 431,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/505dfb62e1cd34b57fa905b047b07dfa2f2a1"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/Practice-Quiz-Additional-Neural-Network-Concepts/Readme.md",
"chars": 229,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/96a5eb1dd10b14343bbbc0cb7495996980997"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/Practice-Quiz-Neural-Network-Training/Readme.md",
"chars": 437,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/36877f8ee5f8437019dfb8f03e134dbbe3464"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/Practice-quiz-Multiclass-Classification/Readme.md",
"chars": 662,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/d98e05e9e0ef94b8fdad0c59b4a086620efe3"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/Readme.md",
"chars": 2401,
"preview": "### C2 - Week 2 Solutions \n\n- [Practice quiz : Neural Networks Training](https://github.com/greyhatguy007/Machine-Learni"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/.ipynb_checkpoints/C2_W2_Multiclass_TF-checkpoint.ipynb",
"chars": 34998,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - Multi-class Classi"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/.ipynb_checkpoints/C2_W2_Relu-checkpoint.ipynb",
"chars": 7161,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - ReLU activation\"\n "
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/.ipynb_checkpoints/C2_W2_SoftMax-checkpoint.ipynb",
"chars": 18567,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/C2_W2_Multiclass_TF.ipynb",
"chars": 34998,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - Multi-class Classi"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/C2_W2_Relu.ipynb",
"chars": 7161,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - ReLU activation\"\n "
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/C2_W2_SoftMax.ipynb",
"chars": 18567,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/archive/.ipynb_checkpoints/C2_W2_SoftMax-Copy1-checkpoint.ipynb",
"chars": 14383,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/archive/.ipynb_checkpoints/C2_W2_SoftMax-Copy2-checkpoint.ipynb",
"chars": 14389,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/archive/C2_W2_SoftMax-Copy1.ipynb",
"chars": 14383,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/archive/C2_W2_SoftMax-Copy2.ipynb",
"chars": 14389,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n \"# Optional Lab -"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/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": "C2 - Advanced Learning Algorithms/week2/optional-labs/backprop/C2_W2_Backprop.ipynb",
"chars": 281024,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"id\": \"84d26ba3\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/backprop/C2_W2_Derivatives.ipynb",
"chars": 18882,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"id\": \"55ca2cda\",\n \"metadata\": {\n \"tags\": []\n },\n \"source\": [\n"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/backprop/lab_utils_backprop.py",
"chars": 12592,
"preview": "from sympy import *\r\nimport numpy as np\r\nimport re\r\n\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib.widgets import Te"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/optional-labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C2 - Advanced Learning Algorithms/week2/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": "C2 - Advanced Learning Algorithms/week2/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": "C2 - Advanced Learning Algorithms/week2/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": "C2 - Advanced Learning Algorithms/week2/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": "C2 - Advanced Learning Algorithms/week2/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": "C2 - Advanced Learning Algorithms/week3/C2W3A1/.ipynb_checkpoints/C2_W3_Assignment-checkpoint.ipynb",
"chars": 47249,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Advice for Applying"
},
{
"path": "C2 - Advanced Learning Algorithms/week3/C2W3A1/C2_W3_Assignment.ipynb",
"chars": 1123037,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"pycharm\": {\n \"name\": \"#%% md\\n\"\n }\n },\n \""
},
{
"path": "C2 - Advanced Learning Algorithms/week3/C2W3A1/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": "C2 - Advanced Learning Algorithms/week3/C2W3A1/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C2 - Advanced Learning Algorithms/week3/C2W3A1/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": "C2 - Advanced Learning Algorithms/week3/C2W3A1/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": "C2 - Advanced Learning Algorithms/week3/Practice-Quiz-Advice-for-applying-machine-learning/Readme.md",
"chars": 231,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/0258a26a9120b0dcc56b591705455f2cd7e26"
},
{
"path": "C2 - Advanced Learning Algorithms/week3/Readme.md",
"chars": 1268,
"preview": "### C2 - Week 3 Solutions \n\n- [Practice quiz : Advice for Applying Machine Learning](https://github.com/greyhatguy007/Ma"
},
{
"path": "C2 - Advanced Learning Algorithms/week3/practice-quiz-bias-and-variance/Readme.md",
"chars": 851,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/9d04ab60f2334c9d2915b031a358a629c8403"
},
{
"path": "C2 - Advanced Learning Algorithms/week3/practice-quiz-machine-learning-development-process/Readme.md",
"chars": 695,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/7a8ce331775aa5c6ad3e9784744650fc77958"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/C2W4A1/.ipynb_checkpoints/C2_W4_Decision_Tree_with_Markdown-checkpoint.ipynb",
"chars": 36852,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Decision Trees\\n\",\n"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/C2W4A1/C2_W4_Decision_Tree_with_Markdown.ipynb",
"chars": 40084,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Practice Lab: Decision Trees\\n\",\n"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/C2W4A1/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": "C2 - Advanced Learning Algorithms/week4/Readme.md",
"chars": 1194,
"preview": "### C2 - Week 4 Solutions \n\n\n- [Practice quiz : Decision Trees](https://github.com/greyhatguy007/Machine-Learning-Specia"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/.ipynb_checkpoints/C2_W4_Lab_01_Decision_Trees-checkpoint.ipynb",
"chars": 16245,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Ungraded Lab: Decision Trees\"\n "
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/.ipynb_checkpoints/C2_W4_Lab_02_Tree_Ensemble-checkpoint (2).ipynb",
"chars": 28765,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Ungraded Lab - Trees Ensemble\\n\","
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/.ipynb_checkpoints/C2_W4_Lab_02_Tree_Ensemble-checkpoint.ipynb",
"chars": 26099,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Optional Lab - Trees Ensemble\\n\","
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/C2_W4_Lab_01_Decision_Trees.ipynb",
"chars": 89153,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Ungraded Lab: Decision Trees\"\n "
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/C2_W4_Lab_02_Tree_Ensemble.ipynb",
"chars": 211065,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Ungraded Lab - Trees Ensemble\\n\","
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/deeplearning (2).mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/deeplearning.mplstyle",
"chars": 4889,
"preview": "# see https://matplotlib.org/stable/tutorials/introductory/customizing.html\nlines.linewidth: 4\nlines.solid_capstyle: but"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/heart.csv",
"chars": 35921,
"preview": "Age,Sex,ChestPainType,RestingBP,Cholesterol,FastingBS,RestingECG,MaxHR,ExerciseAngina,Oldpeak,ST_Slope,HeartDisease\n40,M"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/optional labs/utils.py",
"chars": 6968,
"preview": "from PIL import Image\nimport networkx as nx\nimport matplotlib.pyplot as plt\nfrom networkx.drawing.nx_pydot import graphv"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/practice-quiz-decision-tree-learning/Readme.md",
"chars": 653,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/9d6b795c6a43d44b2c498df8ad3225f8c8849"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/practice-quiz-decision-trees/Readme.md",
"chars": 209,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/9d6b795c6a43d44b2c498df8ad3225f8c8849"
},
{
"path": "C2 - Advanced Learning Algorithms/week4/practice-quiz-tree-ensembles/Readme.md",
"chars": 209,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/9d6b795c6a43d44b2c498df8ad3225f8c8849"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/Readme.md",
"chars": 5378,
"preview": "## Unsupervised Learning, Recommenders, Reinforcement Learning\n\n- [Week 1](https://github.com/greyhatguy007/Machine-Lear"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A1/.ipynb_checkpoints/C3_W1_KMeans_Assignment-checkpoint.ipynb",
"chars": 29779,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# K-means Clustering \\n\",\n \"\\n\","
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A1/C3_W1_KMeans_Assignment.ipynb",
"chars": 362101,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# K-means Clustering \\n\",\n \"\\n\","
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A2/C3_W1_Anomaly_Detection.ipynb",
"chars": 147142,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Anomaly Detection\\n\",\n \"\\n\",\n "
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A2/public_tests.py",
"chars": 3749,
"preview": "import numpy as np\nimport random\n\ndef select_threshold_test(target):\n p_val = np.array([i / 100 for i in range(30)])\n"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/C3W1A/C3W1A2/utils.py",
"chars": 1847,
"preview": "import numpy as np\nimport matplotlib.pyplot as plt\n\ndef load_data():\n X = np.load(\"data/X_part1.npy\")\n X_val = np."
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/Practice Quiz - Anomaly Detection/Readme.md",
"chars": 515,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/ea21a1bf9b251f834c72292d9d08a0f0b2cac"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/Practice Quiz - Clustering/Readme.md",
"chars": 245,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/10895418df442d0136c0d3d4d085351225999"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week1/Readme.md",
"chars": 1357,
"preview": "### C3 - Week 1 Solutions\n\n\n- [Practice quiz : Clustering](https://github.com/greyhatguy007/Machine-Learning-Specializat"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/C3_W2_Collaborative_RecSys_Assignment.ipynb",
"chars": 45440,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"id\": \"Lzk7iX_CodX6\",\n \"tags\": []\n },\n \"source"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/public_tests.py",
"chars": 3325,
"preview": "import numpy as np\n\ndef test_cofi_cost_func(target):\n num_users_r = 4\n num_movies_r = 5 \n num_features_r = 3\n\n "
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A1/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/C3_W2_RecSysNN_Assignment.ipynb",
"chars": 102158,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"id\": \"Lzk7iX_CodX6\",\n \"tags\": []\n },\n \"source"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/data/content_movie_list.csv",
"chars": 36068,
"preview": "movieId,title,genres\n4054,Save the Last Dance (2001),Drama|Romance\n4069,\"Wedding Planner, The (2001)\",Comedy|Romance\n414"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/C3W2/C3W2A2/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": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/Practice Quiz - Collaborative Filtering/Readme.md",
"chars": 528,
"preview": "\n![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/64a19b1c162b79e9d4e70fa25eeb265a6d31"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/Practice Quiz - Content-based filtering/Readme.md",
"chars": 1056,
"preview": "\n![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/64a19b1c162b79e9d4e70fa25eeb265a6d31"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/Practice Quiz - Recommender systems implementation/Readme.md",
"chars": 553,
"preview": "![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/64a19b1c162b79e9d4e70fa25eeb265a6d311"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week2/Readme.md",
"chars": 1767,
"preview": " ### C3 - Week 2 Solutions\n \n - [Practice Quiz : Collaborative Filtering](https://github.com/greyhatguy007/Machine-Learn"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/C3W3A1/C3_W3_A1_Assignment.ipynb",
"chars": 198567,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Deep Q-Learning - Lunar Lander\\n\""
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/C3W3A1/public_tests.py",
"chars": 3562,
"preview": "from tensorflow.keras.activations import relu, linear\nfrom tensorflow.keras.layers import Dense\nfrom tensorflow.keras.op"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/C3W3A1/utils.py",
"chars": 4912,
"preview": "import base64\nimport random\nfrom itertools import zip_longest\n\nimport imageio\nimport IPython\nimport matplotlib.pyplot as"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/Practice Quiz - Continuous state spaces/Readme.md",
"chars": 266,
"preview": "\n![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/7ed64bc6aacf3c7dfb98464e0df9428f1726"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/Practice Quiz - Reinforcement learning introduction/Readme.md",
"chars": 556,
"preview": "\n![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/045f46e1e29d1a901c9ae94c7bbb448b8905"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/Practice Quiz - State-action value function/Readme.md",
"chars": 270,
"preview": "\n![](https://github.com/greyhatguy007/Machine-Learning-Specialization-Coursera/blob/513dbb63423fbc3033a47525470c62a21205"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/Readme.md",
"chars": 1468,
"preview": " ### C3 - Week 3 Solutions\n \n- [Practice quiz : Reinforcement learning introduction](https://github.com/greyhatguy007/Ma"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/optional-labs/.ipynb_checkpoints/State-action value function example-checkpoint.ipynb",
"chars": 23072,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# State Action Value Function Examp"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/optional-labs/State-action value function example.ipynb",
"chars": 29309,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# State Action Value Function Examp"
},
{
"path": "C3 - Unsupervised Learning, Recommenders, Reinforcement Learning/week3/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": "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": "CONTRIBUTING.md",
"chars": 68,
"preview": "If you find it useful,\n\nDropping a *star* would be *motivational* !\n"
},
{
"path": "LICENSE",
"chars": 1063,
"preview": "MIT License\n\nCopyright (c) 2022 Ritvik\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof "
},
{
"path": "README.md",
"chars": 24012,
"preview": "# Machine Learning Specialization Coursera\n\n\n\n\nContains Solutions and Notes for the [Machi"
}
]
// ... and 21 more files (download for full content)
About this extraction
This page contains the full source code of the greyhatguy007/Machine-Learning-Specialization-Coursera GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 213 files (69.8 MB), approximately 7.3M tokens, and a symbol index with 371 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.