DL4J實戰之五：矩陣操作基本功

程式設計師欣宸發表於2021-10-20
矩陣

歡迎訪問我的GitHub

https://github.com/zq2599/blog_demos

內容：所有原創文章分類彙總及配套原始碼，涉及Java、Docker、Kubernetes、DevOPS等；

本篇概覽

  • 作為《DL4J實戰》系列的第五篇，在前面對深度學習有一定的瞭解後，本篇會暫停深度學習相關的操作，轉為基本功練習：矩陣操作，即INDArray介面的基本用法
  • INDArray的類圖如下，由於BaseNDArray是個抽象類，因此在實際使用中，我們們用的都是NDArray的例項：

在這裡插入圖片描述

  • 之所以用一篇文章來學習矩陣操作，是因為後面的實戰過程中處處都有它，處處離不開它，若不熟練就會寸步難行；
  • 本篇涉及的API較多，因此先做好歸類，後面的程式碼按照分類來寫會清晰一些，一共分為五類：矩陣屬性、建立操作、讀操作、寫操作、矩陣計算，接下來用思維導圖列出每一類的常用API
  • 矩陣屬性：

在這裡插入圖片描述

  • 建立操作：

在這裡插入圖片描述

  • 讀操作：

在這裡插入圖片描述

  • 寫操作：

在這裡插入圖片描述

  • 矩陣計算：

在這裡插入圖片描述

原始碼下載

名稱連結備註
專案主頁https://github.com/zq2599/blo...該專案在GitHub上的主頁
git倉庫地址(https)https://github.com/zq2599/blo...該專案原始碼的倉庫地址，https協議
git倉庫地址(ssh)git@github.com:zq2599/blog_demos.git該專案原始碼的倉庫地址，ssh協議
  • 這個git專案中有多個資料夾，《DL4J實戰》系列的原始碼在<font color="blue">dl4j-tutorials</font>資料夾下，如下圖紅框所示：

在這裡插入圖片描述

  • <font color="blue">dl4j-tutorials</font>資料夾下有多個子工程，本次實戰程式碼在<font color="blue">ndarray-experience</font>目錄下，如下圖紅框：

在這裡插入圖片描述

建立工程

  • 在父工程<font color="blue">dl4j-tutorials</font>下新建名為<font color="blue">ndarray-experience</font>的子工程，其pom.xml如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>dlfj-tutorials</artifactId>
        <groupId>com.bolingcavalry</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ndarray-experience</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.nd4j</groupId>
            <!--注意要用nd4j-native-platform，否則容器啟動時報錯：no jnind4jcpu in java.library.path-->
            <artifactId>${nd4j.backend}</artifactId>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
        </dependency>
    </dependencies>

</project>
  • 接下來的程式碼都寫在<font color="blue">ndarray-experience</font>工程中

最基本的方法

  • 先列出兩個最基本的方法，後面學習時會頻繁用到它們：
  • rand：秩，維數，例如2行3列的二維矩陣，rand方法返回值等於2
  • shape：矩陣每個維度的大小，如2行3列的二維矩陣，shape方法返回值等於<font color="blue">[2, 3]</font>
  • 準備一個靜態方法，可以將INDArray例項的詳情列印出來，用的就是rand和shape方法：
    private static void disp(String type, INDArray indArray) {
        StringBuilder stringBuilder = new StringBuilder("*****************************************************\n");
        stringBuilder.append(type)
                     .append("\n維度 : ").append(indArray.rank())
                     .append("\n形狀 : ").append(Arrays.toString(indArray.shape()))
                     .append("\n完整矩陣 : \n").append(indArray);

        System.out.println(stringBuilder);
    }

建立矩陣

  1. 全零矩陣：zeros
// 建立2行3列的全零矩陣
INDArray indArray0 = Nd4j.zeros(2, 3);
disp("全零矩陣", indArray0);
  • 執行結果
全零矩陣
維度 : 2
形狀 : [2, 3]
完整矩陣 : 
[[         0,         0,         0], 
 [         0,         0,         0]]
  1. 全1矩陣：ones
// 建立2行3列的全一矩陣
INDArray indArray1 = Nd4j.ones(2, 3);
disp("全一矩陣", indArray1);
  • 執行結果
全一矩陣
維度 : 2
形狀 : [2, 3]
完整矩陣 : 
[[    1.0000,    1.0000,    1.0000], 
 [    1.0000,    1.0000,    1.0000]]
  1. 全是指定值的矩陣：valueArrayOf
