Sumar y escalar, que ya es media predicción

Dos operaciones y ya está 🌸

Este capítulo es corto porque los vectores solo saben hacer dos cosas: sumarse entre ellos y estirarse. Con eso se construye todo lo demás.

Volvemos a abrir el archivo

Cada capítulo arranca de cero, así que estas líneas se repiten. Son las mismas del capítulo 1 y las vas a ver en todos.

import pandas as pd
import numpy as np

df = pd.read_csv('ventas-miss-yera.csv')
for c in ('unidades', 'monto', 'satisfaccion'):
    df[c] = pd.to_numeric(df[c], errors='coerce')
X = df[['unidades', 'monto', 'satisfaccion']].dropna().to_numpy()
print('X.shape:', X.shape)

X.shape: (2238, 3)

Sumar es componente con componente

a, b = X[0], X[1]
print('a     :', np.round(a, 2))
print('b     :', np.round(b, 2))
print('a + b :', np.round(a + b, 2))
print('a - b :', np.round(a - b, 2))

a     : [ 10.   480.37   4.  ]
b     : [ 10.  524.9   3. ]
a + b : [  20.   1005.27    7.  ]
a - b : [  0.   -44.53   1.  ]

Las unidades con las unidades, los soles con los soles. Nunca se cruzan.

Y mira la resta, que es la que de verdad se usa: [0, -44.53, 1] te dice que las dos ventas tuvieron las mismas unidades, que la segunda facturó 44.53 soles más, y que la primera tuvo un punto más de satisfacción.

Guárdate eso, porque restar dos vectores es cómo se mide una diferencia, y medir diferencias es lo que hace un modelo cuando calcula cuánto se equivocó. Eso es el capítulo de norma y distancia.

Escalar es estirar

print('a * 2 :', np.round(a * 2, 2))
print('a / 2 :', np.round(a / 2, 2))

a * 2 : [ 20.   960.74   8.  ]
a / 2 : [  5.   240.18   2.  ]

Ese número que multiplica se llama escalar, y el nombre no es casual: escala el vector sin cambiar la proporción entre sus componentes.

Fíjate en a * 2: la satisfacción pasó a 8. Matemáticamente correcto y comercialmente absurdo, porque la escala llega a 5. Las operaciones no saben qué significan tus columnas: eso lo pones tú.

Y aquí está la predicción

Ahora júntalas. Supón que quieres estimar cuánto vale una venta, y decides que cada unidad vale 12, cada sol facturado vale 0.35 y cada punto de satisfacción vale 40.

pesos = np.array([12.0, 0.35, 40.0])
print('a       :', np.round(a, 2))
print('pesos   :', pesos)
print('a*pesos :', np.round(a * pesos, 2))
print('suma    :', round(float((a * pesos).sum()), 2))

a       : [ 10.   480.37   4.  ]
pesos   : [12.    0.35 40.  ]
a*pesos : [120.   168.13 160.  ]
suma    : 448.13

Multiplicar cada característica por su peso y sumarlo todo. Eso es una predicción lineal. Ese 448.13 es exactamente la forma que tiene la salida de una regresión lineal, de una regresión logística antes de la sigmoide, y de una sola neurona.

La única diferencia entre esto y un modelo de verdad es de dónde salen los pesos. Yo me los inventé; un modelo los aprende. Cómo los aprende es la parte de optimización de este libro, y lo que hace en cada paso es el capítulo del descenso de gradiente.

Y esa operación de "multiplicar componente a componente y sumar" es tan importante que tiene nombre propio y capítulo propio: el producto punto 🐣

Lo que te llevas

• Sumar vectores es componente con componente. Nunca se cruzan.
• Restar es cómo se mide una diferencia, y de ahí sale el error de un modelo.
• Escalar es multiplicar todo por un número, sin cambiar las proporciones.
• Pesar y sumar es literalmente lo que hace un modelo lineal.
• Las operaciones no saben qué significan tus columnas.

Comprueba que se entendió

Ejercicios

suma = X.sum(axis=0)
media = suma / X.shape[0]
print('a mano :', np.round(media, 2))
print('mean   :', np.round(X.mean(axis=0), 2))

a mano : [ 11.68 803.39   3.02]
mean   : [ 11.68 803.39   3.02]

sin_monto = np.array([12.0, 0.0, 40.0])
print('con monto :', round(float((a * pesos).sum()), 2))
print('sin monto :', round(float((a * sin_monto).sum()), 2))

con monto : 448.13
sin monto : 280.0

dif = a - X.mean(axis=0)
print('diferencia :', np.round(dif, 2))

diferencia : [  -1.68 -323.02    0.98]

Preguntas frecuentes