KotlinDL：Kotlin 高级深度学习 API

KotlinDL 是一个用 Kotlin 编写的高级深度学习 API，其灵感来源于 Keras。在底层，它使用 TensorFlow Java API 和 ONNX Runtime 的 Java API。KotlinDL 提供了简洁的 API，可用于从头开始训练深度学习模型、导入现有的 Keras 和 ONNX 模型进行推理，以及利用迁移学习将现有的预训练模型调整到您的任务中。

该项目旨在让 JVM 和 Android 开发者更轻松地进行深度学习，并简化深度学习模型在生产环境中的部署。

以下是在 KotlinDL 中经典卷积神经网络 LeNet 的示例：

private const val EPOCHS = 3
private const val TRAINING_BATCH_SIZE = 1000
private const val NUM_CHANNELS = 1L
private const val IMAGE_SIZE = 28L
private const val SEED = 12L
private const val TEST_BATCH_SIZE = 1000

private val lenet5Classic = Sequential.of(
    Input(
        IMAGE_SIZE,
        IMAGE_SIZE,
        NUM_CHANNELS
    ),
    Conv2D(
        filters = 6,
        kernelSize = intArrayOf(5, 5),
        strides = intArrayOf(1, 1, 1, 1),
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Zeros(),
        padding = ConvPadding.SAME
    ),
    AvgPool2D(
        poolSize = intArrayOf(1, 2, 2, 1),
        strides = intArrayOf(1, 2, 2, 1),
        padding = ConvPadding.VALID
    ),
    Conv2D(
        filters = 16,
        kernelSize = intArrayOf(5, 5),
        strides = intArrayOf(1, 1, 1, 1),
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Zeros(),
        padding = ConvPadding.SAME
    ),
    AvgPool2D(
        poolSize = intArrayOf(1, 2, 2, 1),
        strides = intArrayOf(1, 2, 2, 1),
        padding = ConvPadding.VALID
    ),
    Flatten(), // 3136
    Dense(
        outputSize = 120,
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Constant(0.1f)
    ),
    Dense(
        outputSize = 84,
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Constant(0.1f)
    ),
    Dense(
        outputSize = 10,
        activation = Activations.Linear,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Constant(0.1f)
    )
)


fun main() {
    val (train, test) = mnist()
    
    lenet5Classic.use {
        it.compile(
            optimizer = Adam(clipGradient = ClipGradientByValue(0.1f)),
            loss = Losses.SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS,
            metric = Metrics.ACCURACY
        )
    
        it.logSummary()
    
        it.fit(dataset = train, epochs = EPOCHS, batchSize = TRAINING_BATCH_SIZE)
    
        val accuracy = it.evaluate(dataset = test, batchSize = TEST_BATCH_SIZE).metrics[Metrics.ACCURACY]
    
        println("Accuracy: $accuracy")
    }
}

目录

• 库结构
• 如何在您的项目中配置 KotlinDL
  • 在 Android 项目中使用 KotlinDL
  • 在 Jupyter Notebook 中使用 KotlinDL
• KotlinDL、ONNX Runtime、Android 和 JDK 版本
• 文档
• 示例和教程
• 在 GPU 上运行 KotlinDL
• 日志记录
• Fat Jar 问题
• 限制
• 贡献
• 报告问题/支持
• 行为准则
• 许可证

库结构

KotlinDL 由多个模块组成：

• kotlin-deeplearning-api API 接口和类
• kotlin-deeplearning-impl 实现类和工具
• kotlin-deeplearning-onnx 使用 ONNX Runtime 进行推理
• kotlin-deeplearning-tensorflow 使用 TensorFlow 进行学习和推理
• kotlin-deeplearning-visualization 可视化工具
• kotlin-deeplearning-dataset 数据集类

其中，kotlin-deeplearning-tensorflow 和 kotlin-deeplearning-dataset 模块仅适用于桌面 JVM，而其他工件也可以在 Android 上使用。

如何在您的项目中配置 KotlinDL

要在您的项目中使用 KotlinDL，请确保已将 mavenCentral 添加到仓库列表中：

repositories {
    mavenCentral()
}

