Spring Boot集成DeepLearning4j实现图片数字识别

1.什么是DeepLearning4j？

DeepLearning4J（DL4J）是一套基于Java语言的神经网络工具包，可以构建、定型和部署神经网络。DL4J与Hadoop和Spark集成，支持分布式CPU和GPU，为商业环境（而非研究工具目的）所设计。Skymind是DL4J的商业支持机构。 Deeplearning4j拥有先进的技术，以即插即用为目标，通过更多预设的使用，避免多余的配置，让非企业也能够进行快速的原型制作。DL4J同时可以规模化定制。DL4J遵循Apache 2.0许可协议，一切以其为基础的衍生作品均属于衍生作品的作

Deeplearning4j的功能

Deeplearning4j包括了分布式、多线程的深度学习框架，以及普通的单线程深度学习框架。定型过程以集群进行，也就是说，Deeplearning4j可以快速处理大量数据。神经网络可通过[迭代化简]平行定型，与 Java、 Scala 和 Clojure 均兼容。Deeplearning4j在开放堆栈中作为模块组件的功能，使之成为首个为微服务架构打造的深度学习框架。

Deeplearning4j的组件

深度神经网络能够实现前所未有的准确度。对神经网络的简介请参见概览页。简而言之，Deeplearning4j能够让你从各类浅层网络（其中每一层在英文中被称为layer）出发，设计深层神经网络。这一灵活性使用户可以根据所需，在分布式、生产级、能够在分布式CPU或GPU的基础上与Spark和Hadoop协同工作的框架内，整合受限玻尔兹曼机、其他自动编码器、卷积网络或递归网络。 此处为我们已经建立的各个库及其在系统整体中的所处位置：  

DeepLearning4J用于设计神经网络：

• Deeplearning4j（简称DL4J）是为Java和Scala编写的首个商业级开源分布式深度学习
• DL4J与Hadoop和Spark集成，为商业环境（而非研究工具目的）所设计。
• 支持GPU和CPU
• 受到 Cloudera, Hortonwork, NVIDIA, Intel, IBM 等认证，可以在Spark, Flink, Hadoop 上运行
• 支持并行迭代算法架构
• DeepLearning4J的JavaDoc可在此处获取
• DeepLearning4J示例的Github代码库请见此处。相关示例的简介汇总请见此处。
• 开源工具 ASF 2.0许可证：github.com/deeplearning4j/deeplearning4j

2.训练模型

训练和测试数据集下载

https://raw.githubusercontent.com/zq2599/blog_download_files/master/files/mnist_png.tar.gz

MNIST简介

• MNIST是经典的计算机视觉数据集，来源是National Institute of Standards and Technology (NIST，美国国家标准与技术研究所)，包含各种手写数字图片，其中训练集60,000张，测试集 10,000张，
• MNIST来源于250 个不同人的手写,其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员.，测试集(test set) 也是同样比例的手写数字数据
• MNIST官网：http://yann.lecun.com/exdb/mnist/

数据集简介

从MNIST官网下载的原始数据并非图片文件，需要按官方给出的格式说明做解析处理才能转为一张张图片，这些事情显然不是本篇的主题，因此咱们可以直接使用DL4J为我们准备好的数据集(下载地址稍后给出)，该数据集中是一张张独立的图片，这些图片所在目录的名字就是该图片具体的数字

模型训练

LeNet-5简介

LeNet-5 结构：

• 输入层

图片大小为 32×32×1，其中 1 表示为黑白图像，只有一个 channel。

• 卷积层

filter 大小 5×5，filter 深度（个数）为 6，padding 为 0， 卷积步长 s=1=1，输出矩阵大小为 28×28×6，其中 6 表示 filter 的个数。

• 池化层

average pooling，filter 大小 2×2（即 f=2=2），步长 s=2=2，no padding，输出矩阵大小为 14×14×6。

• 卷积层

filter 大小 5×5，filter 个数为 16，padding 为 0， 卷积步长 s=1=1，输出矩阵大小为 10×10×16，其中 16 表示 filter 的个数。

• 池化层

average pooling，filter 大小 2×2（即 f=2=2），步长 s=2=2，no padding，输出矩阵大小为 5×5×16。注意，在该层结束，需要将 5×5×16 的矩阵flatten 成一个 400 维的向量。

