Update Algorithms

Author: carefree0910

.idea/workspace.xml

@@ -3,7 +3,6 @@
 import pickle
 import numpy as np
 from abc import ABCMeta
-from copy import deepcopy
 from math import pi, sqrt, ceil
 import matplotlib.pyplot as plt
 
@@ -236,7 +235,7 @@ def wrapper(func, instance, args, kwargs):
     def timings(self):
         return self._timings
 
-    def show_timing_log(self, level):
+    def show_timing_log(self, level=2):
         print()
         print("=" * 110 + "\n" + "Timing log\n" + "-" * 110)
         if not self.timings:
@@ -358,10 +357,44 @@ def start(self):
         self._flush()
 
 
+class TimingMeta(type):
+    def __new__(mcs, *args, **kwargs):
+        name, bases, attr = args[:3]
+        try:
+            _timing = attr[name + "Timing"]
+        except KeyError:
+            _timing = Timing()
+            attr[name + "Timing"] = _timing
+
+        for _name, _value in attr.items():
+            if "__" in _name or "timing" in _name or "estimate" in _name:
+                continue
+            _str_val = str(_value)
+            if "<" not in _str_val and ">" not in _str_val:
+                continue
+            if _str_val.find("function") >= 0 or _str_val.find("staticmethod") >= 0 or _str_val.find("property") >= 0:
+                attr[_name] = _timing.timeit(level=2)(_value)
+
+        def feed_timing(self, timing):
+            setattr(self, name + "Timing", timing)
+
+        def show_timing_log(self, level=2):
+            getattr(self, name + "Timing").show_timing_log(level)
+
+        attr["feed_timing"] = feed_timing
+        attr["show_timing_log"] = show_timing_log
+
+        return type(name, bases, attr)
+
+
 class ClassifierMeta(type):
     def __new__(mcs, *args, **kwargs):
         name, bases, attr = args[:3]
-        clf_timing = attr[name + "Timing"]
+        try:
+            clf_timing = attr[name + "Timing"]
+        except KeyError:
+            clf_timing = Timing()
+            attr[name + "Timing"] = clf_timing
 
         def __str__(self):
             try:
@@ -441,12 +474,22 @@ def show_timing_log(self, level=2):
         return type(name, bases, attr)
 
 
-class TimingMeta(type):
+class SubClassTimingMeta(type):
     def __new__(mcs, *args, **kwargs):
         name, bases, attr = args[:3]
-        timing = getattr(bases[0], bases[0].__name__ + "Timing")
-        attr = {_name: timing.timeit(level=2)(_value) if "__" not in _name else _value
-                for _name, _value in attr.items()}
+        try:
+            timing = getattr(bases[0], bases[0].__name__ + "Timing")
+        except AttributeError:
+            timing = Timing()
+            setattr(bases[0], bases[0].__name__ + "Timing", timing)
+        for _name, _value in attr.items():
+            if "__" in _name or "timing" in _name or "estimate" in _name:
+                continue
+            _str_val = str(_value)
+            if "<" not in _str_val and ">" not in _str_val:
+                continue
+            if _str_val.find("function") >= 0 or _str_val.find("staticmethod") >= 0 or _str_val.find("property") >= 0:
+                attr[_name] = timing.timeit(level=2)(_value)
         return type(name, bases, attr)
 
 

Util.py

@@ -3,11 +3,47 @@
 from abc import ABCMeta
 import matplotlib.pyplot as plt
 
+from Util import Timing
+
+
+class TimingMeta(type):
+    def __new__(mcs, *args, **kwargs):
+        name, bases, attr = args[:3]
+        try:
+            _timing = attr[name + "Timing"]
+        except KeyError:
+            _timing = Timing()
+            attr[name + "Timing"] = _timing
+
+        for _name, _value in attr.items():
+            if "__" in _name or "timing" in _name or "estimate" in _name:
+                continue
+            _str_val = str(_value)
+            if "<" not in _str_val and ">" not in _str_val:
+                continue
+            if _str_val.find("function") >= 0 or _str_val.find("staticmethod") >= 0 or _str_val.find("property") >= 0:
+                attr[_name] = _timing.timeit(level=2)(_value)
+
+        def feed_timing(self, timing):
+            setattr(self, name + "Timing", timing)
+
+        def show_timing_log(self, level=2):
+            getattr(self, name + "Timing").show_timing_log(level)
+
+        attr["feed_timing"] = feed_timing
+        attr["show_timing_log"] = show_timing_log
+
+        return type(name, bases, attr)
+
 
 class ClassifierMeta(type):
     def __new__(mcs, *args, **kwargs):
         name, bases, attr = args[:3]
