矩陣乘法

題目描述

請編程實現矩陣乘法，並考慮當矩陣規模較大時的優化方法。

思路分析

根據wikipedia上的介紹：兩個矩陣的乘法僅當第一個矩陣B的列數和另一個矩陣A的行數相等時才能定義。如A是m×n矩陣和B是n×p矩陣，它們的乘積AB是一個m×p矩陣，它的一個元素其中 1 ≤ i ≤ m, 1 ≤ j ≤ p。

值得一提的是，矩陣乘法滿足結合律和分配率，但並不滿足交換律，如下圖所示的這個例子，兩個矩陣交換相乘後，結果變了：

下面咱們來具體解決這個矩陣相乘的問題。

解法一、暴力解法

其實，通過前面的分析，我們已經很明顯的看出，兩個具有相同維數的矩陣相乘，其複雜度爲O（n^3），參考代碼如下：

//矩陣乘法，3個for循環搞定   

void Mul(int**
matrixA, int** matrixB, int**
matrixC)   

{   

    for(int i
= 0; i < 2; ++i)    

    {   

        for(int j
= 0; j < 2; ++j)    

        {   

            matrixC[i][j] = 0;   

            for(int k
= 0; k < 2; ++k)    

            {   

                matrixC[i][j] += matrixA[i][k] * matrixB[k][j];   

            }   

        }   

    }   

}

解法二、Strassen算法

在解法一中，我們用了3個for循環搞定矩陣乘法，但當兩個矩陣的維度變得很大時，O（n^3）的時間複雜度將會變得很大，於是，我們需要找到一種更優的解法。

一般說來，當數據量一大時，我們往往會把大的數據分割成小的數據，各個分別處理。遵此思路，如果丟給我們一個很大的兩個矩陣呢，是否可以考慮分治的方法循序漸進處理各個小矩陣的相乘，因爲我們知道一個矩陣是可以分成更多小的矩陣的。

如下圖，當給定一個兩個二維矩陣A B時：

這兩個矩陣A B相乘時，我們發現在相乘的過程中，有8次乘法運算，4次加法運算：

矩陣乘法的複雜度主要就是體現在相乘上，而多一兩次的加法並不會讓複雜度上升太多。故此，我們思考，是否可以讓矩陣乘法的運算過程中乘法的運算次數減少，從而達到降低矩陣乘法的複雜度呢？答案是肯定的。

1969年，德國的一位數學家Strassen證明O（N^3）的解法並不是矩陣乘法的最優算法，他做了一系列工作使得最終的時間複雜度降低到了O(n^2.80)。

他是怎麼做到的呢？還是用上文A B兩個矩陣相乘的例子，他定義了7個變量：

如此，Strassen算法的流程如下：

兩個矩陣A B相乘時，將A, B, C分成相等大小的方塊矩陣：

；

可以看出C是這麼得來的：

現在定義7個新矩陣（讀者可以思考下，這7個新矩陣是如何想到的）：

而最後的結果矩陣C 可以通過組合上述7個新矩陣得到：

表面上看，Strassen算法僅僅比通用矩陣相乘算法好一點，因爲通用矩陣相乘算法時間複雜度是，而Strassen算法複雜度只是。但隨着n的變大，比如當n >> 100時，Strassen算法是比通用矩陣相乘算法變得更有效率。

具體實現的僞代碼如下：

