⚠️Programando un perceptrón

Empezando a crear el perceptron

Si deseas construir un perceptrón para la compuerta lógica AND, aquí te presento los pasos que puedes seguir:

1. Define las entradas y las salidas deseadas: En el caso de la compuerta AND, tienes dos entradas binarias (0 y 1) y una salida binaria que representa el resultado de la operación AND.

   Entrada 1	Entrada 2	Salida deseada
   0	0	0
   0	1	0
   1	0	0
   1	1	1

2. Inicializa los pesos: Para la compuerta AND, necesitas dos pesos (w1 y w2) para las dos entradas respectivas. Puedes asignar valores aleatorios a los pesos para comenzar el proceso de entrenamiento.

3. Define la función de activación: En el caso de la compuerta AND, puedes utilizar la función de activación escalón. Esta función devuelve 1 si la sumatoria de las entradas ponderadas por los pesos es mayor o igual a 0, y devuelve 0 en caso contrario.

4. Calcula la sumatoria: Multiplica cada entrada por su peso correspondiente y luego suma los productos. Este resultado se utiliza como entrada para la función de activación.

5. Aplica la función de activación: Utiliza el resultado de la sumatoria y aplica la función de activación para obtener la salida del perceptrón.

6. Calcula el error: Compara la salida obtenida con la salida deseada y calcula el error. En el caso de la compuerta AND, puedes restar la salida deseada de la salida obtenida.

7. Actualiza los pesos: Utiliza el error calculado para actualizar los pesos. Puedes utilizar la regla de aprendizaje del perceptrón, que consiste en ajustar los pesos según la fórmula: nuevo peso = peso actual + tasa de aprendizaje * error * entrada.

8. Repite los pasos 4 a 7 para todas las combinaciones de entradas hasta que el perceptrón alcance un nivel de precisión aceptable.

Este es un enfoque básico para construir un perceptrón para la compuerta lógica AND. Sin embargo, hay diversas formas de implementarlo en diferentes lenguajes de programación, como Python.

Ejemplo paso a paso de cómo resolver el problema de la compuerta lógica AND utilizando un perceptrón:

Define las entradas y salidas deseadas:

entradas = [[0, 0],
            [0, 1],
            [1, 0],
            [1, 1]]
salidas_deseadas = [0, 0, 0, 1]

Inicializa los pesos:

w1 = 0.5
w2 = 0.5

Define la función de activación:

def activacion(valor):
    return 1 if valor >= 0 else 0

Calcula la sumatoria y aplica la función de activación:

for i in range(len(entradas)):
    entrada = entradas[i]
    sumatoria = w1 * entrada[0] + w2 * entrada[1]
    salida = activacion(sumatoria)
    print(f"Entrada: {entrada} | Salida: {salida}")

Resultado:

Entrada: [0, 0] | Salida: 0
Entrada: [0, 1] | Salida: 0
Entrada: [1, 0] | Salida: 0
Entrada: [1, 1] | Salida: 1

Calcula el error y actualiza los pesos:

tasa_aprendizaje = 0.1
for i in range(len(entradas)):
    entrada = entradas[i]
    sumatoria = w1 * entrada[0] + w2 * entrada[1]
    salida = activacion(sumatoria)
    error = salidas_deseadas[i] - salida
    w1 += tasa_aprendizaje * error * entrada[0]
    w2 += tasa_aprendizaje * error * entrada[1]

1. Repite los pasos 4 y 5 varias veces (iteraciones) hasta obtener la salida deseada para todas las entradas.

Este es un ejemplo básico de cómo resolver el problema de la compuerta lógica AND utilizando un perceptrón de una capa. Cabe mencionar que este es un enfoque simple y que existen muchas variaciones y mejoras posibles, como el uso de una función de activación más sofisticada o el entrenamiento en lotes (batch training).

  Scrip completo:

# Definir las entradas y salidas deseadas
entradas = [[0, 0],
            [0, 1],
            [1, 0],
            [1, 1]]
salidas_deseadas = [0, 0, 0, 1]

# Inicializar los pesos
w1 = 0.5
w2 = 0.5

# Definir la función de activación
def activacion(valor):
    return 1 if valor >= 0 else 0

# Definir la tasa de aprendizaje
tasa_aprendizaje = 0.1

# Entrenar el perceptrón
iteraciones = 10
for _ in range(iteraciones):
    for i in range(len(entradas)):
        entrada = entradas[i]
        salida_deseada = salidas_deseadas[i]
        
        # Calcular la sumatoria y aplicar la función de activación
        sumatoria = w1 * entrada[0] + w2 * entrada[1]
        salida = activacion(sumatoria)
        
        # Calcular el error y actualizar los pesos
        error = salida_deseada - salida
        w1 += tasa_aprendizaje * error * entrada[0]
        w2 += tasa_aprendizaje * error * entrada[1]

# Probar el perceptrón entrenado
print("Compuerta AND")
for i in range(len(entradas)):
    entrada = entradas[i]
    salida_deseada = salidas_deseadas[i]
    
    # Calcular la sumatoria y aplicar la función de activación
    sumatoria = w1 * entrada[0] + w2 * entrada[1]
    salida = activacion(sumatoria)
    
    print(f"Entrada: {entrada} | Salida deseada: {salida_deseada} | Salida: {salida}")

Al ejecutar este script, obtendrás la salida para cada entrada de la compuerta AND, junto con la salida deseada. Verás cómo el perceptrón se entrena para producir las salidas correctas para todas las entradas de la compuerta lógica AND.

En el ejemplo, se estableció un número de iteraciones igual a 10 para limitar la cantidad de veces que se ajustan los pesos del perceptrón. La elección de este valor específico fue arbitraria y puede variar según el problema y la convergencia del algoritmo de entrenamiento.

El propósito de las iteraciones es permitir que el perceptrón realice múltiples ajustes a los pesos con el objetivo de mejorar su capacidad para predecir correctamente la salida deseada. En cada iteración, se presentan los ejemplos de entrenamiento al perceptrón, se calcula la salida y se ajustan los pesos en función del error cometido. Repetir este proceso varias veces permite que el perceptrón se acerque gradualmente a una solución óptima.

En la práctica, el número de iteraciones puede ser determinado experimentalmente, observando el rendimiento del perceptrón en un conjunto de datos de validación o hasta que el error en el entrenamiento se reduzca por debajo de un umbral predefinido.