本文目录导读：
我将为您提供几个Java AI应用的典型案例，涵盖不同的AI领域。
图像识别案例 - 手写数字识别
import org.deeplearning4j.datasets.iterator.impl.MnistDataSetIterator;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.learning.config.Adam;
import org.nd4j.linalg.lossfunctions.LossFunctions;
/**
* 使用DL4J实现手写数字识别
*/
public class MnistClassifier {
public static void main(String[] args) throws Exception {
// 加载MNIST数据集
DataSetIterator trainData = new MnistDataSetIterator(64, true, 12345);
DataSetIterator testData = new MnistDataSetIterator(64, false, 12345);
// 构建神经网络模型
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
.updater(new Adam(0.001))
.list()
.layer(0, new DenseLayer.Builder()
.nIn(28 * 28)
.nOut(256)
.activation(Activation.RELU)
.build())
.layer(1, new DenseLayer.Builder()
.nIn(256)
.nOut(128)
.activation(Activation.RELU)
.build())
.layer(2, new OutputLayer.Builder()
.nIn(128)
.nOut(10)
.activation(Activation.SOFTMAX)
.lossFunction(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
.build())
.build();
// 创建模型
MultiLayerNetwork model = new MultiLayerNetwork(conf);
model.init();
// 添加训练监听器
model.setListeners(new ScoreIterationListener(100));
// 训练模型
System.out.println("开始训练模型...");
int epochs = 10;
for (int epoch = 0; epoch < epochs; epoch++) {
model.fit(trainData);
System.out.println("Epoch " + (epoch + 1) + " 完成");
}
// 评估模型
Evaluation eval = new Evaluation(10);
while (testData.hasNext()) {
DataSet batch = testData.next();
INDArray output = model.output(batch.getFeatures());
eval.eval(batch.getLabels(), output);
}
System.out.println("模型准确率: " + eval.accuracy());
System.out.println(eval.stats());
// 保存模型
model.save(new java.io.File("mnist_model.zip"));
System.out.println("模型已保存");
}
}
自然语言处理案例 - 情感分析
import edu.stanford.nlp.ling.CoreAnnotations;
import edu.stanford.nlp.neural.rnn.RNNCoreAnnotations;
import edu.stanford.nlp.pipeline.Annotation;
import edu.stanford.nlp.pipeline.StanfordCoreNLP;
import edu.stanford.nlp.sentiment.SentimentCoreAnnotations;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.util.CoreMap;
import java.util.Properties;
/**
* 使用Stanford CoreNLP进行情感分析
*/
public class SentimentAnalyzer {
private StanfordCoreNLP pipeline;
public SentimentAnalyzer() {
// 初始化NLP管道
Properties props = new Properties();
props.setProperty("annotators", "tokenize, ssplit, parse, sentiment");
pipeline = new StanfordCoreNLP(props);
}
/**
* 分析文本情感
* @param text 要分析的文本
* @return 情感得分 (0=非常消极, 1=消极, 2=中性, 3=积极, 4=非常积极)
*/
public int analyzeSentiment(String text) {
Annotation annotation = pipeline.process(text);
int mainSentiment = 0;
int longestSentence = 0;
for (CoreMap sentence : annotation.get(CoreAnnotations.SentencesAnnotation.class)) {
Tree tree = sentence.get(SentimentCoreAnnotations.SentimentAnnotatedTree.class);
int sentiment = RNNCoreAnnotations.getPredictedClass(tree);
String sentenceText = sentence.get(CoreAnnotations.TextAnnotation.class);
if (sentenceText.length() > longestSentence) {
mainSentiment = sentiment;
longestSentence = sentenceText.length();
}
}
return mainSentiment;
}
/**
* 将情感得分转换为文本描述
*/
public String getSentimentDescription(int sentiment) {
switch (sentiment) {
case 0: return "非常消极";
case 1: return "消极";
case 2: return "中性";
case 3: return "积极";
case 4: return "非常积极";
default: return "未知";
}
}
public static void main(String[] args) {
SentimentAnalyzer analyzer = new SentimentAnalyzer();
String[] texts = {
"I love this product! It's amazing!",
"The service was terrible and the staff was rude.",
"The weather today is quite nice.",
"This movie was disappointing and boring.",
"Great experience, highly recommend!"
};
for (String text : texts) {
int sentiment = analyzer.analyzeSentiment(text);
System.out.println("文本: " + text);
System.out.println("情感: " + analyzer.getSentimentDescription(sentiment));
System.out.println("------------------------");
}
}
}
智能推荐系统案例
import org.apache.mahout.cf.taste.common.TasteException;
import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
import org.apache.mahout.cf.taste.impl.neighborhood.NearestNUserNeighborhood;
import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity;
import org.apache.mahout.cf.taste.model.DataModel;
import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.cf.taste.recommender.Recommender;
import org.apache.mahout.cf.taste.similarity.UserSimilarity;
import java.io.File;
import java.io.IOException;
import java.util.List;
/**
* 使用Apache Mahout实现协同过滤推荐系统
*/
public class RecommendationSystem {
/**
* 构建基于用户协同过滤的推荐器
*/
public static Recommender buildUserBasedRecommender(File dataFile) throws IOException, TasteException {
// 加载数据模型
DataModel model = new FileDataModel(dataFile);
// 计算用户相似度（基于皮尔逊相关系数）
UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
// 定义用户邻域（取最近的100个用户）
UserNeighborhood neighborhood = new NearestNUserNeighborhood(100, similarity, model);
// 构建推荐器
return new GenericUserBasedRecommender(model, neighborhood, similarity);
}
/**
* 为指定用户生成推荐
*/
public static void recommendForUser(Recommender recommender, long userId, int numRecommendations)
throws TasteException {
List<RecommendedItem> recommendations = recommender.recommend(userId, numRecommendations);
System.out.println("为用户 " + userId + " 推荐 " + numRecommendations + " 个项目:");
for (RecommendedItem recommendation : recommendations) {
System.out.println(" 项目 " + recommendation.getItemID() +
" (评分: " + recommendation.getValue() + ")");
}
}
/**
* 创建示例数据文件
*/
public static File createSampleData() throws IOException {
// 创建临时文件存储评分数据
File dataFile = File.createTempFile("ratings", ".csv");
dataFile.deleteOnExit();
StringBuilder sb = new StringBuilder();
// 格式: 用户ID,项目ID,评分
sb.append("1,101,5.0\n");
sb.append("1,102,4.0\n");
sb.append("1,103,3.0\n");
sb.append("2,101,4.0\n");
sb.append("2,102,5.0\n");
sb.append("2,104,2.0\n");
sb.append("3,101,3.0\n");
sb.append("3,104,4.0\n");
sb.append("3,105,5.0\n");
sb.append("4,103,5.0\n");
sb.append("4,105,4.0\n");
sb.append("4,106,3.0\n");
java.nio.file.Files.write(dataFile.toPath(), sb.toString().getBytes());
return dataFile;
}
public static void main(String[] args) {
try {
// 创建示例数据
File dataFile = createSampleData();
// 构建推荐系统
Recommender recommender = buildUserBasedRecommender(dataFile);
// 为用户1生成推荐
recommendForUser(recommender, 1, 3);
// 为用户3生成推荐
recommendForUser(recommender, 3, 3);
} catch (Exception e) {
e.printStackTrace();
}
}
}
实时预测系统案例
import com.github.pemistahl.lingua.api.Language;
import com.github.pemistahl.lingua.api.LanguageDetector;
import com.github.pemistahl.lingua.api.LanguageDetectorBuilder;
import org.knowm.xchart.*;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.factory.Nd4j;
import java.util.*;
import java.util.stream.Collectors;
/**
* 智能文本分类和语言检测系统
*/
public class IntelligentTextSystem {
// 语言检测器
private LanguageDetector languageDetector;
public IntelligentTextSystem() {
// 初始化语言检测器
languageDetector = LanguageDetectorBuilder.fromAllLanguages().build();
}
/**
* 检测文本语言
*/
public Language detectLanguage(String text) {
return languageDetector.detectLanguageOf(text);
}
/**
* 简单的关键词分类器
*/
public String categorizeText(String text) {
String lowerText = text.toLowerCase();
Map<String, Double> scores = new HashMap<>();
// 定义分类关键词
scores.put("技术", calcScore(lowerText,
Arrays.asList("java", "python", "code", "programming", "software", "algorithm")));
scores.put("金融", calcScore(lowerText,
Arrays.asList("money", "bank", "finance", "stock", "investment", "loan")));
scores.put("医疗", calcScore(lowerText,
Arrays.asList("health", "doctor", "hospital", "medicine", "patient", "disease")));
scores.put("教育", calcScore(lowerText,
Arrays.asList("school", "teacher", "student", "education", "course", "learning")));
// 返回得分最高的分类
return scores.entrySet().stream()
.max(Map.Entry.comparingByValue())
.get().getKey();
}
private double calcScore(String text, List<String> keywords) {
return keywords.stream()
.filter(text::contains)
.count() * 1.0;
}
/**
* 生成简易数据可视化
*/
public void visualizeData() {
// 创建示例数据
String[] categories = {"技术", "金融", "医疗", "教育"};
int[] counts = {352, 214, 178, 265};
// 创建柱状图
CategoryChart chart = new CategoryChartBuilder()
.width(800)
.height(600)
.title("文本分类统计")
.xAxisTitle("分类")
.yAxisTitle("数量")
.build();
// 添加数据
chart.addSeries("文本数量", Arrays.asList(categories),
Arrays.stream(counts).boxed().collect(Collectors.toList()));
// 保存图表
try {
new SwingWrapper<>(chart).displayChart();
} catch (Exception e) {
System.out.println("图表显示失败: " + e.getMessage());
}
}
public static void main(String[] args) {
IntelligentTextSystem system = new IntelligentTextSystem();
// 测试文本
String[] texts = {
"Java is a powerful programming language for enterprise applications",
"The stock market showed significant growth this quarter",
"Patients with chronic diseases need regular medical checkups",
"University students are preparing for their final examinations"
};
for (String text : texts) {
// 语言检测
Language lang = system.detectLanguage(text);
// 文本分类
String category = system.categorizeText(text);
// 输出结果
System.out.println("文本内容: " + text);
System.out.println("检测语言: " + lang);
System.out.println("文本分类: " + category);
System.out.println("------------------------");
}
// 生成可视化
system.visualizeData();
}
/**
* 辅助类：用于处理中文文本的简单关键词分类
*/
public static class ChineseTextCategorizer {
private Map<String, List<String>> rules;
public ChineseTextCategorizer() {
rules = new HashMap<>();
rules.put("科技", Arrays.asList("人工智能", "大数据", "云计算", "区块链", "互联网"));
rules.put("体育", Arrays.asList("足球", "篮球", "比赛", "运动员", "奥运会"));
rules.put("娱乐", Arrays.asList("电影", "音乐", "明星", "综艺", "演唱会"));
}
public String categorize(String text) {
for (Map.Entry<String, List<String>> entry : rules.entrySet()) {
if (entry.getValue().stream().anyMatch(text::contains)) {
return entry.getKey();
}
}
return "其他";
}
}
}
深度学习集成案例 - 图像分类与目标检测
import org.deeplearning4j.nn.api.Model;
import org.nd4j.linalg.api.ndarray.INDArray;
import java.util.concurrent.*;
/**
* AI模型管理平台
*/
public class AIModelManager {
private Map<String, Model> models = new ConcurrentHashMap<>();
private ExecutorService executor = Executors.newFixedThreadPool(4);
/**
* 注册模型
*/
public void registerModel(String name, Model model) {
models.put(name, model);
System.out.println("模型 " + name + " 已注册");
}
/**
* 异步执行预测
*/
public CompletableFuture<INDArray> predictAsync(String modelName, INDArray input) {
return CompletableFuture.supplyAsync(() -> {
try {
Model model = models.get(modelName);
if (model == null) {
throw new IllegalArgumentException("模型不存在: " + modelName);
}
// 这里是示例代码，实际需要根据模型类型调用相应的预测方法
// 假设模型是MultiLayerNetwork
if (model instanceof org.deeplearning4j.nn.multilayer.MultiLayerNetwork) {
org.deeplearning4j.nn.multilayer.MultiLayerNetwork net =
(org.deeplearning4j.nn.multilayer.MultiLayerNetwork) model;
return net.output(input);
}
throw new IllegalArgumentException("不支持的模型类型");
} catch (Exception e) {
System.err.println("预测失败: " + e.getMessage());
throw new CompletionException(e);
}
}, executor);
}
/**
* 模型热更新
*/
public void updateModel(String modelName, Model newModel) {
models.put(modelName, newModel);
System.out.println("模型 " + modelName + " 已更新");
}
/**
* 获取所有模型信息
*/
public Map<String, String> getModelInfo() {
return models.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
e -> e.getValue().getClass().getSimpleName()
));
}
/**
* 关闭资源
*/
public void shutdown() {
executor.shutdown();
try {
if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
executor.shutdownNow();
}
} catch (InterruptedException e) {
executor.shutdownNow();
Thread.currentThread().interrupt();
}
}
}
常用AI库/框架
- DL4J (DeepLearning4J)：深度学习框架
- Stanford CoreNLP：NLP处理
- Apache Mahout/MLlib：机器学习算法
- Weka：数据挖掘工具
- MOA：大规模数据分析
学习建议
- 从基础开始：先掌握Java基础，再学习AI相关框架
- 动手实践：尝试解决实际问题
- 理解算法：深入学习算法原理
- 关注性能：Java的并发和性能优化很重要
- 整合生态：熟悉Hadoop、Spark等大数据生态
这些案例涵盖了Java在AI开发中的主要应用场景,需要根据实际需求选择合适的框架和算法。
