Updated models accordingly.

Author: Olcay Taner YILDIZ

Classification/Model/DummyModel.py

@@ -30,12 +30,6 @@ def constructor2(self, fileName: str):
         self.distribution = Model.loadClassDistribution(inputFile)
         inputFile.close()
 
-    def __init__(self, trainSet: object = None):
-        if isinstance(trainSet, InstanceList):
-            self.constructor1(trainSet)
-        elif isinstance(trainSet, str):
-            self.constructor2(trainSet)
-
     def predict(self, instance: Instance) -> str:
         """
         The predict method takes an Instance as an input and returns the entry of distribution which has the maximum

Classification/Model/NeuralNetwork/DeepNetworkModel.py

@@ -112,16 +112,6 @@ def constructor2(self, fileName: str):
         self.__activation_function = self.loadActivationFunction(inputFile)
         inputFile.close()
 
-    def __init__(self,
-                 trainSet: object = None,
-                 validationSet: InstanceList = None,
-                 parameters: DeepNetworkParameter = None):
-        if isinstance(trainSet, InstanceList):
-            self.constructor1(trainSet, validationSet, parameters)
-        elif isinstance(trainSet, str):
-            super().__init__()
-            self.constructor2(trainSet)
-
     def __allocateWeights(self, parameters: DeepNetworkParameter):
         """
         The allocateWeights method takes DeepNetworkParameters as an input. First it adds random weights to the list

Classification/Model/NeuralNetwork/LinearPerceptronModel.py

@@ -71,18 +71,6 @@ def constructor3(self, fileName: str):
         self.W = self.loadMatrix(inputFile)
         inputFile.close()
 
-    def __init__(self, trainSet: object = None, validationSet: InstanceList = None,
-                 parameters: LinearPerceptronParameter = None):
-        if trainSet is not None:
-            if isinstance(trainSet, InstanceList):
-                if validationSet is None:
-                    self.constructor1(trainSet)
-                else:
-                    self.constructor2(trainSet, validationSet, parameters)
-            elif isinstance(trainSet, str):
-                super().__init__()
-                self.constructor3(trainSet)
-
     def calculateOutput(self):
         """
         The calculateOutput method calculates the Matrix y by multiplying Matrix W with Vector x.

Classification/Model/NeuralNetwork/MultiLayerPerceptronModel.py

@@ -108,16 +108,6 @@ def constructor3(self, fileName: str):
         self.__activation_function = self.loadActivationFunction(inputFile)
         inputFile.close()
 
-    def __init__(self,
-                 trainSet: object = None,
-                 validationSet: InstanceList = None,
-                 parameters: MultiLayerPerceptronParameter = None):
-        if isinstance(trainSet, InstanceList):
-            self.constructor2(trainSet, validationSet, parameters)
-        elif isinstance(trainSet, str):
-            super().__init__()
-            self.constructor3(trainSet)
-
     def calculateOutput(self):
         """
         The calculateOutput method calculates the forward single hidden layer by using Matrices W and V.

Classification/Model/NonParametric/KnnModel.py

@@ -46,15 +46,6 @@ def constructor2(self, fileName: str):
         self.__data = self.loadInstanceList(inputFile)
         inputFile.close()
 
-    def __init__(self,
-                 data: object = None,
-                 k: int = None,
-                 distanceMetric: DistanceMetric = None):
-        if isinstance(data, InstanceList):
-            self.constructor1(data, k, distanceMetric)
-        elif isinstance(data, str):
-            self.constructor2(data)
-
     def predict(self, instance: Instance) -> str:
         """
         The predict method takes an Instance as an input and finds the nearest neighbors of given instance. Then

Classification/Model/Parametric/KMeansModel.py

@@ -44,15 +44,6 @@ def constructor2(self, fileName: str):
         self.__class_means = self.loadInstanceList(inputFile)
         inputFile.close()
 
-    def __init__(self,
-                 priorDistribution: object = None,
-                 classMeans: InstanceList = None,
-                 distanceMetric: DistanceMetric = None):
-        if isinstance(priorDistribution, DiscreteDistribution):
-            self.constructor1(priorDistribution, classMeans, distanceMetric)
-        elif isinstance(priorDistribution, str):
-            self.constructor2(priorDistribution)
-
     def calculateMetric(self,
                         instance: Instance,
                         Ci: str) -> float:

Classification/Model/Parametric/LdaModel.py

@@ -46,16 +46,6 @@ def constructor2(self, fileName: str):
         self.loadWandW0(inputFile, size)
         inputFile.close()
 
-    def __init__(self,
-                 priorDistribution: object = None,
-                 w: dict = None,
-                 w0: dict = None):
-        if priorDistribution is not None:
-            if isinstance(priorDistribution, DiscreteDistribution):
-                self.constructor1(priorDistribution, w, w0)
-            elif isinstance(priorDistribution, str):
-                self.constructor2(priorDistribution)
-
     def loadWandW0(self,
                    inputFile: TextIOWrapper,
                    size: int):

Classification/Model/Parametric/NaiveBayesModel.py

@@ -39,12 +39,6 @@ def constructor2(self, fileName: str):
         self.__class_attribute_distributions = None
         inputFile.close()
 
-    def __init__(self, priorDistribution: object = None):
-        if isinstance(priorDistribution, DiscreteDistribution):
-            self.constructor1(priorDistribution)
-        elif isinstance(priorDistribution, str):
-            self.constructor2(priorDistribution)
-
     def initForContinuous(self,
                           classMeans: dict,
                           classDeviations: dict):

Classification/Model/Parametric/QdaModel.py

@@ -55,17 +55,6 @@ def constructor2(self, fileName: str):
             self.__W[c] = matrix
         inputFile.close()
 
-    def __init__(self,
-                 priorDistribution: object = None,
-                 W: dict = None,
-                 w: dict = None,
-                 w0: dict = None):
-        super().__init__()
-        if isinstance(priorDistribution, DiscreteDistribution):
-            self.constructor3(priorDistribution, W, w, w0)
-        elif isinstance(priorDistribution, str):
-            self.constructor2(priorDistribution)
-
     def calculateMetric(self,
                         instance: Instance,
                         Ci: str) -> float:

Classification/Model/RandomModel.py

@@ -42,14 +42,6 @@ def constructor2(self, fileName: str):
             self.__class_labels.append(inputFile.readline().strip())
         inputFile.close()
 
-    def __init__(self,
-                 classLabels: object = None,
-                 seed: int = None):
-        if isinstance(classLabels, list):
-            self.constructor1(classLabels, seed)
-        elif isinstance(classLabels, str):
-            self.constructor2(classLabels)
-
     def predict(self, instance: Instance) -> str:
         """
         The predict method gets an Instance as an input and retrieves the possible class labels as an ArrayList. Then