然后将必要的依赖项添加到您的 build.gradle 文件中。

要开始创建简单的神经网络或下载预训练模型，只需添加以下依赖项：

// build.gradle
dependencies {
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:[KOTLIN-DL-VERSION]'
}

// build.gradle.kts
dependencies {
    implementation ("org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:[KOTLIN-DL-VERSION]")
}

要使用 ONNX Runtime 进行推理，请使用 kotlin-deeplearning-onnx 模块：

// build.gradle
dependencies {
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-onnx:[KOTLIN-DL-VERSION]'
}

// build.gradle.kts
dependencies {
  implementation ("org.jetbrains.kotlinx:kotlin-deeplearning-onnx:[KOTLIN-DL-VERSION]")
}

要在您的项目中充分利用 KotlinDL 的功能，请将以下依赖项添加到您的 build.gradle 文件中：

// build.gradle
dependencies {
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:[KOTLIN-DL-VERSION]'
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-onnx:[KOTLIN-DL-VERSION]'
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-visualization:[KOTLIN-DL-VERSION]'
}

// build.gradle.kts
dependencies {
  implementation ("org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:[KOTLIN-DL-VERSION]")
  implementation ("org.jetbrains.kotlinx:kotlin-deeplearning-onnx:[KOTLIN-DL-VERSION]")
  implementation ("org.jetbrains.kotlinx:kotlin-deeplearning-visualization:[KOTLIN-DL-VERSION]")
}

最新的稳定版 KotlinDL 是 0.5.2，最新的不稳定版是 0.6.0-alpha-1。

有关更多详细信息以及 pom.xml 和 build.gradle.kts 示例，请参阅 快速入门指南。

在 Jupyter Notebook 中使用 KotlinDL

您可以在 Jupyter Notebook 中通过 Kotlin 内核以交互方式使用 KotlinDL。为此，请在笔记本中添加所需的依赖项：

@file:DependsOn("org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:[KOTLIN-DL-VERSION]")

有关安装 Jupyter Notebook 和添加 Kotlin 内核的更多详细信息，请参阅 快速入门指南。

在 Android 项目中使用 KotlinDL

KotlinDL 支持在 Android 平台上对 ONNX 模型进行推理。要在您的 Android 项目中使用 KotlinDL，请将以下依赖项添加到 build.gradle 文件中：

// build.gradle
implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-onnx:[KOTLIN-DL-VERSION]'

// build.gradle.kts
implementation ("org.jetbrains.kotlinx:kotlin-deeplearning-onnx:[KOTLIN-DL-VERSION]")

有关更多详细信息，请参阅 快速入门指南。

KotlinDL、ONNX Runtime、Android 和 JDK 版本对应关系

下表展示了 KotlinDL、TensorFlow、ONNX Runtime、Android 编译 SDK 以及最低支持的 Java 版本之间的对应关系。

KotlinDL 版本	最低 Java 版本	ONNX Runtime 版本	TensorFlow 版本	Android：编译 SDK 版本
0.1.*	8		1.15
0.2.0	8		1.15
0.3.0	8	1.8.1	1.15
0.4.0	8	1.11.0	1.15
0.5.0–0.5.1	11	1.12.1	1.15	31
0.5.2	11	1.14.0	1.15	31
0.6.*	11	1.16.0	1.15	31

文档

• 演示文稿和视频：
  • 使用 KotlinDL 进行深度学习（Zinoviev Alexey 在华为开发者社区 HDG UK 2021 上的演讲，幻灯片)
  • KotlinDL 深度学习简介（Zinoviev Alexey 在 Kotlin 布达佩斯用户组 2021 上的演讲，幻灯片）
• KotlinDL 变更日志
• 完整的 KotlinDL API 参考文档

示例与教程

使用 KotlinDL 不需要具备深度学习的先验经验。

我们正在努力编写详尽的文档来帮助您快速上手。目前，您可以参考我们准备的以下教程：

• 快速入门指南
• 创建您的第一个神经网络
• 导入 Keras 模型
• 迁移学习
• 使用函数式 API 进行迁移学习
• 在 JVM 上使用 ONNX 模型进行推理
• 在 Android 上使用 ONNX 模型进行推理

