# Sumar y escalar, que ya es media predicción

URL canónica: https://missyera.com/guias/matematica-para-machine-learning/suma-y-escalado-de-vectores/
Última actualización: 2026-11-21
Autora: Gera Flores (Miss Yera)

> **Respuesta corta**
>
> Sumar dos vectores es sumar componente con componente. Multiplicar un vector por un número es multiplicar todas sus componentes por ese número. Con esas dos operaciones ya tienes lo que hace por dentro un modelo lineal: pesar cada característica y juntarlo todo.

Capítulo 3 de 22 del libro [Matemática para machine learning](https://missyera.com/guias/matematica-para-machine-learning.md).

## 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)
```

```text
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))
```

```text
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.

`𝐚 + 𝐛 = (a_1 + b_1, a_2 + b_2, …, a_d + b_d)`

sumar dos vectores es sumar componente con componente, cada una con la que le toca y con ninguna otra

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))
```

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

`α 𝐯 = (αv_1, αv_2, …, αv_d)`

multiplicar por un número escala todas las componentes por igual, sin cambiar la proporción entre ellas

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))
```

```text
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ó

Comprueba que lo tienes

Multiplicas cada característica de una venta por su peso y sumas todo. ¿Qué acabas de calcular?

- Una predicción lineal, que es lo que hace por dentro una regresión
- El promedio ponderado de la venta
- La distancia de esa venta al origen
- Nada útil, porque los pesos me los inventé yo

## Ejercicios

**1. El promedio es sumar y escalar**

Calcula la venta media a mano, sin usar mean.

```
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))
```

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

Sumar todos los vectores y escalar por 1 partido el número de filas. El promedio no es una operación aparte: son las dos de este capítulo.

**2. Cambia los pesos y mira qué manda**

Pon a cero el peso del monto y compara.

```
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))
```

```text
con monto : 448.13
sin monto : 280.0
```

Un peso en cero es lo mismo que borrar la columna. Y así es como se lee la importancia en un modelo lineal: el peso te dice cuánto pesa esa característica en el resultado. Con la trampa de que si las columnas están en escalas distintas, los pesos no se pueden comparar entre sí. Eso es el capítulo de escalado del libro de machine learning.

**3. La resta como error**

Compara la primera venta contra la venta media.

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

```text
diferencia : [  -1.68 -323.02    0.98]
```

Esta venta tuvo 1.68 unidades menos que la media, facturó 323.02 soles menos y tuvo casi un punto más de satisfacción. Ese vector de diferencias es la materia prima de casi todo: de la varianza, de la distancia y del error de un modelo.

## Preguntas frecuentes

### ¿Cómo se hace la suma de vectores?

Se suman componente a componente y sale otro vector del mismo largo. Si los largos no coinciden, la operación no existe.

### ¿Y la resta de vectores?

Igual, componente a componente. La resta de dos vectores es la flecha que va de uno al otro, y por eso mide la distancia entre dos clientes.

### ¿Qué es multiplicar un vector por un escalar?

Multiplicar cada componente por el mismo número. Estira el vector si el número es mayor que uno, lo encoge si es menor, y lo da vuelta si es negativo.

### ¿Qué son las operaciones con vectores?

Sumar, restar, escalar y el producto punto. Con esas cuatro está hecho casi todo lo que un modelo lineal calcula.

## Seguir leyendo

- Anterior: [Un vector no es una flecha, es una fila de tu tabla](https://missyera.com/guias/matematica-para-machine-learning/que-es-un-vector.md)
- Siguiente: [La operación que hace todo: el producto punto](https://missyera.com/guias/matematica-para-machine-learning/producto-punto.md)

## Contacto

- Diagnóstico de 30 minutos con Miss Yera: https://calendly.com/soymissyera/reunion-con-yera
- Correo: hola@missyera.com
- Esta página en HTML: https://missyera.com/guias/matematica-para-machine-learning/suma-y-escalado-de-vectores/
- Índice de todas las páginas en texto: https://missyera.com/llms-index.txt
