ver 0.15.12 added many vector viz features

Author: AnonymousCKNN

npy/__init__.py

@@ -8,3 +8,4 @@
 from . import ex
 from . import calc
 from . import data
+from . import viz

npy/tools/tsne.py

@@ -1,5 +1,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
+from ..utils import index_l_of_d
 from .multirank.modify import flatten_vectors, unflatten_vectors
 from .multirank.recursive import get_lengths
 
@@ -30,7 +31,7 @@ def draw_tsne(X, n=4, **kwargs):  # [C, N, D]
     for c in range(C):
         print(c, len(emb[c]))
 
-        _kwargs = {k: v[c] if isinstance(v, list) else v for k, v in kwargs.items()}
+        _kwargs = index_l_of_d(kwargs, c)
         plt.scatter(*emb[c].T, s=10, **_kwargs)
 
 

npy/utils/__init__.py

@@ -8,3 +8,4 @@
 from .utils_info import *
 from .utils_mask import *
 from .utils_decorator import *
+from . import multirank

npy/utils/multirank/__init__.py

@@ -0,0 +1,3 @@
+from .basic import *
+from .modify import *
+from . import recursive

npy/utils/multirank/basic.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+__all__ = ['is_array', 'is_singleton', 'is_vector', 'is_matrix', 'is_multirank', 'argmin', 'argmax']
+
+
+def is_array(v):
+    return isinstance(v, list) or isinstance(v, np.ndarray)
+
+
+def is_singleton(v):
+    return not is_array(v)
+
+
+def is_vector(X):
+    if is_singleton(X):
+        return False
+    return is_singleton(X[0])
+
+
+def is_matrix(X):
+    if is_singleton(X):
+        return False
+    return is_vector(X[0])
+
+
+def is_multirank(X):
+    if is_singleton(X):
+        return False
+    return is_matrix(X)
+
+
+#########
+
+def argmin(X):
+    ind = np.argmin(X)
+    return np.unravel_index(ind, X.shape)
+
+
+def argmax(X):
+    ind = np.argmax(X)
+    return np.unravel_index(ind, X.shape)

npy/utils/multirank/modify.py

@@ -0,0 +1,31 @@
+import numpy as np
+from .basic import *
+from .recursive import get_sum, iter_vector
+
+__all__ = ['unflatten_vectors', 'flatten_vectors']
+
+
+def unflatten_vectors(X, Ns):
+    if is_vector(Ns):
+        if len(Ns) == 1:
+            return [X]
+        else:
+            Ncum = np.cumsum(Ns)
+            return np.split(X, Ncum[:-1])
+    else:
+        if len(Ns) == 1:
+            return [unflatten_vectors(X, Ns[0])]
+        else:
+            Nsub = [get_sum(Nss) for Nss in Ns]
+            Ncum = np.cumsum(Nsub)
+            Xsplit = np.split(X, Ncum[:-1])
+            return [
+                unflatten_vectors(Xone, Nss) for Xone, Nss in zip(Xsplit, Ns)
+            ]
+
+
+def flatten_vectors(X):  # [N1, ..., N2, D] -> [N, D]
+    ret = list()
+    for vec in iter_vector(X):
+        ret.append(vec)
+    return np.stack(ret)

npy/utils/multirank/recursive.py

@@ -0,0 +1,58 @@
+import numpy as np
+from .basic import *
+
+__all__ = ['get_D', 'get_lengths', 'get_sum', 'get_dtype',
+           'equal', 'iter_vector', 'iter_element']
+
+
+def get_D(X):
+    if is_vector(X):
+        return len(X)
+    else:
+        return get_D(X[0])
+
+
+def get_lengths(X):
+    if is_matrix(X):
+        return len(X)
+    else:
+        return [get_lengths(x) for x in X]
+
+
+def get_sum(X):
+    if is_singleton(X):
+        return X
+    else:
+        return sum([get_sum(x) for x in X])
+
+
+def get_dtype(X):
+    if is_singleton(X):
+        return type(X)
+    else:
+        return get_dtype(X[0])
+
+
+def equal(X1, X2):
+    if is_singleton(X1) or is_singleton(X2):
+        return X1 == X2
+    else:
+        if len(X1) != len(X2):
+            return False
+        return all([equal(x1, x2) for x1, x2 in zip(X1, X2)])
+
+
+def iter_vector(X):
+    if is_vector(X):
+        yield X
+    else:
+        for x in X:
+            yield from iter_vector(x)
+
+
+def iter_element(X):
+    if is_singleton(X):
+        yield X
+    else:
+        for x in X:
+            yield from iter_element(x)

npy/utils/utils_primitive/utils_dict.py

@@ -4,7 +4,7 @@
 __all__ = ['keys_d_of_l_of_num', 'keys_d_of_num',
            'append_d_of_l', 'inv_d', 'replace_keys', 'drop_keys',
            'filter_d_of_l_of_num', 'filter_d_of_num', 'filter_keys', 'filter_empty',
-           'dict_eq', 'l_of_dict_eq', 'add_d_of_l', 'merge_l_of_d'
+           'dict_eq', 'l_of_dict_eq', 'add_d_of_l', 'merge_l_of_d', 'index_l_of_d',
            ]
 
 
@@ -142,3 +142,10 @@ def l_of_dict_eq(l1: list, l2: list) -> bool:
     if len(l1) != len(l2):
         return False
     return all([dict_eq(d1, d2) for d1, d2 in zip(l1, l2)])
+
+
+############
+
+def index_l_of_d(d, i):
+    _kwargs = {k: v[i] if isinstance(v, list) else v for k, v in d.items()}
+    return _kwargs

npy/viz/__init__.py

@@ -0,0 +1,2 @@
+from . import scatter
+from . import hist

npy/viz/hist.py

@@ -0,0 +1,40 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from ..utils import multirank, index_l_of_d
+
+__all__ = ['plot', 'plot_std_of_each_dim', 'plot_norm_of_each_vec']
+
+
+def plot(X, ax=None, bins=50, **kwargs):
+    if ax is None:
+        fig, ax = plt.subplots()
+
+    if multirank.is_matrix(X):  # X [C, N]
+        C = len(X)
+        for c in range(C):
+            _kwargs = index_l_of_d(kwargs, c)
+            ax.hist(X[c], bins=bins, **_kwargs)
+
+    else:  # X [N]
+        ax.hist(X, bins=bins, **kwargs)
+    return ax
+
+
+def plot_std_of_each_dim(X, ax=None, bins=50, **kwargs):
+    if multirank.is_multirank(X):  # X [C, N, D]
+        C = len(X)
+        stds = [np.std(X[c], axis=0) for c in range(C)]
+    else:  # X [C, N]
+        stds = np.std(X, axis=0)
+
+    return plot(stds, ax=ax, bins=bins, **kwargs)
+
+
+def plot_norm_of_each_vec(X, ax=None, bins=50, **kwargs):
+    if multirank.is_multirank(X):  # X [C, N, D]
+        C = len(X)
+        norms = [np.linalg.norm(X[c], axis=-1) for c in range(C)]
+    else:  # X [C, N]
+        norms = np.linalg.norm(X, axis=-1)
+
+    return plot(norms, ax=ax, bins=bins, **kwargs)