• 全连接层（Fully Connected layer，FC）

neuron 数量为 120。

• 全连接层（Fully Connected layer，FC）

neuron 数量为 84。

• 全连接层，输出层

现在版本的 LeNet-5 输出层一般会采用 softmax 激活函数，在 LeNet-5 提出的论文中使用的激活函数不是 softmax，但其现在不常用。该层神经元数量为 10，代表 0～9 十个数字类别。（图 1 其实少画了一个表示全连接层的方框，而直接用 ^y^ 表示输出层。）  

1. /*******************************************************************************

2. * Copyright (c) 2020 Konduit K.K.

3. * Copyright (c) 2015-2019 Skymind, Inc.

4. *

5. * This program and the accompanying materials are made available under the

6. * terms of the Apache License, Version 2.0 which is available at

7. * https://www.apache.org/licenses/LICENSE-2.0.

8. *

9. * Unless required by applicable law or agreed to in writing, software

10. * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

11. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

12. * License for the specific language governing permissions and limitations

13. * under the License.

14. *

15. * SPDX-License-Identifier: Apache-2.0

16. ******************************************************************************/

18. package com.et.dl4j.model;

20. import lombok.extern.slf4j.Slf4j;

21. import org.datavec.api.io.labels.ParentPathLabelGenerator;

22. import org.datavec.api.split.FileSplit;

23. import org.datavec.image.loader.NativeImageLoader;

24. import org.datavec.image.recordreader.ImageRecordReader;

25. import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;

26. import org.deeplearning4j.nn.conf.MultiLayerConfiguration;

27. import org.deeplearning4j.nn.conf.NeuralNetConfiguration;

28. import org.deeplearning4j.nn.conf.inputs.InputType;

29. import org.deeplearning4j.nn.conf.layers.ConvolutionLayer;

30. import org.deeplearning4j.nn.conf.layers.DenseLayer;

31. import org.deeplearning4j.nn.conf.layers.OutputLayer;

32. import org.deeplearning4j.nn.conf.layers.SubsamplingLayer;

33. import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;

34. import org.deeplearning4j.nn.weights.WeightInit;

35. import org.deeplearning4j.optimize.listeners.ScoreIterationListener;

36. import org.deeplearning4j.util.ModelSerializer;

37. import org.nd4j.evaluation.classification.Evaluation;

38. import org.nd4j.linalg.activations.Activation;

39. import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;

40. import org.nd4j.linalg.dataset.api.preprocessor.DataNormalization;

41. import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler;

42. import org.nd4j.linalg.learning.config.Nesterovs;

43. import org.nd4j.linalg.lossfunctions.LossFunctions;

44. import org.nd4j.linalg.schedule.MapSchedule;

45. import org.nd4j.linalg.schedule.ScheduleType;

47. import java.io.File;

48. import java.util.HashMap;

49. import java.util.Map;

50. import java.util.Random;

52. /**

53. * Implementation of LeNet-5 for handwritten digits image classification on MNIST dataset (99% accuracy)

54. * <a href="http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf">[LeCun et al., 1998. Gradient based learning applied to document recognition]</a>

55. * Some minor changes are made to the architecture like using ReLU and identity activation instead of

56. * sigmoid/tanh, max pooling instead of avg pooling and softmax output layer.

57. * <p>

58. * This example will download 15 Mb of data on the first run.

59. *

60. * @author hanlon

61. * @author agibsonccc

62. * @author fvaleri

63. * @author dariuszzbyrad

64. */

65. @Slf4j

