Fix type annotation and typo

Author: MarkSong535

tensorcircuit/templates/ensemble.py

@@ -3,43 +3,48 @@
 """
 
 import tensorflow as tf
+import keras
 import numpy as np
+from typing import Any, Optional, Sequence, Tuple, List
+
+NDArray = Any
+kwargus = Any
 
 
 class bagging:  # A.K.A. voting
-    def __init__(self):
-        self.models = []
-        self.is_trained = []
+    def __init__(self) -> None:
+        self.models: List[keras.engine.functional.Functional]= []
+        self.model_trained: List[bool] = []
         self.count = 0
         self.need_confidence = True  # Help in reducing numbers of get_confidence runs
         self.permit_train = False
 
-    def append(self, model, is_trained):
+    def append(self, model: keras.engine.functional.Functional, model_trained: bool) -> None:
         """
         Add model to the voting method
         """
         self.models.append(model)
-        self.is_trained.append(is_trained)
+        self.model_trained.append(model_trained)
         self.count += 1
 
-    def __train_model(self, i, **kwargs):
+    def __train_model(self, i: int, **kwargs: kwargus) -> None:
         """
         Train a model if it isn't trained already
         """
-        if not self.is_trained[i]:
+        if not self.model_trained[i]:
             self.need_confidence = True
-            self.is_trained[i] = True
-            self.models[i]
+            self.model_trained[i] = True
             self.models[i].trainable
             self.models[i].fit(**kwargs)
 
-    def train(self, **kwargs):
+    def train(self, **kwargs: kwargus) -> None:
         """
         Train all models in the class, **kwargs expect to receive the argus that can be directly sent to tf.fit
         Expected to be run after finishing compile
         """
         if not self.permit_train:
-            raise Exception("Needed to be compiled before training")
+            #raise Exception("Needed to be compiled before training")
+            raise ValueError()
         for i in range(self.count):
             if "verbose" in kwargs:
                 if kwargs["verbose"] == 1:
@@ -48,15 +53,15 @@ def train(self, **kwargs):
                 print("Model ", i + 1, "/", self.count, " is training...")
             self.__train_model(i, **kwargs)
 
-    def compile(self, **kwargs):
+    def compile(self, **kwargs: kwargus) -> None:
         """
         Compile code
         """
         self.permit_train = True
         for i in range(self.count):
             self.models[i].compile(**kwargs)
 
-    def __get_confidence(self, model_index, input):
+    def __get_confidence(self, model_index: int, input: NDArray) -> NDArray:
         """
         Get the confidence value that is needed by voting.
         Number of calling this function is reduced by self.need_confidence
