Minería de datos de los balances de los bancos centrales y obtención de un panorama de la liquidez global

Las crisis financieras del siglo XXI —desde la crisis hipotecaria de 2008 hasta la agitación pandémica de la década de 2020— han cambiado radicalmente las reglas del juego. Los bancos centrales ya no se limitan al modesto papel de reguladores de los tipos de interés, y su arsenal se ha ampliado para incluir instrumentos exóticos: compra de bonos corporativos, préstamos bancarios directos, swaps de divisas e incluso financiación del gasto gubernamental. Estas medidas, como potentes bombas, inyectan o extraen liquidez a la economía global, reflejándose en los balances de los bancos centrales, en una especie de espejo de su política monetaria.

Este artículo no es simplemente una guía para analizar los balances de los bancos centrales: también supone un análisis profundo de la creación de un sistema que, como un caldero alquímico, transforma datos brutos de liquidez en pronósticos dorados de los movimientos de los pares de divisas. Hoy combinaremos información de la Reserva Federal de Estados Unidos (Fed), el Banco Central Europeo (BCE), el Banco de Japón (BOJ) y el Banco Popular de China (PBoC) para crear un índice compuesto de liquidez global. Asimismo, exploraremos cómo el aprendizaje automático y el análisis técnico pueden trabajar en conjunto para descubrir patrones ocultos que los métodos tradicionales no pueden. Además, mostraremos cómo integrar este sistema en el trading real, convirtiendo datos abstractos en decisiones comerciales concretas.

El análisis técnico tradicional, con sus gráficos e indicadores, con frecuencia se parece a intentar predecir el clima mirando solo las nubes. El análisis fundamental, por otro lado, requiere una comprensión profunda de la macroeconomía, lo que no siempre resulta adecuado para tomar decisiones comerciales rápidas. Nuestro enfoque supone un puente entre dos mundos, donde los datos de liquidez se vuelven clave para comprender tanto los movimientos a corto plazo como las tendencias a largo plazo. 

Fundamentos teóricos: la liquidez como pulso de la economía global

La liquidez global no es simplemente la cantidad de dinero en circulación, supone el elemento vital de la economía global, un sistema complejo que une agregados monetarios, instrumentos financieros y mecanismos que garantizan el libre flujo de capital. En sentido estricto, la liquidez es la capacidad de un activo de convertirse rápidamente en dinero sin perder valor. Pero a escala global, refleja la facilidad con la que el capital circula entre países, mercados y sectores. El movimiento de capital en sí mismo es la creación de tendencias a largo plazo muy potentes.

Los bancos centrales –la Reserva Federal, el BCE, el Banco de Japón, el Banco Popular de China– son los principales directores de esta orquesta. Sus balances no son simplemente informes contables, sino indicadores de cuánto dinero han inyectado en la economía a través de compras de activos, préstamos y otras medidas. Cuando la Reserva Federal compra bonos gubernamentales, crea nueva liquidez al aumentar su balance. Cuando el BCE aumenta los requisitos de reserva, retira liquidez, lo cual reduce los flujos de dinero.

El aumento del balance del banco central mediante flexibilización cuantitativa o la compra de activos generalmente debilita la divisa nacional. Esto sucede por dos razones: en primer lugar, el crecimiento de la oferta monetaria reduce el valor de la divisa según las leyes de la oferta y la demanda. En segundo lugar, estas medidas suelen acompañarse de tipos de interés más bajos, lo cual hace que la divisa resulte menos atractiva para los inversores que buscan rendimiento.

Sin embargo, esta conexión no es tan sencilla. Si todos los principales bancos centrales expanden sus balances simultáneamente, el efecto sobre los pares de divisas puede ser mínimo: todas las divisas se "inflan" en sincronía. Entonces el factor clave pasa a ser el impulso relativo: si el BOJ expande su balance más rápido que la Fed, es probable que el yen se debilite frente al dólar.

