Decomposição em modos dinâmicos aplicada a séries temporais univariadas na linguagem MQL5
Introdução
A decomposição em modos dinâmicos (DMD) é um método utilizado para analisar sistemas dinâmicos complexos. Na engenharia, ele é empregado na análise do escoamento de fluidos para extrair estruturas espaço-temporais de conjuntos de dados complexos. O DMD decompõe os dados do sistema em representações mais simples, chamadas modos. Cada modo representa um padrão espacial distinto, com sua própria frequência de oscilação e taxa de crescimento ou decaimento. Isso permite aos engenheiros analisar a dinâmica subjacente ao escoamento de fluidos sem precisar resolver as equações fundamentais, muitas vezes complexas, que governam o sistema.
As estruturas espaço-temporais são padrões que preservam sua forma e identidade no tempo e no espaço. Imagine um anel de fumaça flutuando pelo ar. Esse anel é uma estrutura que preserva sua forma e se desloca como um todo, mesmo quando o ar ao seu redor apresenta turbulência.

Os engenheiros utilizam métodos como o DMD para identificar e analisar essas estruturas em escoamentos complexos de fluidos. Neste artigo, examinaremos a implementação do DMD no MetaTrader 5. Por meio de exemplos práticos de código, os leitores aprenderão a utilizar o novo método matricial DynamicModeDecomposition(). Abordaremos seus dados de entrada e apresentaremos os principais utilitários de código necessários para processar os dados de saída do método.
Algoritmo DMD
O algoritmo de decomposição em modos dinâmicos foi desenvolvido por Peter Schmid e Jörn Sesterhenn para aplicações em dinâmica dos fluidos. Essencialmente, o DMD é uma técnica de redução de dimensionalidade que também permite identificar as oscilações presentes nos dados. Seu funcionamento pode ser comparado a uma combinação da análise de componentes principais com a transformada de Fourier para detectar sinais. Uma das principais vantagens do método é que ele não exige pressupostos sobre o conjunto de dados analisado. O DMD pode ser aplicado a séries temporais não estacionárias, e suas variantes mais recentes conseguem até processar dados coletados em intervalos de tempo irregulares. Seu principal requisito está relacionado à estrutura dos dados: recomenda-se que o conjunto apresente multidimensionalidade suficiente.
O método utiliza uma sequência de instantâneos do estado de um sistema dinâmico, coletados ao longo do tempo. Esses instantâneos, que podem conter quaisquer dados relevantes do sistema, são dispostos em uma matriz na qual cada coluna corresponde a um instante específico.

As colunas dessa matriz, que chamaremos de X, representam os instantâneos do estado do sistema. Na prática, os conjuntos de dados utilizados no DMD costumam ser multidimensionais, com centenas ou até milhares de variáveis medidas em cada instante. Isso resulta em uma matriz com mais linhas (variáveis ou características) do que colunas (instantâneos).

A partir da matriz X, obtemos duas novas matrizes: X1 e X2. Juntas, elas representam a evolução temporal do sistema dinâmico. A matriz X1 contém todas as colunas de X, exceto a última; essas colunas representam os estados usados como origem em cada par temporal. Já a matriz X2 contém todas as colunas de X, da segunda até a última, representando os estados do sistema nos instantes seguintes.