66. public class LeNetMNISTReLu {

67. //dataset github：https://raw.githubusercontent.com/zq2599/blog_download_files/master/files/mnist_png.tar.gz

68. // 存放文件的地址，请酌情修改

69. // private static final String BASE_PATH = System.getProperty("java.io.tmpdir") + "/mnist";

70. private static final String BASE_PATH = "/Users/liuhaihua/Downloads";

72. public static void main(String[] args) throws Exception {

73. // 图片像素高

74. int height = 28;

75. // 图片像素宽

76. int width = 28;

78. // 因为是黑白图像，所以颜色通道只有一个

79. int channels = 1;

81. // 分类结果，0-9，共十种数字

82. int outputNum = 10;

84. // 批大小

85. int batchSize = 54;

87. // 循环次数

88. int nEpochs = 1;

90. // 初始化伪随机数的种子

91. int seed = 1234;

93. // 随机数工具

94. Random randNumGen = new Random(seed);

96. log.info("检查数据集文件夹是否存在：{}", BASE_PATH + "/mnist_png");

98. if (!new File(BASE_PATH + "/mnist_png").exists()) {

99. log.info("数据集文件不存在，请下载压缩包并解压到：{}", BASE_PATH);

100. return;

101. }

103. // 标签生成器，将指定文件的父目录作为标签

104. ParentPathLabelGenerator labelMaker = new ParentPathLabelGenerator();

105. // 归一化配置(像素值从0-255变为0-1)

106. DataNormalization imageScaler = new ImagePreProcessingScaler();

108. // 不论训练集还是测试集，初始化操作都是相同套路：

109. // 1. 读取图片，数据格式为NCHW

110. // 2. 根据批大小创建的迭代器

111. // 3. 将归一化器作为预处理器

113. log.info("训练集的矢量化操作...");

114. // 初始化训练集

115. File trainData = new File(BASE_PATH + "/mnist_png/training");

116. FileSplit trainSplit = new FileSplit(trainData, NativeImageLoader.ALLOWED_FORMATS, randNumGen);

117. ImageRecordReader trainRR = new ImageRecordReader(height, width, channels, labelMaker);

118. trainRR.initialize(trainSplit);

119. DataSetIterator trainIter = new RecordReaderDataSetIterator(trainRR, batchSize, 1, outputNum);

120. // 拟合数据(实现类中实际上什么也没做)

121. imageScaler.fit(trainIter);

122. trainIter.setPreProcessor(imageScaler);

124. log.info("测试集的矢量化操作...");

125. // 初始化测试集，与前面的训练集操作类似

126. File testData = new File(BASE_PATH + "/mnist_png/testing");

127. FileSplit testSplit = new FileSplit(testData, NativeImageLoader.ALLOWED_FORMATS, randNumGen);

128. ImageRecordReader testRR = new ImageRecordReader(height, width, channels, labelMaker);

129. testRR.initialize(testSplit);

130. DataSetIterator testIter = new RecordReaderDataSetIterator(testRR, batchSize, 1, outputNum);

131. testIter.setPreProcessor(imageScaler); // same normalization for better results

133. log.info("配置神经网络");

135. // 在训练中，将学习率配置为随着迭代阶梯性下降

136. Map<Integer, Double> learningRateSchedule = new HashMap<>();

137. learningRateSchedule.put(0, 0.06);

138. learningRateSchedule.put(200, 0.05);

139. learningRateSchedule.put(600, 0.028);

140. learningRateSchedule.put(800, 0.0060);

141. learningRateSchedule.put(1000, 0.001);

143. // 超参数

144. MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()

145. .seed(seed)

146. // L2正则化系数

147. .l2(0.0005)

148. // 梯度下降的学习率设置

149. .updater(new Nesterovs(new MapSchedule(ScheduleType.ITERATION, learningRateSchedule)))

150. // 权重初始化

151. .weightInit(WeightInit.XAVIER)

152. // 准备分层

153. .list()

154. // 卷积层

155. .layer(new ConvolutionLayer.Builder(5, 5)

156. .nIn(channels)

157. .stride(1, 1)

158. .nOut(20)

159. .activation(Activation.IDENTITY)

160. .build())

161. // 下采样，即池化

162. .layer(new SubsamplingLayer.Builder(SubsamplingLayer.PoolingType.MAX)

163. .kernelSize(2, 2)

164. .stride(2, 2)

165. .build())

166. // 卷积层

167. .layer(new ConvolutionLayer.Builder(5, 5)

168. .stride(1, 1) // nIn need not specified in later layers

169. .nOut(50)

170. .activation(Activation.IDENTITY)

171. .build())

172. // 下采样，即池化

173. .layer(new SubsamplingLayer.Builder(SubsamplingLayer.PoolingType.MAX)

174. .kernelSize(2, 2)

175. .stride(2, 2)

176. .build())

177. // 稠密层，即全连接

178. .layer(new DenseLayer.Builder().activation(Activation.RELU)

179. .nOut(500)

180. .build())

181. // 输出

182. .layer(new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)

183. .nOut(outputNum)

184. .activation(Activation.SOFTMAX)

185. .build())

186. .setInputType(InputType.convolutionalFlat(height, width, channels)) // InputType.convolutional for normal image

187. .build();

189. MultiLayerNetwork net = new MultiLayerNetwork(conf);

190. net.init();

192. // 每十个迭代打印一次损失函数值

193. net.setListeners(new ScoreIterationListener(10));

195. log.info("神经网络共[{}]个参数", net.numParams());

197. long startTime = System.currentTimeMillis();

198. // 循环操作

199. for (int i = 0; i < nEpochs; i++) {

200. log.info("第[{}]个循环", i);

201. net.fit(trainIter);

202. Evaluation eval = net.evaluate(testIter);

203. log.info(eval.stats());

204. trainIter.reset();

205. testIter.reset();

206. }

207. log.info("完成训练和测试，耗时[{}]毫秒", System.currentTimeMillis()-startTime);

209. // 保存模型

210. File ministModelPath = new File(BASE_PATH + "/minist-model.zip");

211. ModelSerializer.writeModel(net, ministModelPath, true);

212. log.info("最新的MINIST模型保存在[{}]", ministModelPath.getPath());

213. }

