DOC simpler block delimitation in sphinx-gallery examples (scikit-learn#17068)

Co-authored-by: Thomas J. Fan <[email protected]>

Author: rth

examples/applications/plot_out_of_core_classification.py

@@ -43,7 +43,7 @@ def _not_in_sphinx():
     # Hack to detect whether we are running by the sphinx builder
     return '__file__' in globals()
 
-###############################################################################
+# %%
 # Reuters Dataset related routines
 # --------------------------------
 #
@@ -178,7 +178,7 @@ def progress(blocknum, bs, size):
             yield doc
 
 
-###############################################################################
+# %%
 # Main
 # ----
 #
@@ -311,7 +311,7 @@ def progress(cls_name, stats):
         print('\n')
 
 
-###############################################################################
+# %%
 # Plot results
 # ------------
 #

examples/applications/plot_outlier_detection_wine.py

@@ -94,7 +94,7 @@
 
 plt.show()
 
-##############################################################################
+# %%
 # Second example
 # --------------
 # The second example shows the ability of the Minimum Covariance Determinant

examples/cluster/plot_coin_segmentation.py

@@ -66,7 +66,7 @@
 # installed)
 N_REGIONS = 25
 
-#############################################################################
+# %%
 # Visualize the resulting regions
 
 for assign_labels in ('kmeans', 'discretize'):

examples/cluster/plot_linkage_comparison.py

@@ -35,7 +35,7 @@
 
 np.random.seed(0)
 
-######################################################################
+# %%
 # Generate datasets. We choose the size big enough to see the scalability
 # of the algorithms, but not too big to avoid too long running times
 
@@ -58,7 +58,7 @@
                              cluster_std=[1.0, 2.5, 0.5],
                              random_state=random_state)
 
-######################################################################
+# %%
 # Run the clustering and plot
 
 # Set up cluster parameters

examples/compose/plot_column_transformer_mixed_types.py

@@ -44,7 +44,7 @@
 # X = titanic.frame.drop('survived', axis=1)
 # y = titanic.frame['survived']
 
-###############################################################################
+# %%
 # Use ``ColumnTransformer`` by selecting column by names
 ###############################################################################
 # We will train our classifier with the following features:
@@ -90,7 +90,7 @@
 clf.fit(X_train, y_train)
 print("model score: %.3f" % clf.score(X_test, y_test))
 
-##############################################################################
+# %%
 # HTML representation of ``Pipeline``
 ###############################################################################
 # When the ``Pipeline`` is printed out in a jupyter notebook an HTML
@@ -100,7 +100,7 @@
 set_config(display='diagram')
 clf
 
-###############################################################################
+# %%
 # Use ``ColumnTransformer`` by selecting column by data types
 ###############################################################################
 # When dealing with a cleaned dataset, the preprocessing can be automatic by
@@ -113,19 +113,19 @@
 subset_feature = ['embarked', 'sex', 'pclass', 'age', 'fare']
 X_train, X_test = X_train[subset_feature], X_test[subset_feature]
 
-###############################################################################
+# %%
 # Then, we introspect the information regarding each column data type.
 
 X_train.info()
 
-###############################################################################
+# %%
 # We can observe that the `embarked` and `sex` columns were tagged as
 # `category` columns when loading the data with ``fetch_openml``. Therefore, we
 # can use this information to dispatch the categorical columns to the
 # ``categorical_transformer`` and the remaining columns to the
 # ``numerical_transformer``.
 
-###############################################################################
+# %%
 # .. note:: In practice, you will have to handle yourself the column data type.
 #    If you want some columns to be considered as `category`, you will have to
 #    convert them into categorical columns. If you are using pandas, you can
@@ -145,20 +145,20 @@
 clf.fit(X_train, y_train)
 print("model score: %.3f" % clf.score(X_test, y_test))
 
-###############################################################################
+# %%
 # The resulting score is not exactly the same as the one from the previous
 # pipeline becase the dtype-based selector treats the ``pclass`` columns as
 # a numeric features instead of a categorical feature as previously:
 
 selector(dtype_exclude="category")(X_train)
 
-###############################################################################
+# %%
 
 selector(dtype_include="category")(X_train)
 
-###############################################################################
+# %%
 # Using the prediction pipeline in a grid search
-###############################################################################
+##############################################################################
 # Grid search can also be performed on the different preprocessing steps
 # defined in the ``ColumnTransformer`` object, together with the classifier's
 # hyperparameters as part of the ``Pipeline``.
@@ -174,7 +174,7 @@
 grid_search = GridSearchCV(clf, param_grid, cv=10)
 grid_search
 
-###############################################################################
+# %%
 # Calling 'fit' triggers the cross-validated search for the best
 # hyper-parameters combination:
 #
@@ -183,11 +183,11 @@
 print(f"Best params:")
 print(grid_search.best_params_)
 
-###############################################################################
+# %%
 # The internal cross-validation scores obtained by those parameters is:
 print(f"Internal CV score: {grid_search.best_score_:.3f}")
 
-###############################################################################
+# %%
 # We can also introspect the top grid search results as a pandas dataframe:
 import pandas as pd
 
@@ -198,7 +198,7 @@
             "param_classifier__C"
             ]].head(5)
 
