✅Modelo de un perceptrón en python

Vamos a crear un perceptron desde cero y con todos las cuestiones posibles por tener.

Al implementar el perceptrón paso a paso, se consideraron los siguientes aspectos y decisiones:

1. Importar la biblioteca numpy: Se utiliza la biblioteca numpy en Python para realizar cálculos numéricos eficientes, como multiplicación de matrices y sumas vectorizadas.

2. Definir las entradas y las salidas deseadas: En el ejemplo, se definen las entradas y las salidas deseadas para la compuerta lógica AND. Esto proporciona los datos de entrenamiento para el perceptrón.

3. Inicializar los pesos aleatoriamente: Los pesos iniciales se inicializan con valores aleatorios utilizando numpy.random.rand(). La inicialización aleatoria ayuda a evitar cualquier sesgo inicial en el aprendizaje del perceptrón.

4. Definir la función de activación: En este caso, se utiliza la función de activación escalón, que devuelve 1 si la sumatoria es mayor o igual a 0 y 0 en caso contrario. La elección de la función de activación depende del problema que se esté abordando y se selecciona para introducir no linealidad en el modelo.

5. Entrenamiento del perceptrón: Se define un número de épocas y se realiza un bucle para iterar a través de las épocas. Dentro de cada época, se itera a través de las entradas y las salidas deseadas. Se calcula la sumatoria de las entradas ponderadas por los pesos, se aplica la función de activación, se calcula el error y se actualizan los pesos utilizando la regla de aprendizaje del perceptrón.

6. Probar el perceptrón entrenado: Después del entrenamiento, se utiliza el perceptrón entrenado para predecir la salida para cada combinación de entradas de la compuerta AND. Se calcula la sumatoria de las entradas ponderadas por los pesos, se aplica la función de activación y se compara la salida obtenida con la salida deseada.

Cada decisión tomada en el proceso tiene una justificación específica. Por ejemplo, la inicialización aleatoria de los pesos ayuda a evitar problemas de simetría y garantiza que el perceptrón comience con una capacidad de aprendizaje adecuada. La elección de la función de activación escalón es apropiada para la compuerta lógica AND, ya que produce una salida binaria (0 o 1) y es capaz de separar linealmente las clases.

Es importante tener en cuenta que las decisiones específicas pueden variar dependiendo del problema y del contexto en el que se esté utilizando el perceptrón.

Para definir el número de épocas en el entrenamiento de un perceptrón, se puede considerar lo siguiente:

1. Tamaño del conjunto de entrenamiento: El número de épocas puede depender del tamaño del conjunto de entrenamiento. Si el conjunto de entrenamiento es pequeño, es posible que se requieran menos épocas para que el perceptrón converja. Por otro lado, si el conjunto de entrenamiento es grande, puede ser necesario un mayor número de épocas para que el perceptrón aprenda de manera efectiva.

2. Convergencia: Se puede observar la convergencia del perceptrón durante el entrenamiento para determinar cuándo detenerse. Por ejemplo, si el error de entrenamiento deja de disminuir significativamente o se mantiene dentro de un umbral aceptable durante varias épocas consecutivas, se puede considerar que el perceptrón ha convergido y se puede detener el entrenamiento.

3. Recursos computacionales: El número de épocas también puede estar influenciado por los recursos computacionales disponibles. Si se dispone de recursos limitados, como tiempo de CPU o memoria, puede ser necesario limitar el número de épocas para evitar un entrenamiento excesivamente prolongado.

Es importante encontrar un equilibrio entre un número suficiente de épocas para permitir que el perceptrón aprenda correctamente y un número no excesivo que consuma recursos innecesarios. En la práctica, se recomienda realizar experimentos y ajustar el número de épocas según el problema específico y los resultados obtenidos en el entrenamiento.

Programa en python

Podemos representar la compuerta AND de la siguiente manera:

Entrada 1 | Entrada 2 | Salida

