Máquinas de vectores de soporte

a) Los puntos más cercanos entre las dos clases son (1, 0) y (0, 1) de un lado, y (3, 2) y (2, 3) del otro. Los dos primeros están sobre la recta x₁ + x₂ = 1 y los otros dos sobre x₁ + x₂ = 5. La frontera va justo por el medio, paralela a ellas: x₁ + x₂ = 3. Esos cuatro puntos son los vectores de soporte.

b) La calle va de x₁ + x₂ = 1 a x₁ + x₂ = 5. La distancia entre esas dos rectas es 4/√2 ≈ 2,83. Con la fórmula del tema: la frontera x₁ + x₂ − 3 = 0 escrita con la convención de la SVM (puntaje ±1 en los vectores de soporte) es 0,5·x₁ + 0,5·x₂ − 1,5 = 0, y 2/‖w‖ = 2/√0,5 ≈ 2,83.

Los cuatro puntos que elegimos tienen y·z = 1: tocan los bordes de la calle. scikit-learn reporta solo dos de ellos como vectores de soporte porque, al estar alineados sobre los bordes, dos bastan para fijar la calle. Con datos reales, con ruido, casi nunca hay puntos tan perfectamente alineados.

c) No cambia: (−1, −1) y (4, 4) están lejos de la calle y no son vectores de soporte.

X1 = np.array([[0, 0], [1, 0], [0, 1], [-1, -1],
               [3, 3], [2, 3], [3, 2], [4, 4]])
y1 = np.array([0, 0, 0, 0, 1, 1, 1, 1])

duro = SVC(kernel="linear", C=1000).fit(X1, y1)
w1, b1 = duro.coef_[0], duro.intercept_[0]
print("w =", np.round(w1, 3), "  b =", round(b1, 3))
print("y·z de cada punto:", np.round(np.where(y1 == 1, 1, -1)
                                    * duro.decision_function(X1), 2))
print("Vectores de soporte que reporta scikit-learn:",
      duro.support_vectors_.tolist())
print(f"Ancho de la calle: {2 / np.linalg.norm(w1):.2f}")

# Sin los dos puntos lejanos (índices 3 y 7)
quedan = [0, 1, 2, 4, 5, 6]
sin_lejanos = SVC(kernel="linear", C=1000).fit(X1[quedan], y1[quedan])
print("Sin los lejanos: w =", np.round(sin_lejanos.coef_[0], 3),
      "  b =", round(sin_lejanos.intercept_[0], 3))

w = [0.5 0.5]   b = -1.5
y·z de cada punto: [1.5 1.  1.  2.5 1.5 1.  1.  2.5]
Vectores de soporte que reporta scikit-learn: [[1.0, 0.0], [3.0, 2.0]]
Ancho de la calle: 2.83
Sin los lejanos: w = [0.5 0.5]   b = -1.5

a) z = 2·x₁ − 2, así que la frontera es la recta vertical x₁ = 1. Los bordes, donde z = ±1, son x₁ = 0,5 y x₁ = 1,5. El ancho es 2/‖w‖ = 2/2 = 1, que coincide con 1,5 − 0,5.

b)

c) J = ½·(2² + 0²) + 1·(0 + 0,6 + 1,4 + 0) = 2 + 2 = 4.

X2 = np.array([[0, 1], [1.2, 0], [0.8, 2], [3, -1]])
s2 = np.array([-1, 1, 1, 1])
w2, b2 = np.array([2.0, 0.0]), -2.0

z = X2 @ w2 + b2
print("z:      ", np.round(z, 2))
print("y·z:    ", np.round(s2 * z, 2))
print("bisagra:", np.round(np.maximum(0, 1 - s2 * z), 2))
print("J =", round(objetivo(X2, s2, w2, b2, C=1), 2))

z:       [-2.   0.4 -0.4  4. ]
y·z:     [ 2.   0.4 -0.4  4. ]
bisagra: [0.  0.6 1.4 0. ]
J = 4.0

a) Todos: con w = 0 y b = 0, todos los puntajes son 0, así que y·z = 0, que es menor que 1. Cada uno paga una multa de 1 y J = 0 + 4 = 4.

b) Como w = 0, el primer término no aporta y queda −C por la suma de yᵢ·xᵢ de los cuatro puntos:

• Σ yᵢ·xᵢ = −(0, 1) + (1,2; 0) + (0,8; 2) + (3, −1) = (5, 0), así que ∂J/∂w = (−5, 0).
• Σ yᵢ = −1 + 1 + 1 + 1 = 2, así que ∂J/∂b = −2.

