当前位置：首页 > news >正文

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

news 来源：原创 2024/9/28 5:19:40

文章目录

- - 1. 起因
  - 2. Deeplearning4j是什么
  - 3. 相关基本概念
  - 4. Maven依赖
  - 5. 跑起来了，小例子！
  - 6. 鸢尾花分类
  - - 代码
  - 7. 波士顿房价回归预测
  - - 代码
  - 8. 参考资料

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及其他语言编写的代码。它的主要功能包括：

交叉语言接口：支持多种编程语言，包括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监听器// 单(核)CPUfor( 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个epochfor( 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();}}