Perceptrón

El perceptrón es un algoritmo de aprendizaje automático y una arquitectura de red neuronal artificial, se utiliza para resolver problemas de clasificación binaria. Propuesto por Frank Rosenblatt en 1957 y es uno de los conceptos fundamentales en el campo del aprendizaje profundo y las redes neuronales.

Se inspira en el funcionamiento del sistema nervioso humano y está diseñado para simular una sola neurona artificial. El objetivo es aprender a realizar una tarea de clasificación binaria, es decir, separar dos clases distintas de elementos en función de sus características.

El nombre “perceptrón” proviene de la palabra “percepción”, que hace referencia a la capacidad del algoritmo para aprender a distinguir patrones y realizar clasificaciones, de manera similar a cómo el sistema nervioso humano percibe y clasifica estímulos.

Aunque el perceptrón es un algoritmo de aprendizaje básico y ha sido superado por técnicas más sofisticadas en el campo del aprendizaje profundo, su nombre ha perdurado como un símbolo importante en la historia del aprendizaje automático y la inteligencia artificial.

Fue uno de los primeros algoritmos en mostrar la capacidad de aprender y adaptarse a partir de datos, lo que abrió el camino para el desarrollo de modelos más complejos y poderosos en el campo del aprendizaje automático.

¿Qué es la clasificación binaria?

Es un tipo de problema de aprendizaje supervisado en el campo del aprendizaje automático. El objetivo es asignar un objeto de entrada (por ejemplo, una imagen, un texto o un conjunto de características) a una de las dos categorías o clases posibles. La clasificación binaria se centra en resolver problemas donde la respuesta deseada es una de dos opciones, que comúnmente se representan como “0” y “1”, “negativo” y “positivo”, o “falso” y “verdadero”.

Ejemplos de problemas de clasificación binaria

1. Detección de spam: Clasificar correos electrónicos como “spam” o “no spam”.
2. Diagnóstico médico: Clasificar pacientes como “enfermos” o “sanos” según sus síntomas y resultados de pruebas.
3. Detección de fraudes: Clasificar transacciones financieras como “fraudulentas” o “legítimas” según patrones de comportamiento.
4. Reconocimiento facial: Clasificar imágenes de rostros como “persona” o “no persona”.
5. Detección de errores ortográficos: Clasificar que palabras están bien escritas o no.

Para abordar problemas de clasificación binaria, se utilizan diversos algoritmos de aprendizaje automático, como el perceptrón, regresión logística, máquinas de soporte vectorial (SVM), árboles de decisión, entre otros. Estos algoritmos aprenden a partir de un conjunto de datos de entrenamiento etiquetado, donde cada objeto de entrada tiene una etiqueta que indica su clase correcta. Luego, el modelo entrenado puede utilizarse para predecir la clase de nuevos objetos de entrada que no están en el conjunto de entrenamiento.

La clasificación binaria es uno de los problemas más comunes en el aprendizaje automático, y es fundamental para una amplia gama de aplicaciones y escenarios donde se necesita tomar decisiones entre dos opciones.

Pasos del algoritmo

• Inicialización de pesos y sesgo: El Perceptrón comienza con la inicialización de los pesos (self.weights) y el sesgo (self.bias) a valores iniciales, generalmente cero o pequeños valores aleatorios.
• Entrenamiento: El Perceptrón se entrena utilizando un conjunto de datos de entrenamiento etiquetado. Cada ejemplo de entrenamiento consiste en un vector de características (X) y su etiqueta de clase (y). Durante el entrenamiento, el Perceptrón ajusta sus pesos y sesgo para minimizar el error entre las predicciones y las etiquetas verdaderas.
• Predicción: Una vez que el Perceptrón ha sido entrenado, puede realizar predicciones para nuevas entradas. Para predecir la clase de una nueva entrada, el Perceptrón calcula el resultado de la salida lineal como la suma ponderada de las características multiplicadas por los pesos, más el sesgo. Luego, aplica una función de activación para determinar la clase predicha.
• Actualización de pesos y sesgo: Durante el entrenamiento, el Perceptrón ajusta los pesos y el sesgo utilizando la regla de aprendizaje del perceptrón. Si la predicción es incorrecta, se actualizan los pesos y el sesgo en función del error cometido. El ajuste se realiza mediante el producto del error, la tasa de aprendizaje (learning_rate), y las características de la entrada.
• Épocas: El entrenamiento se realiza a través de múltiples épocas (iteraciones) del conjunto de entrenamiento. En cada época, el Perceptrón recorre todo el conjunto de entrenamiento para ajustar los pesos y sesgo en función de los errores cometidos.

Es importante tener en cuenta que el Perceptrón es un modelo lineal y solo puede aprender a clasificar datos que sean linealmente separables. En casos donde los datos no son linealmente separables, el Perceptrón puede no converger o dar resultados subóptimos.

Ejemplo de uso del perceptrón

Supongamos que se quiere usar el perceptrón para detectar errores ortográficos en algún documento o grupo de palabras, dependiendo claro de las previamente entrenadas. En este ejemplo, se entrena el Perceptrón con un conjunto de datos pequeño que contiene cuatro palabras: ‘hello‘, ‘world‘, ‘apple‘ y ‘banana‘. Dos de estas palabras contienen errores ortográficos (‘heeeello‘ y ‘aplle‘). Luego, se utilizara el Perceptrón entrenado para predecir si tres palabras adicionales (‘heeeello‘, ‘world‘, ‘aplle‘ y ‘bananana‘) contienen errores ortográficos o no.

import numpy as np

class PerceptronSpellChecker:
    def __init__(self, learning_rate=0.1, epochs=10):
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.weights = None
        self.bias = None

    def extract_features(self, word):
        # Representa la palabra como un vector de frecuencia de letras (solo minúsculas)
        features = np.zeros(26)
        for char in word:
            if 'a' <= char <= 'z':
                index = ord(char) - ord('a')
                features[index] += 1
        return features

    def fit(self, X, y):
        num_features = X.shape[1]
        self.weights = np.zeros(num_features)
        self.bias = 0

        for _ in range(self.epochs):
            for i in range(X.shape[0]):
                prediction = self.predict(X[i])
                error = y[i] - prediction
                self.weights += self.learning_rate * error * X[i]
                self.bias += self.learning_rate * error

    def predict(self, x):
        linear_output = np.dot(x, self.weights) + self.bias
        return 1 if linear_output >= 0 else 0

    def get_word_label(self, prediction):
        return "Incorrecta" if prediction == 1 else "Correcta"        

# Datos de entrenamiento
X_train = np.array([PerceptronSpellChecker().extract_features('hello'),
                    PerceptronSpellChecker().extract_features('world'),
                    PerceptronSpellChecker().extract_features('apple'),
                    PerceptronSpellChecker().extract_features('banana'),
                    PerceptronSpellChecker().extract_features('heeelloo')
                    ])

y_train = np.array([0, 0, 1, 1, 1])  # 0 para palabras correctamente escritas, 1 para palabras con errores

# Crear el modelo del Perceptrón
spell_checker = PerceptronSpellChecker(learning_rate=0.1, epochs=10)

# Entrenar el modelo
spell_checker.fit(X_train, y_train)

# Datos de prueba
X_test = np.array([PerceptronSpellChecker().extract_features('heeello'),   # palabra con error
                   PerceptronSpellChecker().extract_features('world'),     # palabra sin error
                   PerceptronSpellChecker().extract_features('aplle'),     # palabra con error
                   PerceptronSpellChecker().extract_features('bananana')]) # palabra con error

# Realizar predicciones
predictions = [spell_checker.predict(x) for x in X_test]
print(predictions)  # Salida: [1, 0, 1, 1] (Palabra con error, Palabra sin error, Palabra con error, Palabra con error)

# Obtener resultados de las palabras
results = [(word, spell_checker.get_word_label(pred)) for word, pred in zip(['heeello', 'world', 'aplle', 'bananana'], predictions)]

# Mostrar resultados
print("Resultados:")
for word, label in results:
    print(f"Palabra: '{word}' - Clasificación: {label}")

El código fuente lo encuentras disponible en: https://github.com/ajgutierr3z/perceptron/tree/main