214. }

输出模型文件和得分结果

3.编写模型预测接口

pom.xml

1. <?xml version="1.0" encoding="UTF-8"?>

2. <project xmlns="http://maven.apache.org/POM/4.0.0"

3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

5. <parent>

6. <artifactId>springboot-demo</artifactId>

7. <groupId>com.et</groupId>

8. <version>1.0-SNAPSHOT</version>

9. </parent>

10. <modelVersion>4.0.0</modelVersion>

12. <artifactId>Deeplearning4j</artifactId>

14. <properties>

15. <maven.compiler.source>8</maven.compiler.source>

16. <maven.compiler.target>8</maven.compiler.target>

17. <dl4j-master.version>1.0.0-beta7</dl4j-master.version>

18. <nd4j.backend>nd4j-native</nd4j.backend>

19. </properties>

20. <dependencies>

22. <dependency>

23. <groupId>org.springframework.boot</groupId>

24. <artifactId>spring-boot-starter-web</artifactId>

25. </dependency>

27. <dependency>

28. <groupId>org.springframework.boot</groupId>

29. <artifactId>spring-boot-autoconfigure</artifactId>

30. </dependency>

31. <dependency>

32. <groupId>org.springframework.boot</groupId>

33. <artifactId>spring-boot-starter-test</artifactId>

34. <scope>test</scope>

35. </dependency>

36. <dependency>

37. <groupId>org.projectlombok</groupId>

38. <artifactId>lombok</artifactId>

39. <version>1.18.20</version>

40. </dependency>

42. <dependency>

43. <groupId>ch.qos.logback</groupId>

44. <artifactId>logback-classic</artifactId>

45. </dependency>

47. <dependency>

48. <groupId>org.deeplearning4j</groupId>

49. <artifactId>deeplearning4j-core</artifactId>

50. <version>${dl4j-master.version}</version>

51. </dependency>

53. <dependency>

54. <groupId>org.nd4j</groupId>

55. <artifactId>${nd4j.backend}</artifactId>

56. <version>${dl4j-master.version}</version>

57. </dependency>

59. <!--用于本地GPU-->

60. <!-- <dependency>-->

61. <!-- <groupId>org.deeplearning4j</groupId>-->

62. <!-- <artifactId>deeplearning4j-cuda-9.2</artifactId>-->

63. <!-- <version>${dl4j-master.version}</version>-->

64. <!-- </dependency>-->

66. <!-- <dependency>-->

67. <!-- <groupId>org.nd4j</groupId>-->

68. <!-- <artifactId>nd4j-cuda-9.2-platform</artifactId>-->

69. <!-- <version>${dl4j-master.version}</version>-->