-        clf_timing = attr[name + "Timing"]
+        try:
+            clf_timing = attr[name + "Timing"]
+        except KeyError:
+            clf_timing = Timing()
+            attr[name + "Timing"] = clf_timing
 
         def __str__(self):
             try:
@@ -27,7 +63,12 @@ def estimate(self, x, y):
             print("Acc: {:8.6} %".format(100 * np.sum(self.predict(x) == np.array(y)) / len(y)))
 
         def visualize2d(self, x, y, dense=100):
-            axis, y = np.array(x).T, np.array(y)
+            length = len(x)
+            axis = np.array([[.0] * length, [.0] * length])
+            for i, xx in enumerate(x):
+                axis[0][i] = xx[0]
+                axis[1][i] = xx[1]
+            xs, ys = np.array(x), np.array(y)
 
             print("=" * 30 + "\n" + str(self))
             decision_function = lambda _xx: self.predict(_xx)
@@ -62,7 +103,7 @@ def get_base(_nx, _ny):
             plt.figure()
             plt.pcolormesh(xy_xf, xy_yf, z > 0, cmap=plt.cm.Paired)
             plt.contour(xf, yf, z, c='k-', levels=[0])
-            plt.scatter(axis[0], axis[1], c=[colors[yy] for yy in y])
+            plt.scatter(axis[0], axis[1], c=[colors[y] for y in ys])
             plt.xlim(x_min, x_max)
             plt.ylim(y_min, y_max)
             plt.show()
@@ -82,12 +123,22 @@ def show_timing_log(self, level=2):
         return type(name, bases, attr)
 
 
-class TimingMeta(type):
+class SubClassTimingMeta(type):
     def __new__(mcs, *args, **kwargs):
         name, bases, attr = args[:3]
-        timing = getattr(bases[0], bases[0].__name__ + "Timing")
-        attr = {_name: timing.timeit(level=2)(_value) if "__" not in _name else _value
-                for _name, _value in attr.items()}
+        try:
+            timing = getattr(bases[0], bases[0].__name__ + "Timing")
+        except AttributeError:
+            timing = Timing()
+            setattr(bases[0], bases[0].__name__ + "Timing", timing)
+        for _name, _value in attr.items():
+            if "__" in _name or "timing" in _name or "estimate" in _name:
+                continue
+            _str_val = str(_value)
+            if "<" not in _str_val and ">" not in _str_val:
+                continue
+            if _str_val.find("function") >= 0 or _str_val.find("staticmethod") >= 0 or _str_val.find("property") >= 0:
+                attr[_name] = timing.timeit(level=2)(_value)
         return type(name, bases, attr)
 
 

Zhihu/Python/Utils/clf_metas.py

@@ -47,7 +47,7 @@ def wrapper(func, instance, args, kwargs):
     def timings(self):
         return self._timings
 
-    def show_timing_log(self, level):
+    def show_timing_log(self, level=2):
         print()
         print("=" * 110 + "\n" + "Timing log\n" + "-" * 110)
         if not self.timings:

Zhihu/Python/Utils/timing.py