Comprender cómo se transmite la liquidez a través del sistema financiero resulta fundamental a la hora de realizar previsiones. Existen varios canales:

• Canal de tasas de interés: el recorte de tasas de un banco central aumenta la oferta monetaria, lo cual reduce el rendimiento de los activos denominados en esa divisa.
• Canal de cartera: las compras masivas de activos por parte de los bancos centrales cambian la estructura de las carteras de los inversores, obligándolos a buscar inversiones alternativas.
• Canal de crédito: la mejora de las condiciones crediticias estimula la actividad económica e influye en los flujos de divisas.
• Canal de expectativas: las comunicaciones y las señales adelantadas de los bancos centrales dan forma a las expectativas del mercado incluso antes de que las acciones reales lo hagan. 

Las expectativas sobre la política futura dan lugar a tendencias futuras, como analizaremos ahora con más detalle.

En la era de la transparencia informativa, los bancos centrales se han convertido en maestros de la comunicación. Sus declaraciones, conferencias de prensa y pronósticos no son solo palabras, sino potentes herramientas que dan forma a las expectativas del mercado. Cuando el presidente de la Reserva Federal insinúa un ajuste de la política monetaria, los mercados pueden empezar a vender dólares antes incluso de la decisión oficial. El análisis de liquidez debe considerar no solo los números de los balances, sino también la retórica de los funcionarios, que puede ser tan importante como sus acciones reales.

Arquitectura del sistema: diseñando el futuro financiero

Nuestro sistema no es un monolito, sino un mosaico cuidadosamente construido, donde cada módulo realiza una función claramente definida. GlobalLiquidityMiner recopila y procesa los datos sobre los balances de los bancos centrales, transformando flujos de información caóticos en series temporales coherentes. ForexLiquidityForecaster utiliza dichos datos, los enriquece con indicadores técnicos y los pasa a través de algoritmos de aprendizaje automático para crear pronósticos precisos. Este enfoque permite actualizar componentes individuales sin interrumpir todo el sistema y adaptarlo a nuevas fuentes de datos o condiciones del mercado.

Los mercados financieros son sistemas adaptativos complejos donde el sentimiento de los tráders a corto plazo se entrelaza con las tendencias macroeconómicas a largo plazo. Nuestra arquitectura refleja esta dualidad combinando señales técnicas rápidas con factores fundamentales profundos.

El módulo GlobalLiquidityMiner es el corazón del sistema de recopilación de datos. Funciona con una amplia variedad de fuentes, desde la API FRED de la Reserva Federal hasta formatos de datos complejos del BOJ e información limitada del PBoC. La tarea principal no consiste solo en cargar los datos, sino en llevarlos a un único estándar adecuado para el análisis. Distintos bancos publican datos con distintas frecuencias (la Reserva Federal publica sus informes cada semana, mientras que el Banco Popular de China lo hace trimestralmente) y sobre diferentes divisas. El módulo interpola valores faltantes, normaliza indicadores y sincroniza series temporales.

import pandas as pd
import logging
from typing import Dict
from fredapi import Fred
import yfinance as yf
import requests
from io import StringIO

logger = logging.getLogger(__name__)

