Objetivos del Módulo

En este módulo, aprenderás sobre:

  • La estructura y funcionamiento básico de las redes neuronales.
  • Los componentes principales de una red neuronal.
  • Cómo se entrenan las redes neuronales.
  • Aplicaciones prácticas de las redes neuronales.

¿Qué es una Red Neuronal?

Una red neuronal es un modelo computacional inspirado en la estructura y funcionamiento del cerebro humano. Está compuesta por unidades básicas llamadas neuronas que están interconectadas y trabajan juntas para procesar información y realizar tareas complejas.

Componentes de una Red Neuronal

  1. Neuronas (Nodos): Las unidades básicas que reciben, procesan y transmiten información.
  2. Capas (Layers): Las neuronas están organizadas en capas:
    • Capa de Entrada (Input Layer): Recibe los datos de entrada.
    • Capas Ocultas (Hidden Layers): Procesan la información recibida de la capa de entrada.
    • Capa de Salida (Output Layer): Produce el resultado final.
  3. Pesos (Weights): Valores que determinan la importancia de las conexiones entre neuronas.
  4. Función de Activación (Activation Function): Una función matemática que decide si una neurona debe activarse o no.

Estructura Básica de una Red Neuronal

Input Layer -> Hidden Layer(s) -> Output Layer

Ejemplo de una Red Neuronal Simple

Consideremos una red neuronal con una capa de entrada, una capa oculta y una capa de salida.

Input Layer: 3 Neuronas
Hidden Layer: 4 Neuronas
Output Layer: 1 Neurona

Visualización de la Red Neuronal

Input Layer: [x1, x2, x3]
          |    |    |
Hidden Layer: [h1, h2, h3, h4]
          |    |    |    |
Output Layer: [y]

Funcionamiento de una Red Neuronal

  1. Propagación hacia Adelante (Forward Propagation):

    • Los datos de entrada se pasan a través de la red, capa por capa.
    • En cada capa, las neuronas aplican una función de activación a la suma ponderada de sus entradas.
  2. Función de Activación:

    • Sigmoid: \( \sigma(x) = \frac{1}{1 + e^{-x}} \)
    • ReLU (Rectified Linear Unit): \( \text{ReLU}(x) = \max(0, x) \)
    • Tanh: \( \text{tanh}(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} \)
  3. Propagación hacia Atrás (Backpropagation):

    • Se calcula el error en la salida y se propaga hacia atrás a través de la red.
    • Los pesos se ajustan para minimizar el error utilizando un algoritmo de optimización como el Gradiente Descendente.

Ejemplo de Código: Red Neuronal Simple en Python

A continuación, se muestra un ejemplo básico de una red neuronal utilizando la librería Keras.

import numpy as np
from keras.models import Sequential
from keras.layers import Dense

# Datos de entrada (X) y salida (y)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# Crear el modelo
model = Sequential()
model.add(Dense(4, input_dim=2, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compilar el modelo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Entrenar el modelo
model.fit(X, y, epochs=1000, verbose=0)

# Evaluar el modelo
loss, accuracy = model.evaluate(X, y)
print(f'Precisión: {accuracy * 100:.2f}%')

# Hacer predicciones
predictions = model.predict(X)
print('Predicciones:')
print(predictions)

Explicación del Código

  1. Importar Librerías:

    • numpy para manejar los datos.
    • keras para construir y entrenar la red neuronal.
  2. Datos de Entrada y Salida:

    • X son los datos de entrada.
    • y son los datos de salida esperados.
  3. Crear el Modelo:

    • Sequential para crear una red neuronal secuencial.
    • Dense para añadir capas densas (totalmente conectadas).
  4. Compilar el Modelo:

    • loss='binary_crossentropy' para la función de pérdida.
    • optimizer='adam' para el algoritmo de optimización.
    • metrics=['accuracy'] para evaluar la precisión.
  5. Entrenar el Modelo:

    • model.fit para entrenar la red con los datos.
  6. Evaluar el Modelo:

    • model.evaluate para evaluar la precisión del modelo.
  7. Hacer Predicciones:

    • model.predict para hacer predicciones con los datos de entrada.

Ejercicio Práctico

Ejercicio 1: Crear una Red Neuronal para Clasificación Binaria

  1. Utiliza el conjunto de datos Iris de sklearn.datasets.
  2. Crea una red neuronal con una capa de entrada, una capa oculta y una capa de salida.
  3. Entrena la red para clasificar las flores en dos categorías.

Solución

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import to_categorical

# Cargar el conjunto de datos Iris
iris = load_iris()
X = iris.data
y = (iris.target != 0) * 1  # Clasificación binaria: 0 o no 0

# Dividir el conjunto de datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Crear el modelo
model = Sequential()
model.add(Dense(8, input_dim=4, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compilar el modelo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Entrenar el modelo
model.fit(X_train, y_train, epochs=100, verbose=0)

# Evaluar el modelo
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Precisión: {accuracy * 100:.2f}%')

# Hacer predicciones
predictions = model.predict(X_test)
print('Predicciones:')
print(predictions)

Retroalimentación

  • Error Común 1: No normalizar los datos de entrada puede llevar a un mal rendimiento del modelo.
  • Error Común 2: Usar una función de activación incorrecta en la capa de salida para problemas de clasificación binaria.

Conclusión

En este módulo, hemos introducido los conceptos básicos de las redes neuronales, su estructura y funcionamiento. También hemos visto un ejemplo práctico de cómo construir y entrenar una red neuronal simple utilizando Keras. En el próximo módulo, profundizaremos en la arquitectura de las redes neuronales y exploraremos diferentes tipos de redes neuronales avanzadas.

© Copyright 2024. Todos los derechos reservados