Free cookie consent management tool by TermsFeed Policy Generator

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/HeuristicLab.Algorithms.EMM/Maps
Files:
1 added
7 moved

Legend:

Unmodified
Added
Removed

  • 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);
Note: See TracChangeset for help on using the changeset viewer.