0 | 0 | 0

0 | 1 | 0

1 | 0 | 0

1 | 1 | 1

import numpy as np

# Definir las entradas y las salidas deseadas para la compuerta AND
entradas = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
salidas_deseadas = np.array([0, 0, 0, 1])

# Inicializar los pesos aleatoriamente
np.random.seed(0)
pesos = np.random.rand(2)

# Definir la función de activación (en este caso, la función escalón)
def funcion_activacion(sumatoria):
    return 1 if sumatoria >= 0 else 0

# Entrenamiento del perceptrón
num_epocas = 10
tasa_aprendizaje = 0.1

for epoca in range(num_epocas):
    for entrada, salida_deseada in zip(entradas, salidas_deseadas):
        # Calcular la sumatoria de las entradas ponderadas por los pesos
        sumatoria = np.dot(entrada, pesos)

        # Aplicar la función de activación
        salida = funcion_activacion(sumatoria)

        # Calcular el error
        error = salida_deseada - salida

        # Actualizar los pesos
        pesos += tasa_aprendizaje * error * entrada

# Probar el perceptrón entrenado
for entrada, salida_deseada in zip(entradas, salidas_deseadas):
    sumatoria = np.dot(entrada, pesos)
    salida = funcion_activacion(sumatoria)
    print(f'Entrada: {entrada}, Salida deseada: {salida_deseada}, Salida del perceptrón: {salida}')

Al ejecutar este código, obtendrás la salida del perceptrón para cada combinación de entradas de la compuerta AND y compararla con la salida deseada. Después de entrenar el perceptrón durante algunas épocas, deberías obtener una salida cercana a la salida deseada para todas las combinaciones de entradas, lo que indica que el perceptrón ha aprendido la función lógica AND.

En el ejemplo proporcionado, se utilizó una tasa de aprendizaje de 0.1 para ilustrar el proceso de entrenamiento del perceptrón. Sin embargo, la elección de la tasa de aprendizaje no es única y puede variar según el problema y el algoritmo de entrenamiento utilizado.

La tasa de aprendizaje determina la magnitud de los ajustes realizados a los pesos del perceptrón durante cada iteración del entrenamiento. Una tasa de aprendizaje más alta implica ajustes más grandes en los pesos, lo que puede permitir una convergencia más rápida pero también puede llevar a oscilaciones o a no alcanzar una solución óptima. Por otro lado, una tasa de aprendizaje más baja implica ajustes más pequeños, lo que puede hacer que el entrenamiento sea más lento pero más preciso.

Para decidir la tasa de aprendizaje adecuada, se puede seguir un enfoque empírico. Algunas consideraciones son:

1. Experimentación: Probar diferentes valores de tasa de aprendizaje y evaluar el rendimiento del modelo en el conjunto de entrenamiento y validación. Se puede comenzar con valores pequeños (por ejemplo, 0.1, 0.01) e ir ajustando en función de los resultados obtenidos.

2. Sensibilidad del modelo: Observar la sensibilidad del modelo a cambios en la tasa de aprendizaje. Si los pesos cambian drásticamente con pequeñas variaciones en la tasa de aprendizaje, podría ser una señal de que se está utilizando una tasa demasiado alta.

3. Convergencia: Observar el comportamiento del error durante el entrenamiento. Si el error disminuye lentamente o fluctúa demasiado, podría ser un indicio de que la tasa de aprendizaje es demasiado alta o demasiado baja.

4. Consideraciones del problema: Algunos problemas pueden requerir tasas de aprendizaje más altas o más bajas. Problemas con datos ruidosos o con una gran cantidad de características pueden requerir una tasa de aprendizaje más baja para converger de manera efectiva.

En resumen, la elección de la tasa de aprendizaje es un proceso iterativo basado en la experimentación y la observación del rendimiento del modelo. Es importante probar diferentes valores y ajustar la tasa de aprendizaje según las características del problema específico.