Strassen (N,MatrixA,MatrixB,MatrixResult)
          
    //splitting input Matrixes, into 4 submatrices each.
            for i  <-  0  to  N/2
                for j  <-  0  to  N/2
                    A11[i][j]  <-  MatrixA[i][j];                   //a矩陣塊
                    A12[i][j]  <-  MatrixA[i][j + N / 2];           //b矩陣塊
                    A21[i][j]  <-  MatrixA[i + N / 2][j];           //c矩陣塊
                    A22[i][j]  <-  MatrixA[i + N / 2][j + N / 2];//d矩陣塊
                                
                    B11[i][j]  <-  MatrixB[i][j];                    //e 矩陣塊
                    B12[i][j]  <-  MatrixB[i][j + N / 2];            //f 矩陣塊
                    B21[i][j]  <-  MatrixB[i + N / 2][j];            //g 矩陣塊
                    B22[i][j]  <-  MatrixB[i + N / 2][j + N / 2];    //h矩陣塊
            //here we calculate M1..M7 matrices .                                                                                                                       
            //遞歸求M1
            HalfSize  <-  N/2    
            AResult  <-  A11+A22
            BResult  <-  B11+B22                                                                     
            Strassen( HalfSize, AResult, BResult, M1 );   //M1=(A11+A22)*(B11+B22)          p5=(a+d)*(e+h)    
            //遞歸求M2
            AResult  <-  A21+A22    
            Strassen(HalfSize, AResult, B11, M2);          //M2=(A21+A22)B11                 p3=(c+d)*e
            //遞歸求M3
            BResult  <-  B12 - B22   
            Strassen(HalfSize, A11, BResult, M3);         //M3=A11(B12-B22)                  p1=a*(f-h)
            //遞歸求M4
            BResult  <-  B21 - B11  
            Strassen(HalfSize, A22, BResult, M4);         //M4=A22(B21-B11)                  p4=d*(g-e)
            //遞歸求M5
            AResult  <-  A11+A12    
            Strassen(HalfSize, AResult, B22, M5);         //M5=(A11+A12)B22                  p2=(a+b)*h
            //遞歸求M6
            AResult  <-  A21-A11
            BResult  <-  B11+B12      
            Strassen( HalfSize, AResult, BResult, M6);     //M6=(A21-A11)(B11+B12)          p7=(c-a)(e+f)
            //遞歸求M7
            AResult  <-  A12-A22
            BResult  <-  B21+B22      
            Strassen(HalfSize, AResult, BResult, M7);      //M7=(A12-A22)(B21+B22)          p6=(b-d)*(g+h)

            //計算結果子矩陣
            C11  <-  M1 + M4 - M5 + M7;

            C12  <-  M3 + M5;

            C21  <-  M2 + M4;

            C22  <-  M1 + M3 - M2 + M6;
            //at this point , we have calculated the c11..c22 matrices, and now we are going to
            //put them together and make a unit matrix which would describe our resulting Matrix.
            for i  <-  0  to  N/2
                for j  <-  0  to  N/2
                    MatrixResult[i][j]                  <-  C11[i][j];
                    MatrixResult[i][j + N / 2]          <-  C12[i][j];
                    MatrixResult[i + N / 2][j]          <-  C21[i][j];
                    MatrixResult[i + N / 2][j + N / 2]  <-  C22[i][j];

具體測試代碼如下：

// 4-2.矩陣乘法的Strassen算法.cpp : 定義控制檯應用程序的入口點。
//

#include "stdafx.h"
#include <iostream>
#include <ctime>
#include <Windows.h>
using namespace std;

template<typename T>
class Strassen_class{
public:
      void ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );//樸素算法實現
      void FillMatrix( T** MatrixA, T** MatrixB, int length);//A,B矩陣賦值
      void PrintMatrix(T **MatrixA,int MatrixSize);//打印矩陣
      void Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC);//Strassen算法實現
};
template<typename T>
void Strassen_class<T>::ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] + MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] - MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for (int i=0;i<MatrixSize ;i++)
    {
        for (int j=0;j<MatrixSize ;j++)
        {
            MatrixResult[i][j]=0;
            for (int k=0;k<MatrixSize ;k++)
            {
                MatrixResult[i][j]=MatrixResult[i][j]+MatrixA[i][k]*MatrixB[k][j];
            }
        }
    }
}

