cars_predict_tf_tidy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1o3BONW2Wm7l_7swxNlSMQWNe-dSfBMnF",
      "authorship_tag": "ABX9TyMMIyzgfeZ3GqBUpamB2IkY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MarioMarkov/cars_predict_web/blob/master/cars_predict_tf_tidy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "WV5VDLSBmzgs"
      },
      "outputs": [],
      "source": [
        "#@title Load libraries\n",
        "import pandas as pd \n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "\n",
        "pd.options.display.float_format = '{:.10f}'.format"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Load data\n",
        "data = pd.read_csv('/content/drive/MyDrive/cars_predict/cars-data3.csv', index_col=None)\n",
        "test_pred = pd.read_csv('/content/drive/MyDrive/cars_predict/test-data.csv',  index_col=None)\n",
        "\n",
        "data = data.drop(['id'],axis='columns')\n",
        "\n",
        "data = data.drop(['euro'],axis='columns')\n",
        "test_pred = test_pred.drop(['euro'],axis='columns')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "OWopZfm2m-Et"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Clean data 🧹 \n",
        "\n",
        "print(\"Old Shape before cleaning: \", data.shape)\n",
        "\n",
        "def clean_data(data):\n",
        "\n",
        "  # Remove brands that are seen less than 200 times\n",
        "  data = data.groupby('brand').filter(lambda x :len(x)>200)\n",
        "\n",
        "  #Format BMW model\n",
        "  def format_bmw_model(model_name):\n",
        "    if 'X' in model_name or 'i' in model_name:\n",
        "      return model_name\n",
        "    return model_name[0]\n",
        "\n",
        "  # Trim model to just 1 letter except if it is X or i ex.(318 to 3)\n",
        "  data.loc[data['brand'] == 'BMW', ['model']] = data[data.brand == 'BMW'].model.apply(lambda x: format_bmw_model(x))\n",
        "\n",
        "  # Remove models that are met less than 9 times\n",
        "  data = data.groupby('model').filter(lambda x :len(x)>20)\n",
        "\n",
        "  # Remove years that are met less than 10 times\n",
        "  data = data.groupby('year').filter(lambda x :len(x)>10)\n",
        "\n",
        "  #data.dropna(how=\"any\", axis=0, inplace=True)\n",
        "\n",
        "  # TODO this removes missing values \n",
        "  data = data[(data.hp >30) & (data.hp < 480)]\n",
        "  data = data[(data.price >100) & (data.price < 60000)]\n",
        "  data = data[(data.displacement >100) & (data.displacement < 8000)]\n",
        "  data = data[(data.kms >100) & (data.kms < 1000000)]\n",
        "  data = data.dropna()\n",
        "\n",
        "  return data \n",
        "\n",
        "# Applying function\n",
        "data = clean_data(data)\n",
        "\n",
        "print(\"New Shape after cleaning: \", data.shape)\n",
        "\n",
        "# Put a flag on premium brands\n",
        "premium_brands = [\"Porsche\", \"Audi\",\"Mercedes-Benz\",\"BMW\"]\n",
        "\n",
        "data['premium'] = np.where(data['brand'].isin(premium_brands), 1, 0)\n",
        "test_pred['premium'] = np.where(test_pred['brand'].isin(premium_brands), 1, 0)\n",
        "\n",
        "# data['new'] = np.where(data['year']>2018, 1, 0)\n",
        "# test_pred['new'] = np.where(test_pred['year']>2018, 1, 0)\n",
        "\n",
        "def make_buckets(df):\n",
        "  bins = [0,50000, 100000, 150000,200000,250000,300000,400000,500000,600000]\n",
        "  labels = [1,2,3,4,5,6,7,8,9]\n",
        "  df['kms'] = pd.cut(x = df['kms'], \n",
        "                     bins = bins,\n",
        "                     labels = labels,\n",
        "                     include_lowest = True)\n",
        "  return df\n",
        "data = make_buckets(data)\n",
        "test = make_buckets(test_pred)\n",
        "data = data.dropna()\n",
        "\n",
        "data[\"kms\"] = data[\"kms\"].astype(\"int32\")\n",
        "test[\"kms\"] = test[\"kms\"].astype(\"int32\")\n",
        "\n",
        "numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']\n",
        "# Select columns with 'float64' dtype  \n",
        "numeric_cols = list(data.select_dtypes(include=numerics))\n",
        "\n",
        "# The same code again calling the columns\n",
        "data[numeric_cols] = data[numeric_cols].astype('float32')\n",
        "\n",
        "\n",
        "print(data.describe())\n",
        "\n",
        "# How many missing values per column \n",
        "(data.isnull().sum())\n",
        "data.to_csv('cars-data_index.csv', index=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "cellView": "form",
        "id": "sBZqxjmGnapo",
        "outputId": "78dedb27-2011-4a66-e790-2b218da42ca6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Old Shape before cleaning:  (25670, 12)\n",
            "New Shape after cleaning:  (18799, 12)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-66-0768fa38a36b>:62: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  data[\"kms\"] = data[\"kms\"].astype(\"int32\")\n",
            "<ipython-input-66-0768fa38a36b>:70: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  data[numeric_cols] = data[numeric_cols].astype('float32')\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                  year              kms     transmission            2door  \\\n",
            "count 18795.0000000000 18795.0000000000 18795.0000000000 18795.0000000000   \n",
            "mean   2008.2409667969     4.2332005501     0.2551210523     0.0824155360   \n",
            "std       4.9047985077     1.1936763525     0.4359408319     0.2750040591   \n",
            "min    1990.0000000000     1.0000000000     0.0000000000     0.0000000000   \n",
            "25%    2005.0000000000     4.0000000000     0.0000000000     0.0000000000   \n",
            "50%    2008.0000000000     4.0000000000     0.0000000000     0.0000000000   \n",
            "75%    2011.0000000000     5.0000000000     1.0000000000     0.0000000000   \n",
            "max    2022.0000000000     9.0000000000     1.0000000000     1.0000000000   \n",
            "\n",
            "          displacement               hp            price          premium  \n",
            "count 18795.0000000000 18795.0000000000 18795.0000000000 18795.0000000000  \n",
            "mean   1906.8477783203   131.0482635498 11497.6367187500     0.1308326721  \n",
            "std     577.5339355469    49.3135643005  9097.5136718750     0.3372262418  \n",
            "min     101.0000000000    40.0000000000   599.0000000000     0.0000000000  \n",
            "25%    1588.5000000000    97.0000000000  5500.0000000000     0.0000000000  \n",
            "50%    1900.0000000000   120.0000000000  8700.0000000000     0.0000000000  \n",
            "75%    2000.0000000000   150.0000000000 14400.0000000000     0.0000000000  \n",
            "max    6800.0000000000   450.0000000000 59999.0000000000     1.0000000000  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Define helper Functions\n",
        "\n",
        "def df_to_dataset(dataframe, shuffle=True, batch_size=32):\n",
        "  df = dataframe.copy()\n",
        "  labels = df.pop('price')\n",
        "  df = {key: value[:,tf.newaxis] for key, value in dataframe.items()}\n",
        "  ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))\n",
        "  if shuffle:\n",
        "    ds = ds.shuffle(buffer_size=len(dataframe))\n",
        "  ds = ds.batch(batch_size)\n",
        "  ds = ds.prefetch(batch_size)\n",
        "  return ds\n",
        "\n",
        "def get_normalization_layer(name, dataset):\n",
        "  # Create a Normalization layer for the feature.\n",
        "  normalizer = tf.keras.layers.Normalization(axis=None)\n",
        "\n",
        "  # Prepare a Dataset that only yields the feature.\n",
        "  feature_ds = dataset.map(lambda x, y: x[name])\n",
        "\n",
        "  # Learn the statistics of the data.\n",
        "  normalizer.adapt(feature_ds)\n",
        "  return normalizer\n",
        "\n",
        "def get_category_encoding_layer(name, dataset, dtype, max_tokens=None):\n",
        "  # Create a layer that turns strings into integer indices.\n",
        "  if dtype == 'string':\n",
        "    index = tf.keras.layers.StringLookup(max_tokens=max_tokens)\n",
        "  # Otherwise, create a layer that turns integer values into integer indices.\n",
        "  else:\n",
        "    index = tf.keras.layers.IntegerLookup(max_tokens=max_tokens)\n",
        "\n",
        "  # Prepare a `tf.data.Dataset` that only yields the feature.\n",
        "  feature_ds = dataset.map(lambda x, y: x[name])\n",
        "\n",
        "  # Learn the set of possible values and assign them a fixed integer index.\n",
        "  index.adapt(feature_ds)\n",
        "\n",
        "  # Encode the integer indices.\n",
        "  encoder = tf.keras.layers.CategoryEncoding(num_tokens=index.vocabulary_size())\n",
        "\n",
        "  # Apply multi-hot encoding to the indices. The lambda function captures the\n",
        "  # layer, so you can use them, or include them in the Keras Functional model later.\n",
        "  return lambda feature: encoder(index(feature))\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "dAcMzQRwn5xi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Making tf-dataset\n",
        "# Split data\n",
        "train, val, test = np.split(data.sample(frac=1), [int(0.9*len(data)), int(0.95*len(data))])\n",
        "\n",
        "print(len(train), 'training examples')\n",
        "print(len(val), 'validation examples')\n",
        "print(len(test), 'test examples')\n",
        "\n",
        "batch_size = 64\n",
        "train_ds = df_to_dataset(train, batch_size=batch_size)\n",
        "val_ds = df_to_dataset(val, shuffle=False, batch_size=batch_size)\n",
        "test_ds = df_to_dataset(test, shuffle=False, batch_size=batch_size)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DbktYYo-oD5N",
        "outputId": "6cdc2d9b-8f1a-4636-c69e-21cd7f95d6b6",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16915 training examples\n",
            "940 validation examples\n",
            "940 test examples\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-67-35e913b20012>:6: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.\n",
            "  df = {key: value[:,tf.newaxis] for key, value in dataframe.items()}\n",
            "<ipython-input-67-35e913b20012>:6: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.\n",
            "  df = {key: value[:,tf.newaxis] for key, value in dataframe.items()}\n",
            "<ipython-input-67-35e913b20012>:6: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.\n",
            "  df = {key: value[:,tf.newaxis] for key, value in dataframe.items()}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Tensorflow preprocessing\n",
        "\n",
        "# Normalize numerical features\n",
        "all_inputs = []\n",
        "encoded_features = []\n",
        "columns_to_normalize = ['year','displacement','hp','kms']\n",
        "\n",
        "[(train_features, label_batch)] = train_ds.take(1)\n",
        "\n",
        "for header in columns_to_normalize:\n",
        "  # Input for feature\n",
        "  numeric_col = tf.keras.Input(shape=(1,), name=header)\n",
        "\n",
        "  # Normalization layer for feature\n",
        "  normalization_layer = get_normalization_layer(header, train_ds)\n",
        "\n",
        "  # Normalizes feature\n",
        "  encoded_numeric_col = normalization_layer(numeric_col)\n",
        "\n",
        "  # Appends to all feature\n",
        "  all_inputs.append(numeric_col)\n",
        "\n",
        "  # Appends to encoded features\n",
        "  encoded_features.append(encoded_numeric_col)\n",
        "\n",
        "\n",
        "# Encode zero-one variables\n",
        "transmission_col = tf.keras.Input(shape=(1,), dtype='int64',name= \"transmission\")\n",
        "col_2door = tf.keras.Input(shape=(1,), dtype='int64',name= \"2door\")\n",
        "premium_col = tf.keras.Input(shape=(1,), dtype='int64',name= \"premium\")\n",
        "new_col = tf.keras.Input(shape=(1,), dtype='int64',name= \"new\")\n",
        "\n",
        "encoding_layer_transmission = get_category_encoding_layer(name='transmission',\n",
        "                                             dataset=train_ds,\n",
        "                                             dtype='int64',\n",
        "                                             max_tokens=2)\n",
        "\n",
        "encoding_layer_door2 = get_category_encoding_layer(name='2door',\n",
        "                                             dataset=train_ds,\n",
        "                                             dtype='int64',\n",
        "                                             max_tokens=2)\n",
        "encoding_layer_premium = get_category_encoding_layer(name='premium',\n",
        "                                             dataset=train_ds,\n",
        "                                             dtype='int64',\n",
        "                                             max_tokens=2)\n",
        "# encoding_layer_new = get_category_encoding_layer(name='new',\n",
        "#                                              dataset=train_ds,\n",
        "#                                              dtype='int64',\n",
        "#                                              max_tokens=2)\n",
        "\n",
        "#Transmission\n",
        "encoded_transmission_col = encoding_layer_transmission(transmission_col)\n",
        "\n",
        "# Door w\n",
        "encoded_door2_col = encoding_layer_door2(col_2door)\n",
        "\n",
        "# Premium\n",
        "encoded_premium_col = encoding_layer_premium(premium_col)\n",
        "\n",
        "# New\n",
        "#encoded_new_col = encoding_layer_new(new_col)\n",
        "\n",
        "\n",
        "all_inputs.extend([transmission_col, col_2door, premium_col,\n",
        "                   #new_col \n",
        "                   ])\n",
        "\n",
        "encoded_features.extend([encoded_transmission_col,encoded_door2_col,\n",
        "                         encoded_premium_col,\n",
        "                         #encoded_new_col, \n",
        "                         ])\n",
        "\n",
        "\n",
        "# Encode string variables\n",
        "categorical_cols = ['brand', 'model','type','color','fuel']\n",
        "\n",
        "for header in categorical_cols:\n",
        "  categorical_col = tf.keras.Input(shape=(1,), name=header, dtype='string')\n",
        "  tokens = len(train[header].unique())\n",
        "  print(header, tokens)\n",
        "  encoding_layer = get_category_encoding_layer(name=header,\n",
        "                                               dataset=train_ds,\n",
        "                                               dtype='string',\n",
        "                                               max_tokens=tokens)\n",
        "  encoded_categorical_col = encoding_layer(categorical_col)\n",
        "  all_inputs.append(categorical_col)\n",
        "  encoded_features.append(encoded_categorical_col)\n",
        "\n",
        "\n",
        "all_features = tf.keras.layers.concatenate(encoded_features)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "cellView": "form",
        "id": "xXL4hY8toH9Z",
        "outputId": "5398e7cb-f51a-4505-b817-59067bee2cb6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "brand 29\n",
            "model 219\n",
            "type 8\n",
            "color 20\n",
            "fuel 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Define model\n",
        "\n",
        "initializer = tf.keras.initializers.HeNormal(seed = 42)\n",
        "\n",
        "x_1 = tf.keras.layers.Dense(500, activation=\"relu\",kernel_initializer=initializer,\n",
        "                            bias_initializer='zeros')(all_features)\n",
        "                            \n",
        "x_2 = tf.keras.layers.Dense(300, activation=\"relu\",kernel_initializer=initializer,\n",
        "    bias_initializer='zeros')(x_1)\n",
        "\n",
        "x_3 = tf.keras.layers.Dense(200, activation=\"relu\",kernel_initializer=initializer,\n",
        "    bias_initializer='zeros')(x_2)\n",
        "#x_3 = tf.keras.layers.Dropout(0.5)(x_2)\n",
        "\n",
        "output = tf.keras.layers.Dense(1,kernel_initializer=initializer,\n",
        "    bias_initializer='zeros')(x_3)\n",
        "\n",
        "model = tf.keras.Model(all_inputs, output)\n",
        "\n",
        "loss_fn = tf.keras.losses.Huber()\n",
        "\n",
        "\n",
        "# initial_learning_rate = 0.01\n",
        "# lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n",
        "#     initial_learning_rate,\n",
        "#     decay_steps=250,\n",
        "#     decay_rate=0.95,\n",
        "#     staircase=True)\n",
        "\n",
        "def scheduler(epoch, lr):\n",
        "  if epoch < 7:\n",
        "    return 0.01\n",
        "  elif epoch >=8 and epoch <=15: return 0.003\n",
        "  else:\n",
        "    return 0.001\n",
        "\n",
        "callback = tf.keras.callbacks.LearningRateScheduler(scheduler)\n",
        "\n",
        "def get_lr_metric(optimizer):\n",
        "    def lr(y_true, y_pred):\n",
        "        return optimizer.lr\n",
        "    return lr\n",
        "\n",
        "optimizer = tf.keras.optimizers.Adam()\n",
        "lr_metric = get_lr_metric(optimizer)\n",
        "\n",
        "model.compile(optimizer=optimizer,\n",
        "              loss=loss_fn,\n",
        "              metrics=[tf.keras.metrics.RootMeanSquaredError()])\n",
        "\n",
        "history = model.fit(train_ds, epochs=25, validation_data=val_ds, callbacks=[callback])\n",
        "\n",
        "print(\"Evaluation error: \", model.evaluate(test_ds, verbose=2))"
      ],
      "metadata": {
        "id": "i_ut58MXoYxu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fe733df1-781d-46f9-fc21-6e8a8e2ddac6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/25\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/engine/functional.py:639: UserWarning: Input dict contained keys ['price'] which did not match any model input. They will be ignored by the model.\n",
            "  inputs = self._flatten_to_reference_inputs(inputs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "265/265 [==============================] - 10s 22ms/step - loss: 2771.2344 - root_mean_squared_error: 4815.8140 - val_loss: 2005.9093 - val_root_mean_squared_error: 2960.1599 - lr: 0.0100\n",
            "Epoch 2/25\n",
            "265/265 [==============================] - 4s 13ms/step - loss: 1890.7770 - root_mean_squared_error: 2955.4526 - val_loss: 1848.2769 - val_root_mean_squared_error: 2826.2314 - lr: 0.0100\n",
            "Epoch 3/25\n",
            "265/265 [==============================] - 4s 13ms/step - loss: 1804.7808 - root_mean_squared_error: 2791.5017 - val_loss: 1830.3649 - val_root_mean_squared_error: 2717.0254 - lr: 0.0100\n",
            "Epoch 4/25\n",
            "265/265 [==============================] - 6s 21ms/step - loss: 1755.1027 - root_mean_squared_error: 2723.6440 - val_loss: 1744.4296 - val_root_mean_squared_error: 2669.5679 - lr: 0.0100\n",
            "Epoch 5/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1757.6927 - root_mean_squared_error: 2724.0330 - val_loss: 1703.4587 - val_root_mean_squared_error: 2618.5037 - lr: 0.0100\n",
            "Epoch 6/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1714.9597 - root_mean_squared_error: 2673.3611 - val_loss: 1727.7836 - val_root_mean_squared_error: 2687.1831 - lr: 0.0100\n",
            "Epoch 7/25\n",
            "265/265 [==============================] - 5s 17ms/step - loss: 1642.6708 - root_mean_squared_error: 2558.7800 - val_loss: 1729.8107 - val_root_mean_squared_error: 2663.3572 - lr: 0.0100\n",
            "Epoch 8/25\n",
            "265/265 [==============================] - 5s 19ms/step - loss: 1487.5424 - root_mean_squared_error: 2370.9702 - val_loss: 1681.6790 - val_root_mean_squared_error: 2592.5071 - lr: 0.0010\n",
            "Epoch 9/25\n",
            "265/265 [==============================] - 4s 16ms/step - loss: 1476.9956 - root_mean_squared_error: 2356.2449 - val_loss: 1832.1892 - val_root_mean_squared_error: 2744.0146 - lr: 0.0030\n",
            "Epoch 10/25\n",
            "265/265 [==============================] - 5s 19ms/step - loss: 1453.8671 - root_mean_squared_error: 2327.2808 - val_loss: 1709.8508 - val_root_mean_squared_error: 2612.2334 - lr: 0.0030\n",
            "Epoch 11/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1435.8602 - root_mean_squared_error: 2301.1982 - val_loss: 1693.9868 - val_root_mean_squared_error: 2543.7466 - lr: 0.0030\n",
            "Epoch 12/25\n",
            "265/265 [==============================] - 6s 20ms/step - loss: 1436.6327 - root_mean_squared_error: 2300.4180 - val_loss: 1694.2438 - val_root_mean_squared_error: 2597.3376 - lr: 0.0030\n",
            "Epoch 13/25\n",
            "265/265 [==============================] - 4s 13ms/step - loss: 1406.2379 - root_mean_squared_error: 2260.3767 - val_loss: 1802.1681 - val_root_mean_squared_error: 2669.5361 - lr: 0.0030\n",
            "Epoch 14/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1392.0380 - root_mean_squared_error: 2242.7598 - val_loss: 1703.8262 - val_root_mean_squared_error: 2625.9099 - lr: 0.0030\n",
            "Epoch 15/25\n",
            "265/265 [==============================] - 6s 21ms/step - loss: 1375.7068 - root_mean_squared_error: 2222.1948 - val_loss: 1687.9514 - val_root_mean_squared_error: 2577.5469 - lr: 0.0030\n",
            "Epoch 16/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1360.0057 - root_mean_squared_error: 2209.0068 - val_loss: 1692.2672 - val_root_mean_squared_error: 2593.1079 - lr: 0.0030\n",
            "Epoch 17/25\n",
            "265/265 [==============================] - 5s 16ms/step - loss: 1297.5322 - root_mean_squared_error: 2142.1997 - val_loss: 1682.1938 - val_root_mean_squared_error: 2569.2029 - lr: 0.0010\n",
            "Epoch 18/25\n",
            "265/265 [==============================] - 5s 18ms/step - loss: 1274.0364 - root_mean_squared_error: 2119.6301 - val_loss: 1688.6492 - val_root_mean_squared_error: 2579.2112 - lr: 0.0010\n",
            "Epoch 19/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1263.0673 - root_mean_squared_error: 2104.7063 - val_loss: 1679.0153 - val_root_mean_squared_error: 2574.2646 - lr: 0.0010\n",
            "Epoch 20/25\n",
            "265/265 [==============================] - 4s 13ms/step - loss: 1256.2028 - root_mean_squared_error: 2102.5874 - val_loss: 1678.4197 - val_root_mean_squared_error: 2575.6628 - lr: 0.0010\n",
            "Epoch 21/25\n",
            "265/265 [==============================] - 5s 20ms/step - loss: 1243.2283 - root_mean_squared_error: 2089.6648 - val_loss: 1685.8330 - val_root_mean_squared_error: 2581.1589 - lr: 0.0010\n",
            "Epoch 22/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1234.4277 - root_mean_squared_error: 2076.8528 - val_loss: 1703.8506 - val_root_mean_squared_error: 2587.3171 - lr: 0.0010\n",
            "Epoch 23/25\n",
            "265/265 [==============================] - 4s 13ms/step - loss: 1226.3409 - root_mean_squared_error: 2065.5479 - val_loss: 1703.7094 - val_root_mean_squared_error: 2604.5898 - lr: 0.0010\n",
            "Epoch 24/25\n",
            "265/265 [==============================] - 6s 21ms/step - loss: 1219.0120 - root_mean_squared_error: 2061.6211 - val_loss: 1681.8402 - val_root_mean_squared_error: 2569.9001 - lr: 0.0010\n",
            "Epoch 25/25\n",
            "265/265 [==============================] - 4s 14ms/step - loss: 1212.1395 - root_mean_squared_error: 2055.2322 - val_loss: 1688.1639 - val_root_mean_squared_error: 2581.4729 - lr: 0.0010\n",
            "15/15 - 0s - loss: 1707.7322 - root_mean_squared_error: 2604.4966 - 87ms/epoch - 6ms/step\n",
            "Evaluation error:  [1707.732177734375, 2604.49658203125]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "hist = pd.DataFrame(history.history)\n",
        "hist['epoch'] = history.epoch\n",
        "\n",
        "def plot_loss(history):\n",
        "  plt.plot(history.history['loss'], label='loss')\n",
        "  plt.plot(history.history['val_loss'], label='val_loss')\n",
        "  plt.plot(history.history['val_root_mean_squared_error'], label='val_root_mean_squared_error')\n",
        "  plt.xlabel('Epoch')\n",
        "  plt.ylabel('Error [Price]')\n",
        "  plt.legend()\n",
        "  plt.ylim(0, 3500)\n",
        "  plt.grid(True)\n",
        "  plt.show()\n",
        "\n",
        "plot_loss(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 455
        },
        "id": "huFPUWW3pGOz",
        "outputId": "629e9323-b6b8-4e77-fb4d-1ce571c23c48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "\n",
        "#saved_model = tf.keras.models.load_model('/content/drive/MyDrive/cars_predict/saved_model_new_tf/my_model')\n",
        "\n",
        "sample = {\n",
        "    'brand': 'Opel',\n",
        "    'model': 'Corsa',\n",
        "    'year': 1999,\n",
        "    'type': 'hatchback',\n",
        "    'color': 'white',\n",
        "    'kms': 7,\n",
        "    'transmission': 0,\n",
        "    '2door': 0,\n",
        "    'displacement': 1400,\n",
        "    'hp': 60,\n",
        "    'premium': 0,\n",
        "    'fuel': 'p'\n",
        "}\n",
        "\n",
        "input_dict = {name: tf.convert_to_tensor([value]) for name, value in sample.items()}\n",
        "predictions = model.predict(input_dict)\n",
        "#pd.options.display.float_format = '{:.15f}'.format\n",
        "print(type(input_dict))\n",
        "print(predictions[0][0])\n"
      ],
      "metadata": {
        "id": "F7W4NheCqhTh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8cf219e-ec08-4711-eece-2ffab67637e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 1s 965ms/step\n",
            "<class 'dict'>\n",
            "1899.4023\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save and download model\n",
        "model.save('/content/drive/MyDrive/cars_predict/saved_model_new_tf/my_model')\n",
        "#files.download(\"/content/saved_model\")"
      ],
      "metadata": {
        "id": "Kch_PmLI1msf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3a08ba6-8997-407d-c566-d3b7275f62c4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Function `_wrapped_model` contains input name(s) 2door with unsupported characters which will be renamed to door in the SavedModel.\n",
            "WARNING:absl:Found untraced functions such as _update_step_xla while saving (showing 1 of 1). These functions will not be directly callable after loading.\n"
          ]
        }
      ]
    }
  ]
}