El paso: w = (0, 0) − 0,1·(−5, 0) = (0,5; 0) y b = 0 − 0,1·(−2) = 0,2. La frontera nueva es vertical, en x₁ = −0,4: los puntos de la clase +1 tienen x₁ grande y el paso los empujó hacia su lado.

c)

w_paso, b_paso, h = svm_subgradiente(X2, s2, C=1, tasa=0.1, pasos=1)
print("w =", w_paso, "  b =", round(b_paso, 2))
print(f"J antes = {h[0]:.2f}"
      f"   después = {objetivo(X2, s2, w_paso, b_paso, C=1):.3f}")

w = [0.5 0. ]   b = 0.2
J antes = 4.00   después = 1.925

Sí bajó, de 4 a 1,925, con un solo paso.

from sklearn.linear_model import LogisticRegression

X_lejos = np.vstack([X, [[-1.2, -0.8]]])
y_lejos = np.append(y, 0)

for nombre, Modelo, opciones in [("SVM", SVC, {"kernel": "linear"}),
                                 ("Logística", LogisticRegression, {})]:
    antes = Modelo(**opciones).fit(X, y)
    despues = Modelo(**opciones).fit(X_lejos, y_lejos)
    print(f"{nombre}:  sin el punto w = {np.round(antes.coef_[0], 3)},"
          f" b = {antes.intercept_[0]:.3f}")
    print(f"{nombre}:  con el punto w = {np.round(despues.coef_[0], 3)},"
          f" b = {despues.intercept_[0]:.3f}")

SVM:  sin el punto w = [0.797 0.925], b = 0.174
SVM:  con el punto w = [0.797 0.925], b = 0.174
Logística:  sin el punto w = [1.514 1.298], b = -0.087
Logística:  con el punto w = [1.537 1.301], b = -0.123

La SVM no cambia nada: el punto nuevo está del lado correcto y fuera de la calle, así que su pérdida bisagra es cero y su subgradiente también. No es un vector de soporte. La logística sí cambia, poco pero cambia: la entropía cruzada nunca llega a cero, así que hasta un punto bien clasificado sigue empujando los pesos (cuanto más lejos está, menos empuja, pero nunca deja de hacerlo). Es la diferencia que viste en la figura de la bisagra: en la SVM solo unos pocos puntos deciden la frontera; en la logística opinan todos.

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

Xc, yc = load_breast_cancer(return_X_y=True)
Xc_ent, Xc_prueba, yc_ent, yc_prueba = train_test_split(
    Xc, yc, test_size=0.25, random_state=0, stratify=yc)

pipe_c = make_pipeline(StandardScaler(), SVC(kernel="rbf"))
rejilla_c = {"svc__C": [0.1, 1, 10, 100],
             "svc__gamma": [0.001, 0.01, 0.1, 1]}
busqueda_c = GridSearchCV(pipe_c, rejilla_c, cv=5,
                          return_train_score=True)
busqueda_c.fit(Xc_ent, yc_ent)
print("Mejor combinación:", busqueda_c.best_params_)
print(f"Validación cruzada: {busqueda_c.best_score_:.3f}"
      f"   prueba: {busqueda_c.score(Xc_prueba, yc_prueba):.3f}")

# La última combinación de la rejilla: C = 100 y gamma = 1
res = busqueda_c.cv_results_
print(f"C = 100, gamma = 1:  entrenamiento "
      f"{res['mean_train_score'][-1]:.3f}"
      f"   validación cruzada {res['mean_test_score'][-1]:.3f}")

Mejor combinación: {'svc__C': 100, 'svc__gamma': 0.001}
Validación cruzada: 0.988   prueba: 0.958
C = 100, gamma = 1:  entrenamiento 1.000   validación cruzada 0.629

a) La mejor combinación es C = 100 y γ = 0,001, con 0,988 en validación cruzada y 0,958 en prueba. Fíjate en que quedó en un borde de la rejilla (el C más grande y el γ más chico que probamos): conviene ampliar la rejilla hacia ese lado y buscar de nuevo, porque el mejor valor podría estar afuera. La prueba da algo menos que la validación cruzada; es normal, porque el mejor puntaje de una búsqueda es un poco optimista (tema 10).

b) Con C = 100 y γ = 1, el modelo acierta el 100 % de los datos con que entrena, pero en validación cruzada le va mucho peor: sobreajuste. Con 30 características estandarizadas, γ = 1 hace que cada vector de soporte solo influya en su vecindad inmediata, y C grande no perdona errores: el modelo memoriza. La exactitud de prueba se mide una sola vez, al final, con la combinación ya elegida.