70. <!-- </dependency>-->

73. </dependencies>

74. </project>

cotroller

1. package com.et.dl4j.controller;

3. import com.et.dl4j.service.PredictService;

4. import org.springframework.beans.factory.annotation.Autowired;

5. import org.springframework.web.bind.annotation.*;

6. import org.springframework.web.multipart.MultipartFile;

8. import java.util.HashMap;

9. import java.util.Map;

11. @RestController

12. public class HelloWorldController {

13. @RequestMapping("/hello")

14. public Map<String, Object> showHelloWorld(){

15. Map<String, Object> map = new HashMap<>();

16. map.put("msg", "HelloWorld");

17. return map;

18. }

19. @Autowired

20. PredictService predictService;

23. @PostMapping("/predict-with-black-background")

24. public int predictWithBlackBackground(@RequestParam("file") MultipartFile file) throws Exception {

25. // 训练模型的时候，用的数字是白字黑底，

26. // 因此如果上传白字黑底的图片，可以直接拿去识别，而无需反色处理

27. return predictService.predict(file, false);

28. }

30. @PostMapping("/predict-with-white-background")

31. public int predictWithWhiteBackground(@RequestParam("file") MultipartFile file) throws Exception {

32. // 训练模型的时候，用的数字是白字黑底，

33. // 因此如果上传黑字白底的图片，就需要做反色处理，

34. // 反色之后就是白字黑底了，可以拿去识别

35. return predictService.predict(file, true);

36. }

37. }

service

1. package com.et.dl4j.service;

3. import org.springframework.web.multipart.MultipartFile;

6. public interface PredictService {

8. /**

9. * 取得上传的图片，做转换后识别成数字

10. * @param file 上传的文件

11. * @param isNeedRevert 是否要做反色处理

12. * @return

13. */

14. int predict(MultipartFile file, boolean isNeedRevert) throws Exception ;

15. }

1. package com.et.dl4j.service.impl;

2. import com.et.dl4j.service.PredictService;

3. import com.et.dl4j.util.ImageFileUtil;

4. import lombok.extern.slf4j.Slf4j;

5. import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;

6. import org.deeplearning4j.util.ModelSerializer;

7. import org.nd4j.linalg.api.ndarray.INDArray;

8. import org.springframework.beans.factory.annotation.Value;

9. import org.springframework.stereotype.Service;

10. import org.springframework.web.multipart.MultipartFile;

12. import javax.annotation.PostConstruct;

13. import java.io.File;

16. @Service

17. @Slf4j

18. public class PredictServiceImpl implements PredictService {

20. /**

21. * -1表示识别失败

22. */

23. private static final int RLT_INVALID = -1;

25. /**

26. * 模型文件的位置

27. */

28. @Value("${predict.modelpath}")

29. private String modelPath;

31. /**

32. * 处理图片文件的目录

33. */

34. @Value("${predict.imagefilepath}")

35. private String imageFilePath;

37. /**

38. * 神经网络

39. */

40. private MultiLayerNetwork net;

42. /**

43. * bean实例化成功就加载模型

44. */

45. @PostConstruct

46. private void loadModel() {

47. log.info("load model from [{}]", modelPath);

49. // 加载模型

50. try {

51. net = ModelSerializer.restoreMultiLayerNetwork(new File(modelPath));

52. log.info("module summary\n{}", net.summary());

53. } catch (Exception exception) {

54. log.error("loadModel error", exception);

55. }

56. }

58. @Override

59. public int predict(MultipartFile file, boolean isNeedRevert) throws Exception {

60. log.info("start predict, file [{}], isNeedRevert [{}]", file.getOriginalFilename(), isNeedRevert);

62. // 先存文件

63. String rawFileName = ImageFileUtil.save(imageFilePath, file);

65. if (null==rawFileName) {

66. return RLT_INVALID;

67. }

69. // 反色处理后的文件名

70. String revertFileName = null;

72. // 调整大小后的文件名

73. String resizeFileName;

75. // 是否需要反色处理

76. if (isNeedRevert) {

77. // 把原始文件做反色处理，返回结果是反色处理后的新文件

78. revertFileName = ImageFileUtil.colorRevert(imageFilePath, rawFileName);

80. // 把反色处理后调整为28*28大小的文件

81. resizeFileName = ImageFileUtil.resize(imageFilePath, revertFileName);

82. } else {

83. // 直接把原始文件调整为28*28大小的文件

84. resizeFileName = ImageFileUtil.resize(imageFilePath, rawFileName);

85. }

87. // 现在已经得到了结果反色和调整大小处理过后的文件，

88. // 那么原始文件和反色处理过的文件就可以删除了

89. ImageFileUtil.clear(imageFilePath, rawFileName, revertFileName);

91. // 取出该黑白图片的特征

92. INDArray features = ImageFileUtil.getGrayImageFeatures(imageFilePath, resizeFileName);

94. // 将特征传给模型去识别

95. return net.predict(features)[0];

96. }

97. }