如需更多灵感，请查看此仓库中的 代码示例 以及 示例 Android 应用。

在 GPU 上运行 KotlinDL

要启用 GPU 上的训练和推理，请阅读 TensorFlow GPU 支持页面，并安装 CUDA 框架以支持 GPU 设备上的计算。

请注意，仅支持 NVIDIA 显卡。

如果您希望利用 GPU，还需要在项目中添加以下依赖项：

// build.gradle
implementation 'org.tensorflow:libtensorflow:1.15.0'
implementation 'org.tensorflow:libtensorflow_jni_gpu:1.15.0'

// build.gradle.kts
implementation ("org.tensorflow:libtensorflow:1.15.0")
implementation ("org.tensorflow:libtensorflow_jni_gpu:1.15.0")

在 Windows 系统上，还需要安装以下组件：

• CUDA cuda_10.0.130_411.31_win10
• cuDNN 7.6.3
• C++ Redistributable

对于在 CUDA 设备上对 ONNX 模型进行推理，您还需要在项目中添加以下依赖项：

// build.gradle
api 'com.microsoft.onnxruntime:onnxruntime_gpu:1.16.0'

// build.gradle.kts
api("com.microsoft.onnxruntime:onnxruntime_gpu:1.16.0")

有关 ONNXRuntime 和 CUDA 版本兼容性的更多信息，请参阅 ONNXRuntime CUDA 执行提供程序页面。

日志记录

默认情况下，API 模块使用 kotlin-logging 库来将日志记录流程与具体的日志记录器实现分离。

你可以使用任何具有 Simple Logging Facade for Java (SLF4J) 实现的广泛使用的 JVM 日志库，例如 Logback 或 Log4j/Log4j2。

如果你希望使用 Log4j2，还需要在项目的 src/resource 文件夹中添加以下依赖项和配置文件 log4j2.xml：

// build.gradle
implementation 'org.apache.logging.log4j:log4j-api:2.17.2'
implementation 'org.apache.logging.log4j:log4j-core:2.17.2'
implementation 'org.apache.logging.log4j:log4j-slf4j-impl:2.17.2'

// build.gradle.kts
implementation("org.apache.logging.log4j:log4j-api:2.17.2")
implementation("org.apache.logging.log4j:log4j-core:2.17.2")
implementation("org.apache.logging.log4j:log4j-slf4j-impl:2.17.2")

<Configuration status="WARN">
    <Appenders>
        <Console name="STDOUT" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>

    <Loggers>
        <Root level="debug">
            <AppenderRef ref="STDOUT" level="DEBUG"/>
        </Root>
        <Logger name="io.jhdf" level="off" additivity="true">
            <appender-ref ref="STDOUT" />
        </Logger>
    </Loggers>
</Configuration>

如果你想使用 Logback，则需要在项目的 src/resource 文件夹中包含以下依赖项和配置文件 logback.xml：

// build.gradle
implementation 'ch.qos.logback:logback-classic:1.4.5'

// build.gradle.kts
implementation("ch.qos.logback:logback-classic:1.4.5")

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

这些配置文件可以在 examples 模块中找到。

Fat Jar 问题

Stack Overflow 上有一个已知的问题 question 和 TensorFlow 的一个 issue，涉及在 Amazon EC2 实例上创建和运行 Fat Jar 时出现的问题。

java.lang.UnsatisfiedLinkError: /tmp/tensorflow_native_libraries-1562914806051-0/libtensorflow_jni.so: libtensorflow_framework.so.1: cannot open shared object file: No such file or directory

尽管描述此问题的 bug 在 TensorFlow 1.14 版本中已被关闭，但该问题并未完全修复，仍需在构建脚本中添加一行代码。

一个简单的 solution 是在 Jar 的 Manifest 中添加 TensorFlow 版本信息。以下是用于创建 Fat Jar 的 Gradle 构建任务示例。

// build.gradle

task fatJar(type: Jar) {
    manifest {
        attributes 'Implementation-Version': '1.15'
    }
    classifier = 'all'
    from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
    with jar
}

