Numpy: Estadística

NumPy proporciona numerosas funciones y herramientas para realizar análisis estadísticos eficientes en Python. Esta biblioteca es fundamental para cálculos estadísticos debido a su velocidad y capacidad para manejar grandes conjuntos de datos. En este módulo, exploraremos cómo utilizar NumPy para realizar diversas operaciones estadísticas, desde medidas básicas hasta análisis más complejos.

Medidas estadísticas descriptivas

Medidas de tendencia central

NumPy ofrece funciones para calcular las principales medidas descriptivas de un conjunto de datos. Estas funciones son optimizadas para trabajar con arrays, lo que las hace mucho más rápidas que sus equivalentes en Python puro.

Media aritmética

La media es el promedio de todos los valores en un conjunto de datos. Se puede calcular fácilmente con np.mean():

import numpy as np

datos = np.array([2, 4, 6, 8, 10])
media = np.mean(datos)
print(f"Media: {media}")  # Output: Media: 6.0

También puede calcular la media a lo largo de un eje específico en arrays multidimensionales:

matriz = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
media_filas = np.mean(matriz, axis=1)
media_columnas = np.mean(matriz, axis=0)
print(f"Media por filas: {media_filas}")  # Output: Media por filas: [2. 5. 8.]
print(f"Media por columnas: {media_columnas}")  # Output: Media por columnas: [4. 5. 6.]

Mediana

La mediana es el valor central cuando los datos están ordenados. NumPy proporciona la función np.median():

datos = np.array([1, 3, 5, 7, 9, 11])
mediana = np.median(datos)
print(f"Mediana: {mediana}")  # Output: Mediana: 6.0

# Para un conjunto con número par de elementos
datos_par = np.array([1, 3, 5, 7, 9, 11, 13, 15])
mediana_par = np.median(datos_par)
print(f"Mediana (conjunto par): {mediana_par}")  # Output: Mediana (conjunto par): 8.0

Moda

Aunque NumPy no tiene una función específica para la moda, puede calcularla utilizando scipy.stats:

from scipy import stats

datos = np.array([1, 2, 2, 3, 4, 4, 4, 5])
moda = stats.mode(datos)
print(f"Moda: {moda.mode[0]}, Frecuencia: {moda.count[0]}")  # Output: Moda: 4, Frecuencia: 3

Medidas de dispersión

Las medidas de dispersión indican cuánto se desvían los datos de la media.

Varianza

La varianza mide la dispersión promedio de los datos respecto a la media:

datos = np.array([2, 4, 6, 8, 10])
varianza = np.var(datos)
print(f"Varianza: {varianza}")  # Output: Varianza: 8.0

Por defecto, NumPy calcula la varianza poblacional dividiendo por N. Si desea la varianza muestral (dividida por N-1), debe especificarlo:

# Varianza muestral (dividida por N-1)
varianza_muestral = np.var(datos, ddof=1)
print(f"Varianza muestral: {varianza_muestral}")  # Output: Varianza muestral: 10.0

Desviación estándar

La desviación estándar es la raíz cuadrada de la varianza:

datos = np.array([2, 4, 6, 8, 10])
desviacion = np.std(datos)
print(f"Desviación estándar: {desviacion}")  # Output: Desviación estándar: 2.8284...

# Desviación estándar muestral
desviacion_muestral = np.std(datos, ddof=1)
print(f"Desviación estándar muestral: {desviacion_muestral}")  # Output: Desviación estándar muestral: 3.1622...

Medidas de posición

NumPy también proporciona funciones para calcular percentiles y cuartiles.

Percentiles

Los percentiles dividen un conjunto de datos en 100 partes iguales:

datos = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Calcular el percentil 25 (primer cuartil)
p25 = np.percentile(datos, 25)
print(f"Percentil 25: {p25}")  # Output: Percentil 25: 3.25

# Calcular el percentil 50 (mediana)
p50 = np.percentile(datos, 50)
print(f"Percentil 50: {p50}")  # Output: Percentil 50: 5.5

# Calcular el percentil 75 (tercer cuartil)
p75 = np.percentile(datos, 75)
print(f"Percentil 75: {p75}")  # Output: Percentil 75: 7.75

# Calcular múltiples percentiles a la vez
percentiles = np.percentile(datos, [25, 50, 75])
print(f"Percentiles [25, 50, 75]: {percentiles}")  # Output: Percentiles [25, 50, 75]: [3.25 5.5  7.75]

Cuantiles

NumPy también proporciona la función np.quantile() que es similar a np.percentile() pero trabaja con fracciones entre 0 y 1:

datos = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Primer cuartil (Q1) - equivalente a percentil 25
q1 = np.quantile(datos, 0.25)
print(f"Q1: {q1}")  # Output: Q1: 3.25

# Segundo cuartil (Q2) - equivalente a percentil 50 o mediana
q2 = np.quantile(datos, 0.5)
print(f"Q2: {q2}")  # Output: Q2: 5.5

# Tercer cuartil (Q3) - equivalente a percentil 75
q3 = np.quantile(datos, 0.75)
print(f"Q3: {q3}")  # Output: Q3: 7.75

Rango intercuartílico (IQR)

El rango intercuartílico (IQR) es una medida de dispersión estadística y se calcula como la diferencia entre el tercer y primer cuartil:

datos = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
q1 = np.percentile(datos, 25)
q3 = np.percentile(datos, 75)
iqr = q3 - q1
print(f"Rango intercuartílico: {iqr}")  # Output: Rango intercuartílico: 4.5

El IQR es útil para identificar valores atípicos (outliers):

datos = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 100])
q1 = np.percentile(datos, 25)
q3 = np.percentile(datos, 75)
iqr = q3 - q1

# Límites para detectar outliers
limite_inferior = q1 - 1.5 * iqr
limite_superior = q3 + 1.5 * iqr

print(f"Límite inferior: {limite_inferior}")
print(f"Límite superior: {limite_superior}")

# Identificar outliers
outliers = datos[(datos < limite_inferior) | (datos > limite_superior)]
print(f"Outliers: {outliers}")  # Debería identificar 100 como outlier

Distribuciones estadísticas

NumPy proporciona funciones para trabajar con diversas distribuciones estadísticas a través del módulo numpy.random.

Distribución normal (gaussiana)

La distribución normal es una de las más importantes en estadística:

# Generar una muestra de 1000 números con distribución normal (media=0, desviación=1)
muestra_normal = np.random.normal(loc=0, scale=1, size=1000)

# Calcular estadísticas básicas
print(f"Media: {np.mean(muestra_normal):.4f}")
print(f"Desviación estándar: {np.std(muestra_normal):.4f}")

# Visualizar histograma (requiere matplotlib)
import matplotlib.pyplot as plt
plt.hist(muestra_normal, bins=30, density=True, alpha=0.7, color='skyblue')
plt.title('Distribución Normal')
plt.axvline(x=np.mean(muestra_normal), color='red', linestyle='--')
plt.show()

Distribución uniforme

La distribución uniforme genera números aleatorios con igual probabilidad dentro de un rango:

# Generar 1000 números con distribución uniforme entre 0 y 1
muestra_uniforme = np.random.uniform(low=0, high=1, size=1000)

print(f"Media: {np.mean(muestra_uniforme):.4f}")
print(f"Desviación estándar: {np.std(muestra_uniforme):.4f}")

Otras distribuciones

NumPy permite generar muestras de muchas otras distribuciones estadísticas:

# Distribución binomial (lanzar una moneda 10 veces, probabilidad de cara=0.5, repetir 1000 experimentos)
binomial = np.random.binomial(n=10, p=0.5, size=1000)

# Distribución de Poisson (eventos con tasa media de 4, generar 1000 experimentos)
poisson = np.random.poisson(lam=4, size=1000)

# Distribución exponencial (con parámetro de escala=2, generar 1000 números)
exponencial = np.random.exponential(scale=2, size=1000)

Análisis de correlación

Covarianza

La covarianza mide cómo dos variables cambian juntas. NumPy proporciona la función np.cov():

# Crear dos variables correlacionadas
x = np.random.normal(0, 1, 1000)
y = x * 0.8 + np.random.normal(0, 0.5, 1000)  # y depende parcialmente de x

# Calcular matriz de covarianza
matriz_cov = np.cov(x, y)
print("Matriz de covarianza:")
print(matriz_cov)

# La covarianza entre x e y está en matriz_cov[0, 1] o matriz_cov[1, 0]
covarianza_xy = matriz_cov[0, 1]
print(f"Covarianza entre x e y: {covarianza_xy:.4f}")

La matriz de covarianza contiene la varianza de cada variable en la diagonal y la covarianza entre pares de variables en las posiciones fuera de la diagonal.

Coeficiente de correlación

El coeficiente de correlación de Pearson normaliza la covarianza para obtener un valor entre -1 y 1:

# Calcular matriz de correlación
matriz_corr = np.corrcoef(x, y)
print("Matriz de correlación:")
print(matriz_corr)

# El coeficiente de correlación entre x e y está en matriz_corr[0, 1] o matriz_corr[1, 0]
correlacion_xy = matriz_corr[0, 1]
print(f"Correlación entre x e y: {correlacion_xy:.4f}")

También puede calcular la correlación entre múltiples variables:

# Crear tres variables con diferentes relaciones
x = np.random.normal(0, 1, 100)
y = x * 0.8 + np.random.normal(0, 0.5, 100)  # Correlación positiva con x
z = -x * 0.5 + np.random.normal(0, 0.7, 100)  # Correlación negativa con x

# Agrupar variables
datos = np.vstack((x, y, z))

# Calcular matriz de correlación
matriz_corr = np.corrcoef(datos)
print("Matriz de correlación para x, y, z:")
print(matriz_corr)

Análisis de frecuencias y binning

Histogramas

NumPy proporciona funciones para calcular histogramas de datos:

# Generar datos aleatorios
datos = np.random.normal(170, 10, 1000)  # 1000 alturas con media 170 y desviación 10

# Calcular histograma
hist, bins = np.histogram(datos, bins=10)

print("Frecuencias:")
print(hist)
print("Límites de los bins:")
print(bins)

# Visualizar (requiere matplotlib)
plt.hist(datos, bins=10, alpha=0.7, color='skyblue')
plt.title('Histograma de alturas')
plt.xlabel('Altura (cm)')
plt.ylabel('Frecuencia')
plt.show()

Función histograma con densidad

Para obtener una densidad de probabilidad en lugar de frecuencias absolutas:

# Histograma normalizado (densidad)
hist, bins = np.histogram(datos, bins=10, density=True)

print("Densidades:")
print(hist)
print("Área total bajo la cur