class GlobalLiquidityMiner:
    def __init__(self, fred_api_key: str, start_date: str, end_date: str):
        self.fred = Fred(api_key=fred_api_key) if fred_api_key else None
        self.start_date = start_date
        self.end_date = end_date
        self.data_cache = {}

    def fetch_central_bank_balance_sheets(self) -> Dict[str, pd.DataFrame]:
        """Получение данных балансов центральных банков."""
        balance_sheets = {}
        
        if self.fred:
            logger.info("Загрузка данных ФРС...")
            try:
                fed_total_assets = self.fred.get_series('WALCL', start=self.start_date, end=self.end_date)
                fed_securities = self.fred.get_series('WSHOSHO', start=self.start_date, end=self.end_date)
                fed_loans = self.fred.get_series('WLRRAL', start=self.start_date, end=self.end_date)
                
                balance_sheets['FED'] = pd.DataFrame({
                    'date': fed_total_assets.index,
                    'total_assets': fed_total_assets.values,
                    'securities_held': fed_securities.reindex(fed_total_assets.index, method='ffill').values,
                    'loans_and_repos': fed_loans.reindex(fed_total_assets.index, method='ffill').values,
                    'currency': 'USD'
                })
                
                balance_sheets['FED']['assets_growth_rate'] = balance_sheets['FED']['total_assets'].pct_change(periods=52)
                balance_sheets['FED']['securities_share'] = balance_sheets['FED']['securities_held'] / balance_sheets['FED']['total_assets']
                
                logger.info(f"Загружено {len(fed_total_assets)} записей данных ФРС")
            except Exception as e:
                logger.error(f"Ошибка при загрузке данных ФРС: {e}")
        
        self.data_cache['balance_sheets'] = balance_sheets
        return balance_sheets

Asimismo, combina datos de liquidez con indicadores técnicos, creando funciones para modelos de aprendizaje automático. El uso de ventanas deslizantes nos permite considerar los efectos a corto y largo plazo de los cambios en la liquidez.

from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import r2_score, mean_squared_error
import numpy as np

class ForexLiquidityForecaster:
    def __init__(self, liquidity_miner: GlobalLiquidityMiner):
        self.liquidity_miner = liquidity_miner
        self.models = {}
        self.scalers = {}
        
    def build_prediction_model(self, symbol: str, feature_df: pd.DataFrame):
        """Обучение модели прогнозирования."""
        targets = {
            f'return_{h}d': feature_df['close'].shift(-h) / feature_df['close'] - 1
            for h in [1, 5]
        }
        
        feature_columns = [col for col in feature_df.columns if not col.startswith(('return_', 'volatility_', 'direction_'))]
        X = feature_df[feature_columns].dropna()
        
        train_size = int(len(X) * 0.8)
        X_train, X_test = X.iloc[:train_size], X.iloc[train_size:]
        
        models = {}
        for target_name, target_series in targets.items():
            y = target_series.dropna()
            common_idx = X.index.intersection(y.index)
            X_aligned, y_aligned = X.loc[common_idx], y.loc[common_idx]
            
            scaler = StandardScaler()
            X_train_scaled = scaler.fit_transform(X_aligned.iloc[:train_size])
            X_test_scaled = scaler.transform(X_aligned.iloc[train_size:])
            
            model = RandomForestRegressor(n_estimators=100, max_depth=10, random_state=42)
            model.fit(X_train_scaled, y_aligned.iloc[:train_size])
            
            test_pred = model.predict(X_test_scaled)
            test_r2 = r2_score(y_aligned.iloc[train_size:], test_pred)
            
            models[target_name] = {'model': model, 'scaler': scaler, 'r2': test_r2}
        
        self.models[symbol] = models
        self.scalers[symbol] = scaler

El módulo ForexLiquidityForecaster es el cerebro del sistema, donde los datos de liquidez se encuentran con los indicadores del mercado. Utiliza Random Forest para identificar relaciones no lineales entre los balances de los bancos centrales, los indicadores técnicos (RSI, MACD, promedios móviles) y los movimientos de los pares de divisas. Las funciones se crean considerando los retrasos temporales para captar los efectos inmediatos y retardados de los cambios de liquidez.

from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import r2_score
import numpy as np
import pandas as pd