/*
c++使用二維數組，申請動態內存方法
申請
int **A;
A = new int *[desired_array_row];
for ( int i = 0; i < desired_array_row; i++)
     A[i] = new int [desired_column_size];

釋放
for ( int i = 0; i < your_array_row; i++)
    delete [] A[i];
delete[] A;

*/
template<typename T>
void Strassen_class<T>::Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC)
{

    int HalfSize = N/2;
    int newSize = N/2;

    if ( N <= 64 )    //分治門檻，小於這個值時不再進行遞歸計算，而是採用常規矩陣計算方法
    {
        MUL(MatrixA,MatrixB,MatrixC,N);
    }
    else
    {
        T** A11;
        T** A12;
        T** A21;
        T** A22;
        
        T** B11;
        T** B12;
        T** B21;
        T** B22;
        
        T** C11;
        T** C12;
        T** C21;
        T** C22;
        
        T** M1;
        T** M2;
        T** M3;
        T** M4;
        T** M5;
        T** M6;
        T** M7;
        T** AResult;
        T** BResult;

        //making a 1 diminsional pointer based array.
        A11 = new T *[newSize];
        A12 = new T *[newSize];
        A21 = new T *[newSize];
        A22 = new T *[newSize];
        
        B11 = new T *[newSize];
        B12 = new T *[newSize];
        B21 = new T *[newSize];
        B22 = new T *[newSize];
        
        C11 = new T *[newSize];
        C12 = new T *[newSize];
        C21 = new T *[newSize];
        C22 = new T *[newSize];
        
        M1 = new T *[newSize];
        M2 = new T *[newSize];
        M3 = new T *[newSize];
        M4 = new T *[newSize];
        M5 = new T *[newSize];
        M6 = new T *[newSize];
        M7 = new T *[newSize];

        AResult = new T *[newSize];
        BResult = new T *[newSize];

        int newLength = newSize;

        //making that 1 diminsional pointer based array , a 2D pointer based array
        for ( int i = 0; i < newSize; i++)
        {
            A11[i] = new T[newLength];
            A12[i] = new T[newLength];
            A21[i] = new T[newLength];
            A22[i] = new T[newLength];
            
            B11[i] = new T[newLength];
            B12[i] = new T[newLength];
            B21[i] = new T[newLength];
            B22[i] = new T[newLength];
            
            C11[i] = new T[newLength];
            C12[i] = new T[newLength];
            C21[i] = new T[newLength];
            C22[i] = new T[newLength];

            M1[i] = new T[newLength];
            M2[i] = new T[newLength];
            M3[i] = new T[newLength];
            M4[i] = new T[newLength];
            M5[i] = new T[newLength];
            M6[i] = new T[newLength];
            M7[i] = new T[newLength];

            AResult[i] = new T[newLength];
            BResult[i] = new T[newLength];


        }
        //splitting input Matrixes, into 4 submatrices each.
        for (int i = 0; i < N / 2; i++)
        {
            for (int j = 0; j < N / 2; j++)
            {
                A11[i][j] = MatrixA[i][j];
                A12[i][j] = MatrixA[i][j + N / 2];
                A21[i][j] = MatrixA[i + N / 2][j];
                A22[i][j] = MatrixA[i + N / 2][j + N / 2];

                B11[i][j] = MatrixB[i][j];
                B12[i][j] = MatrixB[i][j + N / 2];
                B21[i][j] = MatrixB[i + N / 2][j];
                B22[i][j] = MatrixB[i + N / 2][j + N / 2];

            }
        }

        //here we calculate M1..M7 matrices .
        //M1[][]
        ADD( A11,A22,AResult, HalfSize);
        ADD( B11,B22,BResult, HalfSize);                //p5=(a+d)*(e+h)
        Strassen( HalfSize, AResult, BResult, M1 ); //now that we need to multiply this , we use the strassen itself .


        //M2[][]
        ADD( A21,A22,AResult, HalfSize);              //M2=(A21+A22)B11   p3=(c+d)*e
        Strassen(HalfSize, AResult, B11, M2);       //Mul(AResult,B11,M2);

        //M3[][]
        SUB( B12,B22,BResult, HalfSize);              //M3=A11(B12-B22)   p1=a*(f-h)
        Strassen(HalfSize, A11, BResult, M3);       //Mul(A11,BResult,M3);

        //M4[][]
        SUB( B21, B11, BResult, HalfSize);           //M4=A22(B21-B11)    p4=d*(g-e)
        Strassen(HalfSize, A22, BResult, M4);       //Mul(A22,BResult,M4);

        //M5[][]
        ADD( A11, A12, AResult, HalfSize);           //M5=(A11+A12)B22   p2=(a+b)*h
        Strassen(HalfSize, AResult, B22, M5);       //Mul(AResult,B22,M5);


        //M6[][]
        SUB( A21, A11, AResult, HalfSize);
        ADD( B11, B12, BResult, HalfSize);             //M6=(A21-A11)(B11+B12)   p7=(c-a)(e+f)
        Strassen( HalfSize, AResult, BResult, M6);    //Mul(AResult,BResult,M6);

        //M7[][]
        SUB(A12, A22, AResult, HalfSize);
        ADD(B21, B22, BResult, HalfSize);             //M7=(A12-A22)(B21+B22)    p6=(b-d)*(g+h)
        Strassen(HalfSize, AResult, BResult, M7);     //Mul(AResult,BResult,M7);

        //C11 = M1 + M4 - M5 + M7;
        ADD( M1, M4, AResult, HalfSize);
        SUB( M7, M5, BResult, HalfSize);
        ADD( AResult, BResult, C11, HalfSize);

        //C12 = M3 + M5;
        ADD( M3, M5, C12, HalfSize);

        //C21 = M2 + M4;
        ADD( M2, M4, C21, HalfSize);

        //C22 = M1 + M3 - M2 + M6;
        ADD( M1, M3, AResult, HalfSize);
        SUB( M6, M2, BResult, HalfSize);
        ADD( AResult, BResult, C22, HalfSize);

        //at this point , we have calculated the c11..c22 matrices, and now we are going to
        //put them together and make a unit matrix which would describe our resulting Matrix.
        //組合小矩陣到一個大矩陣
        for (int i = 0; i < N/2 ; i++)
        {
            for (int j = 0 ; j < N/2 ; j++)
            {
                MatrixC[i][j] = C11[i][j];
                MatrixC[i][j + N / 2] = C12[i][j];
                MatrixC[i + N / 2][j] = C21[i][j];
                MatrixC[i + N / 2][j + N / 2] = C22[i][j];
            }
        }

        // 釋放矩陣內存空間
        for (int i = 0; i < newLength; i++)
        {
            delete[] A11[i];delete[] A12[i];delete[] A21[i];
            delete[] A22[i];

            delete[] B11[i];delete[] B12[i];delete[] B21[i];
            delete[] B22[i];
            delete[] C11[i];delete[] C12[i];delete[] C21[i];
            delete[] C22[i];
            delete[] M1[i];delete[] M2[i];delete[] M3[i];delete[] M4[i];
            delete[] M5[i];delete[] M6[i];delete[] M7[i];
            delete[] AResult[i];delete[] BResult[i] ;
        }
        delete[] A11;delete[] A12;delete[] A21;delete[] A22;
        delete[] B11;delete[] B12;delete[] B21;delete[] B22;
        delete[] C11;delete[] C12;delete[] C21;delete[] C22;
        delete[] M1;delete[] M2;delete[] M3;delete[] M4;delete[] M5;
        delete[] M6;delete[] M7;
        delete[] AResult;
        delete[] BResult ;

    }//end of else

}

