1.1 Conceptos Básicos de las Redes Neuronales

Bienvenido al primer capítulo de "Aprendizaje Profundo Generativo Edición Actualizada: Desbloqueando el Poder Creativo de la IA y Python". En este capítulo, emprenderemos nuestro viaje hacia el fascinante mundo del aprendizaje profundo, comenzando con los conceptos básicos. El aprendizaje profundo es una subcategoría del aprendizaje automático que se enfoca en redes neuronales con muchas capas, a menudo denominadas redes neuronales profundas.

Estas redes han revolucionado numerosos campos, desde la visión por computadora y el procesamiento del lenguaje natural hasta los juegos y la robótica. Nuestro objetivo en este capítulo es proporcionar una base sólida en los principios del aprendizaje profundo, preparando el escenario para temas y aplicaciones más avanzados en capítulos posteriores.

Comenzaremos con una exploración de las redes neuronales, los bloques fundamentales del aprendizaje profundo. Comprender cómo funcionan estas redes, su arquitectura y sus procesos de entrenamiento es crucial para dominar el aprendizaje profundo.

Luego nos adentraremos en los avances recientes que han hecho del aprendizaje profundo una herramienta tan poderosa y ampliamente adoptada. Al final de este capítulo, deberías tener una comprensión clara de los conceptos básicos de las redes neuronales y estar listo para explorar modelos y técnicas más complejos.

Las redes neuronales están inspiradas en la estructura y función del cerebro humano. Consisten en nodos interconectados, o neuronas, que trabajan juntos para procesar e interpretar datos. Comencemos entendiendo los componentes clave y los conceptos de las redes neuronales.

Las redes neuronales están compuestas por nodos interconectados o "neuronas" que procesan e interpretan datos. Están estructuradas en capas: una capa de entrada, una o más capas ocultas y una capa de salida. La capa de entrada recibe los datos, las capas ocultas realizan cálculos y extraen características de los datos, y la capa de salida produce el resultado final.

Uno de los conceptos clave en las redes neuronales es el proceso de aprendizaje, que implica la propagación hacia adelante y hacia atrás. La propagación hacia adelante es el proceso donde los datos de entrada se pasan a través de la red para generar una salida. La propagación hacia atrás, por otro lado, es donde la red ajusta sus pesos basándose en el error o la diferencia entre la salida predicha y la salida real. Este ajuste se realiza mediante un método conocido como descenso de gradiente.

Las funciones de activación son otro componente crucial de las redes neuronales. Introducen no linealidad en la red, permitiéndole aprender patrones complejos. Ejemplos de funciones de activación comunes incluyen la función sigmoide, ReLU (Unidad Lineal Rectificada) y tanh.

Comprender estos fundamentos de las redes neuronales es esencial para profundizar en modelos más complejos en el aprendizaje automático y la inteligencia artificial. Estos conceptos básicos sientan las bases para explorar temas avanzados como el aprendizaje profundo, las redes neuronales convolucionales y las redes neuronales recurrentes.

1.1.1 Estructura de una Red Neuronal

Una red neuronal típicamente consta de tres tipos principales de capas:

Capa de Entrada

Esta capa recibe los datos de entrada. Cada neurona en esta capa representa una característica en el conjunto de datos de entrada. En el contexto del aprendizaje automático o las redes neuronales, la capa de entrada es la primera capa que recibe los datos de entrada para su procesamiento por las capas subsiguientes.

Cada neurona en la capa de entrada representa una característica en el conjunto de datos. Por ejemplo, si estás utilizando una red neuronal para clasificar imágenes, cada píxel en la imagen podría estar representado por una neurona en la capa de entrada. Si la imagen tiene 28x28 píxeles, la capa de entrada tendría 784 neuronas (una para cada píxel).

La capa de entrada es responsable de pasar los datos a la siguiente capa en la red neuronal, comúnmente conocida como una capa oculta. La capa oculta realiza varios cálculos y transformaciones en los datos. El número de capas ocultas y su tamaño pueden variar, y esto es lo que hace que una red sea "profunda".

El resultado de estas transformaciones se pasa luego a la capa final en la red, la capa de salida, que produce el resultado final. Para una tarea de clasificación, la capa de salida tendría una neurona para cada clase potencial, y produciría la probabilidad de que los datos de entrada pertenezcan a cada clase.

La capa de entrada en una red neuronal sirve como el punto de entrada para los datos. Recibe los datos en bruto que serán procesados e interpretados por la red neuronal.

Capas Ocultas

Estas capas realizan cálculos y extraen características de los datos de entrada. El término "profundo" en el aprendizaje profundo se refiere a redes con muchas capas ocultas.

Las capas ocultas en una red neuronal son capas entre la capa de entrada y la capa de salida, donde las neuronas artificiales toman un conjunto de entradas ponderadas y producen una salida a través de una función de activación. Ayudan en el procesamiento de datos complejos y patrones.

Las capas ocultas en una red neuronal realizan la mayor parte de los cálculos complejos requeridos por la red. Se llaman "ocultas" porque, a diferencia de las capas de entrada y salida, sus entradas y salidas no son visibles en el resultado final del modelo.

Cada capa oculta consiste en un conjunto de neuronas, donde cada neurona realiza una suma ponderada de sus datos de entrada. Los pesos son parámetros aprendidos durante el proceso de entrenamiento, y determinan la importancia de cada entrada para la salida de la neurona. El resultado de la suma ponderada se pasa luego a través de una función de activación, que introduce no linealidad en el modelo. Esta no linealidad permite que la red neuronal aprenda patrones complejos y relaciones en los datos.

El número de capas ocultas en una red neuronal y el número de neuronas en cada capa son decisiones de diseño importantes. Estos parámetros pueden impactar significativamente la capacidad del modelo para aprender de los datos y generalizar a datos no vistos. Por lo tanto, a menudo se determinan mediante experimentación y ajuste.

Las redes neuronales con muchas capas ocultas a menudo se denominan "redes neuronales profundas", y el estudio de estas redes se conoce como aprendizaje profundo. Con el advenimiento de recursos de computación más poderosos y el desarrollo de nuevas técnicas de entrenamiento, el aprendizaje profundo ha permitido avances significativos en muchas áreas de la inteligencia artificial, incluyendo el reconocimiento de imágenes y voz, el procesamiento del lenguaje natural y los juegos.

Capa de Salida

Esta capa produce la salida final de la red. En tareas de clasificación, podría representar diferentes clases. La capa de salida es la capa final en una red neuronal, que produce el resultado para las entradas dadas. Interpreta y presenta los datos computados en un formato adecuado para el problema en cuestión.

