Programar o aprender

Dos flujos de información

Programar es construir una función que, dadas las reglas y los datos, produce las respuestas:

Aprender invierte el papel de los datos y de las reglas: se parte de ejemplos con su respuesta y se busca la regla.

Aquí «reglas» significa un modelo con parámetros $\theta$, elegidos para que se equivoque lo menos posible con los ejemplos. Una definición clásica, de Tom Mitchell (1997): un programa aprende de la experiencia $E$ respecto de una clase de tareas $T$ y una medida de desempeño $P$ si su desempeño en $T$, medido con $P$, mejora con $E$. En la lección, $T$ es clasificar correos, $E$ son los treinta ejemplos con respuesta y $P$ es la exactitud con correos nuevos.

El modelo de la lección

Cada correo se resume en dos medidas, $x_1$ (enlaces) y $x_2$ (% de mayúsculas). El modelo calcula un puntaje y decide por su signo:

Los parámetros son $\theta = (w_1, w_2, b)$ y la frontera $w_1 x_1 + w_2 x_2 + b = 0$ es una recta. Para entrenar, el puntaje se convierte en probabilidad con $p = \sigma(s) = 1/(1+e^{-s})$ y el error se mide con la entropía cruzada sobre los $n$ ejemplos, con $y_i = 1$ para spam y $0$ para normal:

Cada paso mueve los parámetros en contra del gradiente, $\theta \leftarrow \theta - \eta\,\nabla L(\theta)$ (lección 4). En la escena: $\eta = 0.5$, 300 pasos y los 30 ejemplos, con las medidas estandarizadas, $(x_1 - 3.5)/2.5$ y $(x_2 - 14)/8$, y un punto de partida arbitrario. El resultado, en las unidades originales, es $w_1 \approx 0.69$, $w_2 \approx 0.53$ y $b \approx -9.63$. La exactitud es aciertos entre total: 27 de 30 con los ejemplos y 52 de 60 con los nuevos. Los datos son sintéticos, inventados para ilustrar; no son correos reales.

La regla a mano de la lección, «spam si $x_1 \ge a$ o $x_2 \ge b$», tampoco es gratuita: también tiene parámetros, los dos umbrales. Aprender es dejar que los datos los fijen en lugar de ajustarlos a ojo.

Por qué la cifra con los ejemplos engaña

La exactitud medida con los mismos ejemplos que sirvieron para ajustar es, en promedio, optimista. En la lección, la mejor de las $10 \times 36 = 360$ reglas que permiten los deslizadores acierta 28 de los 30 ejemplos ($\approx 93\,\%$); hay seis empatadas y, con los 60 correos nuevos, esas seis aciertan entre 47 y 52 ($\approx 78\,\%$ a $87\,\%$). Entre las 84 reglas que aciertan 24 o más de los 30, 58 bajan con los nuevos, 16 suben y 10 quedan igual; el cambio medio es de $-3.2$ puntos porcentuales. Es una tendencia, no una ley: con solo 60 correos nuevos cada cifra es ruidosa, y una regla afinada con cuidado puede aguantar («enlaces $\ge 5$ o mayúsculas $\ge 17\,\%$» acierta 27 de 30 y 54 de 60). Cuantas más opciones se prueban sobre los mismos datos, más se ajusta uno al azar de esos datos.

Con pocos ejemplos pasa algo parecido. Con 4 ejemplos, el modelo acierta los 4 que vio y 48 de los 60 nuevos ($80\,\%$); con los 30, acierta 27 de 30 ($90\,\%$) y 52 de 60 ($87\,\%$): las dos cifras se acercan. Separar entrenamiento, validación y prueba, y medir bien, es el tema de la lección 10.

Samuel y las damas (1959)

