概述

每一个机器学习工作流至少由两部分组成。第一部份是加载你的数据并准备它用于学习。我们将此部分称为ETL（提取、转换、加载）过程。DataVec是我们为让构建数据管道更容易而构建的库。第二部分是实际的学习系统本身。这是DL4J的算法核心。

所有的深层学习都是基于向量和张量的，DL4J依赖于一个叫做ND4J的张量库。它为我们提供了处理n维数组（也叫做张量）的能力。由于其不同的后端，它甚至使我们能够同时使用CPU和GPU。

为学习和预测准备数据

与其他机器学习或深度学习框架不同，DL4J将加载数据和训练算法的任务视为单独的过程。你不只是把模型指向在磁盘上保存的数据，而是使用DataVec加载数据。这为你提供了更大的灵活性，并保留了简单数据加载的便利性。

在算法开始学习之前，你必须准备好数据，即使你已经有了一个经过训练的模型。准备数据意味着加载数据并将其置于正确的形状和值范围（例如，归一化、零均值和单位方差）。从头开始构建这些过程是容易出错的，因此尽可能使用DataVec。

Deeplearning4j可以处理许多不同的数据类型，比如图像、CSV、ARFF、纯文本，并且通过Apache Camel集成，可以处理几乎任何其它可以想到的数据类型。

要使用DataVec，需要连同RecordReaderDataSetIterator一起使用一个RecordReader接口的实现。

一旦你有了一个DataSetIterator, 它是一个描述顺序访问数据的模式，你可以使用它得到适合训练神经网络模型的格式的数据。

归一化数据

当它们被馈送的数据被归一化时，神经网络工作得最好，数据被限制在1到1之间。这样做有几个原因。一个是使用梯度下降训练网络，并且它们的激活函数通常在-1和1之间的某个范围。即使使用不会很快饱和的激活函数，将你的值限制到这个范围以提高性能仍然是很好的实践。

在DL4J中归一化数据相当简单，取决于你想要怎样归一化你的数据，并为你的DataSetIterator设置相关的DataNormalization作为预处理器。

ImagePreProcessingScaler显然是图像数据的不错的选择。如果你在输入数据的所有维度上具有统一的范围，那么NormalizerMinMaxScaler是一个不错的选择，并且NormalizerStandardize是你在其他情况下通常使用的工具。

如果你需要其他类型的归一化，你也可以自由地实现DataNormalization接口。

如果你使用NormalizerStandardize，请注意这是一个取决于从数据中提取的统计信息的一个归一化器，所以你必须同模型一起保存这些统计信息，以便你可以在恢复模型时恢复它们。

DataSets, INDArrays 和 Mini-Batches

顾名思义，DataSetIterator会返回DataSet对象。DataSet对象是数据的特征和标签的容器。但它们并不局限于一次只持有一个实例。数据集可以包含需要的多个实例。

它通过在几个INDArray实例中保存这些值：一个用于实例的特性，一个用于标签，以及另外两个用于屏蔽，如果你正在使用时间序列数据（参见使用RNN/Masking，了解更多信息）。

INDArray是ND4J中使用的n维数组或张量之一。在特征的情况下，它是实例大小数x特征数量的矩阵。即使只有一个实例，它也会有这种形状。

为什么它不同时包含所有的数据实例？

这是深入学习的另一个重要概念：迷你批处理。为了产生准确的结果，经常需要大量真实世界的训练数据。通常，这是比在可用内存中拟合的数据更多，所以有时将其存储在单个数据集中是不可能的。但是，即使有足够的数据存储，还有一个重要的原因不立即使用所有的数据。那就是使用小批量，你可以在一次训练中获得更多的更新。

那么，为什么要在数据集中有一个以上的例子呢？由于模型是使用梯度下降训练，它需要一个良好的梯度学习如何最小化误差。一次只使用一个示例将创建只考虑当前示例产生的错误的梯度。这会使学习行为不稳定，减慢学习，甚至可能导致不可用的结果。

一个小批量应该足够大，以提供真实世界（或者至少是你的数据）的代表性样本。这意味着它应该始终包含你想要预测的所有类，并且这些类的计数应该以与总体数据中的类分布大致相同。

构建一个神经网络模型

DL4J为数据科学家和开发人员提供了工具，用于在一个高层使用的概念上构建一个深度神经网络，例如 layer。它使用一个构建器模式来声明性地构建神经网络，正如您在这个（简化的）示例中可以看到的：

MultiLayerConfiguration conf = 
    new NeuralNetConfiguration.Builder()
        .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
        .updater(new Nesterovs(learningRate, 0.9))
        .list(
            new DenseLayer.Builder().nIn(numInputs).nOut(numHiddenNodes).activation("relu").build(),
            new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD).activation("softmax").nIn(numHiddenNodes).nOut(numOutputs).build()
        ).backprop(true).build();

如果你熟悉其他的深度学习框架，你会注意到这有点像Keras。

与其他框架不同，DL4J从更新器算法中分离优化算法。这允许灵活性，当你寻求一个优化器与更新器来为你的数据和问题最好的工作。

除了上面示例中看到的DenseLayer和OutputLayer之外，还有其他几种层类型，如GravesLSTM、卷积层、RBM、EmbeddingLayer等。使用这些层，你不仅可以定义简单的神经网络，还可以定义递归和卷积网络。

训练一个模型

在你配置你的神经网络之后，你必须训练你的模型。最简单的情况是在模型上简单的调用.fit()方法，并用你的DataSetIterator作为配置参数。这将在你所有的数据上一次性训练你的模型。在整个数据集上传递一次叫做一次训练。DL4J 有多个不同的方法来多次传递数据。

最简单的方法，是重置你的DataSetIterator并在fit的调用上循环你想要的次数。这种方法可以训练你的模型一直到你认为你的训练有良好的拟合。

然而还有一种方法是使用EarlyStoppingTrainer。只要你喜欢，你可以配置这个训练器用于你想要的训练次数。它将在每个训练之后评估你的网络性能（或者你 所配置的任何阶段），并保存性能最好的版本供以后使用。

还要注意的是，DL4J不仅支持多层次网络的训练，而且还支持更灵活的计算图

评估模型性能

当你训练你的模型时，你会想测试它的性能。对于该测试，你将需要一个专用的数据集，该数据集将不用于训练，而是仅用于评估模型。这些数据应该与你想用模型进行预测的真实世界数据有相同的分布。不能简单地将训练数据用于评估的原因是因为机器学习方法容易过拟合（擅长对训练集进行预测，但在较大的数据集上表现不佳）。

评价类用于评价。略有不同的方法适用于评估一个正常的前馈网络或循环网络。有关使用它的更多细节，请查看相应的示例。

神经网络模型故障排查

建立神经网络来解决问题是一个经验过程。也就是说，它需要反复试验。因此，你必须尝试不同的设置和体系结构，以便找到性能良好的神经网络配置。

DL4J提供了一个监听器工具，帮助你直观地监视网络的性能。你可以为你的模型设置监听器，在每个小批量处理之后调用。DL4J最常用的监听器之一是ScoreIterationListener。检查更多的Listeners。

虽然ScoreIterationListener将简单的打印你的网络的当前错误分数，HistogramIterationListener将启动一个网页界面来提供你一组可以用来微调网络配置的不同信息。查看可视化，网络学习监控与调试来知道如何解释这些数据

查看神经网络模型故障排查获取如何改进结果的更多信息。

我该如开始使用深度学习?

你从哪里开始取决于你已经知道了什么。

真正理解深度学习的先决条件是线性代数、微积分和统计学，以及编程和一些机器学习。应用它的先决条件是学习如何部署模型。

在DL4J的场景中，你应该很了解JAVA并且对类似IntelliJ IDE的工具和自动化构建工具Maven感到舒服。

下面你会找到一个资源列表。这些章节大致按它们有用的顺序组织起来。

免费的机器和深度学习在线课程

• 吴恩达在YouTube上的机器学习课程

• Geoff Hinton 在YouTube上的神经网络课程

• Patrick Winston人工智能介绍 @MIT (面向那些对人工智能的调查感兴趣的人)

• Andrej Karpathy斯坦福卷积神经网络课程 (面向那些对图片识别感兴趣的人)

• ML@B: 机器学习速成课程: 第一部分

• ML@B: 机器学习速成课程: 第二部分

• 梯度下降，神经网络如何学习，深度学习, 第二部分

数学

深度学习所涉及的数学基本上是线性代数、微积分和概率，如果你在本科阶段学习了这些，你将能够理解深层学习论文中的大部分思想与符号。如果没有在大学里学习过，就不要害怕。有很多免费的资源（有一些在这个网站上）。

• 看得见的理论: 概率与统计的可视化介绍

• 吴恩达 6部分线性代数综述

• Khan Academy的线性代数课程

• 机器学习所涉及的线性代数; Patrick van der Smagt

• CMU的线性代数综述

• 用于机器学习的数学

• 拟真线性代数

• 概率速查表

• 最佳线性代数书

• 马尔可夫链，视觉解释

• 机器学习的MCMC介绍

• 特征向量、特征值、主成分分析、协方差和熵

• 马尔可夫链蒙特卡洛（MCMC）与机器学习

编程

如果你还不知道如何编程，你可以从Java开始，但你可能会发现其他语言更容易。Python和Ruby资源可以在更快的反馈循环中传达基本思想。“学习Python的硬方法”和“学习编程（Ruby）”是两个很好的开始。

• Java学习的硬方法

• Python学习的硬方法

• Pyret: 一个Python学习环境

• Scratch: 一个来自MIT的可视化编程环境

• 学习Ruby编程

• 命令行介绍

• 附加命令行教程

• 一个Vim基础教程 (Vim 是一种用命令行访问的编辑器。)

• 计算机科学介绍 (CS50 @Harvard edX)

• 机器原理概论

如果你想不使用JAVA而直接使用深度学习，我们推荐Theano和各种可以顶替它的Python框架，包括Keras 和 Lasagne。

Python

• Learn Python the Hard Way

• Google's Python Class

• Udemy: Complete Python 3 Masterclass Journey

• MIT: Introduction to Computer Science and Python Programming

• David Beazley: Python Tutorials

• CS231n: Python Numpy Tutorial

• Pyret: A Python Learning Environment

Java

一旦你有了编程基础，就可以着手Java，这是世界上使用最广泛的编程语言。世界上大多数大型组织都使用巨大的Java代码库。（总是有JAVA的作品）（大数据栈—Hadoop, Spark, Kafka, Lucene, Solr, Cassandra, Flink –在很大程度上是为Java的计算环境JVM编写的。

• Think Java: 基于Web的交互式开发环境

• 学习 Java 的硬方法

• Java 资源

• Java Ranch: 一个Java 初学者社区

• Java编程介绍 @Princeton

• 深入浅出学Java

• Java技术手册

• Java初学者编程250步

Deeplearning4j

带着那些，我们推荐你通过它的 例子来走近DL4J。

快速入门

你也可以下载一个 智能层免费版, 它是支持 Python, Java 和 Scala 机器学习和数据科学的工具 。 SKIL是一个可以在prem和云端工作的机器学习后端，可以装载你的软件，提供一个机器学习模型服务器 。

其它资源

我们所知道的关于深度学习的大部分内容都包含在学术论文中。你可以在这里找到一些主要的研究小组。 虽然个别课程对他们所能教的东西有限制，但互联网却没有。大多数的数学和编程问题可以通过Google和搜索如 Stackoverflow 和 Math Stackexchange。

本页说明向eclipse/deeplearning4j github代码库中的项目贡献代码所需的步骤：https://github.com/eclipse/deeplearning4j

贡献者（任何想将代码提交到存储库的人）在合并他们的代码之前需要做两件事：

1. 签署Eclipse贡献者协议（一次）

2. 签署提交（每次）

为什么这是必需的？

所有Eclipse基础项目都必须满足这两个要求，而不仅仅是DL4J和ND4J: https://projects.eclipse.org/

通过签署ECA，你实际上是在明确你提交的代码是你编写的，或者你有权为项目做出贡献。这是避免版权问题的必要法律保护。

通过签署你的提交，你可以明确该特定提交中的代码是你自己的。

签署Eclipse贡献者协议

你只需要签署一次Eclipse贡献者协议（ECA）。流程如下：

步骤1：注册Eclipse帐户

可以在这里完成 https://accounts.eclipse.org/user/register

注意：你必须使用与你的github帐户（要提交请求的GitHub帐户）相同的电子邮件进行注册。

步骤2：签署ECA

去 https://accounts.eclipse.org/user/eca 并按说明操作。

签署你的提交

签署一个新的提交

有几种方法可以签署提交。请注意，你可以使用这些选项中的任何一个。

选项1：在命令行提交时使用 -s

在这里签署提交很简单：

git commit -s -m "My signed commit"

注意，-s（小写s）-大写S（即，-S）用于GPG签名（见下文）。

选项2：设置Bash别名（“或Windows cmd别名”）用于自动签署

例如，可以在bash中设置以下别名：

alias gcm='git commit -s -m'

然后提交将使用以下操作完成：

gcm "My Commit"

对于Windows命令行，可以通过一些机制使用类似的选项（请参见此处）

一种简单的方法是创建包含以下内容的gcm.bat文件，并将其添加到系统路径中：

@echo off
echo.
git commit -s -m %*

然后，你可以使用与上面相同的过程提交（即gcm“My commit”）

选项3: 使用GPG签署

要获取GPG签署详情，查看此链接

注意，这个选项可以与别名组合使用（见上文），如alias gcm=-git commit-S-m'-注意GPG签署的大写字母-S。

选项4: 使用带自动签署的IntelliJ提交

可用于执行git提交，包括通过签署提交。有关详细信息，请参阅本页。

检查提交是否已签署

在执行提交之后，你可以使用几种不同的方法进行签入。一种方法是使用git log--show signature-1来显示最后一次提交的签署（例如，使用-5来显示最后5次提交）

输出如下：

$ git log --show-signature -2
commit 81681455918371e29da1490d3f0ca3deecaf0490 (HEAD -> commit_test_branch)
Author: YourName <you@email.com>
Date:   Fri Jun 21 22:27:50 2019 +1000

    This commit is unsigned

commit 2349c6aa3497bd65866d7d0a18fe82bb691bb868
Author: YourName <you@email.com>
Date:   Fri Jun 21 21:42:38 2019 +1000

    My signed commit

    Signed-off-by: YourName <you@email.com>

顶部提交是未签署的，而底部提交是已签署的（请注意存在已签名者）。

如果你忘了签署一个提交-修改最后一个提交

如果忘记签署上次提交，可以使用以下命令：

git commit --amend --signoff

如果你忘记了签署多次提交

假设你的分支有3个新提交，所有提交都是未签署的：

$ git log -4 --oneline
4b164026 (HEAD -> commit_test_branch) Your new commit 3
d7799615 Your new commit 2
6bb6113a Your new commit 1
ef09606c This commit already exists

一个简单的方法是压缩并签署这些提交。要在最后3次提交时执行此操作，请使用以下命令：（注意，可能需要先进行备份）

git reset --soft HEAD~3
git commit -s -m "Squashed and signed"

结果:

$ git log -2 --oneline
31658e11 (HEAD -> commit_test_branch) Squashed and signed
ef09606c This commit already exists

你可以使用如前所示显示git log -1 --show-signature来确认提交已签署。

请注意，一旦将提交合并为master，你的提交将被粉碎，因此丢失提交历史并不重要。

如果你正在更新现有的PR，则可能需要强制使用 -f（如git push X -f）。

在本地从主干构建

注意：大多数用户应该使用Maven Central上的快速入门指南，而不是从源代码构建。

除非你有一个非常好的从源码构建的理由（例如开发新的特性——不包括自定义层、自定义激活函数、自定义丢失函数等——所有这些都可以在不直接修改DL4J的情况下添加），否则不应该从源码构建。从源码上构建可能相当复杂，在很多情况下都没有好处。

对于那些喜欢使用最新版本的Deeplearning4j或新建分支并构建自己的版本的开发人员和工程师，这些说明将指导你构建和安装Deeplearning4j。首选安装目的地是你本地机器的Maven仓库。如果不使用主分支，可以根据需要修改这些步骤（即：切换GIT分支并修改build-dl4j-stack.sh脚本）。

本地构建需要构建完整的Deeplearning4j栈，包括：

• libnd4j

• nd4j

• datavec

• deeplearning4j

请注意，Deeplearning4j被设计用于大多数平台（Windows、OS X和Linux），并且还包括多种“风格”，取决于你选择使用的计算架构。这包括CPU（OpenBLAS，MKL，ATLAS）和GPU（CUDA）。DL4J堆栈还支持X86和PowerPC架构。

先决条件

在尝试构建和安装DL4J栈之前，本地机器将需要设置一些基本的软件和环境变量。根据你的平台和操作系统的版本，在使它们工作时指令可能有所不同。该软件包括：

• git

• cmake (3.2或更高版本)

• OpenMP

• gcc (4.9 或更高版本)

• maven (3.3 或更高版本)

架构专用软件包括:

CPU 选项:

• Intel MKL

• OpenBLAS

• ATLAS

GPU 选项:

• CUDA

IDE-指定要求:

• IntelliJ Lombok plugin

DL4J 测试依赖:

• dl4j-test-resources

安装必备工具

Linux

Ubuntu假设你使用Ubuntu作为你的Linux偏好，并且作为非root用户运行，请按照以下步骤安装必备软件：

sudo apt-get purge maven maven2 maven3
sudo add-apt-repository ppa:natecarlson/maven3
sudo apt-get update
sudo apt-get install maven build-essentials cmake libgomp1

OS X

Homebrew是安装必备软件的公认方法。假设你在本地安装了Homebrew，请按照以下步骤安装必要的工具。

首先，在使用Homebrew之前，我们需要确保安装一个最新版本的XCODE（它被用作主编译器）：

xcode-select --install

最后, 安装必备工具:

brew update
brew install maven gcc5

注意：你不能使用CLANG。你也不使能用GCC的新版本。如果你有一个更新版本的GCC，请用这个这个链接切换版本。

Windows

libnd4j 依赖 Unix 工具包来编译。 所以为了编译它你需要安装Msys2 。

按他们的说明安装了MyS2之后，你将不得不安装一些额外的开发包。启动msys2 shell并设置DEV环境：

pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake mingw-w64-x86_64-extra-cmake-modules make pkg-config grep sed gzip tar mingw64/mingw-w64-x86_64-openblas

这将在MyS2 shell中安装所需使用的依赖项。

你还需要设置PATH环境变量来包括C:\msys64\mingw64\bin（或者你决定安装msys2的任何位置）。如果打开了IntelliJ（或其他IDE），则必须在此更改对通过它们启动的应用程序生效之前重新启动它。如果不这样做，你可能会看到一个“Can’t find dependent libraries”的错误。

安装必备架构

一旦安装了必备工具，现在就可以为平台安装所需的架构。

英特尔 MKL

在所有现有的CPU架构中，英特尔MKL是目前最快的。但是，在实际安装之前，它需要一些“开销”。

1. 英特尔网站申请一个许可

2. 通过英特尔网站执行几步之后，你将收到下载链接。

3. 下载MKL并按安装向导进行安装

OpenBLAS

Linux

Ubuntu 假设你正在使用Ubuntu，你可以通过如下安装 OpenBLAS :

sudo apt-get install libopenblas-dev

你还需要确保/opt/OpenBLAS/lib（或OpenBLAS的任何其他主目录）在你的路径上。为了让OpenBLAS与Apache Spark一起工作，你还需要做如下操作：

sudo cp libopenblas.so liblapack.so.3
sudo cp libopenblas.so libblas.so.3

CentOS 用root用户在终端（或ssh会话）输入如下:

yum groupinstall 'Development Tools'

之后，你 应该在终端上看到很多活动和安装。为了验证你有，例如，GCC，请输入此行：

gcc --version

去这里获得更多完整说明。

OS X

你可以在OS X用Homebrew安装OpenBLAS:

brew install homebrew/science/openblas

Windows

msys2 的OpenBLAS包已经可用，你可以用pacman命令安装。

ATLAS

Linux

Ubuntu 在Ubuntu上有一个ATLAS的apt包可以用:

sudo apt-get install libatlas-base-dev libatlas-dev

CentOS 你可以在 CentOS 上按如下按装ATLAS:

sudo yum install atlas-devel

OS X

在OS X上安装ATLAS是一个有点复杂和漫长的过程。但是，下面的命令将适用于大多数机器：

wget --content-disposition https://sourceforge.net/projects/math-atlas/files/latest/download?source=files
tar jxf atlas*.tar.bz2
mkdir atlas (Creating a directory for ATLAS)
mv ATLAS atlas/src-3.10.1
cd atlas/src-3.10.1
wget http://www.netlib.org/lapack/lapack-3.5.0.tgz (It may be possible that the atlas download already contains this file in which case this command is not needed)
mkdir intel(Creating a build directory)
cd intel
cpufreq-selector -g performance (This command requires root access. It is recommended but not essential)
../configure --prefix=/path to the directory where you want ATLAS installed/ --shared --with-netlib-lapack-tarfile=../lapack-3.5.0.tgz
make
make check
make ptcheck
make time
make install

