Changeset 17134 for branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMAlgorithm/EMMAlgorithm.cs

Timestamp:

07/11/19 16:30:22 (5 years ago)

Author:

msemenki

Message:

#2988:

1. The file system was changed, folders was added and part of files was transferred in these folders.
2. HelpFunctions class was divided on 2 parts: HelpFuctions for common purposes static functions and SelfConfiguration that include functions for self-configuration mechanism realization (is used in EMMSucsessMap).
3. Parts of self-configuration mechanism was transferred from EMMSucsessMap.cs to SelfConfiguration.cs. Now EMMSucsessMap used SelfConfiguration like one of data member. Other parts of project was adopted for this changing.
4. FileComunication class was added. It include the majority of functions for printing to files or reading from files. Here were realized possibility to write and read to hl files.
5. ModelTreeNode.cs has additional possibility - to write sub-model in string (then it is possible to write it in file).
6. InfixExpressionFormatter.cs can work with TreeModelNode.
7. Possibility for different map types to be readable from files was extended and cheeked.
8. Such parameters like - ClusterNumbers, ClusterNumbersShow, NegbourNumber, NegbourType (that is used only in several maps) was transferred from EMMAlgorithm to Map Parameters. Now EMMBaseMap class inherited from ParameterizedNamedItem (not from Item). And EMMIslandMap and EMMNetworkMap contains their parameters (constructors was modified). CreationMap calls functions were simplified.
9. Functions for different distance metric calculation was added. Now, it is possible to calculate different types of distances between models (with different random values of constants).
10. DistanceParametr was added. Now maps can be created according different types of distance calculations.
11. The class EMMClustering has new name KMeansClusterizationAlgorithm. On KMeansClusterizationAlgorithm bug with bloating of centroids list was fixed. Algorithm was adopted for working with different type of distance metric and get maximum number of iterations.
12. Possibilities for constants optimization in sub-models an whole tree was added. EMMAlgorithm get new function for evaluation of individuals (and some additional technical stuff for that). Function for trees with model in usual tree transformation and back was added.
13. EMMAlgorithm was divided on 2 parts:

• EMMAlgorithm, that contain evolutionary algorithm working with sub-models, and use ready to use maps;
• ModelSetPreparation, that contain distance calculation, model set simplification and map creation.

Location:

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMAlgorithm

Files:

• . (added)
• EMMAlgorithm.cs (moved) (moved from branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMAlgorithm.cs) (12 diffs)

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMAlgorithm/EMMAlgorithm.cs

@@ -25 +25 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
 using HeuristicLab.Random;
 using HeuristicLab.Selection;
@@ -34 +36 @@
 
 namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