a) No: la mejor SVM con solo x acierta 0,62 (8 de 13 puntos). Con una variable, un modelo lineal predice una clase a un lado de un umbral y la otra al otro lado. Pero la clase 1 está en el medio y la clase 0 en los dos extremos: ningún umbral solo puede separarlas.

b) Sí. Con x², los puntos del medio quedan abajo (x² chico) y los de los extremos arriba: una recta en el plano (x, x²) los separa. Esa recta, vuelta a la variable original, son dos umbrales, uno a cada lado del cero.

x = np.linspace(-3, 3, 13)
clase = (np.abs(x) <= 1.2).astype(int)

solo_x = LinearSVC().fit(x.reshape(-1, 1), clase)
print(f"Solo x:     aciertos {solo_x.score(x.reshape(-1, 1), clase):.2f}")

X_lev = np.column_stack([x, x ** 2])
levantado = LinearSVC().fit(X_lev, clase)
print(f"Con x y x²: aciertos {levantado.score(X_lev, clase):.2f}")

# La frontera w1·x + w2·x² + b = 0 es una ecuación de segundo grado
w_a, w_b = levantado.coef_[0]
print("Umbrales en x:",
      np.round(np.sort(np.roots([w_b, w_a, levantado.intercept_[0]])), 2))

Solo x:     aciertos 0.62
Con x y x²: aciertos 1.00
Umbrales en x: [-1.21  1.21]

Es el mismo truco que con los anillos de la teoría, en una dimensión menos: lo que en el espacio levantado es una frontera lineal, en el original es una frontera curva (aquí, dos cortes).

Este código hace los pasos 1 a 5. Los tiempos cambian de una computadora a otra, así que solo se comparan.

import time
from sklearn.datasets import load_digits
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

Xd, yd = load_digits(return_X_y=True)
Xd_ent, Xd_prueba, yd_ent, yd_prueba = train_test_split(
    Xd, yd, test_size=0.25, random_state=0, stratify=yd)

modelos = {
    "SVM (RBF)": make_pipeline(StandardScaler(), SVC()),
    "Logística": make_pipeline(StandardScaler(),
                               LogisticRegression(max_iter=2000)),
    "Bosque": RandomForestClassifier(random_state=0),
}
tiempos = {}
for nombre, modelo in modelos.items():
    inicio = time.perf_counter()
    modelo.fit(Xd_ent, yd_ent)
    medio = time.perf_counter()
    exactitud = modelo.score(Xd_prueba, yd_prueba)
    fin = time.perf_counter()
    tiempos[nombre] = (medio - inicio, fin - medio)
    print(f"{nombre:10s} exactitud en prueba {exactitud:.3f}")

print("¿La logística predice más rápido que la SVM?",
      tiempos["Logística"][1] < tiempos["SVM (RBF)"][1])

rejilla_d = {"svc__C": [1, 10, 100],
             "svc__gamma": [0.001, 0.01, 0.1]}
busqueda_d = GridSearchCV(make_pipeline(StandardScaler(), SVC()),
                          rejilla_d, cv=5)
busqueda_d.fit(Xd_ent, yd_ent)
print("Mejor combinación:", busqueda_d.best_params_)
print(f"Validación cruzada: {busqueda_d.best_score_:.3f}"
      f"   prueba: {busqueda_d.score(Xd_prueba, yd_prueba):.3f}")
mejor_svc = busqueda_d.best_estimator_[-1]
print("Vectores de soporte:", len(mejor_svc.support_), "de", len(yd_ent))

SVM (RBF)  exactitud en prueba 0.982
Logística  exactitud en prueba 0.969
Bosque     exactitud en prueba 0.980
¿La logística predice más rápido que la SVM? True
Mejor combinación: {'svc__C': 10, 'svc__gamma': 0.01}
Validación cruzada: 0.983   prueba: 0.980
Vectores de soporte: 619 de 1347

• Los tres modelos aciertan entre el 97 % y el 98 % de los dígitos de prueba. La SVM (0,982) y el bosque (0,980) quedan prácticamente empatados; la logística, un poco atrás (0,969). Con 450 imágenes de prueba, una diferencia de 0,002 es una sola imagen: no alcanza para declarar un ganador.
• Ajustar C y γ no mejoró la prueba (0,980 frente a 0,982 con los valores por defecto): los valores por defecto de SVC ya eran buenos para estos datos, y la diferencia es otra vez de una imagen.
• La SVM ajustada usa 619 de los 1347 ejemplos de entrenamiento como vectores de soporte, y para predecir tiene que comparar cada imagen nueva con todos ellos. Por eso la logística, que solo hace una multiplicación por sus pesos, predice más rápido. Con un millón de imágenes, entrenar SVC sería lentísimo: ahí convienen LinearSVC, la logística o una red neuronal.