CUDA

Linux & OS X

在这里可以找到安装GPU架构（如CUDA）的详细说明。

Windows

CUDA后端在构建之前有一些附加的要求：

• CUDA SDK

• Visual Studio 2012 or 2013 (Please note请注意: CUDA 7.5及以下版本不支持Visual Studio 2015)

为了构建CUDA后端，你必须首先调用vcvars64.bat来设置更多的环境变量。但首先，设置系统环境变量 SET_FULL_PATH为true，所以所有vcvars64.bat设置的变量都传递到mingw shell。

1. 在正常的cmd.exe命令提示符内，运行C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\amd64\vcvars64.bat

2. 在理面运行 c:\msys64\mingw64_shell.bat

3. 切换到 libnd4j 目录

4. ./buildnativeoperations.sh -c cuda

这将构建CUDA nd4j.dll.

IDE 要求

如果你是通过一个IDE如IntelliJ构建Deeplearning4j，你将需要安装一些插件，以确保你的IDE使得代码高亮适当。你需要为Lombok安装一个插件：

• IntelliJ Lombok 插件: https://plugins.jetbrains.com/plugin/6317-lombok-plugin

• Eclipse Lombok 插件: Follow instructions at https://projectlombok.org/download.html

如果你想在ScalNet、Scala API或某些模块（如DL4J UI）上工作，则需要确保IDE安装了Scala支持，并且该支持可用。

测试

Deeplearning4j使用一个单独的存储库，包含测试所需的所有资源。这是为了保持中央DL4J存储库轻量级，避免Git历史中的大blobs。为了运行测试，你需要从https://github.com/deeplearning4j/dl4j-test-resources（约10GB）安装测试资源。如果你不关心历史，只做一个浅克隆。

git clone --depth 1 --branch master https://github.com/deeplearning4j/dl4j-test-resources
cd dl4j-test-resources
mvn install

测试将只在testresources和后端profile（例如，test-nd4j-native）被选择时运行。

mvn clean test -P  testresources,test-nd4j-native

[图片上传中...(image-13982b-1540534628348-8)]

运行测试需要一段时间。要运行一个单独的Maven模块的测试，可以添加一个模块约束，用-pl deeplearning4j-core（详情见此处）。

安装DL4J栈

OS X & Linux

检查环境

在运行DL4J栈构建脚本之前，必须确保在运行构建之前定义了某些环境变量。下面将根据你的架构进行概述。

LIBND4J_HOME

你将需要知道运行DL4J构建脚本的目录的确切路径（鼓励你使用干净的空目录）。否则，你的构建将失败。一旦确定了这条路径，就将/libnd4j添加到该路径的末端，并将其导出到本地环境中。这看起来像：

export LIBND4J_HOME=/home/user/directory/libnd4j

CPU 架构 w/ MKL

你可以在构建时连接MKL或是在运行时连接一个二进制文件，初始化时连接另外的BLAS实现，例如OpenBLAS。要根据MKL进行构建，只需将包含libmkl_rt.so（或Windows上的mkl_rt.dll）的路径（例如/path/to/intel64/lib/）添加到Linux上的LD_LIBRARY_PATH环境变量（或Windows上的PATH）中，然后像以前一样构建。在Linux上，为了确保它使用OpenMP的正确版本，我们也可能需要设置这些环境变量：

export MKL_THREADING_LAYER=GNU
export LD_PRELOAD=/lib64/libgomp.so.1

当libnd4j无法重建时，我们可以在事实之后使用MKL库，并在运行时加载它们，而不是OpenBLAS，但是事情有点棘手。请另外按照下面的说明进行操作。

1. 确保这些文件例如 /lib64/libopenblas.so.0 和 /lib64/libblas.so.3 都不可用 (或出现在Windows的PATH参数之后), 或者他们将被LBND4J通过他们的绝对路径加载，在其他事情之前。

2. 在/path/to/intel64/lib/内部，创建libmkl_rt.so（或Windows上的 mkl_rt.dll）到libnd4j需要加载的名称的符号链接或副本，例如：

ln -s libmkl_rt.so libopenblas.so.0
ln -s libmkl_rt.so libblas.so.3

copy mkl_rt.dll libopenblas.dll
copy mkl_rt.dll libblas3.dll

1. 最后，将/path/to/intel64/lib/ 添加到LD_LIBRARY_PATH环境变量（或者在Windows上的PATH路径），并像往常一样运行Java应用程序。

手动构建

如果你愿意，你可以手动在DL4J栈中构建每一块。每个软件块的过程基本上是：

1. Git clone

2. Build

3. Install

整个过程如下面的命令所示，但libnd4j’s ./buildnativeoperations.sh接受基于你正在构建的后端的参数。你需要按照他们给出的顺序来执行这些指令。如果你不这样做，你的执行就会出错误。下面的特定于GPU的指令已经被注释掉了，但是在构建GPU后端时，应该取代特定于CPU的命令。

# removes any existing repositories to ensure a clean build
rm -rf libnd4j
rm -rf nd4j
rm -rf datavec
rm -rf deeplearning4j

# compile libnd4j
git clone https://github.com/deeplearning4j/libnd4j.git
cd libnd4j
./buildnativeoperations.sh
# and/or when using GPU
# ./buildnativeoperations.sh -c cuda -cc INSERT_YOUR_DEVICE_ARCH_HERE 
# i.e. if you have GTX 1070 device, use -cc 61
export LIBND4J_HOME=`pwd`
cd ..

# build and install nd4j to maven locally
git clone https://github.com/deeplearning4j/nd4j.git
cd nd4j
# cross-build across Scala versions (recommended)
bash buildmultiplescalaversions.sh clean install -DskipTests -Dmaven.javadoc.skip=true -pl '!:nd4j-cuda-9.0,!:nd4j-cuda-9.0-platform,!:nd4j-tests'
# or build for a single scala version
# mvn clean install -DskipTests -Dmaven.javadoc.skip=true -pl '!:nd4j-cuda-9.0,!:nd4j-cuda-9.0-platform,!:nd4j-tests'
# or when using GPU
# mvn clean install -DskipTests -Dmaven.javadoc.skip=true -pl '!:nd4j-tests'
cd ..

# build and install datavec
git clone https://github.com/deeplearning4j/datavec.git
cd datavec
if [ "$SCALAV" == "" ]; then
  bash buildmultiplescalaversions.sh clean install -DskipTests -Dmaven.javadoc.skip=true
else
  mvn clean install -DskipTests -Dmaven.javadoc.skip=true -Dscala.binary.version=$SCALAV -Dscala.version=$SCALA
fi
cd ..

# build and install deeplearning4j
git clone https://github.com/deeplearning4j/deeplearning4j.git
cd deeplearning4j
# cross-build across Scala versions (recommended)
./buildmultiplescalaversions.sh clean install -DskipTests -Dmaven.javadoc.skip=true
# or build for a single scala version
# mvn clean install -DskipTests -Dmaven.javadoc.skip=true
# If you skipped CUDA you may need to add
# -pl '!./deeplearning4j-cuda/'
# to the mvn clean install command to prevent the build from looking for cuda libs
cd ..

使用本地依赖

一旦你将DL4J栈安装到本地maven存储库之后，现在可以将其引入在构建工具的依赖项中。按照Deeplearning4j的经典入门说明，在主 POM上用SNAPSHOT版本适当地替换当前使用的版本。

请注意，一些构建工具，如Gradle和SBT没有正确地引入平台特定的二进制文件。你可以按照这里的说明来设置你最喜欢的构建工具。

支持与援助

如果在本地构建时遇到问题，Deeplearning4j的Early Adopters Channel是专门用于帮助解决构建问题和其他源代码问题的通道。请在Gitter上获取帮助。

先决条件

在做出贡献之前，确保你知道所有的Eclipse DL4J库的结构。早在2018年初，所有的库都入住在Deeplearning4j monorepo。这些包括：

• DeepLearning4J: 包含用于既在单个机器上，又在分布式上学习神经网络的所有代码。

• ND4J: “Java的n维数组”。ND4J是建立DL4J的数学后端。所有的DL4J神经网络都是使用ND4J中的运算（矩阵乘法、向量运算等）来构建的。ND4J是DL4J实现在没有改变网络本身的情况化，即可以CPU又可以GPU训练网络的原因。 没有Nd4J，就不会有DL4J。

• DataVec: DataVec处理管道侧的数据导入和转换。如果你 想将图像、视频、音频或简单CSV数据导入DL4J：你可能想要使用DataVec来实现。

• Arbiter: Arbiter是一种用于神经网络超参数优化的软件包。超参数优化是指自动选择网络超参数（学习速率、层数等）以获得良好性能的过程。

我们也有一个额外的示例仓库在 dl4j-examples.

贡献的方式

有多种方式为DeepLearning4J (和相关项目)做贡献，这取决于你的兴趣和经验。这有一些建议：

• 添加一个新的神经网络类型 (例如: 不同类型的 RNNs, 本地连接网络等)

• 添加一个新的训练特征

• 修复缺陷

• DL4J 示例: 那儿有我们没有示例的程序或神经网络架构吗？

• 测试性能和识别瓶颈或可以改进的地方。

• 改进网站的文档（或写教程等）

• 改进java文档

这有很多不同的方法来寻找工作。这些包括：

• 查看缺陷跟踪: https://github.com/deeplearning4j/deeplearning4j/issues https://github.com/deeplearning4j/dl4j-examples/issues

• 回顾我们的路线图

• 与开发人员交谈，特别是我们的早期使用者栏目

• 回顾最近的论文和博客文章关于训练特征、神经网络架构和应用。

• 回顾网站和例子-有什么什么似乎缺少，不完整，或只是有用的（或酷）？

一般准则

在你开始做之前，有一些事情你需要知道。特别是我们使用的工具:

• Maven: 一个依赖性管理和构建工具，用于我们所有的项目。有关Maven的详细信息，请参见此。

• Git: 我们使用的版本控制系统

• Project Lombok: Lombok项目是一种代码生成/注释工具，其目的是减少Java中所需的“多余”代码（即标准重复代码）的数量。要使用源代码，你需要为IDE安装Lombok插件。

• VisualVM:分析工具，最有效的识别性能问题和瓶颈。

• IntelliJ IDEA: 这是我们的IDE选择，当然，你可能会使用替代品，如Eclipse和NetBeans，你可能会发现使用与开发人员相同的IDE更容易避免出现问题。但这取决于你。

要记住的事情:

• 代码应该符合Java 7 或以上

• 如果你添加一个新的方法或类：添加java文档

• 为一个明显的功能添加添加一个作者标签是受大家欢迎的。这也可以帮助特征贡献者，以防他们需要问原作者问题。如果多个作者出现在一个类中：提供谁做了什么的细节（“初始实现”，“添加一个特征”等）

• 在你的代码中提供有益的注释。这有助于保持所有代码的可维护性。

• 任何新的功能都应该包括单元测试（使用JUnit）来测试代码。这应该包括边缘情况。

• 如果添加新的层类型，则必须按照这些单元测试包含数值梯度检查。这些是必要的，以确认计算的梯度是正确的。

• 如果你正在添加重要的新功能，请考虑更新网站的相关部分，并提供一个示例。毕竟，没有人知道的功能（或者没有人知道如何使用）是没有用的。添加合适的文档是非常受到鼓励的，但不是严格要求的。

• 如果你对某些事不确定，请在Gitter 上咨询我们。

关于Eclipse Deeplearning4j

Eclipse DeepLearning4j是一个用Java和Scala开发的开源分布式深度学习项目，由总部位于旧金山的商业智能和企业软件公司Konduit的员工牵头。我们是一个由数据科学家、深度学习专家、Java系统工程师和半感知机器人组成的团队。

当你在训练一个分布式的深度学习网络时，有很多事情要做。我们已经尽了最大努力来解释它们，因此Eclipse Deeplearning4j可以作为在Hadoop和其他文件系统上工作的Java、Scala和Clojure程序员的DIY工具。

媒体

Deeplearning4j 已经在 Wired, GigaOM, Businessweek, Venturebeat, The Wall Street Journal, Fusion 与 Java Magazine 出现过。

引用Eclipse Deeplearning4j

如果你计划出版学术论文并希望引用 Deeplearning4j，请使用这种格式：

Eclipse Deeplearning4j 开发团队。 Deeplearning4j: 用于JVM的开源分布式学习, Apache 软件基金许可2.0. http://deeplearning4j.org

支持者

由 YourKit 分析支持。

用于GPU和CPU的ND4J后端

你可以通过更改ND4J的POM.xml文件中的依赖项来为后端线性代数操作选择GPU或本地CPU。你的选择将影响应用程序中正在使用的ND4J和DL4J。

如果你的CUDA v9.2+已经安装并且有NVIDIA兼容的硬件，那么你的依赖声明将看起来像：

<dependency>
 <groupId>org.nd4j</groupId>
 <artifactId>nd4j-cuda-9.2</artifactId>
 <version>1.0.0-beta2</version>
</dependency>

否则，你将需要使用ND4J的本地实现作为CPU后端：

<dependency>
 <groupId>org.nd4j</groupId>
 <artifactId>nd4j-native</artifactId>
 <version>1.0.0-beta2</version>
</dependency>

系统架构

如果你在多个操作系统/系统架构上开发项目，则可以在artifactId的末尾添加-platform，该artifactId将下载大多数主要系统的二进制文件。

<dependency>
 ...
 <artifactId>nd4j-native-platform</artifactId>
 ...
</dependency>

多GPU

如果你有多个GPU但你的系统迫使你 只能用一个，你可以用 helper CudaEnvironment.getInstance().getConfiguration().allowMultiGPU(true);作为你的 main()方法的第一行。

CuDNN

查看我们的 CuDNN 页。

CUDA 安装

在NVIDIA 网站 上查看CUDA安装说明

ND4J/DL4J内存管理: 它是如何工作的?

ND4J使用堆外内存来存储NDArray，以便在与来自本地代码（如BLAS和CUDA库）的NDAArray一起工作时提供更好的性能。

“堆外”意味着内存被分配到JVM（Java虚拟机）之外，因此不受JVM垃圾收集（GC）的管理。在Java/JVM方面，我们只保存指向堆外内存的指针，这些指针可以通过JNI传递给底层C++代码，用于ND4J操作。

为了管理内存分配，我们使用两种方法：

• JVM 垃圾回收 (GC) 和弱引用追踪

• 内存工作间 - 阅读 内存工作间指引 获取详情

尽管这两种方法之间存在差异，但想法是相同的：一旦Java端不再需要NDArray，与其关联的堆外内存应该被释放，以便以后再使用。GC和“内存工作空间”方法之间的区别在于何时以及如何释放内存。

• 对于JVM/GC内存：每当垃圾收集器收集INDArray时，它的堆外内存将被释放，假设它没有被其他地方使用。

• 对于内存工作间：每当INDArray离开工作区范围时——例如，当一个层完成前向传递/预测时——其内存可以在不释放和重新分配的情况下被重用。这导致如神经网络训练和推理这样周期性的工作有更好的性能。

配置内存限制

对于DL4J/ND4J，有两种类型的内存限制需要注意和配置：堆上JVM内存限制和堆外内存限制（NDArray所在的位置）。这两个限制都是通过Java命令行参数来控制的：

• -Xms -这定义了JVM堆将在应用程序启动时使用多少内存。

• -Xmx - 这允许你指定JVM堆内存限制（最大值，在任何点）。如果需要的话，最多只分配给这个数量（在JVM的自由裁量权下）。

• -Dorg.bytedeco.javacpp.maxbytes - 这允许你指定堆外内存限制。

• -Dorg.bytedeco.javacpp.maxphysicalbytes - 这指定了整个进程的最大字节-通常设置为maxbytes+Xmx加上一些额外的字节，以防其它库还需要一些堆外内存。与设置maxbytes的设置不同，maxphysicalbytes是可选的。

示例: 配置 1GB 初始化堆内存, 2GB 最大堆内存, 8GB 堆外内存, 10GB 进程最大内存:

-Xms1G -Xmx2G -Dorg.bytedeco.javacpp.maxbytes=8G -Dorg.bytedeco.javacpp.maxphysicalbytes=10G

Gotchas: 几件值得注意的事情

• 对于GPU系统，maxbytes和maxphysicalbytes设置当前也有效地定义了GPU的内存限制，因为堆外内存被（通过NDArray）映射到GPU—请阅读下面的GPU部分中的更多信息。

• 对于许多应用程序，你希望JVM堆中使用的RAM更少，堆外使用的RAM更多，因为所有NDArray都存储在那里。如果对JVM堆分配太多，就不会有足够的内存留给堆外内存。

• 如果你得到一个“RuntimeException: Can’t allocate [HOST] memory: xxx; threadId: yyy”，你已经用完了堆外内存。你应该最常使用一个工作间配置来处理你的NDArrays分配，特别的在例如训练或评估/推断循环-如果你没有这么做，NDArray及其堆外（和GPU）资源使用JVM GC回收，这可能引入严重的延迟和可能的内存不足情况。

• 如果不指定JVM堆限制，默认情况下，它将使用系统总RAM的1/4作为限制。

• 如果不指定堆外内存限制，默认情况下将使用JVM堆限制（Xmx）的2倍。即-XMX8G将意味着8GB可以被JVM堆使用，而16GB可以被堆外的ND4J使用。

• 在有限的内存环境中，使用把-Xmx值和-Xms值都设为很大通常是一个坏主意。这是因为这样做不会留下足够的堆外内存。好比一个16GB系统，其中你设置-Xms14G：16GB的14GB将分配给JVM，仅留下2GB用于堆外内存、OS和所有其他程序，这样并不合理。

内存映射文件

当使用nd4j-native后端时，ND4J支持使用内存映射文件代替RAM。一方面，它比RAM慢，但另一方面，它允许你以不可能的方式分配内存块。

以下是示例代码：

WorkspaceConfiguration mmap = WorkspaceConfiguration.builder()
                .initialSize(1000000000)
                .policyLocation(LocationPolicy.MMAP)
                .build();

try (MemoryWorkspace ws = Nd4j.getWorkspaceManager().getAndActivateWorkspace(mmap, "M2")) {
    INDArray x = Nd4j.create(10000);
}

在这种情况下，将创建一个1GB临时文件并会被映射，NDArray X将在该空间中被创建。显然，当你需要的NDArrays不能适合放入你的RAM时，这个选项是可行的。

GPU

当使用GPU时，通常你的CPU使用的RAM往往会大于GPU使用的RAM。当GPU RAM小于CPU RAM时，需要监视堆外使用了多少RAM。你可以根据上面指定的JavaCPP选项来检查。

我们在GPU上分配你指定大小的堆外内存的。我们不会使用超过GPU的内存。也允许你指定大于GPU的堆空间（这是不鼓励的，但这是可能的）。如果这样做，当运行作业时，GPU将耗尽RAM。

我们也在CPU RAM上分配堆外内存。这是为了CPU与GPU的有效通信，以及CPU从NDArray访问数据，而无需每次调用时都从GPU获取数据。

如果JavaCPP或GPU抛出内存不足错误（OOM），或者即使由于GPU内存有限导致计算速度减慢，如果可能，你可能希望减小批处理大小或增加允许JavaCPP分配的堆外内存量。

尝试运行一个堆外内存等于你的GPU的RAM。同时，请记住使用Xmx选项设置一个小的JVM堆空间。

注意，如果你的GPU的RAM小于2G，它可能无法用于深度学习。如果情况是这样，你应该考虑使用你的CPU。典型的深度学习工作负载应该至少有4GB的RAM。尽管这样也是很小。GPU上的8GB RAM被推荐用于深度学习工作负载。

可以使用具有CUDA后端的HOST-only的内存。这可以使用工作区来完成。

示例:

WorkspaceConfiguration basicConfig = WorkspaceConfiguration.builder()
    .policyAllocation(AllocationPolicy.STRICT)
    .policyLearning(LearningPolicy.FIRST_LOOP)
    .policyMirroring(MirroringPolicy.HOST_ONLY) // <--- 这个选项做这个小把戏
    .policySpill(SpillPolicy.EXTERNAL)
    .build();

不建议直接使用只使用HOST-only数组，因为它们会极大地降低性能。但是，它们与INDArray.unsafeDuplication() 方法一起作为内存缓存对，可能是很有用的 。

配置 Maven 构建工具

你可以通过Maven使用DL4J，将以下内容添加到你的pom.xml：

<dependencies>
  <dependency>
      <groupId>org.deeplearning4j</groupId>
      <artifactId>deeplearning4j-core</artifactId>
      <version>1.0.0-beta6</version>
  </dependency>
</dependencies>

下面的指令适用于所有DL4J和ND4J子模块，例如 deeplearning4j-api, deeplearning4j-scaleout和ND4J后端。

添加一个后端

DL4J依赖于ND4J用于硬件特定的实现和张量操作。通过将下面的代码粘贴到你的pom.xml文件中来添加后端:

<dependencies>
  <dependency>
      <groupId>org.nd4j</groupId>
      <artifactId>nd4j-native-platform</artifactId>
      <version>1.0.0-beta6</version>
  </dependency>
</dependencies>