// 建立2行3列的全是指定值的矩陣
INDArray indArray2 = Nd4j.valueArrayOf(new int[] {2, 3}, 888);
disp("全是指定值(888)的矩陣", indArray2);
  • 執行結果
全是指定值(888)的矩陣
維度 : 2
形狀 : [2, 3]
完整矩陣 : 
[[  888.0000,  888.0000,  888.0000], 
 [  888.0000,  888.0000,  888.0000]]
  1. rand：隨機矩陣（0到1之間的隨機數）
// 建立2行3列的隨機矩陣
INDArray indArray2 = Nd4j.rand(2, 3);
disp("隨機矩陣", indArray2);
  • 執行結果
隨機矩陣
維度 : 2
形狀 : [2, 3]
完整矩陣 : 
[[    0.7236,    0.5159,    0.1908], 
 [    0.9458,    0.4413,    0.4173]]
  1. 隨機高斯分佈的矩陣(平均值為0,標準差為1)：randn
// 建立2行3列的隨機高斯分佈矩陣
INDArray indArray3 = Nd4j.randn(2, 3);
disp("隨機高斯分佈矩陣", indArray3);
  • 執行結果
隨機高斯分佈矩陣
維度 : 2
形狀 : [2, 3]
完整矩陣 : 
[[   -0.4287,   -0.5790,    0.5004], 
 [   -0.5122,    1.0551,   -0.1998]]
  1. 等差數列：linspace
// 建立等差數列，
// 從1到6、長度為10的等差數列
INDArray indArray4 = Nd4j.linspace(1,6, 10);
disp("等差數列", indArray4);
  • 執行結果
等差數列
維度 : 1
形狀 : [10]
完整矩陣 : 
[    1.0000,    1.5556,    2.1111,    2.6667,    3.2222,    3.7778,    4.3333,    4.8889,    5.4444,    6.0000]
  1. 根據陣列建立矩陣：create(float[] data, int[] shape)
// 根據陣列建立2行3列的矩陣
INDArray indArray6 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[]  {2,3});
disp("根據陣列建立矩陣", indArray6);
  • 執行結果
根據陣列建立矩陣
維度 : 2
形狀 : [2, 3]
完整矩陣 : 
[[    1.0000,    2.0000,    3.0000], 
 [    4.0000,    5.0000,    6.0000]]
  1. 三維矩陣
// 三維矩陣
INDArray indArray7 = Nd4j.valueArrayOf(new int[] {2, 2, 3}, 888);
disp("三維矩陣", indArray7);

三維矩陣
維度 : 3
形狀 : [2, 2, 3]
完整矩陣 :
[[[ 888.0000, 888.0000, 888.0000],
[ 888.0000, 888.0000, 888.0000]],

[[ 888.0000, 888.0000, 888.0000],
[ 888.0000, 888.0000, 888.0000]]]


9. 建立正方形二維矩陣，並且對角線上的元素值都是1.0：

// 建立3行3列的二維矩陣，對角線值為1.0
INDArray indArray10 = Nd4j.eye(3);
disp("3*3矩陣，且對角線都是1.0", indArray10);


- 執行結果

3*3矩陣，且對角線都是1.0
維度 : 2
形狀 : [3, 3]
完整矩陣 :
[[ 1.0000, 0, 0],
[ 0, 1.0000, 0],
[ 0, 0, 1.0000]]


### 讀操作

- 接下來試試讀取相關的操作，回顧前面用陣列建立的2行3列的矩陣，內容如下：

[[ 1.0000, 2.0000, 3.0000],
[ 4.0000, 5.0000, 6.0000]]


1. 讀取指定位置：

System.out.println("讀取第一行第一列位置的值 : " + indArray6.getDouble(1,1));


- 執行結果

讀取第一行第一列位置的值 : 5.0


2. 指定行：

System.out.println("讀取第一行 : " + indArray6.getRow(1));


- 執行結果

讀取第一行 : [ 4.0000, 5.0000, 6.0000]


3. 指定列：

System.out.println("讀取第二列 : " + indArray6.getColumn(2));


- 執行結果

讀取第二列 : [ 3.0000, 6.0000]


4. 指定多列：

System.out.println("讀取第二、三列 : " + indArray6.getColumns(1,2));


- 執行結果

讀取第二、三列 : [[ 2.0000, 3.0000],
[ 5.0000, 6.0000]]


### 寫操作

- 接下來試試讀取相關的操作，回顧前面用陣列建立的2行3列的矩陣，內容如下：

[[ 1.0000, 2.0000, 3.0000],
[ 4.0000, 5.0000, 6.0000]]


1. 修改指定位置，檢視了原始碼後發現，put方法內容實際上是在呼叫putScalar方法：

