关于云计算:DL4J实战之五矩阵操作基本功

欢送拜访我的 GitHub

https://github.com/zq2599/blog_demos

内容：所有原创文章分类汇总及配套源码，波及 Java、Docker、Kubernetes、DevOPS 等；

本篇概览

• 作为《DL4J 实战》系列的第五篇，在后面对深度学习有肯定的理解后，本篇会暂停深度学习相干的操作，转为基本功练习：矩阵操作，即 INDArray 接口的根本用法
• INDArray 的类图如下，因为 BaseNDArray 是个抽象类，因而在理论应用中，咱们用的都是 NDArray 的实例：

• 之所以用一篇文章来学习矩阵操作，是因为前面的实战过程中处处都有它，处处离不开它，若不纯熟就会举步维艰；
• 本篇波及的 API 较多，因而先做好归类，前面的代码依照分类来写会清晰一些，一共分为五类：矩阵属性、创立操作、读操作、写操作、矩阵计算，接下来用思维导图列出每一类的罕用 API
• 矩阵属性：

• 创立操作：

• 读操作：

• 写操作：

• 矩阵计算：

源码下载

• 本篇实战中的残缺源码可在 GitHub 下载到，地址和链接信息如下表所示(https://github.com/zq2599/blo…)：

• 这个 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]]

2. 全 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]]

3. 全是指定值的矩阵：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]]

4. 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]]

5. 随机高斯分布的矩阵(平均值为 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]]

6. 等差数列：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]

7. 依据数组创立矩阵：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]]

8. 三维矩阵

// 三维矩阵
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 世界...