DL4J Example of Time Series Regression with 2 Outputs:

dl4jRNNStockTimeSeriesRegressionExample.txt

/*
Problem Description:
  Time series forecast for a single securities minor reversal points.  
  A "minor reversal point" is defined as either a period (day) with a high price greater than both the previous and next high prices, or a period with a low value lower than both the previous and next low prices.  
  This is a time series regression problem with 8 input features and 2 regression output dimensions

Input Features: 
 - period return r = (p2 - p1) / p1, descr: a linear return value, typically [-0.05,0.05]
 - period volume, descr: standardized, z = (x - Mean) / SD
 - High-Low spread, descr: standardized, z = (x - Mean) / SD
 - overnight return ((open - previousClose) / previousClose), descr: a linear return value, typically [-0.05,0.05]
 - open position in Range (open / (high - low)), descr:   [0-1]
 - close position in Range (close / (high - low)), descr:   [0-1]
 - return since last minor reversal point, descr: linear return value, typically [-0.10,0.10]
 - periods (days) since last minor reversal point, descr: Standardized, z = (x - Mean) / SD
                 
Regression Targets:
 - linear return of next reversal point relative to current price, descr: linear return value, typically [-0.10,0.10]
 - periods (days) until next reversal point, descr: Standardized, z = (x - Mean) / SD 
 NOTE: Regarding regression target "periods (days)" we'll have to adjust the standardized output of "periods (days)" to the problem domain scale when using the prediction value (i.e. adjustedPeriods = prediction * SD + Mean)
*/
@Test
public void recurrentTimeSeries_1Stock_2Outputs() throws Exception
{
  String symbol="AAPL";
  String featuresPath = String.format("/tmp/features_training_%s.csv", symbol);
  File featuresFile = new File(featuresPath);
  String labelsPath = String.format("/tmp/labels_training_%s.csv", symbol);
  File labelsFile = new File(labelsPath);
  
  String testFeaturesPath = String.format("/tmp/features_test_%s.csv", symbol);
  File testFeaturesFile = new File(testFeaturesPath);
  String testLabelsPath = String.format("/tmp/labels_test_%s.csv", symbol);
  File testLabelsFile = new File(testLabelsPath);
            
  int miniBatchSize = 1; //number of stocks we are learning on
  DataSetIterator trainingIterator = getSequenceIterator(featuresFile, labelsFile, miniBatchSize);
  
  //Set up network configuration:
  int lstmLayerSize = 200;
  int numOutputs = 2;
  int tbpttLength = 125;  //Length for truncated backpropagation through time. i.e., do parameter updates every x periods
  int numEpochs = 400;		//Total number of training epochs
  MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
        .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
        .iterations(1)
        .learningRate(0.001)
        .rmsDecay(0.95)
        .seed(12345)
        .regularization(true)
        .l2(0.001)
        .weightInit(WeightInit.XAVIER)
        .updater(Updater.RMSPROP)
        .list(3)
        .layer(0, new GravesLSTM.Builder().nIn(trainingIterator.inputColumns()).nOut(lstmLayerSize)
                .activation("tanh").build())
        .layer(1, new GravesLSTM.Builder().nIn(lstmLayerSize).nOut(lstmLayerSize)
                .activation("tanh").build())
        .layer(2, new RnnOutputLayer.Builder(LossFunctions.LossFunction.MSE).activation("identity")
                .nIn(lstmLayerSize).nOut(numOutputs).build())
        .backpropType(BackpropType.TruncatedBPTT).tBPTTForwardLength(tbpttLength).tBPTTBackwardLength(tbpttLength)
        .pretrain(false)
        .backprop(true)
        .build();

  MultiLayerNetwork net = new MultiLayerNetwork(conf);
  net.init();
  net.setListeners(new ScoreIterationListener(1));

  //Train the network
  for( int i=0; i<numEpochs; i++ ){
      System.out.println("Training epoch " + i);
      net.fit(trainingIterator);
      trainingIterator.reset();
  }
  System.out.println("Training complete.");

  //Step through Test dataset making predictions and measuring Mean Square Error Deviation for each output variable
  DataSetIterator testingIterator = getSequenceIterator(testFeaturesFile, testLabelsFile, miniBatchSize); 
  int t = 0;
  while(testingIterator.hasNext())
  {
      DataSet dsTest = testingIterator.next();
      INDArray featuresAtTimeT = dsTest.getFeatures();

      INDArray prediction = net.rnnTimeStep(featuresAtTimeT);
      INDArray actuals = dsTest.getLabels();
      System.out.println(String.format("t= %d, Standardized Prediction:  %s, Standardized Actual: %s", 
                                        t, prediction.toString(), actuals.toString()));

      //convert standardized predictions and actuals to non standardized values
      double[] predictionReturns = new double[testSetLength];
      double[] standardPredictionPeriods = new double[testSetLength];

      for(int i=0; i < testSetLength; i++ ) {
          predictionReturns[i] = prediction.getDouble(0, 0, i);
          standardPredictionPeriods[i] = prediction.getDouble(0, 1, i);
      }

      double[] adjustedPredictionPeriods = TALib.convertZScoreToRawScore(standardPredictionPeriods, colMeans[labelIndex2], colStdDevs[labelIndex2]);
      double[] actualReturns = new double[testSetLength];
      double[] standardActualPeriods = new double[testSetLength];

      for(int i=0; i < testSetLength; i++ ) {
          actualReturns[i] = actuals.getDouble(0, 0, i);
          standardActualPeriods[i] = actuals.getDouble(0, 1, i);
      }
      double[] adjustedActualPeriods = TALib.convertZScoreToRawScore(standardActualPeriods, colMeans[labelIndex2], colStdDevs[labelIndex2]);

      System.out.println(String.format("\nt= %d, Adjusted Prediction Returns:  %s, \nAdjusted Actual Returns: %s", t, join(predictionReturns, "%.3f"), join(actualReturns, "%.3f")));
      System.out.println(String.format("\nt= %d, Adjusted Prediction Periods:  %s, \nAdjusted Actual Periods: %s", t, join(adjustedPredictionPeriods, "%.1f"), join(adjustedActualPeriods, "%.1f")));

      //compute mean root square error
      double rmsdReturns = TALib.calcRootMeanSquareDeviation(predictionReturns, actualReturns);
      double rmsdPeriods = TALib.calcRootMeanSquareDeviation(adjustedPredictionPeriods, adjustedActualPeriods);
      System.out.println(String.format("RMSD Returns = %.4f, Periods = %.4f", rmsdReturns, rmsdPeriods));
      t++;
  }

  System.out.println("\n\nExample complete");
}

DataSetIterator getSequenceIterator(File featuresFile, File labelsFile, int miniBatchSize) 
throws IOException, InterruptedException {
    int numLinesToSkip = 1;
    String delimiter = ",";
    boolean regression = true;
    int numClasses = 1; //not used for regression
    SequenceRecordReader featureReader = new CSVSequenceRecordReader(numLinesToSkip, delimiter);
    SequenceRecordReader labelReader = new CSVSequenceRecordReader(numLinesToSkip, delimiter);
    featureReader.initialize(new FileSplit(featuresFile));
    labelReader.initialize(new FileSplit(labelsFile));
    return new SequenceRecordReaderDataSetIterator(featureReader, labelReader, miniBatchSize, numClasses, regression);
}

features_test_AAPL.csv

features_training_AAPL.csv

labels_test_AAPL.csv

labels_training_AAPL.csv

Did you managed to get this working? Is minibatch size really equal the number of stocks you're training?