@@ -0,0 +1,139 @@
+import time
+import wrapt
+
+
+class Timing:
+    _timings = {}
+    _enabled = False
+
+    def __init__(self, enabled=True):
+        Timing._enabled = enabled
+
+    def __str__(self):
+        return "Timing"
+
+    __repr__ = __str__
+
+    @staticmethod
+    def timeit(level=0, name=None, cls_name=None, prefix="[Method] "):
+        @wrapt.decorator
+        def wrapper(func, instance, args, kwargs):
+            if not Timing._enabled:
+                return func(*args, **kwargs)
+            if instance is not None:
+                instance_name = "{:>18s}".format(str(instance))
+            else:
+                instance_name = " " * 18 if cls_name is None else "{:>18s}".format(cls_name)
+            _prefix = "{:>26s}".format(prefix)
+            func_name = "{:>28}".format(func.__name__ if name is None else name)
+            _name = instance_name + _prefix + func_name
+            _t = time.time()
+            rs = func(*args, **kwargs)
+            _t = time.time() - _t
+            try:
+                Timing._timings[_name]["timing"] += _t
+                Timing._timings[_name]["call_time"] += 1
+            except KeyError:
+                Timing._timings[_name] = {
+                    "level": level,
+                    "timing": _t,
+                    "call_time": 1
+                }
+            return rs
+
+        return wrapper
+
+    @property
+    def timings(self):
+        return self._timings
+
+    def show_timing_log(self, level=2):
+        print()
+        print("=" * 110 + "\n" + "Timing log\n" + "-" * 110)
+        if not self.timings:
+            print("None")
+        else:
+            for key in sorted(self.timings.keys()):
+                timing_info = self.timings[key]
+                if level >= timing_info["level"]:
+                    print("{:<42s} :  {:12.7} s (Call Time: {:6d})".format(
+                        key, timing_info["timing"], timing_info["call_time"]))
+        print("-" * 110)
+
+
+class TimingBase:
+    def feed_timing(self, timing):
+        pass
+
+    def show_timing_log(self, level=2):
+        pass
+
+
+class TimingMeta(type):
+    def __new__(mcs, *args, **kwargs):
+        name, bases, attr = args[:3]
+        try:
+            _timing = attr[name + "Timing"]
+        except KeyError:
+            _timing = Timing()
+            attr[name + "Timing"] = _timing
+
+        for _name, _value in attr.items():
+            if "__" in _name or "timing" in _name or "estimate" in _name:
+                continue
+            _str_val = str(_value)
+            if "<" not in _str_val and ">" not in _str_val:
+                continue
+            if _str_val.find("function") >= 0 or _str_val.find("staticmethod") >= 0 or _str_val.find("property") >= 0:
+                attr[_name] = _timing.timeit(level=2)(_value)
+
+        def feed_timing(self, timing):
+            setattr(self, name + "Timing", timing)
+
+        def show_timing_log(self, level=2):
+            getattr(self, name + "Timing").show_timing_log(level)
+
+        attr["feed_timing"] = feed_timing
+        attr["show_timing_log"] = show_timing_log
+
+        return type(name, bases, attr)
+
+
+class Test(TimingBase, metaclass=TimingMeta):
+
+    @staticmethod
+    def test1():
+        for i in range(10 ** 7):
+            pass
+
+    @staticmethod
+    def test2():
+        for i in range(10 ** 7):
+            _ = 1
+
+    @staticmethod
+    def test3():
+        for i in range(10 ** 7):
+            pass
+            pass
+
+    @staticmethod
+    def test4():
+        for i in range(10 ** 7):
+            _ = 1
+            _ = 2
+
+    @staticmethod
+    def test5():
+        for i in range(10 ** 7):
+            _ = 1
+            _ = 1
+
+if __name__ == '__main__':
+    test = Test()
+    test.test1()
+    test.test2()
+    test.test3()
+    test.test4()
+    test.test5()
+    test.show_timing_log()

Zhihu/Python/timing_meta_example.py

@@ -1,10 +1,10 @@
 import matplotlib.pyplot as plt
 
 from b_NaiveBayes.Vectorized.Basic import *
-from Util import TimingMeta
+from Util import SubClassTimingMeta
 
 
-class GaussianNB(NaiveBayes, metaclass=TimingMeta):
+class GaussianNB(NaiveBayes, metaclass=SubClassTimingMeta):
 
     def feed_data(self, x, y, sample_weights=None):
         if sample_weights is not None:

__pycache__/Util.cpython-35.pyc

@@ -1,10 +1,10 @@
 from b_NaiveBayes.Vectorized.Basic import *
 from b_NaiveBayes.Vectorized.MultinomialNB import MultinomialNB
 from b_NaiveBayes.Vectorized.GaussianNB import GaussianNB
-from Util import DataUtil, TimingMeta
+from Util import DataUtil, SubClassTimingMeta
 
 
-class MergedNB(NaiveBayes, metaclass=TimingMeta):
+class MergedNB(NaiveBayes, metaclass=SubClassTimingMeta):
 
     def __init__(self, whether_continuous=None):
         NaiveBayes.__init__(self)

b_NaiveBayes/Original/__pycache__/Basic.cpython-35.pyc

@@ -1,10 +1,10 @@
 import matplotlib.pyplot as plt
 
 from b_NaiveBayes.Vectorized.Basic import *
-from Util import DataUtil, TimingMeta
+from Util import DataUtil, SubClassTimingMeta
 
 
-class MultinomialNB(NaiveBayes, metaclass=TimingMeta):
+class MultinomialNB(NaiveBayes, metaclass=SubClassTimingMeta):
 
     def feed_data(self, x, y, sample_weights=None):
         if sample_weights is not None: