From d22e12f54da1587bc66baa9e2ccfe868119e138a Mon Sep 17 00:00:00 2001 From: Armin Wolf Date: Thu, 7 Sep 2017 19:39:55 +0200 Subject: [PATCH] =?UTF-8?q?f=C3=BCr=20heute=20Reicht=20es...?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Evaluation/EvaluateAlgorithms.java | 332 +++++++----------- .../PercentageErrorBasedMeasure.java | 82 +++++ .../Evaluation/ScaleDependentMeasure.java | 60 ++++ .../Evaluation/ScaledErrorBasedMeasure.java | 71 ++++ src/main/java/Presenter/Presenter.java | 2 +- 5 files changed, 333 insertions(+), 214 deletions(-) create mode 100644 src/main/java/Presenter/Evaluation/PercentageErrorBasedMeasure.java create mode 100644 src/main/java/Presenter/Evaluation/ScaleDependentMeasure.java create mode 100644 src/main/java/Presenter/Evaluation/ScaledErrorBasedMeasure.java diff --git a/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java b/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java index b49d38e..23d97c1 100644 --- a/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java +++ b/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java @@ -3,13 +3,11 @@ package Presenter.Evaluation; import Model.Interval; import Model.Line; import Model.LineModel; -import Model.Point; import Presenter.Algorithms.*; import Presenter.Generator.DatasetGenerator; import java.util.ArrayList; import java.util.LinkedList; -import java.util.List; import java.util.Observable; /** @@ -21,35 +19,8 @@ import java.util.Observable; */ public class EvaluateAlgorithms extends Observable { - private Double m; - private Double b; - private Integer iterationCount; - private LineModel arrangement; - private LinkedList lms; - private LinkedList rm; - private LinkedList ts; - - private LinkedList nodeLms; - private LinkedList nodeTs; - - private String[] lmsResult; - private String[] rmResult; - private String[] tsResult; - /* - ret.add(mse(errorValues).toString()); - ret.add(rmse(errorValues).toString()); - ret.add(mae(errorValues).toString()); - ret.add(mdae(errorValues).toString()); - - ret.add(mape(perrorValues).toString()); - ret.add(mdape(perrorValues).toString()); - ret.add(rmspe(perrorValues).toString()); - ret.add(rmdspe(perrorValues).toString()); - */ - private String[] names = {"MSE", "RMSE", "MAE", "MDAE", "MAPE", "MDAPE", "RMSPE", "RMDSPE"}; - private Thread lmsThread; private Thread rmThread; private Thread tsThread; @@ -58,105 +29,71 @@ public class EvaluateAlgorithms extends Observable { private Double[] rmRes = new Double[2]; private Double[] lmsRes = new Double[2]; - public EvaluateAlgorithms(Double m, Double b, Integer iterationCount) { - this.m = m; - this.b = b; - this.iterationCount = iterationCount; - } + private DatasetGenerator generator; - public EvaluateAlgorithms(){ - this.m = null; - this.b = null; - this.iterationCount = 1; + private String[][] names = {{"MSE", "RMSE", "MAE", "MDAE"}, {"MAPE", "MDAPE", "RMSPE", "RMDSPE"}}; + + //übergebene Parameter + private int type; + private int iterations; + private int alg; + + + public EvaluateAlgorithms(int type, int iterations, int alg){ + this.arrangement = new LineModel(); + generator = new DatasetGenerator(); + arrangement.setLines(generator.generateDataCloud()); + this.type = type; + this.iterations = iterations; + this.alg = alg; + + setChanged(); + String[] msg = {"eval-dataset-generated"}; + notifyObservers(msg); + + IntersectionCounter counter = new IntersectionCounter(); + counter.run(arrangement.getLines(), new Interval(-99999, 99999)); + counter.calculateIntersectionAbscissas(arrangement); } public void run() throws InterruptedException { + ArrayList result = new ArrayList<>(); - this.arrangement = new LineModel(); + switch (type){ + case 0: + for (int i=0;i(arrangement.getLines()); - rm = new LinkedList<>(arrangement.getLines()); - ts = new LinkedList<>(arrangement.getLines()); - nodeLms = new LinkedList<>(arrangement.getNodes()); - nodeTs = new LinkedList<>(arrangement.getNodes()); - - - - lmsThread = new Thread(() -> { - LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(lms, nodeLms); - lmsAlg.run(); - lmsAlg.getResult(); - List errors = sampsonError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception()); - List perrors = percentigeError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception()); - - lmsRes[0] = lmsAlg.getSlope(); - lmsRes[1] = lmsAlg.getyInterception(); - lmsResult = getResults(errors,perrors); - - }); - rmThread = new Thread(() -> { - RepeatedMedianEstimator rmAlg = new RepeatedMedianEstimator(rm); - rmAlg.run(); - rmAlg.getResult(); - List errors = sampsonError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception()); - List perrors = percentigeError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception()); - - rmRes[0] = rmAlg.getSlope(); - rmRes[1] = rmAlg.getyInterception(); - rmResult = getResults(errors,perrors); - }); - tsThread = new Thread(() -> { - TheilSenEstimator tsAlg = new TheilSenEstimator(ts, nodeTs); - tsAlg.run(); - tsAlg.getResult(); - List errors = sampsonError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception()); - List perrors = percentigeError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception()); - tsRes[0] = tsAlg.getSlope(); - tsRes[1] = tsAlg.getyInterception(); - tsResult = getResults(errors,perrors); - }); - - lmsThread.start(); - rmThread.start(); - tsThread.start(); - - lmsThread.join(); - rmThread.join(); - tsThread.join(); - - createGlobalResult(); + //der alg der gewählt wurde + if (alg == 0) { + startLMS(); + result = getScaleDependentMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]); + } else if (alg == 1) { + startRM(); + result = getScaleDependentMeasure(arrangement.getLines(), rmRes[0], rmRes[1]); + } else { + startTS(); + result = getScaleDependentMeasure(arrangement.getLines(), tsRes[0], tsRes[1]); + } + } + break; + case 1: + break; + } + //createGlobalResult(result); } - public void createGlobalResult(){ - ArrayList result = new ArrayList<>(); - for (int i=0;i result){ + ArrayList tableInput = new ArrayList<>(); + + for (int i=0;i { + LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(arrangement.getLines(), arrangement.getNodes()); + lmsAlg.run(); + lmsAlg.getResult(); + lmsRes[0] = lmsAlg.getSlope(); + lmsRes[1] = lmsAlg.getyInterception(); + }); + lmsThread.start(); + lmsThread.join(); + } - public String[] getResults(List errorValues, List perrorValues) { + public void startRM() throws InterruptedException { + rmThread = new Thread(() -> { + RepeatedMedianEstimator rmAlg = new RepeatedMedianEstimator(arrangement.getLines()); + rmAlg.run(); + rmAlg.getResult(); + rmRes[0] = rmAlg.getSlope(); + rmRes[1] = rmAlg.getyInterception(); + }); + rmThread.start(); + rmThread.join(); + } + public void startTS() throws InterruptedException { + tsThread = new Thread(() -> { + TheilSenEstimator tsAlg = new TheilSenEstimator(arrangement.getLines(), arrangement.getNodes()); + tsAlg.run(); + tsAlg.getResult(); + tsRes[0] = tsAlg.getSlope(); + tsRes[1] = tsAlg.getyInterception(); + }); + tsThread.start(); + tsThread.join(); + } + + + public ArrayList getScaleDependentMeasure(LinkedList lines, Double m, Double b) { + ScaleDependentMeasure scaleDependentMeasure = new ScaleDependentMeasure(lines, m, b); ArrayList ret = new ArrayList<>(); - ret.add(mse(errorValues).toString()); - ret.add(rmse(errorValues).toString()); - ret.add(mae(errorValues).toString()); - ret.add(mdae(errorValues).toString()); + ret.add(scaleDependentMeasure.mse().toString()); + ret.add(scaleDependentMeasure.rmse().toString()); + ret.add(scaleDependentMeasure.mae().toString()); + ret.add(scaleDependentMeasure.mdae().toString()); - ret.add(mape(perrorValues).toString()); - ret.add(mdape(perrorValues).toString()); - ret.add(rmspe(perrorValues).toString()); - ret.add(rmdspe(perrorValues).toString()); - - - return ret.stream().toArray(String[]::new); + return ret; } - /* Skalierungs Abhängige Approximationsgüten */ - public Double mse(List errorValues) { - double error = 0; - - for (Double d : errorValues) { - error += Math.pow(d, 2); - } - - error /= errorValues.size(); - - return error; + public ArrayList getPercentigeErrorBasedMeasure(LinkedList lines, Double m, Double b) { + PercentageErrorBasedMeasure percentageErrorBasedMeasure = new PercentageErrorBasedMeasure(lines, m, b); + ArrayList ret = new ArrayList<>(); + ret.add(percentageErrorBasedMeasure.mape().toString()); + ret.add(percentageErrorBasedMeasure.mdape().toString()); + ret.add(percentageErrorBasedMeasure.rmspe().toString()); + ret.add(percentageErrorBasedMeasure.rmdspe().toString()); + return ret; } - public Double rmse(List errorValues) { - return Math.sqrt(mse(errorValues)); - } - - public Double mae(List errorValues) { - double error = 0; - - for (Double d : errorValues) { - error += Math.abs(d); - } - - error /= errorValues.size(); - - return error; - } - - public Double mdae(List errorValues) { - return FastElementSelector.randomizedSelect((ArrayList) errorValues, errorValues.size() * 0.5); - } - - - /* Percentege Error Approximation Measures */ - public Double mape(List errorValues){ - return mae(errorValues); - } - - public Double mdape(List errorValues){ - return mape(errorValues); - } - - public Double rmspe(List errorValues){ - return rmse(errorValues); - } - - public Double rmdspe(List errorValues){ - ArrayList squares = new ArrayList(); - for (Double d : errorValues){ - squares.add(Math.pow(d,2)); - } - - return Math.sqrt(FastElementSelector.randomizedSelect(squares, squares.size() * 0.5)); - } - - - public List percentigeError(final LinkedList lines, Double m, Double b){ - ArrayList sampsonError = (ArrayList) sampsonError(lines, m, b); - ArrayList r = new ArrayList<>(); - - for (int j=0;j sampsonError(final LinkedList lines, Double m, Double b) { - - //Liste mit den Fehler zu jedem Punkt - List sampsonerror = new ArrayList<>(); - - for (Line line : lines) { - Double error = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m, 2) + 1); - sampsonerror.add(error); - } - - return sampsonerror; + public ArrayList getScaledErrorBasedMeasure(LinkedList lines, Double m, Double b){ + ScaledErrorBasedMeasure scaledErrorBasedMeasure = new ScaledErrorBasedMeasure(lines, m, b); + ArrayList ret = new ArrayList<>(); + ret.add(scaledErrorBasedMeasure.mse().toString()); + ret.add(scaledErrorBasedMeasure.rmse().toString()); + ret.add(scaledErrorBasedMeasure.mae().toString()); + ret.add(scaledErrorBasedMeasure.mdae().toString()); + return ret; } diff --git a/src/main/java/Presenter/Evaluation/PercentageErrorBasedMeasure.java b/src/main/java/Presenter/Evaluation/PercentageErrorBasedMeasure.java new file mode 100644 index 0000000..5323a53 --- /dev/null +++ b/src/main/java/Presenter/Evaluation/PercentageErrorBasedMeasure.java @@ -0,0 +1,82 @@ +package Presenter.Evaluation; + +import Model.Line; +import Presenter.Algorithms.FastElementSelector; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +/** + * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden. + * + * @Author: Armin Wolf + * @Email: a_wolf28@uni-muenster.de + * @Date: 07.09.2017. + */ +public class PercentageErrorBasedMeasure { + + + private ArrayList percentageError; + + public PercentageErrorBasedMeasure(final LinkedList lines, Double m, Double b){ + + ArrayList sampson = new ArrayList<>(); + + for (Line line : lines) { + Double e = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m, 2) + 1); + sampson.add(e); + } + + percentageError = new ArrayList<>(); + + for (int j=0;j abs = new ArrayList<>(); + + for (Double d : percentageError){ + abs.add(Math.abs(d)); + } + + return FastElementSelector.randomizedSelect(abs, abs.size() * 0.5); + } + + public Double rmspe(){ + double error = 0; + + for (Double d : percentageError) { + error += Math.pow(d, 2); + } + + error /= percentageError.size(); + + return Math.sqrt(error); + } + + public Double rmdspe(){ + ArrayList squares = new ArrayList(); + for (Double d : percentageError){ + squares.add(Math.pow(d,2)); + } + + return Math.sqrt(FastElementSelector.randomizedSelect(squares, squares.size() * 0.5)); + } +} diff --git a/src/main/java/Presenter/Evaluation/ScaleDependentMeasure.java b/src/main/java/Presenter/Evaluation/ScaleDependentMeasure.java new file mode 100644 index 0000000..00256db --- /dev/null +++ b/src/main/java/Presenter/Evaluation/ScaleDependentMeasure.java @@ -0,0 +1,60 @@ +package Presenter.Evaluation; + +import Model.Line; +import Presenter.Algorithms.FastElementSelector; +import java.util.ArrayList; +import java.util.LinkedList; + +/** + * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden. + * + * @Author: Armin Wolf + * @Email: a_wolf28@uni-muenster.de + * @Date: 07.09.2017. + */ +public class ScaleDependentMeasure { + + private ArrayList errorValues; + + public ScaleDependentMeasure(final LinkedList lines, Double m, Double b){ + //Liste mit den Fehler zu jedem Punkt + errorValues = new ArrayList<>(); + + for (Line line : lines) { + Double e = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m, 2) + 1); + errorValues.add(e); + } + } + + /* Skalierungs Abhängige Approximationsgüten */ + //unterschiedliche Alg.- auf einem Datensatz + public Double mse() { + double error = 0; + + for (Double d : errorValues) { + error += Math.pow(d, 2); + } + + error /= errorValues.size(); + + return error; + } + + public Double rmse() { + return Math.sqrt(mse()); + } + + public Double mae() { + double error = 0; + for (Double d : errorValues) { + error += Math.abs(d); + } + error /= errorValues.size(); + return error; + } + + public Double mdae() { + return FastElementSelector + .randomizedSelect(errorValues, errorValues.size() * 0.5); + } +} diff --git a/src/main/java/Presenter/Evaluation/ScaledErrorBasedMeasure.java b/src/main/java/Presenter/Evaluation/ScaledErrorBasedMeasure.java new file mode 100644 index 0000000..93a9bf3 --- /dev/null +++ b/src/main/java/Presenter/Evaluation/ScaledErrorBasedMeasure.java @@ -0,0 +1,71 @@ +package Presenter.Evaluation; + +import Model.Line; +import Presenter.Algorithms.FastElementSelector; +import java.util.ArrayList; +import java.util.LinkedList; + +/** + * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden. + * + * @Author: Armin Wolf + * @Email: a_wolf28@uni-muenster.de + * @Date: 07.09.2017. + */ +public class ScaledErrorBasedMeasure { + + + private ArrayList scaledError; + + public ScaledErrorBasedMeasure(final LinkedList lines, Double m, Double b){ + //Liste mit den Fehler zu jedem Punkt + ArrayList sampson = new ArrayList<>(); + + + Double denum = 0d; + for (int i=2;i{ try { - eval = new EvaluateAlgorithms(); + eval = new EvaluateAlgorithms(0,1,0); eval.addObserver(this); eval.run(); } catch (InterruptedException e) {