indArray6.put(1,1, 123);
indArray6.putScalar(0,0, 456);
disp("a. 修改後", indArray6);


- 執行結果

a. 修改後
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 456.0000, 2.0000, 3.0000],
[ 4.0000, 123.0000, 6.0000]]


2. 修改整行：

// 準備一維陣列
INDArray row1 = Nd4j.create(new float[] {9,8,7});

// 用一維陣列替換矩陣的整行
indArray6.putRow(1, row1);
disp("b. 修改後", indArray6);


- 執行結果

b. 修改後
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 456.0000, 2.0000, 3.0000],
[ 9.0000, 8.0000, 7.0000]]


### 矩陣計算

- 矩陣計算，我們們從最基本的四則運算開始
1. 加減乘除，入參是一個標量，會與矩陣中的所有元素做計算

// 準備好原始資料，2行3列矩陣
indArray6 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});

// 加法
disp("加法", indArray6.add(1));

// 減法
disp("減法", indArray6.sub(1));

// 乘法
disp("乘法", indArray6.mul(2));

// 除法
disp("除法", indArray6.div(2));


- 執行結果

加法
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 2.0000, 3.0000, 4.0000],
[ 5.0000, 6.0000, 7.0000]]

減法
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 0, 1.0000, 2.0000],
[ 3.0000, 4.0000, 5.0000]]

乘法
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 2.0000, 4.0000, 6.0000],
[ 8.0000, 10.0000, 12.0000]]

除法
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 0.5000, 1.0000, 1.5000],
[ 2.0000, 2.5000, 3.0000]]


2. 前面的add方法，執行完畢後會生成一個新的NDArray例項，不影響原物件，但如果呼叫的是<font color="blue">addi</font>，就會修改原物件的內容：

INDArray indArray8 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
disp("替換前", indArray8);
indArray8.addi(1);
disp("替換後", indArray8);


- 執行結果

替換前
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 1.0000, 2.0000, 3.0000],
[ 4.0000, 5.0000, 6.0000]]

替換後
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 2.0000, 3.0000, 4.0000],
[ 5.0000, 6.0000, 7.0000]]


3. 展開：Nd4j.toFlattened，2行3列的二維矩陣展開後成了一維的

disp("展開", Nd4j.toFlattened(indArray6));


- 執行結果

展開
維度 : 1
形狀 : [6]
完整矩陣 :
[ 1.0000, 2.0000, 3.0000, 4.0000, 5.0000, 6.0000]


4. 轉換：reshape，相當於使用原有資料，但是換一個shape入參

disp("轉換", indArray6.reshape(3,2));


- 執行結果

轉換
維度 : 2
形狀 : [3, 2]
完整矩陣 :
[[ 1.0000, 2.0000],
[ 3.0000, 4.0000],
[ 5.0000, 6.0000]]


5. 提取正方形矩陣的對角線：diag，得到的結果是一維的

// 建立一個人3行3列的正方形矩陣
INDArray indArray9 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6, 7, 8, 9}, new int[] {3,3});
disp("3*3矩陣", indArray9);
// 提取正方形矩陣的對角線
disp("3*3矩陣的對角線", Nd4j.diag(indArray9));


- 執行結果如下圖，diag方法得到了源物件的對角線

![在這裡插入圖片描述](/img/bVcVvxp)

6. 基於源矩陣形狀建立新矩陣，且值都相通（入參值），然後用此新矩陣減去源矩陣：rsub

// 初始化一個2行3列的矩陣
INDArray indArray11 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
// 參考indArray12的結構建立一個2行3列的矩陣，該矩陣的所有元素的值都等於10(入參)，
// 然後，用該矩陣減去indArray11，結果作為rsub方法的返回值返回
INDArray indArray12 = indArray11.rsub(10);
disp("rsub方法", indArray12);


- 執行結果如下，可見所有值都是10減去源矩陣對應位置的值：

rsub方法
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 9.0000, 8.0000, 7.0000],
[ 6.0000, 5.0000, 4.0000]]


7. 兩個矩陣相加：add，兩個形狀相通的矩陣，同樣位置的值相加：

INDArray indArray13 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
INDArray indArray14 = Nd4j.create(new float[] {1, 1, 1, 1, 1, 1}, new int[] {2,3});

disp("矩陣相加", indArray13.add(indArray14));


- 執行結果

矩陣相加
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 2.0000, 3.0000, 4.0000],
[ 5.0000, 6.0000, 7.0000]]


8. 叉乘：mmul，2行3列乘以3行2列，