Dependiendo del tipo de problema, la capa de salida puede realizar varias tareas. Por ejemplo, en un problema de clasificación, la capa de salida podría contener tantas neuronas como el número de clases. Cada neurona produciría la probabilidad de que los datos de entrada pertenezcan a su respectiva clase. La clase con la probabilidad más alta sería la clase predicha para los datos de entrada.

En un problema de regresión, la capa de salida típicamente tiene una sola neurona. Esta neurona produciría un valor continuo correspondiente a la salida predicha.

La función de activación utilizada en la capa de salida también varía según el tipo de problema. Por ejemplo, una función de activación softmax se utiliza a menudo para problemas de clasificación multiclase, ya que produce una distribución de probabilidad sobre las clases. Para problemas de clasificación binaria, podría usarse una función de activación sigmoide, ya que produce un valor entre 0 y 1, representando la probabilidad de la clase positiva. Para problemas de regresión, a menudo se utiliza una función de activación lineal, ya que permite que la red produzca una variedad de valores.

La capa de salida juega un papel crucial en una red neuronal. Es responsable de producir los resultados finales y presentarlos de una manera adecuada para el problema en cuestión. Comprender cómo funciona la capa de salida, junto con el resto de la red, es esencial para construir y entrenar redes neuronales efectivas.

Ejemplo: Una Red Neuronal Simple

Consideremos una red neuronal simple para un problema de clasificación binaria, donde queremos clasificar datos de entrada en una de dos categorías. La red tiene una capa de entrada, una capa oculta y una capa de salida.

import numpy as np

# Sigmoid activation function
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Derivative of sigmoid function
def sigmoid_derivative(x):
    return x * (1 - x)

# Input data (4 samples, 3 features each)
inputs = np.array([[0, 0, 1],
                   [1, 1, 1],
                   [1, 0, 1],
                   [0, 1, 1]])

# Output labels (4 samples, 1 output each)
outputs = np.array([[0], [1], [1], [0]])

# Seed for reproducibility
np.random.seed(1)

# Initialize weights randomly with mean 0
weights_input_hidden = 2 * np.random.random((3, 4)) - 1
weights_hidden_output = 2 * np.random.random((4, 1)) - 1

# Training the neural network
for epoch in range(10000):
    # Forward propagation
    input_layer = inputs
    hidden_layer = sigmoid(np.dot(input_layer, weights_input_hidden))
    output_layer = sigmoid(np.dot(hidden_layer, weights_hidden_output))

    # Error calculation
    error = outputs - output_layer

    # Backward propagation
    output_layer_delta = error * sigmoid_derivative(output_layer)
    hidden_layer_error = output_layer_delta.dot(weights_hidden_output.T)
    hidden_layer_delta = hidden_layer_error * sigmoid_derivative(hidden_layer)

    # Update weights
    weights_hidden_output += hidden_layer.T.dot(output_layer_delta)
    weights_input_hidden += input_layer.T.dot(hidden_layer_delta)

print("Output after training:")
print(output_layer)

El script de ejemplo ofrece una implementación simple de una red neuronal de retroalimentación. Esta red neuronal se entrena utilizando la función de activación sigmoide y su derivada. El código puede dividirse en varias secciones, cada una sirviendo diferentes propósitos en el proceso de entrenamiento.

Primero, el script comienza importando la biblioteca numpy, que es un paquete fundamental para la computación científica en Python. Proporciona soporte para matrices, matrices y funciones matemáticas clave que son esenciales cuando se trabaja con redes neuronales.

En segundo lugar, el script define dos funciones importantes: la función sigmoide y su derivada. La función sigmoide es un tipo de función de activación, comúnmente utilizada en redes neuronales, que asigna cualquier valor de entrada a un rango entre 0 y 1. La función sigmoide es particularmente útil para problemas de clasificación binaria, donde los valores de salida pueden interpretarse como probabilidades. La función derivada sigmoide se usa en el proceso de retropropagación de la red neuronal para ayudar a optimizar los pesos del modelo.

A continuación, el script configura los datos de entrada y salida. Los datos de entrada consisten en cuatro muestras, cada una con tres características, y los datos de salida consisten en cuatro muestras, cada una con una salida. Esta es una configuración típica en el aprendizaje supervisado, donde cada muestra de entrada está asociada con una etiqueta de salida correspondiente.

Después de eso, el script inicializa los pesos para las conexiones entre las capas de entrada y ocultas, y entre las capas ocultas y de salida. Los pesos se inicializan aleatoriamente para romper la simetría durante el proceso de aprendizaje y permitir que la red neuronal aprenda un conjunto diverso de características.

El bucle principal del script es donde se lleva a cabo el entrenamiento de la red neuronal. Este bucle se ejecuta por un número de iteraciones conocido como épocas. En este caso, el script se ejecuta durante 10,000 épocas, pero este número puede ajustarse según los requisitos específicos del problema en cuestión.

El proceso de entrenamiento consiste en dos pasos principales: propagación hacia adelante y propagación hacia atrás.

Durante la propagación hacia adelante, los datos de entrada se pasan a través de la red, capa por capa, hasta que se genera una predicción de salida. El script calcula los valores para las capas ocultas y de salida aplicando los pesos a las entradas y pasando los resultados a través de la función sigmoide.

La propagación hacia atrás es la parte del entrenamiento donde la red aprende de sus errores. El script calcula la diferencia entre la salida predicha y la salida real, conocida como el error. Este error se propaga luego a través de la red, y los pesos se ajustan en consecuencia. El objetivo aquí es minimizar el error en las predicciones subsiguientes.

Los ajustes de los pesos durante la propagación hacia atrás se realizan utilizando un método llamado descenso de gradiente. Es una técnica de optimización numérica utilizada para encontrar el mínimo de una función. En este caso, se utiliza para encontrar los pesos que minimizan la función de error.

Después del proceso de entrenamiento, el script imprime la salida de la red neuronal después del entrenamiento. Esta salida proporciona las predicciones finales de la red después de haber sido entrenada con los datos de entrada.

1.1.2 Funciones de Activación

Las funciones de activación introducen no linealidad en la red, permitiéndole aprender patrones complejos. Las funciones de activación comunes incluyen:

Sigmoide

Como se vio en el ejemplo, la función sigmoide asigna valores de entrada a un rango entre 0 y 1. La sigmoide es una función matemática que tiene una curva característica en forma de S o curva sigmoide. En el aprendizaje automático, la función sigmoide se utiliza a menudo como función de activación para introducir no linealidad en el modelo y para convertir valores en un rango entre 0 y 1.

En el contexto de las redes neuronales, la función sigmoide juega un papel clave en el proceso de propagación hacia adelante. Durante este proceso, los datos de entrada pasan a través de la red capa por capa, hasta que alcanzan la capa de salida. En cada capa, los datos de entrada se ponderan y se aplica la función sigmoide al resultado, asignando la entrada ponderada a un valor entre 0 y 1. Esta salida se convierte entonces en la entrada para la siguiente capa, y el proceso continúa hasta que se produce la salida final.

La función sigmoide también es crucial en el proceso de retropropagación, que es cómo la red aprende de sus errores. Después de que se produce la salida, se calcula el error o la diferencia entre la salida predicha y la salida real.

Este error se propaga luego a través de la red, y los pesos se ajustan en consecuencia. La función sigmoide se utiliza en este proceso para calcular el gradiente del error con respecto a cada peso, lo que determina cuánto debe ajustarse cada peso.

La función sigmoide es un componente clave de las redes neuronales, permitiéndoles aprender patrones complejos y hacer predicciones precisas.

ReLU (Unidad Lineal Rectificada)

La función ReLU produce la entrada directamente si es positiva; de lo contrario, produce cero. Es ampliamente utilizada debido a su simplicidad y efectividad. ReLU, o Unidad Lineal Rectificada, es un tipo de función de activación ampliamente utilizada en redes neuronales y modelos de aprendizaje profundo. Produce la entrada directamente si es positiva; de lo contrario, produce cero.

ReLU, o Unidad Lineal Rectificada, es un tipo de función de activación ampliamente utilizada en redes neuronales y modelos de aprendizaje profundo. La función se define esencialmente como f(x) = max(0, x), lo que significa que produce la entrada directamente si es positiva; de lo contrario, produce cero.

ReLU es una parte importante de muchas redes neuronales modernas debido a su simplicidad y eficiencia. Su principal ventaja es que reduce la complejidad computacional del proceso de entrenamiento al mismo tiempo que preserva la capacidad de representar funciones complejas. Esto se debe a que la función ReLU es lineal para valores positivos y cero para valores negativos, lo que permite un aprendizaje y convergencia más rápidos de la red durante el entrenamiento.

Otro beneficio de ReLU es que ayuda a mitigar el problema del gradiente que se desvanece, un problema común en el entrenamiento de redes neuronales donde los gradientes se vuelven muy pequeños y la red deja de aprender. Esto ocurre significativamente menos con ReLU porque su gradiente es cero (para entradas negativas) o uno (para entradas positivas), lo que ayuda a la red a continuar aprendiendo.

Sin embargo, un problema potencial con ReLU es que puede llevar a neuronas muertas, o neuronas que nunca se activan y, por lo tanto, no contribuyen al proceso de aprendizaje. Esto puede ocurrir cuando las entradas a una neurona son siempre negativas, lo que resulta en una salida cero independientemente de los cambios en los pesos durante el entrenamiento. Para mitigar esto, se pueden usar variantes de la función ReLU como ReLU con filtrado (Leaky ReLU) o ReLU Paramétrica.

Tanh

La función tanh asigna valores de entrada a un rango entre -1 y 1, utilizada a menudo en capas ocultas. Tanh se refiere a la tangente hiperbólica, una función matemática que se utiliza en varios campos como la matemática, la física y la ingeniería. En el contexto del aprendizaje automático y la inteligencia artificial, se utiliza a menudo como una función de activación en redes neuronales.

Las funciones de activación son cruciales en las redes neuronales, ya que introducen no linealidad en el modelo. Esta no linealidad permite que la red aprenda de los errores y ajuste sus pesos, lo que a su vez permite que el modelo represente funciones complejas y haga predicciones precisas.

La función Tanh, como las funciones Sigmoide y ReLU, se utiliza para asignar valores de entrada a un cierto rango. Específicamente, la función Tanh asigna valores de entrada a un rango entre -1 y 1. Esto es útil en muchos escenarios, especialmente cuando el modelo necesita hacer clasificaciones binarias o multiclasificaciones.

Una ventaja de la función Tanh sobre la función Sigmoide es que está centrada en cero. Esto significa que su salida está centrada alrededor de cero, lo que puede facilitar el aprendizaje para la siguiente capa en algunos casos. Sin embargo, al igual que la función Sigmoide, la función Tanh también sufre del problema del gradiente que se desvanece, donde los gradientes se vuelven muy pequeños y la red deja de aprender.

En la práctica, la elección de la función de activación depende de los requisitos específicos del problema en cuestión y a menudo se determina mediante experimentación y ajuste.

Ejemplo:

# ReLU activation function
def relu(x):
    return np.maximum(0, x)

# Example usage of ReLU
input_data = np.array([-1, 2, -0.5, 3])
output_data = relu(input_data)
print(output_data)  # Output: [0. 2. 0. 3.]

Este ejemplo explica la función de activación ReLU (Unidad Lineal Rectificada). Esta función es una parte esencial de las redes neuronales y los modelos de aprendizaje profundo. Las funciones de activación como ReLU introducen no linealidad en estos modelos, permitiéndoles aprender patrones complejos y hacer predicciones precisas.

En la implementación, la función ReLU se define usando Python. La función se llama 'relu' y toma un parámetro 'x'. Este 'x' representa la entrada a la función ReLU, que puede ser cualquier número real.

La función usa la función máxima de numpy para devolver el máximo entre 0 y 'x'. Esta es la característica clave de la función ReLU: si 'x' es mayor que 0, devuelve 'x'; de lo contrario, devuelve 0. Por esto se llama Unidad Lineal Rectificada: rectifica o corrige las entradas negativas a cero, mientras deja las entradas positivas tal como están.

También se proporciona un ejemplo de uso de la función ReLU en el código. Se crea una matriz numpy llamada 'input_data', que contiene cuatro elementos: -1, 2, -0.5 y 3. Luego, se aplica la función ReLU a estos datos de entrada, resultando en una nueva matriz 'output_data'.

El efecto de la función ReLU se puede ver en esta salida. Los valores negativos en la matriz de entrada (-1 y -0.5) se rectifican a 0, mientras que los valores positivos (2 y 3) no se cambian. La salida final de la función ReLU es, por tanto, [0, 2, 0, 3].

Este simple ejemplo demuestra cómo funciona la función ReLU en la práctica. Es un aspecto fundamental de las redes neuronales y el aprendizaje profundo, permitiendo que estos modelos aprendan y representen funciones complejas. A pesar de su simplicidad, la función ReLU es poderosa y ampliamente utilizada en el campo del aprendizaje automático.

1.1.3 Propagación Hacia Adelante y Hacia Atrás

La propagación hacia adelante y hacia atrás son procesos fundamentales en el entrenamiento de una red neuronal, un componente central del aprendizaje profundo y la inteligencia artificial.

La propagación hacia adelante se refiere al proceso donde los datos de entrada se pasan a través de la red para generar una salida. Comienza en la capa de entrada, donde cada neurona recibe un valor de entrada. Estos valores se multiplican por sus pesos correspondientes, y los resultados se suman y pasan a través de una función de activación. Este proceso se repite para cada capa en la red hasta que alcanza la capa de salida, que produce la salida final de la red. Esta salida se compara luego con la salida real o esperada para calcular el error o la diferencia.

La propagación hacia atrás, por otro lado, es el proceso donde la red ajusta sus pesos basándose en el error calculado o la diferencia entre la salida predicha y la salida real. Este proceso comienza desde la capa de salida y trabaja de regreso hacia la capa de entrada, de ahí el término 'hacia atrás'. El objetivo de este proceso es minimizar el error en las predicciones de la red.

El ajuste de los pesos se realiza utilizando un método conocido como descenso de gradiente. Este es un método de optimización matemática que tiene como objetivo encontrar el mínimo de una función, en este caso, la función de error. Funciona calculando el gradiente o la pendiente de la función de error con respecto a cada peso, lo que indica la dirección y la magnitud del cambio que resultaría en el menor error. Los pesos se ajustan en la dirección opuesta del gradiente, descendiendo efectivamente hacia el mínimo de la función de error.

La combinación de propagación hacia adelante y hacia atrás forma un ciclo que se repite muchas veces durante el entrenamiento de una red neuronal. Cada ciclo se refiere como una época. Con cada época, los pesos de la red se ajustan para reducir el error, y con el tiempo, la red aprende a hacer predicciones precisas.

Estos procesos son los mecanismos fundamentales a través de los cuales las redes neuronales aprenden de los datos. Al ajustar sus pesos internos basados en el error de salida, las redes neuronales pueden aprender patrones complejos y relaciones en los datos, convirtiéndolas en herramientas poderosas para tareas como el reconocimiento de imágenes, el procesamiento del lenguaje natural y mucho más. Comprender estos procesos es esencial para cualquiera que desee profundizar en el campo del aprendizaje profundo y la inteligencia artificial.

Ejemplo: Propagación hacia Atrás con Descenso de Gradiente

# Learning rate
learning_rate = 0.1

# Training the neural network with gradient descent
for epoch in range(10000):
    # Forward propagation
    input_layer = inputs
    hidden_layer = sigmoid(np.dot(input_layer, weights_input_hidden))
    output_layer = sigmoid(np.dot(hidden_layer, weights_hidden_output))

    # Error calculation
    error = outputs - output_layer

    # Backward propagation
    output_layer_delta = error * sigmoid_derivative(output_layer)
    hidden_layer_error = output_layer_delta.dot(weights_hidden_output.T)
    hidden_layer_delta = hidden_layer_error * sigmoid_derivative(hidden_layer)

    # Update weights with gradient descent
    weights_hidden_output += learning_rate * hidden_layer.T.dot(output_layer_delta)
    weights_input_hidden += learning_rate * input_layer.T.dot(hidden_layer_delta)

print("Output after training with gradient descent:")
print(output_layer)

Este script de ejemplo está diseñado para entrenar una red neuronal simple usando el algoritmo de descenso de gradiente. La red neuronal está compuesta por una capa de entrada, una capa oculta y una capa de salida, y funciona de la siguiente manera:

Inicialmente, se establece la tasa de aprendizaje en 0.1. La tasa de aprendizaje es un hiperparámetro que controla cuánto se actualizan o cambian los pesos del modelo en respuesta al error estimado cada vez que se actualizan los pesos del modelo. Elegir una tasa de aprendizaje adecuada puede ser esencial para entrenar una red neuronal de manera eficiente. Una tasa de aprendizaje demasiado pequeña puede resultar en un proceso de entrenamiento largo que podría estancarse, mientras que una tasa de aprendizaje demasiado grande puede resultar en el aprendizaje de un conjunto subóptimo de pesos demasiado rápido o en un proceso de entrenamiento inestable.
Luego, la red neuronal se entrena durante 10,000 iteraciones o épocas. Una época es un paso completo a través del conjunto de datos de entrenamiento completo. Durante cada una de estas épocas, cada muestra en el conjunto de datos se expone a la red, que aprende de ella.
En cada época, el proceso comienza con la propagación hacia adelante. Los datos de entrada se pasan a través de la red, desde la capa de entrada hasta la capa oculta, y finalmente a la capa de salida. Los valores en la capa oculta se calculan aplicando los pesos a las entradas y pasando los resultados a través de la función de activación sigmoide. El mismo proceso se repite para calcular los valores en la capa de salida.
Posteriormente, se calcula el error entre las salidas predichas (la capa de salida) y las salidas reales. Este error es una medida de cuán desviadas están las predicciones de la red de los valores reales. En un escenario perfecto, el error sería cero, pero en la realidad, el objetivo es minimizar este error tanto como sea posible.
Luego, el error se propaga a través de la red, desde la capa de salida hasta la capa de entrada, en un proceso conocido como retropropagación. Durante este proceso, se calcula la derivada del error con respecto a los pesos de la red. Estas derivadas indican cuánto cambiaría el error con un pequeño cambio en los pesos.
Los pesos que conectan las neuronas en las capas oculta y de salida de la red se actualizan utilizando los errores calculados. Esto se hace utilizando el algoritmo de optimización de descenso de gradiente. Los pesos se ajustan en la dirección que más disminuye el error, que es la dirección opuesta del gradiente. La tasa de aprendizaje determina el tamaño de estos ajustes.
Finalmente, después de que la red neuronal se haya entrenado completamente, se imprime la salida de la red. Esta salida es la predicción de la red dada la entrada de datos.

Este script ofrece un ejemplo básico de cómo se puede entrenar una red neuronal usando descenso de gradiente. Demuestra conceptos clave en el entrenamiento de redes neuronales, incluyendo la propagación hacia adelante y hacia atrás, las actualizaciones de pesos usando descenso de gradiente y el uso de una función de activación sigmoide. Comprender estos conceptos es crucial para trabajar con redes neuronales y aprendizaje profundo.

1.1.4 Funciones de Pérdida

La función de pérdida, también conocida como función de costo u objetivo, mide qué tan bien coinciden las predicciones de la red neuronal con los valores objetivo reales. Es un componente crítico en el entrenamiento de redes neuronales, ya que guía el proceso de optimización. Las funciones de pérdida comunes incluyen:

Error Cuadrático Medio (MSE)

El Error Cuadrático Medio (MSE) es una medida estadística comúnmente utilizada para cuantificar la diferencia cuadrática promedio entre las observaciones reales y las predicciones hechas por un modelo o estimador. A menudo se usa en análisis de regresión y aprendizaje automático para evaluar el rendimiento de un modelo predictivo.

En el contexto del aprendizaje automático, el MSE se utiliza a menudo como una función de pérdida para problemas de regresión. El propósito de la función de pérdida es medir la discrepancia entre las salidas predichas y las salidas reales del modelo. El objetivo durante el proceso de entrenamiento de un modelo es minimizar esta función de pérdida.

El MSE calcula el promedio de los cuadrados de las diferencias entre los valores predichos y los valores reales. Esto esencialmente magnifica el impacto de los errores más grandes en comparación con los más pequeños, lo que lo hace particularmente útil cuando los errores más grandes son especialmente indeseables.

Si 'y_true' representa los valores reales y 'y_pred' representa los valores predichos, la fórmula para el MSE es:

MSE = (1/n) * Σ (y_true - y_pred)^2

Donde:

n es el número total de puntos de datos o instancias
Σ es el símbolo de sumatoria, que indica que cada diferencia cuadrática se suma
(y_true - y_pred)^2 es la diferencia cuadrática entre los valores reales y los predichos

El cuadrado es crucial ya que elimina el signo, permitiendo que la función considere solo la magnitud del error, no su dirección. Además, el cuadrado enfatiza los errores más grandes sobre los más pequeños.

El MSE es una buena opción de función de pérdida para muchas situaciones, pero puede ser sensible a los valores atípicos ya que cuadratiza los errores. Si se trata con datos que contienen valores atípicos o si la distribución de errores no es simétrica, podría ser conveniente considerar otras funciones de pérdida, como el Error Absoluto Medio (MAE) o la pérdida de Huber.

Pérdida de Entropía Cruzada

La Pérdida de Entropía Cruzada es una función de pérdida utilizada en el aprendizaje automático y la optimización. Mide la disimilitud entre la distribución de probabilidad predicha y la distribución real, utilizada típicamente en problemas de clasificación.

La Pérdida de Entropía Cruzada se usa comúnmente en problemas donde el modelo necesita predecir la probabilidad de cada uno de los diferentes resultados posibles de una distribución categórica. Es particularmente útil en el entrenamiento de modelos de clasificación multiclase en el aprendizaje profundo.

La Pérdida de Entropía Cruzada se calcula tomando el logaritmo negativo de la probabilidad predicha para la clase real. La pérdida aumenta a medida que la probabilidad predicha diverge de la etiqueta real. Por lo tanto, minimizar la Pérdida de Entropía Cruzada lleva a nuestro modelo a maximizar directamente la probabilidad de predecir la clase correcta.

Una de las ventajas significativas de usar la Pérdida de Entropía Cruzada, especialmente en el contexto de redes neuronales, es que puede acelerar el aprendizaje. En comparación con otros métodos como el Error Cuadrático Medio (MSE), se ha encontrado que la Pérdida de Entropía Cruzada permite una convergencia más rápida, lo que lleva a tiempos de entrenamiento más cortos.

Sin embargo, es importante tener en cuenta que la Pérdida de Entropía Cruzada asume que nuestro modelo produce probabilidades, lo que significa que la capa de salida de nuestra red debe ser una capa softmax o equivalente. Además, es sensible al desequilibrio en el conjunto de datos, lo que la hace menos adecuada para problemas donde las clases no están igualmente representadas.

En resumen, la Pérdida de Entropía Cruzada es una herramienta poderosa en la caja de herramientas de los practicantes del aprendizaje automático y es una función de pérdida preferida para problemas de clasificación.

Ejemplo: Pérdida de Entropía Cruzada

import numpy as np

# Example target labels (one-hot encoded)
y_true = np.array([[1, 0, 0],
                   [0, 1, 0],
                   [0, 0, 1]])

# Example predicted probabilities
y_pred = np.array([[0.7, 0.2, 0.1],
                   [0.1, 0.8, 0.1],
                   [0.2, 0.3, 0.5]])

# Cross-entropy loss calculation
def cross_entropy_loss(y_true, y_pred):
    epsilon = 1e-15  # to avoid log(0)
    y_pred = np.clip(y_pred, epsilon, 1. - epsilon)
    return -np.sum(y_true * np.log(y_pred)) / y_true.shape[0]

loss = cross_entropy_loss(y_true, y_pred)
print("Cross-Entropy Loss:", loss)

Este es un fragmento de código de ejemplo que muestra cómo calcular la pérdida de entropía cruzada en un contexto de aprendizaje automático, particularmente para problemas de clasificación. A continuación se presenta un desglose paso a paso de lo que hace el código:

La primera línea del código importa la biblioteca numpy. Numpy es una popular biblioteca de Python que proporciona soporte para arreglos y matrices grandes y multidimensionales, junto con una colección de funciones matemáticas para operar sobre estos arreglos.
A continuación, definimos las etiquetas de destino verdaderas (y_true) y las probabilidades predichas (y_pred). Estas se representan como arreglos numpy. Las etiquetas verdaderas están codificadas en one-hot, lo que significa que para cada muestra, la categoría se representa como un vector binario donde solo el índice de la categoría verdadera es 1 y el resto son 0s.
Se define la función cross_entropy_loss. Esta función calcula la pérdida de entropía cruzada dadas las etiquetas verdaderas y las probabilidades predichas.
- Dentro de la función, se define una pequeña constante epsilon para evitar tomar el logaritmo de cero, lo que resultaría en un valor indefinido. Esta es una técnica comúnmente utilizada en el aprendizaje automático para garantizar la estabilidad numérica.
- La función np.clip se usa para limitar los valores de las probabilidades predichas entre epsilon y 1. - epsilon. Esto asegura que no intentemos tomar el logaritmo de 0 o de un valor mayor a 1, lo cual no tendría sentido en el contexto de probabilidades y podría causar problemas computacionales.
- La pérdida de entropía cruzada se calcula luego usando la fórmula de entropía cruzada, que suma las etiquetas verdaderas multiplicadas por el logaritmo de las probabilidades predichas. El resultado se divide luego por el número de muestras para obtener la pérdida promedio por muestra.
- Finalmente, la función devuelve la pérdida calculada.
La función cross_entropy_loss se llama luego con y_true y y_pred como argumentos. El resultado se almacena en la variable loss.
Finalmente, la pérdida de entropía cruzada calculada se imprime en la consola.

