¿Qué es el aprendizaje profundo? Tutorial sobre aprendizaje profundo

Share on facebook
Share on twitter
Share on linkedin
Share on telegram
Share on whatsapp

Contenidos

Este artículo fue publicado como parte del Blogatón de ciencia de datos.

La guía es principalmente para principiantes, y trataré de definir y enfatizar los temas tanto como pueda. Dado que el aprendizaje profundo es un tema muy grande, dividiría todo el tutorial en pocas partes. Asegúrese de leer las otras partes si encuentra útil esta.

Contenido

1. Introducción

  • ¿Qué es el aprendizaje profundo?
  • ¿Por qué Deep Learning?
  • ¿Qué cantidad de datos es grande?
  • Campos donde se utiliza el aprendizaje profundo
  • Diferencia entre Deep Learning y Machine Learning

2) Importar las bibliotecas necesarias

3) Resumen

4) Regresión logística

  • Grafo computacional
  • Inicializando parámetros
  • Propagación hacia adelante
  • Optimización con Gradient Descent

5) Regresión logística con Sklearn

6) Notas finales

Introducción

¿Qué es el aprendizaje profundo?

  • Es un subcampo del aprendizaje automático, inspirado en las neuronas biológicas del cerebro y traduciéndolo a redes neuronales artificiales con aprendizaje de representación.

¿Por qué el aprendizaje profundo?

  • Cuando aumenta el volumen de datos, las técnicas de aprendizaje automático, sin importar cuán optimizadas sean, comienzan a volverse ineficientes en términos de rendimiento y precisión, mientras que el aprendizaje profundo funciona mucho mejor en tales casos.

¿Qué cantidad de datos es grande?

  • Bueno, no se puede cuantificar un umbral para que los datos se consideren grandes, pero, intuitivamente, digamos que una muestra de un millón podría ser suficiente para decir «Es grande» (aquí es donde Michael Scott habría pronunciado sus famosas palabras «Eso es lo que ella dijo»).

Campos donde se usa DL

  • Clasificación de imágenes, reconocimiento de voz, PNL (procesamiento del lenguaje natural), sistemas de recomendación, etc.

Diferencia entre aprendizaje profundo y aprendizaje automático

  • El aprendizaje profundo es un subconjunto del aprendizaje automático.
  • En Machine Learning, las funciones se proporcionan manualmente.
  • Mientras que Deep Learning aprende funciones directamente de los datos.
21745d3-1394254
Fuente de la imagen: Kaggle

Usaremos el Conjunto de datos de dígitos en lenguaje de señas que está disponible en Kaggle aquí. Ahora comencemos.

Importación de bibliotecas necesarias

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
# Input data files are available in the "../input/" directory.
# import warnings
import warnings
# filter warnings
warnings.filterwarnings('ignore')
from subprocess import check_output
print(check_output(["ls", "../input"]).decode("utf8"))
# Any results you write to the current directory are saved as output.
78581d4-7550372

Resumen de los datos

  • Hay 2062 imágenes de dígitos en lenguaje de señas en este conjunto de datos.
  • Dado que hay 10 dígitos del 0 al 9, hay 10 imágenes de señales únicas.
  • Al principio, solo usaremos 0 y 1 (para que sea simple para los estudiantes)
  • En los datos, el signo de la mano para 0 está entre los índices 204 y 408. Hay 205 muestras para 0.
  • Además, el signo de la mano para 1 está entre los índices 822 y 1027. Hay 206 muestras.
  • Por lo tanto, usaremos 205 muestras de cada clase (Nota: en realidad, 205 muestras son mucho menos para un modelo de Deep Learning adecuado, pero como se trata de un tutorial, podemos ignorarlo),

Ahora prepararemos nuestras matrices X e Y, donde X es nuestra matriz de imágenes (características) e Y es nuestra matriz de etiquetas (0 y 1).

# load data set
x_l = np.load('../input/Sign-language-digits-dataset/X.npy')
Y_l = np.load('../input/Sign-language-digits-dataset/Y.npy')
img_size = 64
plt.subplot(1, 2, 1)
plt.imshow(x_l[260].reshape(img_size, img_size))
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(x_l[900].reshape(img_size, img_size))
plt.axis('off')
12974d5-4372646
# Join a sequence of arrays along an row axis.
# from 0 to 204 is zero sign and from 205 to 410 is one sign
X = np.concatenate((x_l[204:409], x_l[822:1027] ), axis=0)
z = np.zeros(205)
o = np.ones(205)
Y = np.concatenate((z, o), axis=0).reshape(X.shape[0],1)
print("X shape: " , X.shape)
print("Y shape: " , Y.shape)
53633d6-5643002