@@ -73,65 +78,45 @@ def __get_confidence(self, model_index, input):
     More voting strategies can be added beneath, a single function, and a if function in self.predict
     """
 
-    def __voting_weight(self, array):
+    def __voting_weight(self, array: NDArray) -> NDArray:
         result = []
         for i in array:
             result.append(self.__voting_weight_single(i))
-        return result
+        return np.array(result)
 
-    def __voting_most(self, array):
-        result = []
-        for i in array:
-            result.append(self.__voting_most_single(i))
+    def __voting_average(self, array: NDArray) -> NDArray:
+        result = np.mean(array, axis=1)
         return result
 
-    def __voting_average(self, array):
-        result = []
-        for i in array:
-            result.append(self.__voting_average_single(i))
-        return result
-
-    def __voting_weight_single(self, array):
+    def __voting_weight_single(self, array: NDArray) -> float:
         opp_array = np.ones(len(array)) - array
         weight = np.absolute(opp_array - array)
         weight_sum = np.sum(weight)
         weight = weight / weight_sum
         result = array * weight
-        return np.sum(result)
-
-    def __voting_most_single(self, array):
-        weight = array.size
-        result = 0
-        for i in array:
-            result += i / weight
-        return result
-
-    def __voting_average_single(self, array):
-        result = array / array.size
-        return np.sum(result)
+        return float(np.sum(result))
 
-    def predict(self, input_data, voting_policy: str = "none"):
+    def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray:
         """
         Input data is expected to be a 2D array that the first layer is different input data (into the trained models)
         """
         if self.need_confidence:
             predictions = []
             for i in range(self.count):
                 predictions.append(np.array(self.__get_confidence(i, input_data)))
-            predictions = np.array(predictions)
-            self.predictions = np.transpose(predictions)
+            self.predictions = np.transpose(np.array(predictions))
         if voting_policy == "weight":
             return self.__voting_weight(self.predictions)
         elif voting_policy == "most":
-            return self.__voting_most(self.predictions)
+            return self.__voting_average(self.predictions)
         elif voting_policy == "average":
             return self.__voting_average(self.predictions)
-        elif voting_policy == "none":
+        elif voting_policy == "None" or voting_policy == "none":
             return self.predictions
         else:
-            raise Exception("voting_policy must be none, weight, most, or average")
+            raise ValueError()
 
-    def __acc_binarify(self, array):
+    def __acc_binarify(self, array: NDArray) -> NDArray:
         """
         Needed for ACC test
         """
@@ -140,20 +125,20 @@ def __acc_binarify(self, array):
             result.append(1 if (i > 0.5) else 0)
         return result
 
-    def __eval_accuracy(self, input_data):
+    def __eval_accuracy(self, input_data: NDArray) -> float:
         input_data[1] = self.__acc_binarify(input_data[1])
         algo = tf.keras.metrics.Accuracy()
         algo.reset_state()
         algo.update_state(input_data[0], input_data[1])
-        return algo.result().numpy()
+        return float(algo.result().numpy())
 
-    def __eval_auc(self, input_data):
+    def __eval_auc(self, input_data: NDArray) -> float:
         algo = tf.keras.metrics.AUC()
         algo.reset_state()
         algo.update_state(input_data[0], input_data[1])
-        return algo.result().numpy()
+        return float(algo.result().numpy())
 
-    def eval(self, input_data, evaluation_method: str = "acc"):
+    def eval(self, input_data: List[NDArray], evaluation_method: str = "acc") -> float:
         """
         Expect input data to be a 2D array, which a 1D array of yTrue followed by a 1D array of yPred is expected to be the components of the 2D array
         """
@@ -162,4 +147,4 @@ def eval(self, input_data, evaluation_method: str = "acc"):
         elif evaluation_method == "auc":
             return self.__eval_auc(input_data)
         else:
-            raise Exception("evaluation_method must be acc or auc")
+            raise ValueError()

tests/test_ensemble.py

@@ -1,7 +1,7 @@
-import tensorflow as tf
-import numpy as np
 import os
 import sys
+import tensorflow as tf
+import numpy as np
 
 thisfile = os.path.abspath(__file__)
 modulepath = os.path.dirname(os.path.dirname(thisfile))
@@ -13,13 +13,13 @@
 
 def test_ensemble_bagging():
     data_amount = 100  # Amount of data to be used
-    linear_demension = 4  # linear demension of the data
+    linear_dimension = 4  # linear demension of the data
     epochs = 10
     batch_size = 32
     lr = 1e-3
 
     x_train, y_train = (
-        np.ones([data_amount, linear_demension]),
+        np.ones([data_amount, linear_dimension]),
         np.ones([data_amount, 1]),
     )
 
@@ -29,7 +29,7 @@ def model():
         DROP = 0.1
 
         activation = "selu"
-        inputs = tf.keras.Input(shape=(linear_demension,), name="digits")
+        inputs = tf.keras.Input(shape=(linear_dimension,), name="digits")
         x0 = tf.keras.layers.Dense(
             1,
             kernel_regularizer=tf.keras.regularizers.l2(9.613e-06),
@@ -60,8 +60,9 @@ def model():
     )
 
     v_weight = obj_bagging.predict(x_train, "weight")
-    v_most = obj_bagging.predict(x_train, "most")
     v_average = obj_bagging.predict(x_train, "average")
     validation_data = []
     validation_data.append(obj_bagging.eval([y_train, v_weight], "acc"))
     validation_data.append(obj_bagging.eval([y_train, v_weight], "auc"))
+
+test_ensemble_bagging()