Ran black

Author: MarieRoald

src/matcouply/_unimodal_regression.py

@@ -22,8 +22,7 @@ def _merge_intervals_inplace(merge_target, merger, sum_weighted_y, sum_weighted_
 
 
 @jit(
-    nopython=True,
-    cache=True,
+    nopython=True, cache=True,
 )
 def prefix_isotonic_regression(y, weights=None, non_negativity=False):
     if weights is None:
@@ -137,7 +136,6 @@ def unimodal_regression(y, non_negativity=False):
         y2 = np.ascontiguousarray(y)
         y2 = y2.reshape(y2.shape[0], -1)
         unfolded_output = np.stack(
-            [_unimodal_regression(y2[:, r], non_negativity=non_negativity)[0] for r in range(y2.shape[1])],
-            axis=1,
+            [_unimodal_regression(y2[:, r], non_negativity=non_negativity)[0] for r in range(y2.shape[1])], axis=1,
         )
         return unfolded_output.reshape(y.shape)

src/matcouply/data.py

@@ -11,6 +11,7 @@
 import scipy.stats as stats
 import tensorly as tl
 from scipy.io import loadmat
+
 try:
     import pandas as pd
     import requests

src/matcouply/decomposition.py

@@ -327,7 +327,7 @@ def admm_update_C(
 
 
 def _root_sum_squared_list(x_list):
-    return tl.sqrt(sum(tl.sum(x**2) for x in x_list))
+    return tl.sqrt(sum(tl.sum(x ** 2) for x in x_list))
 
 
 def compute_feasibility_gaps(cmf, regs, A_aux_list, B_aux_list, C_aux_list):
@@ -570,11 +570,11 @@ def _compute_l2_penalty(cmf, l2_parameters):
     weights, (A, B_is, C) = cmf
     l2reg = 0
     if l2_parameters[0]:
-        l2reg += 0.5 * l2_parameters[0] * tl.sum(A**2)
+        l2reg += 0.5 * l2_parameters[0] * tl.sum(A ** 2)
     if l2_parameters[1]:
-        l2reg += 0.5 * l2_parameters[1] * sum(tl.sum(B_i**2) for B_i in B_is)
+        l2reg += 0.5 * l2_parameters[1] * sum(tl.sum(B_i ** 2) for B_i in B_is)
     if l2_parameters[2]:
-        l2reg += 0.5 * l2_parameters[2] * tl.sum(C**2)
+        l2reg += 0.5 * l2_parameters[2] * tl.sum(C ** 2)
 
     return l2reg
 
@@ -853,16 +853,8 @@ def cmf_aoadmm(
         regs[2] = []
 
     # TODO  (Improvement): Include cmf to initialize functions in case other init schemes require that?
-    (
-        A_aux_list,
-        B_is_aux_list,
-        C_aux_list,
-    ) = initialize_aux(matrices, rank, regs, random_state=random_state)
-    (
-        A_dual_list,
-        B_is_dual_list,
-        C_dual_list,
-    ) = initialize_dual(matrices, rank, regs, random_state=random_state)
+    (A_aux_list, B_is_aux_list, C_aux_list,) = initialize_aux(matrices, rank, regs, random_state=random_state)
+    (A_dual_list, B_is_dual_list, C_dual_list,) = initialize_dual(matrices, rank, regs, random_state=random_state)
     norm_matrices = _root_sum_squared_list(matrices)
     rec_errors = []
     feasibility_gaps = []
@@ -877,7 +869,7 @@ def cmf_aoadmm(
         + sum(C_reg.penalty(cmf[1][2]) for C_reg in regs[2])
     )
     l2_reg = _compute_l2_penalty(cmf, l2_penalty)
-    losses.append(0.5 * rec_error**2 + l2_reg + reg_penalty)
+    losses.append(0.5 * rec_error ** 2 + l2_reg + reg_penalty)
 
     A_gaps, B_gaps, C_gaps = compute_feasibility_gaps(cmf, regs, A_aux_list, B_is_aux_list, C_aux_list)
     feasibility_gaps.append((A_gaps, B_gaps, C_gaps))
@@ -976,7 +968,7 @@ def cmf_aoadmm(
             )
 
             l2_reg = _compute_l2_penalty(cmf, l2_penalty)
-            losses.append(0.5 * rec_error**2 + l2_reg + reg_penalty)
+            losses.append(0.5 * rec_error ** 2 + l2_reg + reg_penalty)
 
             if verbose and it % verbose == 0 and verbose > 0:
                 A_gaps, B_gaps, C_gaps = curr_feasibility_gaps

src/matcouply/penalties.py

@@ -703,12 +703,7 @@ class GeneralizedL2Penalty(MatrixPenalty):
     """
 
     def __init__(
-        self,
-        norm_matrix,
-        svd="truncated_svd",
-        aux_init="random_uniform",
-        dual_init="random_uniform",
-        validate=True,
+        self, norm_matrix, svd="truncated_svd", aux_init="random_uniform", dual_init="random_uniform", validate=True,
     ):
         super().__init__(aux_init, dual_init)
         self.norm_matrix = norm_matrix
@@ -807,11 +802,7 @@ class TotalVariationPenalty(MatrixPenalty):
     """
 
     def __init__(
-        self,
-        reg_strength,
-        l1_strength=0,
-        aux_init="random_uniform",
-        dual_init="random_uniform",
+        self, reg_strength, l1_strength=0, aux_init="random_uniform", dual_init="random_uniform",
     ):
         if not HAS_TV:
             raise ModuleNotFoundError(
@@ -929,7 +920,7 @@ def __init__(self, norm_bound, non_negativity=False, aux_init="random_uniform",
     def factor_matrix_update(self, factor_matrix, feasibility_penalty, aux):
         if self.non_negativity:
             factor_matrix = tl.clip(factor_matrix, 0, float("inf"))
-        column_norms = tl.sqrt(tl.sum(factor_matrix**2, axis=0))
+        column_norms = tl.sqrt(tl.sum(factor_matrix ** 2, axis=0))
         column_norms = tl.clip(column_norms, self.norm_bound, float("inf"))
         return factor_matrix * self.norm_bound / column_norms
 

src/matcouply/testing/admm_penalty.py

@@ -345,8 +345,7 @@ def test_validating_given_init_dual(self, rng, random_ragged_cmf, aux_init):
             penalty.init_dual(matrices, rank, 1, random_state=rng)
 
     @pytest.mark.parametrize(
-        "dual_init,",
-        ["random_uniform", "random_standard_normal", "zeros"],
+        "dual_init,", ["random_uniform", "random_standard_normal", "zeros"],
     )
     @pytest.mark.parametrize("aux_init", ["random_uniform", "random_standard_normal", "zeros"])
     def test_rank_and_mode_validation_for_init_dual(self, rng, random_ragged_cmf, dual_init, aux_init):
@@ -559,4 +558,4 @@ def test_penalty(self, random_ragged_cmf):
         penalty = self.PenaltyType(**self.penalty_default_kwargs)
         assert penalty.penalty(A) == 0
         assert penalty.penalty(B_is) == 0
-        assert penalty.penalty(C) == 0
+        assert penalty.penalty(C) == 0

src/matcouply/testing/fixtures.py

@@ -40,8 +40,7 @@ def random_regular_shapes(rng):
 
 @pytest.fixture
 def random_ragged_cmf(
-    rng,
-    random_ragged_shapes,
+    rng, random_ragged_shapes,
 ):
     from matcouply.random import random_coupled_matrices
 
@@ -65,8 +64,7 @@ def random_rank5_ragged_cmf(rng):
 
 @pytest.fixture
 def random_regular_cmf(
-    rng,
-    random_regular_shapes,
+    rng, random_regular_shapes,
 ):
     from matcouply.random import random_coupled_matrices
 

src/matcouply/testing/utils.py

@@ -1,6 +1,7 @@
 # MIT License: Copyright (c) 2022, Marie Roald.
 # See the LICENSE file in the root directory for full license text.
 
+
 def random_length(rng, min=2, mean=5):
     """Generate a random dimension length.
 

tests/test_decomposition.py

@@ -22,7 +22,7 @@
 
 
 def normalize(X):
-    ssX = tl.sum(X**2, 0)
+    ssX = tl.sum(X ** 2, 0)
     ssX = tl.reshape(ssX, (1, *tl.shape(ssX)))
     return X / tl.sqrt(ssX)
 
@@ -74,8 +74,7 @@ def test_initialize_cmf_invalid_init(rng):
 
 
 @pytest.mark.parametrize(
-    "rank",
-    [1, 2, 5],
+    "rank", [1, 2, 5],
 )
 def test_initialize_aux(rng, rank):
     shapes = ((5, 10), (10, 10), (15, 10))
@@ -98,8 +97,7 @@ def test_initialize_aux(rng, rank):
 
 
 @pytest.mark.parametrize(
-    "rank",
-    [1, 2, 5],
+    "rank", [1, 2, 5],
 )
 def test_initialize_dual(rng, rank):
     shapes = ((5, 10), (10, 10), (15, 10))
@@ -128,7 +126,7 @@ def test_cmf_reconstruction_error(rng, random_ragged_cmf):
     # Add random noise
     noise = [tl.tensor(rng.standard_normal(size=shape)) for shape in shapes]
     noisy_matrices = [matrix + n for matrix, n in zip(matrices, noise)]
-    noise_norm = tl.sqrt(sum(tl.sum(n**2) for n in noise))
+    noise_norm = tl.sqrt(sum(tl.sum(n ** 2) for n in noise))
 
     # Check that the error is equal to the noise magnitude
     error = decomposition._cmf_reconstruction_error(noisy_matrices, cmf)
@@ -1457,15 +1455,11 @@ def test_cmf_aoadmm(rng, random_ragged_cmf):
 
     # Construct matrices and compute their norm
     matrices = nn_cmf.to_matrices()
-    norm_matrices = tl.sqrt(sum(tl.sum(matrix**2) for matrix in matrices))
+    norm_matrices = tl.sqrt(sum(tl.sum(matrix ** 2) for matrix in matrices))
 
     # Decompose matrices with cmf_aoadmm with no constraints
     out_cmf, (aux, dual), diagnostics = decomposition.cmf_aoadmm(
-        matrices,
-        rank,
-        n_iter_max=5_000,
-        return_errors=True,
-        return_admm_vars=True,
+        matrices, rank, n_iter_max=5_000, return_errors=True, return_admm_vars=True,
     )
 
     # Check that reconstruction error is low
@@ -1615,12 +1609,7 @@ def test_parafac2_makes_nn_cmf_unique(rng):
     regularized_loss = [float("inf")]
     for init in range(5):
         out, diagnostics = decomposition.cmf_aoadmm(
-            matrices,
-            rank,
-            n_iter_max=1_000,
-            return_errors=True,
-            non_negative=[True, True, True],
-            parafac2=True,
+            matrices, rank, n_iter_max=1_000, return_errors=True, non_negative=[True, True, True], parafac2=True,
         )
 
         if diagnostics.regularized_loss[-1] < regularized_loss[-1] and diagnostics.satisfied_feasibility_condition:
@@ -1650,11 +1639,7 @@ def test_cmf_aoadmm_not_updating_A_works(rng, random_rank5_ragged_cmf):
 
     # Decompose matrices with cmf_aoadmm with no constraints
     out_cmf = decomposition.cmf_aoadmm(
-        matrices,
-        rank,
-        n_iter_max=5,
-        update_A=False,
-        init=(None, (wrong_A_copy, B_is_copy, C_copy)),
+        matrices, rank, n_iter_max=5, update_A=False, init=(None, (wrong_A_copy, B_is_copy, C_copy)),
     )
 
     out_weights, (out_A, out_B_is, out_C) = out_cmf
@@ -1677,11 +1662,7 @@ def test_cmf_aoadmm_not_updating_C_works(rng, random_rank5_ragged_cmf):
 
     # Decompose matrices with cmf_aoadmm with no constraints
     out_cmf = decomposition.cmf_aoadmm(
-        matrices,
-        rank,
-        n_iter_max=5,
-        update_C=False,
-        init=(None, (A_copy, B_is_copy, wrong_C_copy)),
+        matrices, rank, n_iter_max=5, update_C=False, init=(None, (A_copy, B_is_copy, wrong_C_copy)),
     )
 
     out_weights, (out_A, out_B_is, out_C) = out_cmf
@@ -1703,11 +1684,7 @@ def test_cmf_aoadmm_not_updating_B_is_works(rng, random_rank5_ragged_cmf):
 
     # Decompose matrices with cmf_aoadmm with no constraints
     out_cmf = decomposition.cmf_aoadmm(
-        matrices,
-        rank,
-        n_iter_max=5,
-        update_B_is=False,
-        init=(None, (A_copy, wrong_B_is_copy, C_copy)),
+        matrices, rank, n_iter_max=5, update_B_is=False, init=(None, (A_copy, wrong_B_is_copy, C_copy)),
     )
 
     out_weights, (out_A, out_B_is, out_C) = out_cmf
@@ -1732,9 +1709,9 @@ def test_compute_l2_penalty(rng, random_ragged_cmf):
     cmf, shapes, rank = random_ragged_cmf
     weights, (A, B_is, C) = cmf
 
-    SS_A = tl.sum(A**2)
-    SS_B = sum(tl.sum(B_i**2) for B_i in B_is)
-    SS_C = tl.sum(C**2)
+    SS_A = tl.sum(A ** 2)
+    SS_B = sum(tl.sum(B_i ** 2) for B_i in B_is)
+    SS_C = tl.sum(C ** 2)
 
     assert decomposition._compute_l2_penalty(cmf, [0, 0, 0]) == 0
     assert decomposition._compute_l2_penalty(cmf, [1, 0, 0]) == pytest.approx(0.5 * SS_A)
@@ -1750,46 +1727,32 @@ def test_l2_penalty_is_included(rng, random_ragged_cmf):
 
     # Decompose matrices with cmf_aoadmm with no constraints
     out_cmf, diagnostics = decomposition.cmf_aoadmm(
-        matrices,
-        rank,
-        n_iter_max=5,
-        return_errors=True,
-        update_B_is=False,
+        matrices, rank, n_iter_max=5, return_errors=True, update_B_is=False,
     )
 
     rel_sse = diagnostics.rec_errors[-1] ** 2
     assert diagnostics.regularized_loss[-1] == pytest.approx(0.5 * rel_sse)
 
     out_cmf, diagnostics = decomposition.cmf_aoadmm(
-        matrices,
-        rank,
-        n_iter_max=5,
-        l2_penalty=1,
-        return_errors=True,
-        update_B_is=False,
+        matrices, rank, n_iter_max=5, l2_penalty=1, return_errors=True, update_B_is=False,
     )
 
     out_weights, (out_A, out_B_is, out_C) = out_cmf
     rel_sse = diagnostics.rec_errors[-1] ** 2
-    SS_A = tl.sum(out_A**2)
-    SS_B = sum(tl.sum(out_B_i**2) for out_B_i in out_B_is)
-    SS_C = tl.sum(out_C**2)
+    SS_A = tl.sum(out_A ** 2)
+    SS_B = sum(tl.sum(out_B_i ** 2) for out_B_i in out_B_is)
+    SS_C = tl.sum(out_C ** 2)
     assert diagnostics.regularized_loss[-1] == pytest.approx(0.5 * rel_sse + 0.5 * (SS_A + SS_B + SS_C))
 
     out_cmf, diagnostics = decomposition.cmf_aoadmm(
-        matrices,
-        rank,
-        n_iter_max=5,
-        l2_penalty=[1, 2, 3],
-        return_errors=True,
-        update_B_is=False,
+        matrices, rank, n_iter_max=5, l2_penalty=[1, 2, 3], return_errors=True, update_B_is=False,
     )
 
     out_weights, (out_A, out_B_is, out_C) = out_cmf
     rel_sse = diagnostics.rec_errors[-1] ** 2
-    SS_A = tl.sum(out_A**2)
-    SS_B = sum(tl.sum(out_B_i**2) for out_B_i in out_B_is)
-    SS_C = tl.sum(out_C**2)
+    SS_A = tl.sum(out_A ** 2)
+    SS_B = sum(tl.sum(out_B_i ** 2) for out_B_i in out_B_is)
+    SS_C = tl.sum(out_C ** 2)
     assert diagnostics.regularized_loss[-1] == pytest.approx(0.5 * rel_sse + 0.5 * (1 * SS_A + 2 * SS_B + 3 * SS_C))
 
 
@@ -1890,11 +1853,11 @@ def test_first_loss_value_is_correct(random_ragged_cmf):
     l1_C = tl.sum(tl.abs(C))
     l1_reg_penalty = l1_A + l1_B + l1_C
     l2_A = tl.sum((weights * A) ** 2)
-    l2_B = sum(tl.sum(B_i**2) for B_i in B_is)
-    l2_C = tl.sum(C**2)
+    l2_B = sum(tl.sum(B_i ** 2) for B_i in B_is)
+    l2_C = tl.sum(C ** 2)
     l2_reg_penalty = l2_A + l2_B + l2_C
     rec_error = 0
-    initial_loss = 0.5 * rec_error**2 + 0.5 * 0.1 * l2_reg_penalty + 0.2 * l1_reg_penalty
+    initial_loss = 0.5 * rec_error ** 2 + 0.5 * 0.1 * l2_reg_penalty + 0.2 * l1_reg_penalty
 
     # Check that we get correct output when none of the conditions are met
     out_cmf, diagnostics = decomposition.cmf_aoadmm(
@@ -1913,8 +1876,7 @@ def test_first_loss_value_is_correct(random_ragged_cmf):
 
 
 @pytest.mark.parametrize(
-    "n_iter_max",
-    [-1, 0],
+    "n_iter_max", [-1, 0],
 )
 def test_cmf_aoadmm_works_with_zero_iteration(random_ragged_cmf, n_iter_max):
     cmf, shapes, rank = random_ragged_cmf
@@ -1960,7 +1922,6 @@ def test_regs_list_is_not_modified(random_ragged_cmf, regs):
     assert regs == regs_unmodified
 
 
-
 @pytest.mark.parametrize("constant_feasibility_penalty", ["", "AB", "C"])
 def test_constant_feasibility_penalty_fails_with_invalid(random_ragged_cmf, constant_feasibility_penalty):
 
@@ -1977,7 +1938,7 @@ def test_constant_feasibility_penalty_fails_with_invalid(random_ragged_cmf, cons
             verbose=False,
             non_negative=True,
             parafac2=True,
-            constant_feasibility_penalty=constant_feasibility_penalty
+            constant_feasibility_penalty=constant_feasibility_penalty,
         )
 
 
@@ -1994,5 +1955,5 @@ def test_constant_feasibility_penalty_works_with_valid(random_ragged_cmf, consta
         verbose=False,
         non_negative=True,
         parafac2=True,
-        constant_feasibility_penalty=constant_feasibility_penalty
+        constant_feasibility_penalty=constant_feasibility_penalty,
     )