SpringBoot用深度学习模型识别数字：开发详解

àì夳堔傛蜴生んèń 2022-10-11 03:55 178阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 本篇概览 ###

*  前文[《三分钟体验：SpringBoot用深度学习模型识别数字》][SpringBoot]中，咱们轻点鼠标体验了一个Java应用，该应用集成了深度学习模型，能识别出图像中的手写数字，那篇文章以体验和操作为主，并没有谈到背后的实现
 *  此刻的您，如果之前对深度学习了解不多，只随着[《三分钟体验：SpringBoot用深度学习模型识别数字》][SpringBoot]做过简单体验，现在应该一头雾水，心中可能有以下疑问：

1.  前文提到的模型文件minist-model.zip是什么？怎么来的？
2.  SpringBoot拿到模型文件后，怎么用的？和识别功能有什么关系？

*  今天咱们一起来写代码，开发出前文的那个应用，也会解答您的疑问，整篇文章由以下内容构成：

1.  全流程概览
2.  训练实战
3.  SpringBoot应用的设计阶段，重点说明第一个关键点
4.  SpringBoot应用的设计阶段，重点说明第二个关键点
5.  SpringBoot应用的设计阶段，梳理完整的流程
6.  SpringBoot应用编码
7.  将应用制作成docker镜像

### 全流程概览 ###

*  简单的说，如果想通过深度学习来解决实际问题（以图片识别为例），需要要做好以下两件事：

1.  拿已有数据做训练，训练结果保存在模型文件中
2.  在业务代码中使用模型文件来识别图片

*  先说说训练：

1.  提前准备一些手写数字图片，这些图片对应的数字已确定，如下图，目录**9**下面全是9的手写体  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]
2.  编写训练模型的代码，设置神经网络的各种参数，例如：归一化、激活函数、损失函数、卷积层数等等
3.  执行训练模型的代码，将上述图片拿去训练
4.  将训练结果保存到文件中，这个文件就是模型文件，前文中就是minist-model.zip
5.  至此训练完成

*  接下来就是使用此模型文件解决实际问题

1.  开发一个业务应用
2.  应用中加载前面训练生成的模型文件
3.  收到用户提交的数据，交给模型处理
4.  将处理结果返回给用户

*  以上就是将深度学习用于业务场景的大致过程，接下来咱们从训练出发，开始实战过程

### 源码下载 ###

*  本篇实战中的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog\_demos)：

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">链接</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">项目主页</td> 
   <td align="left">https://github.com/zq2599/blog_demos</td> 
   <td align="left">该项目在GitHub上的主页</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(https)</td> 
   <td align="left">https://github.com/zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，https协议</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(ssh)</td> 
   <td align="left">git@github.com:zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，ssh协议</td> 
  </tr> 
 </tbody> 
</table>

*  这个git项目中有多个文件夹，《DL4J实战》系列的源码在dl4j-tutorials文件夹下，如下图红框所示：  
    ![在这里插入图片描述][20210614114655964.png_pic_center]
 *  dl4j-tutorials文件夹下有多个子工程，本次实战代码在dlfj-tutorials目录下，如下图红框：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]

### 训练实战 ###

*  整个训练的详细过程，也就是minist-model.zip的生成过程，已在[《DL4J实战之三：经典卷积实例(LeNet-5)》][DL4J_LeNet-5]一文中详细说明，也给出了完整的代码，您只要按照文中所说操作一遍即可，不过操作之前有个问题要特别注意：
 *  [《DL4J实战之三：经典卷积实例(LeNet-5)》][DL4J_LeNet-5]一文中使用的deeplearning4j框架的版本是1.0.0-beta6，请您将其改为1.0.0-beta7，具体的改动方法是打开simple-convolution工程的pom.xml文件(注意是simple-convolution工程，不是它的父工程dlfj-tutorials)，修改下图红框2位置的内容：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]
 *  改完后即可运行程序生成模型文件，然后进入使用模型的阶段
 *  您可能会问，为什么之 [《DL4J实战之三：经典卷积实例(LeNet-5)》][DL4J_LeNet-5]一文中会用1.0.0-beta6版本呢？其实那里是为了使用GPU加速训练过程，那时候1.0.0-beta7不支持CUDA-9.2，在本文中不会用到GPU加速，因此推荐使用1.0.0-beta7版本
 *  接下来开始开发SpringBoot应用，在应用中使用模型去识别图片

### SpringBoot应用设计（第一个关键点） ###

*  在设计阶段有两个关键点要提前注意，第一个和图片大小有关：在训练模型时，使用的图片都是28\*28像素，所以咱们的应用在收到用户提交的图片后，需要做缩放处理将其缩放到28\*28像素

