Discover fundamental deep learning concepts, master coding models using NumPy and Keras, and test your knowledge with quizzes and coding challenges. Gain insights into effective deep learning techniques.

Dockerfile.tar.gz

keras python

keras python - using models

This beginner level and highly comprehensive course is intended for learners who are familiar with Python programming. You will become familiar with the fundamental concepts and terminologies used in deep learning. In addition, this course will help you understand the importance of deep learning techniques. You will examine simple models like perceptron before learning more complex yet powerful deep learning models. The course will provide hands-on practical knowledge of how to code simple and complex deep learning models in NumPy, a powerful Python library and Keras, a cutting-edge library for deep learning in Python. You can test your knowledge with the quizzes that are provided at the end of every lesson and coding challenges that will help you gain a higher understanding. By the end of the course, you should have a general understanding of the basics in deep learning and you will be equipped with the right tools to learn more advanced concepts.

A Beginner's Guide to Deep Learning


# Exploratory data analysis
We have two features X1 and X2 and a label. Each feature has ten data points and the label is 0 or 1. Make a decision boundary that separates the two classes.
Let's look at the #concept=Dataset#dataset.#concept#


> 📝 Note: Remember, we can only apply the perceptron algorithm if the data is linearly separable. For this, we need to draw the points on the graph to visualize the data.

Draw the data points on the #concept=EDA#graph.#concept#





 

import numpy as np

def sigmoid(x): # sigmoid activation function
    """The sigmoid activation function on the input x"""
    return 1 / (1 + np.exp(-x))


def forward_propagation(input_data, weights, bias):
   """
    Computes the forward propagation operation of a perceptron and 
    returns the output after applying the sigmoid activation function
   """
   # take the dot product of input and weight and add the bias
   return sigmoid(np.dot(input_data, weights) + bias) # the perceptron equation
 
def calculate_error(Y, Y_predicted):
   """Computes the binary cross entropy error"""
   # the cross entropy error
   return - Y * np.log(Y_predicted) - (1 - Y) * np.log(1 - Y_predicted)
 
def gradient(target, actual, X):
   """"Gradient of weights and bias"""
   dW = - (target - actual) * X # gradient of weights
   db = target - actual # gradient of bias
   return dW, db
 
def update_parameters(W, b, dW, db, learning_rate):
   """Updating the weights and bias value"""
   W = W - dW * learning_rate # update weight
   b = b - db * learning_rate # update learning rate
   return W, b
 
def train(X, Y, weights, bias, epochs, learning_rate):
   """Training the perceptron using stochastic update"""
   sum_error = 0.0
   for i in range(epochs): # outer loop iterates epoch times
       for j in range(len(X)): # inner loop iterates length of X times
           Y_predicted = forward_propagation(X[j], weights.T, bias) # predicted label
           sum_error = sum_error + calculate_error (Y[j], Y_predicted) # compute error
           dW, db = gradient(Y[j], Y_predicted, X[j]) # find gradient
           weights, bias = update_parameters(weights, bias , dW, db, learning_rate) # update parameters
       print("epochs:", i, "error:", sum_error)  
       sum_error = 0 # re-intialize sum error at the end of each epoch
   return weights, bias
 
# Initialize parameters 
# declaring two data points
X = np.array(
   [[2.78, 2.55],
	[1.46, 2.36],
	[3.39, 4.40],
	[1.38, 1.85],
	[3.06, 3.00],
	[7.62, 2.75],
	[5.33, 2.08],
	[6.92, 1.77],
	[8.67, -0.24],
	[7.67, 3.50]]) 

Y = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) # actual label
weights = np.array([0.0, 0.0]) # weights of perceptron
bias = 0.0 # bias value
learning_rate = 0.1 # learning rate
epochs = 10 # set epochs
print("Before training")
print("weights:", weights, "bias:", bias)

weights, bias = train(X, Y, weights, bias, epochs, learning_rate) # train the function

print("\nAfter training")
print("weights:", weights, "bias:", bias)
# Predict values
predicted_labels = forward_propagation(X, weights.T, bias)
print("Target labels:  ", Y)
print("Predicted label:", (predicted_labels > 0.5) * 1)


# Explanation

## Initialization parameters
The table summarizes the initialized parameters:
|**Variables**| **Definition**|   
|---|---|
|`X`| An array of input data features of size 10 * 2|
|`Y`| The output labels of size 10 * 1|
|`weights`| An array of weights of size 1 * 2 initialized with 0|
|`bias`| The bias initialized with 0.1|
|`learning_rate`| The learning rate initialized with 0.1|
|`epochs`| The epochs initialized with 10|

After initializing the parameters, the perceptron is trained by calling the `train` function.

## Training the perceptron
**`train` function:**

- It takes the features `X`, labels `Y`, `weights`, `bias`, and `learning_rate`.
- A nested `for` loop executes with the outer loop that is initialized with `epochs`. The inner loop is initialized with the length of training examples `len(X)`. We update the weights and bias after iterating over a single training example.
Within the inner iteration:
     -  Calls the `forward propagation` to compute the predicted value and saves the return value in `Y_predicted`.
     - Calls the `compute_error` function to calculate error in each epoch and saves the value in `sum_error`.
     - Calls the `gradient` function to compute the gradient of the error with respect to the weight and bias.
     -  Calls the `update_parameters` function that returns the updated value of weights and bias.


**`forward_propagation` function:** 

- It takes in input variable `X` and `weights`, then calculates the dot product using `np.dot` and adds the bias  to compute the weighted sum. 
- It applies the `sigmoid` to the computed weighted sum.

**`calculate_error` function**

- The function takes in the actual label `y` and the predicted value `y_predicted` (after applying the sigmoid activation function) and returns the value of the binary cross-entropy loss.


**`gradient` function:**

- The function takes in the actual label `Y`, the predicted value `Y_predicted`, and input value `X`.
It calculates error by taking the difference between target and output. 
- It computes the derivative of error w.r.t weight `dW` by taking the product of error and input `X`.
- The derivative of error w.r.t bias `db` is the error.

**`update_parameters` function:**

- The function takes in the parameters, weights `W`, and bias `b` along with their derivatives `W` and `db` respectively and applies the update rule.

- This method of updating weights is known as **Stochastic Gradient Descent**.

The following illustration will help you visualize Stochastic Gradient Descent:

> 📝 For simplicity, we have considered only two data points.

Learn to code the perceptron trick using the Stochastic Gradient Descent.

✨Before We Begin

✨Introduction to Deep Learning

✨Simple Perceptron Models in NumPY

✨Towards Deep Neural Networks in NumPY

🖥️ Project: Build a Letter Classification Model

Deep Learning in NumPy Exam

✨Building Deep Learning Models with Keras

✨Fine-tune Keras Model

🖥️ Project: Build a Digit Recognition Model

✨Conclusion

Deep Learning in Keras Exam

Gradient Descent: The Stochastic Update

Exploratory data analysis