Free cookie consent management tool by TermsFeed Policy Generator

Changeset 17134


Ignore:
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
Files:
8 added
5 edited
15 moved

Legend:

Unmodified
Added
Removed

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Analyzers/ModelClustersFrequencyAnalyzer.cs

    r17133 r17134  
    3737  /// Calculates the accumulated frequencies of variable-symbols over all trees in the population.
    3838  /// </summary>
    39   [Item("SymbolicDataAnalysisModelClustersFrequencyAnalyzer", "Calculates the accumulated frequencies of Model Clusters over all trees in the population.")]
     39  [Item("Symbolic Data Analysis Model Clusters Frequency Analyzer", "Calculates the accumulated frequencies of Model Clusters over all trees in the population.")]
    4040  [StorableType("4755115D-1B73-4577-BA2A-A762AE4C3B2F")]
    4141  public sealed class ModelClustersFrequencyAnalyzer : SymbolicDataAnalysisAnalyzer {
    … …  
    156156          for (int i = 0; i < map.ModelSet.Count; i++) {
    157157            string referenceId = "Tree Probability" + i;
    158             references[referenceId] = sMap.Probabilities[i];
     158            references[referenceId] = sMap.SelfConfigurationMechanism.Probabilities[i];
    159159          }
    160160        } else {

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

    r17133 r17134  
    2525using HeuristicLab.Data;
    2626using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Problems.DataAnalysis;
    2728using HeuristicLab.Problems.DataAnalysis.Symbolic;
     29using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
    2830using HeuristicLab.Random;
    2931using HeuristicLab.Selection;
    … …  
    3436
    3537namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    36   [Item("Evolvment Models Of Models Algorithm (EMM) ", "EMM implementation")]
     38  [Item("Evolvement Models Of Models Algorithm (EMM) ", "EMM implementation")]
    3739  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 125)]
    3840  [StorableType("AD23B21F-089A-4C6C-AD2E-1B01E7939CF5")]
    3941  public class EMMAlgorithm : EvolvmentModelsOfModelsAlgorithmBase {
     42    #region Constructors
    4043    public EMMAlgorithm() : base() { }
    4144    protected EMMAlgorithm(EMMAlgorithm original, Cloner cloner) : base(original, cloner) { }
    … …  
    4649    [StorableConstructor]
    4750    protected EMMAlgorithm(StorableConstructorFlag _) : base(_) { }
    48 
     51    #endregion
     52    #region Algorithm run
    4953    protected override void Run(CancellationToken cancellationToken) {
     54
     55      Map.DistanceParametr = DistanceType.Value;
     56
    5057      if (AlgorithmImplemetationType.Value == "Read") {
    51         Map.MapRead(RandomParameter.Value, trees, "Map.txt");
     58        Map.MapRead(trees);
    5259      } else {
    5360        Map.MapCreationPrepare(trees);
    54         Map.CreateMap(RandomParameter.Value, ClusterNumbersParameter.Value.Value);
    55         // Map.WriteMapToTxtFile(RandomParameter.Value); хайв этого не любит.. ворчит
    56       }
    57       ClusterNumbersShowParameter.Value.Value = Map.Map.Count;
    58 
    59       if (AlgorithmImplemetationType.Value == "OnlyMap") {
    60         globalScope = new Scope("Global Scope");
    61         executionContext = new ExecutionContext(null, this, globalScope);
    62       } else {
    63         if (previousExecutionState != ExecutionState.Paused) {
    64           InitializeAlgorithm(cancellationToken);
    65         }
    66         if (!globalScope.Variables.ContainsKey("TreeModelMap"))
    67           globalScope.Variables.Add(new Variable("TreeModelMap", Map));
    68         if (!globalScope.Variables.ContainsKey("Map"))
    69           globalScope.Variables.Add(new Variable("Map", Map));
    70         EMMAlgorithmRun(cancellationToken);
    71       }
     61        Map.CreateMap(RandomParameter.Value, Problem);
     62      }
     63      if (previousExecutionState != ExecutionState.Paused) {
     64        InitializeAlgorithm(cancellationToken);
     65      }
     66      if (!globalScope.Variables.ContainsKey("TreeModelMap"))
     67        globalScope.Variables.Add(new Variable("TreeModelMap", Map));
     68      if (!globalScope.Variables.ContainsKey("Map"))
     69        globalScope.Variables.Add(new Variable("Map", Map));
     70      EMMAlgorithmRun(cancellationToken);
    7271    }
    7372    private void EMMAlgorithmRun(CancellationToken cancellationToken) {
    … …  
    8887      var rand = RandomParameter.Value;
    8988      var elites = Elites.Value;
    90 
    91       // cancellation token for the inner operations which should not be immediately cancelled
     89      var fmd = new InfixExpressionFormatter();
     90      // cancellation token for the inner operations which should not be immediately canceled
    9291      var innerToken = new CancellationToken();
     92      // for future
     93      //var mutatorTypes = new SymbolicExpressionTreeManipulator[]
     94      //{
     95      //     new EMMMultyPointsMutator(),
     96      //     new EMMMultyPointsMutatorNodeTypeSaving (),
     97      //     new EMMMutators()
     98      //};
     99      //var tuu = MutatorParameter.ValidValues;
     100      //var select = SelectorParameter.ValidValues;
    93101
    94102      while (EvaluatedSolutions < maximumEvaluatedSolutions && !cancellationToken.IsCancellationRequested) {
    … …  
    113121
    114122        for (int i = 0; i < selector.NumberOfSelectedSubScopesParameter.Value.Value; i += 2) {
    115           // crossover
    116123          IScope childScope = null;
     124          // for future
     125          //var obbbb = CrossoverParameter.ValidValues.ToList();
     126          //int nn = 3;
     127          //if (rand.NextDouble() < crossoverProbability) {
     128          //  childScope = new Scope($"{i}+{i + 1}") { Parent = executionContext.Scope };
     129          //  childScope.SubScopes.Add(selected.SubScopes[i]);
     130          //  childScope.SubScopes.Add(selected.SubScopes[i + 1]);
     131          //  var op1 = executionContext.CreateChildOperation(obbbb[nn], childScope);
     132          //  ExecuteOperation(executionContext, innerToken, op1);
     133          //  childScope.SubScopes.Clear();
     134          //}
     135
    117136          if (rand.NextDouble() < crossoverProbability) {
    118137            childScope = new Scope($"{i}+{i + 1}") { Parent = executionContext.Scope };
    … …  
    133152          // evaluation
    134153          if (childScope != null) {
    135             var op3 = executionContext.CreateChildOperation(evaluator, childScope);
    136             ExecuteOperation(executionContext, innerToken, op3);
    137             //if (Problem.ProblemData is IRegressionProblemData problemData) {
    138             //  SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(Problem.SymbolicExpressionTreeInterpreter, (ISymbolicExpressionTree)childScope.Variables["SymbolicExpressionTree"].Value, problemData, problemData.TestIndices, true, 100 /*max iterration*/, true);
    139             //}
    140             ++EvaluatedSolutions;
    141             Population.Add(new EMMSolution(childScope));
     154            if (!childScope.Variables.ContainsKey("Quality"))
     155              childScope.Variables.Add(new Variable("Quality"));
     156            EvaluationComplex(executionContext, innerToken, childScope);
    142157          } else {// no crossover or mutation were applied, a child was not produced, do nothing
    143158            Population.Add(new EMMSolution(selected.SubScopes[i]));
    … …  
    146161            break;
    147162          }
    148 
    149         }
    150         if (Map is EMMSucsessMap) {
    151           var population = new Dictionary<ISymbolicExpressionTree, double>();
    152           foreach (var individ in Population) {
    153             var tree = (ISymbolicExpressionTree)(((IScope)individ.Individual).Variables["SymbolicExpressionTree"].Value);
    154             population.Add(tree, individ.Qualities.Value);
    155           }
    156           Map.MapUpDate(population);
    157           population.Clear();
    158         }
    159         //List<object> A = new List<object>();
    160         //A.Add(new Scope ());
    161         //A.Add(new SymbolicExpressionTree());
     163        }
     164
     165        UpDateParameters();
    162166
    163167        globalScope.SubScopes.Replace(Population.Select(x => (IScope)x.Individual));
    … …  
    165169        var analyze = executionContext.CreateChildOperation(analyzer, globalScope);
    166170        ExecuteOperation(executionContext, innerToken, analyze);
     171
    167172        Results.AddOrUpdateResult("Evaluated Solutions", new IntValue(EvaluatedSolutions));
    168173      }
    169174    }
     175    protected virtual void UpDateParameters() {
     176      if (Map is EMMSucsessMap) {
     177        var population = new Dictionary<ISymbolicExpressionTree, double>();
     178        foreach (var individ in Population) {
     179          var tree = (ISymbolicExpressionTree)(((IScope)individ.Individual).Variables["SymbolicExpressionTree"].Value);
     180          population.Add(tree, individ.Qualities.Value);
     181        }
     182        Map.MapUpDate(population);
     183        population.Clear();
     184      }
     185    }
     186    #endregion
     187    #region Initialization
    170188    protected void InitializeAlgorithm(CancellationToken cancellationToken) {
    171189      globalScope = new Scope("Global Scope");
    … …  
    181199      if (SetSeedRandomly) Seed = RandomSeedGenerator.GetSeed();
    182200      rand.Reset(Seed);
    183 
     201      EvaluatedSolutions = 0;
     202      //  InitializeParametrs(); for future
    184203      InitializePopulation(executionContext, cancellationToken, rand);
    185       EvaluatedSolutions = PopulationSize.Value;
     204
    186205
    187206      base.Initialize(cancellationToken);
    188207    }
     208    protected virtual void InitializeParametrs() { }
    189209
    190210    private void InitializePopulation(ExecutionContext executionContext, CancellationToken cancellationToken, IRandom random) {
    191211      Population = new List<IEMMSolution>();
     212      var fmd = new InfixExpressionFormatter();
    192213      var evaluator = Problem.Evaluator;
    193214      var creator = Problem.SolutionCreator;
     215      var parser = new InfixExpressionParser();
     216
    194217      var parentScope = executionContext.Scope; //main scope for the next step work
    195218                                                // first, create all individuals
    … …  
    199222        var name = ((ISymbolicExpressionTreeCreator)creator).SymbolicExpressionTreeParameter.ActualName;
    200223        var tree = (ISymbolicExpressionTree)childScope.Variables[name].Value;
     224
    201225        foreach (var node in tree.IterateNodesPostfix().OfType<TreeModelTreeNode>()) {
    202226          Map.NodeManipulationForInizializtion(random, node);
    … …  
    207231      for (int i = 0; i < PopulationSize.Value; ++i) {
    208232        var childScope = parentScope.SubScopes[i];
    209         ExecuteOperation(executionContext, cancellationToken, executionContext.CreateChildOperation(evaluator, childScope));
    210         Population.Add(new EMMSolution(childScope));  // Create solution and push individual inside. push solution to Population
    211       }
    212     }
    213 
     233        if (!childScope.Variables.ContainsKey("Quality"))
     234          childScope.Variables.Add(new Variable("Quality", new DoubleValue(0)));
     235        EvaluationComplex(executionContext, cancellationToken, childScope);
     236      }
     237    }
     238    #endregion
     239    #region Evaluators
     240    private void EvaluationComplex(ExecutionContext executionContext, CancellationToken cancellationToken, IScope childScope) {
     241      var evaluator = Problem.Evaluator;
     242      if (evaluator is SymbolicRegressionConstantOptimizationEvaluator eval) {
     243        var creator = Problem.SolutionCreator;
     244        var name = ((ISymbolicExpressionTreeCreator)creator).SymbolicExpressionTreeParameter.ActualName;
     245        var tree = (ISymbolicExpressionTree)childScope.Variables[name].Value;
     246        var treeWithModelInside = ModelToTreePusher(tree);
     247
     248        //ExecuteOperation(executionContext, cancellationToken, executionContext.CreateChildOperation(evaluator, treeScope));
     249        var pd = (IRegressionProblemData)Problem.ProblemData;
     250        var estimationLimits = ((SymbolicRegressionSingleObjectiveProblem)Problem).EstimationLimits;
     251        var interpreter = new SymbolicDataAnalysisExpressionTreeBatchInterpreter();
     252        var quality = SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, treeWithModelInside, pd, pd.TrainingIndices, applyLinearScaling: true, maxIterations: 10, updateVariableWeights: true, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper, updateConstantsInTree: true);
     253        childScope.Variables["Quality"].Value = new DoubleValue(quality);
     254
     255        int index = 0;
     256        ConstuntValuesInTreeUpdate(tree, ConstantValuesFromTreeToListExtruction(treeWithModelInside), ref index);
     257        childScope.Variables[name].Value = tree;
     258        EvaluatedSolutions += 10;
     259      } else {
     260        var op3 = executionContext.CreateChildOperation(evaluator, childScope);
     261        ExecuteOperation(executionContext, cancellationToken, op3);
     262        EvaluatedSolutions += 1;
     263      }
     264      Population.Add(new EMMSolution(childScope));
     265    }
     266    private ISymbolicExpressionTree ModelToTreePusher(ISymbolicExpressionTree tree) {
     267      //All model nodes in tree are exchange to trees that are stored in model nodes.
     268      // After this function we have deal with usual tree
     269      var clone = (ISymbolicExpressionTree)tree.Clone();
     270      foreach (var node in clone.IterateNodesPostfix().OfType<TreeModelTreeNode>()) {
     271        var newChild = node.Tree.Root.GetSubtree(0).GetSubtree(0);
     272        Swap(node, newChild);
     273      }
     274      return clone;
     275    }
     276    protected static void Swap(ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild) {
     277      var parent = oldChild.Parent;
     278      if (parent == null)
     279        return;
     280
     281      var index = parent.IndexOfSubtree(oldChild);
     282      parent.RemoveSubtree(index);
     283      parent.InsertSubtree(index, newChild);
     284    }
     285    private List<double> ConstantValuesFromTreeToListExtruction(ISymbolicExpressionTree tree) {
     286      //This function stored in a list all constants and coefficients from the tree
     287      var constants = new List<double>();
     288      foreach (var node in tree.IterateNodesPostfix()) {
     289        if (node is ConstantTreeNode cNode) {
     290          constants.Add(cNode.Value);
     291        }
     292        if (node is VariableTreeNode vNode) {
     293          constants.Add(vNode.Weight);
     294        }
     295      }
     296      return constants;
     297    }
     298    private void ConstuntValuesInTreeUpdate(ISymbolicExpressionTree tree, List<double> constants, ref int index) {
     299      foreach (var node in tree.IterateNodesPostfix()) {
     300        if (node is ConstantTreeNode cNode) {
     301          cNode.Value = constants[index];
     302          index++;
     303        } else if (node is VariableTreeNode vNode) {
     304          vNode.Weight = constants[index];
     305          index++;
     306        } else if (node is TreeModelTreeNode mNode) {
     307          ConstuntValuesInTreeUpdate(mNode.Tree, constants, ref index);
     308        }
     309
     310      }
     311    }
     312    #endregion
     313    #region Local Search
    214314    // next function was not tested in real work
    215315    private void LocalDecent(ISymbolicDataAnalysisSingleObjectiveProblem problem, CancellationToken cancellationToken, IScope childScope) {
    … …  
    257357      }
    258358    }
     359    #endregion
    259360  }
    260361

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

    r17133 r17134  
    4141
    4242namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    43   [Item("MOEADAlgorithmBase", "Base class for all MOEA/D algorithm variants.")]
     43  [Item("EMMAlgorithmBase", "Base class for all EMM algorithm variants.")]
    4444  [StorableType("A56A396B-965A-4ADE-8A2B-AE3A45F9C239")]
    4545  public abstract class EvolvmentModelsOfModelsAlgorithmBase : FixedDataAnalysisAlgorithm<ISymbolicDataAnalysisSingleObjectiveProblem> {
    … …  
    7878    private const string AnalyzerParameterName = "Analyzer";
    7979    private const string InputFileParameterName = "InputFile";
    80     private const string ClusterNumbersParameterName = "ClusterNumbers";
    81     private const string ClusterNumbersShowParameterName = "ClusterNumbersShow";
    8280    private const string AlgorithmImplementationTypeParameterName = "AlgorithmImplementationType";
     81    private const string DistanceTypeParameterName = "DistanceType";
    8382    private const string MapParameterName = "Map";
    84     private const string NegbourTypeParameterName = "NegbourType";
    85     private const string NegbourNumberParameterName = "NegbourNumber";
    8683    public IValueParameter<MultiAnalyzer> AnalyzerParameter {
    8784      get { return (ValueParameter<MultiAnalyzer>)Parameters[AnalyzerParameterName]; }
    … …  
    9087      get { return (IFixedValueParameter<IntValue>)Parameters[SeedParameterName]; }
    9188    }
    92     public IValueParameter<IntValue> ClusterNumbersParameter {
    93       get { return (IValueParameter<IntValue>)Parameters[ClusterNumbersParameterName]; }
    94     }
    95     public IValueParameter<IntValue> ClusterNumbersShowParameter {
    96       get { return (IValueParameter<IntValue>)Parameters[ClusterNumbersShowParameterName]; }
    97     }
    9889    public IConstrainedValueParameter<StringValue> AlgorithmImplementationTypeParameter {
    9990      get { return (IConstrainedValueParameter<StringValue>)Parameters[AlgorithmImplementationTypeParameterName]; }
    10091    }
     92    public IConstrainedValueParameter<StringValue> DistanceTypeParameter {
     93      get { return (IConstrainedValueParameter<StringValue>)Parameters[DistanceTypeParameterName]; }
     94    }
    10195    public IConstrainedValueParameter<EMMMapBase<ISymbolicExpressionTree>> MapParameter {
    10296      get { return (IConstrainedValueParameter<EMMMapBase<ISymbolicExpressionTree>>)Parameters[MapParameterName]; }
    10397    }
    104     public IFixedValueParameter<StringValue> NegbourTypeParameter {
    105       get { return (IFixedValueParameter<StringValue>)Parameters[NegbourTypeParameterName]; }
    106     }
    107     public IFixedValueParameter<IntValue> NegbourNumberParameter {
    108       get { return (IFixedValueParameter<IntValue>)Parameters[NegbourNumberParameterName]; }
    109     }
     98
    11099    public IFixedValueParameter<StringValue> InputFileParameter {
    111100      get { return (IFixedValueParameter<StringValue>)Parameters[InputFileParameterName]; }
    … …  
    151140      set { SeedParameter.Value.Value = value; }
    152141    }
    153     public IntValue ClusterNumbers {
    154       get { return ClusterNumbersParameter.Value; }
    155       set { ClusterNumbersParameter.Value = value; }
    156     }
    157     public IntValue ClusterNumbersShow {
    158       get { return ClusterNumbersShowParameter.Value; }
    159       set { ClusterNumbersShowParameter.Value = value; }
    160     }
    161142    public StringValue AlgorithmImplemetationType {
    162143      get { return AlgorithmImplementationTypeParameter.Value; }
    163144      set { AlgorithmImplementationTypeParameter.Value.Value = value.Value; }
    164145    }
     146    public StringValue DistanceType {
     147      get { return DistanceTypeParameter.Value; }
     148      set { DistanceTypeParameter.Value.Value = value.Value; }
     149    }
    165150    public EMMMapBase<ISymbolicExpressionTree> Map {
    166151      get { return MapParameter.Value; }
    167152      set { MapParameter.Value = value; }
    168153    }
    169     public StringValue NegbourType {
    170       get { return NegbourTypeParameter.Value; }
    171       set { NegbourTypeParameter.Value.Value = value.Value; }
    172     }
    173     public IntValue NegbourNumber {
    174       get { return NegbourNumberParameter.Value; }
    175       set { NegbourNumberParameter.Value.Value = value.Value; }
    176     }
    177154    public StringValue InputFile {
    178155      get { return InputFileParameter.Value; }
    … …  
    229206      Parameters.Add(new FixedValueParameter<IntValue>(SeedParameterName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
    230207      Parameters.Add(new FixedValueParameter<StringValue>(InputFileParameterName, "The file with set of models that will be.", new StringValue("input.txt")));
    231       Parameters.Add(new ConstrainedValueParameter<StringValue>(AlgorithmImplementationTypeParameterName, "The Type of possible algorith, implemetation, choose one: OnlyMap, Full, Read."));
    232       Parameters.Add(new ConstrainedValueParameter<EMMMapBase<ISymbolicExpressionTree>>(MapParameterName, "The type of map crearion algorithm. Use one from: IslandMap, NetworkMap."));
    233       Parameters.Add(new FixedValueParameter<IntValue>(NegbourNumberParameterName, "The parametr for FullMap type of map crearion algorithm. Use one from: 10, 20.", new IntValue(10)));
    234       Parameters.Add(new FixedValueParameter<StringValue>(NegbourTypeParameterName, "The parametr for FullMap type of map crearion algorithm. Use one from: Percent, Number.", new StringValue("Number")));
     208      Parameters.Add(new ConstrainedValueParameter<StringValue>(AlgorithmImplementationTypeParameterName, "The Type of possible algorithm, implementation, choose one: OnlyMap, Full, Read."));
     209      Parameters.Add(new ConstrainedValueParameter<StringValue>(DistanceTypeParameterName, "The Type of possible distance calculator for case of only distance calculation."));
     210      Parameters.Add(new ConstrainedValueParameter<EMMMapBase<ISymbolicExpressionTree>>(MapParameterName, "The type of map creation algorithm. Use one from: IslandMap, NetworkMap."));
    235211      Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyParameterName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
    236212      Parameters.Add(new ValueParameter<IntValue>(PopulationSizeParameterName, "The size of the population of Solutions.", new IntValue(100)));
    237       Parameters.Add(new ConstrainedValueParameter<ISelector>(SelectorParameterName, "The operator used to sellect parents."));
     213      Parameters.Add(new ConstrainedValueParameter<ISelector>(SelectorParameterName, "The operator used to select parents."));
    238214      Parameters.Add(new ValueParameter<PercentValue>(CrossoverProbabilityParameterName, "The probability that the crossover operator is applied.", new PercentValue(0.9)));
    239215      Parameters.Add(new ValueParameter<IntValue>(GroupSizeParameterName, "The GoupSize that the Selector operator is applied.", new IntValue(3)));
    … …  
    244220      Parameters.Add(new ValueParameter<IntValue>(MaximumEvaluatedSolutionsParameterName, "The maximum number of evaluated Solutions (approximately).", new IntValue(100_000)));
    245221      Parameters.Add(new ValueParameter<IRandom>(RandomParameterName, new MersenneTwister()));
    246       Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite Solutions which are kept in each generation.", new IntValue(1)));
    247       Parameters.Add(new ValueParameter<IntValue>(ClusterNumbersParameterName, "The number of clusters for model Map.", new IntValue(10)));
    248       Parameters.Add(new ValueParameter<IntValue>(ClusterNumbersShowParameterName, "The number of clusters for model Map.", new IntValue(10)));
     222      Parameters.Add(new ValueParameter<IntValue>("Elites", "The number of elite Solutions which are kept in each generation.", new IntValue(1)));
    249223      foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
    250224        SelectorParameter.ValidValues.Add(selector);
    … …  
    274248      if (Problem != null) {
    275249        Problem.SymbolicExpressionTreeInterpreter = new SymbolicDataAnalysisExpressionTreeBatchInterpreter();
    276         //Problem.SymbolicExpressionTreeGrammar = new EMMGrammar();
    277250      }
    278251    }
    279252    protected void MapParameterUpdate() {
    280       int neghboorNumber = 10;
    281 
    282       switch (NegbourType.Value) {
    283         case "Percent": neghboorNumber = Convert.ToInt32((Convert.ToDouble(ClusterNumbersParameter.Value.Value)) * (Convert.ToDouble(NegbourNumber.Value)) / 100.0); break;
    284         case "Number": neghboorNumber = NegbourNumber.Value; break;
    285         default: neghboorNumber = NegbourNumber.Value; break;
    286       }
    287253      var mapTypes = new EMMMapBase<ISymbolicExpressionTree>[]
    288254      {
    289255        new EMMIslandMap(),
    290         new EMMNetworkMap(neghboorNumber),
     256        new EMMNetworkMap(),
    291257        new EMMDisatanceMap(),
    292258        new EMMRankMap(),
    … …  
    301267          new StringValue("Full"),
    302268          new StringValue("Read"),
    303           new StringValue ("OnlyMap")
    304269        };
    305270      foreach (var t in algorithmType) {
    306271        AlgorithmImplementationTypeParameter.ValidValues.Add(t);
    307272      }
     273      var distanceType = new StringValue[]
     274        {
     275          new StringValue("MSE"),
     276          new StringValue("PearsonsRSquared"),
     277          new StringValue ("Covariance"),
     278          new StringValue ("MaxAbsoluteError"),
     279          new StringValue ("MeanAbsoluteError"),
     280          new StringValue ("Symbolic")
     281        };
     282      foreach (var t in distanceType) {
     283        DistanceTypeParameter.ValidValues.Add(t);
     284      }
    308285    }
    309286
    … …  
    320297      }
    321298
    322       //if (original.offspringPopulation != null) {
    323       //  offspringPopulation = original.offspringPopulation.Select(cloner.Clone).ToList();
    324       //}
    325 
    326       //if (original.jointPopulation != null) {
    327       //  jointPopulation = original.jointPopulation.Select(x => cloner.Clone(x)).ToList();
    328       //}
    329 
    330299      if (original.executionContext != null) {
    331300        executionContext = cloner.Clone(original.executionContext);
    … …  
    335304        globalScope = cloner.Clone(original.globalScope);
    336305      }
    337 
    338       // hack
    339       trees = original.trees.Select(x => cloner.Clone(x)).ToArray();
     306      // hack
     307      if (original.trees != null) {
     308        trees = original.trees.Select(x => cloner.Clone(x)).ToArray();
     309      }
    340310    }
    341311

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

    r17133 r17134  
    2424using HeuristicLab.Core;
    2525using DoubleValue = HeuristicLab.Data.DoubleValue;
    26 // Can be deleted potnetinaly
     26// Can be deleted potentially
    2727namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    2828  [StorableType("AB38211D-5F52-4420-A606-1C3CB58BA27C")]

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMOperators/EMMMultyPointsMutator.cs

    r17133 r17134  
    7171
    7272      List<ISymbol> allowedSymbols = new List<ISymbol>();
    73       var probability = (1 / mutationProbability.Value) / (symbolicExpressionTree.Length); // probability for edch node to mutate
     73      var probability = (1 / mutationProbability.Value) / (symbolicExpressionTree.Length); // probability for each node to mutate
    7474      var allAllowedSymbols = symbolicExpressionTree.Root.Grammar.AllowedSymbols.Where(s =>
    7575        !(s is Defun) &&
    … …  
    8181      symbolicExpressionTree.Root.ForEachNodePostfix(node => {//for each node in tree - try to mutate
    8282
    83         if (SymbolTypeCheck(node.Symbol, allAllowedSymbols)) { // we do not want to toch StartSymbol
     83        if (SymbolTypeCheck(node.Symbol, allAllowedSymbols)) { // we do not want to touch StartSymbol
    8484          if (random.NextDouble() < probability) { // ok. this node decide to mutate
    8585
    … …  
    8787              if ((symbol.MaximumArity == node.Symbol.MaximumArity) && (symbol.MinimumArity == node.Symbol.MinimumArity)) { allowedSymbols.Add(symbol); }
    8888            }
    89             if (node.Symbol.MaximumArity == 0) { // for terminal nodes add aditional the same type of nodes
     89            if (node.Symbol.MaximumArity == 0) { // for terminal nodes add additional the same type of nodes
    9090              allowedSymbols.Add(node.Symbol);
    9191            }
    9292            int pTemp = random.Next(map.Count);
    93             if (node is TreeModelTreeNode treeNode) { pTemp = treeNode.TreeNumber; } //remeber the cluster number
     93            if (node is TreeModelTreeNode treeNode) { pTemp = treeNode.TreeNumber; } //remember the cluster number
    9494            var weights = allowedSymbols.Select(s => s.InitialFrequency).ToList(); // set up probabilities
    9595
    9696#pragma warning disable CS0618 // Type or member is obsolete
    97             var newSymbol = allowedSymbols.SelectRandom(weights, random); // create new node from the choosen symbol type. Ror terminal nodes it means that we have only one possible varint.
     97            var newSymbol = allowedSymbols.SelectRandom(weights, random); // create new node from the chosen symbol type. For terminal nodes it means that we have only one possible variant.
    9898#pragma warning restore CS0618 // Type or member is obsolete
    9999            node = newSymbol.CreateTreeNode();
    100100
    101             if (node is TreeModelTreeNode treeNode2) { // make rigth mutation for tree model
     101            if (node is TreeModelTreeNode treeNode2) { // make right mutation for tree model
    102102              treeNode2.TreeNumber = pTemp;
    103103              MapParameter.ActualValue.NodeForMutationChange(random, treeNode2);
    104             } else if (node.HasLocalParameters) { // make local parametrs set up for other node types
     104            } else if (node.HasLocalParameters) { // make local parameters set up for other node types
    105105              node.ResetLocalParameters(random);
    106106            }

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMOperators/EMMMultyPointsMutatorNodeTypeSaving.cs

    r17133 r17134  
    7474
    7575      List<ISymbol> allowedSymbols = new List<ISymbol>();
    76       var probability = (1 / mutationProbability.Value) / (symbolicExpressionTree.Length); // probability for edch node to mutate
     76      var probability = (1 / mutationProbability.Value) / (symbolicExpressionTree.Length); // probability for each node to mutate
    7777      var allAllowedSymbols = symbolicExpressionTree.Root.Grammar.AllowedSymbols.Where(s =>
    7878        !(s is Defun) &&
    … …  
    8484      symbolicExpressionTree.Root.ForEachNodePostfix(node => {//for each node in tree - try to mutate
    8585
    86         if (SymbolTypeCheck(node.Symbol, allAllowedSymbols)) { // we do not want to toch StartSymbol
     86        if (SymbolTypeCheck(node.Symbol, allAllowedSymbols)) { // we do not want to touch StartSymbol
    8787          if (random.NextDouble() < probability) { // ok. this node decide to mutate
    8888            if (node.Symbol.MaximumArity > 0) {
    … …  
    9494            }
    9595            int pTemp = random.Next(modelSet.Count);
    96             if (node is TreeModelTreeNode treeNode) { pTemp = treeNode.TreeNumber; } //remeber the cluster number
     96            if (node is TreeModelTreeNode treeNode) { pTemp = treeNode.TreeNumber; } //remember the cluster number
    9797            var weights = allowedSymbols.Select(s => s.InitialFrequency).ToList(); // set up probabilities
    9898
    9999#pragma warning disable CS0618 // Type or member is obsolete
    100             var newSymbol = allowedSymbols.SelectRandom(weights, random); // create new node from the choosen symbol type. Ror terminal nodes it means that we have only one possible varint.
     100            var newSymbol = allowedSymbols.SelectRandom(weights, random); // create new node from the chosen symbol type. For terminal nodes it means that we have only one possible variant.
    101101#pragma warning restore CS0618 // Type or member is obsolete
    102102            node = newSymbol.CreateTreeNode();
    103103
    104             if (node is TreeModelTreeNode treeNode2) { // make rigth mutation for tree model
     104            if (node is TreeModelTreeNode treeNode2) { // make right mutation for tree model
    105105              treeNode2.TreeNumber = pTemp;
    106106              MapParameter.ActualValue.NodeForMutationChange(random, treeNode2);
    107             } else if (node.HasLocalParameters) { // make local parametrs set up for other node types
     107            } else if (node.HasLocalParameters) { // make local parameters set up for other node types
    108108              node.ResetLocalParameters(random);
    109109            }

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/HelpFunctions.cs

    r17002 r17134  
    2020#endregion
    2121using HeuristicLab.Core;
     22using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     23using HeuristicLab.Problems.DataAnalysis.Symbolic;
     24using HeuristicLab.Random;
    2225using System.Collections.Generic;
    2326using System.Linq;
    … …  
    8588      return maxElementNumber;
    8689    }
    87     public static double CheckSocialKatre(double socialKarteValue, double value, double stepValue) {
    88       if (value > (socialKarteValue + stepValue))
    89         return stepValue;
    90       else if (value > socialKarteValue)
    91         return (value - socialKarteValue);
    92       else return 0;
    93     }
    94     public static void ProbabilitiesUpDate(List<List<double>> sucsessStatistics, List<double> probabilities) {
    9590
    96       var averageQuality = new List<double>();
    97       foreach (var variant in sucsessStatistics) {
    98         if (variant[0] > 0.005) {
    99           averageQuality.Add(variant[1] / variant[0]);
    100         } else { averageQuality.Add(0); }
     91    public static void SetLocalParametersForTree(IRandom random, double shakingFactor, ISymbolicExpressionTree tree) {
     92      foreach (var node in tree.IterateNodesPrefix().Where(x => x.HasLocalParameters)) {
     93        if (node is VariableTreeNode variableTreeNode) {
     94          var symbol = variableTreeNode.Symbol;
     95          variableTreeNode.Weight = NormalDistributedRandom.NextDouble(random, symbol.WeightManipulatorMu, symbol.WeightManipulatorSigma);
     96        } else {
     97          node.ResetLocalParameters(random);
     98        }
    10199      }
    102       int bestModelNumber = ChooseMaxElementIndex(averageQuality);
    103       double socialKarte = 1.0 / (probabilities.Count * 20.0); // parameters of method
    104       double stepValue = socialKarte / 5.0;
    105       double totalChangeValue = 0, changeValue = 0;
    106       for (int i = 0; i < probabilities.Count; i++) {
    107         changeValue = CheckSocialKatre(socialKarte, probabilities[i], stepValue);
    108         totalChangeValue += changeValue;
    109         probabilities[i] -= changeValue;
    110       }
    111       probabilities[bestModelNumber] += totalChangeValue;
    112100    }
    113101  }

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/HeuristicLab.Algorithms.EvolvmentModelsOfModels.csproj

    r17002 r17134  
    117117  </ItemGroup>
    118118  <ItemGroup>
    119     <Compile Include="EMMDisatanceMap.cs" />
    120     <Compile Include="EMMMultyPointsMutator.cs" />
    121     <Compile Include="EMMAlgorithm.cs" />
    122     <Compile Include="EMMClustering.cs" />
    123     <Compile Include="EMMBaseMap.cs" />
    124     <Compile Include="EMMIslandMap.cs" />
    125     <Compile Include="EMMMultyPointsMutatorNodeTypeSaving.cs" />
    126     <Compile Include="EMMMutators.cs" />
    127     <Compile Include="EMMSolution.cs" />
    128     <Compile Include="EMMBaseAlgorithm.cs" />
    129     <Compile Include="EMMNetworkMap.cs" />
    130     <Compile Include="EMMSucsessMap.cs" />
    131     <Compile Include="EMMZeroMap.cs" />
     119    <Compile Include="FileComuncations.cs" />
     120    <Compile Include="Maps\EMMDistanceMap.cs" />
     121    <Compile Include="EMMOperators\EMMMultyPointsMutator.cs" />
     122    <Compile Include="EMMAlgorithm\EMMAlgorithm.cs" />
     123    <Compile Include="KMeansClusterizationAlgorithm.cs" />
     124    <Compile Include="Maps\EMMBaseMap.cs" />
     125    <Compile Include="Maps\EMMIslandMap.cs" />
     126    <Compile Include="EMMOperators\EMMMultyPointsMutatorNodeTypeSaving.cs" />
     127    <Compile Include="EMMOperators\EMMMutators.cs" />
     128    <Compile Include="EMMAlgorithm\EMMSolution.cs" />
     129    <Compile Include="EMMAlgorithm\EMMBaseAlgorithm.cs" />
     130    <Compile Include="Maps\EMMNetworkMap.cs" />
     131    <Compile Include="Maps\EMMSucsessMap.cs" />
     132    <Compile Include="Maps\EMMZeroMap.cs" />
    132133    <Compile Include="HelpFunctions.cs" />
    133     <Compile Include="ModelClustersFrequencyAnalyzer.cs" />
     134    <Compile Include="Analyzers\ModelClustersFrequencyAnalyzer.cs" />
     135    <Compile Include="ModelSetPreporation.cs" />
    134136    <Compile Include="Plugin.cs" />
    135137    <Compile Include="Properties\AssemblyInfo.cs" />
    136     <Compile Include="EMMRankMap.cs" />
     138    <Compile Include="Maps\EMMRankMap.cs" />
     139    <Compile Include="SelfConfiguration.cs" />
    137140  </ItemGroup>
    138141  <ItemGroup>

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/KMeansClusterizationAlgorithm.cs

    r17133 r17134  
    2121
    2222using HeuristicLab.Core;
     23using System;
    2324using System.Collections.Generic;
    2425
    2526namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    26   public class EMModelsClusterizationAlgorithm {
     27  public class KMeansClusterizationAlgorithm {
    2728    public int K { get; private set; }
    28     public EMModelsClusterizationAlgorithm() {
     29    public KMeansClusterizationAlgorithm() {
    2930    }
    30     public EMModelsClusterizationAlgorithm(int k) {
     31    public KMeansClusterizationAlgorithm(int k) {
    3132      K = k;
    3233    }
    33     public EMModelsClusterizationAlgorithm(EMModelsClusterizationAlgorithm old) {
     34    public KMeansClusterizationAlgorithm(KMeansClusterizationAlgorithm old) {
    3435      this.K = old.K;
    3536    }
    … …  
    5253      }
    5354      bool flag = true;
    54 
    55       while (flag) {
     55      int count = 0;
     56      while (flag&&(count<1000)) {
    5657        clusters.Clear();
    5758        for (int i = 0; i < k; i++) {
    … …  
    6162        for (int i = 0; i < mapSize; i++) {
    6263          numberCluster[i] = LookCloseCentroid(centroids, distances, i, k);
    63           clusters[numberCluster[i]].Add(numberCluster[i]);
     64          clusters[numberCluster[i]].Add(i);
    6465        }
    6566        k = NullSizeClusterDelete(centroids, clusters, mapSize, numberCluster, k);
    … …  
    7475          averageClusterDistance.Clear();
    7576        }
     77        count++;
    7678      }
    7779      return k;
    … …  
    110112          }
    111113          clusters.Remove(clusters[i - iter]);
    112           centroids.Remove(i - iter);
     114          centroids.Remove(centroids[i - iter]);
    113115          iter++;
    114116        }
    … …  
    117119      return k;
    118120    }
    119     private static void AverageClusterDistanceCalculation(List<double> averageClusterDistance, double[,] distances, List<int> numberCluster, int MapSize, int currentClusterNumber) {
     121    public static void AverageClusterDistanceCalculation(List<double> averageClusterDistance, double[,] distances, List<int> numberCluster, int MapSize, int currentClusterNumber) {
    120122      int m = 0;
    121123      for (int i = 0; i < MapSize; i++) {
    … …  
    124126          for (int j = 0; j < MapSize; j++) {
    125127            if (numberCluster[j] == currentClusterNumber)
    126               averageClusterDistance[m] += distances[i, j];
     128              averageClusterDistance[m] += Math.Abs(distances[i, j]);
    127129          }
    128130          m++;

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Maps/EMMBaseMap.cs

    r17133 r17134  
    2525using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2626using HeuristicLab.Problems.DataAnalysis.Symbolic;
    27 using HeuristicLab.Random;
    2827using System.Collections.Generic;
    2928using System.IO;
    … …  
    3231namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    3332  [StorableType("83CF9650-98FF-454B-9072-82EA4D39C752")]
    34   public abstract class EMMMapBase<T> : Item where T : class {
     33  public abstract class EMMMapBase<T> : ParameterizedNamedItem where T : class {
    3534    #region data members
    3635    [Storable]
    37     public List<T> ModelSet { get; set; }
     36    public List<T> ModelSet { get; protected set; }
    3837    [Storable]
    3938    public List<List<int>> Map { get; set; }
     39    public string DistanceParametr { get; set; }
    4040    #endregion
    4141    #region constructors
    … …  
    4444    public EMMMapBase() {
    4545      Map = new List<List<int>>();
     46      DistanceParametr = "Symbolic";
    4647    }
    47     public EMMMapBase(EMMMapBase<T> original, Cloner cloner) {
     48    public EMMMapBase(EMMMapBase<T> original, Cloner cloner) : base(original, cloner) {
    4849      if (original.ModelSet != null) {
    4950        if (original.ModelSet is List<ISymbolicExpressionTree> originalSet && ModelSet is List<ISymbolicExpressionTree> set)
    … …  
    5455        Map = original.Map.Select(x => x.ToList()).ToList();
    5556      }
     57      DistanceParametr = original.DistanceParametr;
    5658    }
    5759    #endregion
    5860    #region map creation functions
    59     protected double[,] CalculateDistances() {
    60       double[,] distances;
    61       if (ModelSet is List<ISymbolicExpressionTree> set) {
    62         distances = SymbolicExpressionTreeHash.ComputeSimilarityMatrix(set, simplify: false, strict: true);
    63       } else { /// for future work
    64         distances = new double[ModelSet.Count, ModelSet.Count];
    65         for (int i = 0; i < ModelSet.Count - 1; i++) {
    66           for (int j = 0; j <= i; j++) {
    67             distances[i, j] = 0;
    68           }
    69         }
    70       }
    71       for (int i = 0; i < ModelSet.Count - 1; i++) {
    72         for (int j = i + 1; j < ModelSet.Count; j++) {
    73           distances[j, i] = distances[i, j] = 1 - distances[i, j];
    74         }
    75       }
    76       return distances;
    77     }
    78     public abstract void CreateMap(IRandom random, int k);
     61
     62    public abstract void CreateMap(IRandom random);
    7963    public void MapCreationPrepare(IEnumerable<T> trees) {
    8064      ModelSet = trees.ToList();
     65    }
     66    public virtual void CreateMap(IRandom random, ISymbolicDataAnalysisSingleObjectiveProblem problem) {
     67      if (Map != null) {
     68        Map.Clear();
     69      }
     70      CreateMap(random);
     71    }
     72    public virtual void CreateMap(IRandom random, double[,] totalDistance) {
     73      if (Map != null) {
     74        Map.Clear();
     75      }
     76      CreateMap(random);
    8177    }
    8278
    … …  
    9591    #endregion
    9692    #region map and files
    97     public void MapRead(IRandom random, IEnumerable<T> trees, string fileName = "Map.txt") {
     93    public virtual void MapRead(IEnumerable<T> trees) {
    9894      ModelSet = trees.ToList();
    99       MapFromFileRead(fileName);
    100       if (this is EMMIslandMap island) { island.ClusterNumbersCalculate(); }
    101       if (this is EMMNetworkMap one) { one.NeghboorNumber = Map[0].Count; }
    10295    }
    10396    public void WriteMapToTxtFile(IRandom random) {
    104       string s = random.ToString();
    105       string fileName = "Map";
     97      string s = random.NextDouble().ToString();
     98      string fileName = "MapToAnalize";
    10699      fileName += s;
     100      fileName += DistanceParametr;
    107101      fileName += ".txt";
    108102      File.WriteAllLines(fileName, MapToString());
    109103      string fileName2 = "MapToSee";
    110104      fileName2 += s;
     105      fileName2 += DistanceParametr;
    111106      fileName2 += ".txt";
    112107      File.WriteAllLines(fileName2, MapToSee());
     108      string fileName3 = "Map";
     109      fileName3 += DistanceParametr;
     110      fileName3 += ".txt";
     111      File.WriteAllLines(fileName3, MapToStoreInFile());
    113112    }
    114     public string[] MapToString() { // Function that preapre Map to printing in .txt File: create a set of strings for future reading by computer
     113    public string[] MapToString() { // Function that prepare Map to printing in .txt File: create a set of strings for future analyzing
     114      string[] s;
     115      s = new string[Map.Count];
     116      for (int i = 0; i < Map.Count; i++) {
     117        s[i] = i.ToString() + ": ";
     118        for (int j = 0; j < Map[i].Count; j++) {
     119          s[i] += Map[i][j].ToString();
     120          s[i] += " ";
     121        }
     122        if (this is EMMIslandMap island) {
     123          s[i] += "  Average distance:" + island.AverageDistance[i].ToString();
     124        }
     125      }
     126      return s;
     127    }
     128    public virtual string[] MapToStoreInFile() { // Function that prepare Map to printing in .txt File: create a set of strings for future reading by computer
    115129      string[] s;
    116130      s = new string[Map.Count];
    … …  
    119133        for (int j = 0; j < Map[i].Count; j++) {
    120134          s[i] += Map[i][j].ToString();
    121           s[i] += " ";
     135          if (j != (Map[i].Count - 1)) { s[i] += " "; }
    122136        }
    123137      }
    … …  
    140154      }
    141155      return s;
    142     }
    143     public void MapFromFileRead(string fileName) {
    144       string input = File.ReadAllText(fileName);
    145       int i = 0;
    146       foreach (var row in input.Split('\n')) {
    147         Map.Add(new List<int>());
    148         foreach (var col in row.Trim().Split(' ')) {
    149           Map[i].Add(int.Parse(col.Trim()));
    150         }
    151         i++;
    152       }
    153156    }
    154157    #endregion
    … …  
    173176      treeNode.Tree = new SymbolicExpressionTree(NewModelForMutation(random, out treeNumber, treeNumber2).Root);
    174177      treeNode.TreeNumber = treeNumber;
    175       SetLocalParametersForTree(random, 0.5, treeNode.Tree);
    176     }
    177     public void SetLocalParametersForTree(IRandom random, double shakingFactor, ISymbolicExpressionTree tree) {
    178       foreach (var node in tree.IterateNodesPrefix().Where(x => x.HasLocalParameters)) {
    179         if (node is VariableTreeNode variableTreeNode) {
    180           var symbol = variableTreeNode.Symbol;
    181           variableTreeNode.Weight = NormalDistributedRandom.NextDouble(random, symbol.WeightManipulatorMu, symbol.WeightManipulatorSigma);
    182         } else {
    183           node.ResetLocalParameters(random);
    184         }
    185       }
     178      HelpFunctions.SetLocalParametersForTree(random, 0.5, treeNode.Tree);
    186179    }
    187180    public virtual void MapUpDate(Dictionary<ISymbolicExpressionTree, double> population) { }

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Maps/EMMDistanceMap.cs

    r17133 r17134  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     26using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2627using System;
    2728using System.Collections.Generic;
     29using System.Linq;
    2830
    2931namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    … …  
    3335    [Storable]
    3436    public List<List<double>> Probabilities { get; set; }
    35     #region conctructors
     37    #region constructors
    3638    [StorableConstructor]
    3739    protected EMMDisatanceMap(StorableConstructorFlag _) : base(_) { }
    … …  
    3941      return new EMMDisatanceMap(this, cloner);
    4042    }
    41     public EMMDisatanceMap() : base() { ModelSet = new List<ISymbolicExpressionTree>(); }
    42     public EMMDisatanceMap(EMMDisatanceMap original, Cloner cloner) : base(original, cloner) { }
     43    public EMMDisatanceMap() : base() {
     44      ModelSet = new List<ISymbolicExpressionTree>();
     45      Probabilities = new List<List<double>>();
     46    }
     47    public EMMDisatanceMap(EMMDisatanceMap original, Cloner cloner) : base(original, cloner) {
     48      if (original.Probabilities != null) {
     49        Probabilities = original.Probabilities.Select(x => x.ToList()).ToList();
     50      }
     51    }
    4352    #endregion
    44     #region MapCreation
    45     override public void CreateMap(IRandom random, int k) {
    46 
    47       Probabilities = new List<List<double>>();
     53    #region Map Creation
     54    override public void CreateMap(IRandom random) {
    4855      MapSizeCheck(ModelSet.Count);
    49       ApplyDistanceMapCreationAlgorithm(random, CalculateDistances(), Map, Probabilities);
     56      ApplyDistanceMapCreationAlgorithm(random, ModelSetPreparation.CalculateDistances(ModelSet), Map, Probabilities);
    5057    }
    51     public static void ApplyDistanceMapCreationAlgorithm(IRandom random, double[,] distances, List<List<int>> map, List<List<double>> probabilities) {
     58    override public string[] MapToStoreInFile() { // Function that prepare Map to printing in .txt File: create a set of strings for future reading by computer
     59      string[] s;
     60      s = new string[Map.Count];
     61      for (int i = 0; i < Map.Count; i++) {
     62        s[i] = "";
     63        for (int j = 0; j < (Map.Count - 1); j++) {
     64          s[i] += Probabilities[i][j].ToString();
     65          if (j != (Map.Count - 2)) { s[i] += " "; }
     66        }
     67      }
     68      return s;
     69    }
     70    override public void MapRead(IEnumerable<ISymbolicExpressionTree> trees) {
     71      base.MapRead(trees);
     72      MapFullment(trees.Count());
     73      string fileName = ("Map" + DistanceParametr + ".txt");
     74      Probabilities = FileComuncations.DoubleMatrixFromFileRead(fileName);
     75    }
     76    override public void CreateMap(IRandom random, ISymbolicDataAnalysisSingleObjectiveProblem problem) {
     77      MapSizeCheck(ModelSet.Count);
     78      if (Map != null) {
     79        Map.Clear();
     80      }
     81      ApplyDistanceMapCreationAlgorithm(random, ModelSetPreparation.DistanceMatrixCalculation(ModelSet, DistanceParametr, problem), Map, Probabilities);
     82    }
     83    protected void ApplyDistanceMapCreationAlgorithm(IRandom random, double[,] distances, List<List<int>> map, List<List<double>> probabilities) {
    5284      int mapSize = distances.GetLength(0);
    5385      for (int t = 0; t < mapSize; t++) {
    … …  
    6597      }
    6698    }
     99    protected void MapFullment(int mapSize) {
     100      if (Map != null) {
     101        Map.Clear();
     102      }
     103      for (int t = 0; t < mapSize; t++) {
     104        for (int i = 0; i < mapSize; i++) {
     105          if (i == t)
     106            continue;
     107          Map[t].Add(i);
     108        }
     109      }
     110    }
    67111    #endregion
    68     #region MapApplayFunctions
     112    #region Map Apply Functions
    69113    public override ISymbolicExpressionTree NewModelForMutation(IRandom random, out int treeNumber, int parentTreeNumber) {
    70114      treeNumber = HelpFunctions.OneElementFromListProportionalSelection(random, Probabilities[parentTreeNumber]);

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Maps/EMMIslandMap.cs

    r17133 r17134  
    2323using HeuristicLab.Common;
    2424using HeuristicLab.Core;
     25using HeuristicLab.Data;
    2526using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Parameters;
     28using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2629using HeuristicLab.Random;
    2730using System.Collections.Generic;
    … …  
    3235  [StorableType("E4AB04B9-FD5D-47EE-949D-243660754F3A")]
    3336  public class EMMIslandMap : EMMMapBase<ISymbolicExpressionTree> {
     37
    3438    [Storable]
    3539    public List<int> ClusterNumber { get; set; }  // May be only Island Map really need it
    36     #region conctructors
     40    public double[] AverageDistance { get; private set; }
     41    private const string ClusterNumbersParameterName = "ClusterNumbers";
     42    private const string ClusterNumbersShowParameterName = "ClusterNumbersShow";
     43    public IValueParameter<IntValue> ClusterNumbersParameter {
     44      get { return (IValueParameter<IntValue>)Parameters[ClusterNumbersParameterName]; }
     45    }
     46    public IValueParameter<IntValue> ClusterNumbersShowParameter {
     47      get { return (IValueParameter<IntValue>)Parameters[ClusterNumbersShowParameterName]; }
     48    }
     49    public IntValue ClusterNumbers {
     50      get { return ClusterNumbersParameter.Value; }
     51      set { ClusterNumbersParameter.Value = value; }
     52    }
     53    public IntValue ClusterNumbersShow {
     54      get { return ClusterNumbersShowParameter.Value; }
     55      set { ClusterNumbersShowParameter.Value = value; }
     56    }
     57    #region constructors
    3758    [StorableConstructor]
    3859    protected EMMIslandMap(StorableConstructorFlag _) : base(_) { }
    3960    public EMMIslandMap() {
     61      Parameters.Add(new ValueParameter<IntValue>(ClusterNumbersParameterName, "The number of clusters for model Map.", new IntValue(10)));
     62      Parameters.Add(new ValueParameter<IntValue>(ClusterNumbersShowParameterName, "The number of clusters for model Map.", new IntValue(10)));
    4063      ModelSet = new List<ISymbolicExpressionTree>();
    4164      ClusterNumber = new List<int>();
    … …  
    5073    }
    5174    #endregion
    52     #region MapApplayFunctions
    53     override public void CreateMap(IRandom random, int k) {
    54 
    55       k = EMModelsClusterizationAlgorithm.ApplyClusteringAlgorithm(random, CalculateDistances(), ClusterNumber, k);
    56       MapSizeCheck(k);
     75    #region Map Apply Functions
     76    override public void CreateMap(IRandom random) {
     77      var totalDistance = ModelSetPreparation.CalculateDistances(ModelSet); //structure distances
     78      CreateMap(random, totalDistance);
     79    }
     80    override public void CreateMap(IRandom random, ISymbolicDataAnalysisSingleObjectiveProblem problem) {
     81      CreateMap(random, ModelSetPreparation.TotalDistanceMatrixCalculation(random, problem, ModelSet, DistanceParametr));
     82    }
     83    override public void CreateMap(IRandom random, double[,] totalDistance) {
     84      if (Map != null) {
     85        Map.Clear();
     86      }
     87      ClusterNumbersShow.Value = KMeansClusterizationAlgorithm.ApplyClusteringAlgorithm(random, totalDistance, ClusterNumber, ClusterNumbers.Value);
     88      MapSizeCheck(ClusterNumbersShow.Value);
    5789      for (int i = 0; i < ModelSet.Count; i++) {
    5890        Map[ClusterNumber[i]].Add(i);
    5991      }
     92      AverageDistanceInClusterCalculation(totalDistance, ClusterNumbersShow.Value);
     93    }
     94    override public void MapRead(IEnumerable<ISymbolicExpressionTree> trees) {
     95      base.MapRead(trees);
     96      string fileName = ("Map" + DistanceParametr + ".txt");
     97      Map = FileComuncations.IntMatrixFromFileRead(fileName);
     98      ClusterNumbers.Value = Map.Count;
     99      ClusterNumbersShow.Value = ClusterNumbers.Value;
     100      ClusterNumbersCalculate();
     101      AverageDistanceInClusterCalculation(ModelSetPreparation.CalculateDistances(ModelSet), Map.Count);
    60102    }
    61103    override public ISymbolicExpressionTree NewModelForInizializtionNotTree(IRandom random, out int treeNumber) {
    62104      return NewModelForInizializtion(random, out treeNumber);
    63105    }
    64 
     106    private void AverageDistanceInClusterCalculation(double[,] distances, int k) {
     107      AverageDistance = new double[k];
     108      var temp = new List<double>();
     109      for (int i = 0; i < k; i++) {
     110        KMeansClusterizationAlgorithm.AverageClusterDistanceCalculation(temp, distances, ClusterNumber, ClusterNumber.Count, i);
     111        var number = HelpFunctions.ChooseMinElementIndex(temp);
     112        AverageDistance[i] = temp[number] / Map[i].Count;
     113        temp.Clear();
     114      }
     115    }
    65116    public override ISymbolicExpressionTree NewModelForMutation(IRandom random, out int treeNumber, int parentTreeNumber) {
    66117      if (parentTreeNumber == -10) {
    … …  
    71122      return (ISymbolicExpressionTree)ModelSet[treeNumber].Clone();
    72123    }
    73     public void ClusterNumbersCalculate() {  // May be it should be transported to Child Clase (IslandMap)
     124    public void ClusterNumbersCalculate() {
    74125      for (int i = 0; i < Map.Count; i++) {
    75126        for (int j = 0; j < Map[i].Count; j++) {

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Maps/EMMNetworkMap.cs

    r17133 r17134  
    2323using HeuristicLab.Common;
    2424using HeuristicLab.Core;
     25using HeuristicLab.Data;
    2526using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Parameters;
     28using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2629using HeuristicLab.Random;
     30using System;
    2731using System.Collections.Generic;
    2832
    … …  
    3135  [StorableType("C200ECC2-6D33-4468-A538-580B07D75B3C")]
    3236  public class EMMNetworkMap : EMMMapBase<ISymbolicExpressionTree> {
    33     public int NeghboorNumber { get; set; }
    34     #region conctructors
     37    private const string NegbourTypeParameterName = "NegbourType";
     38    private const string NegbourNumberParameterName = "NegbourNumber";
     39    public IFixedValueParameter<StringValue> NegbourTypeParameter {
     40      get { return (IFixedValueParameter<StringValue>)Parameters[NegbourTypeParameterName]; }
     41    }
     42    public IValueParameter<IntValue> NegbourNumberParameter {
     43      get { return (IValueParameter<IntValue>)Parameters[NegbourNumberParameterName]; }
     44    }
     45    public StringValue NegbourType {
     46      get { return NegbourTypeParameter.Value; }
     47      set { NegbourTypeParameter.Value.Value = value.Value; }
     48    }
     49    public IntValue NegbourNumber {
     50      get { return NegbourNumberParameter.Value; }
     51      set { NegbourNumberParameter.Value.Value = value.Value; }
     52    }
     53    #region constructors
    3554    [StorableConstructor]
    3655    protected EMMNetworkMap(StorableConstructorFlag _) : base(_) { }
    37     public EMMNetworkMap() : this(1) { }
     56
    3857    public override IDeepCloneable Clone(Cloner cloner) {
    3958      return new EMMNetworkMap(this, cloner);
    4059    }
    41     public EMMNetworkMap(int neghboorNumber = 10) : base() {
    42       NeghboorNumber = neghboorNumber;
     60    public EMMNetworkMap() : base() {
     61      Parameters.Add(new ValueParameter<IntValue>(NegbourNumberParameterName, "The parameter for FullMap type of map creation algorithm. Use one from: 10, 20.", new IntValue(10)));
     62      Parameters.Add(new FixedValueParameter<StringValue>(NegbourTypeParameterName, "The parameter for FullMap type of map creation algorithm. Use one from: Percent, Number.", new StringValue("Number")));
     63      MapParameterUpdate();
     64      ModelSet = new List<ISymbolicExpressionTree>();
    4365    }
    44     public EMMNetworkMap(EMMNetworkMap original, Cloner cloner) : base(original, cloner) { NeghboorNumber = original.NeghboorNumber; }
     66    public EMMNetworkMap(EMMNetworkMap original, Cloner cloner) : base(original, cloner) { NegbourNumber = original.NegbourNumber; }
    4567    #endregion
    46     #region MapTransformation
    47     override public void CreateMap(IRandom random, int k) {
    48       ApplyNetworkMapCreationAlgorithm(random, CalculateDistances(), Map, NeghboorNumber);
     68    #region Map Transformation
     69    override public void CreateMap(IRandom random) {
     70      MapParameterUpdate();
     71      if (Map != null) {
     72        Map.Clear();
     73      }
     74      ApplyNetworkMapCreationAlgorithm(random, ModelSetPreparation.CalculateDistances(ModelSet), Map, NegbourNumber.Value);
     75    }
     76    override public void CreateMap(IRandom random, ISymbolicDataAnalysisSingleObjectiveProblem problem) {
     77      MapParameterUpdate();
     78      if (Map != null) {
     79        Map.Clear();
     80      }
     81      ApplyNetworkMapCreationAlgorithm(random, ModelSetPreparation.DistanceMatrixCalculation(ModelSet, DistanceParametr, problem), Map, NegbourNumber.Value);
     82    }
     83    override public void MapRead(IEnumerable<ISymbolicExpressionTree> trees) {
     84      base.MapRead(trees);
     85      string fileName = ("Map" + DistanceParametr + ".txt");
     86      Map = FileComuncations.IntMatrixFromFileRead(fileName);
     87      NegbourNumber.Value = Map[0].Count;
    4988    }
    5089    public static void ApplyNetworkMapCreationAlgorithm(IRandom random, double[,] distances, List<List<int>> map, int neghboorNumber = 10) {
    … …  
    63102      }
    64103    }
     104    protected void MapParameterUpdate() {
     105      switch (NegbourType.Value) {
     106        case "Percent": NegbourNumber.Value = Convert.ToInt32((Convert.ToDouble(ModelSet.Count)) * (Convert.ToDouble(NegbourNumber.Value)) / 100.0); break;
     107        case "Number": NegbourNumber.Value = NegbourNumber.Value; break;
     108        default: NegbourNumber.Value = NegbourNumber.Value; break;
     109      }
     110    }
    65111    #endregion
    66     #region Dialog with surroudings
     112    #region Dialog with surroundings
    67113    public override ISymbolicExpressionTree NewModelForMutation(IRandom random, out int treeNumber, int parentTreeNumber) {
    68114      treeNumber = Map[parentTreeNumber].SampleRandom(random);

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Maps/EMMRankMap.cs

    r17133 r17134  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     26using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2627using System;
    2728using System.Collections.Generic;
     29using System.Linq;
    2830
    2931namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    3032  [Item("RankMap", "A map of models of models of models")]
    3133  [StorableType("1D4DD90E-553A-46DB-B0CD-6A899AA0B6D0")]
    32   public class EMMRankMap : EMMMapBase<ISymbolicExpressionTree> {
     34  public class EMMRankMap : EMMMapBase<ISymbolicExpressionTree> { // it do not work absolutely
    3335    [Storable]
    3436    public List<List<double>> Probabilities { get; set; }
    35     #region conctructors
     37    #region constructors
    3638    [StorableConstructor]
    3739    protected EMMRankMap(StorableConstructorFlag _) : base(_) { }
    … …  
    3941      return new EMMRankMap(this, cloner);
    4042    }
    41     public EMMRankMap() : base() { ModelSet = new List<ISymbolicExpressionTree>(); }
    42     public EMMRankMap(EMMRankMap original, Cloner cloner) : base(original, cloner) { }
     43    public EMMRankMap() : base() {
     44      ModelSet = new List<ISymbolicExpressionTree>();
     45      Probabilities = new List<List<double>>();
     46    }
     47    public EMMRankMap(EMMRankMap original, Cloner cloner) : base(original, cloner) {
     48      if (original.Probabilities != null) {
     49        Probabilities = original.Probabilities.Select(x => x.ToList()).ToList();
     50      }
     51    }
    4352    #endregion
    4453    #region MapCreation
    45     override public void CreateMap(IRandom random, int k) {
    46 
    47       Probabilities = new List<List<double>>();
     54    override public void CreateMap(IRandom random) {
    4855      MapSizeCheck(ModelSet.Count);
    49       ApplyRankMapCreationAlgorithm(random, CalculateDistances(), Map, Probabilities);
     56      ApplyRankMapCreationAlgorithm(ModelSetPreparation.CalculateDistances(ModelSet), Map, Probabilities);
    5057    }
    51     public static void ApplyRankMapCreationAlgorithm(IRandom random, double[,] distances, List<List<int>> map, List<List<double>> probabilities) {
     58    override public void CreateMap(IRandom random, ISymbolicDataAnalysisSingleObjectiveProblem problem) {
     59      MapSizeCheck(ModelSet.Count);
     60      ApplyRankMapCreationAlgorithm(ModelSetPreparation.DistanceMatrixCalculation(ModelSet, DistanceParametr, problem), Map, Probabilities);
     61    }
     62    override public void MapRead(IEnumerable<ISymbolicExpressionTree> trees) {
     63      base.MapRead(trees);
     64      MapFullment(trees.Count());
     65      string fileName = ("Map" + DistanceParametr + ".txt");
     66      Probabilities = FileComuncations.DoubleMatrixFromFileRead(fileName);
     67    }
     68    protected void MapFullment(int mapSize) {
     69      if (Map != null) {
     70        Map.Clear();
     71      }
     72      for (int t = 0; t < mapSize; t++) {
     73        for (int i = 0; i < mapSize; i++) {
     74          if (i == t)
     75            continue;
     76          Map[t].Add(i);
     77        }
     78      }
     79    }
     80    override public string[] MapToStoreInFile() { // Function that prepare Map to printing in .txt File: create a set of strings for future reading by computer
     81      string[] s;
     82      s = new string[Map.Count];
     83      for (int i = 0; i < Map.Count; i++) {
     84        s[i] = "";
     85        for (int j = 0; j < (Map.Count - 1); j++) {
     86          s[i] += Probabilities[i][j].ToString();
     87          if (j != (Map.Count - 2)) { s[i] += " "; }
     88        }
     89      }
     90      return s;
     91    }
     92    public static void ApplyRankMapCreationAlgorithm(double[,] distances, List<List<int>> map, List<List<double>> probabilities) {
    5293      int mapSize = distances.GetLength(0);
    5394      double tempSum = 0;
    … …  
    64105          currentList[i].Add(distances[i, t]);
    65106        }
    66         currentList.Sort((a, b) => a[1].CompareTo(b[1])); ///загадкой является то нафига оно мне вообще понадобилось in DistanceMap.. но это работающая сортировка.
     107        currentList.Sort((a, b) => a[1].CompareTo(b[1])); ///workable sorting
    67108        for (int i = 0; i < currentList.Count; i++) {
    68109          currentList[i].Add(currentList.Count - i);
    … …  
    79120    }
    80121    #endregion
    81     #region MapApplayFunctions
     122    #region Map Apply Functions
    82123    public override ISymbolicExpressionTree NewModelForMutation(IRandom random, out int treeNumber, int parentTreeNumber) {
    83124      treeNumber = Map[parentTreeNumber][HelpFunctions.OneElementFromListProportionalSelection(random, Probabilities[parentTreeNumber])];

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Maps/EMMSucsessMap.cs

    r17133 r17134  
    2323using HeuristicLab.Core;
    2424using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    25 using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2625using System.Collections.Generic;
    27 using System.Linq;
    2826
    2927namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
    … …  
    3230  public class EMMSucsessMap : EMMMapBase<ISymbolicExpressionTree> {
    3331    [Storable]
    34     public List<double> Probabilities { get; private set; }
    35     [Storable]
    36     public List<List<double>> SucsessStatistics { get; private set; }
    37     #region conctructors
     32    public SelfConfiguration SelfConfigurationMechanism { get; private set; }
     33    #region constructors
    3834    [StorableConstructor]
    3935    protected EMMSucsessMap(StorableConstructorFlag _) : base(_) { }
    … …  
    4339    public EMMSucsessMap() : base() {
    4440      ModelSet = new List<ISymbolicExpressionTree>();
    45       SucsessStatistics = new List<List<double>>();
     41      SelfConfigurationMechanism = new SelfConfiguration();
    4642    }
    4743    public EMMSucsessMap(EMMSucsessMap original, Cloner cloner) : base(original, cloner) {
    48       SucsessStatistics = original.SucsessStatistics.Select(x => x.ToList()).ToList();
     44      SelfConfigurationMechanism = new SelfConfiguration(original.SelfConfigurationMechanism, cloner);
    4945    }
    5046    #endregion
    51     #region MapCreation
    52     override public void CreateMap(IRandom random, int k) {
    53 
    54       Probabilities = new List<double>();
    55       Map.Clear();
     47    #region Map Creation
     48    override public void CreateMap(IRandom random) {
     49      if (Map != null) {
     50        Map.Clear();
     51      }
    5652      Map.Add(new List<int>());
    5753      MapSizeCheck(ModelSet.Count);
    58       ApplySucsessMapCreationAlgorithm(random, CalculateDistances(), Map, Probabilities, SucsessStatistics);
     54      ApplySucsessMapCreationAlgorithm(random, ModelSet.Count);
    5955    }
    60     public static void ApplySucsessMapCreationAlgorithm(IRandom random, double[,] distances, List<List<int>> map, List<double> probabilities, List<List<double>> sucsessStatistics) {
    61       int mapSize = distances.GetLength(0);
     56    override public void MapRead(IEnumerable<ISymbolicExpressionTree> trees) {
     57      base.MapRead(trees);
     58      string fileName = ("Map" + DistanceParametr + ".txt");
     59      SelfConfigurationMechanism.ReadFromFile(ModelSet.Count, fileName);
     60    }
     61    override public string[] MapToStoreInFile() { // Function that prepare Map to printing in .txt File: create a set of strings for future reading by computer
     62      string[] s;
     63      s = new string[1];
     64      for (int i = 0; i < Map.Count; i++) {
     65        s[0] = "";
     66        s[0] += SelfConfigurationMechanism.Probabilities[i].ToString();
     67      }
     68      return s;
     69    }
     70    private void ApplySucsessMapCreationAlgorithm(IRandom random, int mapSize) {
    6271      for (int t = 0; t < mapSize; t++) {
    63         map[t].Add(t);
    64         probabilities.Add(1.0 / ((double)(mapSize))); // uniform distribution as start point
     72        Map[t].Add(t);
    6573      }
     74      SelfConfigurationMechanism.Initialization(mapSize);
    6675    }
    6776    public override void MapUpDate(Dictionary<ISymbolicExpressionTree, double> population) {
    68       SucsessStatisticCollection(population);
    69       HelpFunctions.ProbabilitiesUpDate(SucsessStatistics, Probabilities);
    70     }
    71     private void SucsessStatisticCollection(Dictionary<ISymbolicExpressionTree, double> population) {
    72       if (SucsessStatistics.Count != 0)
    73         SucsessStatistics.Clear();
    74       for (int t = 0; t < Probabilities.Count; t++) {
    75         SucsessStatistics.Add(new List<double>());
    76         SucsessStatistics[t].Add(0);
    77         SucsessStatistics[t].Add(0);
    78       }
    79       foreach (var solution in population) {
    80         TreeCheck(solution.Key, solution.Value);
    81       }
    82     }
    83     private void TreeCheck(ISymbolicExpressionTree tree, double treeQuality) {
    84       foreach (var treeNode in tree.IterateNodesPrefix().OfType<TreeModelTreeNode>()) {
    85         SucsessStatistics[treeNode.TreeNumber][0] += 1;
    86         SucsessStatistics[treeNode.TreeNumber][1] += treeQuality;
    87       }
     77      SelfConfigurationMechanism.UpDate(population);
    8878    }
    8979    #endregion
    90     #region MapApplayFunctions
     80    #region Map Apply Functions
    9181    public override ISymbolicExpressionTree NewModelForMutation(IRandom random, out int treeNumber, int parentTreeNumber) {
    92       treeNumber = Map[HelpFunctions.OneElementFromListProportionalSelection(random, Probabilities)][0];
     82      treeNumber = Map[SelfConfigurationMechanism.Aplay(random)][0];
    9383      return (ISymbolicExpressionTree)ModelSet[treeNumber].Clone();
    9484    }

  • branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Maps/EMMZeroMap.cs

    r17133 r17134  
    3030  [StorableType("FF199AE7-DF0A-4E2A-99BC-BECD647E18F0")]
    3131  public class EMMZeroMap : EMMMapBase<ISymbolicExpressionTree> {
    32     #region conctructors
     32    #region constructors
    3333    [StorableConstructor]
    3434    protected EMMZeroMap(StorableConstructorFlag _) : base(_) { }
    … …  
    4141    public EMMZeroMap(EMMZeroMap original, Cloner cloner) : base(original, cloner) { }
    4242    #endregion
    43     #region MapApplayFunctions
    44     override public void CreateMap(IRandom random, int k) { }
     43    #region Map Apply Functions
     44    override public void CreateMap(IRandom random) { }
    4545    override public ISymbolicExpressionTree NewModelForInizializtionNotTree(IRandom random, out int treeNumber) {
    4646      return NewModelForInizializtion(random, out treeNumber);

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs

    r16722 r17134  
    2020#endregion
    2121
     22using HEAL.Attic;
     23using HeuristicLab.Common;
     24using HeuristicLab.Core;
     25using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2226using System;
    2327using System.Globalization;
    2428using System.Linq;
    2529using System.Text;
    26 using HeuristicLab.Common;
    27 using HeuristicLab.Core;
    28 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    29 using HEAL.Attic;
    3030
    3131namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    5858    /// <param name="formatString">The format string for numeric parameters (e.g. \"G4\" to limit to 4 digits, default is \"G\")</param>
    5959    /// <returns>Infix expression</returns>
    60     public string Format(ISymbolicExpressionTree symbolicExpressionTree, NumberFormatInfo numberFormat, string formatString="G") {
     60    public string Format(ISymbolicExpressionTree symbolicExpressionTree, NumberFormatInfo numberFormat, string formatString = "G") {
    6161      // skip root and start symbols
    6262      StringBuilder strBuilder = new StringBuilder();
    … …  
    182182          else
    183183            strBuilder.Append("(").Append(constNode.Value.ToString(formatString, numberFormat)).Append(")"); // (-1
     184        } else if (node.Symbol is TreeModel) {
     185          var modelNode = node as TreeModelTreeNode;
     186          strBuilder.Append(modelNode.TreeToString());
    184187        }
    185188      }

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs

    r16722 r17134  
    101101    public static void CubeRoot(double[] a, double[] b) {
    102102      for (int i = 0; i < BATCHSIZE; ++i)
    103         a[i] = Math.Pow(b[i], 1d / 3d);
     103        a[i] = b[i] < 0 ? -Math.Pow(-b[i], 1d / 3d) : Math.Pow(b[i], 1d / 3d);
    104104    }
    105105

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ModelTreeNode.cs

    r17002 r17134  
    9494      return s;
    9595    }
     96    public string TreeToString() {
     97      var fmt = new InfixExpressionFormatter();
     98      string s = fmt.Format(Tree);
     99      return s;
     100    }
    96101  }
    97102}
Note: See TracChangeset for help on using the changeset viewer.