winning-a-kaggle-competition-in-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explore train data\n",
    "\n",
    "You will work with another Kaggle competition called \"Store Item Demand Forecasting Challenge\". In this competition, you are given 5 years of store-item sales data, and asked to predict 3 months of sales for 50 different items in 10 different stores.\n",
    "\n",
    "To begin, let's explore the train data for this competition. For the faster performance, you will work with a subset of the train data containing only a single month history.\n",
    "\n",
    "Your initial goal is to read the input data and take the first look at it.\n",
    "This course is taken from  Yauhen Babakhin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train shape: (15500, 5)\n",
      "       id        date  store  item  sales\n",
      "0  100000  2017-12-01      1     1     19\n",
      "1  100001  2017-12-02      1     1     16\n",
      "2  100002  2017-12-03      1     1     31\n",
      "3  100003  2017-12-04      1     1      7\n",
      "4  100004  2017-12-05      1     1     20\n"
     ]
    }
   ],
   "source": [
    "# Import pandas\n",
    "import pandas  as pd\n",
    "\n",
    "# Read train data\n",
    "train = pd.read_csv('C:/Users/rzouga/Desktop/ALLINHERE/ALLINHERE/CRIPSDM/demand_forecasting_train_1_month.csv')\n",
    "\n",
    "# Look at the shape of the data\n",
    "print('Train shape:', train.shape)\n",
    "\n",
    "# Look at the head() of the data\n",
    "print(train.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explore test data\n",
    "\n",
    "Having looked at the train data, let's explore the test data in the \"Store Item Demand Forecasting Challenge\". Remember, that the test dataset generally contains one column less than the train one.\n",
    "\n",
    "This column, together with the output format, is presented in the sample submission file. Before making any progress in the competition, you should get familiar with the expected output.\n",
    "\n",
    "That is why, let's look at the columns of the test dataset and compare it to the train columns. Additionally, let's explore the format of the sample submission. The train DataFrame is available in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train columns: ['id', 'date', 'store', 'item', 'sales']\n",
      "Test columns: ['id', 'date', 'store', 'item']\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Read the test data\n",
    "test = pd.read_csv('demand_forecasting_test.csv')\n",
    "\n",
    "# Print train and test columns\n",
    "print('Train columns:', train.columns.tolist())\n",
    "print('Test columns:', test.columns.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>date</th>\n",
       "      <th>store</th>\n",
       "      <th>item</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>2018-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2018-01-02</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2018-01-03</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2018-01-04</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>2018-01-05</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id        date  store  item\n",
       "0   0  2018-01-01      1     1\n",
       "1   1  2018-01-02      1     1\n",
       "2   2  2018-01-03      1     1\n",
       "3   3  2018-01-04      1     1\n",
       "4   4  2018-01-05      1     1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare your first submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestRegressor()"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "\n",
    "\n",
    "# Create a Random Forest object\n",
    "rf =    RandomForestRegressor()\n",
    "\n",
    "# Train a model\n",
    "rf.fit(X=train[['store', 'item']], y=train['sales'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare a submission\n",
    "\n",
    "You've already built a model on the training data from the Kaggle Store Item Demand Forecasting Challenge. Now, it's time to make predictions on the test data and create a submission file in the specified format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get predictions for the test set\n",
    "test['sales'] = rf.predict(test[['store', 'item']])\n",
    "\n",
    "# Write test predictions using the sample_submission format\n",
    "test[['id', 'sales']].to_csv('kaggle_submission.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Public vs Private leaderboard\n",
    "## Overfitting \n",
    "###  Train XGBoost models\n",
    "\n",
    "Every Machine Learning method could potentially overfit. You will see it on this example with XGBoost. Again, you are working with the Store Item Demand Forecasting Challenge. The train DataFrame is available in your workspace.\n",
    "\n",
    "Firstly, let's train multiple XGBoost models with different sets of hyperparameters using XGBoost's learning API. The single hyperparameter you will change is:\n",
    "\n",
    "    max_depth - maximum depth of a tree. Increasing this value will make the model more complex and more likely to overfit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22:10:16] WARNING: C:/Users/Administrator/workspace/xgboost-win64_release_1.4.0/src/objective/regression_obj.cu:171: reg:linear is now deprecated in favor of reg:squarederror.\n",
      "[22:10:16] WARNING: C:/Users/Administrator/workspace/xgboost-win64_release_1.4.0/src/learner.cc:573: \n",
      "Parameters: { \"silent\" } might not be used.\n",
      "\n",
      "  This may not be accurate due to some parameters are only used in language bindings but\n",
      "  passed down to XGBoost core.  Or some parameters are not used but slip through this\n",
      "  verification. Please open an issue if you find above cases.\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import xgboost as xgb\n",
    "\n",
    "# Create DMatrix on train data\n",
    "dtrain = xgb.DMatrix(data=train[['store', 'item']],\n",
    "                     label=train['sales'])\n",
    "\n",
    "# Define xgboost parameters\n",
    "params = {'objective': 'reg:linear',\n",
    "          'max_depth': 2,\n",
    "          'silent': 1}\n",
    "\n",
    "# Train xgboost model\n",
    "xg_depth_2 = xgb.train(params=params, dtrain=dtrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22:10:16] WARNING: C:/Users/Administrator/workspace/xgboost-win64_release_1.4.0/src/objective/regression_obj.cu:171: reg:linear is now deprecated in favor of reg:squarederror.\n",
      "[22:10:16] WARNING: C:/Users/Administrator/workspace/xgboost-win64_release_1.4.0/src/learner.cc:573: \n",
      "Parameters: { \"silent\" } might not be used.\n",
      "\n",
      "  This may not be accurate due to some parameters are only used in language bindings but\n",
      "  passed down to XGBoost core.  Or some parameters are not used but slip through this\n",
      "  verification. Please open an issue if you find above cases.\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Define xgboost parameters\n",
    "params2 = {'objective': 'reg:linear',\n",
    "          'max_depth': 8,\n",
    "          'silent': 1}\n",
    "\n",
    "# Train xgboost model\n",
    "xg_depth_8 = xgb.train(params=params2, dtrain=dtrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22:10:16] WARNING: C:/Users/Administrator/workspace/xgboost-win64_release_1.4.0/src/objective/regression_obj.cu:171: reg:linear is now deprecated in favor of reg:squarederror.\n",
      "[22:10:16] WARNING: C:/Users/Administrator/workspace/xgboost-win64_release_1.4.0/src/learner.cc:573: \n",
      "Parameters: { \"silent\" } might not be used.\n",
      "\n",
      "  This may not be accurate due to some parameters are only used in language bindings but\n",
      "  passed down to XGBoost core.  Or some parameters are not used but slip through this\n",
      "  verification. Please open an issue if you find above cases.\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Define xgboost parameters\n",
    "params3 = {'objective': 'reg:linear',\n",
    "          'max_depth': 15,\n",
    "          'silent': 1}\n",
    "\n",
    "# Train xgboost model\n",
    "xg_depth_15= xgb.train(params=params3, dtrain=dtrain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explore overfitting XGBoost\n",
    "\n",
    "Having trained 3 XGBoost models with different maximum depths, you will now evaluate their quality. For this purpose, you will measure the quality of each model on both the train data and the test data. As you know by now, the train data is the data models have been trained on. The test data is the next month sales data that models have never seen before.\n",
    "\n",
    "The goal of this exercise is to determine whether any of the models trained is overfitting. To measure the quality of the models you will use Mean Squared Error (MSE). It's available in sklearn.metrics as mean_squared_error() function that takes two arguments: true values and predicted values.\n",
    "\n",
    "train and test DataFrames together with 3 models trained (xg_depth_2, xg_depth_8, xg_depth_15) are available in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE Train: 331.064. MSE Test: 249.691\n",
      "MSE Train: 112.057. MSE Test: 30.699\n",
      "MSE Train: 84.952. MSE Test: 3.568\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "dtrain = xgb.DMatrix(data=train[['store', 'item']])\n",
    "dtest = xgb.DMatrix(data=test[['store', 'item']])\n",
    "# For each of 3 trained models\n",
    "for model in [xg_depth_2, xg_depth_8, xg_depth_15]:\n",
    "    # Make predictions\n",
    "    train_pred = model.predict(dtrain)     \n",
    "    test_pred = model.predict(dtest)          \n",
    "    \n",
    "    # Calculate metrics\n",
    "    mse_train = mean_squared_error(train['sales'], train_pred)                  \n",
    "    mse_test = mean_squared_error(test['sales'], test_pred)\n",
    "    print('MSE Train: {:.3f}. MSE Test: {:.3f}'.format(mse_train, mse_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, you see that the third model with depth 15 is already overfitting. It has considerably lower train error compared to the second model, however test error is higher. Be aware of overfitting and move on to the next chapter to know how to beat it!\n",
    "# Understand the problem\n",
    "1. Understand the problem\n",
    "\n",
    "In the previous chapter, we got acquainted with what Machine Learning competition actually looks like, and had an overview of the general competition process. Now it's time to start solving the problems!\n",
    "2. Solution workflow\n",
    "\n",
    "Before proceeding, let's take a look at the broad scheme that we'll be using throughout the subsequent chapters. Let's call it a 'solution workflow'. Typically it consists of four major stages. First, we start by understanding the problem and the competition metric.\n",
    "3. Solution workflow\n",
    "\n",
    "Then we need to make some EDA (exploratory data analysis) in order to see and understand the data we're working with.\n",
    "4. Solution workflow\n",
    "\n",
    "The next very important step is to establish the local validation strategy. We already know that its goal is to prevent overfitting.\n",
    "5. Solution workflow\n",
    "\n",
    "Finally, the longest part of the competition is Modeling, which includes continuous improvements of the solution. In this chapter, we will talk about the first three blocks. The third and fourth chapters are entirely devoted to Modeling.\n",
    "6. Understand the problem\n",
    "\n",
    "To understand the problem we need to perform the following steps. Determine the data type we will be dealing with. Is it the usual tabular data?\n",
    "7. Understand the problem\n",
    "\n",
    "Or maybe we're given time series data.\n",
    "8. Understand the problem\n",
    "\n",
    "Or it's unstructured data like images.\n",
    "9. Understand the problem\n",
    "\n",
    "Or text, and so on. It could be even a mix of multiple data types. In this course, we mostly concentrate on the tabular data and time series. No worries, the general solution workflow is the same for any data type. The next step is to determine the problem type. We've talked about it a little in the previous chapter. Here we should select between classification, regression, ranking and so on. Lastly, we should get familiar with the metric being optimized. As we already know, every competition has a single metric. It is used by Kaggle to evaluate the submissions and to determine the best performing solution.\n",
    "10. Metric definition\n",
    "\n",
    "Generally, the majority of the metrics can be found in the sklearn.metrics library. However, there are some special competition metrics that are not available in scikit-learn. In such cases, we have to create metrics manually. Suppose we're solving the competition problem with Root Mean Squared Logarithmic Error as an evaluation metric. This metric is not implemented in scikit-learn. Its formula is presented on the slide. N is the number of observations in the test set, y is the actual value, y hat is the predicted value. So, it is a usual Root Mean Squared Error in a logarithmic scale. In this situation, we have to define a custom function that takes as input the true and predicted values, and outputs the metric value. Firstly, we compute squares under the sum using numpy log and power methods. Finally, we get the square root of the mean over all the observations, and return the result. \n",
    "# Define a competition metric\n",
    "\n",
    "Competition metric is used by Kaggle to evaluate your submissions. Moreover, you also need to measure the performance of different models on a local validation set.\n",
    "\n",
    "For now, your goal is to manually develop a couple of competition metrics in case if they are not available in sklearn.metrics.\n",
    "\n",
    "In particular, you will define:\n",
    "\n",
    "    Mean Squared Error (MSE) for the regression problem:\n",
    "\n",
    "Logarithmic Loss (LogLoss) for the binary classification problem:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sklearn MSE: 84.95210. \n",
      "Your MSE: 84.95187. \n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Import MSE from sklearn\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "# Define your own MSE function\n",
    "def own_mse(y_true, y_pred):\n",
    "  \t# Raise differences to the power of 2\n",
    "    squares = np.power(y_true - y_pred, 2)\n",
    "    # Find mean over all observations\n",
    "    err = np.mean(squares)\n",
    "    return err\n",
    "y_regression_pred=  model.predict(dtrain)\n",
    "y_regression_true= train.sales\n",
    "print('Sklearn MSE: {:.5f}. '.format(mean_squared_error(y_regression_true, y_regression_pred)))\n",
    "print('Your MSE: {:.5f}. '.format(own_mse(y_regression_true, y_regression_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y_classification_true' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-28-432c1de41a74>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     12\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[1;33m-\u001b[0m\u001b[0merr\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Sklearn LogLoss: {:.5f}'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlog_loss\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_classification_true\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_classification_pred\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     15\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Your LogLoss: {:.5f}'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mown_logloss\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_classification_true\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_classification_pred\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'y_classification_true' is not defined"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Import log_loss from sklearn\n",
    "from sklearn.metrics import log_loss\n",
    "\n",
    "# Define your own LogLoss function\n",
    "def own_logloss(y_true, prob_pred):\n",
    "  \t# Find loss for each observation\n",
    "    terms = y_true * np.log(prob_pred) + (1 - y_true) * np.log(1 - prob_pred)\n",
    "    # Find mean over all observations\n",
    "    err = np.mean(terms) \n",
    "    return -err\n",
    "\n",
    "print('Sklearn LogLoss: {:.5f}'.format(log_loss(y_classification_true, y_classification_pred)))\n",
    "print('Your LogLoss: {:.5f}'.format(own_logloss(y_classification_true, y_classification_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! You see that your functions work the same way that built-in sklearn metrics. Knowing the problem type and evaluation metric, it's time to start Data Analysis. Let's move on to the next lesson on EDA!\n",
    "# EDA\n",
    "1. Initial EDA\n",
    "\n",
    "Now we know how to figure out what problem we're addressing, and how to use the appropriate metric. The next step is to look at the data and find interesting patterns in it using Exploratory Data Analysis (EDA for short).\n",
    "2. Goals of EDA\n",
    "\n",
    "EDA has multiple goals. To start with, we could get the size of the train and test data. It will give us an idea of how much resources we need for the competition and what models we could use. Then we could investigate the properties of the target variable. For example, there could be a high class imbalance in the classification problem, or a skewed distribution in the regression problem. Similarly, we could look at the properties of the features. Finding some peculiarities and dependencies between features and target variable is always useful. Also, EDA is a good place to start in order to generate some ideas and future hypotheses on feature engineering.\n",
    "3. Two sigma connect: rental listing inquiries\n",
    "\n",
    "In this video we'll work with another Kaggle competition. It's called \"Two sigma connect: rental listing inquiries\". In this Kaggle competition, we need to predict how popular an apartment rental listing is based on the listing content. The target variable, 'interest_level', is defined by the number of inquiries a listing obtains. Interest level is split into 3 groups: high, medium and low. So, we have a classification problem with 3 classes. And the metric is a multi-class logarithmic loss.\n",
    "4. EDA. Part I\n",
    "\n",
    "Generally, the first part of the EDA is to look at some basic statistics regarding our data. So, let's start with reading train and test data and finding their shape. We see that train dataset has about 50 thousand observations and 11 columns. The test has about 75 thousand observations and all the columns except for the target variable.\n",
    "5. EDA. Part I\n",
    "\n",
    "Then let's look at the columns. We have the id of the observation, the number of bathrooms and bedrooms in the apartments, the exact coordinates of the apartments, the manager responsible for this listing, the renting price. And finally the target variable: 'interest_level'. Then, for example, we could obtain the distribution of 'interest_level' using pandas' value_counts() method. The majority of the listings have low interest, while only about four thousand observations have high interest. It means that we have some class imbalance. However, it's not so crucial to apply any class balancing methods.\n",
    "6. EDA. Part I\n",
    "\n",
    "Another useful approach to take a first glimpse at the data is pandas' describe() method. It shows the basic statistics of all the numeric columns in the DataFrame. Let's apply it to our train data. We see the minimum and maximum values, together with quartiles and mean values, as well as the count and standard deviation.\n",
    "7. EDA. Part II\n",
    "\n",
    "The next part of the EDA is to actually draw some plots and find interesting dependencies. We will use the matplotlib library. Let's import pyplot from matplotlib as plt and use ggplot style. As an example, let's compare the median price of the apartments across different interest levels. For this purpose, we use pandas' group_by() method and get the median. Note that we specified 'as_index' parameter to False in order not to turn 'interest_level' into the index.\n",
    "8. EDA. Part II\n",
    "\n",
    "We then create a figure and use the bar() method to plot 'interest_level' versus median price. Also, set titles for the axis and the plot itself. Finally, calling the show() method to see a plot.\n",
    "9. EDA. Part II\n",
    "\n",
    "As we see, medium and high interest listings have lower prices. It means that people are searching for cheaper apartments. A potentially useful new feature would be the price per bedroom. If an apartment has a price per bedroom lower than market average, then the listing could obtain higher interest. \n",
    "\n",
    "# EDA statistics\n",
    "\n",
    "As mentioned in the slides, you'll work with New York City taxi fare prediction data. You'll start with finding some basic statistics about the data. Then you'll move forward to plot some dependencies and generate hypotheses on them.\n",
    "\n",
    "The train and test DataFrames are already available in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train shape: (20000, 8)\n",
      "Test shape: (9914, 7)\n",
      "   id  fare_amount          pickup_datetime  pickup_longitude  \\\n",
      "0   0          4.5  2009-06-15 17:26:21 UTC        -73.844311   \n",
      "1   1         16.9  2010-01-05 16:52:16 UTC        -74.016048   \n",
      "2   2          5.7  2011-08-18 00:35:00 UTC        -73.982738   \n",
      "3   3          7.7  2012-04-21 04:30:42 UTC        -73.987130   \n",
      "4   4          5.3  2010-03-09 07:51:00 UTC        -73.968095   \n",
      "\n",
      "   pickup_latitude  dropoff_longitude  dropoff_latitude  passenger_count  \n",
      "0        40.721319         -73.841610         40.712278                1  \n",
      "1        40.711303         -73.979268         40.782004                1  \n",
      "2        40.761270         -73.991242         40.750562                2  \n",
      "3        40.733143         -73.991567         40.758092                1  \n",
      "4        40.768008         -73.956655         40.783762                1  \n"
     ]
    }
   ],
   "source": [
    "# Read train data\n",
    "train = pd.read_csv('C:/Users/rzouga/Desktop/ALLINHERE/ALLINHERE/CRIPSDM/taxi_train_chapter_4.csv')\n",
    "# Read train data\n",
    "test = pd.read_csv('C:/Users/rzouga/Desktop/ALLINHERE/ALLINHERE/CRIPSDM/taxi_test_chapter_4.csv')\n",
    "\n",
    "#\n",
    "# Shapes of train and test data\n",
    "print('Train shape:', train.shape)\n",
    "print('Test shape:', test.shape)\n",
    "\n",
    "# Train head()\n",
    "print(train.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train shape: (20000, 8)\n",
      "Test shape: (9914, 7)\n",
      "   id  fare_amount          pickup_datetime  pickup_longitude  \\\n",
      "0   0          4.5  2009-06-15 17:26:21 UTC        -73.844311   \n",
      "1   1         16.9  2010-01-05 16:52:16 UTC        -74.016048   \n",
      "2   2          5.7  2011-08-18 00:35:00 UTC        -73.982738   \n",
      "3   3          7.7  2012-04-21 04:30:42 UTC        -73.987130   \n",
      "4   4          5.3  2010-03-09 07:51:00 UTC        -73.968095   \n",
      "\n",
      "   pickup_latitude  dropoff_longitude  dropoff_latitude  passenger_count  \n",
      "0        40.721319         -73.841610         40.712278                1  \n",
      "1        40.711303         -73.979268         40.782004                1  \n",
      "2        40.761270         -73.991242         40.750562                2  \n",
      "3        40.733143         -73.991567         40.758092                1  \n",
      "4        40.768008         -73.956655         40.783762                1  \n",
      "count    20000.000000\n",
      "mean        11.303321\n",
      "std          9.541637\n",
      "min         -3.000000\n",
      "25%          6.000000\n",
      "50%          8.500000\n",
      "75%         12.500000\n",
      "max        180.000000\n",
      "Name: fare_amount, dtype: float64\n",
      "1    13999\n",
      "2     2912\n",
      "5     1327\n",
      "3      860\n",
      "4      420\n",
      "6      407\n",
      "0       75\n",
      "Name: passenger_count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Shapes of train and test data\n",
    "print('Train shape:', train.shape)\n",
    "print('Test shape:', test.shape)\n",
    "\n",
    "# Train head()\n",
    "print(train.head())\n",
    "\n",
    "# Describe the target variable\n",
    "print(train.fare_amount.describe())\n",
    "\n",
    "# Train distribution of passengers within rides\n",
    "print(train.passenger_count.value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All right! You just obtained a couple of descriptive statistics about the data. You can look at them to understand the data structure. However, they are not informative enough to get ideas for the future solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the ride distance\n",
    "train['distance_km'] = haversine_distance(train)\n",
    "\n",
    "# Draw a scatterplot\n",
    "plt.scatter(x=train['fare_amount'], y=train['distance_km'], alpha=0.5)\n",
    "plt.xlabel('Fare amount')\n",
    "plt.ylabel('Distance, km')\n",
    "plt.title('Fare amount based on the distance')\n",
    "\n",
    "# Limit on the distance\n",
    "plt.ylim(0, 50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice plot! It's obvious now that there is a clear dependency between ride distance and fare amount. So, ride distance is, probably, a good feature. Let's find some others!\n",
    "# EDA plots II\n",
    "\n",
    "Another idea that comes to mind is that the price of a ride could change during the day.\n",
    "\n",
    "Your goal is to plot the median fare amount for each hour of the day as a simple line plot. The hour feature is calculated for you. Don't worry if you do not know how to work with the date features. We will explore them in the chapter on Feature Engineering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create hour feature\n",
    "import matplotlib.pyplot as plt \n",
    "train['pickup_datetime'] = pd.to_datetime(train.pickup_datetime)\n",
    "train['hour'] = train.pickup_datetime.dt.hour\n",
    "\n",
    "# Find median fare_amount for each hour\n",
    "hour_price = train.groupby('hour', as_index=False)['fare_amount'].median()\n",
    "\n",
    "# Plot the line plot\n",
    "plt.plot(hour_price['hour'], hour_price['fare_amount'], marker='o')\n",
    "plt.xlabel('Hour of the day')\n",
    "plt.ylabel('Median fare amount')\n",
    "plt.title('Fare amount based on day time')\n",
    "plt.xticks(range(24))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Traget encoding :\n",
    "https://maxhalford.github.io/blog/target-encoding/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c 5\n",
      "a 2\n",
      "  3\n",
      "b 4\n",
      "f 5\n"
     ]
    }
   ],
   "source": [
    "check_string = \"cccccaa bbbb f,fkfff \"\n",
    "\n",
    "count = {}\n",
    "for s in check_string:\n",
    "    if s in count:\n",
    "        count[s] += 1\n",
    "    else:\n",
    "        count[s] = 1\n",
    "\n",
    "for key in count:\n",
    "    if count[key] > 1:\n",
    "        print( key, count[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({0: 4, 5: 3, 2: 1, 4: 2, 3: 1, 1: 1, 9: 2})"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "arr = np.array([0, 5, 5, 0, 2, 4, 3, 0, 0, 5, 4, 1, 9, 9])\n",
    "Counter(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4}"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(results.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 2\n",
      "b 4\n",
      "c 5\n",
      "f 5\n"
     ]
    }
   ],
   "source": [
    "# Use urllib.request to send network request if needed.\n",
    "\n",
    "import fileinput\n",
    "\n",
    "inputData = ''\n",
    "\n",
    "for line in fileinput.input():\n",
    "    inputData += line\n",
    "\n",
    "\n",
    "def codeHere(inputData):\n",
    "    # Use the function to return the solution.\n",
    "    import re \n",
    "    import collections\n",
    "    # get only alphanum value preprocess our string  : lower case + eliminate punctuation\n",
    "    string_clean = re.sub(r\"[^a-zA-Z0-9]+\",'', inputData.lower().strip())\n",
    "    results = collections.Counter(string_clean)\n",
    "    finalresult = sorted(results.items())\n",
    "    l1={1}\n",
    "    dic = collections.OrderedDict()\n",
    "    if set(results.values()) == l1:\n",
    "        print('none')\n",
    "    else:\n",
    "        #print(finalresult)\n",
    "        for key, value in finalresult:\n",
    "            if value >= 2:\n",
    "                dic[key]=value\n",
    "    return (\"\\n\".join(f'{k} {v}' for k, v in dic.items()))\n",
    "\n",
    "\n",
    "print(codeHere(inputData))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 3, 'b': 2, 'c': 3}\n",
      "dict_keys(['a', 'b', 'c'])\n",
      "keylist ['a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "dic = {'a':3, 'b':2, 'c':3}\n",
    "print(dic)\n",
    "\n",
    "dictkeys = dic.keys() # or values/items\n",
    "print(dictkeys)\n",
    "\n",
    "keylist = []\n",
    "keylist.extend(iter(dictkeys)) # my big revelation\n",
    "print('keylist', keylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: '-f'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-80-a4ddc5e59dee>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0minputData\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m''\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mfileinput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m     \u001b[0minputData\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mline\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\fileinput.py\u001b[0m in \u001b[0;36m__next__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    250\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__next__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    251\u001b[0m         \u001b[1;32mwhile\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 252\u001b[1;33m             \u001b[0mline\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_readline\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    253\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mline\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    254\u001b[0m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_filelineno\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\fileinput.py\u001b[0m in \u001b[0;36m_readline\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    362\u001b[0m                     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_file\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_openhook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_filename\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    363\u001b[0m                 \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 364\u001b[1;33m                     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_file\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_filename\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    365\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_readline\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_file\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreadline\u001b[0m  \u001b[1;31m# hide FileInput._readline\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    366\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_readline\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '-f'"
     ]
    }
   ],
   "source": [
    "# Use urllib.request to send network request if needed.\n",
    "\n",
    "import fileinput\n",
    "\n",
    "inputData = ''\n",
    "\n",
    "for line in fileinput.input():\n",
    "    inputData += line\n",
    "\n",
    "\n",
    "def codeHere(inputData):\n",
    "    # Use the function to return the solution.\n",
    "    import re \n",
    "    import collections\n",
    "    # get only alphanum value preprocess our string  : lower case + eliminate punctuation\n",
    "    string_clean = re.sub(r\"[^a-zA-Z0-9]+\",'', inputData.lower().strip())\n",
    "    results = collections.Counter(string_clean)\n",
    "    finalresult = sorted(results.items())\n",
    "    for key, value in finalresult:\n",
    "        if value >= 2:\n",
    "            print(key, value)\n",
    "\n",
    "\n",
    "print(codeHere(inputData))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-49-070908258d88>, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-49-070908258d88>\"\u001b[1;36m, line \u001b[1;32m6\u001b[0m\n\u001b[1;33m    jupyter nbconvert --to script [YOUR_NOTEBOOK].ipynb\u001b[0m\n\u001b[1;37m                    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    ">>> import pandas as pd\n",
    ">>> import numpy as np\n",
    ">>> np.random.RandomState(100)\n",
    ">>> num_series = pd.Series(np.random.randint(1, 5, [15]))\n",
    "num_series[~num_series.isin(num_series.value_counts().index[:1])] ='replaced'\n",
    ">>> jupyter nbconvert --to script [YOUR_NOTEBOOK].ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This application is used to convert notebook files (*.ipynb) to various other"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[NbConvertApp] WARNING | pattern '[YOUR_NOTEBOOK].ipynb' matched no files\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "formats.\n",
      "\n",
      "WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.\n",
      "\n",
      "Options\n",
      "\n",
      "-------\n",
      "\n",
      "\n",
      "\n",
      "Arguments that take values are actually convenience aliases to full\n",
      "Configurables, whose aliases are listed on the help line. For more information\n",
      "on full configurables, see '--help-all'.\n",
      "\n",
      "\n",
      "--debug\n",
      "\n",
      "    set log level to logging.DEBUG (maximize logging output)\n",
      "\n",
      "--generate-config\n",
      "\n",
      "    generate default config file\n",
      "\n",
      "-y\n",
      "\n",
      "    Answer yes to any questions instead of prompting.\n",
      "\n",
      "--execute\n",
      "\n",
      "    Execute the notebook prior to export.\n",
      "\n",
      "--allow-errors\n",
      "\n",
      "    Continue notebook execution even if one of the cells throws an error and include the error message in the cell output (the default behaviour is to abort conversion). This flag is only relevant if '--execute' was specified, too.\n",
      "\n",
      "--stdin\n",
      "\n",
      "    read a single notebook file from stdin. Write the resulting notebook with default basename 'notebook.*'\n",
      "\n",
      "--stdout\n",
      "\n",
      "    Write notebook output to stdout instead of files.\n",
      "\n",
      "--inplace\n",
      "\n",
      "    Run nbconvert in place, overwriting the existing notebook (only \n",
      "    relevant when converting to notebook format)\n",
      "\n",
      "--clear-output\n",
      "\n",
      "    Clear output of current file and save in place, \n",
      "    overwriting the existing notebook.\n",
      "\n",
      "--no-prompt\n",
      "\n",
      "    Exclude input and output prompts from converted document.\n",
      "\n",
      "--no-input\n",
      "\n",
      "    Exclude input cells and output prompts from converted document. \n",
      "    This mode is ideal for generating code-free reports.\n",
      "--log-level=<Enum> (Application.log_level)\n",
      "\n",
      "    Default: 30\n",
      "\n",
      "    Choices: (0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL')\n",
      "\n",
      "    Set the log level by value or name.\n",
      "\n",
      "--config=<Unicode> (JupyterApp.config_file)\n",
      "\n",
      "    Default: ''\n",
      "\n",
      "    Full path of a config file.\n",
      "\n",
      "--to=<Unicode> (NbConvertApp.export_format)\n",
      "\n",
      "    Default: 'html'\n",
      "\n",
      "    The export format to be used, either one of the built-in formats\n",
      "\n",
      "    ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf',\n",
      "\n",
      "    'python', 'rst', 'script', 'slides'] or a dotted object name that represents\n",
      "\n",
      "    the import path for an `Exporter` class\n",
      "\n",
      "--template=<Unicode> (TemplateExporter.template_file)\n",
      "\n",
      "    Default: ''\n",
      "\n",
      "    Name of the template file to use\n",
      "\n",
      "--writer=<DottedObjectName> (NbConvertApp.writer_class)\n",
      "\n",
      "    Default: 'FilesWriter'\n",
      "\n",
      "    Writer class used to write the  results of the conversion\n",
      "\n",
      "--post=<DottedOrNone> (NbConvertApp.postprocessor_class)\n",
      "\n",
      "    Default: ''\n",
      "\n",
      "    PostProcessor class used to write the results of the conversion\n",
      "\n",
      "--output=<Unicode> (NbConvertApp.output_base)\n",
      "\n",
      "    Default: ''\n",
      "\n",
      "    overwrite base name use for output files. can only be used when converting\n",
      "\n",
      "    one notebook at a time.\n",
      "\n",
      "--output-dir=<Unicode> (FilesWriter.build_directory)\n",
      "\n",
      "    Default: ''\n",
      "\n",
      "    Directory to write output(s) to. Defaults to output to the directory of each\n",
      "\n",
      "    notebook. To recover previous default behaviour (outputting to the current\n",
      "\n",
      "    working directory) use . as the flag value.\n",
      "\n",
      "--reveal-prefix=<Unicode> (SlidesExporter.reveal_url_prefix)\n",
      "\n",
      "    Default: ''\n",
      "\n",
      "    The URL prefix for reveal.js (version 3.x). This defaults to the reveal CDN,\n",
      "\n",
      "    but can be any url pointing to a copy  of reveal.js.\n",
      "\n",
      "    For speaker notes to work, this must be a relative path to a local  copy of\n",
      "\n",
      "    reveal.js: e.g., \"reveal.js\".\n",
      "\n",
      "    If a relative path is given, it must be a subdirectory of the current\n",
      "\n",
      "    directory (from which the server is run).\n",
      "\n",
      "    See the usage documentation"
     ]
    }
   ],
   "source": [
    "! jupyter nbconvert --to script [YOUR_NOTEBOOK].ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "    (https://nbconvert.readthedocs.io/en/latest/usage.html#reveal-js-html-\n",
      "\n",
      "    slideshow) for more details.\n",
      "\n",
      "--nbformat=<Enum> (NotebookExporter.nbformat_version)\n",
      "\n",
      "    Default: 4\n",
      "\n",
      "    Choices: [1, 2, 3, 4]\n",
      "\n",
      "    The nbformat version to write. Use this to downgrade notebooks.\n",
      "\n",
      "To see all available configurables, use `--help-all`\n",
      "\n",
      "Examples\n",
      "--------\n",
      "\n",
      "    The simplest way to use nbconvert is\n",
      "    \n",
      "    > jupyter nbconvert mynotebook.ipynb\n",
      "    \n",
      "    which will convert mynotebook.ipynb to the default format (probably HTML).\n",
      "    \n",
      "    You can specify the export format with `--to`.\n",
      "    Options include ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'rst', 'script', 'slides'].\n",
      "    \n",
      "    > jupyter nbconvert --to latex mynotebook.ipynb\n",
      "    \n",
      "    Both HTML and LaTeX support multiple output templates. LaTeX includes\n",
      "    'base', 'article' and 'report'.  HTML includes 'basic' and 'full'. You\n",
      "    can specify the flavor of the format used.\n",
      "    \n",
      "    > jupyter nbconvert --to html --template basic mynotebook.ipynb\n",
      "    \n",
      "    You can also pipe the output to stdout, rather than a file\n",
      "    \n",
      "    > jupyter nbconvert mynotebook.ipynb --stdout\n",
      "    \n",
      "    PDF is generated via latex\n",
      "    \n",
      "    > jupyter nbconvert mynotebook.ipynb --to pdf\n",
      "    \n",
      "    You can get (and serve) a Reveal.js-powered slideshow\n",
      "    \n",
      "    > jupyter nbconvert myslides.ipynb --to slides --post serve\n",
      "    \n",
      "    Multiple notebooks can be given at the command line in a couple of \n",
      "    different ways:\n",
      "    \n",
      "    > jupyter nbconvert notebook*.ipynb\n",
      "    > jupyter nbconvert notebook1.ipynb notebook2.ipynb\n",
      "    \n",
      "    or you can specify the notebooks list in a config file, containing::\n",
      "    \n",
      "        c.NbConvertApp.notebooks = [\"my_notebook.ipynb\"]\n",
      "    \n",
      "    > jupyter nbconvert --config mycfg.py\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style>.container { width:100% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ">>> from IPython.core.display import display, HTML\n",
    ">>> display(HTML(\"<style>.container { width:100% !important; }</style>\"))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}