Java小白到AI全栈架构师代码大全

import org.tensorflow.Graph;
import org.tensorflow.Session;
import org.tensorflow.Tensor;
import org.tensorflow.types.UInt8;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class TensorFlowImageClassifier {
    // 模型相关配置
    private static final String MODEL_PATH = "models/mobilenet_v1_1.0_224_frozen.pb";
    private static final String LABELS_PATH = "models/labels.txt";
    private static final int INPUT_WIDTH = 224;
    private static final int INPUT_HEIGHT = 224;
    private static final String INPUT_TENSOR_NAME = "input";
    private static final String OUTPUT_TENSOR_NAME = "MobilenetV1/Predictions/Reshape_1";
    
    // 模型和会话
    private final Graph graph;
    private final Session session;
    private final List<String> labels;

    public TensorFlowImageClassifier() throws IOException {
        // 加载模型
        byte[] graphBytes = Files.readAllBytes(Paths.get(MODEL_PATH));
        this.graph = new Graph();
        this.graph.importGraphDef(graphBytes);
        this.session = new Session(graph);
        
        // 加载标签
        this.labels = loadLabels();
    }

    /**
     * 加载标签文件
     */
    private List<String> loadLabels() throws IOException {
        List<String> labels = new ArrayList<>();
        List<String> lines = Files.readAllLines(Paths.get(LABELS_PATH));
        for (String line : lines) {
            labels.add(line.trim());
        }
        return labels;
    }

    /**
     * 图像预处理
     * 将图像转换为模型需要的输入格式
     */
    private Tensor<Float> preprocessImage(String imagePath) throws IOException {
        // 读取图像
        BufferedImage originalImage = ImageIO.read(new File(imagePath));
        
        // 调整图像大小
        BufferedImage resizedImage = new BufferedImage(
            INPUT_WIDTH, INPUT_HEIGHT, BufferedImage.TYPE_3BYTE_BGR);
        
        Graphics2D g = resizedImage.createGraphics();
        g.drawImage(originalImage, 0, 0, INPUT_WIDTH, INPUT_HEIGHT, null);
        g.dispose();
        
        // 获取像素数据
        byte[] pixels = ((java.awt.image.DataBufferByte) resizedImage.getRaster().getDataBuffer()).getData();
        
        // 归一化像素值到[-1, 1]范围（MobileNet等模型的要求）
        float[] normalizedPixels = new float[INPUT_WIDTH * INPUT_HEIGHT * 3];
        for (int i = 0; i < pixels.length; i++) {
            normalizedPixels[i] = (pixels[i] & 0xFF) / 127.5f - 1.0f;
        }
        
        // 创建Tensor对象
        long[] shape = {1, INPUT_HEIGHT, INPUT_WIDTH, 3}; // [批次大小, 高度, 宽度, 通道数]
        return Tensor.create(Float.class, shape, FloatBuffer.wrap(normalizedPixels));
    }

    /**
     * 对图像进行分类
     */
    public List<PredictionResult> classifyImage(String imagePath, int topK) throws IOException {
        // 预处理图像
        try (Tensor<Float> inputTensor = preprocessImage(imagePath)) {
            // 运行模型进行预测
            Tensor<Float> outputTensor = session.runner()
                .feed(INPUT_TENSOR_NAME, inputTensor)
                .fetch(OUTPUT_TENSOR_NAME)
                .run()
                .get(0)
                .expect(Float.class);
            
            // 处理输出结果
            long[] outputShape = outputTensor.shape();
            int numClasses = (int) outputShape[1];
            
            float[] probabilities = new float[numClasses];
            outputTensor.writeTo(FloatBuffer.wrap(probabilities));
            
            // 获取概率最高的前K个结果
            return getTopKResults(probabilities, topK);
        }
    }

    /**
     * 获取概率最高的前K个预测结果
     */
    private List<PredictionResult> getTopKResults(float[] probabilities, int topK) {
        List<PredictionResult> results = new ArrayList<>();
        
        // 找出概率最高的前K个索引
        for (int i = 0; i < topK && i < probabilities.length; i++) {
            int maxIndex = 0;
            for (int j = 1; j < probabilities.length; j++) {
                if (probabilities[j] > probabilities[maxIndex]) {
                    maxIndex = j;
                }
            }
            
            // 添加到结果列表
            String label = maxIndex < labels.size() ? labels.get(maxIndex) : "Unknown";
            results.add(new PredictionResult(label, probabilities[maxIndex]));
            
            // 将已选中的最大值设为-1，以便下次找到次大值
            probabilities[maxIndex] = -1f;
        }
        
        return results;
    }

    /**
     * 释放资源
     */
    public void close() {
        session.close();
        graph.close();
    }

    /**
     * 预测结果类
     */
    public static class PredictionResult {
        private final String label;
        private final float probability;
        
        public PredictionResult(String label, float probability) {
            this.label = label;
            this.probability = probability;
        }
        
        public String getLabel() {
            return label;
        }
        
        public float getProbability() {
            return probability;
        }
        
        @Override
        public String toString() {
            return String.format("%s: %.2f%%", label, probability * 100);
        }
    }

    /**
     * 主方法示例
     */
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("请提供图像路径作为参数");
            return;
        }
        
        String imagePath = args[0];
        
        try (TensorFlowImageClassifier classifier = new TensorFlowImageClassifier()) {
            List<PredictionResult> results = classifier.classifyImage(imagePath, 5);
            
            System.out.println("图像识别结果（前5名）：");
            for (PredictionResult result : results) {
                System.out.println(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

### 准备工作
1. 下载TensorFlow Java库（在Maven或Gradle中添加依赖）
2. 获取预训练的图像识别模型（如MobileNet、ResNet等）
3. 准备模型对应的标签文件（用于将预测结果映射为类别名称）

### 实现代码

    
    

```xml
<?xml version="1.0" encoding="UTF-8"?>
<proje

```ct 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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>tensorflow-image-recognition</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- TensorFlow Java API -->
        <dependency>
            <groupId>org.tensorflow</groupId>
            <artifactId>tensorflow</artifactId>
            <version>1.15.0</version>
        </dependency>
        
        <!-- 用于图像处理 -->
        <dependency>
            <groupId>javax.media.jai</groupId>
            <artifactId>com.springsource.javax.media.jai.core</artifactId>
            <version>1.1.3</version>
        </dependency>
    </dependencies>
</project>