Broadcasting

Arreglos de formas distintas trabajando juntos

Hasta ahora combinamos arreglos de la misma forma. El broadcasting es el conjunto de reglas que permite a NumPy combinar arreglos de formas distintas sin copiar datos. El caso más simple es un escalar: a + 10 suma 10 a cada elemento, como si 10 se hubiera estirado a la forma de a. El mismo estiramiento funciona entre arreglos: un vector de tres números puede sumarse a cada fila de una matriz de tres columnas, un valor por columna. Así se resta la media de cada columna, se escala cada activo por su volatilidad o se construye una tabla de todas las diferencias por pares sin un solo bucle.

import numpy as np

a = np.array([[1.0, 2.0, 3.0],
              [4.0, 5.0, 6.0]])       # shape (2, 3)

print(a + 10)                          # a scalar is stretched to every element
# [[11. 12. 13.]
#  [14. 15. 16.]]

per_column = np.array([1, 10, 100])    # shape (3,): one value per column
print(a * per_column)
# [[  1.  20. 300.]
#  [  4.  50. 600.]]

print(a - a.mean(axis=0))              # subtract each column's mean
# [[-1.5 -1.5 -1.5]
#  [ 1.5  1.5  1.5]]

La regla: comparar las formas desde la derecha

NumPy alinea las dos formas desde la derecha. En cada posición los dos tamaños deben ser iguales, o uno de ellos debe ser 1 (y se estira), o uno de los arreglos simplemente no tiene dimensión ahí (se trata como 1). Las formas (2, 3) y (3,) funcionan: 3 se encuentra con 3, y la dimensión que falta se estira sobre las 2 filas. Las formas (2, 3) y (2,) fallan, porque 3 se encuentra con 2: NumPy lanza ValueError: operands could not be broadcast together. La forma del resultado toma el tamaño mayor en cada posición.

import numpy as np

a = np.ones((2, 3))
print((a + np.ones(3)).shape)        # (2, 3)   3 meets 3

try:
    a + np.ones(2)                   # 3 meets 2: no match
except ValueError as error:
    print(error)                     # operands could not be broadcast together with shapes (2,3) (2,)

# Size 1 stretches: (3, 1) with (1, 4) gives (3, 4)
print((np.ones((3, 1)) + np.ones((1, 4))).shape)   # (3, 4)

Vectores columna y tablas de pares

Un arreglo 1-D de forma (n,) siempre se alinea con el último eje, así que actúa como una fila. Para aplicar un valor por fila necesitas una columna de forma (n, 1): escribe x[:, np.newaxis] o x.reshape(-1, 1). Combinar una columna con una fila construye toda una tabla: x[:, None] - x[None, :] es la matriz n×n de todas las diferencias x[i] - x[j], y corr * vols[:, None] * vols[None, :] convierte una matriz de correlación en una de covarianza. Cuidado con el error opuesto: sumar formas (3,) y (3, 1) da en silencio una tabla 3×3, no un vector de tres números.

import numpy as np

x = np.array([1.0, 2.0, 4.0])
print(x[:, np.newaxis].shape, x.reshape(-1, 1).shape, x[None, :].shape)   # (3, 1) (3, 1) (1, 3)

# All pairwise differences x[i] - x[j]
print(x[:, None] - x[None, :])
# [[ 0. -1. -3.]
#  [ 1.  0. -2.]
#  [ 3.  2.  0.]]

# One factor per row needs a column
a = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
print(a * np.array([1.0, 2.0])[:, None])
# [[ 1.  2.  3.]
#  [ 8. 10. 12.]]

# Correlation matrix to covariance matrix
corr = np.array([[1.0, 0.5], [0.5, 1.0]])
vols = np.array([0.2, 0.3])
print(corr * vols[:, None] * vols[None, :])
# [[0.04 0.03]
#  [0.03 0.09]]

print((np.ones(3) + np.ones((3, 1))).shape)   # (3, 3)  a silent table, not a vector

import numpy as np

# Standardise every column at once: (x - mean) / std, column by column
a = np.array([[1.0, 10.0],
              [2.0, 20.0],
              [3.0, 30.0]])
z = (a - a.mean(axis=0)) / a.std(axis=0)   # (3, 2) - (2,) -> (3, 2), then divided by (2,)
print(z.round(3).tolist())                 # [[-1.225, -1.225], [0.0, 0.0], [1.225, 1.225]]
print(z.mean(axis=0).round(9).tolist())    # [0.0, 0.0]

# keepdims keeps the reduced axis, so the result can be broadcast back by row too
row_share = a / a.sum(axis=1, keepdims=True)
print(row_share.sum(axis=1).tolist())      # [1.0, 1.0, 1.0]

• Las formas se alinean desde la derecha: los tamaños deben ser iguales o 1 (o faltar); el resultado toma el mayor.
• (n,) actúa como una fila; haz una columna con x[:, None] o x.reshape(-1, 1).
• Columna con fila = una tabla: x[:, None] - x[None, :]; comprueba result.shape, las discrepancias fallan con ValueError.

A continuación: Series de pandas, arreglos unidimensionales que llevan una etiqueta con cada valor.

Lab: qué se califica

• Centrar cada columna con demean_columns25 pts
• Dar a cada fila su propio factor con scale_rows25 pts
• Construir la tabla de todas las diferencias con pairwise_differences25 pts
• Convertir correlaciones en covarianzas con covariance_from_correlation25 pts