### SpringBoot应用设计（第二个关键点） ###

*  再看看用于训练的图片，如下图，所有图片都是黑底白字：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]
 *  那么问题来了：模型是根据黑底白字训练的，无法识别白底黑字，遇到白底黑字的图片该如何处理呢？
 *  所以如果用户输入的是白底黑字的图片，咱们的程序来做颜色反转，将其变为黑底白字再做识别

### SpringBoot应用设计（流程设计） ###

*  现在咱们来梳理一下整个流程，如果用户输入的是白底黑字的图片，那么整个应用的处理流程如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]
 *  如果用户输入的是黑底白字的图片，只需要将上述流程中的反色处理去掉即可
 *  为白底黑字图片提供专用接口predict-with-white-background
 *  为黑底白字图片提供专用接口predict-with-black-background
 *  现在设计工作已经完成，可以开始编码了

### 使用模型（编码） ###

*  为了便于管理demo代码和依赖库的版本，[《DL4J实战之一：准备》][DL4J]一文中创建了名为dl4j-tutorials的maven工程，咱们今天新建的应用也是dl4j-tutorials的子工程，名为predict-number-image，其自身的pom.xml内容如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>dlfj-tutorials</artifactId>
            <groupId>com.bolingcavalry</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>predict-number-image</artifactId>
    
        <packaging>jar</packaging>
    
        
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>${springboot.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
    
            <dependency>
                <groupId>com.bolingcavalry</groupId>
                <artifactId>commons</artifactId>
                <version>${project.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.nd4j</groupId>
                
                
                <artifactId>nd4j-native-platform</artifactId>
            </dependency>
    
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <mainClass>com.bolingcavalry.predictnumber.PredictNumberApplication</mainClass>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </project>

*  可见predict-number-image工程与其父工程dlfj-tutorials的关系不大，仅仅使用了父工程定义的几个库的版本号而已，您也可以独立创建一个没有父子关系的工程；
 *  新建配置文件application.properties，里面有图片相关的配置：

# 上传文件总的最大值
    spring.servlet.multipart.max-request-size=1024MB
    
    # 单个文件的最大值
    spring.servlet.multipart.max-file-size=10MB
    
    # 处理图片文件的目录
    predict.imagefilepath=/app/images/
    
    # 模型所在位置
    predict.modelpath=/app/model/minist-model.zip

*  将处理图片所需的静态方法集中在ImageFileUtil.java的文件中，主要是save（存到磁盘上）、resize（缩放）、colorRevert（反色）、clear（清理）、getGrayImageFeatures（提取特征，操作和训练时的是一样的）：

package com.bolingcavalry.commons.utils;
    
    import lombok.extern.slf4j.Slf4j;
    import org.datavec.api.split.FileSplit;
    import org.datavec.image.loader.NativeImageLoader;
    import org.datavec.image.recordreader.ImageRecordReader;
    import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;
    import org.nd4j.linalg.api.ndarray.INDArray;
    import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
    import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler;
    import org.springframework.web.multipart.MultipartFile;
    import javax.imageio.ImageIO;
    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.IOException;
    import java.util.UUID;
    
    @Slf4j
    public class ImageFileUtil { 
    
        /** * 调整后的文件宽度 */
        public static final int RESIZE_WIDTH = 28;
    
        /** * 调整后的文件高度 */
        public static final int RESIZE_HEIGHT = 28;
    
        /** * 将上传的文件存在服务器上 * @param base 要处理的文件所在的目录 * @param file 要处理的文件 * @return */
        public static String save(String base, MultipartFile file) { 
    
            // 检查是否为空
            if (file.isEmpty()) { 
                log.error("invalid file");
                return null;
            }
    
            // 文件名来自原始文件
            String fileName = file.getOriginalFilename();
    
            // 要保存的位置
            File dest = new File(base + fileName);
    
            // 开始保存
            try { 
                file.transferTo(dest);
            } catch (IOException e) { 
                log.error("upload fail", e);
                return null;
            }
    
            return fileName;
        }
    
        /** * 将图片转为28*28像素 * @param base 处理文件的目录 * @param fileName 待调整的文件名 * @return */
        public static String resize(String base, String fileName) { 
    
            // 新文件名是原文件名在加个随机数后缀，而且扩展名固定为png
            String resizeFileName = fileName.substring(0, fileName.lastIndexOf(".")) + "-" + UUID.randomUUID() + ".png";
    
            log.info("start resize, from [{}] to [{}]", fileName, resizeFileName);
    
            try { 
                // 读原始文件
                BufferedImage bufferedImage = ImageIO.read(new File(base + fileName));
    
                // 缩放后的实例
                Image image = bufferedImage.getScaledInstance(RESIZE_WIDTH, RESIZE_HEIGHT, Image.SCALE_SMOOTH);
    
                BufferedImage resizeBufferedImage = new BufferedImage(28, 28, BufferedImage.TYPE_INT_RGB);
                Graphics graphics = resizeBufferedImage.getGraphics();
    
                // 绘图
                graphics.drawImage(image, 0, 0, null);
                graphics.dispose();
    
                // 转换后的图片写文件
                ImageIO.write(resizeBufferedImage, "png", new File(base + resizeFileName));
    
            } catch (Exception exception) { 
                log.info("resize error from [{}] to [{}], {}", fileName, resizeFileName, exception);
                resizeFileName = null;
            }
    
            log.info("finish resize, from [{}] to [{}]", fileName, resizeFileName);
    
            return resizeFileName;
        }
    
        /** * 将RGB转为int数字 * @param alpha * @param red * @param green * @param blue * @return */
        private static int colorToRGB(int alpha, int red, int green, int blue) { 
            int pixel = 0;
    
            pixel += alpha;
            pixel = pixel << 8;
    
            pixel += red;
            pixel = pixel << 8;
    
            pixel += green;
            pixel = pixel << 8;
    
            pixel += blue;
    
            return pixel;
        }
    
        /** * 反色处理 * @param base 处理文件的目录 * @param src 用于处理的源文件 * @return 反色处理后的新文件 * @throws IOException */
        public static String colorRevert(String base, String src) throws IOException { 
            int color, r, g, b, pixel;
    
            // 读原始文件
            BufferedImage srcImage = ImageIO.read(new File(base + src));
    
            // 修改后的文件
            BufferedImage destImage = new BufferedImage(srcImage.getWidth(), srcImage.getHeight(), srcImage.getType());
    
            for (int i=0; i<srcImage.getWidth(); i++) { 
    
                for (int j=0; j<srcImage.getHeight(); j++) { 
                    color = srcImage.getRGB(i, j);
                    r = (color >> 16) & 0xff;
                    g = (color >> 8) & 0xff;
                    b = color & 0xff;
                    pixel = colorToRGB(255, 0xff - r, 0xff - g, 0xff - b);
                    destImage.setRGB(i, j, pixel);
                }
            }
    
            // 反射文件的名字
            String revertFileName =  src.substring(0, src.lastIndexOf(".")) + "-revert.png";
    
            // 转换后的图片写文件
            ImageIO.write(destImage, "png", new File(base + revertFileName));
    
            return revertFileName;
        }
    
        /** * 取黑白图片的特征 * @param base * @param fileName * @return * @throws Exception */
        public static INDArray getGrayImageFeatures(String base, String fileName) throws Exception { 
            log.info("start getImageFeatures [{}]", base + fileName);
    
            // 和训练模型时一样的设置
            ImageRecordReader imageRecordReader = new ImageRecordReader(RESIZE_HEIGHT, RESIZE_WIDTH, 1);
    
            FileSplit fileSplit = new FileSplit(new File(base + fileName),
                    NativeImageLoader.ALLOWED_FORMATS);
    
            imageRecordReader.initialize(fileSplit);
    
            DataSetIterator dataSetIterator = new RecordReaderDataSetIterator(imageRecordReader, 1);
            dataSetIterator.setPreProcessor(new ImagePreProcessingScaler(0, 1));
    
            // 取特征
            return dataSetIterator.next().getFeatures();
        }
    
        /** * 批量清理文件 * @param base 处理文件的目录 * @param fileNames 待清理文件集合 */
        public static void clear(String base, String...fileNames) { 
            for (String fileName : fileNames) { 
    
                if (null==fileName) { 
                    continue;
                }
    
                File file = new File(base + fileName);
    
                if (file.exists()) { 
                    file.delete();
                }
            }
        }
    }

*  定义service层，只有一个方法，可以通过入参决定是否做反色处理：

package com.bolingcavalry.predictnumber.service;
    
    import org.springframework.web.multipart.MultipartFile;
    
    public interface PredictService { 
    
        /** * 取得上传的图片，做转换后识别成数字 * @param file 上传的文件 * @param isNeedRevert 是否要做反色处理 * @return */
        int predict(MultipartFile file, boolean isNeedRevert) throws Exception ;
    }

*  sevice层的实现，也是本篇的核心，有几处要注意的地方稍后会提到：

package com.bolingcavalry.predictnumber.service.impl;
    
    import com.bolingcavalry.commons.utils.ImageFileUtil;
    import com.bolingcavalry.predictnumber.service.PredictService;
    import lombok.extern.slf4j.Slf4j;
    import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
    import org.deeplearning4j.util.ModelSerializer;
    import org.nd4j.linalg.api.ndarray.INDArray;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    import javax.annotation.PostConstruct;
    import java.io.File;
    
    @Service
    @Slf4j
    public class PredictServiceImpl implements PredictService { 
    
        /** * -1表示识别失败 */
        private static final int RLT_INVALID = -1;
    
        /** * 模型文件的位置 */
        @Value("${predict.modelpath}")
        private String modelPath;
    
        /** * 处理图片文件的目录 */
        @Value("${predict.imagefilepath}")
        private String imageFilePath;
    
        /** * 神经网络 */
        private MultiLayerNetwork net;
    
        /** * bean实例化成功就加载模型 */
        @PostConstruct
        private void loadModel() { 
            log.info("load model from [{}]", modelPath);
    
            // 加载模型
            try { 
                net = ModelSerializer.restoreMultiLayerNetwork(new File(modelPath));
                log.info("module summary\n{}", net.summary());
            } catch (Exception exception) { 
                log.error("loadModel error", exception);
            }
        }
    
        @Override
        public int predict(MultipartFile file, boolean isNeedRevert) throws Exception { 
            log.info("start predict, file [{}], isNeedRevert [{}]", file.getOriginalFilename(), isNeedRevert);
    
            // 先存文件
            String rawFileName = ImageFileUtil.save(imageFilePath, file);
    
            if (null==rawFileName) { 
                return RLT_INVALID;
            }
    
            // 反色处理后的文件名
            String revertFileName = null;
    
            // 调整大小后的文件名
            String resizeFileName;
    
            // 是否需要反色处理
            if (isNeedRevert) { 
                // 把原始文件做反色处理，返回结果是反色处理后的新文件
                revertFileName = ImageFileUtil.colorRevert(imageFilePath, rawFileName);
    
                // 把反色处理后调整为28*28大小的文件
                resizeFileName = ImageFileUtil.resize(imageFilePath, revertFileName);
            } else { 
                // 直接把原始文件调整为28*28大小的文件
                resizeFileName = ImageFileUtil.resize(imageFilePath, rawFileName);
            }
    
            // 现在已经得到了结果反色和调整大小处理过后的文件，
            // 那么原始文件和反色处理过的文件就可以删除了
            ImageFileUtil.clear(imageFilePath, rawFileName, revertFileName);
    
            // 取出该黑白图片的特征
            INDArray features = ImageFileUtil.getGrayImageFeatures(imageFilePath, resizeFileName);
    
            // 将特征传给模型去识别
            return net.predict(features)[0];
        }
    }

*  上述代码中，有两需要注意：

1.  loadModel方法在bean初始化时会执行，里面通过ModelSerializer.restoreMultiLayerNetwork完成模型文件加载
2.  真正的识别操作其实就是MultiLayerNetwork.predict方法，一步而已，何其简单

*  然后是web接口层，对外提供两个接口：

package com.bolingcavalry.predictnumber.controller;
    
    import com.bolingcavalry.predictnumber.service.PredictService;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.multipart.MultipartFile;
    
    @RestController
    public class PredictController { 
    
        final PredictService predictService;
    
        public PredictController(PredictService predictService) { 
            this.predictService = predictService;
        }
    
        @PostMapping("/predict-with-black-background")
        @ResponseBody
        public int predictWithBlackBackground(@RequestParam("file") MultipartFile file) throws Exception { 
            // 训练模型的时候，用的数字是白字黑底，
            // 因此如果上传白字黑底的图片，可以直接拿去识别，而无需反色处理
            return predictService.predict(file, false);
        }
    
        @PostMapping("/predict-with-white-background")
        @ResponseBody
        public int predictWithWhiteBackground(@RequestParam("file") MultipartFile file) throws Exception { 
            // 训练模型的时候，用的数字是白字黑底，
            // 因此如果上传黑字白底的图片，就需要做反色处理，
            // 反色之后就是白字黑底了，可以拿去识别
            return predictService.predict(file, true);
        }
    }

*  最后是启动类：

package com.bolingcavalry.predictnumber;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    @SpringBootApplication
    public class PredictNumberApplication { 
        public static void main(String[] args) { 
            SpringApplication.run(PredictNumberApplication.class, args);
        }
    }

*  此时代码编写已经完成了，您现在就可以运行此应用来验证功能了，不过事情还没结束，因为在[《三分钟体验：SpringBoot用深度学习模型识别数字》][SpringBoot]一文中，咱们是用docker来体验功能的，所以接下来咱们将这个SpringBoot应用做成docker镜像

### 制作docker镜像 ###

*  将SpringBoot应用做成docker镜像有很多方法，这里选用的是SpringBoot官方推荐的方式：
 *  先把Dockerfile文件写好，放在predict-number-image目录下，可见只是简单的文件复制操作，然后指定启动命令：

# 8-jdk-alpine版本启动的时候会crash
    FROM openjdk:8u292-jdk
    
    # 创建目录
    RUN mkdir -p /app/images && mkdir -p /app/model
    
    # 指定镜像的内容的来源位置
    ARG DEPENDENCY=target/dependency
    
    # 复制内容到镜像
    COPY ${DEPENDENCY}/BOOT-INF/lib /app/lib
    COPY ${DEPENDENCY}/META-INF /app/META-INF
    COPY ${DEPENDENCY}/BOOT-INF/classes /app
    
    # 指定启动命令
    ENTRYPOINT ["java","-cp","app:app/lib/*","com.bolingcavalry.predictnumber.PredictNumberApplication"]

*  接下来准备Dockerfile中所需的那些文件，在父工程目录下执行mvn clean package -U，这是个纯粹的maven操作，和docker没有任何关系
 *  进入predict-number-image目录，执行以下命令，作用是从jar文件中提取class、配置文件、依赖库等内容到target/dependency目录:

mkdir -p target/dependency && (cd target/dependency; jar -xf ../*.jar)

*  最后，在Dockerfile文件所在目录执行命令docker build -t bolingcavalry/dl4j-model-app:0.0.3 .(命令的最后有个点，不要漏了)，即可完成镜像制作
 *  如果您有hub.docker.com的账号，还可以通过docker push命令把镜像推送到中央仓库，让更多的人用到：
 *  最后，再来回顾一下[《三分钟体验：SpringBoot用深度学习模型识别数字》][SpringBoot]一文中启动docker容器的命令，如下可见，通过两个-v参数，将宿主机的目录映射到容器中，因此，容器中的/app/images和/app/model可以保持不变，只要能保证宿主机的目录映射正确即可：

docker run \
    --rm \
    -p 18080:8080 \
    -v /home/will/temp/202106/29/images:/app/images \
    -v /home/will/temp/202106/29/model:/app/model \
    bolingcavalry/dl4j-model-app:0.0.3

*  有关SpringBoot官方推荐的docker镜像制作的更多信息，请参考[《SpringBoot(2.4)应用制作Docker镜像(Gradle版官方方案)》][SpringBoot_2.4_Docker_Gradle]
 *  至此，SpringBoot用深度学习模型识别数字的开发实战就完成了，如果您是一位对深度学习感兴趣的java程序员，相信本文能给您带来一些参考，更多深度学习的实战请关注欣宸的《DL4J实战》系列原创；

### 你不孤单，欣宸原创一路相伴 ###

1.  [Java系列][Java]
2.  [Spring系列][Spring]
3.  [Docker系列][Docker]
4.  [kubernetes系列][kubernetes]
5.  [数据库+中间件系列][Link 1]
6.  [DevOps系列][DevOps]

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[SpringBoot]: https://blog.csdn.net/boling_cavalry/article/details/118290933
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/2d5b4c984b0849dfa4797257b314d9e7.png
[20210614114655964.png_pic_center]: /images/20221005/fff0f77d513f4776aa8c0f0bc1695845.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221005/6e9491acf5144b71bf5a64743cd1c689.png
[DL4J_LeNet-5]: https://blog.csdn.net/boling_cavalry/article/details/118239403
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221005/365e33a7feac4d3c903e5d72881a9d1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221005/c324614ce5f74dfb96021bf01c9d28c5.png
[DL4J]: https://blog.csdn.net/boling_cavalry/article/details/117898354
[SpringBoot_2.4_Docker_Gradle]: https://blog.csdn.net/boling_cavalry/article/details/115451129
[Java]: https://xinchen.blog.csdn.net/article/details/105068742
[Spring]: https://xinchen.blog.csdn.net/article/details/105086498
[Docker]: https://xinchen.blog.csdn.net/article/details/105086732
[kubernetes]: https://xinchen.blog.csdn.net/article/details/105086794
[Link 1]: https://xinchen.blog.csdn.net/article/details/105086850
[DevOps]: https://xinchen.blog.csdn.net/article/details/105086920