class ForexLiquidityForecaster:
    def __init__(self, liquidity_miner: GlobalLiquidityMiner):
        self.liquidity_miner = liquidity_miner
        self.models = {}
        self.scalers = {}
        self.forecasts = {}

    def prepare_features(self, symbol: str, historical_data: pd.DataFrame) -> pd.DataFrame:
        """Создание признаков для прогнозирования."""
        df = historical_data.copy()
        
        # Технические индикаторы
        df['rsi_14'] = self.calculate_rsi(df['close'], 14)
        df['ema_50'] = df['close'].ewm(span=50).mean()
        df['volatility_20d'] = df['close'].pct_change().rolling(20).std()
        
        # Присоединение данных ликвидности
        if 'balance_sheets' in self.liquidity_miner.data_cache:
            for bank, bs_data in self.liquidity_miner.data_cache['balance_sheets'].items():
                df = df.join(bs_data[['total_assets']].rename(columns={'total_assets': f'{bank}_balance'}), how='left')
                df[f'{bank}_balance'].fillna(method='ffill', inplace=True)
        
        return df.dropna()

    def calculate_rsi(self, series: pd.Series, period: int = 14) -> pd.Series:
        """Расчет RSI."""
        delta = series.diff()
        gain = delta.where(delta > 0, 0).rolling(window=period).mean()
        loss = -delta.where(delta < 0, 0).rolling(window=period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

    def build_prediction_model(self, symbol: str, feature_df: pd.DataFrame):
        """Обучение модели прогнозирования."""
        targets = {
            f'return_{h}d': feature_df['close'].shift(-h) / feature_df['close'] - 1
            for h in [1, 3, 5, 8]
        }
        
        feature_columns = [col for col in feature_df.columns if not col.startswith('return_')]
        X = feature_df[feature_columns].dropna()
        
        train_size = int(len(X) * 0.8)
        X_train, X_test = X.iloc[:train_size], X.iloc[train_size:]
        
        models = {}
        for target_name, target_series in targets.items():
            y = target_series.dropna()
            common_idx = X.index.intersection(y.index)
            X_aligned, y_aligned = X.loc[common_idx], y.loc[common_idx]
            
            scaler = StandardScaler()
            X_train_scaled = scaler.fit_transform(X_aligned.iloc[:train_size])
            X_test_scaled = scaler.transform(X_aligned.iloc[train_size:])
            
            model = RandomForestRegressor(n_estimators=200, max_depth=15, random_state=42)
            model.fit(X_train_scaled, y_aligned.iloc[:train_size])
            
            test_pred = model.predict(X_test_scaled)
            test_r2 = r2_score(y_aligned.iloc[train_size:], test_pred)
            
            models[target_name] = {'model': model, 'scaler': scaler, 'r2': test_r2}
        
        self.models[symbol] = models
        self.scalers[symbol] = scaler

Implementación práctica: de los datos a la acción

La API FRED es un tesoro de datos sobre el balance de la Reserva Federal, incluidos los activos totales, los valores y los créditos. El código procesa las limitaciones de la API, como los límites de solicitudes, y sincroniza los datos en diferentes intervalos.

def fetch_fed_data(self):
    """Получение данных ФРС через API FRED."""
    try:
        fed_data = self.fred.get_series('WALCL', start=self.start_date, end=self.end_date)
        return pd.DataFrame({
            'date': fed_data.index,
            'total_assets': fed_data.values,
            'currency': 'USD'
        }).set_index('date')
    except Exception as e:
        logger.error(f"Ошибка загрузки данных ФРС: {e}")
        return pd.DataFrame()

Para el BCE, los datos se extraen a través del almacén de datos estadísticos y, de darse interrupciones, se utilizan indicadores proxy como EURUSD y Euro Stoxx 50. En el caso del BOJ y el PBoC, donde el acceso a los datos es limitado, se usan indicadores de mercado (Nikkei 225, USDJPY, bonos chinos).

def fetch_boj_proxy_data(self):
    """Получение прокси-данных BOJ."""
    try:
        usdjpy = yf.download('USDJPY=X', start=self.start_date, end=self.end_date, progress=False)
        nikkei = yf.download('^N225', start=self.start_date, end=self.end_date, progress=False)
        
        proxy_balance = pd.DataFrame(index=usdjpy.index)
        proxy_balance['jpy_strength'] = 1 / usdjpy['Close']
        proxy_balance['equity_liquidity'] = nikkei['Close'] / nikkei['Close'].rolling(252).mean()
        proxy_balance['synthetic_balance'] = proxy_balance['jpy_strength'].rolling(30).mean() * proxy_balance['equity_liquidity'] * 1000000
        
        return proxy_balance
    except Exception as e:
        logger.error(f"Ошибка загрузки данных BOJ: {e}")
        return pd.DataFrame()

El índice de liquidez: creando una brújula financiera

El índice compuesto de liquidez combina datos normalizados de los balances de los bancos centrales con ponderaciones que reflejan su influencia: Fed (35%), BCE (25%), BOJ (15%), PBoC (20%), otros (5%). El ajuste dinámico tiene en cuenta la volatilidad y la fiabilidad de los datos.

def calculate_liquidity_index(self) -> pd.DataFrame:
    """Расчет композитного индекса ликвидности."""
    all_series = {}
    weights = {'FED_balance': 0.35, 'ECB_balance': 0.25, 'BOJ_balance': 0.15, 'PBOC_balance': 0.20}
    
    for bank, df in self.data_cache.get('balance_sheets', {}).items():
        series_name = f'{bank}_balance'
        normalized = (df['total_assets'] - df['total_assets'].rolling(252).mean()) / df['total_assets'].rolling(252).std()
        all_series[series_name] = normalized
    
    combined_df = pd.DataFrame(all_series).fillna(method='ffill')
    liquidity_index = combined_df.dot(pd.Series(weights))
    
    return pd.DataFrame({'liquidity_index': liquidity_index}, index=combined_df.index)

Además del índice principal, el sistema crea subíndices: de corto plazo (30 días), de largo plazo (252 días), índice de aceleración e índice de volatilidad de la liquidez. Estos indicadores ayudan a adaptar los pronósticos a las diferentes condiciones del mercado.

def enhance_liquidity_index(self, base_index: pd.Series) -> pd.DataFrame:
    """Создание расширенных индикаторов ликвидности."""
    enhanced_df = pd.DataFrame(index=base_index.index)
    enhanced_df['base_liquidity_index'] = base_index
    enhanced_df['short_term_liquidity'] = base_index.rolling(window=30).mean()
    enhanced_df['long_term_trend'] = base_index.rolling(window=252).mean()
    enhanced_df['liquidity_acceleration'] = base_index.diff().diff()
    enhanced_df['liquidity_volatility'] = base_index.rolling(window=60).std()
    
    return enhanced_df

Integración con MetaTrader 5: un puente hacia el trading real

El sistema se integra con MetaTrader 5 para obtener datos del mercado y generar señales comerciales. Las características incluyen indicadores técnicos y métricas de liquidez, creando un conjunto de datos único para la ejecución de pronósticos.

import MetaTrader5 as mt5
from datetime import datetime, timedelta

class TradingIntegration:
    def __init__(self, forecaster: ForexLiquidityForecaster):
        self.forecaster = forecaster
        mt5.initialize()
    
    def fetch_forex_data(self, symbol: str, days: int = 1460) -> pd.DataFrame:
        """Получение данных с MetaTrader 5."""
        utc_from = datetime.now() - timedelta(days=days)
        rates = mt5.copy_rates_from(symbol, mt5.TIMEFRAME_D1, utc_from, days)
        
        if rates is None:
            return pd.DataFrame()
        
        df = pd.DataFrame(rates)
        df['date'] = pd.to_datetime(df['time'], unit='s')
        df.set_index('date', inplace=True)
        return df
    
    def generate_trading_signals(self, symbol: str, forecasts: dict) -> dict:
        """Генерация торговых сигналов."""
        signals = {}
        short_term_returns = [f['return'] for h, f in forecasts['forecasts'].items() if h in ['1d', '2d', '3d']]
        avg_return = np.mean(short_term_returns) if short_term_returns else 0
        
        signals['short_term'] = {
            'signal': 'BUY' if avg_return > 0.005 else 'SELL' if avg_return < -0.005 else 'HOLD',
            'strength': min(abs(avg_return) * 100, 100)
        }
        
        return signals

Visualización: una imagen del mundo en gráficos

El sistema crea visualizaciones interactivas que ayudan a los tráders a ver la relación entre la liquidez y los precios. Los gráficos incluyen los pronósticos de los precios, la dinámica del índice de liquidez y la importancia de las características.

import matplotlib.pyplot as plt
import numpy as np

def create_comprehensive_visualization(self, symbol: str):
    """Создание набора визуализаций."""
    forecasts = self.forecaster.forecasts.get(symbol, {})
    historical_data = self.fetch_forex_data(symbol, days=180)
    
    plt.figure(figsize=(15, 8))
    plt.plot(historical_data.index[-60:], historical_data['close'].iloc[-60:], label='Исторические цены', linewidth=2)
    
    forecast_dates = [datetime.strptime(f['date'], '%Y-%m-%d') for f in forecasts.get('forecasts', {}).values()]
    forecast_prices = [f['price'] for f in forecasts.get('forecasts', {}).values()]
    
    if forecast_dates:
        plt.plot(forecast_dates, forecast_prices, 'r--', label='Прогноз', linewidth=2)
    
    plt.title(f'{symbol}: Прогноз цен с учетом ликвидности', fontsize=14, fontweight='bold')
    plt.xlabel('Дата', fontsize=12)
    plt.ylabel('Цена', fontsize=12)
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.savefig(f'forecast_{symbol}.png', dpi=300)
    plt.close()

Como resultado, obtenemos una imagen de la liquidez global:

También se realizan pronósticos basados en ello:

Y la matriz de correlación:

Conclusión

El sistema desarrollado es una potente herramienta que combina el análisis del balance del banco central con técnicas avanzadas de aprendizaje automático y análisis técnico, ofreciendo un enfoque integral para la previsión del tipo de cambio. La arquitectura modular del sistema, que incluye GlobalLiquidityMiner y ForexLiquidityForecaster, garantiza flexibilidad y escalabilidad, así como la capacidad de adaptarse a las condiciones cambiantes del mercado.

La integración con MetaTrader 5 permite a los tráders aplicar pronósticos a transacciones reales, convirtiendo datos complejos en decisiones comerciales concretas. Las visualizaciones interactivas y los resultados de pruebas retrospectivas mejoran la transparencia y fiabilidad del sistema, permitiendo a los tráders tomar decisiones informadas con un alto grado de confianza.

Este sistema va más allá del análisis tradicional, ofreciendo un enfoque holístico que considera tanto factores fundamentales como técnicos. Esto permite a los tráders no solo reaccionar ante los cambios del mercado, sino también anticiparlos, utilizando la liquidez global como brújula en los mares tempestuosos del mercado Forex. Ante la creciente volatilidad e incertidumbre de la economía mundial, este enfoque se está convirtiendo no solo en una ventaja, sino en una necesidad para negociar con éxito.

El sistema no está exento de limitaciones. El acceso limitado a los datos de algunos bancos centrales, como el PBoC, requiere el uso de indicadores proxy, lo cual puede reducir la precisión. Además, el aprendizaje automático, a pesar de su potencia, no garantiza una precisión absoluta en los pronósticos, especialmente ante sacudidas geopolíticas o económicas inesperadas. Sin embargo, la mejora continua de los algoritmos, la ampliación de las fuentes de datos y la consideración de nuevos factores del mercado permitirán que el sistema siga siendo relevante y eficaz.

El desarrollo futuro del sistema puede incluir la integración con modelos de redes neuronales para procesar grandes volúmenes de datos no estructurados, como noticias y redes sociales, lo cual mejorará su poder predictivo. También podremos implementar mecanismos adaptativos que ajusten automáticamente los pesos del índice de liquidez dependiendo de las condiciones económicas actuales. Esto allanará el camino para la creación de una nueva generación de sistemas comerciales aún más resistentes a la incertidumbre y capaces de ofrecer resultados estables en cualquier condición de mercado.