INDArray indArray13 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
INDArray indArray15 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {3,2});
disp("2行3列", indArray13);
disp("3行2列", indArray15);
disp("2行3列矩陣與3行2列矩陣的叉乘", indArray13.mmul(indArray15));


- 執行結果，可見，2行3列矩陣的每一行的元素，都和3行2列矩陣每一列的元素做兩兩相乘再相加，一共四個值，所以結果就是2行2列的矩陣：

![在這裡插入圖片描述](/img/bVcVvxq)

9. 矩陣所有元素值累加：sum

INDArray indArray16 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
// 總和
double sum = indArray16.sum().getDouble();
System.out.println("矩陣元素累加和 : " + sum);


- 執行結果

矩陣元素累加和 : 21.0


10. 轉置操作（不改變源物件）：transpose

INDArray indArray16 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});

disp("轉置前", indArray16);
disp("轉置操作", indArray16.transpose());
disp("transpose操作後的原值(不變)", indArray16);


- 執行結果，可見2行3列轉置後變成了3行2列，但是生成了新物件，而源物件未改變

轉置前
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 1.0000, 2.0000, 3.0000],
[ 4.0000, 5.0000, 6.0000]]

轉置操作
維度 : 2
形狀 : [3, 2]
完整矩陣 :
[[ 1.0000, 4.0000],
[ 2.0000, 5.0000],
[ 3.0000, 6.0000]]

transpose操作後的原值(不變)
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 1.0000, 2.0000, 3.0000],
[ 4.0000, 5.0000, 6.0000]]


11. 轉置操作（源物件被改變）：transposei

INDArray indArray16 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
disp("轉置前", indArray16);
disp("轉置操作", indArray16.transposei());
disp("transposei操作後的原值(已變)", indArray16);


- 執行結果

轉置前
維度 : 2
形狀 : [2, 3]
完整矩陣 :
[[ 1.0000, 2.0000, 3.0000],
[ 4.0000, 5.0000, 6.0000]]

轉置操作
維度 : 2
形狀 : [3, 2]
完整矩陣 :
[[ 1.0000, 4.0000],
[ 2.0000, 5.0000],
[ 3.0000, 6.0000]]

transposei操作後的原值(已變)
維度 : 2
形狀 : [3, 2]
完整矩陣 :
[[ 1.0000, 4.0000],
[ 2.0000, 5.0000],
[ 3.0000, 6.0000]]


12. 橫向拼接：hstack，要求兩個矩陣行數相等

// 2行3列
INDArray indArray17 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
// 2行1列
INDArray indArray18 = Nd4j.create(new float[] {1, 2}, new int[] {2,1});
disp("源矩陣", indArray17);
disp("拼接上的矩陣", indArray18);
// 2行3列的矩陣，橫向拼接一列後，變成了2行4列
disp("橫向拼接(每一行都增加一列)", Nd4j.hstack(indArray17, indArray18));


- 執行結果如下圖，可見是把indArray18 橫著拼到indArray17 的右側

![在這裡插入圖片描述](/img/bVcVvxr)

13. 縱向拼接：vstack，要求兩個矩陣列數相等

// 2行3列
INDArray indArray19 = Nd4j.create(new float[] {1, 2, 3, 4, 5, 6}, new int[] {2,3});
// 1行3列
INDArray indArray20 = Nd4j.create(new float[] {1, 2, 3}, new int[] {1,3});
disp("源矩陣", indArray17);
disp("拼接上的矩陣", indArray18);
// 2行3列的矩陣，縱向拼接一行，變成了3行3列
disp("縱向拼接(增加一行)", Nd4j.vstack(indArray19, indArray20));


- 執行結果如下圖，可見是把indArray20放在了indArray19的底部

![在這裡插入圖片描述](/img/bVcVvxs)

- 以上就是矩陣操作的常用API了，希望能給您一些參考，在深度學習的開發中更熟練的運算元據

### 你不孤單，欣宸原創一路相伴
1. [Java系列](https://xinchen.blog.csdn.net/article/details/105068742)
2. [Spring系列](https://xinchen.blog.csdn.net/article/details/105086498)
3. [Docker系列](https://xinchen.blog.csdn.net/article/details/105086732)
4. [kubernetes系列](https://xinchen.blog.csdn.net/article/details/105086794)
5. [資料庫+中介軟體系列](https://xinchen.blog.csdn.net/article/details/105086850)
6. [DevOps系列](https://xinchen.blog.csdn.net/article/details/105086920)

### 歡迎關注公眾號：程式設計師欣宸
> 微信搜尋「程式設計師欣宸」，我是欣宸，期待與您一同暢遊Java世界...

相關文章