Neural network 神经网络中训练数据的数组化

我正在尝试deeplearning4j中用于文本处理的时间预测模型，该模型不以单词、句子、字符作为输入特征，并产生时间作为输出。但在将输入数据建模为输出时，我很难转换这些值，以及如何告知网络这些输入值是各自的输出值

我是否应该从只使用x1和y而不是x1-x4来减少维数

training-data.csv包含以下列，其中包含100个值。 x1、x2、x3、x4（输入）y（输出）

我尝试使用SequenceRecorder和迭代器来捕获变量输入。 下面是我的代码

public static void main(String[] args) throws Exception
{
    // Initlizing parametres
    final Logger log = LoggerFactory.getLogger(MainExpert.class);
    final int seed =123;
    final int numInput = 4;
    final int numOutput = 1;
    final int numHidden = 20;
    final double learningRate = 0.015;
    final int batchSize =30;
    final int nEpochs =30;
    //final int inputFeatures =4;

    //Constructing Training data

    final File baseFolder =new File("/home/aj/my/samples/corpus");
    final File testFolder = new File("/home/aj/my/samples/corpus/train_data_0.csv");
    SequenceRecordReader trainReader = new CSVSequenceRecordReader(0,",");
    trainReader.initialize(new NumberedFileInputSplit(baseFolder.getAbsolutePath() + "/train_data_%d.csv",0,0));
    DataSetIterator trainIterator = new SequenceRecordReaderDataSetIterator(trainReader,batchSize,-1,4,true);


    SequenceRecordReader testReader = new CSVSequenceRecordReader(0,",");
    testReader.initialize(new NumberedFileInputSplit(baseFolder.getAbsolutePath() + "/test_data_%d.csv",0,0));
    DataSetIterator testIterator = new SequenceRecordReaderDataSetIterator(testReader,batchSize,-1,4,true);

    DataSet trainData = trainIterator.next();
    System.out.println(trainData);
    DataSet testData = testIterator.next();

    NormalizerMinMaxScaler normalizer = new NormalizerMinMaxScaler(0, 1);
    normalizer.fitLabel(true);
    normalizer.fit(trainData);              
    normalizer.transform(trainData);
    normalizer.transform(testData);

    //Configuring Network
    log.info("Building Model");
    MultiLayerConfiguration config = new NeuralNetConfiguration.Builder()
            .seed(seed)
            .iterations(1)
            .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
            .learningRate(learningRate)
            .updater(Updater.NESTEROVS).momentum(0.9)
            .list()
            .layer(0, new DenseLayer.Builder()
                    .nIn(numInput)
                    .nOut(numHidden)
                    .weightInit(WeightInit.XAVIER).
                    activation(Activation.RELU)
                    .build())
            .layer(1, new DenseLayer.Builder()
                    .nIn(numHidden)
                    .nOut(numHidden)
                    .weightInit(WeightInit.XAVIER)
                    .activation(Activation.RELU)
                    .build())
            .layer(2, new OutputLayer.Builder(LossFunction.MSE)
                    .nIn(numHidden)
                    .nOut(numOutput)
                    .weightInit(WeightInit.XAVIER)
                    .activation(Activation.IDENTITY)
                    .build())
            .pretrain(false).backprop(true).build();

    //Initializing network
    log.info("initlizing model");
    MultiLayerNetwork model = new MultiLayerNetwork(config);
    model.init();
    model.setListeners(new ScoreIterationListener(1));

    log.info("Training Model");
    for(int i=0;i<nEpochs;i++)
    {
        model.fit(trainData);
    }
    //Evaluation
    RegressionEvaluation reval=new RegressionEvaluation(1);

        while(testIterator.hasNext())
        {
    INDArray feat =testData.getFeatureMatrix();
    INDArray labels =testData.getLabels();
    INDArray prediction =model.output(feat);
    reval.eval(labels, prediction);
}
    System.out.println(reval.stats());
}

publicstaticvoidmain（字符串[]args）引发异常
{
//初始化参数
最终记录器日志=LoggerFactory.getLogger（MainExpert.class）；
最终整数种子=123；
最终整数输入=4；
最终整数numOutput=1；
最终整数=20；
最终双学习率=0.015；
最终int batchSize=30；
最终int nEpochs=30；
//最终int inputFeatures=4；
//构建训练数据
final File baseFolder=新文件（“/home/aj/my/samples/corpus”）；
最终文件testFolder=新文件（“/home/aj/my/samples/corpus/train_data_0.csv”）；
SequenceRecordReader trainReader=新的CSVSequenceRecordReader（0，“，”）；
trainReader.initialize（新的NumberedFileInputSplit（baseFolder.getAbsolutePath（）+“/train_data_u%d.csv”，0,0））；
DataSetIterator TraineIterator=新的SequenceRecordReaderDataSetIterator（TraineReader，batchSize，-1,4，true）；
SequenceRecordReader testReader=新的CSVSequenceRecordReader（0，“，”）；
初始化（新的NumberedFileInputSplit（baseFolder.getAbsolutePath（）+“/test_data_u%d.csv”，0,0））；
DataSetIterator testIterator=新的SequenceRecordReaderDataSetIterator（testReader，batchSize，-1,4，true）；
DataSet trainData=trainIterator.next（）；
系统输出打印LN（列车数据）；
数据集testData=testIterator.next（）；
NormalizerMinMaxScaler normalizer=新的NormalizerMinMaxScaler（0，1）；
标准化器。fitLabel（真）；
归一化器拟合（列车数据）；
规范化转换（列车数据）；
转换（testData）；
//配置网络
log.info（“建筑模型”）；
多层配置config=new NeuralNetConfiguration.Builder（）
.种子
.迭代次数（1）
.优化算法（优化算法.随机梯度下降）
.学习率（learningRate）
.updater（updater.NESTEROVS）.momentum（0.9）
.list（）
.layer（0，新的DenseLayer.Builder（）
.nIn（努明普特）
.努特（努姆希登）
.weightInit（weightInit.XAVIER）。
激活（activation.RELU）
.build（））
.layer（1，新的DenseLayer.Builder（）
.nIn（努姆希登）
.努特（努姆希登）
.weightInit（weightInit.XAVIER）
.activation（activation.RELU）
.build（））
.layer（2，新的OutputLayer.Builder（LossFunction.MSE）
.nIn（努姆希登）
.努特（努穆特）
.weightInit（weightInit.XAVIER）
.激活（激活.标识）
.build（））
.pretrain（false）.backprop（true）.build（）；
//初始化网络
log.info（“初始化模型”）；
多层网络模型=新的多层网络（配置）；
model.init（）；
setListeners（新的ScoreIterationListener（1））；
log.info（“培训模式”）；
对于（int i=0；i我们这里有一个端到端csv分类器示例：
rnn可以处理多变量输入。事实上我鼓励它。只有一个输入功能对你没有多大帮助。
我认为没有必要把它减少到x1和y