MQL5 ReferansıMatris ve Vektör MetotlarıÇarpımlarGeMM

GeMM

Genel matris çarpımı (General Matrix Multiply, GeMM) yöntemi, iki matrisin genel çarpımını uygular. İşlem C ← α A B + β C olarak tanımlanır, burada A ve B matrisleri isteğe bağlı olarak devrik olabilir. AB matrislerinin (MatMul) normal çarpımı ile alpha skalerin 1'e eşit olduğu, beta'nın da sıfıra eşit olduğu varsayılır.

Verimlilik açısından GeMM ve MatMul arasındaki temel fark, MatMul'un her zaman yeni bir matris/vektör nesnesi oluşturması, GeMM'in ise mevcut matris nesnesi üzerinde çalışması, onu yeniden oluşturmamasıdır. Bu nedenle, GeMM'i kullandığınızda ve ilgili matris için belleği önceden tahsis ettiğinizde, devamında aynı matris büyüklüğüyle çalışırken bellek yeniden tahsisi olmayacaktır. Bu, örneğin strateji sınayıcıda optimizasyon veya sinir ağı eğitimi gerçekleştirilmesi gibi toplu hesaplamalarda GeMM'in önemli bir avantajı olabilir.

MatMul'a benzer şekilde, GeMM de 4 aşırı yüke sahiptir. Ancak, dikey vektörün yatay vektörle çarpılmasının sağlanması amacıyla dördüncü aşırı yükün anlamı değiştirilmiştir.

Mevcut bir matris/vektör nesnesinde, belleği önceden tahsis etmek gerekli değildir. Bellek, ilk GeMM çağrısında tahsis edilecek ve 0'larla doldurulacaktır.

Bir matrisi bir matrisle çarpma: matrix C[M][N] = α * ( matrix A[M][K] * matrix B[K][N]) + β * matrix C[M][N]

bool  matrix::GeMM(
  const matrix &A,    // birinci matris
  const matrix &B,    // ikinci matris
  double alpha,       // AB çarpımı için alpha çarpanı
  double beta,        // C matrisi için beta çarpanı
  uint   flags        // A, B ve C matrislerinin devrik olup olmadığını tanımlayan ENUM_GEMM numaralandırması değerlerinin kombinasyonu (bit cinsinde "veya")
   );

Bir vektörü bir matrisle çarpma: vector C[N] = α * ( vector A[K] * matrix B[K][N]) + β * vector C[N]

bool  vector::GeMM(
  const vector &A,    // yatay vektör
  const matrix &B,    // matris
  double alpha,       // AB çarpımı için alpha çarpanı
  double beta,        // C vektörü için beta çarpanı
  uint   flags        // A matrisinin devrik olup olmadığını tanımlayan ENUM_GEMM numaralandırması değeri
   );

Bir matrisi bir vektörle çarpma: vector C[M] = α * ( matrix A[M][K] * vector B[K] * ) + β * vector C[M]

bool  vector::GeMM(
  const matrix &A,    // matris
  const vector &B,    // dikey vektör
  double alpha,       // AB çarpımı için alpha çarpanı
  double beta,        // C vektörü için beta çarpanı
  uint   flags        // B matrisinin devrik olup olmadığını tanımlayan ENUM_GEMM numaralandırması değeri
   );

Bir vektörü bir vektörle çarpma: matrix C[M][N] = α * ( vector A[M] * vector B[N] * ) + β * matrix C[M][N]. Bu aşırı yük, bir skalerin geri döndürüldüğü MatMul'un aksine, bir matris geri döndürür.

bool  matrix::GeMM(
  const vector &A,    // birinci vektör
  const vector &B,    // ikinci vektör
  double alpha,       // AB çarpımı için alpha çarpanı
  double beta,        // C matrisi için beta çarpanı
  uint   flags        // C matrisinin devrik olup olmadığını tanımlayan ENUM_GEMM numaralandırması değeri
   );

Parametreler

[in] Matris veya vektör.

alpha

[in] AB çarpımı için alpha çarpanı.

beta

[in] Ortaya çıkan C matrisi için beta çarpanı.

flags

[in] A, B ve C matrislerinin devrik olup olmadığını tanımlayan ENUM_GEMM numaralandırması değeri.

Geri dönüş değeri

Başarılı olursa true, aksi takdirde false geri döndürür.

ENUM_GEMM

GeMM metodu için bayrakların numaralandırması.

Kimlik	Açıklama
TRANSP_A	Devrik A matrisini kullan
TRANSP_B	Devrik B matrisini kullan
TRANSP_C	Devrik C matrisini kullan

Not

float, double ve complex türdeki matrisler ve vektörler, A ve B parametreleri olarak kullanılabilir. GeMM metodunun şablon varyantları aşağıdaki gibidir:

bool matrix<T>::GeMM(const matrix<T> &A,const matrix<T> &B,T alpha,T beta,ulong flags);
bool matrix<T>::GeMM(const vector<T> &A,const vector<T> &B,T alpha,T beta,ulong flags);

bool vector<T>::GeMM(const vector<T> &A,const matrix<T> &B,T alpha,T beta,ulong flags);
bool vector<T>::GeMM(const matrix<T> &A,const vector<T> &B,T alpha,T beta,ulong flags);

Temel olarak genel matris çarpımı fonksiyonu şu şekilde tanımlanır:

C[m,n] = α *Sum(A[m,k]*B[k,n]) + β*C[m,n]

Burada A matrisi M x K, B matrisi K x N ve C matrisi de M x N büyüklüğündedir.

Bu nedenle, matrisler çarpma işlemi için uyumlu olmalıdır, yani birinci matristeki sütun sayısı, ikinci matristeki satır sayısına eşit olmalıdır. Matris çarpımı değişmeli değildir: genel olarak, birinci matrisin ikinci matrisle çarpımının sonucu, ikinci matrisin birinci matrisle çarpımının sonucuna eşit değildir.

Örnek:

void OnStart()
  {
   vector vector_a= {1, 2, 3, 4, 5};
   vector vector_b= {4, 3, 2, 1};
   matrix matrix_c;
//--- iki vektör için GeMM hesapla
   matrix_c.GeMM(vector_a, vector_b, 1, 0);
   Print("matrix_c:\n ", matrix_c, "\n");
   /*
   matrix_c:
    [[4,3,2,1]
    [8,6,4,2]
    [12,9,6,3]
    [16,12,8,4]
    [20,15,10,5]]
   */
//--- vektör biçiminde matrisler oluştur
   matrix matrix_a(5, 1);
   matrix matrix_b(1, 4);
   matrix_a.Col(vector_a, 0);
   matrix_b.Row(vector_b, 0);
   Print("matrix_a:\n ", matrix_a);
   Print("matrix_b:\n ", matrix_b);
   /*
   matrix_a:
   [[1]
   [2]
   [3]
   [4]
   [5]]
   matrix_b:
   [[4,3,2,1]]
   */
//-- iki matris için GeMM hesapla ve aynı sonucu al
   matrix_c.GeMM(matrix_a, matrix_b, 1, 0);
   Print("matrix_c:\n ", matrix_c);
   /*
   matrix_c:
    [[4,3,2,1]
    [8,6,4,2]
    [12,9,6,3]
    [16,12,8,4]
    [20,15,10,5]]
   */
  }

Ayrıca bakınız

MatMul

Power