Para crear nuestra matriz X, primero dividimos y concatenamos nuestros segmentos de imágenes de signos de mano de 0 y 1 del conjunto de datos a la matriz X. A continuación, hacemos algo similar con Y, pero usamos las etiquetas en su lugar.

1) Entonces vemos que la forma de nuestra matriz X es (410, 64, 64)

  • El 410 significa 205 imágenes de 0, 205 imágenes de 1.
  • el 64 significa que el tamaño de nuestras imágenes es de 64 x 64 píxeles.

2) La forma de Y es (410,1), por lo tanto, 410 unos y ceros.

3) Ahora dividimos X e Y en trenes y conjuntos de prueba.

  • tren = 75%, tren = 15%
  • random_state = Utiliza una semilla en particular mientras se aleatoriza, por lo tanto, si la celda se ejecuta varias veces, el número aleatorio generado no cambia cada vez. La misma distribución de prueba y tren se crea cada vez.
# Then lets create x_train, y_train, x_test, y_test arrays
from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.15, random_state=42)
number_of_train = X_train.shape[0]
number_of_test = X_test.shape[0]

Tenemos una matriz de entrada tridimensional, por lo que tenemos que aplanarla a 2D para alimentar nuestro primer modelo de aprendizaje profundo. Como y ya es 2D, lo dejamos tal como está.

X_train_flatten = X_train.reshape(number_of_train,X_train.shape[1]*X_train.shape[2])
X_test_flatten = X_test .reshape(number_of_test,X_test.shape[1]*X_test.shape[2])
print("X train flatten",X_train_flatten.shape)
print("X test flatten",X_test_flatten.shape)
42507d7-4429746

Ahora tenemos un total de 348 imágenes, cada una con 4096 píxeles en la matriz de entrenamiento X. Y 62 imágenes de la misma densidad de píxeles 4096 en la matriz de prueba. Ahora transponemos las matrices. Esta es solo una elección personal y verá en los próximos códigos por qué lo digo.

x_train = X_train_flatten.T
x_test = X_test_flatten.T
y_train = Y_train.T
y_test = Y_test.T
print("x train: ",x_train.shape)
print("x test: ",x_test.shape)
print("y train: ",y_train.shape)
print("y test: ",y_test.shape)
14232d8-7233833

Así que ahora hemos terminado con la preparación de nuestros datos requeridos. Así es como se ve:

32686d9-8967079

Ahora nos familiarizaremos con uno de los modelos básicos de Dl, llamado Regresión logística.

Regresión logística

Cuando se habla de clasificación binaria, el primer modelo que me viene a la mente es la regresión logística. Pero uno podría preguntarse ¿cuál es el uso de la regresión logística en el aprendizaje profundo? La respuesta es simple, ya que la regresión logística es una red neuronal simple. Los términos red neuronal y aprendizaje profundo van de la mano. Para comprender la regresión logística, primero tenemos que aprender acerca de las gráficas computacionales.

Gráfico de cálculo

Los gráficos computacionales pueden considerarse una forma pictórica de representar expresiones matemáticas. Entendamos eso con un ejemplo. Supongamos que tenemos una expresión matemática simple como:

c = ( a2 + b2 ) 1/2

Su gráfico computacional será:

41370d10-7649046

Fuente de la imagen: Autor

Ahora veamos un gráfico computacional de regresión logística:

36797d11-7614198

Fuente de la imagen: conjunto de datos de Kaggle

  • Los pesos y el sesgo se denominan parámetros del modelo.
  • Los pesos representan los coeficientes de cada píxel.
  • El sesgo es la intersección de la curva formada al trazar parámetros frente a etiquetas.
  • Z = (px1 * wx1) + (px2 * wx2) +…. + (px4096 * wx4096)
  • y_head = sigmoid_funtion (Z)
  • Lo que hace la función sigmoidea es esencialmente escalar el valor de Z entre 0 y 1, por lo que se convierte en una probabilidad.

¿Por qué utilizar la función sigmoidea?

  • Nos da un resultado probabilístico.
  • Dado que es un derivado, podemos usarlo en el algoritmo de descenso de gradiente.

Ahora examinaremos en detalle cada uno de los componentes del gráfico computacional anterior.

Parámetros de inicialización

37457d12-9554314

Fuente de imagen: Documentos de Microsoft

Cada píxel tiene su propio peso. Pero la pregunta es ¿cuáles serán sus pesos iniciales? Hay varias técnicas para hacer eso que cubriré en la parte 2 de este artículo, pero por ahora, podemos inicializarlas usando cualquier valor aleatorio, digamos 0.01.

La forma de la matriz de pesos será (4096, 1), ya que hay un total de 4096 píxeles por imagen, y deje que el sesgo inicial sea 0.

# lets initialize parameters
# So what we need is dimension 4096 that is number of pixels as a parameter for our initialize method(def)
def initialize_weights_and_bias(dimension):
    w = np.full((dimension,1),0.01)
    b = 0.0
    return w, b
w,b = initialize_weights_and_bias(4096)

Propagación hacia adelante

Todos los pasos desde los píxeles hasta la función de coste se denominan propagación hacia adelante.

Para calcular Z usamos la fórmula: Z = (wT) x + b. donde x es la matriz de píxeles, w pesos y b es el sesgo. Después de calcular Z, lo introducimos en la función sigmoidea que devuelve y_head (probabilidad). Después de eso, calculamos la función de pérdida (error).

La función de costo es la suma de todas las pérdidas y penaliza al modelo por las predicciones incorrectas. Así es como nuestro modelo aprende los parámetros.

# calculation of z
#z = np.dot(w.T,x_train)+b
def sigmoid(z):
    y_head = 1/(1+np.exp(-z))
    return y_head
y_head = sigmoid(0)
y_head
> 0.5

La expresión matemática de la función de pérdida (log) es:

58997d13-6900746

Como dije anteriormente, lo que esencialmente hace la función de pérdida es penalizar las predicciones incorrectas. aquí está el código para la propagación hacia adelante:

# Forward propagation steps:
# find z = w.T*x+b
# y_head = sigmoid(z)
# loss(error) = loss(y,y_head)
# cost = sum(loss)
def forward_propagation(w,b,x_train,y_train):
    z = np.dot(w.T,x_train) + b
    y_head = sigmoid(z) # probabilistic 0-1
    loss = -y_train*np.log(y_head)-(1-y_train)*np.log(1-y_head)
    cost = (np.sum(loss))/x_train.shape[1]      # x_train.shape[1]  is for scaling
    return cost

Optimización con Gradient Descent

43267d13-9574827

Fuente de la imagen: Coursera

Nuestro objetivo es encontrar los valores de nuestros parámetros para los cuales, la función de pérdida es el mínimo. La ecuación para el descenso de gradientes es:

13619d14-9845289

Donde w es el peso o el parámetro. La letra griega alfa es algo llamado tamaño escalonado. Lo que significa es el tamaño de las iteraciones que tomaremos mientras bajamos la pendiente para encontrar los mínimos locales. Y el resto es la derivada de la función de pérdida, también conocida como gradiente. El algoritmo para el descenso de gradientes es simple:

  1. Primero, tomamos un punto de datos aleatorio en nuestro gráfico y encontramos su pendiente.
  2. Luego encontramos la dirección en la que disminuye la función de pérdida de valor.
  3. Actualice los pesos usando la fórmula anterior. (Este método también se llama retropropagación)
  4. Seleccione el siguiente punto tomando un tamaño de α.
  5. Repetir.
# In backward propagation we will use y_head that found in forward progation
# Therefore instead of writing backward propagation method, lets combine forward propagation and backward propagation
def forward_backward_propagation(w,b,x_train,y_train):
    # forward propagation
    z = np.dot(w.T,x_train) + b
    y_head = sigmoid(z)
    loss = -y_train*np.log(y_head)-(1-y_train)*np.log(1-y_head)
    cost = (np.sum(loss))/x_train.shape[1]      # x_train.shape[1]  is for scaling
    # backward propagation
    derivative_weight = (np.dot(x_train,((y_head-y_train).T)))/x_train.shape[1] # x_train.shape[1]  is for scaling
    derivative_bias = np.sum(y_head-y_train)/x_train.shape[1]                 # x_train.shape[1]  is for scaling
    gradients = {"derivative_weight": derivative_weight,"derivative_bias": derivative_bias}
    return cost,gradients

Ahora actualizamos los parámetros de aprendizaje:

# Updating(learning) parameters
def update(w, b, x_train, y_train, learning_rate,number_of_iterarion):
    cost_list = []
    cost_list2 = []
    index = []
    # updating(learning) parameters is number_of_iterarion times
    for i in range(number_of_iterarion):
        # make forward and backward propagation and find cost and gradients
        cost,gradients = forward_backward_propagation(w,b,x_train,y_train)
        cost_list.append(cost)
        # lets update
        w = w - learning_rate * gradients["derivative_weight"]
        b = b - learning_rate * gradients["derivative_bias"]
        if i % 10 == 0:
            cost_list2.append(cost)
            index.append(i)
            print ("Cost after iteration %i: %f" %(i, cost))
    # we update(learn) parameters weights and bias
    parameters = {"weight": w,"bias": b}
    plt.plot(index,cost_list2)
    plt.xticks(index,rotation='vertical')
    plt.xlabel("Number of Iterarion")
    plt.ylabel("Cost")
    plt.show()
    return parameters, gradients, cost_list
