[DOC] shorten lines in the examples (#421)

Author: Remi-Gau

examples/plot_2D_simulation_example.py

@@ -184,9 +184,18 @@ def weight_map_2D_extended(shape, roi_size, delta):
 
 
 # compute desparsified lasso
-beta_hat, sigma_hat, precision_diagonal = desparsified_lasso(X_init, y, n_jobs=n_jobs)
+beta_hat, sigma_hat, precision_diagonal = desparsified_lasso(
+    X_init,
+    y,
+    n_jobs=n_jobs,
+)
 pval, pval_corr, one_minus_pval, one_minus_pval_corr, cb_min, cb_max = (
-    desparsified_lasso_pvalue(X_init.shape[0], beta_hat, sigma_hat, precision_diagonal)
+    desparsified_lasso_pvalue(
+        X_init.shape[0],
+        beta_hat,
+        sigma_hat,
+        precision_diagonal,
+    )
 )
 
 # compute estimated support (first method)
@@ -215,7 +224,14 @@ def weight_map_2D_extended(shape, roi_size, delta):
     X_init, y, ward, n_clusters, scaler_sampling=StandardScaler()
 )
 beta_hat, pval, pval_corr, one_minus_pval, one_minus_pval_corr = (
-    clustered_inference_pvalue(n_samples, False, ward_, beta_hat, theta_hat, omega_diag)
+    clustered_inference_pvalue(
+        n_samples,
+        False,
+        ward_,
+        beta_hat,
+        theta_hat,
+        omega_diag,
+    )
 )
 
 # compute estimated support (first method)

examples/plot_conditional_vs_marginal_xor_data.py

@@ -30,7 +30,12 @@
     np.linspace(np.min(X[:, 1]), np.max(X[:, 1]), 100),
 )
 
-X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    Y,
+    test_size=0.2,
+    random_state=0,
+)
 model = SVC(kernel="rbf", random_state=0)
 model.fit(X_train, y_train)
 Z = model.decision_function(np.c_[xx.ravel(), yy.ravel()])

examples/plot_dcrt_example.py

@@ -70,7 +70,11 @@
 
     ## dcrt Random Forest ##
     d0crt_random_forest = D0CRT(
-        estimator=RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=1),
+        estimator=RandomForestRegressor(
+            n_estimators=100,
+            random_state=42,
+            n_jobs=1,
+        ),
         screening_threshold=None,
     )
     d0crt_random_forest.fit_importance(X, y)
@@ -92,7 +96,13 @@
 
 _, ax = plt.subplots(nrows=1, ncols=2)
 sns.swarmplot(data=df_plot, x="model", y="type-1 error", ax=ax[0], hue="model")
-ax[0].axhline(alpha, linewidth=1, color="tab:red", ls="--", label="Nominal Level")
+ax[0].axhline(
+    alpha,
+    linewidth=1,
+    color="tab:red",
+    ls="--",
+    label="Nominal Level",
+)
 ax[0].legend()
 ax[0].set_ylim(-0.01)
 

examples/plot_diabetes_variable_importance_example.py

@@ -118,7 +118,9 @@
     cfi = CFI(
         estimator=regressor_list[i],
         imputation_model_continuous=RidgeCV(alphas=np.logspace(-3, 3, 10)),
-        imputation_model_categorical=LogisticRegressionCV(Cs=np.logspace(-2, 2, 10)),
+        imputation_model_categorical=LogisticRegressionCV(
+            Cs=np.logspace(-2, 2, 10),
+        ),
         # covariate_estimator=HistGradientBoostingRegressor(random_state=0,),
         n_permutations=50,
         random_state=0,

examples/plot_importance_classification_iris.py

@@ -60,7 +60,15 @@
 # require a K-fold cross-fitting. Computing the importance for each fold is
 # embarrassingly parallel. For this reason, we encapsulate the main computations in a
 # function and use joblib to parallelize the computation.
-def run_one_fold(X, y, model, train_index, test_index, vim_name="CFI", groups=None):
+def run_one_fold(
+    X,
+    y,
+    model,
+    train_index,
+    test_index,
+    vim_name="CFI",
+    groups=None,
+):
     model_c = clone(model)
     model_c.fit(X[train_index], y[train_index])
     y_pred = model_c.predict(X[test_index])
@@ -101,7 +109,10 @@ def run_one_fold(X, y, model, train_index, test_index, vim_name="CFI", groups=No
             "importance": importance,
             "vim": vim_name,
             "model": model_name,
-            "score": balanced_accuracy_score(y_true=y[test_index], y_pred=y_pred),
+            "score": balanced_accuracy_score(
+                y_true=y[test_index],
+                y_pred=y_pred,
+            ),
         }
     )
 

