Cointegración entre mercados de criptomonedas

Question

Me cuesta entender cómo funciona la cointegración. Básicamente estoy tratando de encontrar pares cointegrados en el mercado de criptomonedas, así que hago lo siguiente:

1. Obtenga los datos OHLC para los dos mercados (estoy obteniendo 5k velas en el marco temporal de 5m)
2. Obtenga los rendimientos del registro para los dos mercados
3. Compruebe el valor p cuando busque la cointegración entre los retornos logarítmicos

El problema con mi código es que siempre obtengo valores p muy bajos, sin importar el mercado que pruebe, y en algunos mercados el valor p es 0.

Aquí está mi código:

import pandas as pd
import json
import numpy as np
import requests 
import time
import json
import mplfinance as mpf
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import statsmodels.tsa.stattools as ts
import threading
import scipy
import pandas_ta as ta
import ccxt
from pykalman import KalmanFilter

ftx = ccxt.ftx()

def get_ohlc_ccxt(market, timeframe):
    data = ftx.fetch_ohlcv(market, timeframe, limit=5000)
    ohlcv = pd.DataFrame(data, columns=['time', 'open', 'high', 'low', 'close', 'volume'])
    ohlcv = ohlcv.drop_duplicates(subset=['time', 'open', 'high', 'low', 'close', 'volume'], keep='first')
    ohlcv['time'] = ohlcv['time'].astype('int64')
    ohlcv['time'] = ohlcv['time']/1000
    ohlcv['date'] = pd.to_datetime(ohlcv['time'], unit='s')
    ohlcv = ohlcv.set_index(pd.DatetimeIndex(ohlcv['date']))
    return ohlcv

def check_pair(first_market, second_market, timeframe):
    first = get_ohlc_ccxt(first_market, timeframe)
    second = get_ohlc_ccxt(second_market, timeframe)

    if len(first) != len(second):
        length = min(len(first), len(second))
        first = first.iloc[-length:]
        second = second.iloc[-length:]

    x = first['close'].to_numpy()
    y = second['close'].to_numpy()

    first['logret'] = first.ta.log_return()
    second['logret'] = second.ta.log_return()

    xr = first['logret'].fillna(0)
    yr = second['logret'].fillna(0)

    coint = ts.coint(xr.to_numpy(), yr.to_numpy())
    p_value = coint[1]

    print('Cointegration:', first_market, second_market, p_value)
    spread = xr-yr

    return first, second

data = check_pair('BTC-PERP', 'ETH-PERP', '5m')

En este caso el valor p es 8.94059749424772e-29 . Si pruebo otros mercados (como BTC-LINK, o BTC-LTC y así sucesivamente) el valor p siempre será increíblemente bajo. ¿Puede alguien ayudarme a encontrar lo que estoy haciendo mal?

Answer 1

Es probable que haya un problema con las velas que faltan en sus datos. Aunque ha tomado medidas para asegurarse de que los datos tienen la misma longitud para su prueba, es muy posible que las marcas de tiempo de estas dos series no se alineen y, por lo tanto, terminen cubriendo diferentes períodos de tiempo. los datos no están sincronizados .

Permítanme dar un ejemplo, supongan que miran el BTC-USD y ETH-USD mercados. Ya ha establecido un límite de 5.000 velas a intervalos de 5 minutos para ser devueltas, proporciona todos los parámetros a la biblioteca CCXT, y ésta le devuelve su serie temporal. Permítame ahora denotar el BTC-USD series temporales como $X_{t}$ y el ETH-USD serie como $Y_{t}$ donde para cada serie tenemos $t$ tal que $0 \leq t < 5000$ .

5.000 intervalos de 5 minutos nos llevan a algo menos de 2,5 semanas. Así que tenemos nuestras dos series tales que $X_{0}$ y $Y_{0}$ caen, digamos, el 20 de junio de 2022 a las 00:00:00.

Sin embargo, por la razón que sea, digamos que para ETH-USD Hubo un cierto número de períodos en los que no se ha realizado ninguna operación . Esto puede deberse a mercados ilíquidos en bolsas ilíquidas, a cortes de la bolsa, a una API defectuosa, etc. La cuestión es que es muy posible que no se hayan realizado operaciones durante ciertos intervalos de 5 minutos. Veo que has utilizado FTX como ejemplo, no puedo comentar sobre la documentación de su API, pero sé que es común que otras APIs de intercambio no devuelvan nada para los intervalos de velas en los que se produjeron 0 operaciones. Vea este ejemplo sobre la API de Bitfinex, que no devuelve ninguna marca de tiempo cuando no hay datos de velas debido a que no hay operaciones.

Esto puede hacer que su serie tenga una longitud inferior a 5.000 intervalos. Aunque su método es correcto al asegurar que las dos series temporales son de igual longitud debe asegurarse de que tiene la misma longitud en el lugares adecuados . Su código trunca arbitrariamente las series, pero lo que tiene que hacer es utilizar únicamente los datos en los que existen marcas de tiempo en ambas series.

Volviendo a mi ejemplo, digamos que ETH-USD tenía 3 intervalos / velas perdidas. Digamos que en el $x$ , $y$ y $z$ Intervalo de 5 minutos donde ( $x,y,z \leq 5000$ ), no se produjo ninguna operación. Pero su BTC-USD es completa, entonces sólo se pueden utilizar los datos $X_{t, \text{s.t.} 0 \leq t < 5000, t \notin \{x,y,z\}}$ . Esto garantiza que sus series estén correctamente alineadas y que sus pruebas de cointegración se realicen correctamente.

Answer 2

Esta es una observación común cuando se realizan pruebas de hipótesis en grandes conjuntos de datos.

Las pruebas de hipótesis más comunes tienen la propiedad de que, a medida que aumenta el tamaño de la muestra, la prueba se vuelve cada vez más sensible, siendo en el límite perfectamente sensible a cualquier desviación de la hipótesis nula.

En consecuencia, un tamaño de muestra grande da a su prueba una enorme potencia para rechazar incluso desviaciones mínimas de la hipótesis nula. Sospecho que esto es lo que le ha ocurrido a usted: hay al menos una pequeña desviación, y el gran tamaño de la muestra le permite detectarla.

(Tenga en cuenta que esta sensibilidad se produce cuando la hipótesis nula es realmente falsa. Si la hipótesis nula es verdadera, la sensibilidad debería ser de alrededor de $\alpha$ , lo que significa un $\text{Uniform}(0, 1)$ distribución de los valores p bajo la hipótesis nula).