DataCamp_Genral_CRISP_DM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# CRISP-DM Methodology\n",
    "\n",
    "In this section we overview our selected method for engineering our solution. CRISP-DM stands for Cross-Industry Standard Process for Data Mining. It is an open standard guide that describes common approaches that are used by data mining experts. CRISP-DM includes descriptions of the typical phases of a project, including tasks details and provides an overview of the data mining lifecycle. The lifecycle model consists of six phases with arrows indicating the most important and frequent dependencies between phases. The sequence of the phases is not strict. In fact, most projects move back and forth between phases as necessary. It starts with business understanding, and then moves to data understanding, data preparation, modelling, evaluation, and deployment. The CRISP-DM model is flexible and can be customized easily.\n",
    "\n",
    "# Buissness Understanding\n",
    "\n",
    "    Tasks:\n",
    "    1.Determine business objectives\n",
    "    2.Assess situation\n",
    "    3.Determine data mining goals\n",
    "    4.Produce project plan\n",
    "\n",
    "# Data Understanding\n",
    "\n",
    "    Tasks\n",
    "    1.Collect data\n",
    "    2.Describe data\n",
    "    3.Explore data    \n",
    "\n",
    "# Data Preparation\n",
    "\n",
    "    Tasks\n",
    "    1.Data selection\n",
    "    2.Data preprocessing\n",
    "    3.Feature engineering\n",
    "    4.Dimensionality reduction\n",
    "\n",
    "    Steps:\n",
    "    Data cleaning\n",
    "\n",
    "    Data integration\n",
    "\n",
    "    Data sampling\n",
    "\n",
    "    Data dimensionality reduction\n",
    "\n",
    "    Data formatting\n",
    "\n",
    "    Data transformation\n",
    "\n",
    "    Scaling\n",
    "\n",
    "    Aggregation\n",
    "\n",
    "    Decomposition\n",
    "\n",
    "# Data Modeling :\n",
    "\n",
    "Modeling is the part of the Cross-Industry Standard Process for Data Mining (CRISP-DM) process model that i like best. Our data is already in good shape, and now we can search for useful patterns in our data.\n",
    "\n",
    "    Tasks\n",
    "    1. Select modeling technique Select technique\n",
    "\n",
    "    2. Generate test design\n",
    "\n",
    "    3. Build model\n",
    "\n",
    "    4. Assess model\n",
    "\n",
    "# Data Evaluation :\n",
    "https://www.kdnuggets.com/2018/01/managing-machine-learning-workflows-scikit-learn-pipelines-part-3.html\n",
    "\n",
    "    Tasks\n",
    "    1.Evaluate Result\n",
    "\n",
    "    2.Review Process\n",
    "\n",
    "    3.Determine next steps\n",
    "\n",
    "# Deployment :\n",
    "\n",
    "    Tasks\n",
    "    1.Produce Final presentation\n",
    "    2.Produce Final report \n",
    "    3.Conduct Final review \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Understanding¶\n",
    "    Tasks\n",
    "    1.Collect data\n",
    "    2.Describe data\n",
    "    3.Explore data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inspecting your data\n",
    "https://strftime.org/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DataFrame data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "volunteer.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Statistical exploratory data analysis\n",
    "The median is a very useful statistic, especially in the presence of outliers, when it is more robust than the mean.\n",
    "## Median vs mean\n",
    "\n",
    "In many data sets, there can be large differences in the mean and median value due to the presence of outliers. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "df.mpg.median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the minimum value of the Engineering column\n",
    "print(df.Engineering.min())\n",
    "\n",
    "# Print the maximum value of the Engineering column\n",
    "print(df.Engineering.max())\n",
    "\n",
    "# Construct the mean percentage per year: mean\n",
    "mean = df.mean(axis='columns')\n",
    "# Plot the average percentage per year\n",
    "plt.plot(mean)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.corr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print summary statistics of the fare column with .describe()\n",
    "print(df['fare'].describe())\n",
    "\n",
    "# Generate a box plot of the fare column\n",
    "df['fare'].plot(kind='box')\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the number of countries reported in 2015\n",
    "print(df_t1.count())\n",
    "\n",
    "# Print the 5th and 95th percentiles\n",
    "print(df_t1.quantile([0.05,0.95]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Standard deviation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the mean of the January and March data\n",
    "print(january.mean(), march.mean())\n",
    "\n",
    "# Print the standard deviation of the January and March data\n",
    "print(january.std(), march.std())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visual exploratory data analysis\n",
    "## pandas line plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot all columns (default)\n",
    "df.plot()\n",
    "plt.show()\n",
    "\n",
    "# Plot all columns as subplots\n",
    "df.plot(subplots=True)\n",
    "plt.show()\n",
    "\n",
    "# Plot just the Dew Point data\n",
    "# column_list1 = ['Dew Point (deg F)']\n",
    "#df[column_list1].plot()\n",
    "#plt.show()\n",
    "\n",
    "# Plot the Dew Point and Temperature data, but not the Pressure data\n",
    "#column_list2 = ['Temperature (deg F)','Dew Point (deg F)']\n",
    "#df[column_list2].plot()\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of y-axis column names: y_columns\n",
    "y_columns = ['APPLE','IBM']\n",
    "\n",
    "# Generate a line plot\n",
    "df_t.plot(x='index', y=y_columns)\n",
    "\n",
    "# Add the title\n",
    "plt.title('Monthly stock prices')\n",
    "\n",
    "# Add the y-axis label\n",
    "plt.ylabel('Price ($US)')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## pandas scatter plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a scatter plot\n",
    "df.plot(kind='scatter', x='hp', y='mpg', s=sizes)\n",
    "\n",
    "# Add the title\n",
    "plt.title('Fuel efficiency vs Horse-power')\n",
    "\n",
    "# Add the x-axis label\n",
    "plt.xlabel('Horse-power')\n",
    "\n",
    "# Add the y-axis label\n",
    "plt.ylabel('Fuel efficiency (mpg)')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## pandas box plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a list of the column names to be plotted: cols\n",
    "cols = ['weight', 'mpg']\n",
    "\n",
    "# Generate the box plots\n",
    "df[cols].plot(kind='box', subplots=True)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## pandas hist, pdf and cdf\n",
    "Pandas relies on the .hist() method to not only generate histograms, but also plots of probability density functions (PDFs) and cumulative density functions (CDFs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This formats the plots such that they appear on separate rows\n",
    "fig, axes = plt.subplots(nrows=2, ncols=1)\n",
    "# Plot the PDF\n",
    "df.fraction.plot(ax=axes[0], kind='hist', normed=True, bins=30, range=(0,.3))\n",
    "plt.show()\n",
    "# Plot the CDF\n",
    "df.fraction.plot(ax=axes[1], kind='hist', normed=True, cumulative=True, bins=30, range=(0,.3))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_selection import RFE\n",
    "# Create the RFE with a LogisticRegression estimator and 3 features to select\n",
    "rfe = RFE(estimator=LogisticRegression(), n_features_to_select = 3, verbose=1)\n",
    "\n",
    "# Fits the eliminator to the data\n",
    "rfe.fit(X_train, y_train)\n",
    "\n",
    "# Print the features and their ranking (high = dropped early on)\n",
    "print(dict(zip(X.columns, rfe.ranking_)))\n",
    "\n",
    "# Print the features that are not eliminated\n",
    "print(X.columns[rfe.support_])\n",
    "\n",
    "# Calculates the test set accuracy\n",
    "acc = accuracy_score(y_test, rfe.predict(X_test))\n",
    "print(\"{0:.1%} accuracy on test set.\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the data type of each column\n",
    "print(so_survey_df.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set(style=\"darkgrid\")\n",
    "sns.barplot(country_counts.index, country_counts .values, alpha=0.9)\n",
    "plt.title('Frequency Distribution of countries')\n",
    "plt.ylabel('Number of Occurrences', fontsize=12)\n",
    "plt.xlabel('Country', fontsize=12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = so_survey_df['Country'].astype('category').cat.categories.tolist()\n",
    "counts = so_survey_df['Country'].value_counts()\n",
    "sizes = [counts[var_cat] for var_cat in labels]\n",
    "fig1, ax1 = plt.subplots()\n",
    "ax1.pie(sizes, labels=labels, autopct='%1.1f%%', shadow=True) #autopct is show the % on plot\n",
    "ax1.axis('equal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a series out of the Country column\n",
    "countries = so_survey_df['Country']\n",
    "\n",
    "# Get the counts of each category\n",
    "country_counts = countries.value_counts()\n",
    "\n",
    "# Create a mask for only categories that occur less than 10 times\n",
    "mask = countries.isin(country_counts[country_counts<10].index)\n",
    "\n",
    "# Print the top 5 rows in the mask series\n",
    "print(mask.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "country_counts[country_counts < 10].index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Label all other categories as Other\n",
    "countries[mask] = 'Other'\n",
    "\n",
    "# Print the updated category counts\n",
    "print(countries.value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "volunteer.category_desc.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.boxplot(x=\"target\", y=\"e\", data=df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "g= sns.countplot(x='category_desc', data=volunteer)\n",
    "\n",
    "plt.xticks(rotation=45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "xs= points[:,0]\n",
    "ys = points[:,1]\n",
    "plt.scatter(xs, ys)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    Import TSNE from sklearn.manifold.\n",
    "    Create a TSNE instance called model with learning_rate=200.\n",
    "    Apply the .fit_transform() method of model to samples. Assign the result to tsne_features.\n",
    "    Select the column 0 of tsne_features. Assign the result to xs.\n",
    "    Select the column 1 of tsne_features. Assign the result to ys.\n",
    "    Make a scatter plot of the t-SNE features xs and ys. To color the points by the grain variety, specify the additional keyword argument c=variety_numbers.\n",
    "\"\"\"\n",
    "# Import TSNE\n",
    "from sklearn.manifold import TSNE\n",
    "\n",
    "# Create a TSNE instance: model\n",
    "model = TSNE(learning_rate=200)\n",
    "\n",
    "# Apply fit_transform to samples: tsne_features\n",
    "tsne_features = model.fit_transform(points)\n",
    "\n",
    "# Select the 0th feature: xs\n",
    "xs = tsne_features[:,0]\n",
    "\n",
    "# Select the 1st feature: ys\n",
    "ys = tsne_features[:,1]\n",
    "\n",
    "# Scatter plot, coloring by variety_numbers\n",
    "plt.scatter(xs, ys, c=y)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"A t-SNE map of the stock market\n",
    "\n",
    "t-SNE provides great visualizations when the individual samples can be labeled. \n",
    "In this exercise, you'll apply t-SNE to the company stock price data.\n",
    "A scatter plot of the resulting t-SNE features, labeled by the company names, gives you a map of the stock market!\n",
    "The stock price movements for each company are available as the array normalized_movements (these have already been normalized for you).\n",
    "The list companies gives the name of each company. PyPlot (plt) has been imported for you.\"\"\"\n",
    "\n",
    "# Import TSNE\n",
    "from sklearn.manifold import TSNE\n",
    "\n",
    "# Create a TSNE instance: model\n",
    "model = TSNE(learning_rate=50)\n",
    "\n",
    "# Apply fit_transform to normalized_movements: tsne_features\n",
    "tsne_features = model.fit_transform(normalized_movements)\n",
    "\n",
    "# Select the 0th feature: xs\n",
    "xs = tsne_features[:,0]\n",
    "\n",
    "# Select the 1th feature: ys\n",
    "ys = tsne_features[:,1]\n",
    "\n",
    "# Scatter plot\n",
    "plt.scatter(xs, ys, alpha=0.5)\n",
    "\n",
    "# Annotate the points\n",
    "for x, y, company in zip(xs, ys, companies):\n",
    "    plt.annotate(company, (x, y), fontsize=5, alpha=0.75)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns \n",
    "warnings.filterwarnings(\"ignore\")\n",
    "sns.heatmap(df.corr(), square=True, cmap='RdYlGn')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns \n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "sns.pairplot(df, hue= 'Type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.distplot(df[\"Proline\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns \n",
    "plt.figure()\n",
    "sns.countplot(x='target', data=df, palette='RdBu')\n",
    "plt.xticks([0,1], ['sain', 'malade'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.figure()\n",
    "\n",
    "sns.countplot(x='education', hue='party', data=df, palette='RdBu')\n",
    "\n",
    "plt.xticks([0,1], ['No', 'Yes'])\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns \n",
    "warnings.filterwarnings(\"ignore\")\n",
    "sns.heatmap(df.corr(), square=True, cmap='RdYlGn')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Separating populations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df['origin'] == 'Asia'].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separate and summarize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=df.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/titanic.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the global mean and global standard deviation: global_mean, global_std\n",
    "global_mean = df.mean()\n",
    "global_std = df.std()\n",
    "\n",
    "# Filter the US population from the origin column: us\n",
    "us = df.loc[df['origin'] == 'US']\n",
    "\n",
    "# Compute the US mean and US standard deviation: us_mean, us_std\n",
    "us_mean = us.mean()\n",
    "us_std = us.std()\n",
    "\n",
    "# Print the differences\n",
    "print(us_mean - global_mean)\n",
    "print(us_std - global_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display the box plots on 3 separate rows and 1 column\n",
    "fig, axes = plt.subplots(nrows=3, ncols=1)\n",
    "\n",
    "# Generate a box plot of the fare prices for the First passenger class\n",
    "titanic.loc[titanic['pclass'] == 1].plot(ax=axes[0], y='fare', kind='box')\n",
    "\n",
    "# Generate a box plot of the fare prices for the Second passenger class\n",
    "titanic.loc[titanic['pclass'] == 2].plot(ax=axes[1], y='fare', kind='box')\n",
    "\n",
    "# Generate a box plot of the fare prices for the Third passenger class\n",
    "titanic.loc[titanic['pclass'] == 3].plot(ax=axes[2], y='fare', kind='box')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing time series\n",
    "\n",
    "## Reading and slicing times\n",
    "\n",
    "For this exercise, we have read in the same data file using three different approaches:\n",
    "\n",
    "    df1 = pd.read_csv(filename)\n",
    "\n",
    "    df2 = pd.read_csv(filename, parse_dates=['Date'])\n",
    "\n",
    "    df3 = pd.read_csv(filename, index_col='Date', parse_dates=True)\n",
    "\n",
    "    Use the .head() and .info() methods in the IPython Shell to inspect the DataFrames. Then, try to index each DataFrame with a datetime string. Which of the resulting DataFrames allows you to easily index and slice data by dates using, for example, df1.loc['2010-Aug-01']?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename= '/home/abderrazak/ALLINHERE/NLP/Datacamp/tips.csv'\n",
    "df1 = pd.read_csv(filename)\n",
    "\n",
    "df2 = pd.read_csv(filename, parse_dates=['Date'])\n",
    "\n",
    "df3 = pd.read_csv(filename, index_col='Date', parse_dates=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Df3 is the right choice**\n",
    "# Creating and using a DatetimeIndex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare a format string: time_format\n",
    "time_format='%Y-%m-%d %H:%M'\n",
    "# Convert date_list into a datetime object: my_datetimes\n",
    "my_datetimes = pd.to_datetime(date_list, format=time_format)  \n",
    "# Construct a pandas Series using temperature_list and my_datetimes: time_series\n",
    "time_series = pd.Series(temperature_list, index=my_datetimes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Partial string indexing and slicing\n",
    "\n",
    "Pandas time series support \"partial string\" indexing. What this means is that even when passed only a portion of the datetime, such as the date but not the time, pandas is remarkably good at doing what one would expect. Pandas datetime indexing also supports a wide variety of commonly used datetime string formats, even when mixed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the hour from 9pm to 10pm on '2010-10-11': ts1\n",
    "ts1 = ts0.loc['2010-10-11 21:00:00':'2010-10-11 22:00:00']\n",
    "\n",
    "# Extract '2010-07-04' from ts0: ts2\n",
    "ts2 = ts0.loc['2010-07-04']\n",
    "\n",
    "# Extract data from '2010-12-15' to '2010-12-31': ts3\n",
    "ts3 = ts0.loc['2010-12-15':'2010-12-31']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reindexing the Index\n",
    "\n",
    "Reindexing is useful in preparation for adding or otherwise combining two time series data sets. To reindex the data, we provide a new index and ask pandas to try and match the old data to the new index. If data is unavailable for one of the new index dates or times, you must tell pandas how to fill it in. Otherwise, pandas will fill with NaN by default.\n",
    "\n",
    "In this exercise, two time series data sets containing daily data have been pre-loaded for you, each indexed by dates. The first, ts1, includes weekends, but the second, ts2, does not. The goal is to combine the two data sets in a sensible way. Your job is to reindex the second data set so that it has weekends as well, and then add it to the first. When you are done, it would be informative to inspect your results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reindex without fill method: ts3\n",
    "ts3 = ts2.reindex(ts1.index)\n",
    "\n",
    "# Reindex with fill method, using forward fill: ts4\n",
    "ts4 = ts2.reindex(ts1.index, method='ffill')\n",
    "\n",
    "# Combine ts1 + ts2: sum12\n",
    "sum12 = ts1 + ts2\n",
    "\n",
    "# Combine ts1 + ts3: sum13\n",
    "sum13 = ts1 + ts3\n",
    "\n",
    "# Combine ts1 + ts4: sum14\n",
    "sum14 = ts1 + ts4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resampling time series data\n",
    "\n",
    "## Resampling and frequency\n",
    "\n",
    "Pandas provides methods for resampling time series data. When downsampling or upsampling, the syntax is similar, but the methods called are different. Both use the concept of 'method chaining' - df.method1().method2().method3() - to direct the output from one method call to the input of the next, and so on, as a sequence of operations, one feeding into the next.\n",
    "\n",
    "For example, if you have hourly data, and just need daily data, pandas will not guess how to throw out the 23 of 24 points. You must specify this in the method. One approach, for instance, could be to take the mean, as in df.resample('D').mean(). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Downsample to 6 hour data and aggregate by mean: df1\n",
    "df1 = df['Temperature'].resample('6h').mean()\n",
    "\n",
    "# Downsample to daily data and count the number of data points: df2\n",
    "df2 = df['Temperature'].resample('D').count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rolling mean and frequency\n",
    "\n",
    "In this exercise, some hourly weather data is pre-loaded for you. You will continue to practice resampling, this time using rolling means.\n",
    "\n",
    "Rolling means (or moving averages) are generally used to smooth out short-term fluctuations in time series data and highlight long-term trends. You can read more about them here.\n",
    "\n",
    "To use the .rolling() method, you must always use method chaining, first calling .rolling() and then chaining an aggregation method after it. For example, with a Series hourly_data, hourly_data.rolling(window=24).mean() would compute new values for each hourly point, based on a 24-hour window stretching out behind each point. The frequency of the output data is the same: it is still hourly. Such an operation is useful for smoothing time series data.\n",
    "\n",
    "Your job is to resample the data using the combination of .rolling() and .mean(). You will work with the same DataFrame df from the previous exercise.\n",
    "https://en.wikipedia.org/wiki/Moving_average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract data from 2010-Aug-01 to 2010-Aug-15: unsmoothed\n",
    "unsmoothed = df['Temperature']['2010-Aug-01':'2010-Aug-15']\n",
    "\n",
    "# Apply a rolling mean with a 24 hour window: smoothed\n",
    "smoothed = unsmoothed.rolling(window=24).mean()\n",
    "\n",
    "# Create a new DataFrame with columns smoothed and unsmoothed: august\n",
    "august = pd.DataFrame({'smoothed':smoothed, 'unsmoothed':unsmoothed})\n",
    "\n",
    "# Plot both smoothed and unsmoothed data using august.plot().\n",
    "august.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the August 2010 data: august\n",
    "august = df['Temperature']['2010-Aug']\n",
    "\n",
    "# Resample to daily data, aggregating by max: daily_highs\n",
    "daily_highs = august.resample('D').max()\n",
    "\n",
    "# Use a rolling 7-day window with method chaining to smooth the daily high temperatures in August\n",
    "daily_highs_smoothed = august.resample('D').max().rolling(window=7).mean()\n",
    "print(daily_highs_smoothed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulating time series data\n",
    "## Method chaining and filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strip extra whitespace from the column names: df.columns\n",
    "df.columns = df.columns.str.strip()\n",
    "\n",
    "# Extract data for which the destination airport is Dallas: dallas\n",
    "dallas = df['Destination Airport'].str.contains('DAL')\n",
    "\n",
    "# Compute the total number of Dallas departures each day: daily_departures\n",
    "daily_departures = dallas.resample('D').sum()\n",
    "\n",
    "# Generate the summary statistics for daily Dallas departures: stats\n",
    "stats = daily_departures.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Missing values and interpolation\n",
    "\n",
    "One common application of interpolation in data analysis is to fill in missing data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reset the index of ts2 to ts1, and then use linear interpolation to fill in the NaNs: ts2_interp\n",
    "ts2_interp = ts2.reindex(ts1.index).interpolate(how='linear')\n",
    "\n",
    "# Compute the absolute difference of ts1 and ts2_interp: differences \n",
    "differences = np.abs(ts1 - ts2_interp)\n",
    "\n",
    "# Generate and print summary statistics of the differences\n",
    "print(differences.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time zones and conversion\n",
    "\n",
    "Time zone handling with pandas typically assumes that you are handling the Index of the Series. In this exercise, you will learn how to handle timezones that are associated with datetimes in the column data, and not just the Index.\n",
    "\n",
    "You will work with the flight departure dataset again, and this time you will select Los Angeles ('LAX') as the destination airport.\n",
    "\n",
    "Here we will use a mask to ensure that we only compute on data we actually want. To learn more about Boolean masks, click here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a Boolean mask to filter for the 'LAX' departure flights: mask\n",
    "mask = df['Destination Airport'] == 'LAX'\n",
    "\n",
    "# Use the mask to subset the data: la\n",
    "la = df[mask]\n",
    "\n",
    "# Combine two columns of data to create a datetime series: times_tz_none \n",
    "times_tz_none = pd.to_datetime( la['Date (MM/DD/YYYY)'] + ' ' + la['Wheels-off Time'] )\n",
    "\n",
    "# Localize the time to US/Central: times_tz_central\n",
    "times_tz_central = times_tz_none.dt.tz_localize('US/Central')\n",
    "\n",
    "# Convert the datetimes from US/Central to US/Pacific\n",
    "times_tz_pacific = times_tz_central.dt.tz_convert('US/Pacific')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time series visualization\n",
    "## Plotting time series, datetime indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the raw data before setting the datetime index\n",
    "df.plot()\n",
    "plt.show()\n",
    "\n",
    "# Convert the 'Date' column into a collection of datetime objects: df.Date\n",
    "df.Date = pd.to_datetime(df.Date)\n",
    "\n",
    "# Set the index to be the converted 'Date' column\n",
    "df.set_index('Date', inplace=True)\n",
    "\n",
    "# Re-plot the DataFrame to see that the axis is now datetime aware!\n",
    "df.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the summer data\n",
    "df.Temperature['2010-Jun':'2010-Aug'].plot()\n",
    "plt.show()\n",
    "plt.clf()\n",
    "\n",
    "# Plot the one week data\n",
    "df.Temperature['2010-06-10':'2010-06-17'].plot()\n",
    "plt.show()\n",
    "plt.clf()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "from sklearn.feature_selection import mutual_info_regression\n",
    "\n",
    "def make_mi_scores(X, y, discrete_features):\n",
    "    mi_scores = mutual_info_regression(X, y, discrete_features=discrete_features)\n",
    "    mi_scores = pd.Series(mi_scores, name=\"MI Scores\", index=X.columns)\n",
    "    mi_scores = mi_scores.sort_values(ascending=False)\n",
    "    return mi_scores\n",
    "\n",
    "mi_scores = make_mi_scores(X, y, discrete_features)\n",
    "mi_scores[::3]  # show a few features with their MI scores\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation\n",
    "    Tasks\n",
    "    1.Data selection\n",
    "    2.Data preprocessing\n",
    "    3.Feature engineering\n",
    "    4.Dimensionality reduction\n",
    "\n",
    "    Steps:\n",
    "    Data cleaning\n",
    "\n",
    "    Data integration\n",
    "\n",
    "    Data sampling\n",
    "\n",
    "    Data formatting\n",
    "\n",
    "    Data transformation\n",
    "\n",
    "    Data dimensionality reduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Missing Values \n",
    "### Imputing values in predictive models\n",
    "When working with predictive models you will often have a separate train and test DataFrames. In these cases you want to ensure no information from your test set leaks into your train set. When filling missing values in data to be used in these situations how should approach the two data sets?\n",
    "\n",
    "**==>Apply the measures of central tendency (mean/median etc.) calculated on the train set to both the train and test sets.**\n",
    "\n",
    "**==> values calculated on the train test should be applied to both DataFrames.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the locations of the missing values\n",
    "print(sub_df.head(10).isnull())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the locations of the non-missing values\n",
    "print(sub_df.head(10).notnull())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dealing with missing values\n",
    "Note: we will be using Python and a census data set (modified for the purposes of this tutorial)\n",
    "\n",
    "You might be surprised to find out how many methods for dealing missing data exist. This is a testament to both how important this issue is, and also that there is a lot of potential for creative problem solving.\n",
    "\n",
    "The first thing you should do is count how many you have and try to visualize their distributions. For this step to work properly you should manually inspect the data (or at least a subset of it) to try to determine how they are designated. Possible variations are: ‘NaN’, ‘NA’, ‘None’, ‘ ’, ‘?’ and others. If you have something different than ‘NaN’ you should standardize them by using np.nan. To construct our visualizations we will use the handy missingno package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import missingno as msno\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "msno.matrix(census_data)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new DataFrame dropping all incomplete rows\n",
    "no_missing_values_rows = so_survey_df.dropna()\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_missing_values_rows.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new DataFrame dropping all columns with incomplete rows\n",
    "no_missing_values_cols = so_survey_df.dropna(how='any', axis=1)\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_missing_values_cols.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop all rows where Gender is missing\n",
    "no_gender = so_survey_df.dropna(subset=['Gender'])\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_gender.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "no_gender.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop all rows where Gender is missing\n",
    "no_gender = so_survey_df.dropna(subset=['Gender'])\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_gender.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Replacing missing values with constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the count of occurrences\n",
    "print(so_survey_df['Gender'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert '?' to NaN\n",
    "df[df == '?'] = np.nan\n",
    "\n",
    "# Print the number of NaNs\n",
    "print(df.isnull().sum())\n",
    "\n",
    "# Print shape of original DataFrame\n",
    "print(\"Shape of Original DataFrame: {}\".format(df.shape))\n",
    "\n",
    "# Drop missing values and print shape of new DataFrame\n",
    "df = df.dropna()\n",
    "\n",
    "# Print shape of new DataFrame\n",
    "print(\"Shape of DataFrame After Dropping All Rows with Missing Values: {}\".format(df.shape))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the Imputer module\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.svm import SVC \n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import train_test_split\n",
    "# Setup the Imputation transformer: imp\n",
    "imp =  SimpleImputer(missing_values= np.nan, strategy='most_frequent')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.impute import SimpleImputer\n",
    "arr = [[1., 'x'], [np.nan, 'y'], [7., 'z'], [7., 'y'], [4., np.nan]]\n",
    "df1 = pd.DataFrame({'x1': [x[0] for x in arr],\n",
    "                    'x2': [x[1] for x in arr]},\n",
    "                  index=[l for l in 'abcde'])\n",
    "imp = SimpleImputer(missing_values=np.nan, strategy='most_frequent')\n",
    "print(pd.DataFrame(imp.fit_transform(df1),\n",
    "                   columns=df1.columns,\n",
    "                   index=df1.index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'num': [1.,2.,4.,np.nan],'cate1':['a','a','b',np.nan],'cate2':['a','b','b',np.nan]})\n",
    "\n",
    "# numeric columns\n",
    ">>> df.fillna(df.select_dtypes(include='number').mean().iloc[0], inplace=True)\n",
    "\n",
    "# categorical columns\n",
    ">>> df.fillna(df.select_dtypes(include='object').mode().iloc[0], inplace=True)\n",
    "\n",
    ">>> print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Categorical NaNs\n",
    "Categorical values can be a bit trickier, so you should definitely pay attention to your model performance metrics after editing (compare before and after). The standard thing to do is to replace the missing entry with the most frequent one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "census_data['marital.status'].value_counts()\n",
    "most_common=census_data['marital.status'].value_counts().idxmax()\n",
    "most_common"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_most_common(x):\n",
    "    if pd.isnull(x):\n",
    "        return most_common\n",
    "    else:\n",
    "        return x\n",
    "census_data = census_data['marital.status'].map(replace_most_common)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replace missing values\n",
    "so_survey_df['Gender'].fillna('Not Given', inplace=True)\n",
    "\n",
    "# Print the count of each value\n",
    "print(so_survey_df['Gender'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replace missing values\n",
    "so_survey_df['Gender'].fillna('Not Given', inplace=True)\n",
    "\n",
    "# Print the count of each value\n",
    "print(so_survey_df['Gender'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filling continuous missing values¶\n",
    "A standard and often very good approach is to replace the missing values with mean, median or mode. For numerical values you should go with mean, and if there are some outliers try median (since it is much less sensitive to them)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import Imputer\n",
    "imputer = Imputer(missing_values=np.nan, strategy='median', axis=0)\n",
    "census_data[['fnlwgt']] = imputer.fit_transform(census_data[['fnlwgt']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fill missing values with the mean\n",
    "so_survey_df['StackOverflowJobsRecommend'].fillna(so_survey_df['StackOverflowJobsRecommend'].mean(), inplace=True)\n",
    "# Print the first five rows of StackOverflowJobsRecommend column\n",
    "print(so_survey_df['StackOverflowJobsRecommend'].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fill missing values with the mean\n",
    "so_survey_df['StackOverflowJobsRecommend'].fillna(so_survey_df['StackOverflowJobsRecommend'].mean(), inplace=True)\n",
    "\n",
    "# Round the StackOverflowJobsRecommend values\n",
    "so_survey_df['StackOverflowJobsRecommend'] = round(so_survey_df['StackOverflowJobsRecommend'])\n",
    "\n",
    "# Print the top 5 rows\n",
    "print(so_survey_df['StackOverflowJobsRecommend'].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Removing outliers\n",
    "## Percentage based outlier removal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    Find the 95th quantile of the ConvertedSalary column.\n",
    "    Trim the so_numeric_df DataFrame to retain all rows where ConvertedSalary is less than it's 95th quantile.\n",
    "    Plot the histogram of so_numeric_df[['ConvertedSalary']].\n",
    "    Plot the histogram of trimmed_df[['ConvertedSalary']].\n",
    "\"\"\"\n",
    "# Find the 95th quantile\n",
    "quantile = so_numeric_df['ConvertedSalary'].quantile(0.95)\n",
    "\n",
    "# Trim the outliers\n",
    "trimmed_df = so_numeric_df[so_numeric_df['ConvertedSalary'] < quantile  ]\n",
    "\n",
    "# The original histogram\n",
    "so_numeric_df[['ConvertedSalary']].hist()\n",
    "plt.show()\n",
    "plt.clf()\n",
    "\n",
    "# The trimmed histogram\n",
    "trimmed_df[['ConvertedSalary']].hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Statistical outlier removal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "so_numeric_df[['ConvertedSalary']].boxplot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the mean and standard dev\n",
    "std = so_numeric_df['ConvertedSalary'].std()\n",
    "mean = so_numeric_df['ConvertedSalary'].mean()\n",
    "\n",
    "# Calculate the cutoff\n",
    "cut_off = std * 3\n",
    "lower, upper = mean - cut_off, mean + cut_off\n",
    "\n",
    "# Trim the outliers\n",
    "trimmed_df = so_numeric_df[(so_numeric_df['ConvertedSalary'] < upper) \\\n",
    "                           & (so_numeric_df['ConvertedSalary'] > lower)]\n",
    "\n",
    "# The trimmed box plot\n",
    "trimmed_df[['ConvertedSalary']].boxplot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " # Scaling and transforming new data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Formatting/ Data Transformation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove the commas in the column\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].str.replace(',', '')\n",
    "# Remove the dollar signs in the column\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].str.replace('$','')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Attempt to convert the column to numeric values\n",
    "numeric_vals = pd.to_numeric(so_survey_df['RawSalary'], errors='coerce')\n",
    "\n",
    "# Find the indexes of missing values\n",
    "idx = numeric_vals.isna()\n",
    "\n",
    "# Print the relevant rows\n",
    "print(so_survey_df['RawSalary'][idx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replace the offending characters\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].str.replace('£','')\n",
    "\n",
    "# Convert the column to float\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].astype('float')\n",
    "\n",
    "# Print the column\n",
    "print(so_survey_df['RawSalary'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use method chaining\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary']\\\n",
    "                              .replace(',', '')\\\n",
    "                              .replace('$','')\\\n",
    "                              .replace('£','')\\\n",
    "                              .astype('float')\n",
    " \n",
    "# Print the RawSalary column\n",
    "print(so_survey_df['RawSalary'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What does your data look like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a histogram\n",
    "so_numeric_df.hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a boxplot of two columns\n",
    "so_numeric_df[['Age', 'Years Experience']].boxplot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a boxplot of ConvertedSalary\n",
    "so_numeric_df[['ConvertedSalary']].boxplot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages\n",
    "import matplotlib.pyplot as plt \n",
    "import seaborn as sns \n",
    "\n",
    "# Plot pairwise relationships\n",
    "sns.pairplot(so_numeric_df)\n",
    "\n",
    "# Show plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages\n",
    "import matplotlib.pyplot as plt \n",
    "import seaborn as sns \n",
    "\n",
    "# Plot pairwise relationships\n",
    "sns.pairplot(so_numeric_df)\n",
    "\n",
    "# Show plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print summary statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(so_numeric_df.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Centering and scaling\n",
    "## Identifying features for standardization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normalization :MinMaxScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Import MinMaxScaler from sklearn's preprocessing module.\n",
    "    Instantiate the MinMaxScaler() as MM_scaler.\n",
    "    Fit the MinMaxScaler on the Age column of so_numeric_df.\n",
    "    Transform the same column with the scaler you just fit.\n",
    "\"\"\"\n",
    "# Import MinMaxScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# Instantiate MinMaxScaler\n",
    "MM_scaler = MinMaxScaler()\n",
    "\n",
    "# Fit MM_scaler to the data\n",
    "MM_scaler.fit(so_numeric_df[['Age']])\n",
    "\n",
    "# Transform the data using the fitted scaler\n",
    "so_numeric_df['Age_MM'] = MM_scaler.transform(so_numeric_df[['Age']])\n",
    "\n",
    "# Compare the origional and transformed column\n",
    "print(so_numeric_df[['Age_MM', 'Age']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "so_numeric_df[['Age_MM', 'Age']].hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Log transformation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.distplot(df[\"a\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print out the variance of the Proline column\n",
    "print(df['Proline'].var())\n",
    "\n",
    "# Apply the log normalization function to the Proline column\n",
    "df['Proline_log'] = np.log(df['Proline'])\n",
    "\n",
    "# Check the variance of the normalized Proline column\n",
    "print(df['Proline_log'].var())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import PowerTransformer\n",
    "from sklearn.preprocessing import PowerTransformer\n",
    "\n",
    "# Instantiate PowerTransformer\n",
    "pow_trans = PowerTransformer()\n",
    "\n",
    "# Train the transform on the data\n",
    "pow_trans.fit(so_numeric_df[['ConvertedSalary']])\n",
    "\n",
    "# Apply the power transform to the data\n",
    "so_numeric_df['ConvertedSalary_LG'] = pow_trans.transform(so_numeric_df[['ConvertedSalary']])\n",
    "\n",
    "# Plot the data before and after the transformation\n",
    "so_numeric_df[['ConvertedSalary', 'ConvertedSalary_LG']].hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import StandardScaler\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "# Instantiate StandardScaler\n",
    "SS_scaler = StandardScaler()\n",
    "# Fit SS_scaler to the data\n",
    "SS_scaler.fit(so_numeric_df[['Age']])\n",
    "# Transform the data using the fitted scaler\n",
    "so_numeric_df['Age_SS'] = SS_scaler.transform(so_numeric_df[['Age']])\n",
    "# Compare the origional and transformed column\n",
    "print(so_numeric_df[['Age_SS', 'Age']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "so_numeric_df[['Age_SS', 'Age']].hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import StandardScaler from scikit-learn\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Create the scaler\n",
    "ss = StandardScaler()\n",
    "# Take a subset of the DataFrame you want to scale \n",
    "wine_subset = df[['Ash', 'Alcalinity of ash', 'Magnesium']]\n",
    "\n",
    "# Apply the scaler to the DataFrame subset\n",
    "wine_subset_scaled = ss.fit_transform(wine_subset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.distplot(df['a_log'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Scaling and transforming new data\n",
    " \n",
    " ## Prevent Data Leakage "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    Instantiate the StandardScaler() as SS_scaler.\n",
    "    Fit the StandardScaler on the Age column.\n",
    "    Transform the Age column in the test set (so_test_numeric).\n",
    "\"\"\"\n",
    "# Import StandardScaler\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Apply a standard scaler to the data\n",
    "SS_scaler = StandardScaler()\n",
    "\n",
    "# Fit the standard scaler to the data\n",
    "SS_scaler.fit(so_train_numeric[['Age']])\n",
    "\n",
    "# Transform the test data using the fitted scaler\n",
    "so_test_numeric['Age_ss'] = SS_scaler.transform(so_test_numeric[['Age']])\n",
    "print(so_test_numeric[['Age', 'Age_ss']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_std = so_train_numeric['ConvertedSalary'].mean()\n",
    "train_mean = so_train_numeric['ConvertedSalary'].std()\n",
    "\n",
    "cut_off = train_std * 3\n",
    "train_lower, train_upper = train_mean - cut_off, train_mean + cut_off\n",
    "\n",
    "# Trim the test DataFrame\n",
    "trimmed_df = so_test_numeric[(so_test_numeric['ConvertedSalary'] < train_upper) \\\n",
    "                             & (so_test_numeric['ConvertedSalary'] > train_lower)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature engineering\n",
    "## Encoding categorical variables\n",
    "https://github.com/DeepSparkChaker/FasterDataScienceEducationMiniCourses/blob/master/MachineLearningIntermidateLevelMinicourse2-categorical%20variable.ipynb\n",
    "\n",
    "https://www.kaggle.com/learn/feature-engineering\n",
    "## Engineering numerical features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Feature Engineering\n",
    "Time Series data must be re-framed as a supervised learning dataset before we can start using machine learning algorithms.\n",
    "\n",
    "There is no concept of input and output features in time series. Instead, we must choose the variable to be predicted and use feature engineering to construct all of the inputs that will be used to make predictions for future time steps.\n",
    "The goal of feature engineering is to provide strong and ideally simple relationships between new input features and the output feature for the supervised learning algorithm to model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.1 Label Encoding\n",
    "Remove unwanted data to create space in RAM for further processing.\n",
    "Label Encode categorical features.(I had converted already converted categorical variable to category type. So, I can simply use their codes instead of using LableEncoder)\n",
    "Remove date as its features are already present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Store the categories along with their codes\n",
    "d_id = dict(zip(df.id.cat.codes, df.id))\n",
    "d_item_id = dict(zip(df.item_id.cat.codes, df.item_id))\n",
    "d_dept_id = dict(zip(df.dept_id.cat.codes, df.dept_id))\n",
    "d_cat_id = dict(zip(df.cat_id.cat.codes, df.cat_id))\n",
    "d_store_id = dict(zip(df.store_id.cat.codes, df.store_id))\n",
    "d_state_id = dict(zip(df.state_id.cat.codes, df.state_id))\n",
    "#1\n",
    "del group, group_price_cat, group_price_store, group_state, group_state_store, cal_data\n",
    "gc.collect();\n",
    "\n",
    "#2\n",
    "df.d = df['d'].apply(lambda x: x.split('_')[1]).astype(np.int16)\n",
    "cols = df.dtypes.index.tolist()\n",
    "types = df.dtypes.values.tolist()\n",
    "for i,type in enumerate(types):\n",
    "    if type.name == 'category':\n",
    "        df[cols[i]] = df[cols[i]].cat.codes\n",
    "        \n",
    "#3\n",
    "df.drop('date',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.2 Introduce Lags\n",
    "Go back to topics\n",
    "Lag features are the classical way that time series forecasting problems are transformed into supervised learning problems.\n",
    "\n",
    "Introduce lags to the the target variable sold. The maximum lag I have introduced is 36 days. It's purely upto you how many lags you want to introduce.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Introduce lags\n",
    "lags = [1,2,3,6,12,24,36]\n",
    "for lag in lags:\n",
    "    df['sold_lag_'+str(lag)] = df.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'],as_index=False)['sold'].shift(lag).astype(np.float16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.3 Mean Encoding\n",
    "Go back to topics\n",
    "From a mathematical point of view, mean encoding represents a probability of your target variable, conditional on each value of the feature. In a way, it embodies the target variable in its encoded value. I have calculated mean encodings on the basis of following logical features I could think of:-\n",
    "\n",
    "item\n",
    "state\n",
    "store\n",
    "category\n",
    "department\n",
    "category & department\n",
    "store & item\n",
    "category & item\n",
    "department & item\n",
    "state & store\n",
    "state, store and category\n",
    "store, category and department\n",
    "Feel free to add more!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['iteam_sold_avg'] = df.groupby('item_id')['sold'].transform('mean').astype(np.float16)\n",
    "df['state_sold_avg'] = df.groupby('state_id')['sold'].transform('mean').astype(np.float16)\n",
    "df['store_sold_avg'] = df.groupby('store_id')['sold'].transform('mean').astype(np.float16)\n",
    "df['cat_sold_avg'] = df.groupby('cat_id')['sold'].transform('mean').astype(np.float16)\n",
    "df['dept_sold_avg'] = df.groupby('dept_id')['sold'].transform('mean').astype(np.float16)\n",
    "df['cat_dept_sold_avg'] = df.groupby(['cat_id','dept_id'])['sold'].transform('mean').astype(np.float16)\n",
    "df['store_item_sold_avg'] = df.groupby(['store_id','item_id'])['sold'].transform('mean').astype(np.float16)\n",
    "df['cat_item_sold_avg'] = df.groupby(['cat_id','item_id'])['sold'].transform('mean').astype(np.float16)\n",
    "df['dept_item_sold_avg'] = df.groupby(['dept_id','item_id'])['sold'].transform('mean').astype(np.float16)\n",
    "df['state_store_sold_avg'] = df.groupby(['state_id','store_id'])['sold'].transform('mean').astype(np.float16)\n",
    "df['state_store_cat_sold_avg'] = df.groupby(['state_id','store_id','cat_id'])['sold'].transform('mean').astype(np.float16)\n",
    "df['store_cat_dept_sold_avg'] = df.groupby(['store_id','cat_id','dept_id'])['sold'].transform('mean').astype(np.float16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.4 Rolling Window Statistics\n",
    "\n",
    "Here’s an awesome gif that explains this idea in a wonderfully intuitive way:This method is called the rolling window method because the window would be different for every data point.\n",
    "\n",
    "I'll be calculating weekly rolling avearge of the items sold. More features like rolling min, max or sum can also be calculated. Also, same features can be calculated for revenue as well.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['rolling_sold_mean'] = df.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'])['sold'].transform(lambda x: x.rolling(window=7).mean()).astype(np.float16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.5 Expanding Window Statistics\n",
    "Go back to topics\n",
    "This is simply an advanced version of the rolling window technique. In the case of a rolling window, the size of the window is constant while the window slides as we move forward in time. Hence, we consider only the most recent values and ignore the past values. Here’s a gif that explains how our expanding window function works:\n",
    "\n",
    "I'll be calculating expanding avearge of the items sold. More features like expanding min, max or sum can also be calculated. Also, same features can be calculated for revenue as well.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['expanding_sold_mean'] = df.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'])['sold'].transform(lambda x: x.expanding(2).mean()).astype(np.float16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.6 Trends\n",
    "Go back to topics\n",
    "I will be creating a selling trend feature, which will be some positive value if the daily items sold are greater than the entire duration average ( d_1 - d_1969 ) else negative. More trend features can be added but I'll only add this one to keep it simple.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['daily_avg_sold'] = df.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id','d'])['sold'].transform('mean').astype(np.float16)\n",
    "df['avg_sold'] = df.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'])['sold'].transform('mean').astype(np.float16)\n",
    "df['selling_trend'] = (df['daily_avg_sold'] - df['avg_sold']).astype(np.float16)\n",
    "df.drop(['daily_avg_sold','avg_sold'],axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.7 Save the data\n",
    "Go back to topics\n",
    "Now since all the new features are created, let's save the data so that it can be trained separately.Also, lags introduce a lot of Null values, so I'll remove data for first 35 days as I have introduced lags till 36 days.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[df['d']>=36]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save the data for training.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_pickle('data.pkl')\n",
    "del df\n",
    "gc.collect();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a series out of the Country column\n",
    "countries = so_survey_df['Country']\n",
    "\n",
    "# Get the counts of each category\n",
    "country_counts = countries.value_counts()\n",
    "\n",
    "# Create a mask for only categories that occur less than 10 times\n",
    "mask = countries.isin(country_counts[country_counts<10].index)\n",
    "\n",
    "# Print the top 5 rows in the mask series\n",
    "print(mask.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "country_counts[country_counts < 10].index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Label all other categories as Other\n",
    "countries[mask] = 'Other'\n",
    "\n",
    "# Print the updated category counts\n",
    "print(countries.value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up the LabelEncoder object\n",
    "enc = LabelEncoder()\n",
    "\n",
    "# Apply the encoding to the \"Accessible\" column\n",
    "hiking['Accessible_enc'] = enc.fit_transform(hiking[\"Accessible\"])\n",
    "\n",
    "# Compare the two columns\n",
    "print(hiking[['Accessible', 'Accessible_enc']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transform the category_desc column\n",
    "category_enc = pd.get_dummies(df[\"category_desc\"])\n",
    "\n",
    "# Take a look at the encoded columns\n",
    "print(category_enc.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numeric variables\n",
    "#  Binarizing columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Paid_Job column filled with zeros\n",
    "so_survey_df['Paid_Job'] = 0\n",
    "\n",
    "# Replace all the Paid_Job values where ConvertedSalary is > 0\n",
    "so_survey_df.loc[so_survey_df['ConvertedSalary'] > 0, 'Paid_Job'] = 1\n",
    "\n",
    "# Print the first five rows of the columns\n",
    "print(so_survey_df[['Paid_Job', 'ConvertedSalary']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "so_survey_df['Paid_Job'] = np.where(so_survey_df['ConvertedSalary'] > 0, 1,0)\n",
    "so_survey_df[['Paid_Job', 'ConvertedSalary']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Binning values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bin the continuous variable ConvertedSalary into 5 bins\n",
    "so_survey_df['equal_binned'] = pd.cut(so_survey_df['ConvertedSalary'], bins=5)\n",
    "\n",
    "# Print the first 5 rows of the equal_binned column\n",
    "print(so_survey_df[['equal_binned', 'ConvertedSalary']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Specify the boundaries of the bins\n",
    "bins = [-np.inf, 10000, 50000, 100000, 150000, np.inf]\n",
    "\n",
    "# Bin labels\n",
    "labels = ['Very low', 'Low', 'Medium', 'High', 'Very high']\n",
    "\n",
    "# Bin the continuous variable ConvertedSalary using these boundaries\n",
    "so_survey_df['boundary_binned'] = pd.cut(so_survey_df['ConvertedSalary'], \n",
    "                                         bins=bins,labels=labels )\n",
    "\n",
    "# Print the first 5 rows of the boundary_binned column\n",
    "print(so_survey_df[['boundary_binned', 'ConvertedSalary']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of the columns to average\n",
    "run_columns = [\"run1\", \"run2\", \"run3\", \"run4\", \"run5\"]\n",
    "\n",
    "# Use apply to create a mean column\n",
    "running_times_5k[\"mean\"] = running_times_5k.apply(lambda row: row[run_columns].mean(), axis=1)\n",
    "\n",
    "\n",
    "# Take a look at the results\n",
    "print(running_times_5k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, convert string column to date column\n",
    "volunteer[\"start_date_converted\"] = pd.to_datetime(volunteer[\"start_date_date\"])\n",
    "\n",
    "# Extract just the month from the converted column\n",
    "volunteer[\"start_date_month\"] = volunteer[\"start_date_converted\"].apply(lambda row: row.month)\n",
    "\n",
    "# Take a look at the converted and new month columns\n",
    "print(volunteer[[\"start_date_converted\", \"start_date_month\"]].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re \n",
    "hiking[\"Length\"]=hiking[\"Length\"].astype(\"str\")\n",
    "# Write a pattern to extract numbers and decimals\n",
    "def return_mileage(length):\n",
    "    pattern = re.compile(r\"\\d+\\.\\d+\")\n",
    "    \n",
    "    # Search the text for matches\n",
    "    mile = re.match(pattern, length)\n",
    "    \n",
    "    # If a value is returned, use group(0) to return the found value\n",
    "    if mile is not None:\n",
    "        return float(mile.group(0))\n",
    "        \n",
    "# Apply the function to the Length column and take a look at both columns\n",
    "hiking[\"Length_num\"] = hiking[\"Length\"].apply(lambda row: return_mileage(row))\n",
    "print(hiking[[\"Length\", \"Length_num\"]].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_minutes(time_string):\n",
    "    \n",
    "    # We'll use \\d+ to grab digits and match it to the column values\n",
    "    pattern = re.compile(r\"\\d+\")\n",
    "        \n",
    "    # Use match on the pattern and column\n",
    "    num = re.match(pattern, time_string)\n",
    "    if num is not None:\n",
    "        return int(num.group(0))\n",
    "ufo[\"length_of_time\"]=ufo[\"length_of_time\"].astype(str)     \n",
    "# Apply the extraction to the length_of_time column\n",
    "ufo[\"minutes\"] = ufo[\"length_of_time\"].apply(return_minutes)\n",
    "\n",
    "# Take a look at the head of both of the columns\n",
    "print(ufo[[\"length_of_time\", \"minutes\"]].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "# Take the title text\n",
    "title_text = volunteer[\"title\"]\n",
    "\n",
    "# Create the vectorizer method\n",
    "tfidf_vec = TfidfVectorizer()\n",
    "\n",
    "# Transform the text into tf-idf vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature selection\n",
    "## Removing redundant features\n",
    "## Selecting relevant features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns \n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "sns.heatmap(volunteer.corr())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of redundant column names to drop\n",
    "to_drop = [\"category_desc\", \"created_date\", \"locality\", \"region\", \"vol_requests\"]\n",
    "\n",
    "# Drop those columns from the dataset\n",
    "volunteer_subset = volunteer.drop(to_drop, axis=1)\n",
    "\n",
    "# Print out the head of the new dataset\n",
    "print(volunteer_subset.head(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Checking for correlated features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "skewValue = df.skew()\n",
    "\n",
    "print(\"Skew:\")\n",
    "\n",
    "print(skewValue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print out the column correlations of the wine dataset\n",
    "wine= pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/wine_types.csv')\n",
    "\n",
    "# Print out the column correlations of the wine dataset\n",
    "print(wine.corr())\n",
    "\n",
    "# Take a minute to find the column where the correlation value is greater than 0.75 at least twice\n",
    "to_drop = \"Flavanoids\"\n",
    "\n",
    "# Drop that column from the DataFrame\n",
    "wine = wine.drop(to_drop, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mutual Information\n",
    "https://www.kaggle.com/ryanholbrook/mutual-information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_selection import mutual_info_regression\n",
    "\n",
    "def make_mi_scores(X, y, discrete_features):\n",
    "    mi_scores = mutual_info_regression(X, y, discrete_features=discrete_features)\n",
    "    mi_scores = pd.Series(mi_scores, name=\"MI Scores\", index=X.columns)\n",
    "    mi_scores = mi_scores.sort_values(ascending=False)\n",
    "    return mi_scores\n",
    "mi_scores = make_mi_scores(X, y, discrete_features)\n",
    "mi_scores[::3]  # show a few features with their MI scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    Import:\n",
    "        matplotlib.pyplot as plt.\n",
    "        pearsonr from scipy.stats.\n",
    "    Assign column 0 of grains to width and column 1 of grains to length.\n",
    "    Make a scatter plot with width on the x-axis and length on the y-axis.\n",
    "    Use the pearsonr() function to calculate the Pearson correlation of width and length.\n",
    "\"\"\"\n",
    "# Perform the necessary imports\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import pearsonr\n",
    "\n",
    "# Assign the 0th column of grains: width\n",
    "width = samples[:,0]\n",
    "\n",
    "# Assign the 1st column of grains: length\n",
    "length = samples[:,1]\n",
    "\n",
    "# Scatter plot width vs length\n",
    "plt.scatter(width, length)\n",
    "plt.axis('equal')\n",
    "plt.show()\n",
    "\n",
    "# Calculate the Pearson correlation\n",
    "\n",
    "correlation, pvalue = pearsonr(width, length)\n",
    "\n",
    "# Display the correlation\n",
    "print(correlation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    Import PCA from sklearn.decomposition.\n",
    "    Create an instance of PCA called model.\n",
    "    Use the .fit_transform() method of model to apply the PCA transformation to grains. Assign the result to pca_features.\n",
    "    The subsequent code to extract, plot, and compute the Pearson correlation of the first two columns pca_features has been written for you, so hit 'Submit Answer' to see the result!\n",
    "\"\"\"\n",
    "# Import PCA\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "\n",
    "# Create PCA instance: model\n",
    "model = PCA()\n",
    "\n",
    "# Apply the fit_transform method of model to grains: pca_features\n",
    "pca_features = model.fit_transform(samples)\n",
    "\n",
    "# Assign 0th column of pca_features: xs\n",
    "xs = pca_features[:,0]\n",
    "\n",
    "# Assign 1st column of pca_features: ys\n",
    "ys = pca_features[:,1]\n",
    "\n",
    "# Scatter plot xs vs ys\n",
    "plt.scatter(xs, ys)\n",
    "plt.axis('equal')\n",
    "plt.show()\n",
    "\n",
    "# Calculate the Pearson correlation of xs and ys\n",
    "correlation, pvalue = pearsonr(xs, ys)\n",
    "\n",
    "# Display the correlation\n",
    "print(correlation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a scatter plot of the untransformed points\n",
    "plt.scatter(samples[:,0], samples[:,1])\n",
    "\n",
    "# Create a PCA instance: model\n",
    "model = PCA()\n",
    "\n",
    "# Fit model to points\n",
    "model.fit(samples)\n",
    "\n",
    "# Get the mean of the grain samples: mean\n",
    "mean = model.mean_\n",
    "\n",
    "# Get the first principal component: first_pc\n",
    "first_pc = model.components_[0,:]\n",
    "\n",
    "# Plot first_pc as an arrow, starting at mean\n",
    "plt.arrow(mean[0], mean[1], first_pc[0], first_pc[1], color='red', width=0.01)\n",
    "\n",
    "# Keep axes on same scale\n",
    "plt.axis('equal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(model.n_components_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(model.components_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform the necessary imports\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import make_pipeline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Create scaler: scaler\n",
    "scaler = StandardScaler()\n",
    "\n",
    "# Create a PCA instance: pca\n",
    "pca = PCA()\n",
    "\n",
    "# Create pipeline: pipeline\n",
    "pipeline = make_pipeline(scaler,pca)\n",
    "\n",
    "# Fit the pipeline to 'samples'\n",
    "pipeline.fit(samples)\n",
    "\n",
    "# Plot the explained variances\n",
    "features = range(pca.n_components_)\n",
    "plt.bar(features,pca.explained_variance_)\n",
    "plt.xlabel('PCA feature')\n",
    "plt.ylabel('variance')\n",
    "plt.xticks(features)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# Set up PCA and the X vector for diminsionality reduction\n",
    "pca = PCA()\n",
    "wine_X = wine.drop(\"Type\", axis=1)\n",
    "\n",
    "# Apply PCA to the wine dataset\n",
    "transformed_X = pca.fit_transform(wine_X)\n",
    "\n",
    "# Look at the percentage of variance explained by the different components\n",
    "print(pca.explained_variance_ratio_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding a good variance threshold\n",
    "## Features with low variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalize the data\n",
    "normalized_df = df_numeric / df_numeric.mean()\n",
    "\n",
    "# Print the variances of the normalized data\n",
    "print(normalized_df.var())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_selection import VarianceThreshold\n",
    "\n",
    "# Create a VarianceThreshold feature selector\n",
    "sel = VarianceThreshold(threshold=0.001)\n",
    "\n",
    "# Fit the selector to normalized head_df\n",
    "sel.fit(head_df / head_df.mean())\n",
    "\n",
    "# Create a boolean mask\n",
    "mask = sel.get_support()\n",
    "\n",
    "# Apply the mask to create a reduced dataframe\n",
    "reduced_df = head_df.loc[:, mask]\n",
    "\n",
    "print(\"Dimensionality reduced from {} to {}.\".format(head_df.shape[1], reduced_df.shape[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Removing features with many missing values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a boolean mask on whether each feature less than 50% missing values.\n",
    "mask = school_df.isna().sum() / len(school_df) < 0.5\n",
    "\n",
    "# Create a reduced dataset by applying the mask\n",
    "reduced_df =school_df.loc[:, mask]\n",
    "\n",
    "print(school_df.shape)\n",
    "print(reduced_df.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pairwise correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reduced_df.corr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the correlation matrix and take the absolute value\n",
    "corr_matrix = school_df.corr().abs()\n",
    "\n",
    "# Create a True/False mask and apply it\n",
    "mask = np.triu(np.ones_like(corr_matrix, dtype=bool))\n",
    "tri_df = corr_matrix.mask(mask)\n",
    "\n",
    "# List column names of highly correlated features (r > 0.95)\n",
    "to_drop = [c for c in tri_df.columns if any(tri_df[c] > 0.8)]\n",
    "\n",
    "# Drop the features in the to_drop list\n",
    "reduced_df = school_df.drop(to_drop, axis=1)\n",
    "print(to_drop)\n",
    "print(\"The reduced dataframe has {} columns.\".format(reduced_df.shape[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Selecting features for model performance\n",
    "##  Automatic Recursive Feature Elimination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_selection import RFE\n",
    "# Create the RFE with a LogisticRegression estimator and 3 features to select\n",
    "rfe = RFE(estimator=LogisticRegression(), n_features_to_select = 3, verbose=1)\n",
    "\n",
    "# Fits the eliminator to the data\n",
    "rfe.fit(scaler.fit_transform(X_train), y_train)\n",
    "\n",
    "# Print the features and their ranking (high = dropped early on)\n",
    "print(dict(zip(X.columns, rfe.ranking_)))\n",
    "\n",
    "# Print the features that are not eliminated\n",
    "print(X.columns[rfe.support_])\n",
    "\n",
    "# Calculates the test set accuracy\n",
    "acc = accuracy_score(y_test, rfe.predict(scaler.fit_transform(X_test)))\n",
    "print(\"{0:.1%} accuracy on test set.\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tree-based feature selection\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier \n",
    "\n",
    "# Fit the random forest model to the training data\n",
    "rf = RandomForestClassifier(random_state=0)\n",
    "rf.fit(scaler.fit_transform(X_train),y_train )\n",
    "\n",
    "# Calculate the accuracy\n",
    "acc = accuracy_score(y_test,rf.predict(scaler.transform(X_test)))\n",
    "\n",
    "# Print the importances per feature\n",
    "print(dict(zip(X.columns, rf.feature_importances_.round(2))))\n",
    "\n",
    "# Print accuracy\n",
    "print(\"{0:.1%} accuracy on test set.\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a mask for features importances above the threshold\n",
    "mask = rf.feature_importances_ > 0.15\n",
    "\n",
    "# Prints out the mask\n",
    "print(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a mask for features importances above the threshold\n",
    "mask = rf.feature_importances_ > 0.15\n",
    "\n",
    "# Apply the mask to the feature dataset X\n",
    "reduced_X = X.loc[:, mask]\n",
    "\n",
    "# prints out the selected column names\n",
    "print(reduced_X.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recursive Feature Elimination with random forests\n",
    "You'll wrap a Recursive Feature Eliminator around a random forest model to remove features step by step. This method is more conservative compared to selecting features after applying a single importance threshold. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the feature eliminator to remove 2 features on each step\n",
    "rfe = RFE(estimator=RandomForestClassifier(), n_features_to_select=2, step=2, verbose=1)\n",
    "\n",
    "# Fit the model to the training data\n",
    "rfe.fit(X_train, y_train)\n",
    "\n",
    "# Create a mask\n",
    "mask = rfe.support_\n",
    "\n",
    "# Apply the mask to the feature dataset X and print the result\n",
    "reduced_X = X.loc[:, mask]\n",
    "print(reduced_X.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EDA before moedling "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import pandas\n",
    "import pandas as pd \n",
    "\n",
    "\n",
    "# Read 'gapminder.csv' into a DataFrame: df\n",
    "df = pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/gm_2008_region.csv')\n",
    "\n",
    "# Create a boxplot of life expectancy per region\n",
    "df.boxplot('life', 'Region', rot=60)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.boxplot(x=\"day\", y=\"total_bill\", data=tips)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "tips = sns.load_dataset(\"tips\")\n",
    "\n",
    "ax = sns.boxplot(x=tips[\"total_bill\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.boxplot(x=\"day\", y=\"total_bill\", hue=\"smoker\",\n",
    "\n",
    "                 data=tips, palette=\"Set3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.boxplot(x=\"Region\", y=\"life\",\n",
    "\n",
    "                 data=df, palette=\"Set3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "tips = sns.load_dataset(\"tips\")\n",
    "\n",
    "ax = sns.boxplot(x=tips[\"total_bill\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "def reduce_mem_usage(df):\n",
    "    start_mem = df.memory_usage().sum() / 1024**2\n",
    "    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))\n",
    "\n",
    "    for col in df.columns:\n",
    "        col_type = df[col].dtype\n",
    "    if col_type != object:\n",
    "            c_min = df[col].min()\n",
    "            c_max = df[col].max()\n",
    "            if str(col_type)[:3] == 'int':\n",
    "                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:\n",
    "                    df[col] = df[col].astype(np.int8)\n",
    "                elif c_min > np.iinfo(np.uint8).min and c_max < np.iinfo(np.uint8).max:\n",
    "                    df[col] = df[col].astype(np.uint8)\n",
    "                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:\n",
    "                    df[col] = df[col].astype(np.int16)\n",
    "                elif c_min > np.iinfo(np.uint16).min and c_max < np.iinfo(np.uint16).max:\n",
    "                    df[col] = df[col].astype(np.uint16)\n",
    "                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:\n",
    "                    df[col] = df[col].astype(np.int32)\n",
    "                elif c_min > np.iinfo(np.uint32).min and c_max < np.iinfo(np.uint32).max:\n",
    "                    df[col] = df[col].astype(np.uint32)                    \n",
    "                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:\n",
    "                    df[col] = df[col].astype(np.int64)\n",
    "                elif c_min > np.iinfo(np.uint64).min and c_max < np.iinfo(np.uint64).max:\n",
    "                    df[col] = df[col].astype(np.uint64)\n",
    "            elif str(col_type)[:5] == 'float':\n",
    "                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:\n",
    "                    df[col] = df[col].astype(np.float16)\n",
    "                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:\n",
    "                    df[col] = df[col].astype(np.float32)\n",
    "                else:\n",
    "                    df[col] = df[col].astype(np.float64)\n",
    "\n",
    "    end_mem = df.memory_usage().sum() / 1024**2\n",
    "    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))\n",
    "    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=reduce_mem_usage(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AGGREGATION \n",
    "https://www.shanelynn.ie/summarising-aggregation-and-grouping-data-in-python-pandas/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Modeling :¶\n",
    "Modeling is the part of the Cross-Industry Standard Process for Data Mining (CRISP-DM) process model that i like best. Our data is already in good shape, and now we can search for useful patterns in our data.\n",
    "\n",
    "Tasks\n",
    "1. Select modeling technique Select technique\n",
    "\n",
    "2. Generate test design\n",
    "\n",
    "3. Build model\n",
    "\n",
    "4. Assess model\n",
    "\n",
    "# Machine learning:\n",
    "\n",
    "Ml is a subset of artificial intelligence that uses techniques (such as deep learning) that enable machines to use experience to improve at tasks. The learning process is based on the following steps:\n",
    "\n",
    "    Feed data into an algorithm. (In this step you can provide additional information to the model, for example, by performing feature extraction.)\n",
    "    Use this data to train a model.\n",
    "    Test and deploy the model.\n",
    "    Consume the deployed model to do an automated predictive task. (In other words, call and use the deployed model to receive the predictions returned by the model.)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**df.to_numpy() is better than df.values, here's why.*\n",
    "It's time to deprecate your usage of values and as_matrix().**\n",
    "\n",
    "**pandas v0.24.0 introduced two new methods for obtaining NumPy arrays from pandas objects:**\n",
    "\n",
    "**to_numpy(), which is defined on Index, Series, and DataFrame objects, and\n",
    "array, which is defined on Index and Series objects only.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "df=pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/hourly_wages.csv')\n",
    "\n",
    "#### Create the encoder.\n",
    "# Create arrays for the features and the response variable\n",
    "y = df['manufacturing'].to_numpy()\n",
    "X = df.drop('manufacturing', axis=1).to_numpy()\n",
    "X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numpy and pandas\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "\n",
    "\n",
    "# Create arrays for features and target variabledf = pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/gm_2008_region.csv')\n",
    "df.shape\n",
    "y = df['life'].to_numpy()\n",
    "X = df['fertility'].to_numpy()\n",
    "\n",
    "# Print the dimensions of X and y before reshaping\n",
    "print(\"Dimensions of y before reshaping: {}\".format(y.shape))\n",
    "print(\"Dimensions of X before reshaping: {}\".format(X.shape))\n",
    "\n",
    "# Reshape X and y\n",
    "y =y.reshape(-1,1)\n",
    "X = X.reshape(-1,1)\n",
    "\n",
    "# Print the dimensions of X and y after reshaping\n",
    "print(\"Dimensions of y after reshaping: {}\".format(y.shape))\n",
    "print(\"Dimensions of X after reshaping: {}\".format(X.shape))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup arrays to store train and test accuracies\n",
    "neighbors = np.arange(1, 9)\n",
    "train_accuracy = np.empty(len(neighbors))\n",
    "test_accuracy = np.empty(len(neighbors))\n",
    "\n",
    "# Loop over different values of k\n",
    "for i, k in enumerate(neighbors):\n",
    "    # Setup a k-NN Classifier with k neighbors: knn\n",
    "    knn = KNeighborsClassifier(n_neighbors=k)\n",
    "\n",
    "    # Fit the classifier to the training data\n",
    "    knn.fit(X_train,y_train)\n",
    "    \n",
    "    #Compute accuracy on the training set\n",
    "    train_accuracy[i] = knn.score(X_train, y_train)\n",
    "\n",
    "    #Compute accuracy on the testing set\n",
    "    test_accuracy[i] = knn.score(X_test,y_test )\n",
    "\n",
    "# Generate plot\n",
    "plt.title('k-NN: Varying Number of Neighbors')\n",
    "plt.plot(neighbors, test_accuracy, label = 'Testing Accuracy')\n",
    "plt.plot(neighbors, train_accuracy, label = 'Training Accuracy')\n",
    "plt.legend()\n",
    "plt.xlabel('Number of Neighbors')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Import necessary modules\n",
    "from  sklearn.metrics import classification_report,confusion_matrix\n",
    "\n",
    "\n",
    "\n",
    "# Create training and test set\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.4,random_state=42)\n",
    "\n",
    "# Instantiate a k-NN classifier: knn\n",
    "knn = KNeighborsClassifier(n_neighbors=6)\n",
    "\n",
    "# Fit the classifier to the training data\n",
    "knn.fit(X_train,y_train)\n",
    "\n",
    "# Predict the labels of the test data: y_pred\n",
    "y_pred = knn.predict(X_test)\n",
    "\n",
    "# Generate the confusion matrix and classification report\n",
    "print(confusion_matrix(y_test, y_pred))\n",
    "print(classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.linear_model import LinearRegression\n",
    "reg = LinearRegression()\n",
    "scores = cross_val_score(reg, X,y,  cv = 5 )\n",
    "print(\"scores : {}\".format(scores))\n",
    "print(\"mean scores :{} \".format(np.mean(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Create a linear regression object: reg\n",
    "reg = LinearRegression()\n",
    "\n",
    "# Perform 3-fold CV\n",
    "%timeit cvscores_3 =cross_val_score(reg,X,y,cv=3)\n",
    "print(np.mean(cvscores_3))\n",
    "\n",
    "# Perform 10-fold CV\n",
    "%timeit cvscores_10 = cross_val_score(reg,X,y,cv=10)\n",
    "print(np.mean(cvscores_10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cvscores_3 = cross_val_score(reg,X,y,cv=3)\n",
    "cvscores_10 = cross_val_score(reg,X,y,cv=10)\n",
    "print(\"meanscore3:{}\".format(np.mean(cvscores_3)))\n",
    "print(\"meanscore10:{}\".format(np.mean(cvscores_10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regularized regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example of a normalization\n",
    "from numpy import asarray\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# define min max scaler\n",
    "scaler = MinMaxScaler()\n",
    "# transform data\n",
    "X = scaler.fit_transform(X)\n",
    "print(X[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.linear_model import Lasso\n",
    "# Instantiate a lasso regressor: lasso\n",
    "lasso = Lasso(alpha=0.4,normalize=True)\n",
    "\n",
    "# Fit the regressor to the data\n",
    "lasso.fit(X,y)\n",
    "\n",
    "# Compute and print the coefficients\n",
    "\n",
    "lasso_coef = lasso.fit(X,y).coef_\n",
    "\n",
    "                      \n",
    "print(lasso_coef)\n",
    "\n",
    "# Plot the coefficients\n",
    "plt.plot(range(len(names)), lasso_coef)\n",
    "plt.xticks(range(len(names)),names, rotation=60)\n",
    "plt.margins(0.02)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Setup the array of alphas and lists to store scores\n",
    "alpha_space = np.logspace(-4, 0, 50)\n",
    "ridge_scores = []\n",
    "ridge_scores_std = []\n",
    "\n",
    "# Create a ridge regressor: ridge\n",
    "ridge = Ridge(normalize=True)\n",
    "def display_plot(cv_scores, cv_scores_std):\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(1,1,1)\n",
    "    ax.plot(alpha_space, cv_scores)\n",
    "\n",
    "    std_error = cv_scores_std / np.sqrt(10)\n",
    "\n",
    "    ax.fill_between(alpha_space, cv_scores + std_error, cv_scores - std_error, alpha=0.2)\n",
    "    ax.set_ylabel('CV Score +/- Std Error')\n",
    "    ax.set_xlabel('Alpha')\n",
    "    ax.axhline(np.max(cv_scores), linestyle='--', color='.5')\n",
    "    ax.set_xlim([alpha_space[0], alpha_space[-1]])\n",
    "    ax.set_xscale('log')\n",
    "    plt.show()\n",
    "# Compute scores over range of alphas\n",
    "for alpha in alpha_space:\n",
    "\n",
    "    # Specify the alpha value to use: ridge.alpha\n",
    "    ridge.alpha = alpha\n",
    "    \n",
    "    # Perform 10-fold CV: ridge_cv_scores\n",
    "    ridge_cv_scores = cross_val_score(ridge,X,y,cv=10)\n",
    "    \n",
    "    # Append the mean of ridge_cv_scores to ridge_scores\n",
    "    ridge_scores.append(np.mean(ridge_cv_scores))\n",
    "    \n",
    "    # Append the std of ridge_cv_scores to ridge_scores_std\n",
    "    ridge_scores_std.append(np.std(ridge_cv_scores))\n",
    "\n",
    "# Display the plot\n",
    "display_plot(ridge_scores, ridge_scores_std)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic regression and the ROC curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the necessary modules\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "# Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state=42)\n",
    "\n",
    "# Create the classifier: logreg\n",
    "logreg = LogisticRegression()\n",
    "\n",
    "# Fit the classifier to the training data\n",
    "\n",
    "logreg.fit(X_train,y_train)\n",
    "# Predict the labels of the test set: y_pred\n",
    "y_pred = logreg.predict(X_test)\n",
    "\n",
    "# Compute and print the confusion matrix and classification report\n",
    "print(confusion_matrix(y_test, y_pred))\n",
    "print(classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from sklearn.metrics import roc_auc_score,roc_curve\n",
    "# Compute predicted probabilities: y_pred_prob\n",
    "y_pred_prob = logreg.predict_proba(X_test)[:,1]\n",
    "# Generate ROC curve values: fpr, tpr, thresholds\n",
    "fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)\n",
    "# Plot ROC curve\n",
    "plt.plot([0, 1], [0, 1], 'k--')\n",
    "plt.plot(fpr, tpr)\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('ROC Curve')\n",
    "plt.show()\n",
    "print(roc_auc_score(y_test, y_pred_prob))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.model_selection import cross_val_score\n",
    "y_predprob= logreg.predict_proba(X_test)[:,1]\n",
    "print('AUC:{}'.format(roc_auc_score(y_test,y_predprob)))\n",
    "cv = cross_val_score(logreg,X_train,y_train,scoring='roc_auc')\n",
    "print(\"aucc for cros val :{}\".format(cv)) \n",
    "print(\"meancv : {}\".format(np.mean(cv)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0_bad  0_good  0_worst\n",
      "0      0       1        0\n",
      "1      1       0        0\n",
      "2      0       0        1\n",
      "3      0       1        0\n",
      "4      0       1        0\n",
      "5      1       0        0\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd \n",
    "# data is from @dzieciou's comment above\n",
    "data =pd.DataFrame(pd.Series(['good','bad','worst','good', 'good', 'bad']))\n",
    "# new_data has two values that data does not have. \n",
    "new_data= pd.DataFrame(pd.Series(['good','bad','worst','good', 'good', 'bad','excellent', 'perfect']))\n",
    "df = pd.get_dummies(data)\n",
    "col_list = df.columns.tolist()\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [0., 0., 1.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import OneHotEncoder\n",
    "encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse=False)\n",
    "encoder.fit(data)\n",
    "encoder.transform(new_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperparameter tuning\n",
    "# Hyperparameter tuning with GridSearchCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "# Setup the hyperparameter grid\n",
    "c_space = np.logspace(-5, 8, 15)\n",
    "param_grid = {'C': c_space}\n",
    "\n",
    "# Instantiate a logistic regression classifier: logreg\n",
    "logreg =LogisticRegression()\n",
    "\n",
    "# Instantiate the GridSearchCV object: logreg_cv\n",
    "logreg_cv = GridSearchCV(logreg, param_grid, cv=5)\n",
    "\n",
    "# Fit it to the data\n",
    "\n",
    "logreg_cv.fit(X,y)\n",
    "# Print the tuned parameters and score\n",
    "print(\"Tuned Logistic Regression Parameters: {}\".format(logreg_cv.best_params_)) \n",
    "print(\"Best score is {}\".format(logreg_cv.best_score_))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# Create the hyperparameter grid\n",
    "c_space = np.logspace(-5, 8, 15)\n",
    "param_grid = {'C': c_space, 'penalty': ['l1', 'l2']}\n",
    "\n",
    "# Instantiate the logistic regression classifier: logreg\n",
    "logreg = LogisticRegression()\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test =train_test_split(X,y,test_size=0.4, random_state= 42)\n",
    "\n",
    "# Instantiate the GridSearchCV object: logreg_cv\n",
    "logreg_cv = GridSearchCV(logreg,param_grid,cv=5)\n",
    "\n",
    "# Fit it to the training data\n",
    "logreg_cv.fit(X_train,y_train)\n",
    "\n",
    "# Print the optimal parameters and best score\n",
    "print(\"Tuned Logistic Regression Parameter: {}\".format(logreg_cv.best_params_))\n",
    "print(\"Tuned Logistic Regression Accuracy: {}\".format(logreg_cv.best_score_))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hold-out set in practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from sklearn.linear_model import ElasticNet\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.4, random_state=42)\n",
    "\n",
    "# Create the hyperparameter grid\n",
    "l1_space = np.linspace(0, 1, 30)\n",
    "param_grid = {'l1_ratio': l1_space}\n",
    "\n",
    "# Instantiate the ElasticNet regressor: elastic_net\n",
    "elastic_net = ElasticNet()\n",
    "\n",
    "# Setup the GridSearchCV object: gm_cv\n",
    "gm_cv = GridSearchCV(elastic_net, param_grid, cv=5)\n",
    "\n",
    "# Fit it to the training data\n",
    "gm_cv.fit(X_train,y_train)\n",
    "# Predict on the test set and compute metrics\n",
    "y_pred = gm_cv.predict(X_test)\n",
    "r2 = gm_cv.score(X_test, y_test)\n",
    "mse = mean_squared_error(y_test, y_pred)\n",
    "print(\"Tuned ElasticNet l1 ratio: {}\".format(gm_cv.best_params_))\n",
    "print(\"Tuned ElasticNet R squared: {}\".format(r2))\n",
    "print(\"Tuned ElasticNet MSE: {}\".format(mse))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperparameter tuning with RandomizedSearchCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from scipy.stats import randint\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "\n",
    "# Setup the parameters and distributions to sample from: param_dist\n",
    "param_dist = {\"max_depth\": [3, None],\n",
    "              \"max_features\": randint(1, 9),\n",
    "              \"min_samples_leaf\": randint(1, 9),\n",
    "              \"criterion\": [\"gini\", \"entropy\"]}\n",
    "\n",
    "# Instantiate a Decision Tree classifier: tree\n",
    "tree = DecisionTreeClassifier()\n",
    "# Instantiate the RandomizedSearchCV object: tree_cv\n",
    "tree_cv = RandomizedSearchCV(tree, param_dist, cv=5)\n",
    "# Fit it to the data\n",
    "tree_cv.fit(X,y)\n",
    "\n",
    "# Print the tuned parameters and score\n",
    "print(\"Tuned Decision Tree Parameters: {}\".format(tree_cv.best_params_))\n",
    "print(\"Best score is {}\".format(tree_cv.best_score_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Piplines\n",
    "https://queirozf.com/entries/scikit-learn-pipeline-examples\n",
    "## Pipeline ,SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the Imputer module\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.svm import SVC \n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import train_test_split\n",
    "# Setup the Imputation transformer: imp\n",
    "imp =  SimpleImputer(missing_values= np.nan, strategy='most_frequent')\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "# Instantiate the SVC classifier: clf\n",
    "clf = SVC()\n",
    "\n",
    "# Setup the pipeline with the required steps: steps\n",
    "steps = [('imputation', imp),\n",
    "         ('scaler',scaler),\n",
    "        ('SVM', clf )]\n",
    "pipline=Pipeline(steps)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.3, random_state = 42)\n",
    "pipline.fit(X_train,y_train)\n",
    "# Predict the labels of the test set\n",
    "y_pred =pipeline.predict(X_test)\n",
    "\n",
    "# Compute metrics\n",
    "print(classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary modules\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [('imputation', SimpleImputer(missing_values= np.nan, strategy='most_frequent')),\n",
    "        ('SVM', SVC())]\n",
    "\n",
    "# Create the pipeline: pipeline\n",
    "pipeline = Pipeline(steps)\n",
    "# Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3, random_state=42)\n",
    "\n",
    "# Fit the pipeline to the train set\n",
    "pipeline.fit(X_train,y_train)\n",
    "\n",
    "# Predict the labels of the test set\n",
    "y_pred =pipeline.predict(X_test)\n",
    "\n",
    "# Compute metrics\n",
    "print(classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pipeline KNN "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [('scaler', StandardScaler()),\n",
    "        ('knn', KNeighborsClassifier())]\n",
    "# Create the pipeline: pipeline\n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=42)\n",
    "\n",
    "# Fit the pipeline to the training set: knn_scaled\n",
    "knn_scaled = pipeline.fit(X_train,y_train)\n",
    "\n",
    "# Instantiate and fit a k-NN classifier to the unscaled data\n",
    "knn_unscaled = KNeighborsClassifier().fit(X_train, y_train)\n",
    "\n",
    "# Compute and print metrics\n",
    "print('Accuracy with Scaling: {}'.format(knn_scaled.score(X_test,y_test)))\n",
    "print('Accuracy without Scaling: {}'.format(knn_unscaled.score(X_test,y_test)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup the pipeline\n",
    "steps = [('scaler', StandardScaler()),\n",
    "         ('SVM', SVC())]\n",
    "\n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Specify the hyperparameter space\n",
    "parameters = {'SVM__C':[1, 10, 100],\n",
    "              'SVM__gamma':[0.1, 0.01]}\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.2,random_state=21)\n",
    "\n",
    "# Instantiate the GridSearchCV object: cv\n",
    "cv = GridSearchCV(pipeline,param_grid=parameters)\n",
    "\n",
    "# Fit to the training set\n",
    "cv.fit(X_train,y_train)\n",
    "\n",
    "# Predict the labels of the test set: y_pred\n",
    "y_pred = cv.predict(X_test)\n",
    "\n",
    "# Compute and print metrics\n",
    "print(\"Accuracy: {}\".format(cv.score(X_test, y_test)))\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(\"Tuned Model Parameters: {}\".format(cv.best_params_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numpy and pandas\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Read the CSV file into a DataFrame: df\n",
    "\n",
    "\n",
    "# Create arrays for features and target variabledf = pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/gm_2008_region.csv')\n",
    "df.shape\n",
    "y = df['life'].to_numpy()\n",
    "X = df['fertility'].to_numpy()\n",
    "\n",
    "# Print the dimensions of X and y before reshaping\n",
    "print(\"Dimensions of y before reshaping: {}\".format(y.shape))\n",
    "print(\"Dimensions of X before reshaping: {}\".format(X.shape))\n",
    "\n",
    "# Reshape X and y\n",
    "y =y.reshape(-1,1)\n",
    "X = X.reshape(-1,1)\n",
    "\n",
    "# Print the dimensions of X and y after reshaping\n",
    "print(\"Dimensions of y after reshaping: {}\".format(y.shape))\n",
    "print(\"Dimensions of X after reshaping: {}\".format(X.shape))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# pipeline steps    ElasticNet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup the pipeline steps: steps\n",
    "steps = [('imputation', SimpleImputer(missing_values=np.nan, strategy='mean')),\n",
    "         ('scaler', StandardScaler()),\n",
    "         ('elasticnet',ElasticNet())]\n",
    "\n",
    "# Create the pipeline: pipeline \n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Specify the hyperparameter space\n",
    "parameters = {'elasticnet__l1_ratio':np.linspace(0,1,30)}\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.4,random_state=42)\n",
    "\n",
    "# Create the GridSearchCV object: gm_cv\n",
    "gm_cv = GridSearchCV(pipeline,param_grid=parameters)\n",
    "\n",
    "# Fit to the training set\n",
    "gm_cv.fit(X_train,y_train)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2 = gm_cv.score(X_test, y_test)\n",
    "print(\"Tuned ElasticNet Alpha: {}\".format(gm_cv.best_params_))\n",
    "print(\"Tuned ElasticNet R squared: {}\".format(r2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "s=[1,2,3]\n",
    "x=s.clear()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pipeline  SelectKBest , RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create pipeline with feature selector and classifier\n",
    "pipe = Pipeline([\n",
    "    ('feature_selection', SelectKBest(f_classif)),\n",
    "    ('clf', RandomForestClassifier(random_state=2))])\n",
    "\n",
    "# Create a parameter grid\n",
    "params = {\n",
    "   'feature_selection__k':[10, 20],\n",
    "   'clf__n_estimators':[2, 5]}\n",
    "\n",
    "# Initialise the grid search object\n",
    "grid_search = GridSearchCV(pipe, param_grid=params)\n",
    "\n",
    "# Fit it to the data and print the best value combination\n",
    "print(grid_search.fit(X_train, y_train).best_params_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Wrapping up your workflow inside a pipeline is a sign of a true professional**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Custom function transformers in pipelines\n",
    "https://stackoverflow.com/questions/50965004/sklearn-custom-transformers-difference-between-using-functiontransformer-and-su"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a feature extractor to flag very large values\n",
    "from sklearn.preprocessing import FunctionTransformer\n",
    "def more_than_average(X, multiplier=1.0):\n",
    "    Z = X.copy()\n",
    "    Z[:,1] = Z[:,1] > multiplier*np.mean(Z[:,1])\n",
    "    return Z\n",
    "\n",
    "# Convert your function so that it can be used in a pipeline\n",
    "pipe = Pipeline([\n",
    "  ('ft', FunctionTransformer(more_than_average)),\n",
    "  ('clf', RandomForestClassifier(random_state=2))])\n",
    "\n",
    "# Optimize the parameter multiplier using GridSearchCV\n",
    "params = {'ft__multiplier':[1, 2, 3]}\n",
    "grid_search = GridSearchCV(pipe, param_grid=params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Complete Pipline and Evaluation \n",
    "https://www.kdnuggets.com/2018/01/managing-machine-learning-workflows-scikit-learn-pipelines-part-3.html\n",
    "https://towardsdatascience.com/pipeline-columntransformer-and-featureunion-explained-f5491f815f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn import svm\n",
    "\n",
    "# Load and split the data\n",
    "iris = load_iris()\n",
    "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)\n",
    "\n",
    "# Construct some pipelines\n",
    "pipe_lr = Pipeline([('scl', StandardScaler()),\n",
    "\t\t\t('clf', LogisticRegression(random_state=42))])\n",
    "\n",
    "pipe_lr_pca = Pipeline([('scl', StandardScaler()),\n",
    "\t\t\t('pca', PCA(n_components=2)),\n",
    "\t\t\t('clf', LogisticRegression(random_state=42))])\n",
    "\n",
    "pipe_rf = Pipeline([('scl', StandardScaler()),\n",
    "\t\t\t('clf', RandomForestClassifier(random_state=42))])\n",
    "\n",
    "pipe_rf_pca = Pipeline([('scl', StandardScaler()),\n",
    "\t\t\t('pca', PCA(n_components=2)),\n",
    "\t\t\t('clf', RandomForestClassifier(random_state=42))])\n",
    "\n",
    "pipe_svm = Pipeline([('scl', StandardScaler()),\n",
    "\t\t\t('clf', svm.SVC(random_state=42))])\n",
    "\n",
    "pipe_svm_pca = Pipeline([('scl', StandardScaler()),\n",
    "\t\t\t('pca', PCA(n_components=2)),\n",
    "\t\t\t('clf', svm.SVC(random_state=42))])\n",
    "\t\t\t\n",
    "# Set grid search params\n",
    "param_range = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "param_range_fl = [1.0, 0.5, 0.1]\n",
    "\n",
    "grid_params_lr = [{'clf__penalty': ['l1', 'l2'],\n",
    "\t\t'clf__C': param_range_fl,\n",
    "\t\t'clf__solver': ['liblinear']}] \n",
    "\n",
    "grid_params_rf = [{'clf__criterion': ['gini', 'entropy'],\n",
    "\t\t'clf__min_samples_leaf': param_range,\n",
    "\t\t'clf__max_depth': param_range,\n",
    "\t\t'clf__min_samples_split': param_range[1:]}]\n",
    "\n",
    "grid_params_svm = [{'clf__kernel': ['linear', 'rbf'], \n",
    "\t\t'clf__C': param_range}]\n",
    "\n",
    "# Construct grid searches\n",
    "jobs = -1\n",
    "\n",
    "gs_lr = GridSearchCV(estimator=pipe_lr,\n",
    "\t\t\tparam_grid=grid_params_lr,\n",
    "\t\t\tscoring='accuracy',\n",
    "\t\t\tcv=10) \n",
    "\t\t\t\n",
    "gs_lr_pca = GridSearchCV(estimator=pipe_lr_pca,\n",
    "\t\t\tparam_grid=grid_params_lr,\n",
    "\t\t\tscoring='accuracy',\n",
    "\t\t\tcv=10)\n",
    "\t\t\t\n",
    "gs_rf = GridSearchCV(estimator=pipe_rf,\n",
    "\t\t\tparam_grid=grid_params_rf,\n",
    "\t\t\tscoring='accuracy',\n",
    "\t\t\tcv=10, \n",
    "\t\t\tn_jobs=jobs)\n",
    "\n",
    "gs_rf_pca = GridSearchCV(estimator=pipe_rf_pca,\n",
    "\t\t\tparam_grid=grid_params_rf,\n",
    "\t\t\tscoring='accuracy',\n",
    "\t\t\tcv=10, \n",
    "\t\t\tn_jobs=jobs)\n",
    "\n",
    "gs_svm = GridSearchCV(estimator=pipe_svm,\n",
    "\t\t\tparam_grid=grid_params_svm,\n",
    "\t\t\tscoring='accuracy',\n",
    "\t\t\tcv=10,\n",
    "\t\t\tn_jobs=jobs)\n",
    "\n",
    "gs_svm_pca = GridSearchCV(estimator=pipe_svm_pca,\n",
    "\t\t\tparam_grid=grid_params_svm,\n",
    "\t\t\tscoring='accuracy',\n",
    "\t\t\tcv=10,\n",
    "\t\t\tn_jobs=jobs)\n",
    "\n",
    "# List of pipelines for ease of iteration\n",
    "grids = [gs_lr, gs_lr_pca, gs_rf, gs_rf_pca, gs_svm, gs_svm_pca]\n",
    "\n",
    "# Dictionary of pipelines and classifier types for ease of reference\n",
    "grid_dict = {0: 'Logistic Regression', 1: 'Logistic Regression w/PCA', \n",
    "\t\t2: 'Random Forest', 3: 'Random Forest w/PCA', \n",
    "\t\t4: 'Support Vector Machine', 5: 'Support Vector Machine w/PCA'}\n",
    "\n",
    "# Fit the grid search objects\n",
    "print('Performing model optimizations...')\n",
    "best_acc = 0.0\n",
    "best_clf = 0\n",
    "best_gs = ''\n",
    "for idx, gs in enumerate(grids):\n",
    "\tprint('\\nEstimator: %s' % grid_dict[idx])\t\n",
    "\t# Fit grid search\t\n",
    "\tgs.fit(X_train, y_train)\n",
    "\t# Best params\n",
    "\tprint('Best params: %s' % gs.best_params_)\n",
    "\t# Best training data accuracy\n",
    "\tprint('Best training accuracy: %.3f' % gs.best_score_)\n",
    "\t# Predict on test data with best params\n",
    "\ty_pred = gs.predict(X_test)\n",
    "\t# Test data accuracy of model with best params\n",
    "\tprint('Test set accuracy score for best params: %.3f ' % accuracy_score(y_test, y_pred))\n",
    "\t# Track best (highest test accuracy) model\n",
    "\tif accuracy_score(y_test, y_pred) > best_acc:\n",
    "\t\tbest_acc = accuracy_score(y_test, y_pred)\n",
    "\t\tbest_gs = gs\n",
    "\t\tbest_clf = idx\n",
    "print('\\nClassifier with best test set accuracy: %s' % grid_dict[best_clf])\n",
    "\n",
    "# Save best grid search pipeline to file\n",
    "dump_file = 'best_gs_pipeline.pkl'\n",
    "joblib.dump(best_gs, dump_file, compress=1)\n",
    "print('\\nSaved %s grid search pipeline to file: %s' % (grid_dict[best_clf], dump_file))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pipeline/GridSearch Deep learing\n",
    "https://machinelearningmastery.com/use-keras-deep-learning-models-scikit-learn-python/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MLP for Pima Indians Dataset with grid search via sklearn\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import numpy\n",
    "\n",
    "# Function to create model, required for KerasClassifier\n",
    "def create_model(optimizer='rmsprop', init='glorot_uniform'):\n",
    "\t# create model\n",
    "\tmodel = Sequential()\n",
    "\tmodel.add(Dense(12, input_dim=8, kernel_initializer=init, activation='relu'))\n",
    "\tmodel.add(Dense(8, kernel_initializer=init, activation='relu'))\n",
    "\tmodel.add(Dense(1, kernel_initializer=init, activation='sigmoid'))\n",
    "\t# Compile model\n",
    "\tmodel.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])\n",
    "\treturn model\n",
    "\n",
    "# fix random seed for reproducibility\n",
    "seed = 7\n",
    "numpy.random.seed(seed)\n",
    "# load pima indians dataset\n",
    "dataset = numpy.loadtxt(\"pima-indians-diabetes.csv\", delimiter=\",\")\n",
    "# split into input (X) and output (Y) variables\n",
    "X = dataset[:,0:8]\n",
    "Y = dataset[:,8]\n",
    "# create model\n",
    "model = KerasClassifier(build_fn=create_model, verbose=0)\n",
    "# grid search epochs, batch size and optimizer\n",
    "optimizers = ['rmsprop', 'adam']\n",
    "init = ['glorot_uniform', 'normal', 'uniform']\n",
    "epochs = [50, 100, 150]\n",
    "batches = [5, 10, 20]\n",
    "param_grid = dict(optimizer=optimizers, epochs=epochs, batch_size=batches, init=init)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid)\n",
    "grid_result = grid.fit(X, Y)\n",
    "# summarize results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "for mean, stdev, param in zip(means, stds, params):\n",
    "\tprint(\"%f (%f) with: %r\" % (mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Evaluation :\n",
    "Tasks\n",
    "1.Evaluate Result\n",
    "\n",
    "2.Review Process\n",
    "\n",
    "3.Determine next steps\n",
    "# Evaluation:\n",
    "\n",
    "1) Use F1-score as the evaluation metric in such cases(highly imbalanced data).\n",
    "\n",
    "2) Use stratified sampling while train_test split.\n",
    "\n",
    "3) Try one vs rest classifier.\n",
    "\n",
    "4) Use algorithms like ,Knn ,Naive baya ,xgboost, lightgbm and catboost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {
    "Deploy.PNG": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deploy Model \n",
    "![Deploy.PNG](attachment:Deploy.PNG)\n",
    "\n",
    "## Pickles\n",
    "Finally, it is time for you to push your first model to production. It is a random forest classifier which you will use as a baseline, while you are still working to develop a better alternative. You have access to the data split in training test with their usual names, X_train, X_test, y_train and y_test, as well as to the modules RandomForestClassifier() and pickle, whose methods .load() and .dump() you will need for this exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit a random forest to the training set\n",
    "clf = RandomForestClassifier(random_state=42).fit(\n",
    "  X_train, y_train)\n",
    "\n",
    "# Save it to a file, to be pushed to production\n",
    "with open('model.pkl', 'wb') as file:\n",
    "    pickle.dump(clf, file=file)\n",
    "\n",
    "# Now load the model from file in the production environment\n",
    "with open('model.pkl', 'rb') as file:\n",
    "    clf_from_file = pickle.load(file)\n",
    "\n",
    "# Predict the labels of the test dataset\n",
    "preds = clf_from_file.predict(X_test)"
   ]
  },
  {
   "attachments": {
    "deploy2.PNG": {
     "image/png": "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"
    },
    "deploy3.PNG": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterating without overfitting\n",
    "![deploy2.PNG](attachment:deploy2.PNG)\n",
    "![deploy3.PNG](attachment:deploy3.PNG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine learning:\n",
    "\n",
    "Ml is a subset of artificial intelligence that uses techniques (such as deep learning) that enable machines to use experience to improve at tasks. The learning process is based on the following steps:\n",
    "\n",
    "    Feed data into an algorithm. (In this step you can provide additional information to the model, for example, by performing feature extraction.)\n",
    "    Use this data to train a model.\n",
    "    Test and deploy the model.\n",
    "    Consume the deployed model to do an automated predictive task. (In other words, call and use the deployed model to receive the predictions returned by the model.)\n",
    "\n",
    "Evaluation:\n",
    "\n",
    "1) Use F1-score as the evaluation metric in such cases(highly imbalanced data).\n",
    "\n",
    "2) Use stratified sampling while train_test split.\n",
    "\n",
    "3) Try one vs rest classifier.\n",
    "\n",
    "4) Use algorithms like ,Knn ,Naive baya ,xgboost, lightgbm and catboost."
   ]
  }
 ],
 "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": 2
}