diff --git a/ADV AI/xgboost-with_pca.ipynb b/ADV AI/xgboost-with_pca.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..67353e9096b94160522ae3de27d774bdd340e7e5 --- /dev/null +++ b/ADV AI/xgboost-with_pca.ipynb @@ -0,0 +1,1994 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IfYTqx4bfUBB", + "outputId": "febcb4a7-d668-4597-caae-738e7e6327a9" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " SettlementValue AccidentType Injury_Prognosis \\\n", + "0 520.0 Rear end E. 5 months \n", + "1 870.0 Rear end B. 2 months \n", + "2 2140.0 Other side pulled out of side road G. 7 months \n", + "3 520.0 Rear end - Clt pushed into next vehicle D. 4 months \n", + "4 260.0 Rear end C. 3 months \n", + "\n", + " SpecialHealthExpenses SpecialReduction SpecialOverage GeneralRest \\\n", + "0 0.0 0.0 0.0 0.0 \n", + "1 0.0 0.0 0.0 520.0 \n", + "2 0.0 0.0 0.0 1400.0 \n", + "3 0.0 0.0 0.0 0.0 \n", + "4 0.0 0.0 0.0 0.0 \n", + "\n", + " SpecialAdditionalInjury SpecialEarningsLoss SpecialUsageLoss ... \\\n", + "0 0.0 0.0 0.0 ... \n", + "1 0.0 0.0 90.0 ... \n", + "2 0.0 0.0 0.0 ... \n", + "3 0.0 0.0 0.0 ... \n", + "4 0.0 0.0 0.0 ... \n", + "\n", + " Accident Date Claim Date Vehicle Age \\\n", + "0 2023-11-10 11:22:24.508901 2024-06-11 11:22:24.508901 13.0 \n", + "1 2023-06-25 00:55:01.140228 2024-01-09 00:55:01.140228 4.0 \n", + "2 2020-02-23 17:43:47.805561 2020-03-01 17:43:47.805561 9.0 \n", + "3 2021-10-02 04:36:32.118423 2021-10-13 04:36:32.118423 5.0 \n", + "4 2023-04-02 05:13:07.117423 2023-04-14 05:13:07.117423 9.0 \n", + "\n", + " Driver Age Number of Passengers Accident Description \\\n", + "0 33.0 4.0 Side collision at an intersection. \n", + "1 45.0 2.0 Side collision at an intersection. \n", + "2 45.0 4.0 Lost control on a snowy road. \n", + "3 62.0 1.0 Side collision at an intersection. \n", + "4 78.0 1.0 Lost control on a snowy road. \n", + "\n", + " Injury Description Police Report Filed Witness Present Gender \n", + "0 Whiplash and minor bruises. Yes Yes Male \n", + "1 Minor cuts and scrapes. Yes Yes Female \n", + "2 Whiplash and minor bruises. Yes No Female \n", + "3 Minor cuts and scrapes. Yes Yes Female \n", + "4 Concussion and bruised ribs. Yes Yes Other \n", + "\n", + "[5 rows x 36 columns]\n", + "<class 'pandas.core.frame.DataFrame'>\n", + "RangeIndex: 5000 entries, 0 to 4999\n", + "Data columns (total 36 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 SettlementValue 4894 non-null float64\n", + " 1 AccidentType 4878 non-null object \n", + " 2 Injury_Prognosis 4844 non-null object \n", + " 3 SpecialHealthExpenses 4870 non-null float64\n", + " 4 SpecialReduction 4879 non-null float64\n", + " 5 SpecialOverage 4883 non-null float64\n", + " 6 GeneralRest 4872 non-null float64\n", + " 7 SpecialAdditionalInjury 4866 non-null float64\n", + " 8 SpecialEarningsLoss 4872 non-null float64\n", + " 9 SpecialUsageLoss 4870 non-null float64\n", + " 10 SpecialMedications 4870 non-null float64\n", + " 11 SpecialAssetDamage 4889 non-null float64\n", + " 12 SpecialRehabilitation 4884 non-null float64\n", + " 13 SpecialFixes 4879 non-null float64\n", + " 14 GeneralFixed 4879 non-null float64\n", + " 15 GeneralUplift 4863 non-null float64\n", + " 16 SpecialLoanerVehicle 4861 non-null float64\n", + " 17 SpecialTripCosts 4885 non-null float64\n", + " 18 SpecialJourneyExpenses 4853 non-null float64\n", + " 19 SpecialTherapy 4868 non-null float64\n", + " 20 Exceptional_Circumstances 4891 non-null object \n", + " 21 Minor_Psychological_Injury 4881 non-null object \n", + " 22 Dominant injury 4890 non-null object \n", + " 23 Whiplash 4870 non-null object \n", + " 24 Vehicle Type 4874 non-null object \n", + " 25 Weather Conditions 4886 non-null object \n", + " 26 Accident Date 4862 non-null object \n", + " 27 Claim Date 4891 non-null object \n", + " 28 Vehicle Age 4874 non-null float64\n", + " 29 Driver Age 4871 non-null float64\n", + " 30 Number of Passengers 4878 non-null float64\n", + " 31 Accident Description 4880 non-null object \n", + " 32 Injury Description 4881 non-null object \n", + " 33 Police Report Filed 5000 non-null object \n", + " 34 Witness Present 5000 non-null object \n", + " 35 Gender 5000 non-null object \n", + "dtypes: float64(21), object(15)\n", + "memory usage: 1.4+ MB\n", + "None\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# Load dataset\n", + "file_path = \"sample_data/Synthetic_Data_For_Students.csv\"\n", + "df = pd.read_csv(file_path)\n", + "\n", + "# Display first few rows\n", + "print(df.head())\n", + "\n", + "# Check for missing values and data types\n", + "print(df.info())\n" + ] + }, + { + "cell_type": "code", + "source": [ + "df.tail()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 481 + }, + "id": "_iWXJ1c7roYt", + "outputId": "6dd523ad-97f8-449e-967e-c1110472d55d" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " SettlementValue AccidentType Injury_Prognosis \\\n", + "4995 275.00 Other side turned across Clt's path A. 1 month \n", + "4996 1074.35 Other side pulled out of side road H. 8 months \n", + "4997 2020.00 Other side pulled out of side road F. 6 months \n", + "4998 781.20 Rear end - 3 car - Clt at front D. 4 months \n", + "4999 1390.00 Rear end K. 11 months \n", + "\n", + " SpecialHealthExpenses SpecialReduction SpecialOverage GeneralRest \\\n", + "4995 0.0 0.0 0.0 0.0 \n", + "4996 0.0 0.0 0.0 0.0 \n", + "4997 0.0 0.0 0.0 2020.0 \n", + "4998 0.0 0.0 0.0 0.0 \n", + "4999 0.0 0.0 0.0 2300.0 \n", + "\n", + " SpecialAdditionalInjury SpecialEarningsLoss SpecialUsageLoss ... \\\n", + "4995 0.0 0.0 0.0 ... \n", + "4996 0.0 0.0 0.0 ... \n", + "4997 0.0 0.0 0.0 ... \n", + "4998 0.0 0.0 0.0 ... \n", + "4999 0.0 0.0 0.0 ... \n", + "\n", + " Accident Date Claim Date Vehicle Age \\\n", + "4995 2021-08-25 19:24:19.731946 2022-06-30 19:24:19.731946 18.0 \n", + "4996 2023-05-30 15:05:56.471294 2023-06-13 15:05:56.471294 NaN \n", + "4997 2023-03-09 13:27:25.529105 2023-08-05 13:27:25.529105 11.0 \n", + "4998 2023-02-09 05:32:42.392478 2023-10-18 05:32:42.392478 10.0 \n", + "4999 2020-04-09 00:11:14.054810 2020-06-05 00:11:14.054810 0.0 \n", + "\n", + " Driver Age Number of Passengers Accident Description \\\n", + "4995 18.0 3.0 Hit a deer on the highway. \n", + "4996 70.0 4.0 Side collision at an intersection. \n", + "4997 43.0 1.0 Swerved to avoid another vehicle. \n", + "4998 69.0 1.0 Lost control on a snowy road. \n", + "4999 65.0 2.0 Rear-ended at a stoplight. \n", + "\n", + " Injury Description Police Report Filed Witness Present \\\n", + "4995 Concussion and bruised ribs. No No \n", + "4996 Fractured arm and leg. Yes No \n", + "4997 Minor cuts and scrapes. No Yes \n", + "4998 Sprained ankle and wrist. No No \n", + "4999 Concussion and bruised ribs. Yes No \n", + "\n", + " Gender \n", + "4995 Other \n", + "4996 Female \n", + "4997 Male \n", + "4998 Female \n", + "4999 Other \n", + "\n", + "[5 rows x 36 columns]" + ], + "text/html": [ + "\n", + " <div id=\"df-c68b5c0b-3b8c-4205-acdc-b04a89587285\" 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>SettlementValue</th>\n", + " <th>AccidentType</th>\n", + " <th>Injury_Prognosis</th>\n", + " <th>SpecialHealthExpenses</th>\n", + " <th>SpecialReduction</th>\n", + " <th>SpecialOverage</th>\n", + " <th>GeneralRest</th>\n", + " <th>SpecialAdditionalInjury</th>\n", + " <th>SpecialEarningsLoss</th>\n", + " <th>SpecialUsageLoss</th>\n", + " <th>...</th>\n", + " <th>Accident Date</th>\n", + " <th>Claim Date</th>\n", + " <th>Vehicle Age</th>\n", + " <th>Driver Age</th>\n", + " <th>Number of Passengers</th>\n", + " <th>Accident Description</th>\n", + " <th>Injury Description</th>\n", + " <th>Police Report Filed</th>\n", + " <th>Witness Present</th>\n", + " <th>Gender</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>4995</th>\n", + " <td>275.00</td>\n", + " <td>Other side turned across Clt's path</td>\n", + " <td>A. 1 month</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>2021-08-25 19:24:19.731946</td>\n", + " <td>2022-06-30 19:24:19.731946</td>\n", + " <td>18.0</td>\n", + " <td>18.0</td>\n", + " <td>3.0</td>\n", + " <td>Hit a deer on the highway.</td>\n", + " <td>Concussion and bruised ribs.</td>\n", + " <td>No</td>\n", + " <td>No</td>\n", + " <td>Other</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4996</th>\n", + " <td>1074.35</td>\n", + " <td>Other side pulled out of side road</td>\n", + " <td>H. 8 months</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>2023-05-30 15:05:56.471294</td>\n", + " <td>2023-06-13 15:05:56.471294</td>\n", + " <td>NaN</td>\n", + " <td>70.0</td>\n", + " <td>4.0</td>\n", + " <td>Side collision at an intersection.</td>\n", + " <td>Fractured arm and leg.</td>\n", + " <td>Yes</td>\n", + " <td>No</td>\n", + " <td>Female</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4997</th>\n", + " <td>2020.00</td>\n", + " <td>Other side pulled out of side road</td>\n", + " <td>F. 6 months</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>2020.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>2023-03-09 13:27:25.529105</td>\n", + " <td>2023-08-05 13:27:25.529105</td>\n", + " <td>11.0</td>\n", + " <td>43.0</td>\n", + " <td>1.0</td>\n", + " <td>Swerved to avoid another vehicle.</td>\n", + " <td>Minor cuts and scrapes.</td>\n", + " <td>No</td>\n", + " <td>Yes</td>\n", + " <td>Male</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4998</th>\n", + " <td>781.20</td>\n", + " <td>Rear end - 3 car - Clt at front</td>\n", + " <td>D. 4 months</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>2023-02-09 05:32:42.392478</td>\n", + " <td>2023-10-18 05:32:42.392478</td>\n", + " <td>10.0</td>\n", + " <td>69.0</td>\n", + " <td>1.0</td>\n", + " <td>Lost control on a snowy road.</td>\n", + " <td>Sprained ankle and wrist.</td>\n", + " <td>No</td>\n", + " <td>No</td>\n", + " <td>Female</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4999</th>\n", + " <td>1390.00</td>\n", + " <td>Rear end</td>\n", + " <td>K. 11 months</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>2300.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>...</td>\n", + " <td>2020-04-09 00:11:14.054810</td>\n", + " <td>2020-06-05 00:11:14.054810</td>\n", + " <td>0.0</td>\n", + " <td>65.0</td>\n", + " <td>2.0</td>\n", + " <td>Rear-ended at a stoplight.</td>\n", + " <td>Concussion and bruised ribs.</td>\n", + " <td>Yes</td>\n", + " <td>No</td>\n", + " <td>Other</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>5 rows × 36 columns</p>\n", + "</div>\n", + " <div class=\"colab-df-buttons\">\n", + "\n", + " <div class=\"colab-df-container\">\n", + " <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-c68b5c0b-3b8c-4205-acdc-b04a89587285')\"\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-c68b5c0b-3b8c-4205-acdc-b04a89587285 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-c68b5c0b-3b8c-4205-acdc-b04a89587285');\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-00bc14dd-5170-4da0-b4e8-11edece6449a\">\n", + " <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-00bc14dd-5170-4da0-b4e8-11edece6449a')\"\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-00bc14dd-5170-4da0-b4e8-11edece6449a button');\n", + " quickchartButtonEl.style.display =\n", + " google.colab.kernel.accessAllowed ? 'block' : 'none';\n", + " })();\n", + " </script>\n", + "</div>\n", + "\n", + " </div>\n", + " </div>\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe" + } + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Drop rows with missing values\n", + "df = df.dropna()\n", + "\n", + "# Verify if any missing values remain\n", + "print(df.info())\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OkZJIH5Gj26w", + "outputId": "048efe45-e146-45c0-c73e-02b1afb6a517" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "<class 'pandas.core.frame.DataFrame'>\n", + "Index: 3545 entries, 0 to 4999\n", + "Data columns (total 36 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 SettlementValue 3545 non-null float64\n", + " 1 AccidentType 3545 non-null object \n", + " 2 Injury_Prognosis 3545 non-null object \n", + " 3 SpecialHealthExpenses 3545 non-null float64\n", + " 4 SpecialReduction 3545 non-null float64\n", + " 5 SpecialOverage 3545 non-null float64\n", + " 6 GeneralRest 3545 non-null float64\n", + " 7 SpecialAdditionalInjury 3545 non-null float64\n", + " 8 SpecialEarningsLoss 3545 non-null float64\n", + " 9 SpecialUsageLoss 3545 non-null float64\n", + " 10 SpecialMedications 3545 non-null float64\n", + " 11 SpecialAssetDamage 3545 non-null float64\n", + " 12 SpecialRehabilitation 3545 non-null float64\n", + " 13 SpecialFixes 3545 non-null float64\n", + " 14 GeneralFixed 3545 non-null float64\n", + " 15 GeneralUplift 3545 non-null float64\n", + " 16 SpecialLoanerVehicle 3545 non-null float64\n", + " 17 SpecialTripCosts 3545 non-null float64\n", + " 18 SpecialJourneyExpenses 3545 non-null float64\n", + " 19 SpecialTherapy 3545 non-null float64\n", + " 20 Exceptional_Circumstances 3545 non-null object \n", + " 21 Minor_Psychological_Injury 3545 non-null object \n", + " 22 Dominant injury 3545 non-null object \n", + " 23 Whiplash 3545 non-null object \n", + " 24 Vehicle Type 3545 non-null object \n", + " 25 Weather Conditions 3545 non-null object \n", + " 26 Accident Date 3545 non-null object \n", + " 27 Claim Date 3545 non-null object \n", + " 28 Vehicle Age 3545 non-null float64\n", + " 29 Driver Age 3545 non-null float64\n", + " 30 Number of Passengers 3545 non-null float64\n", + " 31 Accident Description 3545 non-null object \n", + " 32 Injury Description 3545 non-null object \n", + " 33 Police Report Filed 3545 non-null object \n", + " 34 Witness Present 3545 non-null object \n", + " 35 Gender 3545 non-null object \n", + "dtypes: float64(21), object(15)\n", + "memory usage: 1.0+ MB\n", + "None\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Drop unnecessary text columns\n", + "columns_to_drop = [\"Accident Description\", \"Injury Description\", \"Accident Date\", \"Claim Date\", \"Driver Age\", \"Gender\"]\n", + "# Check if columns exist before dropping\n", + "existing_columns = [col for col in columns_to_drop if col in df.columns]\n", + "df = df.drop(columns=existing_columns)\n", + "\n", + "# Check dataset shape after dropping\n", + "print(df.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4q2hTG2PkS-H", + "outputId": "74fe524c-be74-4b7e-c678-3c762704dae2" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(3545, 30)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Identify and drop string/object type columns\n", + "import pandas as pd\n", + "from sklearn.preprocessing import StandardScaler # Import StandardScaler\n", + "\n", + "# Identify and drop string/object type columns\n", + "object_cols = df.drop(columns=[\"SettlementValue\"]).select_dtypes(include=['object']).columns\n", + "df_numeric = df.drop(columns=object_cols) # Drop object type columns\n", + "\n", + "# Step 1: Standardize the data (PCA requires normalized data)\n", + "scaler = StandardScaler()\n", + "X_scaled = scaler.fit_transform(df_numeric.drop(columns=[\"SettlementValue\"])) # Exclude target variable\n" + ], + "metadata": { + "id": "hNVM5mDoeWqG" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(df.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Bxi7FaOneZ-d", + "outputId": "55da470e-1fcf-46e0-e764-1a320fea4ae1" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(3545, 30)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.decomposition import PCA\n", + "from sklearn.preprocessing import StandardScaler\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Step 1: Standardize the data (PCA requires normalized data)\n", + "# Identify and drop string/object type columns EXCEPT the target variable 'SettlementValue'\n", + "object_cols = df.select_dtypes(include=['object']).columns\n", + "object_cols = object_cols[object_cols != \"SettlementValue\"] # Exclude the target variable from object columns\n", + "\n", + "df_numeric = df.drop(columns=object_cols) # Drop object type columns excluding the target\n", + "# Now df_numeric should only contain numerical features and the target variable\n", + "\n", + "scaler = StandardScaler()\n", + "X_scaled = scaler.fit_transform(df_numeric.drop(columns=[\"SettlementValue\"])) # Exclude target variable\n", + "\n", + "# Step 2: Apply PCA and determine the number of components\n", + "pca = PCA(0.5)\n", + "X_pca = pca.fit_transform(X_scaled)\n", + "\n", + "# Step 3: Plot explained variance to choose the optimal number of components\n", + "explained_variance = np.cumsum(pca.explained_variance_ratio_)\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(range(1, len(explained_variance) + 1), explained_variance, marker='o', linestyle='--')\n", + "plt.xlabel('Number of Components')\n", + "plt.ylabel('Cumulative Explained Variance')\n", + "plt.title('Explained Variance by PCA Components')\n", + "plt.grid(True)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "YQGJqxmykg68", + "outputId": "b2413e77-4c55-4045-f956-7031394d322a" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x600 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(X_pca.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "B2PmOSo6ejtM", + "outputId": "e604666e-c038-4b09-b212-bd0c85b453fc" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(3545, 8)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "# Initialize MinMaxScaler\n", + "scaler = MinMaxScaler()\n", + "\n", + "# Select only numerical columns\n", + "numerical_cols = df.select_dtypes(include=[\"float64\", \"int64\"]).columns\n", + "\n", + "# Apply scaling\n", + "df[numerical_cols] = scaler.fit_transform(df[numerical_cols])\n", + "\n", + "# Check if scaling worked\n", + "print(df.head())\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ofdPFRlCe-ye", + "outputId": "01c26d49-85cb-44cc-8fe2-628960bd2cbc" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " SettlementValue AccidentType Injury_Prognosis \\\n", + "0 0.036731 Rear end E. 5 months \n", + "1 0.082646 Rear end B. 2 months \n", + "2 0.249249 Other side pulled out of side road G. 7 months \n", + "3 0.036731 Rear end - Clt pushed into next vehicle D. 4 months \n", + "4 0.002624 Rear end C. 3 months \n", + "\n", + " SpecialHealthExpenses SpecialReduction SpecialOverage GeneralRest \\\n", + "0 0.0 0.0 0.0 0.000000 \n", + "1 0.0 0.0 0.0 0.148571 \n", + "2 0.0 0.0 0.0 0.400000 \n", + "3 0.0 0.0 0.0 0.000000 \n", + "4 0.0 0.0 0.0 0.000000 \n", + "\n", + " SpecialAdditionalInjury SpecialEarningsLoss SpecialUsageLoss ... \\\n", + "0 0.0 0.0 0.000000 ... \n", + "1 0.0 0.0 0.085714 ... \n", + "2 0.0 0.0 0.000000 ... \n", + "3 0.0 0.0 0.000000 ... \n", + "4 0.0 0.0 0.000000 ... \n", + "\n", + " Exceptional_Circumstances Minor_Psychological_Injury Dominant injury \\\n", + "0 No Yes Arms \n", + "1 No Yes Multiple \n", + "2 No No Legs \n", + "3 No Yes Arms \n", + "4 No Yes Arms \n", + "\n", + " Whiplash Vehicle Type Weather Conditions Vehicle Age \\\n", + "0 Yes Motorcycle Rainy 0.684211 \n", + "1 Yes Motorcycle Snowy 0.210526 \n", + "2 Yes Motorcycle Sunny 0.473684 \n", + "3 Yes Truck Rainy 0.263158 \n", + "4 No Motorcycle Rainy 0.473684 \n", + "\n", + " Number of Passengers Police Report Filed Witness Present \n", + "0 1.000000 Yes Yes \n", + "1 0.333333 Yes Yes \n", + "2 1.000000 Yes No \n", + "3 0.000000 Yes Yes \n", + "4 0.000000 Yes Yes \n", + "\n", + "[5 rows x 30 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Define features (X) and target variable (y)\n", + "X = df.drop(columns=[\"SettlementValue\"])\n", + "y = df[\"SettlementValue\"]\n", + "\n", + "# Split into 80% training and 20% test sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)\n", + "\n", + "# Print dataset shapes\n", + "print(f\"Training Set: {X_train.shape}, Test Set: {X_test.shape}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "go4uaMqsfBDC", + "outputId": "e341e14f-835e-46f5-f6d8-2679b36c2da9" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training Set: (2836, 8), Test Set: (709, 8)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import xgboost as xgb\n", + "from sklearn.metrics import r2_score # Import r2_score\n", + "\n", + "# Train XGBoost Model\n", + "xgb_model = xgb.XGBRegressor(n_estimators=500, learning_rate=0.05, max_depth=6, subsample=0.8, colsample_bytree=0.8, random_state=42)\n", + "xgb_model.fit(X_train, y_train)\n", + "\n", + "# Predict & Evaluate\n", + "y_xgb_pred = xgb_model.predict(X_test)\n", + "r2_xgb = r2_score(y_test, y_xgb_pred)\n", + "\n", + "print(f\"XGBoost R² Score: {r2_xgb:.4f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G5MgkY2tfog2", + "outputId": "1f687173-7a8d-4b26-c736-bb559edbc9bb" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "XGBoost R² Score: 0.8456\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.metrics import mean_absolute_error, mean_squared_error\n", + "\n", + "# Predict on test data\n", + "y_xgb_pred = xgb_model.predict(X_test)\n", + "\n", + "# Compute MAE and MSE\n", + "mae_xgb = mean_absolute_error(y_test, y_xgb_pred)\n", + "mse_xgb = mean_squared_error(y_test, y_xgb_pred)\n", + "\n", + "print(f\"XGBoost MAE: {mae_xgb:.4f}\")\n", + "print(f\"XGBoost MSE (Loss): {mse_xgb:.4f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1wM5JZS6gF5S", + "outputId": "3e150482-9736-4204-da57-f85a44e318fc" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "XGBoost MAE: 0.0208\n", + "XGBoost MSE (Loss): 0.0018\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Evaluate on the test set\n", + "test_loss, test_mae = model.evaluate(X_test, y_test)\n", + "\n", + "print(f\"Test MAE: {test_mae}\")\n", + "print(f\"Test Loss: {test_loss}\")\n", + "# Predict on test set\n", + "y_pred = model.predict(X_test)\n", + "\n", + "# Display a few predictions vs actual values\n", + "comparison = pd.DataFrame({\"Actual\": y_test[:10].values, \"Predicted\": y_pred[:10].flatten()})\n", + "print(comparison)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 220 + }, + "id": "fCoQZssUFgdh", + "outputId": "9135be22-4698-40eb-bf24-1ce1fbce1391" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "name 'model' is not defined", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m<ipython-input-16-fba24a99c1ae>\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Evaluate on the test set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtest_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_mae\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Test MAE: {test_mae}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Test Loss: {test_loss}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "import xgboost as xgb\n", + "\n", + "# Get feature importance\n", + "importance = xgb_model.feature_importances_\n", + "features = X.columns\n", + "\n", + "# Sort by importance\n", + "sorted_idx = importance.argsort()\n", + "plt.figure(figsize=(10, 8))\n", + "plt.barh(features[sorted_idx][-15:], importance[sorted_idx][-15:]) # Show top 15 features\n", + "plt.xlabel(\"Feature Importance\")\n", + "plt.title(\"Top Most Important Features\")\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 718 + }, + "id": "oLafGfbJgXp4", + "outputId": "2ba239f5-6fc2-4d80-826c-2fb04d31243c" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x800 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import xgboost as xgb\n", + "import pickle\n", + "from sklearn.metrics import r2_score\n", + "\n", + "\n", + "# Combine model + metadata\n", + "data_to_save = {\n", + " \"model\": xgb_model,\n", + " \"metadata\": {\n", + " \"model_name\": \"Model1\",\n", + " \"r2_score\": r2_xgb\n", + " }\n", + "}\n", + "\n", + "# Save to one file\n", + "with open(\"model1.pkl\", \"wb\") as f:\n", + " pickle.dump(data_to_save, f)\n" + ], + "metadata": { + "id": "AGHa3DIhZmL3" + }, + "execution_count": 19, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import joblib\n", + "joblib.dump(xgb_model, \"new.pkl\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "u5lWo_XywGzx", + "outputId": "bb47ae5b-d6f5-42a5-da74-0ec619c1faac" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['new.pkl']" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pickle\n", + "\n", + "# Open the file in write binary mode ('wb')\n", + "with open(\"xgbpickle.pkl\", \"wb\") as f:\n", + " pickle.dump(xgb_model, f)" + ], + "metadata": { + "id": "D-AMpFH8pWEl" + }, + "execution_count": 16, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import Dense, Dropout\n", + "\n", + "# Define the Neural Network Model\n", + "model = Sequential([\n", + " Dense(128, activation='relu', input_shape=(X_train.shape[1],)), # Input Layer\n", + " Dropout(0.2), # Dropout to reduce overfitting\n", + " Dense(64, activation='relu'),\n", + " Dropout(0.1),\n", + " Dense(32, activation='relu'),\n", + " Dense(1) # Output Layer (Regression)\n", + "])\n", + "\n", + "# Compile the Model\n", + "model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0005), loss='mse', metrics=['mae'])\n", + "\n", + "# Print Model Summary\n", + "model.summary()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 384 + }, + "id": "XhA_2RR3gw3s", + "outputId": "b418c285-bf0b-4fe0-e134-a367d2d706c0" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.11/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,152\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m8,256\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_1 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m2,080\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m33\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">1,152</span> │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">8,256</span> │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">2,080</span> │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">33</span> │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m11,521\u001b[0m (45.00 KB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">11,521</span> (45.00 KB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m11,521\u001b[0m (45.00 KB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">11,521</span> (45.00 KB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n", + "</pre>\n" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "from tensorflow.keras.callbacks import ReduceLROnPlateau\n", + "\n", + "lr_scheduler = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-6)\n", + "\n", + "history = model.fit(X_train, y_train, epochs=300, batch_size=32, validation_data=(X_test, y_test), callbacks=[lr_scheduler])\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0ga8L27BgzG4", + "outputId": "96607527-ccd2-4e04-e031-f2786f6095f3" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - loss: 0.0308 - mae: 0.1012 - val_loss: 0.0060 - val_mae: 0.0470 - learning_rate: 5.0000e-04\n", + "Epoch 2/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0127 - mae: 0.0640 - val_loss: 0.0045 - val_mae: 0.0430 - learning_rate: 5.0000e-04\n", + "Epoch 3/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0078 - mae: 0.0557 - val_loss: 0.0037 - val_mae: 0.0381 - learning_rate: 5.0000e-04\n", + "Epoch 4/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0143 - mae: 0.0548 - val_loss: 0.0036 - val_mae: 0.0399 - learning_rate: 5.0000e-04\n", + "Epoch 5/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0074 - mae: 0.0505 - val_loss: 0.0033 - val_mae: 0.0357 - learning_rate: 5.0000e-04\n", + "Epoch 6/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0066 - mae: 0.0499 - val_loss: 0.0038 - val_mae: 0.0358 - learning_rate: 5.0000e-04\n", + "Epoch 7/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0060 - mae: 0.0468 - val_loss: 0.0031 - val_mae: 0.0354 - learning_rate: 5.0000e-04\n", + "Epoch 8/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0045 - mae: 0.0421 - val_loss: 0.0022 - val_mae: 0.0303 - learning_rate: 5.0000e-04\n", + "Epoch 9/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0045 - mae: 0.0423 - val_loss: 0.0034 - val_mae: 0.0339 - learning_rate: 5.0000e-04\n", + "Epoch 10/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0037 - mae: 0.0390 - val_loss: 0.0027 - val_mae: 0.0316 - learning_rate: 5.0000e-04\n", + "Epoch 11/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0043 - mae: 0.0403 - val_loss: 0.0028 - val_mae: 0.0323 - learning_rate: 5.0000e-04\n", + "Epoch 12/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0039 - mae: 0.0399 - val_loss: 0.0029 - val_mae: 0.0310 - learning_rate: 5.0000e-04\n", + "Epoch 13/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0039 - mae: 0.0382 - val_loss: 0.0028 - val_mae: 0.0310 - learning_rate: 5.0000e-04\n", + "Epoch 14/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0041 - mae: 0.0387 - val_loss: 0.0024 - val_mae: 0.0300 - learning_rate: 2.5000e-04\n", + "Epoch 15/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0040 - mae: 0.0387 - val_loss: 0.0023 - val_mae: 0.0299 - learning_rate: 2.5000e-04\n", + "Epoch 16/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0365 - val_loss: 0.0024 - val_mae: 0.0299 - learning_rate: 2.5000e-04\n", + "Epoch 17/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0038 - mae: 0.0369 - val_loss: 0.0022 - val_mae: 0.0295 - learning_rate: 2.5000e-04\n", + "Epoch 18/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0029 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 2.5000e-04\n", + "Epoch 19/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0037 - mae: 0.0374 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.2500e-04\n", + "Epoch 20/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0358 - val_loss: 0.0024 - val_mae: 0.0297 - learning_rate: 1.2500e-04\n", + "Epoch 21/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0028 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0292 - learning_rate: 1.2500e-04\n", + "Epoch 22/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0038 - mae: 0.0372 - val_loss: 0.0022 - val_mae: 0.0296 - learning_rate: 1.2500e-04\n", + "Epoch 23/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0039 - mae: 0.0362 - val_loss: 0.0023 - val_mae: 0.0295 - learning_rate: 1.2500e-04\n", + "Epoch 24/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0342 - val_loss: 0.0024 - val_mae: 0.0297 - learning_rate: 6.2500e-05\n", + "Epoch 25/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0039 - mae: 0.0381 - val_loss: 0.0023 - val_mae: 0.0296 - learning_rate: 6.2500e-05\n", + "Epoch 26/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0038 - mae: 0.0364 - val_loss: 0.0023 - val_mae: 0.0296 - learning_rate: 6.2500e-05\n", + "Epoch 27/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0358 - val_loss: 0.0023 - val_mae: 0.0295 - learning_rate: 6.2500e-05\n", + "Epoch 28/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0356 - val_loss: 0.0023 - val_mae: 0.0292 - learning_rate: 6.2500e-05\n", + "Epoch 29/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0033 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0291 - learning_rate: 3.1250e-05\n", + "Epoch 30/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0291 - learning_rate: 3.1250e-05\n", + "Epoch 31/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0357 - val_loss: 0.0023 - val_mae: 0.0292 - learning_rate: 3.1250e-05\n", + "Epoch 32/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0031 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 3.1250e-05\n", + "Epoch 33/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0027 - mae: 0.0338 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 3.1250e-05\n", + "Epoch 34/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0032 - mae: 0.0358 - val_loss: 0.0023 - val_mae: 0.0290 - learning_rate: 1.5625e-05\n", + "Epoch 35/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.0033 - mae: 0.0351 - val_loss: 0.0023 - val_mae: 0.0290 - learning_rate: 1.5625e-05\n", + "Epoch 36/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.5625e-05\n", + "Epoch 37/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0027 - mae: 0.0346 - val_loss: 0.0023 - val_mae: 0.0291 - learning_rate: 1.5625e-05\n", + "Epoch 38/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0028 - mae: 0.0345 - val_loss: 0.0023 - val_mae: 0.0291 - learning_rate: 1.5625e-05\n", + "Epoch 39/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0354 - val_loss: 0.0023 - val_mae: 0.0292 - learning_rate: 7.8125e-06\n", + "Epoch 40/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0042 - mae: 0.0369 - val_loss: 0.0023 - val_mae: 0.0292 - learning_rate: 7.8125e-06\n", + "Epoch 41/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0034 - mae: 0.0359 - val_loss: 0.0023 - val_mae: 0.0292 - learning_rate: 7.8125e-06\n", + "Epoch 42/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 7.8125e-06\n", + "Epoch 43/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0357 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 7.8125e-06\n", + "Epoch 44/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 3.9063e-06\n", + "Epoch 45/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 3.9063e-06\n", + "Epoch 46/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 3.9063e-06\n", + "Epoch 47/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 3.9063e-06\n", + "Epoch 48/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 3.9063e-06\n", + "Epoch 49/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.9531e-06\n", + "Epoch 50/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.9531e-06\n", + "Epoch 51/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.9531e-06\n", + "Epoch 52/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0357 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.9531e-06\n", + "Epoch 53/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.9531e-06\n", + "Epoch 54/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 55/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 56/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0048 - mae: 0.0368 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 57/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0028 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 58/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.0030 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 59/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 60/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0364 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 61/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0036 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 62/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0359 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 63/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 64/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0033 - mae: 0.0361 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 65/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 66/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0036 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 67/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 68/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 69/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0360 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 70/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 71/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0034 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 72/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 73/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0339 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 74/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0335 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 75/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 76/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 77/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0029 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 78/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0031 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 79/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0030 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 80/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.0026 - mae: 0.0330 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 81/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0029 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 82/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 83/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0333 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 84/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 85/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 86/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 87/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 88/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0031 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 89/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0357 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 90/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 91/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0028 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 92/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 93/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 94/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 95/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0360 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 96/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 97/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 98/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0027 - mae: 0.0332 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 99/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 100/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0030 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 101/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0028 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 102/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0030 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 103/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0032 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 104/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 105/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0364 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 106/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 107/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 108/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 109/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0027 - mae: 0.0338 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 110/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0361 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 111/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 112/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 113/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 114/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 115/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 116/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 117/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 118/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0026 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 119/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0031 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 120/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 121/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 122/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 123/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0030 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 124/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0032 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 125/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0031 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 126/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0029 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 127/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 128/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0029 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 129/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0028 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 130/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0030 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 131/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0357 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 132/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 133/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0028 - mae: 0.0336 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 134/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0363 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 135/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0031 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 136/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 137/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0030 - mae: 0.0339 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 138/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 139/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 140/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 141/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 142/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0037 - mae: 0.0360 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 143/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0030 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 144/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0030 - mae: 0.0360 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 145/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 146/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0032 - mae: 0.0364 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 147/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.0034 - mae: 0.0359 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 148/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0030 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 149/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0029 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 150/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0031 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 151/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0031 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 152/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 153/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 154/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0339 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 155/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0361 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 156/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0029 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 157/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 158/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0031 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 159/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 160/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0030 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 161/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0341 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 162/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 163/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0029 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 164/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0336 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 165/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0036 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 166/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 167/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0362 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 168/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 169/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 170/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0038 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 171/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 172/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0029 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 173/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0032 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 174/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0030 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 175/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0033 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 176/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0029 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 177/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.0027 - mae: 0.0341 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 178/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0042 - mae: 0.0381 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 179/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0038 - mae: 0.0363 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 180/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 181/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0360 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 182/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0360 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 183/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0338 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 184/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 185/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 186/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 187/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 188/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0041 - mae: 0.0371 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 189/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0336 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 190/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0341 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 191/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 192/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 193/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0338 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 194/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0341 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 195/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.0033 - mae: 0.0357 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 196/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.0033 - mae: 0.0361 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 197/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0337 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 198/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 199/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 200/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.0036 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 201/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 202/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0338 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 203/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 204/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 205/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 206/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step - loss: 0.0030 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 207/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0336 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 208/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 209/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 210/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0037 - mae: 0.0369 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 211/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 212/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 213/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0341 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 214/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.0032 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 215/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0033 - mae: 0.0362 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 216/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.0029 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 217/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 5ms/step - loss: 0.0030 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0290 - learning_rate: 1.0000e-06\n", + "Epoch 218/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 219/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0357 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 220/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 221/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 222/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 223/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 224/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 225/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0353 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 226/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 227/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 228/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0036 - mae: 0.0358 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 229/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0362 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 230/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 231/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0350 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 232/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0337 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 233/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 234/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 235/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 236/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0034 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 237/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0029 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 238/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0040 - mae: 0.0369 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 239/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.0030 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 240/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 241/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 242/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0339 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 243/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0335 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 244/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0362 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 245/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0327 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 246/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 247/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0333 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 248/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0346 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 249/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0042 - mae: 0.0359 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 250/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 251/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0359 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 252/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0354 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 253/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 254/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0361 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 255/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 256/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0025 - mae: 0.0328 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 257/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 258/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 259/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.0032 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 260/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0030 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 261/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 262/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 263/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 264/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0338 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 265/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0348 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 266/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0028 - mae: 0.0342 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 267/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 268/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0027 - mae: 0.0336 - val_loss: 0.0022 - val_mae: 0.0289 - learning_rate: 1.0000e-06\n", + "Epoch 269/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 270/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0355 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 271/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 272/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0046 - mae: 0.0359 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 273/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0349 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 274/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 275/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0362 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 276/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 277/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0033 - mae: 0.0337 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 278/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 279/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 280/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 281/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0028 - mae: 0.0339 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 282/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0030 - mae: 0.0352 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 283/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0032 - mae: 0.0360 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 284/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 6ms/step - loss: 0.0030 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 285/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0356 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 286/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0340 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 287/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0038 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 288/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0035 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 289/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0034 - mae: 0.0365 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 290/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0026 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 291/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 292/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 293/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0029 - mae: 0.0343 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 294/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0025 - mae: 0.0334 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 295/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0032 - mae: 0.0347 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 296/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0344 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 297/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0042 - mae: 0.0371 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 298/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0031 - mae: 0.0345 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 299/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.0038 - mae: 0.0362 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n", + "Epoch 300/300\n", + "\u001b[1m89/89\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 4ms/step - loss: 0.0030 - mae: 0.0351 - val_loss: 0.0022 - val_mae: 0.0288 - learning_rate: 1.0000e-06\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Evaluate on the test set\n", + "test_loss, test_mae = model.evaluate(X_test, y_test)\n", + "\n", + "print(f\"Test MAE: {test_mae}\")\n", + "print(f\"Test Loss: {test_loss}\")\n", + "# Predict on test set\n", + "y_pred = model.predict(X_test)\n", + "\n", + "# Display a few predictions vs actual values\n", + "comparison = pd.DataFrame({\"Actual\": y_test[:10].values, \"Predicted\": y_pred[:10].flatten()})\n", + "print(comparison)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RHL09cZcg2ak", + "outputId": "27d23c7e-d2de-45a1-fb7a-2749df65e47d" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step - loss: 0.0021 - mae: 0.0280 \n", + "Test MAE: 0.028819655999541283\n", + "Test Loss: 0.0021996190771460533\n", + "\u001b[1m23/23\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + " Actual Predicted\n", + "0 0.116098 0.110439\n", + "1 0.104816 0.097230\n", + "2 0.036731 0.032650\n", + "3 0.154928 0.122329\n", + "4 0.049973 0.056336\n", + "5 0.041979 0.044762\n", + "6 0.031642 0.068778\n", + "7 0.000000 0.014473\n", + "8 0.089605 0.084405\n", + "9 0.042780 0.025937\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.metrics import r2_score\n", + "\n", + "# Calculate R² score\n", + "r2 = r2_score(y_test, y_pred)\n", + "\n", + "print(f\"R² Score (Accuracy): {r2:.4f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ddzucy7Ug2Kt", + "outputId": "0ed3cfbc-49fb-4847-e8b8-0a7ab1270779" + }, + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "R² Score (Accuracy): 0.8078\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pickle\n", + "\n", + "# Open the file in write binary mode ('wb')\n", + "with open(\"nnetwork.pkl\", \"wb\") as f:\n", + " pickle.dump(xgb_model, f)" + ], + "metadata": { + "id": "CtCgwSg-wS10" + }, + "execution_count": 23, + "outputs": [] + } + ] +} \ No newline at end of file