Pushing the docs to dev/ for branch: master, commit 94f2e9c5d86263c4c9abb412d44135b4e6bc1ef5

Author: sklearn-ci

dev/_downloads/00a5ddd24a9ad44708f4ab3b157ef0ff/plot_stack_predictors.py

@@ -22,9 +22,9 @@
 # License: BSD 3 clause
 
 
-###############################################################################
+# %%
 # Download the dataset
-###############################################################################
+##############################################################################
 #
 # We will use `Ames Housing`_ dataset which was first compiled by Dean De Cock
 # and became better known after it was used in Kaggle challenge. It is a set
@@ -68,9 +68,9 @@ def load_ames_housing():
 X, y = load_ames_housing()
 
 
-###############################################################################
+# %%
 # Make pipeline to preprocess the data
-###############################################################################
+##############################################################################
 #
 # Before we can use Ames dataset we still need to do some preprocessing.
 # First, the dataset has many missing values. To impute them, we will exchange
@@ -136,9 +136,9 @@ def load_ames_housing():
     remainder='passthrough')
 
 
-###############################################################################
+# %%
 # Stack of predictors on a single data set
-###############################################################################
+##############################################################################
 #
 # It is sometimes tedious to find the model which will best perform on a given
 # dataset. Stacking provide an alternative by combining the outputs of several
@@ -181,9 +181,9 @@ def load_ames_housing():
                                        final_estimator=RidgeCV())
 
 
-###############################################################################
+# %%
 # Measure and plot the results
-###############################################################################
+##############################################################################
 #
 # Now we can use Ames Housing dataset to make the predictions. We check the
 # performance of each individual predictor as well as of the stack of the
@@ -250,7 +250,7 @@ def plot_regression_results(ax, y_true, y_pred, title, scores, elapsed_time):
 plt.subplots_adjust(top=0.9)
 plt.show()
 
-###############################################################################
+# %%
 # The stacked regressor will combine the strengths of the different regressors.
 # However, we also see that training the stacked regressor is much more
 # computationally expensive.

dev/_downloads/0469b1db532e2049dcabff76dcfa3407/plot_cv_indices.py

@@ -22,7 +22,7 @@
 cmap_cv = plt.cm.coolwarm
 n_splits = 4
 
-###############################################################################
+# %%
 # Visualize our data
 # ------------------
 #
@@ -61,7 +61,7 @@ def visualize_groups(classes, groups, name):
 
 visualize_groups(y, groups, 'no groups')
 
-###############################################################################
+# %%
 # Define a function to visualize cross-validation behavior
 # --------------------------------------------------------
 #
@@ -102,15 +102,15 @@ def plot_cv_indices(cv, X, y, group, ax, n_splits, lw=10):
     return ax
 
 
-###############################################################################
+# %%
 # Let's see how it looks for the :class:`~sklearn.model_selection.KFold`
 # cross-validation object:
 
 fig, ax = plt.subplots()
 cv = KFold(n_splits)
 plot_cv_indices(cv, X, y, groups, ax, n_splits)
 
-###############################################################################
+# %%
 # As you can see, by default the KFold cross-validation iterator does not
 # take either datapoint class or group into consideration. We can change this
 # by using the ``StratifiedKFold`` like so.
@@ -119,7 +119,7 @@ def plot_cv_indices(cv, X, y, group, ax, n_splits, lw=10):
 cv = StratifiedKFold(n_splits)
 plot_cv_indices(cv, X, y, groups, ax, n_splits)
 
-###############################################################################
+# %%
 # In this case, the cross-validation retained the same ratio of classes across
 # each CV split. Next we'll visualize this behavior for a number of CV
 # iterators.

dev/_downloads/0537f2a914bc9e8cc2d431935d152a79/plot_roc_curve_visualization_api.py

