FIX stabilize weighted confusion_matrix_at_thresholds on float32-only devices - #34827

cc @david-cortes-intel as we discussed this during a meeting.

❌ Linting issues

This PR is introducing linting issues. Here's a summary of the issues. Note that you can avoid having linting issues by enabling pre-commit hooks. Instructions to enable them can be found here.

You can see the details of the linting issues under the lint job here

ruff check

ruff detected issues. Please run ruff check --fix --output-format=full locally, fix the remaining issues, and push the changes. Here you can see the detected issues. Note that the installed ruff version is ruff=0.12.2.

sklearn/metrics/_ranking.py:1056:25: RUF046 Value being cast to `int` is already an integer
     |
1054 |             max_scaled_total = 0.9 * (2**63 - 1)
1055 |             scale_max = max_scaled_total / (n_samples * weight_max)
1056 |             scale = max(int(round(min(scale_res, scale_max))), 1)
     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ RUF046
1057 |         else:
1058 |             scale = target_units
     |
     = help: Remove unnecessary `int` call

Found 1 error.
No fixes available (1 hidden fix can be enabled with the `--unsafe-fixes` option).

_{Generated for commit: c6f51d5. Link to the linter CI: here}

In my tests your adaptive scale idea works great in all but one easily rectifiable case.

The case goes as w = 1e-8 on the top 10% by score, 1.0 on the rest, n = 1e7:

  scale=1.11e+06  round(1e-8*scale)=0
  tps[500000]  exact 0.0045005   #34827v2 0

tps would be wrong for the starting ones.
This can be fixed by consuming more of 64 bits you got by something in the line of

scale = max(int(0.9 * (2**63 - 1) / (n_samples * weight_max)), 1)

Generally summing in descending order is numerically problematic, the idea to use int64 is quiet good, the classic way of dealing with it is using compensated summing[1] that I tested a vectorized version[2] of it head to head to this version and the current pr is better.

def compensated_cumsum(x):
    c = np.cumsum(x, dtype=f32)
    a = np.concatenate([np.zeros(1, dtype=f32), c[:-1]])
    s = a + x
    bb = s - a
    e = (a - (s - bb)) + (x - bb)
    d = (s - c) + e
    return c + np.cumsum(d, dtype=f32)

[1]: Higham, Nicholas J. 4.6 In Accuracy and Stability of Numerical Algorithms, 2nd ed.
[2]: Knuth D. ch 4.2.2 The Art of Computer Programming, Vol. 2