02_PyCaret_for_Classification_without_Results.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "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.8.5"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/psrana/Machine-Learning-using-PyCaret/blob/main/02_PyCaret_for_Classification_without_Results.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7nQSRI4Dim1Y"
      },
      "source": [
        "---\n",
        "# **PyCaret for Classification**\n",
        "---\n",
        "- It is a bundle of many Machine Learning algorithms.\n",
        "- Only three lines of code is required to compare 20 ML models.\n",
        "- Pycaret is available for:\n",
        "    - Classification\n",
        "    - Regression\n",
        "    - Clustering\n",
        "\n",
        "---\n",
        "\n",
        "### **Self learning resource**\n",
        "1. Tutorial on Pycaret **<a href=\"https://pycaret.readthedocs.io/en/latest/tutorials.html\" target=\"_blank\"> Click Here</a>**\n",
        "\n",
        "2. Documentation on Pycaret-Classification: **<a href=\"https://pycaret.readthedocs.io/en/latest/api/classification.html\" target=\"_blank\"> Click Here </a>**\n",
        "\n",
        "---\n",
        "\n",
        "### **In this tutorial we will learn:**\n",
        "\n",
        "- Getting Data\n",
        "- Setting up Environment\n",
        "- Create Model\n",
        "- Tune Model\n",
        "- Plot Model\n",
        "- Finalize Model\n",
        "- Predict Model\n",
        "- Save / Load Model\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A30y-VtNim1h"
      },
      "source": [
        "### **(a) Install Pycaret**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cF_mSA9Xim1j"
      },
      "source": [
        "!pip install pycaret &> /dev/null\n",
        "print (\"Pycaret installed sucessfully!!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjvBYy0Lim1m"
      },
      "source": [
        "### **(b) Get the version of the pycaret**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NHB2KMhZim1o"
      },
      "source": [
        "from pycaret.utils import version\n",
        "version()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BTLd3s--im1c"
      },
      "source": [
        "---\n",
        "# **1. Classification: Basics**\n",
        "---\n",
        "### **1.1 Get the list of datasets available in pycaret (Total Datasets = 55)**\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "veBU-f21im1x"
      },
      "source": [
        "from pycaret.datasets import get_data\n",
        "dataSets = get_data('index')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nRWYsJNVim1z"
      },
      "source": [
        "---\n",
        "### **1.2 Get the \"diabetes\" dataset (Step-I)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "41abL1k-im10",
        "scrolled": true
      },
      "source": [
        "diabetesDataSet = get_data(\"diabetes\")    # SN is 7"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E3BNV7YLim12"
      },
      "source": [
        "---\n",
        "### **1.3 Parameter setting for all models (Step-II)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c6KthRB9im14"
      },
      "source": [
        "from pycaret.classification import *\n",
        "s = setup(data=diabetesDataSet, target='Class variable')\n",
        "\n",
        "# Other Parameters:\n",
        "# train_size = 0.7\n",
        "# data_split_shuffle = False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kaevs6ROim18"
      },
      "source": [
        "---\n",
        "### **1.4 Run all models (Step-III)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XmPJbrOXim19"
      },
      "source": [
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w8BLSpegim1_"
      },
      "source": [
        "---\n",
        "### **1.5 \"Three line of code\" for model comparison for \"Diabetes\" dataset**\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QPY6bvTsim1_"
      },
      "source": [
        "from pycaret.datasets import get_data\n",
        "from pycaret.classification import *\n",
        "\n",
        "diabetesDataSet = get_data(\"diabetes\")\n",
        "setup(data=diabetesDataSet, target='Class variable')\n",
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kI--n6yWS6Lf"
      },
      "source": [
        "---\n",
        "### **1.6 \"Three line of code\" for model comparison for \"Cancer\" dataset**\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2T2emn2NS6Li"
      },
      "source": [
        "from pycaret.datasets import get_data\n",
        "from pycaret.classification import *\n",
        "\n",
        "cancerDataSet = get_data(\"cancer\")\n",
        "setup(data = cancerDataSet, target='Class')\n",
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9GWuAHd7xQ8i"
      },
      "source": [
        "---\n",
        "# **2. Classification: working with user dataset**\n",
        "---\n",
        "### **2.1 Download the \"diabetes\" dataset to local system**\n",
        "---\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ztv-AJdmhcf",
        "scrolled": true
      },
      "source": [
        "diabetesDataSet.to_csv(\"diabetesDataSet.csv\", index=False)\n",
        "\n",
        "from google.colab import files\n",
        "files.download('diabetesDataSet.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uQ9VggJSV0ZM"
      },
      "source": [
        "---\n",
        "### **2.2 Uploading \"user file\" from user system**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PDSIpXdjvy-8"
      },
      "source": [
        "from google.colab import files\n",
        "files.upload()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tQedmJ0z3xUR"
      },
      "source": [
        "---\n",
        "### **2.3 \"Read\" the uploaded file**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7pOZaoTA1W5H"
      },
      "source": [
        "import pandas as pd\n",
        "myDataSet = pd.read_csv('diabetesDataSet (1).csv')\n",
        "myDataSet.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cSRq3n5NxiNW"
      },
      "source": [
        "---\n",
        "### **2.4 \"Compare\" the model performance**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u2FyeWBWxQ8j"
      },
      "source": [
        "from pycaret.classification import *\n",
        "\n",
        "setup(data = myDataSet, target='Class variable')\n",
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D9Y1VxIsFuqn"
      },
      "source": [
        "---\n",
        "### **2.5 \"Three line of code\" for model comparison for \"user dataset**\n",
        "\n",
        "##### Use it, while working on **\"Anaconda/Jupyter notebook\"** on local machine\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FPiBWwaAFuqp"
      },
      "source": [
        "from pycaret.classification import *\n",
        "import pandas as pd\n",
        "\n",
        "#myDataSet = pd.read_csv(\"myData.csv\")\n",
        "#s = setup(data = myDataSet, target='cancer')\n",
        "#cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zUfHO4wKim1_"
      },
      "source": [
        "---\n",
        "# **3. Classification: Apply \"Data Preprocessing\"**\n",
        "---\n",
        "\n",
        "### **3.1 Model performance using \"Normalization\"**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Atd6jNvmim2A"
      },
      "source": [
        "setup(data=diabetesDataSet, target='Class variable',\n",
        "      normalize = True, normalize_method = 'zscore')\n",
        "cm = compare_models()\n",
        "\n",
        "#normalize_method = {zscore, minmax, maxabs, robust}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oWMPU3KMim2B"
      },
      "source": [
        "---\n",
        "### **3.2 Model performance using \"Feature Selection\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "43l42fj_im2C"
      },
      "source": [
        "setup(data=diabetesDataSet, target='Class variable',\n",
        "      feature_selection = True, feature_selection_method = 'classic')\n",
        "cm = compare_models()\n",
        "\n",
        "#feature_selection_method = {classic, univariate, sequential}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kt034D2wim2C"
      },
      "source": [
        "---\n",
        "### **3.3 Model performance using \"Outlier Removal\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oAaDhJctim2D"
      },
      "source": [
        "setup(data=diabetesDataSet, target='Class variable',\n",
        "      remove_outliers = True, outliers_threshold = 0.05)\n",
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tp1zLWiFim2D"
      },
      "source": [
        "---\n",
        "### **3.4 Model performance using \"Transformation\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TAe7byNYim2D"
      },
      "source": [
        "setup(data=diabetesDataSet, target='Class variable',\n",
        "      transformation = True, transformation_method = 'yeo-johnson')\n",
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9IIR2eMyim2E"
      },
      "source": [
        "---\n",
        "### **3.5 Model performance using \"PCA\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IbRChxn3im2E"
      },
      "source": [
        "setup(data=diabetesDataSet, target='Class variable',\n",
        "      pca = True, pca_method = 'linear')\n",
        "cm = compare_models()\n",
        "#pca_method = {linear, kernel, incremental}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5KwCI6ZkAFMx"
      },
      "source": [
        "---\n",
        "### **3.6 Model performance using \"Outlier Removal\" + \"Normalization\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9XFmW3nyAFM2"
      },
      "source": [
        "setup(data=diabetesDataSet, target='Class variable',\n",
        "      remove_outliers = True, outliers_threshold = 0.05,\n",
        "      normalize = True, normalize_method = 'zscore')\n",
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Awx0XwltEvn"
      },
      "source": [
        "---\n",
        "### **3.7 Model performance using \"Outlier Removal\" +  \"Normalization\" + \"Transformation\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qoSbD33ktEvw"
      },
      "source": [
        "setup(data=diabetesDataSet, target='Class variable',\n",
        "      remove_outliers = True, outliers_threshold = 0.05,\n",
        "      normalize = True, normalize_method = 'zscore',\n",
        "      transformation = True, transformation_method = 'yeo-johnson')\n",
        "cm = compare_models()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CvrwTU8iuLM6"
      },
      "source": [
        "---\n",
        "### **3.8 Explore more parameters of \"setup()\" on pycaret**\n",
        "---\n",
        "- Explore setup() paramaeters in **Step 1.3**\n",
        "- **<a href=\"https://pycaret.readthedocs.io/en/latest/api/classification.html\" target=\"_blank\"> Click Here</a>** for more"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tiTcc636im2F"
      },
      "source": [
        "---\n",
        "# **4. Classification: More Operations**\n",
        "---\n",
        "### **4.1 Build a single model - \"RandomForest\"**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DxkGGGthim2G"
      },
      "source": [
        "from pycaret.datasets import get_data\n",
        "from pycaret.classification import *\n",
        "\n",
        "diabetesDataSet = get_data(\"diabetes\")\n",
        "setup(data=diabetesDataSet, target='Class variable')\n",
        "\n",
        "rfModel = create_model('rf')\n",
        "# Explore more parameters"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6zi9OUp0im2G"
      },
      "source": [
        "---\n",
        "### **4.2 Other available classification models**\n",
        "---\n",
        "-\t'ada' -\tAda Boost Classifier\n",
        "-\t'dt' -\tDecision Tree Classifier\n",
        "-\t'et' -\tExtra Trees Classifier\n",
        "-\t'gbc' -\tGradient Boosting Classifier\n",
        "-\t'knn' -\tK Neighbors Classifier\n",
        "-\t'lightgbm' -\tLight Gradient Boosting Machine\n",
        "-\t'lda' -\tLinear Discriminant Analysis\n",
        "-\t'lr' -\tLogistic Regression\n",
        "-\t'nb' -\tNaive Bayes\n",
        "-\t'qda' -\tQuadratic Discriminant Analysis\n",
        "-\t'rf' -\tRandom Forest Classifier\n",
        "-\t'ridge' -\tRidge Classifier\n",
        "-\t'svm' -\tSVM - Linear Kernel"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SOgkFMblyyhB"
      },
      "source": [
        "---\n",
        "### **4.3 Explore more parameters of \"create_model()\" on pycaret**\n",
        "---\n",
        "\n",
        "**<a href=\"https://pycaret.readthedocs.io/en/latest/api/classification.html#pycaret.classification.create_model\" target=\"_blank\"> Click Here</a>**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbQmlQYcim2L"
      },
      "source": [
        "---\n",
        "### **4.4 Make prediction on the \"new unseen dataset\"**\n",
        "---\n",
        "#### **Get the \"new unseen dataset\"**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ukwXEWlAim2O"
      },
      "source": [
        "# Select top 10 rows from diabetes dataset\n",
        "newDataSet = get_data(\"diabetes\").iloc[:10]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lL8CWgH3im2P"
      },
      "source": [
        "#### **Make prediction on \"new unseen dataset\"**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nk-dR5Fhim2P"
      },
      "source": [
        "newPredictions = predict_model(rfModel, data = newDataSet)\n",
        "newPredictions"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "McwAM2j7im2R"
      },
      "source": [
        "---\n",
        "### **4.5 \"Save\" and \"Download\" the prediction result**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-RXICkjAim2R"
      },
      "source": [
        "newPredictions.to_csv(\"NewPredictions.csv\", index=False)\n",
        "\n",
        "from google.colab import files\n",
        "files.download('NewPredictions.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dk9htsA9im2H"
      },
      "source": [
        "---\n",
        "### **4.6 \"Save\" the trained model**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "997MLzZGim2H"
      },
      "source": [
        "sm = save_model(rfModel, 'rfModelFile')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lrbcsSdhAJOz"
      },
      "source": [
        "---\n",
        "### **4.7 Download the \"trained model file\" to user local system**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gDweanHp_DXB"
      },
      "source": [
        "from google.colab import files\n",
        "files.download('rfModelFile.pkl')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZHQ7kF2im2I"
      },
      "source": [
        "---\n",
        "### **4.8  \"Upload the trained model\" --> \"Load the model\"  --> \"Make the prediction\" on \"new unseen dataset\"**\n",
        "---\n",
        "### **4.8.1 Upload the  \"Trained Model\"**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7GEpSv5YMN0b"
      },
      "source": [
        "from google.colab import files\n",
        "files.upload()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MVGmLPxpMHF1"
      },
      "source": [
        "---\n",
        "### **4.8.2 Load the \"Model\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q15mq4tcim2J"
      },
      "source": [
        "rfModel = load_model('rfModelFile (1)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Br8cNWiaMf0P"
      },
      "source": [
        "---\n",
        "### **4.8.3 Make the prediction on \"new unseen dataset\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ymYG7gs8Mf0Q"
      },
      "source": [
        "newPredictions = predict_model(rfModel, data = newDataSet)\n",
        "newPredictions"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tvnzKUXKim2R"
      },
      "source": [
        "---\n",
        "# **5. Plot the trained model**\n",
        "---\n",
        "**Following parameters can be plot for a trained model**\n",
        "*   Area Under the Curve         - 'auc'\n",
        "*   Discrimination Threshold     - 'threshold'\n",
        "*   Precision Recall Curve       - 'pr'\n",
        "*   Confusion Matrix             - 'confusion_matrix'\n",
        "*   Class Prediction Error       - 'error'\n",
        "*   Classification Report        - 'class_report'\n",
        "*   Decision Boundary            - 'boundary'\n",
        "*   Recursive Feat. Selection    - 'rfe'\n",
        "*   Learning Curve               - 'learning'\n",
        "*   Manifold Learning            - 'manifold'\n",
        "*   Calibration Curve            - 'calibration'\n",
        "*   Validation Curve             - 'vc'\n",
        "*   Dimension Learning           - 'dimension'\n",
        "*   Feature Importance           - 'feature'\n",
        "*   Model Hyperparameter         - 'parameter'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3V830Svhim2R"
      },
      "source": [
        "---\n",
        "### **5.1 Create RandomForest model or any other model**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H0c__zBjim2S"
      },
      "source": [
        "rfModel = create_model('rf')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-RuUMIm2im2S"
      },
      "source": [
        "---\n",
        "### **5.2 Create \"Confusion Matrix\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cDcFbCCGim2T"
      },
      "source": [
        "plot_model(rfModel, plot='confusion_matrix')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tTHlyeJFim2U"
      },
      "source": [
        "---\n",
        "### **5.3 Plot the \"learning curve\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AArgjedYim2U"
      },
      "source": [
        "plot_model(rfModel, plot='learning')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OXdNdg6I-0T3"
      },
      "source": [
        "---\n",
        "### **5.4 Plot the \"AUC Curve\" (Area Under the Curve)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xicye76Bim2V"
      },
      "source": [
        "plot_model(rfModel, plot='auc')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pM4I5nUemXWx"
      },
      "source": [
        "---\n",
        "### **5.5 Plot the \"Decision Boundary\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0NbDzbRRmXW7"
      },
      "source": [
        "plot_model(rfModel, plot='boundary')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eUXaDeoL4mlw"
      },
      "source": [
        "---\n",
        "### **5.6 Get the model \"parameters\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GpfVxNKA4ml3"
      },
      "source": [
        "plot_model(rfModel, plot='parameter')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A8EhMMY7tL15"
      },
      "source": [
        "---\n",
        "### **5.7 Explore the more parameters of \"plot_model()\" on pycaret**\n",
        "---\n",
        "**<a href=\"https://pycaret.readthedocs.io/en/latest/api/classification.html#pycaret.classification.plot_model\" target=\"_blank\"> Click Here </a>**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AsVAOsgc_LbO"
      },
      "source": [
        "---\n",
        "# **6. Feature Importance**\n",
        "---\n",
        "### **6.1 Feature Importance using \"Random Forest\"**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f9OQ4GiGim2W"
      },
      "source": [
        "rfModel = create_model('rf', verbose=False)\n",
        "plot_model(rfModel, plot='feature')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bAQByaGaim2X"
      },
      "source": [
        "---\n",
        "### **6.2 Feature Importance using \"Extra Trees Regressor\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U7FxbMp01sBB"
      },
      "source": [
        "etModel = create_model('et', verbose=False)\n",
        "plot_model(etModel, plot='feature')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3SrR7evnim2X"
      },
      "source": [
        "---\n",
        "### **6.3 Feature Importance using \"Decision Tree\"**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rrLpEocF1upC"
      },
      "source": [
        "dtModel = create_model('dt', verbose=False)\n",
        "plot_model(dtModel, plot='feature')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eoYnuzrcLDx4"
      },
      "source": [
        "---\n",
        "# **7. Tune/Optimize the model performance**\n",
        "---\n",
        "### **7.1 Train \"Decision Tree\" with default parameters**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "itaCP4yPLDx-"
      },
      "source": [
        "dtModel = create_model('dt')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KBWk2aKyLDyA"
      },
      "source": [
        "#### **Get the \"parameters\" of Decision Tree**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Je3ABt9cLDyC"
      },
      "source": [
        "plot_model(dtModel, plot='parameter')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W0TsqU0QLDyD"
      },
      "source": [
        "---\n",
        "### **7.2 Tune \"Decision Tree\" model**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ugxaxz0oLDyE"
      },
      "source": [
        "dtModelTuned = tune_model(dtModel, n_iter=50)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "khusRJwOQc0K"
      },
      "source": [
        "#### **Get the \"tuned parameters\" of Decision Tree**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1x3FC2eeQc0L"
      },
      "source": [
        "plot_model(dtModelTuned, plot='parameter')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FPtPrnT-Q-z1"
      },
      "source": [
        "---\n",
        "### **7.3 Explore more parameters of \"tune_model()\" on pycaret**\n",
        "---\n",
        "**<a href=\"https://pycaret.readthedocs.io/en/latest/api/classification.html#pycaret.classification.tune_model\" target=\"_blank\"> Click Here </a>**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hICikRsyim2Z"
      },
      "source": [
        "---\n",
        "# **8. AutoML - Advanced Machine Learning**\n",
        "---\n",
        "\n",
        "- Select n Best Models:\n",
        "  - Ensemble, Stacking, Begging, Blending\n",
        "  - Auto tune the best n models\n",
        "\n",
        "**<a href=\"https://pycaret.readthedocs.io/en/latest/api/classification.html#pycaret.classification.automl\" target=\"_blank\">Click Here</a>**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UUUyTVy-Q6PY"
      },
      "source": [
        "---\n",
        "# **9. Deploy the model on AWS / Azure**\n",
        "---\n",
        "**<a href=\"https://pycaret.readthedocs.io/en/latest/api/classification.html#pycaret.classification.deploy_model\" target=\"_blank\">Click Here</a>**"
      ]
    }
  ]
}