final_deeplearningmodel(1_5)gitfor_finding_hyper.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "12RLIRCih6lbl3SCk4qms1MAsWN2Rq9c6",
      "authorship_tag": "ABX9TyMRYQ2guyJzK4U8Xy0SFkbW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/josmyrose/project/blob/main/final_deeplearningmodel(1_5)gitfor_finding_hyper.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#1.Business probelm statement"
      ],
      "metadata": {
        "id": "nGfN3NO5fWrq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.1 Build an end to end deeplearning model to predict individual health cost"
      ],
      "metadata": {
        "id": "B944Oh_zwzvC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now a days the overall cost of healthcare services continues to rise, which can directly impact health insurance premiums. As healthcare costs increase, individuals may worry about their ability to afford necessary treatments, medications, or preventive care.The health insurance company named HEALTHPREMIUM appointed me as a Data Scientist.They need to predict the health insurance cost of a person who lives in USA and based on the analysis they want to increase the health premium.\n",
        "\n",
        "Research can be conducted specifically on how these factors interact and affect health insurance costs. This information is essential for improving insurance policy design and outcomes in this increasingly important sector of healthcare.\n",
        "\n"
      ],
      "metadata": {
        "id": "BNfOHnUTff3g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dataset is insurance dataset."
      ],
      "metadata": {
        "id": "Qi4oS64Jhq-e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "These factors include aspects such as age, gender, body mass index (BMI), number of children, smoking status, and region of the person lives in USA"
      ],
      "metadata": {
        "id": "md6wKz19iZpt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Descritption about the features of the dataset\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "age: age of primary beneficiary\n",
        "\n",
        "sex: insurance contractor gender, female, male\n",
        "\n",
        "bmi: Body mass index, providing an understanding of body, weights that are relatively high or low relative to height,\n",
        "objective index of body weight (kg / m ^ 2) using the ratio of height to weight, ideally 18.5 to 24.9\n",
        "\n",
        "children: Number of children covered by health insurance / Number of dependents\n",
        "\n",
        "smoker: Smoking\n",
        "\n",
        "region: the beneficiary's residential area in the US, northeast, southeast, southwest, northwest.\n",
        "\n",
        "charges: Individual medical costs billed by health insurance\n",
        "(www.kaggle.com, n.d.)"
      ],
      "metadata": {
        "id": "ZsyoZDqpm4Pp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this dataset,Charges are target variable and all other variables are independent variable."
      ],
      "metadata": {
        "id": "p6yjN-ub6KiQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Import necessary libraries"
      ],
      "metadata": {
        "id": "XQzyqKbTsTL8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xnIAyl6_sNw1"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "# Import Visualization libraries\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.model_selection import train_test_split\n",
        "from tensorflow.keras.optimizers.legacy import Adam\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.preprocessing import OneHotEncoder, StandardScaler\n",
        "from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV, learning_curve\n",
        "#Perception model\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense\n",
        "from sklearn.linear_model import Perceptron\n",
        "from sklearn.metrics import accuracy_score"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "I have loaded the dataset from kaggle.The link for the dataset is \" https://www.kaggle.com/datasets/mirichoi0218/insurance?select=insurance.csv.\".When I run the code which contains the URL of the dataset,it will not work properly.So I uploaded the dataset into google drive and it is working properly.\n",
        "\n",
        "Read the dataset into python enviornment using URL"
      ],
      "metadata": {
        "id": "O6rOZYK5yCsQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df3=pd.read_csv(' https://www.kaggle.com/datasets/mirichoi0218/insurance?select=insurance.csv.',on_bad_lines='skip')"
      ],
      "metadata": {
        "id": "6SfhkjOay9ps"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Read the dataset into python environment from google drive."
      ],
      "metadata": {
        "id": "F0dp_H0GzHlg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df=pd.read_csv('/content/drive/MyDrive/semester 2/Term1/prediction assessment/insurance.csv')"
      ],
      "metadata": {
        "id": "pi5JRNL6szxM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code give the  information about the column names, data types, and the number of non-null values present in each column. By calling this method, you can obtain a concise overview of you insurance DataFrame."
      ],
      "metadata": {
        "id": "_7stEGZetUYm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oBsS6IbvtP58",
        "outputId": "7d25d26a-eb76-4498-a84d-872d198d663f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 1338 entries, 0 to 1337\n",
            "Data columns (total 7 columns):\n",
            " #   Column    Non-Null Count  Dtype  \n",
            "---  ------    --------------  -----  \n",
            " 0   age       1338 non-null   int64  \n",
            " 1   sex       1338 non-null   object \n",
            " 2   bmi       1338 non-null   float64\n",
            " 3   children  1338 non-null   int64  \n",
            " 4   smoker    1338 non-null   object \n",
            " 5   region    1338 non-null   object \n",
            " 6   charges   1338 non-null   float64\n",
            "dtypes: float64(2), int64(2), object(3)\n",
            "memory usage: 73.3+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code df.head() is called to show the first five rows of the DataFrame df. It provides a quick way to preview the structure and contents of the DataFrame."
      ],
      "metadata": {
        "id": "oInfXqOKzRWN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "J2-hg44TGzbh",
        "outputId": "d71f0177-b3d5-43c3-8158-48455f177b9c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   age     sex     bmi  children smoker     region      charges\n",
              "0   19  female  27.900         0    yes  southwest  16884.92400\n",
              "1   18    male  33.770         1     no  southeast   1725.55230\n",
              "2   28    male  33.000         3     no  southeast   4449.46200\n",
              "3   33    male  22.705         0     no  northwest  21984.47061\n",
              "4   32    male  28.880         0     no  northwest   3866.85520"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-dd29326c-0629-448e-8553-b3cfd0f112a9\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>sex</th>\n",
              "      <th>bmi</th>\n",
              "      <th>children</th>\n",
              "      <th>smoker</th>\n",
              "      <th>region</th>\n",
              "      <th>charges</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>19</td>\n",
              "      <td>female</td>\n",
              "      <td>27.900</td>\n",
              "      <td>0</td>\n",
              "      <td>yes</td>\n",
              "      <td>southwest</td>\n",
              "      <td>16884.92400</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>18</td>\n",
              "      <td>male</td>\n",
              "      <td>33.770</td>\n",
              "      <td>1</td>\n",
              "      <td>no</td>\n",
              "      <td>southeast</td>\n",
              "      <td>1725.55230</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>28</td>\n",
              "      <td>male</td>\n",
              "      <td>33.000</td>\n",
              "      <td>3</td>\n",
              "      <td>no</td>\n",
              "      <td>southeast</td>\n",
              "      <td>4449.46200</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>33</td>\n",
              "      <td>male</td>\n",
              "      <td>22.705</td>\n",
              "      <td>0</td>\n",
              "      <td>no</td>\n",
              "      <td>northwest</td>\n",
              "      <td>21984.47061</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>32</td>\n",
              "      <td>male</td>\n",
              "      <td>28.880</td>\n",
              "      <td>0</td>\n",
              "      <td>no</td>\n",
              "      <td>northwest</td>\n",
              "      <td>3866.85520</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-dd29326c-0629-448e-8553-b3cfd0f112a9')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-dd29326c-0629-448e-8553-b3cfd0f112a9 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-dd29326c-0629-448e-8553-b3cfd0f112a9');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check whether the dataset contains any null values"
      ],
      "metadata": {
        "id": "_pl4A_x8hzmA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.isnull().sum()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z93zbyeSRUru",
        "outputId": "e0d215ba-b883-41ae-a44e-19575e1ef7ba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "age         0\n",
              "sex         0\n",
              "bmi         0\n",
              "children    0\n",
              "smoker      0\n",
              "region      0\n",
              "charges     0\n",
              "dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The dataset does not contain null values."
      ],
      "metadata": {
        "id": "3rCXBzH2iHAo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.DATA EXPLORATORY"
      ],
      "metadata": {
        "id": "wcc8UXiwjcrl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check whether the dataset conatins any duplicated values\n",
        "duplicate_n = df[df.duplicated()]\n",
        "print(\"number of duplicate rows:\\n \", duplicate_n.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hYZqKMl_jjWP",
        "outputId": "cd84ce30-9310-4a70-b1a3-e4b8c13fa65d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "number of duplicate rows:\n",
            "  (1, 7)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The above result indicates that dataset contains one duplicated row.The following code is used for drop the duplicated row from the dataset."
      ],
      "metadata": {
        "id": "gxI0NqRakGSr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df=df.drop_duplicates()#drop the duplicated rows from the dataset"
      ],
      "metadata": {
        "id": "L3E1YxrMkalZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code give the count the number of distinct values"
      ],
      "metadata": {
        "id": "EcpOdhdYWMdb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Loop through each column and count the number of distinct values\n",
        "for col in df.columns:\n",
        "    num_dist = len(df[col].unique())\n",
        "    print(f\"{col}: {num_dist} distinct values\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DHrrjnTb0vZb",
        "outputId": "be2c0db8-8548-493e-c04d-9ac849ad6eba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "age: 47 distinct values\n",
            "sex: 2 distinct values\n",
            "bmi: 548 distinct values\n",
            "children: 6 distinct values\n",
            "smoker: 2 distinct values\n",
            "region: 4 distinct values\n",
            "charges: 1337 distinct values\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following graph depicts that the person who smoke having higher medical charge and person who do not smoke having less medical charge.\n",
        "I have done different bivariate analysis such as age vs charge,BMI vs charge etc.\n",
        "From this,I understood that medical cahrge is directly related with BMI and age.The persons from different regions of USA almost have same medical charges."
      ],
      "metadata": {
        "id": "KNuTfv0h6ktU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualization : Box plot of charges grouped by smoker vs. non-smoker\n",
        "plt.figure(figsize=(6,8))\n",
        "sns.boxplot(data=df, x='smoker', y='charges')\n",
        "plt.xlabel('Smoker')\n",
        "plt.ylabel('Charges')\n",
        "plt.title('Charges Distribution by Smoker')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 718
        },
        "id": "68bOTW136Dqs",
        "outputId": "9a22357b-e151-4330-bcab-b6b44be653f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3.Split the dataset into train,test and validation dataset"
      ],
      "metadata": {
        "id": "Hg6aS18yr56H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#here the dataset is split into target and independent variable.\n",
        "X=df.drop(['charges'],axis=1)#X is independent varaibles\n",
        "#y=df['charges']\n",
        "y = df['charges'].astype('int')#y is target variable"
      ],
      "metadata": {
        "id": "oBeIcD_UVm6K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#The following code split the dataset into train and X_split dataset.80% of the data is allocated to the temporary train set (X_train, y_train), and the remaining 20% is allocated to the holdout set (X_split, y_split).\n",
        "X_train,X_split,y_train, y_split = train_test_split(X,y,test_size=0.2, random_state=42)"
      ],
      "metadata": {
        "id": "3goDbiRvr_83"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**split set into the test set and validation set:**\n"
      ],
      "metadata": {
        "id": "_lWFS20fuhIM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#here the split dataset is divided into test set and validation dataset.\n",
        "X_test, X_val, y_test, y_val = train_test_split(X_split,y_split, test_size=0.5, random_state=42)\n"
      ],
      "metadata": {
        "id": "kxHerz94te0R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Display the size of train,test dataset and validation dataset.\n",
        "print(\"The size of  train dataset\",X_train.shape)\n",
        "print(\"The size of test dataset\",X_test.shape)\n",
        "print(\"The size of validation dataset\",X_val.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X0ZhE6S1vw0V",
        "outputId": "1c709563-9a8b-4042-f8b5-922e46a63c95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The size of  train dataset (1069, 6)\n",
            "The size of test dataset (134, 6)\n",
            "The size of validation dataset (134, 6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.DATA PREPROCESSING: LABEL ENCODING and SCALING"
      ],
      "metadata": {
        "id": "cgUkRj3R99I8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "I encode the categorical variables such as 'sex','smoker','region' using one hot encoder.\n",
        " The StandardScaler is used to standardize the numerical features in the DataFrame df. The fit_transform() method is used to compute the mean and standard deviation of each feature and transform the data accordingly. The resulting scaled data is then converted back to a DataFrame X_train_transformed_data for display.\n",
        "\n",
        "By standardizing the features, the values are transformed to have zero mean and unit variance. This helps in cases where features have different scales, preventing any single feature from dominating the learning process or affecting the results of certain algorithms that are sensitive to the scale of the input data.\n",
        "The scaling is done for test dataset,train dataset and validation dataset separately."
      ],
      "metadata": {
        "id": "QgUaAL669mPs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the columns to apply encodings\n",
        "categorical_columns =['sex','smoker','region']\n",
        "numerical_columns =['age','bmi','children']\n",
        "# Define the encoders for different column types\n",
        "categorical_encoder = OneHotEncoder()\n",
        "numerical_scaler = StandardScaler()\n",
        "\n",
        "# Create the ColumnTransformer\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('cat', categorical_encoder,categorical_columns),\n",
        "        ('num', numerical_scaler,numerical_columns)\n",
        "    ])\n",
        "\n",
        "# Apply the preprocessing steps to train  dataset\n",
        "X_train_transformed_data=preprocessor.fit_transform(X_train)\n",
        "# Apply the preprocessing steps to test  dataset\n",
        "X_test_transformed_data=preprocessor.fit_transform(X_test)\n",
        "# Apply the preprocessing steps to validation  dataset\n",
        "X_val_transformed_data=preprocessor.fit_transform(X_val)\n"
      ],
      "metadata": {
        "id": "zSD_vPlawRR8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "SCALING OF TARGET VARIABLE"
      ],
      "metadata": {
        "id": "DzKhj1zd6uWd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Apply standard scaling to the target variable\n",
        "y_scaler = StandardScaler()\n",
        "y_train=np.array([y_train])\n",
        "y_train_scaled= y_scaler.fit_transform(y_train.reshape(-1, 1)).flatten()\n",
        "y_train_scaled =y_train_scaled.reshape(-1, 1)\n",
        "y_test=np.array([y_test])\n",
        "y_test_scaled= y_scaler.fit_transform(y_test.reshape(-1, 1)).flatten()\n",
        "y_test_scaled =y_test_scaled.reshape(-1, 1)\n",
        "y_val=np.array([y_val])\n",
        "y_val_scaled= y_scaler.fit_transform(y_val.reshape(-1, 1)).flatten()\n",
        "y_val_scaled =y_val_scaled.reshape(-1, 1)\n"
      ],
      "metadata": {
        "id": "R4QCf7amWPGS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.Sequential([\n",
        "    tf.keras.layers.Dense(32, activation='relu', input_shape=(X_train_transformed_data.shape[1],)),\n",
        "    tf.keras.layers.Dense(16, activation='relu'),\n",
        "    tf.keras.layers.Dense(1)\n",
        "])\n"
      ],
      "metadata": {
        "id": "LQzn0kU25mxw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile the model\n",
        "model.compile(loss='mean_squared_error', optimizer='adam')\n",
        "\n",
        "# Train the model\n",
        "model.fit(X_test_transformed_data,y_test_scaled, epochs=100, batch_size=32, verbose=1,validation_data=(X_val_transformed_data,y_val_scaled))\n",
        "\n",
        "# Evaluate the model\n",
        "mse = model.evaluate(X_test_transformed_data,y_test_scaled, verbose=0)\n",
        "print('Mean Squared Error:', mse)\n",
        "\n",
        "\n",
        "# Evaluate the model\n",
        "#mse = model.evaluate(X_test_scaled, y_test, verbose=0)\n",
        "#print('Mean Squared Error:', mse)\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O4zRTIHYbGUN",
        "outputId": "32f95c7b-004a-4497-f29a-897a3b27b087"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "5/5 [==============================] - 1s 52ms/step - loss: 1.1629 - val_loss: 1.0431\n",
            "Epoch 2/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 1.0325 - val_loss: 0.9592\n",
            "Epoch 3/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.9423 - val_loss: 0.8983\n",
            "Epoch 4/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.8697 - val_loss: 0.8529\n",
            "Epoch 5/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.8118 - val_loss: 0.8168\n",
            "Epoch 6/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.7647 - val_loss: 0.7838\n",
            "Epoch 7/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.7195 - val_loss: 0.7551\n",
            "Epoch 8/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.6772 - val_loss: 0.7236\n",
            "Epoch 9/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.6375 - val_loss: 0.6929\n",
            "Epoch 10/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.6009 - val_loss: 0.6595\n",
            "Epoch 11/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.5641 - val_loss: 0.6287\n",
            "Epoch 12/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.5304 - val_loss: 0.5942\n",
            "Epoch 13/100\n",
            "5/5 [==============================] - 0s 12ms/step - loss: 0.4951 - val_loss: 0.5622\n",
            "Epoch 14/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.4665 - val_loss: 0.5326\n",
            "Epoch 15/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.4355 - val_loss: 0.5058\n",
            "Epoch 16/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.4057 - val_loss: 0.4799\n",
            "Epoch 17/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.3781 - val_loss: 0.4541\n",
            "Epoch 18/100\n",
            "5/5 [==============================] - 0s 15ms/step - loss: 0.3508 - val_loss: 0.4302\n",
            "Epoch 19/100\n",
            "5/5 [==============================] - 0s 15ms/step - loss: 0.3244 - val_loss: 0.4069\n",
            "Epoch 20/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.2998 - val_loss: 0.3828\n",
            "Epoch 21/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.2783 - val_loss: 0.3599\n",
            "Epoch 22/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.2563 - val_loss: 0.3390\n",
            "Epoch 23/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.2406 - val_loss: 0.3182\n",
            "Epoch 24/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.2218 - val_loss: 0.2989\n",
            "Epoch 25/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.2067 - val_loss: 0.2825\n",
            "Epoch 26/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.1933 - val_loss: 0.2684\n",
            "Epoch 27/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.1821 - val_loss: 0.2542\n",
            "Epoch 28/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.1685 - val_loss: 0.2426\n",
            "Epoch 29/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.1600 - val_loss: 0.2309\n",
            "Epoch 30/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.1512 - val_loss: 0.2195\n",
            "Epoch 31/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.1431 - val_loss: 0.2103\n",
            "Epoch 32/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.1379 - val_loss: 0.2031\n",
            "Epoch 33/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.1326 - val_loss: 0.1971\n",
            "Epoch 34/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.1271 - val_loss: 0.1934\n",
            "Epoch 35/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.1235 - val_loss: 0.1914\n",
            "Epoch 36/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.1208 - val_loss: 0.1890\n",
            "Epoch 37/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.1180 - val_loss: 0.1851\n",
            "Epoch 38/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.1150 - val_loss: 0.1833\n",
            "Epoch 39/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.1125 - val_loss: 0.1820\n",
            "Epoch 40/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.1100 - val_loss: 0.1808\n",
            "Epoch 41/100\n",
            "5/5 [==============================] - 0s 11ms/step - loss: 0.1081 - val_loss: 0.1807\n",
            "Epoch 42/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.1061 - val_loss: 0.1786\n",
            "Epoch 43/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.1040 - val_loss: 0.1763\n",
            "Epoch 44/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.1026 - val_loss: 0.1754\n",
            "Epoch 45/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.1004 - val_loss: 0.1746\n",
            "Epoch 46/100\n",
            "5/5 [==============================] - 0s 15ms/step - loss: 0.0988 - val_loss: 0.1748\n",
            "Epoch 47/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0989 - val_loss: 0.1747\n",
            "Epoch 48/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.0976 - val_loss: 0.1724\n",
            "Epoch 49/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.0955 - val_loss: 0.1693\n",
            "Epoch 50/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0942 - val_loss: 0.1666\n",
            "Epoch 51/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.0932 - val_loss: 0.1669\n",
            "Epoch 52/100\n",
            "5/5 [==============================] - 0s 11ms/step - loss: 0.0916 - val_loss: 0.1659\n",
            "Epoch 53/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0904 - val_loss: 0.1641\n",
            "Epoch 54/100\n",
            "5/5 [==============================] - 0s 15ms/step - loss: 0.0892 - val_loss: 0.1642\n",
            "Epoch 55/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.0886 - val_loss: 0.1645\n",
            "Epoch 56/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0875 - val_loss: 0.1636\n",
            "Epoch 57/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.0864 - val_loss: 0.1629\n",
            "Epoch 58/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.0863 - val_loss: 0.1622\n",
            "Epoch 59/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.0851 - val_loss: 0.1609\n",
            "Epoch 60/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.0834 - val_loss: 0.1600\n",
            "Epoch 61/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.0827 - val_loss: 0.1598\n",
            "Epoch 62/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0806 - val_loss: 0.1599\n",
            "Epoch 63/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0804 - val_loss: 0.1606\n",
            "Epoch 64/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0798 - val_loss: 0.1615\n",
            "Epoch 65/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0786 - val_loss: 0.1628\n",
            "Epoch 66/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0773 - val_loss: 0.1630\n",
            "Epoch 67/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0767 - val_loss: 0.1627\n",
            "Epoch 68/100\n",
            "5/5 [==============================] - 0s 9ms/step - loss: 0.0763 - val_loss: 0.1611\n",
            "Epoch 69/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0748 - val_loss: 0.1602\n",
            "Epoch 70/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0739 - val_loss: 0.1608\n",
            "Epoch 71/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.0734 - val_loss: 0.1616\n",
            "Epoch 72/100\n",
            "5/5 [==============================] - 0s 10ms/step - loss: 0.0724 - val_loss: 0.1622\n",
            "Epoch 73/100\n",
            "5/5 [==============================] - 0s 17ms/step - loss: 0.0723 - val_loss: 0.1637\n",
            "Epoch 74/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0710 - val_loss: 0.1650\n",
            "Epoch 75/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0704 - val_loss: 0.1653\n",
            "Epoch 76/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0704 - val_loss: 0.1665\n",
            "Epoch 77/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0704 - val_loss: 0.1673\n",
            "Epoch 78/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0685 - val_loss: 0.1681\n",
            "Epoch 79/100\n",
            "5/5 [==============================] - 0s 17ms/step - loss: 0.0688 - val_loss: 0.1702\n",
            "Epoch 80/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0677 - val_loss: 0.1686\n",
            "Epoch 81/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0668 - val_loss: 0.1668\n",
            "Epoch 82/100\n",
            "5/5 [==============================] - 0s 15ms/step - loss: 0.0658 - val_loss: 0.1672\n",
            "Epoch 83/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0652 - val_loss: 0.1674\n",
            "Epoch 84/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0644 - val_loss: 0.1662\n",
            "Epoch 85/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0642 - val_loss: 0.1644\n",
            "Epoch 86/100\n",
            "5/5 [==============================] - 0s 21ms/step - loss: 0.0637 - val_loss: 0.1656\n",
            "Epoch 87/100\n",
            "5/5 [==============================] - 0s 14ms/step - loss: 0.0627 - val_loss: 0.1646\n",
            "Epoch 88/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0619 - val_loss: 0.1647\n",
            "Epoch 89/100\n",
            "5/5 [==============================] - 0s 13ms/step - loss: 0.0621 - val_loss: 0.1646\n",
            "Epoch 90/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0612 - val_loss: 0.1648\n",
            "Epoch 91/100\n",
            "5/5 [==============================] - 0s 18ms/step - loss: 0.0619 - val_loss: 0.1658\n",
            "Epoch 92/100\n",
            "5/5 [==============================] - 0s 19ms/step - loss: 0.0605 - val_loss: 0.1667\n",
            "Epoch 93/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0605 - val_loss: 0.1699\n",
            "Epoch 94/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0611 - val_loss: 0.1686\n",
            "Epoch 95/100\n",
            "5/5 [==============================] - 0s 16ms/step - loss: 0.0595 - val_loss: 0.1650\n",
            "Epoch 96/100\n",
            "5/5 [==============================] - 0s 18ms/step - loss: 0.0582 - val_loss: 0.1631\n",
            "Epoch 97/100\n",
            "5/5 [==============================] - 0s 17ms/step - loss: 0.0584 - val_loss: 0.1622\n",
            "Epoch 98/100\n",
            "5/5 [==============================] - 0s 18ms/step - loss: 0.0578 - val_loss: 0.1627\n",
            "Epoch 99/100\n",
            "5/5 [==============================] - 0s 17ms/step - loss: 0.0573 - val_loss: 0.1640\n",
            "Epoch 100/100\n",
            "5/5 [==============================] - 0s 19ms/step - loss: 0.0568 - val_loss: 0.1638\n",
            "Mean Squared Error: 0.05613725259900093\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Split the train dataset into target and independent variable"
      ],
      "metadata": {
        "id": "qXRADv-oZvMC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "predicted_scaled = model.predict(X_test_transformed_data)\n",
        "#predicted =predicted_scaled.reshape(-1, 1)\n",
        "predicted = y_scaler.inverse_transform(predicted_scaled)\n",
        "print(\"Predicted Health Cost:\", predicted[0][0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p-End5Sk42Ln",
        "outputId": "ac420c1e-d5ff-4fb4-90b1-ca547aa613d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5/5 [==============================] - 0s 2ms/step\n",
            "Predicted Health Cost: 17122.219\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the model\n",
        "mse = model.evaluate(X_test_transformed_data,y_test_scaled, verbose=0)\n",
        "print('Mean Squared Error:', mse)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "krdeJulqh3A-",
        "outputId": "8e25cfec-f23c-4b6a-b0e1-a82b6ff48e7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.05253952741622925\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the model using validation model\n",
        "mse = model.evaluate(X_val_transformed_data,y_val_scaled, verbose=0)\n",
        "print('Mean Squared Error:', mse)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sLxUyL6g8DsK",
        "outputId": "524e087b-4dbd-4881-9388-6bf3e68ca6d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.16383162140846252\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "HYPERPARAMETER TUNING"
      ],
      "metadata": {
        "id": "hqwRda2QMEyG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the list of units and activation functions\n",
        "units_list = [32, 16, 8]\n",
        "activation_list = ['relu', 'sigmoid', 'tanh']\n",
        "\n",
        "# Create an empty DataFrame to store the results\n",
        "results_df = pd.DataFrame(columns=['Units', 'Activation', 'MSE'])\n",
        "\n",
        "# Load or preprocess your data here\n",
        "# X_train, y_train, X_test, y_test = ...\n",
        "\n",
        "# Iterate over the units and activation functions using a for loop\n",
        "for units, activation in zip(units_list, activation_list):\n",
        "    # Create a new Sequential model for each configuration\n",
        "    model = Sequential()\n",
        "    model.add(Dense(units=units, activation=activation, input_shape=(X_train_transformed_data.shape[1],)))\n",
        "    model.add(Dense(5))\n",
        "    model.add(Dense(1))\n",
        "\n",
        "    # Compile the model\n",
        "    model.compile(optimizer='adam', loss='mean_squared_error')\n",
        "\n",
        "    # Fit the model on the training data\n",
        "    model.fit(X_train_transformed_data,y_train_scaled, epochs=100, batch_size=32, verbose=0)\n",
        "\n",
        "    # Make predictions on the test data\n",
        "    #y_pred = model.predict(X_test)\n",
        "\n",
        "    # Evaluate the model using validation model\n",
        "    mse = model.evaluate(X_val_transformed_data,y_val_scaled, verbose=0)\n",
        "    print('Mean Squared Error:', mse)\n",
        "\n",
        "    # Add the results to the DataFrame\n",
        "    results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n",
        "\n",
        "# Print the results as a table\n",
        "print(results_df)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QchgZmTyL7fo",
        "outputId": "17d0e7a1-dbf3-4e55-97b4-19f2d9752b89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.16416998207569122\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-112-4fb3bb6093fe>:33: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.14077818393707275\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-112-4fb3bb6093fe>:33: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.13849198818206787\n",
            "  Units Activation       MSE\n",
            "0    32       relu  0.164170\n",
            "1    16    sigmoid  0.140778\n",
            "2     8       tanh  0.138492\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-112-4fb3bb6093fe>:33: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the list of units and activation functions\n",
        "#units_list = [32, 16, 8]\n",
        "activation_list = ['relu', 'sigmoid', 'tanh']\n",
        "\n",
        "# Create an empty DataFrame to store the results\n",
        "results_df = pd.DataFrame(columns=['Units', 'Activation', 'MSE'])\n",
        "\n",
        "# Load or preprocess your data here\n",
        "# X_train, y_train, X_test, y_test = ...\n",
        "\n",
        "# Iterate over the units and activation functions using a for loop\n",
        "for units in range(11):\n",
        "    # Create a new Sequential model for each configuration\n",
        "    model = Sequential()\n",
        "    # Add the dense layer with the specified number of units and activation funct\n",
        "    model.add(Dense(units=units, activation='relu', input_shape=(X_train_transformed_data.shape[1],)))\n",
        "    model.add(Dense(1))\n",
        "\n",
        "    # Compile the model\n",
        "    model.compile(optimizer='adam', loss='mean_squared_error')\n",
        "       # Fit the model on the training data\n",
        "    model.fit(X_train_transformed_data,y_train_scaled, epochs=100, batch_size=32, verbose=0)\n",
        "       # Make predictions on the test data\n",
        "       #y_pred = model.predict(X_test)\n",
        "       # Evaluate the model using validation model\n",
        "    mse = model.evaluate(X_val_transformed_data,y_val_scaled, verbose=0)\n",
        "    print('Mean Squared Error:', mse)\n",
        "       # Add the results to the DataFrame\n",
        "    results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n",
        "\n",
        "# Print the results as a table\n",
        "print(results_df)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kQBxFwuRRAj3",
        "outputId": "4dc96373-188d-480f-ed9d-742cb11a54cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 1.0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 1.0000146627426147\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.21818885207176208\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.14713285863399506\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.1285214126110077\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.13622047007083893\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.1392875611782074\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.12881053984165192\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.1526876538991928\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.12943878769874573\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.14632390439510345\n",
            "   Units Activation       MSE\n",
            "0      0    (relu,)  1.000000\n",
            "1      1    (relu,)  1.000015\n",
            "2      2    (relu,)  0.218189\n",
            "3      3    (relu,)  0.147133\n",
            "4      4    (relu,)  0.128521\n",
            "5      5    (relu,)  0.136220\n",
            "6      6    (relu,)  0.139288\n",
            "7      7    (relu,)  0.128811\n",
            "8      8    (relu,)  0.152688\n",
            "9      9    (relu,)  0.129439\n",
            "10    10    (relu,)  0.146324\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-111-cc5a0f470b24>:29: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
            "  results_df = results_df.append({'Units': units, 'Activation': activation, 'MSE': mse}, ignore_index=True)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the model creation function\n",
        "from tensorflow.keras.wrappers.scikit_learn import KerasRegressor\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.model_selection import KFold\n",
        "def create_model(hidden_units=32, activation='relu', optimizer='adam'):\n",
        "    model = Sequential()\n",
        "    model.add(Dense(hidden_units, activation=activation, input_shape=(X_train_transformed_data.shape[1],)))\n",
        "    model.add(Dense(1))\n",
        "    model.compile(optimizer=optimizer, loss='mean_squared_error')\n",
        "    return model\n",
        "\n",
        "# Create the KerasRegressor wrapper\n",
        "model = KerasRegressor(build_fn=create_model, verbose=0)\n",
        "\n",
        "# Define the hyperparameters and their values to search\n",
        "param_grid = {\n",
        "    'hidden_units': [100, 110, 120],\n",
        "    'activation': ['relu', 'tanh'],\n",
        "    'optimizer': ['adam', 'rmsprop']\n",
        "}\n",
        "\n",
        "# Define the cross-validation strategy\n",
        "cv = KFold(n_splits=5, shuffle=True, random_state=42)\n",
        "\n",
        "# Perform grid search with cross-validation\n",
        "grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=cv, scoring='neg_mean_squared_error')\n",
        "grid_result = grid_search.fit(X_train_transformed_data,y_train_scaled)\n",
        "\n",
        "# Extract the results and create a table\n",
        "results = pd.DataFrame(grid_result.cv_results_)\n",
        "results_table = results[['param_hidden_units', 'param_activation', 'mean_test_score']]\n",
        "results_table['mean_test_score'] = -results_table['mean_test_score']\n",
        "\n",
        "# Print the results table\n",
        "print(results_table)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v-s3bRb2DWmm",
        "outputId": "c8526a43-8e05-4927-d64c-6d923b696771"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-27-26c373903476>:13: DeprecationWarning: KerasRegressor is deprecated, use Sci-Keras (https://github.com/adriangb/scikeras) instead. See https://www.adriangb.com/scikeras/stable/migration.html for help migrating.\n",
            "  model = KerasRegressor(build_fn=create_model, verbose=0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   param_hidden_units param_activation  mean_test_score\n",
            "0                 100             relu         0.732457\n",
            "1                 100             relu         0.596711\n",
            "2                 110             relu         0.641011\n",
            "3                 110             relu         0.584731\n",
            "4                 120             relu         0.682560\n",
            "5                 120             relu         0.622445\n",
            "6                 100             tanh         0.577528\n",
            "7                 100             tanh         0.488061\n",
            "8                 110             tanh         0.532581\n",
            "9                 110             tanh         0.402319\n",
            "10                120             tanh         0.517911\n",
            "11                120             tanh         0.470576\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-27-26c373903476>:32: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  results_table['mean_test_score'] = -results_table['mean_test_score']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.wrappers.scikit_learn import KerasRegressor\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.model_selection import KFold\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
        "def create_model(hidden_units=32, activation='relu', optimizer='adam'):\n",
        "    model = Sequential()\n",
        "    model.add(Dense(hidden_units, activation=activation, input_shape=(X_train_transformed_data.shape[1],)))\n",
        "    model.add(Dense(1))\n",
        "    model.compile(optimizer=optimizer, loss='mean_squared_error')\n",
        "    return model\n",
        "\n",
        "# Create the KerasRegressor wrapper\n",
        "model = KerasRegressor(build_fn=create_model, verbose=0)\n",
        "\n",
        "# Define the hyperparameters and their values to search\n",
        "param_grid = {\n",
        "    'hidden_units': [100, 110, 120],\n",
        "    'activation': ['relu', 'tanh'],\n",
        "    'optimizer': ['adam', 'rmsprop']\n",
        "}\n",
        "\n",
        "# Define the cross-validation strategy\n",
        "cv = KFold(n_splits=5, shuffle=True, random_state=42)\n",
        "\n",
        "# Perform grid search with cross-validation\n",
        "grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=cv, scoring='neg_mean_squared_error')\n",
        "grid_result = grid_search.fit(X_train_transformed_data,y_train_scaled,validation_data=(X_val_transformed_data,y_val_scaled))\n",
        "\n",
        "# Extract the results and create a table\n",
        "results = pd.DataFrame(grid_result.cv_results_)\n",
        "results_table = results[['param_hidden_units', 'param_activation', 'mean_test_score']]\n",
        "results_table['mean_test_score'] = -results_table['mean_test_score']\n",
        "\n",
        "# Print the results table\n",
        "print(results_table)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "savIV7Bi-UEM",
        "outputId": "95b92914-3b27-41af-d47e-c6d0785c9b37"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   param_hidden_units param_activation  mean_test_score\n",
            "0                 100             relu         0.718715\n",
            "1                 100             relu         0.645790\n",
            "2                 110             relu         0.666051\n",
            "3                 110             relu         0.564331\n",
            "4                 120             relu         0.624233\n",
            "5                 120             relu         0.586602\n",
            "6                 100             tanh         0.529007\n",
            "7                 100             tanh         0.477772\n",
            "8                 110             tanh         0.543624\n",
            "9                 110             tanh         0.399659\n",
            "10                120             tanh         0.499821\n",
            "11                120             tanh         0.430086\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-23-30074ade802f>:33: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  results_table['mean_test_score'] = -results_table['mean_test_score']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#ALGORITHM USED HERE"
      ],
      "metadata": {
        "id": "4eNAjdl8kPmt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "REFERENCES"
      ],
      "metadata": {
        "id": "WX552c0Ssvnh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.www.kaggle.com. (n.d.). Medical Cost Personal Datasets. [online] Available at: https://www.kaggle.com/datasets/mirichoi0218/insurance?select=insurance.csv.\n",
        "\n",
        "‌"
      ],
      "metadata": {
        "id": "FaW_jN1enTJd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.https://www.kaggle.com/datasets/mirichoi0218/insurance?select=insurance.csv"
      ],
      "metadata": {
        "id": "GGpIvcmUsxyj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "Arf_NrFWe2xh"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "bQxPPOO3sxGp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "https://www.kaggle.com/code/tumpanjawat/medcost-eda-k-cluster-gradient-boost-full"
      ],
      "metadata": {
        "id": "X5dx0jEPjCs2"
      }
    }
  ]
}