{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Standard Scikit-learn Classification Summary with FACET\n", "\n", "FACET is composed of the following key components:\n", "\n", "- **Model Inspection**\n", "\n", " FACET introduces a new algorithm to quantify dependencies and interactions between features in ML models. This new tool for human-explainable AI adds a new, global perspective to the observation-level explanations provided by the popular [SHAP](https://shap.readthedocs.io/en/latest/) approach. To learn more about FACET's model inspection capabilities, see the getting started example below.\n", "\n", "\n", "- **Model Simulation**\n", "\n", " FACET's model simulation algorithms use ML models for *virtual experiments* to help identify scenarios that optimise predicted outcomes. To quantify the uncertainty in simulations, FACET utilises a range of bootstrapping algorithms including stationary and stratified bootstraps. For an example of FACET’s bootstrap simulations, see the getting started example below. \n", " \n", " \n", "- **Enhanced Machine Learning Workflow** \n", "\n", " FACET offers an efficient and transparent machine learning workflow, enhancing [scikit-learn]( https://scikit-learn.org/stable/index.html)'s tried and tested pipelining paradigm with new capabilities for model selection, inspection, and simulation. FACET also introduces [sklearndf](https://github.com/BCG-X-Official/sklearndf), an augmented version of *scikit-learn* with enhanced support for *pandas* dataframes that ensures end-to-end traceability of features. \n", "\n", "***\n", "\n", "**Context**\n", "\n", "In this tutorial notebook we will first build a classifier for predicting customer churn using a well known datasets from [Kaggle](https://www.kaggle.com/blastchar/telco-customer-churn). Then using the developed classifier we will demonstrate how to perform selected typical model performance summary tasks including:\n", "- Using a final fitted model on all CV-folds to obtain a confusion matrix, classification report and precision-recall curve\n", "- Using models fitted to each CV fold, create a set of summary metrics and a ROC curve both with an assessment of error based on the cross-validation\n", "\n", "***\n", "\n", "**Tutorial outline**\n", "\n", "1. [Required imports](#Required-imports)\n", "2. [Quick data preparation](#Quick-data-preparation)\n", "3. [Preprocessing and feature selection](#Preprocessing-and-feature-selection)\n", "4. [Learner selection with FACET](#Learner-selection-with-FACET)\n", "5. [Using the final fitted model](#Using-the-final-fitted-model)\n", "6. [Using the crossfit for the best model](#Using-the-crossfit-for-the-best-model)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "delete_for_interactive": true, "nbsphinx": "hidden" }, "outputs": [], "source": [ "# this cell's metadata contains\n", "# \"nbsphinx\": \"hidden\" so it is hidden by nbsphinx\n", "\n", "\n", "# ignore irrelevant warnings that would affect the output of this tutorial notebook\n", "\n", "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\", category=UserWarning, message=r\".*Xcode_8\\.3\\.3\")\n", "warnings.filterwarnings(\"ignore\", message=r\".*`should_run_async` will not call `transform_cell`\")\n", "warnings.filterwarnings(\"ignore\", message=r\".*`np\\..*` is a deprecated alias\")\n", "warnings.filterwarnings(\"ignore\", message=r\"Importing display from IPython.core.display is deprecated.*\")\n", "\n", "\n", "# set global options for matplotlib\n", "\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "matplotlib.rcParams[\"figure.figsize\"] = (12.0, 6.0)\n", "matplotlib.rcParams[\"figure.dpi\"] = 96" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In order to run this notebook, we will import not only the FACET package, but also other packages useful to solve this task. Overall, we can break down the imports into three categories: \n", "\n", "1. Common packages (pandas, matplotlib, sklearn, etc.)\n", "2. Required FACET classes (i.e., selection)\n", "3. Other BCG GAMMA packages which simplify pipelining (sklearndf, see on [GitHub](https://github.com/orgs/BCG-X-Official/sklearndf/)) when using FACET" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Common package imports**" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "from numpy import interp\n", "import matplotlib.pylab as plt\n", "\n", "from sklearn.metrics import (\n", " classification_report,\n", " confusion_matrix,\n", " roc_curve,\n", " roc_auc_score,\n", " auc,\n", " accuracy_score,\n", " f1_score,\n", " precision_score,\n", " recall_score,\n", " precision_recall_curve,\n", " ConfusionMatrixDisplay,\n", " PrecisionRecallDisplay,\n", ")\n", "from sklearn.compose import make_column_selector\n", "from sklearn.model_selection import RepeatedKFold, GridSearchCV" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**FACET imports**" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from facet.data import Sample\n", "from facet.selection import LearnerSelector, MultiEstimatorParameterSpace, ParameterSpace" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**sklearndf imports**\n", "\n", "Instead of using the \"regular\" scikit-learn package, we are going to use sklearndf (see on [GitHub](https://github.com/orgs/BCG-X-Official/sklearndf/)). sklearndf is an open source library designed to address a common issue with scikit-learn: the outputs of transformers are numpy arrays, even when the input is a data frame. However, to inspect a model it is essential to keep track of the feature names. sklearndf retains all the functionality available through scikit-learn plus the feature traceability and usability associated with Pandas data frames. Additionally, the names of all your favourite scikit-learn functions are the same except for `DF` on the end. For example, the standard scikit-learn import:\n", "\n", "`from sklearn.pipeline import Pipeline`\n", "\n", "becomes:\n", "\n", "`from sklearndf.pipeline import PipelineDF`" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "from sklearndf.pipeline import PipelineDF, ClassifierPipelineDF\n", "from sklearndf.classification import RandomForestClassifierDF\n", "from sklearndf.transformation import (\n", " ColumnTransformerDF,\n", " OneHotEncoderDF,\n", " SimpleImputerDF,\n", ")\n", "from sklearndf.transformation.extra import BorutaDF" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Quick data preparation\n", "\n", "We start by obtaining a dataset for analysis. In this case we use the well known Telco Customer Churn dataset from [Kaggle](https://www.kaggle.com/blastchar/telco-customer-churn).\n", "\n", "Briefly, the dataset contains one row for each of 7043 customers and includes information on those who left with the last month (i.e., `Churn` - our target of interest, n=1869), services signed up for, account information and demographics.\n", "\n", "As this dataset has been well described and analyzed, we apply the minimum number of steps necessary to prepare the data for this tutorial. These are as follows:\n", "\n", "- drop the `customerID` column\n", "- convert `TotalCharges` to numeric type\n", "- convert `SeniorCitizen` to string type\n", "- relabel and convert `Churn` to a 0/1 target\n", "\n", "Finally we place the dataframe in a FACET `Sample` object for easier data management. This allows us to:\n", "\n", "- Quickly access the target vs. features\n", "- Pass our data into sklearndf pipelines\n", "- Pass information to other FACET functions" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "churn sample data loaded with 7043 observations\n" ] } ], "source": [ "# This dataset is from Kaggle has been analyzed numerous times, and so we skip EDA\n", "# read in the data\n", "churn_df = pd.read_csv('KAGGLE-Telco-Customer-Churn.csv')\n", "\n", "# drop customer ID\n", "churn_df = churn_df.drop(columns=['customerID'])\n", "\n", "# TotalCharges needs to be float (known to have a few missing values)\n", "churn_df.TotalCharges = pd.to_numeric(churn_df.TotalCharges, errors='coerce')\n", "\n", "# To support preprocessing pipeline we will also convert SeniorCitizen to object type\n", "# only tenure, MonthlyCharges and TotalCharges are numeric\n", "churn_df.SeniorCitizen = churn_df.SeniorCitizen.astype(\"category\")\n", "\n", "# Create a new 0/1 target where 1=churn\n", "churn_df.Churn = churn_df.Churn.map(dict(Yes=1, No=0))\n", "\n", "# create sample object\n", "churn_sample = Sample(\n", " observations=churn_df,\n", " feature_names=churn_df.drop(columns=[\"Churn\"]).columns,\n", " target_name=\"Churn\",\n", ")\n", "\n", "print(f\"churn sample data loaded with {len(churn_sample)} observations\")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['gender',\n", " 'SeniorCitizen',\n", " 'Partner',\n", " 'Dependents',\n", " 'tenure',\n", " 'PhoneService',\n", " 'MultipleLines',\n", " 'InternetService',\n", " 'OnlineSecurity',\n", " 'OnlineBackup',\n", " 'DeviceProtection',\n", " 'TechSupport',\n", " 'StreamingTV',\n", " 'StreamingMovies',\n", " 'Contract',\n", " 'PaperlessBilling',\n", " 'PaymentMethod',\n", " 'MonthlyCharges',\n", " 'TotalCharges']" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# get feature names\n", "churn_sample.feature_names" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Preprocessing and feature selection\n", "\n", "Our first step is to create a minimum preprocessing pipeline which based on our dataset needs to address the following:\n", "\n", "- Simple imputation for missing values\n", "\n", "- One-hot encoding for categorical features\n", "\n", "We will use the sklearndf wrappers for scikit-learn functions such as `SimpleImputerDF` in place of `SimpleImputer`, `OneHotEncoderDF` in place of `OneHotEncoder`, and so on." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# for categorical features we will use the mode as the imputation value and also one-hot encode\n", "preprocessing_categorical = PipelineDF(\n", " steps=[\n", " (\"imputer\", SimpleImputerDF(strategy=\"most_frequent\", fill_value=\"\")),\n", " (\"one-hot\", OneHotEncoderDF(sparse=False, handle_unknown=\"ignore\")),\n", " ]\n", ")\n", "\n", "# for numeric features we will impute using the median\n", "preprocessing_numerical = SimpleImputerDF(strategy=\"median\")\n", "\n", "# put the pipeline together\n", "preprocessing_features = ColumnTransformerDF(\n", " transformers=[\n", " (\n", " \"categorical\",\n", " preprocessing_categorical,\n", " make_column_selector(dtype_include=object),\n", " ),\n", " (\n", " \"numerical\",\n", " preprocessing_numerical,\n", " make_column_selector(dtype_include=np.number),\n", " ),\n", " ],\n", " verbose_feature_names_out=False,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we perform some initial feature selection using Boruta, a recent approach shown to have quite good performance. The Boruta algorithm removes features that are no more predictive than random noise. If you are interested further, please see this [article](https://www.jstatsoft.org/article/view/v036i11).\n", "\n", "The `BorutaDF` transformer in our sklearndf package provides easy access to this powerful method. The approach relies on a tree-based learner, usually a random forest. For settings, a `max_depth` of between 3 and 7 is typically recommended, and here we rely on the default setting of 5. However, as this depends on the number of features and the complexity of interactions one could also explore the sensitivity of feature selection to this parameter. The number of trees is automatically managed by the Boruta feature selector argument `n_estimators=\"auto\"`.\n", "\n", "We also use parallelization for the random forest using `n_jobs` to accelerate the Boruta iterations." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(['InternetService', 'OnlineSecurity', 'OnlineBackup',\n", " 'DeviceProtection', 'TechSupport', 'StreamingTV',\n", " 'StreamingMovies', 'Contract', 'PaperlessBilling', 'PaymentMethod',\n", " 'tenure', 'MonthlyCharges', 'TotalCharges'], dtype=object)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# create the pipeline for Boruta\n", "boruta_feature_selection = PipelineDF(\n", " steps=[\n", " (\"preprocessing\", preprocessing_features),\n", " (\n", " \"boruta\",\n", " BorutaDF(\n", " estimator=RandomForestClassifierDF(\n", " max_depth=5, n_jobs=-3, random_state=42\n", " ),\n", " n_estimators=\"auto\",\n", " random_state=42,\n", " verbose=False,\n", " ),\n", " ),\n", " ]\n", ")\n", "\n", "# run feature selection using Boruta and report those selected\n", "boruta_feature_selection.fit(X=churn_sample.features, y=churn_sample.target)\n", "selected = boruta_feature_selection.feature_names_original_.unique()\n", "selected" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Learner selection with FACET\n", "\n", "FACET implements several additional useful wrappers which simplify comparing and tuning models:\n", "\n", "- `ParameterSpace`: allows you to pass a learner pipeline (i.e., classifier + any preprocessing) and set hyperparameters.\n", "\n", "- `LearnerSelector`: multiple LearnerGrids can be passed into this class as a list - this allows tuning hyperparameters both across different types of learners in a single step and ranks the resulting models accordingly\n", "\n", "For the purpose of this tutorial we will assess a Random Forest Classifier and hyperparameter ranges will be assessed using 10 repeated 5-fold cross-validation and be scored using AUC:\n", "\n", "Random forest: with hyperparameters\n", "\n", "- max_depth: [4, 8, 16, 32]\n", "\n", "- n_estimators: [200, 500]\n", "\n", "Learner ranking uses the average performance minus two times the standard deviation, so that we consider both the average performance and variability when selecting a classifier.\n", "\n", "If you want a list of available hyperparameters you can use `classifier_name().get_params().keys()` where `classifier_name` could be for example `RandomForestClassifierDF` and if you want to see the default values, just use `classifier_name().get_params()`." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
scoreparamtime
testclassifierfitscore
rankmeanstdmax_depthn_estimatorsmeanstdmeanstd
310.8464670.01019872000.4288130.0056490.0300350.002274
220.8461760.01020771000.2250230.0029870.0180260.000395
130.8427050.01057042000.3307420.0042080.0229320.000563
040.8420600.01070241000.1761520.0022480.0148630.000459
550.8416390.010050102000.5480960.0221820.0380360.003584
460.8409890.010235101000.2881220.0198390.0230280.003089
\n", "
" ], "text/plain": [ " score param time \\\n", " test classifier fit \n", " rank mean std max_depth n_estimators mean std \n", "3 1 0.846467 0.010198 7 200 0.428813 0.005649 \n", "2 2 0.846176 0.010207 7 100 0.225023 0.002987 \n", "1 3 0.842705 0.010570 4 200 0.330742 0.004208 \n", "0 4 0.842060 0.010702 4 100 0.176152 0.002248 \n", "5 5 0.841639 0.010050 10 200 0.548096 0.022182 \n", "4 6 0.840989 0.010235 10 100 0.288122 0.019839 \n", "\n", " \n", " score \n", " mean std \n", "3 0.030035 0.002274 \n", "2 0.018026 0.000395 \n", "1 0.022932 0.000563 \n", "0 0.014863 0.000459 \n", "5 0.038036 0.003584 \n", "4 0.023028 0.003089 " ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# reduce sample object to selected features\n", "churn_sample_kept_features = churn_sample.keep(feature_names=selected)\n", "\n", "# Classifier pipeline composed of the feature preprocessing steps created earlier and random forest learner\n", "rforest_clf = ClassifierPipelineDF(\n", " preprocessing=preprocessing_features,\n", " classifier=RandomForestClassifierDF(random_state=42),\n", ")\n", "\n", "# set space of hyper-parameters \n", "classifier_ps = ParameterSpace(rforest_clf)\n", "classifier_ps.classifier.max_depth = [4, 7, 10]\n", "classifier_ps.classifier.n_estimators = [100, 200]\n", "\n", "# run the learner selector\n", "clf_selector = LearnerSelector(\n", " searcher_type=GridSearchCV,\n", " parameter_space=classifier_ps,\n", " cv=RepeatedKFold(n_splits=5, n_repeats=10, random_state=42),\n", " n_jobs=-3,\n", " scoring=\"roc_auc\",\n", ").fit(churn_sample_kept_features)\n", "\n", "# look at results\n", "clf_selector.summary_report()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Using the final fitted model\n", "\n", "As part of the `clf_selector` we can access a final model (`best_estimator_`) that represents the selected best model but re-fit using all available training data. With this model we can then predict either the class or the probability (score) and generate standard scikit-learn classifier performance summaries such as a classification report, confusion matrix or precision-recall curve." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# obtain required quantities\n", "y_pred = clf_selector.best_estimator_.predict(churn_sample_kept_features.features)\n", "y_prob = clf_selector.best_estimator_.predict_proba(churn_sample_kept_features.features)[1]\n", "y_true = churn_sample_kept_features.target" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Classification Report\n", "\n", "The classification report from scikit-learn is often used as a summary for classifiers, especially in the case of imbalanced datasets, as it provides precision, recall and the f1-score by class along with the support (number of observations for a class). For more information on the implementation in scikit-learn please see [sklearn.metrics.classification_report](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report)." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.84 0.92 0.88 5174\n", " 1 0.70 0.53 0.61 1869\n", "\n", " accuracy 0.82 7043\n", " macro avg 0.77 0.73 0.74 7043\n", "weighted avg 0.81 0.82 0.81 7043\n", "\n" ] } ], "source": [ "print(classification_report(y_true, y_pred))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Confusion Matrix\n", "\n", "The confusion matrix can be used to evaluate the accuracy of the fitted classifier by comparing the predicted class to the observed class. For more information on the implementation in scikit-learn please see [sklearn.metrics.confusion_matrix](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html)." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cf_matrix = confusion_matrix(y_true, y_pred)\n", "ConfusionMatrixDisplay(cf_matrix).plot()" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Precision-recall curve\n", "\n", "The precision-recall curve is helpful for understanding the trade off between precision (positive predictive value) and recall (sensitivity) according to a specified threshold applied to the predicted probability (or score) for determining the predicted class for an observation. For more information on the implementation in scikit-learn please see [sklearn.metrics.precision_recall_curve](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve)." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "prec, recall, _ = precision_recall_curve(y_true, y_prob, pos_label=1)\n", "PrecisionRecallDisplay(precision=prec, recall=recall).plot()" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Panel of metrics\n", "\n", "Below we demonstrate how to use the best estimator results to obtain a set of common classification metrics: Accuracy, F1, Precision, Recall and AUC. This approach can of course be adapted to any metric and any summary thereof.\n", "\n", "For more information about classifier metrics in scikit-learn please see [classification-metrics](https://scikit-learn.org/stable/modules/model_evaluation.html#classification-metrics)." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'Summary of model performance')" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "metrics = []\n", "\n", "# calculate metrics\n", "metrics.append(pd.Series({\n", " 'Accuracy': accuracy_score(y_true, y_pred),\n", " 'F1': f1_score(y_true, y_pred),\n", " 'Precision': precision_score(y_true, y_pred),\n", " 'Recall': recall_score(y_true, y_pred),\n", " 'AUC': roc_auc_score(y_true, y_prob)})\n", ")\n", " \n", "# collect required summaries and plot\n", "metrics_df = pd.DataFrame(metrics)\n", "fig, ax = plt.subplots()\n", "ax.bar(\n", " metrics_df.columns,\n", " metrics_df.mean(),\n", " align='center',\n", " ecolor='lime',\n", " capsize=10,\n", " color='lightgrey'\n", ")\n", "ax.set_ylabel('Metric')\n", "ax.set_title('Summary of model performance')" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.13" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": false, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": { "height": "calc(100% - 180px)", "left": "10px", "top": "150px", "width": "384px" }, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }