Red Neuronal Monocapa

Las redes neuronales monocapa, también conocidas como perceptrones, son una forma fundamental de inteligencia artificial que consta de una sola capa de neuronas interconectadas.

Aunque son simples en su estructura, estas redes son capaces de realizar una variedad de tareas, desde problemas de clasificación hasta cálculos numéricos.

En esta introducción, exploraremos cómo funcionan las redes monocapa y cómo pueden aplicarse a un ejemplo específico, como la multiplicación de números.

Ejemplo

En este ejemplo, utilizaremos una red neuronal monocapa para realizar la multiplicación de dos números.

A través de este ejemplo, veremos cómo las redes neuronales monocapa pueden aplicarse a problemas numéricos simples y cómo los pesos de las conexiones entre las neuronas pueden ajustarse para que la red pueda realizar cálculos precisos.

Esta introducción nos dará una comprensión básica de cómo funcionan las redes monocapa y cómo pueden aplicarse en diversos contextos.

Implementación en Python

Importamos los módulos necesarios

import random

import torch
import torch.nn as nn
import torch.optim as optim

Definimos los datos de entrenamiento, donde $𝑥$ son los datos de entradas e $𝑦$ son las etiquetas.

# Datos de entrenamiento
X = [1, 2, 3, 4, 5]  # Datos de entrada
y = [2, 4, 6, 8, 10]  # Datos de salida

# Datos de entrenamiento
X = torch.tensor([[1.0], [2.0], [3.0], [4.0]], dtype=torch.float32)
y = torch.tensor([[2.0], [4.0], [6.0], [8.0]], dtype=torch.float32)

Definimos el modelo y el entrenamiento de una red neuronal simple:

Definimos el peso $𝑤$ y sesgo $𝑏$ inicial de forma aleatoria, así como la tasa de aprendizaje.

w = random.uniform(0, 1)  # Peso inicial
b = random.uniform(0, 1)  # Sesgo inicial
lr = 0.01  # Tasa de aprendizaje

Definimos el número de épocas para realizar el entrenamiento.

epochs = 100

Realizamos el entrenamiento

for epoch in range(epochs):
    total_error = 0
    for i in range(len(X)):
        # Predicción de la neurona
        y_pred = w * X[i] + b

        # Cálculo del error
        error = y[i] - y_pred

        # Actualización de pesos y sesgo
        w += lr * error * X[i]
        b += lr * error

        total_error += error

    # Calcular el error cuadrático medio (MSE) promedio
    mse = total_error / len(X)

    # Mostrar el progreso
    if (epoch + 1) % 100 == 0:
        _mse = "{:.20f}".format(mse)
        print(f'Época {epoch + 1}, MSE: {_mse}')

# Resultado final
print(f'Peso (w): {w}')
print(f'Sesgo (b): {b}')

Definimos el modelo de una red neuronal simple:

Se crea una clase llamada SimpleNet que hereda de nn.Module. En el constructor init, definimos una capa lineal (nn.Linear) con una entrada de 1 y una salida de 1, dicha capa representa una única neurona.

En el método forward, especificamos cómo se deben realizar las operaciones hacia adelante. En este caso, simplemente pasamos los datos de entrada a través de la capa lineal.

class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(1, 1)

    def forward(self, x):
        return self.fc(x)

Creamos una instancia del modelo

model = SimpleNet()

Definimos una función de pérdida (criterion) que mide la diferencia entre las predicciones del modelo y los valores reales. Usamos el error cuadrático medio (MSE) en este caso.

Configuramos un optimizador (optimizer) para actualizar los pesos del modelo durante el entrenamiento.

Usamos el optimizador SGD (descenso de gradiente estocástico) con una tasa de aprendizaje de 0.01.

criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

Entrenamiento del modelo

En un bucle de entrenamiento, iteramos a través de 1000 épocas.

En cada época: Realizamos una pasada hacia adelante (forward pass) para obtener las predicciones del modelo. Calculamos la pérdida comparando las predicciones con los valores reales.

Realizamos una pasada hacia atrás (backward pass) para calcular los gradientes y actualizar los pesos del modelo con el optimizador.

Mostramos la pérdida en cada época, lo que nos permite seguir el progreso del entrenamiento.