parameters, gradients, cost_list = update(w, b, x_train, y_train, learning_rate = 0.009,number_of_iterarion = 200)

Hasta este punto, aprendimos nuestros parámetros. Significa que estamos ajustando los datos. En el paso de predicción, tenemos x_test como entrada y usándolo, hacemos predicciones hacia adelante.

 # prediction
def predict(w,b,x_test):
    # x_test is a input for forward propagation
    z = sigmoid(np.dot(w.T,x_test)+b)
    Y_prediction = np.zeros((1,x_test.shape[1]))
    # if z is bigger than 0.5, our prediction is sign one (y_head=1),
    # if z is smaller than 0.5, our prediction is sign zero (y_head=0),
    for i in range(z.shape[1]):
        if z[0,i]<= 0.5:
            Y_prediction[0,i] = 0
        else:
            Y_prediction[0,i] = 1

    return Y_prediction
predict(parameters["weight"],parameters["bias"],x_test)

Ahora hacemos nuestras predicciones. Pongámoslo todo junto:

def logistic_regression(x_train, y_train, x_test, y_test, learning_rate ,  num_iterations):
    # initialize
    dimension =  x_train.shape[0]  # that is 4096
    w,b = initialize_weights_and_bias(dimension)
    # do not change learning rate
    parameters, gradients, cost_list = update(w, b, x_train, y_train, learning_rate,num_iterations)
    
    y_prediction_test = predict(parameters["weight"],parameters["bias"],x_test)
    y_prediction_train = predict(parameters["weight"],parameters["bias"],x_train)

    # Print train/test Errors
    print("train accuracy: {} %".format(100 - np.mean(np.abs(y_prediction_train - y_train)) * 100))
    print("test accuracy: {} %".format(100 - np.mean(np.abs(y_prediction_test - y_test)) * 100))
    
logistic_regression(x_train, y_train, x_test, y_test,learning_rate = 0.01, num_iterations = 150)
95509d16-9154939
62658d17-4480017
24920d18-9284821

Entonces, como puede ver, incluso el modelo más fundamental de aprendizaje profundo es bastante difícil. No es fácil para ti aprender, y los principiantes a veces pueden sentirse abrumados al estudiar todo esto de una vez. Pero la cuestión es que aún no hemos tocado el aprendizaje profundo, esto es como la superficie. Hay mucho más que agregaré en la parte 2 de este artículo.

Dado que hemos aprendido la lógica detrás de la regresión logística, podemos usar una biblioteca llamada SKlearn que ya tiene muchos de los modelos y algoritmos incorporados, por lo que no tiene que comenzar todo desde cero.

Regresión logística con Sklearn

82219d20-9434379

No voy a explicar mucho en esta sección ya que conoces casi toda la lógica y la intuición detrás de la regresión logística. Si está interesado en leer sobre la biblioteca de Sklearn, puede leer la documentación oficial aquí. Aquí está el código, y estoy seguro de que se quedará atónito al ver el poco esfuerzo que requiere:

from sklearn import linear_model
logreg = linear_model.LogisticRegression(random_state = 42,max_iter= 150)
print("test accuracy: {} ".format(logreg.fit(x_train.T, y_train.T).score(x_test.T, y_test.T)))
print("train accuracy: {} ".format(logreg.fit(x_train.T, y_train.T).score(x_train.T, y_train.T)))
32351d19-6178650

¡Sí! esto es todo lo que se necesitó, ¡solo 1 línea de código!

Notas finales

Hemos aprendido mucho hoy. Pero esto es solo el principio. Asegúrese de consultar la parte 2 de este artículo. Puede encontrarlo en el siguiente enlace. Si le gusta lo que lee, puede leer algunos de los otros artículos interesantes que he escrito.

Sion | Autor en DataPeaker

Espero que hayas pasado un buen rato leyendo mi artículo. ¡¡Salud!!

Los medios que se muestran en este artículo sobre las principales bibliotecas de aprendizaje automático en Julia no son propiedad de DataPeaker y se utilizan a discreción del autor.

Suscribite a nuestro Newsletter

No te enviaremos correo SPAM. Lo odiamos tanto como tú.