// build.gradle.kts

plugins {
    kotlin("jvm") version "1.5.31"
    id("com.github.johnrengelman.shadow") version "7.0.0"
}

tasks{
    shadowJar {
        manifest {
            attributes(Pair("Main-Class", "MainKt"))
            attributes(Pair("Implementation-Version", "1.15"))
        }
    }
}

限制

目前仅支持有限的一组深度学习架构。以下是可用层的列表：

• 核心层：
  • Input、Dense、Flatten、Reshape、Dropout、BatchNorm。
• 卷积层：
  • Conv1D、Conv2D、Conv3D；
  • Conv1DTranspose、Conv2DTranspose、Conv3DTranspose；
  • DepthwiseConv2D；
  • SeparableConv2D。
• 池化层：
  • MaxPool1D、MaxPool2D、MaxPooling3D；
  • AvgPool1D、AvgPool2D、AvgPool3D；
  • GlobalMaxPool1D、GlobalMaxPool2D、GlobalMaxPool3D；
  • GlobalAvgPool1D、GlobalAvgPool2D、GlobalAvgPool3D。
• 合并层：
  • Add、Subtract、Multiply；
  • Average、Maximum、Minimum；
  • Dot；
  • Concatenate。
• 激活层：
  • ELU、LeakyReLU、PReLU、ReLU、Softmax、ThresholdedReLU；
  • ActivationLayer。
• 裁剪层：
  • Cropping1D、Cropping2D、Cropping3D。
• 上采样层：
  • UpSampling1D、UpSampling2D、UpSampling3D。
• 零填充层：
  • ZeroPadding1D、ZeroPadding2D、ZeroPadding3D。
• 其他层：
  • Permute、RepeatVector。

目前，层的实现使用的是 TensorFlow 1.15 Java API，但该项目将在不久的将来切换到 TensorFlow 2.x 及以上版本。不过，这并不影响高层 API。目前，TensorFlow 模型的推理仅支持在桌面端运行。

贡献

请阅读 贡献指南。

报告问题/支持

请使用 GitHub issues 提交功能请求和错误报告。你也可以加入 Kotlin Slack 中的 #kotlindl 频道。

行为准则

本项目及其相关社区受 JetBrains 开源与社区行为准则 约束，请务必阅读。

许可证

KotlinDL 采用 Apache 2.0 许可证 许可。

KotlinDL 快速上手指南

KotlinDL 是一个用 Kotlin 编写的高级深度学习 API，灵感来源于 Keras。它底层基于 TensorFlow Java API 和 ONNX Runtime，旨在让 JVM 和 Android 开发者能够轻松地从零训练模型、导入现有模型进行推理或使用迁移学习。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• JDK 版本：推荐使用 JDK 11 或更高版本（KotlinDL 0.5.0+ 要求最低 JDK 11）。
• 构建工具：Gradle (推荐) 或 Maven。
• 操作系统：Windows, macOS, Linux (桌面端); Android (仅支持 ONNX 推理)。
• GPU 支持 (可选)：如需使用 GPU 加速训练，需安装 NVIDIA CUDA 框架 (仅支持 NVIDIA 显卡)。
  • Windows 用户需额外安装：CUDA 10.0+, cuDNN 7.6.3+, Visual C++ Redistributable。

安装步骤

1. 配置仓库

确保在 build.gradle 或 build.gradle.kts 中添加 mavenCentral() 仓库。国内开发者若遇到下载慢的问题，可配置阿里云镜像：

repositories {
    // 阿里云镜像 (推荐国内开发者使用)
    maven { url 'https://maven.aliyun.com/repository/central' }
    mavenCentral()
}

2. 添加依赖

根据您的使用场景，在 dependencies 块中添加相应的依赖。请将 [KOTLIN-DL-VERSION] 替换为最新版本（当前稳定版为 0.5.2）。

场景 A：从零构建神经网络 (基于 TensorFlow)

适用于桌面端 JVM 项目，用于训练和推理。

// build.gradle
dependencies {
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:0.5.2'
}

// build.gradle.kts
dependencies {
    implementation("org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:0.5.2")
}