@@ -9,7 +9,7 @@
 """
 print(__doc__)
 
-##############################################################################
+# %%
 # Load Data and Train a SVC
 # -------------------------
 # First, we load the wine dataset and convert it to a binary classification
@@ -28,7 +28,7 @@
 svc = SVC(random_state=42)
 svc.fit(X_train, y_train)
 
-##############################################################################
+# %%
 # Plotting the ROC Curve
 # ----------------------
 # Next, we plot the ROC curve with a single call to
@@ -38,7 +38,7 @@
 svc_disp = plot_roc_curve(svc, X_test, y_test)
 plt.show()
 
-##############################################################################
+# %%
 # Training a Random Forest and Plotting the ROC Curve
 # --------------------------------------------------------
 # We train a random forest classifier and create a plot comparing it to the SVC

dev/_downloads/08d5dd49f57f99e9638e3f76f11e28ac/plot_multi_metric_evaluation.py

@@ -29,7 +29,7 @@
 
 print(__doc__)
 
-###############################################################################
+# %%
 # Running ``GridSearchCV`` using multiple evaluation metrics
 # ----------------------------------------------------------
 #
@@ -51,7 +51,7 @@
 gs.fit(X, y)
 results = gs.cv_results_
 
-###############################################################################
+# %%
 # Plotting the result
 # -------------------
 

dev/_downloads/0d59ba71a84b25ededa8e1298aed7cf2/plot_transformed_target.ipynb

@@ -105,14 +105,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Real-world data set\n##############################################################################\n\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "In a similar manner, the Ames housing data set is used to show the impact\nof transforming the targets before learning a model. In this example, the\ntarget to be predicted is the selling price of each house.\n\n"
+        "Real-world data set\n##############################################################################\n\n In a similar manner, the Ames housing data set is used to show the impact\n of transforming the targets before learning a model. In this example, the\n target to be predicted is the selling price of each house.\n\n"
       ]
     },
     {

dev/_downloads/3409d9766d352cc9f9b169d4a799a87a/auto_examples_python.zip

@@ -29,7 +29,7 @@
 from sklearn.inspection import permutation_importance
 from sklearn.model_selection import train_test_split
 
-##############################################################################
+# %%
 # Random Forest Feature Importance on Breast Cancer Data
 # ------------------------------------------------------
 # First, we train a random forest on the breast cancer dataset and evaluate
@@ -42,7 +42,7 @@
 clf.fit(X_train, y_train)
 print("Accuracy on test data: {:.2f}".format(clf.score(X_test, y_test)))
 
-##############################################################################
+# %%
 # Next, we plot the tree based feature importance and the permutation
 # importance. The permutation importance plot shows that permuting a feature
 # drops the accuracy by at most `0.012`, which would suggest that none of the
@@ -68,7 +68,7 @@
 fig.tight_layout()
 plt.show()
 
-##############################################################################
+# %%
 # Handling Multicollinear Features
 # --------------------------------
 # When features are collinear, permutating one feature will have little
@@ -92,7 +92,7 @@
 fig.tight_layout()
 plt.show()
 
-##############################################################################
+# %%
 # Next, we manually pick a threshold by visual inspection of the dendrogram
 # to group our features into clusters and choose a feature from each cluster to
 # keep, select those features from our dataset, and train a new random forest.

dev/_downloads/34da82a8792cf79d06c7598ae139cc1c/plot_permutation_importance_multicollinear.py

@@ -93,7 +93,7 @@ def is_interactive():
 print()
 
 
-##############################################################################
+# %%
 # Load data from the training set
 # ------------------------------------
 # Let's load data from the newsgroups dataset which comprises around 18000
@@ -199,7 +199,7 @@ def trim(s):
     return s if len(s) <= 80 else s[:77] + "..."
 
 
-##############################################################################
+# %%
 # Benchmark classifiers
 # ------------------------------------
 # We train and test the datasets with 15 different classification models
@@ -297,7 +297,7 @@ def benchmark(clf):
   ('classification', LinearSVC(penalty="l2"))])))
 
 
-##############################################################################
+# %%
 # Add plots
 # ------------------------------------
 # The bar plot indicates the accuracy, training time (normalized) and test time

dev/_downloads/388641d133587cc11aa26f2dbef4b950/plot_document_classification_20newsgroups.py

@@ -15,7 +15,7 @@
 """
 print(__doc__)
 