-  [Item("Evolvment Models Of Models Algorithm (EMM) ", "EMM implementation")]
+  [Item("Evolvement Models Of Models Algorithm (EMM) ", "EMM implementation")]
   [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 125)]
   [StorableType("AD23B21F-089A-4C6C-AD2E-1B01E7939CF5")]
   public class EMMAlgorithm : EvolvmentModelsOfModelsAlgorithmBase {
+    #region Constructors
     public EMMAlgorithm() : base() { }
     protected EMMAlgorithm(EMMAlgorithm original, Cloner cloner) : base(original, cloner) { }
@@ -46 +49 @@
     [StorableConstructor]
     protected EMMAlgorithm(StorableConstructorFlag _) : base(_) { }
-
+    #endregion
+    #region Algorithm run
     protected override void Run(CancellationToken cancellationToken) {
+
+      Map.DistanceParametr = DistanceType.Value;
+
       if (AlgorithmImplemetationType.Value == "Read") {
-        Map.MapRead(RandomParameter.Value, trees, "Map.txt");
+        Map.MapRead(trees);
       } else {
         Map.MapCreationPrepare(trees);
-        Map.CreateMap(RandomParameter.Value, ClusterNumbersParameter.Value.Value);
-        // Map.WriteMapToTxtFile(RandomParameter.Value); хайв этого не любит.. ворчит
-      }
-      ClusterNumbersShowParameter.Value.Value = Map.Map.Count;
-
-      if (AlgorithmImplemetationType.Value == "OnlyMap") {
-        globalScope = new Scope("Global Scope");
-        executionContext = new ExecutionContext(null, this, globalScope);
-      } else {
-        if (previousExecutionState != ExecutionState.Paused) {
-          InitializeAlgorithm(cancellationToken);
-        }
-        if (!globalScope.Variables.ContainsKey("TreeModelMap"))
-          globalScope.Variables.Add(new Variable("TreeModelMap", Map));
-        if (!globalScope.Variables.ContainsKey("Map"))
-          globalScope.Variables.Add(new Variable("Map", Map));
-        EMMAlgorithmRun(cancellationToken);
-      }
+        Map.CreateMap(RandomParameter.Value, Problem);
+      }
+      if (previousExecutionState != ExecutionState.Paused) {
+        InitializeAlgorithm(cancellationToken);
+      }
+      if (!globalScope.Variables.ContainsKey("TreeModelMap"))
+        globalScope.Variables.Add(new Variable("TreeModelMap", Map));
+      if (!globalScope.Variables.ContainsKey("Map"))
+        globalScope.Variables.Add(new Variable("Map", Map));
+      EMMAlgorithmRun(cancellationToken);
     }
     private void EMMAlgorithmRun(CancellationToken cancellationToken) {
@@ -88 +87 @@
       var rand = RandomParameter.Value;
       var elites = Elites.Value;
-
-      // cancellation token for the inner operations which should not be immediately cancelled
+      var fmd = new InfixExpressionFormatter();
+      // cancellation token for the inner operations which should not be immediately canceled
       var innerToken = new CancellationToken();
+      // for future
+      //var mutatorTypes = new SymbolicExpressionTreeManipulator[]
+      //{
+      //     new EMMMultyPointsMutator(),
+      //     new EMMMultyPointsMutatorNodeTypeSaving (),
+      //     new EMMMutators()
+      //};
+      //var tuu = MutatorParameter.ValidValues;
+      //var select = SelectorParameter.ValidValues;
 
       while (EvaluatedSolutions < maximumEvaluatedSolutions && !cancellationToken.IsCancellationRequested) {
@@ -113 +121 @@
 
         for (int i = 0; i < selector.NumberOfSelectedSubScopesParameter.Value.Value; i += 2) {
-          // crossover
           IScope childScope = null;
+          // for future
+          //var obbbb = CrossoverParameter.ValidValues.ToList();
+          //int nn = 3;
+          //if (rand.NextDouble() < crossoverProbability) {
+          //  childScope = new Scope($"{i}+{i + 1}") { Parent = executionContext.Scope };
+          //  childScope.SubScopes.Add(selected.SubScopes[i]);
+          //  childScope.SubScopes.Add(selected.SubScopes[i + 1]);
+          //  var op1 = executionContext.CreateChildOperation(obbbb[nn], childScope);
+          //  ExecuteOperation(executionContext, innerToken, op1);
+          //  childScope.SubScopes.Clear();
+          //}
+
           if (rand.NextDouble() < crossoverProbability) {
             childScope = new Scope($"{i}+{i + 1}") { Parent = executionContext.Scope };
@@ -133 +152 @@
           // evaluation
           if (childScope != null) {
-            var op3 = executionContext.CreateChildOperation(evaluator, childScope);
-            ExecuteOperation(executionContext, innerToken, op3);
-            //if (Problem.ProblemData is IRegressionProblemData problemData) {
-            //  SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(Problem.SymbolicExpressionTreeInterpreter, (ISymbolicExpressionTree)childScope.Variables["SymbolicExpressionTree"].Value, problemData, problemData.TestIndices, true, 100 /*max iterration*/, true);
-            //}
-            ++EvaluatedSolutions;
-            Population.Add(new EMMSolution(childScope));
+            if (!childScope.Variables.ContainsKey("Quality"))
+              childScope.Variables.Add(new Variable("Quality"));
+            EvaluationComplex(executionContext, innerToken, childScope);
           } else {// no crossover or mutation were applied, a child was not produced, do nothing
             Population.Add(new EMMSolution(selected.SubScopes[i]));
@@ -146 +161 @@
             break;
           }
-
-        }
-        if (Map is EMMSucsessMap) {
-          var population = new Dictionary<ISymbolicExpressionTree, double>();
-          foreach (var individ in Population) {
-            var tree = (ISymbolicExpressionTree)(((IScope)individ.Individual).Variables["SymbolicExpressionTree"].Value);
-            population.Add(tree, individ.Qualities.Value);
-          }
-          Map.MapUpDate(population);
-          population.Clear();
-        }
-        //List<object> A = new List<object>();
-        //A.Add(new Scope ());
-        //A.Add(new SymbolicExpressionTree());
+        }
+
+        UpDateParameters();
 
         globalScope.SubScopes.Replace(Population.Select(x => (IScope)x.Individual));
@@ -165 +169 @@
         var analyze = executionContext.CreateChildOperation(analyzer, globalScope);
         ExecuteOperation(executionContext, innerToken, analyze);
+
         Results.AddOrUpdateResult("Evaluated Solutions", new IntValue(EvaluatedSolutions));
       }
     }
