Is there a reason this is tested only for ESTIMATORS[1:2], I tried it with LabelSpreading estimators as well and it fails.... something to perhaps investigate further (and for now add in XFAIL), unless there are any insights as to why it's expected to fail?

The first and third ESTIMATORS use method rbf which creates a dense affinity_matrix.
And the fourth and following ESTIMATORS use the LabelSpreading class that constructs a laplacian_matrix instead of an affinity_matrix, so the normalization is different.

It might be cleaner to inline the Estimator and parameters here instead of fixtures since we are only testing one case. I agree that it looks strange to use only one of the list of Estimators, but that's all we want to test.

Upon reflection, I think it is worthwhile to test both dense and sparse cases for LabelPropagation._build_graph. So I've included the suggestion to use ESTIMATORS[:2].

I haven't added any tests for LabelSpreading._build_graph because the rows are not supposed to sum to 1 there. [The result there is not normalized beyond the normalization done while computing the laplacian from the affinity matrix].

I wonder if we could use sparse multiplication instead. The code is much easier to read, and I believe it's pretty efficient for row normalization (to be confirmed). Have you tried and compared sparse multiplication with your alternatives for csr/csc formats ?

normalizer = affinity_matrix.sum(axis=1)
# handle spmatrix (make 1D)
if sparse.isspmatrix(affinity_matrix):
    normalizer = np.ravel(normalizer)
if sparse.issparse(affinity_matrix):
    inv_normalizer = sparse.diags(1.0 / normalizer)
    affinity_matrix = inv_normalizer @ affinity_matrix
else:
    affinity_matrix /= normalizer[:, np.newaxis]

Typical timing differences are longer for the matmul-by-diagonal approach than multiplying-the-guts of the sparse representation. For small graphs, matmul takes about 10 times longer, but it does better with larger matrices. It seems to level off with 1.8 times longer for CSR format and 4 times longer for CSC format. That pattern holds at least until my memory gets full. But, the times aren't very long -- max of a second or so. So, the readability can take precedence. I'll do whatever seems best. (timing details below)

DENSITY = 1.0

Timing guts then matmul for shape: (3, 3), format: 'csr'
8.35 μs ± 18.1 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
93.7 μs ± 466 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Timing guts then matmul for shape: (3, 3), format: 'csc'
6.44 μs ± 24.3 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
111 μs ± 339 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Timing guts then matmul for shape: (2500, 2500), format: 'csr'
15.6 ms ± 63.5 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
26.2 ms ± 549 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Timing guts then matmul for shape: (2500, 2500), format: 'csc'
15.8 ms ± 44.5 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
66.3 ms ± 366 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Timing guts then matmul for shape: (5000, 5000), format: 'csr'
61.5 ms ± 248 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)
109 ms ± 252 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Timing guts then matmul for shape: (5000, 5000), format: 'csc'
70 ms ± 3.46 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
317 ms ± 794 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)

Timing guts then matmul for shape: (10000, 10000), format: 'csr'
297 ms ± 749 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)
453 ms ± 908 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)

Timing guts then matmul for shape: (10000, 10000), format: 'csc'
281 ms ± 439 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)
1.3 s ± 31.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
===================

DENSITY = 0.01
Timing guts then matmul for shape: (2500, 2500), nnz: 62500, format: 'csr'
178 μs ± 6.21 μs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
389 μs ± 9.25 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

Timing guts then matmul for shape: (2500, 2500), nnz: 62500, format: 'csc'
139 μs ± 606 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
536 μs ± 8.74 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

Timing guts then matmul for shape: (5000, 5000), nnz: 250000, format: 'csr'
728 μs ± 38.7 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
1.26 ms ± 17.8 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

Timing guts then matmul for shape: (5000, 5000), nnz: 250000, format: 'csc'
607 μs ± 37.5 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
2.06 ms ± 95.3 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Timing guts then matmul for shape: (10000, 10000), nnz: 1000000, format: 'csr'
2.68 ms ± 89.1 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
4.87 ms ± 87.8 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Timing guts then matmul for shape: (10000, 10000), nnz: 1000000, format: 'csc'
2.61 ms ± 40.1 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
8.55 ms ± 76.1 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

import numpy as np
rng = np.random.default_rng()
import scipy as sp
import sklearn

affinities = [
    np.array([[1.0, 1.0, 0.0], [2.0, 1.0, 1.0], [0.0, 1.0, 3.0]]),
#    rng.random((500, 500)),
    rng.random((2500, 2500)),
    rng.random((5000, 5000)),
    rng.random((10_000, 10_000)),
    sp.sparse.random_array((2500, 2500), density=0.01, rng=rng),
    sp.sparse.random_array((5000, 5000), density=0.01, rng=rng),
    sp.sparse.random_array((10000, 10000), density=0.01, rng=rng),
#    rng.random((20_000, 20_000)),
#    rng.random((40_000, 40_000)),
]

def setup(affinity_matrix):
    affinity_csr = sp.sparse.csr_array(affinity_matrix)
    affinity_csc = sp.sparse.csc_array(affinity_matrix)
    return affinity_csr, affinity_csc

def guts_normalization(affinity_matrix):
    normalizer = affinity_matrix.sum(axis=1)
    if affinity_matrix.format == "csr":
        repeats = np.diff(affinity_matrix.indptr)
        rows = np.repeat(np.arange(affinity_matrix.shape[0]), repeats)
    else:  # CSC format
        rows = affinity_matrix.indices
    affinity_matrix.data /= normalizer[rows]
    return affinity_matrix

def matmul_normalization(affinity_matrix):
    normalizer = affinity_matrix.sum(axis=1)
    inv_normalizer = sp.sparse.diags(1.0 / normalizer)
    affinity_matrix = inv_normalizer @ affinity_matrix
    return affinity_matrix

print('To run the timing, use:')
print('for affinity in affinities:')
print('  for affinity_matrix in setup(affinity):')
print('    guts = guts_normalization(affinity_matrix)')
print('    matmul = matmul_normalization(affinity_matrix)')
print('    np.testing.assert_allclose(guts.toarray(), matmul.toarray())')
print('    print("\\nTiming guts then matmul for ", end="")')
print('    print(f"shape: {affinity_matrix.shape} ", end="")')
print('    print(f"format: {affinity_matrix.format=}", end="")')
print('    print(f"nnz: {affinity_matrix.nnz=}")')
print('    %timeit guts_normalization(affinity_matrix)')
print('    %timeit matmul_normalization(affinity_matrix)')

Thanks for the timing analysis !

How much does the overhead compare to the overall fit time ?
As _build_graph is only called once, maybe the overhead is negligible compared to the many iterations in fit.

Using a 2500x2500 affinity matrix I time fit as 477ms
while the timing results for building the graph is 27ms for csr.
another way to put it into perspective: self.X_.tocsr() takes 36ms.

Since timing isn't critical here, in the long run we can just use
affinity_matrix /= normalizer[:, np.newaxis] for both dense and sparse cases.
But min dependence on SciPy has to be v1.12 before we can do that.

So I changed this to using the matrix multiply for sparse, with a comment to update when SciPy 1.12+ is required.

I think this should be ready to go.

this ESTIMATORS[:2] is brittle. We might change that list in the future, and I'm not sure why not all of them are tested here.

I think it's testing LabelPropagation instances only. Maybe creating a new constant:

LP_ESTIMATORS = [est for est in ESTIMATORS if isinstance(est, LabelPropagation)]

[I think so, you can check if it renders properly in rendered docs / what's new / link for LabelPropagation should redirect to the API doc]

My bad :) it wasn't the proper filter.