详细解释一下Java中使用TensorFlow进行图像识别的实现代码

import org.tensorflow.Graph;
import org.tensorflow.Operation;
import org.tensorflow.Output;
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.*;
import java.nio.FloatBuffer;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.List;

/**
 * TensorFlow图像分类器实现类
 * 功能：使用预训练的TensorFlow模型对图像进行分类识别
 */
public class TensorFlowImageClassifier implements AutoCloseable {
    // 模型相关配置
    private final String modelPath;      // 模型文件路径
    private final String labelsPath;     // 标签文件路径
    private final int inputHeight;       // 模型输入图像高度
    private final int inputWidth;        // 模型输入图像宽度
    private final String inputName;      // 输入张量名称
    private final String outputName;     // 输出张量名称
    
    // TensorFlow核心组件
    private Graph graph;
    private Session session;
    private List<String> labels;         // 类别标签列表

    /**
     * 构造函数：初始化分类器
     * @param modelPath 模型文件路径(.pb格式)
     * @param labelsPath 标签文件路径
     * @param inputHeight 输入图像高度
     * @param inputWidth 输入图像宽度
     * @param inputName 输入张量名称
     * @param outputName 输出张量名称
     * @throws IOException 加载文件时可能抛出的异常
     */
    public TensorFlowImageClassifier(
            String modelPath, 
            String labelsPath, 
            int inputHeight, 
            int inputWidth, 
            String inputName, 
            String outputName) throws IOException {
        
        this.modelPath = modelPath;
        this.labelsPath = labelsPath;
        this.inputHeight = inputHeight;
        this.inputWidth = inputWidth;
        this.inputName = inputName;
        this.outputName = outputName;
        
        // 初始化模型和标签
        init();
    }

    /**
     * 初始化方法：加载模型和标签
     * @throws IOException 加载文件时可能抛出的异常
     */
    private void init() throws IOException {
        // 加载模型
        byte[] graphBytes = Files.readAllBytes(Paths.get(modelPath));
        graph = new Graph();
        graph.importGraphDef(graphBytes);
        session = new Session(graph);
        
        // 加载标签
        labels = loadLabels(labelsPath);
        System.out.println("成功加载模型和标签，类别数量：" + labels.size());
    }

