Varianza, Desviación Estándar y Coeficiente de Variación: Midiendo la volatilidad de criptomonedas

Introducción

En este post vamos a entender tres conceptos estadísticos fundamentales usando un caso práctico: medir la volatilidad de criptomonedas.

Estas métricas responden preguntas como:

• ¿Qué tan estable es el precio de Bitcoin?
• ¿Es más volátil Ethereum o una stablecoin?
• ¿Cómo comparar la volatilidad de activos con precios muy diferentes?

---

El problema: Datos de precios

Imaginemos que tenemos los precios diarios (en USD) durante una semana de tres criptomonedas:

# Precios diarios en USD
bitcoin = [43000, 44500, 42000, 45000, 43500, 44000, 43200]
ethereum = [2300, 2450, 2200, 2500, 2350, 2400, 2320]
usdc = [1.00, 1.01, 0.99, 1.00, 1.00, 0.99, 1.01]  # stablecoin

Pregunta: ¿Cuál es más volátil?

A simple vista:

• Bitcoin varía entre $42,000 y$45,000 (rango: $3,000)
• Ethereum varía entre $2,200 y$2,500 (rango: $300)
• USDC varía entre $0.99 y$1.01 (rango: $0.02)

Pero el rango no es suficiente para comparar. Necesitamos medidas más robustas.

---

1. Media (Promedio)

Es el punto central de los datos.

Fórmula:

$\mu = \frac{1}{n} \sum_{i=1}^{n} x_i$

Cálculo manual:

bitcoin = [43000, 44500, 42000, 45000, 43500, 44000, 43200]

suma = 43000 + 44500 + 42000 + 45000 + 43500 + 44000 + 43200
n = 7
media = suma / n

print(f"Suma: {suma}")
print(f"Media: {media:.2f}")

Salida:

Suma: 305200
Media: 43600.00

Interpretación: El precio promedio de Bitcoin durante la semana fue $43,600.

---

2. Varianza

Mide qué tan dispersos están los datos respecto a la media. Es el promedio de las distancias al cuadrado.

Fórmula:

$\sigma^2 = \frac{1}{n} \sum_{i=1}^{n} (x_i - \mu)^2$

Paso a paso:

1. Calcular la media
2. Restar la media a cada valor
3. Elevar al cuadrado cada diferencia
4. Promediar

Cálculo manual:

import numpy as np

bitcoin = np.array([43000, 44500, 42000, 45000, 43500, 44000, 43200])

# Paso 1: Media
media = bitcoin.mean()
print(f"Media: {media:.2f}")

# Paso 2: Diferencias respecto a la media
diferencias = bitcoin - media
print(f"\nDiferencias: {diferencias}")

# Paso 3: Elevar al cuadrado
diferencias_cuadradas = diferencias ** 2
print(f"\nDiferencias²: {diferencias_cuadradas}")

# Paso 4: Promedio
varianza = diferencias_cuadradas.mean()
print(f"\nVarianza: {varianza:.2f}")

Salida:

Media: 43600.00

Diferencias: [ -600   900 -1600  1400  -100   400  -400]

Diferencias²: [ 360000  810000 2560000 1960000   10000  160000  160000]

Varianza: 1145714.29

Problema: La varianza está en unidades al cuadrado ($² USD²), lo cual no es interpretable.

---

3. Desviación Estándar

Es la raíz cuadrada de la varianza. Vuelve las unidades a la escala original.

Fórmula:

$\sigma = \sqrt{\sigma^2} = \sqrt{\frac{1}{n} \sum_{i=1}^{n} (x_i - \mu)^2}$

Cálculo manual:

import numpy as np

bitcoin = np.array([43000, 44500, 42000, 45000, 43500, 44000, 43200])

varianza = ((bitcoin - bitcoin.mean()) ** 2).mean()
desviacion_std = np.sqrt(varianza)

print(f"Varianza:          {varianza:.2f} USD²")
print(f"Desviación Std:    {desviacion_std:.2f} USD")