O fundamento matemático do DMD é a relação presumida entre as matrizes X1 e X2: considera-se que existe uma matriz A tal que o produto AX1 forneça uma aproximação suficientemente precisa de X2. O objetivo do DMD é determinar a estrutura espectral de A sem precisar calcular explicitamente essa matriz.
Para isso, o DMD utiliza um procedimento semelhante ao método de Rayleigh-Ritz, uma técnica clássica de álgebra linear para aproximar os autovalores e autovetores de matrizes de grande dimensão. O método projeta o problema em um subespaço de dimensão reduzida, cuidadosamente selecionado a partir dos dados. No DMD, esse subespaço corresponde a uma parte do espaço gerado pelas colunas da matriz de dados X1. Normalmente, ele é construído a partir dos principais vetores singulares à esquerda de X1, obtidos por meio da decomposição em valores singulares (Singular Value Decomposition, SVD).
O algoritmo constrói uma aproximação da matriz A utilizando a matriz de dados X2 e os resultados da decomposição SVD de X1. Na expressão abaixo, k representa o posto após o truncamento.
Essa aproximação matricial do operador A é conhecida como matriz DMD ou quociente de Rayleigh. Os autovalores dessa matriz reduzida são chamados de valores de Ritz ou autovalores DMD, enquanto os autovetores correspondentes são utilizados para calcular os vetores de Ritz, também conhecidos como modos DMD projetados.
Os valores e vetores de Ritz formam os pares de Ritz, que representam a decomposição do conjunto de dados em modos dinâmicos. Esses modos permitem obter uma aproximação de baixo posto da dinâmica do sistema a partir dos dados.
A qualidade dessa aproximação depende diretamente da escolha do subespaço, que, no DMD, está intrinsecamente ligada aos dados dos instantâneos. Os modos DMD descrevem padrões que evoluem no tempo de acordo com os autovalores DMD. Em outras palavras, os modos representam as estruturas do sistema, enquanto os autovalores determinam como essas estruturas evoluem ao longo do tempo.
A evolução temporal de um modo pode ser visualizada calculando seu comportamento ao longo do tempo. Para isso, é necessário determinar sua amplitude. As amplitudes funcionam como pesos ou coeficientes iniciais que indicam a contribuição de cada modo para o estado inicial do sistema e sua evolução geral. Um modo de grande amplitude exerce uma influência dominante sobre a dinâmica do sistema, enquanto um modo de pequena amplitude tem uma contribuição menor. Combinando os modos, os autovalores e as amplitudes, o DMD permite construir uma aproximação do comportamento do sistema. Além disso, essa representação reconstruída pode ser extrapolada no tempo para prever o comportamento futuro do sistema.
Imersão por atraso temporal
Além do algoritmo DMD clássico, existem diversas variantes desenvolvidas para atender a diferentes tipos de conjuntos de dados e aplicações. A maioria delas se distingue do DMD clássico pela inclusão de etapas de pré-processamento ou pós-processamento que melhoram os resultados do método. Um exemplo é a imersão por atraso temporal, uma técnica que amplia o espaço de estados do sistema, tornando os dados mais adequados à análise por DMD.
O DMD convencional pressupõe que a dinâmica do sistema possa ser aproximada linearmente entre instantâneos consecutivos. Essa hipótese pode deixar de ser válida em sistemas fortemente não lineares ou quando os dados apresentam poucas variáveis espaciais (linhas). Ao incorporar observações anteriores ao vetor de estado atual, as coordenadas de atraso permitem revelar aspectos mais complexos da dinâmica do sistema. Dessa forma, uma aproximação linear, como a utilizada pelo DMD, pode capturar características essenciais de sistemas não lineares ou caóticos. Isso amplia as possibilidades de aplicação do DMD a conjuntos de dados que, originalmente, não apresentam multidimensionalidade suficiente.
A ideia consiste em construir uma matriz de dados ampliada. Em vez de utilizar apenas um instantâneo em cada etapa temporal, criamos um novo vetor de estado que reúne o instantâneo atual e uma sequência de instantâneos anteriores, separados por determinados intervalos de tempo. Essa abordagem é semelhante à construção de uma matriz de trajetória na análise espectral singular (Singular Spectrum Analysis). O código a seguir define a função time_delay_embedding(), que permite construir uma matriz ampliada formada por observações defasadas.
//+------------------------------------------------------------------+ //| pseudo hankelization | //+------------------------------------------------------------------+ matrix time_delay_embedding(matrix &data, ulong delay=2) { if(delay>=data.Cols() || delay<1) { Print(__FUNCTION__, " invalid input parameters "); return matrix::Zeros(0,0); } ulong rows = data.Rows(); matrix matrices; matrix out(rows*delay,data.Cols()-(delay-1)); for(ulong i = 0; i<delay; i++) { matrices = np::sliceMatrixCols(data,long(i),long(i+data.Cols()-(delay-1))); if(!np::matrixCopyRows(out,matrices,long(i*rows),long((i*rows)+matrices.Rows()))) { Print(__FUNCTION__, " failed copy operation "); return matrix::Zeros(0,0); } } return out;
A função time_delay_reconstruction() pode ser aplicada aos resultados de reconstrução ou previsão obtidos pelo DMD a partir de dados previamente processados com imersão por atraso temporal. Isso permite recuperar o formato original dos dados.
//+------------------------------------------------------------------+ //| rebuild original shape of data after augmentation | //+------------------------------------------------------------------+ matrix time_delay_reconstruction(matrix &data, ulong delay) { ulong rows = data.Rows(); ulong cols = data.Cols(); if(rows<delay) { Print(__FUNCTION__," invalid inputs"); return data; } matrix out(rows/delay,cols + delay - 1); matrix splitted[]; ulong splits = data.Hsplit(delay,splitted); for(ulong i = 0; i<splits; i++) if(!np::matrixCopyCols(out,splitted[i],long(i),long(i+cols))) { Print(__FUNCTION__, " failed copy operation "); return data; } return out; }
Independentemente da variante utilizada, os métodos DMD produzem essencialmente os mesmos tipos de resultados: autovalores DMD, modos DMD e amplitudes DMD. O ponto central da análise por DMD é interpretar esses resultados, especialmente os autovalores DMD. A melhor maneira de demonstrar como interpretar os resultados do DMD é recorrer a um exemplo prático. Para isso, precisamos examinar o código com mais detalhes.
DMD na linguagem MQL5
A ampliação do suporte às rotinas OpenBIAS no MetaTrader introduziu dois métodos que implementam a abordagem DMD. O primeiro, DynamicModeDecomposition(), utiliza o algoritmo DMD convencional baseado em SVD, enquanto o segundo, DynamicModeDecompositionQR(), emprega uma implementação baseada na decomposição QR. Neste artigo, vamos nos concentrar na versão baseada em SVD. Para explorar seu funcionamento, utilizaremos uma série sintética definida no trecho de código a seguir.
//+------------------------------------------------------------------+ //| univariate process | //+------------------------------------------------------------------+ vector f(vector &in) { return cos(in)*sin(cos(in))*cos(in*0.2); }
O código define uma série formada pelo produto de três componentes oscilatórias distintas, resultando em uma onda complexa cuja amplitude e frequência variam ao longo do tempo.
A combinação dessas três componentes produz um padrão complexo e periódico, que não corresponde a uma simples oscilação harmônica. As oscilações rápidas de cos(x)sin(cos(x)) são "alongadas" e "comprimidas" pela componente mais lenta cos(0.2x), resultando na forma de onda complexa apresentada no gráfico. A decomposição dessa série é realizada pelo script DMD_Demo.mq5. O primeiro passo consiste em preparar os dados, armazenando a série em uma estrutura adequada para a decomposição.
//+------------------------------------------------------------------+ //| DMD_Demo.mq5 | //| Copyright 2024, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2024, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs //--- #include<np.mqh> #include<cmath.mqh> //--- input ENUM_DMD_SCALE jobs = DMDSCALE_N; input ENUM_DMD_EIGV jobz = DMDEIGV_V; input ENUM_DMD_RESIDUALS jobr = DMDRESIDUALS_R; input ENUM_DMD_REFINE jobf = DMDREFINE_R; input ENUM_SVD_ALG whtsvd = SVDALG_1; input long nrnk = -1; input double tol_ = 1.e-9;//tol input ulong Delay = 50;//apply time delay embedding //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- ulong series_len = 100; double dt = 0.1010101; double first_time_point = 0.0; vector t = np::arange(series_len,first_time_point,dt); vector F = f(t); matrix X(1,series_len); X.Row(F,0);
Na linguagem MQL5, DynamicModeDecomposition() é um método matricial que retorna um valor booleano indicando se a decomposição foi concluída com sucesso. Conforme a documentação, o método exige vários parâmetros de entrada, alguns dos quais precisam ser escolhidos com cuidado, pois influenciam significativamente os resultados. A seguir, examinaremos os parâmetros de DynamicModeDecomposition().
//--- if(Delay) X = time_delay_embedding(X,Delay); //--- Print("X shape is ", X.Rows(),":",X.Cols()); //--- matrix X1 = np::sliceMatrixCols(X,0,X.Cols()-1); matrix X2 = np::sliceMatrixCols(X,1); //--- vectorc eigen_values; matrix W; matrix B; vector residuals; matrix left_vectors; matrix res_vectors; matrix Z,S; if(!X1.DynamicModeDecomposition(X2,jobs,jobz,jobr,jobf,whtsvd,nrnk,tol_,eigen_values,left_vectors,Z,residuals,res_vectors,B,W,S)) { Print(" DMD error ",GetLastError()); return;
Em relação às matrizes, DynamicModeDecomposition() exige duas matrizes de entrada. A primeira é a matriz dos instantâneos de origem, sobre a qual o método é chamado. A matriz dos instantâneos subsequentes é fornecida como primeiro argumento. O requisito fundamental é que as matrizes apresentem um grau suficiente de multidimensionalidade. O método exige matrizes com número de linhas maior ou igual ao número de colunas. Se alguma delas tiver mais colunas do que linhas, ocorrerá um erro durante a execução. Ao aplicar a imersão por atraso temporal, é necessário que as matrizes obtidas a partir da matriz ampliada atendam a esse requisito. A dimensão da imersão determina o número de linhas da matriz ampliada.
Considere nossa série de exemplo, que, ao ser convertida em matriz, apresenta uma linha e 100 colunas, correspondentes aos instantâneos. A aplicação da imersão por atraso temporal com dimensão 50 gera uma matriz ampliada de 50 linhas (número original de linhas × dimensão da imersão) e 51 colunas (número original de colunas - dimensão da imersão + 1). A escolha da dimensão adequada para a imersão por atraso temporal exige um equilíbrio entre ampliar o espaço de estados e preservar uma quantidade suficiente de instantâneos para uma análise eficaz.
input ENUM_DMD_SCALE jobs = DMDSCALE_NO segundo parâmetro de DynamicModeDecomposition() é uma enumeração que define uma etapa interna de pré-processamento. Esse parâmetro permite selecionar o procedimento de escalonamento aplicado aos dados. Existem quatro opções, incluindo a possibilidade de não aplicar nenhum escalonamento. Ao colocar todas as colunas na mesma escala, o algoritmo reduz o risco de que algumas colunas com normas muito elevadas dominem a análise, tornando os cálculos mais equilibrados e numericamente estáveis. Isso ajuda a equilibrar a influência dos instantâneos na análise da dinâmica geral, evitando que os resultados sejam influenciados de maneira desproporcional por alguns eventos de grande magnitude. Assim, o algoritmo consegue identificar modos relevantes para toda a série temporal, inclusive aqueles associados a fenômenos de menor escala.
input ENUM_SVD_ALG whtsvd = SVDALG_1;O parâmetro whtsvd é uma enumeração do tipo ENUM_SVD_ALG que permite escolher entre quatro implementações de SVD para o procedimento DMD. Essas implementações apresentam diferenças de precisão que podem influenciar os resultados finais.
input long nrnk = -1;
Um valor positivo de nrnk estabelece um limite máximo para o posto de truncamento e, consequentemente, para a dimensão do subespaço retido para o modelo de ordem reduzida. Esse valor deve ser menor ou igual ao número de colunas do conjunto de dados. Outra opção é definir esse parâmetro como -1 ou -2, permitindo que o posto de truncamento seja determinado a partir dos dados com auxílio do parâmetro tol.
input double tol_ = 1.e-9;//tol
O parâmetro tol define uma tolerância utilizada como limiar para os valores singulares obtidos pela decomposição SVD, permitindo determinar o posto ideal do conjunto de dados. Os demais parâmetros de entrada do método estão relacionados aos resultados da decomposição. Vamos examiná-los ao analisar esses resultados. Com todos os parâmetros definidos, podemos executar o programa e observar os resultados, começando pelos autovalores DMD.
Análise dos autovalores
Os autovalores DMD, também chamados de valores de Ritz, são retornados no parâmetro vetorial eigen_values. Esses autovalores caracterizam a evolução temporal do sistema. São números complexos que representam o comportamento geral de cada modo correspondente. A quantidade de autovalores é igual ao posto do modelo de ordem reduzida calculado pelo DMD. Para um autovalor não nulo, seu argumento determina a frequência de oscilação por amostra, enquanto seu módulo determina a evolução da amplitude do modo.
A estabilidade de um modo pode ser avaliada pelo módulo do autovalor correspondente:
- Módulo > 1: o modo é instável e sua amplitude aumenta ao longo do tempo.
- Módulo<1: o modo é estável, com amplitude que diminui ao longo do tempo.
- Módulo = 1: o modo apresenta estabilidade neutra, com oscilações que não crescem nem decaem. Esse comportamento é característico de oscilações persistentes ou de estados estacionários.
Outra maneira de avaliar a estabilidade dos modos é representar graficamente os valores de Ritz no plano complexo. O objetivo dessa visualização é observar a posição dos autovalores em relação à circunferência unitária. Nosso interesse está nos modos que apresentam comportamento persistente, pois eles indicam a presença de estruturas ou padrões consistentes ao longo do tempo. Os autovalores desses modos encontram-se aproximadamente sobre a circunferência unitária. O gráfico a seguir apresenta os autovalores obtidos para nosso exemplo.
Em relação às frequências, componentes oscilatórias reais podem ser representadas por pares de exponenciais complexas conjugadas, associados a pares de autovalores conjugados. Uma única exponencial complexa não consegue descrever dados reais formados por combinações de senos e cossenos. De acordo com a fórmula de Euler, uma função real requer um par de exponenciais complexas, razão pela qual o DMD produz pares conjugados. Ao observar nosso conjunto de dados sintéticos, percebemos que a função contém várias componentes periódicas. Portanto, esperamos que o DMD identifique diversos pares de autovalores complexos conjugados correspondentes a essas oscilações. Além disso, o argumento dos autovalores não nulos caracteriza a frequência de oscilação dos respectivos modos. Argumentos próximos de zero indicam baixa frequência de oscilação, enquanto o módulo determina a evolução da amplitude.
IN 0 20:48:41.719 DMD_univariate (AUDUSD,D1) DMD eigenvalues or Ritz values NF 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.5094085277495803,0.8361736631055409) MR 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.5094085277495803,-0.8361736631055409) LH 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9997963823571733,0.02020000684364618) IG 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9997963823571733,-0.02020000684364618) CQ 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9835155147230954,0.1808172385894571) DN 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9835155147230954,-0.1808172385894571) RG 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9754097172453285,0.2203989043734001) QS 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9754097172453285,-0.2203989043734001) LL 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9272204223699192,0.3744766566706951) CE 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9272204223699192,-0.3744766566706951) MR 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9113505757240357,0.4116425317268657) FO 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.9113505757240357,-0.4116425317268657) LH 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.8329207590629218,0.5528761024511968) KP 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.8329207590629218,-0.5528761024511968) KN 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.810278335748567,0.5863411580059696) NI 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.810278335748567,-0.5863411580059696) CP 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.6775746857433339,0.740515480806191) JL 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.6775746857433339,-0.740515480806191) JH 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.6991117585413807,0.7090540641602167) QQ 0 20:48:41.719 DMD_univariate (AUDUSD,D1) (0.6991117585413807,-0.7090540641602167) CM 0 20:48:41.719 DMD_univariate (AUDUSD,D1) Eigenvalues shape - (20,)
Para expressar a frequência de cada modo em unidades físicas de tempo, é necessário conhecer o intervalo entre a coleta de instantâneos consecutivos. Esse aspecto não recebe destaque no método DynamicModeDecomposition(). O intervalo entre os instantâneos é fundamental porque o DMD calcula um operador de tempo discreto, e esse intervalo permite relacionar os resultados discretos à dinâmica subjacente do sistema em tempo contínuo. Sem essa informação, não é possível converter com precisão os autovalores de tempo discreto em frequências e taxas de crescimento ou decaimento correspondentes ao tempo contínuo. Essas frequências e taxas são calculadas a partir do intervalo entre os instantâneos, utilizando as seguintes fórmulas.
Vetores singulares à esquerda
A matriz retornada no parâmetro left_vectors contém todos os vetores singulares à esquerda obtidos pela decomposição SVD da matriz X1 dos instantâneos de origem. As colunas de left_vectors são conhecidas como modos da decomposição ortogonal própria (Proper Orthogonal Decomposition, POD) do conjunto de dados. Esse termo é utilizado em áreas técnicas e corresponde, conceitualmente, às componentes principais da análise estatística.
Left singular vectors -> left_vectors [[-0.2186571002130553,0.2532378192042484,-0.03145683319876429,-0.08784983133100939,0.3705873208513075,0.2206528031484838,0.1522505585095688,0.2508786634158028,0.4005453375455179,-0.2070914249820868,-0.256938973254042,0.1083123043478309,0.3743749436717269,-0.08325285604985129,0.2153162921311084,0.03514527602276374,0.2660964556173894,-0.02288502160553232,0.08420865568250724,-0.1244960454833032,-0.05915206418948179,0.1412740898453582,-0.06378450251683798,0.05225051446648973,0.04596520897629693,0.05533900119077329,-0.03035343487604242,0.01632904421933207,0.02488201223142909,0.009443994581533457,0.003233076671905151,-0.007000002498680975,-0.0003763343596269273,-0.002249960643275939,0.006083378336102527,0.002738028494735405,-0.003071412428518359,0.007630930463007241,0.0006780866248171729,-0.001537236018891231,0.001097628276266037,0.002549189417918068,-0.00121555935468654,0.0002914617225681344,-0.001329425380550676,-0.0008417462519557183,-0.0001925572219431676,0.0006672631970817051,1.658425254616608e-07,-0.003517246244801298] ,[-0.2120650337138182,0.2460711108749398,0.02614922665855949,-0.06095346519256405,0.316287819867838,0.1367332022924505,0.1608350411867044,0.08971817028514953,0.1591329520755127,0.016649392674401,-0.02435104895770137,-0.1166535735451681,-0.1350117043919009,0.1534878122543588,-0.2129032230923289,0.07705593536128043,-0.375021818402949,-0.07706813579203413,-0.1050339399444373,0.2860161516006371,0.08475158498594149,-0.3855235413551042,0.1862630616541108,-0.1991183017470892,-0.1509536720131326,-0.2375913171609213,0.1371371152602869,-0.0898699217072978,-0.1292195766965235,-0.06648667026234195,-0.01812981549697532,0.0417051043959161,0.009525456359058087,0.01011521692378288,-0.03803922672356531,-0.02106190474509607,0.01766810797476536,-0.04822406797849837,-0.003057210631146539,0.006231539022859201,-0.006288330102253714,-0.0156751476701437,0.009093777375705452,-0.003891906142160671,0.01113869460673238,0.005700478320541056,0.001323281173233992,-0.004963029289243439,0.002210166681645755,0.01885563684292829] ,[-0.2050754583292416,0.2276848333084614,0.08120826878905353,-0.0401725018668373,0.255713699260657,0.06031724967005543,0.1260872837922681,-0.05233055144856189,-0.02895470981613132,0.1414817752150981,0.1496548155010341,-0.1633919339675757,-0.2909072792943354,0.1170695606024898,-0.2104477264601786,-0.05761666740975601,-0.1642196356337907,0.09376106622320569,-0.09917019230808037,-0.0512314209072473,0.07533085329520638,0.2045397680225845,-0.1172476831676734,0.2373535055615748,0.1327391899523122,0.363322598165184,-0.2353759964165236,0.2001199525018012,0.2797917856739792,0.2087875622138012,0.03391328469051902,-0.1093628961879368,-0.04980659874835306,-0.009841138497083401,0.1071536601377198,0.07721338502591252,-0.04348696114962958,0.1359693579381065,0.005776723545380768,-0.00329638274325811,0.01197007184135679,0.04141926298403621,-0.03188888672341144,0.02029703016126579,-0.0411903406233533,-0.02103491458905859,-0.004064246582866178,0.01736432751085308,-0.01540381295312496,-0.04519633129179929] ,[-0.197864304332741,0.198939547987894,0.1313736616978487,-0.02558290784786304,0.1925995771445337,-0.006134276320507245,0.05852103373207649,-0.1566416078904816,-0.1489006796224137,0.1767605998850408,0.2187235587134117,-0.08102546015612813,-0.2025179789413045,-0.02467023236462294,0.007177707826474537,-0.1394599646494139,0.1774528338997285,0.1254318761473469,0.06991185536803274,-0.2322392434345509,-0.1022804195006251,0.2595084087385101,-0.1385151209344889,0.02231602330043558,0.08496345787013258,-0.1181672772615679,0.1251167503291135,-0.1942278207520568,-0.2798025229501522,-0.3656598349104803,0.01139657187065844,0.1552588902748942,0.1253960619854343,-0.03868294575932402,-0.1774709498310883,-0.172412195179344,0.05203395600508887,-0.2094389089818375,-0.004270301693629558,-0.03143829332941872,0.006497267040059443,-0.05389031613821053,0.06861563190685697,-0.0601060573479536,0.08699077151177441,0.05297098886227182,0.005414702197319015,-0.03549882813964893,0.05199258221374336,0.05778558739229585…] Left singular vectors shape - (50,50)
Modos DMD
Os modos DMD projetados, também conhecidos como vetores de Ritz, são retornados na matriz de saída Z. O parâmetro jobz é uma enumeração do tipo ENUM_DMD_EIGV que controla os resultados fornecidos nessa matriz. Ele permite optar por não calcular os modos quando eles não forem necessários. Vamos examinar os modos obtidos pela decomposição de nosso conjunto de dados sintéticos. Os leitores mais atentos perceberão que a matriz Z contém elementos reais, embora os autovalores correspondentes sejam complexos. Como isso é possível? Na verdade, os modos também são complexos. O método DynamicModeDecomposition() retorna esses valores complexos em uma representação compacta.
KN 0 20:54:02.688 DMD_univariate (AUDUSD,D1) Z MJ 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [[-0.2115833899347683,0.04066707935807452,0.1309479910169292,-0.05340607539953211,-0.1311407627226479,-0.05294578413949149,0.1307327748372062,-0.05393554251234634,0.1300831102003118,0.05561343290756637,0.05476143012438625,0.1303708466035617,-0.0602971275669671,0.1290171409159042,0.1325833779653352,-0.0474567460410165,0.03953679964167294,0.1224969410523646,-0.08648845700023616,0.1302991571594397] KL 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [-0.1410082298469801,-0.1561422002553993,0.1320001302525303,-0.05075005112167052,-0.1194054633670081,-0.07578550974758559,0.1394053542006602,-0.02379589291884476,0.09978976936668775,0.1002790127266047,-0.003759313795174276,0.1413556653516757,-0.1215537937113269,0.07412474322962503,0.1352548790995219,0.03928642939266112,-0.06394467904383667,0.1123039293425674,-0.1528368724559976,0.02980086078332629] KE 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0.0571288895384227,-0.1979205129165305,0.1329984050115342,-0.0480733131719782,-0.1037338006863208,-0.09612679258491226,0.1412219243613748,0.007514043825130007,0.05497499123596727,0.1303496653103515,-0.06161407873237246,0.1272770978516157,-0.1422252875452086,-0.00546499036287681,0.08655973711477287,0.1111375957285514,-0.1264360522083525,0.02869970692204134,-0.1280036213687715,-0.0876039346033588] QM 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0.1946438003924811,-0.0523269950779746,0.1339424057467836,-0.04537695566367969,-0.08464242182804624,-0.1132990516514234,0.1360931500665304,0.03845442944292374,0.002161029940774177,0.1414497110787759,-0.1085446923168975,0.09063109173113748,-0.1154409995132384,-0.08318535501859128,0.004972784147358847,0.1408055296621761,-0.1069381563322531,-0.07420079524911123,-0.02739821515064329,-0.1519997996523627] MD 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0.1442714745004026,0.1362363903857534,0.1348317466067521,-0.04266207939022894,-0.06276071186776834,-0.1267361823950489,0.1242712682729774,0.06750360361706979,-0.05096588923209126,0.1319643397659119,-0.1362298611687498,0.03791506074287562,-0.0501630100812688,-0.133110472474709,-0.07853144874233632,0.1170082970122646,-0.01755245167388933,-0.1294221063050899,0.08865106243357559,-0.1256351416263412] FO 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [-0.03992077677928203,0.1893519332890936,0.1356660661019982,-0.03992979099864888,-0.03881004602829696,-0.1359952192100831,0.10633768314148,0.09323292091368418,-0.09667419061156554,0.1032745163734511,-0.139760607057441,-0.02152411345851591,0.0318114520997212,-0.1386035419997053,-0.1322392470005959,0.04876382240238289,0.08394555153666447,-0.1006538267573124,0.1510967437027885,-0.02495855075802432] IE 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [-0.1796559181414814,0.06272269832359235,0.1364450246963949,-0.03718120464898366,-0.01358000327434823,-0.1407709344456745,0.08317437492830956,0.1143770068564059,-0.1283121621102718,0.05955600024366348,-0.1185106827077816,-0.07714740932760773,0.103127741913013,-0.09785844890997622,-0.1357422735154563,-0.03802553162801222,0.1314496877308521,-0.006061975670165805,0.123318478664932,0.08964429318551075] ON 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [-0.145052625469143,-0.1177739752477081,0.1371683036826087,-0.03441744261256562,0.01209766591051641,-0.140905898452734,0.05592052522418876,0.1298959869971385,-0.1412759661384557,0.007171600964583176,-0.07624763897835488,-0.1190923437906344,0.1400016038285632,-0.02449262903763641,-0.08769262768666558,-0.1104036026020508,0.09357636250498216,0.09318079023848276,0.02260518070773477,0.1500697490161283] OD 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0.02477722278466908,-0.1806550663349361,0.1378356065274133,-0.03163963382212003,0.03737645720044752,-0.1363956708335061,0.02591649044609354,0.1390266308270787,-0.1336795590605116,-0.04625490379734653,-0.02046485321417844,-0.1399216409042799,0.1301514645240822,0.05700280745582626,-0.006321464342295452,-0.1408756808015346,-0.00561461203492375,0.1324202843066922,-0.09062222999370595,0.1209556314953582] FO 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0.1648424157584578,-0.07139540484283648,0.1384466607105591,-0.02884891198589165,0.06142301561190965,-0.1273889490658437,-0.005362119258359672,0.141319891110143,-0.1066290580133119,-0.09294834217094237,0.03894705870314489,-0.1359418964516609,0.0768895241650633,0.1194373735899043,0.0774784937512529,-0.1178541799925052,-0.1018942505428861,0.08561003773138477,-0.149086741625562,0.0203522730386399…] ID 0 20:54:02.688 DMD_univariate (AUDUSD,D1) Z shape - (50,20)
Para cada modo representado por uma coluna da matriz Z, se o autovalor correspondente tiver parte imaginária diferente de zero, a coluna seguinte de Z conterá as componentes imaginárias desse modo. Isso também implica a existência de outro autovetor, que corresponde ao conjugado complexo do autovetor resultante. Por outro lado, quando o autovalor não possui parte imaginária, a coluna seguinte corresponde a outro autovalor. O código a seguir define uma função auxiliar chamada compact_to_complex(), que recebe estruturas contendo números reais (utilizados para representar números complexos em formato compacto) e um vetor de números complexos que serve como referência para decodificar a representação original. A função retorna uma estrutura contendo os números complexos reconstruídos.
//+------------------------------------------------------------------+ //|process vector representing complex numbers in compact form | //+------------------------------------------------------------------+ vectorc compact_to_complex(vector& v,vectorc& bp) { vectorc v_out = vectorc::Zeros(v.Size()); for(ulong i = 0; i<v.Size() && i<bp.Size();) { if(bp[i].imag) { v_out[i].real = v[i]; if(i+1 < v.Size()) { v_out[i].imag = v[i+1]; v_out[i+1].real = v_out[i].real; v_out[i+1].imag = -1.0*v_out[i].imag; i+=2; } } else { v_out[i].real = v[i]; i+=1; } } return v_out; } //+------------------------------------------------------------------+ //| process matrix representing complex numbers in compact form | //+------------------------------------------------------------------+ matrixc compact_to_complex(matrix& m, vectorc& bp) { matrixc m_out = matrixc::Zeros(m.Rows(), m.Cols()); for(ulong i = 0; i<m.Rows(); i++) { vector row = m.Row(i); vectorc row_c = compact_to_complex(row,bp); m_out.Row(row_c,i); } return m_out; }
A seguir, podemos observar a diferença entre os modos armazenados em formato compacto e os mesmos modos em sua representação complexa completa.
CF 0 20:54:02.688 DMD_univariate (AUDUSD,D1) DMD modes or Ritz Vectors -> Z PS 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [[(-0.2115833899347683,0.04066707935807452),(-0.2115833899347683,-0.04066707935807452),(0.1309479910169292,-0.05340607539953211),(0.1309479910169292,0.05340607539953211),(-0.1311407627226479,-0.05294578413949149),(-0.1311407627226479,0.05294578413949149),(0.1307327748372062,-0.05393554251234634),(0.1307327748372062,0.05393554251234634),(0.1300831102003118,0.05561343290756637),(0.1300831102003118,-0.05561343290756637),(0.05476143012438625,0.1303708466035617),(0.05476143012438625,-0.1303708466035617),(-0.0602971275669671,0.1290171409159042),(-0.0602971275669671,-0.1290171409159042),(0.1325833779653352,-0.0474567460410165),(0.1325833779653352,0.0474567460410165),(0.03953679964167294,0.1224969410523646),(0.03953679964167294,-0.1224969410523646),(-0.08648845700023616,0.1302991571594397),(-0.08648845700023616,-0.1302991571594397)] OO 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [(-0.1410082298469801,-0.1561422002553993),(-0.1410082298469801,0.1561422002553993),(0.1320001302525303,-0.05075005112167052),(0.1320001302525303,0.05075005112167052),(-0.1194054633670081,-0.07578550974758559),(-0.1194054633670081,0.07578550974758559),(0.1394053542006602,-0.02379589291884476),(0.1394053542006602,0.02379589291884476),(0.09978976936668775,0.1002790127266047),(0.09978976936668775,-0.1002790127266047),(-0.003759313795174276,0.1413556653516757),(-0.003759313795174276,-0.1413556653516757),(-0.1215537937113269,0.07412474322962503),(-0.1215537937113269,-0.07412474322962503),(0.1352548790995219,0.03928642939266112),(0.1352548790995219,-0.03928642939266112),(-0.06394467904383667,0.1123039293425674),(-0.06394467904383667,-0.1123039293425674),(-0.1528368724559976,0.02980086078332629),(-0.1528368724559976,-0.02980086078332629)] MN 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [(0.0571288895384227,-0.1979205129165305),(0.0571288895384227,0.1979205129165305),(0.1329984050115342,-0.0480733131719782),(0.1329984050115342,0.0480733131719782),(-0.1037338006863208,-0.09612679258491226),(-0.1037338006863208,0.09612679258491226),(0.1412219243613748,0.007514043825130007),(0.1412219243613748,-0.007514043825130007),(0.05497499123596727,0.1303496653103515),(0.05497499123596727,-0.1303496653103515),(-0.06161407873237246,0.1272770978516157),(-0.06161407873237246,-0.1272770978516157),(-0.1422252875452086,-0.00546499036287681),(-0.1422252875452086,0.00546499036287681),(0.08655973711477287,0.1111375957285514),(0.08655973711477287,-0.1111375957285514),(-0.1264360522083525,0.02869970692204134),(-0.1264360522083525,-0.02869970692204134),(-0.1280036213687715,-0.0876039346033588),(-0.1280036213687715,0.0876039346033588)] OI 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [(0.1946438003924811,-0.0523269950779746),(0.1946438003924811,0.0523269950779746),(0.1339424057467836,-0.04537695566367969),(0.1339424057467836,0.04537695566367969),(-0.08464242182804624,-0.1132990516514234),(-0.08464242182804624,0.1132990516514234),(0.1360931500665304,0.03845442944292374),(0.1360931500665304,-0.03845442944292374),(0.002161029940774177,0.1414497110787759),(0.002161029940774177,-0.1414497110787759),(-0.1085446923168975,0.09063109173113748),(-0.1085446923168975,-0.09063109173113748),(-0.1154409995132384,-0.08318535501859128),(-0.1154409995132384,0.08318535501859128),(0.004972784147358847,0.1408055296621761),(0.004972784147358847,-0.1408055296621761),(-0.1069381563322531,-0.07420079524911123),(-0.1069381563322531,0.07420079524911123),(-0.02739821515064329,-0.1519997996523627),(-0.02739821515064329,0.1519997996523627)] CH 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [(0.1442714745004026,0.1362363903857534),(0.1442714745004026,-0.1362363903857534),(0.1348317466067521,-0.04266207939022894),(0.1348317466067521,0.04266207939022894),(-0.06276071186776834,-0.1267361823950489),(-0.06276071186776834,0.1267361823950489),(0.1242712682729774,0.06750360361706979),(0.1242712682729774,-0.06750360361706979),(-0.05096588923209126,0.1319643397659119),(-0.05096588923209126,-0.1319643397659119),(-0.1362298611687498,0.03791506074287562),(-0.1362298611687498,-0.03791506074287562),(-0.0501630100812688,-0.133110472474709),(-0.0501630100812688,0.133110472474709),(-0.07853144874233632,0.1170082970122646),(-0.07853144874233632,-0.1170082970122646),…] KG 0 20:54:02.688 DMD_univariate (AUDUSD,D1) DMD modes or Ritz Vectors shape (50,20)
Resíduos
Os dois parâmetros de saída seguintes, residuals e res_vectors, estão relacionados. Cada elemento do vetor residuals corresponde à norma euclidiana de um vetor residual armazenado em uma coluna da matriz res_vectors. Cada vetor residual está associado a um par de Ritz e mede o desvio entre a aplicação do operador ao vetor de Ritz e o produto desse vetor pelo valor de Ritz correspondente. De modo geral, quanto menores forem essas normas, melhor será a aproximação dos respectivos pares de Ritz.
CD 0 20:54:02.689 DMD_univariate (AUDUSD,D1) Residual norms -> residuals FO 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0.008836676346169272,0.008836676346169272,9.235187494765224e-09,9.235187494765224e-09,1.742579533919419e-08,1.742579533919419e-08,1.653443663139743e-08,1.653443663139743e-08,2.597847624528849e-07,2.597847624528849e-07,2.320987987120818e-07,2.320987987120818e-07,9.788834713137558e-06,9.788834713137558e-06,8.123609086522145e-06,8.123609086522145e-06,0.0004010758671648529,0.0004010758671648529,0.0004371025994576595,0.0004371025994576595] EN 0 20:54:02.689 DMD_univariate (AUDUSD,D1) Residuals shape - (20,)
O parâmetro de saída residuals é um vetor de números reais, enquanto res_vectors é uma matriz que armazena números complexos em formato compacto.
CD 0 20:54:02.690 DMD_univariate (AUDUSD,D1) Residual vectors -> res_vectors OR 0 20:54:02.690 DMD_univariate (AUDUSD,D1) [[(0.0007788944957199118,6.210241253423732E-05),(0.0007788944957199118,-6.210241253423732E-05),(-5.316966866786288E-10,-4.560266955722092E-10),(-5.316966866786288E-10,4.560266955722092E-10),(9.00277352666734E-10,9.748073598325746E-10),(9.00277352666734E-10,-9.748073598325746E-10),(7.854966954656817E-10,-9.872156113421848E-10),(7.854966954656817E-10,9.872156113421848E-10),(-1.459522849800443E-08,1.377941803715199E-08),(-1.459522849800443E-08,-1.377941803715199E-08),(1.069276902784799E-08,-1.449544934084557E-08),(1.069276902784799E-08,1.449544934084557E-08),(-5.704307382975449E-07,5.291619083608312E-07),(-5.704307382975449E-07,-5.291619083608312E-07),(-4.031761563494385E-07,5.112246791380559E-07),(-4.031761563494385E-07,-5.112246791380559E-07),(-2.293253034875431E-05,2.549073482446818E-05),(-2.293253034875431E-05,-2.549073482446818E-05),(1.737165621398806E-05,3.217988337436348E-05),(1.737165621398806E-05,-3.217988337436348E-05)] PH 0 20:54:02.690 DMD_univariate (AUDUSD,D1) [(-0.001602312423460747,-0.0004729759518786458),(-0.001602312423460747,0.0004729759518786458),(9.344054696658333E-10,8.094462253249723E-10),(9.344054696658333E-10,-8.094462253249723E-10),(-1.519821102302643E-09,-1.798446391809705E-09),(-1.519821102302643E-09,1.798446391809705E-09),(-1.489875889326697E-09,1.679088970293896E-09),(-1.489875889326697E-09,-1.679088970293896E-09),(2.855568843884715E-08,-2.24272293236627E-08),(2.855568843884715E-08,2.24272293236627E-08),(-2.198151384524838E-08,2.429971562856181E-08),(-2.198151384524838E-08,-2.429971562856181E-08),(1.189711697907603E-06,-8.400539607544832E-07),(1.189711697907603E-06,8.400539607544832E-07),(8.892800195531292E-07,-8.493346006915869E-07),(8.892800195531292E-07,8.493346006915869E-07),(5.40418365579387E-05,-4.256796091403961E-05),(5.40418365579387E-05,4.256796091403961E-05),(-2.314522858359869E-05,-6.846121833149754E-05),(-2.314522858359869E-05,6.846121833149754E-05)] FG 0 20:54:02.690 DMD_univariate (AUDUSD,D1) [(4.593660886884066E-05,0.0007257275432220045),(4.593660886884066E-05,-0.0007257275432220045),(3.019065830667245E-10,2.421602848801108E-10),(3.019065830667245E-10,-2.421602848801108E-10),(-6.415215442201472E-10,-3.751031429910512E-10),(-6.415215442201472E-10,3.751031429910512E-10),(-2.171667012884626E-10,6.773338626087089E-10),(-2.171667012884626E-10,-6.773338626087089E-10),(2.210737475895341E-09,-1.156460674445192E-08),(2.210737475895341E-09,1.156460674445192E-08),(5.990476170669723E-10,1.068699011230745E-08),(5.990476170669723E-10,-1.068699011230745E-08),(-6.762525454895307E-08,-4.884491409673508E-07),(-6.762525454895307E-08,4.884491409673508E-07),(-1.490076587543424E-07,-3.929403302738166E-07),(-1.490076587543424E-07,3.929403302738166E-07),(-1.571073502396048E-05,-1.913611580105223E-05),(-1.571073502396048E-05,1.913611580105223E-05),(-2.530414087616173E-05,6.629116600515017E-06),(-2.530414087616173E-05,-6.629116600515017E-06)] DS 0 20:54:02.690 DMD_univariate (AUDUSD,D1) [(0.001363806542495044,0.0001361882900650091),(0.001363806542495044,-0.0001361882900650091),(-9.180490534443919E-10,-7.880395988535405E-10),(-9.180490534443919E-10,7.880395988535405E-10),(1.549437189662939E-09,1.690010908994566E-09),(1.549437189662939E-09,-1.690010908994566E-09),(1.36508163106619E-09,-1.700071097787692E-09),(1.36508163106619E-09,1.700071097787692E-09),(-2.543471129545782E-08,2.364815934741138E-08),(-2.543471129545782E-08,-2.364815934741138E-08),(1.871941607278771E-08,-2.493395216685013E-08),(1.871941607278771E-08,2.493395216685013E-08),(-1.000003475026823E-06,9.064440836814569E-07),(-1.000003475026823E-06,-9.064440836814569E-07),(-7.106895980740768E-07,8.787577454316686E-07),(-7.106895980740768E-07,-8.787577454316686E-07),(-4.07015728396895E-05,4.38344900164922E-05),(-4.07015728396895E-05,-4.38344900164922E-05),(2.940113570619463E-05,5.652142258574799E-05),(2.940113570619463E-05,-5.652142258574799E-05)] OK 0 20:54:02.690 DMD_univariate (AUDUSD,D1) [(0.0005033857628483629,-0.0006840539757191899),(0.0005033857628483629,0.0006840539757191899),(-6.779790617805759E-10,-5.646610123921647E-10),(-6.779790617805759E-10,5.646610123921647E-10),(1.278677420890606E-09,1.06406300437456E-09),(1.278677420890606E-09,-1.06406300437456E-09),…] PG 0 20:54:02.690 DMD_univariate (AUDUSD,D1) OJ 0 20:54:02.690 DMD_univariate (AUDUSD,D1) Residual vectors shape - (50,20)
O parâmetro jobr, do tipo de enumeração ENUM_DMD_RESIDUALS, permite desativar o cálculo dos resíduos quando eles não forem necessários.
Refinamento de Ritz e modos DMD exatos
O parâmetro jobf é uma enumeração do tipo ENUM_DMD_REFINE que determina o conteúdo retornado na matriz B.- Quando jobf é definido como DMDREFINE_N, o método não calcula dados de refinamento e não utiliza a matriz de saída B.
- Quando jobf é definido como DMDREFINE_E, a matriz B contém os modos DMD exatos, representados por números complexos em formato compacto. A diferença entre os modos DMD exatos e os modos DMD projetados está na relação de cada um com o operador linear subjacente que aproxima a dinâmica do sistema. Embora ambos estejam associados aos mesmos autovalores, suas estruturas espaciais, ou seja, os próprios modos, são diferentes. Os modos DMD projetados são obtidos por projeção em um subespaço gerado por vetores de base. Por isso, são aproximações, e não necessariamente os autovetores do operador linear que melhor representa a dinâmica do sistema. O cálculo dos modos DMD exatos utiliza uma abordagem alternativa para resolver o mesmo problema. Em vez de restringir os modos ao subespaço de projeção, essa abordagem permite obter diretamente os autovetores do operador linear aproximado. Os modos resultantes são considerados exatos porque correspondem aos autovetores do operador que fornece a melhor aproximação linear do sistema. Isso ocorre porque eles não ficam restritos ao espaço gerado pelos instantâneos dos dados originais.
- Quando jobf é definido como DMDREFINE_R, a matriz B retorna os valores necessários para uma etapa de pós-processamento denominada refinamento de Ritz. Como vimos anteriormente, os pares de Ritz são calculados a partir de uma aproximação do operador linear A. O refinamento de Ritz é uma técnica utilizada para melhorar a precisão dos vetores de Ritz. Nesse caso, a matriz B contém os valores necessários para minimizar os resíduos iniciais. Embora o refinamento de Ritz esteja fora do escopo deste artigo, essa etapa costuma ser útil para melhorar a qualidade das previsões.
Quociente de Rayleigh
O parâmetro de saída W é outra matriz que armazena números complexos em formato compacto.
DQ 0 20:54:02.689 DMD_univariate (AUDUSD,D1) DMD matrix eigenvectors - W CQ 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [[(0.03397841954159109,0.03317980055719008),(0.03397841954159109,-0.03317980055719008),(-0.9002396504998079,0),(-0.9002396504998079,-0),(0.01119040053117125,0.1182840538877034),(0.01119040053117125,-0.1182840538877034),(-0.08933258155433688,-0.07445561873978643),(-0.08933258155433688,0.07445561873978643),(0.002252288602000291,-0.07268070968789277),(0.002252288602000291,0.07268070968789277),(0.06363962546273101,-0.06242908185135146),(0.06363962546273101,0.06242908185135146),(0.05937239512593095,0.01490455626039135),(0.05937239512593095,-0.01490455626039135),(-0.02589857176991502,-0.03197379959572326),(-0.02589857176991502,0.03197379959572326),(0.03403147435273887,-0.02518975096744712),(0.03403147435273887,0.02518975096744712),(0.04814500369424651,0.0006646006481806285),(0.04814500369424651,-0.0006646006481806285)] LK 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [(-0.03856865140041035,-0.04728745684412225),(-0.03856865140041035,0.04728745684412225),(-0.07418687400224905,-0.02671782636983063),(-0.07418687400224905,0.02671782636983063),(-0.6278925369875541,0),(-0.6278925369875541,-0),(0.6611296439031247,0),(0.6611296439031247,-0),(-0.01948319607116129,0.1638582051901045),(-0.01948319607116129,-0.1638582051901045),(-0.1160509917189585,0.04684553196764583),(-0.1160509917189585,-0.04684553196764583),(-0.06080699466607752,-0.007252509160005485),(-0.06080699466607752,0.007252509160005485),(0.04824148800646633,0.0544753020238296),(0.04824148800646633,-0.0544753020238296),(-0.02631424783289801,0.02396317634823539),(-0.02631424783289801,-0.02396317634823539),(-0.05371125803952446,-0.01772350219292688),(-0.05371125803952446,0.01772350219292688)] JS 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [(0.01927996329670138,-0.003323809768950481),(0.01927996329670138,0.003323809768950481),(-0.001092132447284393,-0.08813408560005521),(-0.001092132447284393,0.08813408560005521),(-0.01686362521399225,-0.6191005830078983),(-0.01686362521399225,0.6191005830078983),(0.02637345886634726,0.5944648032143058),(0.02637345886634726,-0.5944648032143058),(-0.1052128591626567,-0.008385210070686162),(-0.1052128591626567,0.008385210070686162),(-0.004565995041448841,-0.09830093201273357),(-0.004565995041448841,0.09830093201273357),(0.02484135400580122,-0.004386892506558514),(0.02484135400580122,0.004386892506558514),(-0.01604018998961423,0.01817361621091497),(-0.01604018998961423,-0.01817361621091497),(0.01513765754343997,-0.01442045062996068),(0.01513765754343997,0.01442045062996068),(0.02301961366729926,-0.02281949313848668),(0.02301961366729926,0.02281949313848668)] DQ 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [(0.01349178032453495,0.04031036542801018),(0.01349178032453495,-0.04031036542801018),(0.2800915230663114,0.2610589921860959),(0.2800915230663114,-0.2610589921860959),(0.07750855775646105,-0.2950535943034701),(0.07750855775646105,0.2950535943034701),(-0.2337105682364486,0.0040858569402831),(-0.2337105682364486,-0.0040858569402831),(0.06293226732327413,-0.1508577239678987),(0.06293226732327413,0.1508577239678987),(-0.03484731631897012,0.1006710384526284),(-0.03484731631897012,-0.1006710384526284),(-0.01073717194453397,-0.1026561241299194),(-0.01073717194453397,0.1026561241299194),(-0.08143509356008606,-0.07823035735671989),(-0.08143509356008606,0.07823035735671989),(-0.06786249180652332,-0.01131117739979555),(-0.06786249180652332,0.01131117739979555),(-0.01459517002905221,0.04968638335424509),(-0.01459517002905221,-0.04968638335424509)] DS 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [(-0.06312195367435448,-0.05788238216619907),(-0.06312195367435448,0.05788238216619907),(-0.106179393196619,-0.1067792237431208),(-0.106179393196619,0.1067792237431208),(0.2228105336536818,-0.09464986022387956),(0.2228105336536818,0.09464986022387956),(-0.1223565828897724,-0.2665717534473687),(-0.1223565828897724,0.2665717534473687),(0.0407625323894802,0.0608679763109657),(0.0407625323894802,-0.0608679763109657),(-0.0236347933639726,0.2167362736925585),(-0.0236347933639726,-0.2167362736925585),(-0.1397842805702028,0.002686549243340094),(-0.1397842805702028,-0.002686549243340094),(0.0494448535458599,0.07175076524193082),(0.0494448535458599,-0.07175076524193082),(-0.05089933082548433,0.06350343732496355),…] LP 0 20:54:02.689 DMD_univariate (AUDUSD,D1) FK 0 20:54:02.689 DMD_univariate (AUDUSD,D1) W shape - (20,20)
Essa matriz contém os autovetores da matriz obtida pelo cálculo do quociente de Rayleigh. A matriz de saída S contém a matriz de Rayleigh, que representa o operador linear projetado no subespaço de dimensão reduzida. Nesse contexto, o quociente de Rayleigh é definido pela seguinte expressão.
O resultado é uma matriz quadrada que aproxima o operador linear A nesse subespaço.
RF 0 20:54:02.688 DMD_univariate (AUDUSD,D1) DMD matrix or Rayleigh Quotient -> S HR 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [[0.5094085277495803,-0.8604610082897919,0.0002006138033779966,0.04760027059805147,-0.002803306343440372,-0.0391415882078795,-0.0003134843372287616,0.07893996206869613,0.001757225544053047,0.05891514022091245,0.1021418500890567,0.0154878531271508,0.08161025402145326,-0.01322727684398736,0.05289807915719862,0.1366031199179701,0.09067443894366256,0.02387635894976379,-0.1337617534319445,0.3158438887995204] GG 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0.8125718517577054,0.5094085277495803,0.03212818037482736,0.07731373949333104,-0.004523461571676836,-0.06365727084560829,0.07166331416570983,0.1149560436517001,0.0417897026770658,0.0807703163043338,0.1168290328074077,-0.07784523729378179,0.08134266010864513,0.0457586690177342,-0.05281322289935021,0.1041166865025129,0.06016908821880863,-0.02262883866060445,0.01864963663274376,0.1592958144288718] QM 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0,0,0.9997963823571733,-0.06841114291664024,0.003677630227929817,0.05134906476950822,0.001010343646915456,-0.1036712695688504,-0.001982116115745312,-0.07741467176450138,-0.1344061700387433,-0.02117211346836873,-0.1074879052755059,0.01790950142871103,-0.07054528189524574,-0.180179648794732,-0.1196714016226133,-0.0318305136919558,0.177441519638216,-0.4172515456746314] PO 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0,0,0.005964529447791189,0.9997963823571733,-6.130430193796907e-05,0.0001608255296355939,-0.1417177910594132,0.02603215499459065,-0.07645245784783392,0.02929171223870932,0.09632863544056425,0.2022679146534209,0.1005224694321643,-0.1320544694433864,0.2724705351116244,0.2311524902397419,0.1709822160686499,0.1206265129749707,-0.4633910086326531,0.6944803173283216] RG 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0,0,0,0,0.9835155147230954,-0.1807872789366,-0.01287650437961382,0.002273054758487322,-0.006948726541217937,0.002592615695004415,0.008633127046368962,0.01836065518926932,0.009038166070419178,-0.01198352209799287,0.02469606203936868,0.02084314801005234,0.01542969758433841,0.01093290292806937,-0.04194970752430172,0.06273377057840418] OE 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0,0,0,0,0.1808472032071591,0.9835155147230954,0.1161226589750725,-0.02159149420945333,0.06263828964805583,-0.02419610245484403,-0.07926824162748283,-0.1657867613281642,-0.08263670791881386,0.1082473436056935,-0.2234334894897005,-0.1898550808858993,-0.1404004467922538,-0.09891860736477874,0.3801384435040523,-0.5700922000360884] QE 0 20:54:02.688 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0.9754097172453285,-0.3671559385031988,-0.005735330959573934,-0.1752131166062669,-0.3034665524406584,-0.0447757385532624,-0.2423096107440454,0.03850758043656835,-0.1556886673590776,-0.4051646386927485,-0.2688190825258632,-0.07028522559611267,0.3951927856107862,-0.935685263814825] ES 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0.1323025776105538,0.9754097172453285,-0.1277498034867074,0.01635682016747238,0.1038905065841927,0.3269719154788018,0.122074385755231,-0.211766280182049,0.4229381295746578,0.3086378423896532,0.2339698855185775,0.1869911903713443,-0.6953365989256011,0.9790102802912404] EJ 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0,0,0.9272204223699192,-0.4253756556605945,-0.1675761806365016,-0.0322689202475039,-0.1347517961361585,0.0260709867621285,-0.09491983678538948,-0.2278476057705441,-0.1518792160120434,-0.04275596295515771,0.2317849265989918,-0.532635511016381] FM 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0,0,0.3296680581625781,0.9272204223699192,0.05633171550556969,0.2408424337338481,0.07416894629162182,-0.1553200191742876,0.3047043287502109,0.2020029040523848,0.1558084075499993,0.1346159453957157,-0.4912332208887085,0.6651615829764952] HG 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0,0,0,0,0.9113505757240357,-0.2568972073981867,0.05055669367035209,-0.2566052078814798,0.4776439687989247,0.2195895146754944,0.1834173442058648,0.2105372198999828,-0.7236933009079901,0.8511605081274156] JD 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0,0,0,0,0.6596006848134373,0.9113505757240357,0.3140920520023247,-0.01324336135550369,0.1361348333013918,0.5052672912884386,0.3296699228616658,0.06220880832355302,-0.4176612853765882,1.116102030438296] JE 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0,0,0,0,0,0,0.8329207590629218,0.4624722437908844,0.355960803548531,0.1072881843791952,0.1013740688581597,0.1566216030021757,-0.5124168716630659,0.5231145883642944] LP 0 20:54:02.689 DMD_univariate (AUDUSD,D1) [0,0,0,0,0,0,0,0,0,0,0,0,-0.6609520652656545,0.8329207590629218,-0.07009147383110947,-0.3140620624168415,-0.2035214647743208,-0.03229751959115882…] NH 0 20:54:02.689 DMD_univariate (AUDUSD,D1) S shape - (20,20)
Com isso, concluímos a análise dos parâmetros de DynamicModeDecomposition(). A seguir, mostraremos como combinar esses resultados para reconstruir os dados, aplicar filtros e gerar previsões. Antes, porém, precisamos contornar as limitações do suporte a números complexos na linguagem MQL5. Algumas funções integradas não aceitam argumentos complexos, o que exige a implementação de utilitários próprios. Para isso, apresentamos a biblioteca cmath, definida no arquivo cmath.mqh.
Operações com números complexos na linguagem MQL5
O arquivo cmath.mqh contém diversos utilitários para operações com números complexos. Entre eles, estão funções que extraem as partes real e imaginária de arrays, vetores e matrizes de números complexos.
//+------------------------------------------------------------------+ //| get real part from container of complex numbers | //+------------------------------------------------------------------+ void real(complex& data[],double& out[]) { ArrayResize(out,data.Size()); for(ulong i = 0; i<out.Size(); i++) out[i] = data[i].real; } //+-------------------------------------------------------------------+ //| get imaginary part from container of complex numbers | //+-------------------------------------------------------------------+ void imaginary(complex& data[],double& out[]) { ArrayResize(out,data.Size()); for(ulong i = 0; i<out.Size(); i++) out[i] = data[i].imag; } //+------------------------------------------------------------------+ //| get real part from container of complex numbers | //+------------------------------------------------------------------+ vector real(vectorc& data) { vector out=vector::Zeros(data.Size()); for(ulong i = 0; i<out.Size(); i++) out[i] = data[i].real; return out; } //+-------------------------------------------------------------------+ //| get imaginary part from container of complex numbers | //+-------------------------------------------------------------------+ vector imaginary(vectorc& data) { vector out=vector::Zeros(data.Size()); for(ulong i = 0; i<out.Size(); i++) out[i] = data[i].imag; return out; } //+------------------------------------------------------------------+ //| get real part from container of complex numbers | //+------------------------------------------------------------------+ matrix real(matrixc& data) { matrix out=matrix::Zeros(data.Rows(),data.Cols()); for(ulong i = 0; i<out.Rows(); i++) for(ulong j = 0; j<out.Cols(); j++) out[i,j] = data[i,j].real; return out; } //+-------------------------------------------------------------------+ //| get imaginary part from container of complex numbers | //+-------------------------------------------------------------------+ matrix imaginary(matrixc& data) { matrix out=matrix::Zeros(data.Rows(),data.Cols()); for(ulong i = 0; i<out.Rows(); i++) for(ulong j = 0; j<out.Cols(); j++) out[i,j] = data[i,j].imag; return out; }
A biblioteca também oferece rotinas para converter estruturas de dados com números reais em estruturas com números complexos e vice-versa.
//+------------------------------------------------------------------+ //| create complex containers from real numbers | //+------------------------------------------------------------------+ vectorc as_complex(vector& re,vector& im) { vectorc out = vectorc::Zeros(MathMax(re.Size(),im.Size())); for(ulong i = 0; i<out.Size(); i++) { out[i].real = i<re.Size()?re[i]:0.0; out[i].imag = i<im.Size()?im[i]:0.0; } return out; } //+------------------------------------------------------------------+ //| create complex containers from real numbers | //+------------------------------------------------------------------+ matrixc as_complex(matrix& re,matrix& im) { matrixc out = matrixc::Zeros((ulong)MathMax(re.Rows(),im.Rows()),(ulong)MathMax(re.Cols(),im.Cols())); for(ulong i = 0; i<out.Rows(); i++) { for(ulong j = 0; j<out.Cols(); j++) { out[i,j].real = (i<re.Rows() && j<re.Cols())?re[i,j]:0.0; out[i,j].imag = (i<im.Rows() && j<im.Cols())?im[i,j]:0.0; } } return out; } //+------------------------------------------------------------------+ //| create complex containers from real numbers | //+------------------------------------------------------------------+ vectorc as_complex(vector& re) { vectorc out = vectorc::Zeros(re.Size()); for(ulong i = 0; i<out.Size(); i++) { out[i].real = re[i]; out[i].imag = 0.0; } return out; } //+------------------------------------------------------------------+ //| create complex containers from real numbers | //+------------------------------------------------------------------+ matrixc as_complex(matrix& re) { matrixc out = matrixc::Zeros(re.Rows(),re.Cols()); for(ulong i = 0; i<out.Rows(); i++) { for(ulong j = 0; j<out.Cols(); j++) { out[i,j].real = re[i,j]; out[i,j].imag = 0.0; } } return out;
Por fim, inclui implementações das funções exponencial, potência, valor absoluto e logaritmo natural para números complexos, bem como para arrays, vetores e matrizes que os contêm.
//+------------------------------------------------------------------+ //| power of complex number | //+------------------------------------------------------------------+ complex c_pow(complex base, complex exponent) { return c_exp(exponent*c_log(base)); } //+------------------------------------------------------------------+ //| simple power of complex number | //+------------------------------------------------------------------+ vectorc c_pow(vectorc &vect, complex exponent) { vectorc out(vect.Size()); for(ulong i = 0; i<vect.Size(); i++) out[i] = c_pow(vect[i],exponent); return out; } //+------------------------------------------------------------------+ //| simple power of complex number | //+------------------------------------------------------------------+ matrixc c_pow(matrixc &matrx, complex exponent) { matrixc out(matrx.Rows(),matrx.Cols()); for(ulong i = 0; i<out.Cols(); i++) out.Col(c_pow(matrx.Col(i),exponent),i); return out; } //+------------------------------------------------------------------+ //| power of complex number | //+------------------------------------------------------------------+ complex c_pow(complex value, double alpha) { complex out = value; double r = c_abs(value); double theta = atan2(value.imag,value.real); double n_r = pow(r,alpha); double n_theta = alpha*theta; out.real = n_r*cos(n_theta); out.imag = n_r*sin(n_theta); return out; } //+------------------------------------------------------------------+ //| simple power of complex number | //+------------------------------------------------------------------+ vectorc c_pow(vectorc &vect, double alpha) { vectorc out(vect.Size()); for(ulong i = 0; i<vect.Size(); i++) out[i] = c_pow(vect[i],alpha); return out; } //+------------------------------------------------------------------+ //| simple power of complex number | //+------------------------------------------------------------------+ matrixc c_pow(matrixc &matrx, double alpha) { matrixc out(matrx.Rows(),matrx.Cols()); for(ulong i = 0; i<out.Cols(); i++) out.Col(c_pow(matrx.Col(i),alpha),i); return out; } //+------------------------------------------------------------------+ //| Complex Signum Function | //+------------------------------------------------------------------+ complex signum(complex z) { double magnitude = sqrt((z.real*z.real) + (z.imag*z.imag)); if(!magnitude) return 0+0i; complex magz; magz.real = magnitude; magz.imag = 0.0; return z/magz; } //+------------------------------------------------------------------+ //| absolute value of a complex number (magnitude) | //+------------------------------------------------------------------+ double c_abs(complex z) { return sqrt((z.real*z.real) + (z.imag*z.imag)); } //+------------------------------------------------------------------+ //| absolute value of a complex number (magnitude) | //+------------------------------------------------------------------+ vector c_abs(vectorc &z) { CComplexVector v(z); return sqrt((v.re*v.re) + (v.im*v.im)); } //+------------------------------------------------------------------+ //| absolute value of a complex number (magnitude) | //+------------------------------------------------------------------+ matrix abs(matrixc &z) { CComplexMatrix v(z); return sqrt((v.re*v.re) + (v.im*v.im)); } //+------------------------------------------------------------------+ //| sqrt of complex number | //+------------------------------------------------------------------+ complex c_sqrt(complex z) { double mag_z = c_abs(z); mag_z=sqrt(mag_z); double theta = atan2(z.imag,z.real); complex out; out.real = mag_z*cos(theta/2.0); out.imag = mag_z*sin(theta/2.0); return out; } //+------------------------------------------------------------------+ //| sqrt of complex vector | //+------------------------------------------------------------------+ vectorc c_sqrt(vectorc &z) { vectorc out = z; for(ulong i = 0; i<out.Size(); i++) out[i] = c_sqrt(z[i]); return out; } //+------------------------------------------------------------------+ //| sqrt of complex vector | //+------------------------------------------------------------------+ matrixc c_sqrt(matrixc &z) { matrixc out = z; for(ulong i = 0; i<out.Cols(); i++) out.Col(c_sqrt(z.Col(i)),i); return out; } //+------------------------------------------------------------------+ //| log of complex number | //+------------------------------------------------------------------+ complex c_log(complex z) { complex out; out.real = c_abs(z); out.imag = atan2(z.imag,z.real); return out; } //+------------------------------------------------------------------+ //| log of complex number | //+------------------------------------------------------------------+ vectorc c_log(vectorc &z) { vectorc out = z; for(ulong i = 0; i<out.Size(); i++) out[i] = c_log(z[i]); return out; } //+------------------------------------------------------------------+ //| log of complex number | //+------------------------------------------------------------------+ matrixc c_log(matrixc &z) { matrixc out = z; for(ulong i = 0; i<out.Cols(); i++) out.Col(c_log(z.Col(i)),i); return out; } //+------------------------------------------------------------------+ //| exp function of complex number | //+------------------------------------------------------------------+ complex c_exp(complex z) { complex out; out.real = exp(z.real)*cos(z.imag); out.imag = exp(z.real)*sin(z.imag); return out; } //+------------------------------------------------------------------+ //| exp function of complex number | //+------------------------------------------------------------------+ vectorc c_exp(vectorc &z) { vectorc out = z; for(ulong i = 0; i<out.Size(); i++) out[i] = c_exp(z[i]); return out; } //+------------------------------------------------------------------+ //| exp function of complex number | //+------------------------------------------------------------------+ matrixc c_exp(matrixc &z) { matrixc out = z; for(ulong i = 0; i<out.Cols(); i++) out.Col(c_exp(z.Col(i)),i); return out; }
Amplitude e dinâmica dos modos
No DMD, a reconstrução consiste em reproduzir os dados de entrada utilizando os modos identificados pela decomposição. Já a filtragem por DMD consiste em reconstruir esses dados utilizando somente os modos selecionados. A previsão, por sua vez, consiste em extrapolar a reconstrução para instantes futuros. Para realizar qualquer uma dessas operações, precisamos calcular as amplitudes e a evolução temporal dos modos correspondentes. As amplitudes não são retornadas diretamente pelo método DynamicModeDecomposition(); elas precisam ser calculadas separadamente, ajustando os modos a um instantâneo do sistema. Normalmente, esse cálculo é realizado pelo método dos mínimos quadrados ou pela aplicação da pseudoinversa da matriz de modos.
Para resolver um problema de mínimos quadrados envolvendo uma matriz não simétrica com elementos complexos, podemos utilizar a decomposição LU das equações normais. Essas equações permitem reformular o problema de mínimos quadrados de um sistema sobredeterminado como um sistema quadrado, que pode ser resolvido por métodos convencionais. Essa operação pode ser realizada com os utilitários da biblioteca ALGLIB, conforme demonstrado no trecho de código a seguir.
//+------------------------------------------------------------------+ //| compute the DMD amplitudes | //+------------------------------------------------------------------+ vectorc compute_amplitudes(matrix& snapshots, matrixc& modes) { vectorc amplitudes(0); vectorc x0 = as_complex(snapshots.Col(0)); matrixc A_h = modes.TransposeConjugate(); matrixc B = np::matmul(A_h,modes); vectorc c = np::matmul(A_h,x0); complex right_side[], solution[]; int pivots[]; CMatrixComplex lua = B; if(!np::vecAsArray(c,right_side)) { Print(__FUNCTION__, " vector as array failure "); return amplitudes; } vector check_pivots; ResetLastError(); CAlglib::CMatrixLU(lua,lua.Rows(),lua.Cols(),pivots); int info; check_pivots.Assign(pivots); if(check_pivots.Max() == check_pivots.Min()) { Print(__FUNCTION__," CAlglib::CMatrixLU() failure ", GetLastError()); return amplitudes; } CDenseSolverReportShell shell; CAlglib::CMatrixLUSolve(lua,pivots,int(pivots.Size()),right_side,info,shell,solution); if(info < 1) { Print(__FUNCTION__, " modes matrix is singular, or VERY close to singular. ", GetLastError()); return amplitudes; } amplitudes.Assign(solution); return amplitudes;
O código define uma função que calcula as amplitudes a partir de uma matriz de instantâneos e de uma matriz de modos. Observe que, neste exemplo, utilizamos o primeiro instantâneo, mas é possível utilizar um instantâneo correspondente a qualquer instante da série. O ajuste pelo método dos mínimos quadrados fornece as amplitudes, que são números complexos. Essas amplitudes também permitem identificar os modos dominantes obtidos pela decomposição DMD. Para isso, calculamos o módulo de cada amplitude. Essa informação pode ser utilizada na etapa de filtragem.
//--- vector abs_dmd_amplitudes = c_abs(dmd_amplitudes); //--- long amp_indices[]; if(!np::arange(amp_indices,int(abs_dmd_amplitudes.Size())) || !np::quickSortIndices(abs_dmd_amplitudes,false,amp_indices,amp_indices[0],amp_indices[amp_indices.Size()-1])) { Print(" error "); return; } //---
Com as amplitudes calculadas, podemos determinar a evolução temporal dos modos. A matriz de dinâmica DMD é construída a partir de uma matriz de Vandermonde, na qual cada linha descreve a evolução de um modo ao longo do tempo. Para esse cálculo, precisamos dos instantes discretos correspondentes aos instantâneos e dos autovalores DMD. Os autovalores são organizados em vetores coluna e elevados às potências correspondentes aos índices temporais discretos do conjunto de dados. Por fim, a evolução de cada modo é ponderada por sua amplitude. A função compute_dynamics() calcula a matriz de dinâmica DMD a partir das amplitudes, dos valores de Ritz e de um vetor com os instantes de amostragem dos instantâneos.
//+------------------------------------------------------------------+ //| calculate the mode dynamics | //+------------------------------------------------------------------+ matrixc compute_dynamics(vectorc& amplitudes,vectorc& eigs, vector& timesteps) { matrixc mat_eigs = np::repeat_vector_as_rows_cols(eigs,timesteps.Size(),false); vector tpow = (timesteps - timesteps[0])/(timesteps[1] - timesteps[0]); matrixc dyn = mat_eigs; for(ulong i = 0; i<mat_eigs.Cols(); i++) { vectorc column = mat_eigs.Col(i); column = c_pow(column,tpow[i]); column*=amplitudes; dyn.Col(column,i); } return dyn; }
O gráfico a seguir apresenta a evolução temporal do modo dominante em nosso exemplo. Ele foi gerado pelo script DMD_Mode_Dynamics.ex5.
Reconstrução e previsão
Os modos DMD, as amplitudes e os autovalores podem ser combinados para construir uma aproximação dos dados de entrada. O conjunto de dados reconstruído constitui uma representação de baixo posto que captura a dinâmica dominante dos dados originais. Essa reconstrução é obtida pela multiplicação da matriz de modos pela matriz de dinâmica correspondente.
//+------------------------------------------------------------------+ //| reconstruct the input data based on the dominant dmd dynamics | //+------------------------------------------------------------------+ matrixc reconstructed_data(matrixc& dynamics, matrixc& modes) { return np::matmul(modes,dynamics); }
A seguir, apresentamos a série reconstruída pelo modelo DMD.
Para filtrar os dados, precisamos "desativar" os modos que desejamos descartar. Isso pode ser feito zerando as colunas correspondentes aos modos excluídos e, em seguida, multiplicando a matriz resultante pela matriz de dinâmica.
//--- vector time_steps = np::arange(X1.Cols()+1,t[0],dt); matrixc dmd_dynamics = compute_dynamics(dmd_amplitudes,eigen_values,time_steps); matrixc masked_modes; //--- if(NumTop) { double min_amp = abs_dmd_amplitudes[amp_indices[NumTop]]; masked_modes = matrixc::Zeros(dmd_modes.Rows(),dmd_modes.Cols()); for(ulong i = 0; i<dmd_modes.Cols(); i++) { bool select = c_abs(dmd_amplitudes[i])>min_amp; if(select) masked_modes.Col(dmd_modes.Col(i),i); } } else masked_modes = dmd_modes; //--- matrixc reconstructed = reconstructed_data(dmd_dynamics,masked_modes); //--- matrix real_rec = real(reconstructed); //--- real_rec = time_delay_reconstruction(real_rec,Delay); //--
O gráfico abaixo apresenta uma reconstrução filtrada que utiliza apenas os modos dominantes.
A previsão é realizada estendendo os índices temporais discretos para além do intervalo coberto pelos dados de entrada durante o cálculo da dinâmica dos modos. O modelo DMD utiliza essa extensão para extrapolar a evolução dos modos e gerar previsões. A precisão dessas previsões depende da capacidade do modelo linear obtido pelo DMD de representar adequadamente a dinâmica do sistema.
//--- vector time_steps = np::arange((X1.Cols())+Num_future_points+1,first_time_point,dt); //--- matrixc dmd_dynamics = compute_dynamics(dmd_amplitudes,eigen_values,time_steps); //--- matrixc reconstruction = reconstructed_data(dmd_dynamics,dmd_modes); //--
A seguir, podemos observar o resultado de uma previsão de 10 passos à frente.
Vale destacar que nossa demonstração utiliza uma série com um sinal bem definido e sem ruído. Na próxima seção, veremos como as previsões do DMD se comportam quando aplicadas a dados com ruído.
Aplicação do DMD a dados de preços
O script DMD_Price_Decomposition.ex5 demonstra a aplicação do DMD a dados reais. Ele carrega uma amostra de cotações de preços e decompõe a série em componentes. Em seguida, o modelo DMD obtido é utilizado para gerar a quantidade de previsões definida pelo usuário. Por fim, a série prevista é apresentada graficamente junto às cotações reais para permitir a comparação dos resultados.
//+------------------------------------------------------------------+ //| DMD_Price_Decompostion.mq5 | //| Copyright 2025, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include<dmd_utils.mqh> //--- input parameters input string Symbol_="AUDUSD"; input ENUM_TIMEFRAMES TimeFrame=PERIOD_D1; input datetime StartDate=D'2025.06.02'; input ENUM_DMD_SCALE jobs = DMDSCALE_N; input ENUM_DMD_EIGV jobz = DMDEIGV_V; input ENUM_DMD_RESIDUALS jobr = DMDRESIDUALS_R; input ENUM_DMD_REFINE jobf = DMDREFINE_R; input ENUM_SVD_ALG whtsvd = SVDALG_1; input long nrnk = 20; input double tol_ = 1.e-9;//tol input ulong Delay = 50;//apply time delay embedding input ulong Num_Future_steps = 10; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- vector prices; if(!prices.CopyRates(Symbol_,TimeFrame,COPY_RATES_CLOSE,StartDate,100+Num_Future_steps)) { Print(" failed to get close prices for ", Symbol_,". Error ", GetLastError()); return; } //--- matrix X = matrix::Zeros(1,100); vector input_series = np::sliceVector(prices,0,100); X.Row(input_series,0); np::matrix2csv("AUDUSD.csv",X.Transpose()); //--- CDmd dmd; if(!dmd.fit(X,1,tol_,nrnk,Delay,jobs,whtsvd,jobz,jobr,jobf)) return; else Print(" It worked! "); vectorc egs = dmd.dmd_eigs(); Print("DMD eigenvalues or Ritz values\n",egs); matrix forecast = dmd.reconstructed_data(Num_Future_steps); vector time = np::arange(prices.Size(),0.0,dmd.dmd_time_delta()); plot_forecast(prices,forecast.Row(0),time,Num_Future_steps," Price forecast",0,0,0,0,500,400,true,30); }
O programa utiliza a classe CDmd, definida no arquivo dmd_utils.mqh. Essa classe combina as funcionalidades do método integrado DynamicModeDecomposition() com os recursos apresentados neste artigo. Sua interface inclui o método fit(), responsável por executar a decomposição. Para isso, é necessário fornecer um conjunto de parâmetros que configuram o procedimento DMD, incluindo a opção de aplicar a imersão por atraso temporal.
virtual bool fit(matrix &X,double time_delta, double tolerance, long svd_rank = -1,ulong embedding_dimension = 0,ENUM_DMD_SCALE scale = DMDSCALE_N,ENUM_SVD_ALG svd_method = SVDALG_1, ENUM_DMD_EIGV eigv = DMDEIGV_V,ENUM_DMD_RESIDUALS resid = DMDRESIDUALS_R,ENUM_DMD_REFINE refine = DMDREFINE_R) { reset(); matrix z,res_vectors,b,w,s; vector residuals; m_delay = embedding_dimension; matrix snapshots = m_delay>1?time_delay_embedding(X,m_delay):X; if(!snapshots.Cols()) return false; m_snapshots_x = np::sliceMatrixCols(snapshots,0,snapshots.Cols()-1); m_snapshots_y = np::sliceMatrixCols(snapshots,1); if(!m_snapshots_x.DynamicModeDecomposition(m_snapshots_y,scale,eigv,resid,refine,svd_method,svd_rank,tolerance,m_eigs,m_left_vectors,z,m_residuals,res_vectors,b,w,s)) { Print(__FUNCTION__, " DMD error ", GetLastError()); return false; } if(eigv != DMDEIGV_N) m_modes = compact_to_complex(z,m_eigs); m_eigenvectors = compact_to_complex(w,m_eigs); if(refine == DMDREFINE_E) { m_modes = compact_to_complex(b,m_eigs); m_exact_modes = true; } else if(refine == DMDREFINE_R) m_residual_vectors = compact_to_complex(res_vectors,m_eigs); m_og_first = m_dmd_first = 0.0; m_og_dt = m_dmd_dt = time_delta; m_og_timesteps = m_dmd_timesteps = np::arange(m_snapshots_x.Cols()+1,m_dmd_first,m_dmd_dt); m_og_last = m_dmd_last = m_dmd_timesteps.Size()-1; m_fitted = compute_amplitudes() ; return m_fitted; }
Após configurar o modelo, podemos consultar suas diferentes características por meio dos métodos de acesso apresentados a seguir.
matrixc dmd_modes(void) { return m_modes; } double dmd_time_delta(void) { return m_dmd_dt; } double dmd_first_time(void) { return m_dmd_first; } ulong dmd_last_time(void) { return m_dmd_last; } double og_first_time(void) { return m_og_first; } ulong og_last_time(void) { return m_og_last; } vector dmd_time_steps(void) { return m_dmd_timesteps; } vector og_time_steps(void) { return m_og_timesteps; } vectorc dmd_eigs(void) { return m_eigs; } vectorc dmd_amplitudes(void) { return m_amplitudes; } matrixc exact_dmd_modes(void) { if(m_exact_modes) return m_modes; else return matrixc::Zeros(0,0); } matrixc eigenvectors(void) { return m_eigenvectors; } vector growth_rate(void) { return real(m_eigs)/m_dmd_dt; } vector frequency(void) { vectorc f = c_log(m_eigs); return imaginary(f)/(2.0*M_PI*m_dmd_dt); } matrixc residual_vectors(void) { return m_residual_vectors; } vector residuals(void) { return m_residuals; }
As operações de reconstrução, previsão e filtragem são realizadas pelas versões sobrecarregadas do método reconstructed_data(). Ambas retornam estruturas de dados com valores reais no formato original dos dados de entrada. A versão de reconstructed_data() que possui um único parâmetro opcional é utilizada principalmente para gerar previsões e reconstruções sem filtragem. Quando esse parâmetro recebe um valor diferente de zero, o método retorna a reconstrução estendida pelo número solicitado de passos futuros. Caso contrário, retorna a reconstrução dos dados de entrada.
matrix reconstructed_data(ulong num_future_steps = 0) { if(num_future_steps) { m_dmd_last+=num_future_steps; m_dmd_timesteps = np::arange(m_dmd_last+1,m_dmd_first,m_dmd_dt); } matrixc d = dynamics(); matrixc data = np::matmul(m_modes,d); if(!num_future_steps) data = np::sliceMatrixCols(data,0,long(m_og_last+1)); matrix rdata = real(data); if(m_delay>1) rdata = time_delay_reconstruction(rdata,m_delay); return rdata; }
A segunda versão de reconstructed_data() recebe um parâmetro adicional do tipo vetor. Nesse caso, o usuário deve fornecer um vetor composto por zeros e uns, cujo tamanho corresponda à quantidade de modos. Cada zero indica que o modo correspondente deve ser descartado. Essa seleção não modifica os modos originais, mas permite gerar reconstruções ou previsões filtradas.
matrix reconstructed_data(vector& modes_mask, ulong num_future_steps = 0) { if(num_future_steps) { m_dmd_last+=num_future_steps; m_dmd_timesteps = np::arange(m_dmd_last+1,m_dmd_first,m_dmd_dt); } matrixc d = dynamics(); matrixc masked_modes = matrixc::Zeros(m_modes.Rows(),m_modes.Cols()); if(modes_mask.Size() == m_modes.Cols()) { for(ulong i = 0; i<masked_modes.Cols(); i++) if(modes_mask[i]) masked_modes.Col(m_modes.Col(i),i); } matrixc data = np::matmul(masked_modes,d); if(!num_future_steps) data = np::sliceMatrixCols(data,0,long(m_og_last+1)); matrix rdata = real(data); if(m_delay>1) rdata = time_delay_reconstruction(rdata,m_delay); return rdata; }
Ao executar o programa, obtemos os seguintes resultados.
Podemos observar que o DMD apresenta dificuldades para identificar a dinâmica subjacente, provavelmente devido ao ruído presente na série. As previsões para além de alguns passos à frente tornam-se pouco confiáveis. Esses resultados indicam que, neste exemplo, o DMD é mais adequado a previsões de curto prazo. À medida que ampliamos o horizonte de previsão, mesmo que apenas alguns passos, a qualidade das previsões se deteriora rapidamente.
Conclusão
Neste artigo, demonstramos como aplicar a decomposição em modos dinâmicos a séries temporais univariadas na linguagem MQL5, utilizando o novo método matricial DynamicModeDecomposition(). Examinamos os parâmetros de entrada desse método e as formas de interpretar e processar seus resultados para fins de análise. Também apresentamos os principais utilitários necessários para realizar operações com números complexos. O DMD pode ser uma adição valiosa aos recursos do MQL5, mas, para aproveitar plenamente seu potencial, é necessário ter conhecimentos sólidos tanto sobre o próprio método quanto sobre o conjunto de dados analisado. Todo o código mencionado neste artigo está listado e disponibilizado a seguir.| Nome do arquivo | Descrição |
|---|---|
| MQL5/include/np.mqh | Arquivo de cabeçalho que contém funções auxiliares para operações com vetores e matrizes. |
| MQL5/include/cmath.mqh | Arquivo de cabeçalho que contém funções auxiliares para operações com números complexos. |
| MQL5/include/dmd_utils.mqh | Arquivo de cabeçalho que contém a definição da classe CDmd e diversas funções auxiliares para a análise por DMD. |
| MQL5/scripts/DMD_Demo.mq5 | Script utilizado para gerar o gráfico dos autovalores. |
| MQL5/scripts/DMD_Mode_Dynamics.mq5 | Script que demonstra o cálculo e a representação gráfica da evolução temporal de um modo. |
| MQL5/scripts/DMD_Reconstruction.mq5 | Script que demonstra a reconstrução dos dados pelo modelo DMD e a utilização do DMD para filtragem. |
| MQL5/scripts/DMD_Forecast_Demo.m5 | Script que demonstra como gerar previsões utilizando um modelo DMD. |
| MQL5/scripts/DMD_Price_Decomposition.mq5 | Script que demonstra a utilização da classe CDmd e a aplicação do DMD a cotações reais de preços. |
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19188
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.