ConvergenceWarnings cannot be turned off

Hi, I'm unable to turn off convergence warnings from `GraphicalLassoCV`.

I've tried most of the solutions from, and none of them worked (see below for actual implementations):
https://stackoverflow.com/questions/879173/how-to-ignore-deprecation-warnings-in-python
https://stackoverflow.com/questions/32612180/eliminating-warnings-from-scikit-learn/33812427#33812427
https://stackoverflow.com/questions/53968004/how-to-silence-all-sklearn-warning
https://stackoverflow.com/questions/14463277/how-to-disable-python-warnings

Contrary to what the designers of the sklearn's exceptions must have thought when it was implemented, some of us actually use stdout to log important information of the host program for diagnostics purposes.  Flooding it with garbage that cannot be turned off, as is in the case with cross-validation, is not ok. 

To briefly speak to the severity of the issue, the above sklearn-specific questions relating to suppressing warnings have been viewed ~500K times with combined ~400 upvotes, and dates back 7 years. 

I've tried the following (`n_jobs` parameter does not appear to affect the result):

```py
from sklearn.covariance import GraphicalLassoCV
import warnings
warnings.filterwarnings("ignore", category=ConvergenceWarning)

model = GraphicalLassoCV(n_jobs=4)
model = model.fit(data)
```

```py
from sklearn.covariance import GraphicalLassoCV
import warnings
warnings.filterwarnings(action='ignore')

model = GraphicalLassoCV(n_jobs=4)
model = model.fit(data)
```

```py
import warnings
with warnings.catch_warnings():
    warnings.simplefilter("ignore", ConvergenceWarning)

    model = GraphicalLassoCV(n_jobs=4)
    model = model.fit(data)
```

```py
from sklearn.covariance import GraphicalLassoCV
def warn(*args, **kwargs):
    pass
import warnings
warnings.warn = warn

model = GraphicalLassoCV(n_jobs=4)
model = model.fit(data)
```

```py
import contextlib
import os, sys

@contextlib.contextmanager
def suppress_stdout():
    with open(os.devnull, 'w') as fnull:
        old_stdout = sys.stdout
        sys.stdout = fnull
        try:
            yield
        finally:
            sys.stdout = old_stdout

with suppress_stdout():
    model = GraphicalLassoCV(n_jobs=4)
    model = model.fit(data)
```

```py
import logging
logging.captureWarnings(True)

logging.getLogger("py.warnings").setLevel(logging.ERROR)

model = GraphicalLassoCV(n_jobs=4)
model = model.fit(data)
```

COMMENT:
Here is a slightly less hacky work-around than https://github.com/scikit-learn/scikit-learn/issues/29294#issuecomment-2177775871 based on the fact that `loky` (the default joblib backend) is trying to reuse the same processes. It may also work for `backend='multiprocessing'` on POSIX, since the default start method is `fork` (until Python <= 3.13) even though workers are not reused (not sure and not tested).

```py
from joblib import Parallel, delayed

def set_warnings_filters():
    warnings.filterwarnings("ignore", category=ConvergenceWarning)

n_jobs = 2

set_warnings_filters()
# I used 2*n_jobs just to be safe and make sure that set_warnings_filters is called on all workers
Parallel(n_jobs=n_jobs)(delayed(set_warnings_filters)() for _ in range(2*n_jobs))
```

The reproducer from @erickdcohen (thanks by the way!) does not give any warnings for me with this:
```py
import warnings
import numpy as np
import pandas as pd
from joblib import Parallel, delayed
from sklearn.exceptions import ConvergenceWarning
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import RandomizedSearchCV

def set_warnings_filters():
    warnings.filterwarnings("ignore", category=ConvergenceWarning)

n_jobs = 2

set_warnings_filters()
# I used 2*n_jobs just to be safe and make sure that set_warnings_filters is called on all workers
Parallel(n_jobs=n_jobs)(delayed(set_warnings_filters)() for _ in range(2*n_jobs))

X_train = pd.DataFrame(
    data={
        "a": np.linspace(0, 1, 100),
        "b": 1 + np.linspace(0, 1, 100),
        "c": np.repeat([1, 0], 50),
    }
)

y_train = np.repeat([np.repeat(1, 5), np.repeat(0, 5)], 10)

lr = LogisticRegression(
    penalty="elasticnet",
    l1_ratio=0.5,
    solver="saga",
    max_iter=10,
    random_state=103,
)

log_reg_params = {
    "tol": (1e-3, 5e-2, 1e-2),
    "C": np.linspace(0.01, 0.8, 5),
}


random_search = RandomizedSearchCV(
    estimator=lr,
    param_distributions=log_reg_params,
    cv=5,
    random_state=104,
    n_jobs=n_jobs, # IF N_JOBS IS 1, THEN NO WARNING
)

random_search.fit(X_train, y_train)
```

Longer-term I think that tackling this in joblib adding `initializers` function to all the backend https://github.com/joblib/joblib/issues/381 seems one way to go although this is definitely not going to happen overnight.

@erickdcohen about free-threading, this is an experimental interpreter in CPython 3.13 that allows you to have efficient multi-threading by removing the GIL (Global Interpreter Lock), see https://py-free-threading.github.io/ for more details. If you are using multi-threading `warnings.filters` are shared in all workers in contrary to multi-processing where you have separate Python processes with separate `warnings.filters`.

Labels: Moderate, help wanted