Salida:

Varianza:          1145714.29 USD²
Desviación Std:    1070.38 USD

Interpretación: Los precios de Bitcoin se desvían en promedio $1,070 del precio medio.

---

4. Coeficiente de Variación

Es la desviación estándar relativa a la media. Permite comparar la variabilidad de datasets con escalas diferentes.

Fórmula:

$CV = \frac{\sigma}{\mu} \times 100\%$

¿Por qué es útil?

No podemos comparar directamente:

• Bitcoin: $\sigma = 1070$ USD
• Ethereum: $\sigma = 100$ USD

Porque tienen precios promedio muy diferentes:

• Bitcoin: $\mu = 43,600$ USD
• Ethereum: $\mu = 2,360$ USD

El coeficiente de variación normaliza respecto a la media.

Cálculo manual:

import numpy as np

bitcoin = np.array([43000, 44500, 42000, 45000, 43500, 44000, 43200])
ethereum = np.array([2300, 2450, 2200, 2500, 2350, 2400, 2320])
usdc = np.array([1.00, 1.01, 0.99, 1.00, 1.00, 0.99, 1.01])

# Bitcoin
btc_media = bitcoin.mean()
btc_std = bitcoin.std()
btc_cv = (btc_std / btc_media) * 100

# Ethereum
eth_media = ethereum.mean()
eth_std = ethereum.std()
eth_cv = (eth_std / eth_media) * 100

# USDC (stablecoin)
usdc_media = usdc.mean()
usdc_std = usdc.std()
usdc_cv = (usdc_std / usdc_media) * 100

print("=" * 60)
print(f"{'Cripto':<10} {'Media':<12} {'Std Dev':<12} {'CV (%)':<10}")
print("=" * 60)
print(f"{'Bitcoin':<10} ${btc_media:<11.2f} ${btc_std:<11.2f} {btc_cv:.2f}%")
print(f"{'Ethereum':<10} ${eth_media:<11.2f} ${eth_std:<11.2f} {eth_cv:.2f}%")
print(f"{'USDC':<10} ${usdc_media:<11.2f} ${usdc_std:<11.4f} {usdc_cv:.2f}%")
print("=" * 60)

Salida:

============================================================
Cripto     Media        Std Dev      CV (%)    
============================================================
Bitcoin    $43600.00    $1070.38     2.45%
Ethereum   $2360.00     $106.90      4.53%
USDC       $1.00        $0.0082      0.82%
============================================================

Interpretación:

• USDC: CV = 0.82% → Muy estable (es una stablecoin)
• Bitcoin: CV = 2.45% → Moderadamente volátil
• Ethereum: CV = 4.53% → Más volátil que Bitcoin (casi el doble)

Aunque Bitcoin tiene mayor desviación estándar absoluta ($1,070 vs$107), Ethereum es proporcionalmente más volátil respecto a su precio medio.

---

Fórmulas clave

Varianza:

$\sigma^2 = \frac{1}{n} \sum_{i=1}^{n} (x_i - \mu)^2$

Desviación Estándar:

$\sigma = \sqrt{\sigma^2}$

Coeficiente de Variación:

$CV = \frac{\sigma}{\mu} \times 100\%$

---

Conclusión

Las tres métricas trabajan juntas:

1. Varianza ($\sigma^2$): Base matemática, unidades al cuadrado
2. Desviación Estándar ($\sigma$): Dispersión en unidades originales
3. Coeficiente de Variación (CV): Dispersión relativa, permite comparar

En nuestro ejemplo:

• USDC: Muy estable, ideal para preservar valor
• Bitcoin: Moderadamente volátil
• Ethereum: El más volátil de los tres (proporcionalmente)

Regla general: Mayor volatilidad = Mayor riesgo = Mayor potencial de ganancia (o pérdida)

---

Tags: #Estadística #Varianza #DesviacionEstandar #CoeficienteVariacion #Criptomonedas #Python