diff --git a/Wine_prices_regressor.ipynb b/Wine_prices_regressor.ipynb
new file mode 100644
index 0000000..5696336
--- /dev/null
+++ b/Wine_prices_regressor.ipynb
@@ -0,0 +1,670 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 106,
+      "metadata": {
+        "id": "dbQ7GYwm1WS9"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "from sklearn.preprocessing import LabelEncoder\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.impute import SimpleImputer\n",
+        "import seaborn as sns\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 69,
+      "metadata": {
+        "id": "CgyD63rD1XSO"
+      },
+      "outputs": [],
+      "source": [
+        "df = pd.read_csv('wines_SPA.csv')\n",
+        "df = df.drop(columns=['winery','country','region','num_reviews'])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 70,
+      "metadata": {
+        "id": "tn4dUcNoNOYc"
+      },
+      "outputs": [],
+      "source": [
+        "label_encoder = LabelEncoder()\n",
+        "df['wine_encoded'] = label_encoder.fit_transform(df['wine'])\n",
+        "label_encoder = LabelEncoder()\n",
+        "df['type_encoded'] = label_encoder.fit_transform(df['type'])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 77,
+      "metadata": {
+        "id": "YBNiaBln1Z4S"
+      },
+      "outputs": [],
+      "source": [
+        "df['year'] = df['year'].replace('N.V.', np.NaN)\n",
+        "imputer = SimpleImputer(strategy='most_frequent')\n",
+        "object_columns = df.select_dtypes(include=['object']).columns\n",
+        "df[object_columns] = imputer.fit_transform(df[object_columns])\n",
+        "df['year'] = df['year'].astype(np.int64)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 71,
+      "metadata": {
+        "id": "Gg_EbXvA57T6"
+      },
+      "outputs": [],
+      "source": [
+        "numerical_columns = df.select_dtypes(include=['number']).columns\n",
+        "imputer = SimpleImputer(strategy='mean')\n",
+        "df[numerical_columns] = imputer.fit_transform(df[numerical_columns])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 72,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6s2x1o4-2geb",
+        "outputId": "93a35e23-4692-41d9-caf2-267c7fe0941c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "wine              0\n",
+            "year              2\n",
+            "rating            0\n",
+            "price             0\n",
+            "type            545\n",
+            "body              0\n",
+            "acidity           0\n",
+            "wine_encoded      0\n",
+            "type_encoded      0\n",
+            "dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "null_values = df.isnull().sum()\n",
+        "print(null_values)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 94,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "ADKoKFDxHkjT",
+        "outputId": "53b980b0-6412-4aa3-e42d-55a8578a0f2c"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "repr_error": "Out of range float values are not JSON compliant: nan",
+              "type": "dataframe",
+              "variable_name": "df"
+            },
+            "text/html": [
+              "\n",
+              "  <div id=\"df-a07f15dc-bf84-4120-8f31-c8855682e286\" 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>acidity</th>\n",
+              "      <th>body</th>\n",
+              "      <th>price</th>\n",
+              "      <th>rating</th>\n",
+              "      <th>type</th>\n",
+              "      <th>type_encoded</th>\n",
+              "      <th>wine</th>\n",
+              "      <th>wine_encoded</th>\n",
+              "      <th>year</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0.234120</td>\n",
+              "      <td>1.570221</td>\n",
+              "      <td>6.217909</td>\n",
+              "      <td>5.465322</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>1.640694</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>1.257290</td>\n",
+              "      <td>-0.058537</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>-4.151132</td>\n",
+              "      <td>-0.295595</td>\n",
+              "      <td>1.685354</td>\n",
+              "      <td>5.465322</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>1.410909</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>1.516454</td>\n",
+              "      <td>0.674395</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>0.234120</td>\n",
+              "      <td>1.570221</td>\n",
+              "      <td>1.761506</td>\n",
+              "      <td>4.618073</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>-0.197584</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>1.339359</td>\n",
+              "      <td>-0.644882</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>0.234120</td>\n",
+              "      <td>1.570221</td>\n",
+              "      <td>4.209086</td>\n",
+              "      <td>4.618073</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>-0.197584</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>1.339359</td>\n",
+              "      <td>-2.110745</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0.234120</td>\n",
+              "      <td>1.570221</td>\n",
+              "      <td>4.775073</td>\n",
+              "      <td>4.618073</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>-0.197584</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>1.339359</td>\n",
+              "      <td>-2.550504</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-a07f15dc-bf84-4120-8f31-c8855682e286')\"\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 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\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",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\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-a07f15dc-bf84-4120-8f31-c8855682e286 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-a07f15dc-bf84-4120-8f31-c8855682e286');\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",
+              "\n",
+              "\n",
+              "<div id=\"df-0e580c8b-bfed-4459-9061-ca472398468c\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-0e580c8b-bfed-4459-9061-ca472398468c')\"\n",
+              "            title=\"Suggest charts\"\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",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-0e580c8b-bfed-4459-9061-ca472398468c button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "text/plain": [
+              "    acidity      body     price    rating type  type_encoded wine  \\\n",
+              "0  0.234120  1.570221  6.217909  5.465322  NaN      1.640694  NaN   \n",
+              "1 -4.151132 -0.295595  1.685354  5.465322  NaN      1.410909  NaN   \n",
+              "2  0.234120  1.570221  1.761506  4.618073  NaN     -0.197584  NaN   \n",
+              "3  0.234120  1.570221  4.209086  4.618073  NaN     -0.197584  NaN   \n",
+              "4  0.234120  1.570221  4.775073  4.618073  NaN     -0.197584  NaN   \n",
+              "\n",
+              "   wine_encoded      year  \n",
+              "0      1.257290 -0.058537  \n",
+              "1      1.516454  0.674395  \n",
+              "2      1.339359 -0.644882  \n",
+              "3      1.339359 -2.110745  \n",
+              "4      1.339359 -2.550504  "
+            ]
+          },
+          "execution_count": 94,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "df = (df-df.mean())/df.std()\n",
+        "df.head()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 109,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "my1dLu6KWhMQ",
+        "outputId": "325e6e02-f738-4b9f-e16a-eda9d385667d"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Number of outliers removed: 4478\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "<ipython-input-109-8b68ae56f5f7>:1: FutureWarning: The default value of numeric_only in DataFrame.quantile is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.\n",
+            "  Q1 = df.quantile(0.25)\n",
+            "<ipython-input-109-8b68ae56f5f7>:2: FutureWarning: The default value of numeric_only in DataFrame.quantile is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.\n",
+            "  Q3 = df.quantile(0.75)\n",
+            "<ipython-input-109-8b68ae56f5f7>:6: FutureWarning: Automatic reindexing on DataFrame vs Series comparisons is deprecated and will raise ValueError in a future version. Do `left, right = left.align(right, axis=1, copy=False)` before e.g. `left == right`\n",
+            "  df_no_outliers = df[~((df < lower_bound) | (df > upper_bound)).any(axis=1)]\n",
+            "<ipython-input-109-8b68ae56f5f7>:6: FutureWarning: Automatic reindexing on DataFrame vs Series comparisons is deprecated and will raise ValueError in a future version. Do `left, right = left.align(right, axis=1, copy=False)` before e.g. `left == right`\n",
+            "  df_no_outliers = df[~((df < lower_bound) | (df > upper_bound)).any(axis=1)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "Q1 = df.quantile(0.25)\n",
+        "Q3 = df.quantile(0.75)\n",
+        "IQR = Q3 - Q1\n",
+        "lower_bound = Q1 - 1.5 * IQR\n",
+        "upper_bound = Q3 + 1.5 * IQR\n",
+        "df_no_outliers = df[~((df < lower_bound) | (df > upper_bound)).any(axis=1)]\n",
+        "print(\"Number of outliers removed:\", len(df) - len(df_no_outliers))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 110,
+      "metadata": {
+        "id": "A2uWY65wH0N4"
+      },
+      "outputs": [],
+      "source": [
+        "y = df.iloc[:, -4].values\n",
+        "X = df.drop(columns=['price'])\n",
+        "X = X.drop(columns=['wine','type','type_encoded'])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 111,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 839
+        },
+        "id": "LSmhssJIVvVa",
+        "outputId": "add166ca-053c-4601-90d6-2cfc4db7f305"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "<ipython-input-111-9c86a81425f4>:1: FutureWarning: The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.\n",
+            "  corr = df.corr()\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x800 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "corr = df.corr()\n",
+        "plt.figure(figsize=(10, 8))\n",
+        "sns.heatmap(corr, annot=True, cmap='coolwarm', fmt=\".2f\", linewidths=.5)\n",
+        "plt.title('Correlation Matrix Heatmap')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 112,
+      "metadata": {
+        "id": "R9sOziuD3w8l"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.model_selection import train_test_split\n",
+        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 1)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 113,
+      "metadata": {
+        "id": "Ph02lNwN359r"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.linear_model import LinearRegression, Lasso, Ridge, BayesianRidge\n",
+        "from sklearn.ensemble import GradientBoostingRegressor\n",
+        "from sklearn.tree import DecisionTreeRegressor\n",
+        "from sklearn.svm import LinearSVR\n",
+        "from sklearn.neighbors import KNeighborsRegressor\n",
+        "from sklearn.ensemble import RandomForestRegressor\n",
+        "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 114,
+      "metadata": {
+        "id": "5h5SA67U4AiZ"
+      },
+      "outputs": [],
+      "source": [
+        "models = {}\n",
+        "def train_validate_predict(regressor, x_train, y_train, x_test, y_test, index):\n",
+        "    model = regressor\n",
+        "    model.fit(x_train, y_train)\n",
+        "\n",
+        "    y_pred = model.predict(x_test)\n",
+        "\n",
+        "    r2 = r2_score(y_test, y_pred)\n",
+        "    models[index] = r2"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 115,
+      "metadata": {
+        "id": "jGjhp_RK4EK4"
+      },
+      "outputs": [],
+      "source": [
+        "model_list = [LinearRegression, Lasso, Ridge, BayesianRidge, DecisionTreeRegressor, LinearSVR, KNeighborsRegressor,\n",
+        "              RandomForestRegressor,GradientBoostingRegressor]\n",
+        "model_names = ['Linear Regression', 'Lasso', 'Ridge', 'Bayesian Ridge', 'Decision Tree Regressor', 'Linear SVR',\n",
+        "               'KNeighbors Regressor', 'Random Forest Regressor','GradientBosstingRegressor']\n",
+        "\n",
+        "index = 0\n",
+        "for regressor in model_list:\n",
+        "    train_validate_predict(regressor(), X_train, y_train, X_test, y_test, model_names[index])\n",
+        "    index+=1"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 116,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IJ-63Ovl4IT_",
+        "outputId": "2fec7103-4f3d-4ff8-d3e6-617c53c44fc9"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{'Linear Regression': 0.1951597654962578,\n",
+              " 'Lasso': -0.0021941725558101144,\n",
+              " 'Ridge': 0.1951598146320498,\n",
+              " 'Bayesian Ridge': 0.1951583238088359,\n",
+              " 'Decision Tree Regressor': 0.7015865852072032,\n",
+              " 'Linear SVR': -0.03208957266383039,\n",
+              " 'KNeighbors Regressor': 0.7918658915316562,\n",
+              " 'Random Forest Regressor': 0.8231690513673763,\n",
+              " 'GradientBosstingRegressor': 0.8083165276847154}"
+            ]
+          },
+          "execution_count": 116,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "models"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}