Este fragmento de código es un ejemplo básico de cómo calcular la pérdida de entropía cruzada en Python. En la práctica, las etiquetas verdaderas y las probabilidades predichas se obtendrían de los datos reales y de las predicciones de un modelo de aprendizaje automático, respectivamente.

Calcular la pérdida es un paso crucial en el entrenamiento de modelos de aprendizaje automático, ya que proporciona una medida de qué tan bien las predicciones del modelo coinciden con los datos reales. Esto es típicamente lo que el modelo trata de minimizar durante el proceso de entrenamiento.

1.1.5 Optimizadores

Los optimizadores representan un componente crucial de los algoritmos de aprendizaje automático, particularmente en las redes neuronales. Son un tipo de algoritmos diseñados específicamente para ajustar y afinar los pesos asociados con varios nodos en la red neuronal.

Su función principal es minimizar la función de pérdida, que es un indicador de la desviación de las predicciones del modelo respecto a los valores reales. Al hacerlo, los optimizadores ayudan a mejorar la precisión de la red neuronal.

Sin embargo, es importante notar que diferentes tipos de optimizadores pueden tener niveles variados de impacto en la eficiencia del entrenamiento de la red neuronal y, consecuentemente, en el rendimiento general del modelo de aprendizaje automático. Por lo tanto, la elección del optimizador podría ser un factor significativo en la efectividad y precisión del modelo.

Optimizadores comunes incluyen:

Descenso de Gradiente

El algoritmo de optimización más simple que actualiza los pesos en la dirección del gradiente negativo de la función de pérdida. El descenso de gradiente es un algoritmo de optimización comúnmente usado en el aprendizaje automático e inteligencia artificial para minimizar una función. Se utiliza para encontrar el valor mínimo de una función, moviéndose iterativamente en la dirección del descenso más pronunciado, definido por el negativo del gradiente.

El algoritmo comienza con una estimación inicial del mínimo y actualiza iterativamente esta estimación tomando pasos proporcionales al gradiente negativo de la función en el punto actual. Este proceso continúa hasta que el algoritmo converge al verdadero mínimo de la función.

En el contexto del aprendizaje automático y profundo, el descenso de gradiente se utiliza para minimizar la función de pérdida, que mide la discrepancia entre las predicciones del modelo y los datos reales. Al minimizar esta función de pérdida, el modelo puede aprender el mejor conjunto de parámetros que hacen sus predicciones tan precisas como sea posible.

Aquí hay un esquema simplificado de cómo funciona el descenso de gradiente:

Inicializar los parámetros del modelo con valores aleatorios.
Calcular el gradiente de la función de pérdida con respecto a los parámetros del modelo.
Actualizar los parámetros tomando un paso en la dirección del gradiente negativo.
Repetir los pasos 2 y 3 hasta que el algoritmo converja al mínimo de la función de pérdida.

Hay varias variantes del descenso de gradiente, incluyendo el descenso de gradiente por lotes (Batch Gradient Descent), el descenso de gradiente estocástico (Stochastic Gradient Descent) y el descenso de gradiente por mini-lotes (Mini-Batch Gradient Descent). Estas variantes difieren principalmente en la cantidad de datos que utilizan para calcular el gradiente de la función de pérdida en cada paso.

El descenso de gradiente por lotes utiliza todo el conjunto de datos para calcular el gradiente en cada paso.
El descenso de gradiente estocástico utiliza solo un punto de datos aleatorio para calcular el gradiente en cada paso.
El descenso de gradiente por mini-lotes equilibra los dos, utilizando una pequeña muestra aleatoria de datos para calcular el gradiente en cada paso.

A pesar de su simplicidad, el descenso de gradiente es un algoritmo de optimización poderoso y eficiente que forma la base de muchos modelos de aprendizaje automático y profundo.

Descenso de Gradiente Estocástico (SGD)

Una extensión del descenso de gradiente que actualiza los pesos utilizando un subconjunto aleatorio de los datos de entrenamiento, en lugar de todo el conjunto de datos. El descenso de gradiente estocástico (SGD) es un método iterativo para optimizar una función objetivo con propiedades adecuadas. Se utiliza comúnmente en el aprendizaje automático e inteligencia artificial para entrenar modelos, particularmente en casos donde los datos son demasiado grandes para caber en memoria.

El SGD es una extensión del algoritmo de optimización de descenso de gradiente. En el descenso de gradiente estándar (o "por lotes"), el gradiente de la función de pérdida se calcula a partir de todo el conjunto de datos de entrenamiento y se utiliza para actualizar los parámetros del modelo (o pesos). Esto puede ser computacionalmente costoso para grandes conjuntos de datos e impráctico para conjuntos de datos que no caben en memoria.

En contraste, el SGD estima el gradiente a partir de una sola instancia seleccionada aleatoriamente de los datos de entrenamiento en cada paso antes de actualizar los parámetros. Esto lo hace mucho más rápido y capaz de manejar conjuntos de datos mucho más grandes.

La desventaja es que las actualizaciones son más ruidosas, lo que puede significar que el algoritmo tarde más en converger al mínimo de la función de pérdida y puede no encontrar el mínimo exacto. Sin embargo, esto también puede ser una ventaja, ya que el ruido puede ayudar al algoritmo a salir de los mínimos locales de la función de pérdida, mejorando las posibilidades de encontrar un mejor mínimo (o incluso el global).

El SGD se ha utilizado con éxito en una variedad de tareas de aprendizaje automático y es uno de los algoritmos clave que ha permitido la aplicación práctica del aprendizaje automático a gran escala. Se utiliza en una variedad de modelos de aprendizaje automático, incluyendo la regresión lineal, la regresión logística y las redes neuronales.

Adam (Adaptive Moment Estimation)

Un optimizador popular que combina las ventajas de otras dos extensiones del descenso de gradiente estocástico – AdaGrad y RMSProp. Adam es un algoritmo de optimización utilizado en el aprendizaje automático y profundo para entrenar redes neuronales. Calcula tasas de aprendizaje adaptativas para cada parámetro, mejorando la eficiencia del proceso de aprendizaje.

A diferencia del descenso de gradiente estocástico clásico, Adam mantiene una tasa de aprendizaje separada para cada peso en la red y ajusta estas tasas de aprendizaje por separado a medida que avanza el aprendizaje. Esta característica hace de Adam un optimizador eficiente, particularmente para problemas con grandes datos o muchos parámetros.

