Vectores y operaciones con sentido

Fundamentos — Leer las formas y las cuentas · Ruta de Aprendizaje

En 00 usamos filas y columnas. Ahora construiremos las operaciones que después usarán vecinos, PCA y atención. Los bloques continúan unos a otros; basta NumPy. Una forma compatible permite ejecutar, pero solo el significado de los ejes permite decidir si calculamos lo que queríamos.

Seleccionar sin confundir valor y posición

import numpy as np
 
X = np.array([[1., 2., 3.], [4., 5., 6.]])
print(X[1, 2])      # 6: fila 1, columna 2
print(X[0, :])      # [1., 2., 3.]: toda la fila 0
print(X[:, 1])      # [2., 5.]: toda la columna 1
print(X[:, 1:2])    # [[2.], [5.]]: una tabla de dos filas y una columna

La coma separa la selección de cada eje. : toma todas sus posiciones. Seleccionar un índice elimina ese eje; seleccionar un slice lo conserva: X[:,1] tiene forma (2,), mientras X[:,1:2] tiene (2,1).

scores = np.array([[0.2, 0.7, 0.1], [0.8, 0.1, 0.1]])
print(scores.max(axis=1))     # [0.7, 0.8]: valores mayores
print(scores.argmax(axis=1))  # [1, 0]: posiciones de esos valores

Cada fila es un ejemplo y cada columna una clase: argmax devuelve el índice de clase elegida. Con axis=0 compararíamos ejemplos dentro de cada columna, otra pregunta. En un empate, estas operaciones de índice de NumPy eligen la primera aparición; eso no aporta evidencia de que esa clase sea mejor.

Cambiar forma no es cambiar el orden de los ejes

Un vector de tres valores tiene un eje. Podemos añadir un eje de tamaño uno para interpretarlo como fila o columna:

v = np.array([1., 2., 3.])
fila = v.reshape(1, 3)
columna = v.reshape(3, 1)
print(v.shape, fila.shape, columna.shape)  # (3,) (1, 3) (3, 1)
print(v[:, None].shape)                   # (3, 1), otro modo de añadir ese eje
print(v.reshape(-1, 1).shape)             # (3, 1)

None en la indexación añade un eje. En reshape, un −1 pide inferir el tamaño que falta conservando la cantidad de elementos: tres valores y una columna necesitan tres filas. No sirve para inventar datos ni para corregir cualquier forma. v.T sigue teniendo (3,): con un solo eje no hay dos ejes que intercambiar.

print(X.T)                 # [[1.,4.], [2.,5.], [3.,6.]]
print(X.reshape(3, 2))     # [[1.,2.], [3.,4.], [5.,6.]]

La transposición intercambia filas y columnas: la columna original pasa a fila. reshape recorre los valores en el orden habitual y los reorganiza en otra forma. Ambas salidas tienen (3,2) pero contienen parejas diferentes. Si cada fila de X era una persona, el segundo resultado ya mezcla sus datos.

Una suma de productos

Una compra tiene cantidades [2,1,3] y precios unitarios [4,5,2]. El total es 2×4 + 1×5 + 3×2 = 19. Eso es el producto punto:

cantidades = np.array([2., 1., 3.])
precios = np.array([4., 5., 2.])
aportes = cantidades * precios
print(aportes)                    # [8., 5., 6.]
print(aportes.sum())              # 19
print(cantidades @ precios)       # 19: producto punto

* conserva un aporte por coordenada; @ los combina. Para dos compras y dos listas de precios, guardamos compras por filas y precios por columnas:

compras = np.array([[2., 1., 3.], [0., 2., 1.]])
tarifas = np.array([[4., 3.], [5., 6.], [2., 2.]])
totales = compras @ tarifas
print(totales)  # [[19.,18.], [12.,14.]]

La casilla (0,1) suma 2×3 + 1×6 + 3×2 = 18. Cada casilla combina una fila y una columna. Las dimensiones (2,3) @ (3,2) producen (2,2): el eje de productos, de tamaño tres, se suma; quedan compras y tarifas. La regla de formas resume esta cuenta, no sustituye comprenderla.

Distancia, longitud y dirección

Entre los puntos (1,2) y (4,6) hay cambios de 3 y 4. La distancia euclidiana es √(3²+4²)=5. La norma es la distancia al origen:

p = np.array([1., 2.])
q = np.array([4., 6.])
diferencia = q - p
distancia = np.sqrt((diferencia ** 2).sum())
print(diferencia, distancia)  # [3., 4.] 5.0
direccion = diferencia / distancia
print(direccion)             # [0.6, 0.8]: longitud 1

Dividir por la norma conserva la dirección y elimina la longitud. Un vector cero no tiene dirección: no podemos dividirlo por su norma. La similitud coseno compara direcciones mediante su producto punto una vez normalizadas; dos vectores del mismo sentido dan 1, perpendiculares dan 0 y opuestos −1. Ese parecido geométrico será útil solo si las coordenadas representan algo pertinente para la tarea.

Un promedio también combina vectores

Si tres vectores son (2,0), (0,4) y (4,4), una mezcla con pesos 0.25, 0.25 y 0.5 produce (2.5,3). Calculamos cada coordenada por separado:

valores = np.array([[2., 0.], [0., 4.], [4., 4.]])
pesos = np.array([0.25, 0.25, 0.5])
contribuciones = pesos[:, None] * valores
mezcla = contribuciones.sum(axis=0)
print(contribuciones)  # [[0.5,0.], [0.,1.], [2.,2.]]
print(mezcla)          # [2.5, 3.]
print(pesos @ valores) # la misma suma de productos

pesos[:,None] tiene (3,1): aplica un peso a las dos coordenadas de su fila. Después sumamos las tres filas. Es un promedio ponderado porque los pesos son no negativos y suman uno. Esta misma operación reaparecerá en atención; primero la entendemos sin una red.

Una variación para probar

Calcula la segunda compra con precios [1,2,3]. Luego cambia los pesos de la mezcla a [0.5,0.5,0]. Explica qué fila deja de aportar y por qué.


← 00 - De programar a programar con datos · Ruta de Aprendizaje · 01 - Pandas y mirar los datos →