black formatting

Author: martinalex000

bhc/api.py

@@ -6,13 +6,15 @@
 
 
 class Result(object):
-    def __init__(self,
-                 arc_list,
-                 node_ids,
-                 last_log_p,
-                 weights,
-                 hierarchy_cut,
-                 n_clusters):
+    def __init__(
+        self,
+        arc_list,
+        node_ids,
+        last_log_p,
+        weights,
+        hierarchy_cut,
+        n_clusters,
+    ):
         self.arc_list = arc_list
         self.node_ids = node_ids
         self.last_log_p = last_log_p
@@ -30,23 +32,20 @@ def __eq__(self, other):
         return self.source == other.source and self.target == other.target
 
     def __repr__(self):
-        return '{0} -> {1}'.format(str(self.source), str(self.target))
+        return "{0} -> {1}".format(str(self.source), str(self.target))
 
 
 class AbstractPrior(ABC):
     @abstractmethod
-    def calc_log_mlh(self, x_mat):
-        ...
+    def calc_log_mlh(self, x_mat): ...
 
 
 class AbstractHierarchicalClustering(ABC):
     @abstractmethod
-    def build(self):
-        ...
+    def build(self): ...
 
 
-class AbstractBayesianBasedHierarchicalClustering(
-        AbstractHierarchicalClustering, ABC):
+class AbstractBayesianBasedHierarchicalClustering(AbstractHierarchicalClustering, ABC):
     def __init__(self, data, model, alpha, cut_allowed):
         self.data = data
         self.model = model

bhc/core/bhc.py

@@ -8,8 +8,7 @@
 import bhc.api as api
 
 
