Normalización de datos: qué es, para qué sirve y cómo revertirla

Introducción

Cuando trabajamos con datos en Machine Learning, es muy común encontrarnos con variables que tienen escalas completamente distintas.

Por ejemplo:

Variable	Rango típico
edad	18 – 80
salario	20.000 – 200.000
horas trabajadas	0 – 60

Si usamos estas variables directamente sin ningún tratamiento, el modelo puede verse dominado por las que tienen valores más grandes, no porque sean más importantes, sino simplemente porque sus números son mayores.

La normalización resuelve ese problema.

---

1. ¿Qué es normalizar datos?

Normalizar es transformar los valores de una variable para que queden en una escala común, sin cambiar la información que contienen.

El modelo ya no ve “80.000 de salario” sino algo como “0.45”, que está en la misma escala que el resto de las variables.

Hay dos formas principales de normalizar:

• Min-Max Scaling: lleva los datos a un rango fijo, generalmente [0, 1].
• Estandarización (Z-score): transforma los datos usando la media y la desviación estándar.

En este post nos vamos a enfocar en la estandarización, que es la más usada en Machine Learning.

---

2. ¿Para qué sirve normalizar?

Evitar que una variable domine por su escala

Si una variable va de 0 a 1 y otra va de 0 a 100.000, los algoritmos basados en distancias o gradientes van a “escuchar” más a la que tiene valores grandes, aunque no sea más relevante.

Mejorar la convergencia del gradiente descendente

Cuando los datos están en escalas muy distintas, el gradiente oscila y converge más lento. Con datos normalizados, los pasos son más uniformes y el entrenamiento es más estable.

Es requisito para muchos algoritmos

Algoritmos como:

• regresión lineal con regularización,
• redes neuronales,
• KNN,
• SVM,

asumen o se benefician de que los datos estén en la misma escala.

---

3. ¿Cuándo usar la estandarización con media y desviación estándar?

La estandarización (también llamada Z-score normalization) se recomienda cuando:

• no sabes el rango máximo y mínimo de tus datos de antemano,
• los datos pueden tener valores extremos (outliers) y no querés que distorsionen la escala,
• el algoritmo asume que los datos siguen una distribución aproximadamente normal,
• usás algoritmos que dependen de distancias o gradientes.

---

4. La fórmula de estandarización

La fórmula es:

$z = \frac{x - \mu}{\sigma}$

Donde:

• $x$ = valor original,
• $\mu$ = media del conjunto,
• $\sigma$ = desviación estándar del conjunto,
• $z$ = valor estandarizado.

Si no tenés claro qué es la varianza o la desviación estándar, te recomiendo leer primero: Varianza, Desviación Estándar y Coeficiente de Variación

Lo que hace esta fórmula es:

1. Restar la media: centra los datos en 0. La media del resultado va a ser 0.
2. Dividir por la desviación estándar: escala los datos para que la dispersión sea uniforme. La desviación estándar del resultado va a ser 1.

---

5. Ejemplo numérico paso a paso (sin código)

Supongamos que tenemos los salarios de 5 personas:

[20.000, 40.000, 60.000, 80.000, 100.000]

Paso 1: calcular la media

$\mu = \frac{20.000 + 40.000 + 60.000 + 80.000 + 100.000}{5} = 60.000$

Paso 2: calcular la desviación estándar

Primero calculamos las diferencias respecto a la media:

20.000 - 60.000 = -40.000
40.000 - 60.000 = -20.000
60.000 - 60.000 =       0
80.000 - 60.000 =  20.000
100.000 - 60.000 =  40.000

Elevamos al cuadrado y promediamos:

$\sigma^2 = \frac{(-40.000)^2 + (-20.000)^2 + 0^2 + 20.000^2 + 40.000^2}{5} = 800.000.000$

$\sigma = \sqrt{800.000.000} \approx 28.284$

Paso 3: aplicar la fórmula

Salario original	Cálculo	Valor estandarizado
20.000	(20.000 − 60.000) / 28.284	−1.414
40.000	(40.000 − 60.000) / 28.284	−0.707
60.000	(60.000 − 60.000) / 28.284	0.000
80.000	(80.000 − 60.000) / 28.284	0.707
100.000	(100.000 − 60.000) / 28.284	1.414

El resultado tiene:

• media = 0
• desviación estándar = 1

---

6. ¿Por qué los datos estandarizados siguen siendo los mismos datos?

Esta es una pregunta clave.

La estandarización no cambia la información ni las relaciones entre los datos. Solo cambia la escala, no el contenido.

Fijate en los valores estandarizados de arriba:

• el orden se mantiene igual,
• las distancias relativas entre los valores son iguales,
• el valor más bajo sigue siendo el más bajo,
• el valor del medio sigue siendo el del medio.

Lo único que cambió fue la unidad de medida.

Es como pasar de medir en metros a medir en centímetros o en pulgadas: los objetos no cambiaron, solo la forma de expresar la medida.

---

7. Cómo recuperar los datos originales (desnormalizar)

Si tenés los valores estandarizados $z$ y guardaste $\mu$ y $\sigma$, podés volver a los datos originales con la operación inversa:

$x = z \cdot \sigma + \mu$

Eso es todo. Solo multiplicás por la desviación estándar y sumás la media.

Ejemplo con los valores anteriores

Queremos recuperar el salario original del primer empleado:

$z = -1.414, \quad \mu = 60.000, \quad \sigma = 28.284$

$x = -1.414 \times 28.284 + 60.000 \approx 20.000 ✓$

---

8. Por eso siempre hay que guardar µ y σ del entrenamiento

Este punto es importante en la práctica.

Si no estás familiarizado con la división entre datos de entrenamiento y de prueba, te recomiendo leer antes: Conjunto de entrenamiento (train) y prueba (test)

Cuando normalizás un dataset, calculás µ y σ usando solo los datos de entrenamiento.

Luego:

• usás esos mismos µ y σ para normalizar los datos de test,
• y también para desnormalizar las predicciones si fuera necesario.

Si calculás µ y σ por separado para train y test, estarás usando escalas distintas, lo cual introduce inconsistencias.

---

9. Ahora con código

import numpy as np

salarios = np.array([20000, 40000, 60000, 80000, 100000], dtype=float)

# Calcular media y desviación estándar
mu = salarios.mean()
sigma = salarios.std()

print(f"Media (µ):              {mu:.2f}")
print(f"Desviación estándar (σ): {sigma:.2f}")

# Estandarizar
salarios_norm = (salarios - mu) / sigma

print(f"\nSalarios originales:     {salarios}")
print(f"Salarios estandarizados: {salarios_norm}")

# Verificar media y std del resultado
print(f"\nMedia normalizada:    {salarios_norm.mean():.10f}")
print(f"Std normalizada:      {salarios_norm.std():.10f}")

Resultado:

Media (µ):               60000.00
Desviación estándar (σ): 28284.27

Salarios originales:     [ 20000.  40000.  60000.  80000. 100000.]
Salarios estandarizados: [-1.41421356 -0.70710678  0.          0.70710678  1.41421356]

Media normalizada:    0.0000000000
Std normalizada:      1.0000000000

---

10. Recuperar los datos originales con código

# Desnormalizar
salarios_recuperados = salarios_norm * sigma + mu

print(f"Salarios recuperados: {salarios_recuperados}")

Resultado:

Salarios recuperados: [ 20000.  40000.  60000.  80000. 100000.]

Los datos originales se recuperan exactamente.

---

11. Con sklearn: StandardScaler

En la práctica se usa StandardScaler de scikit-learn, que hace exactamente lo mismo pero de forma más cómoda y consistente cuando hay que aplicarlo sobre train y test por separado.

import numpy as np
from sklearn.preprocessing import StandardScaler

salarios = np.array([20000, 40000, 60000, 80000, 100000], dtype=float).reshape(-1, 1)

scaler = StandardScaler()

# Ajustar con datos de entrenamiento y transformar
salarios_norm = scaler.fit_transform(salarios)
print("Estandarizados:")
print(salarios_norm.flatten())

# Recuperar los datos originales
salarios_recuperados = scaler.inverse_transform(salarios_norm)
print("\nRecuperados:")
print(salarios_recuperados.flatten())

Resultado:

Estandarizados:
[-1.41421356 -0.70710678  0.          0.70710678  1.41421356]

Recuperados:
[20000. 40000. 60000. 80000. 100000.]

El método inverse_transform hace exactamente $x = z \cdot \sigma + \mu$ por vos.

---

12. Flujo correcto cuando hay train y test

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import numpy as np

X = np.array([[20000], [40000], [60000], [80000], [100000],
              [30000], [50000], [70000], [90000], [110000]], dtype=float)

X_train, X_test = train_test_split(X, test_size=0.2, random_state=42)

scaler = StandardScaler()

# Ajustar SOLO con train, transformar ambos
X_train_norm = scaler.fit_transform(X_train)
X_test_norm  = scaler.transform(X_test)  # solo transform, no fit

print("X_train normalizado:", X_train_norm.flatten())
print("X_test  normalizado:", X_test_norm.flatten())

La clave está en la línea del test:

• fit_transform → ajusta µ y σ y transforma. Solo para train.
• transform → usa µ y σ ya aprendidos. Solo para test.

---

13. Resumen visual del proceso

Datos originales
      ↓
  calcular µ y σ  (solo con train)
      ↓
  z = (x - µ) / σ  →  datos normalizados
      ↓
  entrenar modelo con datos normalizados
      ↓
  obtener predicción normalizada
      ↓
  x = z * σ + µ  →  predicción en escala original

---

Conclusión

La normalización por estandarización:

1. centra los datos en 0 (restando la media),
2. escala los datos para que tengan desviación estándar 1 (dividiendo por σ),
3. no pierde información: el orden y las relaciones relativas se mantienen,
4. se puede revertir exactamente con $x = z \cdot \sigma + \mu$,
5. siempre se calcula sobre train y se aplica igual a test.

---

Frase final para el post

Normalizar no cambia lo que dicen los datos. Solo hace que todos hablen el mismo idioma.