Perceptrón

Perceptrón

Un perceptrón es una neurona artificial, y por tanto, una unidad de una red neuronal. El perceptrón efectúa cálculos para detectar características o tendencias en los datos de entrada. El perceptrón desempeña un papel esencial en los proyectos de Machine Learning.

Se utiliza en gran medida para clasificar datos, o como algoritmo que permite simplificar o supervisar las capacidades de aprendizaje de los clasificadores binarios.

Con base en el trabajo McCullock y W. Pitts, F. Rosenblatt en The Perceptron: A perceiving and Recoggnizing Automaton en 1957, da a conocer el primer concepto de la regla de aprendizaje de un perceptrón

Según la regla de aprendizaje del perceptrón, el algoritmo aprende automáticamente los coeficientes de peso óptimo. Para determinar si una neurona “se enciende” o no, las características de los datos de entrada se multiplican por esos pesos.

El perceptrón recibe múltiples señales de entrada. Si la suma de las señales supera un umbral determinado, se produce una señal o, por el contrario, no se emite ningún resultado, como se muestra en la imagen.

Imagen de un perceptrón

El modelo anterior consta de:

• entradas $x_{1}, ..., x_{N}$,

• pesos $w_{1}, ..., w_{N}$, correspondientes a cada entrada.

• una función de activación 𝜑

• una salida $y$.

En este modelo, la salida de la neurona está dada por

$$y = \varphi(w_1\cdot x + \dots+ w_2\cdot y)=\varphi(\Sigma_{i=0}^{n}w_i\cdot x_{i}) = \varphi(\vec{w}\cdot\vec{x})$$

La función de activación 𝜑 es seleccionada de acuerdo a la tarea realizada por la neurona

Implementación en Python

En este ejemplo, crearemos un perceptrón para resolver la operación lógica OR (inclusivo):

El operador OR inclusivo (a nivel de bit) compara los valores (en formato binario) de cada operando y produce un valor cuyo patrón de bits muestra qué bits en cualquiera de los operandos tiene el valor 1. Si ambos bits son 0, el resultado de ese bit es 0; de lo contrario, el resultado es 1.

Definimos las entradas, los pesos y los valores esperados (labels) para cada entrada

Python

# Definición de entradas y pesos iniciales
inputs = [[0, 0], [0, 1], [1, 0], [1, 1]] # Cambia las entradas para probar otros casos
weights = [0.4, 0.6]  # Pesos iniciales (ajustables)

# Definición de los objetivos (resultados esperados para las entradas
# correspondientes) para la operación OR
targets = [0, 1, 1, 1]

Definimos la función de activación.

Python

# Definición de una función de activación simple
def step_function(x, umbral=0):
    # Esto describe una función piso
    return 1 if x >= umbral else 0

Definimos una función que describe el Perceptrón

Python

# Función para realizar la operación del perceptrón
def perceptron(inputs, weights, umbral):
    weighted_sum = sum(w * x for w, x in zip(weights, inputs))
    return step_function(weighted_sum, umbral)

Definimos una función de entrenamiento para el perceptrón

Python

# Función de entrenamiento del perceptrón
def train_perceptron(inputs, weights, target, umbral, learning_rate):
    for i in range(len(weights)):
        output = perceptron(inputs, weights, umbral)
        error = target - output # Aqui entra en concepto de Función de Pérdida 
        weights[i] += learning_rate * error * inputs[i]
    return weights

Entrenamos el perceptrón durante 1,000 épocas y con un learnign rate de 0.01

Python

# Entrenamiento del perceptrón
epochs = 1000
learning_rate = 0.0001
umbral = 0.45
for _ in range(epochs):
    for i in range(len(inputs)):
        weights = train_perceptron(inputs[i], weights, targets[i], umbral, learning_rate)
    print(f"epoca {_} tiene los pesos {weights}")

Probamos el modelo

Python

# Prueba del perceptrón
_inputs = [[0,0], [0,1], [1,0], [1,1]]
for i in range(len(_inputs)):
    result = perceptron(_inputs[i], weights, umbral)
    print(f"Entradas: {_inputs[i]}, Pesos: {weights}, Salida: {result}")

Learning Rate

En implementación anterior, el learning_rate (tasa de aprendizaje) controla cuánto se ajustan los pesos de la neurona durante cada iteración del entrenamiento.

Es un valor que se elige antes de iniciar el entrenamiento y afecta la velocidad y la calidad del aprendizaje de la red.

Cuando el learning rate es pequeño, los ajustes de los pesos son pequeños, lo que hace que el entrenamiento sea más lento pero potencialmente más preciso.

Por otro lado, cuando el learning rate es grande, los ajustes de los pesos son mayores y el entrenamiento es más rápido, pero podría no converger o converger de manera inestable.

El learning rate se multiplica por el error cometido por la red para determinar cuánto cambiar los pesos en cada iteración. La fórmula general para actualizar los pesos es:

Nuevo Peso = Peso Actual + (Learning Rate * Error)

El valor del learning rate es crítico y debe elegirse cuidadosamente. Valores típicos de learning_rate pueden variar según el problema, pero comúnmente se prueban valores como 0.1, 0.01, 0.001, y luego se selecciona el que proporciona el mejor equilibrio entre velocidad y precisión en el aprendizaje.

Código completo

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