Broadcasting

import numpy as np

lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))
print("lecturas:", lecturas.shape)

print()
print("Broadcasting es lo que permite que dos arrays de formas DISTINTAS")
print("participen de una operacion elemento a elemento.")
print()
print("Las reglas, aplicadas alineando las formas por la DERECHA:")
print("   1. si las dos dimensiones son iguales -> pasa")
print("   2. si una de las dos vale 1           -> se estira")
print("   3. si a una le falta la dimension     -> se agrega como 1")
print("   cualquier otra cosa                   -> ValueError")

print()
print("CASO 1 - con un escalar. Es el que ya usabas:")
print("   lecturas * 2      -> shape", (lecturas * 2).shape)
print("   El numero no tiene forma, asi que se repite en todos lados.")

print()
print("CASO 2 - restar el promedio de cada HORA (una columna por hora):")
por_hora = np.nanmean(lecturas, axis=0)
print("   por_hora.shape       :", por_hora.shape)
print("   lecturas - por_hora  -> shape", (lecturas - por_hora).shape)
print("   Alineado a la derecha: 24 contra 24 coinciden, y el 10 de la")
print("   izquierda no tiene con quien: se repite.")
print("   comprobacion: el promedio por hora del resultado da cero ->",
      np.round(np.nanmean(lecturas - por_hora, axis=0), 10)[:4], "...")

print()
print("CASO 3 - restar el promedio de cada SENSOR. Aca NO alcanza:")
por_sensor = np.nanmean(lecturas, axis=1)
print("   por_sensor.shape:", por_sensor.shape)
try:
    lecturas - por_sensor
except ValueError as error:
    print("   lecturas - por_sensor ->", type(error).__name__)
    print("  ", error)
print("   Alineado a la derecha, ese 10 se compara contra las 24")
print("   columnas. No son iguales y ninguno vale 1: choca.")

print()
print("EL ARREGLO - darle la dimension que le falta:")
columna = por_sensor.reshape(-1, 1)
print("   por_sensor.reshape(-1, 1).shape ->", columna.shape)
centrado = lecturas - columna
print("   lecturas - columna -> shape", centrado.shape)
print("   comprobacion: el promedio por sensor del resultado da cero ->",
      np.round(np.nanmean(centrado, axis=1), 10))

print()
print("O directamente, pidiendole a la reduccion que conserve la dimension:")
otro = lecturas - np.nanmean(lecturas, axis=1, keepdims=True)
print("   np.nanmean(..., keepdims=True).shape ->",
      np.nanmean(lecturas, axis=1, keepdims=True).shape)
print("   ¿mismo resultado?", np.allclose(centrado, otro, equal_nan=True))
print("   keepdims=True es la forma recomendada: dice la intencion y")
print("   evita acordarse de si el reshape va (-1, 1) o (1, -1).")

import numpy as np

lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))

# La lectura imposible se marca como ausente antes de cualquier cuenta:
# con 999.9 adentro, la media y el desvio de S05 no significan nada.
limpias = np.where(lecturas > 50, np.nan, lecturas)
print("NaN antes:", int(np.isnan(lecturas).sum()),
      "| despues de marcar el imposible:", int(np.isnan(limpias).sum()))

medias = np.nanmean(limpias, axis=1, keepdims=True)
desvios = np.nanstd(limpias, axis=1, keepdims=True)
print()
print("medias.shape :", medias.shape)
print("desvios.shape:", desvios.shape)

z = (limpias - medias) / desvios
print()
print("z = (limpias - medias) / desvios   -> shape", z.shape)
print("Una sola linea, dos broadcasts: (10,24) con (10,1), dos veces.")

print()
print("Y esto es lo que consigue: cada sensor queda con media 0 y desvio 1,")
print("aunque midan temperaturas distintas.")
print(f"   {'sensor':<8} {'media orig':>11} {'desvio orig':>12} "
      f"{'media z':>9} {'desvio z':>9}")
