devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

将【深度学习】和【Spring Boot】集成：使用 DL4J 的综合指南

作者：秋刀鱼在做梦 | 2024-08-23 01:01:27

赞

踩

将【深度学习】和【Spring Boot】集成：使用 DL4J 的综合指南

1. 什么是DeepLearning4j？

DeepLearning4J (DL4J) 是一个基于 Java 的神经网络工具包，用于构建、训练和部署神经网络。DL4J 与 Hadoop 和Spark集成，支持分布式 CPU 和 GPU，专为商业环境而设计，而非研究工具用途。Skymind是 DL4J 的商业支持组织。Deeplearning4j 拥有先进的技术，旨在实现即插即用，有更多预设可供使用，避免冗余配置，即使非企业也可以快速进行原型设计。DL4J 还可以进行大规模定制。DL4J 在 Apache 2.0 许可下获得许可，所有基于它的衍生作品均为衍生作品。

2. Deeplearning4j 的功能

Deeplearning4j 包括分布式、多线程深度学习框架，以及常见的单线程深度学习框架。训练过程在集群中进行，这意味着 Deeplearning4j 可以快速处理大量数据。神经网络可以通过 [迭代简化] 并行训练，并且可以与 Java、Scala和Clojure并行使用，全部兼容。Deeplearning4j 能够作为开放堆栈中的模块组件，使其成为同类中第一个面向微服务架构的深度学习框架。

3. 场景设想

 示例：使用 Spring Boot、Java 和 DL4J 的贷款审批推荐系统

您想要在“贷款审批”应用程序中构建一个微服务，根据历史数据建议是否批准或拒绝贷款申请。该建议基于使用 DL4J 训练的机器学习模型。

4. 实施步骤

  1. 数据准备：收集和预处理历史贷款申请数据，包括信用评分、收入、贷款金额、就业状况和贷款违约历史等特征。
  2. 模型训练：使用 DL4J 对这些数据训练神经网络模型，将贷款申请分类为“批准”或“拒绝”。
  3. 集成到 Spring Boot：将训练好的模型作为 REST API 公开在 Spring Boot 应用程序中，以提供实时贷款审批建议。

5. 逐步实施细节

5.1 数据准备

创建一个 CSV 文件 (loan_data.csv)，其中包含 credit_score、income、loan_amount、employment_status 和 label 等列（其中 label 为 1 表示贷款已获批准，为 0 表示贷款已拒绝）。

  1. csv file
  2.  
  3. credit_score,income,loan_amount,employment_status,label
  4. 700,50000,20000,1,1
  5. 650,45000,15000,1,1
  6. 600,30000,25000,0,0
  7. 720,60000,22000,1,1
  8. 580,29000,18000,0,0

