Add analysis

Author: jhosoume

NoiseFiltersPy/NeighborwiseInjector.py

@@ -7,6 +7,7 @@ class NeighborwiseInjector(Injector):
     def generate(self, seed: int = None):
         self._new_noise = self._define_noise_examples()
         self._gen_random(seed = seed)
+        return self
 
     def _cal_dNN(self, distances, example_indx):
         equal_class = self._labels == self._labels.iloc[example_indx]

NoiseFiltersPy/NoiseHandler.py

@@ -26,20 +26,51 @@ def filter(self, methods):
         times = []
         for filter_type in methods:
             if filter_type in _implemented_filters:
-                filter = _implemented_filters()
-                filter, time = timeit(
-                    filter,
-                    data = self._attrs,
-                    classes = self._labels 
-                )
+                filter = _implemented_filters[filter_type]()
+                if self._measure_time:
+                    filter, time = timeit(
+                        filter,
+                        data = self._attrs,
+                        classes = self._labels 
+                    )
+                    times.append(time)
+                else:
+                    filter = filter(
+                        filter,
+                        data = self._attrs,
+                        classes = self._labels 
+                    )
                 self._attrs = filter.clean_data
                 self._classes = filter.clean_classes
                 filters.append(filter)
-                times.append(time)
-        return filters, times
+        if self._measure_time:
+            return filters, times
+        return filters
+
 
     def inject(self, methods):
-        pass
+        injectors = []
+        times = []
+        for injector_type in methods:
+            if injector_type in _implemented_injectors:
+                injector = _implemented_injectors[injector_type]()
+                if self._measure_time:
+                    filter, time = timeit(
+                        injector,
+                        data = self._attrs,
+                        classes = self._labels 
+                    )
+                    times.append(time)
+                else:
+                    filter = filter(
+                        filter,
+                        data = self._attrs,
+                        classes = self._labels 
+                    )
+                injectors.append(filter)
+        if self._measure_time:
+            return injectors, times
+        return injectors 
 
     def _output_converter(self):
         raise NotImplementedError

NoiseFiltersPy/NonlinearwiseInjector.py

@@ -8,6 +8,7 @@ class NonlinearwiseInjector(Injector):
     def generate(self, seed: int = None):
         self._new_noise = self._define_noise_examples(seed = seed)
         self._gen_random(seed = seed)
+        return self
 
     def _one_vs_one(self):
         labels_comb = itertools.combinations(self._label_types, 2)

NoiseFiltersPy/RandomInjector.py

@@ -6,4 +6,5 @@ class RandomInjector(Injector):
     def generate(self, seed: int = None):
         rng = np.random.default_rng(seed)
         self._new_noise = rng.choice(self._labels.shape[0], size = self._num_noise, replace = False)
-        self._gen_random(seed = seed)
+        self._gen_random(seed = seed)
+        return self

NoiseFiltersPy/_filters.py

@@ -1,9 +1,9 @@
 from NoiseFiltersPy import AENN, CNN, DROP, ENN, TomekLinks
 
 _implemented_filters = {
-    "AENN": AENN,
-    "CNN": CNN,
-    "DROP": DROP,
-    "ENN": ENN,
-    "TomekLinks": TomekLinks
+    "AENN": AENN.AENN,
+    "CNN": CNN.CNN,
+    "DROP": DROP.DROPv1,
+    "ENN": ENN.ENN,
+    "TomekLinks": TomekLinks.TomekLinks
 }

NoiseFiltersPy/_injectors.py

@@ -1,7 +1,7 @@
 from NoiseFiltersPy import RandomInjector, NonlinearwiseInjector, NeighborwiseInjector
 
 _implemented_injectors = {
-    "RandomInjector": RandomInjector,
-    "NonlinearwiseInjector": NonlinearwiseInjector,
-    "NeighborwiseInjector": NeighborwiseInjector
+    "RandomInjector": RandomInjector.RandomInjector,
+    "NonlinearwiseInjector": NonlinearwiseInjector.NonlinearwiseInjector,
+    "NeighborwiseInjector": NeighborwiseInjector.NeighborwiseInjector
 }

analysis/compare_filters.py

@@ -0,0 +1,59 @@
+from os import listdir
+from os.path import isfile, join
+import numpy as np
+import pandas as pd
+from scipy.io import arff as arff_io
+from sklearn import preprocessing, metrics
+
+from NoiseFiltersPy._filters import _implemented_filters
+from NoiseFiltersPy._injectors import _implemented_injectors 
+
+DATASETS_PATH = "analysis/datasets/"
+
+datasets = [f for f in listdir(DATASETS_PATH)
+                if ( isfile(join(DATASETS_PATH, f)) and
+                ( f.endswith("json") or f.endswith("arff") ) )]
+
+enc = preprocessing.OneHotEncoder(handle_unknown = 'ignore')
+le = preprocessing.LabelEncoder()
+
+def calculate_filter_f1(dataset, filter, injector, rate = 0.1):
+    # Reading dataset
+    if dataset.endswith("json"):
+        data = pd.read_json(DATASETS_PATH + dataset)
+    elif dataset.endswith("arff"):
+        data = arff_io.loadarff(DATASETS_PATH + dataset)
+        data = pd.DataFrame(data[0])
+    target = data["class"].values
+    # Data preprocessing (type transformation)
+    if target.dtype == object:
+        le.fit(target)
+        target = le.transform(target)
+    attrs = data.drop("class", axis = 1).values
+    if not np.issubdtype(attrs.dtype, np.number):
+        enc.fit(attrs)
+        attrs = enc.transform(attrs).toarray()
+
+    injector = injector(attrs, target, rate)
+    injector.generate()
+
+    filter = filter()
+    filter = filter(attrs, np.ravel(injector.labels.values))
+    real_values = [1 if indx in injector.noise_indx else 0 for indx in range(len(target))]
+    pred_values = [1 if indx in filter.rem_indx else 0 for indx in range(len(target))]
+    return metrics.f1_score(real_values, pred_values, average = "micro")
+
+results = {}
+for filter in _implemented_filters.keys():
+    results[filter] = {}
+    for injector in _implemented_injectors.keys():
+        results[filter][injector] = {}
+        for dataset in datasets:
+            results[filter][injector][dataset] = calculate_filter_f1(
+                dataset,
+                _implemented_filters[filter], 
+                _implemented_injectors[injector]
+            )
+
+results = pd.DataFrame(results)
+results.to_csv("compare_filters.csv")