El optimizador Adam combina dos metodologías de descenso de gradiente: AdaGrad (Algoritmo de Gradiente Adaptativo) y RMSProp (Propagación de Media Cuadrada). De RMSProp, Adam toma el concepto de usar un promedio móvil de gradientes cuadrados para escalar la tasa de aprendizaje. De AdaGrad, toma la idea de usar un promedio exponencial decreciente de gradientes pasados.

Esta combinación permite a Adam manejar tanto gradientes escasos como datos ruidosos, lo que lo convierte en una herramienta de optimización poderosa para una amplia gama de problemas de aprendizaje automático.

Adam tiene varias ventajas sobre otros algoritmos de optimización utilizados en el aprendizaje profundo:

Fácil de implementar.
Eficiente computacionalmente.
Requiere poca memoria.
Invariante a la reescalación diagonal de los gradientes.
Bien adaptado para problemas grandes en términos de datos y/o parámetros.
Apropiado para objetivos no estacionarios.
Capaz de manejar gradientes escasos.
Proporciona cierta robustez al ruido.

Sin embargo, como cualquier optimizador, Adam no está exento de limitaciones. A veces puede no converger a la solución óptima bajo condiciones específicas, y sus hiperparámetros a menudo requieren ajuste para lograr los mejores resultados.

A pesar de estos posibles inconvenientes, Adam es ampliamente utilizado en el aprendizaje profundo y a menudo se recomienda como la opción predeterminada de optimizador, dada su facilidad de uso y su sólido rendimiento en una amplia gama de tareas.

Ejemplo: Uso del Optimizador Adam

import tensorflow as tf

# Sample neural network model
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(4, activation='relu', input_shape=(3,)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# Compile the model with Adam optimizer
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Sample data
inputs = np.array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
outputs = np.array([[0], [1], [1], [0]])

# Train the model
model.fit(inputs, outputs, epochs=1000, verbose=0)

# Evaluate the model
loss, accuracy = model.evaluate(inputs, outputs, verbose=0)
print("Loss:", loss)
print("Accuracy:", accuracy)

Desglosamos el script:

Importación de la biblioteca necesaria: El script comienza importando TensorFlow, que se utilizará para construir y entrenar la red neuronal.

pythonCopy code
import tensorflow as tf

Definiendo el modelo: Luego, el script define un modelo de red neuronal simple utilizando la API Keras de TensorFlow, que proporciona una interfaz de alto nivel y fácil de usar para definir y manipular modelos.

pythonCopy code
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(4, activation='relu', input_shape=(3,)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

El modelo es un modelo Secuencial, lo que significa que está compuesto por una pila lineal de capas. El modelo tiene dos capas. La primera capa es una capa Densa (totalmente conectada) con 4 neuronas y utiliza la función de activación ReLU (Rectified Linear Unit). La segunda capa también es una capa Densa, tiene una sola neurona y utiliza la función de activación sigmoide. La forma de entrada de la primera capa es 3, lo que indica que cada muestra de entrada es un arreglo de 3 números.

Compilando el modelo: Una vez definido el modelo, debe ser compilado antes de que pueda ser ejecutado. Durante la compilación, se establecen el optimizador (en este caso, 'adam'), la función de pérdida (en este caso, 'binary_crossentropy') y las métricas (en este caso, 'accuracy') para el entrenamiento.

pythonCopy code
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

Definiendo los datos de muestra: El script define algunos datos de entrada y salida de muestra para entrenar el modelo. Las entradas son un arreglo de cuatro arreglos de 3 elementos, y las salidas son un arreglo de cuatro arreglos de 1 elemento.

pythonCopy code
inputs = np.array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
outputs = np.array([[0], [1], [1], [0]])

Entrenando el modelo: Luego, el modelo se entrena utilizando los datos de muestra. El modelo se entrena durante 1000 épocas, donde una época es un pase completo a través de todo el conjunto de datos de entrenamiento.

pythonCopy code
model.fit(inputs, outputs, epochs=1000, verbose=0)

6.Evaluando el modelo: Una vez que el modelo ha sido entrenado, el script evalúa el modelo utilizando los mismos datos de muestra. Esto implica ejecutar el modelo con las entradas de muestra, comparando las salidas del modelo con las salidas de muestra y calculando un valor de pérdida y precisión. La pérdida es una medida de qué tan diferentes son las salidas del modelo de las salidas de muestra, y la precisión es una medida del porcentaje de coincidencia de las salidas del modelo con las salidas de muestra.

pythonCopy code
loss, accuracy = model.evaluate(inputs, outputs, verbose=0)
print("Loss:", loss)
print("Accuracy:", accuracy)

El ejemplo demuestra cómo definir un modelo, compilarlo, entrenarlo con datos de muestra y luego evaluar el modelo entrenado. A pesar de su simplicidad, el script cubre muchos de los aspectos clave del uso de redes neuronales, lo que lo convierte en un buen punto de partida para aquellos que son nuevos en el campo.

1.1.6 Sobreajuste y Regularización

El sobreajuste es un problema común en el aprendizaje automático y ocurre cuando una red neuronal u otro modelo aprende demasiado del ruido o las fluctuaciones aleatorias presentes en los datos de entrenamiento. Esta información sobreaprendida no representa los patrones o tendencias subyacentes reales en los datos y, como resultado, el modelo tiene un rendimiento deficiente al generalizar su conocimiento a nuevos datos no vistos.

En esencia, el modelo se vuelve demasiado especializado en los datos de entrenamiento, hasta el punto de que no puede aplicar efectivamente su aprendizaje a otros conjuntos de datos similares. Para combatir este problema, se emplean varias técnicas de regularización.

Estas técnicas funcionan al agregar una penalización a la función de pérdida que el modelo utiliza para aprender de los datos, limitando efectivamente la complejidad del modelo y, por lo tanto, evitando que aprenda el ruido en los datos de entrenamiento. Esto, a su vez, ayuda a mejorar la capacidad del modelo para generalizar y aplicar su aprendizaje a nuevos datos, mejorando su rendimiento general y utilidad.

Las técnicas de regularización comunes incluyen:

Regularización L2 (Ridge)

Agrega una penalización igual a la suma de los pesos cuadrados a la función de pérdida. La regularización L2, también conocida como Regresión Ridge, es una técnica utilizada en el aprendizaje automático para prevenir el sobreajuste de los modelos. Lo hace agregando una penalización equivalente al cuadrado de la magnitud de los coeficientes a la función de pérdida.

La regularización L2 funciona al desalentar que los pesos alcancen valores grandes al agregar una penalización proporcional al cuadrado de los pesos a la función de pérdida. Esto ayuda a prevenir que el modelo dependa demasiado de una sola característica, lo que conduce a un modelo más equilibrado y generalizado.

La regularización L2 es particularmente útil al tratar con multicolinealidad (alta correlación entre las variables predictoras), un problema común en los conjuntos de datos del mundo real. Al aplicar la regularización L2, el modelo se vuelve más robusto y menos sensible a las características individuales, mejorando así su capacidad de generalización.

En el contexto de las redes neuronales, el peso de cada neurona se actualiza de una manera que no solo minimiza el error, sino que también mantiene los pesos tan pequeños como sea posible, lo que resulta en un modelo más simple y menos complejo.

Uno de los otros beneficios de usar la regularización L2 es que no conduce a la eliminación completa de ninguna característica, ya que no fuerza a ningún coeficiente a cero, sino que los distribuye uniformemente. Esto es particularmente útil cuando no queremos descartar completamente ninguna característica.

A pesar de sus beneficios, la regularización L2 introduce un hiperparámetro adicional lambda (λ) que controla la fuerza de la regularización, y que necesita ser determinado. Un valor grande de λ puede llevar a un subajuste, donde el modelo es demasiado simple para capturar patrones en los datos. Por el contrario, un valor pequeño de λ puede todavía llevar a un sobreajuste, donde el modelo es demasiado complejo y ajusta el ruido en los datos en lugar de la tendencia subyacente.

Por lo tanto, el valor adecuado de λ se encuentra típicamente mediante validación cruzada u otros métodos de ajuste. A pesar de este paso adicional, la regularización L2 sigue siendo una herramienta poderosa en el conjunto de herramientas del practicante de aprendizaje automático para crear modelos robustos y generalizables.

Dropout: Elimina aleatoriamente una fracción de las neuronas durante el entrenamiento para evitar que la red se vuelva demasiado dependiente de neuronas específicas, mejorando así la generalización.

Dropout es una técnica utilizada en el aprendizaje automático y las redes neuronales para prevenir el sobreajuste, que es la creación de modelos que están demasiado especializados en los datos de entrenamiento y tienen un rendimiento deficiente en datos nuevos. Funciona ignorando aleatoriamente, o "eliminando", algunas de las neuronas durante el proceso de entrenamiento.

Al hacer esto, Dropout evita que la red se vuelva demasiado dependiente de neuronas específicas, fomentando un esfuerzo más distribuido y colaborativo entre las neuronas para aprender de los datos. De esta manera, mejora la capacidad de la red para generalizar y rendir bien en datos nuevos no vistos.

Dropout se implementa seleccionando aleatoriamente una fracción de las neuronas en la red y eliminándolas temporalmente junto con todas sus conexiones entrantes y salientes. La tasa a la que se eliminan las neuronas es un hiperparámetro y típicamente se establece entre 0.2 y 0.5.

Ejemplo: Aplicando Dropout

Aquí hay un ejemplo de código en Python de cómo aplicar Dropout en una red neuronal utilizando la API Keras de TensorFlow:

import tensorflow as tf

# Sample neural network model with Dropout
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.5),  # Dropout layer with 50% rate
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Assuming 'x_train' and 'y_train' are the training data and labels
# Train the model
model.fit(x_train, y_train, epochs=10, batch_size=32, verbose=1)

# Evaluate the model
loss, accuracy = model.evaluate(x_test, y_test, verbose=0)
print("Loss:", loss)
print("Accuracy:", accuracy)

Este ejemplo demuestra cómo crear y entrenar una red neuronal simple usando TensorFlow. La primera línea import tensorflow as tf importa la biblioteca TensorFlow, que proporciona las funciones necesarias para construir y entrenar modelos de aprendizaje automático.

La siguiente sección de código crea el modelo:

model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.5),  # Dropout layer with 50% rate
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(10, activation='softmax')
])

