implemented generateSolutions function

Author: cosminlovin7

DataFilesReader.py

@@ -20,10 +20,3 @@ def getData(self):
         self.trainValues = self.tresholds[0:9]
         self.validationValues = self.tresholds[9:-1]
         self.testValues = self.tresholds[-1]
-
-    def getMean(self):
-        mean = 0
-        for value in self.tresholds:
-            mean = mean + value
-        
-        return mean / len(self.tresholds)

FunctionPicker.py

@@ -0,0 +1,59 @@
+import numpy as np
+import statistics as stats
+import math
+import random
+
+class FunctionPicker:
+    def function_mean(self, array):
+        return np.mean(array)
+
+    def function_geo_mean(self, array):
+        return stats.geometric_mean(array)
+
+    def function_harmonic_mean(self, array):
+        return stats.harmonic_mean(array)
+
+    def function_square_mean(self, array):
+        square_sum = 0
+
+        for value in array:
+            square_sum = square_sum + value * value
+        
+        return math.sqrt(square_sum / len(array))
+
+    def function_min(self, array):
+        return min(array)
+
+    def function_max(self, array):
+        return max(array)
+
+    def function_median(self, array):
+        return stats.median(array)
+
+    def random_applier(self, array, function_number):
+        match function_number:
+            case 0:
+                return self.function_mean(array)
+            
+            case 1:
+                return self.function_geo_mean(array)
+
+            case 2:
+                return self.function_harmonic_mean(array)
+
+            case 3:
+                return self.function_square_mean(array)
+
+            case 4:
+                return self.function_min(array)
+
+            case 5:
+                return self.function_max(array)
+
+            case 6:
+                return self.function_median(array)
+
+if __name__ == "__main__":
+    function_picker = FunctionPicker()
+    function_number = random.randint(0, 6)
+    print(function_picker.random_applier([0.633333, 0.570588, 0.567427, 0.868627, 0.865466, 0.892157, 0.629412], function_number))

Predictor.py

@@ -1,28 +1,62 @@
 import pandas as pd
 import math
 import glob
+import platform
+import random
 
 from DataFilesReader import DataFilesReader
+from FunctionPicker import FunctionPicker
 
 class Predictor:
     def __init__(self, filespath):
         self.filespath = filespath
         self.pathToFiles = glob.glob(filespath)
 
     def iterateThroughFiles(self):
-        for pathToFile in self.pathToFiles:
-            # pathToFile = 'input/input0.CSV'
-            dataFilesReader = DataFilesReader(pathToFile)
-            dataFilesReader.getData()
-            
+        readers = []
+        # for pathToFile in self.pathToFiles:
+        pathToFile = 'input\\input5.CSV'
+        dataFilesReader = DataFilesReader(pathToFile)
+        dataFilesReader.getData()
+        
+        if (platform.system() == 'Linux'):
             output_path = 'output/' + pathToFile.split('/')[-1][:-3] + 'out'
-            output_file = open(output_path, 'w+')
-            output_file.write(str(dataFilesReader.expectedValue))
-            output_file.write('\n')
-            output_file.write(str(dataFilesReader.getMean()))
+        else:
+            output_path = 'output/' + pathToFile.split('\\')[-1][:-3] + 'out'
+        output_file = open(output_path, 'w+')
+
+        readers.append(dataFilesReader)
+
+        self.readers = readers
+
+    def generateSolutions(self):
+        functionPicker = FunctionPicker()
+
+        output_path = 'output/logs.out'
+        output_file = open(output_path, 'w+')
 
+        for i in range(1000):
+            random_nr = random.randint(2, len(self.readers[0].trainValues))
+            function_number = random.randint(0, 6)
+            random_indexes = []
+            for nr in range(random_nr):
+                random_indexes.append(random.randint(0, len(self.readers[0].trainValues) - 1))
+
+            score = 0
+            for reader in self.readers:
+                values = []
+                for index in random_indexes:
+                    values.append(reader.trainValues[index])
+
+                reader.trainValues.append(functionPicker.random_applier(values, function_number))
+                score_index = round(255 * reader.trainValues[-1])
+                score = score + reader.fmeans[score_index]
+
+            output_file.write(str(random_nr) + ' ' + str(random_indexes) + ' ' + str(function_number) + ' ' + str(score / len(self.readers)) + '\n')
+            
     def startAlgorithm(self):
         self.iterateThroughFiles()
+        self.generateSolutions()
 
 if __name__ == "__main__":
     predictor = Predictor("input/*.CSV")