Machine Learning 101 — Perceptron

Perceptron es uno de los patrones más simples y antiguos en Machine Learning. Este patrón se utiliza para realizar la clasificación binaria de datos en dos categorías y está basado en el concepto de la neurona biológica y su forma de procesar la información.

En este patrón recibe una entrada y se obtiene un output binario. Cada entrada tiene un peso (w por weight), que representa la importancia de esa entrada para la clasificación. Luego suma los pesos de todas las entradas y, si la suma supera un umbral(thershold), produce una salida positiva. De lo contrario, produce una salida negativa. Esta clasificación se realiza mediante lo que llamamos una función de activación.

Diagrama de una neurona de perceptron

El entrenamiento del perceptrón se realiza mediante la actualización de los pesos en función de los errores cometidos en la clasificación. Si el perceptrón clasifica mal una entrada, se ajustan los pesos para disminuir el error. Este proceso se repite hasta que el perceptrón aprenda a clasificar correctamente todas las entradas.

Resultado de la clasificación de los elementos en 2 clases

Como implementamos el patrón en python

A continuación comparto el código para implementar este patron junto a unas funciones para realizar las pruebas, se puede modificar el set de datos para ver distintas salidas.

import numpy as np


class Perceptron:
    def __init__(self, learning_rate=0.01, n_iters=1000):
        self.lr = learning_rate
        self.n_iters = n_iters
        self.activation_func = self._unit_step_func
        self.weights = None
        self.bias = None

    def fit(self, X, y):  # Entrenamiento
        n_samples, n_features = X.shape

        # init param
        self.weights = np.zeros(n_features)
        self.bias = 0

        y_ = np.array([1 if i > 0 else 0 for i in y])

        # Estos dos bucles representan la función de enumeración
        for _ in range(self.n_iters):

            for idx, x_i in enumerate(X):

                linear_output = np.dot(x_i, self.weights) + self.bias
                y_predicted = self.activation_func(
                    linear_output)  # Función de activación

                # Perceptron - funcion de actualización
                update = self.lr * (y_[idx] - y_predicted)

                self.weights += update * x_i
                self.bias += update

    def predict(self, X):  # predicción
        linear_output = np.dot(X, self.weights) + self.bias
        y_predicted = self.activation_func(linear_output)
        return y_predicted

    def _unit_step_func(self, x):
        return np.where(x >= 0, 1, 0)


# Test de la implementación
if __name__ == "__main__":
    # Imports
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn import datasets

    def accuracy(y_true, y_pred):
        accuracy = np.sum(y_true == y_pred) / len(y_true)
        return accuracy

    X, y = datasets.make_blobs(
        n_samples=150, n_features=2, centers=2, cluster_std=1.05, random_state=2
    )
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=123
    )

    p = Perceptron(learning_rate=0.01, n_iters=1000)
    p.fit(X_train, y_train)
    predictions = p.predict(X_test)

    print("Perceptron - Presisición de la clasificación",
          accuracy(y_test, predictions))

    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    plt.scatter(X_train[:, 0], X_train[:, 1], marker="o", c=y_train)

    x0_1 = np.amin(X_train[:, 0])
    x0_2 = np.amax(X_train[:, 0])

    x1_1 = (-p.weights[0] * x0_1 - p.bias) / p.weights[1]
    x1_2 = (-p.weights[0] * x0_2 - p.bias) / p.weights[1]

    ax.plot([x0_1, x0_2], [x1_1, x1_2], "k")

    ymin = np.amin(X_train[:, 1])
    ymax = np.amax(X_train[:, 1])
    ax.set_ylim([ymin - 3, ymax + 3])

    plt.show()

Hay 3 funciones a tener en cuenta

• Función linear: es una operación matemática que calcula la suma ponderada de las entradas y los pesos asociados a cada una. Esta suma ponderada es la entrada de la función de activación.
• Función de enumeración: se utiliza para clasificar los datos de entrada en diferentes categorías. Se puede utilizar una función de enumeración para predecir la clase a la que pertenece un objeto en función de sus características.
• Función de activación: es una función no lineal que toma la entrada del perceptrón y produce una salida binaria, es decir, un valor de “1” o “0”. La función de activación más comúnmente utilizada en el perceptrón es la función escalón de Heaviside, que produce una salida de “1” si la entrada es mayor que un umbral, y una salida de “0” en caso contrario. Otras funciones de activación comunes incluyen la función sigmoide y la función de unidad lineal rectificada (ReLU).

Podes ver este código y el de los otros artículos en este repositorio.