Merge remote-tracking branch 'origin/k-means' into ai

jastadd-mquat-solver-ilp/src/main/java/de/tudresden/inf/st/mquat/solving/clustering/AbstractNormalizer.java

+package de.tudresden.inf.st.mquat.solving.clustering;
+
+import java.util.Map;
+
+public abstract class AbstractNormalizer implements Normalizer {
+    Map<String, Double> minValue;
+    Map<String, Double> maxValue;
+
+    public AbstractNormalizer(Map<String, Double> minValue,  Map<String, Double> maxValue){
+        this.minValue = minValue;
+        this.maxValue = maxValue;
+    }
+
+}

jastadd-mquat-solver-ilp/src/main/java/de/tudresden/inf/st/mquat/solving/clustering/HardwareComponent.java

@@ -4,6 +4,9 @@ import de.tudresden.inf.st.mquat.jastadd.model.Resource;
 import weka.core.DenseInstance;
 import weka.core.Instance;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /***
  * An entity unifying WEKA instances and Jastadd resources
  */
@@ -11,10 +14,15 @@ public class HardwareComponent {
 
     private Resource resource;
     private Instance instance;
+    //TODO: do it with Jastadd
+    private Map<String, Double> value;
+    private Map<String, Double> normalizedValue;
 
-  public HardwareComponent(Resource resource, int attributes_number) {
+    HardwareComponent(Resource resource, int attributes_number) {
         this.resource = resource;
         this.instance = new DenseInstance(attributes_number);
+        value = new HashMap<>();
+        normalizedValue = new HashMap<>();
     }
 
   public Resource getResource() {
@@ -32,4 +40,20 @@ public class HardwareComponent {
     public void setInstance(Instance instance) {
         this.instance = instance;
     }
+
+    public Map<String, Double> getValue() {
+        return value;
+    }
+
+    public void setValue(Map<String, Double> value) {
+        this.value = value;
+    }
+
+    public Map<String, Double> getNormalizedValue() {
+        return normalizedValue;
+    }
+
+    public void setNormalizedValue(Map<String, Double> normalizedValue) {
+        this.normalizedValue = normalizedValue;
+    }
 }

jastadd-mquat-solver-ilp/src/main/java/de/tudresden/inf/st/mquat/solving/clustering/KMeans.java

@@ -26,26 +26,24 @@ import java.util.Map;
  */
 public class KMeans {
   private static final Logger logger = LogManager.getLogger(KMeans.class);
-
   // dataset
   private Instances resources;
-
   // the model
   private Root model;
-
   // list of resources
   private ArrayList<HardwareComponent> hardwareComponentList = new ArrayList<>();
 
+  /***
+   * Prepare clustering algorithm, extract WEKA instances from Jastadd model
+   * @param model Jastadd model
+   */
   public KMeans(Root model) {
-
     this.model = model;
-
     // create attributes for instances
     Attribute cpu = new Attribute("cpu");
     Attribute ram = new Attribute("ram");
     Attribute disk = new Attribute("disk");
     Attribute network = new Attribute("network");
-
     ArrayList<Attribute> attributeList = new ArrayList<>();
 
     // we expect one top-level resource type and consider at most four sub-resources of the following names
@@ -78,19 +76,23 @@ public class KMeans {
           String typeName = sub.getType().getName().getName();
           switch (typeName) {
             case "CPU":
-              hardwareComponent.getInstance().setValue(cpu, sub.getCurrentValueByPropertyName("frequency"));
+              hardwareComponent.getValue().put("CPU", sub.getCurrentValueByPropertyName("frequency"));
+              //hardwareComponent.getInstance().setValue(cpu, sub.getCurrentValueByPropertyName("frequency"));
               break;
             case "RAM":
-              hardwareComponent.getInstance().setValue(ram, sub.getCurrentValueByPropertyName("total"));
+              hardwareComponent.getValue().put("RAM", sub.getCurrentValueByPropertyName("total"));
+              //hardwareComponent.getInstance().setValue(ram, sub.getCurrentValueByPropertyName("total"));
               break;
             case "DISK":
-              hardwareComponent.getInstance().setValue(disk, sub.getCurrentValueByPropertyName("total"));
+              hardwareComponent.getValue().put("DISK", sub.getCurrentValueByPropertyName("total"));
+              //hardwareComponent.getInstance().setValue(disk, sub.getCurrentValueByPropertyName("total"));
               break;
             case "NETWORK":
-              hardwareComponent.getInstance().setValue(network, sub.getCurrentValueByPropertyName("throughput"));
+              hardwareComponent.getValue().put("NETWORK", sub.getCurrentValueByPropertyName("throughput"));
+              //hardwareComponent.getInstance().setValue(network, sub.getCurrentValueByPropertyName("throughput"));
               break;
             default:
-              throw new EvalutationException("Unable to transform unknown resource of type" + typeName);
+              throw new RuntimeException("Unable to transform unknown resource of type" + typeName);
           }
         }
 
@@ -98,9 +100,48 @@ public class KMeans {
       }
     }
 
-    for (HardwareComponent hwc : hardwareComponentList)
-      resources.add(hwc.getInstance());
+    Map<String, Double> minValue = new HashMap<>();
+    Map<String, Double> maxValue = new HashMap<>();
+
+    for (HardwareComponent hwc : hardwareComponentList) {
+      for (String key : hwc.getValue().keySet()) {
+        if (!minValue.containsKey(key))
+          minValue.put(key, hwc.getValue().get(key));
+        else if (minValue.get(key) > hwc.getValue().get(key))
+          minValue.put(key, hwc.getValue().get(key));
+
+        if (!maxValue.containsKey(key))
+          maxValue.put(key, hwc.getValue().get(key));
+        else if (maxValue.get(key) < hwc.getValue().get(key))
+          maxValue.put(key, hwc.getValue().get(key));
+      }
+    }
+    LinearNormalizer linearNormalizer = new LinearNormalizer(minValue, maxValue);
+
+    for (HardwareComponent hwc : hardwareComponentList) {
+      hwc.setNormalizedValue(linearNormalizer.normalize(hwc));
+      for (String key : hwc.getNormalizedValue().keySet()) {
+        switch (key) {
+          case "CPU":
+            hwc.getInstance().setValue(cpu, hwc.getNormalizedValue().get(key));
+
+            break;
+          case "RAM":
+            hwc.getInstance().setValue(ram, hwc.getNormalizedValue().get(key));
+            break;
+          case "DISK":
+            hwc.getInstance().setValue(disk, hwc.getNormalizedValue().get(key));
+            break;
+          case "NETWORK":
+            hwc.getInstance().setValue(network, hwc.getNormalizedValue().get(key));
 
+            break;
+          default:
+            throw new RuntimeException("Unable to transform unknown resource of type" + key);
+        }
+      }
+      resources.add(hwc.getInstance());
+    }
   }
 
   public Map<Integer, ArrayList<Resource>> buildClusters(int numClusters) {

jastadd-mquat-solver-ilp/src/main/java/de/tudresden/inf/st/mquat/solving/clustering/LinearNormalizer.java

+package de.tudresden.inf.st.mquat.solving.clustering;
+
+import de.tudresden.inf.st.mquat.jastadd.model.Resource;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LinearNormalizer extends AbstractNormalizer implements Normalizer  {
+
+    public LinearNormalizer(Map<String, Double> minValue,  Map<String, Double> maxValue)
+    {
+        super(minValue, maxValue);
+    }
+
+    @Override
+    public Map<String, Double> normalize(HardwareComponent hardwareComponent) {
+        Map<String, Double> normalizedHWC = new HashMap<>();
+        for (String key : hardwareComponent.getValue().keySet()){
+            double normalized =
+                    (hardwareComponent.getValue().get(key) - minValue.get(key))/(maxValue.get(key) - minValue.get(key));
+            normalizedHWC.put(key, normalized);
+        }
+        return normalizedHWC;
+    }
+}

jastadd-mquat-solver-ilp/src/main/java/de/tudresden/inf/st/mquat/solving/clustering/Normalizer.java

+package de.tudresden.inf.st.mquat.solving.clustering;
+
+import java.util.Map;
+
+public interface Normalizer {
+    Map<String, Double> normalize(HardwareComponent resource);
+}

jastadd-mquat-solver-ilp/src/main/java/de/tudresden/inf/st/mquat/solving/clustering/StudentNormalizer.java

+package de.tudresden.inf.st.mquat.solving.clustering;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class StudentNormalizer implements Normalizer {
+
+    @Override
+    public Map<String, Double> normalize(HardwareComponent hardwareComponent) {
+        return new HashMap<>();
+    }
+}