[17848] | 1 | using System;
|
---|
| 2 | using System.Collections.Generic;
|
---|
| 3 | using System.Linq;
|
---|
| 4 | using HEAL.Attic;
|
---|
| 5 | using HeuristicLab.Analysis;
|
---|
| 6 | using HeuristicLab.Common;
|
---|
| 7 | using HeuristicLab.Core;
|
---|
| 8 | using HeuristicLab.Data;
|
---|
| 9 | using HeuristicLab.Encodings.BinaryVectorEncoding;
|
---|
| 10 | using HeuristicLab.Encodings.RealVectorEncoding;
|
---|
| 11 | using HeuristicLab.Optimization;
|
---|
| 12 | using HeuristicLab.Parameters;
|
---|
| 13 | using HeuristicLab.Problems.DataAnalysis;
|
---|
| 14 | using HeuristicLab.Problems.Instances;
|
---|
| 15 |
|
---|
| 16 | namespace HeuristicLab.Algorithms.DataAnalysis.ContinuedFractionRegression {
|
---|
| 17 | [Item("Continued Fraction Regression (CFR)", "Attempts to find a continued fraction minimizing the regularized MSE / R^2 to given data.")]
|
---|
| 18 | [StorableType("CAC0F743-8524-436C-B81E-7C628A302DF8")]
|
---|
| 19 | [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 999)]
|
---|
| 20 | public class Problem : HeuristicLab.Optimization.SingleObjectiveBasicProblem<MultiEncoding>
|
---|
| 21 | /*, IProblemInstanceConsumer<IRegressionProblemData>, IProblemInstanceExporter<IRegressionProblemData>*/ // only if we can change the code to work with a single dataset
|
---|
| 22 | {
|
---|
| 23 | private const double epsilon = 1e-6;
|
---|
| 24 | enum Fitting { MSE, RegMSE, ElasticNet }
|
---|
| 25 | private readonly Fitting fit = Fitting.ElasticNet;
|
---|
| 26 |
|
---|
| 27 | #region parameter properties
|
---|
| 28 | public IFixedValueParameter<DoubleValue> L1L2MixingParameter {
|
---|
| 29 | get { return (IFixedValueParameter<DoubleValue>)Parameters["L1L2_mixing"]; }
|
---|
| 30 | }
|
---|
| 31 | public IFixedValueParameter<DoubleValue> L1L2WeightParameter {
|
---|
| 32 | get { return (IFixedValueParameter<DoubleValue>)Parameters["L1L2_weight"]; }
|
---|
| 33 | }
|
---|
| 34 | public IFixedValueParameter<DoubleValue> PenaltyParameter {
|
---|
| 35 | get { return (IFixedValueParameter<DoubleValue>)Parameters["penalty"]; }
|
---|
| 36 | }
|
---|
| 37 | public IFixedValueParameter<IntValue> FractionDepthParameter {
|
---|
| 38 | get { return (IFixedValueParameter<IntValue>)Parameters["fraction_depth"]; }
|
---|
| 39 | }
|
---|
| 40 | public IValueParameter<Dataset> DatasetParameter {
|
---|
| 41 | get { return (IValueParameter<Dataset>)Parameters["dataset"]; }
|
---|
| 42 | }
|
---|
| 43 | public IValueParameter<Dataset> TrainingTrainingDatasetParameter {
|
---|
| 44 | get { return (IValueParameter<Dataset>)Parameters["datasetTrainingTraining"]; }
|
---|
| 45 | }
|
---|
| 46 | public IValueParameter<Dataset> TrainingTestDatasetParameter {
|
---|
| 47 | get { return (IValueParameter<Dataset>)Parameters["datasetTrainingTest"]; }
|
---|
| 48 | }
|
---|
| 49 | public IValueParameter<Dataset> Phi0_08DatasetParameter {
|
---|
| 50 | get { return (IValueParameter<Dataset>)Parameters["data_phi_0_08"]; }
|
---|
| 51 | }
|
---|
| 52 | #endregion
|
---|
| 53 |
|
---|
| 54 | #region properties
|
---|
| 55 | public double L1L2Mixing {
|
---|
| 56 | get { return L1L2MixingParameter.Value.Value; }
|
---|
| 57 | set { L1L2MixingParameter.Value.Value = value; }
|
---|
| 58 | }
|
---|
| 59 | public double L1L2Weight {
|
---|
| 60 | get { return L1L2WeightParameter.Value.Value; }
|
---|
| 61 | set { L1L2WeightParameter.Value.Value = value; }
|
---|
| 62 | }
|
---|
| 63 | public double Penalty {
|
---|
| 64 | get { return PenaltyParameter.Value.Value; }
|
---|
| 65 | set { PenaltyParameter.Value.Value = value; }
|
---|
| 66 | }
|
---|
| 67 | public int FractionDepth {
|
---|
| 68 | get { return FractionDepthParameter.Value.Value; }
|
---|
| 69 | set { FractionDepthParameter.Value.Value = value; }
|
---|
| 70 | }
|
---|
| 71 | public Dataset Dataset {
|
---|
| 72 | get { return DatasetParameter.Value; }
|
---|
| 73 | set { DatasetParameter.Value = value; }
|
---|
| 74 | }
|
---|
| 75 | public Dataset TrainingTrainingDataset {
|
---|
| 76 | get { return TrainingTrainingDatasetParameter.Value; }
|
---|
| 77 | set { TrainingTrainingDatasetParameter.Value = value; }
|
---|
| 78 | }
|
---|
| 79 | public Dataset TrainingTestDataset {
|
---|
| 80 | get { return TrainingTestDatasetParameter.Value; }
|
---|
| 81 | set { TrainingTestDatasetParameter.Value = value; }
|
---|
| 82 | }
|
---|
| 83 | public Dataset Phi0_08Dataset {
|
---|
| 84 | get { return Phi0_08DatasetParameter.Value; }
|
---|
| 85 | set { Phi0_08DatasetParameter.Value = value; }
|
---|
| 86 | }
|
---|
| 87 | #endregion
|
---|
| 88 |
|
---|
| 89 |
|
---|
| 90 | public override bool Maximization { get { return false; } }
|
---|
| 91 |
|
---|
| 92 | public IRegressionProblemData ProblemData { get; set; }
|
---|
| 93 |
|
---|
| 94 | // BEWARE local fields
|
---|
| 95 | // DO NOT store or clone
|
---|
| 96 | // these variables are initialized on the first call of Evaluate.
|
---|
| 97 | // whenever a dataset parameter is changed (which has an effect on these variables)
|
---|
| 98 | // all variables must be cleared to ensure that they are recalculated on the next call of Evaluate
|
---|
| 99 | private DoubleMatrix dataMatrix; // data for training
|
---|
| 100 | private DoubleMatrix dataNelderMead; // data for optimizing coefficients
|
---|
| 101 | private DoubleMatrix dataMatrixTest; // data for testing
|
---|
| 102 | private Transformation transformation;
|
---|
| 103 | private double arithmeticMean;
|
---|
| 104 | private double SQT; //Sum of Squares Total, short: SQT
|
---|
| 105 | private void ClearLocalVariables() {
|
---|
| 106 | dataMatrix = null;
|
---|
| 107 | dataNelderMead = null;
|
---|
| 108 | dataMatrixTest = null;
|
---|
| 109 | transformation = null;
|
---|
| 110 | arithmeticMean = 0.0;
|
---|
| 111 | SQT = 0.0;
|
---|
| 112 | }
|
---|
| 113 | // END local fields
|
---|
| 114 |
|
---|
| 115 |
|
---|
| 116 | // cloning ctor
|
---|
| 117 | public Problem(Problem orig, Cloner cloner) : base(orig, cloner) {
|
---|
| 118 | }
|
---|
| 119 |
|
---|
| 120 | public Problem() : base() {
|
---|
| 121 | Parameters.Add(new FixedValueParameter<DoubleValue>("L1L2_mixing", "TODO Description", new DoubleValue(0.2)));
|
---|
| 122 | Parameters.Add(new FixedValueParameter<DoubleValue>("L1L2_weight", "TODO Description", new DoubleValue(1)));
|
---|
| 123 | Parameters.Add(new FixedValueParameter<DoubleValue>("penality", "TODO Description", new DoubleValue(0.01)));
|
---|
| 124 | Parameters.Add(new FixedValueParameter<IntValue>("fraction_depth", "TODO Description", new IntValue(4)));
|
---|
| 125 | Parameters.Add(new ValueParameter<Dataset>("dataset", "TODO Description", new Dataset()));
|
---|
| 126 | Parameters.Add(new ValueParameter<Dataset>("datasetTrainingTraining", "TODO Description", new Dataset()));
|
---|
| 127 | Parameters.Add(new ValueParameter<Dataset>("data_phi_0_08", "TODO Description", new Dataset()));
|
---|
| 128 | Parameters.Add(new ValueParameter<Dataset>("datasetTrainingTest", "TODO Description", new Dataset()));
|
---|
| 129 |
|
---|
| 130 | foreach (var temperature in new[] { 350, 375, 400, 425, 450, 475, 500 }) {
|
---|
| 131 | foreach (var phip in new[] { "0_001", "0_01", "0_1", "1" }) {
|
---|
| 132 | // TODO: refactor
|
---|
| 133 | Parameters.Add(new ValueParameter<Dataset>("data_" + temperature + "_" + phip, "TODO Description", new Dataset()));
|
---|
| 134 | }
|
---|
| 135 | }
|
---|
| 136 |
|
---|
| 137 | ClearLocalVariables();
|
---|
| 138 |
|
---|
| 139 | DatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 140 | TrainingTrainingDatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 141 | TrainingTestDatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 142 | Phi0_08DatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 143 |
|
---|
| 144 | UpdateEncoding();
|
---|
| 145 | }
|
---|
| 146 |
|
---|
[17849] | 147 | [StorableHook(HookType.AfterDeserialization)]
|
---|
| 148 | private void AfterDeserialization() {
|
---|
| 149 | DatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 150 | TrainingTrainingDatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 151 | TrainingTestDatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 152 | Phi0_08DatasetParameter.ValueChanged += DatasetParameter_ValueChanged;
|
---|
| 153 | }
|
---|
| 154 |
|
---|
[17848] | 155 | #region event handlers for clearing local variables whenever a dataset is changed
|
---|
| 156 | private void DatasetParameter_ValueChanged(object sender, EventArgs e) {
|
---|
| 157 | ClearLocalVariables();
|
---|
| 158 | UpdateEncoding();
|
---|
| 159 | }
|
---|
| 160 |
|
---|
| 161 | private void UpdateEncoding() {
|
---|
| 162 | int fraction_depth = FractionDepth;
|
---|
| 163 | int number_variables = Dataset.Columns;
|
---|
| 164 | int vector_length = (2 * fraction_depth - 1) * number_variables; //number of variables n because n-1 coefficients + 1 constant
|
---|
| 165 |
|
---|
| 166 | Encoding = new MultiEncoding()
|
---|
| 167 | .Add(new RealVectorEncoding("coeff", length: vector_length, min: -3, max: 3))
|
---|
| 168 | .Add(new BinaryVectorEncoding("binar", length: vector_length))
|
---|
| 169 | ;
|
---|
| 170 | }
|
---|
| 171 | #endregion
|
---|
| 172 |
|
---|
| 173 | public override IDeepCloneable Clone(Cloner cloner) {
|
---|
| 174 | return new Problem(this, cloner);
|
---|
| 175 | }
|
---|
| 176 |
|
---|
| 177 | public override double Evaluate(Individual individual, IRandom random) {
|
---|
| 178 | if(dataMatrix == null) {
|
---|
| 179 | InitializeTransformedDatasets();
|
---|
| 180 | }
|
---|
| 181 |
|
---|
| 182 | double LS = 0.0; //sum of squared residuals -> SQR = LS
|
---|
| 183 | double quality = 0.0;
|
---|
| 184 |
|
---|
| 185 | double[] coeff = individual.RealVector("coeff").ToArray();
|
---|
| 186 | bool[] binar = individual.BinaryVector("binar").ToArray();
|
---|
| 187 |
|
---|
| 188 | LS = calculateLS(coeff, binar, dataMatrix);
|
---|
| 189 | quality = calculateQuality(coeff, binar, LS);
|
---|
| 190 |
|
---|
| 191 | #region Nelder-Mead-Methode
|
---|
| 192 | double uniformPeturbation = 1.0;
|
---|
| 193 | double tolerance = 1e-3;
|
---|
| 194 | int maxEvals = 250;
|
---|
| 195 | int numSearches = 4;
|
---|
| 196 | int numPoints = dataMatrix.Rows / 5; // 20% of the training samples
|
---|
| 197 |
|
---|
| 198 | double[] optimizedCoeffShort = new double[numVariablesUsed(binar)];
|
---|
| 199 | double[] optimizedCoeffLong = new double[coeff.Length];
|
---|
| 200 |
|
---|
| 201 | for (int count = 0; count < numSearches; count++) {
|
---|
| 202 | int indexShort = 0;
|
---|
| 203 | for (int indexLong = 0; indexLong < coeff.Length; indexLong++) {
|
---|
| 204 | if (binar[indexLong] == true) {
|
---|
| 205 | optimizedCoeffShort[indexShort] = coeff[indexLong];
|
---|
| 206 | indexShort++;
|
---|
| 207 | }
|
---|
| 208 | }
|
---|
| 209 |
|
---|
| 210 | SimplexConstant[] constants = new SimplexConstant[numVariablesUsed(binar)];
|
---|
| 211 | for (int i = 0; i < numVariablesUsed(binar); i++) {
|
---|
| 212 | constants[i] = new SimplexConstant(optimizedCoeffShort[i], uniformPeturbation);
|
---|
| 213 | }
|
---|
| 214 |
|
---|
| 215 | //ObjFunctionNelderMead NelderMead = new ObjFunctionNelderMead(this, dataNelderMead, coeff, binar);
|
---|
| 216 | ObjFunctionNelderMead NelderMead = new ObjFunctionNelderMead(this, dataMatrix, numPoints, coeff, binar);
|
---|
| 217 |
|
---|
| 218 | ObjectiveFunctionDelegate objFunction = new ObjectiveFunctionDelegate(NelderMead.objFunctionNelderMead);
|
---|
| 219 | RegressionResult result = NelderMeadSimplex.Regress(constants, tolerance, maxEvals, objFunction);
|
---|
| 220 |
|
---|
| 221 | optimizedCoeffShort = result.Constants;
|
---|
| 222 | int shortIndex = 0;
|
---|
| 223 | for (int i = 0; i < coeff.Length; i++) {
|
---|
| 224 | if (binar[i] == true) {
|
---|
| 225 | optimizedCoeffLong[i] = optimizedCoeffShort[shortIndex];
|
---|
| 226 | shortIndex++;
|
---|
| 227 | } else {
|
---|
| 228 | optimizedCoeffLong[i] = coeff[i];
|
---|
| 229 | }
|
---|
| 230 | }
|
---|
| 231 |
|
---|
| 232 | double newLS = calculateLS(optimizedCoeffLong, binar, dataMatrix);
|
---|
| 233 | double newQuality = calculateQuality(optimizedCoeffLong, binar, newLS);
|
---|
| 234 |
|
---|
| 235 | if (newQuality < quality) {
|
---|
| 236 | // dont set new coeff!
|
---|
| 237 | individual["coeff"] = new RealVector(optimizedCoeffLong);
|
---|
| 238 | LS = newLS;
|
---|
| 239 | quality = newQuality;
|
---|
| 240 | }
|
---|
| 241 | }
|
---|
| 242 | #endregion
|
---|
| 243 |
|
---|
| 244 | //doubleThrowInvOrNaN(quality, "quality");
|
---|
| 245 | individual["LS"] = new DoubleValue(LS); //Least Squares - Sum of Squares Residual, short: SQR
|
---|
| 246 | individual["Depth"] = new DoubleValue(calculateDepth(coeff, binar));
|
---|
| 247 | individual["CoeffNumber"] = new DoubleValue((double)numVariablesUsed(binar));
|
---|
| 248 | individual["MSE"] = new DoubleValue(LS / dataMatrix.Rows);
|
---|
| 249 | individual["MSETest"] = new DoubleValue(0.0); // only calculated for the best solution in a generation (see Analyze())
|
---|
| 250 | individual["R2"] = new DoubleValue(1.0 - LS / SQT); //R^2 = 1 - SQR/SQT
|
---|
| 251 |
|
---|
| 252 | return quality;
|
---|
| 253 | }
|
---|
| 254 |
|
---|
| 255 | private void InitializeTransformedDatasets() {
|
---|
| 256 | //dataMatrix = new DoubleMatrix(this.createMatrix("dataset", 1000));
|
---|
| 257 | dataMatrix = new DoubleMatrix(TrainingTrainingDataset.ToArray(TrainingTrainingDataset.VariableNames, Enumerable.Range(0, TrainingTrainingDataset.Rows)));
|
---|
| 258 | dataNelderMead = new DoubleMatrix(Phi0_08Dataset.ToArray(Phi0_08Dataset.VariableNames, Enumerable.Range(0, Phi0_08Dataset.Rows)));
|
---|
| 259 | dataMatrixTest = new DoubleMatrix(TrainingTestDataset.ToArray(TrainingTestDataset.VariableNames, Enumerable.Range(0, TrainingTestDataset.Rows)));
|
---|
| 260 | //minMaxTransformation(0);
|
---|
| 261 | //minMaxTransformation(1);
|
---|
| 262 | //log10Transformation(2); // no negativ values!
|
---|
| 263 | //minMaxTransformation(2); // Min and Max have to be different!
|
---|
| 264 |
|
---|
| 265 | transformation = new Transformation(dataMatrix);
|
---|
| 266 | // vars["dataMatrix"] = dataMatrix;
|
---|
| 267 |
|
---|
| 268 | transformation.useSameTransformation(dataNelderMead);
|
---|
| 269 | // vars["dataNelderMead"] = dataNelderMead;
|
---|
| 270 |
|
---|
| 271 | transformation.useSameTransformation(dataMatrixTest);
|
---|
| 272 | // vars["dataMatrixTest"] = dataMatrixTest;
|
---|
| 273 |
|
---|
| 274 | arithmeticMean = calculateArithmeticMean();
|
---|
| 275 | SQT = calculateSQT(arithmeticMean);
|
---|
| 276 | }
|
---|
| 277 |
|
---|
| 278 | public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
|
---|
| 279 | // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
|
---|
| 280 | // Write or update results given the range of vectors and resulting qualities
|
---|
| 281 |
|
---|
| 282 | Individual bestIndividual = null;
|
---|
| 283 | double bestQuality = double.MaxValue;
|
---|
| 284 | int theBest = 0;
|
---|
| 285 |
|
---|
| 286 | for (int i = 0; i < qualities.Count(); i++) {
|
---|
| 287 | if (qualities[i] < bestQuality) {
|
---|
| 288 | bestQuality = qualities[i];
|
---|
| 289 | bestIndividual = individuals[i].Copy();
|
---|
| 290 | theBest = i;
|
---|
| 291 | }
|
---|
| 292 | }
|
---|
| 293 |
|
---|
| 294 | /*
|
---|
| 295 | // Uncomment the following lines if you want to retrieve the best individual
|
---|
| 296 | var orderedIndividuals = individuals.Zip(qualities, (i, q) => new { Individual = i, Quality = q }).OrderBy(z => z.Quality);
|
---|
| 297 | var best = Maximization ? orderedIndividuals.Last().Individual : orderedIndividuals.First().Individual;
|
---|
| 298 | if (!results.ContainsKey("Best Solution")) {
|
---|
| 299 | results.Add(new Result("Best Solution", typeof(RealVector)));
|
---|
| 300 |
|
---|
| 301 | }
|
---|
| 302 | results["Best Solution"].Value = (IItem)best.RealVector("coeff").Clone();
|
---|
| 303 | //
|
---|
| 304 | */
|
---|
| 305 |
|
---|
| 306 | bool[] binar = bestIndividual.BinaryVector("binar").ToArray();
|
---|
| 307 | double[] coeff = bestIndividual.RealVector("coeff").ToArray();
|
---|
| 308 |
|
---|
| 309 | // calculate and set test-MSE (only) for the individual with best training-MSE
|
---|
| 310 | double bestLSTest = calculateLS(coeff, binar, dataMatrixTest);
|
---|
| 311 | double bestQualityTest = calculateQuality(coeff, binar, bestLSTest);
|
---|
| 312 | individuals[theBest]["MSETest"] = new DoubleValue(bestQualityTest);
|
---|
| 313 |
|
---|
| 314 | InitDataTables(results);
|
---|
| 315 | InitScatterPlots(results);
|
---|
| 316 |
|
---|
| 317 | #region set dataTables
|
---|
| 318 | var datatable = (DataTable)results["datatable"].Value;
|
---|
| 319 | var coefficients = (DataTable)results["coefficients"].Value;
|
---|
| 320 | var pearsonR2 = (DataTable)results["personR2"].Value;
|
---|
| 321 |
|
---|
| 322 | datatable.Rows["MSE"].Values.Add(calculateRegMSE(((DoubleValue)bestIndividual["LS"]).Value, binar, 0.0));
|
---|
| 323 | datatable.Rows["RegMSE"].Values.Add(calculateRegMSE(((DoubleValue)bestIndividual["LS"]).Value, binar, Penalty));
|
---|
| 324 | datatable.Rows["ElasticNet"].Values.Add(calculateElasticNet(((DoubleValue)bestIndividual["LS"]).Value, coeff, binar));
|
---|
| 325 |
|
---|
| 326 | coefficients.Rows["Depth"].Values.Add(((DoubleValue)bestIndividual["Depth"]).Value);
|
---|
| 327 | coefficients.Rows["Number"].Values.Add(((DoubleValue)bestIndividual["CoeffNumber"]).Value);
|
---|
| 328 |
|
---|
| 329 | pearsonR2.Rows["R2"].Values.Add(((DoubleValue)bestIndividual["R2"]).Value);
|
---|
| 330 | #endregion
|
---|
| 331 |
|
---|
| 332 | #region set scatterPlots
|
---|
| 333 | var curves0_001 = (ScatterPlot)results["Curves0_001"].Value;
|
---|
| 334 | var curves0_01 = (ScatterPlot)results["Curves0_01"].Value;
|
---|
| 335 | var curves0_1 = (ScatterPlot)results["Curves0_1"].Value;
|
---|
| 336 | var curves1 = (ScatterPlot)results["Curves1"].Value;
|
---|
| 337 | #region curves 0.001
|
---|
| 338 | curves0_001.Rows["Temp350Convergence"].Points.Clear();
|
---|
| 339 | curves0_001.Rows["Temp375Convergence"].Points.Clear();
|
---|
| 340 | curves0_001.Rows["Temp400Convergence"].Points.Clear();
|
---|
| 341 | curves0_001.Rows["Temp425Convergence"].Points.Clear();
|
---|
| 342 | curves0_001.Rows["Temp450Convergence"].Points.Clear();
|
---|
| 343 | curves0_001.Rows["Temp475Convergence"].Points.Clear();
|
---|
| 344 | curves0_001.Rows["Temp500Convergence"].Points.Clear();
|
---|
| 345 | sampleCurve(curves0_001, "Temp350Convergence", coeff, binar, 350.0, 0.001, 100, 50.0);
|
---|
| 346 | sampleCurve(curves0_001, "Temp375Convergence", coeff, binar, 375.0, 0.001, 100, 50.0);
|
---|
| 347 | sampleCurve(curves0_001, "Temp400Convergence", coeff, binar, 400.0, 0.001, 100, 50.0);
|
---|
| 348 | sampleCurve(curves0_001, "Temp425Convergence", coeff, binar, 425.0, 0.001, 100, 50.0);
|
---|
| 349 | sampleCurve(curves0_001, "Temp450Convergence", coeff, binar, 450.0, 0.001, 100, 50.0);
|
---|
| 350 | sampleCurve(curves0_001, "Temp475Convergence", coeff, binar, 475.0, 0.001, 100, 50.0);
|
---|
| 351 | sampleCurve(curves0_001, "Temp500Convergence", coeff, binar, 500.0, 0.001, 100, 50.0);
|
---|
| 352 |
|
---|
| 353 | results.AddOrUpdateResult("Curves Phi' = 0.001", curves0_001);
|
---|
| 354 | #endregion
|
---|
| 355 | #region curves 0.01
|
---|
| 356 | curves0_01.Rows["Temp350Convergence"].Points.Clear();
|
---|
| 357 | curves0_01.Rows["Temp375Convergence"].Points.Clear();
|
---|
| 358 | curves0_01.Rows["Temp400Convergence"].Points.Clear();
|
---|
| 359 | curves0_01.Rows["Temp425Convergence"].Points.Clear();
|
---|
| 360 | curves0_01.Rows["Temp450Convergence"].Points.Clear();
|
---|
| 361 | curves0_01.Rows["Temp475Convergence"].Points.Clear();
|
---|
| 362 | curves0_01.Rows["Temp500Convergence"].Points.Clear();
|
---|
| 363 | sampleCurve(curves0_01, "Temp350Convergence", coeff, binar, 350.0, 0.01, 100, 60.0);
|
---|
| 364 | sampleCurve(curves0_01, "Temp375Convergence", coeff, binar, 375.0, 0.01, 100, 60.0);
|
---|
| 365 | sampleCurve(curves0_01, "Temp400Convergence", coeff, binar, 400.0, 0.01, 100, 60.0);
|
---|
| 366 | sampleCurve(curves0_01, "Temp425Convergence", coeff, binar, 425.0, 0.01, 100, 60.0);
|
---|
| 367 | sampleCurve(curves0_01, "Temp450Convergence", coeff, binar, 450.0, 0.01, 100, 60.0);
|
---|
| 368 | sampleCurve(curves0_01, "Temp475Convergence", coeff, binar, 475.0, 0.01, 100, 60.0);
|
---|
| 369 | sampleCurve(curves0_01, "Temp500Convergence", coeff, binar, 500.0, 0.01, 100, 60.0);
|
---|
| 370 |
|
---|
| 371 | results.AddOrUpdateResult("Curves Phi' = 0.01", curves0_01);
|
---|
| 372 | #endregion
|
---|
| 373 | #region curves 0.1
|
---|
| 374 | curves0_1.Rows["Temp350Convergence"].Points.Clear();
|
---|
| 375 | curves0_1.Rows["Temp375Convergence"].Points.Clear();
|
---|
| 376 | curves0_1.Rows["Temp400Convergence"].Points.Clear();
|
---|
| 377 | curves0_1.Rows["Temp425Convergence"].Points.Clear();
|
---|
| 378 | curves0_1.Rows["Temp450Convergence"].Points.Clear();
|
---|
| 379 | curves0_1.Rows["Temp475Convergence"].Points.Clear();
|
---|
| 380 | curves0_1.Rows["Temp500Convergence"].Points.Clear();
|
---|
| 381 | sampleCurve(curves0_1, "Temp350Convergence", coeff, binar, 350.0, 0.1, 100, 70.0);
|
---|
| 382 | sampleCurve(curves0_1, "Temp375Convergence", coeff, binar, 375.0, 0.1, 100, 70.0);
|
---|
| 383 | sampleCurve(curves0_1, "Temp400Convergence", coeff, binar, 400.0, 0.1, 100, 70.0);
|
---|
| 384 | sampleCurve(curves0_1, "Temp425Convergence", coeff, binar, 425.0, 0.1, 100, 70.0);
|
---|
| 385 | sampleCurve(curves0_1, "Temp450Convergence", coeff, binar, 450.0, 0.1, 100, 70.0);
|
---|
| 386 | sampleCurve(curves0_1, "Temp475Convergence", coeff, binar, 475.0, 0.1, 100, 70.0);
|
---|
| 387 | sampleCurve(curves0_1, "Temp500Convergence", coeff, binar, 500.0, 0.1, 100, 70.0);
|
---|
| 388 |
|
---|
| 389 | results.AddOrUpdateResult("Curves Phi' = 0.1", curves0_1);
|
---|
| 390 | #endregion
|
---|
| 391 | #region curves 1
|
---|
| 392 | curves1.Rows["Temp350Convergence"].Points.Clear();
|
---|
| 393 | curves1.Rows["Temp375Convergence"].Points.Clear();
|
---|
| 394 | curves1.Rows["Temp400Convergence"].Points.Clear();
|
---|
| 395 | curves1.Rows["Temp425Convergence"].Points.Clear();
|
---|
| 396 | curves1.Rows["Temp450Convergence"].Points.Clear();
|
---|
| 397 | curves1.Rows["Temp475Convergence"].Points.Clear();
|
---|
| 398 | curves1.Rows["Temp500Convergence"].Points.Clear();
|
---|
| 399 | sampleCurve(curves1, "Temp350Convergence", coeff, binar, 350.0, 1, 100, 80.0);
|
---|
| 400 | sampleCurve(curves1, "Temp375Convergence", coeff, binar, 375.0, 1, 100, 80.0);
|
---|
| 401 | sampleCurve(curves1, "Temp400Convergence", coeff, binar, 400.0, 1, 100, 80.0);
|
---|
| 402 | sampleCurve(curves1, "Temp425Convergence", coeff, binar, 425.0, 1, 100, 80.0);
|
---|
| 403 | sampleCurve(curves1, "Temp450Convergence", coeff, binar, 450.0, 1, 100, 80.0);
|
---|
| 404 | sampleCurve(curves1, "Temp475Convergence", coeff, binar, 475.0, 1, 100, 80.0);
|
---|
| 405 | sampleCurve(curves1, "Temp500Convergence", coeff, binar, 500.0, 1, 100, 80.0);
|
---|
| 406 |
|
---|
| 407 | results.AddOrUpdateResult("Curves Phi' = 1", curves1);
|
---|
| 408 | #endregion
|
---|
| 409 | #endregion
|
---|
| 410 | }
|
---|
| 411 |
|
---|
| 412 | private void InitDataTables(ResultCollection results) {
|
---|
| 413 | DataTable datatable, coefficients, pearsonR2;
|
---|
| 414 | if (!results.ContainsKey("Datatable")) {
|
---|
| 415 | datatable = new DataTable("Fitness");
|
---|
| 416 | DataRow MSE = new DataRow("MSE");
|
---|
| 417 | DataRow RegMSE = new DataRow("RegMSE");
|
---|
| 418 | DataRow ElasticNet = new DataRow("ElasticNet");
|
---|
| 419 | datatable.Rows.Add(MSE);
|
---|
| 420 | datatable.Rows.Add(RegMSE);
|
---|
| 421 | datatable.Rows.Add(ElasticNet);
|
---|
| 422 | results.Add(new Result("Datatable", datatable));
|
---|
| 423 | }
|
---|
| 424 |
|
---|
| 425 |
|
---|
| 426 | if (!results.ContainsKey("Coefficients")) {
|
---|
| 427 | coefficients = new DataTable("Coefficients");
|
---|
| 428 | DataRow Depth = new DataRow("Depth");
|
---|
| 429 | DataRow Number = new DataRow("Number");
|
---|
| 430 | coefficients.Rows.Add(Depth);
|
---|
| 431 | coefficients.Rows.Add(Number);
|
---|
| 432 | results.Add(new Result("Coefficients", coefficients));
|
---|
| 433 | }
|
---|
| 434 |
|
---|
| 435 | if (!results.ContainsKey("Pearson R2")) {
|
---|
| 436 | pearsonR2 = new DataTable("PearsonR2");
|
---|
| 437 | DataRow R2 = new DataRow("R2");
|
---|
| 438 | pearsonR2.Rows.Add(R2);
|
---|
| 439 | results.Add(new Result("Pearson R2", pearsonR2));
|
---|
| 440 | }
|
---|
| 441 | }
|
---|
| 442 |
|
---|
| 443 | private void InitScatterPlots(ResultCollection results) {
|
---|
| 444 | #region curves 0.001
|
---|
| 445 | ScatterPlot curves0_001 = new ScatterPlot("Curves0_001", "Kurven mit Phi'=0.001");
|
---|
| 446 | readCurve(curves0_001, "data6082_350_0_001", "Temp350", System.Drawing.Color.Blue);
|
---|
| 447 | readCurve(curves0_001, "data6082_375_0_001", "Temp375", System.Drawing.Color.Orange);
|
---|
| 448 | readCurve(curves0_001, "data6082_400_0_001", "Temp400", System.Drawing.Color.Red);
|
---|
| 449 | readCurve(curves0_001, "data6082_425_0_001", "Temp425", System.Drawing.Color.Green);
|
---|
| 450 | readCurve(curves0_001, "data6082_450_0_001", "Temp450", System.Drawing.Color.Gray);
|
---|
| 451 | readCurve(curves0_001, "data6082_475_0_001", "Temp475", System.Drawing.Color.Olive);
|
---|
| 452 | readCurve(curves0_001, "data6082_500_0_001", "Temp500", System.Drawing.Color.Gold);
|
---|
| 453 |
|
---|
| 454 | var empty0_001 = new Point2D<double>[0];
|
---|
| 455 | ScatterPlotDataRow Temp350Convergence0_001 = new ScatterPlotDataRow("Temp350Convergence", "Temp350Convergence", empty0_001);
|
---|
| 456 | Temp350Convergence0_001.VisualProperties.Color = System.Drawing.Color.Blue;
|
---|
| 457 | Temp350Convergence0_001.VisualProperties.PointSize = 2;
|
---|
| 458 | curves0_001.Rows.Add(Temp350Convergence0_001);
|
---|
| 459 |
|
---|
| 460 | ScatterPlotDataRow Temp375Convergence0_001 = new ScatterPlotDataRow("Temp375Convergence", "Temp375Convergence", empty0_001);
|
---|
| 461 | Temp375Convergence0_001.VisualProperties.Color = System.Drawing.Color.Orange;
|
---|
| 462 | Temp375Convergence0_001.VisualProperties.PointSize = 2;
|
---|
| 463 | curves0_001.Rows.Add(Temp375Convergence0_001);
|
---|
| 464 |
|
---|
| 465 | ScatterPlotDataRow Temp400Convergence0_001 = new ScatterPlotDataRow("Temp400Convergence", "Temp400Convergence", empty0_001);
|
---|
| 466 | Temp400Convergence0_001.VisualProperties.Color = System.Drawing.Color.Red;
|
---|
| 467 | Temp400Convergence0_001.VisualProperties.PointSize = 2;
|
---|
| 468 | curves0_001.Rows.Add(Temp400Convergence0_001);
|
---|
| 469 |
|
---|
| 470 | ScatterPlotDataRow Temp425Convergence0_001 = new ScatterPlotDataRow("Temp425Convergence", "Temp425Convergence", empty0_001);
|
---|
| 471 | Temp425Convergence0_001.VisualProperties.Color = System.Drawing.Color.Green;
|
---|
| 472 | Temp425Convergence0_001.VisualProperties.PointSize = 2;
|
---|
| 473 | curves0_001.Rows.Add(Temp425Convergence0_001);
|
---|
| 474 |
|
---|
| 475 | ScatterPlotDataRow Temp450Convergence0_001 = new ScatterPlotDataRow("Temp450Convergence", "Temp450Convergence", empty0_001);
|
---|
| 476 | Temp450Convergence0_001.VisualProperties.Color = System.Drawing.Color.Gray;
|
---|
| 477 | Temp450Convergence0_001.VisualProperties.PointSize = 2;
|
---|
| 478 | curves0_001.Rows.Add(Temp450Convergence0_001);
|
---|
| 479 |
|
---|
| 480 | ScatterPlotDataRow Temp475Convergence0_001 = new ScatterPlotDataRow("Temp475Convergence", "Temp475Convergence", empty0_001);
|
---|
| 481 | Temp475Convergence0_001.VisualProperties.Color = System.Drawing.Color.Olive;
|
---|
| 482 | Temp475Convergence0_001.VisualProperties.PointSize = 2;
|
---|
| 483 | curves0_001.Rows.Add(Temp475Convergence0_001);
|
---|
| 484 |
|
---|
| 485 | ScatterPlotDataRow Temp500Convergence0_001 = new ScatterPlotDataRow("Temp500Convergence", "Temp500Convergence", empty0_001);
|
---|
| 486 | Temp500Convergence0_001.VisualProperties.Color = System.Drawing.Color.Gold;
|
---|
| 487 | Temp500Convergence0_001.VisualProperties.PointSize = 2;
|
---|
| 488 | curves0_001.Rows.Add(Temp500Convergence0_001);
|
---|
| 489 | results.Add(new Result("Curves0_001", curves0_001));
|
---|
| 490 |
|
---|
| 491 | #endregion
|
---|
| 492 | #region curves 0.01
|
---|
| 493 | ScatterPlot curves0_01 = new ScatterPlot("Curves0_01", "Kurven mit Phi'=0.01");
|
---|
| 494 | readCurve(curves0_01, "data6082_350_0_01", "Temp350", System.Drawing.Color.Blue);
|
---|
| 495 | readCurve(curves0_01, "data6082_375_0_01", "Temp375", System.Drawing.Color.Orange);
|
---|
| 496 | readCurve(curves0_01, "data6082_400_0_01", "Temp400", System.Drawing.Color.Red);
|
---|
| 497 | readCurve(curves0_01, "data6082_425_0_01", "Temp425", System.Drawing.Color.Green);
|
---|
| 498 | readCurve(curves0_01, "data6082_450_0_01", "Temp450", System.Drawing.Color.Gray);
|
---|
| 499 | readCurve(curves0_01, "data6082_475_0_01", "Temp475", System.Drawing.Color.Olive);
|
---|
| 500 | readCurve(curves0_01, "data6082_500_0_01", "Temp500", System.Drawing.Color.Gold);
|
---|
| 501 |
|
---|
| 502 | var empty0_01 = new Point2D<double>[0];
|
---|
| 503 | ScatterPlotDataRow Temp350Convergence0_01 = new ScatterPlotDataRow("Temp350Convergence", "Temp350Convergence", empty0_01);
|
---|
| 504 | Temp350Convergence0_01.VisualProperties.Color = System.Drawing.Color.Blue;
|
---|
| 505 | Temp350Convergence0_01.VisualProperties.PointSize = 2;
|
---|
| 506 | curves0_01.Rows.Add(Temp350Convergence0_01);
|
---|
| 507 |
|
---|
| 508 | ScatterPlotDataRow Temp375Convergence0_01 = new ScatterPlotDataRow("Temp375Convergence", "Temp375Convergence", empty0_01);
|
---|
| 509 | Temp375Convergence0_01.VisualProperties.Color = System.Drawing.Color.Orange;
|
---|
| 510 | Temp375Convergence0_01.VisualProperties.PointSize = 2;
|
---|
| 511 | curves0_01.Rows.Add(Temp375Convergence0_01);
|
---|
| 512 |
|
---|
| 513 | ScatterPlotDataRow Temp400Convergence0_01 = new ScatterPlotDataRow("Temp400Convergence", "Temp400Convergence", empty0_01);
|
---|
| 514 | Temp400Convergence0_01.VisualProperties.Color = System.Drawing.Color.Red;
|
---|
| 515 | Temp400Convergence0_01.VisualProperties.PointSize = 2;
|
---|
| 516 | curves0_01.Rows.Add(Temp400Convergence0_01);
|
---|
| 517 |
|
---|
| 518 | ScatterPlotDataRow Temp425Convergence0_01 = new ScatterPlotDataRow("Temp425Convergence", "Temp425Convergence", empty0_01);
|
---|
| 519 | Temp425Convergence0_01.VisualProperties.Color = System.Drawing.Color.Green;
|
---|
| 520 | Temp425Convergence0_01.VisualProperties.PointSize = 2;
|
---|
| 521 | curves0_01.Rows.Add(Temp425Convergence0_01);
|
---|
| 522 |
|
---|
| 523 | ScatterPlotDataRow Temp450Convergence0_01 = new ScatterPlotDataRow("Temp450Convergence", "Temp450Convergence", empty0_01);
|
---|
| 524 | Temp450Convergence0_01.VisualProperties.Color = System.Drawing.Color.Gray;
|
---|
| 525 | Temp450Convergence0_01.VisualProperties.PointSize = 2;
|
---|
| 526 | curves0_01.Rows.Add(Temp450Convergence0_01);
|
---|
| 527 |
|
---|
| 528 | ScatterPlotDataRow Temp475Convergence0_01 = new ScatterPlotDataRow("Temp475Convergence", "Temp475Convergence", empty0_01);
|
---|
| 529 | Temp475Convergence0_01.VisualProperties.Color = System.Drawing.Color.Olive;
|
---|
| 530 | Temp475Convergence0_01.VisualProperties.PointSize = 2;
|
---|
| 531 | curves0_01.Rows.Add(Temp475Convergence0_01);
|
---|
| 532 |
|
---|
| 533 | ScatterPlotDataRow Temp500Convergence0_01 = new ScatterPlotDataRow("Temp500Convergence", "Temp500Convergence", empty0_01);
|
---|
| 534 | Temp500Convergence0_01.VisualProperties.Color = System.Drawing.Color.Gold;
|
---|
| 535 | Temp500Convergence0_01.VisualProperties.PointSize = 2;
|
---|
| 536 | curves0_01.Rows.Add(Temp500Convergence0_01);
|
---|
| 537 | results.Add(new Result("Curves0_01", curves0_01));
|
---|
| 538 |
|
---|
| 539 | #endregion
|
---|
| 540 | #region curves 0.1
|
---|
| 541 | ScatterPlot curves0_1 = new ScatterPlot("Curves0_1", "Kurven mit Phi'=0.1");
|
---|
| 542 | readCurve(curves0_1, "data6082_350_0_1", "Temp350", System.Drawing.Color.Blue);
|
---|
| 543 | readCurve(curves0_1, "data6082_375_0_1", "Temp375", System.Drawing.Color.Orange);
|
---|
| 544 | readCurve(curves0_1, "data6082_400_0_1", "Temp400", System.Drawing.Color.Red);
|
---|
| 545 | readCurve(curves0_1, "data6082_425_0_1", "Temp425", System.Drawing.Color.Green);
|
---|
| 546 | readCurve(curves0_1, "data6082_450_0_1", "Temp450", System.Drawing.Color.Gray);
|
---|
| 547 | readCurve(curves0_1, "data6082_475_0_1", "Temp475", System.Drawing.Color.Olive);
|
---|
| 548 | readCurve(curves0_1, "data6082_500_0_1", "Temp500", System.Drawing.Color.Gold);
|
---|
| 549 |
|
---|
| 550 | var empty0_1 = new Point2D<double>[0];
|
---|
| 551 | ScatterPlotDataRow Temp350Convergence0_1 = new ScatterPlotDataRow("Temp350Convergence", "Temp350Convergence", empty0_1);
|
---|
| 552 | Temp350Convergence0_1.VisualProperties.Color = System.Drawing.Color.Blue;
|
---|
| 553 | Temp350Convergence0_1.VisualProperties.PointSize = 2;
|
---|
| 554 | curves0_1.Rows.Add(Temp350Convergence0_1);
|
---|
| 555 |
|
---|
| 556 | ScatterPlotDataRow Temp375Convergence0_1 = new ScatterPlotDataRow("Temp375Convergence", "Temp375Convergence", empty0_1);
|
---|
| 557 | Temp375Convergence0_1.VisualProperties.Color = System.Drawing.Color.Orange;
|
---|
| 558 | Temp375Convergence0_1.VisualProperties.PointSize = 2;
|
---|
| 559 | curves0_1.Rows.Add(Temp375Convergence0_1);
|
---|
| 560 |
|
---|
| 561 | ScatterPlotDataRow Temp400Convergence0_1 = new ScatterPlotDataRow("Temp400Convergence", "Temp400Convergence", empty0_1);
|
---|
| 562 | Temp400Convergence0_1.VisualProperties.Color = System.Drawing.Color.Red;
|
---|
| 563 | Temp400Convergence0_1.VisualProperties.PointSize = 2;
|
---|
| 564 | curves0_1.Rows.Add(Temp400Convergence0_1);
|
---|
| 565 |
|
---|
| 566 | ScatterPlotDataRow Temp425Convergence0_1 = new ScatterPlotDataRow("Temp425Convergence", "Temp425Convergence", empty0_1);
|
---|
| 567 | Temp425Convergence0_1.VisualProperties.Color = System.Drawing.Color.Green;
|
---|
| 568 | Temp425Convergence0_1.VisualProperties.PointSize = 2;
|
---|
| 569 | curves0_1.Rows.Add(Temp425Convergence0_1);
|
---|
| 570 |
|
---|
| 571 | ScatterPlotDataRow Temp450Convergence0_1 = new ScatterPlotDataRow("Temp450Convergence", "Temp450Convergence", empty0_1);
|
---|
| 572 | Temp450Convergence0_1.VisualProperties.Color = System.Drawing.Color.Gray;
|
---|
| 573 | Temp450Convergence0_1.VisualProperties.PointSize = 2;
|
---|
| 574 | curves0_1.Rows.Add(Temp450Convergence0_1);
|
---|
| 575 |
|
---|
| 576 | ScatterPlotDataRow Temp475Convergence0_1 = new ScatterPlotDataRow("Temp475Convergence", "Temp475Convergence", empty0_1);
|
---|
| 577 | Temp475Convergence0_1.VisualProperties.Color = System.Drawing.Color.Olive;
|
---|
| 578 | Temp475Convergence0_1.VisualProperties.PointSize = 2;
|
---|
| 579 | curves0_1.Rows.Add(Temp475Convergence0_1);
|
---|
| 580 |
|
---|
| 581 | ScatterPlotDataRow Temp500Convergence0_1 = new ScatterPlotDataRow("Temp500Convergence", "Temp500Convergence", empty0_1);
|
---|
| 582 | Temp500Convergence0_1.VisualProperties.Color = System.Drawing.Color.Gold;
|
---|
| 583 | Temp500Convergence0_1.VisualProperties.PointSize = 2;
|
---|
| 584 | curves0_1.Rows.Add(Temp500Convergence0_1);
|
---|
| 585 | results.Add(new Result("Curves0_1", curves0_1));
|
---|
| 586 | #endregion
|
---|
| 587 | #region curves 1
|
---|
| 588 | ScatterPlot curves1 = new ScatterPlot("Curves1", "Kurven mit Phi'=1");
|
---|
| 589 | readCurve(curves1, "data6082_350_1", "Temp350", System.Drawing.Color.Blue);
|
---|
| 590 | readCurve(curves1, "data6082_375_1", "Temp375", System.Drawing.Color.Orange);
|
---|
| 591 | readCurve(curves1, "data6082_400_1", "Temp400", System.Drawing.Color.Red);
|
---|
| 592 | readCurve(curves1, "data6082_425_1", "Temp425", System.Drawing.Color.Green);
|
---|
| 593 | readCurve(curves1, "data6082_450_1", "Temp450", System.Drawing.Color.Gray);
|
---|
| 594 | readCurve(curves1, "data6082_475_1", "Temp475", System.Drawing.Color.Olive);
|
---|
| 595 | readCurve(curves1, "data6082_500_1", "Temp500", System.Drawing.Color.Gold);
|
---|
| 596 |
|
---|
| 597 | var empty1 = new Point2D<double>[0];
|
---|
| 598 | ScatterPlotDataRow Temp350Convergence1 = new ScatterPlotDataRow("Temp350Convergence", "Temp350Convergence", empty1);
|
---|
| 599 | Temp350Convergence1.VisualProperties.Color = System.Drawing.Color.Blue;
|
---|
| 600 | Temp350Convergence1.VisualProperties.PointSize = 2;
|
---|
| 601 | curves1.Rows.Add(Temp350Convergence1);
|
---|
| 602 |
|
---|
| 603 | ScatterPlotDataRow Temp375Convergence1 = new ScatterPlotDataRow("Temp375Convergence", "Temp375Convergence", empty1);
|
---|
| 604 | Temp375Convergence1.VisualProperties.Color = System.Drawing.Color.Orange;
|
---|
| 605 | Temp375Convergence1.VisualProperties.PointSize = 2;
|
---|
| 606 | curves1.Rows.Add(Temp375Convergence1);
|
---|
| 607 |
|
---|
| 608 | ScatterPlotDataRow Temp400Convergence1 = new ScatterPlotDataRow("Temp400Convergence", "Temp400Convergence", empty1);
|
---|
| 609 | Temp400Convergence1.VisualProperties.Color = System.Drawing.Color.Red;
|
---|
| 610 | Temp400Convergence1.VisualProperties.PointSize = 2;
|
---|
| 611 | curves1.Rows.Add(Temp400Convergence1);
|
---|
| 612 |
|
---|
| 613 | ScatterPlotDataRow Temp425Convergence1 = new ScatterPlotDataRow("Temp425Convergence", "Temp425Convergence", empty1);
|
---|
| 614 | Temp425Convergence1.VisualProperties.Color = System.Drawing.Color.Green;
|
---|
| 615 | Temp425Convergence1.VisualProperties.PointSize = 2;
|
---|
| 616 | curves1.Rows.Add(Temp425Convergence1);
|
---|
| 617 |
|
---|
| 618 | ScatterPlotDataRow Temp450Convergence1 = new ScatterPlotDataRow("Temp450Convergence", "Temp450Convergence", empty1);
|
---|
| 619 | Temp450Convergence1.VisualProperties.Color = System.Drawing.Color.Gray;
|
---|
| 620 | Temp450Convergence1.VisualProperties.PointSize = 2;
|
---|
| 621 | curves1.Rows.Add(Temp450Convergence1);
|
---|
| 622 |
|
---|
| 623 | ScatterPlotDataRow Temp475Convergence1 = new ScatterPlotDataRow("Temp475Convergence", "Temp475Convergence", empty1);
|
---|
| 624 | Temp475Convergence1.VisualProperties.Color = System.Drawing.Color.Olive;
|
---|
| 625 | Temp475Convergence1.VisualProperties.PointSize = 2;
|
---|
| 626 | curves1.Rows.Add(Temp475Convergence1);
|
---|
| 627 |
|
---|
| 628 | ScatterPlotDataRow Temp500Convergence1 = new ScatterPlotDataRow("Temp500Convergence", "Temp500Convergence", empty1);
|
---|
| 629 | Temp500Convergence1.VisualProperties.Color = System.Drawing.Color.Gold;
|
---|
| 630 | Temp500Convergence1.VisualProperties.PointSize = 2;
|
---|
| 631 | curves1.Rows.Add(Temp500Convergence1);
|
---|
| 632 | results.Add(new Result("Curves1", curves1));
|
---|
| 633 | #endregion
|
---|
| 634 | }
|
---|
| 635 |
|
---|
| 636 | public override IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
|
---|
| 637 | // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
|
---|
| 638 | // Create new vectors, based on the given one that represent small changes
|
---|
| 639 | // This method is only called from move-based algorithms (Local Search, Simulated Annealing, etc.)
|
---|
| 640 | while (true) {
|
---|
| 641 | // Algorithm will draw only a finite amount of samples
|
---|
| 642 | // Change to a for-loop to return a concrete amount of neighbors
|
---|
| 643 | var neighbor = individual.Copy();
|
---|
| 644 | // For instance, perform a single bit-flip in a binary parameter
|
---|
| 645 | //var bIndex = random.Next(neighbor.BinaryVector("b").Length);
|
---|
| 646 | //neighbor.BinaryVector("b")[bIndex] = !neighbor.BinaryVector("b")[bIndex];
|
---|
| 647 | yield return neighbor;
|
---|
| 648 | }
|
---|
| 649 | }
|
---|
| 650 | #region Import & Export
|
---|
| 651 | public void Load(IRegressionProblemData data) {
|
---|
| 652 | ProblemData = data;
|
---|
| 653 | }
|
---|
| 654 |
|
---|
| 655 | public IRegressionProblemData Export() {
|
---|
| 656 | return ProblemData;
|
---|
| 657 | }
|
---|
| 658 | #endregion
|
---|
| 659 |
|
---|
| 660 | // Implement further classes and methods
|
---|
| 661 |
|
---|
| 662 | private int numVariablesUsed(bool[] binar) {
|
---|
| 663 | int num = 0;
|
---|
| 664 | for (int i = 0; i < binar.Count(); i++) {
|
---|
| 665 | if (binar[i] == true) // eventually we need coeff < valuenearzero too
|
---|
| 666 | num++;
|
---|
| 667 | }
|
---|
| 668 | return num;
|
---|
| 669 | }
|
---|
| 670 |
|
---|
| 671 |
|
---|
| 672 | /* old code
|
---|
| 673 | private double[,] createMatrix(string name, int numRows) {
|
---|
| 674 | var dataset = (HeuristicLab.Problems.DataAnalysis.Dataset)vars[name];
|
---|
| 675 |
|
---|
| 676 | IEnumerable<string> variables = dataset.VariableNames;
|
---|
| 677 | // var rows = dataset.Rows;
|
---|
| 678 | var rows = Enumerable.Range(0, numRows).ToArray();
|
---|
| 679 |
|
---|
| 680 | double[,] dataMatrix = dataset.ToArray(variables, rows);
|
---|
| 681 |
|
---|
| 682 | return dataMatrix;
|
---|
| 683 | }
|
---|
| 684 | */
|
---|
| 685 |
|
---|
| 686 |
|
---|
| 687 | private double evaluateContinuedFraction(double[] coeff, bool[] binar, double[] dataPoint) {
|
---|
| 688 | double value = 0.0;
|
---|
| 689 | bool firstCoeffUnequalZero = false;
|
---|
| 690 |
|
---|
| 691 | for (var i = coeff.Count() - 1; i > 0; i = i - 2 * dataPoint.Count()) {
|
---|
| 692 |
|
---|
| 693 | if ((linearFunctionEqualZero(coeff, binar, i - dataPoint.Count() + 1, i) == false)) {
|
---|
| 694 | firstCoeffUnequalZero = true;
|
---|
| 695 | value = this.evaluateLinearFunction(coeff, binar, i - dataPoint.Count() + 1, i, dataPoint) + value;
|
---|
| 696 | }
|
---|
| 697 |
|
---|
| 698 | if (firstCoeffUnequalZero == true && i > 2 * dataPoint.Count()) { // don't take the first coeffVecPart and don't take the last coeffVecPart (both are only to add)
|
---|
| 699 | if (linearFunctionEqualZero(coeff, binar, i - 2 * dataPoint.Count() + 1, i - dataPoint.Count()) == false) {
|
---|
| 700 | if (valueNearZero(value) == true) // no division by zero
|
---|
| 701 | return double.MaxValue;
|
---|
| 702 | else
|
---|
| 703 | value = this.evaluateLinearFunction(coeff, binar, i - 2 * dataPoint.Count() + 1, i - dataPoint.Count(), dataPoint) / value;
|
---|
| 704 | } else return double.MaxValue; // don't allow coeffVecParts in middle to be equal zero
|
---|
| 705 | }
|
---|
| 706 | }
|
---|
| 707 |
|
---|
| 708 | //doubleThrowInvOrNaN(value, "evaluateContinuedFractionValue");
|
---|
| 709 | return value;
|
---|
| 710 | }
|
---|
| 711 |
|
---|
| 712 | private bool linearFunctionEqualZero(double[] coeff, bool[] binar, int start, int end) {
|
---|
| 713 | for (int i = start; i <= end; i++) {
|
---|
| 714 | if (binar[i] == true && valueNearZero(coeff[i]) == false)
|
---|
| 715 | return false;
|
---|
| 716 | }
|
---|
| 717 | return true;
|
---|
| 718 | }
|
---|
| 719 |
|
---|
| 720 | private double evaluateLinearFunction(double[] coeff, bool[] binar, int start, int end, double[] dataPoint) {
|
---|
| 721 | double value = 0.0;
|
---|
| 722 |
|
---|
| 723 | for (int i = start; i < end; i++) {
|
---|
| 724 | if (binar[i] == true)
|
---|
| 725 | value += dataPoint[i - start] * coeff[i];
|
---|
| 726 | }
|
---|
| 727 | if (binar[end] == true)
|
---|
| 728 | value += coeff[end];
|
---|
| 729 |
|
---|
| 730 | //doubleThrowInvOrNaN(value, "evaluateLinearFunctionValue");
|
---|
| 731 | return value;
|
---|
| 732 | }
|
---|
| 733 |
|
---|
| 734 | private bool valueNearZero(double value) {
|
---|
| 735 | if (Math.Abs(value) < epsilon)
|
---|
| 736 | return true;
|
---|
| 737 | else
|
---|
| 738 | return false;
|
---|
| 739 | }
|
---|
| 740 |
|
---|
| 741 | private double calculateDepth(double[] coeff, bool[] binar) {
|
---|
| 742 | int coeffUnequalZero = -1;
|
---|
| 743 | double depth = 0.0;
|
---|
| 744 |
|
---|
| 745 | for (int i = 0; i < coeff.Count(); i++) {
|
---|
| 746 | if (valueNearZero(coeff[i]) == false && binar[i] == true)
|
---|
| 747 | coeffUnequalZero = i;
|
---|
| 748 | }
|
---|
| 749 | if (coeffUnequalZero == -1) return 0.0; // equal zero
|
---|
| 750 | if (coeffUnequalZero < dataMatrix.Columns) return 1.0; // linear function
|
---|
| 751 | depth = (double)(coeffUnequalZero - dataMatrix.Columns + 1);
|
---|
| 752 | depth = Math.Ceiling(depth / (2 * dataMatrix.Columns)) + 1.0;
|
---|
| 753 | return depth;
|
---|
| 754 | }
|
---|
| 755 |
|
---|
| 756 | private double calculateRegMSE(double quality, bool[] binar, double penalty) {
|
---|
| 757 | return (quality / dataMatrix.Rows) * (1 + penalty * (double)numVariablesUsed(binar));
|
---|
| 758 | }
|
---|
| 759 |
|
---|
| 760 | private double calculateElasticNet(double quality, double[] coeff, bool[] binar) {
|
---|
| 761 | double valueL1 = 0.0;
|
---|
| 762 | double valueL2 = 0.0;
|
---|
| 763 | double elasticNet = 0.0;
|
---|
| 764 | double L1L2weight = L1L2Weight;
|
---|
| 765 | double L1L2mixing = L1L2Mixing;
|
---|
| 766 |
|
---|
| 767 | for (int i = 0; i < coeff.Count(); i++) {
|
---|
| 768 | if (binar[i] == true) {
|
---|
| 769 | valueL1 += Math.Abs(coeff[i]);
|
---|
| 770 | valueL2 += Math.Pow(coeff[i], 2);
|
---|
| 771 | }
|
---|
| 772 | }
|
---|
| 773 | elasticNet = quality + (L1L2weight * L1L2mixing * valueL1) + (L1L2weight * (1 - L1L2mixing) * valueL2);
|
---|
| 774 | return elasticNet / dataMatrix.Rows;
|
---|
| 775 | }
|
---|
| 776 |
|
---|
| 777 | public double calculateLS(double[] coeff, bool[] binar, DoubleMatrix dataMatrix) {
|
---|
| 778 | double LS = 0.0;
|
---|
| 779 | double[] dataPoint = new double[dataMatrix.Columns];
|
---|
| 780 | for (var i = 0; i < dataMatrix.Rows; i++) {
|
---|
| 781 | for (var j = 0; j < dataMatrix.Columns; j++) {
|
---|
| 782 | dataPoint[j] = dataMatrix[i, j];
|
---|
| 783 | }
|
---|
| 784 | double continuedFractionValue = evaluateContinuedFraction(coeff, binar, dataPoint);
|
---|
| 785 | if (continuedFractionValue == double.MaxValue)
|
---|
| 786 | return double.MaxValue;
|
---|
| 787 | else
|
---|
| 788 | LS += Math.Pow((continuedFractionValue - dataMatrix[i, dataMatrix.Columns - 1]), 2);
|
---|
| 789 | }
|
---|
| 790 | return LS;
|
---|
| 791 | }
|
---|
| 792 |
|
---|
| 793 | public double calculateQuality(double[] coeff, bool[] binar, double LS) {
|
---|
| 794 | switch (fit) {
|
---|
| 795 | case Fitting.MSE:
|
---|
| 796 | return calculateRegMSE(LS, binar, 0.0); //MSE
|
---|
| 797 | case Fitting.RegMSE:
|
---|
| 798 | return calculateRegMSE(LS, binar, Penalty); //RegMSE
|
---|
| 799 | case Fitting.ElasticNet:
|
---|
| 800 | return calculateElasticNet(LS, coeff, binar); // Elastic Net
|
---|
| 801 | default:
|
---|
| 802 | return calculateElasticNet(LS, coeff, binar);
|
---|
| 803 | }
|
---|
| 804 | }
|
---|
| 805 |
|
---|
| 806 | private double calculateArithmeticMean() {
|
---|
| 807 | double arithmeticMean = 0.0;
|
---|
| 808 | for (int i = 0; i < dataMatrix.Rows; i++) {
|
---|
| 809 | arithmeticMean = arithmeticMean + dataMatrix[i, dataMatrix.Columns - 1];
|
---|
| 810 | }
|
---|
| 811 | return arithmeticMean / dataMatrix.Rows;
|
---|
| 812 | }
|
---|
| 813 |
|
---|
| 814 | private double calculateSQT(double arithmeticMean) {
|
---|
| 815 | double SQT = 0.0;
|
---|
| 816 | for (int i = 0; i < dataMatrix.Rows; i++) {
|
---|
| 817 | SQT += Math.Pow((dataMatrix[i, dataMatrix.Columns - 1] - arithmeticMean), 2);
|
---|
| 818 | }
|
---|
| 819 | return SQT;
|
---|
| 820 | }
|
---|
| 821 |
|
---|
| 822 | private static void doubleThrowInvOrNaN(double value, string valueName) {
|
---|
| 823 | if (double.IsInfinity(value) || double.IsNaN(value))
|
---|
| 824 | throw new InvalidProgramException(valueName + " is Infinity or NaN");
|
---|
| 825 | }
|
---|
| 826 |
|
---|
| 827 |
|
---|
| 828 | private void readCurve(ScatterPlot scatterPlot, string matrixName, string RowName, System.Drawing.Color color) {
|
---|
| 829 | var ds = ((IValueParameter<Dataset>)Parameters[matrixName]).Value;
|
---|
| 830 | DoubleMatrix dataMatrix = new DoubleMatrix(ds.ToArray(ds.VariableNames, Enumerable.Range(0, ds.Rows))); // TODO: performance / refactoring
|
---|
| 831 | var points = new Point2D<double>[dataMatrix.Rows];
|
---|
| 832 | for (int i = 0; i < dataMatrix.Rows; i++) {
|
---|
| 833 | points[i] = new Point2D<double>(dataMatrix[i, 1], dataMatrix[i, 3]);
|
---|
| 834 | }
|
---|
| 835 | ScatterPlotDataRow Curve = new ScatterPlotDataRow(RowName, RowName, points);
|
---|
| 836 | Curve.VisualProperties.Color = color;
|
---|
| 837 | scatterPlot.Rows.Add(Curve);
|
---|
| 838 | }
|
---|
| 839 |
|
---|
| 840 | private void sampleCurve(ScatterPlot scatterPlot, string scatterPlotDataRow, double[] coeff, bool[] binar, double temp, double phip, int subdivisions, double maxStress) {
|
---|
| 841 | var points = new Point2D<double>[subdivisions + 1];
|
---|
| 842 | double phiMin = 0.0;
|
---|
| 843 | double phiMax = 0.70;
|
---|
| 844 | double step = (phiMax - phiMin) / subdivisions; // subdivisions > 0 !
|
---|
| 845 | double minStress = 0.0;
|
---|
| 846 |
|
---|
| 847 | double[] dataPoint = new double[3] { temp, 0.0, phip };
|
---|
| 848 | //vars["sample0"] = new DoubleArray(dataPoint);
|
---|
| 849 | double[] dataPointNew = new double[4];
|
---|
| 850 | double x = 0.0;
|
---|
| 851 | //scatterPlot.Rows[scatterPlotDataRow].Points.Clear();
|
---|
| 852 | for (int i = 0; i <= subdivisions; i++) {
|
---|
| 853 | x = phiMin + (double)i * step;
|
---|
| 854 | dataPoint[0] = temp;
|
---|
| 855 | dataPoint[1] = x;
|
---|
| 856 | dataPoint[2] = phip;
|
---|
| 857 | //vars["sample1"] = new DoubleArray(dataPoint);
|
---|
| 858 | dataPoint = transformation.transform0(dataPoint);
|
---|
| 859 | //vars["sample2"] = new DoubleArray(dataPoint);
|
---|
| 860 | dataPointNew[0] = dataPoint[0];
|
---|
| 861 | dataPointNew[1] = dataPoint[1];
|
---|
| 862 | dataPointNew[2] = dataPoint[2];
|
---|
| 863 | dataPointNew[3] = 0.0;
|
---|
| 864 | points[i] = new Point2D<double>(x, evaluateContinuedFraction(coeff, binar, dataPointNew));
|
---|
| 865 | if (points[i].Y >= minStress && points[i].Y <= maxStress) {
|
---|
| 866 | scatterPlot.Rows[scatterPlotDataRow].Points.Add(points[i]);
|
---|
| 867 | }
|
---|
| 868 | }
|
---|
| 869 | //scatterPlot.Rows[ScatterPlotDataRow].Point2D.Add(points);
|
---|
| 870 | }
|
---|
| 871 | }
|
---|
| 872 | }
|
---|
| 873 |
|
---|