for i in range(10):
    print(f"   S{i + 1:02d}      {float(medias[i, 0]):>11.2f} "
          f"{float(desvios[i, 0]):>12.2f} "
          f"{float(np.nanmean(z[i])):>9.2f} {float(np.nanstd(z[i])):>9.2f}")

print()
print("Para que sirve: ahora las lecturas de sensores distintos se pueden")
print("comparar entre si. Un z de 2.1 significa lo mismo en el deposito")
print("que en la sala de servidores: 'dos desvios por encima de LO SUYO'.")

print()
print("El maximo z de cada sensor, que es su hora mas atipica:")
horas = [f"h{h:02d}" for h in range(24)]
for i in range(10):
    fila = z[i]
    if np.isnan(fila).all():
        continue
    j = int(np.nanargmax(np.abs(fila)))
    print(f"   S{i + 1:02d}  {horas[j]}  z = {fila[j]:+.2f}  "
          f"({limpias[i, j]:.1f} grados)")

print()
print("Sin centrar, la hora mas calurosa seria siempre la del sensor mas")
print("caluroso. Centrando, cada uno se compara consigo mismo.")
print()
print("El z-score vuelve en la leccion 3.7 como criterio de atipico, y en")
print("el ejercicio EJ-3.2 sobre las notas de los estudiantes.")

import numpy as np

sensores = np.arange(1, 11)          # (10,)
horas = np.arange(24)                # (24,)
print("sensores:", sensores.shape, "| horas:", horas.shape)

print()
print("Tres formas de agregar una dimension, y son la misma:")
print("   sensores.reshape(-1, 1).shape   ->", sensores.reshape(-1, 1).shape)
print("   sensores[:, np.newaxis].shape   ->", sensores[:, np.newaxis].shape)
print("   sensores[:, None].shape         ->", sensores[:, None].shape)
print("   np.newaxis ES None: se escribe asi porque se lee mejor.")

print()
print("Y del otro lado, para hacerlo fila:")
print("   horas[np.newaxis, :].shape ->", horas[np.newaxis, :].shape)

print()
print("Ahora el caso que sorprende: dos vectores dan una MATRIZ.")
combinaciones = sensores[:, None] * 100 + horas[None, :]
print("   sensores[:, None] * 100 + horas[None, :] -> shape",
      combinaciones.shape)
print("   primeras 3 filas, primeras 6 columnas:")
print(combinaciones[:3, :6])
print("   Cada sensor se combino con cada hora: 10 x 24 = 240 numeros")
print("   a partir de 34. Se llama producto exterior, y es como se")
print("   arman grillas de coordenadas.")

print()
print("Sirve tambien para tablas de distancias, o para una tabla de")
print("multiplicar sin bucles:")
n = np.arange(1, 6)
print("   n[:, None] * n[None, :] ->")
print(n[:, None] * n[None, :])

print()
print("=" * 62)
print("EL COSTO ESCONDIDO")
print("=" * 62)
print("Broadcasting no copia los datos para operar, pero el RESULTADO si")
print("ocupa el tamano completo.")
a = np.arange(10)
b = np.arange(24)
resultado = a[:, None] + b[None, :]
print(f"   a: {a.nbytes} bytes | b: {b.nbytes} bytes | "
      f"a[:, None] + b: {resultado.nbytes} bytes")
print("   Con 10 y 24 no importa. Con dos vectores de 100.000:")
print("   100000 x 100000 x 8 bytes = 80 GB. No entra.")
print("   Es el error de memoria mas comun de NumPy, y siempre viene de")
print("   un broadcast que uno no queria hacer.")

print()
print("La senal de alarma: mirar el shape ANTES de dejar correr la linea.")
print("   np.broadcast_shapes((10,), (24,))     ->", end=" ")
try:
    print(np.broadcast_shapes((10,), (24,)))
except ValueError as error:
    print(type(error).__name__ + ":", error)
print("   np.broadcast_shapes((10, 1), (1, 24)) ->",
      np.broadcast_shapes((10, 1), (1, 24)))
print("   np.broadcast_shapes((10, 24), (24,))  ->",
      np.broadcast_shapes((10, 24), (24,)))
print("   Contesta la pregunta sin construir nada.")