More time series with EncogModel

Author: jeffheaton

src/main/java/org/encog/ml/data/versatile/NormalizationHelper.java

@@ -129,26 +129,14 @@ public int calculateNormalizedOutputCount() {
 
 		return normalizedOutputColumns;
 	}
-	
 	public MLData allocateInputVector() {
-		return new BasicMLData(calculateNormalizedInputCount());
+		return allocateInputVector(1);
 	}
-	public void normalizeInputVector(String[] line, MLData inputVector, boolean originalOrder) {
-		int outputIndex=0;
-		int i = 0;
-		for(ColumnDefinition colDef: this.inputColumns) {
-			int idx;
-			
-			if( originalOrder ) {
-				idx = this.sourceColumns.indexOf(colDef);
-			} else {
-				idx = i;
-			}
-			outputIndex = normalizeToVector(colDef, outputIndex, inputVector.getData(), false, line[idx]);
-			i++;
-		}
-		
+	
+	public MLData allocateInputVector(int multiplier) {
+		return new BasicMLData(calculateNormalizedInputCount()*multiplier);
 	}
+
 	public String[] denormalizeOutputVectorToString(MLData output) {
 		String[] result = new String[this.outputColumns.size()];
 
@@ -222,6 +210,20 @@ public void defineMissingHandler(ColumnDefinition colDef, MissingHandler handler
 		this.missingHandlers.put(colDef, handler);
 		handler.init(this);
 	}
-	
-	
+	public void normalizeInputVector(String[] line, double[] data,
+			boolean originalOrder) {
+		int outputIndex=0;
+		int i = 0;
+		for(ColumnDefinition colDef: this.inputColumns) {
+			int idx;
+			
+			if( originalOrder ) {
+				idx = this.sourceColumns.indexOf(colDef);
+			} else {
+				idx = i;
+			}
+			outputIndex = normalizeToVector(colDef, outputIndex, data, false, line[idx]);
+			i++;
+		}
+	}	
 }

src/main/java/org/encog/ml/data/versatile/PerformDataDivision.java

@@ -13,22 +13,24 @@ public PerformDataDivision(boolean theShuffle, GenerateRandom theRandom) {
 		this.rnd = theRandom;
 	}
 
-	public void perform(List<DataDivision> dataDivisionList, double[][] data,
+	public void perform(List<DataDivision> dataDivisionList, VersatileMLDataSet dataset,
 			int inputCount, int idealCount) {
-		generateCounts(dataDivisionList, data.length);
+		generateCounts(dataDivisionList, dataset.getData().length);
 		generateMasks(dataDivisionList);
 		if (this.shuffle) {
-			performShuffle(dataDivisionList, data.length);
+			performShuffle(dataDivisionList, dataset.getData().length);
 		}
-		createDividedDatasets(dataDivisionList, data, inputCount, idealCount);
+		createDividedDatasets(dataDivisionList, dataset, inputCount, idealCount);
 
 	}
 
 	private void createDividedDatasets(List<DataDivision> dataDivisionList,
-			double[][] data, int inputCount, int idealCount) {
+			VersatileMLDataSet parentDataset, int inputCount, int idealCount) {
 		for (DataDivision division : dataDivisionList) {
-			MatrixMLDataSet dataset = new MatrixMLDataSet(data, inputCount,
+			MatrixMLDataSet dataset = new MatrixMLDataSet(parentDataset.getData(), inputCount,
 					idealCount, division.getMask());
+			dataset.setLagWindowSize(parentDataset.getLagWindowSize());
+			dataset.setLeadWindowSize(parentDataset.getLeadWindowSize());
 			division.setDataset(dataset);
 		}
 	}

src/main/java/org/encog/ml/data/versatile/VersatileMLDataSet.java

@@ -149,7 +149,7 @@ public void divide(List<DataDivision> dataDivisionList, boolean shuffle,
 		}
 
 		PerformDataDivision divide = new PerformDataDivision(shuffle, rnd);
-		divide.perform(dataDivisionList, getData(), getCalculatedInputSize(),
+		divide.perform(dataDivisionList, this, getCalculatedInputSize(),
 				getCalculatedIdealSize());
 
 	}

src/main/java/org/encog/ml/model/EncogModel.java

@@ -276,9 +276,4 @@ public StatusReportable getReport() {
 	public void setReport(StatusReportable report) {
 		this.report = report;
 	}
-	
-	
-	
-	
-	
 }

src/main/java/org/encog/ml/train/strategy/end/SimpleEarlyStoppingStrategy.java

@@ -27,6 +27,9 @@
 import org.encog.ml.data.MLDataSet;
 import org.encog.ml.train.MLTrain;
 
+/**
+ * A simple early stopping strategy that halts training when the validation set no longer improves.
+ */
 public class SimpleEarlyStoppingStrategy implements EndTrainingStrategy {
 	/**
 	 * The validation set.
@@ -135,6 +138,9 @@ public double getTrainingError() {
 	}
 
 
+	/**
+	 * @return The validation error.
+	 */
 	public double getValidationError() {
 		return this.lastValidationError;
 	}

src/main/java/org/encog/util/arrayutil/VectorWindow.java

@@ -0,0 +1,72 @@
+package org.encog.util.arrayutil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.encog.EncogError;
+import org.encog.util.EngineArray;
+
+/**
+ * Create a sliding window of double arrays. New vectors can be added to the
+ * window. Once the required number of vectors have been added then the entire
+ * window can be copied to an output vector large enough to hold it.
+ */
+public class VectorWindow {
+	
+	/**
+	 * The window.
+	 */
+	private final List<double[]> window = new ArrayList<double[]>();
+	
+	/**
+	 * The number of slices in a window.
+	 */
+	private final int sliceCount;
+
+	/**
+	 * Construct a sliding window.
+	 * @param theSliceCount The number of slices in a window.
+	 */
+	public VectorWindow(int theSliceCount) {
+		this.sliceCount = theSliceCount;
+	}
+
+	/**
+	 * Add a single vector to the window.
+	 * @param vec The vector to add to the window.
+	 */
+	public void add(double[] vec) {
+		this.window.add(vec.clone());
+		while (this.window.size() > this.sliceCount) {
+			this.window.remove(0);
+		}
+	}
+
+	/**
+	 * @return True, if we've added enough slices for a complete window.
+	 */
+	public boolean isReady() {
+		return this.window.size() >= this.sliceCount;
+	}
+
+	/**
+	 * Copy the entire window to a complete vector.
+	 * @param output The vector to copy to.
+	 * @param startPos The starting position to write to.
+	 */
+	public void copyWindow(double[] output, int startPos) {
+		if (!isReady()) {
+			throw new EncogError("Can't produce a timeslice of size "
+					+ this.sliceCount + ", there are only "
+					+ this.window.size() + " vectors loaded.");
+		}
+
+		int currentIndex = startPos;
+		for (int i = 0; i < this.window.size(); i++) {
+			double[] source = this.window.get(i);
+			EngineArray.arrayCopy(source, 0, output, currentIndex,
+					source.length);
+			currentIndex += source.length;
+		}
+	}
+}

src/main/java/org/encog/util/simple/EncogUtility.java

@@ -47,6 +47,7 @@
 import org.encog.ml.data.buffer.codec.CSVDataCODEC;
 import org.encog.ml.data.buffer.codec.DataSetCODEC;
 import org.encog.ml.data.specific.CSVNeuralDataSet;
+import org.encog.ml.data.versatile.MatrixMLDataSet;
 import org.encog.ml.svm.SVM;
 import org.encog.ml.svm.training.SVMTrain;
 import org.encog.ml.train.MLTrain;
@@ -462,4 +463,72 @@ public static void saveEGB(File f, MLDataSet data) {
 		binary.load(data);
 		data.close();		
 	}
+
+	public static void explainErrorMSE(MLRegression method,
+			MatrixMLDataSet training) {
+		StringBuilder line = new StringBuilder();
+		double sum = 0;
+		int count = 0;
+		int itemNum = 0;
+		
+		for (final MLDataPair pair : training) {
+			final MLData output = method.compute(pair.getInput());
+			double dsum = 0;
+			for(int i=0;i<output.size();i++) { 
+				double diff = output.getData()[i] - pair.getIdeal().getData(i);
+				dsum+=diff*diff;
+				count++;
+			}
+			sum+=dsum;
+			
+			line.setLength(0);
+			line.append("Item #");
+			line.append(itemNum++);
+			line.append(", Actual=");
+			line.append(EncogUtility.formatNeuralData(output));
+			line.append(", Ideal=");
+			line.append(EncogUtility.formatNeuralData(pair.getIdeal()));
+			line.append(", Delta=");
+			line.append(Format.formatDouble(dsum, 4));
+			line.append(", Count=");
+			line.append(count);
+			line.append(", MSE=");
+			line.append(Format.formatDouble(sum/count, 4));
+			System.out.println(line.toString());
+		}
+	}
+	
+	public static void explainErrorRMS(MLRegression method,
+			MatrixMLDataSet training) {
+		StringBuilder line = new StringBuilder();
+		double sum = 0;
+		int count = 0;
+		int itemNum = 0;
+		
+		for (final MLDataPair pair : training) {
+			final MLData output = method.compute(pair.getInput());
+			double dsum = 0;
+			for(int i=0;i<output.size();i++) { 
+				double diff = output.getData()[i] - pair.getIdeal().getData(i);
+				dsum+=diff*diff;
+				count++;
+			}
+			sum+=dsum;
+			
+			line.setLength(0);
+			line.append("Item #");
+			line.append(itemNum++);
+			line.append(", Actual=");
+			line.append(EncogUtility.formatNeuralData(output));
+			line.append(", Ideal=");
+			line.append(EncogUtility.formatNeuralData(pair.getIdeal()));
+			line.append(", Delta=");
+			line.append(Format.formatDouble(dsum, 4));
+			line.append(", Count=");
+			line.append(count);
+			line.append(", RMS=");
+			line.append(Format.formatDouble(Math.sqrt(sum/count), 4));
+			System.out.println(line.toString());
+		}
+	}
 }

src/test/java/org/encog/util/arrayutil/TestVectorWindow.java

@@ -0,0 +1,42 @@
+package org.encog.util.arrayutil;
+
+import org.encog.Encog;
+import org.encog.EncogError;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestVectorWindow {
+	@Test(expected=EncogError.class)
+	public void testIncomplete() {
+		double[] o = new double[1];
+		VectorWindow window = new VectorWindow(3);
+		window.add(new double[] {1});
+		window.copyWindow(o, 0);
+	}
+	
+	@Test
+	public void testComplete() {
+		final double[] expect = {1.0, 2.0, 3.0};
+		double[] o = new double[3];
+		VectorWindow window = new VectorWindow(3);
+		window.add(new double[] {1});
+		window.add(new double[] {2});
+		window.add(new double[] {3});
+		window.copyWindow(o, 0);
+		Assert.assertArrayEquals(expect,o,Encog.DEFAULT_DOUBLE_EQUAL);
+	}
+	
+	@Test
+	public void testCompleteScroll() {
+		final double[] expect = {2.0, 3.0, 4.0};
+		double[] o = new double[3];
+		VectorWindow window = new VectorWindow(3);
+		window.add(new double[] {1});
+		window.add(new double[] {2});
+		window.add(new double[] {3});
+		window.add(new double[] {4});
+		window.copyWindow(o, 0);
+		Assert.assertArrayEquals(expect,o,Encog.DEFAULT_DOUBLE_EQUAL);
+	}
+
+}