Changeset 14395 for branches/HeuristicLab.Algorithms.DataAnalysis.Glmnet

Timestamp:

11/15/16 21:53:42 (7 years ago)

Author:

gkronber

Message:

#745: code simplification using functionality from refactored trunk and fixed lambda parameter

File:

• branches/HeuristicLab.Algorithms.DataAnalysis.Glmnet/3.4/ElasticNetLinearRegression.cs (modified) (9 diffs)

branches/HeuristicLab.Algorithms.DataAnalysis.Glmnet/3.4/ElasticNetLinearRegression.cs

@@ -40 +40 @@
   public sealed class ElasticNetLinearRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string PenalityParameterName = "Penality";
-    private const string LogLambdaParameterName = "Log10(Lambda)";
+    private const string LambdaParameterName = "Lambda";
     #region parameters
     public IFixedValueParameter<DoubleValue> PenalityParameter {
       get { return (IFixedValueParameter<DoubleValue>)Parameters[PenalityParameterName]; }
     }
-    public IValueParameter<DoubleValue> LogLambdaParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters[LogLambdaParameterName]; }
+    public IValueParameter<DoubleValue> LambdaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[LambdaParameterName]; }
     }
     #endregion
@@ -54 +54 @@
       set { PenalityParameter.Value.Value = value; }
     }
-    public DoubleValue LogLambda {
-      get { return LogLambdaParameter.Value; }
-      set { LogLambdaParameter.Value = value; }
+    public DoubleValue Lambda {
+      get { return LambdaParameter.Value; }
+      set { LambdaParameter.Value = value; }
     }
     #endregion
@@ -69 +69 @@
       Problem = new RegressionProblem();
       Parameters.Add(new FixedValueParameter<DoubleValue>(PenalityParameterName, "Penalty factor (alpha) for balancing between ridge (0.0) and lasso (1.0) regression", new DoubleValue(0.5)));
-      Parameters.Add(new OptionalValueParameter<DoubleValue>(LogLambdaParameterName, "Optional: the value of lambda for which to calculate an elastic-net solution. lambda == null => calculate the whole path of all lambdas"));
+      Parameters.Add(new OptionalValueParameter<DoubleValue>(LambdaParameterName, "Optional: the value of lambda for which to calculate an elastic-net solution. lambda == null => calculate the whole path of all lambdas"));
     }
 
