美文网首页程序员
DeepLearning4j实战1--ND4J矩阵操作

DeepLearning4j实战1--ND4J矩阵操作

作者: 横竖撇折点 | 来源:发表于2018-12-17 10:56 被阅读0次

    本文示例源码地址:

    https://github.com/tianlanlandelan/DL4JTest/blob/master/src/test/java/com/dl4j/demo/Nd4jTest.java

    ## maven安装DL4J

    pom文件引入:

    <dependency>

                <groupId>org.nd4j</groupId>

                <artifactId>nd4j-native</artifactId>

                <version>1.0.0-beta3</version>

            </dependency>

            <dependency>

                <groupId>org.deeplearning4j</groupId>

                <artifactId>deeplearning4j-core</artifactId>

                <version>1.0.0-beta3</version>

            </dependency>

    ## 创建矩阵

    //生成一个全0二维矩阵

            INDArray tensorA =  Nd4j.zeros(4,5);

            println("全0二维矩阵",tensorA);

            //生成一个全1二维矩阵

            INDArray tensorB =  Nd4j.ones(4,5);

            println("全1二维矩阵",tensorB);

            //生成一个全1二维矩阵

            INDArray tensorC =  Nd4j.rand(4,5);

            println("随机二维矩阵",tensorC)

    运行结果:

    ====全0二维矩阵===

    [[        0,        0,        0,        0,        0],

    [        0,        0,        0,        0,        0],

    [        0,        0,        0,        0,        0],

    [        0,        0,        0,        0,        0]]

    ====全1二维矩阵===

    [[    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [    1.0000,    1.0000,    1.0000,    1.0000,    1.0000]]

    ====随机二维矩阵===

    [[    0.5017,    0.9461,    0.3255,    0.2155,    0.9273],

    [    0.0239,    0.5130,    0.8028,    0.5011,    0.3680],

    [    0.3644,    0.0864,    0.0342,    0.4126,    0.5553],

    [    0.2027,    0.7989,    0.6696,    0.0402,    0.7059]]

    ## 矩阵运算--拼接

    println("水平拼接若干矩阵,矩阵必须有相同的行数", Nd4j.hstack(tensorA,tensorB));

    println("垂直拼接若干矩阵,矩阵必须有相同的列数", Nd4j.vstack(tensorA,tensorB));

    运行结果:

    ====水平拼接若干矩阵,矩阵必须有相同的行数===

    [[        0,        0,        0,        0,        0,    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [        0,        0,        0,        0,        0,    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [        0,        0,        0,        0,        0,    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [        0,        0,        0,        0,        0,    1.0000,    1.0000,    1.0000,    1.0000,    1.0000]]

    ====垂直拼接若干矩阵,矩阵必须有相同的列数===

    [[        0,        0,        0,        0,        0],

    [        0,        0,        0,        0,        0],

    [        0,        0,        0,        0,        0],

    [        0,        0,        0,        0,        0],

    [    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [    1.0000,    1.0000,    1.0000,    1.0000,    1.0000],

    [    1.0000,    1.0000,    1.0000,    1.0000,    1.0000]]

    ## 矩阵运算-加减

    注意,每个运算函数都有一个加i的函数,如 add和addi,加i的函数运算后会覆盖掉原矩阵

            println("矩阵元素加上一个标量",tensorA.add(10));

            println("矩阵相加",tensorA.add(tensorB));

            println("矩阵元素加上标量后覆盖原矩阵tensorA",tensorA.addi(10));

            println("矩阵相减",tensorA.sub(tensorB));

    运行结果:

    ====矩阵元素加上一个标量===

    [[  10.0000,  10.0000,  10.0000],

    [  10.0000,  10.0000,  10.0000]]

    ====矩阵相加===

    [[    0.2202,    0.1473,    0.1217],

    [    0.8428,    0.6761,    0.8127]]

    ====矩阵元素加上标量后覆盖原矩阵tensorA===

    [[  10.0000,  10.0000,  10.0000],

    [  10.0000,  10.0000,  10.0000]]

    ====矩阵相减===

    [[    9.7798,    9.8527,    9.8783],

    [    9.1572,    9.3239,    9.1873]]

    ## 矩阵运算-乘除

    println("矩阵对应元素相乘",tensorA.mul(tensorB));

            println("矩阵元素除以一个标量",tensorA.div(2));

            println("矩阵对应元素相除",tensorA.div(tensorB));

            /*

            矩阵A*B=C

            需要注意:

            1、当矩阵A的列数等于矩阵B的行数时,A与B可以相乘。

            2、矩阵C的行数等于矩阵A的行数,C的列数等于B的列数。( A:2,3; B:3,4; C:2,4 )

            3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。

            */

            println("矩阵相乘",tensorA.mmul(tensorB));

    运算结果:

    ```bash

    ====矩阵对应元素相乘===

    [[    2.2015,    1.4728,    1.2173],

    [    8.4281,    6.7608,    8.1272]]

    ====矩阵元素除以一个标量===

    [[    5.0000,    5.0000,    5.0000],

    [    5.0000,    5.0000,    5.0000]]

    ====矩阵对应元素相除===

    [[  45.4231,  67.8989,  82.1506],

    [  11.8650,  14.7911,  12.3043]]

    ====矩阵相乘===

    [[    4.8916,  23.3161],

    [    4.8916,  23.3161]]

    ## 矩阵运算-翻转

    println("矩阵转置",tensorB.transpose());

    println("矩阵转置后替换原矩阵tensorB",tensorB.transposei());

    运算结果:

    ====矩阵转置===

    [[    0.2202,    0.8428],

    [    0.1473,    0.6761],

    [    0.1217,    0.8127]]

    ====矩阵转置后替换原矩阵tensorB===

    [[    0.2202,    0.8428],

    [    0.1473,    0.6761],

    [    0.1217,    0.8127]]

    ## 三维矩阵

    三维矩阵和二维矩阵操作一样

            //创建一个三维矩阵 2*3*4

            INDArray tensor3d_1 = Nd4j.create(new int[]{2,3,4});

            println("创建空的三维矩阵",tensor3d_1);

            //创建一个随机的三维矩阵 2*3*4

            INDArray tensor3d_2 =  Nd4j.rand(new int[]{2,3,4});

            println("创建随机三维矩阵",tensor3d_2);

            //矩阵的每个元素减去一个标量后覆盖原矩阵

            println("矩阵元素减去一个标量",tensor3d_1.subi(-5));

            //矩阵相减

            println("三维矩阵相减",tensor3d_1.sub(tensor3d_2));

    运算结果:

    ====创建空的三维矩阵===

    [[[        0,        0,        0,        0],

      [        0,        0,        0,        0],

      [        0,        0,        0,        0]],

    [[        0,        0,        0,        0],

      [        0,        0,        0,        0],

      [        0,        0,        0,        0]]]

    ====创建随机三维矩阵===

    [[[    0.7030,    0.0575,    0.3288,    0.8928],

      [    0.7067,    0.4539,    0.6318,    0.8632],

      [    0.2914,    0.7980,    0.3350,    0.8783]],

    [[    0.8559,    0.7396,    0.6039,    0.1946],

      [    0.5336,    0.9253,    0.4747,    0.2658],

      [    0.9690,    0.3269,    0.0520,    0.1754]]]

    ====矩阵元素减去一个标量===

    [[[    5.0000,    5.0000,    5.0000,    5.0000],

      [    5.0000,    5.0000,    5.0000,    5.0000],

      [    5.0000,    5.0000,    5.0000,    5.0000]],

    [[    5.0000,    5.0000,    5.0000,    5.0000],

      [    5.0000,    5.0000,    5.0000,    5.0000],

      [    5.0000,    5.0000,    5.0000,    5.0000]]]

    ====三维矩阵相减===

    [[[    4.2970,    4.9425,    4.6712,    4.1072],

      [    4.2933,    4.5461,    4.3682,    4.1368],

      [    4.7086,    4.2020,    4.6650,    4.1217]],

    [[    4.1441,    4.2604,    4.3961,    4.8054],

      [    4.4664,    4.0747,    4.5253,    4.7342],

      [    4.0310,    4.6731,    4.9480,    4.8246]]

    相关文章

      网友评论

        本文标题:DeepLearning4j实战1--ND4J矩阵操作

        本文链接:https://www.haomeiwen.com/subject/jujqkqtx.html