+    protected virtual void UpDateParameters() {
+      if (Map is EMMSucsessMap) {
+        var population = new Dictionary<ISymbolicExpressionTree, double>();
+        foreach (var individ in Population) {
+          var tree = (ISymbolicExpressionTree)(((IScope)individ.Individual).Variables["SymbolicExpressionTree"].Value);
+          population.Add(tree, individ.Qualities.Value);
+        }
+        Map.MapUpDate(population);
+        population.Clear();
+      }
+    }
+    #endregion
+    #region Initialization
     protected void InitializeAlgorithm(CancellationToken cancellationToken) {
       globalScope = new Scope("Global Scope");
@@ -181 +199 @@
       if (SetSeedRandomly) Seed = RandomSeedGenerator.GetSeed();
       rand.Reset(Seed);
-
+      EvaluatedSolutions = 0;
+      //  InitializeParametrs(); for future
       InitializePopulation(executionContext, cancellationToken, rand);
-      EvaluatedSolutions = PopulationSize.Value;
+
 
       base.Initialize(cancellationToken);
     }
+    protected virtual void InitializeParametrs() { }
 
     private void InitializePopulation(ExecutionContext executionContext, CancellationToken cancellationToken, IRandom random) {
       Population = new List<IEMMSolution>();
+      var fmd = new InfixExpressionFormatter();
       var evaluator = Problem.Evaluator;
       var creator = Problem.SolutionCreator;
+      var parser = new InfixExpressionParser();
+
       var parentScope = executionContext.Scope; //main scope for the next step work
                                                 // first, create all individuals
@@ -199 +222 @@
         var name = ((ISymbolicExpressionTreeCreator)creator).SymbolicExpressionTreeParameter.ActualName;
         var tree = (ISymbolicExpressionTree)childScope.Variables[name].Value;
+
         foreach (var node in tree.IterateNodesPostfix().OfType<TreeModelTreeNode>()) {
           Map.NodeManipulationForInizializtion(random, node);
@@ -207 +231 @@
       for (int i = 0; i < PopulationSize.Value; ++i) {
         var childScope = parentScope.SubScopes[i];
-        ExecuteOperation(executionContext, cancellationToken, executionContext.CreateChildOperation(evaluator, childScope));
-        Population.Add(new EMMSolution(childScope));  // Create solution and push individual inside. push solution to Population 
-      }
-    }
-
+        if (!childScope.Variables.ContainsKey("Quality"))
+          childScope.Variables.Add(new Variable("Quality", new DoubleValue(0)));
+        EvaluationComplex(executionContext, cancellationToken, childScope);
+      }
+    }
+    #endregion
+    #region Evaluators
+    private void EvaluationComplex(ExecutionContext executionContext, CancellationToken cancellationToken, IScope childScope) {
+      var evaluator = Problem.Evaluator;
+      if (evaluator is SymbolicRegressionConstantOptimizationEvaluator eval) {
+        var creator = Problem.SolutionCreator;
+        var name = ((ISymbolicExpressionTreeCreator)creator).SymbolicExpressionTreeParameter.ActualName;
+        var tree = (ISymbolicExpressionTree)childScope.Variables[name].Value;
+        var treeWithModelInside = ModelToTreePusher(tree);
+
+        //ExecuteOperation(executionContext, cancellationToken, executionContext.CreateChildOperation(evaluator, treeScope));
+        var pd = (IRegressionProblemData)Problem.ProblemData;
+        var estimationLimits = ((SymbolicRegressionSingleObjectiveProblem)Problem).EstimationLimits;
+        var interpreter = new SymbolicDataAnalysisExpressionTreeBatchInterpreter();
+        var quality = SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, treeWithModelInside, pd, pd.TrainingIndices, applyLinearScaling: true, maxIterations: 10, updateVariableWeights: true, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper, updateConstantsInTree: true);
+        childScope.Variables["Quality"].Value = new DoubleValue(quality);
+
+        int index = 0;
+        ConstuntValuesInTreeUpdate(tree, ConstantValuesFromTreeToListExtruction(treeWithModelInside), ref index);
+        childScope.Variables[name].Value = tree;
+        EvaluatedSolutions += 10;
+      } else {
+        var op3 = executionContext.CreateChildOperation(evaluator, childScope);
+        ExecuteOperation(executionContext, cancellationToken, op3);
+        EvaluatedSolutions += 1;
+      }
+      Population.Add(new EMMSolution(childScope));
+    }
+    private ISymbolicExpressionTree ModelToTreePusher(ISymbolicExpressionTree tree) {
+      //All model nodes in tree are exchange to trees that are stored in model nodes.
+      // After this function we have deal with usual tree
+      var clone = (ISymbolicExpressionTree)tree.Clone();
+      foreach (var node in clone.IterateNodesPostfix().OfType<TreeModelTreeNode>()) {
+        var newChild = node.Tree.Root.GetSubtree(0).GetSubtree(0);
+        Swap(node, newChild);
+      }
+      return clone;
+    }
+    protected static void Swap(ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild) {
+      var parent = oldChild.Parent;
+      if (parent == null)
+        return;
+
+      var index = parent.IndexOfSubtree(oldChild);
+      parent.RemoveSubtree(index);
+      parent.InsertSubtree(index, newChild);
+    }
+    private List<double> ConstantValuesFromTreeToListExtruction(ISymbolicExpressionTree tree) {
+      //This function stored in a list all constants and coefficients from the tree
+      var constants = new List<double>();
+      foreach (var node in tree.IterateNodesPostfix()) {
+        if (node is ConstantTreeNode cNode) {
+          constants.Add(cNode.Value);
+        }
+        if (node is VariableTreeNode vNode) {
+          constants.Add(vNode.Weight);
+        }
+      }
+      return constants;
+    }
+    private void ConstuntValuesInTreeUpdate(ISymbolicExpressionTree tree, List<double> constants, ref int index) {
+      foreach (var node in tree.IterateNodesPostfix()) {
+        if (node is ConstantTreeNode cNode) {
+          cNode.Value = constants[index];
+          index++;
+        } else if (node is VariableTreeNode vNode) {
+          vNode.Weight = constants[index];
+          index++;
+        } else if (node is TreeModelTreeNode mNode) {
+          ConstuntValuesInTreeUpdate(mNode.Tree, constants, ref index);
+        }
+
+      }
+    }
+    #endregion
+    #region Local Search
     // next function was not tested in real work
     private void LocalDecent(ISymbolicDataAnalysisSingleObjectiveProblem problem, CancellationToken cancellationToken, IScope childScope) {
@@ -257 +357 @@
       }
     }
+    #endregion
   }