ELMo：让 AI 真正理解词语的「动态语义」

<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>deeplearning4j-core</artifactId>
    <version>1.0.0-beta7</version>
</dependency>
<dependency>
    <groupId>org.nd4j</groupId>
    <artifactId>nd4j-native-platform</artifactId>
    <version>1.0.0-beta7</version>
</dependency>

import org.deeplearning4j.nn.graph.ComputationGraph;
import org.deeplearning4j.nn.modelimport.keras.KerasModelImport;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.factory.Nd4j;
import org.nd4j.linalg.indexing.NDArrayIndex;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * ELMo模型封装类，用于生成上下文相关的词向量
 */
public class ELMo {
    private ComputationGraph model;
    private int embeddingSize;
    private int maxSequenceLength;
    
    /**
     * 加载预训练的ELMo模型
     * @param modelPath 模型文件路径
     * @param embeddingSize 词向量维度
     * @param maxSequenceLength 最大序列长度
     */
    public ELMo(String modelPath, int embeddingSize, int maxSequenceLength) throws Exception {
        this.model = KerasModelImport.importKerasModelAndWeights(modelPath);
        this.embeddingSize = embeddingSize;
        this.maxSequenceLength = maxSequenceLength;
    }
    
    /**
     * 生成句子中每个词的ELMo向量
     * @param sentence 输入句子
     * @return 每个词的ELMo向量列表
     */
    public List<INDArray> getEmbeddings(String sentence) {
        // 简单分词处理
        List<String> tokens = Arrays.asList(sentence.split(" "));
        
        // 构建输入张量 [batchSize, maxSequenceLength]
        INDArray inputIds = Nd4j.zeros(1, maxSequenceLength);
        
        // 将词转换为索引（实际应用中需要使用真实的词表）
        for (int i = 0; i < Math.min(tokens.size(), maxSequenceLength); i++) {
            // 这里简化处理，实际应该使用词表映射
            inputIds.putScalar(new int[]{0, i}, tokens.get(i).hashCode() % 10000);
        }
        
        // 模型推理
        INDArray[] outputs = model.output(inputIds);
        
        // 提取各层输出并融合（简化示例，实际需要加权融合）
        List<INDArray> layerOutputs = new ArrayList<>();
        for (INDArray output : outputs) {
            // 提取batch中第一个样本的输出
            INDArray sampleOutput = output.get(NDArrayIndex.point(0));
            layerOutputs.add(sampleOutput);
        }
        
        // 简单平均融合各层输出（实际应用中权重应由任务学习得到）
        List<INDArray> wordEmbeddings = new ArrayList<>();
        for (int i = 0; i < tokens.size(); i++) {
            INDArray wordEmbedding = Nd4j.zeros(embeddingSize);
            for (INDArray layerOutput : layerOutputs) {
                wordEmbedding.addi(layerOutput.get(NDArrayIndex.point(i)));
            }
            wordEmbedding.divi(layerOutputs.size());
            wordEmbeddings.add(wordEmbedding);
        }
        
        return wordEmbeddings;
    }
    
    public static void main(String[] args) {
        try {
            // 实际使用时需要替换为真实的模型路径和参数
            ELMo elmo = new ELMo("path/to/elmo_model.h5", 1024, 50);
            String sentence = "I love natural language processing!";
            List<INDArray> embeddings = elmo.getEmbeddings(sentence);
            
            System.out.println("生成的词向量数量: " + embeddings.size());
            System.out.println("第一个词的向量维度: " + embeddings.get(0).shapeInfoToString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}