Changeset 12820


Ignore:
Timestamp:
07/30/15 18:42:18 (4 years ago)
Author:
gkronber
Message:

#2434: merged r12787:12819 from trunk to branch

Location:
branches/crossvalidation-2434
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • branches/crossvalidation-2434

  • branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis

  • branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs

    r12012 r12820  
    108108      Parameters[ApproximateGradientsParameterName].Hidden = true; // should not be changed
    109109
     110      // necessary for BFGS
     111      Parameters.Add(new ValueParameter<BoolValue>("Maximization", new BoolValue(false)));
     112      Parameters["Maximization"].Hidden = true;
     113
    110114      var randomCreator = new HeuristicLab.Random.RandomCreator();
    111115      var gpInitializer = new GaussianProcessHyperparameterInitializer();
     
    181185    [StorableHook(HookType.AfterDeserialization)]
    182186    private void AfterDeserialization() {
     187      // BackwardsCompatibility3.4
     188      #region Backwards compatible code, remove with 3.5
     189      if (!Parameters.ContainsKey("Maximization")) {
     190        Parameters.Add(new ValueParameter<BoolValue>("Maximization", new BoolValue(false)));
     191        Parameters["Maximization"].Hidden = true;
     192      }
     193      #endregion
    183194    }
    184195  }
  • branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs

    r12509 r12820  
    8585    private double[] covarianceParameter;
    8686
    87     [Storable]
    88     private double[,] l;
    89 
    90     [Storable]
    91     private double[,] x;
     87    private double[,] l; // used to be storable in previous versions (is calculated lazily now)
     88    private double[,] x; // scaled training dataset, used to be storable in previous versions (is calculated lazily now)
     89
     90    // BackwardsCompatibility3.4
     91    #region Backwards compatible code, remove with 3.5
     92    [Storable(Name = "l")] // restore if available but don't store anymore
     93    private double[,] l_storable {
     94      set { this.l = value; }
     95      get {
     96        if (trainingDataset == null) return l; // this model has been created with an old version
     97        else return null; // if the training dataset is available l should not be serialized
     98      }
     99    }
     100    [Storable(Name = "x")] // restore if available but don't store anymore
     101    private double[,] x_storable {
     102      set { this.x = value; }
     103      get {
     104        if (trainingDataset == null) return x; // this model has been created with an old version
     105        else return null; // if the training dataset is available x should not be serialized
     106      }
     107    }
     108    #endregion
     109
     110
     111    [Storable]
     112    private IDataset trainingDataset; // it is better to store the original training dataset completely because this is more efficient in persistence
     113    [Storable]
     114    private int[] trainingRows;
     115
    92116    [Storable]
    93117    private Scaling inputScaling;
     
    101125      this.covarianceFunction = cloner.Clone(original.covarianceFunction);
    102126      this.inputScaling = cloner.Clone(original.inputScaling);
     127      this.trainingDataset = cloner.Clone(original.trainingDataset);
    103128      this.negativeLogLikelihood = original.negativeLogLikelihood;
    104129      this.targetVariable = original.targetVariable;
     
    112137
    113138      // shallow copies of arrays because they cannot be modified
     139      this.trainingRows = original.trainingRows;
    114140      this.allowedInputVariables = original.allowedInputVariables;
    115141      this.alpha = original.alpha;
     
    137163                                             .ToArray();
    138164      sqrSigmaNoise = Math.Exp(2.0 * hyp.Last());
    139 
    140165      CalculateModel(ds, rows);
    141166    }
    142167
    143168    private void CalculateModel(IDataset ds, IEnumerable<int> rows) {
    144       inputScaling = new Scaling(ds, allowedInputVariables, rows);
    145       x = AlglibUtil.PrepareAndScaleInputMatrix(ds, allowedInputVariables, rows, inputScaling);
     169      this.trainingDataset = (IDataset)ds.Clone();
     170      this.trainingRows = rows.ToArray();
     171      this.inputScaling = new Scaling(trainingDataset, allowedInputVariables, rows);
     172      this.x = CalculateX(trainingDataset, allowedInputVariables, rows, inputScaling);
    146173      var y = ds.GetDoubleValues(targetVariable, rows);
    147174
    148175      int n = x.GetLength(0);
    149       l = new double[n, n];
    150 
    151       // calculate means and covariances
     176
     177      // calculate cholesky decomposed (lower triangular) covariance matrix
     178      var cov = covarianceFunction.GetParameterizedCovarianceFunction(covarianceParameter, Enumerable.Range(0, x.GetLength(1)));
     179      this.l = CalculateL(x, cov, sqrSigmaNoise);
     180
     181      // calculate mean
    152182      var mean = meanFunction.GetParameterizedMeanFunction(meanParameter, Enumerable.Range(0, x.GetLength(1)));
    153183      double[] m = Enumerable.Range(0, x.GetLength(0))
     
    155185        .ToArray();
    156186
    157       var cov = covarianceFunction.GetParameterizedCovarianceFunction(covarianceParameter, Enumerable.Range(0, x.GetLength(1)));
    158       for (int i = 0; i < n; i++) {
    159         for (int j = i; j < n; j++) {
    160           l[j, i] = cov.Covariance(x, i, j) / sqrSigmaNoise;
    161           if (j == i) l[j, i] += 1.0;
    162         }
    163       }
    164 
    165 
    166       // cholesky decomposition
     187
     188
     189      // calculate sum of diagonal elements for likelihood
     190      double diagSum = Enumerable.Range(0, n).Select(i => Math.Log(l[i, i])).Sum();
     191
     192      // solve for alpha
     193      double[] ym = y.Zip(m, (a, b) => a - b).ToArray();
     194
    167195      int info;
    168196      alglib.densesolverreport denseSolveRep;
    169 
    170       var res = alglib.trfac.spdmatrixcholesky(ref l, n, false);
    171       if (!res) throw new ArgumentException("Matrix is not positive semidefinite");
    172 
    173       // calculate sum of diagonal elements for likelihood
    174       double diagSum = Enumerable.Range(0, n).Select(i => Math.Log(l[i, i])).Sum();
    175 
    176       // solve for alpha
    177       double[] ym = y.Zip(m, (a, b) => a - b).ToArray();
    178197
    179198      alglib.spdmatrixcholeskysolve(l, n, false, ym, out info, out denseSolveRep, out alpha);
     
    230249    }
    231250
     251    private static double[,] CalculateX(IDataset ds, IEnumerable<string> allowedInputVariables, IEnumerable<int> rows, Scaling inputScaling) {
     252      return AlglibUtil.PrepareAndScaleInputMatrix(ds, allowedInputVariables, rows, inputScaling);
     253    }
     254
     255    private static double[,] CalculateL(double[,] x, ParameterizedCovarianceFunction cov, double sqrSigmaNoise) {
     256      int n = x.GetLength(0);
     257      var l = new double[n, n];
     258
     259      // calculate covariances
     260      for (int i = 0; i < n; i++) {
     261        for (int j = i; j < n; j++) {
     262          l[j, i] = cov.Covariance(x, i, j) / sqrSigmaNoise;
     263          if (j == i) l[j, i] += 1.0;
     264        }
     265      }
     266
     267      // cholesky decomposition
     268      var res = alglib.trfac.spdmatrixcholesky(ref l, n, false);
     269      if (!res) throw new ArgumentException("Matrix is not positive semidefinite");
     270      return l;
     271    }
     272
    232273
    233274    public override IDeepCloneable Clone(Cloner cloner) {
     
    258299
    259300    private IEnumerable<double> GetEstimatedValuesHelper(IDataset dataset, IEnumerable<int> rows) {
     301      if (x == null) {
     302        this.x = CalculateX(trainingDataset, allowedInputVariables, trainingRows, inputScaling);
     303      }
     304      int n = x.GetLength(0);
     305
    260306      var newX = AlglibUtil.PrepareAndScaleInputMatrix(dataset, allowedInputVariables, rows, inputScaling);
    261307      int newN = newX.GetLength(0);
    262       int n = x.GetLength(0);
     308
    263309      var Ks = new double[newN, n];
    264310      var mean = meanFunction.GetParameterizedMeanFunction(meanParameter, Enumerable.Range(0, newX.GetLength(1)));
     
    278324
    279325    public IEnumerable<double> GetEstimatedVariance(IDataset dataset, IEnumerable<int> rows) {
     326      if (x == null) {
     327        this.x = CalculateX(trainingDataset, allowedInputVariables, trainingRows, inputScaling);
     328      }
     329      int n = x.GetLength(0);
     330
    280331      var newX = AlglibUtil.PrepareAndScaleInputMatrix(dataset, allowedInputVariables, rows, inputScaling);
    281332      int newN = newX.GetLength(0);
    282       int n = x.GetLength(0);
    283333
    284334      var kss = new double[newN];
    285335      double[,] sWKs = new double[n, newN];
    286336      var cov = covarianceFunction.GetParameterizedCovarianceFunction(covarianceParameter, Enumerable.Range(0, x.GetLength(1)));
     337
     338      if (l == null) {
     339        l = CalculateL(x, cov, sqrSigmaNoise);
     340      }
    287341
    288342      // for stddev
  • branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/Lbfgs.cs

    r12504 r12820  
    200200        RegisterEvents();
    201201        solutionCreator.OperatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
     202        solutionCreator.OperatorParameter.Hidden = true;
    202203        evaluator.OperatorParameter.ActualName = Problem.EvaluatorParameter.Name;
     204        evaluator.OperatorParameter.Hidden = true;
    203205        UpdateAnalyzers();
    204206        ParameterizeOperators();
     
    220222    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
    221223      base.Problem_OperatorsChanged(sender, e);
     224      RegisterEvents();
     225      solutionCreator.OperatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
     226      solutionCreator.OperatorParameter.Hidden = true;
     227      evaluator.OperatorParameter.ActualName = Problem.EvaluatorParameter.Name;
     228      evaluator.OperatorParameter.Hidden = true;
    222229      UpdateAnalyzers();
     230      ParameterizeOperators();
    223231    }
    224232
     
    266274        var realVectorParameterName = realVectorCreator.RealVectorParameter.ActualName;
    267275        initializer.PointParameter.ActualName = realVectorParameterName;
     276        initializer.PointParameter.Hidden = true;
    268277        makeStep.PointParameter.ActualName = realVectorParameterName;
     278        makeStep.PointParameter.Hidden = true;
    269279        analyzer.PointParameter.ActualName = realVectorParameterName;
     280        analyzer.PointParameter.Hidden = true;
    270281      }
    271282
    272283      var qualityParameterName = Problem.Evaluator.QualityParameter.ActualName;
    273284      updateResults.QualityParameter.ActualName = qualityParameterName;
     285      updateResults.QualityParameter.Hidden = true;
    274286      analyzer.QualityParameter.ActualName = qualityParameterName;
     287      analyzer.QualityParameter.Hidden = true;
    275288    }
    276289  }
  • branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/LbfgsUpdateResults.cs

    r12012 r12820  
    3737    private const string StateParameterName = "State";
    3838    private const string ApproximateGradientsParameterName = "ApproximateGradients";
     39    private const string MaximizationParameterName = "Maximization";
    3940
    4041    #region Parameter Properties
     
    5152      get { return (ILookupParameter<LbfgsState>)Parameters[StateParameterName]; }
    5253    }
     54    public ILookupParameter<BoolValue> MaximizationParameter {
     55      get { return (ILookupParameter<BoolValue>)Parameters[MaximizationParameterName]; }
     56    }
    5357    #endregion
    5458
     
    5862    private DoubleValue Quality { get { return QualityParameter.ActualValue; } }
    5963    private LbfgsState State { get { return StateParameter.ActualValue; } }
     64
     65    private BoolValue Maximization {
     66      get {
     67        // BackwardsCompatibility3.3
     68        #region Backwards compatible code, remove with 3.4
     69        // the parameter is new, previously we assumed minimization problems
     70        if (MaximizationParameter.ActualValue == null) return new BoolValue(false);
     71        #endregion
     72        return MaximizationParameter.ActualValue;
     73      }
     74    }
     75
    6076    #endregion
    6177
     
    7086      Parameters.Add(new LookupParameter<BoolValue>(ApproximateGradientsParameterName,
    7187                                                    "Flag that indicates if gradients should be approximated."));
     88      Parameters.Add(new LookupParameter<BoolValue>(MaximizationParameterName, "Flag that indicates if we solve a maximization problem."));
    7289      // in & out
    7390      Parameters.Add(new LookupParameter<LbfgsState>(StateParameterName, "The state of the LM-BFGS algorithm."));
     91    }
     92
     93    [StorableHook(HookType.AfterDeserialization)]
     94    private void AfterDeserialization() {
     95      // BackwardsCompatibility3.3
     96
     97      #region Backwards compatible code, remove with 3.4
     98      if (!Parameters.ContainsKey(MaximizationParameterName)) {
     99        // previous behaviour defaulted to minimization
     100        Parameters.Add(new LookupParameter<BoolValue>(MaximizationParameterName, "Flag that indicates if we solve a maximization problem."));
     101      }
     102      #endregion
    74103    }
    75104
     
    80109    public override IOperation Apply() {
    81110      var state = State;
    82       var f = Quality.Value;
     111      var sign = Maximization.Value ? -1.0 : 1.0;
     112      var f = sign * Quality.Value;
    83113      state.State.f = f;
    84114      if (!ApproximateGradients.Value) {
    85         var g = QualityGradients.ToArray();
     115        var g = QualityGradients.Select(gi => sign * gi).ToArray();
    86116        state.State.g = g;
    87117      }
  • branches/crossvalidation-2434/HeuristicLab.Optimization.Views

  • branches/crossvalidation-2434/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionBoxPlotView.cs

    r12077 r12820  
    345345      switch (axisDimension) {
    346346        case AxisDimension.Color: {
    347             value = GetCategoricalValue(-1, run.Color.ToString());
     347            const int colorDimension = -1;
     348            if (!categoricalMapping.ContainsKey(colorDimension)) {
     349              categoricalMapping[colorDimension] = Content.Where(r => r.Visible)
     350                  .Select(r => r.Color.Name)
     351                  .Distinct()
     352                  .OrderBy(c => c, new NaturalStringComparer())
     353                  .Select((c, i) => new { Color = c, Index = i })
     354                  .ToDictionary(a => (object)a.Color, a => (double)a.Index);
     355
     356            }
     357            value = GetCategoricalValue(colorDimension, run.Color.Name);
    348358            break;
    349359          }
  • branches/crossvalidation-2434/HeuristicLab.Optimizer

  • branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis

  • branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs

    r12509 r12820  
    4949    }
    5050
     51    [Storable]
    5152    private readonly ItemCollection<IClassificationSolution> classificationSolutions;
    5253    public IItemCollection<IClassificationSolution> ClassificationSolutions {
     
    6667    [StorableHook(HookType.AfterDeserialization)]
    6768    private void AfterDeserialization() {
    68       foreach (var model in Model.Models) {
    69         IClassificationProblemData problemData = (IClassificationProblemData)ProblemData.Clone();
    70         problemData.TrainingPartition.Start = trainingPartitions[model].Start;
    71         problemData.TrainingPartition.End = trainingPartitions[model].End;
    72         problemData.TestPartition.Start = testPartitions[model].Start;
    73         problemData.TestPartition.End = testPartitions[model].End;
    74 
    75         classificationSolutions.Add(model.CreateClassificationSolution(problemData));
     69      if (!classificationSolutions.Any()) {
     70        foreach (var model in Model.Models) {
     71          IClassificationProblemData problemData = (IClassificationProblemData)ProblemData.Clone();
     72          problemData.TrainingPartition.Start = trainingPartitions[model].Start;
     73          problemData.TrainingPartition.End = trainingPartitions[model].End;
     74          problemData.TestPartition.Start = testPartitions[model].Start;
     75          problemData.TestPartition.End = testPartitions[model].End;
     76
     77          classificationSolutions.Add(model.CreateClassificationSolution(problemData));
     78        }
    7679      }
    7780      RegisterClassificationSolutionsEventHandler();
  • branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs

    r12509 r12820  
    5050    }
    5151
     52    [Storable]
    5253    private readonly ItemCollection<IRegressionSolution> regressionSolutions;
    5354    public IItemCollection<IRegressionSolution> RegressionSolutions {
     
    6768    [StorableHook(HookType.AfterDeserialization)]
    6869    private void AfterDeserialization() {
    69       foreach (var model in Model.Models) {
    70         IRegressionProblemData problemData = (IRegressionProblemData)ProblemData.Clone();
    71         problemData.TrainingPartition.Start = trainingPartitions[model].Start;
    72         problemData.TrainingPartition.End = trainingPartitions[model].End;
    73         problemData.TestPartition.Start = testPartitions[model].Start;
    74         problemData.TestPartition.End = testPartitions[model].End;
    75 
    76         regressionSolutions.Add(model.CreateRegressionSolution(problemData));
     70      if (!regressionSolutions.Any()) {
     71        foreach (var model in Model.Models) {
     72          IRegressionProblemData problemData = (IRegressionProblemData)ProblemData.Clone();
     73          problemData.TrainingPartition.Start = trainingPartitions[model].Start;
     74          problemData.TrainingPartition.End = trainingPartitions[model].End;
     75          problemData.TestPartition.Start = testPartitions[model].Start;
     76          problemData.TestPartition.End = testPartitions[model].End;
     77
     78          regressionSolutions.Add(model.CreateRegressionSolution(problemData));
     79        }
    7780      }
    7881      RegisterRegressionSolutionsEventHandler();
  • branches/crossvalidation-2434/HeuristicLab.Problems.NK/3.3

    • Property svn:ignore set to
      bin
      obj
      Plugin.cs
  • branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment

  • branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs

    r12012 r12820  
    9090    private ILookupParameter<BoolValue> AllMovesTabuParameter {
    9191      get { return (ILookupParameter<BoolValue>)Parameters["AllMovesTabu"]; }
     92    }
     93
     94    public ILookupParameter<IntValue> EvaluatedMovesParameter {
     95      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedMoves"]; }
    9296    }
    9397    #endregion
     
    117121      Parameters.Add(new ValueLookupParameter<IntValue>("AlternativeAspirationTenure", "The time t that a move will be remembered for the alternative aspiration condition."));
    118122      Parameters.Add(new LookupParameter<BoolValue>("AllMovesTabu", "Indicates that all moves are tabu."));
     123      Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of move evaluations made."));
    119124    }
    120125
     
    129134      if (!Parameters.ContainsKey("AllMovesTabu")) {
    130135        Parameters.Add(new LookupParameter<BoolValue>("AllMovesTabu", "Indicates that all moves are tabu."));
     136      }
     137      if (!Parameters.ContainsKey("EvaluatedMoves")) {
     138        Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of move evaluations made."));
    131139      }
    132140      #endregion
     
    163171      bool already_aspired = false;
    164172
     173      var evaluatedMoves = 0;
    165174      foreach (Swap2Move move in ExhaustiveSwap2MoveGenerator.Generate(solution)) {
    166175        double moveQuality;
    167         if (lastMove == null)
     176        if (lastMove == null) {
    168177          moveQuality = QAPSwap2MoveEvaluator.Apply(solution, move, weights, distances);
    169         else if (allMovesTabu) moveQuality = moveQualityMatrix[move.Index1, move.Index2];
    170         else moveQuality = QAPSwap2MoveEvaluator.Apply(solution, move, moveQualityMatrix[move.Index1, move.Index2], weights, distances, lastMove);
     178          evaluatedMoves++;
     179        } else if (allMovesTabu) moveQuality = moveQualityMatrix[move.Index1, move.Index2];
     180        else {
     181          moveQuality = QAPSwap2MoveEvaluator.Apply(solution, move, moveQualityMatrix[move.Index1, move.Index2], weights, distances, lastMove);
     182          evaluatedMoves++;
     183        }
    171184
    172185        moveQualityMatrix[move.Index1, move.Index2] = moveQuality;
     
    200213        }
    201214      }
     215
     216      EvaluatedMovesParameter.ActualValue.Value += evaluatedMoves;
    202217
    203218      allMovesTabu = bestMove == null;
  • branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs

    r12504 r12820  
    168168      VariableCreator variableCreator = new VariableCreator();
    169169      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
     170      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
     171      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedMoves", new IntValue(0)));
    170172
    171173      ResultsCollector resultsCollector = new ResultsCollector();
    172174      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations", "The actual iteration."));
     175      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of full solution evaluations."));
     176      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of move evaluations."));
    173177
    174178      solutionsCreator = new SolutionsCreator();
    175179      solutionsCreator.NumberOfSolutions = new IntValue(1);
     180
     181      IntCounter counter = new IntCounter();
     182      counter.ValueParameter.ActualName = "EvaluatedSolutions";
     183      counter.Increment = new IntValue(1);
    176184
    177185      Placeholder analyzer = new Placeholder();
     
    194202      mainOperator.ShortTermMemoryParameter.ActualName = "ShortTermMemory";
    195203      mainOperator.UseAlternativeAspirationParameter.ActualName = UseAlternativeAspirationParameter.Name;
     204      mainOperator.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
    196205
    197206      ConditionalBranch qualityStopBranch = new ConditionalBranch();
     
    226235      variableCreator.Successor = resultsCollector;
    227236      resultsCollector.Successor = solutionsCreator;
    228       solutionsCreator.Successor = analyzer;
     237      solutionsCreator.Successor = counter;
     238      counter.Successor = analyzer;
    229239      analyzer.Successor = ussp;
    230240      ussp.Operator = mainOperator;
  • branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs

    r12012 r12820  
    108108          }
    109109        }
    110         evaluatedSolutions.Value = (int)Math.Ceiling(evaluations);
     110        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
    111111        if (bestMove == null) break;
    112112        InversionManipulator.Apply(assignment, bestMove.Index1, bestMove.Index2);
  • branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs

    r12012 r12820  
    119119          }
    120120        }
    121         evaluatedSolutions.Value = (int)Math.Ceiling(evaluations);
     121        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
    122122        if (bestMove == null) break;
    123123        ScrambleManipulator.Apply(assignment, bestMove.StartIndex, bestMove.ScrambledIndices);
  • branches/crossvalidation-2434/HeuristicLab.Tests

  • branches/crossvalidation-2434/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsOpSampleTest.cs

    r12722 r12820  
    7575
    7676      opProblem.Name = "1_p64_t070";
    77       opProblem.Description = "Represents a symmetric Traveling Salesman Problem.";
     77      opProblem.Description = "Represents an instance of an orienteering problem.";
    7878      #endregion
    7979      #region Algorithm Configuration
    80       vns.Name = "Variable Neighborhood Search - TSP";
    81       vns.Description = "A variable neighborhood search algorithm which solves a funny TSP instance";
     80      vns.Name = "Variable Neighborhood Search - OP";
     81      vns.Description = "A variable neighborhood search algorithm which solves an orienteering problem instance";
    8282      vns.Problem = opProblem;
    8383
Note: See TracChangeset for help on using the changeset viewer.