template<typename T>
void Strassen_class<T>::FillMatrix( T** MatrixA, T** MatrixB, int length)
{
    for(int row = 0; row<length; row++)
    {
        for(int column = 0; column<length; column++)
        {

            MatrixB[row][column] = (MatrixA[row][column] = rand() %5);
            //matrix2[row][column] = rand() % 2;//ba hazfe in khat 50% afzayeshe soorat khahim dasht
        }

    }
}
template<typename T>
void Strassen_class<T>::PrintMatrix(T **MatrixA,int MatrixSize)
{
    cout<<endl;
    for(int row = 0; row<MatrixSize; row++)
    {
        for(int column = 0; column<MatrixSize; column++)
        {


            cout<<MatrixA[row][column]<<"\t";
            if ((column+1)%((MatrixSize)) == 0)
                cout<<endl;
        }

    }
    cout<<endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	Strassen_class<int> stra;//定義Strassen_class類對象
    int MatrixSize = 0;

    int** MatrixA;    //存放矩陣A
    int** MatrixB;    //存放矩陣B
    int** MatrixC;    //存放結果矩陣

    clock_t startTime_For_Normal_Multipilication ;
    clock_t endTime_For_Normal_Multipilication ;

    clock_t startTime_For_Strassen ;
    clock_t endTime_For_Strassen ;
    srand(time(0));

    cout<<"\n請輸入矩陣大小(必須是2的冪指數值(例如:32,64,512,..): ";
    cin>>MatrixSize;

    int N = MatrixSize;//for readiblity.

    //申請內存
    MatrixA = new int *[MatrixSize];
    MatrixB = new int *[MatrixSize];
    MatrixC = new int *[MatrixSize];

    for (int i = 0; i < MatrixSize; i++)
    {
        MatrixA[i] = new int [MatrixSize];
        MatrixB[i] = new int [MatrixSize];
        MatrixC[i] = new int [MatrixSize];
    }

    stra.FillMatrix(MatrixA,MatrixB,MatrixSize);  //矩陣賦值

  //*******************conventional multiplication test
        cout<<"樸素矩陣算法開始時鐘:  "<< (startTime_For_Normal_Multipilication = clock());

        stra.MUL(MatrixA,MatrixB,MatrixC,MatrixSize);//樸素矩陣相乘算法 T(n) = O(n^3)

        cout<<"\n樸素矩陣算法結束時鐘: "<< (endTime_For_Normal_Multipilication = clock());

        cout<<"\n矩陣運算結果... \n";
        stra.PrintMatrix(MatrixC,MatrixSize);

  //*******************Strassen multiplication test
        cout<<"\nStrassen算法開始時鐘: "<< (startTime_For_Strassen = clock());

        stra.Strassen( N, MatrixA, MatrixB, MatrixC ); //strassen矩陣相乘算法

        cout<<"\nStrassen算法結束時鐘: "<<(endTime_For_Strassen = clock());


    cout<<"\n矩陣運算結果... \n";
    stra.PrintMatrix(MatrixC,MatrixSize);

    cout<<"矩陣大小 "<<MatrixSize;
    cout<<"\n樸素矩陣算法: "<<(endTime_For_Normal_Multipilication - startTime_For_Normal_Multipilication)<<" Clocks.."<<(endTime_For_Normal_Multipilication - startTime_For_Normal_Multipilication)/CLOCKS_PER_SEC<<" Sec";
    cout<<"\nStrassen算法:"<<(endTime_For_Strassen - startTime_For_Strassen)<<" Clocks.."<<(endTime_For_Strassen - startTime_For_Strassen)/CLOCKS_PER_SEC<<" Sec\n";
    system("Pause");

	return 0;
}