@@ -80 +80 @@
 
     protected override void Run() {
-      if (LogLambda == null) {
+      if (Lambda == null) {
         CreateSolutionPath();
       } else {
-        CreateSolution(LogLambda.Value);
-      }
-    }
-
-    private void CreateSolution(double logLambda) {
+        CreateSolution(Lambda.Value);
+      }
+    }
+
+    private void CreateSolution(double lambda) {
       double trainNMSE;
       double testNMSE;
-      var coeff = CreateElasticNetLinearRegressionSolution(Problem.ProblemData, Penality, Math.Pow(10, logLambda), out trainNMSE, out testNMSE);
+      var coeff = CreateElasticNetLinearRegressionSolution(Problem.ProblemData, Penality, lambda, out trainNMSE, out testNMSE);
       Results.Add(new Result("NMSE (train)", new DoubleValue(trainNMSE)));
       Results.Add(new Result("NMSE (test)", new DoubleValue(testNMSE)));
 
-      // copied from LR => TODO: reuse code (but skip coefficients = 0.0)
-      ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
-      ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode();
-      tree.Root.AddSubtree(startNode);
-      ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode();
-      startNode.AddSubtree(addition);
-
-      int col = 0;
-      foreach (string column in Problem.ProblemData.AllowedInputVariables) {
-        if (!coeff[col].IsAlmost(0.0)) {
-          VariableTreeNode vNode = (VariableTreeNode)new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable().CreateTreeNode();
-          vNode.VariableName = column;
-          vNode.Weight = coeff[col];
-          addition.AddSubtree(vNode);
-        }
-        col++;
-      }
-
-      if (!coeff[coeff.Length - 1].IsAlmost(0.0)) {
-        ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
-        cNode.Value = coeff[coeff.Length - 1];
-        addition.AddSubtree(cNode);
-      }
+      var allVariables = Problem.ProblemData.AllowedInputVariables.ToArray();
+
+      var remainingVars = Enumerable.Range(0, allVariables.Length)
+        .Where(idx => !coeff[idx].IsAlmost(0.0)).Select(idx => allVariables[idx])
+        .ToArray();
+      var remainingCoeff = Enumerable.Range(0, allVariables.Length)
+        .Select(idx => coeff[idx])
+        .Where(c => !c.IsAlmost(0.0))
+        .ToArray();
+
+      var tree = LinearModelToTreeConverter.CreateTree(remainingVars, remainingCoeff, coeff.Last());
+
 
       SymbolicRegressionSolution solution = new SymbolicRegressionSolution(
@@ -142 +131 @@
 
       coeffTable.VisualProperties.XAxisLogScale = true;
-      coeffTable.VisualProperties.XAxisTitle = "Log10(Lambda)";
+      coeffTable.VisualProperties.XAxisTitle = "Lambda";
       coeffTable.VisualProperties.YAxisTitle = "Coefficients";
       coeffTable.VisualProperties.SecondYAxisTitle = "Number of variables";
@@ -184 +173 @@
       errorTable.VisualProperties.YAxisMaximumFixedValue = 1.0;
       errorTable.VisualProperties.XAxisLogScale = true;
-      errorTable.VisualProperties.XAxisTitle = "Log10(Lambda)";
+      errorTable.VisualProperties.XAxisTitle = "Lambda";
       errorTable.VisualProperties.YAxisTitle = "Normalized mean of squared errors (NMSE)";
-      errorTable.VisualProperties.SecondYAxisTitle= "Number of variables";
+      errorTable.VisualProperties.SecondYAxisTitle = "Number of variables";
       errorTable.Rows.Add(new IndexedDataRow<double>("NMSE (train)", "Path of NMSE values over different lambda values", lambda.Zip(trainNMSE, (l, v) => Tuple.Create(l, v))));
       errorTable.Rows.Add(new IndexedDataRow<double>("NMSE (test)", "Path of NMSE values over different lambda values", lambda.Zip(testNMSE, (l, v) => Tuple.Create(l, v))));
@@ -198 +187 @@
       errorTable.Rows["Number of variables"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
       errorTable.Rows["Number of variables"].VisualProperties.SecondYAxis = true;
-                                                                                       
+
       Results.Add(new Result(errorTable.Name, errorTable.Description, errorTable));
     }
@@ -270 +259 @@
       double[,] trainX;
       double[,] testX;
-
       double[] trainY;
       double[] testY;
-      int numTrainObs, numTestObs;
-      int numVars;
-      PrepareData(problemData, out trainX, out trainY, out numTrainObs, out testX, out testY, out numTestObs, out numVars);
+
+      PrepareData(problemData, out trainX, out trainY, out testX, out testY);
+      var numTrainObs = trainX.GetLength(1);
+      var numTestObs = testX.GetLength(1);
+      var numVars = trainX.GetLength(0);
 
       int ka = 1; // => covariance updating algorithm
@@ -334 +324 @@
     }
 
-    private static void PrepareData(IRegressionProblemData problemData, out double[,] trainX, out double[] trainY, out int numTrainObs,
-      out double[,] testX, out double[] testY, out int numTestObs, out int numVars) {
-      numVars = problemData.AllowedInputVariables.Count();
-      numTrainObs = problemData.TrainingIndices.Count();
-      numTestObs = problemData.TestIndices.Count();
-
-      trainX = new double[numVars, numTrainObs];
-      trainY = new double[numTrainObs];
-      testX = new double[numVars, numTestObs];
-      testY = new double[numTestObs];
+    private static void PrepareData(IRegressionProblemData problemData, out double[,] trainX, out double[] trainY,
+      out double[,] testX, out double[] testY) {
+
       var ds = problemData.Dataset;
-      var targetVar = problemData.TargetVariable;
-      // train
-      int rIdx = 0;
-      foreach (var row in problemData.TrainingIndices) {
-        int cIdx = 0;
-        foreach (var var in problemData.AllowedInputVariables) {
-          trainX[cIdx, rIdx] = ds.GetDoubleValue(var, row);
-          cIdx++;
-        }
-        trainY[rIdx] = ds.GetDoubleValue(targetVar, row);
-        rIdx++;
-      }
-      // test
-      rIdx = 0;
-      foreach (var row in problemData.TestIndices) {
-        int cIdx = 0;
-        foreach (var var in problemData.AllowedInputVariables) {
-          testX[cIdx, rIdx] = ds.GetDoubleValue(var, row);
-          cIdx++;
-        }
-        testY[rIdx] = ds.GetDoubleValue(targetVar, row);
-        rIdx++;
-      }
-    }
-
+      trainX = ds.ToArray(problemData.AllowedInputVariables, problemData.TrainingIndices);
+      trainX = trainX.Transpose();
+      trainY = problemData.Dataset.GetDoubleValues(problemData.TargetVariable,
+        problemData.TrainingIndices)
+        .ToArray();
+      testX = ds.ToArray(problemData.AllowedInputVariables, problemData.TestIndices);
+      testX = testX.Transpose();
+      testY = problemData.Dataset.GetDoubleValues(problemData.TargetVariable,
+        problemData.TestIndices)
+        .ToArray();
+    }
   }
 }