for epoch in range(1000):
    # Forward pass
    outputs = model(X)
    loss = criterion(outputs, y)

    # Backward pass y actualización de pesos
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        _mse = "{:.20f}".format(loss.item())
        print(f'Época {epoch + 1}, Pérdida (MSE): {_mse}')

Comprobamos el comportamiento con valores distintos a los que entreno nuestro modelo.

# Nuevos datos de prueba
X_test = [6, 7, 8, 9, 10]

# Realizar predicciones con el modelo entrenado
predictions = [w * x + b for x in X_test]

# Imprimir las predicciones
for i in range(len(X_test)):
    print(f'Entrada: {X_test[i]}, Predicción: {predictions[i]}')

# Evaluar el modelo
X_test = [[[5.0]], [[6.0]], [[7.0]], [[8.0]]]
for i in range(len(X_test)):
    predicted = model(torch.tensor(X_test[i], dtype=torch.float32))
    print(f'Entrada: {X_test[i]}, Predicción: {predicted.item()}')

Interpretación del MSE

El Error Cuadrático Medio (MSE, por sus siglas en inglés, Mean Squared Error) es una medida de cuánto se desvían las predicciones de un modelo de regresión lineal de los valores reales en un conjunto de datos.

Es ampliamente utilizado en la evaluación de modelos de regresión y representa la diferencia cuadrada promedio entre las predicciones del modelo y los valores reales.

La fórmula del MSE se expresa de la siguiente manera:

$𝑚𝑠𝑒=\frac{1}{𝑛}Σ(𝑦_𝑖−\bar{𝑦}_𝑖)^2$

Donde:

$𝑚𝑠𝑒$ es el Error Cuadrático Medio.
$𝑛$ es el número de puntos de datos en el conjunto de datos.
$𝑦_𝑖$ es el valor real (la etiqueta) para el punto $𝑥_𝑖$ .
$\bar{𝑦}_𝑖$ es la predicción del modelo para el punto $𝑥_𝑖$ .

El MSE calcula la diferencia entre cada valor real y su predicción, lo eleva al cuadrado y luego toma el promedio de estas diferencias al dividir por el número total de puntos de datos.

El cuadrado se utiliza para darle un mayor peso a los errores más grandes y penalizarlos.

El valor correcto del Error Cuadrático Medio (MSE) depende en gran medida del contexto específico de tu problema y de las unidades de medida de tus datos.

Sin embargo, hay algunas pautas generales que se pueden seguir para interpretar el MSE:

MSE Cercano a Cero: Un MSE cercano a cero indica un excelente ajuste del modelo a los datos de entrenamiento. En términos generales, cuanto más cercano a cero sea el MSE, mejor será el modelo.

MSE Pequeño: Un MSE pequeño (por ejemplo, 0.01) sugiere un buen ajuste del modelo. Esto significa que las predicciones del modelo son muy similares a los valores reales y que el modelo es capaz de capturar eficazmente la relación entre las entradas y las salidas.

MSE Moderado: Un MSE moderado (por ejemplo, entre 0.1 y 1) podría considerarse aceptable en algunos casos. Esto depende de la tolerancia para el error en tu problema específico. En algunos casos, un ajuste más preciso puede ser necesario, mientras que en otros, un error moderado podría ser aceptable.

MSE Grande: Un MSE grande (por ejemplo, superior a 1) sugiere que el modelo tiene dificultades para ajustarse a los datos y puede no ser adecuado para el problema en cuestión. Un MSE significativamente alto indica que el modelo no está capturando bien la relación entre las entradas y las salidas.

Es importante destacar que el MSE debe interpretarse en relación con el contexto de tu problema.

Además, es fundamental considerar cómo el modelo se desempeña en datos de prueba independientes.

Por ejemplo, un MSE bajo en los datos de entrenamiento, pero un MSE alto en los datos de prueba, puede indicar que el modelo está sobreajustando (overfitting) a los datos de entrenamiento.

Código completo

Lo anterior, se encuentra disponible en el siguiente google colab: https://github.com/mevangelista-alvarado/neural_networks/blob/main/EjemploRedNeuronalMonocapa.ipynb

PreviousRed Neuronal Multicapa NextRed Neuronal Multicapa

Last updated 2 months ago