application.properties

1. # 上传文件总的最大值

2. spring.servlet.multipart.max-request-size=1024MB

4. # 单个文件的最大值

5. spring.servlet.multipart.max-file-size=10MB

7. # 处理图片文件的目录

8. predict.imagefilepath=/Users/liuhaihua/Downloads/images/

10. # 模型所在位置

11. predict.modelpath=/Users/liuhaihua/Downloads/minist-model.zip

工具类

1. package com.et.dl4j.util;

3. import lombok.extern.slf4j.Slf4j;

4. import org.datavec.api.split.FileSplit;

5. import org.datavec.image.loader.NativeImageLoader;

6. import org.datavec.image.recordreader.ImageRecordReader;

7. import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;

8. import org.nd4j.linalg.api.ndarray.INDArray;

9. import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;

10. import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler;

11. import org.springframework.web.multipart.MultipartFile;

13. import javax.imageio.ImageIO;

14. import java.awt.*;

15. import java.awt.image.BufferedImage;

16. import java.io.File;

17. import java.io.IOException;

18. import java.util.UUID;

21. @Slf4j

22. public class ImageFileUtil {

24. /**

25. * 调整后的文件宽度

26. */

27. public static final int RESIZE_WIDTH = 28;

29. /**

30. * 调整后的文件高度

31. */

32. public static final int RESIZE_HEIGHT = 28;

34. /**

35. * 将上传的文件存在服务器上

36. * @param base 要处理的文件所在的目录

37. * @param file 要处理的文件

38. * @return

39. */

40. public static String save(String base, MultipartFile file) {

42. // 检查是否为空

43. if (file.isEmpty()) {

44. log.error("invalid file");

45. return null;

46. }

48. // 文件名来自原始文件

49. String fileName = file.getOriginalFilename();

51. // 要保存的位置

52. File dest = new File(base + fileName);

54. // 开始保存

55. try {

56. file.transferTo(dest);

57. } catch (IOException e) {

58. log.error("upload fail", e);

59. return null;

60. }

62. return fileName;

63. }

65. /**

66. * 将图片转为28*28像素

67. * @param base 处理文件的目录

68. * @param fileName 待调整的文件名

69. * @return

70. */

71. public static String resize(String base, String fileName) {

73. // 新文件名是原文件名在加个随机数后缀，而且扩展名固定为png

74. String resizeFileName = fileName.substring(0, fileName.lastIndexOf(".")) + "-" + UUID.randomUUID() + ".png";

76. log.info("start resize, from [{}] to [{}]", fileName, resizeFileName);

78. try {

79. // 读原始文件

80. BufferedImage bufferedImage = ImageIO.read(new File(base + fileName));

82. // 缩放后的实例

83. Image image = bufferedImage.getScaledInstance(RESIZE_WIDTH, RESIZE_HEIGHT, Image.SCALE_SMOOTH);

85. BufferedImage resizeBufferedImage = new BufferedImage(28, 28, BufferedImage.TYPE_INT_RGB);

86. Graphics graphics = resizeBufferedImage.getGraphics();

88. // 绘图

89. graphics.drawImage(image, 0, 0, null);

90. graphics.dispose();

92. // 转换后的图片写文件

93. ImageIO.write(resizeBufferedImage, "png", new File(base + resizeFileName));

95. } catch (Exception exception) {

96. log.info("resize error from [{}] to [{}], {}", fileName, resizeFileName, exception);

97. resizeFileName = null;

98. }

100. log.info("finish resize, from [{}] to [{}]", fileName, resizeFileName);

102. return resizeFileName;

103. }

105. /**

106. * 将RGB转为int数字

107. * @param alpha

108. * @param red

109. * @param green

110. * @param blue

111. * @return

112. */

113. private static int colorToRGB(int alpha, int red, int green, int blue) {

114. int pixel = 0;

116. pixel += alpha;

117. pixel = pixel << 8;

119. pixel += red;

120. pixel = pixel << 8;

122. pixel += green;

123. pixel = pixel << 8;

125. pixel += blue;

127. return pixel;

128. }

130. /**

131. * 反色处理

132. * @param base 处理文件的目录

133. * @param src 用于处理的源文件

134. * @return 反色处理后的新文件

135. * @throws IOException

136. */

137. public static String colorRevert(String base, String src) throws IOException {

138. int color, r, g, b, pixel;

140. // 读原始文件

141. BufferedImage srcImage = ImageIO.read(new File(base + src));

143. // 修改后的文件

144. BufferedImage destImage = new BufferedImage(srcImage.getWidth(), srcImage.getHeight(), srcImage.getType());

146. for (int i=0; i<srcImage.getWidth(); i++) {

148. for (int j=0; j<srcImage.getHeight(); j++) {

149. color = srcImage.getRGB(i, j);

150. r = (color >> 16) & 0xff;

151. g = (color >> 8) & 0xff;

152. b = color & 0xff;

153. pixel = colorToRGB(255, 0xff - r, 0xff - g, 0xff - b);

154. destImage.setRGB(i, j, pixel);

155. }

156. }

158. // 反射文件的名字

159. String revertFileName = src.substring(0, src.lastIndexOf(".")) + "-revert.png";

161. // 转换后的图片写文件

162. ImageIO.write(destImage, "png", new File(base + revertFileName));

164. return revertFileName;

165. }

167. /**

168. * 取黑白图片的特征

169. * @param base

170. * @param fileName

171. * @return

172. * @throws Exception

173. */

174. public static INDArray getGrayImageFeatures(String base, String fileName) throws Exception {

175. log.info("start getImageFeatures [{}]", base + fileName);

177. // 和训练模型时一样的设置

178. ImageRecordReader imageRecordReader = new ImageRecordReader(RESIZE_HEIGHT, RESIZE_WIDTH, 1);

180. FileSplit fileSplit = new FileSplit(new File(base + fileName),

181. NativeImageLoader.ALLOWED_FORMATS);

183. imageRecordReader.initialize(fileSplit);

185. DataSetIterator dataSetIterator = new RecordReaderDataSetIterator(imageRecordReader, 1);

186. dataSetIterator.setPreProcessor(new ImagePreProcessingScaler(0, 1));

188. // 取特征

189. return dataSetIterator.next().getFeatures();

190. }

192. /**

193. * 批量清理文件

194. * @param base 处理文件的目录

195. * @param fileNames 待清理文件集合

196. */

197. public static void clear(String base, String...fileNames) {

198. for (String fileName : fileNames) {

200. if (null==fileName) {

201. continue;

202. }

204. File file = new File(base + fileName);

206. if (file.exists()) {

207. file.delete();

208. }

209. }

210. }

213. }

DemoApplication.java

1. package com.et.dl4j;

3. import org.springframework.boot.SpringApplication;

4. import org.springframework.boot.autoconfigure.SpringBootApplication;

6. @SpringBootApplication

7. public class DemoApplication {

9. public static void main(String[] args) {

10. SpringApplication.run(DemoApplication.class, args);

11. }

12. }

以上只是一些关键代码，所有代码请参见下面代码仓库

代码仓库

• GitHub - Harries/springboot-demo: a simple springboot demo with some components for example: redis,solr,rockmq and so on.

4.测试

启动Spring Boot应用，上传图片测试

• 如果用户输入的是黑底白字的图片，只需要将上述流程中的反色处理去掉即可
• 为白底黑字图片提供专用接口predict-with-white-background
• 为黑底白字图片提供专用接口predict-with-black-background

5.引用