Guía de algotradingSecciones
Programación en MQL5 para tradersAPI comunesMatrices y vectoresTransformaciones (descomposición) de matrices 
Download in one file:
MQL5 Algo Book in PDF
MQL5 Algo Book in CHM

Transformaciones (descomposición) de matrices

Las transformaciones matriciales son las operaciones más utilizadas cuando se trabaja con datos. No obstante, muchas transformaciones complejas no pueden realizarse analíticamente y con absoluta precisión.

Las transformaciones matriciales (o, dicho de otro modo, las descomposiciones) son métodos que descomponen una matriz en sus partes componentes, lo que facilita el cálculo de operaciones matriciales más complejas. Los métodos de descomposición de matrices, también llamados métodos de factorización de matrices, son la base de los algoritmos de álgebra lineal, como la resolución de sistemas de ecuaciones lineales y el cálculo de la inversa de una matriz o determinante.

En concreto, la descomposición en valores singulares (SVD, por sus siglas en inglés) es muy utilizada en el aprendizaje automático, ya que permite representar la matriz original como producto de otras tres matrices. La descomposición SVD se utiliza para resolver diversos problemas, desde la aproximación por mínimos cuadrados hasta la compresión y el reconocimiento de imágenes.

Lista de métodos disponibles:

  • Cholesky: calcular la descomposición de Cholesky
  • Eig: calcular los valores propios y los vectores propios derechos de una matriz cuadrada
  • Eig Vals: calcular los valores propios de la matriz común
  • LU: implementar la factorización LU de una matriz como producto de una matriz triangular inferior y una matriz triangular superior
  • LUP: implementar la factorización LUP con rotación parcial, que es una factorización LU sólo con permutaciones de filas, PA=LU
  • QR: aplicar la factorización QR de la matriz
  • SVD: descomposición en valores singulares

A continuación se presentan los prototipos de métodos.

bool matrix<T>::Cholesky(matrix<T> &L)

bool matrix<T>::Eig(matrix<T> &eigen_vectors, vector<T> &eigen_values)

bool matrix<T>::EigVals(vector<T> &eigen_values)

bool matrix<T>::LU(matrix<T> &L, matrix<T> &U)

bool matrix<T>::LUP(matrix<T> &L, matrix<T> &U, matrix<T> &P)

bool matrix<T>::QR(matrix<T> &Q, matrix<T> &R)

bool matrix<T>::SVD(matrix<T> &U, matrix<T> &V, vector<T> &singular_values)

Veamos un ejemplo de descomposición de valores singulares con el método SVD (véase. archivo MatrixSVD.mq5). En primer lugar, inicializamos la matriz original.

matrix a = {{0, 1, 2, 3, 4, 5, 6, 7, 8}};
a = a - 4;
a.Reshape(3, 3);
Print("matrix a \n", a);

Seguidamente hacemos una descomposición SVD:

matrix U, V;
vector singular_values;
a.SVD(U, V, singular_values);
Print("U \n", U);
Print("V \n", V);
Print("singular_values = ", singular_values);

Comprobemos la expansión, que debe cumplir la siguiente igualdad: U * "singular diagonal" * V = A.

matrix matrix_s;
matrix_s.Diag(singular_values);
Print("matrix_s \n", matrix_s);
matrix matrix_vt = V.Transpose();
Print("matrix_vt \n", matrix_vt);
matrix matrix_usvt = (U.MatMul(matrix_s)).MatMul(matrix_vt);
Print("matrix_usvt \n", matrix_usvt);

Vamos a comprobar la matriz resultante y la original en busca de errores.

ulong errors = (int)a.Compare(matrix_usvt, 1e-9);
Print("errors=", errors);

El registro debería tener este aspecto:

matrix a
[[-4,-3,-2]
 [-1,0,1]
 [2,3,4]]
U
[[-0.7071067811865474,0.5773502691896254,0.408248290463863]
 [-6.827109697437648e-17,0.5773502691896253,-0.8164965809277256]
 [0.7071067811865472,0.5773502691896255,0.4082482904638627]]
V
[[0.5773502691896258,-0.7071067811865474,-0.408248290463863]
 [0.5773502691896258,1.779939029415334e-16,0.8164965809277258]
 [0.5773502691896256,0.7071067811865474,-0.408248290463863]]
singular_values = [7.348469228349533,2.449489742783175,3.277709923350408e-17]
  
matrix_s
[[7.348469228349533,0,0]
 [0,2.449489742783175,0]
 [0,0,3.277709923350408e-17]]
matrix_vt
[[0.5773502691896258,0.5773502691896258,0.5773502691896256]
 [-0.7071067811865474,1.779939029415334e-16,0.7071067811865474]
 [-0.408248290463863,0.8164965809277258,-0.408248290463863]]
matrix_usvt
[[-3.999999999999997,-2.999999999999999,-2]
 [-0.9999999999999981,-5.977974170712231e-17,0.9999999999999974]
 [2,2.999999999999999,3.999999999999996]]
errors=0

Otro caso práctico de aplicación del método Convolve se incluye en el ejemplo de Métodos de aprendizaje automático.