-###############################################################################
+# %%
 # The best hyper-parameters have be used to re-fit a final model on the full
 # training set. We can evaluate that final model on held out test data that was
 # not used for hyparameter tuning.

examples/compose/plot_compare_reduction.py

@@ -20,7 +20,7 @@
 Note that the use of ``memory`` to enable caching becomes interesting when the
 fitting of a transformer is costly.
 
-###############################################################################
+# %%
 Illustration of ``Pipeline`` and ``GridSearchCV``
 ###############################################################################
 
@@ -89,7 +89,7 @@
 
 plt.show()
 
-###############################################################################
+# %%
 # Caching transformers within a ``Pipeline``
 ###############################################################################
 # It is sometimes worthwhile storing the state of a specific transformer
@@ -119,7 +119,7 @@
 memory.clear(warn=False)
 rmtree(location)
 
-###############################################################################
+# %%
 # The ``PCA`` fitting is only computed at the evaluation of the first
 # configuration of the ``C`` parameter of the ``LinearSVC`` classifier. The
 # other configurations of ``C`` will trigger the loading of the cached ``PCA``

examples/compose/plot_transformed_target.py

@@ -27,7 +27,7 @@
 from sklearn.compose import TransformedTargetRegressor
 from sklearn.metrics import median_absolute_error, r2_score
 
-###############################################################################
+# %%
 # Synthetic example
 ##############################################################################
 
@@ -37,7 +37,7 @@
 else:
     density_param = {'normed': True}
 
-###############################################################################
+# %%
 # A synthetic random regression dataset is generated. The targets ``y`` are
 # modified by:
 #
@@ -54,7 +54,7 @@
 y = np.expm1((y + abs(y.min())) / 200)
 y_trans = np.log1p(y)
 
-###############################################################################
+# %%
 # Below we plot the probability density functions of the target
 # before and after applying the logarithmic functions.
 
@@ -76,7 +76,7 @@
 
 X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
 
-###############################################################################
+# %%
 # At first, a linear model will be applied on the original targets. Due to the
 # non-linearity, the model trained will not be precise during
 # prediction. Subsequently, a logarithmic function is used to linearize the
@@ -118,11 +118,10 @@
 f.suptitle("Synthetic data", y=0.035)
 f.tight_layout(rect=[0.05, 0.05, 0.95, 0.95])
 
-###############################################################################
+# %%
 # Real-world data set
 ###############################################################################
-
-###############################################################################
+#
 # In a similar manner, the Ames housing data set is used to show the impact
 # of transforming the targets before learning a model. In this example, the
 # target to be predicted is the selling price of each house.
@@ -140,8 +139,7 @@
                              n_quantiles=900,
                              output_distribution='normal',
                              copy=True).squeeze()
-
-###############################################################################
+# %%
 # A :class:`~sklearn.preprocessing.QuantileTransformer` is used to normalize
 # the target distribution before applying a
 # :class:`~sklearn.linear_model.RidgeCV` model.
@@ -164,7 +162,7 @@
 
 X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
 
-###############################################################################
+# %%
 # The effect of the transformer is weaker than on the synthetic data. However,
 # the transformation results in an increase in :math:`R^2` and large decrease
 # of the MAE. The residual plot (predicted target - true target vs predicted

examples/covariance/plot_lw_vs_oas.py

@@ -29,7 +29,7 @@
 from sklearn.covariance import LedoitWolf, OAS
 
 np.random.seed(0)
-###############################################################################
+# %%
 n_features = 100
 # simulation covariance matrix (AR(1) process)
 r = 0.1

examples/ensemble/plot_gradient_boosting_early_stopping.py

@@ -91,7 +91,7 @@
 index = np.arange(0, n * bar_width, bar_width) * 2.5
 index = index[0:n]
 
-#######################################################################
+# %%
 # Compare scores with and without early stopping
 # ----------------------------------------------
 
@@ -129,7 +129,7 @@ def autolabel(rects, n_estimators):
 plt.show()
 
 
-#######################################################################
+# %%
 # Compare fit times with and without early stopping
 # -------------------------------------------------
 

examples/ensemble/plot_gradient_boosting_regression.py

@@ -28,7 +28,7 @@
 from sklearn.metrics import mean_squared_error
 from sklearn.model_selection import train_test_split
 
-##############################################################################
+# %%
 # Load the data
 # -------------------------------------
 #
@@ -37,7 +37,7 @@
 diabetes = datasets.load_diabetes()
 X, y = diabetes.data, diabetes.target
 
-##############################################################################
+# %%
 # Data preprocessing
 # -------------------------------------
 #
@@ -69,7 +69,7 @@
           'learning_rate': 0.01,
           'loss': 'ls'}
 
-##############################################################################
+# %%
 # Fit regression model
 # -------------------------------------
 #
@@ -82,7 +82,7 @@
 mse = mean_squared_error(y_test, reg.predict(X_test))
 print("The mean squared error (MSE) on test set: {:.4f}".format(mse))
 
-##############################################################################
+# %%
 # Plot training deviance
 # -------------------------------------
 #
@@ -106,7 +106,7 @@
 fig.tight_layout()
 plt.show()
 
-##############################################################################
+# %%
 # Plot feature importance
 # -------------------------------------
 #