Changeset 2985

Timestamp:

03/09/10 20:26:03 (14 years ago)

Author:

gkronber

Message:

Fixed bugs in MLP operators, extended operators to work for time series prognosis and added pre-configured engine for time series prognosis with MLP. #882 (Artificial neural networks engine for time series prognosis)

Location:

trunk/sources/HeuristicLab.ArtificialNeuralNetworks/3.2

Files:

• HeuristicLab.ArtificialNeuralNetworks-3.2.csproj (modified) (1 diff)
• MultiLayerPerceptron.cs (modified) (3 diffs)
• MultiLayerPerceptronEvaluator.cs (modified) (2 diffs)
• MultiLayerPerceptronRegression.cs (modified) (1 diff)
• MultiLayerPerceptronRegressionOperator.cs (modified) (7 diffs)
• MultiLayerPerceptronTimeSeries.cs (added)
• Predictor.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.ArtificialNeuralNetworks/3.2/HeuristicLab.ArtificialNeuralNetworks-3.2.csproj

@@ -138 +138 @@
     <None Include="HeuristicLab.snk" />
     <None Include="Properties\AssemblyInfo.frame" />
+    <Compile Include="MultiLayerPerceptronTimeSeries.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

trunk/sources/HeuristicLab.ArtificialNeuralNetworks/3.2/MultiLayerPerceptron.cs

@@ -68 +68 @@
 
       clone.inputVariables = new List<string>(inputVariables);
+      clone.minTimeOffset = MinTimeOffset;
+      clone.maxTimeOffset = MaxTimeOffset;
 
       double[] ra = null;
