Update Algorithms

Author: carefree0910

Util/Util.py

@@ -149,7 +149,7 @@ def gen_xor(size=100, scale=1, one_hot=True):
         return np.c_[x, y].astype(np.float32), np.argmax(z, axis=1)
 
     @staticmethod
-    def gen_spin(size=50, n=7, n_class=7, scale=4, one_hot=True):
+    def gen_spiral(size=50, n=7, n_class=7, scale=4, one_hot=True):
         xs = np.zeros((size * n, 2), dtype=np.float32)
         ys = np.zeros(size * n, dtype=np.int8)
         for i in range(n):

Zhihu/NN/_extra/one/Test.py

@@ -1,29 +1,29 @@
-from Util.Util import DataUtil
-from Zhihu.NN._extra.one.Networks import *
-
-np.random.seed(142857)  # for reproducibility
-
-
-def main():
-
-    nn = NNDist()
-    epoch = 1000
-
-    timing = Timing(enabled=True)
-    timing_level = 1
-    nn.feed_timing(timing)
-
-    x, y = DataUtil.gen_spin(100)
-
-    nn.add(ReLU((x.shape[1], 24)))
-    nn.add(ReLU((24,)))
-    nn.add(Softmax((y.shape[1],)))
-
-    nn.fit(x, y, epoch=epoch)
-    nn.visualize_2d(x, y)
-    nn.evaluate(x, y)
-
-    timing.show_timing_log(timing_level)
-
-if __name__ == '__main__':
-    main()
+from Util.Util import DataUtil
+from Zhihu.NN._extra.one.Networks import *
+
+np.random.seed(142857)  # for reproducibility
+
+
+def main():
+
+    nn = NNDist()
+    epoch = 1000
+
+    timing = Timing(enabled=True)
+    timing_level = 1
+    nn.feed_timing(timing)
+
+    x, y = DataUtil.gen_spiral(100)
+
+    nn.add(ReLU((x.shape[1], 24)))
+    nn.add(ReLU((24,)))
+    nn.add(Softmax((y.shape[1],)))
+
+    nn.fit(x, y, epoch=epoch)
+    nn.visualize_2d(x, y)
+    nn.evaluate(x, y)
+
+    timing.show_timing_log(timing_level)
+
+if __name__ == '__main__':
+    main()

Zhihu/NN/_extra/two/Test.py

@@ -1,30 +1,30 @@
-from Zhihu.NN._extra.two.Networks import *
-
-from Util.Util import DataUtil
-
-np.random.seed(142857)  # for reproducibility
-
-
-def main():
-
-    nn = NNDist()
-    epoch = 1000
-
-    timing = Timing(enabled=True)
-    timing_level = 1
-    nn.feed_timing(timing)
-
-    x, y = DataUtil.gen_spin(100)
-
-    nn.add(ReLU((x.shape[1], 24)))
-    nn.add(ReLU((24,)))
-    nn.add(Softmax((y.shape[1],)))
-
-    nn.fit(x, y, epoch=epoch, verbose=2, metrics=["acc", "f1_score"], train_rate=0.8)
-    nn.draw_logs()
-    nn.visualize_2d(x, y)
-
-    timing.show_timing_log(timing_level)
-
-if __name__ == '__main__':
-    main()
+from Zhihu.NN._extra.two.Networks import *
+
+from Util.Util import DataUtil
+
+np.random.seed(142857)  # for reproducibility
+
+
+def main():
+
+    nn = NNDist()
+    epoch = 1000
+
+    timing = Timing(enabled=True)
+    timing_level = 1
+    nn.feed_timing(timing)
+
+    x, y = DataUtil.gen_spiral(100)
+
+    nn.add(ReLU((x.shape[1], 24)))
+    nn.add(ReLU((24,)))
+    nn.add(Softmax((y.shape[1],)))
+
+    nn.fit(x, y, epoch=epoch, verbose=2, metrics=["acc", "f1_score"], train_rate=0.8)
+    nn.draw_logs()
+    nn.visualize_2d(x, y)
+
+    timing.show_timing_log(timing_level)
+
+if __name__ == '__main__':
+    main()

Zhihu/NN/two/Test.py