El nombre machine learning se asocia a Arthur L. Samuel, que lo usa en el título de «Some Studies in Machine Learning Using the Game of Checkers» (IBM Journal of Research and Development, vol. 3, n.º 3, julio de 1959). Su programa, en una IBM 704, elegía jugadas mirando varias jugadas por delante y puntuaba cada posición del tablero con un «polinomio lineal», en sus palabras: una suma ponderada de rasgos del tablero. En una de sus dos formas de aprendizaje (la «generalización») el programa determinaba el signo y la magnitud de los coeficientes que multiplican esos rasgos y escogía qué términos usar: la misma forma de modelo que en esta lección, aunque con otro fin (puntuar posiciones, no clasificar). En la versión que describe había 38 términos, además del de ventaja de piezas, de los que 16 estaban activos a la vez. El resumen afirma que una computadora puede programarse para aprender a jugar mejor que la persona que escribió el programa, en 8 o 10 horas de juego de la máquina y dadas solo las reglas del juego, un sentido de dirección y una lista redundante e incompleta de parámetros. Y el propio artículo plantea el objetivo: programar las computadoras para que aprendan de la experiencia «debería eliminar con el tiempo la necesidad de buena parte de este esfuerzo de programación detallada» (traducción nuestra). La frase muy repetida «el campo de estudio que da a las computadoras la capacidad de aprender sin ser programadas explícitamente» se le atribuye con frecuencia, pero no figura en ese artículo.

Un caso real: filtrar correo basura

En 1998, Sahami, Dumais, Heckerman y Horvitz estudiaron cómo construir filtros de correo basura de forma automática. Señalan que las reglas escritas a mano suponen usuarios capaces de construirlas y deben ajustarse sin cesar a medida que cambia el correo basura, y proponen en cambio aprender de los mensajes del propio usuario. Su clasificador probabilístico (bayesiano ingenuo) combinaba el texto del mensaje con rasgos propios del problema, como el porcentaje de caracteres no alfanuméricos del asunto. Subrayan además que clasificar como basura un correo legítimo suele costar mucho más que dejar pasar uno de basura; por eso solo marcaban un mensaje como basura si su probabilidad superaba el 99.9 %.

En código

import math

# (enlaces, % de mayúsculas, es_spam)
datos = [(0, 5, 0), (1, 8, 0), (2, 10, 0), (3, 7, 0),
         (4, 20, 1), (6, 25, 1), (7, 15, 1), (9, 30, 1)]

def puntaje(w1, w2, b, enlaces, mayus):
    return w1 * enlaces + w2 * mayus + b

w1 = w2 = b = 0.0            # parámetros: se empieza con ceros
eta = 0.1                    # tamaño del paso
for _ in range(2000):        # entrenar: muchas pasadas por los ejemplos
    g1 = g2 = gb = 0.0
    for enlaces, mayus, y in datos:
        z = puntaje(w1, w2, b, enlaces / 10, mayus / 100)  # medidas a escala 0-1
        p = 1 / (1 + math.exp(-z))                         # probabilidad de spam
        e = p - y                                          # cuánto se equivoca
        g1 += e * enlaces / 10
        g2 += e * mayus / 100
        gb += e
    n = len(datos)
    w1 -= eta * g1 / n
    w2 -= eta * g2 / n
    b -= eta * gb / n

print(round(w1, 1), round(w2, 1), round(b, 1))   # pesos en la escala 0-1 de las medidas
# usar: parámetros fijos, solo aritmética
for enlaces, mayus in [(1, 6), (8, 12), (5, 30)]:
    s = puntaje(w1, w2, b, enlaces / 10, mayus / 100)
    print((enlaces, mayus), round(s, 1), 'spam' if s > 0 else 'normal')
# 7.7 2.8 -3.3
# (1, 6) -2.3 normal
# (8, 12) 3.3 spam
# (5, 30) 1.5 spam
# Estos 8 ejemplos se separan del todo: con más pasos los pesos seguirían creciendo;
# 2000 bastan para clasificarlos bien.

Lo que viene

En la lección 2 veremos cómo cualquier dato (una imagen, un sonido, un texto) se convierte en números para poder usarse como $x_1, x_2, \dots$; en la 3, cómo se mide el error de un modelo; y en la 4, cómo se ajustan los parámetros paso a paso (el descenso del gradiente que aquí solo se vio actuar). El modelo de esta lección, una suma ponderada que decide por su signo, es en esencia una neurona artificial (lección 5).