{

 "cells": [

  {

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "# Global Experiment Setup"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 3,

   "metadata": {},

   "outputs": [

    {

     "data": {

      "text/plain": [

       "<Experiment: artifact_location='/Users/arham/Downloads/Projects/03-Experiments/mlruns/2', creation_time=1713912394972, experiment_id='2', last_update_time=1713912394972, lifecycle_stage='active', name='XGBoost', tags={}>"

      ]

     },

     "execution_count": 3,

     "metadata": {},

     "output_type": "execute_result"

    }

   ],

   "source": [

    "import mlflow\n",

    "\n",

    "\n",

    "# Set the MLflow tracking URI to a new SQLite URI\n",

    "mlflow.set_tracking_uri(\"sqlite:///new_mlflow.db\")\n",

    "mlflow.set_experiment(\"XGBoost\")\n",

    "\n"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 4,

   "metadata": {},

   "outputs": [],

   "source": [

    "import pandas as pd\n",

    "from sklearn.model_selection import train_test_split\n",

    "import matplotlib.pyplot as plt\n",

    "import seaborn as sns\n",

    "import numpy as np\n",

    "from sklearn.preprocessing import MinMaxScaler\n",

    "from sklearn.preprocessing import PolynomialFeatures\n",

    "import lightgbm as lgb\n",

    "from sklearn.metrics import accuracy_score\n",

    "import warnings\n",

    "from sklearn.tree import DecisionTreeClassifier\n",

    "from sklearn.model_selection import cross_val_score\n",

    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",

    "import xgboost as xgb\n",

    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",

    "from sklearn.model_selection import cross_val_score\n",

    "\n",

    "\n",

    "def load_data(path):\n",

    "    df = pd.read_csv(path)\n",

    "    train_df, test_df = train_test_split(df, test_size=0.35, random_state=42)\n",

    "    train_df, val_df,  = train_test_split(train_df, test_size=0.20, random_state=42)\n",

    "    train_df = train_df.drop(['id'], axis=1).drop_duplicates().reset_index(drop=True)\n",

    "    test_df = test_df.drop(['id'], axis=1).drop_duplicates().reset_index(drop=True)\n",

    "    val_df = val_df.drop(['id'], axis=1).drop_duplicates().reset_index(drop=True)\n",

    "    return train_df, val_df, test_df\n",

    "\n",

    "def encode_target(train):\n",

    "    target_key = {'Insufficient_Weight': 0, 'Normal_Weight': 1, 'Overweight_Level_I': 2, 'Overweight_Level_II': 3, 'Obesity_Type_I': 4,'Obesity_Type_II' : 5, 'Obesity_Type_III': 6}\n",

    "    train['NObeyesdad'] = train['NObeyesdad'].map(target_key)\n",

    "    return train\n",

    "\n",

    "def make_gender_binary(train):\n",

    "    train['Gender'] = train['Gender'].map({'Male':0, 'Female':1})\n",

    "\n",

    "def datatypes(train):\n",

    "    train['Weight'] = train['Weight'].astype(float)\n",

    "    train['Age'] = train['Age'].astype(float)\n",

    "    train['Height'] = train['Height'].astype(float)\n",

    "    return train\n",

    "\n",

    "# def age_binning(train_df):\n",

    "#     # train_df['Age_Group'] = pd.cut(train_df['Age'], bins=[0, 20, 30, 40, 50, train_df['Age'].max()], labels=['0-20', '21-30', '31-40', '41-50', '50+'])\n",

    "#     train_df['Age_Group'] = pd.cut(train_df['Age'], bins=[0, 20, 30, 40, 50, train_df['Age'].max()], labels=[1, 2, 3, 4, 5])\n",

    "#     train_df['Age_Group'] = train_df['Age_Group'].astype(int)\n",

    "#     return train_df\n",

    "\n",

    "def age_binning(df):\n",

    "    age_groups = []\n",

    "    for age in df['Age']:\n",

    "        if age <= 20:\n",

    "            age_group = 1\n",

    "        elif age <= 30:\n",

    "            age_group = 2\n",

    "        elif age <= 40:\n",

    "            age_group = 3\n",

    "        elif age <= 50:\n",

    "            age_group = 4\n",

    "        else:\n",

    "            age_group = 5\n",

    "        age_groups.append(age_group)\n",

    "    df['Age_Group'] = age_groups\n",

    "    return df\n",

    "\n",

    "def age_scaling_log(train_df):\n",

    "    train_df['Age'] = train_df['Age'].astype(float)\n",

    "    train_df['Log_Age'] = np.log1p(train_df['Age'])\n",

    "    return train_df\n",

    "\n",

    "def age_scaling_minmax(train_df):\n",

    "    train_df['Age'] = train_df['Age'].astype(float)\n",

    "    scaler_age = MinMaxScaler()\n",

    "    train_df['Scaled_Age'] = scaler_age.fit_transform(train_df['Age'].values.reshape(-1, 1))\n",

    "    return train_df, scaler_age\n",

    "\n",

    "def weight_scaling_log(train_df):\n",

    "    train_df['Weight'] = train_df['Weight'].astype(float)\n",

    "    train_df['Log_Weight'] = np.log1p(train_df['Weight'])\n",

    "    return train_df\n",

    "\n",

    "def weight_scaling_minmax(train_df):\n",

    "    train_df['Weight'] = train_df['Weight'].astype(float)\n",

    "    scaler_weight = MinMaxScaler()\n",

    "    train_df['Scaled_Weight'] = scaler_weight.fit_transform(train_df['Weight'].values.reshape(-1, 1))\n",

    "    return train_df, scaler_weight\n",

    "\n",

    "def height_scaling_log(train_df):\n",

    "    train_df['Log_Height'] = np.log1p(train_df['Height'])\n",

    "    return train_df\n",

    "\n",

    "def height_scaling_minmax(train_df):\n",

    "    scaler_height = MinMaxScaler()\n",

    "    train_df['Scaled_Height'] = scaler_height.fit_transform(train_df['Height'].values.reshape(-1, 1))\n",

    "    return train_df, scaler_height\n",

    "\n",

    "def make_gender_binary(train):\n",

    "    train['Gender'] = train['Gender'].map({'Female':1, 'Male':0})\n",

    "    return train\n",

    "\n",

    "def fix_binary_columns(train):\n",

    "    Binary_Cols = ['family_history_with_overweight','FAVC', 'SCC','SMOKE']\n",

    "    # if yes then 1 else 0\n",

    "    for col in Binary_Cols:\n",

    "        train[col] = train[col].map({'yes': 1, 'no': 0})\n",

    "        # column datatype integer\n",

    "        train[col] = train[col].astype(int)\n",

    "    return train\n",

    "\n",

    "def freq_cat_cols(train):\n",

    "    # One hot encoding\n",

    "    cat_cols = ['CAEC', 'CALC']\n",

    "    for col in cat_cols:\n",

    "        train[col] = train[col].map({'no': 0, 'Sometimes': 1, 'Frequently': 2, 'Always': 3})\n",

    "    return train\n",

    "\n",

    "def Mtrans(train):\n",

    "    \"\"\"\n",

    "    Public_Transportation    8692\n",

    "    Automobile               1835\n",

    "    Walking                   231\n",

    "    Motorbike                  19\n",

    "    Bike                       16\n",

    "    \"\"\"\n",

    "    # train['MTRANS'] = train['MTRANS'].map({'Public_Transportation': 3, 'Automobile': 5, 'Walking': 1, 'Motorbike': 4, 'Bike': 2})\n",

    "    # dummify column\n",

    "    train = pd.get_dummies(train, columns=['MTRANS'])\n",

    "    # convert these columns to integer\n",

    "    train['MTRANS_Automobile'] = train['MTRANS_Automobile'].astype(int)\n",

    "    train['MTRANS_Walking'] = train['MTRANS_Walking'].astype(int)\n",

    "    train['MTRANS_Motorbike'] = train['MTRANS_Motorbike'].astype(int)\n",

    "    train['MTRANS_Bike'] = train['MTRANS_Bike'].astype(int)\n",

    "    train['MTRANS_Public_Transportation'] = train['MTRANS_Public_Transportation'].astype(int)\n",

    "    return train\n",

    "\n",

    "\n",

    "def other_features(train):\n",

    "    train['BMI'] = train['Weight'] / (train['Height'] ** 2)\n",

    "    # train['Age'*'Gender'] = train['Age'] * train['Gender']\n",

    "    polynomial_features = PolynomialFeatures(degree=2)\n",

    "    X_poly = polynomial_features.fit_transform(train[['Age', 'BMI']])\n",

    "    poly_features_df = pd.DataFrame(X_poly, columns=['Age^2', 'Age^3', 'BMI^2', 'Age * BMI', 'Age * BMI^2', 'Age^2 * BMI^2'])\n",

    "    train = pd.concat([train, poly_features_df], axis=1)\n",

    "    return train\n",

    "\n",

    "\n",

    "def test_pipeline(test, scaler_age, scaler_weight, scaler_height):\n",

    "    test = datatypes(test)\n",

    "    test = encode_target(test)\n",

    "    test = age_binning(test)\n",

    "    test = age_scaling_log(test)\n",

    "    test['Scaled_Age'] = scaler_age.transform(test['Age'].values.reshape(-1, 1))\n",

    "    test = weight_scaling_log(test)\n",

    "    test['Scaled_Weight'] = scaler_weight.transform(test['Weight'].values.reshape(-1, 1))\n",

    "    test = height_scaling_log(test)\n",

    "    test['Scaled_Height'] = scaler_height.transform(test['Height'].values.reshape(-1, 1))\n",

    "    test = make_gender_binary(test)\n",

    "    test = fix_binary_columns(test)\n",

    "    test = freq_cat_cols(test)\n",

    "    test = Mtrans(test)\n",

    "    test = other_features(test)\n",

    "\n",

    "    return test\n",

    "\n",

    "def train_model(params, X_train, y_train):\n",

    "    lgb_train = lgb.Dataset(X_train, y_train)\n",

    "    model = lgb.train(params, lgb_train, num_boost_round=1000)\n",

    "    return model\n",

    "\n",

    "def evaluate_model(model, X_val, y_val):\n",

    "    y_pred = model.predict(X_val)\n",

    "    y_pred = [np.argmax(y) for y in y_pred]\n",

    "    accuracy = accuracy_score(y_val, y_pred)\n",

    "    return accuracy\n",

    "\n",

    "def objective(trial, X_train, y_train):\n",

    "    params = {\n",

    "        'objective': 'multiclass',\n",

    "        'num_class': 7,\n",

    "        'metric': 'multi_logloss',\n",

    "        'boosting_type': 'gbdt',\n",

    "        'learning_rate': trial.suggest_loguniform('learning_rate', 0.005, 0.5),\n",

    "        'num_leaves': trial.suggest_int('num_leaves', 10, 1000),\n",

    "        'max_depth': trial.suggest_int('max_depth', -1, 20),\n",

    "        'bagging_fraction': trial.suggest_uniform('bagging_fraction', 0.6, 0.95),\n",

    "        'feature_fraction': trial.suggest_uniform('feature_fraction', 0.6, 0.95),\n",

    "        'verbosity': -1\n",

    "    }\n",

    "\n",

    "    n_splits = 5\n",

    "    kf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)\n",

    "    scores = []\n",

    "\n",

    "    for train_index, val_index in kf.split(X_train, y_train):\n",

    "        X_tr, X_val = X_train.iloc[train_index], X_train.iloc[val_index]\n",

    "        y_tr, y_val = y_train.iloc[train_index], y_train.iloc[val_index]\n",

    "\n",

    "        model = train_model(params, X_tr, y_tr)\n",

    "        accuracy = evaluate_model(model, X_val, y_val)\n",

    "        scores.append(accuracy)\n",

    "\n",

    "    return np.mean(scores)\n",

    "\n",

    "def optimize_hyperparameters(X_train, y_train, n_trials=2):\n",

    "    study = optuna.create_study(direction='maximize')\n",

    "    study.optimize(lambda trial: objective(trial, X_train, y_train), n_trials=n_trials)\n",

    "    return study.best_params\n"

   ]

  },

  {

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "### XGB With Feature Engineering"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 5,

   "metadata": {},

   "outputs": [],

   "source": [

    "\n",

    "path = '/Users/arham/Downloads/Projects/01-Dataset/01-Data-for-model-building/train.csv'\n",

    "train_df, val_df, test_df = load_data(path)\n",

    "\n",

    "train_df = datatypes(train_df)\n",

    "train_df = encode_target(train_df)\n",

    "train_df = age_binning(train_df)\n",

    "train_df, scaler_age = age_scaling_minmax(train_df)\n",

    "train_df = age_scaling_log(train_df)\n",

    "train_df, scaler_weight = weight_scaling_minmax(train_df)\n",

    "train_df = weight_scaling_log(train_df)\n",

    "train_df, scaler_height = height_scaling_minmax(train_df)\n",

    "train_df = height_scaling_log(train_df)\n",

    "train_df = make_gender_binary(train_df)\n",

    "train_df = fix_binary_columns(train_df)\n",

    "train_df = freq_cat_cols(train_df)\n",

    "train_df = Mtrans(train_df)\n",

    "train_df = other_features(train_df)\n",

    "\n",

    "val_df = test_pipeline(val_df, scaler_age, scaler_weight, scaler_height)\n",

    "test_df = test_pipeline(test_df, scaler_age, scaler_weight, scaler_height)\n",

    "\n",

    "Target = 'NObeyesdad'\n",

    "# features = train_df.columns.drop(Target)\n",

    "features = ['Gender', 'Age', 'Height', 'Weight', 'family_history_with_overweight',\n",

    "       'FAVC', 'FCVC', 'NCP', 'CAEC', 'SMOKE', 'CH2O', 'SCC', 'FAF', 'TUE',\n",

    "       'CALC', 'Age_Group', \n",

    "       'MTRANS_Automobile', 'MTRANS_Bike', 'MTRANS_Motorbike',\n",

    "       'MTRANS_Public_Transportation', 'MTRANS_Walking', 'BMI', 'Age^2',\n",

    "       'Age^3', 'BMI^2', 'Age * BMI', 'Age * BMI^2', 'Age^2 * BMI^2'] \n",

    "\n",

    "       #'Scaled_Age', 'Log_Age', 'Scaled_Weight', 'Log_Weight', 'Scaled_Height', 'Log_Height',\n",

    "\n",

    "\n",

    "X_train = train_df[features]\n",

    "y_train = train_df[Target]\n",

    "X_val = val_df[features]\n",

    "y_val = val_df[Target]\n",

    "X_test = test_df[features]\n",

    "y_test = test_df[Target]\n",

    "\n",

    "# save X_train, y_train, X_val, X_test, y_test\n"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 8,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "Target Drift For Each Class [0.004943133623686147, 0.011990707821925795, -0.0087675011457998, -0.001077949504617301, -0.017190035106736085, -0.00032756263090533144, 0.01042920694244659]\n",

      "Cross-validation Scores (XGBoost): [nan nan nan nan nan]\n",

      "Mean CV Accuracy (XGBoost): nan\n"

     ]

    },

    {

     "ename": "TypeError",

     "evalue": "XGBClassifier.fit() got an unexpected keyword argument 'objective'",

     "output_type": "error",

     "traceback": [

      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",

      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",

      "Cell \u001b[0;32mIn[8], line 23\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCross-validation Scores (XGBoost):\u001b[39m\u001b[38;5;124m\"\u001b[39m, cv_scores_xgb)\n\u001b[1;32m     22\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMean CV Accuracy (XGBoost):\u001b[39m\u001b[38;5;124m\"\u001b[39m, cv_scores_xgb\u001b[38;5;241m.\u001b[39mmean())\n\u001b[0;32m---> 23\u001b[0m \u001b[43mxgb_classifier\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mobjective\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmulti:softmax\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     24\u001b[0m y_val_pred_xgb \u001b[38;5;241m=\u001b[39m xgb_classifier\u001b[38;5;241m.\u001b[39mpredict(X_val)\n\u001b[1;32m     25\u001b[0m accuracy_xgb \u001b[38;5;241m=\u001b[39m accuracy_score(y_val, y_val_pred_xgb)\n",

      "File \u001b[0;32m~/anaconda3/envs/DataScience/lib/python3.10/site-packages/xgboost/core.py:620\u001b[0m, in \u001b[0;36mrequire_keyword_args.<locals>.throw_if.<locals>.inner_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    618\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(sig\u001b[38;5;241m.\u001b[39mparameters, args):\n\u001b[1;32m    619\u001b[0m     kwargs[k] \u001b[38;5;241m=\u001b[39m arg\n\u001b[0;32m--> 620\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",

      "\u001b[0;31mTypeError\u001b[0m: XGBClassifier.fit() got an unexpected keyword argument 'objective'"

     ]

    }

   ],

   "source": [

    "\n",

    "import xgboost as xgb\n",

    "from sklearn.model_selection import cross_val_score\n",

    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",

    "import mlflow\n",

    "import warnings\n",

    "warnings.filterwarnings(\"ignore\")\n",

    "# import precision_recall_fscore_support\n",

    "from sklearn.metrics import precision_recall_fscore_support\n",

    "\n",

    "mlflow.sklearn.autolog(disable=True)\n",

    "\n",

    "with mlflow.start_run(run_name=\"XGB_FE_Recall\"):\n",

    "    class_counts_train = [y_train[y_train == i].count() / y_train.count() for i in range(7)]\n",

    "    class_counts_val = [y_val[y_val == i].count() / y_val.count() for i in range(7)]\n",

    "    target_drift = [(train_count - val_count) for train_count, val_count in zip(class_counts_train, class_counts_val)]\n",

    "    print(f\"Target Drift For Each Class {target_drift}\")\n",

    "    mlflow.log_params({'Target_Drift_' + str(i): freq for i, freq in enumerate(target_drift)})\n",

    "\n",

    "    xgb_classifier = xgb.XGBClassifier()\n",

    "    cv_scores_xgb = cross_val_score(xgb_classifier, X_train, y_train, cv=5, scoring='recall')\n",

    "    print(\"Cross-validation Scores (XGBoost):\", cv_scores_xgb)\n",

    "    print(\"Mean CV Accuracy (XGBoost):\", cv_scores_xgb.mean())\n",

    "    xgb_classifier.fit(X_train, y_train)\n",

    "    y_val_pred_xgb = xgb_classifier.predict(X_val)\n",

    "    accuracy_xgb = accuracy_score(y_val, y_val_pred_xgb)\n",

    "    precision_xgb = precision_score(y_val, y_val_pred_xgb, average='weighted')\n",

    "    recall_xgb = recall_score(y_val, y_val_pred_xgb, average='weighted')\n",

    "    f1_xgb = 2 * (precision_xgb * recall_xgb) / (precision_xgb + recall_xgb)\n",

    "    print(\"\\nAccuracy (XGBoost):\", accuracy_xgb)\n",

    "    print(\"Precision (XGBoost):\", precision_xgb)\n",

    "    print(\"Recall (XGBoost):\", recall_xgb)\n",

    "    print(\"F1 (XGBoost):\", f1_xgb)\n",

    "    mlflow.log_metric('accuracy', accuracy_xgb)\n",

    "    mlflow.log_metric('precision', precision_xgb)\n",

    "    mlflow.log_metric('recall', recall_xgb)\n",

    "    mlflow.log_metric('f1', f1_xgb)\n",

    "\n",

    "    precision_per_class, recall_per_class, f1_per_class, support_per_class = precision_recall_fscore_support(y_val, y_val_pred_xgb, average=None)\n",

    "    for i in range(len(recall_per_class)):\n",

    "        print(f\"Recall for class {i}: {recall_per_class[i]}\")\n",

    "        mlflow.log_metric(f'recall_class_{i}', recall_per_class[i])\n",

    "\n",

    "    mlflow.xgboost.log_model(xgb_classifier, 'model')\n",

    "    mlflow.set_tag('experiments', 'Arham A.')\n",

    "    mlflow.set_tag('model_name', 'XGBoost')\n",

    "    mlflow.set_tag('preprocessing', 'Yes')\n"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 7,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "[2024-04-25 14:27:06 -0400] [12399] [INFO] Starting gunicorn 21.2.0\n",

      "[2024-04-25 14:27:06 -0400] [12399] [INFO] Listening at: http://127.0.0.1:5000 (12399)\n",

      "[2024-04-25 14:27:06 -0400] [12399] [INFO] Using worker: sync\n",

      "[2024-04-25 14:27:06 -0400] [12400] [INFO] Booting worker with pid: 12400\n",

      "[2024-04-25 14:27:06 -0400] [12401] [INFO] Booting worker with pid: 12401\n",

      "[2024-04-25 14:27:06 -0400] [12402] [INFO] Booting worker with pid: 12402\n",

      "[2024-04-25 14:27:06 -0400] [12403] [INFO] Booting worker with pid: 12403\n",

      "^C\n",

      "[2024-04-25 14:34:22 -0400] [12399] [INFO] Handling signal: int\n",

      "[2024-04-25 14:34:22 -0400] [12400] [INFO] Worker exiting (pid: 12400)\n",

      "[2024-04-25 14:34:22 -0400] [12401] [INFO] Worker exiting (pid: 12401)\n",

      "[2024-04-25 14:34:22 -0400] [12403] [INFO] Worker exiting (pid: 12403)\n",

      "[2024-04-25 14:34:22 -0400] [12402] [INFO] Worker exiting (pid: 12402)\n"

     ]

    }

   ],

   "source": [

    "!mlflow ui --backend-store-uri \"sqlite:////Users/arham/Downloads/Projects/03-Experiments/new_mlflow.db\""

   ]

  },

  {

   "cell_type": "code",

   "execution_count": null,

   "metadata": {},

   "outputs": [],

   "source": []

  }

 ],

 "metadata": {

  "kernelspec": {

   "display_name": "DataScience",

   "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.10.13"

  }

 },

 "nbformat": 4,

 "nbformat_minor": 2

}