El modelo es de tipo Sequential, que es una pila lineal de capas que están conectadas secuencialmente. El modelo Sequential es apropiado para una pila simple de capas donde cada capa tiene exactamente un tensor de entrada y uno de salida.

El modelo consta de dos capas Dense y dos capas de Dropout. Las capas Dense son capas totalmente conectadas, y la primera capa Dense tiene 128 nodos (o 'neuronas'). La función de activación 'relu' se aplica a la salida de esta capa. Esta función devuelve la entrada directamente si es positiva, de lo contrario, devuelve cero. El parámetro 'input_shape' especifica la forma de los datos de entrada, y en este caso, la entrada es un arreglo 1D de tamaño 784.

La capa de Dropout establece aleatoriamente una fracción de las unidades de entrada a 0 en cada actualización durante el tiempo de entrenamiento, lo que ayuda a prevenir el sobreajuste. En este modelo, el Dropout se aplica después de la primera y segunda capas Dense, con una tasa de Dropout del 50%.

La capa Dense final tiene 10 nodos y utiliza la función de activación 'softmax'. Esta función convierte un vector real en un vector de probabilidades categóricas. Los elementos del vector de salida están en el rango (0, 1) y suman 1.

Una vez que se define el modelo, se compila con la siguiente línea de código:

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

Aquí, 'adam' se usa como optimizador. Adam es un algoritmo de optimización que se puede usar en lugar del procedimiento clásico de descenso de gradiente estocástico para actualizar iterativamente los pesos de la red basándose en los datos de entrenamiento.

La función de pérdida, 'sparse_categorical_crossentropy', se usa porque este es un problema de clasificación multiclase. Esta función de pérdida se usa cuando hay dos o más clases de etiquetas y las etiquetas se proporcionan como enteros.

La métrica 'accuracy' se usa para evaluar el rendimiento del modelo.

A continuación, el modelo se entrena en 'x_train' y 'y_train' usando la función fit():

model.fit(x_train, y_train, epochs=10, batch_size=32, verbose=1)

El modelo se entrena durante 10 épocas. Una época es una iteración sobre todo el conjunto de datos de entrenamiento. El tamaño del lote se establece en 32, lo que significa que el modelo usa 32 muestras de datos de entrenamiento en cada actualización de los parámetros del modelo.

Después de entrenar el modelo, se evalúa en los datos de prueba 'x_test' y 'y_test':

loss, accuracy = model.evaluate(x_test, y_test, verbose=0)
print("Loss:", loss)
print("Accuracy:", accuracy)

La función evaluate() devuelve el valor de pérdida y los valores de las métricas para el modelo en 'modo de prueba'. En este caso, devuelve la 'pérdida' y la 'precisión' del modelo cuando se prueba en los datos de prueba. La 'pérdida' es una medida del error y la 'precisión' es la fracción de predicciones correctas hechas por el modelo. Estos dos valores se imprimen luego en la consola.