@@ -1,25 +1,25 @@
-from Zhihu.NN.two.Network import *
-from Zhihu.NN.Layers import *
-
-from Util.Util import DataUtil
-
-np.random.seed(142857)  # for reproducibility
-
-
-def main():
-
-    nn = NNDist()
-    epoch = 1000
-
-    x, y = DataUtil.gen_spin(100)
-
-    nn.add(ReLU((x.shape[1], 24)))
-    nn.add(ReLU((24,)))
-    nn.add(CrossEntropy((y.shape[1],)))
-
-    nn.fit(x, y, epoch=epoch, verbose=2, metrics=["acc", "f1_score"], train_rate=0.8)
-    nn.draw_logs()
-    nn.visualize_2d(x, y)
-
-if __name__ == '__main__':
-    main()
+from Zhihu.NN.two.Network import *
+from Zhihu.NN.Layers import *
+
+from Util.Util import DataUtil
+
+np.random.seed(142857)  # for reproducibility
+
+
+def main():
+
+    nn = NNDist()
+    epoch = 1000
+
+    x, y = DataUtil.gen_spiral(100)
+
+    nn.add(ReLU((x.shape[1], 24)))
+    nn.add(ReLU((24,)))
+    nn.add(CrossEntropy((y.shape[1],)))
+
+    nn.fit(x, y, epoch=epoch, verbose=2, metrics=["acc", "f1_score"], train_rate=0.8)
+    nn.draw_logs()
+    nn.visualize_2d(x, y)
+
+if __name__ == '__main__':
+    main()

b_NaiveBayes/Original/Basic.py

@@ -1,90 +1,90 @@
-import numpy as np
-from math import pi, exp
-
-from Util.Timing import Timing
-from Util.Bases import ClassifierBase
-
-sqrt_pi = (2 * pi) ** 0.5
-
-
-class NBFunctions:
-    @staticmethod
-    def gaussian(x, mu, sigma):
-        return exp(-(x - mu) ** 2 / (2 * sigma ** 2)) / (sqrt_pi * sigma)
-
-    @staticmethod
-    def gaussian_maximum_likelihood(labelled_x, n_category, dim):
-
-        mu = [np.sum(
-            labelled_x[c][dim]) / len(labelled_x[c][dim]) for c in range(n_category)]
-        sigma = [np.sum(
-            (labelled_x[c][dim] - mu[c]) ** 2) / len(labelled_x[c][dim]) for c in range(n_category)]
-
-        def func(_c):
-            def sub(_x):
-                return NBFunctions.gaussian(_x, mu[_c], sigma[_c])
-            return sub
-
-        return [func(_c=c) for c in range(n_category)]
-
-
-class NaiveBayes(ClassifierBase):
-    NaiveBayesTiming = Timing()
-
-    def __init__(self, **kwargs):
-        super(NaiveBayes, self).__init__(**kwargs)
-        self._x = self._y = None
-        self._data = self._func = None
-        self._n_possibilities = None
-        self._labelled_x = self._label_zip = None
-        self._cat_counter = self._con_counter = None
-        self.label_dic = self._feat_dics = None
-
-        self._params["lb"] = kwargs.get("lb", 1)
-
-    def feed_data(self, x, y, sample_weight=None):
-        pass
-
-    def feed_sample_weight(self, sample_weight=None):
-        pass
-
-    @NaiveBayesTiming.timeit(level=2, prefix="[API] ")
-    def get_prior_probability(self, lb=1):
-        return [(_c_num + lb) / (len(self._y) + lb * len(self._cat_counter))
-                for _c_num in self._cat_counter]
-
-    @NaiveBayesTiming.timeit(level=2, prefix="[API] ")
-    def fit(self, x=None, y=None, sample_weight=None, lb=None):
-        if sample_weight is None:
-            sample_weight = self._params["sw"]
-        if lb is None:
-            lb = self._params["lb"]
-        if x is not None and y is not None:
-            self.feed_data(x, y, sample_weight)
-        self._func = self._fit(lb)
-
-    def _fit(self, lb):
-        pass
-
-    @NaiveBayesTiming.timeit(level=1, prefix="[API] ")
-    def predict_one(self, x, get_raw_result=False):
-        if type(x) is np.ndarray:
-            x = x.tolist()
-        else:
-            x = x[:]
-        x = self._transfer_x(x)
-        m_arg, m_probability = 0, 0
-        for i in range(len(self._cat_counter)):
-            p = self._func(x, i)
-            if p > m_probability:
-                m_arg, m_probability = i, p
-        if not get_raw_result:
-            return self.label_dic[m_arg]
-        return m_probability
-
-    @NaiveBayesTiming.timeit(level=3, prefix="[API] ")
-    def predict(self, x, get_raw_result=False):
-        return np.array([self.predict_one(xx, get_raw_result) for xx in x])
-
-    def _transfer_x(self, x):
-        return x
+import numpy as np
+from math import pi, exp
+
+from Util.Timing import Timing
+from Util.Bases import ClassifierBase
+
+sqrt_pi = (2 * pi) ** 0.5
+
+
+class NBFunctions:
+    @staticmethod
+    def gaussian(x, mu, sigma):
+        return exp(-(x - mu) ** 2 / (2 * sigma ** 2)) / (sqrt_pi * sigma)
+
+    @staticmethod
+    def gaussian_maximum_likelihood(labelled_x, n_category, dim):
+
+        mu = [np.sum(
+            labelled_x[c][dim]) / len(labelled_x[c][dim]) for c in range(n_category)]
+        sigma = [np.sum(
+            (labelled_x[c][dim] - mu[c]) ** 2) / len(labelled_x[c][dim]) for c in range(n_category)]
+
+        def func(_c):
+            def sub(x):
+                return NBFunctions.gaussian(x, mu[_c], sigma[_c])
+            return sub
+
+        return [func(_c=c) for c in range(n_category)]
+
+
+class NaiveBayes(ClassifierBase):
+    NaiveBayesTiming = Timing()
+
+    def __init__(self, **kwargs):
+        super(NaiveBayes, self).__init__(**kwargs)
+        self._x = self._y = None
+        self._data = self._func = None
+        self._n_possibilities = None
+        self._labelled_x = self._label_zip = None
+        self._cat_counter = self._con_counter = None
+        self.label_dic = self._feat_dics = None
+
+        self._params["lb"] = kwargs.get("lb", 1)
+
+    def feed_data(self, x, y, sample_weight=None):
+        pass
+
+    def feed_sample_weight(self, sample_weight=None):
+        pass
+
+    @NaiveBayesTiming.timeit(level=2, prefix="[API] ")
+    def get_prior_probability(self, lb=1):
+        return [(c_num + lb) / (len(self._y) + lb * len(self._cat_counter))
+                for c_num in self._cat_counter]
+
+    @NaiveBayesTiming.timeit(level=2, prefix="[API] ")
+    def fit(self, x=None, y=None, sample_weight=None, lb=None):
+        if sample_weight is None:
+            sample_weight = self._params["sw"]
+        if lb is None:
+            lb = self._params["lb"]
+        if x is not None and y is not None:
+            self.feed_data(x, y, sample_weight)
+        self._func = self._fit(lb)
+
+    def _fit(self, lb):
+        pass
+
+    @NaiveBayesTiming.timeit(level=1, prefix="[API] ")
+    def predict_one(self, x, get_raw_result=False):
+        if type(x) is np.ndarray:
+            x = x.tolist()
+        else:
+            x = x[:]
+        x = self._transfer_x(x)
+        m_arg, m_probability = 0, 0
+        for i in range(len(self._cat_counter)):
+            p = self._func(x, i)
+            if p > m_probability:
+                m_arg, m_probability = i, p
+        if not get_raw_result:
+            return self.label_dic[m_arg]
+        return m_probability
+
+    @NaiveBayesTiming.timeit(level=3, prefix="[API] ")
+    def predict(self, x, get_raw_result=False):
+        return np.array([self.predict_one(xx, get_raw_result) for xx in x])
+
+    def _transfer_x(self, x):
+        return x

b_NaiveBayes/Original/GaussianNB.py

@@ -23,7 +23,7 @@ def feed_data(self, x, y, sample_weight=None):
 
         self._x, self._y = x.T, y
         self._labelled_x, self._label_zip = labelled_x, labels
-        self._cat_counter, self.label_dic = cat_counter, {i: _l for _l, i in label_dic.items()}
+        self._cat_counter, self.label_dic = cat_counter, {i: l for l, i in label_dic.items()}
         self.feed_sample_weight(sample_weight)
 
     @GaussianNBTiming.timeit(level=1, prefix="[Core] ")
@@ -52,7 +52,7 @@ def func(input_x, tar_category):
 
     def visualize(self, save=False):
         colors = plt.cm.Paired([i / len(self.label_dic) for i in range(len(self.label_dic))])
-        colors = {_cat: _color for _cat, _color in zip(self.label_dic.values(), colors)}
+        colors = {cat: color for cat, color in zip(self.label_dic.values(), colors)}
         for j in range(len(self._x)):
             tmp_data = self._x[j]
             x_min, x_max = np.min(tmp_data), np.max(tmp_data)