diff --git a/samples/modules/tensorflow/hello_world/train/README.md b/samples/modules/tensorflow/hello_world/train/README.md new file mode 100644 index 00000000000..ed59b2a7866 --- /dev/null +++ b/samples/modules/tensorflow/hello_world/train/README.md @@ -0,0 +1,63 @@ +# Hello World Training + +This example shows how to train a 2.5 kB model to generate a `sine` wave. + +## Table of contents + +- [Overview](#overview) +- [Training](#training) +- [Trained Models](#trained-models) +- [Model Architecture](#model-architecture) + +## Overview + +1. Dataset: Data is generated locally in the Jupyter Notebook. +2. Dataset Type: **Structured Data** +3. Deep Learning Framework: **TensorFlow 2** +4. Language: **Python 3.7** +5. Model Size: **2.5 kB** +6. Model Category: **Regression** + +## Training + +Train the model in the cloud using Google Colaboratory or locally using a +Jupyter Notebook. + + + + +
+ Google Colaboratory + + Jupyter Notebook +
+ +*Estimated Training Time: 10 minutes.* + + +## Trained Models + +Download Link | [hello_world.zip](https://storage.googleapis.com/download.tensorflow.org/models/tflite/micro/hello_world_2020_12_28.zip) +------------- | ------------------------------------------------------------------------------------------------------------------------ + +The `models` directory in the above zip file can be generated by following the +instructions in the [Training](#training) section above. It +includes the following 3 model files: + +| Name | Format | Target Framework | Target Device | +| :------------- |:-------------|:-------------|-----| +| `model.pb` | Keras SavedModel | TensorFlow | Large-Scale/Cloud/Servers | +| `model.tflite` *(2.5 kB)* | Integer Only Quantized TFLite Model | TensorFlow Lite | Mobile Devices| +| `model.cc` | C Source File | TensorFlow Lite for Microcontrollers | Microcontrollers | + + +## Model Architecture + +The final model used to simulate a sine wave is displayed below. It is a +simple feed forward deep neural network with 2 fully connected layers with +ReLu activations and a final fully connected output layer with as shown below. + +![model_architecture.png](../images/model_architecture.png) + +*This image was derived from visualizing the 'model.tflite' file in [Netron](https://github.com/lutzroeder/netron)* + diff --git a/samples/modules/tensorflow/hello_world/train/train_hello_world_model.ipynb b/samples/modules/tensorflow/hello_world/train/train_hello_world_model.ipynb new file mode 100644 index 00000000000..54f8fcb360f --- /dev/null +++ b/samples/modules/tensorflow/hello_world/train/train_hello_world_model.ipynb @@ -0,0 +1,3691 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "train_hello_world_model.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "aCZBFzjClURz" + }, + "source": [ + "# Train a Simple TensorFlow Lite for Microcontrollers model\n", + "\n", + "This notebook demonstrates the process of training a 2.5 kB model using TensorFlow and converting it for use with TensorFlow Lite for Microcontrollers. \n", + "\n", + "Deep learning networks learn to model patterns in underlying data. Here, we're going to train a network to model data generated by a [sine](https://en.wikipedia.org/wiki/Sine) function. This will result in a model that can take a value, `x`, and predict its sine, `y`.\n", + "\n", + "The model created in this notebook is used in the [hello_world](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/micro/examples/hello_world) example for [TensorFlow Lite for MicroControllers](https://www.tensorflow.org/lite/microcontrollers/overview).\n", + "\n", + "\n", + " \n", + " \n", + "
\n", + " Run in Google Colab\n", + " \n", + " View source on GitHub\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_UQblnrLd_ET" + }, + "source": [ + "## Configure Defaults" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5PYwRFppd-WB" + }, + "source": [ + "# Define paths to model files\n", + "import os\n", + "MODELS_DIR = 'models/'\n", + "if not os.path.exists(MODELS_DIR):\n", + " os.mkdir(MODELS_DIR)\n", + "MODEL_TF = MODELS_DIR + 'model'\n", + "MODEL_NO_QUANT_TFLITE = MODELS_DIR + 'model_no_quant.tflite'\n", + "MODEL_TFLITE = MODELS_DIR + 'model.tflite'\n", + "MODEL_TFLITE_MICRO = MODELS_DIR + 'model.cc'" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dh4AXGuHWeu1" + }, + "source": [ + "## Setup Environment\n", + "\n", + "Install Dependencies" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cr1VLfotanf6", + "outputId": "510567d6-300e-40e2-f5b8-c3520a3f3a8b", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "source": [ + "! pip install tensorflow==2.4.0" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Requirement already satisfied: tensorflow==2.4.0rc0 in /usr/local/lib/python3.6/dist-packages (2.4.0rc0)\n", + "Requirement already satisfied: termcolor~=1.1.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.1.0)\n", + "Requirement already satisfied: gast==0.3.3 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (0.3.3)\n", + "Requirement already satisfied: astunparse~=1.6.3 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.6.3)\n", + "Requirement already satisfied: absl-py~=0.10 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (0.10.0)\n", + "Requirement already satisfied: keras-preprocessing~=1.1.2 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.1.2)\n", + "Requirement already satisfied: six~=1.15.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.15.0)\n", + "Requirement already satisfied: tensorboard~=2.3 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (2.3.0)\n", + "Requirement already satisfied: tensorflow-estimator~=2.3.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (2.3.0)\n", + "Requirement already satisfied: flatbuffers~=1.12.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.12)\n", + "Requirement already satisfied: google-pasta~=0.2 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (0.2.0)\n", + "Requirement already satisfied: protobuf~=3.13.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (3.13.0)\n", + "Requirement already satisfied: grpcio~=1.32.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.32.0)\n", + "Requirement already satisfied: h5py~=2.10.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (2.10.0)\n", + "Requirement already satisfied: wrapt~=1.12.1 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.12.1)\n", + "Requirement already satisfied: opt-einsum~=3.3.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (3.3.0)\n", + "Requirement already satisfied: numpy~=1.19.2 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (1.19.4)\n", + "Requirement already satisfied: typing-extensions~=3.7.4 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (3.7.4.3)\n", + "Requirement already satisfied: wheel~=0.35 in /usr/local/lib/python3.6/dist-packages (from tensorflow==2.4.0rc0) (0.35.1)\n", + "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.6/dist-packages (from tensorboard~=2.3->tensorflow==2.4.0rc0) (1.0.1)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tensorboard~=2.3->tensorflow==2.4.0rc0) (3.3.3)\n", + "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.6/dist-packages (from tensorboard~=2.3->tensorflow==2.4.0rc0) (0.4.2)\n", + "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard~=2.3->tensorflow==2.4.0rc0) (1.7.0)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard~=2.3->tensorflow==2.4.0rc0) (2.23.0)\n", + "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard~=2.3->tensorflow==2.4.0rc0) (50.3.2)\n", + "Requirement already satisfied: google-auth<2,>=1.6.3 in /usr/local/lib/python3.6/dist-packages (from tensorboard~=2.3->tensorflow==2.4.0rc0) (1.17.2)\n", + "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.6/dist-packages (from markdown>=2.6.8->tensorboard~=2.3->tensorflow==2.4.0rc0) (2.0.0)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard~=2.3->tensorflow==2.4.0rc0) (1.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.3->tensorflow==2.4.0rc0) (2020.6.20)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.3->tensorflow==2.4.0rc0) (1.24.3)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.3->tensorflow==2.4.0rc0) (3.0.4)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.3->tensorflow==2.4.0rc0) (2.10)\n", + "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard~=2.3->tensorflow==2.4.0rc0) (4.1.1)\n", + "Requirement already satisfied: rsa<5,>=3.1.4; python_version >= \"3\" in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard~=2.3->tensorflow==2.4.0rc0) (4.6)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard~=2.3->tensorflow==2.4.0rc0) (0.2.8)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.6/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard~=2.3->tensorflow==2.4.0rc0) (3.4.0)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.6/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard~=2.3->tensorflow==2.4.0rc0) (3.1.0)\n", + "Requirement already satisfied: pyasn1>=0.1.3 in /usr/local/lib/python3.6/dist-packages (from rsa<5,>=3.1.4; python_version >= \"3\"->google-auth<2,>=1.6.3->tensorboard~=2.3->tensorflow==2.4.0rc0) (0.4.8)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tx9lOPWh9grN" + }, + "source": [ + "Import Dependencies" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "53PBJBv1jEtJ" + }, + "source": [ + "# TensorFlow is an open source machine learning library\n", + "import tensorflow as tf\n", + "\n", + "# Keras is TensorFlow's high-level API for deep learning\n", + "from tensorflow import keras\n", + "# Numpy is a math library\n", + "import numpy as np\n", + "# Pandas is a data manipulation library \n", + "import pandas as pd\n", + "# Matplotlib is a graphing library\n", + "import matplotlib.pyplot as plt\n", + "# Math is Python's math library\n", + "import math\n", + "\n", + "# Set seed for experiment reproducibility\n", + "seed = 1\n", + "np.random.seed(seed)\n", + "tf.random.set_seed(seed)" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p-PuBEb6CMeo" + }, + "source": [ + "## Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7gB0-dlNmLT-" + }, + "source": [ + "### 1. Generate Data\n", + "\n", + "The code in the following cell will generate a set of random `x` values, calculate their sine values, and display them on a graph." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uKjg7QeMDsDx", + "outputId": "2ded7790-62a2-40df-a4f9-429f2dd5357f", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "source": [ + "# Number of sample datapoints\n", + "SAMPLES = 1000\n", + "\n", + "# Generate a uniformly distributed set of random numbers in the range from\n", + "# 0 to 2π, which covers a complete sine wave oscillation\n", + "x_values = np.random.uniform(\n", + " low=0, high=2*math.pi, size=SAMPLES).astype(np.float32)\n", + "\n", + "# Shuffle the values to guarantee they're not in order\n", + "np.random.shuffle(x_values)\n", + "\n", + "# Calculate the corresponding sine values\n", + "y_values = np.sin(x_values).astype(np.float32)\n", + "\n", + "# Plot our data. The 'b.' argument tells the library to print blue dots.\n", + "plt.plot(x_values, y_values, 'b.')\n", + "plt.show()" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iWOlC7W_FYvA" + }, + "source": [ + "### 2. Add Noise\n", + "Since it was generated directly by the sine function, our data fits a nice, smooth curve.\n", + "\n", + "However, machine learning models are good at extracting underlying meaning from messy, real world data. To demonstrate this, we can add some noise to our data to approximate something more life-like.\n", + "\n", + "In the following cell, we'll add some random noise to each value, then draw a new graph:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "i0FJe3Y-Gkac", + "outputId": "10d4d994-3b78-4512-a029-5ef0e444d75c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "source": [ + "# Add a small random number to each y value\n", + "y_values += 0.1 * np.random.randn(*y_values.shape)\n", + "\n", + "# Plot our data\n", + "plt.plot(x_values, y_values, 'b.')\n", + "plt.show()" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Up8Xk_pMH4Rt" + }, + "source": [ + "### 3. Split the Data\n", + "We now have a noisy dataset that approximates real world data. We'll be using this to train our model.\n", + "\n", + "To evaluate the accuracy of the model we train, we'll need to compare its predictions to real data and check how well they match up. This evaluation happens during training (where it is referred to as validation) and after training (referred to as testing) It's important in both cases that we use fresh data that was not already used to train the model.\n", + "\n", + "The data is split as follows:\n", + " 1. Training: 60%\n", + " 2. Validation: 20%\n", + " 3. Testing: 20% \n", + "\n", + "The following code will split our data and then plots each set as a different color:\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nNYko5L1keqZ", + "outputId": "e1e6915d-5cfe-4086-d20f-8e3aebd80292", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "source": [ + "# We'll use 60% of our data for training and 20% for testing. The remaining 20%\n", + "# will be used for validation. Calculate the indices of each section.\n", + "TRAIN_SPLIT = int(0.6 * SAMPLES)\n", + "TEST_SPLIT = int(0.2 * SAMPLES + TRAIN_SPLIT)\n", + "\n", + "# Use np.split to chop our data into three parts.\n", + "# The second argument to np.split is an array of indices where the data will be\n", + "# split. We provide two indices, so the data will be divided into three chunks.\n", + "x_train, x_test, x_validate = np.split(x_values, [TRAIN_SPLIT, TEST_SPLIT])\n", + "y_train, y_test, y_validate = np.split(y_values, [TRAIN_SPLIT, TEST_SPLIT])\n", + "\n", + "# Double check that our splits add up correctly\n", + "assert (x_train.size + x_validate.size + x_test.size) == SAMPLES\n", + "\n", + "# Plot the data in each partition in different colors:\n", + "plt.plot(x_train, y_train, 'b.', label=\"Train\")\n", + "plt.plot(x_test, y_test, 'r.', label=\"Test\")\n", + "plt.plot(x_validate, y_validate, 'y.', label=\"Validate\")\n", + "plt.legend()\n", + "plt.show()\n" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wfdelu1TmgPk" + }, + "source": [ + "## Training" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t5McVnHmNiDw" + }, + "source": [ + "### 1. Design the Model\n", + "We're going to build a simple neural network model that will take an input value (in this case, `x`) and use it to predict a numeric output value (the sine of `x`). This type of problem is called a _regression_. It will use _layers_ of _neurons_ to attempt to learn any patterns underlying the training data, so it can make predictions.\n", + "\n", + "To begin with, we'll define two layers. The first layer takes a single input (our `x` value) and runs it through 8 neurons. Based on this input, each neuron will become _activated_ to a certain degree based on its internal state (its _weight_ and _bias_ values). A neuron's degree of activation is expressed as a number.\n", + "\n", + "The activation numbers from our first layer will be fed as inputs to our second layer, which is a single neuron. It will apply its own weights and bias to these inputs and calculate its own activation, which will be output as our `y` value.\n", + "\n", + "**Note:** To learn more about how neural networks function, you can explore the [Learn TensorFlow](https://codelabs.developers.google.com/codelabs/tensorflow-lab1-helloworld) codelabs.\n", + "\n", + "The code in the following cell defines our model using [Keras](https://www.tensorflow.org/guide/keras), TensorFlow's high-level API for creating deep learning networks. Once the network is defined, we _compile_ it, specifying parameters that determine how it will be trained:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gD60bE8cXQId" + }, + "source": [ + "# We'll use Keras to create a simple model architecture\n", + "model_1 = tf.keras.Sequential()\n", + "\n", + "# First layer takes a scalar input and feeds it through 8 \"neurons\". The\n", + "# neurons decide whether to activate based on the 'relu' activation function.\n", + "model_1.add(keras.layers.Dense(8, activation='relu', input_shape=(1,)))\n", + "\n", + "# Final layer is a single neuron, since we want to output a single value\n", + "model_1.add(keras.layers.Dense(1))\n", + "\n", + "# Compile the model using the standard 'adam' optimizer and the mean squared error or 'mse' loss function for regression.\n", + "model_1.compile(optimizer='adam', loss='mse', metrics=['mae'])" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O0idLyRLQeGj" + }, + "source": [ + "### 2. Train the Model\n", + "Once we've defined the model, we can use our data to _train_ it. Training involves passing an `x` value into the neural network, checking how far the network's output deviates from the expected `y` value, and adjusting the neurons' weights and biases so that the output is more likely to be correct the next time.\n", + "\n", + "Training runs this process on the full dataset multiple times, and each full run-through is known as an _epoch_. The number of epochs to run during training is a parameter we can set.\n", + "\n", + "During each epoch, data is run through the network in multiple _batches_. Each batch, several pieces of data are passed into the network, producing output values. These outputs' correctness is measured in aggregate and the network's weights and biases are adjusted accordingly, once per batch. The _batch size_ is also a parameter we can set.\n", + "\n", + "The code in the following cell uses the `x` and `y` values from our training data to train the model. It runs for 500 _epochs_, with 64 pieces of data in each _batch_. We also pass in some data for _validation_. As you will see when you run the cell, training can take a while to complete:\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "p8hQKr4cVOdE", + "outputId": "e275e119-9fea-451e-89ae-6b3746cbf96d", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "source": [ + "# Train the model on our training data while validating on our validation set\n", + "history_1 = model_1.fit(x_train, y_train, epochs=500, batch_size=64,\n", + " validation_data=(x_validate, y_validate))" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Epoch 1/500\n", + "10/10 [==============================] - 1s 47ms/step - loss: 0.7289 - mae: 0.7120 - val_loss: 0.6401 - val_mae: 0.6504\n", + "Epoch 2/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.6329 - mae: 0.6488 - val_loss: 0.5587 - val_mae: 0.6031\n", + "Epoch 3/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.5201 - mae: 0.5735 - val_loss: 0.5014 - val_mae: 0.5763\n", + "Epoch 4/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.5057 - mae: 0.5760 - val_loss: 0.4632 - val_mae: 0.5615\n", + "Epoch 5/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.4502 - mae: 0.5459 - val_loss: 0.4386 - val_mae: 0.5536\n", + "Epoch 6/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.4168 - mae: 0.5332 - val_loss: 0.4227 - val_mae: 0.5490\n", + "Epoch 7/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.4211 - mae: 0.5341 - val_loss: 0.4125 - val_mae: 0.5464\n", + "Epoch 8/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3988 - mae: 0.5287 - val_loss: 0.4060 - val_mae: 0.5452\n", + "Epoch 9/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3901 - mae: 0.5230 - val_loss: 0.4014 - val_mae: 0.5440\n", + "Epoch 10/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3804 - mae: 0.5179 - val_loss: 0.3979 - val_mae: 0.5426\n", + "Epoch 11/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3695 - mae: 0.5150 - val_loss: 0.3950 - val_mae: 0.5412\n", + "Epoch 12/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3856 - mae: 0.5245 - val_loss: 0.3921 - val_mae: 0.5399\n", + "Epoch 13/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3744 - mae: 0.5184 - val_loss: 0.3893 - val_mae: 0.5386\n", + "Epoch 14/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3749 - mae: 0.5175 - val_loss: 0.3865 - val_mae: 0.5371\n", + "Epoch 15/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3467 - mae: 0.4993 - val_loss: 0.3837 - val_mae: 0.5354\n", + "Epoch 16/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3736 - mae: 0.5234 - val_loss: 0.3808 - val_mae: 0.5336\n", + "Epoch 17/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3655 - mae: 0.5148 - val_loss: 0.3778 - val_mae: 0.5318\n", + "Epoch 18/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3558 - mae: 0.5067 - val_loss: 0.3747 - val_mae: 0.5297\n", + "Epoch 19/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3343 - mae: 0.4908 - val_loss: 0.3716 - val_mae: 0.5275\n", + "Epoch 20/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3742 - mae: 0.5257 - val_loss: 0.3686 - val_mae: 0.5258\n", + "Epoch 21/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3296 - mae: 0.4831 - val_loss: 0.3654 - val_mae: 0.5235\n", + "Epoch 22/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3432 - mae: 0.4962 - val_loss: 0.3622 - val_mae: 0.5214\n", + "Epoch 23/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3397 - mae: 0.4951 - val_loss: 0.3589 - val_mae: 0.5191\n", + "Epoch 24/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3229 - mae: 0.4803 - val_loss: 0.3558 - val_mae: 0.5172\n", + "Epoch 25/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3562 - mae: 0.5105 - val_loss: 0.3524 - val_mae: 0.5150\n", + "Epoch 26/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3458 - mae: 0.5042 - val_loss: 0.3492 - val_mae: 0.5128\n", + "Epoch 27/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3163 - mae: 0.4764 - val_loss: 0.3459 - val_mae: 0.5106\n", + "Epoch 28/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3441 - mae: 0.5018 - val_loss: 0.3427 - val_mae: 0.5086\n", + "Epoch 29/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3062 - mae: 0.4705 - val_loss: 0.3395 - val_mae: 0.5065\n", + "Epoch 30/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3202 - mae: 0.4808 - val_loss: 0.3362 - val_mae: 0.5043\n", + "Epoch 31/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.3313 - mae: 0.4919 - val_loss: 0.3330 - val_mae: 0.5022\n", + "Epoch 32/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.3028 - mae: 0.4682 - val_loss: 0.3297 - val_mae: 0.4996\n", + "Epoch 33/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3056 - mae: 0.4670 - val_loss: 0.3264 - val_mae: 0.4972\n", + "Epoch 34/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3203 - mae: 0.4781 - val_loss: 0.3233 - val_mae: 0.4954\n", + "Epoch 35/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3256 - mae: 0.4912 - val_loss: 0.3201 - val_mae: 0.4929\n", + "Epoch 36/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3079 - mae: 0.4728 - val_loss: 0.3170 - val_mae: 0.4905\n", + "Epoch 37/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2969 - mae: 0.4641 - val_loss: 0.3139 - val_mae: 0.4885\n", + "Epoch 38/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3043 - mae: 0.4693 - val_loss: 0.3108 - val_mae: 0.4863\n", + "Epoch 39/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2902 - mae: 0.4549 - val_loss: 0.3078 - val_mae: 0.4843\n", + "Epoch 40/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3003 - mae: 0.4720 - val_loss: 0.3047 - val_mae: 0.4823\n", + "Epoch 41/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2970 - mae: 0.4678 - val_loss: 0.3017 - val_mae: 0.4804\n", + "Epoch 42/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2903 - mae: 0.4582 - val_loss: 0.2988 - val_mae: 0.4787\n", + "Epoch 43/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2853 - mae: 0.4553 - val_loss: 0.2960 - val_mae: 0.4769\n", + "Epoch 44/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2910 - mae: 0.4603 - val_loss: 0.2931 - val_mae: 0.4748\n", + "Epoch 45/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2819 - mae: 0.4533 - val_loss: 0.2902 - val_mae: 0.4727\n", + "Epoch 46/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2744 - mae: 0.4525 - val_loss: 0.2872 - val_mae: 0.4697\n", + "Epoch 47/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2707 - mae: 0.4411 - val_loss: 0.2845 - val_mae: 0.4680\n", + "Epoch 48/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2641 - mae: 0.4414 - val_loss: 0.2818 - val_mae: 0.4661\n", + "Epoch 49/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2642 - mae: 0.4378 - val_loss: 0.2793 - val_mae: 0.4647\n", + "Epoch 50/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2603 - mae: 0.4385 - val_loss: 0.2767 - val_mae: 0.4628\n", + "Epoch 51/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2684 - mae: 0.4473 - val_loss: 0.2740 - val_mae: 0.4604\n", + "Epoch 52/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2539 - mae: 0.4312 - val_loss: 0.2714 - val_mae: 0.4583\n", + "Epoch 53/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2621 - mae: 0.4417 - val_loss: 0.2690 - val_mae: 0.4568\n", + "Epoch 54/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2556 - mae: 0.4366 - val_loss: 0.2664 - val_mae: 0.4545\n", + "Epoch 55/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2524 - mae: 0.4309 - val_loss: 0.2639 - val_mae: 0.4525\n", + "Epoch 56/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2555 - mae: 0.4364 - val_loss: 0.2614 - val_mae: 0.4507\n", + "Epoch 57/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2483 - mae: 0.4264 - val_loss: 0.2589 - val_mae: 0.4485\n", + "Epoch 58/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.2403 - mae: 0.4212 - val_loss: 0.2564 - val_mae: 0.4460\n", + "Epoch 59/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2462 - mae: 0.4274 - val_loss: 0.2542 - val_mae: 0.4446\n", + "Epoch 60/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2364 - mae: 0.4178 - val_loss: 0.2522 - val_mae: 0.4437\n", + "Epoch 61/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2409 - mae: 0.4254 - val_loss: 0.2500 - val_mae: 0.4418\n", + "Epoch 62/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2338 - mae: 0.4172 - val_loss: 0.2478 - val_mae: 0.4400\n", + "Epoch 63/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2283 - mae: 0.4132 - val_loss: 0.2456 - val_mae: 0.4381\n", + "Epoch 64/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2438 - mae: 0.4330 - val_loss: 0.2433 - val_mae: 0.4360\n", + "Epoch 65/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2169 - mae: 0.4049 - val_loss: 0.2415 - val_mae: 0.4348\n", + "Epoch 66/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2208 - mae: 0.4087 - val_loss: 0.2393 - val_mae: 0.4329\n", + "Epoch 67/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2440 - mae: 0.4321 - val_loss: 0.2373 - val_mae: 0.4312\n", + "Epoch 68/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2250 - mae: 0.4131 - val_loss: 0.2353 - val_mae: 0.4295\n", + "Epoch 69/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2222 - mae: 0.4081 - val_loss: 0.2334 - val_mae: 0.4277\n", + "Epoch 70/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2245 - mae: 0.4138 - val_loss: 0.2316 - val_mae: 0.4261\n", + "Epoch 71/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2132 - mae: 0.3983 - val_loss: 0.2298 - val_mae: 0.4244\n", + "Epoch 72/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.2232 - mae: 0.4144 - val_loss: 0.2280 - val_mae: 0.4227\n", + "Epoch 73/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.2077 - mae: 0.3941 - val_loss: 0.2265 - val_mae: 0.4219\n", + "Epoch 74/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2116 - mae: 0.3993 - val_loss: 0.2249 - val_mae: 0.4205\n", + "Epoch 75/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.2227 - mae: 0.4148 - val_loss: 0.2235 - val_mae: 0.4198\n", + "Epoch 76/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2026 - mae: 0.3917 - val_loss: 0.2216 - val_mae: 0.4175\n", + "Epoch 77/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2083 - mae: 0.3966 - val_loss: 0.2200 - val_mae: 0.4157\n", + "Epoch 78/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2055 - mae: 0.3947 - val_loss: 0.2186 - val_mae: 0.4144\n", + "Epoch 79/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2069 - mae: 0.3965 - val_loss: 0.2171 - val_mae: 0.4128\n", + "Epoch 80/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1983 - mae: 0.3871 - val_loss: 0.2158 - val_mae: 0.4117\n", + "Epoch 81/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1994 - mae: 0.3876 - val_loss: 0.2146 - val_mae: 0.4109\n", + "Epoch 82/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1971 - mae: 0.3824 - val_loss: 0.2135 - val_mae: 0.4104\n", + "Epoch 83/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1965 - mae: 0.3879 - val_loss: 0.2120 - val_mae: 0.4085\n", + "Epoch 84/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2006 - mae: 0.3906 - val_loss: 0.2109 - val_mae: 0.4074\n", + "Epoch 85/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2048 - mae: 0.3979 - val_loss: 0.2096 - val_mae: 0.4057\n", + "Epoch 86/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1932 - mae: 0.3864 - val_loss: 0.2083 - val_mae: 0.4042\n", + "Epoch 87/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1916 - mae: 0.3830 - val_loss: 0.2073 - val_mae: 0.4036\n", + "Epoch 88/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1984 - mae: 0.3905 - val_loss: 0.2062 - val_mae: 0.4023\n", + "Epoch 89/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1939 - mae: 0.3874 - val_loss: 0.2052 - val_mae: 0.4010\n", + "Epoch 90/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1902 - mae: 0.3827 - val_loss: 0.2042 - val_mae: 0.4001\n", + "Epoch 91/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1888 - mae: 0.3784 - val_loss: 0.2038 - val_mae: 0.4009\n", + "Epoch 92/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1927 - mae: 0.3843 - val_loss: 0.2030 - val_mae: 0.4003\n", + "Epoch 93/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1851 - mae: 0.3730 - val_loss: 0.2018 - val_mae: 0.3981\n", + "Epoch 94/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1984 - mae: 0.3916 - val_loss: 0.2008 - val_mae: 0.3963\n", + "Epoch 95/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1851 - mae: 0.3733 - val_loss: 0.2001 - val_mae: 0.3960\n", + "Epoch 96/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1881 - mae: 0.3796 - val_loss: 0.1994 - val_mae: 0.3953\n", + "Epoch 97/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1859 - mae: 0.3765 - val_loss: 0.1987 - val_mae: 0.3949\n", + "Epoch 98/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1822 - mae: 0.3711 - val_loss: 0.1979 - val_mae: 0.3935\n", + "Epoch 99/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1886 - mae: 0.3764 - val_loss: 0.1970 - val_mae: 0.3915\n", + "Epoch 100/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1878 - mae: 0.3758 - val_loss: 0.1964 - val_mae: 0.3908\n", + "Epoch 101/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1769 - mae: 0.3670 - val_loss: 0.1958 - val_mae: 0.3897\n", + "Epoch 102/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1832 - mae: 0.3731 - val_loss: 0.1953 - val_mae: 0.3897\n", + "Epoch 103/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1827 - mae: 0.3728 - val_loss: 0.1952 - val_mae: 0.3910\n", + "Epoch 104/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1867 - mae: 0.3783 - val_loss: 0.1945 - val_mae: 0.3898\n", + "Epoch 105/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1813 - mae: 0.3691 - val_loss: 0.1937 - val_mae: 0.3869\n", + "Epoch 106/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1715 - mae: 0.3605 - val_loss: 0.1932 - val_mae: 0.3869\n", + "Epoch 107/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1800 - mae: 0.3692 - val_loss: 0.1928 - val_mae: 0.3859\n", + "Epoch 108/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1884 - mae: 0.3725 - val_loss: 0.1925 - val_mae: 0.3863\n", + "Epoch 109/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1777 - mae: 0.3686 - val_loss: 0.1922 - val_mae: 0.3862\n", + "Epoch 110/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1801 - mae: 0.3715 - val_loss: 0.1917 - val_mae: 0.3853\n", + "Epoch 111/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1794 - mae: 0.3665 - val_loss: 0.1913 - val_mae: 0.3846\n", + "Epoch 112/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1811 - mae: 0.3664 - val_loss: 0.1908 - val_mae: 0.3831\n", + "Epoch 113/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1821 - mae: 0.3655 - val_loss: 0.1904 - val_mae: 0.3823\n", + "Epoch 114/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1755 - mae: 0.3621 - val_loss: 0.1901 - val_mae: 0.3818\n", + "Epoch 115/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1718 - mae: 0.3584 - val_loss: 0.1899 - val_mae: 0.3820\n", + "Epoch 116/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1684 - mae: 0.3516 - val_loss: 0.1896 - val_mae: 0.3815\n", + "Epoch 117/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1760 - mae: 0.3618 - val_loss: 0.1894 - val_mae: 0.3816\n", + "Epoch 118/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1748 - mae: 0.3587 - val_loss: 0.1890 - val_mae: 0.3804\n", + "Epoch 119/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1749 - mae: 0.3626 - val_loss: 0.1887 - val_mae: 0.3792\n", + "Epoch 120/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1620 - mae: 0.3493 - val_loss: 0.1884 - val_mae: 0.3779\n", + "Epoch 121/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1720 - mae: 0.3573 - val_loss: 0.1883 - val_mae: 0.3789\n", + "Epoch 122/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.1767 - mae: 0.3623 - val_loss: 0.1881 - val_mae: 0.3787\n", + "Epoch 123/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1835 - mae: 0.3729 - val_loss: 0.1881 - val_mae: 0.3794\n", + "Epoch 124/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1782 - mae: 0.3691 - val_loss: 0.1876 - val_mae: 0.3775\n", + "Epoch 125/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1669 - mae: 0.3548 - val_loss: 0.1877 - val_mae: 0.3784\n", + "Epoch 126/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1819 - mae: 0.3693 - val_loss: 0.1878 - val_mae: 0.3791\n", + "Epoch 127/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1731 - mae: 0.3626 - val_loss: 0.1877 - val_mae: 0.3789\n", + "Epoch 128/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1696 - mae: 0.3556 - val_loss: 0.1872 - val_mae: 0.3773\n", + "Epoch 129/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1764 - mae: 0.3649 - val_loss: 0.1869 - val_mae: 0.3758\n", + "Epoch 130/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1770 - mae: 0.3649 - val_loss: 0.1867 - val_mae: 0.3750\n", + "Epoch 131/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1857 - mae: 0.3696 - val_loss: 0.1867 - val_mae: 0.3760\n", + "Epoch 132/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1715 - mae: 0.3566 - val_loss: 0.1865 - val_mae: 0.3754\n", + "Epoch 133/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1717 - mae: 0.3536 - val_loss: 0.1869 - val_mae: 0.3772\n", + "Epoch 134/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1692 - mae: 0.3558 - val_loss: 0.1863 - val_mae: 0.3751\n", + "Epoch 135/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1844 - mae: 0.3690 - val_loss: 0.1862 - val_mae: 0.3744\n", + "Epoch 136/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1608 - mae: 0.3431 - val_loss: 0.1861 - val_mae: 0.3737\n", + "Epoch 137/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1626 - mae: 0.3457 - val_loss: 0.1860 - val_mae: 0.3739\n", + "Epoch 138/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1705 - mae: 0.3598 - val_loss: 0.1861 - val_mae: 0.3748\n", + "Epoch 139/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1797 - mae: 0.3651 - val_loss: 0.1863 - val_mae: 0.3759\n", + "Epoch 140/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1692 - mae: 0.3543 - val_loss: 0.1858 - val_mae: 0.3739\n", + "Epoch 141/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1696 - mae: 0.3572 - val_loss: 0.1859 - val_mae: 0.3743\n", + "Epoch 142/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1652 - mae: 0.3503 - val_loss: 0.1861 - val_mae: 0.3754\n", + "Epoch 143/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1644 - mae: 0.3504 - val_loss: 0.1857 - val_mae: 0.3734\n", + "Epoch 144/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1721 - mae: 0.3567 - val_loss: 0.1855 - val_mae: 0.3728\n", + "Epoch 145/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1772 - mae: 0.3612 - val_loss: 0.1856 - val_mae: 0.3737\n", + "Epoch 146/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1654 - mae: 0.3502 - val_loss: 0.1856 - val_mae: 0.3736\n", + "Epoch 147/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1761 - mae: 0.3575 - val_loss: 0.1856 - val_mae: 0.3738\n", + "Epoch 148/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1693 - mae: 0.3542 - val_loss: 0.1853 - val_mae: 0.3719\n", + "Epoch 149/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1634 - mae: 0.3450 - val_loss: 0.1854 - val_mae: 0.3727\n", + "Epoch 150/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1642 - mae: 0.3457 - val_loss: 0.1853 - val_mae: 0.3723\n", + "Epoch 151/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1868 - mae: 0.3703 - val_loss: 0.1854 - val_mae: 0.3731\n", + "Epoch 152/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1797 - mae: 0.3615 - val_loss: 0.1852 - val_mae: 0.3716\n", + "Epoch 153/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1739 - mae: 0.3548 - val_loss: 0.1851 - val_mae: 0.3716\n", + "Epoch 154/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1779 - mae: 0.3633 - val_loss: 0.1851 - val_mae: 0.3711\n", + "Epoch 155/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1606 - mae: 0.3401 - val_loss: 0.1850 - val_mae: 0.3709\n", + "Epoch 156/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1834 - mae: 0.3646 - val_loss: 0.1853 - val_mae: 0.3728\n", + "Epoch 157/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1704 - mae: 0.3552 - val_loss: 0.1850 - val_mae: 0.3712\n", + "Epoch 158/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1741 - mae: 0.3575 - val_loss: 0.1850 - val_mae: 0.3714\n", + "Epoch 159/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1624 - mae: 0.3450 - val_loss: 0.1849 - val_mae: 0.3705\n", + "Epoch 160/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1691 - mae: 0.3547 - val_loss: 0.1850 - val_mae: 0.3712\n", + "Epoch 161/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1604 - mae: 0.3414 - val_loss: 0.1849 - val_mae: 0.3703\n", + "Epoch 162/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.1600 - mae: 0.3412 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 163/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1564 - mae: 0.3413 - val_loss: 0.1848 - val_mae: 0.3694\n", + "Epoch 164/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1664 - mae: 0.3461 - val_loss: 0.1851 - val_mae: 0.3719\n", + "Epoch 165/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1672 - mae: 0.3500 - val_loss: 0.1848 - val_mae: 0.3698\n", + "Epoch 166/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1717 - mae: 0.3600 - val_loss: 0.1847 - val_mae: 0.3694\n", + "Epoch 167/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1645 - mae: 0.3450 - val_loss: 0.1849 - val_mae: 0.3707\n", + "Epoch 168/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1697 - mae: 0.3467 - val_loss: 0.1853 - val_mae: 0.3724\n", + "Epoch 169/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1742 - mae: 0.3566 - val_loss: 0.1850 - val_mae: 0.3712\n", + "Epoch 170/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1650 - mae: 0.3455 - val_loss: 0.1847 - val_mae: 0.3693\n", + "Epoch 171/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1667 - mae: 0.3511 - val_loss: 0.1847 - val_mae: 0.3693\n", + "Epoch 172/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1689 - mae: 0.3476 - val_loss: 0.1849 - val_mae: 0.3710\n", + "Epoch 173/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1709 - mae: 0.3538 - val_loss: 0.1848 - val_mae: 0.3706\n", + "Epoch 174/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1794 - mae: 0.3588 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 175/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1753 - mae: 0.3539 - val_loss: 0.1846 - val_mae: 0.3680\n", + "Epoch 176/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1704 - mae: 0.3511 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 177/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1635 - mae: 0.3465 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 178/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1669 - mae: 0.3508 - val_loss: 0.1850 - val_mae: 0.3712\n", + "Epoch 179/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1661 - mae: 0.3434 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 180/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1668 - mae: 0.3500 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 181/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1600 - mae: 0.3416 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 182/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1672 - mae: 0.3500 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 183/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1663 - mae: 0.3461 - val_loss: 0.1847 - val_mae: 0.3698\n", + "Epoch 184/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1690 - mae: 0.3494 - val_loss: 0.1847 - val_mae: 0.3695\n", + "Epoch 185/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1716 - mae: 0.3513 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 186/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1748 - mae: 0.3588 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 187/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1588 - mae: 0.3364 - val_loss: 0.1849 - val_mae: 0.3705\n", + "Epoch 188/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1739 - mae: 0.3539 - val_loss: 0.1849 - val_mae: 0.3704\n", + "Epoch 189/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1711 - mae: 0.3497 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 190/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1706 - mae: 0.3525 - val_loss: 0.1845 - val_mae: 0.3678\n", + "Epoch 191/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1621 - mae: 0.3447 - val_loss: 0.1846 - val_mae: 0.3688\n", + "Epoch 192/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1669 - mae: 0.3485 - val_loss: 0.1847 - val_mae: 0.3699\n", + "Epoch 193/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1694 - mae: 0.3498 - val_loss: 0.1847 - val_mae: 0.3697\n", + "Epoch 194/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1708 - mae: 0.3520 - val_loss: 0.1846 - val_mae: 0.3694\n", + "Epoch 195/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1796 - mae: 0.3623 - val_loss: 0.1849 - val_mae: 0.3708\n", + "Epoch 196/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1624 - mae: 0.3417 - val_loss: 0.1849 - val_mae: 0.3706\n", + "Epoch 197/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1671 - mae: 0.3529 - val_loss: 0.1848 - val_mae: 0.3703\n", + "Epoch 198/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1680 - mae: 0.3479 - val_loss: 0.1845 - val_mae: 0.3690\n", + "Epoch 199/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1750 - mae: 0.3587 - val_loss: 0.1844 - val_mae: 0.3677\n", + "Epoch 200/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1613 - mae: 0.3419 - val_loss: 0.1845 - val_mae: 0.3684\n", + "Epoch 201/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1625 - mae: 0.3434 - val_loss: 0.1845 - val_mae: 0.3684\n", + "Epoch 202/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1780 - mae: 0.3576 - val_loss: 0.1845 - val_mae: 0.3688\n", + "Epoch 203/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1567 - mae: 0.3381 - val_loss: 0.1845 - val_mae: 0.3677\n", + "Epoch 204/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1675 - mae: 0.3489 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 205/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1766 - mae: 0.3609 - val_loss: 0.1847 - val_mae: 0.3694\n", + "Epoch 206/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1649 - mae: 0.3489 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 207/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1723 - mae: 0.3526 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 208/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1788 - mae: 0.3573 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 209/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1659 - mae: 0.3427 - val_loss: 0.1847 - val_mae: 0.3694\n", + "Epoch 210/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1737 - mae: 0.3549 - val_loss: 0.1845 - val_mae: 0.3684\n", + "Epoch 211/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1616 - mae: 0.3437 - val_loss: 0.1845 - val_mae: 0.3686\n", + "Epoch 212/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.1665 - mae: 0.3466 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 213/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1726 - mae: 0.3560 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 214/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1716 - mae: 0.3516 - val_loss: 0.1844 - val_mae: 0.3673\n", + "Epoch 215/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1662 - mae: 0.3398 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 216/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1773 - mae: 0.3588 - val_loss: 0.1845 - val_mae: 0.3686\n", + "Epoch 217/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1645 - mae: 0.3485 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 218/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1664 - mae: 0.3514 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 219/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1775 - mae: 0.3572 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 220/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1650 - mae: 0.3451 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 221/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1607 - mae: 0.3393 - val_loss: 0.1845 - val_mae: 0.3686\n", + "Epoch 222/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1796 - mae: 0.3623 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 223/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1759 - mae: 0.3592 - val_loss: 0.1845 - val_mae: 0.3682\n", + "Epoch 224/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1702 - mae: 0.3513 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 225/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1823 - mae: 0.3648 - val_loss: 0.1852 - val_mae: 0.3715\n", + "Epoch 226/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1698 - mae: 0.3515 - val_loss: 0.1848 - val_mae: 0.3701\n", + "Epoch 227/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1658 - mae: 0.3447 - val_loss: 0.1847 - val_mae: 0.3699\n", + "Epoch 228/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1756 - mae: 0.3553 - val_loss: 0.1846 - val_mae: 0.3694\n", + "Epoch 229/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1670 - mae: 0.3549 - val_loss: 0.1844 - val_mae: 0.3671\n", + "Epoch 230/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1685 - mae: 0.3480 - val_loss: 0.1845 - val_mae: 0.3682\n", + "Epoch 231/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1740 - mae: 0.3578 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 232/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1774 - mae: 0.3602 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 233/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1566 - mae: 0.3383 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 234/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1714 - mae: 0.3518 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 235/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1650 - mae: 0.3435 - val_loss: 0.1847 - val_mae: 0.3697\n", + "Epoch 236/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1721 - mae: 0.3513 - val_loss: 0.1846 - val_mae: 0.3694\n", + "Epoch 237/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1710 - mae: 0.3535 - val_loss: 0.1845 - val_mae: 0.3683\n", + "Epoch 238/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1638 - mae: 0.3453 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 239/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1687 - mae: 0.3518 - val_loss: 0.1845 - val_mae: 0.3687\n", + "Epoch 240/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1701 - mae: 0.3519 - val_loss: 0.1847 - val_mae: 0.3697\n", + "Epoch 241/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1721 - mae: 0.3530 - val_loss: 0.1849 - val_mae: 0.3703\n", + "Epoch 242/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1610 - mae: 0.3413 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 243/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1556 - mae: 0.3387 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 244/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1663 - mae: 0.3485 - val_loss: 0.1845 - val_mae: 0.3688\n", + "Epoch 245/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1761 - mae: 0.3585 - val_loss: 0.1848 - val_mae: 0.3703\n", + "Epoch 246/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1592 - mae: 0.3394 - val_loss: 0.1849 - val_mae: 0.3706\n", + "Epoch 247/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1724 - mae: 0.3568 - val_loss: 0.1845 - val_mae: 0.3682\n", + "Epoch 248/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1668 - mae: 0.3516 - val_loss: 0.1844 - val_mae: 0.3671\n", + "Epoch 249/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1676 - mae: 0.3474 - val_loss: 0.1845 - val_mae: 0.3688\n", + "Epoch 250/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1747 - mae: 0.3563 - val_loss: 0.1844 - val_mae: 0.3680\n", + "Epoch 251/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1766 - mae: 0.3607 - val_loss: 0.1844 - val_mae: 0.3676\n", + "Epoch 252/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1693 - mae: 0.3522 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 253/500\n", + "10/10 [==============================] - 0s 19ms/step - loss: 0.1632 - mae: 0.3429 - val_loss: 0.1844 - val_mae: 0.3675\n", + "Epoch 254/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1747 - mae: 0.3537 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 255/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1731 - mae: 0.3574 - val_loss: 0.1847 - val_mae: 0.3695\n", + "Epoch 256/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1696 - mae: 0.3525 - val_loss: 0.1845 - val_mae: 0.3676\n", + "Epoch 257/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1572 - mae: 0.3387 - val_loss: 0.1845 - val_mae: 0.3681\n", + "Epoch 258/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1617 - mae: 0.3409 - val_loss: 0.1849 - val_mae: 0.3702\n", + "Epoch 259/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1809 - mae: 0.3600 - val_loss: 0.1850 - val_mae: 0.3707\n", + "Epoch 260/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1633 - mae: 0.3435 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 261/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1684 - mae: 0.3506 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 262/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1710 - mae: 0.3512 - val_loss: 0.1848 - val_mae: 0.3703\n", + "Epoch 263/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1657 - mae: 0.3471 - val_loss: 0.1850 - val_mae: 0.3709\n", + "Epoch 264/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1764 - mae: 0.3611 - val_loss: 0.1849 - val_mae: 0.3704\n", + "Epoch 265/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1710 - mae: 0.3487 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 266/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1759 - mae: 0.3565 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 267/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1680 - mae: 0.3505 - val_loss: 0.1844 - val_mae: 0.3669\n", + "Epoch 268/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1764 - mae: 0.3597 - val_loss: 0.1844 - val_mae: 0.3671\n", + "Epoch 269/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1676 - mae: 0.3494 - val_loss: 0.1847 - val_mae: 0.3693\n", + "Epoch 270/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1641 - mae: 0.3478 - val_loss: 0.1846 - val_mae: 0.3687\n", + "Epoch 271/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1784 - mae: 0.3615 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 272/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1767 - mae: 0.3571 - val_loss: 0.1846 - val_mae: 0.3687\n", + "Epoch 273/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1714 - mae: 0.3521 - val_loss: 0.1845 - val_mae: 0.3676\n", + "Epoch 274/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1710 - mae: 0.3503 - val_loss: 0.1845 - val_mae: 0.3678\n", + "Epoch 275/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1729 - mae: 0.3507 - val_loss: 0.1845 - val_mae: 0.3683\n", + "Epoch 276/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1754 - mae: 0.3579 - val_loss: 0.1845 - val_mae: 0.3677\n", + "Epoch 277/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1705 - mae: 0.3504 - val_loss: 0.1845 - val_mae: 0.3672\n", + "Epoch 278/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1721 - mae: 0.3553 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 279/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1664 - mae: 0.3476 - val_loss: 0.1847 - val_mae: 0.3692\n", + "Epoch 280/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1655 - mae: 0.3467 - val_loss: 0.1847 - val_mae: 0.3692\n", + "Epoch 281/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1693 - mae: 0.3534 - val_loss: 0.1846 - val_mae: 0.3687\n", + "Epoch 282/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1732 - mae: 0.3580 - val_loss: 0.1847 - val_mae: 0.3692\n", + "Epoch 283/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1779 - mae: 0.3598 - val_loss: 0.1847 - val_mae: 0.3694\n", + "Epoch 284/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1763 - mae: 0.3570 - val_loss: 0.1849 - val_mae: 0.3705\n", + "Epoch 285/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1636 - mae: 0.3474 - val_loss: 0.1845 - val_mae: 0.3674\n", + "Epoch 286/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1716 - mae: 0.3496 - val_loss: 0.1845 - val_mae: 0.3680\n", + "Epoch 287/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1769 - mae: 0.3579 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 288/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1771 - mae: 0.3565 - val_loss: 0.1856 - val_mae: 0.3726\n", + "Epoch 289/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1709 - mae: 0.3516 - val_loss: 0.1848 - val_mae: 0.3703\n", + "Epoch 290/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1719 - mae: 0.3584 - val_loss: 0.1844 - val_mae: 0.3675\n", + "Epoch 291/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1730 - mae: 0.3544 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 292/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1751 - mae: 0.3558 - val_loss: 0.1846 - val_mae: 0.3694\n", + "Epoch 293/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1658 - mae: 0.3511 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 294/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1713 - mae: 0.3536 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 295/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1725 - mae: 0.3565 - val_loss: 0.1844 - val_mae: 0.3678\n", + "Epoch 296/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1724 - mae: 0.3513 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 297/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1680 - mae: 0.3520 - val_loss: 0.1845 - val_mae: 0.3683\n", + "Epoch 298/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1734 - mae: 0.3523 - val_loss: 0.1848 - val_mae: 0.3704\n", + "Epoch 299/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1756 - mae: 0.3561 - val_loss: 0.1846 - val_mae: 0.3695\n", + "Epoch 300/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1650 - mae: 0.3467 - val_loss: 0.1844 - val_mae: 0.3675\n", + "Epoch 301/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1690 - mae: 0.3495 - val_loss: 0.1844 - val_mae: 0.3669\n", + "Epoch 302/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1642 - mae: 0.3458 - val_loss: 0.1846 - val_mae: 0.3655\n", + "Epoch 303/500\n", + "10/10 [==============================] - 0s 19ms/step - loss: 0.1732 - mae: 0.3490 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 304/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1686 - mae: 0.3514 - val_loss: 0.1847 - val_mae: 0.3698\n", + "Epoch 305/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1757 - mae: 0.3568 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 306/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1650 - mae: 0.3475 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 307/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1544 - mae: 0.3364 - val_loss: 0.1845 - val_mae: 0.3673\n", + "Epoch 308/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1714 - mae: 0.3512 - val_loss: 0.1849 - val_mae: 0.3703\n", + "Epoch 309/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1729 - mae: 0.3549 - val_loss: 0.1853 - val_mae: 0.3718\n", + "Epoch 310/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1677 - mae: 0.3540 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 311/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1731 - mae: 0.3513 - val_loss: 0.1845 - val_mae: 0.3678\n", + "Epoch 312/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1717 - mae: 0.3521 - val_loss: 0.1845 - val_mae: 0.3687\n", + "Epoch 313/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1656 - mae: 0.3425 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 314/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1632 - mae: 0.3439 - val_loss: 0.1847 - val_mae: 0.3694\n", + "Epoch 315/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1694 - mae: 0.3512 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 316/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1679 - mae: 0.3496 - val_loss: 0.1851 - val_mae: 0.3712\n", + "Epoch 317/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1754 - mae: 0.3533 - val_loss: 0.1851 - val_mae: 0.3712\n", + "Epoch 318/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1757 - mae: 0.3582 - val_loss: 0.1847 - val_mae: 0.3694\n", + "Epoch 319/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1705 - mae: 0.3522 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 320/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1539 - mae: 0.3368 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 321/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1691 - mae: 0.3523 - val_loss: 0.1849 - val_mae: 0.3704\n", + "Epoch 322/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1695 - mae: 0.3494 - val_loss: 0.1854 - val_mae: 0.3720\n", + "Epoch 323/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1648 - mae: 0.3469 - val_loss: 0.1845 - val_mae: 0.3680\n", + "Epoch 324/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1781 - mae: 0.3610 - val_loss: 0.1845 - val_mae: 0.3684\n", + "Epoch 325/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1565 - mae: 0.3364 - val_loss: 0.1850 - val_mae: 0.3707\n", + "Epoch 326/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1680 - mae: 0.3496 - val_loss: 0.1849 - val_mae: 0.3706\n", + "Epoch 327/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1680 - mae: 0.3463 - val_loss: 0.1849 - val_mae: 0.3704\n", + "Epoch 328/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1699 - mae: 0.3538 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 329/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1782 - mae: 0.3604 - val_loss: 0.1848 - val_mae: 0.3704\n", + "Epoch 330/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1746 - mae: 0.3527 - val_loss: 0.1848 - val_mae: 0.3704\n", + "Epoch 331/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1695 - mae: 0.3496 - val_loss: 0.1846 - val_mae: 0.3695\n", + "Epoch 332/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1635 - mae: 0.3445 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 333/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1611 - mae: 0.3453 - val_loss: 0.1845 - val_mae: 0.3678\n", + "Epoch 334/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1595 - mae: 0.3416 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 335/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1733 - mae: 0.3562 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 336/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1668 - mae: 0.3458 - val_loss: 0.1845 - val_mae: 0.3676\n", + "Epoch 337/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1678 - mae: 0.3455 - val_loss: 0.1846 - val_mae: 0.3685\n", + "Epoch 338/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1768 - mae: 0.3578 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 339/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1674 - mae: 0.3485 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 340/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1736 - mae: 0.3536 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 341/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1655 - mae: 0.3474 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 342/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1727 - mae: 0.3539 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 343/500\n", + "10/10 [==============================] - 0s 19ms/step - loss: 0.1721 - mae: 0.3489 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 344/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1620 - mae: 0.3464 - val_loss: 0.1845 - val_mae: 0.3675\n", + "Epoch 345/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1757 - mae: 0.3548 - val_loss: 0.1845 - val_mae: 0.3681\n", + "Epoch 346/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1753 - mae: 0.3576 - val_loss: 0.1846 - val_mae: 0.3685\n", + "Epoch 347/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1698 - mae: 0.3471 - val_loss: 0.1845 - val_mae: 0.3678\n", + "Epoch 348/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1793 - mae: 0.3578 - val_loss: 0.1845 - val_mae: 0.3676\n", + "Epoch 349/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1677 - mae: 0.3506 - val_loss: 0.1846 - val_mae: 0.3683\n", + "Epoch 350/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1683 - mae: 0.3502 - val_loss: 0.1847 - val_mae: 0.3686\n", + "Epoch 351/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1813 - mae: 0.3624 - val_loss: 0.1846 - val_mae: 0.3678\n", + "Epoch 352/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1656 - mae: 0.3440 - val_loss: 0.1846 - val_mae: 0.3674\n", + "Epoch 353/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1705 - mae: 0.3515 - val_loss: 0.1848 - val_mae: 0.3692\n", + "Epoch 354/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1786 - mae: 0.3562 - val_loss: 0.1850 - val_mae: 0.3703\n", + "Epoch 355/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1719 - mae: 0.3518 - val_loss: 0.1847 - val_mae: 0.3683\n", + "Epoch 356/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1698 - mae: 0.3528 - val_loss: 0.1846 - val_mae: 0.3679\n", + "Epoch 357/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1682 - mae: 0.3499 - val_loss: 0.1846 - val_mae: 0.3678\n", + "Epoch 358/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1627 - mae: 0.3442 - val_loss: 0.1848 - val_mae: 0.3694\n", + "Epoch 359/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1634 - mae: 0.3428 - val_loss: 0.1855 - val_mae: 0.3718\n", + "Epoch 360/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1671 - mae: 0.3486 - val_loss: 0.1848 - val_mae: 0.3694\n", + "Epoch 361/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1748 - mae: 0.3609 - val_loss: 0.1846 - val_mae: 0.3681\n", + "Epoch 362/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1655 - mae: 0.3470 - val_loss: 0.1846 - val_mae: 0.3673\n", + "Epoch 363/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1610 - mae: 0.3395 - val_loss: 0.1848 - val_mae: 0.3693\n", + "Epoch 364/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1713 - mae: 0.3539 - val_loss: 0.1847 - val_mae: 0.3688\n", + "Epoch 365/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1664 - mae: 0.3484 - val_loss: 0.1847 - val_mae: 0.3691\n", + "Epoch 366/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1554 - mae: 0.3350 - val_loss: 0.1847 - val_mae: 0.3691\n", + "Epoch 367/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1701 - mae: 0.3511 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 368/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1720 - mae: 0.3546 - val_loss: 0.1847 - val_mae: 0.3691\n", + "Epoch 369/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1675 - mae: 0.3495 - val_loss: 0.1847 - val_mae: 0.3695\n", + "Epoch 370/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1645 - mae: 0.3449 - val_loss: 0.1846 - val_mae: 0.3684\n", + "Epoch 371/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1790 - mae: 0.3588 - val_loss: 0.1846 - val_mae: 0.3687\n", + "Epoch 372/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1662 - mae: 0.3466 - val_loss: 0.1847 - val_mae: 0.3689\n", + "Epoch 373/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1693 - mae: 0.3557 - val_loss: 0.1850 - val_mae: 0.3707\n", + "Epoch 374/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1682 - mae: 0.3493 - val_loss: 0.1851 - val_mae: 0.3711\n", + "Epoch 375/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1777 - mae: 0.3612 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 376/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1682 - mae: 0.3517 - val_loss: 0.1846 - val_mae: 0.3687\n", + "Epoch 377/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1623 - mae: 0.3432 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 378/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1790 - mae: 0.3576 - val_loss: 0.1850 - val_mae: 0.3709\n", + "Epoch 379/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1795 - mae: 0.3594 - val_loss: 0.1846 - val_mae: 0.3685\n", + "Epoch 380/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1635 - mae: 0.3440 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 381/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1727 - mae: 0.3509 - val_loss: 0.1847 - val_mae: 0.3697\n", + "Epoch 382/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1671 - mae: 0.3511 - val_loss: 0.1848 - val_mae: 0.3703\n", + "Epoch 383/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1748 - mae: 0.3557 - val_loss: 0.1848 - val_mae: 0.3701\n", + "Epoch 384/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1745 - mae: 0.3581 - val_loss: 0.1848 - val_mae: 0.3703\n", + "Epoch 385/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1728 - mae: 0.3566 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 386/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1679 - mae: 0.3499 - val_loss: 0.1847 - val_mae: 0.3696\n", + "Epoch 387/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1647 - mae: 0.3420 - val_loss: 0.1849 - val_mae: 0.3704\n", + "Epoch 388/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1685 - mae: 0.3485 - val_loss: 0.1846 - val_mae: 0.3684\n", + "Epoch 389/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1622 - mae: 0.3443 - val_loss: 0.1847 - val_mae: 0.3692\n", + "Epoch 390/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1656 - mae: 0.3495 - val_loss: 0.1847 - val_mae: 0.3692\n", + "Epoch 391/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1680 - mae: 0.3484 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 392/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1779 - mae: 0.3601 - val_loss: 0.1846 - val_mae: 0.3688\n", + "Epoch 393/500\n", + "10/10 [==============================] - 0s 19ms/step - loss: 0.1667 - mae: 0.3450 - val_loss: 0.1847 - val_mae: 0.3695\n", + "Epoch 394/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1668 - mae: 0.3466 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 395/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1751 - mae: 0.3564 - val_loss: 0.1845 - val_mae: 0.3683\n", + "Epoch 396/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1742 - mae: 0.3558 - val_loss: 0.1845 - val_mae: 0.3686\n", + "Epoch 397/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1800 - mae: 0.3653 - val_loss: 0.1845 - val_mae: 0.3676\n", + "Epoch 398/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1663 - mae: 0.3425 - val_loss: 0.1845 - val_mae: 0.3678\n", + "Epoch 399/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1731 - mae: 0.3566 - val_loss: 0.1845 - val_mae: 0.3683\n", + "Epoch 400/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1656 - mae: 0.3431 - val_loss: 0.1846 - val_mae: 0.3691\n", + "Epoch 401/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1603 - mae: 0.3438 - val_loss: 0.1846 - val_mae: 0.3688\n", + "Epoch 402/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1670 - mae: 0.3487 - val_loss: 0.1848 - val_mae: 0.3701\n", + "Epoch 403/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1762 - mae: 0.3544 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 404/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1714 - mae: 0.3497 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 405/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1652 - mae: 0.3454 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 406/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1663 - mae: 0.3471 - val_loss: 0.1851 - val_mae: 0.3710\n", + "Epoch 407/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1604 - mae: 0.3435 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 408/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1710 - mae: 0.3495 - val_loss: 0.1845 - val_mae: 0.3671\n", + "Epoch 409/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1716 - mae: 0.3498 - val_loss: 0.1846 - val_mae: 0.3689\n", + "Epoch 410/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1906 - mae: 0.3736 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 411/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1804 - mae: 0.3610 - val_loss: 0.1848 - val_mae: 0.3703\n", + "Epoch 412/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1685 - mae: 0.3505 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 413/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1598 - mae: 0.3406 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 414/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1619 - mae: 0.3453 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 415/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1786 - mae: 0.3603 - val_loss: 0.1849 - val_mae: 0.3704\n", + "Epoch 416/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1803 - mae: 0.3594 - val_loss: 0.1847 - val_mae: 0.3698\n", + "Epoch 417/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1714 - mae: 0.3564 - val_loss: 0.1845 - val_mae: 0.3681\n", + "Epoch 418/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1673 - mae: 0.3479 - val_loss: 0.1845 - val_mae: 0.3674\n", + "Epoch 419/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1648 - mae: 0.3469 - val_loss: 0.1847 - val_mae: 0.3695\n", + "Epoch 420/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1642 - mae: 0.3439 - val_loss: 0.1847 - val_mae: 0.3698\n", + "Epoch 421/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1738 - mae: 0.3554 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 422/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1662 - mae: 0.3466 - val_loss: 0.1845 - val_mae: 0.3681\n", + "Epoch 423/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1678 - mae: 0.3476 - val_loss: 0.1845 - val_mae: 0.3686\n", + "Epoch 424/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1762 - mae: 0.3599 - val_loss: 0.1845 - val_mae: 0.3684\n", + "Epoch 425/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1688 - mae: 0.3467 - val_loss: 0.1846 - val_mae: 0.3693\n", + "Epoch 426/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1708 - mae: 0.3483 - val_loss: 0.1846 - val_mae: 0.3687\n", + "Epoch 427/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1641 - mae: 0.3435 - val_loss: 0.1845 - val_mae: 0.3680\n", + "Epoch 428/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1683 - mae: 0.3438 - val_loss: 0.1845 - val_mae: 0.3683\n", + "Epoch 429/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1659 - mae: 0.3468 - val_loss: 0.1845 - val_mae: 0.3667\n", + "Epoch 430/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1630 - mae: 0.3462 - val_loss: 0.1845 - val_mae: 0.3670\n", + "Epoch 431/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1713 - mae: 0.3480 - val_loss: 0.1849 - val_mae: 0.3703\n", + "Epoch 432/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1818 - mae: 0.3676 - val_loss: 0.1851 - val_mae: 0.3712\n", + "Epoch 433/500\n", + "10/10 [==============================] - 0s 19ms/step - loss: 0.1833 - mae: 0.3606 - val_loss: 0.1847 - val_mae: 0.3697\n", + "Epoch 434/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1676 - mae: 0.3489 - val_loss: 0.1845 - val_mae: 0.3669\n", + "Epoch 435/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1651 - mae: 0.3451 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 436/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1736 - mae: 0.3534 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 437/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1700 - mae: 0.3531 - val_loss: 0.1847 - val_mae: 0.3697\n", + "Epoch 438/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1799 - mae: 0.3615 - val_loss: 0.1845 - val_mae: 0.3685\n", + "Epoch 439/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1684 - mae: 0.3535 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 440/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1644 - mae: 0.3445 - val_loss: 0.1848 - val_mae: 0.3699\n", + "Epoch 441/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1702 - mae: 0.3541 - val_loss: 0.1845 - val_mae: 0.3682\n", + "Epoch 442/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1621 - mae: 0.3424 - val_loss: 0.1845 - val_mae: 0.3666\n", + "Epoch 443/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1757 - mae: 0.3551 - val_loss: 0.1845 - val_mae: 0.3670\n", + "Epoch 444/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1639 - mae: 0.3403 - val_loss: 0.1845 - val_mae: 0.3682\n", + "Epoch 445/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1739 - mae: 0.3512 - val_loss: 0.1848 - val_mae: 0.3695\n", + "Epoch 446/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1712 - mae: 0.3530 - val_loss: 0.1848 - val_mae: 0.3700\n", + "Epoch 447/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1630 - mae: 0.3460 - val_loss: 0.1848 - val_mae: 0.3698\n", + "Epoch 448/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1670 - mae: 0.3458 - val_loss: 0.1846 - val_mae: 0.3687\n", + "Epoch 449/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1576 - mae: 0.3345 - val_loss: 0.1846 - val_mae: 0.3685\n", + "Epoch 450/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1603 - mae: 0.3429 - val_loss: 0.1847 - val_mae: 0.3694\n", + "Epoch 451/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1689 - mae: 0.3507 - val_loss: 0.1848 - val_mae: 0.3697\n", + "Epoch 452/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1692 - mae: 0.3490 - val_loss: 0.1848 - val_mae: 0.3699\n", + "Epoch 453/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1685 - mae: 0.3514 - val_loss: 0.1845 - val_mae: 0.3679\n", + "Epoch 454/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1774 - mae: 0.3588 - val_loss: 0.1846 - val_mae: 0.3692\n", + "Epoch 455/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1672 - mae: 0.3472 - val_loss: 0.1846 - val_mae: 0.3690\n", + "Epoch 456/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1731 - mae: 0.3566 - val_loss: 0.1846 - val_mae: 0.3688\n", + "Epoch 457/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1658 - mae: 0.3454 - val_loss: 0.1847 - val_mae: 0.3693\n", + "Epoch 458/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1702 - mae: 0.3520 - val_loss: 0.1845 - val_mae: 0.3683\n", + "Epoch 459/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1739 - mae: 0.3532 - val_loss: 0.1846 - val_mae: 0.3684\n", + "Epoch 460/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1699 - mae: 0.3490 - val_loss: 0.1846 - val_mae: 0.3688\n", + "Epoch 461/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1703 - mae: 0.3547 - val_loss: 0.1845 - val_mae: 0.3671\n", + "Epoch 462/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1694 - mae: 0.3505 - val_loss: 0.1846 - val_mae: 0.3682\n", + "Epoch 463/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1728 - mae: 0.3542 - val_loss: 0.1848 - val_mae: 0.3698\n", + "Epoch 464/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1638 - mae: 0.3433 - val_loss: 0.1847 - val_mae: 0.3691\n", + "Epoch 465/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1648 - mae: 0.3382 - val_loss: 0.1845 - val_mae: 0.3676\n", + "Epoch 466/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1713 - mae: 0.3515 - val_loss: 0.1845 - val_mae: 0.3670\n", + "Epoch 467/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1660 - mae: 0.3467 - val_loss: 0.1846 - val_mae: 0.3684\n", + "Epoch 468/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1815 - mae: 0.3630 - val_loss: 0.1852 - val_mae: 0.3714\n", + "Epoch 469/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1685 - mae: 0.3455 - val_loss: 0.1852 - val_mae: 0.3712\n", + "Epoch 470/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1791 - mae: 0.3612 - val_loss: 0.1846 - val_mae: 0.3686\n", + "Epoch 471/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1707 - mae: 0.3523 - val_loss: 0.1846 - val_mae: 0.3685\n", + "Epoch 472/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1703 - mae: 0.3525 - val_loss: 0.1846 - val_mae: 0.3683\n", + "Epoch 473/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1608 - mae: 0.3447 - val_loss: 0.1846 - val_mae: 0.3671\n", + "Epoch 474/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1675 - mae: 0.3465 - val_loss: 0.1848 - val_mae: 0.3693\n", + "Epoch 475/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1689 - mae: 0.3513 - val_loss: 0.1846 - val_mae: 0.3683\n", + "Epoch 476/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1632 - mae: 0.3431 - val_loss: 0.1847 - val_mae: 0.3692\n", + "Epoch 477/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1642 - mae: 0.3464 - val_loss: 0.1846 - val_mae: 0.3674\n", + "Epoch 478/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1734 - mae: 0.3511 - val_loss: 0.1851 - val_mae: 0.3707\n", + "Epoch 479/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1803 - mae: 0.3612 - val_loss: 0.1847 - val_mae: 0.3687\n", + "Epoch 480/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1679 - mae: 0.3531 - val_loss: 0.1846 - val_mae: 0.3677\n", + "Epoch 481/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1597 - mae: 0.3406 - val_loss: 0.1846 - val_mae: 0.3677\n", + "Epoch 482/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1761 - mae: 0.3575 - val_loss: 0.1850 - val_mae: 0.3701\n", + "Epoch 483/500\n", + "10/10 [==============================] - 0s 20ms/step - loss: 0.1707 - mae: 0.3541 - val_loss: 0.1847 - val_mae: 0.3692\n", + "Epoch 484/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1746 - mae: 0.3534 - val_loss: 0.1847 - val_mae: 0.3686\n", + "Epoch 485/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1644 - mae: 0.3457 - val_loss: 0.1846 - val_mae: 0.3675\n", + "Epoch 486/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1724 - mae: 0.3497 - val_loss: 0.1849 - val_mae: 0.3699\n", + "Epoch 487/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1743 - mae: 0.3552 - val_loss: 0.1849 - val_mae: 0.3699\n", + "Epoch 488/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.1662 - mae: 0.3468 - val_loss: 0.1846 - val_mae: 0.3678\n", + "Epoch 489/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1742 - mae: 0.3513 - val_loss: 0.1847 - val_mae: 0.3686\n", + "Epoch 490/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1695 - mae: 0.3481 - val_loss: 0.1846 - val_mae: 0.3674\n", + "Epoch 491/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1736 - mae: 0.3521 - val_loss: 0.1847 - val_mae: 0.3689\n", + "Epoch 492/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1554 - mae: 0.3364 - val_loss: 0.1846 - val_mae: 0.3664\n", + "Epoch 493/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1760 - mae: 0.3597 - val_loss: 0.1847 - val_mae: 0.3685\n", + "Epoch 494/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1666 - mae: 0.3457 - val_loss: 0.1849 - val_mae: 0.3697\n", + "Epoch 495/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1673 - mae: 0.3484 - val_loss: 0.1848 - val_mae: 0.3695\n", + "Epoch 496/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1754 - mae: 0.3581 - val_loss: 0.1848 - val_mae: 0.3695\n", + "Epoch 497/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1729 - mae: 0.3563 - val_loss: 0.1847 - val_mae: 0.3687\n", + "Epoch 498/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1727 - mae: 0.3584 - val_loss: 0.1847 - val_mae: 0.3688\n", + "Epoch 499/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1713 - mae: 0.3522 - val_loss: 0.1847 - val_mae: 0.3685\n", + "Epoch 500/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1634 - mae: 0.3428 - val_loss: 0.1846 - val_mae: 0.3680\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cRE8KpEqVfaS" + }, + "source": [ + "### 3. Plot Metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SDsjqfjFm7Fz" + }, + "source": [ + "**1. Loss (or Mean Squared Error)**\n", + "\n", + "During training, the model's performance is constantly being measured against both our training data and the validation data that we set aside earlier. Training produces a log of data that tells us how the model's performance changed over the course of the training process.\n", + "\n", + "The following cells will display some of that data in a graphical form:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "CmvA-ksoln8r", + "outputId": "220ea767-6ffd-4eab-c327-c82a016c10eb", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + } + }, + "source": [ + "# Draw a graph of the loss, which is the distance between\n", + "# the predicted and actual values during training and validation.\n", + "train_loss = history_1.history['loss']\n", + "val_loss = history_1.history['val_loss']\n", + "\n", + "epochs = range(1, len(train_loss) + 1)\n", + "\n", + "plt.plot(epochs, train_loss, 'g.', label='Training loss')\n", + "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n", + "plt.title('Training and validation loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iOFBSbPcYCN4" + }, + "source": [ + "The graph shows the _loss_ (or the difference between the model's predictions and the actual data) for each epoch. There are several ways to calculate loss, and the method we have used is _mean squared error_. There is a distinct loss value given for the training and the validation data.\n", + "\n", + "As we can see, the amount of loss rapidly decreases over the first 25 epochs, before flattening out. This means that the model is improving and producing more accurate predictions!\n", + "\n", + "Our goal is to stop training when either the model is no longer improving, or when the _training loss_ is less than the _validation loss_, which would mean that the model has learned to predict the training data so well that it can no longer generalize to new data.\n", + "\n", + "To make the flatter part of the graph more readable, let's skip the first 50 epochs:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Zo0RYroFZYIV", + "outputId": "8dc7544d-9504-4ec8-e362-d8dab905a474", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + } + }, + "source": [ + "# Exclude the first few epochs so the graph is easier to read\n", + "SKIP = 50\n", + "\n", + "plt.plot(epochs[SKIP:], train_loss[SKIP:], 'g.', label='Training loss')\n", + "plt.plot(epochs[SKIP:], val_loss[SKIP:], 'b.', label='Validation loss')\n", + "plt.title('Training and validation loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W4EQD-Bb8hLM" + }, + "source": [ + "From the plot, we can see that loss continues to reduce until around 200 epochs, at which point it is mostly stable. This means that there's no need to train our network beyond 200 epochs.\n", + "\n", + "However, we can also see that the lowest loss value is still around 0.155. This means that our network's predictions are off by an average of ~15%. In addition, the validation loss values jump around a lot, and is sometimes even higher.\n", + "\n", + "**2. Mean Absolute Error**\n", + "\n", + "To gain more insight into our model's performance we can plot some more data. This time, we'll plot the _mean absolute error_, which is another way of measuring how far the network's predictions are from the actual numbers:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Md9E_azmpkZU", + "outputId": "e47fe879-5e16-4e3c-9e98-279059955384", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + } + }, + "source": [ + "plt.clf()\n", + "\n", + "# Draw a graph of mean absolute error, which is another way of\n", + "# measuring the amount of error in the prediction.\n", + "train_mae = history_1.history['mae']\n", + "val_mae = history_1.history['val_mae']\n", + "\n", + "plt.plot(epochs[SKIP:], train_mae[SKIP:], 'g.', label='Training MAE')\n", + "plt.plot(epochs[SKIP:], val_mae[SKIP:], 'b.', label='Validation MAE')\n", + "plt.title('Training and validation mean absolute error')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('MAE')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ctawd0CXAVEw" + }, + "source": [ + "This graph of _mean absolute error_ tells another story. We can see that training data shows consistently lower error than validation data, which means that the network may have _overfit_, or learned the training data so rigidly that it can't make effective predictions about new data.\n", + "\n", + "In addition, the mean absolute error values are quite high, ~0.305 at best, which means some of the model's predictions are at least 30% off. A 30% error means we are very far from accurately modelling the sine wave function.\n", + "\n", + "**3. Actual vs Predicted Outputs**\n", + "\n", + "To get more insight into what is happening, let's check its predictions against the test dataset we set aside earlier:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "i13eVIT3B9Mj", + "outputId": "6004cf7f-77d3-4cb9-fa0d-49bdc591301e", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 299 + } + }, + "source": [ + "# Calculate and print the loss on our test dataset\n", + "test_loss, test_mae = model_1.evaluate(x_test, y_test)\n", + "\n", + "# Make predictions based on our test dataset\n", + "y_test_pred = model_1.predict(x_test)\n", + "\n", + "# Graph the predictions against the actual values\n", + "plt.clf()\n", + "plt.title('Comparison of predictions and actual values')\n", + "plt.plot(x_test, y_test, 'b.', label='Actual values')\n", + "plt.plot(x_test, y_test_pred, 'r.', label='TF predictions')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "text": [ + "7/7 [==============================] - 0s 2ms/step - loss: 0.1627 - mae: 0.3434\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wokallj1D21L" + }, + "source": [ + "Oh dear! The graph makes it clear that our network has learned to approximate the sine function in a very limited way.\n", + "\n", + "The rigidity of this fit suggests that the model does not have enough capacity to learn the full complexity of the sine wave function, so it's only able to approximate it in an overly simplistic way. By making our model bigger, we should be able to improve its performance." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T7sL-hWtoAZC" + }, + "source": [ + "## Training a Larger Model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aQd0JSdOoAbw" + }, + "source": [ + "### 1. Design the Model\n", + "To make our model bigger, let's add an additional layer of neurons. The following cell redefines our model in the same way as earlier, but with 16 neurons in the first layer and an additional layer of 16 neurons in the middle:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "oW0xus6AF-4o" + }, + "source": [ + "model = tf.keras.Sequential()\n", + "\n", + "# First layer takes a scalar input and feeds it through 16 \"neurons\". The\n", + "# neurons decide whether to activate based on the 'relu' activation function.\n", + "model.add(keras.layers.Dense(16, activation='relu', input_shape=(1,)))\n", + "\n", + "# The new second and third layer will help the network learn more complex representations\n", + "model.add(keras.layers.Dense(16, activation='relu'))\n", + "\n", + "# Final layer is a single neuron, since we want to output a single value\n", + "model.add(keras.layers.Dense(1))\n", + "\n", + "# Compile the model using the standard 'adam' optimizer and the mean squared error or 'mse' loss function for regression.\n", + "model.compile(optimizer='adam', loss=\"mse\", metrics=[\"mae\"])" + ], + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Dv2SC409Grap" + }, + "source": [ + "### 2. Train the Model ###\n", + "\n", + "We'll now train and save the new model." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "DPAUrdkmGq1M", + "outputId": "b0b50b8b-f5fc-4433-db0e-703697443b76", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "source": [ + "# Train the model\n", + "history = model.fit(x_train, y_train, epochs=500, batch_size=64,\n", + " validation_data=(x_validate, y_validate))\n", + "\n", + "# Save the model to disk\n", + "model.save(MODEL_TF)" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Epoch 1/500\n", + "10/10 [==============================] - 1s 20ms/step - loss: 0.4355 - mae: 0.5542 - val_loss: 0.4315 - val_mae: 0.5685\n", + "Epoch 2/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.4183 - mae: 0.5548 - val_loss: 0.4157 - val_mae: 0.5581\n", + "Epoch 3/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3871 - mae: 0.5322 - val_loss: 0.3988 - val_mae: 0.5444\n", + "Epoch 4/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3954 - mae: 0.5348 - val_loss: 0.3834 - val_mae: 0.5350\n", + "Epoch 5/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3670 - mae: 0.5163 - val_loss: 0.3684 - val_mae: 0.5257\n", + "Epoch 6/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3426 - mae: 0.4999 - val_loss: 0.3532 - val_mae: 0.5166\n", + "Epoch 7/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3453 - mae: 0.5006 - val_loss: 0.3369 - val_mae: 0.5055\n", + "Epoch 8/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.3182 - mae: 0.4830 - val_loss: 0.3203 - val_mae: 0.4940\n", + "Epoch 9/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.3013 - mae: 0.4691 - val_loss: 0.3041 - val_mae: 0.4833\n", + "Epoch 10/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2795 - mae: 0.4523 - val_loss: 0.2867 - val_mae: 0.4699\n", + "Epoch 11/500\n", + "10/10 [==============================] - 0s 20ms/step - loss: 0.2632 - mae: 0.4395 - val_loss: 0.2698 - val_mae: 0.4558\n", + "Epoch 12/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.2581 - mae: 0.4331 - val_loss: 0.2534 - val_mae: 0.4436\n", + "Epoch 13/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2363 - mae: 0.4185 - val_loss: 0.2381 - val_mae: 0.4318\n", + "Epoch 14/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.2171 - mae: 0.3972 - val_loss: 0.2220 - val_mae: 0.4151\n", + "Epoch 15/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1944 - mae: 0.3783 - val_loss: 0.2095 - val_mae: 0.4041\n", + "Epoch 16/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1948 - mae: 0.3796 - val_loss: 0.1969 - val_mae: 0.3902\n", + "Epoch 17/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1842 - mae: 0.3642 - val_loss: 0.1868 - val_mae: 0.3790\n", + "Epoch 18/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1706 - mae: 0.3480 - val_loss: 0.1781 - val_mae: 0.3677\n", + "Epoch 19/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1599 - mae: 0.3348 - val_loss: 0.1713 - val_mae: 0.3576\n", + "Epoch 20/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1563 - mae: 0.3340 - val_loss: 0.1653 - val_mae: 0.3468\n", + "Epoch 21/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1487 - mae: 0.3161 - val_loss: 0.1613 - val_mae: 0.3391\n", + "Epoch 22/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1425 - mae: 0.3061 - val_loss: 0.1577 - val_mae: 0.3306\n", + "Epoch 23/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1347 - mae: 0.3005 - val_loss: 0.1552 - val_mae: 0.3235\n", + "Epoch 24/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1411 - mae: 0.2995 - val_loss: 0.1533 - val_mae: 0.3185\n", + "Epoch 25/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1414 - mae: 0.2992 - val_loss: 0.1517 - val_mae: 0.3122\n", + "Epoch 26/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1397 - mae: 0.3011 - val_loss: 0.1517 - val_mae: 0.3129\n", + "Epoch 27/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1335 - mae: 0.2879 - val_loss: 0.1494 - val_mae: 0.3057\n", + "Epoch 28/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1335 - mae: 0.2897 - val_loss: 0.1490 - val_mae: 0.3049\n", + "Epoch 29/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1287 - mae: 0.2792 - val_loss: 0.1478 - val_mae: 0.3010\n", + "Epoch 30/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1291 - mae: 0.2774 - val_loss: 0.1472 - val_mae: 0.2992\n", + "Epoch 31/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1245 - mae: 0.2756 - val_loss: 0.1467 - val_mae: 0.2991\n", + "Epoch 32/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1327 - mae: 0.2775 - val_loss: 0.1460 - val_mae: 0.2977\n", + "Epoch 33/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1163 - mae: 0.2613 - val_loss: 0.1453 - val_mae: 0.2955\n", + "Epoch 34/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1251 - mae: 0.2731 - val_loss: 0.1443 - val_mae: 0.2922\n", + "Epoch 35/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1365 - mae: 0.2829 - val_loss: 0.1441 - val_mae: 0.2951\n", + "Epoch 36/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1283 - mae: 0.2757 - val_loss: 0.1427 - val_mae: 0.2905\n", + "Epoch 37/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1146 - mae: 0.2567 - val_loss: 0.1432 - val_mae: 0.2930\n", + "Epoch 38/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1231 - mae: 0.2655 - val_loss: 0.1412 - val_mae: 0.2869\n", + "Epoch 39/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1263 - mae: 0.2739 - val_loss: 0.1407 - val_mae: 0.2890\n", + "Epoch 40/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1396 - mae: 0.2878 - val_loss: 0.1398 - val_mae: 0.2867\n", + "Epoch 41/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1194 - mae: 0.2651 - val_loss: 0.1390 - val_mae: 0.2835\n", + "Epoch 42/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1206 - mae: 0.2607 - val_loss: 0.1379 - val_mae: 0.2831\n", + "Epoch 43/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1296 - mae: 0.2716 - val_loss: 0.1373 - val_mae: 0.2850\n", + "Epoch 44/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1155 - mae: 0.2545 - val_loss: 0.1362 - val_mae: 0.2814\n", + "Epoch 45/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1237 - mae: 0.2610 - val_loss: 0.1353 - val_mae: 0.2806\n", + "Epoch 46/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1163 - mae: 0.2529 - val_loss: 0.1350 - val_mae: 0.2815\n", + "Epoch 47/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1123 - mae: 0.2527 - val_loss: 0.1339 - val_mae: 0.2814\n", + "Epoch 48/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1136 - mae: 0.2541 - val_loss: 0.1325 - val_mae: 0.2775\n", + "Epoch 49/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1154 - mae: 0.2535 - val_loss: 0.1318 - val_mae: 0.2783\n", + "Epoch 50/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1249 - mae: 0.2632 - val_loss: 0.1312 - val_mae: 0.2715\n", + "Epoch 51/500\n", + "10/10 [==============================] - 0s 17ms/step - loss: 0.1117 - mae: 0.2534 - val_loss: 0.1319 - val_mae: 0.2801\n", + "Epoch 52/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1088 - mae: 0.2529 - val_loss: 0.1289 - val_mae: 0.2727\n", + "Epoch 53/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1166 - mae: 0.2611 - val_loss: 0.1290 - val_mae: 0.2760\n", + "Epoch 54/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1137 - mae: 0.2537 - val_loss: 0.1270 - val_mae: 0.2696\n", + "Epoch 55/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1063 - mae: 0.2480 - val_loss: 0.1268 - val_mae: 0.2726\n", + "Epoch 56/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1083 - mae: 0.2461 - val_loss: 0.1253 - val_mae: 0.2655\n", + "Epoch 57/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0997 - mae: 0.2326 - val_loss: 0.1245 - val_mae: 0.2668\n", + "Epoch 58/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1066 - mae: 0.2470 - val_loss: 0.1235 - val_mae: 0.2644\n", + "Epoch 59/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.1068 - mae: 0.2399 - val_loss: 0.1231 - val_mae: 0.2662\n", + "Epoch 60/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1055 - mae: 0.2396 - val_loss: 0.1217 - val_mae: 0.2618\n", + "Epoch 61/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1034 - mae: 0.2338 - val_loss: 0.1207 - val_mae: 0.2606\n", + "Epoch 62/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1057 - mae: 0.2456 - val_loss: 0.1217 - val_mae: 0.2662\n", + "Epoch 63/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1067 - mae: 0.2439 - val_loss: 0.1189 - val_mae: 0.2564\n", + "Epoch 64/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0984 - mae: 0.2338 - val_loss: 0.1185 - val_mae: 0.2593\n", + "Epoch 65/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0974 - mae: 0.2356 - val_loss: 0.1175 - val_mae: 0.2598\n", + "Epoch 66/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0982 - mae: 0.2355 - val_loss: 0.1161 - val_mae: 0.2540\n", + "Epoch 67/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.1027 - mae: 0.2385 - val_loss: 0.1159 - val_mae: 0.2556\n", + "Epoch 68/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1017 - mae: 0.2356 - val_loss: 0.1144 - val_mae: 0.2511\n", + "Epoch 69/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0948 - mae: 0.2266 - val_loss: 0.1136 - val_mae: 0.2529\n", + "Epoch 70/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0969 - mae: 0.2316 - val_loss: 0.1127 - val_mae: 0.2516\n", + "Epoch 71/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0959 - mae: 0.2247 - val_loss: 0.1116 - val_mae: 0.2473\n", + "Epoch 72/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0988 - mae: 0.2279 - val_loss: 0.1107 - val_mae: 0.2468\n", + "Epoch 73/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.1069 - mae: 0.2367 - val_loss: 0.1097 - val_mae: 0.2461\n", + "Epoch 74/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0924 - mae: 0.2292 - val_loss: 0.1090 - val_mae: 0.2463\n", + "Epoch 75/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0967 - mae: 0.2268 - val_loss: 0.1080 - val_mae: 0.2454\n", + "Epoch 76/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0892 - mae: 0.2194 - val_loss: 0.1070 - val_mae: 0.2415\n", + "Epoch 77/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0939 - mae: 0.2265 - val_loss: 0.1064 - val_mae: 0.2431\n", + "Epoch 78/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0874 - mae: 0.2146 - val_loss: 0.1056 - val_mae: 0.2370\n", + "Epoch 79/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0895 - mae: 0.2188 - val_loss: 0.1050 - val_mae: 0.2413\n", + "Epoch 80/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0820 - mae: 0.2127 - val_loss: 0.1036 - val_mae: 0.2366\n", + "Epoch 81/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0890 - mae: 0.2167 - val_loss: 0.1027 - val_mae: 0.2380\n", + "Epoch 82/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0905 - mae: 0.2191 - val_loss: 0.1018 - val_mae: 0.2359\n", + "Epoch 83/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0822 - mae: 0.2072 - val_loss: 0.1012 - val_mae: 0.2346\n", + "Epoch 84/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0870 - mae: 0.2135 - val_loss: 0.1001 - val_mae: 0.2334\n", + "Epoch 85/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0936 - mae: 0.2228 - val_loss: 0.0993 - val_mae: 0.2310\n", + "Epoch 86/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0762 - mae: 0.2036 - val_loss: 0.0990 - val_mae: 0.2330\n", + "Epoch 87/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0781 - mae: 0.2018 - val_loss: 0.0978 - val_mae: 0.2314\n", + "Epoch 88/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0835 - mae: 0.2111 - val_loss: 0.0969 - val_mae: 0.2289\n", + "Epoch 89/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0814 - mae: 0.2084 - val_loss: 0.0961 - val_mae: 0.2279\n", + "Epoch 90/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0791 - mae: 0.2048 - val_loss: 0.0953 - val_mae: 0.2268\n", + "Epoch 91/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0816 - mae: 0.2088 - val_loss: 0.0948 - val_mae: 0.2288\n", + "Epoch 92/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0818 - mae: 0.2083 - val_loss: 0.0939 - val_mae: 0.2217\n", + "Epoch 93/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0735 - mae: 0.1931 - val_loss: 0.0934 - val_mae: 0.2255\n", + "Epoch 94/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0812 - mae: 0.2072 - val_loss: 0.0921 - val_mae: 0.2217\n", + "Epoch 95/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0815 - mae: 0.2055 - val_loss: 0.0913 - val_mae: 0.2205\n", + "Epoch 96/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0766 - mae: 0.2003 - val_loss: 0.0905 - val_mae: 0.2187\n", + "Epoch 97/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0803 - mae: 0.2053 - val_loss: 0.0898 - val_mae: 0.2202\n", + "Epoch 98/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0748 - mae: 0.1963 - val_loss: 0.0890 - val_mae: 0.2184\n", + "Epoch 99/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0754 - mae: 0.1959 - val_loss: 0.0885 - val_mae: 0.2134\n", + "Epoch 100/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0785 - mae: 0.2020 - val_loss: 0.0876 - val_mae: 0.2138\n", + "Epoch 101/500\n", + "10/10 [==============================] - 0s 19ms/step - loss: 0.0724 - mae: 0.1939 - val_loss: 0.0868 - val_mae: 0.2148\n", + "Epoch 102/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0742 - mae: 0.1977 - val_loss: 0.0861 - val_mae: 0.2130\n", + "Epoch 103/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0714 - mae: 0.1943 - val_loss: 0.0855 - val_mae: 0.2151\n", + "Epoch 104/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0777 - mae: 0.2017 - val_loss: 0.0845 - val_mae: 0.2110\n", + "Epoch 105/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0689 - mae: 0.1883 - val_loss: 0.0845 - val_mae: 0.2105\n", + "Epoch 106/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0660 - mae: 0.1848 - val_loss: 0.0832 - val_mae: 0.2100\n", + "Epoch 107/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0721 - mae: 0.1913 - val_loss: 0.0825 - val_mae: 0.2089\n", + "Epoch 108/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0819 - mae: 0.2055 - val_loss: 0.0819 - val_mae: 0.2077\n", + "Epoch 109/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0731 - mae: 0.1940 - val_loss: 0.0812 - val_mae: 0.2072\n", + "Epoch 110/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0678 - mae: 0.1863 - val_loss: 0.0805 - val_mae: 0.2051\n", + "Epoch 111/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0688 - mae: 0.1840 - val_loss: 0.0799 - val_mae: 0.2031\n", + "Epoch 112/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0739 - mae: 0.1874 - val_loss: 0.0792 - val_mae: 0.2031\n", + "Epoch 113/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0745 - mae: 0.1944 - val_loss: 0.0788 - val_mae: 0.2023\n", + "Epoch 114/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0704 - mae: 0.1902 - val_loss: 0.0780 - val_mae: 0.2016\n", + "Epoch 115/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0664 - mae: 0.1864 - val_loss: 0.0774 - val_mae: 0.2016\n", + "Epoch 116/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0624 - mae: 0.1774 - val_loss: 0.0769 - val_mae: 0.1986\n", + "Epoch 117/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0688 - mae: 0.1869 - val_loss: 0.0761 - val_mae: 0.1991\n", + "Epoch 118/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0671 - mae: 0.1801 - val_loss: 0.0756 - val_mae: 0.1975\n", + "Epoch 119/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0656 - mae: 0.1839 - val_loss: 0.0750 - val_mae: 0.1986\n", + "Epoch 120/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0554 - mae: 0.1686 - val_loss: 0.0742 - val_mae: 0.1973\n", + "Epoch 121/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0627 - mae: 0.1815 - val_loss: 0.0737 - val_mae: 0.1971\n", + "Epoch 122/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0668 - mae: 0.1842 - val_loss: 0.0733 - val_mae: 0.1955\n", + "Epoch 123/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0683 - mae: 0.1886 - val_loss: 0.0726 - val_mae: 0.1935\n", + "Epoch 124/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0601 - mae: 0.1734 - val_loss: 0.0726 - val_mae: 0.1966\n", + "Epoch 125/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0608 - mae: 0.1845 - val_loss: 0.0715 - val_mae: 0.1950\n", + "Epoch 126/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0644 - mae: 0.1833 - val_loss: 0.0709 - val_mae: 0.1940\n", + "Epoch 127/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0572 - mae: 0.1708 - val_loss: 0.0703 - val_mae: 0.1916\n", + "Epoch 128/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0571 - mae: 0.1712 - val_loss: 0.0698 - val_mae: 0.1901\n", + "Epoch 129/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0593 - mae: 0.1732 - val_loss: 0.0692 - val_mae: 0.1899\n", + "Epoch 130/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0583 - mae: 0.1718 - val_loss: 0.0688 - val_mae: 0.1914\n", + "Epoch 131/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0659 - mae: 0.1828 - val_loss: 0.0681 - val_mae: 0.1880\n", + "Epoch 132/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0601 - mae: 0.1734 - val_loss: 0.0686 - val_mae: 0.1927\n", + "Epoch 133/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0614 - mae: 0.1796 - val_loss: 0.0675 - val_mae: 0.1877\n", + "Epoch 134/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0575 - mae: 0.1725 - val_loss: 0.0670 - val_mae: 0.1899\n", + "Epoch 135/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0638 - mae: 0.1833 - val_loss: 0.0663 - val_mae: 0.1832\n", + "Epoch 136/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0519 - mae: 0.1603 - val_loss: 0.0661 - val_mae: 0.1886\n", + "Epoch 137/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0523 - mae: 0.1655 - val_loss: 0.0650 - val_mae: 0.1851\n", + "Epoch 138/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0499 - mae: 0.1625 - val_loss: 0.0645 - val_mae: 0.1841\n", + "Epoch 139/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0582 - mae: 0.1712 - val_loss: 0.0640 - val_mae: 0.1838\n", + "Epoch 140/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0520 - mae: 0.1618 - val_loss: 0.0640 - val_mae: 0.1853\n", + "Epoch 141/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0509 - mae: 0.1662 - val_loss: 0.0630 - val_mae: 0.1824\n", + "Epoch 142/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.0508 - mae: 0.1620 - val_loss: 0.0625 - val_mae: 0.1832\n", + "Epoch 143/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0484 - mae: 0.1564 - val_loss: 0.0624 - val_mae: 0.1823\n", + "Epoch 144/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0526 - mae: 0.1651 - val_loss: 0.0615 - val_mae: 0.1791\n", + "Epoch 145/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0536 - mae: 0.1649 - val_loss: 0.0611 - val_mae: 0.1809\n", + "Epoch 146/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0484 - mae: 0.1590 - val_loss: 0.0606 - val_mae: 0.1786\n", + "Epoch 147/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0555 - mae: 0.1652 - val_loss: 0.0601 - val_mae: 0.1770\n", + "Epoch 148/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0493 - mae: 0.1578 - val_loss: 0.0597 - val_mae: 0.1778\n", + "Epoch 149/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0475 - mae: 0.1538 - val_loss: 0.0591 - val_mae: 0.1779\n", + "Epoch 150/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0484 - mae: 0.1541 - val_loss: 0.0589 - val_mae: 0.1765\n", + "Epoch 151/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0580 - mae: 0.1705 - val_loss: 0.0584 - val_mae: 0.1741\n", + "Epoch 152/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0556 - mae: 0.1653 - val_loss: 0.0579 - val_mae: 0.1759\n", + "Epoch 153/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0491 - mae: 0.1562 - val_loss: 0.0576 - val_mae: 0.1714\n", + "Epoch 154/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0526 - mae: 0.1610 - val_loss: 0.0569 - val_mae: 0.1756\n", + "Epoch 155/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0460 - mae: 0.1538 - val_loss: 0.0563 - val_mae: 0.1722\n", + "Epoch 156/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0530 - mae: 0.1634 - val_loss: 0.0558 - val_mae: 0.1721\n", + "Epoch 157/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0464 - mae: 0.1522 - val_loss: 0.0556 - val_mae: 0.1710\n", + "Epoch 158/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0477 - mae: 0.1548 - val_loss: 0.0550 - val_mae: 0.1701\n", + "Epoch 159/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0447 - mae: 0.1499 - val_loss: 0.0546 - val_mae: 0.1706\n", + "Epoch 160/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0428 - mae: 0.1500 - val_loss: 0.0541 - val_mae: 0.1686\n", + "Epoch 161/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0436 - mae: 0.1471 - val_loss: 0.0540 - val_mae: 0.1717\n", + "Epoch 162/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0400 - mae: 0.1434 - val_loss: 0.0534 - val_mae: 0.1664\n", + "Epoch 163/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0361 - mae: 0.1362 - val_loss: 0.0540 - val_mae: 0.1735\n", + "Epoch 164/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0431 - mae: 0.1522 - val_loss: 0.0536 - val_mae: 0.1694\n", + "Epoch 165/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0444 - mae: 0.1504 - val_loss: 0.0531 - val_mae: 0.1711\n", + "Epoch 166/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0448 - mae: 0.1549 - val_loss: 0.0516 - val_mae: 0.1643\n", + "Epoch 167/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0417 - mae: 0.1455 - val_loss: 0.0511 - val_mae: 0.1664\n", + "Epoch 168/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0454 - mae: 0.1517 - val_loss: 0.0510 - val_mae: 0.1636\n", + "Epoch 169/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0439 - mae: 0.1469 - val_loss: 0.0506 - val_mae: 0.1663\n", + "Epoch 170/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0410 - mae: 0.1447 - val_loss: 0.0501 - val_mae: 0.1610\n", + "Epoch 171/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0404 - mae: 0.1449 - val_loss: 0.0495 - val_mae: 0.1643\n", + "Epoch 172/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0427 - mae: 0.1489 - val_loss: 0.0491 - val_mae: 0.1626\n", + "Epoch 173/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0421 - mae: 0.1473 - val_loss: 0.0490 - val_mae: 0.1632\n", + "Epoch 174/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0460 - mae: 0.1511 - val_loss: 0.0486 - val_mae: 0.1590\n", + "Epoch 175/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0431 - mae: 0.1461 - val_loss: 0.0480 - val_mae: 0.1602\n", + "Epoch 176/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0426 - mae: 0.1484 - val_loss: 0.0473 - val_mae: 0.1597\n", + "Epoch 177/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0380 - mae: 0.1396 - val_loss: 0.0473 - val_mae: 0.1617\n", + "Epoch 178/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0367 - mae: 0.1401 - val_loss: 0.0467 - val_mae: 0.1582\n", + "Epoch 179/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0406 - mae: 0.1438 - val_loss: 0.0462 - val_mae: 0.1578\n", + "Epoch 180/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0378 - mae: 0.1410 - val_loss: 0.0461 - val_mae: 0.1566\n", + "Epoch 181/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0353 - mae: 0.1352 - val_loss: 0.0457 - val_mae: 0.1591\n", + "Epoch 182/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0381 - mae: 0.1427 - val_loss: 0.0451 - val_mae: 0.1558\n", + "Epoch 183/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0372 - mae: 0.1353 - val_loss: 0.0448 - val_mae: 0.1562\n", + "Epoch 184/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0400 - mae: 0.1428 - val_loss: 0.0442 - val_mae: 0.1548\n", + "Epoch 185/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0378 - mae: 0.1393 - val_loss: 0.0438 - val_mae: 0.1541\n", + "Epoch 186/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0379 - mae: 0.1409 - val_loss: 0.0434 - val_mae: 0.1540\n", + "Epoch 187/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0357 - mae: 0.1355 - val_loss: 0.0431 - val_mae: 0.1535\n", + "Epoch 188/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0405 - mae: 0.1478 - val_loss: 0.0427 - val_mae: 0.1514\n", + "Epoch 189/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0375 - mae: 0.1384 - val_loss: 0.0423 - val_mae: 0.1512\n", + "Epoch 190/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0387 - mae: 0.1432 - val_loss: 0.0425 - val_mae: 0.1541\n", + "Epoch 191/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0347 - mae: 0.1374 - val_loss: 0.0418 - val_mae: 0.1500\n", + "Epoch 192/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0336 - mae: 0.1321 - val_loss: 0.0413 - val_mae: 0.1518\n", + "Epoch 193/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0369 - mae: 0.1356 - val_loss: 0.0409 - val_mae: 0.1506\n", + "Epoch 194/500\n", + "10/10 [==============================] - 0s 19ms/step - loss: 0.0355 - mae: 0.1353 - val_loss: 0.0405 - val_mae: 0.1480\n", + "Epoch 195/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0396 - mae: 0.1430 - val_loss: 0.0401 - val_mae: 0.1487\n", + "Epoch 196/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0348 - mae: 0.1352 - val_loss: 0.0403 - val_mae: 0.1510\n", + "Epoch 197/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0320 - mae: 0.1299 - val_loss: 0.0396 - val_mae: 0.1464\n", + "Epoch 198/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0349 - mae: 0.1328 - val_loss: 0.0393 - val_mae: 0.1484\n", + "Epoch 199/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0362 - mae: 0.1389 - val_loss: 0.0387 - val_mae: 0.1446\n", + "Epoch 200/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0303 - mae: 0.1235 - val_loss: 0.0384 - val_mae: 0.1446\n", + "Epoch 201/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0326 - mae: 0.1310 - val_loss: 0.0394 - val_mae: 0.1510\n", + "Epoch 202/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0345 - mae: 0.1359 - val_loss: 0.0389 - val_mae: 0.1460\n", + "Epoch 203/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0294 - mae: 0.1263 - val_loss: 0.0388 - val_mae: 0.1494\n", + "Epoch 204/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0336 - mae: 0.1355 - val_loss: 0.0373 - val_mae: 0.1438\n", + "Epoch 205/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0323 - mae: 0.1316 - val_loss: 0.0368 - val_mae: 0.1418\n", + "Epoch 206/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0294 - mae: 0.1234 - val_loss: 0.0366 - val_mae: 0.1427\n", + "Epoch 207/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0330 - mae: 0.1294 - val_loss: 0.0360 - val_mae: 0.1410\n", + "Epoch 208/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0333 - mae: 0.1314 - val_loss: 0.0357 - val_mae: 0.1417\n", + "Epoch 209/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0295 - mae: 0.1240 - val_loss: 0.0360 - val_mae: 0.1401\n", + "Epoch 210/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0313 - mae: 0.1265 - val_loss: 0.0356 - val_mae: 0.1434\n", + "Epoch 211/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0301 - mae: 0.1257 - val_loss: 0.0348 - val_mae: 0.1396\n", + "Epoch 212/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0295 - mae: 0.1253 - val_loss: 0.0349 - val_mae: 0.1390\n", + "Epoch 213/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0314 - mae: 0.1312 - val_loss: 0.0341 - val_mae: 0.1387\n", + "Epoch 214/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0332 - mae: 0.1322 - val_loss: 0.0341 - val_mae: 0.1381\n", + "Epoch 215/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0310 - mae: 0.1268 - val_loss: 0.0344 - val_mae: 0.1396\n", + "Epoch 216/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0310 - mae: 0.1300 - val_loss: 0.0331 - val_mae: 0.1369\n", + "Epoch 217/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0273 - mae: 0.1208 - val_loss: 0.0329 - val_mae: 0.1352\n", + "Epoch 218/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0278 - mae: 0.1210 - val_loss: 0.0326 - val_mae: 0.1368\n", + "Epoch 219/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0308 - mae: 0.1274 - val_loss: 0.0327 - val_mae: 0.1341\n", + "Epoch 220/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0267 - mae: 0.1191 - val_loss: 0.0319 - val_mae: 0.1340\n", + "Epoch 221/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0258 - mae: 0.1150 - val_loss: 0.0318 - val_mae: 0.1359\n", + "Epoch 222/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0307 - mae: 0.1293 - val_loss: 0.0326 - val_mae: 0.1346\n", + "Epoch 223/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0305 - mae: 0.1271 - val_loss: 0.0320 - val_mae: 0.1380\n", + "Epoch 224/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0284 - mae: 0.1225 - val_loss: 0.0306 - val_mae: 0.1320\n", + "Epoch 225/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0305 - mae: 0.1289 - val_loss: 0.0313 - val_mae: 0.1332\n", + "Epoch 226/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0281 - mae: 0.1235 - val_loss: 0.0309 - val_mae: 0.1355\n", + "Epoch 227/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0266 - mae: 0.1183 - val_loss: 0.0320 - val_mae: 0.1343\n", + "Epoch 228/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0306 - mae: 0.1269 - val_loss: 0.0294 - val_mae: 0.1294\n", + "Epoch 229/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0257 - mae: 0.1170 - val_loss: 0.0316 - val_mae: 0.1385\n", + "Epoch 230/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0275 - mae: 0.1260 - val_loss: 0.0293 - val_mae: 0.1300\n", + "Epoch 231/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0268 - mae: 0.1226 - val_loss: 0.0286 - val_mae: 0.1288\n", + "Epoch 232/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0270 - mae: 0.1187 - val_loss: 0.0291 - val_mae: 0.1270\n", + "Epoch 233/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0236 - mae: 0.1130 - val_loss: 0.0281 - val_mae: 0.1288\n", + "Epoch 234/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0263 - mae: 0.1200 - val_loss: 0.0276 - val_mae: 0.1266\n", + "Epoch 235/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0249 - mae: 0.1160 - val_loss: 0.0282 - val_mae: 0.1251\n", + "Epoch 236/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.0265 - mae: 0.1175 - val_loss: 0.0272 - val_mae: 0.1249\n", + "Epoch 237/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0263 - mae: 0.1169 - val_loss: 0.0273 - val_mae: 0.1278\n", + "Epoch 238/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0232 - mae: 0.1113 - val_loss: 0.0269 - val_mae: 0.1241\n", + "Epoch 239/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0234 - mae: 0.1135 - val_loss: 0.0263 - val_mae: 0.1240\n", + "Epoch 240/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0234 - mae: 0.1114 - val_loss: 0.0261 - val_mae: 0.1247\n", + "Epoch 241/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0241 - mae: 0.1151 - val_loss: 0.0263 - val_mae: 0.1229\n", + "Epoch 242/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0225 - mae: 0.1123 - val_loss: 0.0257 - val_mae: 0.1235\n", + "Epoch 243/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0217 - mae: 0.1099 - val_loss: 0.0253 - val_mae: 0.1234\n", + "Epoch 244/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0247 - mae: 0.1167 - val_loss: 0.0249 - val_mae: 0.1222\n", + "Epoch 245/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0243 - mae: 0.1174 - val_loss: 0.0247 - val_mae: 0.1216\n", + "Epoch 246/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0207 - mae: 0.1061 - val_loss: 0.0245 - val_mae: 0.1210\n", + "Epoch 247/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0224 - mae: 0.1101 - val_loss: 0.0244 - val_mae: 0.1203\n", + "Epoch 248/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0212 - mae: 0.1060 - val_loss: 0.0240 - val_mae: 0.1203\n", + "Epoch 249/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0200 - mae: 0.1066 - val_loss: 0.0237 - val_mae: 0.1199\n", + "Epoch 250/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0221 - mae: 0.1084 - val_loss: 0.0241 - val_mae: 0.1182\n", + "Epoch 251/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0230 - mae: 0.1124 - val_loss: 0.0235 - val_mae: 0.1195\n", + "Epoch 252/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0206 - mae: 0.1072 - val_loss: 0.0237 - val_mae: 0.1199\n", + "Epoch 253/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0205 - mae: 0.1058 - val_loss: 0.0235 - val_mae: 0.1192\n", + "Epoch 254/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0221 - mae: 0.1101 - val_loss: 0.0230 - val_mae: 0.1177\n", + "Epoch 255/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0215 - mae: 0.1077 - val_loss: 0.0225 - val_mae: 0.1171\n", + "Epoch 256/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0202 - mae: 0.1054 - val_loss: 0.0235 - val_mae: 0.1206\n", + "Epoch 257/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0205 - mae: 0.1071 - val_loss: 0.0220 - val_mae: 0.1163\n", + "Epoch 258/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0208 - mae: 0.1110 - val_loss: 0.0218 - val_mae: 0.1163\n", + "Epoch 259/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0224 - mae: 0.1096 - val_loss: 0.0219 - val_mae: 0.1151\n", + "Epoch 260/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0206 - mae: 0.1071 - val_loss: 0.0222 - val_mae: 0.1178\n", + "Epoch 261/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0209 - mae: 0.1093 - val_loss: 0.0214 - val_mae: 0.1157\n", + "Epoch 262/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0211 - mae: 0.1089 - val_loss: 0.0226 - val_mae: 0.1142\n", + "Epoch 263/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0201 - mae: 0.1063 - val_loss: 0.0208 - val_mae: 0.1141\n", + "Epoch 264/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0186 - mae: 0.1007 - val_loss: 0.0207 - val_mae: 0.1134\n", + "Epoch 265/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0195 - mae: 0.1037 - val_loss: 0.0209 - val_mae: 0.1129\n", + "Epoch 266/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0208 - mae: 0.1072 - val_loss: 0.0207 - val_mae: 0.1124\n", + "Epoch 267/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0186 - mae: 0.1016 - val_loss: 0.0216 - val_mae: 0.1167\n", + "Epoch 268/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0193 - mae: 0.1050 - val_loss: 0.0206 - val_mae: 0.1119\n", + "Epoch 269/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0193 - mae: 0.1063 - val_loss: 0.0198 - val_mae: 0.1116\n", + "Epoch 270/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0175 - mae: 0.0996 - val_loss: 0.0197 - val_mae: 0.1114\n", + "Epoch 271/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0194 - mae: 0.1037 - val_loss: 0.0196 - val_mae: 0.1107\n", + "Epoch 272/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0191 - mae: 0.1032 - val_loss: 0.0194 - val_mae: 0.1106\n", + "Epoch 273/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0182 - mae: 0.1026 - val_loss: 0.0193 - val_mae: 0.1106\n", + "Epoch 274/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0189 - mae: 0.1042 - val_loss: 0.0197 - val_mae: 0.1105\n", + "Epoch 275/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0192 - mae: 0.1077 - val_loss: 0.0189 - val_mae: 0.1098\n", + "Epoch 276/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0199 - mae: 0.1072 - val_loss: 0.0204 - val_mae: 0.1141\n", + "Epoch 277/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0197 - mae: 0.1104 - val_loss: 0.0195 - val_mae: 0.1116\n", + "Epoch 278/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0194 - mae: 0.1074 - val_loss: 0.0192 - val_mae: 0.1091\n", + "Epoch 279/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0179 - mae: 0.1027 - val_loss: 0.0183 - val_mae: 0.1081\n", + "Epoch 280/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0177 - mae: 0.1019 - val_loss: 0.0182 - val_mae: 0.1076\n", + "Epoch 281/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0170 - mae: 0.0987 - val_loss: 0.0181 - val_mae: 0.1079\n", + "Epoch 282/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0167 - mae: 0.0997 - val_loss: 0.0182 - val_mae: 0.1069\n", + "Epoch 283/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0182 - mae: 0.1022 - val_loss: 0.0177 - val_mae: 0.1069\n", + "Epoch 284/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0199 - mae: 0.1073 - val_loss: 0.0192 - val_mae: 0.1088\n", + "Epoch 285/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0179 - mae: 0.1033 - val_loss: 0.0177 - val_mae: 0.1061\n", + "Epoch 286/500\n", + "10/10 [==============================] - 0s 21ms/step - loss: 0.0171 - mae: 0.1013 - val_loss: 0.0173 - val_mae: 0.1060\n", + "Epoch 287/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0179 - mae: 0.1022 - val_loss: 0.0174 - val_mae: 0.1053\n", + "Epoch 288/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0185 - mae: 0.1055 - val_loss: 0.0182 - val_mae: 0.1070\n", + "Epoch 289/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0182 - mae: 0.1038 - val_loss: 0.0176 - val_mae: 0.1047\n", + "Epoch 290/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0173 - mae: 0.1032 - val_loss: 0.0177 - val_mae: 0.1069\n", + "Epoch 291/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0176 - mae: 0.1015 - val_loss: 0.0169 - val_mae: 0.1044\n", + "Epoch 292/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0173 - mae: 0.1022 - val_loss: 0.0171 - val_mae: 0.1044\n", + "Epoch 293/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0152 - mae: 0.0967 - val_loss: 0.0166 - val_mae: 0.1037\n", + "Epoch 294/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0165 - mae: 0.0998 - val_loss: 0.0164 - val_mae: 0.1027\n", + "Epoch 295/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0165 - mae: 0.0986 - val_loss: 0.0163 - val_mae: 0.1024\n", + "Epoch 296/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0165 - mae: 0.0979 - val_loss: 0.0163 - val_mae: 0.1026\n", + "Epoch 297/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0162 - mae: 0.0987 - val_loss: 0.0162 - val_mae: 0.1020\n", + "Epoch 298/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0173 - mae: 0.1011 - val_loss: 0.0160 - val_mae: 0.1021\n", + "Epoch 299/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0170 - mae: 0.1019 - val_loss: 0.0165 - val_mae: 0.1029\n", + "Epoch 300/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0164 - mae: 0.0996 - val_loss: 0.0155 - val_mae: 0.1005\n", + "Epoch 301/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0161 - mae: 0.0987 - val_loss: 0.0156 - val_mae: 0.1005\n", + "Epoch 302/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0147 - mae: 0.0952 - val_loss: 0.0162 - val_mae: 0.1029\n", + "Epoch 303/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0161 - mae: 0.0999 - val_loss: 0.0171 - val_mae: 0.1027\n", + "Epoch 304/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0164 - mae: 0.0990 - val_loss: 0.0161 - val_mae: 0.1007\n", + "Epoch 305/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0161 - mae: 0.0975 - val_loss: 0.0156 - val_mae: 0.1001\n", + "Epoch 306/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0159 - mae: 0.0982 - val_loss: 0.0167 - val_mae: 0.1039\n", + "Epoch 307/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0150 - mae: 0.0951 - val_loss: 0.0162 - val_mae: 0.1023\n", + "Epoch 308/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0175 - mae: 0.1035 - val_loss: 0.0148 - val_mae: 0.0985\n", + "Epoch 309/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0152 - mae: 0.0970 - val_loss: 0.0187 - val_mae: 0.1059\n", + "Epoch 310/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0172 - mae: 0.1025 - val_loss: 0.0154 - val_mae: 0.1006\n", + "Epoch 311/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0162 - mae: 0.0999 - val_loss: 0.0180 - val_mae: 0.1055\n", + "Epoch 312/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0162 - mae: 0.1019 - val_loss: 0.0149 - val_mae: 0.0978\n", + "Epoch 313/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0151 - mae: 0.0991 - val_loss: 0.0157 - val_mae: 0.0996\n", + "Epoch 314/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0150 - mae: 0.0951 - val_loss: 0.0148 - val_mae: 0.0983\n", + "Epoch 315/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0151 - mae: 0.0974 - val_loss: 0.0150 - val_mae: 0.0988\n", + "Epoch 316/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0156 - mae: 0.0987 - val_loss: 0.0146 - val_mae: 0.0977\n", + "Epoch 317/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0160 - mae: 0.0987 - val_loss: 0.0151 - val_mae: 0.0971\n", + "Epoch 318/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0154 - mae: 0.0973 - val_loss: 0.0141 - val_mae: 0.0960\n", + "Epoch 319/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0143 - mae: 0.0940 - val_loss: 0.0141 - val_mae: 0.0963\n", + "Epoch 320/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0131 - mae: 0.0904 - val_loss: 0.0143 - val_mae: 0.0965\n", + "Epoch 321/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0142 - mae: 0.0952 - val_loss: 0.0144 - val_mae: 0.0972\n", + "Epoch 322/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0146 - mae: 0.0954 - val_loss: 0.0147 - val_mae: 0.0964\n", + "Epoch 323/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0143 - mae: 0.0941 - val_loss: 0.0147 - val_mae: 0.0973\n", + "Epoch 324/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0149 - mae: 0.0952 - val_loss: 0.0150 - val_mae: 0.0984\n", + "Epoch 325/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0154 - mae: 0.0975 - val_loss: 0.0137 - val_mae: 0.0945\n", + "Epoch 326/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.0135 - mae: 0.0925 - val_loss: 0.0137 - val_mae: 0.0944\n", + "Epoch 327/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0134 - mae: 0.0913 - val_loss: 0.0142 - val_mae: 0.0962\n", + "Epoch 328/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0143 - mae: 0.0955 - val_loss: 0.0135 - val_mae: 0.0937\n", + "Epoch 329/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0142 - mae: 0.0938 - val_loss: 0.0145 - val_mae: 0.0957\n", + "Epoch 330/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0150 - mae: 0.0955 - val_loss: 0.0160 - val_mae: 0.1011\n", + "Epoch 331/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0162 - mae: 0.0996 - val_loss: 0.0136 - val_mae: 0.0940\n", + "Epoch 332/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0135 - mae: 0.0913 - val_loss: 0.0134 - val_mae: 0.0933\n", + "Epoch 333/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0133 - mae: 0.0900 - val_loss: 0.0141 - val_mae: 0.0953\n", + "Epoch 334/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0144 - mae: 0.0954 - val_loss: 0.0132 - val_mae: 0.0929\n", + "Epoch 335/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0134 - mae: 0.0895 - val_loss: 0.0144 - val_mae: 0.0956\n", + "Epoch 336/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0142 - mae: 0.0930 - val_loss: 0.0136 - val_mae: 0.0939\n", + "Epoch 337/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0135 - mae: 0.0924 - val_loss: 0.0130 - val_mae: 0.0922\n", + "Epoch 338/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0133 - mae: 0.0918 - val_loss: 0.0130 - val_mae: 0.0920\n", + "Epoch 339/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0132 - mae: 0.0921 - val_loss: 0.0131 - val_mae: 0.0920\n", + "Epoch 340/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0890 - val_loss: 0.0134 - val_mae: 0.0928\n", + "Epoch 341/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0139 - mae: 0.0937 - val_loss: 0.0135 - val_mae: 0.0929\n", + "Epoch 342/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0141 - mae: 0.0948 - val_loss: 0.0131 - val_mae: 0.0919\n", + "Epoch 343/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0154 - mae: 0.0979 - val_loss: 0.0143 - val_mae: 0.0955\n", + "Epoch 344/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0139 - mae: 0.0927 - val_loss: 0.0136 - val_mae: 0.0932\n", + "Epoch 345/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0136 - mae: 0.0914 - val_loss: 0.0127 - val_mae: 0.0906\n", + "Epoch 346/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0139 - mae: 0.0944 - val_loss: 0.0142 - val_mae: 0.0951\n", + "Epoch 347/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0129 - mae: 0.0892 - val_loss: 0.0129 - val_mae: 0.0910\n", + "Epoch 348/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0148 - mae: 0.0956 - val_loss: 0.0134 - val_mae: 0.0925\n", + "Epoch 349/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0127 - mae: 0.0886 - val_loss: 0.0141 - val_mae: 0.0943\n", + "Epoch 350/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0130 - mae: 0.0918 - val_loss: 0.0130 - val_mae: 0.0915\n", + "Epoch 351/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0144 - mae: 0.0945 - val_loss: 0.0131 - val_mae: 0.0920\n", + "Epoch 352/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0128 - mae: 0.0893 - val_loss: 0.0127 - val_mae: 0.0907\n", + "Epoch 353/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0132 - mae: 0.0926 - val_loss: 0.0135 - val_mae: 0.0927\n", + "Epoch 354/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0136 - mae: 0.0945 - val_loss: 0.0127 - val_mae: 0.0904\n", + "Epoch 355/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0127 - mae: 0.0893 - val_loss: 0.0136 - val_mae: 0.0937\n", + "Epoch 356/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0137 - mae: 0.0936 - val_loss: 0.0135 - val_mae: 0.0937\n", + "Epoch 357/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0144 - mae: 0.0973 - val_loss: 0.0128 - val_mae: 0.0906\n", + "Epoch 358/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0130 - mae: 0.0906 - val_loss: 0.0125 - val_mae: 0.0893\n", + "Epoch 359/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0896 - val_loss: 0.0125 - val_mae: 0.0899\n", + "Epoch 360/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0136 - mae: 0.0931 - val_loss: 0.0134 - val_mae: 0.0935\n", + "Epoch 361/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0139 - mae: 0.0942 - val_loss: 0.0124 - val_mae: 0.0892\n", + "Epoch 362/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0133 - mae: 0.0922 - val_loss: 0.0125 - val_mae: 0.0894\n", + "Epoch 363/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0127 - mae: 0.0894 - val_loss: 0.0126 - val_mae: 0.0904\n", + "Epoch 364/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0126 - mae: 0.0910 - val_loss: 0.0124 - val_mae: 0.0895\n", + "Epoch 365/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0121 - mae: 0.0883 - val_loss: 0.0123 - val_mae: 0.0892\n", + "Epoch 366/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0118 - mae: 0.0867 - val_loss: 0.0124 - val_mae: 0.0896\n", + "Epoch 367/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0122 - mae: 0.0872 - val_loss: 0.0121 - val_mae: 0.0881\n", + "Epoch 368/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0118 - mae: 0.0865 - val_loss: 0.0125 - val_mae: 0.0903\n", + "Epoch 369/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0131 - mae: 0.0908 - val_loss: 0.0121 - val_mae: 0.0885\n", + "Epoch 370/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0131 - mae: 0.0910 - val_loss: 0.0120 - val_mae: 0.0879\n", + "Epoch 371/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0127 - mae: 0.0897 - val_loss: 0.0129 - val_mae: 0.0906\n", + "Epoch 372/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0137 - mae: 0.0928 - val_loss: 0.0129 - val_mae: 0.0904\n", + "Epoch 373/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0128 - mae: 0.0900 - val_loss: 0.0123 - val_mae: 0.0886\n", + "Epoch 374/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0125 - mae: 0.0898 - val_loss: 0.0125 - val_mae: 0.0901\n", + "Epoch 375/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0131 - mae: 0.0911 - val_loss: 0.0120 - val_mae: 0.0877\n", + "Epoch 376/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.0121 - mae: 0.0889 - val_loss: 0.0121 - val_mae: 0.0878\n", + "Epoch 377/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0112 - mae: 0.0845 - val_loss: 0.0125 - val_mae: 0.0889\n", + "Epoch 378/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0123 - mae: 0.0869 - val_loss: 0.0122 - val_mae: 0.0880\n", + "Epoch 379/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0123 - mae: 0.0886 - val_loss: 0.0128 - val_mae: 0.0911\n", + "Epoch 380/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0904 - val_loss: 0.0119 - val_mae: 0.0878\n", + "Epoch 381/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0125 - mae: 0.0897 - val_loss: 0.0124 - val_mae: 0.0897\n", + "Epoch 382/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0127 - mae: 0.0904 - val_loss: 0.0119 - val_mae: 0.0872\n", + "Epoch 383/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0896 - val_loss: 0.0118 - val_mae: 0.0872\n", + "Epoch 384/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0127 - mae: 0.0895 - val_loss: 0.0120 - val_mae: 0.0881\n", + "Epoch 385/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0127 - mae: 0.0897 - val_loss: 0.0120 - val_mae: 0.0884\n", + "Epoch 386/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0120 - mae: 0.0875 - val_loss: 0.0120 - val_mae: 0.0882\n", + "Epoch 387/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0124 - mae: 0.0889 - val_loss: 0.0118 - val_mae: 0.0874\n", + "Epoch 388/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0135 - mae: 0.0933 - val_loss: 0.0132 - val_mae: 0.0915\n", + "Epoch 389/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0133 - mae: 0.0926 - val_loss: 0.0125 - val_mae: 0.0892\n", + "Epoch 390/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0130 - mae: 0.0903 - val_loss: 0.0130 - val_mae: 0.0909\n", + "Epoch 391/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0899 - val_loss: 0.0126 - val_mae: 0.0896\n", + "Epoch 392/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0132 - mae: 0.0906 - val_loss: 0.0121 - val_mae: 0.0878\n", + "Epoch 393/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0129 - mae: 0.0902 - val_loss: 0.0122 - val_mae: 0.0887\n", + "Epoch 394/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0123 - mae: 0.0901 - val_loss: 0.0117 - val_mae: 0.0870\n", + "Epoch 395/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0909 - val_loss: 0.0120 - val_mae: 0.0882\n", + "Epoch 396/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0125 - mae: 0.0885 - val_loss: 0.0117 - val_mae: 0.0869\n", + "Epoch 397/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0123 - mae: 0.0885 - val_loss: 0.0120 - val_mae: 0.0883\n", + "Epoch 398/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0130 - mae: 0.0907 - val_loss: 0.0120 - val_mae: 0.0882\n", + "Epoch 399/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0128 - mae: 0.0918 - val_loss: 0.0122 - val_mae: 0.0889\n", + "Epoch 400/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0124 - mae: 0.0901 - val_loss: 0.0119 - val_mae: 0.0878\n", + "Epoch 401/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0116 - mae: 0.0862 - val_loss: 0.0117 - val_mae: 0.0868\n", + "Epoch 402/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0900 - val_loss: 0.0119 - val_mae: 0.0878\n", + "Epoch 403/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0118 - mae: 0.0861 - val_loss: 0.0124 - val_mae: 0.0896\n", + "Epoch 404/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0893 - val_loss: 0.0118 - val_mae: 0.0875\n", + "Epoch 405/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0119 - mae: 0.0881 - val_loss: 0.0121 - val_mae: 0.0879\n", + "Epoch 406/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0122 - mae: 0.0884 - val_loss: 0.0115 - val_mae: 0.0862\n", + "Epoch 407/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0115 - mae: 0.0864 - val_loss: 0.0121 - val_mae: 0.0880\n", + "Epoch 408/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0127 - mae: 0.0901 - val_loss: 0.0121 - val_mae: 0.0886\n", + "Epoch 409/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0123 - mae: 0.0882 - val_loss: 0.0127 - val_mae: 0.0906\n", + "Epoch 410/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0130 - mae: 0.0898 - val_loss: 0.0119 - val_mae: 0.0875\n", + "Epoch 411/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0127 - mae: 0.0903 - val_loss: 0.0126 - val_mae: 0.0896\n", + "Epoch 412/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0119 - mae: 0.0872 - val_loss: 0.0115 - val_mae: 0.0864\n", + "Epoch 413/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0117 - mae: 0.0867 - val_loss: 0.0127 - val_mae: 0.0896\n", + "Epoch 414/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0117 - mae: 0.0874 - val_loss: 0.0127 - val_mae: 0.0898\n", + "Epoch 415/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0134 - mae: 0.0921 - val_loss: 0.0120 - val_mae: 0.0876\n", + "Epoch 416/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0139 - mae: 0.0941 - val_loss: 0.0117 - val_mae: 0.0869\n", + "Epoch 417/500\n", + "10/10 [==============================] - 0s 18ms/step - loss: 0.0122 - mae: 0.0889 - val_loss: 0.0120 - val_mae: 0.0879\n", + "Epoch 418/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0120 - mae: 0.0868 - val_loss: 0.0120 - val_mae: 0.0882\n", + "Epoch 419/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0122 - mae: 0.0884 - val_loss: 0.0119 - val_mae: 0.0877\n", + "Epoch 420/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0123 - mae: 0.0895 - val_loss: 0.0127 - val_mae: 0.0902\n", + "Epoch 421/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0901 - val_loss: 0.0128 - val_mae: 0.0911\n", + "Epoch 422/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0134 - mae: 0.0921 - val_loss: 0.0117 - val_mae: 0.0868\n", + "Epoch 423/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0119 - mae: 0.0880 - val_loss: 0.0118 - val_mae: 0.0871\n", + "Epoch 424/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0127 - mae: 0.0910 - val_loss: 0.0117 - val_mae: 0.0868\n", + "Epoch 425/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0120 - mae: 0.0881 - val_loss: 0.0117 - val_mae: 0.0869\n", + "Epoch 426/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0127 - mae: 0.0896 - val_loss: 0.0118 - val_mae: 0.0870\n", + "Epoch 427/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0117 - mae: 0.0870 - val_loss: 0.0116 - val_mae: 0.0865\n", + "Epoch 428/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0126 - mae: 0.0909 - val_loss: 0.0119 - val_mae: 0.0874\n", + "Epoch 429/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0115 - mae: 0.0848 - val_loss: 0.0119 - val_mae: 0.0877\n", + "Epoch 430/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0118 - mae: 0.0878 - val_loss: 0.0122 - val_mae: 0.0883\n", + "Epoch 431/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0123 - mae: 0.0889 - val_loss: 0.0118 - val_mae: 0.0871\n", + "Epoch 432/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0124 - mae: 0.0885 - val_loss: 0.0120 - val_mae: 0.0878\n", + "Epoch 433/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0124 - mae: 0.0891 - val_loss: 0.0116 - val_mae: 0.0863\n", + "Epoch 434/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0117 - mae: 0.0879 - val_loss: 0.0119 - val_mae: 0.0877\n", + "Epoch 435/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0124 - mae: 0.0891 - val_loss: 0.0126 - val_mae: 0.0901\n", + "Epoch 436/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0125 - mae: 0.0887 - val_loss: 0.0126 - val_mae: 0.0901\n", + "Epoch 437/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0129 - mae: 0.0913 - val_loss: 0.0123 - val_mae: 0.0886\n", + "Epoch 438/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0120 - mae: 0.0868 - val_loss: 0.0116 - val_mae: 0.0868\n", + "Epoch 439/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0128 - mae: 0.0894 - val_loss: 0.0132 - val_mae: 0.0911\n", + "Epoch 440/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0111 - mae: 0.0849 - val_loss: 0.0115 - val_mae: 0.0865\n", + "Epoch 441/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0121 - mae: 0.0866 - val_loss: 0.0118 - val_mae: 0.0875\n", + "Epoch 442/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0116 - mae: 0.0868 - val_loss: 0.0119 - val_mae: 0.0875\n", + "Epoch 443/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0118 - mae: 0.0861 - val_loss: 0.0124 - val_mae: 0.0891\n", + "Epoch 444/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0883 - val_loss: 0.0121 - val_mae: 0.0883\n", + "Epoch 445/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0114 - mae: 0.0854 - val_loss: 0.0122 - val_mae: 0.0884\n", + "Epoch 446/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0893 - val_loss: 0.0116 - val_mae: 0.0866\n", + "Epoch 447/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0879 - val_loss: 0.0122 - val_mae: 0.0885\n", + "Epoch 448/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0121 - mae: 0.0878 - val_loss: 0.0117 - val_mae: 0.0868\n", + "Epoch 449/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0113 - mae: 0.0865 - val_loss: 0.0117 - val_mae: 0.0866\n", + "Epoch 450/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0112 - mae: 0.0855 - val_loss: 0.0133 - val_mae: 0.0930\n", + "Epoch 451/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0137 - mae: 0.0931 - val_loss: 0.0121 - val_mae: 0.0883\n", + "Epoch 452/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0117 - mae: 0.0861 - val_loss: 0.0114 - val_mae: 0.0862\n", + "Epoch 453/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0113 - mae: 0.0855 - val_loss: 0.0117 - val_mae: 0.0870\n", + "Epoch 454/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0135 - mae: 0.0928 - val_loss: 0.0118 - val_mae: 0.0870\n", + "Epoch 455/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0884 - val_loss: 0.0114 - val_mae: 0.0860\n", + "Epoch 456/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0125 - mae: 0.0904 - val_loss: 0.0117 - val_mae: 0.0869\n", + "Epoch 457/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0124 - mae: 0.0883 - val_loss: 0.0114 - val_mae: 0.0862\n", + "Epoch 458/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0122 - mae: 0.0873 - val_loss: 0.0117 - val_mae: 0.0869\n", + "Epoch 459/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0122 - mae: 0.0887 - val_loss: 0.0116 - val_mae: 0.0865\n", + "Epoch 460/500\n", + "10/10 [==============================] - 0s 5ms/step - loss: 0.0125 - mae: 0.0894 - val_loss: 0.0118 - val_mae: 0.0874\n", + "Epoch 461/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0115 - mae: 0.0857 - val_loss: 0.0115 - val_mae: 0.0863\n", + "Epoch 462/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0115 - mae: 0.0862 - val_loss: 0.0117 - val_mae: 0.0874\n", + "Epoch 463/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0118 - mae: 0.0880 - val_loss: 0.0119 - val_mae: 0.0876\n", + "Epoch 464/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0132 - mae: 0.0928 - val_loss: 0.0116 - val_mae: 0.0865\n", + "Epoch 465/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0135 - mae: 0.0922 - val_loss: 0.0116 - val_mae: 0.0865\n", + "Epoch 466/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0121 - mae: 0.0885 - val_loss: 0.0115 - val_mae: 0.0863\n", + "Epoch 467/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0117 - mae: 0.0868 - val_loss: 0.0116 - val_mae: 0.0871\n", + "Epoch 468/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0117 - mae: 0.0861 - val_loss: 0.0117 - val_mae: 0.0872\n", + "Epoch 469/500\n", + "10/10 [==============================] - 0s 17ms/step - loss: 0.0121 - mae: 0.0896 - val_loss: 0.0115 - val_mae: 0.0863\n", + "Epoch 470/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0123 - mae: 0.0896 - val_loss: 0.0125 - val_mae: 0.0895\n", + "Epoch 471/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0916 - val_loss: 0.0114 - val_mae: 0.0862\n", + "Epoch 472/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0113 - mae: 0.0854 - val_loss: 0.0114 - val_mae: 0.0861\n", + "Epoch 473/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0116 - mae: 0.0862 - val_loss: 0.0129 - val_mae: 0.0904\n", + "Epoch 474/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0138 - mae: 0.0954 - val_loss: 0.0127 - val_mae: 0.0901\n", + "Epoch 475/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0134 - mae: 0.0923 - val_loss: 0.0118 - val_mae: 0.0877\n", + "Epoch 476/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0121 - mae: 0.0877 - val_loss: 0.0115 - val_mae: 0.0862\n", + "Epoch 477/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0117 - mae: 0.0865 - val_loss: 0.0117 - val_mae: 0.0874\n", + "Epoch 478/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0130 - mae: 0.0899 - val_loss: 0.0113 - val_mae: 0.0859\n", + "Epoch 479/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0131 - mae: 0.0907 - val_loss: 0.0115 - val_mae: 0.0864\n", + "Epoch 480/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0122 - mae: 0.0877 - val_loss: 0.0118 - val_mae: 0.0877\n", + "Epoch 481/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0119 - mae: 0.0866 - val_loss: 0.0115 - val_mae: 0.0864\n", + "Epoch 482/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0118 - mae: 0.0874 - val_loss: 0.0115 - val_mae: 0.0866\n", + "Epoch 483/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0121 - mae: 0.0873 - val_loss: 0.0123 - val_mae: 0.0890\n", + "Epoch 484/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0127 - mae: 0.0898 - val_loss: 0.0116 - val_mae: 0.0868\n", + "Epoch 485/500\n", + "10/10 [==============================] - 0s 9ms/step - loss: 0.0112 - mae: 0.0845 - val_loss: 0.0123 - val_mae: 0.0890\n", + "Epoch 486/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0123 - mae: 0.0876 - val_loss: 0.0114 - val_mae: 0.0860\n", + "Epoch 487/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0116 - mae: 0.0852 - val_loss: 0.0118 - val_mae: 0.0873\n", + "Epoch 488/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0114 - mae: 0.0859 - val_loss: 0.0114 - val_mae: 0.0859\n", + "Epoch 489/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0117 - mae: 0.0871 - val_loss: 0.0130 - val_mae: 0.0917\n", + "Epoch 490/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0135 - mae: 0.0933 - val_loss: 0.0131 - val_mae: 0.0920\n", + "Epoch 491/500\n", + "10/10 [==============================] - 0s 8ms/step - loss: 0.0120 - mae: 0.0879 - val_loss: 0.0119 - val_mae: 0.0881\n", + "Epoch 492/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0115 - mae: 0.0859 - val_loss: 0.0115 - val_mae: 0.0863\n", + "Epoch 493/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0113 - mae: 0.0854 - val_loss: 0.0114 - val_mae: 0.0862\n", + "Epoch 494/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0114 - mae: 0.0866 - val_loss: 0.0116 - val_mae: 0.0868\n", + "Epoch 495/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0119 - mae: 0.0875 - val_loss: 0.0113 - val_mae: 0.0860\n", + "Epoch 496/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0118 - mae: 0.0861 - val_loss: 0.0114 - val_mae: 0.0863\n", + "Epoch 497/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0107 - mae: 0.0818 - val_loss: 0.0115 - val_mae: 0.0864\n", + "Epoch 498/500\n", + "10/10 [==============================] - 0s 7ms/step - loss: 0.0123 - mae: 0.0894 - val_loss: 0.0114 - val_mae: 0.0862\n", + "Epoch 499/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0126 - mae: 0.0895 - val_loss: 0.0113 - val_mae: 0.0857\n", + "Epoch 500/500\n", + "10/10 [==============================] - 0s 6ms/step - loss: 0.0121 - mae: 0.0882 - val_loss: 0.0115 - val_mae: 0.0865\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/training.py:2325: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.\n", + " warnings.warn('`Model.state_updates` will be removed in a future version. '\n", + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/base_layer.py:1397: UserWarning: `layer.updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.\n", + " warnings.warn('`layer.updates` will be removed in a future version. '\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "WARNING:tensorflow:FOR KERAS USERS: The object that you are saving contains one or more Keras models or layers. If you are loading the SavedModel with `tf.keras.models.load_model`, continue reading (otherwise, you may ignore the following instructions). Please change your code to save with `tf.keras.models.save_model` or `model.save`, and confirm that the file \"keras.metadata\" exists in the export directory. In the future, Keras will only load the SavedModels that have this file. In other words, `tf.saved_model.save` will no longer write SavedModels that can be recovered as Keras models (this will apply in TF 2.5).\n", + "\n", + "FOR DEVS: If you are overwriting _tracking_metadata in your class, this property has been used to save metadata in the SavedModel. The metadta field will be deprecated soon, so please move the metadata to a different file.\n", + "INFO:tensorflow:Assets written to: models/model/assets\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mc_CQu2_IvOP" + }, + "source": [ + "### 3. Plot Metrics\n", + "Each training epoch, the model prints out its loss and mean absolute error for training and validation. You can read this in the output above (note that your exact numbers may differ): \n", + "\n", + "```\n", + "Epoch 500/500\n", + "10/10 [==============================] - 0s 10ms/step - loss: 0.0121 - mae: 0.0882 - val_loss: 0.0115 - val_mae: 0.0865\n", + "```\n", + "\n", + "You can see that we've already got a huge improvement - validation loss has dropped from 0.15 to 0.01, and validation MAE has dropped from 0.33 to 0.08.\n", + "\n", + "The following cell will print the same graphs we used to evaluate our original model, but showing our new training history:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SYHGswAJJgrC", + "outputId": "0b4baed5-9565-45c7-9fcc-2fd59a86d438", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + } + }, + "source": [ + "# Draw a graph of the loss, which is the distance between\n", + "# the predicted and actual values during training and validation.\n", + "train_loss = history.history['loss']\n", + "val_loss = history.history['val_loss']\n", + "\n", + "epochs = range(1, len(train_loss) + 1)\n", + "\n", + "# Exclude the first few epochs so the graph is easier to read\n", + "SKIP = 100\n", + "\n", + "plt.figure(figsize=(10, 4))\n", + "plt.subplot(1, 2, 1)\n", + "\n", + "plt.plot(epochs[SKIP:], train_loss[SKIP:], 'g.', label='Training loss')\n", + "plt.plot(epochs[SKIP:], val_loss[SKIP:], 'b.', label='Validation loss')\n", + "plt.title('Training and validation loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "\n", + "# Draw a graph of mean absolute error, which is another way of\n", + "# measuring the amount of error in the prediction.\n", + "train_mae = history.history['mae']\n", + "val_mae = history.history['val_mae']\n", + "\n", + "plt.plot(epochs[SKIP:], train_mae[SKIP:], 'g.', label='Training MAE')\n", + "plt.plot(epochs[SKIP:], val_mae[SKIP:], 'b.', label='Validation MAE')\n", + "plt.title('Training and validation mean absolute error')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('MAE')\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "f86dWOyZKmN9" + }, + "source": [ + "Great results! From these graphs, we can see several exciting things:\n", + "\n", + "* The overall loss and MAE are much better than our previous network\n", + "* Metrics are better for validation than training, which means the network is not overfitting\n", + "\n", + "The reason the metrics for validation are better than those for training is that validation metrics are calculated at the end of each epoch, while training metrics are calculated throughout the epoch, so validation happens on a model that has been trained slightly longer.\n", + "\n", + "This all means our network seems to be performing well! To confirm, let's check its predictions against the test dataset we set aside earlier:\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "lZfztKKyhLxX", + "outputId": "f48f33ad-aba0-4c62-ba15-cc742bd23805", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 299 + } + }, + "source": [ + "# Calculate and print the loss on our test dataset\n", + "test_loss, test_mae = model.evaluate(x_test, y_test)\n", + "\n", + "# Make predictions based on our test dataset\n", + "y_test_pred = model.predict(x_test)\n", + "\n", + "# Graph the predictions against the actual values\n", + "plt.clf()\n", + "plt.title('Comparison of predictions and actual values')\n", + "plt.plot(x_test, y_test, 'b.', label='Actual values')\n", + "plt.plot(x_test, y_test_pred, 'r.', label='TF predicted')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "text": [ + "7/7 [==============================] - 0s 2ms/step - loss: 0.0102 - mae: 0.0815\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3h7IcvuOOS4J" + }, + "source": [ + "Much better! The evaluation metrics we printed show that the model has a low loss and MAE on the test data, and the predictions line up visually with our data fairly well.\n", + "\n", + "The model isn't perfect; its predictions don't form a smooth sine curve. For instance, the line is almost straight when `x` is between 4.2 and 5.2. If we wanted to go further, we could try further increasing the capacity of the model, perhaps using some techniques to defend from overfitting.\n", + "\n", + "However, an important part of machine learning is *knowing when to stop*. This model is good enough for our use case - which is to make some LEDs blink in a pleasing pattern.\n", + "\n", + "## Generate a TensorFlow Lite Model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sHe-Wv47rhm8" + }, + "source": [ + "### 1. Generate Models with or without Quantization\n", + "We now have an acceptably accurate model. We'll use the [TensorFlow Lite Converter](https://www.tensorflow.org/lite/convert) to convert the model into a special, space-efficient format for use on memory-constrained devices.\n", + "\n", + "Since this model is going to be deployed on a microcontroller, we want it to be as tiny as possible! One technique for reducing the size of a model is called [quantization](https://www.tensorflow.org/lite/performance/post_training_quantization). It reduces the precision of the model's weights, and possibly the activations (output of each layer) as well, which saves memory, often without much impact on accuracy. Quantized models also run faster, since the calculations required are simpler.\n", + "\n", + "In the following cell, we'll convert the model twice: once with quantization, once without." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "1muAoUm8lSXL", + "outputId": "aad8259e-df57-4f03-da77-d490e5609d9f", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "source": [ + "# Convert the model to the TensorFlow Lite format without quantization\n", + "converter = tf.lite.TFLiteConverter.from_saved_model(MODEL_TF)\n", + "model_no_quant_tflite = converter.convert()\n", + "\n", + "# Save the model to disk\n", + "open(MODEL_NO_QUANT_TFLITE, \"wb\").write(model_no_quant_tflite)\n", + "\n", + "# Convert the model to the TensorFlow Lite format with quantization\n", + "def representative_dataset():\n", + " for i in range(500):\n", + " yield([x_train[i].reshape(1, 1)])\n", + "# Set the optimization flag.\n", + "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n", + "# Enforce integer only quantization\n", + "converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]\n", + "converter.inference_input_type = tf.int8\n", + "converter.inference_output_type = tf.int8\n", + "# Provide a representative dataset to ensure we quantize correctly.\n", + "converter.representative_dataset = representative_dataset\n", + "model_tflite = converter.convert()\n", + "\n", + "# Save the model to disk\n", + "open(MODEL_TFLITE, \"wb\").write(model_tflite)" + ], + "execution_count": 17, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "2488" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 17 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L_vE-ZDkHVxe" + }, + "source": [ + "### 2. Compare Model Performance\n", + "\n", + "To prove these models are accurate even after conversion and quantization, we'll compare their predictions and loss on our test dataset.\n", + "\n", + "**Helper functions**\n", + "\n", + "We define the `predict` (for predictions) and `evaluate` (for loss) functions for TFLite models. *Note: These are already included in a TF model, but not in a TFLite model.*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "NKtmxEhko1S1", + "cellView": "code" + }, + "source": [ + "def predict_tflite(tflite_model, x_test):\n", + " # Prepare the test data\n", + " x_test_ = x_test.copy()\n", + " x_test_ = x_test_.reshape((x_test.size, 1))\n", + " x_test_ = x_test_.astype(np.float32)\n", + "\n", + " # Initialize the TFLite interpreter\n", + " interpreter = tf.lite.Interpreter(model_content=tflite_model)\n", + " interpreter.allocate_tensors()\n", + "\n", + " input_details = interpreter.get_input_details()[0]\n", + " output_details = interpreter.get_output_details()[0]\n", + "\n", + " # If required, quantize the input layer (from float to integer)\n", + " input_scale, input_zero_point = input_details[\"quantization\"]\n", + " if (input_scale, input_zero_point) != (0.0, 0):\n", + " x_test_ = x_test_ / input_scale + input_zero_point\n", + " x_test_ = x_test_.astype(input_details[\"dtype\"])\n", + " \n", + " # Invoke the interpreter\n", + " y_pred = np.empty(x_test_.size, dtype=output_details[\"dtype\"])\n", + " for i in range(len(x_test_)):\n", + " interpreter.set_tensor(input_details[\"index\"], [x_test_[i]])\n", + " interpreter.invoke()\n", + " y_pred[i] = interpreter.get_tensor(output_details[\"index\"])[0]\n", + " \n", + " # If required, dequantized the output layer (from integer to float)\n", + " output_scale, output_zero_point = output_details[\"quantization\"]\n", + " if (output_scale, output_zero_point) != (0.0, 0):\n", + " y_pred = y_pred.astype(np.float32)\n", + " y_pred = (y_pred - output_zero_point) * output_scale\n", + "\n", + " return y_pred\n", + "\n", + "def evaluate_tflite(tflite_model, x_test, y_true):\n", + " global model\n", + " y_pred = predict_tflite(tflite_model, x_test)\n", + " loss_function = tf.keras.losses.get(model.loss)\n", + " loss = loss_function(y_true, y_pred).numpy()\n", + " return loss" + ], + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pLZLY0D4gl6U" + }, + "source": [ + "**1. Predictions**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0RS3zni1gkrt" + }, + "source": [ + "# Calculate predictions\n", + "y_test_pred_tf = model.predict(x_test)\n", + "y_test_pred_no_quant_tflite = predict_tflite(model_no_quant_tflite, x_test)\n", + "y_test_pred_tflite = predict_tflite(model_tflite, x_test)" + ], + "execution_count": 28, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "-J7IKlXiYVPz", + "outputId": "24017e5e-7672-460c-8b76-c0ed71f3ec27", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + } + }, + "source": [ + "# Compare predictions\n", + "plt.clf()\n", + "plt.title('Comparison of various models against actual values')\n", + "plt.plot(x_test, y_test, 'bo', label='Actual values')\n", + "plt.plot(x_test, y_test_pred_tf, 'ro', label='TF predictions')\n", + "plt.plot(x_test, y_test_pred_no_quant_tflite, 'bx', label='TFLite predictions')\n", + "plt.plot(x_test, y_test_pred_tflite, 'gx', label='TFLite quantized predictions')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 29, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V7vlfJqbiZMU" + }, + "source": [ + "**2. Loss (MSE/Mean Squared Error)**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IpHifyGZRhw8" + }, + "source": [ + "# Calculate loss\n", + "loss_tf, _ = model.evaluate(x_test, y_test, verbose=0)\n", + "loss_no_quant_tflite = evaluate_tflite(model_no_quant_tflite, x_test, y_test)\n", + "loss_tflite = evaluate_tflite(model_tflite, x_test, y_test)" + ], + "execution_count": 30, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "g3HLT0UOjTY_", + "outputId": "0c1c279a-96bd-4e8d-8a65-6a071376825b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 171 + } + }, + "source": [ + "# Compare loss\n", + "df = pd.DataFrame.from_records(\n", + " [[\"TensorFlow\", loss_tf],\n", + " [\"TensorFlow Lite\", loss_no_quant_tflite],\n", + " [\"TensorFlow Lite Quantized\", loss_tflite]],\n", + " columns = [\"Model\", \"Loss/MSE\"], index=\"Model\").round(4)\n", + "df" + ], + "execution_count": 31, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Loss/MSE
Model
TensorFlow0.0102
TensorFlow Lite0.0102
TensorFlow Lite Quantized0.0108
\n", + "
" + ], + "text/plain": [ + " Loss/MSE\n", + "Model \n", + "TensorFlow 0.0102\n", + "TensorFlow Lite 0.0102\n", + "TensorFlow Lite Quantized 0.0108" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 31 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E7Vjw7VckLu1" + }, + "source": [ + "**3. Size**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "wEXiJ8dFkL2R" + }, + "source": [ + "# Calculate size\n", + "size_tf = os.path.getsize(MODEL_TF)\n", + "size_no_quant_tflite = os.path.getsize(MODEL_NO_QUANT_TFLITE)\n", + "size_tflite = os.path.getsize(MODEL_TFLITE)" + ], + "execution_count": 32, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "8DdsCaL7kL4u", + "outputId": "9644f10d-0914-4939-b596-facb90e4b961", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 171 + } + }, + "source": [ + "# Compare size\n", + "pd.DataFrame.from_records(\n", + " [[\"TensorFlow\", f\"{size_tf} bytes\", \"\"],\n", + " [\"TensorFlow Lite\", f\"{size_no_quant_tflite} bytes \", f\"(reduced by {size_tf - size_no_quant_tflite} bytes)\"],\n", + " [\"TensorFlow Lite Quantized\", f\"{size_tflite} bytes\", f\"(reduced by {size_no_quant_tflite - size_tflite} bytes)\"]],\n", + " columns = [\"Model\", \"Size\", \"\"], index=\"Model\")" + ], + "execution_count": 33, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Size
Model
TensorFlow4096 bytes
TensorFlow Lite2788 bytes(reduced by 1308 bytes)
TensorFlow Lite Quantized2488 bytes(reduced by 300 bytes)
\n", + "
" + ], + "text/plain": [ + " Size \n", + "Model \n", + "TensorFlow 4096 bytes \n", + "TensorFlow Lite 2788 bytes (reduced by 1308 bytes)\n", + "TensorFlow Lite Quantized 2488 bytes (reduced by 300 bytes)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 33 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qXdmfo7imGMB" + }, + "source": [ + "**Summary**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "R1LVMA2nkM_l" + }, + "source": [ + "We can see from the predictions (graph) and loss (table) that the original TF model, the TFLite model, and the quantized TFLite model are all close enough to be indistinguishable - even though they differ in size (table). This implies that the quantized (smallest) model is ready to use!\n", + "\n", + "*Note: The quantized (integer) TFLite model is just 300 bytes smaller than the original (float) TFLite model - a tiny reduction in size! This is because the model is already so small that quantization has little effect. Complex models with more weights, can have upto a 4x reduction in size!*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HPSFmDL7pv2L" + }, + "source": [ + "## Generate a TensorFlow Lite for Microcontrollers Model\n", + "Convert the TensorFlow Lite quantized model into a C source file that can be loaded by TensorFlow Lite for Microcontrollers." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "j1FB4ieeg0lw", + "outputId": "c25b75c6-a28d-47b1-9b3a-b7ba821ee310", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "source": [ + "# Install xxd if it is not available\n", + "!apt-get update && apt-get -qq install xxd\n", + "# Convert to a C source file, i.e, a TensorFlow Lite for Microcontrollers model\n", + "!xxd -i {MODEL_TFLITE} > {MODEL_TFLITE_MICRO}\n", + "# Update variable names\n", + "REPLACE_TEXT = MODEL_TFLITE.replace('/', '_').replace('.', '_')\n", + "!sed -i 's/'{REPLACE_TEXT}'/g_model/g' {MODEL_TFLITE_MICRO}" + ], + "execution_count": 34, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\r0% [Working]\r \rIgn:1 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 InRelease\n", + "\r0% [Waiting for headers] [Waiting for headers] [Waiting for headers] [Waiting f\r \rHit:2 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease\n", + "\r0% [Waiting for headers] [Waiting for headers] [Waiting for headers] [Waiting f\r0% [2 InRelease gpgv 3,626 B] [Waiting for headers] [Waiting for headers] [Wait\r \rIgn:3 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 InRelease\n", + "\r0% [2 InRelease gpgv 3,626 B] [Waiting for headers] [Waiting for headers] [Wait\r \rHit:4 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n", + "\r0% [2 InRelease gpgv 3,626 B] [Waiting for headers] [Waiting for headers] [Conn\r \rHit:5 http://archive.ubuntu.com/ubuntu bionic InRelease\n", + "\r0% [2 InRelease gpgv 3,626 B] [Waiting for headers] [Waiting for headers] [Conn\r \rHit:6 http://security.ubuntu.com/ubuntu bionic-security InRelease\n", + "Hit:7 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 Release\n", + "Hit:8 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 Release\n", + "Hit:9 http://archive.ubuntu.com/ubuntu bionic-updates InRelease\n", + "Hit:10 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n", + "Hit:11 http://archive.ubuntu.com/ubuntu bionic-backports InRelease\n", + "Reading package lists... Done\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JvRy0ZyMhQOX" + }, + "source": [ + "## Deploy to a Microcontroller\n", + "\n", + "Follow the instructions in the [hello_world](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/micro/examples/hello_world) README.md for [TensorFlow Lite for MicroControllers](https://www.tensorflow.org/lite/microcontrollers/overview) to deploy this model on a specific microcontroller.\n", + "\n", + "**Reference Model:** If you have not modified this notebook, you can follow the instructions as is, to deploy the model. Refer to the [`hello_world/train/models`](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/micro/examples/hello_world/train/models) directory to access the models generated in this notebook.\n", + "\n", + "**New Model:** If you have generated a new model, then update the values assigned to the variables defined in [`hello_world/model.cc`](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/micro/examples/hello_world/model.cc) with values displayed after running the following cell." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "l4-WhtGpvb-E", + "outputId": "4c7925a5-4cf3-4f7a-fcbc-c8c2857423ea", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "source": [ + "# Print the C source file\n", + "!cat {MODEL_TFLITE_MICRO}" + ], + "execution_count": 35, + "outputs": [ + { + "output_type": "stream", + "text": [ + "unsigned char g_model[] = {\n", + " 0x1c, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c, 0x33, 0x14, 0x00, 0x20, 0x00,\n", + " 0x1c, 0x00, 0x18, 0x00, 0x14, 0x00, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00,\n", + " 0x08, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,\n", + " 0x98, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x1c, 0x03, 0x00, 0x00,\n", + " 0x2c, 0x03, 0x00, 0x00, 0x30, 0x09, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x60, 0xf7, 0xff, 0xff,\n", + " 0x10, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,\n", + " 0x44, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x73, 0x65, 0x72, 0x76,\n", + " 0x65, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x73, 0x65, 0x72, 0x76,\n", + " 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xbc, 0xff, 0xff, 0xff,\n", + " 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,\n", + " 0x64, 0x65, 0x6e, 0x73, 0x65, 0x5f, 0x34, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x04, 0x00, 0x00, 0x00, 0x76, 0xfd, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,\n", + " 0x0d, 0x00, 0x00, 0x00, 0x64, 0x65, 0x6e, 0x73, 0x65, 0x5f, 0x32, 0x5f,\n", + " 0x69, 0x6e, 0x70, 0x75, 0x74, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00,\n", + " 0x08, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0x13, 0x00, 0x00, 0x00, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x75, 0x6e, 0x74,\n", + " 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00,\n", + " 0x0c, 0x00, 0x00, 0x00, 0x50, 0x02, 0x00, 0x00, 0x48, 0x02, 0x00, 0x00,\n", + " 0x34, 0x02, 0x00, 0x00, 0xdc, 0x01, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00,\n", + " 0x6c, 0x01, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,\n", + " 0x34, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,\n", + " 0x04, 0x00, 0x00, 0x00, 0xfa, 0xfd, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,\n", + " 0x10, 0x00, 0x00, 0x00, 0x31, 0x2e, 0x35, 0x2e, 0x30, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xfd, 0xff, 0xff,\n", + " 0x88, 0xfd, 0xff, 0xff, 0x8c, 0xfd, 0xff, 0xff, 0x22, 0xfe, 0xff, 0xff,\n", + " 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x21, 0xa5, 0x8b, 0xca,\n", + " 0x5e, 0x1d, 0xce, 0x42, 0x9d, 0xce, 0x1f, 0xb0, 0xdf, 0x54, 0x2f, 0x81,\n", + " 0x3e, 0xfe, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,\n", + " 0xee, 0xfc, 0x00, 0xec, 0x05, 0x17, 0xef, 0xec, 0xe6, 0xf8, 0x03, 0x01,\n", + " 0x00, 0xfa, 0xf8, 0xf5, 0xdc, 0xeb, 0x27, 0x14, 0xf1, 0xde, 0xe2, 0xdb,\n", + " 0xf0, 0xde, 0x31, 0x06, 0x02, 0xe6, 0xee, 0xf9, 0x00, 0x16, 0x07, 0xe0,\n", + " 0xfe, 0xff, 0xe9, 0x06, 0xe7, 0xef, 0x81, 0x1b, 0x18, 0xea, 0xc9, 0x01,\n", + " 0x0f, 0x00, 0xda, 0xf7, 0x0e, 0xec, 0x13, 0x1f, 0x04, 0x13, 0xb4, 0xe6,\n", + " 0xfd, 0x06, 0xb9, 0xe0, 0x0d, 0xec, 0xf0, 0xde, 0xeb, 0xf7, 0x05, 0x26,\n", + " 0x1a, 0xe4, 0x6f, 0x1a, 0xea, 0x1e, 0x35, 0xdf, 0x1a, 0xf3, 0xf1, 0x19,\n", + " 0x0f, 0x03, 0x1b, 0xe1, 0xde, 0x13, 0xf6, 0x19, 0xff, 0xf6, 0x1b, 0x18,\n", + " 0xf0, 0x1c, 0xda, 0x1b, 0x1b, 0x20, 0xe5, 0x1a, 0xf5, 0xff, 0x96, 0x0b,\n", + " 0x00, 0x01, 0xcd, 0xde, 0x0d, 0xf6, 0x16, 0xe3, 0xed, 0xfc, 0x0e, 0xe9,\n", + " 0xfa, 0xeb, 0x5c, 0xfc, 0x1d, 0x02, 0x5b, 0xe2, 0xe1, 0xf5, 0x15, 0xec,\n", + " 0xf4, 0x00, 0x13, 0x05, 0xec, 0x0c, 0x1d, 0x14, 0x0e, 0xe7, 0x0b, 0xf4,\n", + " 0x19, 0x00, 0xd7, 0x05, 0x27, 0x02, 0x15, 0xea, 0xea, 0x02, 0x9b, 0x00,\n", + " 0x0c, 0xfa, 0xe8, 0xea, 0xfd, 0x00, 0x14, 0xfd, 0x0b, 0x02, 0xef, 0xee,\n", + " 0x06, 0xee, 0x01, 0x0d, 0x06, 0xe6, 0xf7, 0x11, 0xf7, 0x09, 0xf8, 0xf1,\n", + " 0x21, 0xff, 0x0e, 0xf3, 0xec, 0x12, 0x26, 0x1d, 0xf2, 0xe9, 0x28, 0x18,\n", + " 0xe0, 0xfb, 0xf3, 0xf4, 0x05, 0x1d, 0x1d, 0xfb, 0xfd, 0x1e, 0xfc, 0x11,\n", + " 0xe8, 0x07, 0x09, 0x03, 0x12, 0xf2, 0x36, 0xfb, 0xdc, 0x1c, 0xf9, 0xef,\n", + " 0xf3, 0xe7, 0x6f, 0x0c, 0x1d, 0x00, 0x45, 0xfd, 0x0e, 0xf0, 0x0b, 0x19,\n", + " 0x1a, 0xfa, 0xe0, 0x19, 0x1f, 0x13, 0x36, 0x1c, 0x12, 0xeb, 0x3b, 0x0c,\n", + " 0xb4, 0xcb, 0xe6, 0x13, 0xfa, 0xeb, 0xf1, 0x06, 0x1c, 0xfa, 0x18, 0xe5,\n", + " 0xeb, 0xcb, 0x0c, 0xf4, 0x4a, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,\n", + " 0x10, 0x00, 0x00, 0x00, 0x75, 0x1c, 0x11, 0xe1, 0x0c, 0x81, 0xa5, 0x42,\n", + " 0xfe, 0xd5, 0xd4, 0xb2, 0x61, 0x78, 0x19, 0xdf, 0x66, 0xff, 0xff, 0xff,\n", + " 0x04, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0x77, 0x0b, 0x00, 0x00, 0x53, 0xf6, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,\n", + " 0x77, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0xd3, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x72, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x07, 0x00, 0x00,\n", + " 0x67, 0xf5, 0xff, 0xff, 0x34, 0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,\n", + " 0xb2, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0xb5, 0x04, 0x00, 0x00, 0x78, 0x0a, 0x00, 0x00,\n", + " 0x2d, 0x06, 0x00, 0x00, 0x71, 0xf8, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,\n", + " 0x9a, 0x0a, 0x00, 0x00, 0xfe, 0xf7, 0xff, 0xff, 0x0e, 0x05, 0x00, 0x00,\n", + " 0xd4, 0x09, 0x00, 0x00, 0x47, 0xfe, 0xff, 0xff, 0xb6, 0x04, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0xac, 0xf7, 0xff, 0xff, 0x4b, 0xf9, 0xff, 0xff,\n", + " 0x4a, 0x05, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x08, 0x00, 0x04, 0x00,\n", + " 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0x8c, 0xef, 0xff, 0xff, 0x84, 0xff, 0xff, 0xff, 0x88, 0xff, 0xff, 0xff,\n", + " 0x0f, 0x00, 0x00, 0x00, 0x4d, 0x4c, 0x49, 0x52, 0x20, 0x43, 0x6f, 0x6e,\n", + " 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x18, 0x00, 0x14, 0x00,\n", + " 0x10, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00,\n", + " 0x14, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00,\n", + " 0xe0, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,\n", + " 0x84, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0x96, 0xff, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,\n", + " 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00,\n", + " 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,\n", + " 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0xca, 0xff, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,\n", + " 0xba, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,\n", + " 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,\n", + " 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00,\n", + " 0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x0c, 0x00, 0x0b, 0x00, 0x04, 0x00,\n", + " 0x0e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,\n", + " 0x18, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,\n", + " 0x08, 0x00, 0x07, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,\n", + " 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x4c, 0x04, 0x00, 0x00,\n", + " 0xd0, 0x03, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00,\n", + " 0x98, 0x02, 0x00, 0x00, 0x24, 0x02, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00,\n", + " 0x24, 0x01, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0xf0, 0xfb, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x54, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,\n", + " 0x6c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,\n", + " 0x01, 0x00, 0x00, 0x00, 0xdc, 0xfb, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00,\n", + " 0x18, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x4a, 0xce, 0x0a, 0x3c, 0x01, 0x00, 0x00, 0x00,\n", + " 0x34, 0x84, 0x85, 0x3f, 0x01, 0x00, 0x00, 0x00, 0xc5, 0x02, 0x8f, 0xbf,\n", + " 0x1e, 0x00, 0x00, 0x00, 0x53, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c,\n", + " 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x43,\n", + " 0x61, 0x6c, 0x6c, 0x3a, 0x30, 0x5f, 0x69, 0x6e, 0x74, 0x38, 0x00, 0x00,\n", + " 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x80, 0xfc, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x54, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,\n", + " 0x64, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,\n", + " 0x10, 0x00, 0x00, 0x00, 0x6c, 0xfc, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00,\n", + " 0x18, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n", + " 0x01, 0x00, 0x00, 0x00, 0x93, 0xd0, 0xc0, 0x3b, 0x01, 0x00, 0x00, 0x00,\n", + " 0xc2, 0x0f, 0xc0, 0x3f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x14, 0x00, 0x00, 0x00, 0x74, 0x66, 0x6c, 0x2e, 0x66, 0x75, 0x6c, 0x6c,\n", + " 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x31,\n", + " 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x10, 0x00, 0x00, 0x00, 0x08, 0xfd, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00,\n", + " 0x20, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x09, 0x64, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,\n", + " 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00, 0xf4, 0xfc, 0xff, 0xff,\n", + " 0x10, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,\n", + " 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0xe0, 0xdb, 0x47, 0x3c, 0x01, 0x00, 0x00, 0x00, 0x04, 0x14, 0x47, 0x40,\n", + " 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,\n", + " 0x74, 0x66, 0x6c, 0x2e, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x5f, 0x63, 0x6f,\n", + " 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x00, 0x02, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0xfe, 0xff, 0xff,\n", + " 0x14, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x09, 0x50, 0x00, 0x00, 0x00, 0x6c, 0xfd, 0xff, 0xff,\n", + " 0x10, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,\n", + " 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xfb, 0x4b, 0x0b, 0x3c,\n", + " 0x01, 0x00, 0x00, 0x00, 0x40, 0x84, 0x4b, 0x3f, 0x01, 0x00, 0x00, 0x00,\n", + " 0x63, 0x35, 0x8a, 0xbf, 0x0d, 0x00, 0x00, 0x00, 0x73, 0x74, 0x64, 0x2e,\n", + " 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x32, 0x00, 0x00, 0x00,\n", + " 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\n", + " 0x72, 0xfe, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,\n", + " 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x50, 0x00, 0x00, 0x00,\n", + " 0xdc, 0xfd, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,\n", + " 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x60, 0x01, 0x4f, 0x3c, 0x01, 0x00, 0x00, 0x00, 0x47, 0x6d, 0xb3, 0x3f,\n", + " 0x01, 0x00, 0x00, 0x00, 0x5d, 0x63, 0xcd, 0xbf, 0x0d, 0x00, 0x00, 0x00,\n", + " 0x73, 0x74, 0x64, 0x2e, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74,\n", + " 0x31, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\n", + " 0x10, 0x00, 0x00, 0x00, 0xe2, 0xfe, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00,\n", + " 0x48, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,\n", + " 0x50, 0x00, 0x00, 0x00, 0x4c, 0xfe, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00,\n", + " 0x18, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0xd5, 0x6b, 0x8a, 0x3b, 0x01, 0x00, 0x00, 0x00,\n", + " 0xab, 0x49, 0x01, 0x3f, 0x01, 0x00, 0x00, 0x00, 0xfd, 0x56, 0x09, 0xbf,\n", + " 0x0c, 0x00, 0x00, 0x00, 0x73, 0x74, 0x64, 0x2e, 0x63, 0x6f, 0x6e, 0x73,\n", + " 0x74, 0x61, 0x6e, 0x74, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,\n", + " 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x52, 0xff, 0xff, 0xff,\n", + " 0x14, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x02, 0x3c, 0x00, 0x00, 0x00, 0x44, 0xff, 0xff, 0xff,\n", + " 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x28, 0xb3, 0xd9, 0x38, 0x0c, 0x00, 0x00, 0x00,\n", + " 0x64, 0x65, 0x6e, 0x73, 0x65, 0x5f, 0x32, 0x2f, 0x62, 0x69, 0x61, 0x73,\n", + " 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\n", + " 0xaa, 0xff, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,\n", + " 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x38, 0x00, 0x00, 0x00,\n", + " 0x9c, 0xff, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0xdd, 0x9b, 0x21, 0x39, 0x0c, 0x00, 0x00, 0x00,\n", + " 0x64, 0x65, 0x6e, 0x73, 0x65, 0x5f, 0x33, 0x2f, 0x62, 0x69, 0x61, 0x73,\n", + " 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x0e, 0x00, 0x18, 0x00, 0x14, 0x00, 0x13, 0x00, 0x0c, 0x00,\n", + " 0x08, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x40, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,\n", + " 0x48, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x08, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,\n", + " 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0xf4, 0xd4, 0x51, 0x38, 0x0c, 0x00, 0x00, 0x00, 0x64, 0x65, 0x6e, 0x73,\n", + " 0x65, 0x5f, 0x34, 0x2f, 0x62, 0x69, 0x61, 0x73, 0x00, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x1c, 0x00,\n", + " 0x18, 0x00, 0x17, 0x00, 0x10, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,\n", + " 0x2c, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x09, 0x84, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,\n", + " 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x14, 0x00,\n", + " 0x10, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00,\n", + " 0x10, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,\n", + " 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,\n", + " 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x5d, 0x4f, 0xc9, 0x3c, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x86, 0xc8, 0x40,\n", + " 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,\n", + " 0x73, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x66, 0x61,\n", + " 0x75, 0x6c, 0x74, 0x5f, 0x64, 0x65, 0x6e, 0x73, 0x65, 0x5f, 0x32, 0x5f,\n", + " 0x69, 0x6e, 0x70, 0x75, 0x74, 0x3a, 0x30, 0x5f, 0x69, 0x6e, 0x74, 0x38,\n", + " 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,\n", + " 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,\n", + " 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xd8, 0xff, 0xff, 0xff,\n", + " 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,\n", + " 0x0c, 0x00, 0x0c, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,\n", + " 0x0c, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72,\n", + " 0x0c, 0x00, 0x10, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00,\n", + " 0x0c, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,\n", + " 0x00, 0x00, 0x00, 0x09\n", + "};\n", + "unsigned int g_model_len = 2488;\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file