你还可以把 GPUs 替换为标准的CPU实现

配置你的构建工具

虽然我们鼓励Deeplearning4j、ND4J和DataVec用户使用Maven，但是为如何为其它工具配置构建文件编写文档是值得的，就像Ivy, Gradle 和 SBT，特别是对于Android项目，Google更喜欢Gradle而不是Maven。

下面的指令适用于所有DL4J和ND4J子模块，例如deeplearning4j-api、deeplearning4j-scaleout和ND4J后端。

Gradle

你可以在Gradle上使用DL4J，通过添加如下代码到你的build.gradle的依赖块中

compile "org.deeplearning4j:deeplearning4j-core:1.0.0-beta6"

通过添加如下代码到你的 build.gradle 来添加一个后端:

compile "org.nd4j:nd4j-native-platform:1.0.0-beta6"

你还可以把 GPUs 替换为标准的CPU实现。

SBT

你可以通过添加如下代码到build.sbt以便在SBT中使用DL4J：

libraryDependencies += "org.deeplearning4j" % "deeplearning4j-core" % "1.0.0-beta6"

通过添加如下代码到你的 build.sbt 来添加一个后端:

libraryDependencies += "org.nd4j" % "nd4j-native-platform" % "1.0.0-beta6"

你还可以把 GPUs 替换为标准的CPU实现。

Ivy

你可以通过添加如下代码到ivy.xml以便在ivy中使用DL4J：

<dependency org="org.deeplearning4j" name="deeplearning4j-core" rev="1.0.0-beta6" conf="build" />

通过添加如下代码到你的 ivy.xml 来添加一个后端:

<dependency org="org.nd4j" name="nd4j-native-platform" rev="1.0.0-beta6" conf="build" />

你还可以把 GPUs 替换为标准的CPU实现。

Leinengen

Clojure程序员可能希望使用Leiningen或 Boot与Maven一起工作。这里有一个Leiningen教程。

注意：你仍然需要下载ND4J、DataVec和Deeplearning4j，或者双击Maven/Ivy/Gradle下载的相应JAR文件，以便在Eclipse安装中安装它们。

与cuDNN一起使用DL4J

DL4J支持CUDA，但可以进一步通过cuDNN加速。大多数2D 卷积神经网络层（如ConvolutionLayer、SubsamplingLayer等），以及LSTM和BatchNormalization层都支持cuDNN。

要让DL4J加载cuDNN，我们只需要添加一个依赖项deeplearning4j-cuda-9.2, deeplearning4j-cuda-10.0, 或 deeplearning4j-cuda-10.1, 例如 :

<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>deeplearning4j-cuda-9.2</artifactId>
    <version>1.0.0-beta6</version>
</dependency>

或

<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>deeplearning4j-cuda-10.0</artifactId>
    <version>1.0.0-beta6</version>
</dependency>

或

<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>deeplearning4j-cuda-10.1</artifactId>
    <version>1.0.0-beta6</version>
</dependency>

cuDNN的实际库没有捆绑，因此请确保从NVIDIA下载并安装适合你的平台的包

• NVIDIA cuDNN

注意cuDNN和CUDA有多个组合被支持。当前，DL4J的支持下面的组合：

要安装，只需将库提取到本地库使用的系统路径中找到的目录即可。最简单的方法是将它放在默认目录中的CUDA之外的其他库中。 (/usr/local/cuda/lib64/ 在 Linux上, /usr/local/cuda/lib/ 在 Mac OS X, 并且 C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.2\bin\, C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\bin\, 或 C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1\bin\ 在 Windows上)。

或者，对于CUDA 9.2，cuDNN与用于CUDA的JavaCPP Presets 的“redist”包捆绑在一起。在同意许可之后，我们可以添加以下依赖项，来取代安装CUDA和cuDNN：

<dependency>
     <groupId>org.bytedeco</groupId>
     <artifactId>cuda-platform-redist</artifactId>
     <version>10.2-7.6-1.5.2</version>
 </dependency>

还要注意，默认情况下，DL4j将使用根据cuDNN可用的最快算法，但是内存使用可能溢出，导致奇怪的启动错误。当这种情况发生时，尝试通过使用通过网络配置设置的NO_WORKSPACE模式来减少内存使用， 替换默认的ConvolutionLayer.AlgoMode.PREFER_FASTEST，例如：

    // 对于整个网络
    new NeuralNetConfiguration.Builder()
            .cudnnAlgoMode(ConvolutionLayer.AlgoMode.NO_WORKSPACE)
            // ...
    // 或对于单个层
    new ConvolutionLayer.Builder(h, w)
            .cudnnAlgoMode(ConvolutionLayer.AlgoMode.NO_WORKSPACE)
            // ...

内容

• 快照介绍

• 安装说明

• 局限

• ND4J后端配置

• Gradle用户需知

概述／介绍

我们提供仓库的自动化日常构建，如ND4J, DataVec, DeepLearning4j, RL4J等等，所以所有最新的功能和最新的bug修复都是每天发布的。

快照像任何其他的Maven依赖一样工作。唯一的区别是，它们是从自定义存储库提供的，而不是从Maven Central提供的。

由于正在进行的开发，快照版应该被认为比发布版更不稳定：在正常开发过程中，原则上可以在任何时候引入破坏性的变化或错误。通常情况下，应在可能的情况下使用发布版本（不是快照），除非需要修复错误或需要新的功能。

安装说明

步骤1: 若要在项目中使用快照，应将像这样将快照仓库信息添加到你的POM.xml文件中：

<repositories>
    <repository>
        <id>snapshots-repo</id>
        <url>https://oss.sonatype.org/content/repositories/snapshots</url>
        <releases>
            <enabled>false</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
            <updatePolicy>daily</updatePolicy>  <!-- Optional, update daily -->
        </snapshots>
    </repository>
</repositories>

步骤2: 请确保指定快照版本。我们遵循一个简单的规则：如果最新的稳定发布版本是A.B.C，快照版本将是A.B.(C+1)-SNAPSHOT。当前快照版本为 1.0.0-SNAPSHOT。有关pom.xml文件的存储库部分的更多细节，请参见Maven 文档

如果使用类似DL4J示例的属性，则更改：从版本：

<dl4j.version>1.0.0-beta6</dl4j.version>
<nd4j.version>1.0.0-beta6</nd4j.version>

改为版本:

<dl4j.version>1.0.0-SNAPSHOT</dl4j.version>
<nd4j.version>1.0.0-SNAPSHOT</nd4j.version>

使用快照的示例pom.xml

这里提供了示例pom.xml：使用快照的示例pom.xml。这是从DL4J独立示例项目中获取的，并且使用上面的步骤1和2进行了修改。原件（使用最新版本）可以在这里找到

局限

-platform（所有操作系统）和单操作系统（非平台）快照依赖项都已释放。由于快照的多平台构建特性，-platform工件可能（虽然很少）暂时不同步，这可能会导致构建问题。

如果您只在一个平台上构建和部署，那么使用如下non-platform构件会比较安全

        <dependency>
            <groupId>org.nd4j</groupId>
            <artifactId>nd4j-native</artifactId>
            <version>${nd4j.version}</version>
        </dependency>

用于快照的有用的Maven命令

在Maven中使用快照依赖时可能有用的两个命令如下：

1. -U - 例如, 在 mvn package -U. 这个 -U 选项强制Maven去检查 (并且有必要的话，下载)最新的快照版。这在你需要确保你有绝对最新快照版时很有用。

2. -nsu - 例如, 在 mvn package -nsu. 这个 -nsu 选项停止Maven正在进行的快照版检查。但是，请注意，只有当你有一些快照依赖项已经下载到本地Maven缓存 (.m2 目录)中时，你的构建才会成功使用此选项。

另一种方法（1）是在<repositories>节点设置 <updatePolicy>always</updatePolicy>

另一种方法（2）是在<repositories>节点设置设置<updatePolicy>never</updatePolicy>

Gradle用户需知

快照不能与Gradle一起工作。你必须使用Maven下载文件。之后，你可以尝试使用 mavenLocal()使用本地Maven仓库。

最小文件像这样：

version '1.0-SNAPSHOT'

apply plugin: 'java'

sourceCompatibility = 1.8

repositories {
    maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
    mavenCentral()
}

dependencies {
    compile group: 'org.deeplearning4j', name: 'deeplearning4j-core', version: '1.0.0-SNAPSHOT'
    compile group: 'org.deeplearning4j', name: 'deeplearning4j-modelimport', version: '1.0.0-SNAPSHOT'
    compile "org.nd4j:nd4j-native:1.0.0-SNAPSHOT"
    // Use windows-x86_64 or linux-x86_64 if you are not on macos
    compile "org.nd4j:nd4j-native:1.0.0-SNAPSHOT:macosx-x86_64"
    testCompile group: 'junit', name: 'junit', version: '4.12'

}

应该在理论上工作，但事实并非如此。这是因为Gradle的一个缺陷。带有快照的Gradle和Maven分类器似乎有问题。

值得注意的是，当使用Gradle上的ND4J本地后端（和SBT -但不是Maven）时，需要添加OpenBLAS作为依赖项。我们在-platform pom上为你做了这件事。参考-platform pom 这里来重复检查你的依赖关系。请注意，这些是版本属性。有关运行 nd4j-native所需的OpenBLAS和javacpp presets当前版本，请参阅POM的<properties>节点。

什么是AVX，为什么重要？

AVX（高级向量扩展）是一组用于加速数值计算的CPU指令。更多细节见维基百科。

请注意，AVX仅适用于x86设备的nd4j-native（CPU）后端，而不适用于GPU和ARM/PPC设备。

AVX的重要性：性能。您希望使用系统支持的最高级别AVX编译的ND4J版本。

不同CPU的AVX支持-摘要：

• 大多数现代x86 CPU：支持AVX2

• 一些高端服务器CPU:AVX512可能被支持

• 旧CPU（2012年之前）和低功耗x86（Atom、Celeron）：不支持AVX（通常）

注意，支持更高版本AVX的CPU还包括所有更早版本。这意味着可以在支持AVX512的系统上运行通用X86或AVX2二进制指令。但是，不可能在不支持这些指令的CPU上运行为更高版本（如AVX512）构建的二进制指令。

在版本1.0.0-beta6和更高版本中，如果未优化配置AVX，则可能会收到以下警告：

*********************************** CPU Feature Check Warning ***********************************
Warning: Initializing ND4J with Generic x86 binary on a CPU with AVX/AVX2 support
Using ND4J with AVX/AVX2 will improve performance. See deeplearning4j.org/cpu for more details
Or set environment variable ND4J_IGNORE_AVX=true to suppress this warning
************************************************************************************************

在ND4J/DL4J中配置AVX

如前所述，为了获得最佳性能，您应该使用与CPU支持的AVX级别相匹配的ND4J版本。

对于nd4j/nd4j-platform依赖项，ND4J默认配置（仅包括nd4j-native 或 nd4j-native-platform依赖项而不包括maven分类器配置）是“generic x86”（无AVX）。

要配置AVX2和AVX512，需要为适当的架构指定一个分类器。

为X86体系结构提供了以下二进制文件（nd4j-native分类器）：

• Generic x86 (no AVX): linux-x86_64, windows-x86_64, macosx-x86_64

• AVX2: linux-x86_64-avx2, windows-x86_64-avx2, macosx-x86_64-avx2

• AVX512: linux-x86_64-avx512

示例：在Windows上配置AVX2（Maven pom.xml）

<dependency>
    <groupId>org.nd4j</groupId>
    <artifactId>nd4j-native</artifactId>
    <version>${nd4j.version}</version>
</dependency>

<dependency>
    <groupId>org.nd4j</groupId>
    <artifactId>nd4j-native</artifactId>
    <version>${nd4j.version}</version>
    <classifier>windows-x86_64-avx2</classifier>
</dependency>

示例：在Linux上配置AVX512（Maven pom.xml）

<dependency>
    <groupId>org.nd4j</groupId>
    <artifactId>nd4j-native</artifactId>
    <version>${nd4j.version}</version>
</dependency>

<dependency>
    <groupId>org.nd4j</groupId>
    <artifactId>nd4j-native</artifactId>
    <version>${nd4j.version}</version>
    <classifier>linux-x86_64-avx512</classifier>
</dependency>

请注意，您需要nd4j-native依赖项-有或没有分类器。

在上面的例子中，假设Maven属性 nd4j.version 设置为适当的ND4J版本， 1.0.0-beta6

什么是变量

定义或传递每个SameDiff实例的所有值（无论是权重、偏差、输入、激活或常规参数）都由SDVariable类的对象处理。

观察到变量，我们通常指的不仅仅是单个值——就像在描述自动微分的各种在线示例中所做的那样——而是它们的整个多维数组。

变量类型

SameDiff中的所有变量都属于四种变量类型之一，构成枚举VariableType。它们在这里：

• VARIABLE: 是网络的可训练参数，例如层的权重和偏差。当然，我们希望它们都被存储起来以供进一步使用——我们说，它们是持久化的——也在训练期间被更新。

• CONSTANT: 是那些参数，像变量一样，对于网络来说是持久化的，但是没有被训练；但是，它们可以由用户在外部更改。

• PLACEHOLDER: 存储要从外部提供的临时值，如输入和标签。 因此，由于新占位符的值是在每次迭代时提供的，所以它们不会被存储：换句话说，与VARIABLE和CONSTANT不同，PLACEHOLDER不是持久化的。

• ARRAY: 也是临时值，表示SameDiff中操作的输出，例如向量的和、层的激活等等。它们在每次迭代时都要重新计算，因此，与PLACEHOLDER一样，它们不是持久化的。

要推断特定变量的类型，可以使用getVariableType方法，如下所示：

VariableType varType = yourVariable.getVariableType();

可以使用getArr或getArr(true)获取INDArray形式的变量的当前值，如果希望程序在变量值未初始化时抛出异常，则使用后者。

数据类型

每个变量中的数据也有其数据类型，包含在DataType中。目前，在DataType中有三种浮点类型：FLOAT、DOUBLE和HALF；四种整数类型：LONG、INT、SHORT和UBYTE；一种布尔类型BOOL—所有这些类型都称为数值类型。此外，还有一个字符串类型称为UTF8；还有两个helper数据类型COMPRESSED和UNKNOWN。16位浮点格式BFLOAT16和无符号整数类型（UINT16、UINT32和UINT64）将在1.0.0-beta5中提供。

要推断变量的数据类型，请使用

DataType dataType = yourVariable.dataType();

您可能需要跟踪变量的数据类型，因为有时它确实很重要，您在操作中使用哪些类型。例如，一个卷积积，比如这个

SDVariable prod = samediff.cnn.conv1d(input, weights, config);

将要求其SDVariable参数input和weights为浮点数据类型之一，否则将抛出异常。另外，正如我们下面将要讨论的，VARIABLE类型的所有SDVariables都应该是浮点类型的。

变量的共同特征

在我们讨论变量之间的差异之前，让我们先看看它们共享的属性

• 所有变量最终都来自SameDiff的一个实例，作为其图。实际上，每个变量都有一个SameDiff作为其字段之一。

• 所有操作的结果（输出）均为ARRAY类型。

• 操作中涉及的所有SDVariable都属于同一个SameDiff。

• 所有变量都可能有名字，也可能没有名字——在后一种情况下，名字实际上是自动创建的。无论哪种方式，名称都必须是唯一的。我们将回到下面的命名。

变量类型之间的差异

现在让我们更仔细地看看每种类型的变量，以及它们之间的区别。

变量

变量是网络的可训练参数。这就预先决定了他们在SameDiff中的本性。如前所述，变量的值既需要为应用程序保留，也需要在训练期间更新。训练意味着，我们迭代地用梯度的一小部分来更新值，这只有当变量是浮点类型时才有意义（见上面的数据类型）。

变量可以使用SameDiff实例中不同版本的var函数添加到SameDiff中。例如，代码

SDVariable weights = samediff.var("weights", DataType.FLOAT, 784, 10);

将一个784x10个float数字数组的变量，一个单层MNIST感知器中的权重，这是一个预先存在的SameDiff实例samediff。

但是，通过这种方式，变量中的值将被设置为零。您也可以使用预设INDArray中的值创建变量。这样

SDVariable weights = samediff.var("weigths", Nd4j.nrand(784, 10).div(28));

将创建一个充满正态分布随机生成数的变量，方差为1/28。当然，您可以使用任何其他数组创建方法，而不是nrand或任何预设数组。此外，您还可以使用一些流行的初始化方案，例如：

SDVariable weights = samediff.var("weights", new XavierInitScheme('c', 784, 10), DataType.FLOAT, 784, 10);