@@ -78 +80 @@
     public override System.Xml.XmlNode GetXmlNode(string name, System.Xml.XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-
+      var minTimeOffsetAttr = document.CreateAttribute("MinTimeOffset");
+      minTimeOffsetAttr.Value = minTimeOffset.ToString();
+      var maxTimeOffsetAttr = document.CreateAttribute("MaxTimeOffset");
+      maxTimeOffsetAttr.Value = maxTimeOffset.ToString();
+      node.Attributes.Append(minTimeOffsetAttr);
+      node.Attributes.Append(maxTimeOffsetAttr);
       XmlNode networkInformation = document.CreateElement("NetworkInformation");
       double[] ra = null;
@@ -94 +101 @@
     public override void Populate(System.Xml.XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
+      minTimeOffset = XmlConvert.ToInt32(node.Attributes["MinTimeOffset"].Value);
+      maxTimeOffset = XmlConvert.ToInt32(node.Attributes["MaxTimeOffset"].Value);
       double[] ra = (from s in node.SelectSingleNode("NetworkInformation").InnerText.Split(';')
                      select double.Parse(s, CultureInfo.InvariantCulture)).ToArray();

trunk/sources/HeuristicLab.ArtificialNeuralNetworks/3.2/MultiLayerPerceptronEvaluator.cs

@@ -52 +52 @@
                                select ((StringData)x).Data;
       string targetVariable = GetVariableValue<StringData>("TargetVariable", scope, true).Data;
-      int targetVariableIndex = dataset.GetVariableIndex(targetVariable);
+      // int targetVariableIndex = dataset.GetVariableIndex(targetVariable);
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
@@ -61 +61 @@
       MultiLayerPerceptron model = GetVariableValue<MultiLayerPerceptron>("MultiLayerPerceptron", scope, true);
 
-      double[,] values = new double[end - start, 2];
-      for (int i = 0; i < end - start; i++) {
+      double[] targetVector;
+      double[,] inputMatrix;
+      MultiLayerPerceptronRegressionOperator.PrepareDataset(dataset, targetVariable, inputVariableNames, start, end, minTimeOffset, maxTimeOffset,
+        out inputMatrix, out targetVector);
+
+      double[,] values = new double[targetVector.Length, 2];
+      for (int i = 0; i < targetVector.Length; i++) {
         double[] output = new double[1];
-        double[] inputRow = new double[dataset.Columns - 1];
-        for (int c = 1; c < inputRow.Length; c++) {
-          inputRow[c - 1] = dataset.GetValue(i + start, c);
+        double[] inputRow = new double[inputMatrix.GetLength(1)];
+        for (int c = 0; c < inputRow.Length; c++) {
+          inputRow[c] = inputMatrix[i, c];
         }
         alglib.mlpbase.multilayerperceptron p = model.Perceptron;
         alglib.mlpbase.mlpprocess(ref p, ref inputRow, ref output);
         model.Perceptron = p;
-        values[i, 0] = dataset.GetValue(start + i, targetVariableIndex);
+        values[i, 0] = targetVector[i];
         values[i, 1] = output[0];
       }

trunk/sources/HeuristicLab.ArtificialNeuralNetworks/3.2/MultiLayerPerceptronRegression.cs

@@ -123 +123 @@
       get {
         if (!engine.Terminated) throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
-        IScope bestModelScope = engine.GlobalScope;
+        IScope bestModelScope = engine.GlobalScope.SubScopes[0];
         return CreateMlpModel(bestModelScope);
       }

trunk/sources/HeuristicLab.ArtificialNeuralNetworks/3.2/MultiLayerPerceptronRegressionOperator.cs

@@ -36 +36 @@
       AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("ValidationSamplesStart", "Start of validation set", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("ValidationSamplesEnd", "End of validation set", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("NumberOfHiddenLayerNeurons", "The number of nodes in the hidden layer.", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("MaxTimeOffset", "(optional) Maximal time offset for time-series prognosis", typeof(IntData), VariableKind.In));
@@ -48 +50 @@
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
+
+      int valStart = GetVariableValue<IntData>("ValidationSamplesStart", scope, true).Data;
+      int valEnd = GetVariableValue<IntData>("ValidationSamplesEnd", scope, true).Data;
+
+
       IntData maxTimeOffsetData = GetVariableValue<IntData>("MaxTimeOffset", scope, true, false);
       int maxTimeOffset = maxTimeOffsetData == null ? 0 : maxTimeOffsetData.Data;
@@ -54 +61 @@
       int nHiddenNodes = GetVariableValue<IntData>("NumberOfHiddenLayerNeurons", scope, true).Data;
 
-      var perceptron = CreateModel(dataset, targetVariable, dataset.VariableNames, start, end, minTimeOffset, maxTimeOffset, nHiddenNodes);
+      var perceptron = CreateModel(dataset, targetVariable, dataset.VariableNames, start, end, valStart, valEnd, minTimeOffset, maxTimeOffset, nHiddenNodes);
       scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MultiLayerPerceptron"), perceptron));
       return null;
     }
 
-    public static MultiLayerPerceptron CreateModel(Dataset dataset, string targetVariable, IEnumerable<string> inputVariables, int start, int end, int nHiddenNodes) {
-      return CreateModel(dataset, targetVariable, inputVariables, start, end, 0, 0, nHiddenNodes);
-    }
+    //public static MultiLayerPerceptron CreateModel(Dataset dataset, string targetVariable, IEnumerable<string> inputVariables, int start, int end, int nHiddenNodes) {
+    //  return CreateModel(dataset, targetVariable, inputVariables, start, end, 0, 0, nHiddenNodes);
+    //}
 
     public static MultiLayerPerceptron CreateModel(Dataset dataset, string targetVariable, IEnumerable<string> inputVariables,
-        int start, int end,
+        int start, int end, int valStart, int valEnd,
         int minTimeOffset, int maxTimeOffset, int nHiddenNodes) {
-      int targetVariableIndex = dataset.GetVariableIndex(targetVariable);
-      List<int> allowedColumns = CalculateAllowedColumns(dataset, targetVariableIndex, inputVariables.Select(x => dataset.GetVariableIndex(x)), start, end);
-      List<int> allowedRows = CalculateAllowedRows(dataset, targetVariableIndex, allowedColumns, start, end, minTimeOffset, maxTimeOffset);
-
-      double[,] inputMatrix = PrepareInputMatrix(dataset, allowedColumns, allowedRows, minTimeOffset, maxTimeOffset);
-      double[] targetVector = PrepareTargetVector(dataset, targetVariableIndex, allowedRows);
-
-      var perceptron = TrainPerceptron(inputMatrix, targetVector, nHiddenNodes);
+      double[,] inputMatrix;
+      double[,] validationData;
+      double[] targetVector;
+      double[] validationTargetVector;
+      PrepareDataset(dataset, targetVariable, inputVariables, start, end, minTimeOffset, maxTimeOffset, out inputMatrix, out targetVector);
+      PrepareDataset(dataset, targetVariable, inputVariables, valStart, valEnd, minTimeOffset, maxTimeOffset, out validationData, out validationTargetVector);
+      var perceptron = TrainPerceptron(inputMatrix, targetVector, nHiddenNodes, validationData, validationTargetVector);
       return new MultiLayerPerceptron(perceptron, inputVariables, minTimeOffset, maxTimeOffset);
     }
@@ -79 +85 @@
 
 
-    private static alglib.mlpbase.multilayerperceptron TrainPerceptron(double[,] inputMatrix, double[] targetVector, int nHiddenNodes) {
+    private static alglib.mlpbase.multilayerperceptron TrainPerceptron(double[,] inputMatrix, double[] targetVector, int nHiddenNodes, double[,] validationData, double[] validationTargetVector) {
       int retVal = 0;
       int n = targetVector.Length;
+      int validationN = validationTargetVector.Length;
       int p = inputMatrix.GetLength(1);
       alglib.mlpbase.multilayerperceptron perceptron = new alglib.mlpbase.multilayerperceptron();
@@ -93 +100 @@
         dataset[row, p - 1] = targetVector[row];
       }
-      alglib.mlptrain.mlptrainlbfgs(ref perceptron, ref dataset, n, 0.001, 2, 0.01, 0, ref retVal, ref report);
-      if (retVal != 2) throw new ArgumentException("Error in training of multi layer perceptron");
+      double[,] validationDataset = new double[validationN, p];
+      for (int row = 0; row < validationN; row++) {
+        for (int column = 0; column < p - 1; column++) {
+          validationDataset[row, column] = validationData[row, column];
+        }
+        validationDataset[row, p - 1] = validationTargetVector[row];
+      }
+      //alglib.mlptrain.mlptrainlbfgs(ref perceptron, ref dataset, n, 0.001, 10, 0.01, 0, ref retVal, ref report);
+      alglib.mlptrain.mlptraines(ref perceptron, ref dataset, n, ref validationDataset, validationN, 0.001, 10, ref retVal, ref report);
+      if (retVal != 2 && retVal != 6) throw new ArgumentException("Error in training of multi layer perceptron");
       return perceptron;
+    }
+
+    public static void PrepareDataset(Dataset dataset, string targetVariable, IEnumerable<string> inputVariables, int start, int end, int minTimeOffset, int maxTimeOffset,
+      out double[,] inputMatrix, out double[] targetVector) {
+      int targetVariableIndex = dataset.GetVariableIndex(targetVariable);
+      List<int> allowedColumns = CalculateAllowedColumns(dataset, targetVariableIndex, inputVariables.Select(x => dataset.GetVariableIndex(x)), start, end);
+      List<int> allowedRows = CalculateAllowedRows(dataset, targetVariableIndex, allowedColumns, start, end, minTimeOffset, maxTimeOffset);
+
+      inputMatrix = PrepareInputMatrix(dataset, allowedColumns, allowedRows, minTimeOffset, maxTimeOffset);
+      targetVector = PrepareTargetVector(dataset, targetVariableIndex, allowedRows);
+
     }
 
@@ -139 +165 @@
       int rowCount = allowedRows.Count;
       int timeOffsetRange = (maxTimeOffset - minTimeOffset + 1);
-      double[,] matrix = new double[rowCount, (allowedColumns.Count * timeOffsetRange) + 1];
+      double[,] matrix = new double[rowCount, (allowedColumns.Count * timeOffsetRange)];
       for (int row = 0; row < allowedRows.Count; row++)
         for (int col = 0; col < allowedColumns.Count; col++) {
@@ -145 +171 @@
             matrix[row, (col * timeOffsetRange) + (timeOffset - minTimeOffset)] = dataset.GetValue(allowedRows[row] + timeOffset, allowedColumns[col]);
         }
-      //add constant 1.0 in last column
-      for (int i = 0; i < rowCount; i++)
-        matrix[i, allowedColumns.Count * timeOffsetRange] = 1.0;
       return matrix;
     }

trunk/sources/HeuristicLab.ArtificialNeuralNetworks/3.2/Predictor.cs

@@ -27 +27 @@
 using System.Xml;
 using HeuristicLab.DataAnalysis;
+using System.Linq;
 
 namespace HeuristicLab.ArtificialNeuralNetworks {
@@ -44 +45 @@
       for (int i = 0; i < end - start; i++) {
         double[] output = new double[1];
-        double[] inputRow = new double[input.Columns - 1];
-        for (int c = 1; c < inputRow.Length; c++) {
-          inputRow[c - 1] = input.GetValue(i + start, c);
+        double[] inputRow = new double[GetInputVariables().Count()];
+        int c = 0;
+        foreach (var inputVariable in GetInputVariables()) {
+          int inputVariableIndex = input.GetVariableIndex(inputVariable);
+          inputRow[c++] = input.GetValue(i + start, inputVariableIndex);
         }
-        alglib.mlpbase.multilayerperceptron p = perceptron.Perceptron;
-        alglib.mlpbase.mlpprocess(ref p, ref inputRow, ref output);
-        perceptron.Perceptron = p;
-        yield return Math.Max(Math.Min(output[0], UpperPredictionLimit), LowerPredictionLimit);
+        double estimatedValue;
+        try {
+          alglib.mlpbase.multilayerperceptron p = perceptron.Perceptron;
+          alglib.mlpbase.mlpprocess(ref p, ref inputRow, ref output);
+          perceptron.Perceptron = p;
+          estimatedValue = output[0];
+        }
+        catch (ArithmeticException) {
+          estimatedValue = UpperPredictionLimit;
+        }
+        yield return Math.Max(Math.Min(estimatedValue, UpperPredictionLimit), LowerPredictionLimit);
       }
     }