generalbgh/algorithms-for-computing-line-estimators
generalbgh
/
algorithms-for-computing-line-estimators
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

für heute Reicht es...

This commit is contained in:
Armin Wolf 2017-09-07 19:39:55 +02:00
parent a4b8a9f261
commit d22e12f54d
5 changed files with 333 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

332
src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java
View File

@ -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<Line> lms;
private LinkedList<Line> rm;
private LinkedList<Line> ts;
private LinkedList<Point> nodeLms;
private LinkedList<Point> 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<String> result = new ArrayList<>();
this.arrangement = new LineModel();
switch (type){
case 0:
for (int i=0;i<iterations;i++) {
DatasetGenerator generator;
if (m != null && b != null) {
generator = new DatasetGenerator(m, b);
} else {
generator = new DatasetGenerator();
}
arrangement.setLines(generator.generateDataCloud());
setChanged();
String[] msg = {"eval-dataset-generated"};
notifyObservers(msg);
IntersectionCounter counter = new IntersectionCounter();
counter.run(arrangement.getLines(), new Interval(-99999, 99999));
counter.calculateIntersectionAbscissas(arrangement);
lms = new LinkedList<>(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<Double> errors = sampsonError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception());
List<Double> 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<Double> errors = sampsonError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception());
List<Double> 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<Double> errors = sampsonError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception());
List<Double> 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<String> result = new ArrayList<>();
for (int i=0;i<names.length;i++){
result.add("eval");
result.add(names[i]);
result.add(tsResult[i]);
result.add(rmResult[i]);
result.add(lmsResult[i]);
public void createGlobalResult(ArrayList<String> result){
ArrayList<String> tableInput = new ArrayList<>();
for (int i=0;i<names[type].length;i++) {
tableInput.add("eval");
tableInput.add(names[type][i]);
tableInput.add(result.get(i));
setChanged();
notifyObservers(result.stream().toArray(String[]::new));
result.clear();
tableInput.clear();
}
String[] separator = {"eval", "", "", "", ""};
@ -170,116 +107,85 @@ public class EvaluateAlgorithms extends Observable {
//lms res
lines.add(lmsRes[0]+"");
lines.add(lmsRes[1]+"");
//rm res
lines.add(rmRes[0]+"");
lines.add(rmRes[1]+"");
//ts res
lines.add(tsRes[0]+"");
lines.add(tsRes[1]+"");
//
// //rm res
// lines.add(rmRes[0]+"");
// lines.add(rmRes[1]+"");
//
// //ts res
// lines.add(tsRes[0]+"");
// lines.add(tsRes[1]+"");
setChanged();
notifyObservers(lines.stream().toArray(String[]::new));
}
public void startLMS() throws InterruptedException {
lmsThread = new Thread(() -> {
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<Double> errorValues, List<Double> 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<String> getScaleDependentMeasure(LinkedList<Line> lines, Double m, Double b) {
ScaleDependentMeasure scaleDependentMeasure = new ScaleDependentMeasure(lines, m, b);
ArrayList<String> 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<Double> errorValues) {
double error = 0;
for (Double d : errorValues) {
error += Math.pow(d, 2);
}
error /= errorValues.size();
return error;
public ArrayList<String> getPercentigeErrorBasedMeasure(LinkedList<Line> lines, Double m, Double b) {
PercentageErrorBasedMeasure percentageErrorBasedMeasure = new PercentageErrorBasedMeasure(lines, m, b);
ArrayList<String> 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<Double> errorValues) {
return Math.sqrt(mse(errorValues));
}
public Double mae(List<Double> errorValues) {
double error = 0;
for (Double d : errorValues) {
error += Math.abs(d);
}
error /= errorValues.size();
return error;
}
public Double mdae(List<Double> errorValues) {
return FastElementSelector.randomizedSelect((ArrayList<Double>) errorValues, errorValues.size() * 0.5);
}
/* Percentege Error Approximation Measures */
public Double mape(List<Double> errorValues){
return mae(errorValues);
}
public Double mdape(List<Double> errorValues){
return mape(errorValues);
}
public Double rmspe(List<Double> errorValues){
return rmse(errorValues);
}
public Double rmdspe(List<Double> 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<Double> percentigeError(final LinkedList<Line> lines, Double m, Double b){
ArrayList<Double> sampsonError = (ArrayList<Double>) sampsonError(lines, m, b);
ArrayList<Double> r = new ArrayList<>();
for (int j=0;j<sampsonError.size();j++){
r.add(100 * sampsonError.get(j) / lines.get(j).getB());
}
return r;
}
public List<Double> sampsonError(final LinkedList<Line> lines, Double m, Double b) {
//Liste mit den Fehler zu jedem Punkt
List<Double> 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<String> getScaledErrorBasedMeasure(LinkedList<Line> lines, Double m, Double b){
ScaledErrorBasedMeasure scaledErrorBasedMeasure = new ScaledErrorBasedMeasure(lines, m, b);
ArrayList<String> 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;
}

82
src/main/java/Presenter/Evaluation/PercentageErrorBasedMeasure.java Normal file
View File

@ -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<Double> percentageError;
public PercentageErrorBasedMeasure(final LinkedList<Line> lines, Double m, Double b){
ArrayList<Double> 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<sampson.size();j++){
percentageError.add(100 * sampson.get(j) / lines.get(j).getB());
}
}
/* Percentege Error Approximation Measures */
//verschiedene Eingaben für einen Alg.
public Double mape(){
double error = 0;
for (Double d : percentageError) {
error += Math.abs(d);
}
error /= percentageError.size();
return error;
}
public Double mdape(){
ArrayList<Double> 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));
}
}

60
src/main/java/Presenter/Evaluation/ScaleDependentMeasure.java Normal file
View File

@ -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<Double> errorValues;
public ScaleDependentMeasure(final LinkedList<Line> 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);
}
}

71
src/main/java/Presenter/Evaluation/ScaledErrorBasedMeasure.java Normal file
View File

@ -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<Double> scaledError;
public ScaledErrorBasedMeasure(final LinkedList<Line> lines, Double m, Double b){
//Liste mit den Fehler zu jedem Punkt
ArrayList<Double> sampson = new ArrayList<>();
Double denum = 0d;
for (int i=2;i<lines.size();i++){
denum += Math.abs(lines.get(i).getM() - lines.get(i-1).getM());
}
denum *= 1/(lines.size() - 1);
for (Line line : lines) {
Double e = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m, 2) + 1);
sampson.add(e);
Double val = e / (denum);
scaledError.add(val);
}
}
/* Skalierungs Abhängige Approximationsgüten */
//unterschiedliche Alg.- auf einem Datensatz
public Double mse() {
double error = 0;
for (Double d : scaledError) {
error += Math.pow(d, 2);
}
error /= scaledError.size();
return error;
}
public Double rmse() {
return Math.sqrt(mse());
}
public Double mae() {
double error = 0;
for (Double d : scaledError) {
error += Math.abs(d);
}
error /= scaledError.size();
return error;
}
public Double mdae() {
return FastElementSelector
.randomizedSelect(scaledError, scaledError.size() * 0.5);
}
}

2
src/main/java/Presenter/Presenter.java
View File

@ -312,7 +312,7 @@ public class Presenter implements Observer {
if (evalThread == null || !evalThread.isAlive()){
evalThread = new Thread(() ->{
try {
eval = new EvaluateAlgorithms();
eval = new EvaluateAlgorithms(0,1,0);
eval.addObserver(this);
eval.run();
} catch (InterruptedException e) {