⚠️ CI failed on Linux_Docker.debian_atlas_32bit (last failure: Sep 03, 2024) ⚠️

**CI is still failing on [Linux_Docker.debian_atlas_32bit](https://dev.azure.com/scikit-learn/scikit-learn/_build/results?buildId=69809&view=logs&j=aabdcdc3-bb64-5414-b357-ed024fe8659e)** (Sep 03, 2024)
- test_spectral_clustering_with_arpack_amg_solvers
- test_img_to_graph
- test_imputation_mean_median[csc_matrix]
- test_imputation_mean_median[csc_array]
- test_robust_scale_axis1

COMMENT:
Just in case the logs are removed, here is the trackback:

<details><summary>Traceback</summary>

```python-traceback
    def test_inverse_transform(
        whiten, n_components, expected_mixing_shape, global_random_seed, global_dtype
    ):
        # Test FastICA.inverse_transform
        n_samples = 100
        rng = np.random.RandomState(global_random_seed)
        X = rng.random_sample((n_samples, 10)).astype(global_dtype)
    
        ica = FastICA(n_components=n_components, random_state=rng, whiten=whiten)
        with warnings.catch_warnings():
            # For some dataset (depending on the value of global_dtype) the model
            # can fail to converge but this should not impact the definition of
            # a valid inverse transform.
            warnings.simplefilter("ignore", ConvergenceWarning)
            Xt = ica.fit_transform(X)
        assert ica.mixing_.shape == expected_mixing_shape
        X2 = ica.inverse_transform(Xt)
        assert X.shape == X2.shape
    
        # reversibility test in non-reduction case
        if n_components == X.shape[1]:
            # XXX: we have to set atol for this test to pass for all seeds when
            # fitting with float32 data. Is this revealing a bug?
            if global_dtype:
                # XXX: dividing by a smaller number makes
                # tests fail for some seeds.
                atol = np.abs(X2).mean() / 1e5
            else:
                atol = 0.0  # the default rtol is enough for float64 data
>           assert_allclose(X, X2, atol=atol)

X          = array([[0.49460164, 0.2280831 , 0.2554739 , 0.3963299 , 0.3773151 ,
        0.9965742 , 0.4081972 , 0.771894  , 0.7605...01 , 0.8702239 , 0.85998875,
        0.9062211 , 0.52288705, 0.5902804 , 0.97106504, 0.39498487]],
      dtype=float32)
X2         = array([[ 0.45655584,  0.53900224,  0.25547385,  0.22837974,  0.5666931 ,
         0.8485345 ,  0.50125885,  0.50586027....6070828 ,  0.69734764,
         0.67427313,  0.61682725,  0.6224894 ,  0.6810832 ,  0.6395092 ]],
      dtype=float32)
Xt         = array([[ 8.86449367e-02, -1.35140147e+12,  4.84007215e+11,
        -4.84007215e+11,  3.34746321e+11, -5.69215943e+11,
..., -7.34393467e+11,
        -6.70885806e+11,  7.15465097e+11, -1.02009510e+12,
        -1.02305740e+12]], dtype=float32)
atol       = 4.925061464309693e-06
expected_mixing_shape = (10, 10)
global_dtype = <class 'numpy.float32'>
global_random_seed = 50
ica        = FastICA(n_components=10, random_state=RandomState(MT19937) at 0xE4629DA8,
        whiten=False)
n_components = 10
n_samples  = 100
rng        = RandomState(MT19937) at 0xE4629DA8
whiten     = False

/io/sklearn/decomposition/tests/test_fastica.py:362:

[...]
        --------
        numpy.testing.assert_allclose
    
        Examples
        --------
        >>> import numpy as np
        >>> from sklearn.utils._testing import assert_allclose
        >>> x = [1e-5, 1e-3, 1e-1]
        >>> y = np.arccos(np.cos(x))
        >>> assert_allclose(x, y, rtol=1e-5, atol=0)
        >>> a = np.full(shape=10, fill_value=1e-5, dtype=np.float32)
        >>> assert_allclose(a, 1e-5)
        """
        dtypes = []
    
        actual, desired = np.asanyarray(actual), np.asanyarray(desired)
        dtypes = [actual.dtype, desired.dtype]
    
        if rtol is None:
            rtols = [1e-4 if dtype == np.float32 else 1e-7 for dtype in dtypes]
            rtol = max(rtols)
    
>       np_assert_allclose(
            actual,
            desired,
            rtol=rtol,
            atol=atol,
            equal_nan=equal_nan,
            err_msg=err_msg,
            verbose=verbose,
        )
E       AssertionError: 
E       Not equal to tolerance rtol=0.0001, atol=4.92506e-06
E       
E       Mismatched elements: 899 / 1000 (89.9%)
E       Max absolute difference: 0.6766666
E       Max relative difference: 2.5423577
E        x: array([[0.494602, 0.228083, 0.255474, 0.39633 , 0.377315, 0.996574,
E               0.408197, 0.771894, 0.760537, 0.310009],
E              [0.346541, 0.351765, 0.145467, 0.972665, 0.909178, 0.559957,...
E        y: array([[ 0.456556,  0.539002,  0.255474,  0.22838 ,  0.566693,  0.848535,
E                0.501259,  0.50586 ,  0.553476,  0.519691],
E              [ 0.533576,  0.629931,  0.145467,  0.789647,  0.662293,  0.398639,...

actual     = array([[0.49460164, 0.2280831 , 0.2554739 , 0.3963299 , 0.3773151 ,
        0.9965742 , 0.4081972 , 0.771894  , 0.7605...01 , 0.8702239 , 0.85998875,
        0.9062211 , 0.52288705, 0.5902804 , 0.97106504, 0.39498487]],
      dtype=float32)
atol       = 4.925061464309693e-06
desired    = array([[ 0.45655584,  0.53900224,  0.25547385,  0.22837974,  0.5666931 ,
         0.8485345 ,  0.50125885,  0.50586027....6070828 ,  0.69734764,
         0.67427313,  0.61682725,  0.6224894 ,  0.6810832 ,  0.6395092 ]],
      dtype=float32)
dtypes     = [dtype('float32'), dtype('float32')]
equal_nan  = True
err_msg    = ''
rtol       = 0.0001
rtols      = [0.0001, 0.0001]
verbose    = True
```

</details>

Labels: Build / CI, Numerical Stability