Coursera Deep Learning Specialization

Description

This repository contains all source code and lecture notes of the Deep Learning Specialization of Andrew Ng on Coursera.

Contents

File / folder	Description
01_neural_networks_and_deep_learning	This folder contains the source code as well as lecture notes for the "Neural Networks and Deep Learning" course. The source code includes: A Jupyter notebook for numpy basics.A Jupyter notebook for building a logistic regression model as a neural network with numpy.A Jupyter notebook for building a 3-layer neural network with numpy to classify different generated datasets.A Jupyter notebook for building deep neural networks with numpy.A Jupyter notebook for building a deep neural network with numpy to classify images into cat and non-cat images. Key concepts covered in this course are: Understand the major trends driving the rise of deep learning.Be able to explain how deep learning is applied to supervised learning.Understand what are the major categories of models (such as CNNs and RNNs), and when they should be applied.Be able to recognize the basics of when deep learning will (or will not) work well.Build a logistic regression model, structured as a shallow neural network.Implement the main steps of an ML algorithm, including making predictions, derivative computation, and gradient descent.Implement computationally efficient, highly vectorized, versions of models.Understand how to compute derivatives for logistic regression, using a backpropagation mindset.Become familiar with Python and Numpy.Work with iPython Notebooks.Be able to implement vectorization across multiple training examples.Understand hidden units and hidden layers.Be able to apply a variety of activation functions in a neural network.Build your first forward and backward propagation with a hidden layer.Apply random initialization to your neural network.Become fluent with Deep Learning notations and Neural Network Representations.Build and train a neural network with one hidden layer.See deep neural networks as successive blocks put one after each other.Build and train a deep L-layer Neural Network.Analyze matrix and vector dimensions to check neural network implementations.Understand how to use a cache to pass information from forward propagation to back propagation.Understand the role of hyperparameters in deep learning.
02_improving_dnns_with_hyperparameter_tuning _regularization_and_optimization	This folder contains the source code as well as lecture notes for the "Improving DNNs with Hyperparameter Tuning, Regularization and Optimization" course. The source code includes: A Jupyter notebook for weight initialization in numpy.A Jupyter notebook for L2 and dropout regularization in numpy.A Jupyter notebook for gradient checking.A Jupyter notebook for comparison of different optimizers.A Jupyter notebook containing a tensorflow tutorial. Key concepts covered in this course are: Recall that different types of initializations lead to different results.Recognize the importance of initialization in complex neural networks.Recognize the difference between train/dev/test sets.Diagnose the bias and variance issues in your model.Learn when and how to use regularization methods such as dropout or L2 regularization.Understand experimental issues in deep learning such as Vanishing or Exploding gradients and learn how to deal with them.Use gradient checking to verify the correctness of your backpropagation implementation.Remember different optimization methods such as (Stochastic) Gradient Descent, Momentum, RMSProp and Adam.Use random minibatches to accelerate the convergence and improve the optimization.Know the benefits of learning rate decay and apply it to your optimization.Master the process of hyperparameter tuning.
03_structuring_machine_learning_projects	This folder contains the lecture notes for the "Structuring Machine Learning Projects" course. There were no coding exercises in this course. Key concepts covered in this course are: Understand why Machine Learning strategy is important.Apply satisficing and optimizing metrics to set up your goal for ML projects.Choose a correct train/dev/test split of your dataset.Understand how to define human-level performance.Use human-level performance to define your key priorities in ML projects.Take the correct ML Strategic decision based on observations of performances and dataset.Understand what multi-task learning and transfer learning are.Recognize bias, variance and data-mismatch by looking at the performances of your algorithm on train/dev/test sets.
04_convolutional_neural_networks	This folder contains the source code as well as lecture notes for the "Convolutional Neural Networks" course. This includes juypter notebooks for building a convnet in numpy, for building a convnet with tensorflow, for a keras tutorial and for face recognition. The source code includes: A Jupyter notebook for building a convolutional neural network in numpy.A Jupyter notebook for building a convolutional neural network with tensorflow.A Jupyter notebook containing a keras tutorial.A Jupyter notebook for building a residual neural network with keras.A Jupyter notebook for car detection using the YOLO algorithm.A Jupyter notebook for art generation with neural style transfer.A Jupyter notebook for face recognition using keras. Key concepts covered in this course are: Understand the convolution operation.Understand the pooling operation.Remember the vocabulary used in convolutional neural networks (padding, stride, filter, ...).Build a convolutional neural network for image multi-class classification.Understand multiple foundational papers of convolutional neural networks.Analyze the dimensionality reduction of a volume in a very deep network.Understand and implement a residual network.Build a deep neural network using Keras.Implement a skip-connection in your network.Clone a repository from github and use transfer learning.Understand the challenges of Object Localization, Object Detection and Landmark Finding.Understand and implement non-max suppression.Understand and implement intersection over union.Understand how we label a dataset for an object detection application.Remember the vocabulary of object detection (landmark, anchor, bounding box, grid, ...).Discover how CNNs can be applied to multiple fields, including art generation and face recognition. Implement your own algorithm to generate art and recognize faces.
05_sequence_models	This folder contains the source code as well as lecture notes for the "Sequence Models" course. The source code includes: A Jupyter notebook containing forward and backward prop of RNNs and LSTMs in numpy.A Jupyter notebook for building a character level language model with a RNN implemented in numpy.A Jupyter notebook for building a jazz improvisation model with a LSTM implemented in keras.A Jupyter notebook covering Glove word embeddings and operations such as cosine similarity on top of these embeddings.A Jupyter notebook to emojify text with Glove word embeddings and keras LSTMs.A Jupyter notebook to do neural machine translation with attention models based on keras LSTMs.A Jupyter notebook for trigger word detection with keras 1d convolutional and GRU layers. Key concepts covered in this course are: Learn about recurrent neural networks. This type of model has been proven to perform extremely well on temporal data. It has several variants including LSTMs, GRUs and Bidirectional RNNs.Natural language processing with deep learning is an important combination. Using word vector representations and embedding layers you can train recurrent neural networks with outstanding performances in a wide variety of industries. Examples of applications are sentiment analysis, named entity recognition and machine translation.Sequence models can be augmented using an attention mechanism. This algorithm will help your model understand where it should focus its attention given a sequence of inputs. This week, you will also learn about speech recognition and how to deal with audio data.
README.md	This README file.

Installing the Conda Environment and Using it in Jupyter Notebook

Available Environments

ENVIRONMENT_NAME	FILE_NAME	DESCRIPTION
nndlspec	nndlspec.yml	Environment file for 01_neural_networks_and_deep_learning
improvdlspec	improvdlspec.yml	Environment file for 02_improving_dnns_with_hyperparameter_tuning_regularization_and_optimization
cnndlspec	cnndlspec.yml	Environment file for 04_convolutional_neural_networks
smdlspec	smdlspec.yml	Environment file for 05_sequence_models

Installation Instructions

1. conda env create -f <FILE_NAME>
2. conda activate <ENVIRONMENT_NAME>
3. python -m ipykernel install --user --name=<ENVIRONMENT_NAME>
4. Change kernel to <ENVIRONMENT_NAME> in Jupyter Notebook (see screenshot)

Sources & Links

1. Download source files from Coursera: https://www.coursera.org/learn/neural-networks-deep-learning/discussions/forums/a-1G6KlmEeeYBA47k-OCuA/threads/LTMmAazcEemTxQ73F53h-A
2. Git Large File Storage: https://git-lfs.github.com/