Red neuronal profunda con propagación hacia adelante y hacia atrás desde cero – Python

Este artículo tiene como objetivo implementar una red neuronal profunda desde cero. Implementaremos una red neuronal profunda que contiene una capa oculta con cuatro unidades y una capa de salida. La implementación irá desde cero y se implementarán los siguientes pasos.
Algoritmo:

1. Visualizing the input data
2. Deciding the shapes of Weight and bias matrix
3. Initializing matrix, function to be used
4. Implementing the forward propagation method
5. Implementing the cost calculation
6. Backpropagation and optimizing
7. prediction and visualizing the output

Arquitectura del modelo:
La arquitectura del modelo ha sido definida por la siguiente figura donde la capa oculta usa la Tangente Hiperbólica como función de activación mientras que la capa de salida, siendo el problema de clasificación usa la función sigmoidea.

Arquitectura modelo

Pesos y sesgos:
Los pesos y el sesgo que se va a utilizar para ambas capas deben declararse inicialmente y también entre ellos los pesos se declararán aleatoriamente para evitar la misma salida de todas las unidades, mientras que el sesgo será inicializado a cero. El cálculo se realizará desde el principio y de acuerdo con las reglas que se indican a continuación, donde W1, W2 y b1, b2 son los pesos y el sesgo de la primera y segunda capa, respectivamente. Aquí A representa la activación de una capa particular.

# Package imports
import numpy as np
import matplotlib.pyplot as plt
# here planar_utils.py can be found on its github repo
from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset
# Loading the Sample data
X, Y = load_planar_dataset()
  
# Visualize the data:
plt.scatter(X[0, :], X[1, :], c = Y, s = 40, cmap = plt.cm.Spectral);

Código: inicialización de la array de peso y sesgo
Aquí está el número de unidades ocultas es cuatro, por lo tanto, la array de peso W1 tendrá la forma (4, número de características) y la array de sesgo tendrá la forma (4, 1) que después de la transmisión se sumará a la array de peso de acuerdo con la fórmula anterior. Lo mismo se puede aplicar al W2.

# X --> input dataset of shape (input size, number of examples)
# Y --> labels of shape (output size, number of examples)
  
W1 = np.random.randn(4, X.shape[0]) * 0.01
b1 = np.zeros(shape =(4, 1))
  
W2 = np.random.randn(Y.shape[0], 4) * 0.01
b2 = np.zeros(shape =(Y.shape[0], 1))

Código: Propagación directa:
ahora realizaremos la propagación directa utilizando W1, W2 y el sesgo b1, b2. En este paso, las salidas correspondientes se calculan en la función definida como forward_prop.

def forward_prop(X, W1, W2, b1, b2):
  
    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)
      
    # here the cache is the data of previous iteration
    # This will be used for backpropagation
    cache = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}
      
    return A2, cache

Código: Definición de la función de costo:

# Here Y is actual output
def compute_cost(A2, Y):
    m = Y.shape[1]
    # implementing the above formula
    cost_sum = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))
    cost = - np.sum(logprobs) / m
      
    # Squeezing to avoid unnecessary dimensions
    cost = np.squeeze(cost)
    return cost

Código: finalmente, función de retropropagación:
este es un paso muy importante, ya que implica una gran cantidad de álgebra lineal para la implementación de la retropropagación de las redes neuronales profundas. Las fórmulas para encontrar las derivadas se pueden derivar con algún concepto matemático de álgebra lineal, que no vamos a derivar aquí. Solo tenga en cuenta que dZ, dW, db son las derivadas de la función de costo con la suma ponderada, los pesos y el sesgo de las capas.

def back_propagate(W1, b1, W2, b2, cache):
   
    # Retrieve also A1 and A2 from dictionary "cache"
    A1 = cache['A1']
    A2 = cache['A2']
  
    # Backward propagation: calculate dW1, db1, dW2, db2. 
    dZ2 = A2 - Y
    dW2 = (1 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis = 1, keepdims = True)
  
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis = 1, keepdims = True)
      
    # Updating the parameters according to algorithm
    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2
  
    return W1, W2, b1, b2

Código: Entrenamiento del modelo personalizado Ahora entrenaremos el modelo usando las funciones definidas anteriormente, las épocas se pueden poner según la conveniencia y el poder de la unidad de procesamiento.

# Please note that the weights and bias are global 
# Here num_iteration is epochs
for i in range(0, num_iterations):
    
        # Forward propagation. Inputs: "X, parameters". return: "A2, cache".
        A2, cache = forward_propagation(X, W1, W2, b1, b2)
          
        # Cost function. Inputs: "A2, Y". Outputs: "cost".
        cost = compute_cost(A2, Y)
   
        # Backpropagation. Inputs: "parameters, cache, X, Y". Outputs: "grads".
        W1, W2, b1, b2 = backward_propagation(W1, b1, W2, b2, cache)
          
        # Print the cost every 1000 iterations
        if print_cost and i % 1000 == 0:
            print ("Cost after iteration % i: % f" % (i, cost))

Salida con parámetros aprendidos
Después de entrenar el modelo, tome los pesos y prediga los resultados usando la función forward_propagate anterior y luego use los valores para trazar la figura de salida. Tendrás una salida similar.

Visualización de los límites de los datos

Conclusión:
Deep Learning es un mundo en el que los tronos son capturados por aquellos que llegan a lo básico, así que trata de desarrollar los conceptos básicos tan fuerte que después, puedas ser el desarrollador de una nueva arquitectura de modelos que puede revolucionar la comunidad. .