Free cookie consent management tool by TermsFeed Policy Generator

Changeset 1873 for trunk/sources


Ignore:
Timestamp:
05/20/09 17:38:19 (15 years ago)
Author:
gkronber
Message:

Worked on different dispatching of deterministic and non-deterministic modeling algorithms. #635

Location:
trunk/sources
Files:
13 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.CEDMA.DB.Interfaces/3.3/Ontology.cs

    r1529 r1873  
    9191    public static Entity PredicateInstanceOf {
    9292      get { return new Entity(CedmaNameSpace + "InstanceOf"); }
    93     }
    94     public static Entity TypeGeneticProgrammingFunctionTree {
    95       get { return new Entity(CedmaNameSpace + "FunctionTree"); }
    9693    }
    9794    public static Entity TypeDataSet {

  • trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherBase.cs

    r1869 r1873  
    6161      DataSet dataSet = new DataSet(store, dataSetEntity);
    6262
    63       int targetVariable = SelectTargetVariable(dataSet, dataSet.Problem.AllowedTargetVariables.ToArray());
    64       IAlgorithm selectedAlgorithm = SelectAlgorithm(dataSet, targetVariable, dataSet.Problem.LearningTask);
     63      int targetVariable = SelectTargetVariable(dataSetEntity, dataSet.Problem.AllowedTargetVariables.ToArray());
     64      IAlgorithm selectedAlgorithm = SelectAlgorithm(dataSetEntity, targetVariable, dataSet.Problem.LearningTask);
    6565      string targetVariableName = dataSet.Problem.GetVariableName(targetVariable);
    6666
    … …  
    7575
    7676    public abstract Entity SelectDataSet(Entity[] datasets);
    77     public abstract int SelectTargetVariable(DataSet dataSet, int[] targetVariables);
    78     public abstract IAlgorithm SelectAlgorithm(DataSet dataSet, int targetVariable, LearningTask learningTask);
     77    public abstract int SelectTargetVariable(Entity dataSet, int[] targetVariables);
     78    public abstract IAlgorithm SelectAlgorithm(Entity dataSet, int targetVariable, LearningTask learningTask);
    7979
    8080    private Execution CreateExecution(Problem problem, int targetVariable, IAlgorithm algorithm) {

  • trunk/sources/HeuristicLab.CEDMA.Server/3.3/Executer.cs

    r1529 r1873  
    129129    private void StoreResults(Execution finishedExecution, ProcessingEngine finishedEngine) {
    130130      Entity model = new Entity(Ontology.CedmaNameSpace + Guid.NewGuid());
    131       store.Add(new Statement(model, Ontology.PredicateInstanceOf, Ontology.TypeGeneticProgrammingFunctionTree));
    132131      store.Add(new Statement(finishedExecution.DataSetEntity, Ontology.PredicateHasModel, model));
    133132      StoreModelAttribute(model, Ontology.TargetVariable, finishedExecution.TargetVariable);

  • trunk/sources/HeuristicLab.CEDMA.Server/3.3/HeuristicLab.CEDMA.Server-3.3.csproj

    r1857 r1873  
    9595    <Compile Include="Execution.cs" />
    9696    <Compile Include="Executer.cs" />
    97     <Compile Include="RandomDispatcher.cs" />
    9897    <Compile Include="Server.cs" />
    9998    <Compile Include="ServerApplication.cs" />
    … …  
    106105      <DependentUpon>ServerForm.cs</DependentUpon>
    107106    </Compile>
     107    <Compile Include="SimpleDispatcher.cs" />
    108108  </ItemGroup>
    109109  <ItemGroup>

  • trunk/sources/HeuristicLab.CEDMA.Server/3.3/ServerForm.cs

    r1529 r1873  
    6363
    6464    private void connectButton_Click(object sender, EventArgs e) {
    65       dispatcher = new RandomDispatcher(store);
     65      dispatcher = new SimpleDispatcher(store);
    6666      executer = new Executer(dispatcher, store, gridAddress.Text);
    6767      executer.Start();

  • trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs

    r1857 r1873  
    3838
    3939namespace HeuristicLab.CEDMA.Server {
    40   public class RandomDispatcher : DispatcherBase {
     40  public class SimpleDispatcher : DispatcherBase {
    4141    private Random random;
    42     public RandomDispatcher(IStore store)
     42    private IStore store;
     43    private Dictionary<Entity, Dictionary<int, List<string>>> finishedAndDispatchedRuns;
     44
     45    public SimpleDispatcher(IStore store)
    4346      : base(store) {
     47      this.store = store;
    4448      random = new Random();
     49      finishedAndDispatchedRuns = new Dictionary<Entity, Dictionary<int, List<string>>>();
     50      PopulateFinishedRuns();
    4551    }
    4652
    47     public override IAlgorithm SelectAlgorithm(DataSet dataSet, int targetVariable, LearningTask learningTask) {
     53    public override IAlgorithm SelectAlgorithm(Entity dataSetEntity, int targetVariable, LearningTask learningTask) {
    4854      DiscoveryService ds = new DiscoveryService();
    4955      IAlgorithm[] algos = ds.GetInstances<IAlgorithm>();
     56      IAlgorithm selectedAlgorithm = null;
    5057      switch (learningTask) {
    5158        case LearningTask.Regression: {
    5259            var regressionAlgos = algos.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
    53             if (regressionAlgos.Count() == 0) return null;
    54             return regressionAlgos.ElementAt(random.Next(regressionAlgos.Count()));
     60            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, regressionAlgos) ?? ChooseStochastic(regressionAlgos);
     61            break;
    5562          }
    5663        case LearningTask.Classification: {
    5764            var classificationAlgos = algos.Where(a => (a as IClassificationAlgorithm) != null);
    58             if (classificationAlgos.Count() == 0) return null;
    59             return classificationAlgos.ElementAt(random.Next(classificationAlgos.Count()));
     65            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, classificationAlgos) ?? ChooseStochastic(classificationAlgos);
     66            break;
    6067          }
    6168        case LearningTask.TimeSeries: {
    6269            var timeSeriesAlgos = algos.Where(a => (a as ITimeSeriesAlgorithm) != null);
    63             if (timeSeriesAlgos.Count() == 0) return null;
    64             return timeSeriesAlgos.ElementAt(random.Next(timeSeriesAlgos.Count()));
     70            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, timeSeriesAlgos) ?? ChooseStochastic(timeSeriesAlgos);
     71            break;
    6572          }
    6673      }
    67       return null;
     74      if (selectedAlgorithm != null) {
     75        AddDispatchedRun(dataSetEntity, targetVariable, selectedAlgorithm.Name);
     76      }
     77      return selectedAlgorithm;
     78    }
     79
     80    private IAlgorithm ChooseDeterministic(Entity dataSetEntity, int targetVariable, IEnumerable<IAlgorithm> algos) {
     81      var deterministicAlgos = algos
     82        .Where(a => (a as IStochasticAlgorithm) == null)
     83        .Where(a => AlgorithmFinishedOrDispatched(dataSetEntity, targetVariable, a.Name) == false);
     84
     85      if (deterministicAlgos.Count() == 0) return null;
     86      return deterministicAlgos.ElementAt(random.Next(deterministicAlgos.Count()));
     87    }
     88
     89    private IAlgorithm ChooseStochastic(IEnumerable<IAlgorithm> regressionAlgos) {
     90      var stochasticAlgos = regressionAlgos.Where(a => (a as IStochasticAlgorithm) != null);
     91      if (stochasticAlgos.Count() == 0) return null;
     92      return stochasticAlgos.ElementAt(random.Next(stochasticAlgos.Count()));
    6893    }
    6994
    … …  
    7297    }
    7398
    74     public override int SelectTargetVariable(DataSet dataSet, int[] targetVariables) {
     99    public override int SelectTargetVariable(Entity dataSet, int[] targetVariables) {
    75100      return targetVariables[random.Next(targetVariables.Length)];
     101    }
     102
     103    private void PopulateFinishedRuns() {
     104      var result = store
     105        .Query("?DataSet <" + Ontology.PredicateInstanceOf.Uri + "> <" + Ontology.TypeDataSet.Uri + "> ." + Environment.NewLine +
     106        "?DataSet <" + Ontology.PredicateHasModel + "> ?Model ." + Environment.NewLine +
     107        "?Model <" + Ontology.TargetVariable + "> ?TargetVariable ." + Environment.NewLine +
     108        "?Model <" + Ontology.AlgorithmName + "> ?AlgoName .",
     109        0, 1000)
     110        .Select(x => new Resource[] { (Entity)x.Get("DataSet"), (Literal)x.Get("TargetVariable"), (Literal)x.Get("AlgoName") });
     111
     112      foreach (Resource[] row in result) {
     113        Entity dataset = (Entity)row[0];
     114        int targetVariable = (int)((Literal)row[1]).Value;
     115        string algoName = (string)((Literal)row[2]).Value;
     116        if (!AlgorithmFinishedOrDispatched(dataset, targetVariable, algoName))
     117          AddDispatchedRun(dataset, targetVariable, algoName);
     118      }
     119    }
     120
     121    private void AddDispatchedRun(Entity dataSetEntity, int targetVariable, string algoName) {
     122      if (!finishedAndDispatchedRuns.ContainsKey(dataSetEntity)) {
     123        finishedAndDispatchedRuns[dataSetEntity] = new Dictionary<int, List<string>>();
     124      }
     125      if (!finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable)) {
     126        finishedAndDispatchedRuns[dataSetEntity][targetVariable] = new List<string>();
     127      }
     128      finishedAndDispatchedRuns[dataSetEntity][targetVariable].Add(algoName);
     129    }
     130
     131    private bool AlgorithmFinishedOrDispatched(Entity dataSetEntity, int targetVariable, string algoName) {
     132      return
     133        finishedAndDispatchedRuns.ContainsKey(dataSetEntity) &&
     134        finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable) &&
     135        finishedAndDispatchedRuns[dataSetEntity][targetVariable].Contains(algoName);
    76136    }
    77137  }

  • trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLabGPClassificationPlugin.cs

    r1856 r1873  
    3434  [Dependency(Dependency = "HeuristicLab.GP-3.3")]
    3535  [Dependency(Dependency = "HeuristicLab.GP.StructureIdentification-3.3")]
    36   [Dependency(Dependency = "HeuristicLab.Modeling-3.3")]
     36  [Dependency(Dependency = "HeuristicLab.Modeling-3.2")]
    3737  [Dependency(Dependency = "HeuristicLab.Operators-3.2")]
    3838  [Dependency(Dependency = "HeuristicLab.Random-3.2")]

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/AlgorithmBase.cs

    r1857 r1873  
    136136      IOperator initialization = CreateInitialization();
    137137      IOperator funLibInjector = CreateFunctionLibraryInjector();
     138      IOperator treeEvaluatorInjector = new HL2TreeEvaluatorInjector();
     139
    138140      IOperator mainLoop = CreateMainLoop();
    139141      mainLoop.Name = "Main loop";
    … …  
    157159      seq.AddSubOperator(globalInjector);
    158160      seq.AddSubOperator(funLibInjector);
     161      seq.AddSubOperator(treeEvaluatorInjector);
    159162      seq.AddSubOperator(initialization);
    160163      seq.AddSubOperator(mainLoop);

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/ConfigurableFunctionLibraryInjector.cs

    r1540 r1873  
    2828using HeuristicLab.DataAnalysis;
    2929using HeuristicLab.Constraints;
    30 using StructId = HeuristicLab.GP.StructureIdentification;
    3130
    3231namespace HeuristicLab.GP.StructureIdentification {
    … …  
    6665      AddVariableInfo(new Core.VariableInfo(VARIABLES_ALLOWED, VARIABLES_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    6766      GetVariableInfo(VARIABLES_ALLOWED).Local = true;
    68       AddVariable(new Core.Variable(VARIABLES_ALLOWED,  new BoolData(true)));
     67      AddVariable(new Core.Variable(VARIABLES_ALLOWED, new BoolData(true)));
    6968
    7069      AddVariableInfo(new Core.VariableInfo(CONSTANTS_ALLOWED, CONSTANTS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    7170      GetVariableInfo(CONSTANTS_ALLOWED).Local = true;
    72       AddVariable(new Core.Variable(CONSTANTS_ALLOWED,  new BoolData(true)));
     71      AddVariable(new Core.Variable(CONSTANTS_ALLOWED, new BoolData(true)));
    7372
    7473      AddVariableInfo(new Core.VariableInfo(ADDITION_ALLOWED, ADDITION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    7574      GetVariableInfo(ADDITION_ALLOWED).Local = true;
    76       AddVariable(new Core.Variable(ADDITION_ALLOWED,  new BoolData(true)));
     75      AddVariable(new Core.Variable(ADDITION_ALLOWED, new BoolData(true)));
    7776
    7877      AddVariableInfo(new Core.VariableInfo(AVERAGE_ALLOWED, AVERAGE_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    7978      GetVariableInfo(AVERAGE_ALLOWED).Local = true;
    80       AddVariable(new Core.Variable(AVERAGE_ALLOWED,  new BoolData(true)));
     79      AddVariable(new Core.Variable(AVERAGE_ALLOWED, new BoolData(true)));
    8180
    8281      AddVariableInfo(new Core.VariableInfo(AND_ALLOWED, AND_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    8382      GetVariableInfo(AND_ALLOWED).Local = true;
    84       AddVariable(new Core.Variable(AND_ALLOWED,  new BoolData(true)));
     83      AddVariable(new Core.Variable(AND_ALLOWED, new BoolData(true)));
    8584
    8685      AddVariableInfo(new Core.VariableInfo(COSINUS_ALLOWED, COSINUS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    8786      GetVariableInfo(COSINUS_ALLOWED).Local = true;
    88       AddVariable(new Core.Variable(COSINUS_ALLOWED,  new BoolData(true)));
     87      AddVariable(new Core.Variable(COSINUS_ALLOWED, new BoolData(true)));
    8988
    9089      AddVariableInfo(new Core.VariableInfo(DIVISION_ALLOWED, DIVISION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    9190      GetVariableInfo(DIVISION_ALLOWED).Local = true;
    92       AddVariable(new Core.Variable(DIVISION_ALLOWED,  new BoolData(true)));
     91      AddVariable(new Core.Variable(DIVISION_ALLOWED, new BoolData(true)));
    9392
    9493      AddVariableInfo(new Core.VariableInfo(EQUAL_ALLOWED, EQUAL_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    9594      GetVariableInfo(EQUAL_ALLOWED).Local = true;
    96       AddVariable(new Core.Variable(EQUAL_ALLOWED,  new BoolData(true)));
     95      AddVariable(new Core.Variable(EQUAL_ALLOWED, new BoolData(true)));
    9796
    9897      AddVariableInfo(new Core.VariableInfo(EXPONENTIAL_ALLOWED, EXPONENTIAL_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    9998      GetVariableInfo(EXPONENTIAL_ALLOWED).Local = true;
    100       AddVariable(new Core.Variable(EXPONENTIAL_ALLOWED,  new BoolData(true)));
     99      AddVariable(new Core.Variable(EXPONENTIAL_ALLOWED, new BoolData(true)));
    101100
    102101      AddVariableInfo(new Core.VariableInfo(GREATERTHAN_ALLOWED, GREATERTHAN_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    103102      GetVariableInfo(GREATERTHAN_ALLOWED).Local = true;
    104       AddVariable(new Core.Variable(GREATERTHAN_ALLOWED,  new BoolData(true)));
     103      AddVariable(new Core.Variable(GREATERTHAN_ALLOWED, new BoolData(true)));
    105104
    106105      AddVariableInfo(new Core.VariableInfo(IFTHENELSE_ALLOWED, IFTHENELSE_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    107106      GetVariableInfo(IFTHENELSE_ALLOWED).Local = true;
    108       AddVariable(new Core.Variable(IFTHENELSE_ALLOWED,  new BoolData(true)));
     107      AddVariable(new Core.Variable(IFTHENELSE_ALLOWED, new BoolData(true)));
    109108
    110109      AddVariableInfo(new Core.VariableInfo(LESSTHAN_ALLOWED, LESSTHAN_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    111110      GetVariableInfo(LESSTHAN_ALLOWED).Local = true;
    112       AddVariable(new Core.Variable(LESSTHAN_ALLOWED,  new BoolData(true)));
     111      AddVariable(new Core.Variable(LESSTHAN_ALLOWED, new BoolData(true)));
    113112
    114113      AddVariableInfo(new Core.VariableInfo(LOGARTIHM_ALLOWED, LOGARTIHM_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    115114      GetVariableInfo(LOGARTIHM_ALLOWED).Local = true;
    116       AddVariable(new Core.Variable(LOGARTIHM_ALLOWED,  new BoolData(true)));
     115      AddVariable(new Core.Variable(LOGARTIHM_ALLOWED, new BoolData(true)));
    117116
    118117      AddVariableInfo(new Core.VariableInfo(MULTIPLICATION_ALLOWED, MULTIPLICATION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    119118      GetVariableInfo(MULTIPLICATION_ALLOWED).Local = true;
    120       AddVariable(new Core.Variable(MULTIPLICATION_ALLOWED,  new BoolData(true)));
     119      AddVariable(new Core.Variable(MULTIPLICATION_ALLOWED, new BoolData(true)));
    121120
    122121      AddVariableInfo(new Core.VariableInfo(NOT_ALLOWED, NOT_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    123122      GetVariableInfo(NOT_ALLOWED).Local = true;
    124       AddVariable(new Core.Variable(NOT_ALLOWED,  new BoolData(true)));
     123      AddVariable(new Core.Variable(NOT_ALLOWED, new BoolData(true)));
    125124
    126125      AddVariableInfo(new Core.VariableInfo(POWER_ALLOWED, POWER_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    127126      GetVariableInfo(POWER_ALLOWED).Local = true;
    128       AddVariable(new Core.Variable(POWER_ALLOWED,  new BoolData(true)));
     127      AddVariable(new Core.Variable(POWER_ALLOWED, new BoolData(true)));
    129128
    130129      AddVariableInfo(new Core.VariableInfo(OR_ALLOWED, OR_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    131130      GetVariableInfo(OR_ALLOWED).Local = true;
    132       AddVariable(new Core.Variable(OR_ALLOWED,  new BoolData(true)));
     131      AddVariable(new Core.Variable(OR_ALLOWED, new BoolData(true)));
    133132
    134133      AddVariableInfo(new Core.VariableInfo(SIGNUM_ALLOWED, SIGNUM_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    135134      GetVariableInfo(SIGNUM_ALLOWED).Local = true;
    136       AddVariable(new Core.Variable(SIGNUM_ALLOWED,  new BoolData(true)));
     135      AddVariable(new Core.Variable(SIGNUM_ALLOWED, new BoolData(true)));
    137136
    138137      AddVariableInfo(new Core.VariableInfo(SINUS_ALLOWED, SINUS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    139138      GetVariableInfo(SINUS_ALLOWED).Local = true;
    140       AddVariable(new Core.Variable(SINUS_ALLOWED,  new BoolData(true)));
     139      AddVariable(new Core.Variable(SINUS_ALLOWED, new BoolData(true)));
    141140
    142141      AddVariableInfo(new Core.VariableInfo(SQRT_ALLOWED, SQRT_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    … …  
    146145      AddVariableInfo(new Core.VariableInfo(SUBTRACTION_ALLOWED, SUBTRACTION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    147146      GetVariableInfo(SUBTRACTION_ALLOWED).Local = true;
    148       AddVariable(new Core.Variable(SUBTRACTION_ALLOWED,  new BoolData(true)));
     147      AddVariable(new Core.Variable(SUBTRACTION_ALLOWED, new BoolData(true)));
    149148
    150149      AddVariableInfo(new Core.VariableInfo(TANGENS_ALLOWED, TANGENS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    … …  
    154153      AddVariableInfo(new Core.VariableInfo(XOR_ALLOWED, XOR_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
    155154      GetVariableInfo(XOR_ALLOWED).Local = true;
    156       AddVariable(new Core.Variable(XOR_ALLOWED,  new BoolData(true)));
    157     }
    158 
    159     //public override IView CreateView() {
    160     //  return new ConfigurableFunctionLibraryInjectorView(this);
    161     //}
     155      AddVariable(new Core.Variable(XOR_ALLOWED, new BoolData(true)));
     156    }
    162157
    163158    public override IOperation Apply(IScope scope) {
    … …  
    180175      if (!((BoolData)GetVariable(DIVISION_ALLOWED).Value).Data)
    181176        functionLibrary.GPOperatorGroup.RemoveOperator(FindOperator(functionLibrary.GPOperatorGroup, typeof(Division)));
    182       if (!((BoolData)GetVariable(EQUAL_ALLOWED).Value).Data)                                                       
     177      if (!((BoolData)GetVariable(EQUAL_ALLOWED).Value).Data)
    183178        functionLibrary.GPOperatorGroup.RemoveOperator(FindOperator(functionLibrary.GPOperatorGroup, typeof(Equal)));
    184179      if (!((BoolData)GetVariable(EXPONENTIAL_ALLOWED).Value).Data)
    … …  
    212207      if (!((BoolData)GetVariable(XOR_ALLOWED).Value).Data)
    213208        functionLibrary.GPOperatorGroup.RemoveOperator(FindOperator(functionLibrary.GPOperatorGroup, typeof(Xor)));
    214 
    215 
    216209      return null;
    217210    }
    218211
    219     private IFunction FindOperator(GPOperatorGroup g, Type t)  {
     212    private IFunction FindOperator(GPOperatorGroup g, Type t) {
    220213      foreach (IFunction func in g.Operators)
    221214        if (func.GetType() == t)
    222215          return func;
    223216      return null;
    224   }
    225 
    226 
     217    }
    227218  }
    228219}

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.cs

    r1529 r1873  
    7474    protected virtual void SetDataBinding() {
    7575      setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", OffspringSelectionGP, "SetSeedRandomly");
    76       randomSeedTextBox.DataBindings.Add("Text", OffspringSelectionGP, "Seed");
     76      randomSeedTextBox.DataBindings.Add("Text", OffspringSelectionGP, "RandomSeed");
    7777      populationSizeTextBox.DataBindings.Add("Text", OffspringSelectionGP, "PopulationSize");
    7878      maximumEvaluatedSolutionsTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MaxEvaluatedSolutions");

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs

    r1857 r1873  
    142142
    143143    protected internal override IOperator CreateFunctionLibraryInjector() {
    144       return new FunctionLibraryInjector();
     144      ConfigurableFunctionLibraryInjector funLibInjector = new ConfigurableFunctionLibraryInjector();
     145      funLibInjector.GetVariableValue<BoolData>("Xor", null, false).Data = false;
     146      funLibInjector.GetVariableValue<BoolData>("Average", null, false).Data = false;
     147      return funLibInjector;
    145148    }
    146149

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.cs

    r1529 r1873  
    7373    protected virtual void SetDataBinding() {
    7474      setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", StandardGP, "SetSeedRandomly");
    75       randomSeedTextBox.DataBindings.Add("Text", StandardGP, "Seed");
     75      randomSeedTextBox.DataBindings.Add("Text", StandardGP, "RandomSeed");
    7676      populationSizeTextBox.DataBindings.Add("Text", StandardGP, "PopulationSize");
    7777      maximumGenerationsTextBox.DataBindings.Add("Text", StandardGP, "MaxGenerations");

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/TreeEvaluatorBase.cs

    r1836 r1873  
    124124    public override object Clone(IDictionary<Guid, object> clonedObjects) {
    125125      TreeEvaluatorBase clone = (TreeEvaluatorBase)base.Clone(clonedObjects);
    126       clone.dataset = (Dataset)dataset.Clone(clonedObjects);
     126      if (!clonedObjects.ContainsKey(dataset.Guid)) {
     127        clone.dataset = (Dataset)dataset.Clone(clonedObjects);
     128      } else {
     129        clone.dataset = (Dataset)clonedObjects[dataset.Guid];
     130      }
    127131      clone.estimatedValueMax = estimatedValueMax;
    128132      clone.estimatedValueMin = estimatedValueMin;

  • trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs

    r1869 r1873  
    140140      ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("Nu"));
    141141      ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("Cost"));
    142       ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("ValidationMSE"));
     142      ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("ValidationQuality"));
    143143      modelProcessor.AddSubOperator(collector);
    144144
    145145      BestSolutionStorer solStorer = new BestSolutionStorer();
    146       solStorer.GetVariableInfo("Quality").ActualName = "ValidationMSE";
     146      solStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
    147147      solStorer.GetVariableInfo("Maximization").Local = true;
    148148      solStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
    … …  
    201201      mseEvaluator.Name = p + "MseEvaluator";
    202202      mseEvaluator.GetVariableInfo("Values").ActualName = p + "Values";
    203       mseEvaluator.GetVariableInfo("MSE").ActualName = p + "MSE";
     203      mseEvaluator.GetVariableInfo("MSE").ActualName = p + "Quality";
    204204      SimpleR2Evaluator r2Evaluator = new SimpleR2Evaluator();
    205205      r2Evaluator.Name = p + "R2Evaluator";
Note: See TracChangeset for help on using the changeset viewer.