现在，权重将使用Xavier方案随机初始化。有其他方法可以创建和填充变量：您可以在[我们的javadoc]的'known subclasses'部分中查找它们(https://deeplearning4j.org/api/latest/org/nd4j/weightinit/WeightInitScheme.html").

常数

常量保存存储的值，但与变量不同的是，在训练期间保持不变。例如，这些可能是您希望在网络中拥有的一些超参数，可以从外部访问。或者它们可能是您希望保持不变的神经网络的预训练权重（请参阅下面更改变量类型中的更多内容）。常数可以是任何数据类型。

• 例如，int和boolean可以与float和double一起使用。

通常，常量是通过constant方法添加到SameDiff中的。常数可以从INDArray创建，如下所示：

SDVariable constant = samediff.constant("constants", Nd4j.create(new float[] {3.1415f, 42f}));

可以使用scalar方法之一创建由单个标量值组成的常量：

INDArray someScalar = samediff.scalar("scalar", 42);

同样，我们引用javadoc作为整个参考。

占位符

SameDiff中最常见的占位符通常是输入和标签（如果适用）。可以创建任何数据类型的占位符，具体取决于在其中使用它们的操作。要向SameDiff添加占位符，可以调用占位符方法之一，例如：

SDVariable in = samediff.placeHolder("input", DataType.FLOAT, -1, 784);

如MNIST中。在这里，我们指定你的占位符的名称，数据类型和形状-在这里，我们有28x28个灰度图片呈现为1d向量（因此784）来成批的长度，我们事先不知道（因此-1）。

数组

ARRAY类型的变量显示为SameDiff中操作的输出。因此，数组类型变量的数据类型取决于它所生成的操作类型和它的参数的变量类型。数组不是持久化的——它们是一次性的值，将在下一步从头开始重新计算。但是，与占位符不同，梯度是为它们计算的，因为这些是更新VARIABLE值所必需的。

创建数组类型变量的方法和创建操作的方法一样多，因此您最好关注我们的操作部分、javadoc和示例。

汇总表

让我们在一个表中总结变量类型的主要属性：

我们还没有讨论“工作间”的含义—如果您不知道，不用担心，这是一个内部技术术语，基本上描述了内存是如何在内部管理的。

修改变量类型

您也可以更改变量类型。目前，有三种选择：

变量到常量

有时-例如，如果执行迁移学习-您可能希望将变量转换为常量。这样做：

samediff.convertToConstant(someVariable);

其中someVariable是VARIABLE类型的。变量someVariable将不再被训练。

常量到变量

相反，如果常量是浮点数据类型，则可以转换为变量。所以，举个例子，如果你希望你的冻结权重能够再次训练

samediff.convertToVariable(frozenWeights); //不再冻结

占位符到常量

占位符也可以转换为常量-例如，如果需要冻结其中一个输入。对数据类型没有任何限制，但是，由于占位符值不是持久化的，在将它们转换为常量之前，应该设置它们的值。这可以按如下方式进行

placeHolder.setArray(someArray);
samediff.convertToConstant(placeHolder);

现在不可能将常量转换回占位符，如果需要，我们可以考虑添加此功能。现在，如果您希望有效地冻结占位符，但能够再次使用它，请考虑为它提供常量值，而不是将其转换为常量。

变量的名称和值

从SameDiff获取变量

回想一下SameDiff实例中的每个变量都有其唯一的String名。SameDiff实际上是按变量名跟踪变量，并允许您使用getVariable(String name)方法检索它们。

请考虑以下几行：

SDVariable regressionCost = weights.mmul(input).sub("regression_prediction", bias).squaredDifference(labels);

这里，在函数sub中，我们实际上已经隐式地引入了一个变量（ARRAY类型），它保存了减法的结果。通过在操作的参数中添加一个名称，我们保证了从其他地方检索变量的可能性：例如，如果以后需要推断标签和作为向量的预测之间的差异，可以只写：

SDVariable errorVector = samediff.getVariable("regressionPrediction").sub(labels);

如果您的整个SameDiff实例在其他地方初始化，并且您仍然需要掌握它的一些变量（例如，多个输出），那么这将变得特别方便。

您可以获取和设置SDVariable的名称，方法分别是getVarName和setVarName。重命名时，请注意变量的名称在其SameDiff中保持唯一。

获取变量值

可以使用eval()方法以INDArray的形式检索任何变量的当前值。注意，对于非持久化变量，应该首先设置该值。对于具有梯度的变量，也可以使用getGradient方法推断梯度的值。

什么是工作间?

ND4J提供了一个额外的内存管理模型：工作间。这允许你在没有用于堆外内存跟踪的JVM垃圾回收器的情况下，重用循环工作负载的内存。换句话说，在工作间循环结束时，所有的数组内存内容都会失效。工作间被集成到DL4J中进行训练和推理。

基本思想很简单：你可以在工作间（或空间）内执行你需要的操作，并且如果你要从其去除一个INDArray（即，将结果移出工作空间），只需调用INDArray.detach()，你将获得一个独立的INDArray副本。

神经网络

对于DL4J用户来说，工作间提供了更好的性能，并且默认情况下从1.0.0-alpha开始启用。因此，对于大多数用户，不需要明确的工作间配置。

为了从工作间中受益，它们需要被启用。你可以使用以下方式配置工作间模式：

在你的神经网络中使用 .trainingWorkspaceMode(WorkspaceMode.SEPARATE) 或 .inferenceWorkspaceMode(WorkspaceMode.SINGLE) 。

SEPARATE工作间和SINGLE工作间之间的差异是性能和内存占用之间的折衷：

• SEPARATE 稍微慢一点，但是使用更少的内存。

• SINGLE 稍微快一点，但使用更多内存。

也就是说，可以使用不同的模式进行训练和推理（即，使用SEPARATE进行训练，并使用SINGLE进行推理，由于推理仅涉及前馈循环，而不涉及反向传播或更新器）。

通过启用工作间，在训练期间使用的所有内存将被重用和跟踪，而不会受到JVM GC干扰。唯一例外的是在内部使用前馈循环的工作间（如果启用的话）的output()方法。随后，它将产生的INDArray从工作间中分离出来，从而为您提供独立的INDArray，该INDArray将由JVM GC处理。

请注意：在1.0.0-alpha发行版之后，DL4J中的工作间被重构——SEPARATE/SINGLE模式已经被废弃，并且用户应该使用ENABLED来代替。

垃圾回收器

如果你的训练过程使用工作间，建议你禁用（或减少周期性GC调用的频率）。可以这样做：

// 这将限制GC调用的频率为5000毫秒。
Nd4j.getMemoryManager().setAutoGcWindow(5000)

// 或者你可以完全禁用它
Nd4j.getMemoryManager().togglePeriodicGc(false);

把它放到 model.fit(...) 调用之前。

ParallelWrapper & ParallelInference

对于ParallelWrapper，还添加了工作间模式配置选项。这样，每个训练线程将使用一个单独的工作间，连接到指定的设备。

ParallelWrapper wrapper = new ParallelWrapper.Builder(model)
      // DataSets 预获取选项。每个工作机器的缓存大小。
      .prefetchBuffer(8)

      //设置工作机器的数量为GPU的数量
      .workers(2)

      // 罕见的平均性能提高，但可能会降低模型准确率
      .averagingFrequency(5)

      // 如果设置为TRUE，则每个平均模型得分将被报告。
      .reportScoreAfterAveraging(false)

      // 3 选项在这里: NONE, SINGLE, SEPARATE
      .workspaceMode(WorkspaceMode.SINGLE)

      .build();

迭代器

我们提供异步预获取迭代器、AsyncDataSetIterator和AsyncMultiDataSetIterator，它们通常在内部使用。

这些迭代器可选地使用特殊的循环工作间模式来获得较小的内存占用。在这种情况下，工作空间的大小将由从底层迭代器出来的第一个DataSet的内存需求决定，而缓冲区大小由用户定义。如果内存需求随时间变化（例如，如果使用可变长度的时间序列），则工作间将被调整。

警告：如果你使用的是自定义迭代器或RecordReader，请确保在第一次next()调用中没有初始化大型对象。在构造函数中这样做，以避免不希望的工作间增长。

警告：使用了AsyncDataSetIterator，DataSets应在调用next()数据集之前被使用。你不应该以任何方式存储它们，也不应不调用detach() 。否则，在DataSet内用于INDArrays的内存最终将在AsyncDataSetIterator内被覆盖。

如果由于某种原因，你不希望将迭代器包装到异步预获取器中（例如，用于调试目的），则提供特殊的包装器：AsyncShieldDataSetIterator和AsyncShieldMultiDataSetIterator。基本上，这些只是薄的包装，防止预获取。

评估

通常，评估假设使用model.output()方法，该方法本质上返回与工作空间分离的INDArray。在训练过程中定期评估的情况下，最好使用内置的方法进行评估。例如：

Evaluation eval = new Evaluation(outputNum);
ROC roceval = new ROC(outputNum);
model.doEvaluation(iteratorTest, eval, roceval);

这段代码将在iteratorTest上运行一个单独的周期，并且它将在不需要任何额外INDArray分配的情况下更新两个IEvaluation实现（或更少/更多，如果你要求）。

工作间破坏

也有一些情况，比如，你缺少RAM，可能希望释放你无法控制的所有工作空间；例如，在评估或训练期间。

那么可以这样做：Nd4j.getWorkspaceManager().destroyAllWorkspacesForCurrentThread();

此方法将销毁在调用线程中创建的所有工作空间。如果你自己在一些外部线程中创建了工作间，那么可以在不再需要工作间之后，在该线程中使用相同的方法。

工作间异常

如果工作区使用不正确（例如，在自定义层或数据管道中的缺陷），你可能会看到一个错误消息，如：

org.nd4j.linalg.exception.ND4JIllegalStateException: Op [set] Y argument uses leaked workspace pointer from workspace [LOOP_EXTERNAL]
For more details, see the ND4J User Guide: nd4j.org/userguide#workspaces-panic

DL4J的层工作间管理器

DL4J的层API包含一个“层工作区管理器”的概念。

这个类的思想是，它允许我们在给定工作间的不同的可能配置的情况下，轻松且精确地控制给定数组的位置。例如，层外的激活可以在推理期间放置在一个工作间中，而在训练期间放置在另一个工作间中；这是出于性能原因。然而，使用层工作间管理器设计，层的实现者不需要为此而烦恼。

这在实践中意味着什么？通常很简单…

• 当返回 (activate(boolean training, LayerWorkspaceMgr workspaceMgr) 方法)，确保返回的数组已在 ArrayType.ACTIVATIONS (i.e., 使用 LayerWorkspaceMgr.create(ArrayType.ACTIVATIONS, …) 或类似)中定义

• 当返回激活梯度 (backpropGradient(INDArray epsilon, LayerWorkspaceMgr workspaceMgr))，类似的返回一个在 ArrayType.ACTIVATION_GRAD 中定义的数组。

你还可以在适合的工作间使用一个在任何工作间定义的数组，例如：LayerWorkspaceMgr.leverageTo(ArrayType.ACTIVATIONS, myArray)

注意，如果你没有实现自定义层（而是只想对MultiLayerNetwork/ComputationGraph之外的层执行转发），那么可以使用LayerWorkspaceMgr.noWorkspaces()。

SameDiff快速概述

要开始使用SameDiff，请熟悉GitHub上ND4J API的autodiff模块。

不管好坏，SameDiff代码只组织在几个关键的地方。对于SameDiff的基本使用和测试，以下模块是关键。我们将更详细地讨论其中的一些。

• functions: 这个模块有基本的构建块来构建SameDiff变量和图。

• execution: 拥有与SameDiff图执行相关的所有内容。

• gradcheck: 用于检查SameDiff梯度的实用程序功能，其结构类似于DL4J中的相应工具。

• loss: SameDiff的损失函数

• samediff: 主要用于定义、设置和运行SameDiff操作和图形的SameDiff模块。

functions 模块中的微分函数

请参阅GitHub上的functions模块。

functions模块的中心抽象是DifferentialFunction，它几乎是SameDiff中所有内容的基础。在数学上，我们在SameDiff中所做的是建立一个有向无环图，它的节点是微分函数，我们可以计算梯度。在这方面，DifferentialFunction构成了一个基本层次上的SameDiff图。

注意，每个DifferentialFunction函数都有一个SameDiff实例。我们稍后再讨论SameDiff和这段关系。另外，虽然只有很少的关键抽象，但它们实际上在任何地方都被使用，所以几乎不可能单独讨论SameDiff概念。最后，我们将讨论每个部分。

属性与映射

每个微分函数都有属性。在最简单的情况下，微分函数只有一个名字。根据所讨论的操作，通常会有更多的属性（考虑卷积中的步幅或内核大小）。当我们从其他项目（TensorFlow、ONNX等）导入计算图时，这些属性需要映射到我们内部使用的约定。attributeAdaptersForFunction、mappingsForFunction、propertiesForFunction和resolvePropertiesFromSameDiffBeforExecution方法是您希望在开始时查看的内容。

定义属性并正确映射后，分别为TensorFlow和ONNX import调用initFromTensorFlow和initFromOnnx。稍后，当我们讨论构建SameDiff操作时，将详细介绍这一点。

输入与输出

使用函数属性对输入列表执行微分函数，并生成一个或多个输出变量。您可以访问许多帮助函数来设置或访问这些变量：

• args(): 返回所有输入变量。

• arg(): 返回第一个输入变量（唯一一个用于一元操作）。

• larg() 与 rarg(): 返回二进制操作的第一个和第二个（读“left”和“right”）参数

• outputVariables(): 返回所有输出变量的列表。这取决于操作，可以动态计算。正如我们稍后将看到的，要获得具有单个输出的ops的结果，我们将调用.outputVariables()[0]。

处理输出变量是很棘手的，也是使用和扩展SameDiff的一个陷阱。例如，可能需要为微分函数实现calculateOutputShape，但如果实现不正确，则可能导致难以调试的失败。（注意，SameDiff最终将调用libnd4j中的操作执行，动态自定义操作要么推断输出形状，要么需要提供正确的输出形状。）

自动微分

微分函数的自动微分是用一种方法实现的：doDiff。每个操作都必须提供doDiff的实现。如果您正在为libnd4j op x实现SameDiff操作，并且幸运地找到了x_bp（如“反向传播”），那么您可以使用它，并且doDiff实现基本上是自由的。

您还将看到内部使用的diff实现并调用doDiff。

微分函数工厂

重要的是，每个微分函数都可以通过调用f()访问factory（DifferentialFunctionFactory的实例）。更准确地说，这将返回微分函数具有的SameDiff实例的工厂：

public DifferentialFunctionFactory f() {
    return sameDiff.f();
}

这在许多地方都有使用，并允许您访问当前在SameDiff中注册的所有微分函数。把这家工厂看作是一个操作提供者。下面是一个将sum暴露给DifferentialFunctionFactory的示例：

public SDVariable sum(...) {
    return new Sum(...).outputVariables()[0];
}

我们故意省略了函数参数。注意，我们所做的只是重定向到ND4J中其他地方定义的Sum操作，然后返回第一个输出变量（SDVariable类型，将在第二个中讨论）。现在不考虑实现细节，这允许您从任何可以访问微分函数工厂的地方调用f().sum(...)。例如，当实现SameDiff op x并且函数工厂中已经有x_bp时，可以重写x的doDiff

@Override
public List<SDVariable> doDiff(List<SDVariable> grad) {
    ...
    return Arrays.asList(f().x_bp(...));
}

SameDiff中图的构建与执行

请参阅GitHub上的samediff模块。

不足为奇，这就是魔法发生的地方。这个模块具有SameDiff操作的核心结构。首先，让我们看看构成SameDiff操作的变量。

SameDiff 变量

SDVariable（读取SameDiff变量）是DifferentialFunction的扩展，它对SameDiff的作用就像INDArray对老ND4J的作用一样，特别是SameDiff图对这些变量进行操作，每个单独的操作都会接收并输出一个SDVariable列表。SDVariable带有一个名称，配备一个SameDiff实例，具有形状信息，并且知道如何使用ND4J WeightInitScheme初始化自身。您还可以找到一些助手来设置和获取这些属性。

SDVariable可以做的少数事情之一就是DifferentialFunction不能通过调用eval()评估其结果并返回底层的INDArray。这将在内部运行SameDiff并获取结果。类似的getter是getArr()，您可以在任何时候调用它来获取此变量的当前值。此功能广泛用于测试，以断言正确的结果。SDVariable还可以通过gradient()访问其当前梯度。初始化时不会有任何梯度，通常在稍后的点计算。

除了这些方法之外，SDVariable还提供了具体操作的方法（在这方面与DifferentialFunctionFactory有点相似）。例如，定义add如下：

public SDVariable add(double sameDiffVariable) {
    return add(sameDiff.generateNewVarName(new AddOp().opName(),0),sameDiffVariable);
}

允许对两个SameDiff变量调用c=a.add(b)，其结果可由c.eval()访问。

SameDiff

SameDiff类是该模块的主要工作程序，它汇集了迄今为止讨论的大多数概念。有点不幸的是，反过来也是正确的，SameDiff实例在某种程度上是所有其他SameDiff模块抽象的一部分（这就是为什么您已经多次看到它）。一般来说，SameDiff是自动微分的主要入口点，您可以使用它来定义一个符号图，该图对SDVariables执行操作。一旦构建，SameDiff图可以通过几种方式运行，例如exec()和execandResult()。

让自己相信调用SameDiff()会创建很多很多东西！本质上，SameDiff将收集并允许您访问（就getter和setter而言）

• 图的所有微分函数及其所有属性，可以通过各种方式（如名称或id）访问。

• 所述功能的所有输入和输出信息。

• 所有函数属性以及如何映射它们、propertiesToResolve和propertiesForFunction都特别值得注意。

SameDiff也是向SameDiff模块公开新操作的地方。实际上，您可以为DifferentialFunctionFactory实例f()中的各个操作编写一个小包装器。下面是交叉积的一个例子：

public SDVariable cross(SDVariable a, SDVariable b) {
    return cross(null, a, b);
}

public SDVariable cross(String name, SDVariable a, SDVariable b) {
    SDVariable ret = f().cross(a, b);
    return updateVariableNameAndReference(ret, name);
}

SameDiff 执行示例和测试

在这一点上，查看并运行几个示例可能是一个好主意。SameDiff测试是一个很好的来源。下面是一个如何将两个SameDiff变量相乘的示例

SameDiff sd = SameDiff.create();

INDArray inArr = Nd4j.linspace(1, n, n).reshape(inOrder, d0, d1, d2);
INDArray inMul2Exp = inArr.mul(2);

SDVariable in = sd.var("in", inArr);
SDVariable inMul2 = in.mul(2.0);

sd.exec();

这个例子取自SameDiffTests，它是一个主要的测试源，在这里您还可以找到一些完整的端到端的例子。

你发现测试的第二个地方是samediff 。无论何时向SameDiff添加新操作，都要为前向传播和梯度检查添加测试。

第三组相关测试存储在imports中，包含用于导入TensorFlow和ONNX图的测试。另外，这些导入测试的资源是在我们的TFOpsTests项目中生成的。

创建和公开新的SameDiff操作

我们已经看到了DifferentialFunctionFactory和SameDiff如何获取ND4J操作，以便在不同级别将它们暴露给SameDiff。至于实际实现这些操作，您需要知道一些事情。在libnd4j中，您可以找到两类操作，这里将详细介绍这两类操作。我们将演示如何实现这两种操作类型。

所有的操作都是在这里进行的，而且大多数情况下，很明显要把操作放在哪里。要特别注意层，这是为深度学习层实现（如Conv2D）保留的。这些高级操作基于模块的概念，类似于pytorch中的模块或TensorFlow中的层。这些层操作实现还提供了更多涉及操作实现的源。

实现遗留操作

遗留（或XYZ）操作是具有特征“XYZ”签名的老一代ND4J操作。下面是如何在ND4J中通过包装libn4j中的cos遗留操作来实现cosine:cosine实现。说到SameDiff，遗留操作的好处是它们已经在ND4J中可用，但是需要通过SameDiff特定的功能来增强才能通过测试。因为余弦函数没有任何属性，所以这个实现很简单。使此操作SameDiff兼容的部分包括：

• 指定SameDiff构造函数 这里

• 你实现 doDiff 这里

• 在此处指定SameDiff opName、TensorFlow tensorflowName和ONNX onnxName。

如果仔细观察，这只是事实的一部分，因为Cos扩展了实现其他SameDiff功能的BaseTransformOp。（注意，BaseTransformOp是一个BaseOp，它早期扩展了DifferentialFunction。）例如，calculateOutputShape就是在这里实现的。如果您想实现一个新的转换，也可以简单地从BaseTransformOp继承。对于其他的操作类型，如reductions等，也可以使用操作基类，这意味着您只需要解决上面的三个要点。

在极少数情况下，您需要从头开始编写一个遗留操作，您需要从libn4j中找到相应的操作编号，可以在legacy-ops.h中找到。

实现动态自定义操作

DynamicCustomOp是libnd4j中的一种新操作，所有最近添加的操作都是这样实现的。ND4J中的这种操作类型直接扩展了DifferentialFunction。

这里是从DynamicCustomOp继承的BatchToSpace操作的示例：

• BatchToSpace由两个属性（block和crops）初始化。请注意，blocks和crops都是整数类型的，它们是如何通过调用addIArgument添加到操作的整数参数中的。对于float参数和其他类型，请改用addTArgument。

• 操作获取自己的名称和要导入的名称，

• 和doDiff 被实现

BatchToSpace操作在这里集成到DifferentialFunctionFactory中，在这里暴露在SameDiff中并在这里测试。

BatchToSpace当前唯一缺少的是属性映射。我们调用这个操作block和crops的属性，但是在ONNX或TensorFlow中，它们的调用和存储方式可能完全不同。要查找正确映射的差异，请参见Tensorflow的ops.proto和ONNX的onnxops.json。

让我们看看另一个正确执行属性映射的操作，即DynamicPartition。这个操作只有一个属性，在SameDiff中称为numPartitions。要映射和使用此属性，请执行以下操作：

• 实现一个名为addArgs的小助手方法，该方法用于op的构造函数和导入助手中，下面一行我们将讨论。这是没有必要的，但鼓励这样做，并一致称之为addArgs，为了清晰。

• 重写initFromTensorFlow方法，该方法使用TFGraphMapper实例为我们映射属性，并使用addArgs添加参数。注意，由于ONNX在编写本文时不支持动态分区（因此没有onnxName），因此也没有initFromOnnx方法，其工作方式与initFromTensorFlow几乎相同。

• 为了使TensorFlow导入可以工作，我们还需要重写mappingsForFunction。这个映射示例非常简单，它所做的只是将TensorFlow的属性名称 num_partitions映射到我们的名称 numPartitions。

请注意，虽然DynamicPartition具有正确的属性映射，但它当前没有一个有效的doDiff实现。

作为最后一个例子，我们展示了一个更有趣的属性映射设置，即Dilation2d。正如您在mappingsForFunction中看到的，这个操作不仅要映射更多的属性，而且属性还带有属性值，如attributeAdaptersForFunction中定义的。我们之所以选择显示此操作，是因为它具有属性映射，但既不向DifferentialFunctionFactory公开，也不向SameDiff公开。

因此，所示的三个DynamicCustomOp示例都有自己的缺陷，并代表了必须为SameDiff完成的工作的示例。总之，要添加新的SameDiff 操作，您需要：

• 在ND4J中创建扩展DifferentialFunction的新操作。具体如何设置此实现取决于

  • 操作生成 (遗留与动态定制)

  • 操作类型 (变换、缩减等)

• 定义自己的操作名，以及TensorFlow和ONNX名称。

• 定义必要的SameDiff构造函数

• 使用addArgs以可重用的方式添加操作参数。

• 首先在DifferentialFunctionFactory中公开操作，然后将其包装在SameDiff（或变量方法的SDVariable）中。

• 实现doDiff的自动微分。

• 重写mappingsForFunction以映射TensorFlow和ONNX的属性

• If necessary, also provide an attribute adapter by overriding attributeAdaptersForFunction.如果需要，还可以通过重写attributeAdaptersForFunction来提供属性适配器。

• 通过添加initFromTensorFlow和initFromOnnx（使用addArgs），为TensorFlow和ONNX添加import一行。

• 测试，测试，测试

通用基准测试准则

准则1: 在基准测试之前运行预热迭代

预热期是你开始计时进行更多迭代之前，在没有计时的情况下运行多个（例如 几百个）迭代。

为什么有预热期？任意ND4J/DL4J 执行的前几次迭代可能比后面的迭代要慢，有以下原因：

1. 在初始化基准测试迭代中，JVM没有时间去进行代码的即时编译。一旦即时编译完成，对于所有后续操作，代码可能执行得更快。

2. 在ND4J 和 DL4J (和其它库)都有某种程度的懒初始化：第一次操作可能触发一些一次性执行的代码。

3. DL4J 或 ND4J (当使用工作间) 可以用一些迭代来学习执行的内存要求。在这个学习过程中，性能会比在它完成之前低。

准则 2: 为所有基准测试运行多个迭代

你的基准测试不是运行在你电脑上的惟一的东西（更不用说如果你使用的是云硬件，可能有共享资源）。并且操作运行时间不是完全确定的。

为了让基准测试可信，多次迭代是很重要的- 并且理想地报告运行时的均值和标准差。没有这一点，就不可能比较操作的性能，因为性能差异可能只是由于随机变化造成的。

准则3: 特别注意你基准测试的是什么

当比较框架时，这尤其重要。在声明“X操作的性能为Y”或“A比B快”之前，请确保：

你只对你感兴趣的操作进行基准测试。

如果您的目标是检查操作的性能，请确保只有此操作正被计时。

您应该仔细检查是否无意中包括其他内容——例如，是否包括：JVM初始化时间？库初始化时间？结果数组分配时间？垃圾收集时间？数据加载时间？

理想情况下，这些应在你报告的任何时间/性能结果中排除。如果他们不能被排除在外，请在制定性能要求时务必注意这点。

1. 你使用的是哪些本地库? 例如：BLAS的实现是什么（MKL, OpenBLAS, 等）？如果你正在使用CUD，你也使用了CuDNN吗？ ND4J 和 DL4J 可使用这些库(MKL, CuDNN)，当它们可用的时候。但通常默认是不可用的。如果它们没有被设为可用，性能会比较低，有时候相当低。

   在比较库之间的结果时，这一点尤其重要：例如，如果比较两个库（一个使用OpenBLAS，另一个使用MLK），那么结果可能只是反映了正在使用的BLAS库的性能差异，而不是别的正在测试的库的性能。类似地，一个CuDNN和另一个没有CuDNN的库可能简单地反映了使用CuDNN的性能收益。

2. 如何配置? 不论好坏，DL4J和ND4J允许很多配置。对于大多数用户来说，这种配置的默认值是足够的，但有时需要手动配置才能获得最佳性能。这在某些基准测试中尤其适用。例如，这些配置选项中的一些允许用户以更高的内存使用以获得更好的性能。需要注意的一些配置选项：(a)内存配置(b)工作区和垃圾收集(c)CuDNN(d)DL4J缓存模式(启用.cacheMode(CacheMode.DEVICE))

   如果你不确定你是否只是在运行DL4J或ND4J代码时测量您想要测量的内容，那么可以使用分析器，例如VisualVM或YourKit Profilers。

3. 你正在使用的是哪个版本? 在基准测试时，您应该使用最新版本的任何基准测试库。识别和报告一个6个月前修复的瓶颈是没有意义的。当您在版本间比较性能时，这将是一个例外。还请注意，DL4J和ND4J的快照版本也是可用的——它们可能包含性能改进（可以随时询问）

准则 4: 关注现实世界的用例——并运行一定范围的大小

例如，考虑一个基准测试，两个数字相加:

double x = 0;
//<start timing>
x += 1.0;
//<end timing>

在 ND4J 中等价于:

INDArray x = Nd4j.create(1);
//<start timing>
x.addi(1.0);
//<end timing>

当然，上面的ND4J基准测试要慢得多—需要方法调用、执行输入验证、必须调用本地代码（具有上下文切换开销）等等。一个必须问的问题：这个问题是用户实际使用ND4J还是等价的线性代数库？这是一个极端的例子，但一般的观点是有效的。

还要注意，数学运算的性能可是特定的大小和形状。例如，如果你对矩阵乘法的性能进行基准测试，那么矩阵维数可能非常重要。在一些内部基准测试中，我们发现不同的BLAS实现（MKL 对比 OpenBLAS）和不同的后端（CPU 对比 GPU）可以在不同的矩阵维度下表现非常不同。对于所有输入形状和大小，我们在内部测试的BLAS实现（OpenBLAS、MKL、CUDA）没有一个比其他BLAS实现本质上更快。

因此，无论何时运行基准测试，都必须以多种不同的输入形状/大小运行这些基准测试，以获得完整的性能图。

准则 5: 理解你的硬件

当比较不同的硬件时，重要的是要知道它擅长什么。例如，你可能会发现神经网络小批量大小为1的时候，在CPU上训练比在GPU上执行得更快—但是更大的小批量大小正好相反。类似地，小的网络层尺寸可能不能充分利用GPU的计算能力。

此外，可能需要特别编译一些深度学习发行版来提供对诸如AVX2之类的硬件特性的支持（注意，ND4J的最新版本封装有支持这些特性的CPU的二进制文件）。当运行基准时，这些特征的利用（或缺乏）会对性能造成相当大的差异。

准则 6: 让它可重现

当运行基准测试时，重要的是使基准测试可重现。为什么？好或坏的表现可能只在某些有限的情况下发生。

最后，记住（a）ND4J和DL4J在不断发展，（b）基准测试有时的确会识别性能瓶颈（毕竟我们-ND4J实际上包括数百个不同的操作）。如果你确定了性能瓶颈，我们很想知道它，这样我们可以修复它。每当发现一个潜在的瓶颈时，我们首先需要重现它—这样我们就可以研究它、理解它并最终修复它。

准则 7: 理解你的基准测试的局限

线性代数库包含数百个不同的操作。神经网络库包含几十种层类型。当基准测试时，了解这些基准测试的局限性是很重要的。对一个类型的操作或层进行基准测试不能告诉你关于其他类型层或操作的任何性能，除非它们共享已被识别为性能瓶颈的代码。

准则 8: 如果你不确定 - 咨询

DL4J/ND4J开发者可在Gitter上使用。你可以在那里问一些关于基准测试和性能的问题: https://gitter.im/deeplearning4j/deeplearning4j

如果你碰巧发现一个性能问题-让我们知道！

ND4J 特定的基准测试

一个关于BLAS和数组顺序的标注

BLAS或基本线性代数子程序-是指用于线性代数运算的接口和方法集。一些例子包括“gemm”-通用矩阵乘法和“axpy”，它实现了Y = a*X+Y.

ND4J可以使用多个BLAS实现，1.0.0-beta版本及以上已经默认为OpenBLAS。然而，如果安装了英特尔MKL(这里提供免费版本)，ND4J将与其链接，以提高许多BLAS操作的性能。

注意ND4J在初始化的时候会打印在后台使用的BLAS信息，例如:

14:17:34,169 INFO  ~ Loaded [CpuBackend] backend
14:17:34,672 INFO  ~ Number of threads used for NativeOps: 8
14:17:34,823 INFO  ~ Number of threads used for BLAS: 8
14:17:34,831 INFO  ~ Backend used: [CPU]; OS: [Windows 10]
14:17:34,831 INFO  ~ Cores: [16]; Memory: [7.1GB];
14:17:34,831 INFO  ~ Blas vendor: [OPENBLAS]

性能取决于可用的BLAS库—在内部测试中，我们发现OpenBLAS比MKL快30%或慢8倍——这取决于阵列大小和数组顺序。

考虑到数组顺序，这也是影响性能的重要因素。ND4J有可能行优先(‘c’)也有可能列优先 (‘f’) 顺序呈现数组。查看这个维基百科页面 获取更多详情。矩阵乘法操作的性能和更通用的ND4J操作-取决于输入和结果顺序。

对于矩阵乘法，这意味着存在8个数组顺序的可能组合（对于输入1、输入2和结果阵列中的每个都为c/f）。对于所有的情况，性能都是不一样的。

类似地，对于某些输入顺序的组合，诸如逐元素相加(即，z=x+y)的操作将比其他操作快得多，尤其是当x、y和z都是相同顺序时。简而言之，这是由于内存跨步造成的：当这些内存地址在存储器中彼此相邻时，读取一系列内存地址要比分散到很远的地方成本更低。

注意，在缺省情况下，ND4J期望结果数组（用于矩阵乘法）按照列优先（“f”）顺序定义，以便在后端保持一致，因为CuBLAS（即，NVIDIA的用于CUDA的BLAS库）要求结果为f顺序。因此，与用“f”顺序数组执行相同操作相比，用结果数组按c顺序执行矩阵乘法的一些方法性能更低。

最后，当说到CUDA：数组顺序/跨步比在CPU上运行更重要。例如某些顺序组合可以比其他组合快得多-当输入输出的维度是32 或64的偶数倍的时候要比不是32的偶数倍的时候快（有时候快得多）。

DL4J 特定的基准测试

对于ND4J所说的大部分也适用于DL4J。

另外:

1. 如果你正在使用nd4j-native (CPU) 后台，确保你正在使用 Intel MKL。在多数情况下这比默认的OpenBLAS要快。

2. 如果你正在使用CUDA, 确保你正在使用 CuDNN (链接

3. 检查工作间和内存向导。默认值通常是很好的，但有时可以通过调整来获得更好的性能。如果在训练时内存中有很多Java对象（例如，Word2VEC向量），这一点尤其重要。

4. 注意ETL瓶颈。你可以在网络训练中添加PerformanceListener以查看ETL是否是瓶颈。

5. 别忘了性能取决于小批量的大小。不要使用微批量为1用来基准测试-使用更真实的数字。

6. 如果你需要多GPU 训练或推理 ，请使用ParallelWrapper 或ParallelInference。

7. 别忘了CuDNN 是可配置的: 你可以指定 DL4J/CuDNN 来获取更好的性能 -以内存消耗为代价 - 在卷积层上使用 .cudnnAlgoMode(ConvolutionLayer.AlgoMode.PREFER_FASTEST)配置

8. 当使用 GPU的时候, 对于输入大小或层的大小 8 (或 32) 的倍数可能性能更好。

9. 当使用 RNNs (并且手动创建INDArrays), 为特征和(RnnOutputLayer) 标签使用 ‘f’ 有序数组. 否则，使用“C”有序数组。这是为了更快的内存访问。

常见的基准测试错误

最后，这里列出了常见的基准测试错误：

1. 没有使用ND4J/DL4J的最新版本（没有发现瓶颈，因为在前几个版本就已经修复）。考虑尝试快照以获得最新的性能改进。

2. 没有注意正在使用什么本地库(MKL, OpenBLAS, CuDNN 等)

3. 在基准测试开始之前没有提供预热期

4. 只运行一个（或很少）的迭代，或没有报告均值，方差和迭代次数。

5. 没有配置工作间，垃圾回收等。

6. 只运行一种可能的情况-例如，在BLAS基准测试操作中对一单个数组维度/顺序集合进行基准测试。

7. 运行异常小的输入-例如，在GPU上微批次大小为1（这可能是慢的，但不真实！）

8. 不精确地测量，只测量你要测量的（例如，不考虑数组分配、初始化或垃圾收集时间）

9. 没有让你的基准测试可重现（基准结测试论可归纳吗？基准测试有问题吗？我们能做些什么来修复它？）

10. 跨硬件来比较结果，没有计算差异（例如，一个在带有AVX2的机器上测试，一个在没有AVX2的机器上测试）

11. 没有咨询开发者（通过DL4J/ND4J 极客频道） 我们很高兴提供建议和对性能不正常时进行调查。

如何运行Deeplearning4j 基准测试 - 指南

总训练时间通常是ETL时间加上计算时间 。也就是说，数据管道和矩阵操作一起决定了神经网络在数据集上训练的时间。

当一个熟悉Python的程序员试图将 Deeplearning4j基准测试与著名的Python框架的基准测试进行比较，他们通常在DL4J上用ETL+计算时间与Python框架的计算时间作为比较。那就是说，他们在用苹果与桔子作比较。下面我们将解释如何优化一些参数。

JVM有调整的旋钮，如果你知道如何调整它们，你可以使它成为一个非常快速的深度学习环境。在JVM上有几件事要牢记。你需要：

• 增加堆空间

• 让垃圾回收正确

• 让ETL异步进行

• 预保存数据集

堆空间设置

用户必须自己重新配置JVM，包括设置堆空间。我们不能把预先配置好的给你，但是我们可以告诉你怎么做。这里是堆空间的两个最重要的旋钮。

• Xms 设置最小的堆空间

• Xmx 设置最大的推空间

你可以将这些设置在IntelliJ和Eclipse等IDE中，也可以通过客户端这样设置：

    java -Xms256m -Xmx1024m YourClassNameHere

在 IntelliJ中，这是一个虚拟机参数, 不是一个程序参数。当你在IntelliJ中点击（绿色按钮）运行时，会设置运行时配置。IJ以你指定的配置启动Java VM。

设置XMX的理想量是多少？这取决于计算机上有多少RAM。一般来说，按照JVM需要完成的任务分配尽可能多的堆空间。假设你在一个16G RAM的笔记本电脑上，向JVM分配8G的RAM。更小RAM的笔记本应设为3G，所以

    java -Xmx3g

这似乎是违反直觉的，但你希望堆空间最小值和堆空间最大值是相同的，即Xms应该等于Xmx。如果它们不相等，JVM将根据需要逐步分配更多的内存，直到达到最大值，并且逐渐分配的过程会减慢速度。你希望在开始时预先分配它。所以

    java -Xms3g -Xmx3g YourClassNameHere

IntelliJ 将自动指定所涉及的 Java 主类 。

另一种方法是设置环境变量。在这里，你将更改隐藏的.bash_profile文件，它将环境变量添加到BASH中。若要查看这些变量，请在命令行中输入env。若要添加更多的堆空间，请在控制台中输入此命令：

    echo "export MAVEN_OPTS="-Xmx512m -XX:MaxPermSize=512m"" > ~/.bash_profile

我们需要增加堆空间，因为Deeplearning4j在后台加载数据，这意味着我们在内存中占用更多的RAM。通过为JVM提供更多的堆空间，我们可以在内存中缓存更多的数据。

垃圾回收

垃圾回收器是在JVM上运行并清除Java应用程序不再使用的对象的程序。它是自动内存管理。在Java中创建一个新对象占用堆内存：默认情况下，一个新的Java对象占用8字节的内存。因此，创建的每个新的DatasetIterator都需要额外8个字节。

你可能需要更改Java正在使用的垃圾回收算法。这可以通过命令行完成，例如：

    java -XX:+UseG1GC

更好的垃圾收集算法增加了吞吐量。关于这个问题的更详细的探索，请阅读这篇InfoQ 文章。

DL4J与垃圾回收器紧密相连。JavaCPP是JVM和C++之间的桥梁，它遵循你用Xmx设置的堆空间，并广泛使用堆外内存。堆外内存不会超过指定的堆空间。

JavaCPP，由Skymind工程师创建，依赖于垃圾回收器告诉它什么已经完成。我们依赖Java垃圾回收器告诉我们什么要被收集；Java垃圾回收器指向我们知道如何用JavaCPP去销毁它们的对象。这同样适用于我们如何使用GPU。

你使用的批次越大，内存占用的RAM越多。

ETL & 异步ETL

在我们的dl4j-examples中，我们没有使用异步的ETL，因为我们的目标是让它们更简单。但对于真实问题，你需要使用异步的ETL，我们将在示例中展示如何使用它。

数据存储在磁盘上，磁盘速度慢，这是默认的。因此，当将数据加载到硬盘上时，会遇到瓶颈。当优化吞吐量时，最慢的组件始终是瓶颈。例如，使用三GPU的机器和一个CPU的机器分布式spark作业将有CPU瓶颈。GPU必须等待CPU完成。

Deeplearning4j 的 DatasetIterator 类隐藏了从磁盘加载数据的复杂性。用于任何Datasetiterator的代码通常是一样的，调用看上去是一样的，但它们以不同的方式工作。

• 一个从磁盘加载

• 一个异步加载

• 一个从RAM加载预保存的数据

下面是对于MISIST如何统一调用DatasetIterator的方法：

        while(mnistTest.hasNext()){
                DataSet ds = mnistTest.next();
                INDArray output = model.output(ds.getFeatures(), false);
                eval.eval(ds.getLabels(), output);
        }

你可以通过在后台使用一个异步加载器来优化。Java可以实现真正的多线程。它可以在后台加载数据，而其他线程则负责计算。因此，你正在运行计算的同时，将数据加载到GPU中。甚至当你从内存中获取新数据时，神经网络也在进行训练。

这是 相关代码，第三行比较特殊:

    MultiDataSetIterator iterator;
    if (prefetchSize > 0 && source.asyncSupported()) {
        iterator = new AsyncMultiDataSetIterator(source, prefetchSize);
    } else iterator = source;

实际上有两种类型的异步数据集迭代器。“AsyncDataSetIterator”是你在大多数时间使用的。它在 Javadoc 中被描述。

对于特殊情况，如应用于时间序列的循环神经网络，或用于计算图，你将使用一个 AsyncMultiDataSetIterator, 在 Javadoc 中被描述。

在上面的代码中注意，prefetchSize是另一个要设置的参数。正常的批大小可能是1000个示例，但是如果将prefetchSize设为3，它将预获取3000个实例。

ETL: Python框架与Deeplearning4j对比

在Python中，程序员将它们的数据转换为泡菜或二进制数据对象。如果他们用一个小玩具数据集工作，他们将所有的泡菜装入RAM中。因此，它们有效地归避了处理较大数据集的主要任务。同时，当对DL4J进行基准测试时，它们不将所有数据加载到RAM上。所以他们实际上将Dl4j的训练计算+ETL的时间与Python框架的训练计算时间进行了比较。

但是Java有强大的工具来移动大数据，如果比较正确，比Python快得多。Deeplearning4j社区报告说，在优化ETL和计算时，与Python框架相比，Deeplearning4j速度提高了3700%。

Deeplearning4j使用DataVec作为ETL和向量化库。与其他深度学习工具不同，DataVec不强制数据集是一种特定格式。（例如，Caffe强制你使用hdf5）。

我们试着变得更灵活。这意味着你可以将DL4J指向原始照片，它会加载图像、运行转换并将其放入NDArray中动态生成数据集。

但是如果但如果你的训练管道每次都这样做，Deeplearning4j看起来会比其他框架慢10倍，因为你把时间花费在了创建数据集上。每次你调用“fit”，你都会一遍又一遍地创建数据集。为了方便我们允许这样使用它，但是我们可以告诉你如何加快速度。有多种办法使它变快。

一种类似于Python框架的方式预先保存数据集的方法。（泡菜是预先格式化的数据）。当你预先保存数据集时，你将创建一个单独的类。

这里你是如何 预保存数据集 的例子

Recordreaderdatasetiterator 与 Datavec 交互并为DL4J输出数据。

这里是你如何 加载预保存数据 的例子。

第90行是你看到异步ETL的地方。在本例中，它包装了预先保存的迭代器，因此你可以利用这两种方法，通过异步将预先保存的数据加载到后台作为网络训练。

CPU上的MKL和推理

如果您在CPU上运行推理基准测试，请确保你正在和Intel的MKL库一起使用Deeplearning4j，该库可以通过单击安装包获得；即，Deeplearning4j不像Anaconda那样捆绑MKL，Anaconda是PyTorch等库使用的。

介绍

ND4J是JVM的科学计算库。它是用来在生产环境中使用的，而不是作为一个研究工具，这意味着常规的设计是为了以最低的RAM需求快速运行。主要特点是：

• 一个多功能的n维数组对象。

• 线性代数和信号处理函数。

• 多平台功能，包括GPU。

  • 所有主要操作系统: win/linux/osx/android.

  • 架构: x86, arm, ppc.

此快速入门遵循与Numpy快速入门相同的布局和方法。这将帮助熟悉Python和Numpy的人快速开始使用Nd4J。

先决条件

您可以从任何JVM语言中使用Nd4J。（例如：Scala、Kotlin）。可以将Nd4J与任何构建工具一起使用。此快速入门中的示例代码使用以下内容：

• Java (developer version) 1.7或更高版本（仅支持64位版本）

• Apache Maven (自动构建和依赖关系管理器)

• Git (分布式版本控制系统)

为了提高可读性，我们向您展示System.out.println(...)的输出。但是我们还没有在示例代码中显示print语句。如果您有信心知道如何使用maven和git，请随时跳到基础部分。在本节的其余部分中，我们将构建一个小型的“hello ND4J”应用程序，以验证先决条件设置是否正确。

执行以下命令从github获取项目。

git clone https://github.com/RobAltena/HelloNd4J.git

cd HelloNd4J

mvn install

mvn exec:java -Dexec.mainClass="HelloNd4j"

当一切设置正确时，您应该看到以下输出：

[         0,         0]

基础

Nd4j的主要特点是具有多功能的n维阵列接口INDArray。为了提高性能，Nd4j使用堆外内存来存储数据。INDArray不同于标准Java数组。

INDArray x的一些关键属性和方法如下：

import org.nd4j.linalg.factory.Nd4j;
import org.nd4j.linalg.api.buffer.DataType;

INDArray x = Nd4j.zeros(3,4);

// 数组的轴数（维度）。
int dimensions = x.rank();

// 数组的维数。每个维度的大小。
long[] shape = x.shape();

// 元素的总数。
long length = x.length();

// 数组元素的类型。 
DataType dt = x.dataType();

数组创建

要创建INDArray，可以使用Nd4j类的静态工厂方法。

Nd4j.createFromArray函数被重载，以便于从常规Java数组创建INDArrays。下面的示例使用Javadouble数组。类似的create方法对于float、int和long重载。对于所有类型，Nd4j.createFromArray函数都有高达4d的重载。

double arr_2d[][]={{1.0,2.0,3.0},{4.0,5.0,6.0},{7.0,8.0,9.0}};
INDArray x_2d = Nd4j.createFromArray(arr_2d);

double arr_1d[]={1.0,2.0,3.0};
INDArray  x_1d = Nd4j.createFromArray(arr_1d);

Nd4j可以使用函数zeros和ones创建用0和1初始化的数组。rand函数允许您创建用随机值初始化的数组。创建的INDArray的默认数据类型是float。有些重载允许您设置数据类型。

INDArray  x = Nd4j.zeros(5);
//[         0,         0,         0,         0,         0], FLOAT

int [] shape = {5};
x = Nd4j.zeros(DataType.DOUBLE, 5);
//[         0,         0,         0,         0,         0], DOUBLE

// 对于更高的维度，可以提供形状数组。二维随机矩阵示例：
int rows = 4;
int cols = 5;
int[] shape = {rows, cols};
INDArray x = Nd4j.rand(shape);

使用arange函数创建一个均匀空间值数组：

INDArray  x = Nd4j.arange(5);
// [         0,    1.0000,    2.0000,    3.0000,    4.0000]

INDArray  x = Nd4j.arange(2, 7);
// [    2.0000,    3.0000,    4.0000,    5.0000,    6.0000]

linspace函数允许您指定生成的点数：

//开始数, 停止数, 个数.
INDArray  x = Nd4j.linspace(1, 10, 5); 
// [    1.0000,    3.2500,    5.5000,    7.7500,   10.0000]

// 对函数进行多点评估。
import static org.nd4j.linalg.ops.transforms.Transforms.sin;
INDArray  x = Nd4j.linspace(0.0, Math.PI, 100, DataType.DOUBLE);
INDArray  y = sin(x);

打印数组

INDArray支持Java的toString()方法。当前的实现具有有限的精度和有限的元素数。输出类似于打印NumPy数组：

//1维数组
INDArray  x = Nd4j.arange(6);
//我们现在只给出print命令的输出。
System.out.println(x);  
// [         0,    1.0000,    2.0000,    3.0000,    4.0000,    5.0000]

int [] shape = {4,3};
//2维数组
x = Nd4j.arange(12).reshape(shape);   
/*
[[         0,    1.0000,    2.0000], 
 [    3.0000,    4.0000,    5.0000], 
 [    6.0000,    7.0000,    8.0000], 
 [    9.0000,   10.0000,   11.0000]]
*/

int [] shape2 = {2,3,4};
//3维数组
x = Nd4j.arange(24).reshape(shape2); 
/*
[[[         0,    1.0000,    2.0000,    3.0000], 
  [    4.0000,    5.0000,    6.0000,    7.0000], 
  [    8.0000,    9.0000,   10.0000,   11.0000]], 

 [[   12.0000,   13.0000,   14.0000,   15.0000], 
  [   16.0000,   17.0000,   18.0000,   19.0000], 
  [   20.0000,   21.0000,   22.0000,   23.0000]]]
*/

基本操作

必须使用INDArray方法对数组执行操作。有就地（in-place）和复制重载、标量和元素级重载版本。就地（in-place）运算符返回对数组的引用，因此可以方便地将操作链接在一起。尽可能使用就地（in-place）运算符来提高性能。复制运算符有新的数组创建开销。

//复制
//返回一个新数组，并将标量添加到arr的每个元素。
arr_new = arr.add(scalar);  
//返回一个新数组，它是arr和其他arr元素级别的加法。  
arr_new = arr.add(other_arr); 

//就地
arr_new = arr.addi(scalar); 
arr_new = arr.addi(other_arr);

加法: arr.add(...), arr.addi(...) 减法: arr.sub(...), arr.subi(...) 乘法: arr.mul(...), arr.muli(...) 除法 : arr.div(...), arr.divi(...)

执行基本操作时，必须确保基础数据类型相同。

int [] shape = {5};
INDArray  x = Nd4j.zeros(shape, DataType.DOUBLE);
INDArray  x2 = Nd4j.zeros(shape, DataType.INT);
INDArray  x3 = x.add(x2);
// java.lang.IllegalArgumentException: Op.X 和 Op.Y must have the same data type, but got INT vs DOUBLE

// 将x2转换为DOUBLE可以解决以下问题：
INDArray x3 = x.add(x2.castTo(DataType.DOUBLE));

INDArray有实现缩减/累加操作的方法，如 sum, min, max.

int [] shape = {2,3};
INDArray  x = Nd4j.rand(shape);
x;
x.sum();
x.min();
x.max();
/*
[[    0.8621,    0.9224,    0.8407], 
 [    0.1504,    0.5489,    0.9584]]
4.2830
0.1504
0.9584
*/

提供维度参数以在指定维度上应用操作：

INDArray x = Nd4j.arange(12).reshape(3, 4);
/*
[[         0,    1.0000,    2.0000,    3.0000], 
 [    4.0000,    5.0000,    6.0000,    7.0000], 
 [    8.0000,    9.0000,   10.0000,   11.0000]]
*/        

//每列的总和。
x.sum(0); 
//[   12.0000,   15.0000,   18.0000,   21.0000]

//每行最小值
x.min(1); 
//[         0,    4.0000,    8.0000]

//每行的累计和，
x.cumsum(1); 
/*
[[         0,    1.0000,    3.0000,    6.0000], 
 [    4.0000,    9.0000,   15.0000,   22.0000], 
 [    8.0000,   17.0000,   27.0000,   38.0000]]
*/

转换操作

Nd4j提供熟悉的数学函数，如sin、cos和exp，这些称为转换操作。结果作为INDArray返回。

import static org.nd4j.linalg.ops.transforms.Transforms.exp;
import static org.nd4j.linalg.ops.transforms.Transforms.sqrt;

INDArray x = Nd4j.arange(3);
// [         0,    1.0000,    2.0000]
exp(x);
// [    1.0000,    2.7183,    7.3891]
sqrt(x);
// [         0,    1.0000,    1.4142]

您可以在Javadoc中查看转换操作的完整列表

矩陈乘法

我们已经在基本操作中看到了元素的乘法运算。其他矩阵运算有自己的方法：

INDArray x = Nd4j.arange(12).reshape(3, 4);
/*
[[         0,    1.0000,    2.0000,    3.0000], 
 [    4.0000,    5.0000,    6.0000,    7.0000], 
 [    8.0000,    9.0000,   10.0000,   11.0000]]
*/

INDArray y = Nd4j.arange(12).reshape(4, 3);
/*
[[         0,    1.0000,    2.0000], 
 [    3.0000,    4.0000,    5.0000], 
 [    6.0000,    7.0000,    8.0000], 
 [    9.0000,   10.0000,   11.0000]]
*/
// 矩阵乘积.
x.mmul(y);  
/*
[[   42.0000,   48.0000,   54.0000], 
 [  114.0000,  136.0000,  158.0000], 
 [  186.0000,  224.0000,  262.0000]]
*/

//点积
INDArray x = Nd4j.arange(12);
INDArray y = Nd4j.arange(12);
dot(x, y);  
//506.0000

索引、切片和迭代

索引、切片和迭代在Java中比Python更困难。 要从INDArray检索单个值，可以使用getDouble、getFloat或getInt方法。INDArrays不能像Java数组那样被索引。可以使用toDoubleVector()、toDoubleMatrix()、toFloatVector()和toFloatMatrix()从INDArray获取Java数组。

INDArray x = Nd4j.arange(12);
// [         0,    1.0000,    2.0000,    3.0000,    4.0000,    5.0000,    6.0000,    7.0000,    8.0000,    9.0000,   10.0000,   11.0000]
//单一元素访问。其他方法: getDouble, getInt, ...
float f = x.getFloat(3);  
// 3.0
//转换为Java数组。
float []  fArr = x.toFloatVector();
// [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0]

INDArray x2 = x.get(NDArrayIndex.interval(2, 6));
// [    2.0000,    3.0000,    4.0000,    5.0000]


//在x的副本上：从开始到位置6（不包括），将每2个元素设置为-1.0
INDArray y = x.dup();
y.get(NDArrayIndex.interval(0, 2, 6)).assign(-1.0);
//[   -1.0000,    1.0000,   -1.0000,    3.0000,   -1.0000,    5.0000,    6.0000,    7.0000,    8.0000,    9.0000,   10.0000,   11.0000]

//y的反向副本。
INDArray y2 = Nd4j.reverse(y.dup());
//[   11.0000,   10.0000,    9.0000,    8.0000,    7.0000,    6.0000,    5.0000,   -1.0000,    3.0000,   -1.0000,    1.0000,   -1.0000]

对于多维数组，应该使用INDArray.get(NDArrayIndex...)。下面的示例演示如何遍历二维数组的行和列。注意，对于2D数组，我们可以使用getColumn和getRow便利方法。

// 在2d数组的行和列上迭代。
int rows = 4;
int cols = 5;
int[] shape = {rows, cols};

INDArray x = Nd4j.rand(shape);
/*
[[    0.2228,    0.2871,    0.3880,    0.7167,    0.9951], 
 [    0.7181,    0.8106,    0.9062,    0.9291,    0.5115], 
 [    0.5483,    0.7515,    0.3623,    0.7797,    0.5887], 
 [    0.6822,    0.7785,    0.4456,    0.4231,    0.9157]]
*/

for (int row=0; row<rows; row++) {
    INDArray y = x.get(NDArrayIndex.point(row), NDArrayIndex.all());
    }
/*
[    0.2228,    0.2871,    0.3880,    0.7167,    0.9951]
[    0.7181,    0.8106,    0.9062,    0.9291,    0.5115]
[    0.5483,    0.7515,    0.3623,    0.7797,    0.5887]
[    0.6822,    0.7785,    0.4456,    0.4231,    0.9157]
*/

for (int col=0; col<cols; col++) {
    INDArray y = x.get(NDArrayIndex.all(), NDArrayIndex.point(col));
    }
/*
[    0.2228,    0.7181,    0.5483,    0.6822]
[    0.2871,    0.8106,    0.7515,    0.7785]
[    0.3880,    0.9062,    0.3623,    0.4456]
[    0.7167,    0.9291,    0.7797,    0.4231]
[    0.9951,    0.5115,    0.5887,    0.9157]
*/

形状操作

改变数组的形状

沿着每个轴的元素的数量是形状。形状可以用各种方法改变。

INDArray x = Nd4j.rand(3,4);
x.shape();
// [3, 4]

INDArray x2 = x.ravel();
x2.shape();
// [12]

INDArray x3 = x.reshape(6,2).shape();
x3.shape();
//[6, 2]

//注意x、x2和x3共享相同的数据。 
x2.putScalar(5, -1.0);

System.out.println( x);
/*
[[    0.0270,    0.3799,    0.5576,    0.3086], 
 [    0.2266,   -1.0000,    0.1107,    0.4895], 
 [    0.8431,    0.6011,    0.2996,    0.7500]]
*/

System.out.println( x2);
// [    0.0270,    0.3799,    0.5576,    0.3086,    0.2266,   -1.0000,    0.1107,    0.4895,    0.8431,    0.6011,    0.2996,    0.7500]

System.out.println( x3);
/*        
[[    0.0270,    0.3799], 
 [    0.5576,    0.3086], 
 [    0.2266,   -1.0000], 
 [    0.1107,    0.4895], 
 [    0.8431,    0.6011], 
 [    0.2996,    0.7500]]
*/

将不同的数组堆叠在一起

可以使用vstack和hstack方法将数组堆叠在一起。

INDArray x = Nd4j.rand(2,2);
INDArray y = Nd4j.rand(2,2);

x
/*
[[    0.1462,    0.5037], 
 [    0.1418,    0.8645]]
*/

y;
/*
[[    0.2305,    0.4798], 
 [    0.9407,    0.9735]]
*/

Nd4j.vstack(x, y);
/*
[[    0.1462,    0.5037], 
 [    0.1418,    0.8645], 
 [    0.2305,    0.4798], 
 [    0.9407,    0.9735]]
*/

Nd4j.hstack(x, y);
/*
[[    0.1462,    0.5037,    0.2305,    0.4798], 
 [    0.1418,    0.8645,    0.9407,    0.9735]]
*/

副本和视图

使用INDArrays时，并不总是复制数据。这里有三种情况你应该注意。

完全没有复制

简单的指派不会复制数据。Java通过引用传递对象。在方法调用上不生成任何副本。

INDArray x = Nd4j.rand(2,2);
//y和x指向同一个INDArray对象。
INDArray y = x; 

public static void f(INDArray x){
   //没有副本。对x的任何更改在函数调用之后都是可见的。
}

视图或浅复制

一些函数将返回数组的视图。

INDArray x = Nd4j.rand(3,4);
INDArray  x2 = x.ravel();
INDArray  x3 = x.reshape(6,2);

// 修改 x, x2 和 x3
x2.putScalar(5, -1.0); 

x
/*
[[    0.8546,    0.1509,    0.0331,    0.1308], 
 [    0.1753,   -1.0000,    0.2277,    0.1998], 
 [    0.2741,    0.8257,    0.6946,    0.6851]]
*/

x2
// [    0.8546,    0.1509,    0.0331,    0.1308,    0.1753,   -1.0000,    0.2277,    0.1998,    0.2741,    0.8257,    0.6946,    0.6851]

x3
/*
[[    0.8546,    0.1509], 
 [    0.0331,    0.1308], 
 [    0.1753,   -1.0000], 
 [    0.2277,    0.1998], 
 [    0.2741,    0.8257], 
 [    0.6946,    0.6851]]
*/

深考贝

要复制数组，请使用dup方法。这将为您提供一个包含新数据的新数组。

INDArray x = Nd4j.rand(3,4);
INDArray  x2 = x.ravel().dup();

//现在只改变x2。
x2.putScalar(5, -1.0); 
x
/*
[[    0.1604,    0.0322,    0.8910,    0.4604], 
 [    0.7724,    0.1267,    0.1617,    0.7586], 
 [    0.6117,    0.5385,    0.1251,    0.6886]]
*/

x2
// [    0.1604,    0.0322,    0.8910,    0.4604,    0.7724,   -1.0000,    0.1617,    0.7586,    0.6117,    0.5385,    0.1251,    0.6886]

功能和方法概述

数组创建

arange, create, copy, empty, empty_like, eye, linspace, meshgrid, ones, ones_like, rand, readTxt, zeros, zeros_like

转换

convertToDoubles, convertToFloats, convertToHalfs

操作

concatenate, hstack, ravel, repeat, reshape, squeeze, swapaxes, tear, transpose, vstack

排序

argmax, max, min, sort

操作

choice, cumsum, mmul, prod, put, putWhere, sum

基本统计

covarianceMatrix, mean, std, var

基本线性代数

cross, dot, gesvd, mmul

SameDiff中的操作基本上是按照您预期的方式进行的。在我们的框架中，变量是SDVariable类型的对象，对它们执行apply操作，从而生成新的变量。在对可用操作进行概述之前，让我们列出它们的一些公共属性。

操作的一般属性

• 任何变量类型的变量都可以在任何操作中使用，只要它们的数据类型与操作所需的数据类型匹配（同样，请参阅变量部分了解变量类型）。大多数情况下，操作将要求其SDVariable具有浮点数据类型。

• 由操作创建的变量具有ARRAY变量类型。

• 对于所有操作，您可以定义结果变量的字符串名称，尽管对于大多数操作，这不是必需的。名称作为每个操作中的第一个参数，如下所示：

  Copy

  SDVariable linear = weights.mmul("matrix_product", input).add(bias); 
  SDVariable output = sameDiff.nn.sigmoid("output", linear);

  可以使用SameDiff方法getVariable(String name)从外部访问命名变量。对于上面的代码，此方法将允许您推断output和mmul操作的结果。注意我们 甚至没有显式地将此结果定义为单独的SDVariable，但是相应的SDVariable将在内部创建并添加到SameDiff的实例中，字符串名为“matrix_product”。事实上字符串名称是为操作生成的每个SDVariable指定的：如果不显式指定名称，则会根据操作的名称自动将其指定给生成的SDVariable。

操作概览

当前可用的操作的数量，包括重载总计数百，它们按复杂度排序，从通过卷积层产生输出的简单加法和乘法到创建专用的循环神经网络模块，以及更多。操作的数量之多会使得将它们全部列在一页上变得很麻烦。因此，如果您已经在寻找特定的东西，那么最好检查我们的javadoc，它已经包含了每个操作的详细信息，或者只需浏览自动完成提示（如果您的IDE支持的话）。在这里，我们试图给你一个主意，你可能会找到什么样的行动，并在哪里寻找他们。

所有操作可以分为两个主要分支：SDVariable方法和SameDiff类方法。让我们仔细看看每一个：

SDVariable 操作

我们已经在前面的例子中看到了SDVariable操作，比如

SDVariable z = x.add(y);

其中x和y是SDVariable的。

在SDVariable方法中，您将发现：

• 执行线性代数的BLAS类型操作：例如add, neg, mul （用于缩放和元素相乘）和mmul（矩阵相乘）、dot、rdiv等。；

• 比较操作，如gt或lte，用于将每个元素与固定的双精度值进行比较，以及与相同形状的另一个SDVariable进行元素级比较；

• 基本缩减运算：如min、sum、prod（数组中元素的乘积）、mean、norm2、argmax（最大元素的索引）、squaredDifference，可以沿着指定的维度进行；

• 计算给定尺寸的平均值和标准差的基本统计操作：平均值和标准差。

• 重组底层数组的操作：reshape和permute，以及shape——一个将变量的形状作为整数数组传递的操作——维度大小；

SDVariable 操作很容易链接，生产线如下：

SDVariable regressionCost = weights.mmul(input).add("regression_prediction", bias).squaredDifference(labels);

SameDiff 操作

SameDiff方法的操作是通过每一个SameDiff中存在的6个辅助对象之一调用的，该操作将所有操作分割成6个不均匀分支：

• math - 一般数学运算；

• random - 创建不同的随机数生成器；

• nn - 通用神经网络工具；

• cnn - 卷积神经网络工具；

• rnn - 循环神经网络工具；

• loss - 损失函数;

  为了使用特定的操作，您需要从SameDiff实例调用这6个对象中的一个，然后调用操作本身，如下所示：

  Copy

  SDVariable y = sameDiff.math.sin(x);

  或

  Copy

  SDVariable y = samediff.math().sin(x);

辅助对象之间的操作分布在结构上不具有更直观的方式来组织事物。所以，举个例子，如果你不确定是在math还是nn中寻找tanh运算，不用担心：我们都有。

让我们简要描述一下您希望在每个分支中找到的操作类型：

math - 基本数学运算

数学模块主要由通用数学函数和统计方法组成。其中包括：

• 幂函数，例如 square, cube, sqrt, pow, reciprocal 等;

• 三角函数，例如。 sin, atan 等;

• 指数/双曲函数，如 exp, sinh, log, atanh 等;

• 各种各样的元素操作，比如取绝对值、舍入和剪裁，比如 abs, sign, ceil, round, clipByValue, clipByNorm 等;

• 指定维度的缩减: min, amax, mean, asum, logEntropy, 以及类似的;

• distance (reduction) operations, such as距离缩减操作，例如 euclideanDistance, manhattanDistance, jaccardDistance, cosineDistance,

  hammingDistance, cosineSimilarity, 沿指定维度，对于两个形状相同的 SDVariables;

• 特定矩阵运算: matrixInverse, matrixDeterminant, diag (创建对角矩阵), trace, eye

  (变维恒等式矩阵的建立), 和一些其它的;

• 更多统计操作: standardize, moment, normalizeMoments, erf 和 erfc (高斯误差函数及其互补);

• 计数和索引缩减：类似方法 conuntZero (零元素数字), iamin (具有最小绝对值的元素的索引), firstIndex （满足指定Condition函数的第一元素的索引）；

• 表示底层数组属性的缩减。这些包括例如。 isNaN (按元素检查), isMax

  （沿指定维度保持形状）, isNonDecreasing (沿指定维度缩减);

• 元素逻辑操作： and, or, xor, not.

math中的大多数运算都有非常简单的结构，并且是这样推断的：

SDVariable activation = sameDiff.math.cube(input);

操作可以是链式的，尽管与SDVariable操作相比，其方式更为繁琐，例如：

SDVariable matrixNorm1 = sameDiff.math.max(sameDiff.math.sum(sameDiff.math.abs(matrix), 1));

观察到sum操作中的（整数）参数1告诉我们必须沿着1维，即矩阵的列取最大绝对值。

random - 创建随机值

这些操作创建变量，其基础数组将按某些分布填充随机数

• 比如，伯努利，正态，二项式等等。这些值将在每次迭代时重置。例如，如果希望创建一个变量，将高斯噪声添加到MNIST数据集的条目中，可以执行以下操作：

  Copy

  double mean = 0.;
  double deviation = 0.05;
  long[] shape = new long[28, 28];
  SDVariable noise_mnist = sameDiff.random.normal("noise_mnist", mean, deviation, shape);

  随机变量的形状可能会有所不同。例如，假设你有不同长度的音频信号，你想给它们添加噪声。然后，您需要指定一个SDVariable，例如，windowShape和一个整数数据类型，然后继续这样做

  Copy

  SDVariabel noise_audio = sameDiff.random.normal("noise_audio", mean, deviation, windowShape);

nn - 通用神经网络工具

这里我们存储的神经网络方法不一定与卷积的方法相关。其中包括

• 创建密连的线性层和ReLU层（带或不带偏置），并单独添加偏置：linear, reluLayer, biasAdd;

• 常用的激活函数，例如。 relu, sigmoid, tanh, softmax 以及使用较少的版本，如

  leakyRelu, elu, hardTanh, 还有更多；

• 使用pad方法填充的二维数组，支持多种填充类型，具有恒定和可变的填充宽度；

• 梯度爆炸/过拟合预防，如层dropout、layerNorm、batchNorm。批量归一化；

有些方法是为内部使用而创建的，但可以公开使用。其中包括：

• 一些流行的激活函数的导数-这些主要是为了加速反向传播；

• attention模块-基本上，我们将在下面讨论循环神经网络的构建模块。

虽然nn中的激活相当简单，但其他操作变得更加复杂。例如，要创建线性层或ReLU层，可能需要多达三个预定义的SDVariable对象，如下代码所示：

SDVariable denseReluLayer = sameDiff.nn.reluLayer(input, weights, bias);

其中input、weights和bias需要具有相互匹配的维度。

要创建具有softmax激活的密连层，可以按以下步骤进行：

SDVariable linear = sameDiff.nn.linear(input, weight, bias);
SDVariable output = sameDiff.nn.softmax(linear);

cnn - 卷积神经网络工具

cnn模块包含通常用于卷积神经网络的层和操作-可以从nn模块中提取不同的激活。在cnn的操作中，我们目前已经创建了：

• 线性卷积层，目前用于尺寸小于等于3的张量（不包括小批量）：conv1d, conv2d,

  conv3d, depthWiseConv2d, separableConv2D/sconv2d;

• 线性反卷积层，目前 deconv1d, deconv2d, deconv3d;

• 池化，例如 maxPoooling2D, avgPooling1D;

• 特殊变形方法： batchToSpace, spaceToDepth, col2Im 和类似的

• 上采样，目前由upsampling2d操作提出；

• 局部响应归一化：localResponseNormalization，目前仅用于二维卷积层；

卷积和反卷积操作由许多静态参数指定，如核大小、膨胀、有无偏置等。为了简化创建过程，我们将所需的参数打包成易于构造和更改的配置对象。所需的激活可以从nn模块借用。因此，例如，如果我们想要创建一个具有relu激活的3x3卷积层，我们可以如下进行：

Conv2DConfig config2d = new Conv2DConfig().builder().kW(3).kH(3).pW(2).pH(2).build();
SDVariable convolution2dLinear = sameDiff.cnn.conv2d(input, weights, config2d);
SDVariable convolution2dOutput = sameDiff.nn.relu(convolution2dLinear);

在第一行中，我们使用它的默认构造函数构造卷积配置。然后我们指定内核大小（这是必需的）和可选的填充大小，并保持其他默认设置（单位步幅、无伸缩、无偏置 、NCHW数据格式）。然后，我们使用此配置创建一个线性卷积，其中预定义了用于输入和权重的SDVariables；weights的形状将调整为input和预先config的形状。因此，在上面的例子中，如果input有形状，比如说，[-1，nIn，height，width]，那么weights的形式就是[nIn，nOut，3，3]（因为我们有3x3卷积核）。结果变量convoluton2d的形状将由这些参数预先确定（在我们的情况下，它将是[-1，nOut，height，width]）。最后，在最后一行中，我们应用relu激活。

rnn - 循环神经网络

这个模块可以说包含了框架中最复杂的方法。目前它允许您创建

• 简单循环单元，使用 sru 和 sruCell 方法;

• LSTM 单元，使用 lstmCell, lstmBlockCell 和 lstmLayer;

• Graves LSTM 单元，使用 gru 方法。

到目前为止，循环操作需要特殊的配置对象作为输入，在这些对象中，您需要打包将在一个单元中使用的所有变量。这可能会在以后的版本中发生更改。例如，要创建一个简单的循环单元，您需要这样进行：

SRUConfiguration sruConfig = new SRUConfiguration(input, weights, bias, init);
SDVariable sruOutput = samediff.rnn().sru(sruConfig);

这里，SRUConfiguration构造函数中的参数是预先定义的变量。显然，它们的形状应该是匹配的，并且这些形状预先确定了output的形状。

loss - 损失函数

在这个分支中，我们保留了共同的损失函数。大多数损失函数可以非常简单地创建，例如：

SDVariable logLoss = sameDiff.loss.logLoss("logLoss", label, predictions);

其中labels和predictions是SDVariable的。在大多数loss方法中，字符串名称是必需的参数，但它可能被设置为空-在这种情况下，将自动生成名称。您还可以通过添加另一个包含权重的SDVariable参数来创建加权损失函数，并指定小批量损失的减少方法（见下文）。因此，一个全面的logLoss操作可能看起来像：

SDVariable wLogLossMean = sameDiff.loss.logLoss("wLogLossMean", label, predictions, weights, LossReduce.MEAN_BY_WEIGHT);

一些损失操作可能允许/需要进一步的参数，这取决于它们的类型：例如，计算损失的维度（如cosineLoss），或一些实数参数。

至于缩减方法，在小批中，目前有4种可用。因此，首先计算每个小批量样例的损失值，然后乘以权重（如果指定），最后执行下列程序之一：

• NONE - 保持结果（权重）损失值不变；结果是具有小批量长度的INDArray:sum_loss=sum(weights*loss_per_sample)。

• SUM - 对值求和，生成标量结果。

• MEAN_BY_WEIGHT - 首先计算上述总和，然后除以所有权重之和，生成标量值：mean_loss = sum(weights * loss_per_sample) / sum(weights)。 如果未指定权重，则将所有权重都设置为1.0，此缩减等于获得小批量的平均损失值。

• MEAN_BY_NONZERO_WEIGHT_COUNT - 将加权和除以非零权重的个数，生成标量：

  mean_count_loss = sum(weights * loss_per_sample) / count(weights != 0)。有用的，例如，当你只想计算有效样本子集的平均值时，将权重设置为0或1。当没有给出权重时，它只产生平均值，因此等价于MEAN_BY_WEIGHT。

操作注意事项

为了使SameDiff操作正常工作，需要遵守几个主要规则。如果不这样做，可能会导致异常，甚至会导致工作代码产生不希望的结果。我们在本节提到的所有事情都描述了什么是你最好不要做的。

• 一个操作中的所有变量都必须属于SamdeDiff的同一个实例（请参阅变量部分，了解如何将变量添加到SameDiff实例）。换句话说，你最好不要

  Copy

  SDVariable x = sameDiff0.var(DataType.FLOAT, 1);
  SDVariable y = sameDiff1.placeHolder(DataType.FLOAT, 1);
  SDVariable z = x.add(y);

• 充其量，为一个操作或一系列操作的结果创建一个新变量。换句话说，最好不要重新定义现有变量，最好不要让操作返回结果。换言之，尽量避免这样的代码：

  Copy

  SDVariable z = x.add(y);
  //DON'T!!!
  z.mul(2);
  x = z.mul(y);

  上述代码的正确工作版本（如果我们希望以一种不寻常的方式获得2xy+2y2）将是

  Copy

  SDVariable z = x.add(y);
  SDVariable _2z = z.mul(2);
  w = _2z.mul(y);

  要了解它为什么会这样工作，请参阅我们的图章节。

快速检索

DL4J（和相关项目）有很多功能。此篇的目标是总结这个功能，以便用户知道存在什么功能，以及在哪里可以找到更多信息。

内容

• 层

  • 前馈层

  • 输出层

  • 卷积层

  • 循环层

  • 无监督层

  • 其它层

  • 图顶点

  • 输入预处理器

• 迭代/训练监听器

• 评估

• 网络保存和加载

• 网络配置

  • 激活函数

  • 权重初始化

  • 更新器 (优化器)

  • 学习率调度

  • 正则化

    • L1/L2 正则化

    • Dropout(丢弃)

    • 权重噪声

    • 约束

• 数据类

  • 迭代器

    • 迭代器 - 内置 (DL4J-提供数据)

    • 迭代器 -用户提供数据

    • 迭代器 - 适配器和实用迭代器

  • 读取原始数据: DataVec 记录读取器

  • 数据归一化

  • Spark 网络训练数据类

• 迁移学习

• 已训练的模型库 - Model Zoo

• Keras 导入

• 分布式训练 (Spark)

• 超参数优化(Arbiter)

层

前馈层

DenseLayer - (源码) - 简单/标准全连接层

EmbeddingLayer - (源码) - 以正整数索引作为输入，输出向量。只作为模型中的第一层使用。数学上等效于（当启用偏置）DenseLayer，使用OneHot输入，但更高效。

输出层

输出层:通常用作网络中的最后一层。这里会设置损失函数。

OutputLayer - (源码) - 在MLPs/CNNs中的标准分类/回归输出层。有一个内置的全连接的DenseLayer。 2d 输入/输出 (即, 每个示例中的行向量)。

LossLayer - (源码) - 没有参数的输出层 - 只有损失函数和激活函数。2d 输入/输出 (即, 每个示例中的行向量)。与Outputlayer 不同，它有nIn = nOut的限制。

RnnOutputLayer - (源码) - 循环神经网络的输出层。三维（时间序列）的输入和输出。内置有时间分布全连接层。

RnnLossLayer - (源码) - 无参版本的RnnOutputLayer。 三维（时间序列）的输入和输出。

CnnLossLayer - (源码) - 与CNNs一起使用，其中必须在输出的每个空间位置进行预测（例如：分割或去噪）。没有参数，四维输入/输出与形状[小批量，深度，高度，宽度]。当使用softmax时，这是在每个空间位置的深度应用。

Yolo2OutputLayer - (源码) - 用于目标检测的YOLO 2模型实现

CenterLossOutputLayer - (源码) - OutputLayer的一个版本，也试图最小化示例激活的类内距离，即，“如果示例x在Y类中，则确保嵌入(x)接近于所有示例y在Y中的平均值(嵌入(y))。

卷积层

• ConvolutionLayer / Convolution2D - (Source) - 标准的二维卷积神经网络层。输入和输出有4个维度形状分别为 [minibatch,depthIn,heightIn,widthIn] 和[minibatch,depthOut,heightOut,widthOut]。

• Convolution1DLayer / Convolution1D - (Source) - 标准的一维卷积神经网络层。

• Deconvolution2DLayer - (Source) - 也称为转置或分数阶卷积。可以认为是“反向”卷积层；输出通常大于输入，同时保持空间连接结构。

• SeparableConvolution2DLayer - (Source) - 深度可分离卷积层。

• SubsamplingLayer - (Source) -为CNNs实现的标准二维空间池化，最大、平均和p范数池可用。

• Subsampling1DLayer - (Source)

• Upsampling2D - (Source) - 通过重复行／列 来升级CNN激活 。

• Upsampling1D - (Source) - 一维版本的上采样层

• Cropping2D - (Source) - 二维卷积神经网络的裁剪层。

• ZeroPaddingLayer - (Source) -非常简单的层，将指定数量的零填充添加到四维输入激活的边缘。

• ZeroPadding1DLayer - (Source) - 一维版本的ZeroPaddingLayer

• SpaceToDepth - (Source) - 给定块大小，这个操作采用四维数组，并把数据从空间维度移动到通道。

• SpaceToBatch - (Source) - 根据指定的“块”，将张量从2个空间维度转换为批量维度。

循环层

• LSTM - (Source) - 没有窥视孔连接的LSTM RNN。 支持 CuDNN。

• GravesLSTM - (Source) - 具有窥视孔连接的LSTM RNN。不支持CuDNN（因此对于GPU，LSTM应该优先使用）。

• GravesBidirectionalLSTM - (Source) - 具有窥视连接的双向LSTM实现。等效于双向（ADD，GravesLSTM）。由于增加了双向包装（以下），已被主干弃用。

• Bidirectional - (Source) - 一个“包装”层-将任何标准的单向RNN转换成双向RNN（双倍数量的参数-前向/后向网络具有独立的参数）。前向/后向网络的激活可以是增加的、乘法的、平均的或级联的。

• SimpleRnn - (Source) - 一个标准的“普通”RNN层。在长时间系列依赖的情况下，通常在实际中不生效。更推荐使用LSTM。

• LastTimeStep - (Source) - 一个“包装器”层提取出它封装的（非双向）RNN层的最后一个时间步长。三维输入的形状[minibatch, size, timeSeriesLength]，二维输出与形状[minibatch, size]。

无监督层

• VariationalAutoencoder - (Source) 一种用于编码器和解码器的MLP/稠密层的变分自编码器实现。支持多种不同类型的重构分布。

• AutoEncoder - (Source) - 标准降噪自动编码器层

其它层

• GlobalPoolingLayer - (Source) - 实现基于时间的池化（对于RNs/时间序列-输入大小[minibatch，size，timeSeriesLength]、out[minibatch，size]）和全局空间池化（对于CNN-输入大小[minibatch，.，h，w]、out[minibatch，.]）。可用的池模式：和，平均，最大和p-范数。

• ActivationLayer - (Source) - 将激活函数（仅）应用于输入激活。请注意，大多数DL4J层具有作为配置选项内置的激活函数。

• DropoutLayer - (Source) - 实现丢弃的单独的层。注意大多数 DL4J层有一个内置的丢弃配置选项。

• BatchNormalization - (Source) - 二维（前馈），三维（时间系列）或4维（卷积神经网络）激少的批量归一化。对于时间系列，参数是跨时间共享的；对于卷积神经网络，参数是跨空间位置（不是深度）共享的。

• LocalResponseNormalization - (Source) - 卷积神经网络的本地响应归一化层。在现代的卷积神经网络架构中不经常用。

• FrozenLayer - (Source) - 通常不会被用户直接使用-被作为迁移学习的一部份添加，用于冻结层在将来的训练中不再改变的参数。

图顶点

图顶点: 与 ComputationGraph 一起使用。和层类似，顶点通常没有任何参数，并可以支持多个输入。

• ElementWiseVertex - (Source) - 对输入进行元素操作-加法、减法、乘积、平均值、最大值

• L2NormalizeVertex - (Source) - 通过对每个示例除以L2范数来归一化输入激活。即，out＜-out／L2范数（out）

• L2Vertex - (Source) - 为每个示例分别计算两个输入阵列之间的L2距离。对于每个输入值，输出是一个单一值。

• MergeVertex - (Source) - 将输入激活沿维度1合并，以生成更大的输出数组。对于CNNs，它实现沿深度/通道维度的合并。

• PreprocessorVertex - (Source) - 包括一个输入预处理器的简单的图顶点

• ReshapeVertex - (Source) - 执行任意激活阵列整形。下一节中的预处理器通常是首选的。

• ScaleVertex - (Source) - 实现输入的简单乘法缩放，即OUT =标量*输入。

• ShiftVertex - (Source) - 在输入上实现简单的标量元素添加（即，out＝输入+标量）。

• StackVertex - (Source) - 用于按小批量的维度堆叠所有输入。类似于MergeVertex，但沿维度0（小批量）而不是维度1（输出/通道）

• SubsetVertex - (Source) - 用于获得沿维度1的输入激活的连续子集。例如，可以使用两个SubsetVertex实例来将激活从输入数组分割为两个单独的激活。本质上与MergeVertex是相反的。

• UnstackVertex - (Source) - 与SubsetVertex类似，但沿维度0（小批量）而不是维度1（输出/通道）。与StackVertex相反。

输入预处理器

输入预处理器是一个简单的类/接口，它对一个层的输入进行操作。也就是说，预处理器连接到一个层上，并在输入到输出之前对输入执行一些操作。预处理器还处理反向传播——即，预处理操作一般是可求导的。

请注意，在许多情况下（例如XtoYPreProcessor类），用户不需要（也不应该）手动添加这些，而只能使用.setInputType(InputType.feedForward(10))来代替，这会根据需要推断和添加预处理器。

• CnnToFeedForwardPreProcessor - (Source) - 对一个卷积层(ConvolutionLayer, SubsamplingLayer, etc) 到 DenseLayer/OutputLayer的转换做必要的激活修正处理。

• CnnToRnnPreProcessor - (Source) - 对一个卷积神经网络层到循环神经网络层的转换做必要的激活修正处理。

• ComposableInputPreProcessor - (Source) - 一个简单的类，允许多个预处理器链接在单个层上。

• FeedForwardToCnnPreProcessor - (Source) - 对一个行向量到一个卷积网络层的转换做激活修正处理。注意这种转换或预处理仅在激活为真实的卷积神经网络激活，但已被扁平化为一个行向量。

• FeedForwardToRnnPreProcessor - (Source) - 处理从（时间分布）前馈层到RNN层的转换。

• RnnToCnnPreProcessor - (Source) - 处理从具有形状[minibatch，...，timeSeriesLength]格式的CNN激活序列到时间分布[numExam.*timeSeriesLength，numChannels，inputWidth，inputHeight]格式的转换。

• RnnToFeedForwardPreProcessor - (Source) - 处理从时间序列激活(.[minibatch,size,timeSeriesLength])到时分布前馈(.[minibatch*tsLength,size])激活的转换。

迭代/训练监听器

迭代监听器：可以附加到模型，并在训练期间调用，在每次迭代之后（即，在每次参数更新之后）。训练监听器：迭代监听器的扩展。在训练的不同阶段调用许多附加方法。即在向前传递、梯度计算之后，在每次训练开始或结束。

没有（迭代/训练）在训练之外（即在输出或前馈方法中）被调用。

• ScoreIterationListener - (Source, Javadoc) - 记录每隔n次训练迭代的损失函数评分。

• PerformanceListener - (Source, Javadoc) -记录每N次训练迭代的性能（每秒钟多少示例，每秒钟多少微批次，ETL时间）并可以选择评分

• EvaluativeListener - (Source, Javadoc) - 在一个测试集上评估每N次迭代或训练的网络性能。也有一个回调系统，来保存评估结果。

• CheckpointListener - (Source, Javadoc) - 周期性的保存网络检查点-基于训练，迭代或时间（或这三个中的组合）

• StatsListener - (Source) - DL4J的基于网页的神经网络训练用户界面的主要监听器。查看可视化页面来获取详情。

• CollectScoresIterationListener - (Source, Javadoc) - 与ScoreIterationListener类似，但在一个本地的列表中保存评分（用于之后获取），而不是记录评分

• TimeIterationListener - (Source, Javadoc) - 试图，基于当前的速度和指定的迭代次数估算训练完成之前的时间。

评估

链接: 主要的评估页

DL4J具有用于评估网络性能的多个类，与测试集相对应。不同的评估类适合于不同类型的网络。

• Evaluation - (Source) - 用于多类分类器的评估（假设标准one-hot标签，以及N类上的软最大概率分布用于预测）。计算一些度量-正确率，精确率，召回，F1，Fβ，马休斯相关系数，混淆矩阵。可选地计算前N正确率、自定义二分类决策阈值和成本数组（对于非二分类情况）。通常用于软最大 + 麦克森特/负对数似然网络。

• EvaluationBinary - (Source) -评估类的多标签二分类版本。假设每个网络输出是独立的/独立的二分类，概率0到1与所有其他输出无关。通常用于sigmoid+二值交叉熵网络。

• EvaluationCalibration - (Source) - 用于评价二分类或多类分类器的校准。产生可靠性图、残差图和概率直方图。使用EvaluationTools.exportevaluationCalibrationToHtmlFile 方法导出图表到HTML

• ROC - (Source) - 仅用于单输出二分类器。即，具有nOut(1) + sigmoid, 或 nOut(2) + softmax。支持2种模式：阈值（近似）或精确（默认）。计算ROC曲线下面积，精确召回曲线下面积。使用EvaluationTools绘制ROC和P-R曲线到HTML。

• ROCBinary - (Source) - 一个用于多标签二分类网络（即 sigmoid + 二值交叉熵）的ROC版本，它的每个网络的输出假被为一个独立的二分类变量。

• ROCMultiClass - (Source) - 一个用于多类（非二分类）网络的ROC版本。 (即, softmax + 麦克森特/负对数似然 网络)。由于ROC度量仅定义为二分类，因此将多类输出视为一组“一对所有”的二分类问题。

• RegressionEvaluation - (Source) - 一个用于回归模型的评估类（包括多输出回归模型）。报告每个输出的度量，例如均方误差（MSE）、平均绝对误差等。

网络的保存与加载

可以使用ModelSerializer类，特别是writeModel、restoreMultiLayerNetwork和restoreComputationGraph方法来保存多层网络和计算图。

对于当前主干（但不是0.9.1） MultiLayerNetwork.save(File)方法 和 MultiLayerNetwork.load(File) 方法已被添加。这些在内部使用ModelSerializer。计算图也增加了类似的保存/加载方法。

示例: 加载与保存网络

网络可以在保存和加载之后进一步训练：但是，请确保加载“更新器”（即，更新器的历史状态，如momentum）。如果不需要进一步的训练，则更新器状态可以被忽略以节省磁盘空间和内存。

大多数归一化器(实现ND4J Normalizer接口)也可以使用addNormalizerToModel方法添加到模型中。

注意，DL4J中用于模型的格式是.zip：可以使用支持zip格式的程序打开/提取这些文件。

网络配置

本节列出了DL4J支持的各种配置选项。

激活函数

激活函数可以用两种方式之一定义：(a)通过向配置传递激活枚举值，例如，.activation(Activation.TANH)(b)通过传递IActivation实例，例如，.activation(new ActivationSigmoid())。

注意，DL4J支持自定义激活函数，它可以通过扩展BaseActivationFunction来定义。

支持的激活函数列表:

• CUBE - (Source) - f(x) = x^3

• ELU - (Source) - 指数线性单位(参考文献)

• HARDSIGMOID - (Source) - 标准sigmoid激活函数的分段线性化. f(x) = min(1, max(0, 0.2*x + 0.5))

• HARDTANH - (Source) - 标准 tanh 激活函数的分段线性化.

• IDENTITY - (Source) - 一个“无运算”激活函数: f(x) = x

• LEAKYRELU - (Source) - 漏校正线性单元. f(x) = max(0, x) + alpha * min(0, x) 默认的 alpha=0.01 .

• RATIONALTANH - (Source) - tanh(y) ~ sgn(y) * { 1 - 1/(1+|y|+y^2+1.41645*y^4)} 近似于 f(x) = 1.7159 * tanh(2x/3), 但执行起来更快. (参考文献)

• RELU - (Source) - 标准校正线性单元: f(x) = x if x>0 或 f(x) = 0

• RRELU - (Source) - 随机校正线性单位。在测试期间有确定性. (参考文献)

• SIGMOID - (Source) - 标准的 sigmoid 激活函数, f(x) = 1 / (1 + exp(-x))

• SOFTMAX - (Source) - 标准的 softmax 激活函数

• SOFTPLUS - (Source) - f(x) = log(1+e^x) - 形状类似于RELU 激活函数的平滑版本

• SOFTSIGN - (Source) - f(x) = x / (1+|x|) - 形状类似于标准的 tanh 激活函数 (计算更快).

• TANH - (Source) - 标准的 tanh (双曲正切) 激活函数

• RECTIFIEDTANH - (Source) - f(x) = max(0, tanh(x))

• SELU - (Source) - 比例指数线性单位，与自归一化神经网络一起使用

• SWISH - (Source) - Swish 激活函数, f(x) = x * sigmoid(x)(参考文献)

权重初始化

权值初始化指的是一个新网络的初始参数应该被设置的方法。

权重初始化通常使用WeightInit枚举来定义。

自定义权重初始化可以使用 .weightInit(WeightInit.DISTRIBUTION).dist(new NormalDistribution(0, 1)) 例如. 对于主干 (非 0.9.1 版本) .weightInit(new NormalDistribution(0, 1)) 也是可用的, 这相当于以前的方法。

可用的权重初始化。并不是所有的版本都在0.9.1版本中可用：

• DISTRIBUTION: Sample weights from a provided distribution 从给定的分布获取权重样例 (specified 通过 dist 配置方法来指定）

• ZERO: 生成权重为零

• ONES: 所有权重设为1

• SIGMOID_UNIFORM: sigmoid激活函数的一个XAVIER_UNIFORM版本。 U(-r,r) with r=4*sqrt(6/(fanIn + fanOut))

• NORMAL: 均值为0，标准差为 1/sqrt(fanIn)的 正态/高斯分布。这是Klambauer等人提出的初始化，2017、“自归一化神经网络”论文。相当于 DL4J’的 XAVIER_FAN_IN 和 LECUN_NORMAL (即. Keras 的 “lecun_normal”)

• LECUN_UNIFORM: U[-a,a] 与 a=3/sqrt(fanIn)保持统一

• UNIFORM: U[-a,a] 与 a=1/sqrt(fanIn)保持统一。 Glorot和BeNIO 2010的“常用启发式”

• XAVIER: As per Glorot and Bengio 2010: 均值 0, 方差为 2.0/(fanIn + fanOut)的高斯分布

• XAVIER_UNIFORM: As per Glorot and Bengio 2010: 分布 U(-s,s) 与 s = sqrt(6/(fanIn + fanOut))保持统一

• XAVIER_FAN_IN: 类似于Xavier, 除了 1/fanIn -> Caffe 原来用过这个.

• RELU: He et al. (2015), “深入研究整流器”. 方差为2.0/nIn的正态分布

• RELU_UNIFORM: He et al. (2015), “深入研究整流器”. 分布 U(-s,s) 与 s = sqrt(6/fanIn)保持统一

• IDENTITY: 权重被设置为单位矩阵。注：只能与平方权重矩阵一起使用。

• VAR_SCALING_NORMAL_FAN_IN: 均值0，方差为1.0/(fanIn)的高斯分布

• VAR_SCALING_NORMAL_FAN_OUT: 均值0，方差为1.0/(fanOut)的高斯分布

• VAR_SCALING_NORMAL_FAN_AVG: 均值0，方差为1.0/((fanIn + fanOut)/2)的高斯分布

• VAR_SCALING_UNIFORM_FAN_IN: U[-a,a] 与 a=3.0/(fanIn)保持统一

• VAR_SCALING_UNIFORM_FAN_OUT: U[-a,a] 与 a=3.0/(fanOut)保持统一

• VAR_SCALING_UNIFORM_FAN_AVG:U[-a,a] 与 a=3.0/((fanIn + fanOut)/2)保持统一

更新器 (优化器)

DL4J中的“更新器”是一个需要原始梯度并将其修改为更新的类。然后将这些更新应用于网络参数。这篇CS231n 课程笔记对这些更新器有很好的解释。

DL4J支持的更新器:

• AdaDelta - (Source) - Reference

• AdaGrad - (Source) - Reference

• AdaMax - (Source) - Adam 更新器的一个变体 - 参考文献

• Adam - (Source)

• Nadam - (Source) - Adam 更新器的一个变体，使用牛顿动量更新规则 - 参考文献

• Nesterovs - (Source) - 牛顿动量更新器

• NoOp - (Source) - 一个“无操作”更新程序。也就是说，梯度不会被这个更新器修改。数学等价于学习率为1的SGD更新器

• RmsProp - (Source) - 参考文献

• Sgd - (Source) - 标准随机梯度下降更新器。此更新器仅适用学习速率。

学习调度

支持学习速率的所有更新器也支持学习速率调度（牛顿动量更新器也支持动量调度）。学习速率调度可以根据迭代次数或已逝去的训练数来指定。Dropout（见下文）也可以利用这里列出的调度表。

配置用法，例如: .updater(new Adam(new ExponentialSchedule(ScheduleType.ITERATION, 0.1, 0.99 ))) 你可以在你创建的调度对象上通过调用ISchedule.valueAt(int iteration, int epoch) 来制图／监视将在任意点使用的学习率。

可用的调度:

• ExponentialSchedule - (Source) - 实现 value(i) = initialValue * gamma^i

• InverseSchedule - (Source) - 实现 value(i) = initialValue * (1 + gamma * i)^(-power)

• MapSchedule - (Source) - 基于用户提供的映射的学习率调度。注意所提供的映射必须有一个用于迭代／训练 0次 的值。有一个构建器类来方便的定义一个调度。

• PolySchedule - (Source) - 实现 value(i) = initialValue * (1 + i/maxIter)^(-power)

• SigmoidSchedule - (Source) - 实现 value(i) = initialValue * 1.0 / (1 + exp(-gamma * (iter - stepSize)))

• StepSchedule - (Source) - 实现 value(i) = initialValue * gamma^( floor(iter/step) )

请注意，自定义调度可以通过实现ISchedule接口来创建。

正则化

L1/L2 正则化

L1和L2正则化可以容易地通过配置：.l1(0.1).l2(0.2)添加到网络中。注意， .regularization(true) 必须在0.9.1上启用（这个选项在0.9.1发布后被删除）。 L1和L2正则化仅适用于权重参数。也就是说，.l1 和 .l2 不会影响偏置参数-这些可以使用.l1Bias(0.1).l2Bias(0.2)实现被正则化。

Dropout（丢弃）

所有的丢弃类型公在训练时应用。它们不在测试时应用。

• Dropout - (Source) - 每个输入激活X被独立地设置为（0，与概率1-p）或（x/p与概率p）。

• GaussianDropout - (Source) - 这是一个输入激活上的乘法高斯噪声（均值1)。每个输入激活X独立地设置为：x * y, y ~ N(1, stdev = sqrt((1-rate)/rate))

• GaussianNoise - (Source) - 将加法，平均零高斯噪声应用于输入-即 x = x + N(0,stddev)

• AlphaDropout - (Source) - AlphaDropout是一个丢弃技术，由Klaumbauer et al. 2017 - 自归一化神经网络提出。设计为自归一化神经网络(SELU 激活函数, NORMAL 权重初始化)。试图让丢弃后激活的均值和方差与AlphaDropout被应用之前相同。

注意（从当前主干开始，但不是0.9.1），丢弃参数也可以根据学习率调度部分中提到的任何调度类来指定。

权重噪声

根据丢弃，丢弃连接/权重噪声只适用于训练时间。

• DropConnect - (Source) - 参考文献 DropConnect与dropout类似，但应用于网络参数（而不是输入激活）

• WeightNoise - (Source) - 在训练时把指定分布噪声应用于权重。支持加法和乘法模式。-当 加法时，噪声应当均值为0，当乘法时，噪声均值应当为1。

约束

约束是在每次迭代结束时（在参数更新发生之后）放置在模型的参数上的确定性限制。它们可以被认为是正则化的一种类型。

• MaxNormConstraint - (Source) - 将每个单元的输入权重的最大L2范数约束为小于或等于指定值。如果L2范数超过指定值，则权重将被缩减以满足约束。

• MinMaxNormConstraint - (Source) -将每个单元的输入权重的最小和最大L2范数约束在指定值之间。如果需要的话，权重将被放大/缩小。

• NonNegativeConstraint - (Source) - 约束所有参数为非负。负参数将被替换为0。

• UnitNormConstraint - (Source) -将每个单元的输入权重的L2范数约束为1。

数据类

迭代器

DataSetIterator是DL4J用于对小批量数据进行迭代的抽象，用于训练。DataSetIterator返回DataSet对象，这些对象是小批量，并支持最多1个输入和1个输出数组（INDArray）。 MultiDataSetIterator类似于DataSetIterator，但是返回MultiDataSet对象，该对象可以具有网络所需的多个输入和多个输出数组。

内置迭代器 (DL4J-提供数据)

这些迭代器按需要下载它们的数据。它们返回的实际数据集不是可定制的。

• MnistDataSetIterator - (Source) - 著名的MNIST数字数据集的DataSetIterator。默认情况下，返回行向量（1x784），其值被归一化为0至1范围。使用.setInputType(InputType.convolutionalFlat())来与CNN一起使用。

• EmnistDataSetIterator - (Source) - 类似于MNIST数字数据集，但有更多的例子，也有字母。包括多个不同的分割（仅字母，数字，字母+数字等）。因此，可以使用与MNIST相同的1x784格式（除了用于某些分割的不同数量的标签之外）作为MnistDataSetIterator的置换置换。 参考文献 1, 参考文献2

• IrisDataSetIterator - (Source) -一个众所周知的鸢尾花数据集的迭代器。4个特征，3个输出类。

• CifarDataSetIterator - (Source) - CIOFAR图像数据集的迭代器。10类，在DL4J中CNNs的4D特征/激活格式：[minibatch,channels,height,width] = [minibatch,3,32,32]。特征不是归一化的，而是在0到255的范围内。

• LFWDataSetIterator - (Source)

• TinyImageNetDataSetIterator (Source) - 标准IMANET数据集的子集；200个类，每个类500个图像

• UciSequenceDataSetIterator (Source) - UCI 综合控制时间序列数据集

迭代器-用户提供的数据

此子章节的迭代器与用户提供的数据一起使用。

• RecordReaderDataSetIterator - (Source) - 采用DataVec记录读取器（如CsvRecordReader或ImageRecordReader）并处理到数据集的转换、批处理、屏蔽等的迭代器。DL4J中最常用的迭代器之一。只处理非序列数据，作为输入（即，RecordReader，非SequenceeRecordReader）。

• RecordReaderMultiDataSetIterator - (Source) - RecordReaderDataSetIterator 的MultiDataSet版本, 支持多个读取器。具有用于创建更复杂的数据管道的构建器模式（例如，读取器输出到不同输入/输出阵列的不同子集、转换到一个热点等等）。处理序列和非序列数据作为输入。

• SequenceRecordReaderDataSetIterator - (Source) - RecordReaderDataSetIterator 的sequence (SequenceRecordReader) 版本。 用户最好结合RecordReaderMultiDataSetIterator使用。

• DoublesDataSetIterator - (Source)

• FloatsDataSetIterator - (Source)

• INDArrayDataSetIterator - (Source)

迭代器 - 适配器与实用迭代器

• MultiDataSetIteratorAdapter - (Source) - 包装一个 DataSetIterator来转换为一个MultiDataSetIterator

• SingletonMultiDataSetIterator - (Source) - 包装一个MultiDataSet 转换为一个 MultiDataSetIterator 并返回一个 MultiDataSet (即, 包装的MultiDataSet是不可分割的)

• AsyncDataSetIterator - (Source) - 在适当的情况下由多层网络和计算图自动使用。实现数据集的异步预获取以提高性能。

• AsyncMultiDataSetIterator - (Source) - 在适当的情况下由计算图自动使用。实现多数据集的异步预获取以提高性能。

• AsyncShieldDataSetIterator - (Source) - 通常只用于调试。使用AsyncDataSetIterator来停止多层网络和计算图。

• AsyncShieldMultiDataSetIterator - (Source) - AsyncShieldDataSetIterator 的 MultiDataSetIterator 版本。

• EarlyTerminationDataSetIterator - (Source) - 包装另一个DataSetIterator，确保在重置之间仅返回指定（最大）数量的小批量（DataSet）对象。可以用来“剪短”一个迭代器，只返回前N个数据集。

• EarlyTerminationMultiDataSetIterator - (Source) - EarlyTerminationDataSetIterator的MultiDataSetIterator版本

• ExistingDataSetIterator - (Source) - 转换一个 Iterator<DataSet> 或 Iterable<DataSet> 为 一个 DataSetIterator。 不拆分基础数据集对象

• FileDataSetIterator - (Source) - 一个迭代器，用于迭代以前用 DataSet.save(File)保存的DataSet文件。支持随机化、过滤、不同的输出批量大小与保存的数据集批量大小等。

• FileMultiDataSetIterator - (Source) - FileDataSetIterator的MultiDataSet版本。

• IteratorDataSetIterator - (Source) - 转换一个 Iterator<DataSet> 为一个 DataSetIterator. 与ExistingDataSetIterator不同，底层DataSet对象可以是拆分/组合的——即，对于输出，小批量大小可能与输入迭代器不同。

• IteratorMultiDataSetIterator - (Source) - IteratorDataSetIterator 的Iterator<MultiDataSet>版本

• MultiDataSetWrapperIterator - (Source) - 转换一个MultiDataSetIterator 为一个 DataSetIterator。 注意，如果特征和标签数组的数量等于1，才是可能的。

• MultipleEpochsIterator - (Source) - 当训练时，将基础迭代器的多次训练视为单个训练。

• WorkspaceShieldDataSetIterator - (Source) - 通常只用于调试，而通常不由用户使用。分离/迁移来自底层DataSetIterator的数据集。

数据归一化

ND4J提供了用于执行数据归一化的多个类。这些实现为数据集预处理器。归一化的基本模式：

1. 创建你的 (非归一化) DataSetIterator 或 MultiDataSetIterator: DataSetIterator myTrainData = ...

2. 创建你想使用的归一化器: NormalizerMinMaxScaler normalizer = new NormalizerMinMaxScaler();

3. 拟合归一化器: normalizer.fit(myTrainData)

4. 在迭代器上设置归一化器／预处理器 : myTrainData.setPreProcessor(normalizer); 最终结果：来自DataSetIterator的数据现在将被归一化。

通常你应该只在训练数据上拟合，并且与仅在训练数据上拟合的相同的/单一的归一化器一起执行 trainData.setPreProcessor(normalizer) 和 testData.setPreProcessor(normalizer)

注意，在适当的情况下（NormalizerStandard.，NormalizerMinMaxScaler），诸如平均值/标准偏差/最小值/最小值的统计数据，跨时间（对于时间序列）和跨图像x/y位置（但是对于图像数据不是深度/通道）共享。

数据归一化示例: 链接

可用的归一化器: DataSet / DataSetIterator

• ImagePreProcessingScaler - (Source) - 应用最小最大缩放到图像激活。默认设置将0到255输入到0-1输出（但是是可配置的）。注意，与这里的其他归一化器不同，该归一化器不依赖于从数据收集的统计数据(均值/最小值/最大值 等)，因此normalizer.fit(trainData)步骤是不必要的(是非操作性的)。

• NormalizerStandardize - (Source) - 独立地将每个特征值（和可选的标签值）归一化为0平均值和1的标准差。

• NormalizerMinMaxScaler - (Source) - 独立归一化每个特征值（以及可选的标签值），使其位于最小值和最大值之间（默认情况下在 0和1之间）

• VGG16ImagePreProcessor - (Source) - 这是一个专门用于VG16的预处理器。在训练集上计算，减去每个像素RGB的平均值，如在链接中所报告的。

可用的归一化器: MultiDataSet / MultiDataSetIterator

• ImageMultiPreProcessingScaler - (Source) - ImagePreProcessingScaler的MultiDataSet/MultiDataSetIterator版本

• MultiNormalizerStandardize - (Source) - NormalizerStandardize的MultiDataSet/MultiDataSetIterator版本

• MultiNormalizerMinMaxScaler - (Source) - NormalizerMinMaxScaler的 MultiDataSet/MultiDataSetIterator 版本

• MultiNormalizerHybrid - (Source) - 一个 MultiDataSet归一化器，可以为 不同的 输入/特征 和输出/标签 数组组合不同的归一化类型（标准化，最小／最大化） 。

迁移学习

DL4j具有用于执行迁移学习的类/实用程序——即，采用现有网络，并修改一些层（可选地冻结其他层，以便它们的参数不改变）。例如，可以在ImageNet上训练图像分类器，然后应用于新的/不同的数据集。多层网络和计算图都可以与迁移学习一起使用——通常从模型动物园的预训练模型开始（参见下一节），虽然可以单独使用任何多层网络/计算图。

链接: 迁移学习示例

迁移学习的主要类别是TransferLearning。该类具有可用于添加/删除层、冻结层等的构建器模式。FineTuneConfiguration可用于指定非冻结层的学习速率和其他设置。

已训练的模型库 - Model Zoo

DL4J提供了一个“model zoo”——一组预训练模型，可以下载和使用（例如，用于图像分类），或者经常用于迁移学习。

链接: Deeplearning4j Model Zoo

DL4J 的 model zoo中可用的模型有:

• AlexNet - (Source)

• Darknet19 - (Source)

• FaceNetNN4Small2 - (Source)

• InceptionResNetV1 - (Source)

• LeNet - (Source)

• ResNet50 - (Source)

• SimpleCNN - (Source)

• TextGenerationLSTM - (Source)

• TinyYOLO - (Source)

• VGG16 - (Source)

• VGG19 - (Source)

*注: Keras 已训练好的模型 (不是 DL4J 提供) 或许也可以导入, 使用 DL4J的 Keras 模型导入功能。

速查表代码片段

Eclipse DL4J库提供了很多功能，我们将这个速查表放在一起，以帮助用户组装神经网络并更快地使用张量。

神经网络

用于多层网络和计算图的通用参数和层的配置代码。完整的API见MultiLayerNetwork和ComputationGraph。

序列网络

大多数网络配置可以使用多层网络类，如果它们是序列的和简单的。

MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
    .seed(1234)
    // 如下的参数会被复制到网络中的每一层
    // 对于像 dropOut() 或 activation()这样的参数你应该每一层都设置
    // 只指定你需要的参数
    .updater(new AdaGrad())
    .activation(Activation.RELU)
    .dropOut(0.8)
    .l1(0.001)
    .l2(1e-4)
    .weightInit(WeightInit.XAVIER)
    .weightInit(Distribution.TruncatedNormalDistribution)
    .cudnnAlgoMode(ConvolutionLayer.AlgoMode.PREFER_FASTEST)
    .gradientNormalization(GradientNormalization.RenormalizeL2PerLayer)
    .gradientNormalizationThreshold(1e-3)
    .list()
    // 网络中的层，按顺序添加
    // 每层设置的参数覆盖上面设置的参数
    .layer(new DenseLayer.Builder().nIn(numInputs).nOut(numHiddenNodes)
            .weightInit(WeightInit.XAVIER)
            .build())
    .layer(new ActivationLayer(Activation.RELU))
    .layer(new ConvolutionLayer.Builder(1,1)
            .nIn(1024)
            .nOut(2048)
            .stride(1,1)
            .convolutionMode(ConvolutionMode.Same)
            .weightInit(WeightInit.XAVIER)
            .activation(Activation.IDENTITY)
            .build())
    .layer(new GravesLSTM.Builder()
            .activation(Activation.TANH)
            .nIn(inputNum)
            .nOut(100)
            .build())
    .layer(new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD)
            .weightInit(WeightInit.XAVIER)
            .activation(Activation.SOFTMAX)
            .nIn(numHiddenNodes).nOut(numOutputs).build())
    .pretrain(false).backprop(true)
    .build();

MultiLayerNetwork neuralNetwork = new MultiLayerNetwork(conf);