<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>deeplearning4j-core</artifactId>
    <version>1.0.0-beta7</version>
</dependency>
<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>deeplearning4j-nlp</artifactId>
    <version>1.0.0-beta7</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

import org.deeplearning4j.text.tokenization.tokenizerfactory.TokenizerFactory;
import org.deeplearning4j.text.tokenization.tokenizerfactory.UimaTokenizerFactory;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.dataset.api.preprocessor.DataNormalization;
import org.nd4j.linalg.dataset.api.preprocessor.NormalizerStandardize;

public class DataPreprocessor {

    public static DataSetIterator preprocessData(String filePath) {
        // 創(chuàng)建 TokenizerFactory
        TokenizerFactory tokenizerFactory = new UimaTokenizerFactory();

        // 創(chuàng)建文檔向量器
        DocumentVectorizer documentVectorizer = new DocumentVectorizer.Builder()
               .setTokenizerFactory(tokenizerFactory)
               .build();

        // 加載數(shù)據(jù)集
        InMemoryDataSetIterator dataSetIterator = new InMemoryDataSetIterator.Builder()
               .addSource(filePath, documentVectorizer)
               .build();

        // 數(shù)據(jù)標準化
        DataNormalization normalizer = new NormalizerStandardize();
        normalizer.fit(dataSetIterator);
        dataSetIterator.setPreProcessor(normalizer);

        return dataSetIterator;
    }
}

import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.LSTM;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.weights.WeightInit;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.lossfunctions.LossFunctions;

public class TextClassificationModel {

    public static MultiLayerNetwork buildModel(int inputSize, int numClasses) {
        // 構(gòu)建神經(jīng)網(wǎng)絡配置
        MultiLayerConfiguration configuration = new NeuralNetConfiguration.Builder()
               .seed(12345)
               .weightInit(WeightInit.XAVIER)
               .updater(Updater.ADAGRAD)
               .list()
               .layer(0, new LSTM.Builder()
                       .nIn(inputSize)
                       .nOut(128)
                       .activation(Activation.TANH)
                       .build())
               .layer(1, new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                       .activation(Activation.SOFTMAX)
                       .nOut(numClasses)
                       .build())
               .build();

        // 創(chuàng)建神經(jīng)網(wǎng)絡模型
        MultiLayerNetwork model = new MultiLayerNetwork(configuration);
        model.init();

        return model;
    }
}

import org.deeplearning4j.nn.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;

public class ModelTrainer {

    public static void trainModel(MultiLayerNetwork model, DataSetIterator iterator, int numEpochs) {
        // 設(shè)置優(yōu)化算法和學習率
        model.setOptimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT);
        model.setLearningRate(0.01);

        // 添加訓練監(jiān)聽器
        model.setListeners(new ScoreIterationListener(100));

        // 訓練模型
        for (int epoch = 0; epoch < numEpochs; epoch++) {
            model.fit(iterator);
            System.out.println("Epoch " + epoch + " completed.");
        }
    }
}

import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;

public class ModelPredictor {

    public static String predictCategory(MultiLayerNetwork model, String text) {
        // 預處理文本數(shù)據(jù)
        DataSet dataSet = DataPreprocessor.preprocessData(text);

        // 預測類別
        INDArray output = model.output(dataSet.getFeatureMatrix());
        int predictedClass = argMax(output);

        // 返回類別名稱
        return getCategoryName(predictedClass);
    }

    private static int argMax(INDArray array) {
        double maxValue = Double.NEGATIVE_INFINITY;
        int maxIndex = -1;
        for (int i = 0; i < array.length(); i++) {
            if (array.getDouble(i) > maxValue) {
                maxValue = array.getDouble(i);
                maxIndex = i;
            }
        }
        return maxIndex;
    }

    private static String getCategoryName(int classIndex) {
        // 根據(jù)類別索引返回類別名稱
        switch (classIndex) {
            case 0:
                return "政治新聞";
            case 1:
                return "體育新聞";
            case 2:
                return "娛樂新聞";
            default:
                return "未知類別";
        }
    }
}

import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class TextClassificationSystemTest {

    private MultiLayerNetwork model;
    private DataSetIterator iterator;

    @BeforeEach
    public void setUp() {
        // 加載數(shù)據(jù)集并預處理
        iterator = DataPreprocessor.preprocessData("path/to/dataset.csv");

        // 構(gòu)建模型
        model = TextClassificationModel.buildModel(iterator.inputColumns(), iterator.totalOutcomes());
    }

    @Test
    public void testModelTraining() {
        // 訓練模型
        ModelTrainer.trainModel(model, iterator, 10);

        // 預測結(jié)果
        String text = "美國總統(tǒng)拜登發(fā)表重要講話";
        String predictedCategory = ModelPredictor.predictCategory(model, text);

        // 驗證預測結(jié)果
        assertEquals("政治新聞", predictedCategory);
    }
}

Epoch 0 completed.
Epoch 1 completed.
...
Epoch 9 completed.