5.2 项目pom.xml设置

  • 首先创建一个新的 Spring Boot 项目。
  • 将 DL4J 和 ND4J 依赖项添加到项目的构建配置中（例如，在pom.xmlMaven 或build.gradleGradle 中）：
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.  
  5.     <groupId>com.example</groupId>
  6.     <artifactId>loan-approval</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <packaging>jar</packaging>
  9.  
  10.     <name>loan-approval</name>
  11.     <description>Loan Approval Recommendation System using DL4J</description>
  12.  
  13.     <parent>
  14.         <groupId>org.springframework.boot</groupId>
  15.         <artifactId>spring-boot-starter-parent</artifactId>
  16.         <version>2.7.1</version>
  17.         <relativePath/> <!-- lookup parent from repository -->
  18.     </parent>
  19.  
  20.     <properties>
  21.         <java.version>11</java.version>
  22.         <dl4j.version>1.0.0-M1.1</dl4j.version>
  23.     </properties>
  24.  
  25.     <dependencies>
  26.  
  27.         <!-- Spring Boot Starter Web -->
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-web</artifactId>
  31.         </dependency>
  32.  
  33.         <!-- Deeplearning4j Dependencies -->
  34.         <dependency>
  35.             <groupId>org.deeplearning4j</groupId>
  36.             <artifactId>deeplearning4j-core</artifactId>
  37.             <version>${dl4j.version}</version>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.deeplearning4j</groupId>
  41.             <artifactId>deeplearning4j-nn</artifactId>
  42.             <version>${dl4j.version}</version>
  43.         </dependency>
  44.         <dependency>
  45.             <groupId>org.nd4j</groupId>
  46.             <artifactId>nd4j-native-platform</artifactId>
  47.             <version>${dl4j.version}</version>
  48.         </dependency>
  49.  
  50.         <!-- DataVec (for CSV reading) -->
  51.         <dependency>
  52.             <groupId>org.datavec</groupId>
  53.             <artifactId>datavec-api</artifactId>
  54.             <version>${dl4j.version}</version>
  55.         </dependency>
  56.         <dependency>
  57.             <groupId>org.datavec</groupId>
  58.             <artifactId>datavec-local</artifactId>
  59.             <version>${dl4j.version}</version>
  60.         </dependency>
  61.  
  62.         <!-- Lombok (Optional, for reducing boilerplate code) -->
  63.         <dependency>
  64.             <groupId>org.projectlombok</groupId>
  65.             <artifactId>lombok</artifactId>
  66.             <scope>provided</scope>
  67.         </dependency>
  68.  
  69.         <!-- Spring Boot DevTools (Optional, for development convenience) -->
  70.         <dependency>
  71.             <groupId>org.springframework.boot</groupId>
  72.             <artifactId>spring-boot-devtools</artifactId>
  73.             <scope>runtime</scope>
  74.             <optional>true</optional>
  75.         </dependency>
  76.  
  77.         <!-- Spring Boot Test (Optional, for unit tests) -->
  78.         <dependency>
  79.             <groupId>org.springframework.boot</groupId>
  80.             <artifactId>spring-boot-starter-test</artifactId>
  81.             <scope>test</scope>
  82.         </dependency>
  83.  
  84.     </dependencies>
  85.  
  86.     <build>
  87.         <plugins>
  88.             <plugin>
  89.                 <groupId>org.springframework.boot</groupId>
  90.                 <artifactId>spring-boot-maven-plugin</artifactId>
  91.             </plugin>
  92.         </plugins>
  93.     </build>
  94.  
  95. </project>

5.3 使用 DL4J 进行模型训练

使用 Java 中的 DL4J 创建一个简单的神经网络模型。

  1. import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
  2. import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
  3. import org.deeplearning4j.nn.conf.layers.DenseLayer;
  4. import org.deeplearning4j.nn.conf.layers.OutputLayer;
  5. import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
  6. import org.deeplearning4j.nn.weights.WeightInit;
  7. import org.deeplearning4j.optimize.api.IterationListener;
  8. import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
  9. import org.nd4j.linalg.activations.Activation;
  10. import org.nd4j.linalg.dataset.DataSet;
  11. import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
  12. import org.nd4j.linalg.dataset.api.preprocessor.DataNormalization;
  13. import org.nd4j.linalg.dataset.api.preprocessor.NormalizerStandardize;
  14. import org.nd4j.linalg.factory.Nd4j;
  15. import org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction;
  16. import org.nd4j.linalg.dataset.api.iterator.RecordReaderDataSetIterator;
  17. import org.datavec.api.records.reader.impl.csv.CSVRecordReader;
  18. import org.datavec.api.split.FileSplit;
  19. import org.datavec.api.util.ClassPathResource;
  20.  
  21. public class LoanApprovalModel {
  22.  
  23.     public static void main(String[] args) throws Exception {
  24.         // Load dataset
  25.         int numLinesToSkip = 0;
  26.         char delimiter = ',';
  27.         CSVRecordReader recordReader = new CSVRecordReader(numLinesToSkip, delimiter);
  28.         recordReader.initialize(new FileSplit(new ClassPathResource("loan_data.csv").getFile()));
  29.         
  30.         int labelIndex = 4; // Index of the label (approve/reject)
  31.         int numClasses = 2; // Approve or Reject
  32.         int batchSize = 5;
  33.         DataSetIterator iterator = new RecordReaderDataSetIterator(recordReader, batchSize, labelIndex, numClasses);
  34.  
  35.         // Normalize the data
  36.         DataNormalization normalizer = new NormalizerStandardize();
  37.         normalizer.fit(iterator); 
  38.         iterator.setPreProcessor(normalizer);
  39.  
  40.         // Define the network configuration
  41.         MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
  42.             .iterations(1000)
  43.             .activation(Activation.RELU)
  44.             .weightInit(WeightInit.XAVIER)
  45.             .learningRate(0.01)
  46.             .list()
  47.             .layer(0, new DenseLayer.Builder().nIn(4).nOut(3).build())
  48.             .layer(1, new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD)
  49.                     .activation(Activation.SOFTMAX)
  50.                     .nIn(3).nOut(2).build())
  51.             .backprop(true).pretrain(false).build();
  52.  
  53.         MultiLayerNetwork model = new MultiLayerNetwork(conf);
  54.         model.init();
  55.         model.setListeners(new ScoreIterationListener(100));
  56.  
  57.         // 训练模型
  58.         for (int i = 0; i < 1000; i++) {
  59.             iterator.reset();
  60.             model.fit(iterator);
  61.         }
  62.  
  63.         // 保存模型
  64.         model.save(new File("loan_approval_model.zip"), true);
  65.     }
  66. }

5.4 与 Spring Boot 集成

创建一个 Spring Boot REST API，加载经过训练的模型并使用它来对新的贷款申请进行预测。

  1. import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
  2. import org.nd4j.linalg.factory.Nd4j;
  3. import org.nd4j.linalg.api.ndarray.INDArray;
  4. import org.springframework.web.bind.annotation.*;
  5.  
  6. import java.io.File;
  7. import java.io.IOException;
  8.  
  9. @RestController
  10. @RequestMapping("/loan")
  11. public class LoanApprovalController {
  12.  
  13.     private MultiLayerNetwork model;
  14.  
  15.     public LoanApprovalController() throws IOException {
  16.         // Load the trained model
  17.         model = MultiLayerNetwork.load(new File("loan_approval_model.zip"), true);
  18.     }
  19.  
  20.     @PostMapping("/approve")
  21.     public String approveLoan(@RequestBody LoanApplication loanApplication) {
  22.         // Prepare input data
  23.         INDArray input = Nd4j.create(new double[]{
  24.                 loanApplication.getCreditScore(),
  25.                 loanApplication.getIncome(),
  26.                 loanApplication.getLoanAmount(),
  27.                 loanApplication.getEmploymentStatus()
  28.         }, 1, 4);
  29.  
  30.         // Make prediction
  31.         INDArray output = model.output(input);
  32.         int prediction = Nd4j.argMax(output, 1).getInt(0);
  33.  
  34.         return prediction == 1 ? "Approved" : "Rejected";
  35.     }
  36. }
  37.  
  38. class LoanApplication {
  39.     private double creditScore;
  40.     private double income;
  41.     private double loanAmount;
  42.     private int employmentStatus;
  43.  
  44.     // Getters and setters
  45. }

5.5 运行应用程序

构建并运行您的 Spring Boot 应用程序。
向上面的web服务地址 /loan/approve 发送一个 POST 请求，其中包含代表贷款申请的 JSON 主体：

  1. {
  2.     "creditScore": 710,
  3.     "income": 55000,
  4.     "loanAmount": 20000,
  5.     "employmentStatus": 1
  6. }

API 将根据模型的预测返回“已批准”或“已拒绝”。

6. 结论

“使用 Spring Boot 和 DL4J 为‘贷款审批’应用程序开发了贷款审批推荐系统。实施了一个神经网络模型，根据申请人数据预测贷款审批，大大增强了决策过程并降低了违约风险。”


此示例演示了您使用现代 springboot框架将机器学习集成到生产环境的能力。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/1018748
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号