场景 B：ONNX 模型推理 (支持 Android)

适用于加载现有的 Keras/ONNX 模型进行推理，支持桌面端和 Android。

// build.gradle
dependencies {
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-onnx:0.5.2'
}

场景 C：完整功能 (桌面端)

包含 TensorFlow 训练、ONNX 推理及可视化工具。

// build.gradle
dependencies {
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:0.5.2'
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-onnx:0.5.2'
    implementation 'org.jetbrains.kotlinx:kotlin-deeplearning-visualization:0.5.2'
}

注意：kotlin-deeplearning-tensorflow 模块仅支持桌面端 JVM，不可用于 Android。

基本使用

以下示例展示了如何使用 KotlinDL 构建经典的 LeNet-5 卷积神经网络，并在 MNIST 数据集上进行训练和评估。

import org.jetbrains.kotlinx.dl.api.core.*
import org.jetbrains.kotlinx.dl.api.core.initializer.*
import org.jetbrains.kotlinx.dl.api.core.layer.*
import org.jetbrains.kotlinx.dl.api.core.loss.Losses
import org.jetbrains.kotlinx.dl.api.core.metric.Metrics
import org.jetbrains.kotlinx.dl.api.core.optimizer.Adam
import org.jetbrains.kotlinx.dl.api.core.optimizer.ClipGradientByValue
import org.jetbrains.kotlinx.dl.dataset.mnist

private const val EPOCHS = 3
private const val TRAINING_BATCH_SIZE = 1000
private const val NUM_CHANNELS = 1L
private const val IMAGE_SIZE = 28L
private const val SEED = 12L
private const val TEST_BATCH_SIZE = 1000

// 定义模型结构
private val lenet5Classic = Sequential.of(
    Input(IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS),
    Conv2D(
        filters = 6,
        kernelSize = intArrayOf(5, 5),
        strides = intArrayOf(1, 1, 1, 1),
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Zeros(),
        padding = ConvPadding.SAME
    ),
    AvgPool2D(
        poolSize = intArrayOf(1, 2, 2, 1),
        strides = intArrayOf(1, 2, 2, 1),
        padding = ConvPadding.VALID
    ),
    Conv2D(
        filters = 16,
        kernelSize = intArrayOf(5, 5),
        strides = intArrayOf(1, 1, 1, 1),
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Zeros(),
        padding = ConvPadding.SAME
    ),
    AvgPool2D(
        poolSize = intArrayOf(1, 2, 2, 1),
        strides = intArrayOf(1, 2, 2, 1),
        padding = ConvPadding.VALID
    ),
    Flatten(),
    Dense(
        outputSize = 120,
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Constant(0.1f)
    ),
    Dense(
        outputSize = 84,
        activation = Activations.Tanh,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Constant(0.1f)
    ),
    Dense(
        outputSize = 10,
        activation = Activations.Linear,
        kernelInitializer = GlorotNormal(SEED),
        biasInitializer = Constant(0.1f)
    )
)

fun main() {
    // 加载 MNIST 数据集
    val (train, test) = mnist()
    
    lenet5Classic.use {
        // 编译模型：设置优化器、损失函数和评估指标
        it.compile(
            optimizer = Adam(clipGradient = ClipGradientByValue(0.1f)),
            loss = Losses.SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS,
            metric = Metrics.ACCURACY
        )
    
        it.logSummary() // 打印模型摘要
    
        // 训练模型
        it.fit(dataset = train, epochs = EPOCHS, batchSize = TRAINING_BATCH_SIZE)
    
        // 评估模型
        val accuracy = it.evaluate(dataset = test, batchSize = TEST_BATCH_SIZE).metrics[Metrics.ACCURACY]
    
        println("Accuracy: $accuracy")
    }
}

Jupyter Notebook 用户

如果您使用带有 Kotlin Kernel 的 Jupyter Notebook，可以直接在单元格中使用 @file:DependsOn 注解加载库：

@file:DependsOn("org.jetbrains.kotlinx:kotlin-deeplearning-tensorflow:0.5.2")
// 接下来即可运行上述模型代码