-##############################################################################
+# %%
 # Load Data and train model
 # -------------------------
 # For this example, we load a blood transfusion service center data set from
@@ -35,7 +35,7 @@
 clf = make_pipeline(StandardScaler(), LogisticRegression(random_state=0))
 clf.fit(X_train, y_train)
 
-##############################################################################
+# %%
 # Create :class:`ConfusionMatrixDisplay`
 ##############################################################################
 # With the fitted model, we compute the predictions of the model on the test
@@ -50,7 +50,7 @@
 cm_display = ConfusionMatrixDisplay(cm).plot()
 
 
-##############################################################################
+# %%
 # Create :class:`RocCurveDisplay`
 ##############################################################################
 # The roc curve requires either the probabilities or the non-thresholded
@@ -63,7 +63,7 @@
 fpr, tpr, _ = roc_curve(y_test, y_score, pos_label=clf.classes_[1])
 roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot()
 
-##############################################################################
+# %%
 # Create :class:`PrecisionRecallDisplay`
 ##############################################################################
 # Similarly, the precision recall curve can be plotted using `y_score` from
@@ -75,7 +75,7 @@
                                          pos_label=clf.classes_[1])
 pr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot()
 
-##############################################################################
+# %%
 # Combining the display objects into a single plot
 ##############################################################################
 # The display objects store the computed values that were passed as arguments.

dev/_downloads/418020d5fd9dd75fcb92704f51fc42db/plot_display_object_visualization.py

@@ -32,7 +32,7 @@
 # Authors: Maria Telenczuk  <https://github.com/maikia>
 # License: BSD 3 clause
 
-###############################################################################
+# %%
 # Download the data and make missing values sets
 ################################################
 #
@@ -83,7 +83,7 @@ def add_missing_values(X_full, y_full):
     X_diabetes, y_diabetes)
 
 
-###############################################################################
+# %%
 # Impute the missing data and score
 # #################################
 # Now we will write a function which will score the results on the differently
@@ -104,7 +104,7 @@ def add_missing_values(X_full, y_full):
 N_SPLITS = 5
 regressor = RandomForestRegressor(random_state=0)
 
-###############################################################################
+# %%
 # Missing information
 # -------------------
 # In addition to imputing the missing values, the imputers have an
@@ -132,7 +132,7 @@ def get_scores_for_imputer(imputer, X_missing, y_missing):
 mses_diabetes = np.zeros(5)
 stds_diabetes = np.zeros(5)
 
-###############################################################################
+# %%
 # Estimate the score
 # ------------------
 # First, we want to estimate the score on the original data:
@@ -151,7 +151,7 @@ def get_full_score(X_full, y_full):
 mses_diabetes[0], stds_diabetes[0] = get_full_score(X_diabetes, y_diabetes)
 
 
-###############################################################################
+# %%
 # Replace missing values by 0
 # ---------------------------
 #
@@ -174,7 +174,7 @@ def get_impute_zero_score(X_missing, y_missing):
                                                            y_miss_diabetes)
 
 
-###############################################################################
+# %%
 # kNN-imputation of the missing values
 # ------------------------------------
 #
@@ -193,7 +193,7 @@ def get_impute_knn_score(X_missing, y_missing):
                                                           y_miss_diabetes)
 
 
-###############################################################################
+# %%
 # Impute missing values with mean
 # -------------------------------
 #
@@ -211,7 +211,7 @@ def get_impute_mean(X_missing, y_missing):
                                                      y_miss_diabetes)
 
 
-###############################################################################
+# %%
 # Iterative imputation of the missing values
 # ------------------------------------------
 #
@@ -241,7 +241,7 @@ def get_impute_iterative(X_missing, y_missing):
 mses_diabetes = mses_diabetes * -1
 mses_california = mses_california * -1
 
-###############################################################################
+# %%
 # Plot the results
 # ################
 #