- El perceptrón converge en un número finito de actualizaciones si los datos son linealmente separables, siendo uno de los algoritmos de clasificación más antiguos.
- La predicción se basa en el signo de \(\mathbf{w}^\top \mathbf{x} + b\); cuando la señal es incorrecta, ese ejemplo actualiza los pesos.
- La regla de actualización “敗umar el ejemplo mal clasificado escalado por la tasa de aprendizaje”・ofrece una introducción intuitiva a los métodos basados en gradiente.
- Si los datos no son separables linealmente, conviene ampliar características o recurrir a kernel tricks.
Intuición #
El perceptrón mueve la frontera de decisión cada vez que se equivoca, desplazándola hacia el lado correcto. El vector de pesos \(\mathbf{w}\) es normal a la frontera, mientras que el sesgo \(b\) ajusta el desplazamiento. La tasa de aprendizaje \(\eta\) controla la magnitud de cada movimiento.
Formulación matemática #
La predicción se calcula como
$$ \hat{y} = \operatorname{sign}(\mathbf{w}^\top \mathbf{x} + b). $$
Si un ejemplo \((\mathbf{x}_i, y_i)\) queda mal clasificado, se actualiza mediante
$$ \mathbf{w} \leftarrow \mathbf{w} + \eta, y_i, \mathbf{x}_i,\qquad b \leftarrow b + \eta, y_i. $$
Cuando los datos son separables linealmente, este procedimiento converge.
Experimentos con Python #
El siguiente ejemplo aplica el perceptrón a datos sintéticos, muestra el número de errores por época y dibuja la frontera obtenida.
from __future__ import annotations
import japanize_matplotlib
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_blobs
from sklearn.metrics import accuracy_score
def run_perceptron_demo(
n_samples: int = 200,
lr: float = 0.1,
n_epochs: int = 20,
random_state: int = 0,
title: str = "Frontera de decisión del perceptrón",
xlabel: str = "característica 1",
ylabel: str = "característica 2",
label_boundary: str = "frontera de decisión",
) -> dict[str, object]:
"""Train a perceptron on synthetic blobs and plot the decision boundary."""
japanize_matplotlib.japanize()
X, y = make_blobs(n_samples=n_samples, centers=2, cluster_std=1.0, random_state=random_state)
y_signed = np.where(y == 0, -1, 1)
w = np.zeros(X.shape[1])
b = 0.0
history: list[int] = []
for _ in range(n_epochs):
errors = 0
for xi, target in zip(X, y_signed):
update = lr * target if target * (np.dot(w, xi) + b) <= 0 else 0.0
if update != 0.0:
w += update * xi
b += update
errors += 1
history.append(int(errors))
if errors == 0:
break
preds = np.where(np.dot(X, w) + b >= 0, 1, -1)
accuracy = float(accuracy_score(y_signed, preds))
xx = np.linspace(X[:, 0].min() - 1, X[:, 0].max() + 1, 200)
yy = -(w[0] * xx + b) / w[1]
fig, ax = plt.subplots(figsize=(6, 5))
ax.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolor="k")
ax.plot(xx, yy, color="black", linewidth=2, label=label_boundary)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.set_title(title)
ax.legend(loc="best")
fig.tight_layout()
plt.show()
return {"weights": w, "bias": b, "errors": history, "accuracy": accuracy}
metrics = run_perceptron_demo(
title="Frontera de decisión del perceptrón",
xlabel="característica 1",
ylabel="característica 2",
label_boundary="frontera de decisión",
)
print(f"Precisión de entrenamiento: {metrics['accuracy']:.3f}")
print("Pesos:", metrics['weights'])
print(f"Sesgo: {metrics['bias']:.3f}")
print("Errores por época:", metrics['errors'])
Referencias #
- Rosenblatt, F. (1958). The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain. Psychological Review, 65(6), 386"・08.
- Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press.