Logo de Pablo MadariagaPablo MadariagaData ScientistAgendar reunión

Capítulo 9

Procesos Aleatorios

Secuencias de variables aleatorias indexadas en el tiempo: estacionariedad, autocorrelación, densidad espectral de potencia y filtrado óptimo.

9.1 Conceptos Básicos

Un proceso aleatorio X(t)

Un proceso aleatorio es una colección de variables aleatorias indexadas por tiempo: {X(t):t∈T}\{X(t) : t \in T\}.

Para cada t fijo, X(t)X(t) es una variable aleatoria. Para cada resultado ω fijo, X(⋅,ω)X(\cdot, \omega) es unatrayectoria (realización) del proceso.

Clasificación

  • • Tiempo discreto vs continuo
  • • Estado discreto vs continuo
  • • Estacionario vs no estacionario
  • • Markov vs no Markov

Ejemplos

  • • Ruido blanco: X(t)X(t) independientes
  • • Paseo aleatorio: X(t)=X(t−1)+W(t)X(t) = X(t-1) + W(t)
  • • Proceso de Poisson: conteo de eventos
  • • Señal de audio, precio de acciones

9.2 Funciones de Media y Correlación

Estadísticos de primer y segundo orden

Función de media

μX(t)=E[X(t)]\mu_X(t) = \mathbb{E}[X(t)]

Valor esperado del proceso en cada instante t.

Autocorrelación

RX(t1,t2)=E[X(t1)X(t2)]R_X(t_1, t_2) = \mathbb{E}[X(t_1) X(t_2)]

Mide la relación lineal del proceso consigo mismo en dos instantes.

Autocovarianza

CX(t1,t2)=RX(t1,t2)−μX(t1)μX(t2)C_X(t_1, t_2) = R_X(t_1, t_2) - \mu_X(t_1) \mu_X(t_2)

9.3 Procesos Estacionarios en Sentido Amplio (WSS)

Propiedades que no cambian con el tiempo

Un proceso es WSS si cumple:

  1. μX(t)=μ\mu_X(t) = \mu (constante)
  2. RX(t1,t2)=RX(τ)R_X(t_1, t_2) = R_X(\tau) donde τ=t1−t2\tau = t_1 - t_2

Propiedades de RX(τ)

  • • RX(0)=E[X(t)2]R_X(0) = \mathbb{E}[X(t)^2] (potencia promedio)
  • • ∣RX(τ)∣≤RX(0)|R_X(\tau)| \le R_X(0)
  • • RX(−τ)=RX(τ)R_X(-\tau) = R_X(\tau) (simetría)

Ergodismo

Un proceso ergódico permite estimar propiedades del conjunto (ensemble) a partir de una sola trayectoria suficientemente larga: los promedios temporales igualan los promedios estadísticos.

9.4 Densidad Espectral de Potencia (PSD)

La autocorrelación en frecuencia

La PSD es la transformada de Fourier de la autocorrelación (Teorema de Wiener-Khinchin):

SX(f)=∫−∞∞RX(τ)e−j2πfτdτS_X(f) = \int_{-\infty}^\infty R_X(\tau) e^{-j 2\pi f \tau} d\tau
RX(τ)=∫−∞∞SX(f)ej2πfτdfR_X(\tau) = \int_{-\infty}^\infty S_X(f) e^{j 2\pi f \tau} df

Interpretación

La PSD muestra cómo se distribuye la potencia del proceso en las frecuencias. El área bajo SX(f)S_X(f) es la potencia total:

E[X(t)2]=∫−∞∞SX(f)df\mathbb{E}[X(t)^2] = \int_{-\infty}^\infty S_X(f) df

Ejemplos

  • • Ruido blanco: SX(f)=N0/2S_X(f) = N_0/2 (constante)
  • • Proceso AR(1): PSD con forma de Lorentziana
  • • Onda seno: delta en la frecuencia fundamental

9.5 Sistemas Lineales e Invariantes en el Tiempo

Filtrado de procesos aleatorios

Si un proceso WSS pasa por un sistema LTI con respuesta al impulso h(t):

Media a la salida

μY=μX∫−∞∞h(t)dt=μXH(0)\mu_Y = \mu_X \int_{-\infty}^\infty h(t) dt = \mu_X H(0)

PSD a la salida

SY(f)=∣H(f)∣2SX(f)S_Y(f) = |H(f)|^2 S_X(f)

Donde H(f)H(f) es la respuesta en frecuencia del sistema.

9.6 Filtro de Wiener

El filtro óptimo para recuperar una señal

El filtro de Wiener busca recuperar una señal S(t)S(t)a partir de observaciones ruidosas X(t)=S(t)+N(t)X(t) = S(t) + N(t), minimizando el error cuadrático medio.

Ecuaciones de Wiener-Hopf

RX∗h=RSXR_X * h = R_{SX}

La respuesta del filtro óptimo satisface esta ecuación integral.

En el dominio de la frecuencia

H(f)=SSX(f)SX(f)=SS(f)SS(f)+SN(f)H(f) = \frac{S_{SX}(f)}{S_X(f)} = \frac{S_S(f)}{S_S(f) + S_N(f)}

Cuando S y N son incorrelados. El filtro atenúa las frecuencias donde domina el ruido.

python
import numpy as np
from scipy import signal
import matplotlib.pyplot as plt

# Simular una señal + ruido
np.random.seed(42)
n = 1000
t = np.arange(n)
S = np.sin(0.02 * t)  # señal limpia
N = 0.5 * np.random.randn(n)  # ruido
X = S + N  # observación ruidosa

# Estimar PSD con periodograma
f, psd_X = signal.periodogram(X)
f, psd_S = signal.periodogram(S)

# Filtro de Wiener (aproximación)
SNR = psd_S / psd_X
H = np.clip(SNR, 0, 1)

# Aplicar filtro (multiplicar en frecuencia)
fft_X = np.fft.fft(X)
fft_filtrado = fft_X * np.fft.fft(H, n)
filtrado = np.fft.ifft(fft_filtrado).real

print(f"SNR mejora: {10*np.log10(np.var(S)/np.var(X - S)):.1f} dB")
print(f"SNR entrada: {10*np.log10(np.var(S)/np.var(N)):.1f} dB")
print(f"SNR salida: {10*np.log10(np.var(S)/np.var(filtrado - S)):.1f} dB")