運行結果：

性能分析：

數據取600位上界，即超過10分鐘跳出。可以看到使用Strassen算法時，耗時不但沒有減少，反而劇烈增多，在n=700時計算時間就無法忍受。仔細研究後發現，採用Strassen算法作遞歸運算，需要創建大量的動態二維數組，其中分配堆內存空間將佔用大量計算時間，從而掩蓋了Strassen算法的優勢。於是對Strassen算法做出改進，設定一個界限。當n<界限時，使用普通法計算矩陣，而不繼續分治遞歸。

改進後算法優勢明顯，就算時間大幅下降。之後，針對不同大小的界限進行試驗。在初步試驗中發現，當數據規模小於1000時，下界S法的差別不大，規模大於1000以後，n取值越大，消耗時間下降。最優的界限值在32～128之間。

因爲計算機每次運算時的系統環境不同（CPU佔用、內存佔用等），所以計算出的時間會有一定浮動。雖然這樣，試驗結果已經能得出結論Strassen算法比常規法優勢明顯。使用下界法改進後，在分治效率和動態分配內存間取捨，針對不同的數據規模稍加試驗可以得到一個最優的界限。

小結：

1）採用Strassen算法作遞歸運算，需要創建大量的動態二維數組，其中分配堆內存空間將佔用大量計算時間，從而掩蓋了Strassen算法的優勢

2）於是對Strassen算法做出改進，設定一個界限。當n<界限時，使用普通法計算矩陣，而不繼續分治遞歸。需要合理設置界限，不同環境（硬件配置）下界限不同

3）矩陣乘法一般意義上還是選擇的是樸素的方法，只有當矩陣變稠密，而且矩陣的階數很大時，纔會考慮使用Strassen算法。

題目描述

思路分析

解法一、暴力解法

解法二、Strassen算法

job.waitForCompletion(true)空指針問題

數學之美番外篇：平凡而又神奇的貝葉斯方法

mapreduce在控制檯打印log4j日誌

hdfs下載文件到本地

java.io.IOException: Stream closed

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結