【Deeplearning4j】小小的了解下深度学习

最新推荐文章于 2024-09-11 09:53:39 发布
最新推荐文章于 2024-09-11 09:53:39 发布
阅读量2k 收藏 14
点赞数
分类专栏： Deeplearning4j 深度学习 学习 文章标签： 学习 深度学习 deep learning deeplearning4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Genmer/article/details/134810338
版权

文章目录

1. 起因

其实一直对这些什么深度学习，神经网络很感兴趣，之前也尝试过可能因为Java做这个不成熟或者其他什么原因但是没开始。这次，从Jone到TensorFlow到Deeplearning4j（DL4j）试了好几种，最终选了DL4j。

2. Deeplearning4j是什么

深度学习是一个极具吸引力的新领域，尤其是在 计算机视觉Q、自然语言处理等领域。目前，业界热议的有基手TensorFlow、Caffe、Theano枸建的开源深度学习框架，还有基于Spark构建的分布式、高性能的神经网络平台。而近年来，基于多种深度学习框架的开源工具如Keras、Torch、MxNet等越来越火爆。但是，这些框架各不兼容，很难构建复杂的深度学习模型。为解决这个问题，业界提出了另一种思路——用统一的JavaAP!构建统一的深度学习框架，使得不同深度学习框架可以方便地互联互通。从此，Deeplearning4j诞生了！
Deeplearning4j（简称DL4J)是Apache顶级项目，面向机器学习和深度学习开发者提供一个开源、商业级、健壮的平台。已是基于JVM (Java Virtual Machine） 的框架，支持Java、Scala及其他语言编写的代码。它的主要功能包括：

  1. 交叉语言接口：支持多种编程语言，包括Java、Scala、Python、C++、尺等；
    2.向量化计算：支持高度优化的矢量化计算，同时也兼顾易用性；
    3.自动微分：支持自动求导，并针对各类机器学习任务进行优化；
    4.深度学习模型库：包括卷积网络、循环网络、递归网络等；
    5.可扩展性：提供了便利的组件模型，并且允许用户自定义组件；
    6.分布式计算：通过Spark、Hadoop等计算框架可实现海量数据的分布式运算；
    7.模型训练工具：提供了命令行工具和图形界面工具，让用户快速上手；
    8.文档和示例代码：提供详尽的文档和丰富的示例代码，帮助用户快速入门。

3. 相关基本概念

列举了后面代码可能遇到的
3.1.神经网络(Neural Network)
神经网络(neural network）是由大量感知器组织起来的集成系统，每个感知器具有多个输入和输出连接，根据一定规则对其输入信号做加权处理，然后送给输出单元，产生一个输出信号。一个简单的神经元可以看作是—个具有单个阅值的线性分类器，它接受多个输入信号并决定是否激活，将信号传播至输出层。神经网络中的感知器可以互相连接，构成一个多层结构。深度学习中的神经网络通常具有多层结构，其中隐藏层的数量和各层节点的数量是手动设定的。
3.2.反向传播算法(Backpropagation algorithm)
反向传播算法是指用来更新神经网络参数的最常用的方法之一。每一次选代中，从最后一层往回迭代，首先计算当前层的误差值，然后依据误差和权重更新前一层的参数，直到更新完整个网络。反向传播算法相当于一个链式法则，将权重与误差传播给每一层，并根据这一链式法则更新权重，最终达到合理的训练结果。
3.3.梯度下降算法(Gradient Descent Algorithm)
梯度下降算法是反向传播算法的基础，它是利用误差最小化的方法来确定参数的最优解。具体来说，梯度下降算法以损失函数对参数的偏导数作为搜索方向，沿着该方向递减参数，直到找到全局最优解。梯度下降算法在每次迭代中计算出代价函数在当前参数处的梯度，根据梯度更新参数，直到得到局部最优解。
3.4.激活函数(Activation function)
激活函数 (activation function）是神经网络的关键组件之一。它作用在每一个非线性变换之后，用来修正线性组合的输出，使其成为非线性的。常用的激活函数有sigmoid函数、tanh函数、ReLU函数和softmax函数。
3.5.损失函数(Loss Function)
损失函数 (loss function）是描述神经网络性能的指标。神经网络的目标是最小化损失函数的值，以达到良好的性能。常用的损失函数有均方误差函数(mean squared error)、交叉熵函数 (cross entropy)

4. Maven依赖

不多废话，直接给能跑的代码
本人使用环境 MacOS 13.1 JDK 1.8

首先，在Windows/Linux/Mac 系统上，操作系统需要 64 位的（早期的版本支持 32 位，但由于训练深度神经网络需要大量内存，而 32 位系统访问内存有限，因此后期的版本只支持 64 位系统）。
其次，由于 Deeplearning4j 是基于 JVM 的框架，因此JDK 必须安装，JDK 版本推荐 1.7以上。由于篇幅关系，这里不再赘述JDK 的相关安装，请读者自行阅读Oracle 相关文档进行安装和相关环境变量的设置。
再者，DeepLearnina 依赖以及间接依赖的库很多，比如 JavaCPP、JavaCV、Guava、Spark 等。所以我们需要用类似 Maven 的jar 包管理工具进行依赖的引入。

在DL4j版本上进行过多次选择 一开始直接1.0.0-beta7 → 0.8.0 →0.9.0→0.9.1→1.0.0-beta4

因为有很多周边配置或者依赖或者机器（Apple M1 Pro）arm原因，目前是beta4（2023.12.02）

注意：但是以下两个例子需要0.8.0的版本，所以使用0.8.0，后面MNIST手写数据识别，会修改为1.0.0-beta4

为了怕遗漏，我就把我的相关依赖全放上去了（要下挺久）

 <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <dl4j.version>0.8.0</dl4j.version>
        <nd4j.version>0.8.0</nd4j.version>
        <spark.version>2</spark.version>
        <datavec.version>0.8.0</datavec.version>
        <scala.binary.version>2.11</scala.binary.version>
    </properties>

        <!--deeplearning4j-->
        <dependency>
            <groupId>org.deeplearning4j</groupId>
            <artifactId>deeplearning4j-core</artifactId>
            <version>${dl4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.deeplearning4j</groupId>
            <artifactId>deeplearning4j-nn</artifactId>
            <version>${dl4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.deeplearning4j</groupId>
            <artifactId>deeplearning4j-zoo</artifactId>
            <version>0.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.nd4j</groupId>
            <artifactId>nd4j-native-platform</artifactId>
            <version>${nd4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.deeplearning4j</groupId>
            <artifactId>deeplearning4j-ui_${scala.binary.version}</artifactId>
            <version>${dl4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.datavec</groupId>
            <artifactId>datavec-api</artifactId>
            <version>${datavec.version}</version>
        </dependency>
        <dependency>
            <groupId>org.datavec</groupId>
            <artifactId>datavec-data-image</artifactId>
            <version>${datavec.version}</version>
        </dependency>
        <dependency>
            <groupId>org.datavec</groupId>
            <artifactId>datavec-spark_${scala.binary.version}</artifactId>
            <version>${dl4j.version}_spark_2</version>
        </dependency>
        <dependency>
            <groupId>org.nd4j</groupId>
            <artifactId>nd4j-native</artifactId>
            <version>${dl4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.deeplearning4j</groupId>
            <artifactId>deeplearning4j-scaleout-parallelwrapper-parameter-server</artifactId>
            <version>${dl4j.version}</version>
        </dependency>

如果下不了，可以在pom.xml project标签下新增（存在就看着替换）仓库

 <repositories>
        <repository>
            <id>tensorflow-maven-repo</id>
            <url>https://repo.maven.apache.org/maven2/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>tensorflow-snapshots</id>
       <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>

5. 跑起来了，小例子！

直接跑 ，超简单的小例子（加法）


import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.factory.Nd4j;

import java.io.IOException;

public class ND4j_create {
        public static void main(String[] args) throws IOException{
            System.out.println(Nd4j.getBackend());
            INDArray tensor1 = Nd4j.create(new double[]{1,2,3});
            INDArray tensor2 = Nd4j.create(new double[]{10.0,20.0,30.0});
            System.out.println(tensor1.add(tensor2));
        }
}

6. 鸢尾花分类

以下俩例子，仅模型训练来自参考资料2的付费课程（提醒下文章中在线图片都过期了，有会员的可以看看）

两个例子所需文件在文章顶部，无需积分

也可以直接去参考资料3，下载官网demo

鸢尾花是广泛分布于温带的一种植物，在中国国内也种植有大量的鸢尾花，据百度百科—一鸢尾花词条中记录的信息表明，鸢尾花的种类有 13种之多。
鸢尾花数据集是由 R.A.Fisher 收集的关于 3种鸢尾花 (lris Setosa、Iris Versicolour 和 Iris Virginica） 且每一个种类有 50 条记录的开源数据集。

数据集中的每条记录共包含 4 个维度(萼片长度、萼片宽度、花瓣长度和花瓣宽度），部分数据集的截图如下：
在这里插入图片描述

需要注意的是，最后一列表示鸢尾花类别的例子是文本的，因此为了方便之后训练数据集的构建，我们将最后一列统一替换成数字(用数字 0、1、2分别标识三种类别的鸢尾花）。

代码

以下代码中说的单核多核，在现在的版本好像没什么区别了，默认好像就是多线程的

import org.deeplearning4j.api.storage.StatsStorage;
import org.deeplearning4j.datasets.iterator.impl.ListDataSetIterator;
import org.deeplearning4j.eval.Evaluation;
import org.deeplearning4j.nn.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.Updater;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.weights.WeightInit;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.deeplearning4j.ui.api.UIServer;
import org.deeplearning4j.ui.stats.StatsListener;
import org.deeplearning4j.ui.storage.InMemoryStatsStorage;
import org.deeplearning4j.util.ModelSerializer;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.dataset.SplitTestAndTrain;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.factory.Nd4j;
import org.nd4j.linalg.lossfunctions.LossFunctions;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

/**
 * 鸢尾花： http://archive.ics.uci.edu/dataset/53/iris
 *
 * 本Demo需要在 0.8.0版本才能跑，1.0.0-beta4 一堆问题
 */
public class MLPClassifyLris {
        private final static int numClasses= 3;
        private final static String TRAIN_DATA_PATCH = "src/main/resources/training/iris.csv";
        // 模型保存路径（注意模型无后缀 lris_model就是我起的模型名称，这和后面版本不一样，后面是zip后缀）
        private final static String MODEL_PATCH = "your path/lris_model";



        public static void training() throws IOException {
            /*--------------超参数常量声明------------------*/
            final int batchSize = 3;
            final long SEED = 1234L;
            final int trainSize = 120;
            /*--------------数据集构建------------------*/
            List<DataSet> irisList = loadIrisSeq(new File(TRAIN_DATA_PATCH));
//            merge(irisList,batchSize);
            DataSet allData = DataSet.merge(irisList);
            allData.shuffle(SEED);
            SplitTestAndTrain split = allData.splitTestAndTrain(trainSize);
            DataSet dsTrain = split.getTrain();
            DataSet dsTest = split.getTest();
            DataSetIterator trainIter = new ListDataSetIterator(dsTrain.asList() , batchSize);
            DataSetIterator testIter = new ListDataSetIterator(dsTest.asList() , batchSize);

            // 设置UI页面
            UIServer uiServer = UIServer.getInstance();
            StatsStorage statsStorage = new InMemoryStatsStorage();
            uiServer.attach(statsStorage);

            // 加载模型
            MultiLayerNetwork mlp = model();
            mlp.setListeners(new StatsListener(statsStorage));

            mlp.setListeners(new ScoreIterationListener(1));    //loss score监听器
            // 单(核)CPU
            for( int i = 0; i < 20; ++i ){
                mlp.fit(trainIter);    //训练模型
                trainIter.reset();
                Evaluation eval = mlp.evaluate(testIter);    //在验证集上进行准确性测试
                System.out.println(eval.stats());
                testIter.reset();
            }
            ModelSerializer.writeModel(mlp, new File(MODEL_PATCH), true);    //save model
        }
    public static List<DataSet> loadIrisSeq(File file) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(file));
        String line = null;
        List<DataSet> trainDataSetList = new LinkedList<DataSet>();
        while( (line = br.readLine()) != null ){
            String[] token = line.split(",");
            double[] featureArray = new double[token.length - 1];
            double[] labelArray = new double[numClasses];
            for( int i = 0; i < token.length - 1; ++i ){
                featureArray[i] = Double.parseDouble(token[i]);
            }
            labelArray[Integer.parseInt(token[token.length - 1])] = 1.0;
            //
            INDArray featureNDArray = Nd4j.create(featureArray);
            INDArray labelNDArray = Nd4j.create(labelArray);
            trainDataSetList.add(new DataSet(featureNDArray, labelNDArray));
        }
        br.close();
        return trainDataSetList;
    }

    public static List<DataSet> merge(List<DataSet> seq, int batchSize){
        int count = 0;
        List<DataSet> miniBatchSeq = new LinkedList<DataSet>();
        List<DataSet> tempSeq = new LinkedList<DataSet>();
        for( DataSet ds : seq ){
            if( count == batchSize ){
                miniBatchSeq.add(DataSet.merge(tempSeq));
                tempSeq.clear();
                count = 0;
            }
            tempSeq.add(ds);
            ++count;
        }
        if( !tempSeq.isEmpty() ){
            miniBatchSeq.add(DataSet.merge(tempSeq));
        }
        return miniBatchSeq;
    }

    public static MultiLayerNetwork model(){
        MultiLayerConfiguration.Builder builder = new NeuralNetConfiguration.Builder()
                .seed(12345)
//                .iterations(1) // Training iterations as above 0.9.1 ok | 1.0.0 X
//                .learningRate(0.01)
                .weightInit(WeightInit.XAVIER)
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .updater(Updater.ADAM)
                .list()
                .layer(0, new DenseLayer.Builder().activation(Activation.LEAKYRELU)
                        .nIn(4).nOut(2).build())
                .layer(1, new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                        .activation(Activation.SOFTMAX)
                        .nIn(2).nOut(3).build());
        MultiLayerConfiguration conf = builder.build();
        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        return model;
    }
    public static void main(String[] args) throws IOException, InterruptedException {
        training();
    }

}

如无意外，结果为：
鸢尾花模型训练完成
准确率（Accuracy）为 0.9333，表示模型正确预测的样本比例约为 93.33%。
精确率（Precision）为 0.9583，表示模型在预测为正类的样本中，正确预测为正类的比例约为 95.83%。
召回率（Recall）为 0.9259，表示模型在所有正类样本中，正确预测为正类的比例约为 92.59%。
F1 分数（F1 Score）为 0.9419，综合考虑了精确率和召回率的综合指标，越接近 1 表示模型的性能越好。

然后你设定的路径上会多一个模型文件
在这里插入图片描述
这里两个例子为就不使用模型了，我是在后面的MNIST才开始使用的

7. 波士顿房价 回归预测

前面说分类，好理解，那什么是回归

回归分析是一种统计分析方法，用于研究变量之间的关系和预测一个变量（称为因变量）的值，基于其他变量（称为自变量）的值。它旨在寻找自变量与因变量之间的关联，并使用这种关联来预测因变量的值。

回归分析的目标是建立一个数学模型，该模型可以描述自变量与因变量之间的函数关系。常见的回归分析方法包括线性回归、多项式回归、逻辑回归等。

在回归分析中，通常假设自变量与因变量之间存在某种线性或非线性关系。通过分析数据样本，回归分析可以估计出模型的参数，从而预测因变量的值。

回归分析在许多领域中都有广泛的应用，包括经济学、金融学、社会科学、医学、工程等。它可以帮助研究人员了解变量之间的关系、预测未来的趋势和行为，并支持决策和策略制定。

总而言之，回归分析是一种用于研究变量关系和预测因变量的统计分析方法，它是统计学和数据分析中常用的工具之一。

（所需数据在文章顶部，有资源链接，无需积分）
在这里插入图片描述

代码
package cn.genmer.test.security.machinelearning.deeplearning4j.begin;

import org.deeplearning4j.api.storage.StatsStorage;
import org.deeplearning4j.datasets.iterator.impl.ListDataSetIterator;
import org.deeplearning4j.eval.RegressionEvaluation;
import org.deeplearning4j.nn.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.weights.WeightInit;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.deeplearning4j.ui.api.UIServer;
import org.deeplearning4j.ui.storage.InMemoryStatsStorage;
import org.deeplearning4j.util.ModelSerializer;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.dataset.SplitTestAndTrain;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.dataset.api.preprocessor.DataNormalization;
import org.nd4j.linalg.dataset.api.preprocessor.NormalizerMinMaxScaler;
import org.nd4j.linalg.factory.Nd4j;
import org.nd4j.linalg.lossfunctions.LossFunctions;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

/**
 * 波士顿房价： http://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html
 * 本Demo需要在 0.8.0版本才能跑，1.0.0-beta4 一堆问题
 */
public class MLPRetuenTheBostonHousingDataset {
        private final static String TRAIN_DATA_PATCH = "src/main/resources/training/boston-house-price.csv";
        private final static String MODEL_PATCH = "your path/bostonHousing_model";



        public static void training() throws IOException {
            final int batchSize = 4;
            final long SEED = 1234L;
            final int trainSize = 400;
            List<DataSet> housePriceList = loadHousePrice(new File(TRAIN_DATA_PATCH));
            //获取全部数据并且打乱顺序
            DataSet allData = DataSet.merge(housePriceList);
            allData.shuffle(SEED);
            //划分训练集和验证集
            SplitTestAndTrain split = allData.splitTestAndTrain(trainSize);
            DataSet dsTrain = split.getTrain();
            DataSet dsTest = split.getTest();
            DataSetIterator trainIter = new ListDataSetIterator(dsTrain.asList() , batchSize);
            DataSetIterator testIter = new ListDataSetIterator(dsTest.asList() , batchSize);
            //归一化处理
            DataNormalization scaler = new NormalizerMinMaxScaler(0,1);
            scaler.fit(trainIter);
            scaler.fit(testIter);
            trainIter.setPreProcessor(scaler);
            testIter.setPreProcessor(scaler);
            //声明多层感知机
            MultiLayerNetwork mlp = model();
            mlp.setListeners(new ScoreIterationListener(1));
            // 设置UI页面
            UIServer uiServer = UIServer.getInstance();
            StatsStorage statsStorage = new InMemoryStatsStorage();
            uiServer.attach(statsStorage);
            //训练200个epoch
            for( int i = 0; i < 200; ++i ){
                mlp.fit(trainIter);
                trainIter.reset();
            }
            //利用 Deeplearning4j 内置的回归模型分析器进行模型评估
            RegressionEvaluation eval = mlp.evaluateRegression(testIter);
            System.out.println(eval.stats());
            testIter.reset();
            //输出验证集的真实值和预测值
            System.out.println("真实值：");
            System.out.println(testIter.next(testIter.totalExamples()).getLabels());
            System.out.println();
            testIter.reset();
            System.out.println("预测值：");
            System.out.println(mlp.output(testIter));
            testIter.reset();

            ModelSerializer.writeModel(mlp, new File(MODEL_PATCH), true);    //save model
        }
    public static List<DataSet> loadHousePrice(File file) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(file));
        String line = null;
        List<DataSet> totalDataSetList = new LinkedList<DataSet>();
        while( (line = br.readLine()) != null ){
            String[] token = line.split(",");
            double[] featureArray = new double[token.length - 1];
            double[] labelArray = new double[1];
            for( int i = 0; i < token.length - 1; ++i ){
                featureArray[i] = Double.parseDouble(token[i]);
            }
            labelArray[0] = Double.parseDouble(token[token.length - 1]);
            //
            INDArray featureNDArray = Nd4j.create(featureArray);
            INDArray labelNDArray = Nd4j.create(labelArray);
            totalDataSetList.add(new DataSet(featureNDArray, labelNDArray));
        }
        br.close();
        return totalDataSetList;
    }

    public static List<DataSet> merge(List<DataSet> seq, int batchSize){
        int count = 0;
        List<DataSet> miniBatchSeq = new LinkedList<DataSet>();
        List<DataSet> tempSeq = new LinkedList<DataSet>();
        for( DataSet ds : seq ){
            if( count == batchSize ){
                miniBatchSeq.add(DataSet.merge(tempSeq));
                tempSeq.clear();
                count = 0;
            }
            tempSeq.add(ds);
            ++count;
        }
        if( !tempSeq.isEmpty() ){
            miniBatchSeq.add(DataSet.merge(tempSeq));
        }
        return miniBatchSeq;
    }

    public static MultiLayerNetwork model(){
        MultiLayerConfiguration.Builder builder = new NeuralNetConfiguration.Builder()
                .seed(12345L)
//                .iterations(1)
//                .updater(Updater.ADAM)
                .weightInit(WeightInit.XAVIER)
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .list()
                .layer(0, new DenseLayer.Builder().activation(Activation.LEAKYRELU)
                        .nIn(13).nOut(10).build())
                .layer(1, new OutputLayer.Builder(LossFunctions.LossFunction.MEAN_SQUARED_LOGARITHMIC_ERROR)
                        .activation(Activation.IDENTITY)
                        .nIn(10).nOut(1).build());
//                .backprop(true).pretrain(false);
        MultiLayerConfiguration conf = builder.build();
        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        return model;
    }
    public static void loadModelAndPredict(INDArray feature) throws IOException{
        MultiLayerNetwork reloadModel = ModelSerializer.restoreMultiLayerNetwork(new File(MODEL_PATCH));
        reloadModel.predict(feature);
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        training();
    }

}

执行结果
在这里插入图片描述
在这里插入图片描述

8. 参考资料

  1. 介绍来自 Deeplearning4j: 用 Java 实现深度学习框架
  2. 鸢尾花 & 波士顿房价预测 多层感知机在结构化数据中的应用实现
  3. Deeplearning4j官网项目地址 有demo
Genmer
关注
专栏目录
Java 工程师快速入门深度学习，就从 Deeplearning4j 开始
GitChat
12-13 1万+
作者：万宫玺 随着机器学习、深度学习为主要代表的人工智能技术的逐渐成熟，越来越多的 AI 产品得到了真正的落地。无论是以语音识别和自然语言处理为基础的个人助理软件，还是以人脸识别为基础的刷脸付费系统，这些都是 AI 技术在现实生活中的实际应用。应当说 AI 正在走进千家万户，来到你我的身边。 另一方面，从研发角度来讲，AI 产品的落地并不是一件容易的事情： AI 技术数学理论要求高，数理统计...
Java深度学习库之Deeplearning4j
微微一笑满城空
04-18 645
Deeplearning4j是一个全面、成熟且企业级的深度学习库，专为Java和Scala开发者设计，提供了丰富的深度学习模型、易用的API、强大的分布式计算支持以及与Java生态系统的紧密集成。凭借其跨平台、高性能和高度可定制的特点，Deeplearning4j成为许多企业级项目在JVM平台上实现深度学习功能的首选工具。Deeplearning4j（简称 DL4J）是一个面向Java和Scala开发者、基于Java虚拟机（JVM）的开源深度学习库。
使用Deeplearning4j进行深度学习
weixin_53840353的博客
08-06 735
Deeplearning4j 是一个开源的、分布式的深度学习库，适用于JVM语言（如Java、Scala等）。它为研究人员和开发人员提供了构建、训练和部署深度学习模型的工具。DL4J的设计目标是与Hadoop和Spark等大数据工具无缝集成，以支持大规模数据处理。
Deeplearning4j【基础 01】初识Java深度学习框架DL4J
最新发布
2401_86951331的博客
09-11 523
网安所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
Deeplearning4j 快速入门
CSDN人工智能头条
01-08 934
Deeplearning4j 快速入门课程简介：机器学习经典案例基于 DL4J 的实现Spark 分布式场景下的模型训练及调优多 GPU 环境下的并行建模迁移和强化学习的...
Deeplearning4j
lifeqiuzhi521的博客
07-03 850
QUICKSTARTDOCUMENTATIONGPUSSPARKLSTMABOUTNEWSLETTERDownload SKIL Community EditionDeep Learning TextbookGetting StartedDeepLearning4J OverviewQuickstart: Running DL4JDeepLearning4J: Core ConceptsCompr...
深度学习入门: DeepLearning4j的基础知识和概念
程序员光剑
12-27 495
1.背景介绍 深度学习是一种人工智能技术，它旨在模仿人类大脑中的神经网络，以解决复杂的问题。深度学习已经成功应用于图像识别、自然语言处理、语音识别、机器学习等领域。DeepLearning4j 是一个用于深度学习的开源库，它为 Java 和 Scala 提供了深度学习功能。在本文中，我们将深入了解 DeepLearning4j 的基础知识和概念。 1.1 DeepLearning4j 的历史与...
On Deep Learning with Label Differential Privacy 深度学习中的本地差分隐私技术的应用和改进
weixin_43641509的博客
11-15 4991
On Deep Learning with Label Differential Privacy 链接: (1) Ghazi, B.; Golowich, N.; Kumar, R.; Manurangsi, P.; Zhang, C. On Deep Learning with Label Differential Privacy. arXiv preprint arXiv:2102.06062 2021. . 这里写目录标题On Deep Learning with Label Differential
deeplearning4j 官方示例（全）
10-16
deeplearning4j ，java深度学习示例，idea项目，maven项目，直接下载解压即可使用，超多main方法，每个main就是一个示例，CSDN自动更新积分，有需要的给我发消息，积分不好赚 ------------->以下为更新信息-------------> 积分上涨太快，更正为0积分
DeepLearning4j-使用Java训练YOLO模型
01-27
本文来自于csdn，文章介绍了数据集、模型训练中读取训练数据以及模型检测可视化等相关内容。在这个Yolov3发布的大好日子。 Deeplearning4j终于迎来了新的版本更新1.0.0-alpha，在zoomodel中引入TinyYolo模型可以训练自己的数据用于目标检测。 不得不说，在Yolov3这种性能和准确率上面都有大幅度提升的情况下，dl4j才引入TinyYolo总有一种49年加入国军的感觉 数据来源自
deeplearning4j
03-28
经典数据挖掘开源系统, 国外创业公司Skymind的产品, 目前最新的版本更新到了0.7.2。
deeplearning4j基础教程及源码
01-02
dl4j基础教程 配套视频：https://space.bilibili.com/327018681/#/
吴恩达deeplearning.ai系列课程笔记+编程作业(4)第一课 神经网络和深度学习-第4周：深层神经网络(Deep Neural Networks)
肖泽的博客
03-20 1253
第一门课 神经网络和深度学习(Neural Networks and Deep Learning) 第4周：深层神经网络(Deep Neural Networks) 文章目录第一门课 神经网络和深度学习(Neural Networks and Deep Learning)第4周：深层神经网络(Deep Neural Networks)4.1 深层神经网络（Deep L-layer neural n...
Neural Networks and Deep Learning之中文翻译-第一章 用神经网络识别手写数字
wangchongttg的博客
11-22 1094
Neural Networks and Deep Learning之中文翻译-第一章 用神经网络识别手写数字
深度迁移学习概述
makabaka的博客
10-08 2686
深度迁移学习概述： 深度迁移学习为传统迁移学习与深度神经网络相结合的一种新兴研究方向，以其对比非深度方法还有两个优势：自动化地提取更具现力的特征，以及满足了实际应用中的端到端 (End-to-End) 需求。 下图为深度迁移学习与传统迁移的结果比对。图中深度迁移学习方法 (BA、DDC、DAN) 对比传统迁移学习方法 (TCA、GFK 等)。 1.实验测试： 目前，深度迁移学习大致的思路为： 在...
目标检测YOLO实战应用案例100讲-基于深度学习的无人机目标检测算法轻量化研究
qq_36130719的博客
08-01 999
在Darknet深度学习框架支撑下，注重精度速度均衡化的YOLO系列算法结 合新算法思想，不断推陈出新。而YOLO系列经典算法YOLOv3，继承了YOLOv1、 YOLO9000[ 61]算法精度高、推理速度块、检测种类多的优势，综合提高了各大尺 度目标的检测精度，算法思想如下：(1) 基于残差网络构建的骨干网络Darknet53，基本模块为下采样和残差块 的连续组合，详细结构见表2.1。下采样模块一方面可以降低网络计算量，另一 方面也增大了感受野，提高对大目标的检测性能；
Deeplearning4j学习流程
05-28
以下是 Deeplearning4j 的学习流程： 1. 学习 Java 编程基础：Deeplearning4j 是一个基于 Java 的深度学习框架，因此需要先掌握 Java 的基本语法和面向对象编程的思想。 2. 学习机器学习和深度学习基础：需要了解机器学习和深度学习的基本概念和常见算法，如线性回归、逻辑回归、卷积神经网络等。 3. 学习 Deeplearning4j 的基础知识：包括 Deeplearning4j 的安装、配置和基本使用方法，以及各种数据处理、模型构建和模型训练的技巧。 4. 学习 Deeplearning4j 的高级应用：包括利用 Deeplearning4j 进行图像识别、自然语言处理、推荐系统等任务，以及将 Deeplearning4j 与其他框架（如 Hadoop、Spark）结合使用的方法。 5. 实践项目：通过实践项目来巩固所学知识，例如使用 Deeplearning4j 构建人脸识别系统、情感分析系统等。 6. 参与社区：在 Deeplearning4j 的社区中积极参与讨论、提出问题和解答问题，以便更好地了解 Deeplearning4j 的最新进展和应用。 希望这些步骤能够帮助你更好地学习 Deeplearning4j。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值