SimCLR：自监督学习领域的 “寻宝猎人”

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.nn.weights.WeightInit;
import org.nd4j.evaluation.classification.Evaluation;
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.factory.Nd4j;
import org.nd4j.linalg.learning.config.Adam;
import org.nd4j.linalg.lossfunctions.LossFunctions;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class SimCLRExample {
    // 模拟数据增强操作（简单随机噪声添加）
    private static INDArray dataAugmentation(INDArray input) {
        Random random = new Random();
        INDArray augmented = input.dup();
        for (int i = 0; i < augmented.rows(); i++) {
            for (int j = 0; j < augmented.columns(); j++) {
                double noise = (random.nextDouble() - 0.5) * 0.1; // 添加小范围随机噪声
                augmented.putScalar(i, j, augmented.getDouble(i, j) + noise);
            }
        }
        return augmented;
    }

    // 计算余弦相似度
    private static double cosineSimilarity(INDArray a, INDArray b) {
        return a.dot(b) / (a.norm2() * b.norm2());
    }

    // 构建编码器和投影头模型
    private static MultiLayerNetwork buildModel(int inputSize, int hiddenSize, int outputSize) {
        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
               .seed(12345)
               .weightInit(WeightInit.XAVIER)
               .updater(new Adam(0.001))
               .list()
               .layer(new DenseLayer.Builder()
                       .nIn(inputSize)
                       .nOut(hiddenSize)
                       .activation(Activation.RELU)
                       .build())
               .layer(new OutputLayer.Builder(LossFunctions.LossFunction.MSE)
                       .nIn(hiddenSize)
                       .nOut(outputSize)
                       .activation(Activation.IDENTITY)
                       .build())
               .build();

        return new MultiLayerNetwork(conf);
    }

    public static void main(String[] args) {
        int batchSize = 32;
        int inputSize = 100;
        int hiddenSize = 64;
        int outputSize = 32;
        int numEpochs = 10;
        double temperature = 0.1;

        MultiLayerNetwork encoder = buildModel(inputSize, hiddenSize, outputSize);
        encoder.init();

        // 模拟数据集（随机生成）
        List<INDArray> dataset = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            dataset.add(Nd4j.randn(inputSize));
        }

        for (int epoch = 0; epoch < numEpochs; epoch++) {
            for (int batchStart = 0; batchStart < dataset.size(); batchStart += batchSize) {
                int batchEnd = Math.min(batchStart + batchSize, dataset.size());
                List<INDArray> batch = dataset.subList(batchStart, batchEnd);

                INDArray batchArray = Nd4j.vstack(batch);
                INDArray augmented1 = dataAugmentation(batchArray);
                INDArray augmented2 = dataAugmentation(batchArray);

                INDArray encoded1 = encoder.output(augmented1);
                INDArray encoded2 = encoder.output(augmented2);

                double loss = 0;
                for (int i = 0; i < batchSize; i++) {
                    INDArray zi = encoded1.getRow(i);
                    INDArray zj = encoded2.getRow(i);
                    double sim_ij = cosineSimilarity(zi, zj);

                    double numerator = Math.exp(sim_ij / temperature);
                    double denominator = 0;
                    for (int k = 0; k < 2 * batchSize; k++) {
                        if (k != i) {
                            INDArray zk = (k < batchSize)? encoded1.getRow(k) : encoded2.getRow(k - batchSize);
                            denominator += Math.exp(cosineSimilarity(zi, zk) / temperature);
                        }
                    }
                    loss -= Math.log(numerator / denominator);
                }
                loss /= batchSize;

                // 这里简化处理，未进行反向传播和参数更新，实际需使用DL4J的训练机制
                System.out.println("Epoch " + epoch + ", Batch Loss: " + loss);
            }
        }

        // 评估模型（简化示例，未包含完整评估逻辑）
        Evaluation evaluation = new Evaluation(2); // 示例，根据实际任务调整类别数
        System.out.println(evaluation.stats());
    }
}