-class BayesianHierarchicalClustering(
-        api.AbstractBayesianBasedHierarchicalClustering):
+class BayesianHierarchicalClustering(api.AbstractBayesianBasedHierarchicalClustering):
     """
     Reference: HELLER, Katherine A.; GHAHRAMANI, Zoubin.
                Bayesian hierarchical clustering.
@@ -26,7 +25,7 @@ def build(self):
 
         weights = []
 
-        # active nodes
+        # active nodes (all)
         active_nodes = np.arange(n_objects)
         # assignments - starting each point in its own cluster
         assignments = np.arange(n_objects)
@@ -41,7 +40,8 @@ def build(self):
         for i in range(n_objects):
             # compute log(d_k)
             log_d[i] = BayesianHierarchicalClustering.__calc_log_d(
-                self.alpha, n[i], None)
+                self.alpha, n[i], None
+            )
             # compute log(p_i)
             log_p[i] = self.model.calc_log_mlh(self.data[i])
 
@@ -54,7 +54,8 @@ def build(self):
                 n_ch = n[i] + n[j]
                 log_d_ch = log_d[i] + log_d[j]
                 log_dk = BayesianHierarchicalClustering.__calc_log_d(
-                    self.alpha, n_ch, log_d_ch)
+                    self.alpha, n_ch, log_d_ch
+                )
                 # compute log(pi_k)
                 log_pik = np.log(self.alpha) + gammaln(n_ch) - log_dk
                 # compute log(p_k)
@@ -67,8 +68,11 @@ def build(self):
                 log_r = r1 - r2
                 # store results
                 merge_info = [i, j, log_r, r1, r2]
-                tmp_merge = merge_info if tmp_merge is None \
+                tmp_merge = (
+                    merge_info
+                    if tmp_merge is None
                     else np.vstack((tmp_merge, merge_info))
+                )
 
         # find clusters to merge
         arc_list = np.empty(0, dtype=api.Arc)
@@ -100,7 +104,8 @@ def build(self):
             # compute log(d_ij)
             log_d_ch = log_d[i] + log_d[j]
             log_d_ij = BayesianHierarchicalClustering.__calc_log_d(
-                self.alpha, n[ij], log_d_ch)
+                self.alpha, n[ij], log_d_ch
+            )
             log_d = np.append(log_d, log_d_ij)
             # update assignments
             assignments[np.argwhere(assignments == i)] = ij
@@ -129,14 +134,15 @@ def build(self):
                 n_ch = n[k] + n[ij]
                 log_d_ch = log_d[k] + log_d[ij]
                 log_dij = BayesianHierarchicalClustering.__calc_log_d(
-                    self.alpha, n_ch, log_d_ch)
+                    self.alpha, n_ch, log_d_ch
+                )
                 # compute log(pi_k)
                 log_pik = np.log(self.alpha) + gammaln(n_ch) - log_dij
                 # compute log(p_k)
-                data_merged = self.data[np.argwhere(
-                    assignments == active_nodes[k]).flatten()]
-                log_p_ij = self.model.calc_log_mlh(
-                    np.vstack((x_mat_ij, data_merged)))
+                data_merged = self.data[
+                    np.argwhere(assignments == active_nodes[k]).flatten()
+                ]
+                log_p_ij = self.model.calc_log_mlh(np.vstack((x_mat_ij, data_merged)))
                 # compute log(r_k)
                 log_p_ch = log_p[ij] + log_p[active_nodes[k]]
                 r1 = log_pik + log_p_ij
@@ -146,12 +152,14 @@ def build(self):
                 merge_info = [ij, active_nodes[k], log_r, r1, r2]
                 tmp_merge = np.vstack((tmp_merge, merge_info))
 
-        return api.Result(arc_list,
-                          np.arange(0, ij + 1),
-                          log_p[-1],
-                          np.array(weights),
-                          hierarchy_cut,
-                          len(np.unique(assignments)))
+        return api.Result(
+            arc_list,
+            np.arange(0, ij + 1),
+            log_p[-1],
+            np.array(weights),
+            hierarchy_cut,
+            len(np.unique(assignments)),
+        )
 
     @staticmethod
     def __calc_log_d(alpha, nk, log_d_ch):

bhc/core/prior.py

@@ -31,16 +31,16 @@ def calc_log_mlh(self, x_mat):
         x_mat_l = x_mat_l[np.newaxis] if x_mat_l.ndim == 1 else x_mat_l
         n, d = x_mat_l.shape
         s_mat_p, rp, vp = NormalInverseWishart.__calc_posterior(
-            x_mat_l, self.s_mat, self.r, self.v, self.m)
+            x_mat_l, self.s_mat, self.r, self.v, self.m
+        )
         log_prior = NormalInverseWishart.__calc_log_prior(s_mat_p, rp, vp)
         return log_prior - self.log_prior0 - LOG2PI * (n * d / 2.0)
 
     @staticmethod
     def __calc_log_prior(s_mat, r, v):
         d = s_mat.shape[0]
         log_prior = LOG2 * (v * d / 2.0) + (d / 2.0) * np.log(2.0 * np.pi / r)
-        log_prior += multigammaln(v / 2.0, d) - \
-            (v / 2.0) * np.log(np.linalg.det(s_mat))
+        log_prior += multigammaln(v / 2.0, d) - (v / 2.0) * np.log(np.linalg.det(s_mat))
         return log_prior
 
     @staticmethod
@@ -49,8 +49,7 @@ def __calc_posterior(x_mat, s_mat, r, v, m):
         x_bar = np.mean(x_mat, axis=0)
         rp = r + n
         vp = v + n
-        s_mat_t = np.zeros(s_mat.shape) if n == 1 else (
-            n - 1) * np.cov(x_mat.T)
+        s_mat_t = np.zeros(s_mat.shape) if n == 1 else (n - 1) * np.cov(x_mat.T)
         dt = (x_bar - m)[np.newaxis]
         s_mat_p = s_mat + s_mat_t + (r * n / rp) * np.dot(dt.T, dt)
         return s_mat_p, rp, vp
@@ -62,7 +61,6 @@ def create(data, g, scale_factor):
         data_matrix_cov = np.cov(data.T)
         scatter_matrix = (data_matrix_cov / g).T
 
-        return NormalInverseWishart(scatter_matrix,
-                                    scale_factor,
-                                    degrees_of_freedom,
-                                    data_mean)
+        return NormalInverseWishart(
+            scatter_matrix, scale_factor, degrees_of_freedom, data_mean
+        )