Rename '*_dic' to '*_dict'

Author: carefree0910

Util/Bases.py

@@ -46,7 +46,7 @@ class ModelBase:
     clf_timing = Timing()
 
     def __init__(self, **kwargs):
-        self._plot_label_dic = {}
+        self._plot_label_dict = {}
         self._title = self._name = None
         self._metrics, self._available_metrics = [], {
             "acc": ClassifierBase.acc
@@ -135,9 +135,9 @@ def scatter2d(self, x, y, padding=0.5, title=None):
         y_max += y_padding
 
         if labels.ndim == 1:
-            if not self._plot_label_dic:
-                self._plot_label_dic = {c: i for i, c in enumerate(set(labels))}
-            dic = self._plot_label_dic
+            if not self._plot_label_dict:
+                self._plot_label_dict = {c: i for i, c in enumerate(set(labels))}
+            dic = self._plot_label_dict
             n_label = len(dic)
             labels = np.array([dic[label] for label in labels])
         else:
@@ -181,9 +181,9 @@ def scatter3d(self, x, y, padding=0.1, title=None):
 
         def transform_arr(arr):
             if arr.ndim == 1:
-                _dic = {c: i for i, c in enumerate(set(arr))}
-                n_dim = len(_dic)
-                arr = np.array([_dic[label] for label in arr])
+                dic = {c: i for i, c in enumerate(set(arr))}
+                n_dim = len(dic)
+                arr = np.array([dic[label] for label in arr])
             else:
                 n_dim = arr.shape[1]
                 arr = np.argmax(arr, axis=1)
@@ -197,15 +197,15 @@ def transform_arr(arr):
 
         labels, n_label = transform_arr(labels)
         colors = plt.cm.rainbow([i / n_label for i in range(n_label)])[labels]
-        _indices = [labels == i for i in range(n_label)]
-        _scatters = []
+        indices = [labels == i for i in range(n_label)]
+        scatters = []
         fig = plt.figure()
         plt.title(title)
         ax = fig.add_subplot(111, projection='3d')
-        for _index in _indices:
-            _scatters.append(ax.scatter(axis[0][_index], axis[1][_index], axis[2][_index], c=colors[_index]))
-        ax.legend(_scatters, ["$c_{}$".format("{" + str(i) + "}") for i in range(len(_scatters))],
-                  ncol=math.ceil(math.sqrt(len(_scatters))), fontsize=8)
+        for _index in indices:
+            scatters.append(ax.scatter(axis[0][_index], axis[1][_index], axis[2][_index], c=colors[_index]))
+        ax.legend(scatters, ["$c_{}$".format("{" + str(i) + "}") for i in range(len(scatters))],
+                  ncol=math.ceil(math.sqrt(len(scatters))), fontsize=8)
         plt.show()
 
     # Util
@@ -344,9 +344,9 @@ def get_base(_nx, _ny):
         z = self.predict(base_matrix).reshape((nx, ny))
 
         if labels.ndim == 1:
-            if not self._plot_label_dic:
-                self._plot_label_dic = {c: i for i, c in enumerate(set(labels))}
-            dic = self._plot_label_dic
+            if not self._plot_label_dict:
+                self._plot_label_dict = {c: i for i, c in enumerate(set(labels))}
+            dic = self._plot_label_dict
             n_label = len(dic)
             labels = np.array([dic[label] for label in labels])
         else:
@@ -366,9 +366,9 @@ def get_base(_nx, _ny):
             plt.contour(xf, yf, z, c='k-', levels=[0])
         plt.scatter(axis[0], axis[1], c=colors)
         if emphasize is not None:
-            _indices = np.array([False] * len(axis[0]))
-            _indices[np.asarray(emphasize)] = True
-            plt.scatter(axis[0][_indices], axis[1][_indices], s=80,
+            indices = np.array([False] * len(axis[0]))
+            indices[np.asarray(emphasize)] = True
+            plt.scatter(axis[0][indices], axis[1][indices], s=80,
                         facecolors="None", zorder=10)
         if extra is not None:
             plt.scatter(*np.asarray(extra).T, s=80, zorder=25, facecolors="red")
@@ -411,9 +411,9 @@ def get_base(_nx, _ny):
         print("Drawing figures...")
         xy_xf, xy_yf = np.meshgrid(xf, yf, sparse=True)
         if labels.ndim == 1:
-            if not self._plot_label_dic:
-                self._plot_label_dic = {c: i for i, c in enumerate(set(labels))}
-            dic = self._plot_label_dic
+            if not self._plot_label_dict:
+                self._plot_label_dict = {c: i for i, c in enumerate(set(labels))}
+            dic = self._plot_label_dict
             n_label = len(dic)
             labels = np.array([dic[label] for label in labels])
         else:
@@ -439,9 +439,9 @@ def get_base(_nx, _ny):
             plt.contour(xf, yf, z, c='k-', levels=[0])
         plt.scatter(axis[0], axis[1], c=colors)
         if emphasize is not None:
-            _indices = np.array([False] * len(axis[0]))
-            _indices[np.asarray(emphasize)] = True
-            plt.scatter(axis[0][_indices], axis[1][_indices], s=80,
+            indices = np.array([False] * len(axis[0]))
+            indices[np.asarray(emphasize)] = True
+            plt.scatter(axis[0][indices], axis[1][indices], s=80,
                         facecolors="None", zorder=10)
         if extra is not None:
             plt.scatter(*np.asarray(extra).T, s=80, zorder=25, facecolors="red")
@@ -503,9 +503,9 @@ def get_base(_nx, _ny, _nz):
 
         def transform_arr(arr):
             if arr.ndim == 1:
-                _dic = {c: i for i, c in enumerate(set(arr))}
-                n_dim = len(_dic)
-                arr = np.array([_dic[label] for label in arr])
+                dic = {c: i for i, c in enumerate(set(arr))}
+                n_dim = len(dic)
+                arr = np.array([dic[label] for label in arr])
             else:
                 n_dim = arr.shape[1]
                 arr = np.argmax(arr, axis=1)
@@ -566,9 +566,9 @@ def _draw(_ax, _x, _xf, _y, _yf, _z):
         def _emphasize(_ax, axis0, axis1, _c):
             _ax.scatter(axis0, axis1, c=_c)
             if emphasize is not None:
-                _indices = np.array([False] * len(axis[0]))
-                _indices[np.asarray(emphasize)] = True
-                _ax.scatter(axis0[_indices], axis1[_indices], s=80,
+                indices = np.array([False] * len(axis[0]))
+                indices[np.asarray(emphasize)] = True
+                _ax.scatter(axis0[indices], axis1[indices], s=80,
                             facecolors="None", zorder=10)
 
         def _extra(_ax, axis0, axis1, _c, _ex0, _ex1):

Util/Util.py

@@ -20,15 +20,6 @@
 
 
 class Util:
-    @staticmethod
-    def get_and_pop(dic, key, default):
-        try:
-            val = dic[key]
-            dic.pop(key)
-        except KeyError:
-            val = default
-        return val
-
     @staticmethod
     def callable(obj):
         _str_obj = str(obj)
@@ -123,14 +114,14 @@ def get_dataset(name, path, train_num=None, tar_idx=None, shuffle=True,
             if train_num is None:
                 return x, y
             return (x[:train_num], y[:train_num]), (x[train_num:], y[train_num:])
-        x, y, wc, features, feat_dics, label_dic = DataUtil.quantize_data(x, y, **kwargs)
+        x, y, wc, features, feat_dicts, label_dict = DataUtil.quantize_data(x, y, **kwargs)
         if one_hot:
             y = (y[..., None] == np.arange(np.max(y)+1)).astype(np.int8)
         if train_num is None:
-            return x, y, wc, features, feat_dics, label_dic
+            return x, y, wc, features, feat_dicts, label_dict
         return (
             (x[:train_num], y[:train_num]), (x[train_num:], y[train_num:]),
-            wc, features, feat_dics, label_dic
+            wc, features, feat_dicts, label_dict
         )
 
     @staticmethod
@@ -205,34 +196,34 @@ def quantize_data(x, y, wc=None, continuous_rate=0.1, separate=False):
             wc = np.array([False] * len(xt))
         else:
             wc = np.asarray(wc)
-        feat_dics = [{_l: i for i, _l in enumerate(feats)} if not wc[i] else None
+        feat_dicts = [{_l: i for i, _l in enumerate(feats)} if not wc[i] else None
                      for i, feats in enumerate(features)]
         if not separate:
             if np.all(~wc):
                 dtype = np.int
             else:
                 dtype = np.float32
-            x = np.array([[feat_dics[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
+            x = np.array([[feat_dicts[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
                           for sample in x], dtype=dtype)
         else:
-            x = np.array([[feat_dics[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
+            x = np.array([[feat_dicts[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
                           for sample in x], dtype=np.float32)
             x = (x[:, ~wc].astype(np.int), x[:, wc])
-        label_dic = {l: i for i, l in enumerate(set(y))}
-        y = np.array([label_dic[yy] for yy in y], dtype=np.int8)
-        label_dic = {i: l for l, i in label_dic.items()}
-        return x, y, wc, features, feat_dics, label_dic
+        label_dict = {l: i for i, l in enumerate(set(y))}
+        y = np.array([label_dict[yy] for yy in y], dtype=np.int8)
+        label_dict = {i: l for l, i in label_dict.items()}
+        return x, y, wc, features, feat_dicts, label_dict
 
     @staticmethod
-    def transform_data(x, y, wc, feat_dics, label_dic):
+    def transform_data(x, y, wc, feat_dicts, label_dict):
         if np.all(~wc):
             dtype = np.int
         else:
             dtype = np.float32
-        label_dic = {l: i for i, l in label_dic.items()}
-        x = np.array([[feat_dics[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
+        label_dict = {l: i for i, l in label_dict.items()}
+        x = np.array([[feat_dicts[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
                       for sample in x], dtype=dtype)
-        y = np.array([label_dic[yy] for yy in y], dtype=np.int8)
+        y = np.array([label_dict[yy] for yy in y], dtype=np.int8)
         return x, y
 
 
@@ -338,9 +329,9 @@ def make_mp4(ims, name="", fps=20, scale=1, extend=30):
 
 
 class Overview:
-    def __init__(self, label_dic, shape=(1440, 576)):
+    def __init__(self, label_dict, shape=(1440, 576)):
         self.shape = shape
-        self.label_dic = label_dic
+        self.label_dict = label_dict
         self.n_col = self.n_row = 0
         self.ans = self.pred = self.results = self.prob = None
 
@@ -354,7 +345,7 @@ def _get_detail(self, event, x, y, *_):
                 title = "Detail (prob: {:6.4})".format(prob)
             else:
                 title = "True label: {} (prob: {:6.4})".format(
-                    self.label_dic[self.ans[idx]], prob)
+                    self.label_dict[self.ans[idx]], prob)
             while 1:
                 cv2.imshow(title, self.results[idx])
                 if cv2.waitKey(20) & 0xFF == 27:
@@ -377,7 +368,7 @@ def _get_results(self, ans, y_pred, images):
         for i, img in enumerate(images):
             pred = y_pred[i]
             indices = np.argsort(pred)[-3:][::-1]
-            ps, labels = pred[indices], self.label_dic[indices]
+            ps, labels = pred[indices], self.label_dict[indices]
             if true_classes is None:
                 color = np.array([255, 255, 255], dtype=np.uint8)
             else:

Zhihu/CvDTree/three/CvDTree.py

@@ -90,7 +90,7 @@ def __init__(self, tree=None, base=2, ent=None,
         self._prev_feat = prev_feat
         self.leafs = {}
         self.pruned = False
-        self.label_dic = {}
+        self.label_dict = {}
 
     def __getitem__(self, item):
         if isinstance(item, str):
@@ -105,7 +105,7 @@ def __str__(self):
             return "CvDNode ({}) ({} -> {})".format(
                 self._depth, self._prev_feat, self.feature_dim)
         return "CvDNode ({}) ({} -> class: {})".format(
-            self._depth, self._prev_feat, self.label_dic[self.category])
+            self._depth, self._prev_feat, self.label_dict[self.category])
 
     __repr__ = __str__
 
@@ -128,7 +128,7 @@ def prev_feat(self):
         return self._prev_feat
 
     @property
-    def info_dic(self):
+    def info_dict(self):
         return {
             "ent": self.ent,
             "labels": self.labels
@@ -163,25 +163,25 @@ def get_class(self):
 
     def _gen_children(self, feat, con_chaos):
         features = self._data[:, feat]
-        _new_feats = self.feats[:]
-        _new_feats.remove(feat)
+        new_feats = self.feats[:]
+        new_feats.remove(feat)
         for feat in set(features):
-            _feat_mask = features == feat
-            _new_node = self.__class__(
+            feat_mask = features == feat
+            new_node = self.__class__(
                 self.tree, self._base, ent=con_chaos,
                 depth=self._depth + 1, parent=self, is_root=False, prev_feat=feat)
-            _new_node.feats = _new_feats
-            _new_node.label_dic = self.label_dic
-            self.children[feat] = _new_node
-            _local_weights = None if self.sample_weights is None else self.sample_weights[_feat_mask]
-            _new_node.fit(self._data[_feat_mask, :], self.labels[_feat_mask], _local_weights)
+            new_node.feats = new_feats
+            new_node.label_dict = self.label_dict
+            self.children[feat] = new_node
+            _local_weights = None if self.sample_weights is None else self.sample_weights[feat_mask]
+            new_node.fit(self._data[feat_mask, :], self.labels[feat_mask], _local_weights)
 
     def _handle_terminate(self):
         self.category = self.get_class()
-        _parent = self
-        while _parent is not None:
-            _parent.leafs[self.key] = self.info_dic
-            _parent = _parent.parent
+        parent = self
+        while parent is not None:
+            parent.leafs[self.key] = self.info_dict
+            parent = parent.parent
 
     def fit(self, data, labels, sample_weights, eps=1e-8):
         if data is not None and labels is not None:
@@ -212,7 +212,7 @@ def prune(self):
         while _parent is not None:
             for _k in _pop_lst:
                 _parent.leafs.pop(_k)
-            _parent.leafs[self.key] = self.info_dic
+            _parent.leafs[self.key] = self.info_dict
             _parent = _parent.parent
         self.mark_pruned()
         self.children = {}
@@ -265,7 +265,7 @@ def __init__(self, max_depth=None, node=None):
         self._max_depth = max_depth
         self.root = node
         self.root.feed_tree(self)
-        self.label_dic = {}
+        self.label_dict = {}
         self.prune_alpha = 1
 
     def __str__(self):
@@ -282,11 +282,11 @@ def acc(y, y_pred):
         return np.sum(np.array(y) == np.array(y_pred)) / len(y)
 
     def fit(self, data=None, labels=None, sample_weights=None, eps=1e-8, **kwargs):
-        _dic = {c: i for i, c in enumerate(set(labels))}
-        labels = np.array([_dic[yy] for yy in labels])
-        self.label_dic = {value: key for key, value in _dic.items()}
+        dic = {c: i for i, c in enumerate(set(labels))}
+        labels = np.array([dic[yy] for yy in labels])
+        self.label_dict = {value: key for key, value in dic.items()}
         data = np.array(data)
-        self.root.label_dic = self.label_dic
+        self.root.label_dict = self.label_dict
         self.root.feats = [i for i in range(data.shape[1])]
         self.root.fit(data, labels, sample_weights, eps)
         self.prune_alpha = kwargs.get("alpha", self.prune_alpha)
@@ -318,7 +318,7 @@ def prune(self):
 
     def predict_one(self, x, transform=True):
         if transform:
-            return self.label_dic[self.root.predict_one(x)]
+            return self.label_dict[self.root.predict_one(x)]
         return self.root.predict_one(x)
 
     def predict(self, x, transform=True):
@@ -357,7 +357,7 @@ def draw(self, radius=24, width=1200, height=800, padding=0.2, plot_num=30, titl
                     text = str(node.feature_dim)
                     color = (0, 0, 255)
                 else:
-                    text = str(self.label_dic[node.category])
+                    text = str(self.label_dict[node.category])
                     color = (0, 255, 0)
                 cv2.putText(img, text, (x-7*len(text)+2, y+3), cv2.LINE_AA, 0.6, color, 1)