    /**
     * 加载标签文件
     * @param labelsPath 标签文件路径
     * @return 标签列表
     * @throws IOException 读取文件异常
     */
    private List<String> loadLabels(String labelsPath) throws IOException {
        List<String> labels = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader(labelsPath))) {
            String line;
            while ((line = br.readLine()) != null) {
                labels.add(line.trim());
            }
        }
        return labels;
    }

    /**
     * 图像分类主方法
     * @param imagePath 图像文件路径
     * @param topK 返回概率最高的前K个结果
     * @return 分类结果列表，包含类别名称和对应概率
     * @throws IOException 读取图像异常
     */
    public List<ClassificationResult> classifyImage(String imagePath, int topK) throws IOException {
        // 1. 读取并预处理图像
        Tensor<Float> imageTensor = preprocessImage(imagePath);
        
        try {
            // 2. 执行模型推理
            float[] predictions = executeInference(imageTensor);
            
            // 3. 处理并返回结果
            return processResults(predictions, topK);
        } finally {
            // 释放张量资源
            imageTensor.close();
        }
    }

    /**
     * 图像预处理：将图像转换为模型所需的输入格式
     * @param imagePath 图像文件路径
     * @return 处理后的图像张量
     * @throws IOException 读取或处理图像异常
     */
    private Tensor<Float> preprocessImage(String imagePath) throws IOException {
        // 读取图像文件
        BufferedImage originalImage = ImageIO.read(new File(imagePath));
        
        // 调整图像大小至模型输入尺寸
        BufferedImage resizedImage = resizeImage(originalImage, inputWidth, inputHeight);
        
        // 将图像转换为RGB格式
        BufferedImage rgbImage = convertToRGB(resizedImage);
        
        // 提取像素数据并归一化
        float[] pixelData = extractPixels(rgbImage);
        
        // 创建符合模型输入要求的张量
        long[] shape = {1, inputHeight, inputWidth, 3}; // 批次大小为1，3个颜色通道
        return Tensor.create(Float.class, shape, FloatBuffer.wrap(pixelData));
    }

    /**
     * 调整图像大小
     * @param image 原始图像
     * @param width 目标宽度
     * @param height 目标高度
     * @return 调整后的图像
     */
    private BufferedImage resizeImage(BufferedImage image, int width, int height) {
        BufferedImage resizedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = resizedImage.createGraphics();
        g.drawImage(image, 0, 0, width, height, null);
        g.dispose();
        return resizedImage;
    }

    /**
     * 将图像转换为RGB格式
     * @param image 原始图像
     * @return RGB格式图像
     */
    private BufferedImage convertToRGB(BufferedImage image) {
        if (image.getType() == BufferedImage.TYPE_INT_RGB) {
            return image;
        }
        
        BufferedImage rgbImage = new BufferedImage(
            image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB);
        rgbImage.getGraphics().drawImage(image, 0, 0, null);
        return rgbImage;
    }

    /**
     * 提取像素数据并进行归一化
     * @param image 处理后的图像
     * @return 归一化的像素数据数组
     */
    private float[] extractPixels(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        int[] pixels = new int[width * height];
        image.getRGB(0, 0, width, height, pixels, 0, width);
        
        float[] pixelData = new float[width * height * 3];
        int index = 0;
        
        for (int pixel : pixels) {
            // 提取RGB通道值 (0-255)
            int red = (pixel >> 16) & 0xFF;
            int green = (pixel >> 8) & 0xFF;
            int blue = pixel & 0xFF;
            
            // 归一化到[-1, 1]范围 (适用于大多数预训练模型)
            pixelData[index++] = (red - 127.5f) / 127.5f;
            pixelData[index++] = (green - 127.5f) / 127.5f;
            pixelData[index++] = (blue - 127.5f) / 127.5f;
        }
        
        return pixelData;
    }

    /**
     * 执行模型推理
     * @param imageTensor 预处理后的图像张量
     * @return 模型输出的概率数组
     */
    private float[] executeInference(Tensor<Float> imageTensor) {
        // 构建输入张量映射
        Map<String, Tensor<?>> inputs = new HashMap<>();
        inputs.put(inputName, imageTensor);
        
        // 指定输出张量
        List<Tensor<?>> outputs = session.runner()
                .feed(inputName, imageTensor)
                .fetch(outputName)
                .run();
        
        try {
            // 解析输出结果
            Tensor<Float> resultTensor = outputs.get(0).expect(Float.class);
            long[] shape = resultTensor.shape();
            int numClasses = (int) shape[1]; // 获取类别数量
            
            float[] predictions = new float[numClasses];
            resultTensor.copyTo(predictions);
            
            return predictions;
        } finally {
            // 释放输出张量资源
            for (Tensor<?> t : outputs) {
                t.close();
            }
        }
    }

    /**
     * 处理推理结果，获取概率最高的前K个类别
     * @param predictions 模型输出的概率数组
     * @param topK 要返回的前K个结果
     * @return 排序后的分类结果列表
     */
    private List<ClassificationResult> processResults(float[] predictions, int topK) {
        // 创建包含所有类别及其概率的列表
        List<ClassificationResult> results = new ArrayList<>();
        for (int i = 0; i < predictions.length; i++) {
            // 确保标签索引不越界
            String label = i < labels.size() ? labels.get(i) : "unknown";
            results.add(new ClassificationResult(label, predictions[i]));
        }
        
        // 按概率降序排序
        results.sort((a, b) -> Float.compare(b.getProbability(), a.getProbability()));
        
        // 返回前K个结果
        return results.subList(0, Math.min(topK, results.size()));
    }

    /**
     * 释放资源
     */
    @Override
    public void close() {
        if (session != null) {
            session.close();
        }
        if (graph != null) {
            graph.close();
        }
    }

    /**
     * 分类结果数据类
     */
    public static class ClassificationResult {
        private final String label;      // 类别标签
        private final float probability; // 概率值

        public ClassificationResult(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) {
        // 配置参数 - 请根据实际模型修改这些参数
        String modelPath = "path/to/your/model.pb";      // 模型文件路径
        String labelsPath = "path/to/your/labels.txt";  // 标签文件路径
        int inputHeight = 224;                           // 模型输入高度
        int inputWidth = 224;                            // 模型输入宽度
        String inputName = "input";                      // 输入张量名称
        String outputName = "output";                    // 输出张量名称
        String imagePath = "path/to/your/test-image.jpg";// 测试图像路径

        try (TensorFlowImageClassifier classifier = new TensorFlowImageClassifier(
                modelPath, labelsPath, inputHeight, inputWidth, inputName, outputName)) {
            
            // 分类图像，获取前5个结果
            List<ClassificationResult> results = classifier.classifyImage(imagePath, 5);
            
            // 打印结果
            System.out.println("图像识别结果：");
            for (ClassificationResult result : results) {
                System.out.println(result);
            }
            
        } catch (Exception e) {
            System.err.println("图像分类失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
}