Bugfixed smile classifiers + mark features + wind deviation penalty

improvement
This commit is contained in:
Vladislav Chumak committed 2018-09-08 01:53:29 +02:00
1 parent 39306f2c03
commit 2685ef282e
26 files changed
+225 -66

No files matched your search

@@ -32,7 +32,7 @@ public class ManeuverTypeGraphBasedWindEstimatorImpl
List<CompetitorTrackWithEstimationData<ManeuverForEstimation>> transformedCompetitorTracks = maneuverForEstimationTransformer
.transform(filteredCompetitorTracks);
ManeuverTypeSequenceGraph maneuverGraph = new ManeuverTypeSequenceGraph(transformedCompetitorTracks,
new ManeuverClassifiersCache(60000, false, getPolarService()), new ManeuverNodeBestPathsCalculator());
new ManeuverClassifiersCache(60000, false, true, getPolarService()), new ManeuverNodeBestPathsCalculator());
return maneuverGraph.estimateWindTrack();
}
@@ -32,7 +32,7 @@ public class PointOfSailGraphBasedWindEstimatorImpl
List<CompetitorTrackWithEstimationData<ManeuverForEstimation>> transformedCompetitorTracks = maneuverForEstimationTransformer
.transform(filteredCompetitorTracks);
PointOfSailSequenceGraph maneuverGraph = new PointOfSailSequenceGraph(transformedCompetitorTracks,
new ManeuverClassifiersCache(60000, false, getPolarService()), new BestPathsCalculator());
new ManeuverClassifiersCache(60000, false, true, getPolarService()), new BestPathsCalculator());
return maneuverGraph.estimateWindTrack();
}
@@ -61,8 +61,8 @@ public class CompleteManeuverCurveWithEstimationDataImporter {
private final ManeuverForDataAnalysisJsonSerializer maneuverForDataAnalysisJsonSerializer;
private final ManeuverForEstimationJsonSerializer maneuverForEstimationJsonSerializer;
private boolean skipRace = true;
private final String startFromRegattaName = "WCS 2018 Hyeres - Laser";
private final String startFromRegattaRace = "R4 (Laser)";
private final String startFromRegattaName = "KW 2016 International - 29er";
private final String startFromRegattaRace = "F4 Silver (29er)";
public CompleteManeuverCurveWithEstimationDataImporter() throws UnknownHostException {
this.completeManeuverCurvePersistanceManager = new RaceWithCompleteManeuverCurvePersistenceManager();
@@ -1,5 +1,6 @@
package com.sap.sailing.windestimation.maneuverclassifier;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
@@ -9,8 +10,9 @@ import com.sap.sailing.windestimation.data.ManeuverCategory;
import com.sap.sailing.windestimation.data.ManeuverForEstimation;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
public abstract class AbstractManeuverClassifier implements ManeuverClassifier, SingleManeuverClassifier {
public abstract class AbstractManeuverClassifier implements SingleManeuverClassifier, Serializable {
private static final long serialVersionUID = 908308394572292148L;
private final ManeuverFeatures maneuverFeatures;
private final BoatClass boatClass;
private final int[] supportedManeuverTypesMapping;
@@ -1,4 +1,4 @@
package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
package com.sap.sailing.windestimation.maneuverclassifier;
public class ClassifierPersistenceException extends Exception {
@@ -71,21 +71,30 @@ public class ClassifierScoring {
}
str.append("AVG");
double avgStatisticValue = statisticValueSum / supportedManeuverTypesCount;
str.append(String.format("%.03f | ", avgStatisticValue));
str.append(String.format(" %.03f | ", avgStatisticValue));
return avgStatisticValue;
}
private double recall(int tp, int fn) {
if (tp + fn == 0) {
return 0;
}
return 1.0 * tp / (tp + fn);
}
private double precision(int tp, int fp) {
if (tp + fp == 0) {
return 0;
}
return 1.0 * tp / (tp + fp);
}
private double f1score(int tp, int fp, int fn) {
double p = precision(tp, fp);
double r = recall(tp, fn);
if (p + r == 0) {
return 0;
}
return 2.0 * (p * r) / (p + r);
}
@@ -6,7 +6,6 @@ import java.util.List;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.ClassifierPersistenceException;
public class ManeuverClassifierLoader {
@@ -1,16 +1,24 @@
package com.sap.sailing.windestimation.maneuverclassifier;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.json.simple.parser.ParseException;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.domain.polars.PolarDataService;
import com.sap.sailing.server.gateway.deserialization.JsonDeserializationException;
import com.sap.sailing.windestimation.data.ManeuverForEstimation;
import com.sap.sailing.windestimation.data.persistence.PolarDataServiceAccessUtil;
import com.sap.sailing.windestimation.data.persistence.RegularManeuversForEstimationPersistenceManager;
import com.sap.sailing.windestimation.data.persistence.TransformedManeuversPersistenceManager;
import com.sap.sailing.windestimation.maneuverclassifier.impl.MLUtil;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.util.LoggingUtil;
import com.sap.sse.common.Util.Pair;
public class ManeuverClassifierTrainer {
private static final double TRAIN_TEST_SPLIT_RATIO = 0.8;
@@ -18,6 +26,8 @@ public class ManeuverClassifierTrainer {
private final TransformedManeuversPersistenceManager<ManeuverForEstimation> persistenceManager;
private final PolarDataService polarService;
private List<ManeuverForEstimation> allManeuvers;
private Map<Pair<String, ManeuverFeatures>, List<ManeuverForEstimation>> maneuversPerBoatClass = new HashMap<>();
public ManeuverClassifierTrainer(TransformedManeuversPersistenceManager<ManeuverForEstimation> persistenceManager,
PolarDataService polarService) {
@@ -29,13 +39,10 @@ public class ManeuverClassifierTrainer {
LoggingUtil.logInfo("Connecting to MongoDB");
persistenceManager.createIfNotExistsCollectionWithTransformedManeuvers();
LoggingUtil.logInfo("Querying train dataset...");
BoatClass boatClass = classifier.getBoatClass();
Long fixesCountForBoatClass = polarService.getFixCountPerBoatClass().get(boatClass);
String query = null;
if (boatClass != null) {
query = "{\"boatClass\" : {$eq: \"" + boatClass.getName() + "\"}}";
}
List<ManeuverForEstimation> maneuvers = persistenceManager.getAllElements(query);
Long fixesCountForBoatClass = classifier.getBoatClass() == null ? null
: polarService.getFixCountPerBoatClass().get(classifier.getBoatClass());
List<ManeuverForEstimation> maneuvers = getSuitableManeuvers(classifier.getManeuverFeatures(),
classifier.getBoatClass());
LoggingUtil.logInfo("Queried " + maneuvers.size() + " maneuvers");
if (maneuvers.size() < MIN_MANEUVERS_COUNT) {
LoggingUtil.logInfo("Not enough maneuver data for training. Training aborted!");
@@ -53,7 +60,6 @@ public class ManeuverClassifierTrainer {
LoggingUtil.logInfo("Preparing test data...");
List<ManeuverForEstimation> testManeuvers = maneuvers.subList(splitFromIndex, maneuvers.size());
maneuvers = persistenceManager.getAllElements(query);
LoggingUtil.logInfo("Validating on test dataset with " + testManeuvers.size() + " maneuvers...");
printScoring = classifierScoring.printScoring(testManeuvers);
LoggingUtil.logInfo("Test score:\n" + printScoring);
@@ -66,27 +72,51 @@ public class ManeuverClassifierTrainer {
}
}
private List<ManeuverForEstimation> getSuitableManeuvers(ManeuverFeatures maneuverFeatures, BoatClass boatClass)
throws JsonDeserializationException, ParseException {
Pair<String, ManeuverFeatures> key = new Pair<>(boatClass == null ? null : boatClass.getName(),
maneuverFeatures);
List<ManeuverForEstimation> maneuvers = maneuversPerBoatClass.get(key);
if (maneuvers == null) {
if (allManeuvers == null) {
allManeuvers = persistenceManager.getAllElements();
}
maneuvers = allManeuvers.stream()
.filter(maneuver -> MLUtil.isManeuverContainsAllFeatures(maneuver, maneuverFeatures, boatClass))
.collect(Collectors.toList());
maneuversPerBoatClass.put(key, maneuvers);
}
return maneuvers;
}
public static void main(String[] args) throws Exception {
PolarDataService polarService = PolarDataServiceAccessUtil.getPersistedPolarService();
Set<BoatClass> allBoatClasses = polarService.getAllBoatClassesWithPolarSheetsAvailable();
for (ManeuverFeatures maneuverFeatures : ManeuverFeatures.values()) {
LoggingUtil.logInfo("##### Training classifier with features: " + maneuverFeatures);
TrainableSingleManeuverOfflineClassifier classifier = ManeuverClassifiersFactory
.getNewClassifierInstance(maneuverFeatures, null);
ManeuverClassifierTrainer classifierTrainer = new ManeuverClassifierTrainer(
new RegularManeuversForEstimationPersistenceManager(), polarService);
classifierTrainer.trainClassifier(classifier);
LoggingUtil.logInfo(
"### Training classifier for all boat classes with maneuver features: " + maneuverFeatures);
List<TrainableSingleManeuverOfflineClassifier> allTrainableClassifierInstances = ManeuverClassifiersFactory
.getAllTrainableClassifierInstances(maneuverFeatures, null);
for (TrainableSingleManeuverOfflineClassifier classifier : allTrainableClassifierInstances) {
LoggingUtil.logInfo("## Classifier: " + classifier.getClass().getName());
ManeuverClassifierTrainer classifierTrainer = new ManeuverClassifierTrainer(
new RegularManeuversForEstimationPersistenceManager(), polarService);
classifierTrainer.trainClassifier(classifier);
}
}
for (ManeuverFeatures maneuverFeatures : ManeuverFeatures.values()) {
for (BoatClass boatClass : allBoatClasses) {
LoggingUtil.logInfo("### Training classifier for boat class " + boatClass + " with maneuver features: "
+ maneuverFeatures);
TrainableSingleManeuverOfflineClassifier classifier = ManeuverClassifiersFactory
.getNewClassifierInstance(maneuverFeatures, boatClass);
ManeuverClassifierTrainer classifierTrainer = new ManeuverClassifierTrainer(
new RegularManeuversForEstimationPersistenceManager(), polarService);
classifierTrainer.trainClassifier(classifier);
List<TrainableSingleManeuverOfflineClassifier> allTrainableClassifierInstances = ManeuverClassifiersFactory
.getAllTrainableClassifierInstances(maneuverFeatures, boatClass);
for (TrainableSingleManeuverOfflineClassifier classifier : allTrainableClassifierInstances) {
LoggingUtil.logInfo("## Classifier: " + classifier.getClass().getName());
ManeuverClassifierTrainer classifierTrainer = new ManeuverClassifierTrainer(
new RegularManeuversForEstimationPersistenceManager(), polarService);
classifierTrainer.trainClassifier(classifier);
}
}
}
}
@@ -13,10 +13,12 @@ public class ManeuverClassifiersCache {
private final ShortTimeAfterLastHitCache<ClassifierType, SingleManeuverClassifier> classifierCache;
private final boolean liveRace;
private final PolarDataService polarDataService;
private final boolean marksAvailable;
public ManeuverClassifiersCache(long preserveLoadedClassifiersMillis, boolean liveRace,
public ManeuverClassifiersCache(long preserveLoadedClassifiersMillis, boolean liveRace, boolean marksAvailable,
PolarDataService polarDataService) {
this.liveRace = liveRace;
this.marksAvailable = marksAvailable;
this.polarDataService = polarDataService;
this.classifierCache = new ShortTimeAfterLastHitCache<ClassifierType, SingleManeuverClassifier>(
preserveLoadedClassifiersMillis, classifierType -> ManeuverClassifierLoader
@@ -30,8 +32,12 @@ public class ManeuverClassifiersCache {
private ManeuverFeatures determineManeuverFeatures(ManeuverForEstimation maneuver) {
Long fixesCountForBoatClass = polarDataService.getFixCountPerBoatClass().get(maneuver.getBoatClass());
boolean polars = fixesCountForBoatClass != null && fixesCountForBoatClass >= MIN_FIXES_FOR_POLARS_INFORMATION;
return new ManeuverFeatures(polars, !liveRace);
boolean polars = fixesCountForBoatClass != null && fixesCountForBoatClass >= MIN_FIXES_FOR_POLARS_INFORMATION
&& maneuver.getDeviationFromOptimalJibeAngleInDegrees() != null
&& maneuver.getDeviationFromOptimalTackAngleInDegrees() != null;
boolean marks = marksAvailable && maneuver.getRelativeBearingToNextMarkAfter() != null
&& maneuver.getRelativeBearingToNextMarkBefore() != null;
return new ManeuverFeatures(polars, !liveRace, marks);
}
public PolarDataService getPolarDataService() {
@@ -1,7 +1,17 @@
package com.sap.sailing.windestimation.maneuverclassifier;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.GradientBoostingManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.LDAManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.LogisticRegressionManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.NaiveBayesManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.NeuralNetworkManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.QDAManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.RandomForestManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.SVMManeuverClassifier;
@@ -22,4 +32,20 @@ public class ManeuverClassifiersFactory {
}
}
public static List<TrainableSingleManeuverOfflineClassifier> getAllTrainableClassifierInstances(
ManeuverFeatures maneuverFeatures, BoatClass boatClass) {
List<TrainableSingleManeuverOfflineClassifier> classifiers = new ArrayList<>();
classifiers.add(new GradientBoostingManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
classifiers.add(new LDAManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
classifiers.add(new LogisticRegressionManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
classifiers.add(new NaiveBayesManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
classifiers.add(new NeuralNetworkManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
classifiers.add(new QDAManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
classifiers.add(new RandomForestManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
classifiers.add(new SVMManeuverClassifier(maneuverFeatures, boatClass, supportedManeuverTypes));
List<TrainableSingleManeuverOfflineClassifier> suitableClassifiers = classifiers.stream()
.filter(classifier -> classifier.hasSupportForProvidedFeatures()).collect(Collectors.toList());
return suitableClassifiers;
}
}
@@ -1,7 +1,5 @@
package com.sap.sailing.windestimation.maneuverclassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.ClassifierPersistenceException;
public interface PersistableModel {
void loadPersistedModel() throws ClassifierPersistenceException;
@@ -1,4 +1,4 @@
package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
package com.sap.sailing.windestimation.maneuverclassifier;
import java.io.Serializable;
@@ -33,4 +33,6 @@ public interface SingleManeuverClassifier extends ManeuverClassifier {
int getFixesCountForBoatClass();
boolean hasSupportForProvidedFeatures();
}
@@ -2,6 +2,7 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl;
import java.util.List;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.data.LabelledManeuverForEstimation;
import com.sap.sailing.windestimation.data.ManeuverForEstimation;
@@ -26,9 +27,31 @@ public class MLUtil {
inputVector[i++] = maneuver.getScaledSpeedBefore();
inputVector[i++] = maneuver.getScaledSpeedAfter();
}
if (maneuverFeatures.isMarksInformation()) {
inputVector[i++] = maneuver.isMarkPassing() ? 1.0 : 0.0;
inputVector[i++] = maneuver.getRelativeBearingToNextMarkBefore();
inputVector[i++] = maneuver.getRelativeBearingToNextMarkAfter();
}
return inputVector;
}
public static boolean isManeuverContainsAllFeatures(ManeuverForEstimation maneuver,
ManeuverFeatures maneuverFeatures, BoatClass boatClass) {
if (maneuverFeatures.isPolarsInformation()) {
if (maneuver.getDeviationFromOptimalJibeAngleInDegrees() == null
|| maneuver.getDeviationFromOptimalTackAngleInDegrees() == null) {
return false;
}
}
if (maneuverFeatures.isMarksInformation()) {
if (maneuver.getRelativeBearingToNextMarkBefore() == null
|| maneuver.getRelativeBearingToNextMarkAfter() == null) {
return false;
}
}
return true;
}
public static double[][] getInputMatrixAsDoubleArray(List<ManeuverForEstimation> maneuvers,
ManeuverFeatures maneuverFeatures) {
double[][] inputMatrix = new double[maneuvers.size()][];
@@ -44,7 +67,7 @@ public class MLUtil {
int[] output = new int[maneuvers.size()];
int i = 0;
for (ManeuverForEstimation maneuver : maneuvers) {
output[i] = supportedManeuverTypesMapping[((LabelledManeuverForEstimation) maneuver).getManeuverType()
output[i++] = supportedManeuverTypesMapping[((LabelledManeuverForEstimation) maneuver).getManeuverType()
.ordinal()];
}
return output;
@@ -58,6 +81,9 @@ public class MLUtil {
if (maneuverFeatures.isScaledSpeed()) {
numberOfFeatures += 2;
}
if (maneuverFeatures.isMarksInformation()) {
numberOfFeatures += 3;
}
return numberOfFeatures;
}
@@ -1,13 +1,32 @@
package com.sap.sailing.windestimation.maneuverclassifier.impl;
public class ManeuverFeatures {
import java.io.Serializable;
public class ManeuverFeatures implements Serializable {
private static final long serialVersionUID = -695419180697024150L;
private static final ManeuverFeatures[] values = new ManeuverFeatures[8];
static {
int i = 0;
for(int polars = 0; polars <= 1; polars++) {
for(int scaledSpeed = 0; scaledSpeed <= 1; scaledSpeed++) {
for(int marks = 0; marks <= 1; marks++) {
values[i++] = new ManeuverFeatures(polars == 0, scaledSpeed == 0, marks == 0);
}
}
}
}
private final boolean polarsInformation;
private final boolean scaledSpeed;
private final boolean marksInformation;
public ManeuverFeatures(boolean polarsInformation, boolean scaledSpeed) {
public ManeuverFeatures(boolean polarsInformation, boolean scaledSpeed, boolean marksInformation) {
this.polarsInformation = polarsInformation;
this.scaledSpeed = scaledSpeed;
this.marksInformation = marksInformation;
}
public boolean isPolarsInformation() {
@@ -17,15 +36,19 @@ public class ManeuverFeatures {
public boolean isScaledSpeed() {
return scaledSpeed;
}
public boolean isMarksInformation() {
return marksInformation;
}
public boolean isSubset(ManeuverFeatures superSet) {
return equals(superSet) && (!polarsInformation || superSet.polarsInformation)
&& (!scaledSpeed || superSet.scaledSpeed);
&& (!scaledSpeed || superSet.scaledSpeed) && (!marksInformation || superSet.marksInformation);
}
@Override
public String toString() {
if (polarsInformation || scaledSpeed) {
if (polarsInformation || scaledSpeed || marksInformation) {
StringBuilder str = new StringBuilder();
if (polarsInformation) {
str.append("Polars");
@@ -33,6 +56,9 @@ public class ManeuverFeatures {
if (scaledSpeed) {
str.append("ScaledSpeed");
}
if(marksInformation) {
str.append("Marks");
}
return str.toString();
}
return "Basic";
@@ -42,6 +68,7 @@ public class ManeuverFeatures {
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (marksInformation ? 1231 : 1237);
result = prime * result + (polarsInformation ? 1231 : 1237);
result = prime * result + (scaledSpeed ? 1231 : 1237);
return result;
@@ -56,6 +83,8 @@ public class ManeuverFeatures {
if (getClass() != obj.getClass())
return false;
ManeuverFeatures other = (ManeuverFeatures) obj;
if (marksInformation != other.marksInformation)
return false;
if (polarsInformation != other.polarsInformation)
return false;
if (scaledSpeed != other.scaledSpeed)
@@ -64,8 +93,7 @@ public class ManeuverFeatures {
}
public static ManeuverFeatures[] values() {
return new ManeuverFeatures[] { new ManeuverFeatures(true, true), new ManeuverFeatures(true, false),
new ManeuverFeatures(false, true), new ManeuverFeatures(false, false) };
return values;
}
}
@@ -11,7 +11,9 @@ import java.util.List;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.data.ManeuverForEstimation;
import com.sap.sailing.windestimation.maneuverclassifier.AbstractManeuverClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.ClassifierPersistenceException;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig;
import com.sap.sailing.windestimation.maneuverclassifier.TrainableSingleManeuverOfflineClassifier;
import com.sap.sailing.windestimation.maneuverclassifier.impl.MLUtil;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
@@ -24,6 +26,7 @@ import smile.projection.PCA;
public abstract class AbstractSmileManeuverClassifier<T extends SoftClassifier<double[]>>
extends AbstractManeuverClassifier implements TrainableSingleManeuverOfflineClassifier {
private static final long serialVersionUID = -8548600189459410079L;
private T classifier = null;
private double trainScore = 0;
private double testScore = 0;
@@ -82,14 +85,10 @@ public abstract class AbstractSmileManeuverClassifier<T extends SoftClassifier<d
}
}
private String getFileNameForClassifier() {
String filename = "SMILE_" + getClass().getName() + "-" + getManeuverFeatures().toString() + "-"
+ getBoatClass();
return filename;
}
private File getFileForClassifier() {
return new File("persisted_classifiers" + File.pathSeparator + getFileNameForClassifier());
String filename = "classifier_smile_" + getClass().getSimpleName() + "-" + getManeuverFeatures().toString()
+ "-" + (getBoatClass() == null ? "All" : getBoatClass().getName());
return new File(filename);
}
@Override
@@ -172,4 +171,9 @@ public abstract class AbstractSmileManeuverClassifier<T extends SoftClassifier<d
this.fixesCountForBoatClass = fixesCountForBoatClass;
}
@Override
public boolean hasSupportForProvidedFeatures() {
return true;
}
}
@@ -2,16 +2,18 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.GradientTreeBoost;
public class GradientBoostingManeuverClassifier extends AbstractSmileManeuverClassifier<GradientTreeBoost> {
private static final long serialVersionUID = -3364152319152090775L;
public GradientBoostingManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().build(), supportedManeuverTypes);
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().scaling().build(), supportedManeuverTypes);
}
@Override
@@ -2,16 +2,18 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.LDA;
public class LDAManeuverClassifier extends AbstractSmileManeuverClassifier<LDA> {
private static final long serialVersionUID = -3364152319152090775L;
public LDAManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().build(), supportedManeuverTypes);
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().scaling().build(), supportedManeuverTypes);
}
@Override
@@ -2,16 +2,18 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.LogisticRegression;
public class LogisticRegressionManeuverClassifier extends AbstractSmileManeuverClassifier<LogisticRegression> {
private static final long serialVersionUID = -3364152319152090775L;
public LogisticRegressionManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().build(), supportedManeuverTypes);
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().scaling().build(), supportedManeuverTypes);
}
@Override
@@ -2,24 +2,26 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.MLUtil;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.NaiveBayes;
public class NaiveBayesManeuverClassifier extends AbstractSmileManeuverClassifier<NaiveBayes> {
private static final long serialVersionUID = -3364152319152090775L;
public NaiveBayesManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().build(), supportedManeuverTypes);
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().scaling().build(), supportedManeuverTypes);
}
@Override
protected NaiveBayes createTrainedClassifier(double[][] x, int[] y) {
int numberOfInputFeatures = MLUtil.getNumberOfInputFeatures(getManeuverFeatures());
int numberOfClasses = getSupportedManeuverTypesCount();
NaiveBayes nbc = new NaiveBayes(NaiveBayes.Model.GENERAL, numberOfClasses, numberOfInputFeatures);
NaiveBayes nbc = new NaiveBayes(NaiveBayes.Model.MULTINOMIAL, numberOfClasses, numberOfInputFeatures);
nbc.learn(x, y);
return nbc;
}
@@ -2,14 +2,16 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.MLUtil;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.NeuralNetwork;
public class NeuralNetworkManeuverClassifier extends AbstractSmileManeuverClassifier<NeuralNetwork> {
private static final long serialVersionUID = -3364152319152090775L;
public NeuralNetworkManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().scaling().build(), supportedManeuverTypes);
@@ -25,7 +27,7 @@ public class NeuralNetworkManeuverClassifier extends AbstractSmileManeuverClassi
NeuralNetwork.ActivationFunction.LOGISTIC_SIGMOID, numberOfInputFeatures, 100, 100, 1);
} else {
net = new NeuralNetwork(NeuralNetwork.ErrorFunction.CROSS_ENTROPY, NeuralNetwork.ActivationFunction.SOFTMAX,
100, 100, k);
numberOfInputFeatures, 100, 100, k);
}
for (int i = 0; i < 20; i++) {
@@ -2,16 +2,18 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.QDA;
public class QDAManeuverClassifier extends AbstractSmileManeuverClassifier<QDA> {
private static final long serialVersionUID = -3364152319152090775L;
public QDAManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().build(), supportedManeuverTypes);
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().scaling().build(), supportedManeuverTypes);
}
@Override
@@ -2,13 +2,15 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.RandomForest;
public class RandomForestManeuverClassifier extends AbstractSmileManeuverClassifier<RandomForest> {
private static final long serialVersionUID = -3364152319152090775L;
public RandomForestManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().build(), supportedManeuverTypes);
@@ -2,14 +2,16 @@ package com.sap.sailing.windestimation.maneuverclassifier.impl.smile;
import com.sap.sailing.domain.base.BoatClass;
import com.sap.sailing.windestimation.maneuverclassifier.ManeuverTypeForClassification;
import com.sap.sailing.windestimation.maneuverclassifier.PreprocessingConfig.PreprocessingConfigBuilder;
import com.sap.sailing.windestimation.maneuverclassifier.impl.ManeuverFeatures;
import com.sap.sailing.windestimation.maneuverclassifier.impl.smile.PreprocessingConfig.PreprocessingConfigBuilder;
import smile.classification.SVM;
import smile.math.kernel.GaussianKernel;
public class SVMManeuverClassifier extends AbstractSmileManeuverClassifier<SVM<double[]>> {
private static final long serialVersionUID = -3364152319152090775L;
public SVMManeuverClassifier(ManeuverFeatures maneuverFeatures, BoatClass boatClass,
ManeuverTypeForClassification[] supportedManeuverTypes) {
super(maneuverFeatures, boatClass, new PreprocessingConfigBuilder().scaling().build(), supportedManeuverTypes);
@@ -26,4 +28,9 @@ public class SVMManeuverClassifier extends AbstractSmileManeuverClassifier<SVM<d
return svm;
}
@Override
public boolean hasSupportForProvidedFeatures() {
return getBoatClass() != null;
}
}
@@ -158,6 +158,8 @@ public class ManeuverNodeBestPathsCalculator {
penaltyFactor = 1 / (1
+ (MAX_ABS_WIND_COURSE_DEVIATION_TOLERANCE_WITHIN_ANALYSIS_INTERVAL_IN_DEGREES + violationRange)
* 0.01);
} else if (violationRange <= MAX_ABS_WIND_COURSE_DEVIATION_TOLERANCE_WITHIN_ANALYSIS_INTERVAL_IN_DEGREES) {
penaltyFactor = 1 / (1 + Math.pow((violationRange) / 15, 2));
} else {
penaltyFactor = 1 / (4 + Math.pow((violationRange) / 5, 2));
}
@@ -25,6 +25,7 @@ public class ManeuverNodeGraphLevel {
private ManeuverNodeGraphLevel nextLevel = null;
private final List<ManeuverNode> levelNodes = new ArrayList<>();
private double probabilitiesSum = 1.0;
public ManeuverNodeGraphLevel(ManeuverForEstimation maneuver, ManeuverEstimationResult maneuverEstimationResult) {
this.maneuver = maneuver;
@@ -51,8 +52,8 @@ public class ManeuverNodeGraphLevel {
private void addManeuverNode(ManeuverTypeForClassification maneuverType, Tack tackAfter,
WindRangeForManeuverNode windRange, boolean windRangeToExclude, double confidence) {
ManeuverNode maneuverNode = new ManeuverNode(maneuverType, tackAfter, windRange, windRangeToExclude, confidence,
levelNodes.size() - 1);
ManeuverNode maneuverNode = new ManeuverNode(maneuverType, tackAfter, windRange, windRangeToExclude,
confidence / probabilitiesSum, levelNodes.size() - 1);
levelNodes.add(maneuverNode);
}
@@ -62,10 +63,15 @@ public class ManeuverNodeGraphLevel {
}
private void initNodesAsRegular() {
probabilitiesSum = 0;
probabilitiesSum += maneuverEstimationResult.getManeuverTypeLikelihood(CoarseGrainedManeuverType.TACK);
probabilitiesSum += maneuverEstimationResult.getManeuverTypeLikelihood(CoarseGrainedManeuverType.JIBE);
probabilitiesSum += maneuverEstimationResult.getManeuverTypeLikelihood(CoarseGrainedManeuverType.BEAR_AWAY);
probabilitiesSum += maneuverEstimationResult.getManeuverTypeLikelihood(CoarseGrainedManeuverType.HEAD_UP);
for (ManeuverTypeForClassification maneuverType : ManeuverTypeForClassification.values()) {
switch (maneuverType) {
case TACK:
initTackNode();
initTackNode(probabilitiesSum);
break;
case JIBE:
initJibeNode();
@@ -133,7 +139,7 @@ public class ManeuverNodeGraphLevel {
addManeuverNode(ManeuverTypeForClassification.JIBE, tackAfter, windRange, false, confidence);
}
private void initTackNode() {
private void initTackNode(double probabilitiesSum) {
Bearing middleCourse = maneuver.getMiddleCourse();
double absCourseChangeDeg = Math.abs(maneuver.getCourseChangeInDegrees());
Double optimalTackDeviationDeg = maneuver.getDeviationFromOptimalTackAngleInDegrees();