Maintain aggregation unit tests (#214)

* Remove dead code in tests/unit/aggregation/_inputs.py
* Remove useless warning filtering in test_cagrad
* Shorten test_imtlg_zero
* Update docstring of test_equivalence_upgrad_sum_two_rows

Author: ValerianRey

tests/unit/aggregation/_inputs.py

@@ -118,37 +118,6 @@ def generate_matrix(n_rows: int, n_cols: int, rank: int) -> Tensor:
     return matrix
 
 
-def generate_positively_oriented_matrix(
-    n_rows: int, n_cols: int, rank: int
-) -> tuple[Tensor, tuple[Tensor, Tensor, Tensor]]:
-    """
-    Generates a random matrix of shape [n_rows, n_cols] with an SVD such that the largest singular
-    value corresponds to a left singular vector that is all positive. Also returns the singular
-    triple corresponding the largest singular value.
-    If ``M, (u, s, v)`` is the output, we guarantee that:
-    - ``s * u ~= M @ v``
-    - ``u`` is a positive vector.
-    - ``s`` is the largest singular value of ``M``.
-    """
-
-    _check_valid_rank(n_rows, n_cols, rank)
-    if rank == 0:
-        matrix = torch.zeros([n_rows, n_cols], device=DEVICE)
-        largest_singular_value_triple = (
-            torch.zeros([n_rows], device=DEVICE),
-            torch.zeros([], device=DEVICE),
-            torch.zeros([n_cols], device=DEVICE),
-        )
-    else:
-        U = _generate_unitary_matrix_with_positive_column(n_rows, rank)
-        V = _generate_unitary_matrix(n_cols, rank)
-        S = _generate_diagonal_singular_values(rank)
-        matrix = U @ S @ V.T
-        largest_singular_value_triple = (U[:, 0], S[0, 0], V[:, 0])
-
-    return matrix, largest_singular_value_triple
-
-
 def generate_stationary_matrix(n_rows: int, n_cols: int, rank: int) -> Tensor:
     """
     Generates a random matrix of shape [``n_rows``, ``n_cols``] with provided ``rank``. The matrix
@@ -199,10 +168,6 @@ def generate_stationary_matrix(n_rows: int, n_cols: int, rank: int) -> Tensor:
 scaled_matrices_2_plus_rows = [
     matrix for matrix in scaled_matrices + zero_rank_matrices if matrix.shape[0] >= 2
 ]
-matrices_and_triples = [
-    generate_positively_oriented_matrix(n_rows, n_cols, rank)
-    for n_rows, n_cols, rank in _matrix_dimension_triples
-]
 stationary_matrices = [
     generate_stationary_matrix(n_rows, n_cols, rank)
     for n_rows, n_cols, rank in _matrix_dimension_triples

tests/unit/aggregation/test_cagrad.py

@@ -8,21 +8,18 @@
 from ._property_testers import ExpectedStructureProperty, NonConflictingProperty
 
 
-@mark.filterwarnings("ignore:np.find_common_type is deprecated:")
 @mark.parametrize("aggregator", [CAGrad(c=0.5)])
 class TestCAGrad(ExpectedStructureProperty):
     pass
 
 
-@mark.filterwarnings("ignore:np.find_common_type is deprecated:")
 @mark.parametrize("aggregator", [CAGrad(c=1.0), CAGrad(c=2.0)])
 class TestCAGradNonConflicting(NonConflictingProperty):
     """Tests that CAGrad is non-conflicting when c >= 1 (it should not hold when c < 1)"""
 
     pass
 
 
-@mark.filterwarnings("ignore:np.find_common_type is deprecated:")
 @mark.parametrize("matrix", stationary_matrices + matrices)
 def test_equivalence_mean(matrix: Tensor):
     """Tests that CAGrad is equivalent to Mean when c=0."""

tests/unit/aggregation/test_imtl_g.py

@@ -21,11 +21,7 @@ def test_imtlg_zero():
 
     A = IMTLG()
     J = torch.zeros(2, 3, device=DEVICE)
-
-    aggregation = A(J)
-    expected = torch.zeros(3, device=DEVICE)
-
-    assert_close(aggregation, expected)
+    assert_close(A(J), torch.zeros(3, device=DEVICE))
 
 
 def test_representations():

tests/unit/aggregation/test_pcgrad.py

@@ -33,7 +33,7 @@ class TestPCGrad(ExpectedStructureProperty):
 )
 def test_equivalence_upgrad_sum_two_rows(shape: tuple[int, int]):
     """
-    Tests that UPGradWrapper of a SumWeighting is equivalent to PCGradWeighting for matrices of 2
+    Tests that _UPGradWrapper of a _SumWeighting is equivalent to _PCGradWeighting for matrices of 2
     rows.
     """