Free cookie consent management tool by TermsFeed Policy Generator

Changeset 2370


Ignore:
Timestamp:
09/18/09 22:20:34 (15 years ago)
Author:
gkronber
Message:

Added enumerable type for model results and changed analyzer model, the database backend and the model analysis operators to use the enumerable type instead of hard-coded strings. #755 (Hard-coded strings for variable names of data-modeling results)

Location:
trunk/sources
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Modeling.Database.SQLServerCompact/3.2/DatabaseService.cs

    r2355 r2370  
    6060      dlo.LoadWith<InputVariableResult>(ir => ir.Result);
    6161      dlo.LoadWith<Model>(m => m.TargetVariable);
    62       dlo.LoadWith<Model>(m => m.Algorithm);     
     62      dlo.LoadWith<Model>(m => m.Algorithm);
    6363      ctx.LoadOptions = dlo;
    6464    }
    … …  
    110110
    111111      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
    112         foreach (KeyValuePair<string, double> pair in model.Results) {
    113           Result result = GetOrCreateResult(pair.Key);
     112        foreach (KeyValuePair<ModelingResult, double> pair in model.Results) {
     113          Result result = GetOrCreateResult(pair.Key.ToString());
    114114          ctx.ModelResults.InsertOnSubmit(new ModelResult(m, result, pair.Value));
    115115        }
    … …  
    127127
    128128      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
    129         IEnumerable<MethodInfo> inputVariableResultInfos = model.GetType().GetMethods().Where(
    130           info => info.GetParameters().Count() == 1 &&
    131              info.GetParameters()[0].ParameterType == typeof(string) &&
    132              info.GetParameters()[0].Name == "variableName" &&
    133              info.ReturnParameter.ParameterType == typeof(double) &&
    134              info.Name.StartsWith("Get"));
    135         foreach (MethodInfo inputVariableResultInfo in inputVariableResultInfos) {
    136           Result result = GetOrCreateResult(inputVariableResultInfo.Name.Substring(3));
    137           foreach (InputVariable variable in ctx.InputVariables.Where(iv => iv.Model == m)) {
    138             double value = (double)inputVariableResultInfo.Invoke(model, new object[] { variable.Variable.Name });
    139             ctx.InputVariableResults.InsertOnSubmit(new InputVariableResult(variable, result, value));
     129        foreach (InputVariable variable in ctx.InputVariables.Where(iv => iv.Model == m)) {
     130          foreach (KeyValuePair<ModelingResult, double> variableResult in model.GetVariableResults(variable.Variable.Name)) {
     131            Result result = GetOrCreateResult(variableResult.Key.ToString());
     132            ctx.InputVariableResults.InsertOnSubmit(new InputVariableResult(variable, result, variableResult.Value));
    140133          }
    141134        }
    … …  
    286279      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
    287280        var md = from r in ctx.MetaData
    288                       where r.Name == name
    289                       select r;
     281                 where r.Name == name
     282                 select r;
    290283        if (md.Count() == 0) {
    291284          metadata = new MetaData(name);

  • trunk/sources/HeuristicLab.Modeling/3.2/AnalyzerModel.cs

    r2369 r2370  
    2525using HeuristicLab.Core;
    2626using HeuristicLab.DataAnalysis;
     27using HeuristicLab.Data;
    2728
    2829namespace HeuristicLab.Modeling {
    … …  
    6364    }
    6465
    65     private Dictionary<string, double> results = new Dictionary<string, double>();
    66     public IEnumerable<KeyValuePair<string, double>> Results {
     66    private Dictionary<ModelingResult, double> results = new Dictionary<ModelingResult, double>();
     67    public IEnumerable<KeyValuePair<ModelingResult, double>> Results {
    6768      get { return results; }
    6869    }
    6970
    70     public void SetResult(string name, double value) {
    71       results.Add(name, value);
     71    public void ExtractResult(IScope scope, ModelingResult result) {
     72      SetResult(result, scope.GetVariableValue<DoubleData>(result.ToString(), false).Data);
    7273    }
    7374
    74     public double GetResult(string name) {
    75       return results[name];
     75
     76    public void SetResult(ModelingResult result, double value) {
     77      results.Add(result, value);
     78    }
     79
     80    public double GetResult(ModelingResult result) {
     81      return results[result];
    7682    }
    7783
    … …  
    8995    }
    9096
    91     public double GetVariableQualityImpact(string variableName) {
    92       if (variableQualityImpacts.ContainsKey(variableName)) return variableQualityImpacts[variableName];
    93       else throw new ArgumentException("Impact of variable " + variableName + " is not available.");
     97    private Dictionary<string, Dictionary<ModelingResult, double>> variableResults = new Dictionary<string, Dictionary<ModelingResult, double>>();
     98    public double GetVariableResult(ModelingResult result, string variableName) {
     99      if (variableResults.ContainsKey(variableName)) {
     100        if (variableResults[variableName].ContainsKey(result)) {
     101          return variableResults[variableName][result];
     102        } else throw new ArgumentException("No value for modeling result: " + result + ".");
     103      } else throw new ArgumentException("No variable result for variable " + variableName + ".");
    94104    }
    95105
    96     public double GetVariableEvaluationImpact(string variableName) {
    97       if (variableEvaluationImpacts.ContainsKey(variableName)) return variableEvaluationImpacts[variableName];
    98       else throw new ArgumentException("Impact of variable " + variableName + " is not available.");
     106    public void SetVariableResult(ModelingResult result, string variableName, double value) {
     107      if (!variableResults.ContainsKey(variableName)) {
     108        variableResults.Add(variableName, new Dictionary<ModelingResult, double>());
     109      }
     110      variableResults[variableName][result] = value;
     111    }
     112
     113    public IEnumerable<KeyValuePair<ModelingResult, double>> GetVariableResults(string variableName) {
     114      return variableResults[variableName];
    99115    }
    100116
    … …  
    103119    #endregion
    104120
    105     private Dictionary<string, double> variableQualityImpacts = new Dictionary<string, double>();
    106     public void SetVariableQualityImpact(string variableName, double impact) {
    107       variableQualityImpacts[variableName] = impact;
    108     }
    109 
    110     public void SetVariableQualityImpact(int variableIndex, double impact) {
    111       variableQualityImpacts[dataset.GetVariableName(variableIndex)] = impact;
    112     }
    113 
    114     private Dictionary<string, double> variableEvaluationImpacts = new Dictionary<string, double>();
    115     public void SetVariableEvaluationImpact(string variableName, double impact) {
    116       variableEvaluationImpacts[variableName] = impact;
    117     }
    118 
    119     public void SetVariableEvaluationImpact(int variableIndex, double impact) {
    120       variableEvaluationImpacts[dataset.GetVariableName(variableIndex)] = impact;
    121     }
    122121  }
    123122}

  • trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs

    r2369 r2370  
    3737      SimpleAccuracyEvaluator trainingAccuracy = new SimpleAccuracyEvaluator();
    3838      trainingAccuracy.Name = "TrainingAccuracyEvaluator";
    39       trainingAccuracy.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
     39      trainingAccuracy.GetVariableInfo("Accuracy").ActualName = ModelingResult.TrainingAccuracy.ToString();
    4040      trainingAccuracy.GetVariableInfo("Values").ActualName = "TrainingValues";
    4141
    4242      SimpleAccuracyEvaluator validationAccuracy = new SimpleAccuracyEvaluator();
    4343      validationAccuracy.Name = "ValidationAccuracyEvaluator";
    44       validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
     44      validationAccuracy.GetVariableInfo("Accuracy").ActualName = ModelingResult.ValidationAccuracy.ToString();
    4545      validationAccuracy.GetVariableInfo("Values").ActualName = "ValidationValues";
    4646
    4747      SimpleAccuracyEvaluator testAccuracy = new SimpleAccuracyEvaluator();
    4848      testAccuracy.Name = "TestAccuracyEvaluator";
    49       testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
     49      testAccuracy.GetVariableInfo("Accuracy").ActualName = ModelingResult.TestAccuracy.ToString();
    5050      testAccuracy.GetVariableInfo("Values").ActualName = "TestValues";
    5151
    … …  
    8282    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
    8383      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
    84       model.SetResult("TrainingAccuracy", modelScope.GetVariableValue<DoubleData>("TrainingAccuracy", false).Data);
    85       model.SetResult("ValidationAccuracy", modelScope.GetVariableValue<DoubleData>("ValidationAccuracy", false).Data);
    86       model.SetResult("TestAccuracy", modelScope.GetVariableValue<DoubleData>("TestAccuracy", false).Data);
     84      model.ExtractResult(modelScope, ModelingResult.TrainingAccuracy);
     85      model.ExtractResult(modelScope, ModelingResult.ValidationAccuracy);
     86      model.ExtractResult(modelScope, ModelingResult.TestAccuracy);
    8787      model.Type = ModelType.Classification;
    8888      return model;

  • trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs

    r2369 r2370  
    5050      SimpleMSEEvaluator trainingMseEvaluator = new SimpleMSEEvaluator();
    5151      trainingMseEvaluator.Name = "TrainingMseEvaluator";
    52       trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
     52      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = ModelingResult.TrainingMeanSquaredError.ToString();
    5353      trainingMseEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
    5454      SimpleMSEEvaluator validationMseEvaluator = new SimpleMSEEvaluator();
    5555      validationMseEvaluator.Name = "ValidationMseEvaluator";
    56       validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
     56      validationMseEvaluator.GetVariableInfo("MSE").ActualName = ModelingResult.ValidationMeanSquaredError.ToString();
    5757      validationMseEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
    5858      SimpleMSEEvaluator testMseEvaluator = new SimpleMSEEvaluator();
    5959      testMseEvaluator.Name = "TestMseEvaluator";
    60       testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
     60      testMseEvaluator.GetVariableInfo("MSE").ActualName = ModelingResult.TestMeanSquaredError.ToString();
    6161      testMseEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
    6262      #endregion
    … …  
    6464      SimpleMeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
    6565      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
    66       trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
     66      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = ModelingResult.ValidationMeanAbsolutePercentageError.ToString();
    6767      trainingMapeEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
    6868      SimpleMeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
    6969      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
    70       validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
     70      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = ModelingResult.ValidationMeanAbsolutePercentageError.ToString();
    7171      validationMapeEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
    7272      SimpleMeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
    7373      testMapeEvaluator.Name = "TestMapeEvaluator";
    74       testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
     74      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = ModelingResult.TestMeanAbsolutePercentageError.ToString();
    7575      testMapeEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
    7676      #endregion
    … …  
    7878      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
    7979      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
    80       trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
     80      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = ModelingResult.TrainingMeanAbsolutePercentageOfRangeError.ToString();
    8181      trainingMapreEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
    8282      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
    8383      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
    84       validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
     84      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = ModelingResult.ValidationMeanAbsolutePercentageOfRangeError.ToString();
    8585      validationMapreEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
    8686      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
    8787      testMapreEvaluator.Name = "TestMapreEvaluator";
    88       testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
     88      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = ModelingResult.TestMeanAbsolutePercentageOfRangeError.ToString();
    8989      testMapreEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
    9090      #endregion MAPRE
    … …  
    9292      SimpleR2Evaluator trainingR2Evaluator = new SimpleR2Evaluator();
    9393      trainingR2Evaluator.Name = "TrainingR2Evaluator";
    94       trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
     94      trainingR2Evaluator.GetVariableInfo("R2").ActualName = ModelingResult.TrainingCoefficientOfDetermination.ToString();
    9595      trainingR2Evaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
    9696      SimpleR2Evaluator validationR2Evaluator = new SimpleR2Evaluator();
    9797      validationR2Evaluator.Name = "ValidationR2Evaluator";
    98       validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
     98      validationR2Evaluator.GetVariableInfo("R2").ActualName = ModelingResult.ValidationCoefficientOfDetermination.ToString();
    9999      validationR2Evaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
    100100      SimpleR2Evaluator testR2Evaluator = new SimpleR2Evaluator();
    101101      testR2Evaluator.Name = "TestR2Evaluator";
    102       testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
     102      testR2Evaluator.GetVariableInfo("R2").ActualName = ModelingResult.TestCoefficientOfDetermination.ToString();
    103103      testR2Evaluator.GetVariableInfo("Values").ActualName = "TestValues";
    104104      #endregion
    … …  
    106106      SimpleVarianceAccountedForEvaluator trainingVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
    107107      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
    108       trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
     108      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = ModelingResult.TrainingVarianceAccountedFor.ToString();
    109109      trainingVAFEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
    110110      SimpleVarianceAccountedForEvaluator validationVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
    111111      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
    112       validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
     112      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = ModelingResult.ValidationVarianceAccountedFor.ToString();
    113113      validationVAFEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
    114114      SimpleVarianceAccountedForEvaluator testVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
    115115      testVAFEvaluator.Name = "TestVAFEvaluator";
    116       testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
     116      testVAFEvaluator.GetVariableInfo("VAF").ActualName = ModelingResult.TestVarianceAccountedFor.ToString();
    117117      testVAFEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
    118118      #endregion
    … …  
    164164      model.TestSamplesEnd = modelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
    165165
    166       model.SetResult("TrainingMeanSquaredError", modelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data);
    167       model.SetResult("ValidationMeanSquaredError", modelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data);
    168       model.SetResult("TestMeanSquaredError", modelScope.GetVariableValue<DoubleData>("TestMSE", false).Data);
    169       model.SetResult("TrainingCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data);
    170       model.SetResult("ValidationCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data);
    171       model.SetResult("TestCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("TestR2", false).Data);
    172       model.SetResult("TrainingMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data);
    173       model.SetResult("ValidationMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
    174       model.SetResult("TestMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data);
    175       model.SetResult("TrainingMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data);
    176       model.SetResult("ValidationMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data);
    177       model.SetResult("TestMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data);
    178       model.SetResult("TrainingVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data);
    179       model.SetResult("ValidationVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data);
    180       model.SetResult("TestVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("TestVAF", false).Data);
    181 
    182       ItemList evaluationImpacts = modelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
    183       ItemList qualityImpacts = modelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
     166      model.ExtractResult(modelScope, ModelingResult.TrainingMeanSquaredError);
     167      model.ExtractResult(modelScope, ModelingResult.ValidationMeanSquaredError);
     168      model.ExtractResult(modelScope, ModelingResult.TestMeanSquaredError);
     169      model.ExtractResult(modelScope, ModelingResult.TrainingMeanAbsolutePercentageError);
     170      model.ExtractResult(modelScope, ModelingResult.ValidationMeanAbsolutePercentageError);
     171      model.ExtractResult(modelScope, ModelingResult.TestMeanAbsolutePercentageError);
     172      model.ExtractResult(modelScope, ModelingResult.TrainingMeanAbsolutePercentageOfRangeError);
     173      model.ExtractResult(modelScope, ModelingResult.ValidationMeanAbsolutePercentageOfRangeError);
     174      model.ExtractResult(modelScope, ModelingResult.TestMeanAbsolutePercentageOfRangeError);
     175      model.ExtractResult(modelScope, ModelingResult.TrainingCoefficientOfDetermination);
     176      model.ExtractResult(modelScope, ModelingResult.ValidationCoefficientOfDetermination);
     177      model.ExtractResult(modelScope, ModelingResult.TestCoefficientOfDetermination);
     178      model.ExtractResult(modelScope, ModelingResult.TrainingVarianceAccountedFor);
     179      model.ExtractResult(modelScope, ModelingResult.ValidationVarianceAccountedFor);
     180      model.ExtractResult(modelScope, ModelingResult.TestVarianceAccountedFor);
     181
     182      ItemList evaluationImpacts = modelScope.GetVariableValue<ItemList>(ModelingResult.VariableEvaluationImpact.ToString(), false);
     183      ItemList qualityImpacts = modelScope.GetVariableValue<ItemList>(ModelingResult.VariableQualityImpact.ToString(), false);
    184184      foreach (ItemList row in evaluationImpacts) {
    185185        string variableName = ((StringData)row[0]).Data;
    186186        double impact = ((DoubleData)row[1]).Data;
    187         model.SetVariableEvaluationImpact(variableName, impact);
     187        model.SetVariableResult(ModelingResult.VariableEvaluationImpact, variableName, impact);
    188188        model.AddInputVariable(variableName);
    189189      }
    … …  
    191191        string variableName = ((StringData)row[0]).Data;
    192192        double impact = ((DoubleData)row[1]).Data;
    193         model.SetVariableQualityImpact(variableName, impact);
     193        model.SetVariableResult(ModelingResult.VariableQualityImpact, variableName, impact);
    194194        model.AddInputVariable(variableName);
    195195      }

  • trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs

    r2369 r2370  
    4848      trainingTheil.Name = "TrainingTheilInequalityEvaluator";
    4949      trainingTheil.GetVariableInfo("Values").ActualName = "TrainingValues";
    50       trainingTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TrainingTheilInequalityCoefficient";
     50      trainingTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = ModelingResult.TrainingTheilInequality.ToString();
    5151      SimpleTheilInequalityCoefficientEvaluator validationTheil = new SimpleTheilInequalityCoefficientEvaluator();
    5252      validationTheil.Name = "ValidationTheilInequalityEvaluator";
    5353      validationTheil.GetVariableInfo("Values").ActualName = "ValidationValues";
    54       validationTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "ValidationTheilInequalityCoefficient";
     54      validationTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = ModelingResult.ValidationTheilInequality.ToString();
    5555      SimpleTheilInequalityCoefficientEvaluator testTheil = new SimpleTheilInequalityCoefficientEvaluator();
    5656      testTheil.Name = "TestTheilInequalityEvaluator";
    5757      testTheil.GetVariableInfo("Values").ActualName = "TestValues";
    58       testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TestTheilInequalityCoefficient";
     58      testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = ModelingResult.TestTheilInequality.ToString();
    5959
    6060      seq.AddSubOperator(trainingTheil);
    … …  
    6969    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
    7070      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
    71       model.SetResult("TrainingTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("TrainingTheilInequalityCoefficient", true).Data);
    72       model.SetResult("ValidationTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("ValidationTheilInequalityCoefficient", true).Data);
    73       model.SetResult("TestTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("TestTheilInequalityCoefficient", true).Data);
     71      model.ExtractResult(modelScope, ModelingResult.TrainingTheilInequality);
     72      model.ExtractResult(modelScope, ModelingResult.ValidationTheilInequality);
     73      model.ExtractResult(modelScope, ModelingResult.TestTheilInequality);
    7474      model.Type = ModelType.TimeSeriesPrognosis;
    7575      return model;

  • trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj

    r2356 r2370  
    8484    <Compile Include="AnalyzerModel.cs" />
    8585    <Compile Include="BestSolutionStorer.cs" />
     86    <Compile Include="ModelingResult.cs" />
     87    <Compile Include="ModelType.cs" />
    8688    <Compile Include="DefaultClassificationOperators.cs" />
    8789    <Compile Include="DefaultRegressionOperators.cs" />

  • trunk/sources/HeuristicLab.Modeling/3.2/IAnalyzerModel.cs

    r2369 r2370  
    3333    ModelType Type { get; set; }
    3434    IEnumerable<string> InputVariables { get; }
    35     IEnumerable<KeyValuePair<string, double>> Results { get; }
     35    IEnumerable<KeyValuePair<ModelingResult, double>> Results { get; }
    3636    IEnumerable<KeyValuePair<string, double>> MetaData { get; }
    3737    int TrainingSamplesStart { get; set; }
    … …  
    4141    int TestSamplesStart { get; set; }
    4242    int TestSamplesEnd { get; set; }
    43     void SetResult(string name, double value);
    44     double GetResult(string name);
     43    void ExtractResult(IScope scope, ModelingResult result);
     44    void SetResult(ModelingResult result, double value);
     45    double GetResult(ModelingResult result);
    4546    void SetMetaData(string name, double data);
    4647    double GetMetaData(string name);
    47     double GetVariableEvaluationImpact(string variableName);
    48     double GetVariableQualityImpact(string variableName);
     48    double GetVariableResult(ModelingResult result, string variableName);
    4949    void AddInputVariable(string variableName);
    50     void SetVariableEvaluationImpact(string variableName, double impact);
    51     void SetVariableQualityImpact(string variableName, double impact);
     50    void SetVariableResult(ModelingResult result, string variableName, double value);
     51    IEnumerable<KeyValuePair<ModelingResult, double>> GetVariableResults(string variableName);
    5252  }
    5353}
Note: See TracChangeset for help on using the changeset viewer.