examples/plot_knockoffs_wisconsin.py

@@ -106,7 +106,10 @@
 lasso_noisy.fit(noisy_train, y_train)
 y_pred_noisy = lasso_noisy.predict(noisy_test)
 print(
-    f"Accuracy of Lasso on test set with noise: {lasso_noisy.score(noisy_test, y_test):.3f}"
+    (
+        "Accuracy of Lasso on test set with noise: "
+        f"{lasso_noisy.score(noisy_test, y_test):.3f}"
+    )
 )
 
 selected_mask = [

examples/plot_model_agnostic_importance.py

@@ -74,7 +74,10 @@
 d0crt_linear.fit_importance(X, y)
 pval_dcrt_linear = d0crt_linear.pvalues_
 
-d0crt_non_linear = D0CRT(estimator=clone(non_linear_model), screening_threshold=None)
+d0crt_non_linear = D0CRT(
+    estimator=clone(non_linear_model),
+    screening_threshold=None,
+)
 d0crt_non_linear.fit_importance(X, y)
 pval_dcrt_non_linear = d0crt_non_linear.pvalues_
 
@@ -97,7 +100,10 @@
     linear_model_.fit(X[train], y[train])
 
     vim_linear = LOCO(
-        estimator=linear_model_, loss=log_loss, method="predict_proba", n_jobs=2
+        estimator=linear_model_,
+        loss=log_loss,
+        method="predict_proba",
+        n_jobs=2,
     )
     vim_non_linear = LOCO(
         estimator=non_linear_model_,
@@ -108,7 +114,9 @@
     vim_linear.fit(X[train], y[train])
     vim_non_linear.fit(X[train], y[train])
 
-    importances_linear.append(vim_linear.importance(X[test], y[test])["importance"])
+    importances_linear.append(
+        vim_linear.importance(X[test], y[test])["importance"],
+    )
     importances_non_linear.append(
         vim_non_linear.importance(X[test], y[test])["importance"]
     )
@@ -118,15 +126,25 @@
 # To select variables using LOCO, we compute the p-values using a t-test over the
 # importance scores.
 
-_, pval_linear = ttest_1samp(importances_linear, 0, axis=0, alternative="greater")
+_, pval_linear = ttest_1samp(
+    importances_linear,
+    0,
+    axis=0,
+    alternative="greater",
+)
 _, pval_non_linear = ttest_1samp(
     importances_non_linear, 0, axis=0, alternative="greater"
 )
 
 df_pval = pd.DataFrame(
     {
         "pval": np.hstack(
-            [pval_dcrt_linear, pval_dcrt_non_linear, pval_linear, pval_non_linear]
+            [
+                pval_dcrt_linear,
+                pval_dcrt_non_linear,
+                pval_linear,
+                pval_non_linear,
+            ]
         ),
         "method": ["d0CRT-linear"] * 2
         + ["d0CRT-non-linear"] * 2
@@ -152,7 +170,11 @@
 )
 ax.set_xlabel("-$\\log_{10}(pval)$")
 ax.axvline(
-    -np.log10(0.05), color="k", lw=3, linestyle="--", label="-$\\log_{10}(0.05)$"
+    -np.log10(0.05),
+    color="k",
+    lw=3,
+    linestyle="--",
+    label="-$\\log_{10}(0.05)$",
 )
 ax.legend()
 plt.show()

examples/plot_pitfalls_permutation_importance.py

@@ -40,7 +40,13 @@
 dataset = fetch_california_housing()
 X_, y_ = dataset.data, dataset.target
 # only use 2/3 of samples to speed up the example
-X, _, y, _ = train_test_split(X_, y_, test_size=0.6667, random_state=0, shuffle=True)
+X, _, y, _ = train_test_split(
+    X_,
+    y_,
+    test_size=0.6667,
+    random_state=0,
+    shuffle=True,
+)
 
 redundant_coef = rng.choice(np.arange(X.shape[1]), size=(3,), replace=False)
 X_spurious = X[:, redundant_coef].sum(axis=1)