diff --git a/BLcourse4/bayesian_neural_networks_wine.ipynb b/BLcourse4/bayesian_neural_networks_wine.ipynb
index fe250fa5b8b584bc3b8c95fc615b524715b0bbfc..47b78eac5434d3613788ffe9088a3ad7202b141e 100644
--- a/BLcourse4/bayesian_neural_networks_wine.ipynb
+++ b/BLcourse4/bayesian_neural_networks_wine.ipynb
@@ -1,746 +1,5071 @@
{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "bQufHvzxJZX1"
- },
- "source": [
- "# Probabilistic Bayesian Neural Networks\n",
- "\n",
- "**Author:** [Khalid Salama](https://www.linkedin.com/in/khalid-salama-24403144/)<br>\n",
- "**Date created:** 2021/01/15<br>\n",
- "**Last modified:** 2021/01/15<br>\n",
- "**Description:** Building probabilistic Bayesian neural network models with TensorFlow Probability."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "d6RFQWP6JZX3"
- },
- "source": [
- "## Introduction\n",
- "\n",
- "Taking a probabilistic approach to deep learning allows to account for *uncertainty*,\n",
- "so that models can assign less levels of confidence to incorrect predictions.\n",
- "Sources of uncertainty can be found in the data, due to measurement error or\n",
- "noise in the labels, or the model, due to insufficient data availability for\n",
- "the model to learn effectively.\n",
- "\n",
- "\n",
- "This example demonstrates how to build basic probabilistic Bayesian neural networks\n",
- "to account for these two types of uncertainty.\n",
- "We use [TensorFlow Probability](https://www.tensorflow.org/probability) library,\n",
- "which is compatible with Keras API.\n",
- "\n",
- "This example requires TensorFlow 2.3 or higher.\n",
- "You can install Tensorflow Probability using the following command:\n",
- "\n",
- "```python\n",
- "pip install tensorflow-probability\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "7upK2dweJZX4"
- },
- "source": [
- "## The dataset\n",
- "\n",
- "We use the [Wine Quality](https://archive.ics.uci.edu/ml/datasets/wine+quality)\n",
- "dataset, which is available in the [TensorFlow Datasets](https://www.tensorflow.org/datasets/catalog/wine_quality).\n",
- "We use the red wine subset, which contains 4,898 examples.\n",
- "The dataset has 11numerical physicochemical features of the wine, and the task\n",
- "is to predict the wine quality, which is a score between 0 and 10.\n",
- "In this example, we treat this as a regression task.\n",
- "\n",
- "You can install TensorFlow Datasets using the following command:\n",
- "\n",
- "```python\n",
- "pip install tensorflow-datasets\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "Rg3x9SPVJZX4"
- },
- "source": [
- "## Setup"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "id": "SZ8HIsVcJZX5",
- "outputId": "d986c301-f9f1-4982-b0cf-91571dfd9b2f",
- "colab": {
- "base_uri": "https://localhost:8080/"
- }
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
- "Requirement already satisfied: tensorflow-probability in /usr/local/lib/python3.9/dist-packages (0.19.0)\n",
- "Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.9/dist-packages (from tensorflow-probability) (1.16.0)\n",
- "Requirement already satisfied: cloudpickle>=1.3 in /usr/local/lib/python3.9/dist-packages (from tensorflow-probability) (2.2.1)\n",
- "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.9/dist-packages (from tensorflow-probability) (1.22.4)\n",
- "Requirement already satisfied: gast>=0.3.2 in /usr/local/lib/python3.9/dist-packages (from tensorflow-probability) (0.4.0)\n",
- "Requirement already satisfied: absl-py in /usr/local/lib/python3.9/dist-packages (from tensorflow-probability) (1.4.0)\n",
- "Requirement already satisfied: decorator in /usr/local/lib/python3.9/dist-packages (from tensorflow-probability) (4.4.2)\n",
- "Requirement already satisfied: dm-tree in /usr/local/lib/python3.9/dist-packages (from tensorflow-probability) (0.1.8)\n",
- "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
- "Requirement already satisfied: tensorflow-datasets in /usr/local/lib/python3.9/dist-packages (4.8.3)\n",
- "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (1.22.4)\n",
- "Requirement already satisfied: termcolor in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (2.2.0)\n",
- "Requirement already satisfied: tensorflow-metadata in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (1.12.0)\n",
- "Requirement already satisfied: click in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (8.1.3)\n",
- "Requirement already satisfied: dm-tree in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (0.1.8)\n",
- "Requirement already satisfied: wrapt in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (1.15.0)\n",
- "Requirement already satisfied: tqdm in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (4.65.0)\n",
- "Requirement already satisfied: toml in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (0.10.2)\n",
- "Requirement already satisfied: etils[enp,epath]>=0.9.0 in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (1.1.1)\n",
- "Requirement already satisfied: promise in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (2.3)\n",
- "Requirement already satisfied: psutil in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (5.9.4)\n",
- "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (2.27.1)\n",
- "Requirement already satisfied: absl-py in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (1.4.0)\n",
- "Requirement already satisfied: protobuf>=3.12.2 in /usr/local/lib/python3.9/dist-packages (from tensorflow-datasets) (3.19.6)\n",
- "Requirement already satisfied: typing_extensions in /usr/local/lib/python3.9/dist-packages (from etils[enp,epath]>=0.9.0->tensorflow-datasets) (4.5.0)\n",
- "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.9/dist-packages (from etils[enp,epath]>=0.9.0->tensorflow-datasets) (5.12.0)\n",
- "Requirement already satisfied: zipp in /usr/local/lib/python3.9/dist-packages (from etils[enp,epath]>=0.9.0->tensorflow-datasets) (3.15.0)\n",
- "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests>=2.19.0->tensorflow-datasets) (1.26.15)\n",
- "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests>=2.19.0->tensorflow-datasets) (2.0.12)\n",
- "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests>=2.19.0->tensorflow-datasets) (3.4)\n",
- "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests>=2.19.0->tensorflow-datasets) (2022.12.7)\n",
- "Requirement already satisfied: six in /usr/local/lib/python3.9/dist-packages (from promise->tensorflow-datasets) (1.16.0)\n",
- "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /usr/local/lib/python3.9/dist-packages (from tensorflow-metadata->tensorflow-datasets) (1.59.0)\n"
- ]
- }
- ],
- "source": [
- "!pip install tensorflow-probability\n",
- "!pip install tensorflow-datasets\n",
- "import numpy as np\n",
- "import tensorflow as tf\n",
- "from tensorflow import keras\n",
- "from tensorflow.keras import layers\n",
- "import tensorflow_datasets as tfds\n",
- "import tensorflow_probability as tfp"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "r_fw7qGhJZX5"
- },
- "source": [
- "## Create training and evaluation datasets\n",
- "\n",
- "Here, we load the `wine_quality` dataset using `tfds.load()`, and we convert\n",
- "the target feature to float. Then, we shuffle the dataset and split it into\n",
- "training and test sets. We take the first `train_size` examples as the train\n",
- "split, and the rest as the test split."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "id": "47HHMmwvJZX6"
- },
- "outputs": [],
- "source": [
- "\n",
- "def get_train_and_test_splits(train_size, batch_size=1):\n",
- " # We prefetch with a buffer the same size as the dataset because th dataset\n",
- " # is very small and fits into memory.\n",
- " dataset = (\n",
- " tfds.load(name=\"wine_quality\", as_supervised=True, split=\"train\")\n",
- " .map(lambda x, y: (x, tf.cast(y, tf.float32)))\n",
- " .prefetch(buffer_size=dataset_size)\n",
- " .cache()\n",
- " )\n",
- " # We shuffle with a buffer the same size as the dataset.\n",
- " train_dataset = (\n",
- " dataset.take(train_size).shuffle(buffer_size=train_size).batch(batch_size)\n",
- " )\n",
- " test_dataset = dataset.skip(train_size).batch(batch_size)\n",
- "\n",
- " return train_dataset, test_dataset\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "BnNWHEbCJZX6"
- },
- "source": [
- "## Compile, train, and evaluate the model"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "id": "cz1h4N0jJZX6"
- },
- "outputs": [],
- "source": [
- "hidden_units = [8, 8]\n",
- "learning_rate = 0.001\n",
- "\n",
- "\n",
- "def run_experiment(model, loss, train_dataset, test_dataset):\n",
- "\n",
- " model.compile(\n",
- " optimizer=keras.optimizers.RMSprop(learning_rate=learning_rate),\n",
- " loss=loss,\n",
- " metrics=[keras.metrics.RootMeanSquaredError()],\n",
- " )\n",
- "\n",
- " print(\"Start training the model...\")\n",
- " model.fit(train_dataset, epochs=num_epochs, validation_data=test_dataset)\n",
- " print(\"Model training finished.\")\n",
- " _, rmse = model.evaluate(train_dataset, verbose=0)\n",
- " print(f\"Train RMSE: {round(rmse, 3)}\")\n",
- "\n",
- " print(\"Evaluating model performance...\")\n",
- " _, rmse = model.evaluate(test_dataset, verbose=0)\n",
- " print(f\"Test RMSE: {round(rmse, 3)}\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "tHoGJPopJZX6"
- },
- "source": [
- "## Create model inputs"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "4gjSUoRRJZX7"
- },
- "outputs": [],
- "source": [
- "FEATURE_NAMES = [\n",
- " \"fixed acidity\",\n",
- " \"volatile acidity\",\n",
- " \"citric acid\",\n",
- " \"residual sugar\",\n",
- " \"chlorides\",\n",
- " \"free sulfur dioxide\",\n",
- " \"total sulfur dioxide\",\n",
- " \"density\",\n",
- " \"pH\",\n",
- " \"sulphates\",\n",
- " \"alcohol\",\n",
- "]\n",
- "\n",
- "\n",
- "def create_model_inputs():\n",
- " inputs = {}\n",
- " for feature_name in FEATURE_NAMES:\n",
- " inputs[feature_name] = layers.Input(\n",
- " name=feature_name, shape=(1,), dtype=tf.float32\n",
- " )\n",
- " return inputs\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "RyCIq6FlJZX7"
- },
- "source": [
- "## Experiment 1: standard neural network\n",
- "\n",
- "We create a standard deterministic neural network model as a baseline."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "NmMnI_LzJZX7"
- },
- "outputs": [],
- "source": [
- "\n",
- "def create_baseline_model():\n",
- " inputs = create_model_inputs()\n",
- " input_values = [value for _, value in sorted(inputs.items())]\n",
- " features = keras.layers.concatenate(input_values)\n",
- " features = layers.BatchNormalization()(features)\n",
- "\n",
- " # Create hidden layers with deterministic weights using the Dense layer.\n",
- " for units in hidden_units:\n",
- " features = layers.Dense(units, activation=\"sigmoid\")(features)\n",
- " # The output is deterministic: a single point estimate.\n",
- " outputs = layers.Dense(units=1)(features)\n",
- "\n",
- " model = keras.Model(inputs=inputs, outputs=outputs)\n",
- " return model\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "bV0P5F9FJZX7"
- },
- "source": [
- "Let's split the wine dataset into training and test sets, with 85% and 15% of\n",
- "the examples, respectively."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "j71HZHqEJZX7"
- },
- "outputs": [],
- "source": [
- "dataset_size = 4898\n",
- "batch_size = 256\n",
- "train_size = int(dataset_size * 0.85)\n",
- "train_dataset, test_dataset = get_train_and_test_splits(train_size, batch_size)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "mwPeGoCTJZX8"
- },
- "source": [
- "Now let's train the baseline model. We use the `MeanSquaredError`\n",
- "as the loss function."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "pAMJafENJZX8"
- },
- "outputs": [],
- "source": [
- "num_epochs = 100\n",
- "mse_loss = keras.losses.MeanSquaredError()\n",
- "baseline_model = create_baseline_model()\n",
- "run_experiment(baseline_model, mse_loss, train_dataset, test_dataset)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "SYVUafCKJZX8"
- },
- "source": [
- "We take a sample from the test set use the model to obtain predictions for them.\n",
- "Note that since the baseline model is deterministic, we get a single a\n",
- "*point estimate* prediction for each test example, with no information about the\n",
- "uncertainty of the model nor the prediction."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "sBt9xVWJJZX8"
- },
- "outputs": [],
- "source": [
- "sample = 10\n",
- "examples, targets = list(test_dataset.unbatch().shuffle(batch_size * 10).batch(sample))[\n",
- " 0\n",
- "]\n",
- "\n",
- "predicted = baseline_model(examples).numpy()\n",
- "for idx in range(sample):\n",
- " print(f\"Predicted: {round(float(predicted[idx][0]), 1)} - Actual: {targets[idx]}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "RRyLpJQ4JZX8"
- },
- "source": [
- "## Experiment 2: Bayesian neural network (BNN)\n",
- "\n",
- "The object of the Bayesian approach for modeling neural networks is to capture\n",
- "the *epistemic uncertainty*, which is uncertainty about the model fitness,\n",
- "due to limited training data.\n",
- "\n",
- "The idea is that, instead of learning specific weight (and bias) *values* in the\n",
- "neural network, the Bayesian approach learns weight *distributions*\n",
- "- from which we can sample to produce an output for a given input -\n",
- "to encode weight uncertainty.\n",
- "\n",
- "Thus, we need to define prior and the posterior distributions of these weights,\n",
- "and the training process is to learn the parameters of these distributions."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "eRZ-K9-yJZX8"
- },
- "outputs": [],
- "source": [
- "# Define the prior weight distribution as Normal of mean=0 and stddev=1.\n",
- "# Note that, in this example, the we prior distribution is not trainable,\n",
- "# as we fix its parameters.\n",
- "def prior(kernel_size, bias_size, dtype=None):\n",
- " n = kernel_size + bias_size\n",
- " prior_model = keras.Sequential(\n",
- " [\n",
- " tfp.layers.DistributionLambda(\n",
- " lambda t: tfp.distributions.MultivariateNormalDiag(\n",
- " loc=tf.zeros(n), scale_diag=tf.ones(n)\n",
- " )\n",
- " )\n",
- " ]\n",
- " )\n",
- " return prior_model\n",
- "\n",
- "\n",
- "# Define variational posterior weight distribution as multivariate Gaussian.\n",
- "# Note that the learnable parameters for this distribution are the means,\n",
- "# variances, and covariances.\n",
- "def posterior(kernel_size, bias_size, dtype=None):\n",
- " n = kernel_size + bias_size\n",
- " posterior_model = keras.Sequential(\n",
- " [\n",
- " tfp.layers.VariableLayer(\n",
- " tfp.layers.MultivariateNormalTriL.params_size(n), dtype=dtype\n",
- " ),\n",
- " tfp.layers.MultivariateNormalTriL(n),\n",
- " ]\n",
- " )\n",
- " return posterior_model\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "1oyFZyk6JZX9"
- },
- "source": [
- "We use the `tfp.layers.DenseVariational` layer instead of the standard\n",
- "`keras.layers.Dense` layer in the neural network model."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "EtdF-vuJJZX9"
- },
- "outputs": [],
- "source": [
- "\n",
- "def create_bnn_model(train_size):\n",
- " inputs = create_model_inputs()\n",
- " features = keras.layers.concatenate(list(inputs.values()))\n",
- " features = layers.BatchNormalization()(features)\n",
- "\n",
- " # Create hidden layers with weight uncertainty using the DenseVariational layer.\n",
- " for units in hidden_units:\n",
- " features = tfp.layers.DenseVariational(\n",
- " units=units,\n",
- " make_prior_fn=prior,\n",
- " make_posterior_fn=posterior,\n",
- " kl_weight=1 / train_size,\n",
- " activation=\"sigmoid\",\n",
- " )(features)\n",
- "\n",
- " # The output is deterministic: a single point estimate.\n",
- " outputs = layers.Dense(units=1)(features)\n",
- " model = keras.Model(inputs=inputs, outputs=outputs)\n",
- " return model\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "7mWuwXVoJZX9"
- },
- "source": [
- "The epistemic uncertainty can be reduced as we increase the size of the\n",
- "training data. That is, the more data the BNN model sees, the more it is certain\n",
- "about its estimates for the weights (distribution parameters).\n",
- "Let's test this behaviour by training the BNN model on a small subset of\n",
- "the training set, and then on the full training set, to compare the output variances."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "qVqiPpv3JZX9"
- },
- "source": [
- "### Train BNN with a small training subset."
- ]
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bQufHvzxJZX1"
+ },
+ "source": [
+ "# Probabilistic Bayesian Neural Networks\n",
+ "\n",
+ "**Author:** [Khalid Salama](https://www.linkedin.com/in/khalid-salama-24403144/)<br>\n",
+ "**Date created:** 2021/01/15<br>\n",
+ "**Last modified:** 2021/01/15<br>\n",
+ "**Description:** Building probabilistic Bayesian neural network models with TensorFlow Probability."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "d6RFQWP6JZX3"
+ },
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "Taking a probabilistic approach to deep learning allows to account for *uncertainty*,\n",
+ "so that models can assign less levels of confidence to incorrect predictions.\n",
+ "Sources of uncertainty can be found in the data, due to measurement error or\n",
+ "noise in the labels, or the model, due to insufficient data availability for\n",
+ "the model to learn effectively.\n",
+ "\n",
+ "\n",
+ "This example demonstrates how to build basic probabilistic Bayesian neural networks\n",
+ "to account for these two types of uncertainty.\n",
+ "We use [TensorFlow Probability](https://www.tensorflow.org/probability) library,\n",
+ "which is compatible with Keras API.\n",
+ "\n",
+ "This example requires TensorFlow 2.3 or higher.\n",
+ "You can install Tensorflow Probability using the following command:\n",
+ "\n",
+ "```python\n",
+ "pip install tensorflow-probability\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7upK2dweJZX4"
+ },
+ "source": [
+ "## The dataset\n",
+ "\n",
+ "We use the [Wine Quality](https://archive.ics.uci.edu/ml/datasets/wine+quality)\n",
+ "dataset, which is available in the [TensorFlow Datasets](https://www.tensorflow.org/datasets/catalog/wine_quality).\n",
+ "We use the red wine subset, which contains 4,898 examples.\n",
+ "The dataset has 11numerical physicochemical features of the wine, and the task\n",
+ "is to predict the wine quality, which is a score between 0 and 10.\n",
+ "In this example, we treat this as a regression task.\n",
+ "\n",
+ "You can install TensorFlow Datasets using the following command:\n",
+ "\n",
+ "```python\n",
+ "pip install tensorflow-datasets\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Rg3x9SPVJZX4"
+ },
+ "source": [
+ "## Setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
},
+ "id": "SZ8HIsVcJZX5",
+ "outputId": "d986c301-f9f1-4982-b0cf-91571dfd9b2f"
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import tensorflow as tf\n",
+ "from tensorflow import keras\n",
+ "from tensorflow.keras import layers\n",
+ "import tensorflow_datasets as tfds\n",
+ "import tensorflow_probability as tfp"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "r_fw7qGhJZX5"
+ },
+ "source": [
+ "## Create training and evaluation datasets\n",
+ "\n",
+ "Here, we load the `wine_quality` dataset using `tfds.load()`, and we convert\n",
+ "the target feature to float. Then, we shuffle the dataset and split it into\n",
+ "training and test sets. We take the first `train_size` examples as the train\n",
+ "split, and the rest as the test split."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "id": "47HHMmwvJZX6"
+ },
+ "outputs": [],
+ "source": [
+ "\n",
+ "def get_train_and_test_splits(train_size, batch_size=1):\n",
+ " # We prefetch with a buffer the same size as the dataset because th dataset\n",
+ " # is very small and fits into memory.\n",
+ " dataset = (\n",
+ " tfds.load(name=\"wine_quality\", data_dir=\"/p/project/training2305/course-material-upd/BLcourse4/datasets/\", as_supervised=True, split=\"train\")\n",
+ " .map(lambda x, y: (x, tf.cast(y, tf.float32)))\n",
+ " .prefetch(buffer_size=dataset_size)\n",
+ " .cache()\n",
+ " )\n",
+ " # We shuffle with a buffer the same size as the dataset.\n",
+ " train_dataset = (\n",
+ " dataset.take(train_size).shuffle(buffer_size=train_size).batch(batch_size)\n",
+ " )\n",
+ " test_dataset = dataset.skip(train_size).batch(batch_size)\n",
+ "\n",
+ " return train_dataset, test_dataset\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BnNWHEbCJZX6"
+ },
+ "source": [
+ "## Compile, train, and evaluate the model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "id": "cz1h4N0jJZX6"
+ },
+ "outputs": [],
+ "source": [
+ "hidden_units = [8, 8]\n",
+ "learning_rate = 0.001\n",
+ "\n",
+ "\n",
+ "def run_experiment(model, loss, train_dataset, test_dataset):\n",
+ "\n",
+ " model.compile(\n",
+ " optimizer=keras.optimizers.RMSprop(learning_rate=learning_rate),\n",
+ " loss=loss,\n",
+ " metrics=[keras.metrics.RootMeanSquaredError()],\n",
+ " )\n",
+ "\n",
+ " print(\"Start training the model...\")\n",
+ " model.fit(train_dataset, epochs=num_epochs, validation_data=test_dataset)\n",
+ " print(\"Model training finished.\")\n",
+ " _, rmse = model.evaluate(train_dataset, verbose=0)\n",
+ " print(f\"Train RMSE: {round(rmse, 3)}\")\n",
+ "\n",
+ " print(\"Evaluating model performance...\")\n",
+ " _, rmse = model.evaluate(test_dataset, verbose=0)\n",
+ " print(f\"Test RMSE: {round(rmse, 3)}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "tHoGJPopJZX6"
+ },
+ "source": [
+ "## Create model inputs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "id": "4gjSUoRRJZX7"
+ },
+ "outputs": [],
+ "source": [
+ "FEATURE_NAMES = [\n",
+ " \"fixed acidity\",\n",
+ " \"volatile acidity\",\n",
+ " \"citric acid\",\n",
+ " \"residual sugar\",\n",
+ " \"chlorides\",\n",
+ " \"free sulfur dioxide\",\n",
+ " \"total sulfur dioxide\",\n",
+ " \"density\",\n",
+ " \"pH\",\n",
+ " \"sulphates\",\n",
+ " \"alcohol\",\n",
+ "]\n",
+ "\n",
+ "\n",
+ "def create_model_inputs():\n",
+ " inputs = {}\n",
+ " for feature_name in FEATURE_NAMES:\n",
+ " inputs[feature_name] = layers.Input(\n",
+ " name=feature_name, shape=(1,), dtype=tf.float32\n",
+ " )\n",
+ " return inputs\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RyCIq6FlJZX7"
+ },
+ "source": [
+ "## Experiment 1: standard neural network\n",
+ "\n",
+ "We create a standard deterministic neural network model as a baseline."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "id": "NmMnI_LzJZX7"
+ },
+ "outputs": [],
+ "source": [
+ "\n",
+ "def create_baseline_model():\n",
+ " inputs = create_model_inputs()\n",
+ " input_values = [value for _, value in sorted(inputs.items())]\n",
+ " features = keras.layers.concatenate(input_values)\n",
+ " features = layers.BatchNormalization()(features)\n",
+ "\n",
+ " # Create hidden layers with deterministic weights using the Dense layer.\n",
+ " for units in hidden_units:\n",
+ " features = layers.Dense(units, activation=\"sigmoid\")(features)\n",
+ " # The output is deterministic: a single point estimate.\n",
+ " outputs = layers.Dense(units=1)(features)\n",
+ "\n",
+ " model = keras.Model(inputs=inputs, outputs=outputs)\n",
+ " return model\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bV0P5F9FJZX7"
+ },
+ "source": [
+ "Let's split the wine dataset into training and test sets, with 85% and 15% of\n",
+ "the examples, respectively."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "id": "j71HZHqEJZX7"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "_FTuHpudJZX9"
- },
- "outputs": [],
- "source": [
- "num_epochs = 500\n",
- "train_sample_size = int(train_size * 0.3)\n",
- "small_train_dataset = train_dataset.unbatch().take(train_sample_size).batch(batch_size)\n",
- "\n",
- "bnn_model_small = create_bnn_model(train_sample_size)\n",
- "run_experiment(bnn_model_small, mse_loss, small_train_dataset, test_dataset)"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "WARNING:tensorflow:From /p/software/jusuf/stages/2023/software/TensorFlow/2.11.0-foss-2022a-CUDA-11.7/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.\n",
+ "Instructions for updating:\n",
+ "Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089\n"
+ ]
},
{
- "cell_type": "markdown",
- "metadata": {
- "id": "fO-VvjydJZX9"
- },
- "source": [
- "Since we have trained a BNN model, the model produces a different output each time\n",
- "we call it with the same input, since each time a new set of weights are sampled\n",
- "from the distributions to construct the network and produce an output.\n",
- "The less certain the mode weights are, the more variability (wider range) we will\n",
- "see in the outputs of the same inputs."
- ]
- },
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2023-03-24 00:48:26.870482: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1613] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14628 MB memory: -> device: 0, name: Tesla V100-PCIE-16GB, pci bus id: 0000:01:00.0, compute capability: 7.0\n",
+ "WARNING:tensorflow:From /p/software/jusuf/stages/2023/software/TensorFlow/2.11.0-foss-2022a-CUDA-11.7/lib/python3.10/site-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.\n",
+ "Instructions for updating:\n",
+ "Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089\n"
+ ]
+ }
+ ],
+ "source": [
+ "dataset_size = 4898\n",
+ "batch_size = 256\n",
+ "train_size = int(dataset_size * 0.85)\n",
+ "train_dataset, test_dataset = get_train_and_test_splits(train_size, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mwPeGoCTJZX8"
+ },
+ "source": [
+ "Now let's train the baseline model. We use the `MeanSquaredError`\n",
+ "as the loss function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "id": "pAMJafENJZX8"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "oDLpALs7JZX-"
- },
- "outputs": [],
- "source": [
- "\n",
- "def compute_predictions(model, iterations=100):\n",
- " predicted = []\n",
- " for _ in range(iterations):\n",
- " predicted.append(model(examples).numpy())\n",
- " predicted = np.concatenate(predicted, axis=1)\n",
- "\n",
- " prediction_mean = np.mean(predicted, axis=1).tolist()\n",
- " prediction_min = np.min(predicted, axis=1).tolist()\n",
- " prediction_max = np.max(predicted, axis=1).tolist()\n",
- " prediction_range = (np.max(predicted, axis=1) - np.min(predicted, axis=1)).tolist()\n",
- "\n",
- " for idx in range(sample):\n",
- " print(\n",
- " f\"Predictions mean: {round(prediction_mean[idx], 2)}, \"\n",
- " f\"min: {round(prediction_min[idx], 2)}, \"\n",
- " f\"max: {round(prediction_max[idx], 2)}, \"\n",
- " f\"range: {round(prediction_range[idx], 2)} - \"\n",
- " f\"Actual: {targets[idx]}\"\n",
- " )\n",
- "\n",
- "\n",
- "compute_predictions(bnn_model_small)"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Start training the model...\n",
+ "Epoch 1/100\n"
+ ]
},
{
- "cell_type": "markdown",
- "metadata": {
- "id": "Mh1cMJ1VJZX-"
- },
- "source": [
- "### Train BNN with the whole training set."
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2023-03-24 00:48:44.574518: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n",
+ "2023-03-24 00:48:44.576634: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n",
+ "2023-03-24 00:48:45.665693: I tensorflow/compiler/xla/service/service.cc:173] XLA service 0x1d48f450 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
+ "2023-03-24 00:48:45.665736: I tensorflow/compiler/xla/service/service.cc:181] StreamExecutor device (0): Tesla V100-PCIE-16GB, Compute Capability 7.0\n",
+ "2023-03-24 00:48:45.672561: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
+ "2023-03-24 00:48:45.864279: I tensorflow/compiler/jit/xla_compilation_cache.cc:477] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n"
+ ]
},
{
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "_e8b8DCJJZX-"
- },
- "outputs": [],
- "source": [
- "num_epochs = 500\n",
- "bnn_model_full = create_bnn_model(train_size)\n",
- "run_experiment(bnn_model_full, mse_loss, train_dataset, test_dataset)\n",
- "\n",
- "compute_predictions(bnn_model_full)"
- ]
- },
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "17/17 [==============================] - 3s 29ms/step - loss: 28.1717 - root_mean_squared_error: 5.3077 - val_loss: 30.2676 - val_root_mean_squared_error: 5.5016\n",
+ "Epoch 2/100\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 26.5429 - root_mean_squared_error: 5.1520 - val_loss: 28.8875 - val_root_mean_squared_error: 5.3747\n",
+ "Epoch 3/100\n",
+ "17/17 [==============================] - 0s 8ms/step - loss: 25.1419 - root_mean_squared_error: 5.0142 - val_loss: 27.3569 - val_root_mean_squared_error: 5.2304\n",
+ "Epoch 4/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 23.7807 - root_mean_squared_error: 4.8765 - val_loss: 25.7095 - val_root_mean_squared_error: 5.0705\n",
+ "Epoch 5/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 22.4434 - root_mean_squared_error: 4.7374 - val_loss: 23.9920 - val_root_mean_squared_error: 4.8982\n",
+ "Epoch 6/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 21.1341 - root_mean_squared_error: 4.5972 - val_loss: 22.2725 - val_root_mean_squared_error: 4.7194\n",
+ "Epoch 7/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 19.8476 - root_mean_squared_error: 4.4551 - val_loss: 20.5857 - val_root_mean_squared_error: 4.5371\n",
+ "Epoch 8/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 18.5882 - root_mean_squared_error: 4.3114 - val_loss: 18.9616 - val_root_mean_squared_error: 4.3545\n",
+ "Epoch 9/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 17.3534 - root_mean_squared_error: 4.1657 - val_loss: 17.4257 - val_root_mean_squared_error: 4.1744\n",
+ "Epoch 10/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 16.1507 - root_mean_squared_error: 4.0188 - val_loss: 15.9671 - val_root_mean_squared_error: 3.9959\n",
+ "Epoch 11/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 14.9810 - root_mean_squared_error: 3.8705 - val_loss: 14.6045 - val_root_mean_squared_error: 3.8216\n",
+ "Epoch 12/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 13.8507 - root_mean_squared_error: 3.7217 - val_loss: 13.3276 - val_root_mean_squared_error: 3.6507\n",
+ "Epoch 13/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 12.7603 - root_mean_squared_error: 3.5722 - val_loss: 12.1438 - val_root_mean_squared_error: 3.4848\n",
+ "Epoch 14/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 11.7146 - root_mean_squared_error: 3.4227 - val_loss: 11.0377 - val_root_mean_squared_error: 3.3223\n",
+ "Epoch 15/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 10.7145 - root_mean_squared_error: 3.2733 - val_loss: 10.0098 - val_root_mean_squared_error: 3.1638\n",
+ "Epoch 16/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 9.7619 - root_mean_squared_error: 3.1244 - val_loss: 9.0556 - val_root_mean_squared_error: 3.0092\n",
+ "Epoch 17/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 8.8589 - root_mean_squared_error: 2.9764 - val_loss: 8.1651 - val_root_mean_squared_error: 2.8575\n",
+ "Epoch 18/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 8.0045 - root_mean_squared_error: 2.8292 - val_loss: 7.3380 - val_root_mean_squared_error: 2.7089\n",
+ "Epoch 19/100\n",
+ "17/17 [==============================] - 0s 8ms/step - loss: 7.1984 - root_mean_squared_error: 2.6830 - val_loss: 6.5688 - val_root_mean_squared_error: 2.5630\n",
+ "Epoch 20/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 6.4430 - root_mean_squared_error: 2.5383 - val_loss: 5.8499 - val_root_mean_squared_error: 2.4186\n",
+ "Epoch 21/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 5.7350 - root_mean_squared_error: 2.3948 - val_loss: 5.1847 - val_root_mean_squared_error: 2.2770\n",
+ "Epoch 22/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 5.0756 - root_mean_squared_error: 2.2529 - val_loss: 4.5714 - val_root_mean_squared_error: 2.1381\n",
+ "Epoch 23/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 4.4679 - root_mean_squared_error: 2.1137 - val_loss: 4.0112 - val_root_mean_squared_error: 2.0028\n",
+ "Epoch 24/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 3.9115 - root_mean_squared_error: 1.9778 - val_loss: 3.4982 - val_root_mean_squared_error: 1.8704\n",
+ "Epoch 25/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 3.4032 - root_mean_squared_error: 1.8448 - val_loss: 3.0336 - val_root_mean_squared_error: 1.7417\n",
+ "Epoch 26/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 2.9429 - root_mean_squared_error: 1.7155 - val_loss: 2.6135 - val_root_mean_squared_error: 1.6166\n",
+ "Epoch 27/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 2.5300 - root_mean_squared_error: 1.5906 - val_loss: 2.2460 - val_root_mean_squared_error: 1.4987\n",
+ "Epoch 28/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 2.1674 - root_mean_squared_error: 1.4722 - val_loss: 1.9191 - val_root_mean_squared_error: 1.3853\n",
+ "Epoch 29/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 1.8475 - root_mean_squared_error: 1.3592 - val_loss: 1.6381 - val_root_mean_squared_error: 1.2799\n",
+ "Epoch 30/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 1.5732 - root_mean_squared_error: 1.2543 - val_loss: 1.3985 - val_root_mean_squared_error: 1.1826\n",
+ "Epoch 31/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 1.3427 - root_mean_squared_error: 1.1588 - val_loss: 1.2057 - val_root_mean_squared_error: 1.0981\n",
+ "Epoch 32/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 1.1577 - root_mean_squared_error: 1.0760 - val_loss: 1.0539 - val_root_mean_squared_error: 1.0266\n",
+ "Epoch 33/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 1.0113 - root_mean_squared_error: 1.0057 - val_loss: 0.9381 - val_root_mean_squared_error: 0.9685\n",
+ "Epoch 34/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.9044 - root_mean_squared_error: 0.9510 - val_loss: 0.8645 - val_root_mean_squared_error: 0.9298\n",
+ "Epoch 35/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.8344 - root_mean_squared_error: 0.9134 - val_loss: 0.8181 - val_root_mean_squared_error: 0.9045\n",
+ "Epoch 36/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7923 - root_mean_squared_error: 0.8901 - val_loss: 0.7994 - val_root_mean_squared_error: 0.8941\n",
+ "Epoch 37/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7762 - root_mean_squared_error: 0.8810 - val_loss: 0.7969 - val_root_mean_squared_error: 0.8927\n",
+ "Epoch 38/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7717 - root_mean_squared_error: 0.8784 - val_loss: 0.7953 - val_root_mean_squared_error: 0.8918\n",
+ "Epoch 39/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7702 - root_mean_squared_error: 0.8776 - val_loss: 0.7948 - val_root_mean_squared_error: 0.8915\n",
+ "Epoch 40/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7679 - root_mean_squared_error: 0.8763 - val_loss: 0.7910 - val_root_mean_squared_error: 0.8894\n",
+ "Epoch 41/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7649 - root_mean_squared_error: 0.8746 - val_loss: 0.7904 - val_root_mean_squared_error: 0.8890\n",
+ "Epoch 42/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7621 - root_mean_squared_error: 0.8730 - val_loss: 0.7867 - val_root_mean_squared_error: 0.8870\n",
+ "Epoch 43/100\n",
+ "17/17 [==============================] - 0s 8ms/step - loss: 0.7593 - root_mean_squared_error: 0.8714 - val_loss: 0.7836 - val_root_mean_squared_error: 0.8852\n",
+ "Epoch 44/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7553 - root_mean_squared_error: 0.8691 - val_loss: 0.7801 - val_root_mean_squared_error: 0.8832\n",
+ "Epoch 45/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7516 - root_mean_squared_error: 0.8669 - val_loss: 0.7784 - val_root_mean_squared_error: 0.8822\n",
+ "Epoch 46/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7488 - root_mean_squared_error: 0.8653 - val_loss: 0.7707 - val_root_mean_squared_error: 0.8779\n",
+ "Epoch 47/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7445 - root_mean_squared_error: 0.8628 - val_loss: 0.7671 - val_root_mean_squared_error: 0.8758\n",
+ "Epoch 48/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7420 - root_mean_squared_error: 0.8614 - val_loss: 0.7647 - val_root_mean_squared_error: 0.8745\n",
+ "Epoch 49/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7396 - root_mean_squared_error: 0.8600 - val_loss: 0.7624 - val_root_mean_squared_error: 0.8732\n",
+ "Epoch 50/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7374 - root_mean_squared_error: 0.8587 - val_loss: 0.7605 - val_root_mean_squared_error: 0.8721\n",
+ "Epoch 51/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7349 - root_mean_squared_error: 0.8572 - val_loss: 0.7573 - val_root_mean_squared_error: 0.8702\n",
+ "Epoch 52/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7331 - root_mean_squared_error: 0.8562 - val_loss: 0.7552 - val_root_mean_squared_error: 0.8690\n",
+ "Epoch 53/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7315 - root_mean_squared_error: 0.8553 - val_loss: 0.7511 - val_root_mean_squared_error: 0.8667\n",
+ "Epoch 54/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7291 - root_mean_squared_error: 0.8539 - val_loss: 0.7499 - val_root_mean_squared_error: 0.8660\n",
+ "Epoch 55/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7284 - root_mean_squared_error: 0.8535 - val_loss: 0.7483 - val_root_mean_squared_error: 0.8651\n",
+ "Epoch 56/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7268 - root_mean_squared_error: 0.8525 - val_loss: 0.7456 - val_root_mean_squared_error: 0.8635\n",
+ "Epoch 57/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7241 - root_mean_squared_error: 0.8509 - val_loss: 0.7421 - val_root_mean_squared_error: 0.8615\n",
+ "Epoch 58/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7226 - root_mean_squared_error: 0.8500 - val_loss: 0.7405 - val_root_mean_squared_error: 0.8605\n",
+ "Epoch 59/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7200 - root_mean_squared_error: 0.8485 - val_loss: 0.7403 - val_root_mean_squared_error: 0.8604\n",
+ "Epoch 60/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7177 - root_mean_squared_error: 0.8472 - val_loss: 0.7338 - val_root_mean_squared_error: 0.8566\n",
+ "Epoch 61/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7151 - root_mean_squared_error: 0.8457 - val_loss: 0.7341 - val_root_mean_squared_error: 0.8568\n",
+ "Epoch 62/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7126 - root_mean_squared_error: 0.8442 - val_loss: 0.7275 - val_root_mean_squared_error: 0.8529\n",
+ "Epoch 63/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7112 - root_mean_squared_error: 0.8433 - val_loss: 0.7248 - val_root_mean_squared_error: 0.8513\n",
+ "Epoch 64/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7079 - root_mean_squared_error: 0.8414 - val_loss: 0.7239 - val_root_mean_squared_error: 0.8508\n",
+ "Epoch 65/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7049 - root_mean_squared_error: 0.8396 - val_loss: 0.7182 - val_root_mean_squared_error: 0.8475\n",
+ "Epoch 66/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.7020 - root_mean_squared_error: 0.8379 - val_loss: 0.7133 - val_root_mean_squared_error: 0.8446\n",
+ "Epoch 67/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6991 - root_mean_squared_error: 0.8361 - val_loss: 0.7102 - val_root_mean_squared_error: 0.8427\n",
+ "Epoch 68/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6944 - root_mean_squared_error: 0.8333 - val_loss: 0.7045 - val_root_mean_squared_error: 0.8394\n",
+ "Epoch 69/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6918 - root_mean_squared_error: 0.8317 - val_loss: 0.7033 - val_root_mean_squared_error: 0.8386\n",
+ "Epoch 70/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6864 - root_mean_squared_error: 0.8285 - val_loss: 0.6954 - val_root_mean_squared_error: 0.8339\n",
+ "Epoch 71/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6830 - root_mean_squared_error: 0.8264 - val_loss: 0.6929 - val_root_mean_squared_error: 0.8324\n",
+ "Epoch 72/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6788 - root_mean_squared_error: 0.8239 - val_loss: 0.6858 - val_root_mean_squared_error: 0.8281\n",
+ "Epoch 73/100\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6736 - root_mean_squared_error: 0.8207 - val_loss: 0.6806 - val_root_mean_squared_error: 0.8250\n",
+ "Epoch 74/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6693 - root_mean_squared_error: 0.8181 - val_loss: 0.6732 - val_root_mean_squared_error: 0.8205\n",
+ "Epoch 75/100\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6649 - root_mean_squared_error: 0.8154 - val_loss: 0.6676 - val_root_mean_squared_error: 0.8171\n",
+ "Epoch 76/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6605 - root_mean_squared_error: 0.8127 - val_loss: 0.6627 - val_root_mean_squared_error: 0.8141\n",
+ "Epoch 77/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6545 - root_mean_squared_error: 0.8090 - val_loss: 0.6585 - val_root_mean_squared_error: 0.8115\n",
+ "Epoch 78/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6487 - root_mean_squared_error: 0.8054 - val_loss: 0.6527 - val_root_mean_squared_error: 0.8079\n",
+ "Epoch 79/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6446 - root_mean_squared_error: 0.8029 - val_loss: 0.6437 - val_root_mean_squared_error: 0.8023\n",
+ "Epoch 80/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6378 - root_mean_squared_error: 0.7986 - val_loss: 0.6394 - val_root_mean_squared_error: 0.7996\n",
+ "Epoch 81/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6327 - root_mean_squared_error: 0.7955 - val_loss: 0.6323 - val_root_mean_squared_error: 0.7952\n",
+ "Epoch 82/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6278 - root_mean_squared_error: 0.7923 - val_loss: 0.6248 - val_root_mean_squared_error: 0.7904\n",
+ "Epoch 83/100\n",
+ "17/17 [==============================] - 0s 8ms/step - loss: 0.6205 - root_mean_squared_error: 0.7877 - val_loss: 0.6181 - val_root_mean_squared_error: 0.7862\n",
+ "Epoch 84/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6162 - root_mean_squared_error: 0.7850 - val_loss: 0.6121 - val_root_mean_squared_error: 0.7824\n",
+ "Epoch 85/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6099 - root_mean_squared_error: 0.7810 - val_loss: 0.6088 - val_root_mean_squared_error: 0.7803\n",
+ "Epoch 86/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6077 - root_mean_squared_error: 0.7796 - val_loss: 0.6015 - val_root_mean_squared_error: 0.7756\n",
+ "Epoch 87/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.6020 - root_mean_squared_error: 0.7759 - val_loss: 0.5970 - val_root_mean_squared_error: 0.7727\n",
+ "Epoch 88/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5985 - root_mean_squared_error: 0.7736 - val_loss: 0.5913 - val_root_mean_squared_error: 0.7690\n",
+ "Epoch 89/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5933 - root_mean_squared_error: 0.7703 - val_loss: 0.5885 - val_root_mean_squared_error: 0.7671\n",
+ "Epoch 90/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5915 - root_mean_squared_error: 0.7691 - val_loss: 0.5858 - val_root_mean_squared_error: 0.7654\n",
+ "Epoch 91/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5857 - root_mean_squared_error: 0.7653 - val_loss: 0.5801 - val_root_mean_squared_error: 0.7617\n",
+ "Epoch 92/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5840 - root_mean_squared_error: 0.7642 - val_loss: 0.5754 - val_root_mean_squared_error: 0.7585\n",
+ "Epoch 93/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5811 - root_mean_squared_error: 0.7623 - val_loss: 0.5724 - val_root_mean_squared_error: 0.7566\n",
+ "Epoch 94/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5767 - root_mean_squared_error: 0.7594 - val_loss: 0.5700 - val_root_mean_squared_error: 0.7550\n",
+ "Epoch 95/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5750 - root_mean_squared_error: 0.7583 - val_loss: 0.5679 - val_root_mean_squared_error: 0.7536\n",
+ "Epoch 96/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5744 - root_mean_squared_error: 0.7579 - val_loss: 0.5652 - val_root_mean_squared_error: 0.7518\n",
+ "Epoch 97/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5725 - root_mean_squared_error: 0.7566 - val_loss: 0.5637 - val_root_mean_squared_error: 0.7508\n",
+ "Epoch 98/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5717 - root_mean_squared_error: 0.7561 - val_loss: 0.5623 - val_root_mean_squared_error: 0.7499\n",
+ "Epoch 99/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5719 - root_mean_squared_error: 0.7562 - val_loss: 0.5606 - val_root_mean_squared_error: 0.7487\n",
+ "Epoch 100/100\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 0.5697 - root_mean_squared_error: 0.7548 - val_loss: 0.5593 - val_root_mean_squared_error: 0.7479\n",
+ "Model training finished.\n",
+ "Train RMSE: 0.754\n",
+ "Evaluating model performance...\n",
+ "Test RMSE: 0.748\n"
+ ]
+ }
+ ],
+ "source": [
+ "num_epochs = 100\n",
+ "mse_loss = keras.losses.MeanSquaredError()\n",
+ "baseline_model = create_baseline_model()\n",
+ "run_experiment(baseline_model, mse_loss, train_dataset, test_dataset)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SYVUafCKJZX8"
+ },
+ "source": [
+ "We take a sample from the test set use the model to obtain predictions for them.\n",
+ "Note that since the baseline model is deterministic, we get a single a\n",
+ "*point estimate* prediction for each test example, with no information about the\n",
+ "uncertainty of the model nor the prediction."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "id": "sBt9xVWJJZX8"
+ },
+ "outputs": [
{
- "cell_type": "markdown",
- "metadata": {
- "id": "Zd0ET93XJZX-"
- },
- "source": [
- "Notice that the model trained with the full training dataset shows smaller range\n",
- "(uncertainty) in the prediction values for the same inputs, compared to the model\n",
- "trained with a subset of the training dataset."
- ]
- },
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Predicted: 5.7 - Actual: 6.0\n",
+ "Predicted: 6.2 - Actual: 7.0\n",
+ "Predicted: 6.0 - Actual: 7.0\n",
+ "Predicted: 6.5 - Actual: 6.0\n",
+ "Predicted: 6.4 - Actual: 5.0\n",
+ "Predicted: 6.5 - Actual: 7.0\n",
+ "Predicted: 6.0 - Actual: 6.0\n",
+ "Predicted: 6.0 - Actual: 6.0\n",
+ "Predicted: 6.6 - Actual: 8.0\n",
+ "Predicted: 5.6 - Actual: 6.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "sample = 10\n",
+ "examples, targets = list(test_dataset.unbatch().shuffle(batch_size * 10).batch(sample))[\n",
+ " 0\n",
+ "]\n",
+ "\n",
+ "predicted = baseline_model(examples).numpy()\n",
+ "for idx in range(sample):\n",
+ " print(f\"Predicted: {round(float(predicted[idx][0]), 1)} - Actual: {targets[idx]}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RRyLpJQ4JZX8"
+ },
+ "source": [
+ "## Experiment 2: Bayesian neural network (BNN)\n",
+ "\n",
+ "The object of the Bayesian approach for modeling neural networks is to capture\n",
+ "the *epistemic uncertainty*, which is uncertainty about the model fitness,\n",
+ "due to limited training data.\n",
+ "\n",
+ "The idea is that, instead of learning specific weight (and bias) *values* in the\n",
+ "neural network, the Bayesian approach learns weight *distributions*\n",
+ "- from which we can sample to produce an output for a given input -\n",
+ "to encode weight uncertainty.\n",
+ "\n",
+ "Thus, we need to define prior and the posterior distributions of these weights,\n",
+ "and the training process is to learn the parameters of these distributions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "id": "eRZ-K9-yJZX8"
+ },
+ "outputs": [],
+ "source": [
+ "# Define the prior weight distribution as Normal of mean=0 and stddev=1.\n",
+ "# Note that, in this example, the we prior distribution is not trainable,\n",
+ "# as we fix its parameters.\n",
+ "def prior(kernel_size, bias_size, dtype=None):\n",
+ " n = kernel_size + bias_size\n",
+ " prior_model = keras.Sequential(\n",
+ " [\n",
+ " tfp.layers.DistributionLambda(\n",
+ " lambda t: tfp.distributions.MultivariateNormalDiag(\n",
+ " loc=tf.zeros(n), scale_diag=tf.ones(n)\n",
+ " )\n",
+ " )\n",
+ " ]\n",
+ " )\n",
+ " return prior_model\n",
+ "\n",
+ "\n",
+ "# Define variational posterior weight distribution as multivariate Gaussian.\n",
+ "# Note that the learnable parameters for this distribution are the means,\n",
+ "# variances, and covariances.\n",
+ "def posterior(kernel_size, bias_size, dtype=None):\n",
+ " n = kernel_size + bias_size\n",
+ " posterior_model = keras.Sequential(\n",
+ " [\n",
+ " tfp.layers.VariableLayer(\n",
+ " tfp.layers.MultivariateNormalTriL.params_size(n), dtype=dtype\n",
+ " ),\n",
+ " tfp.layers.MultivariateNormalTriL(n),\n",
+ " ]\n",
+ " )\n",
+ " return posterior_model\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1oyFZyk6JZX9"
+ },
+ "source": [
+ "We use the `tfp.layers.DenseVariational` layer instead of the standard\n",
+ "`keras.layers.Dense` layer in the neural network model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "id": "EtdF-vuJJZX9"
+ },
+ "outputs": [],
+ "source": [
+ "\n",
+ "def create_bnn_model(train_size):\n",
+ " inputs = create_model_inputs()\n",
+ " features = keras.layers.concatenate(list(inputs.values()))\n",
+ " features = layers.BatchNormalization()(features)\n",
+ "\n",
+ " # Create hidden layers with weight uncertainty using the DenseVariational layer.\n",
+ " for units in hidden_units:\n",
+ " features = tfp.layers.DenseVariational(\n",
+ " units=units,\n",
+ " make_prior_fn=prior,\n",
+ " make_posterior_fn=posterior,\n",
+ " kl_weight=1 / train_size,\n",
+ " activation=\"sigmoid\",\n",
+ " )(features)\n",
+ "\n",
+ " # The output is deterministic: a single point estimate.\n",
+ " outputs = layers.Dense(units=1)(features)\n",
+ " model = keras.Model(inputs=inputs, outputs=outputs)\n",
+ " return model\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7mWuwXVoJZX9"
+ },
+ "source": [
+ "The epistemic uncertainty can be reduced as we increase the size of the\n",
+ "training data. That is, the more data the BNN model sees, the more it is certain\n",
+ "about its estimates for the weights (distribution parameters).\n",
+ "Let's test this behaviour by training the BNN model on a small subset of\n",
+ "the training set, and then on the full training set, to compare the output variances."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qVqiPpv3JZX9"
+ },
+ "source": [
+ "### Train BNN with a small training subset."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "id": "_FTuHpudJZX9"
+ },
+ "outputs": [
{
- "cell_type": "markdown",
- "metadata": {
- "id": "2b2sbxYRJZX-"
- },
- "source": [
- "## Experiment 3: probabilistic Bayesian neural network\n",
- "\n",
- "So far, the output of the standard and the Bayesian NN models that we built is\n",
- "deterministic, that is, produces a point estimate as a prediction for a given example.\n",
- "We can create a probabilistic NN by letting the model output a distribution.\n",
- "In this case, the model captures the *aleatoric uncertainty* as well,\n",
- "which is due to irreducible noise in the data, or to the stochastic nature of the\n",
- "process generating the data.\n",
- "\n",
- "In this example, we model the output as a `IndependentNormal` distribution,\n",
- "with learnable mean and variance parameters. If the task was classification,\n",
- "we would have used `IndependentBernoulli` with binary classes, and `OneHotCategorical`\n",
- "with multiple classes, to model distribution of the model output."
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "WARNING:tensorflow:From /p/project/training2305/sc_venv_template-bl/venv/lib/python3.10/site-packages/tensorflow_probability/python/distributions/distribution.py:342: calling MultivariateNormalDiag.__init__ (from tensorflow_probability.python.distributions.mvn_diag) with scale_identity_multiplier is deprecated and will be removed after 2020-01-01.\n",
+ "Instructions for updating:\n",
+ "`scale_identity_multiplier` is deprecated; please combine it into `scale_diag` directly instead.\n"
+ ]
},
{
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "9nzDZQedJZX_"
- },
- "outputs": [],
- "source": [
- "\n",
- "def create_probablistic_bnn_model(train_size):\n",
- " inputs = create_model_inputs()\n",
- " features = keras.layers.concatenate(list(inputs.values()))\n",
- " features = layers.BatchNormalization()(features)\n",
- "\n",
- " # Create hidden layers with weight uncertainty using the DenseVariational layer.\n",
- " for units in hidden_units:\n",
- " features = tfp.layers.DenseVariational(\n",
- " units=units,\n",
- " make_prior_fn=prior,\n",
- " make_posterior_fn=posterior,\n",
- " kl_weight=1 / train_size,\n",
- " activation=\"sigmoid\",\n",
- " )(features)\n",
- "\n",
- " # Create a probabilisticå output (Normal distribution), and use the `Dense` layer\n",
- " # to produce the parameters of the distribution.\n",
- " # We set units=2 to learn both the mean and the variance of the Normal distribution.\n",
- " distribution_params = layers.Dense(units=2)(features)\n",
- " outputs = tfp.layers.IndependentNormal(1)(distribution_params)\n",
- "\n",
- " model = keras.Model(inputs=inputs, outputs=outputs)\n",
- " return model\n"
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:tensorflow:From /p/project/training2305/sc_venv_template-bl/venv/lib/python3.10/site-packages/tensorflow_probability/python/distributions/distribution.py:342: calling MultivariateNormalDiag.__init__ (from tensorflow_probability.python.distributions.mvn_diag) with scale_identity_multiplier is deprecated and will be removed after 2020-01-01.\n",
+ "Instructions for updating:\n",
+ "`scale_identity_multiplier` is deprecated; please combine it into `scale_diag` directly instead.\n"
+ ]
},
{
- "cell_type": "markdown",
- "metadata": {
- "id": "qUFOwXTyJZX_"
- },
- "source": [
- "Since the output of the model is a distribution, rather than a point estimate,\n",
- "we use the [negative loglikelihood](https://en.wikipedia.org/wiki/Likelihood_function)\n",
- "as our loss function to compute how likely to see the true data (targets) from the\n",
- "estimated distribution produced by the model."
- ]
- },
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Start training the model...\n",
+ "Epoch 1/500\n",
+ "5/5 [==============================] - 4s 557ms/step - loss: 57.0129 - root_mean_squared_error: 7.5497 - val_loss: 56.7286 - val_root_mean_squared_error: 7.5309\n",
+ "Epoch 2/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 52.7787 - root_mean_squared_error: 7.2640 - val_loss: 49.4205 - val_root_mean_squared_error: 7.0291\n",
+ "Epoch 3/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 55.1672 - root_mean_squared_error: 7.4266 - val_loss: 53.8305 - val_root_mean_squared_error: 7.3360\n",
+ "Epoch 4/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 54.0287 - root_mean_squared_error: 7.3497 - val_loss: 50.6124 - val_root_mean_squared_error: 7.1131\n",
+ "Epoch 5/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 50.9889 - root_mean_squared_error: 7.1395 - val_loss: 51.2843 - val_root_mean_squared_error: 7.1604\n",
+ "Epoch 6/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 51.8222 - root_mean_squared_error: 7.1976 - val_loss: 53.2796 - val_root_mean_squared_error: 7.2985\n",
+ "Epoch 7/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 52.6715 - root_mean_squared_error: 7.2567 - val_loss: 51.2377 - val_root_mean_squared_error: 7.1574\n",
+ "Epoch 8/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 52.9132 - root_mean_squared_error: 7.2730 - val_loss: 55.1586 - val_root_mean_squared_error: 7.4260\n",
+ "Epoch 9/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 52.2086 - root_mean_squared_error: 7.2245 - val_loss: 46.4330 - val_root_mean_squared_error: 6.8134\n",
+ "Epoch 10/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 50.9335 - root_mean_squared_error: 7.1358 - val_loss: 46.8694 - val_root_mean_squared_error: 6.8452\n",
+ "Epoch 11/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 50.2360 - root_mean_squared_error: 7.0867 - val_loss: 54.9606 - val_root_mean_squared_error: 7.4126\n",
+ "Epoch 12/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 48.2649 - root_mean_squared_error: 6.9463 - val_loss: 45.6966 - val_root_mean_squared_error: 6.7591\n",
+ "Epoch 13/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 49.0749 - root_mean_squared_error: 7.0043 - val_loss: 49.5114 - val_root_mean_squared_error: 7.0354\n",
+ "Epoch 14/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 46.5035 - root_mean_squared_error: 6.8183 - val_loss: 47.7520 - val_root_mean_squared_error: 6.9091\n",
+ "Epoch 15/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 53.5044 - root_mean_squared_error: 7.3137 - val_loss: 49.9759 - val_root_mean_squared_error: 7.0682\n",
+ "Epoch 16/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 48.7602 - root_mean_squared_error: 6.9820 - val_loss: 49.8098 - val_root_mean_squared_error: 7.0565\n",
+ "Epoch 17/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 48.0525 - root_mean_squared_error: 6.9308 - val_loss: 47.2923 - val_root_mean_squared_error: 6.8759\n",
+ "Epoch 18/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 48.7001 - root_mean_squared_error: 6.9774 - val_loss: 45.3507 - val_root_mean_squared_error: 6.7332\n",
+ "Epoch 19/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 45.9967 - root_mean_squared_error: 6.7809 - val_loss: 51.5288 - val_root_mean_squared_error: 7.1776\n",
+ "Epoch 20/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 45.0668 - root_mean_squared_error: 6.7121 - val_loss: 44.2659 - val_root_mean_squared_error: 6.6521\n",
+ "Epoch 21/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 45.8024 - root_mean_squared_error: 6.7665 - val_loss: 42.4139 - val_root_mean_squared_error: 6.5113\n",
+ "Epoch 22/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 46.9955 - root_mean_squared_error: 6.8542 - val_loss: 47.0784 - val_root_mean_squared_error: 6.8600\n",
+ "Epoch 23/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 44.1119 - root_mean_squared_error: 6.6405 - val_loss: 45.3969 - val_root_mean_squared_error: 6.7364\n",
+ "Epoch 24/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 44.0670 - root_mean_squared_error: 6.6372 - val_loss: 45.3408 - val_root_mean_squared_error: 6.7327\n",
+ "Epoch 25/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 45.0380 - root_mean_squared_error: 6.7099 - val_loss: 45.7874 - val_root_mean_squared_error: 6.7656\n",
+ "Epoch 26/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 43.8603 - root_mean_squared_error: 6.6216 - val_loss: 42.9501 - val_root_mean_squared_error: 6.5527\n",
+ "Epoch 27/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 44.7173 - root_mean_squared_error: 6.6860 - val_loss: 45.5102 - val_root_mean_squared_error: 6.7452\n",
+ "Epoch 28/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 40.9454 - root_mean_squared_error: 6.3974 - val_loss: 43.2894 - val_root_mean_squared_error: 6.5785\n",
+ "Epoch 29/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 42.2195 - root_mean_squared_error: 6.4966 - val_loss: 40.0281 - val_root_mean_squared_error: 6.3254\n",
+ "Epoch 30/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 39.2515 - root_mean_squared_error: 6.2636 - val_loss: 42.5028 - val_root_mean_squared_error: 6.5181\n",
+ "Epoch 31/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 42.7703 - root_mean_squared_error: 6.5386 - val_loss: 41.6595 - val_root_mean_squared_error: 6.4531\n",
+ "Epoch 32/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 40.3649 - root_mean_squared_error: 6.3522 - val_loss: 39.7245 - val_root_mean_squared_error: 6.3015\n",
+ "Epoch 33/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 38.1933 - root_mean_squared_error: 6.1788 - val_loss: 36.7037 - val_root_mean_squared_error: 6.0567\n",
+ "Epoch 34/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 40.1268 - root_mean_squared_error: 6.3335 - val_loss: 40.8225 - val_root_mean_squared_error: 6.3880\n",
+ "Epoch 35/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 39.1419 - root_mean_squared_error: 6.2552 - val_loss: 36.6122 - val_root_mean_squared_error: 6.0494\n",
+ "Epoch 36/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 39.2029 - root_mean_squared_error: 6.2600 - val_loss: 36.6162 - val_root_mean_squared_error: 6.0498\n",
+ "Epoch 37/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 38.5928 - root_mean_squared_error: 6.2109 - val_loss: 37.6816 - val_root_mean_squared_error: 6.1375\n",
+ "Epoch 38/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 40.8756 - root_mean_squared_error: 6.3922 - val_loss: 39.3902 - val_root_mean_squared_error: 6.2753\n",
+ "Epoch 39/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 38.9052 - root_mean_squared_error: 6.2360 - val_loss: 35.4052 - val_root_mean_squared_error: 5.9486\n",
+ "Epoch 40/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 36.0730 - root_mean_squared_error: 6.0048 - val_loss: 39.9429 - val_root_mean_squared_error: 6.3188\n",
+ "Epoch 41/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 37.7098 - root_mean_squared_error: 6.1394 - val_loss: 36.7212 - val_root_mean_squared_error: 6.0588\n",
+ "Epoch 42/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 34.4501 - root_mean_squared_error: 5.8679 - val_loss: 35.2537 - val_root_mean_squared_error: 5.9361\n",
+ "Epoch 43/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 36.3017 - root_mean_squared_error: 6.0235 - val_loss: 33.8819 - val_root_mean_squared_error: 5.8196\n",
+ "Epoch 44/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 35.6835 - root_mean_squared_error: 5.9722 - val_loss: 38.2949 - val_root_mean_squared_error: 6.1871\n",
+ "Epoch 45/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 33.1830 - root_mean_squared_error: 5.7592 - val_loss: 35.2678 - val_root_mean_squared_error: 5.9375\n",
+ "Epoch 46/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 34.6403 - root_mean_squared_error: 5.8841 - val_loss: 34.4320 - val_root_mean_squared_error: 5.8666\n",
+ "Epoch 47/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 35.9900 - root_mean_squared_error: 5.9980 - val_loss: 36.1400 - val_root_mean_squared_error: 6.0101\n",
+ "Epoch 48/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 33.9624 - root_mean_squared_error: 5.8263 - val_loss: 34.1770 - val_root_mean_squared_error: 5.8447\n",
+ "Epoch 49/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 33.8744 - root_mean_squared_error: 5.8188 - val_loss: 32.8798 - val_root_mean_squared_error: 5.7328\n",
+ "Epoch 50/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 33.8414 - root_mean_squared_error: 5.8161 - val_loss: 35.2764 - val_root_mean_squared_error: 5.9379\n",
+ "Epoch 51/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 33.2538 - root_mean_squared_error: 5.7651 - val_loss: 36.0869 - val_root_mean_squared_error: 6.0056\n",
+ "Epoch 52/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 32.6954 - root_mean_squared_error: 5.7171 - val_loss: 34.1802 - val_root_mean_squared_error: 5.8448\n",
+ "Epoch 53/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 31.4900 - root_mean_squared_error: 5.6101 - val_loss: 32.2507 - val_root_mean_squared_error: 5.6775\n",
+ "Epoch 54/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 32.2751 - root_mean_squared_error: 5.6796 - val_loss: 33.6289 - val_root_mean_squared_error: 5.7975\n",
+ "Epoch 55/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 30.5764 - root_mean_squared_error: 5.5276 - val_loss: 30.3345 - val_root_mean_squared_error: 5.5058\n",
+ "Epoch 56/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 34.0280 - root_mean_squared_error: 5.8317 - val_loss: 30.1419 - val_root_mean_squared_error: 5.4883\n",
+ "Epoch 57/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 31.7069 - root_mean_squared_error: 5.6292 - val_loss: 31.1548 - val_root_mean_squared_error: 5.5800\n",
+ "Epoch 58/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 31.4960 - root_mean_squared_error: 5.6106 - val_loss: 29.9524 - val_root_mean_squared_error: 5.4720\n",
+ "Epoch 59/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 33.5438 - root_mean_squared_error: 5.7904 - val_loss: 30.6013 - val_root_mean_squared_error: 5.5303\n",
+ "Epoch 60/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 33.0082 - root_mean_squared_error: 5.7437 - val_loss: 29.7980 - val_root_mean_squared_error: 5.4571\n",
+ "Epoch 61/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 28.9597 - root_mean_squared_error: 5.3796 - val_loss: 32.6550 - val_root_mean_squared_error: 5.7129\n",
+ "Epoch 62/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 30.9942 - root_mean_squared_error: 5.5654 - val_loss: 29.8465 - val_root_mean_squared_error: 5.4615\n",
+ "Epoch 63/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 29.6922 - root_mean_squared_error: 5.4475 - val_loss: 27.8239 - val_root_mean_squared_error: 5.2726\n",
+ "Epoch 64/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 28.8519 - root_mean_squared_error: 5.3692 - val_loss: 29.0606 - val_root_mean_squared_error: 5.3892\n",
+ "Epoch 65/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 28.9408 - root_mean_squared_error: 5.3777 - val_loss: 29.2193 - val_root_mean_squared_error: 5.4037\n",
+ "Epoch 66/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 28.5027 - root_mean_squared_error: 5.3371 - val_loss: 30.2509 - val_root_mean_squared_error: 5.4986\n",
+ "Epoch 67/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 28.6993 - root_mean_squared_error: 5.3552 - val_loss: 28.1582 - val_root_mean_squared_error: 5.3044\n",
+ "Epoch 68/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 29.2733 - root_mean_squared_error: 5.4089 - val_loss: 27.6948 - val_root_mean_squared_error: 5.2611\n",
+ "Epoch 69/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 28.0797 - root_mean_squared_error: 5.2971 - val_loss: 27.7246 - val_root_mean_squared_error: 5.2630\n",
+ "Epoch 70/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 29.7607 - root_mean_squared_error: 5.4538 - val_loss: 27.6516 - val_root_mean_squared_error: 5.2566\n",
+ "Epoch 71/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 28.9980 - root_mean_squared_error: 5.3831 - val_loss: 26.7979 - val_root_mean_squared_error: 5.1743\n",
+ "Epoch 72/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 28.8477 - root_mean_squared_error: 5.3694 - val_loss: 28.0050 - val_root_mean_squared_error: 5.2903\n",
+ "Epoch 73/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 28.7916 - root_mean_squared_error: 5.3644 - val_loss: 25.0189 - val_root_mean_squared_error: 4.9997\n",
+ "Epoch 74/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 26.0490 - root_mean_squared_error: 5.1014 - val_loss: 25.2151 - val_root_mean_squared_error: 5.0195\n",
+ "Epoch 75/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 26.4882 - root_mean_squared_error: 5.1449 - val_loss: 24.9189 - val_root_mean_squared_error: 4.9894\n",
+ "Epoch 76/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 27.0735 - root_mean_squared_error: 5.2015 - val_loss: 26.9598 - val_root_mean_squared_error: 5.1903\n",
+ "Epoch 77/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 26.0508 - root_mean_squared_error: 5.1021 - val_loss: 24.9614 - val_root_mean_squared_error: 4.9939\n",
+ "Epoch 78/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 27.2053 - root_mean_squared_error: 5.2141 - val_loss: 23.9003 - val_root_mean_squared_error: 4.8863\n",
+ "Epoch 79/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 27.3039 - root_mean_squared_error: 5.2236 - val_loss: 24.3818 - val_root_mean_squared_error: 4.9356\n",
+ "Epoch 80/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 25.1867 - root_mean_squared_error: 5.0165 - val_loss: 24.0422 - val_root_mean_squared_error: 4.9009\n",
+ "Epoch 81/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 24.2412 - root_mean_squared_error: 4.9212 - val_loss: 27.4497 - val_root_mean_squared_error: 5.2374\n",
+ "Epoch 82/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 25.6320 - root_mean_squared_error: 5.0606 - val_loss: 25.4330 - val_root_mean_squared_error: 5.0411\n",
+ "Epoch 83/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 25.0061 - root_mean_squared_error: 4.9987 - val_loss: 24.0740 - val_root_mean_squared_error: 4.9044\n",
+ "Epoch 84/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 24.5057 - root_mean_squared_error: 4.9485 - val_loss: 23.7218 - val_root_mean_squared_error: 4.8681\n",
+ "Epoch 85/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 23.6273 - root_mean_squared_error: 4.8586 - val_loss: 24.4322 - val_root_mean_squared_error: 4.9407\n",
+ "Epoch 86/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 24.5021 - root_mean_squared_error: 4.9479 - val_loss: 23.0119 - val_root_mean_squared_error: 4.7947\n",
+ "Epoch 87/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 24.7429 - root_mean_squared_error: 4.9721 - val_loss: 23.7462 - val_root_mean_squared_error: 4.8704\n",
+ "Epoch 88/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 23.7419 - root_mean_squared_error: 4.8701 - val_loss: 23.0700 - val_root_mean_squared_error: 4.8007\n",
+ "Epoch 89/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 22.6764 - root_mean_squared_error: 4.7592 - val_loss: 22.5206 - val_root_mean_squared_error: 4.7431\n",
+ "Epoch 90/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 23.2829 - root_mean_squared_error: 4.8232 - val_loss: 23.0072 - val_root_mean_squared_error: 4.7943\n",
+ "Epoch 91/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 24.4655 - root_mean_squared_error: 4.9441 - val_loss: 24.7697 - val_root_mean_squared_error: 4.9753\n",
+ "Epoch 92/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 23.7739 - root_mean_squared_error: 4.8735 - val_loss: 23.2210 - val_root_mean_squared_error: 4.8169\n",
+ "Epoch 93/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 22.4935 - root_mean_squared_error: 4.7403 - val_loss: 23.1276 - val_root_mean_squared_error: 4.8071\n",
+ "Epoch 94/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 21.5418 - root_mean_squared_error: 4.6387 - val_loss: 22.3647 - val_root_mean_squared_error: 4.7268\n",
+ "Epoch 95/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 22.2177 - root_mean_squared_error: 4.7109 - val_loss: 20.8299 - val_root_mean_squared_error: 4.5613\n",
+ "Epoch 96/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 22.9174 - root_mean_squared_error: 4.7850 - val_loss: 21.4278 - val_root_mean_squared_error: 4.6270\n",
+ "Epoch 97/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 22.0471 - root_mean_squared_error: 4.6931 - val_loss: 22.4457 - val_root_mean_squared_error: 4.7352\n",
+ "Epoch 98/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 21.5958 - root_mean_squared_error: 4.6447 - val_loss: 21.9172 - val_root_mean_squared_error: 4.6791\n",
+ "Epoch 99/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 22.6420 - root_mean_squared_error: 4.7566 - val_loss: 22.5990 - val_root_mean_squared_error: 4.7521\n",
+ "Epoch 100/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 21.5387 - root_mean_squared_error: 4.6384 - val_loss: 21.2408 - val_root_mean_squared_error: 4.6060\n",
+ "Epoch 101/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 21.7356 - root_mean_squared_error: 4.6600 - val_loss: 20.8517 - val_root_mean_squared_error: 4.5639\n",
+ "Epoch 102/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 19.9914 - root_mean_squared_error: 4.4685 - val_loss: 20.5966 - val_root_mean_squared_error: 4.5356\n",
+ "Epoch 103/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 20.1531 - root_mean_squared_error: 4.4862 - val_loss: 20.0918 - val_root_mean_squared_error: 4.4798\n",
+ "Epoch 104/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 20.7306 - root_mean_squared_error: 4.5506 - val_loss: 19.8531 - val_root_mean_squared_error: 4.4528\n",
+ "Epoch 105/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 20.1664 - root_mean_squared_error: 4.4880 - val_loss: 19.9779 - val_root_mean_squared_error: 4.4673\n",
+ "Epoch 106/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 20.5011 - root_mean_squared_error: 4.5253 - val_loss: 20.2513 - val_root_mean_squared_error: 4.4973\n",
+ "Epoch 107/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 19.6751 - root_mean_squared_error: 4.4332 - val_loss: 19.1514 - val_root_mean_squared_error: 4.3732\n",
+ "Epoch 108/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 19.2913 - root_mean_squared_error: 4.3895 - val_loss: 18.8102 - val_root_mean_squared_error: 4.3338\n",
+ "Epoch 109/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 19.0559 - root_mean_squared_error: 4.3627 - val_loss: 19.0571 - val_root_mean_squared_error: 4.3626\n",
+ "Epoch 110/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 19.8701 - root_mean_squared_error: 4.4549 - val_loss: 19.8402 - val_root_mean_squared_error: 4.4514\n",
+ "Epoch 111/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 18.4038 - root_mean_squared_error: 4.2875 - val_loss: 18.4694 - val_root_mean_squared_error: 4.2948\n",
+ "Epoch 112/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 19.8099 - root_mean_squared_error: 4.4485 - val_loss: 18.8064 - val_root_mean_squared_error: 4.3337\n",
+ "Epoch 113/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 18.3808 - root_mean_squared_error: 4.2843 - val_loss: 18.3303 - val_root_mean_squared_error: 4.2785\n",
+ "Epoch 114/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 19.2153 - root_mean_squared_error: 4.3805 - val_loss: 18.1571 - val_root_mean_squared_error: 4.2578\n",
+ "Epoch 115/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 17.9376 - root_mean_squared_error: 4.2323 - val_loss: 17.4677 - val_root_mean_squared_error: 4.1762\n",
+ "Epoch 116/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 19.2671 - root_mean_squared_error: 4.3868 - val_loss: 17.7120 - val_root_mean_squared_error: 4.2057\n",
+ "Epoch 117/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 17.5023 - root_mean_squared_error: 4.1802 - val_loss: 17.5487 - val_root_mean_squared_error: 4.1860\n",
+ "Epoch 118/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 17.5560 - root_mean_squared_error: 4.1871 - val_loss: 17.6304 - val_root_mean_squared_error: 4.1958\n",
+ "Epoch 119/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 17.5586 - root_mean_squared_error: 4.1871 - val_loss: 16.7192 - val_root_mean_squared_error: 4.0862\n",
+ "Epoch 120/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 18.1624 - root_mean_squared_error: 4.2585 - val_loss: 17.1333 - val_root_mean_squared_error: 4.1365\n",
+ "Epoch 121/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 17.1096 - root_mean_squared_error: 4.1332 - val_loss: 16.7204 - val_root_mean_squared_error: 4.0858\n",
+ "Epoch 122/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 16.6286 - root_mean_squared_error: 4.0742 - val_loss: 16.8656 - val_root_mean_squared_error: 4.1036\n",
+ "Epoch 123/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 16.7034 - root_mean_squared_error: 4.0836 - val_loss: 16.6020 - val_root_mean_squared_error: 4.0720\n",
+ "Epoch 124/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 17.4135 - root_mean_squared_error: 4.1699 - val_loss: 16.2530 - val_root_mean_squared_error: 4.0280\n",
+ "Epoch 125/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 17.1698 - root_mean_squared_error: 4.1406 - val_loss: 16.1303 - val_root_mean_squared_error: 4.0130\n",
+ "Epoch 126/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 16.4671 - root_mean_squared_error: 4.0544 - val_loss: 15.7126 - val_root_mean_squared_error: 3.9600\n",
+ "Epoch 127/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 16.3764 - root_mean_squared_error: 4.0436 - val_loss: 16.4962 - val_root_mean_squared_error: 4.0584\n",
+ "Epoch 128/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 16.1884 - root_mean_squared_error: 4.0201 - val_loss: 16.2926 - val_root_mean_squared_error: 4.0335\n",
+ "Epoch 129/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 15.5219 - root_mean_squared_error: 3.9356 - val_loss: 15.7980 - val_root_mean_squared_error: 3.9715\n",
+ "Epoch 130/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 16.6318 - root_mean_squared_error: 4.0753 - val_loss: 15.9729 - val_root_mean_squared_error: 3.9935\n",
+ "Epoch 131/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 16.0311 - root_mean_squared_error: 4.0012 - val_loss: 15.0711 - val_root_mean_squared_error: 3.8788\n",
+ "Epoch 132/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 15.8952 - root_mean_squared_error: 3.9838 - val_loss: 15.0009 - val_root_mean_squared_error: 3.8695\n",
+ "Epoch 133/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 15.3139 - root_mean_squared_error: 3.9104 - val_loss: 15.0381 - val_root_mean_squared_error: 3.8742\n",
+ "Epoch 134/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 15.2270 - root_mean_squared_error: 3.8985 - val_loss: 14.6033 - val_root_mean_squared_error: 3.8183\n",
+ "Epoch 135/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 15.5290 - root_mean_squared_error: 3.9374 - val_loss: 14.5799 - val_root_mean_squared_error: 3.8144\n",
+ "Epoch 136/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 15.5088 - root_mean_squared_error: 3.9350 - val_loss: 15.2540 - val_root_mean_squared_error: 3.9025\n",
+ "Epoch 137/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 15.0281 - root_mean_squared_error: 3.8734 - val_loss: 13.8088 - val_root_mean_squared_error: 3.7117\n",
+ "Epoch 138/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 15.2251 - root_mean_squared_error: 3.8984 - val_loss: 14.1852 - val_root_mean_squared_error: 3.7625\n",
+ "Epoch 139/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 14.2683 - root_mean_squared_error: 3.7737 - val_loss: 15.5110 - val_root_mean_squared_error: 3.9352\n",
+ "Epoch 140/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 13.8089 - root_mean_squared_error: 3.7124 - val_loss: 13.6880 - val_root_mean_squared_error: 3.6964\n",
+ "Epoch 141/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 14.0246 - root_mean_squared_error: 3.7416 - val_loss: 13.2767 - val_root_mean_squared_error: 3.6396\n",
+ "Epoch 142/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 13.9703 - root_mean_squared_error: 3.7342 - val_loss: 13.3109 - val_root_mean_squared_error: 3.6448\n",
+ "Epoch 143/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 13.8884 - root_mean_squared_error: 3.7231 - val_loss: 13.2664 - val_root_mean_squared_error: 3.6395\n",
+ "Epoch 144/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 13.6581 - root_mean_squared_error: 3.6919 - val_loss: 14.3135 - val_root_mean_squared_error: 3.7802\n",
+ "Epoch 145/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 13.4983 - root_mean_squared_error: 3.6704 - val_loss: 12.6536 - val_root_mean_squared_error: 3.5536\n",
+ "Epoch 146/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 13.5602 - root_mean_squared_error: 3.6792 - val_loss: 13.4458 - val_root_mean_squared_error: 3.6625\n",
+ "Epoch 147/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 12.5726 - root_mean_squared_error: 3.5417 - val_loss: 13.4134 - val_root_mean_squared_error: 3.6589\n",
+ "Epoch 148/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 13.2480 - root_mean_squared_error: 3.6360 - val_loss: 12.6870 - val_root_mean_squared_error: 3.5586\n",
+ "Epoch 149/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 12.8816 - root_mean_squared_error: 3.5854 - val_loss: 12.3010 - val_root_mean_squared_error: 3.5031\n",
+ "Epoch 150/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 13.0819 - root_mean_squared_error: 3.6130 - val_loss: 12.4213 - val_root_mean_squared_error: 3.5199\n",
+ "Epoch 151/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 12.6296 - root_mean_squared_error: 3.5498 - val_loss: 12.7055 - val_root_mean_squared_error: 3.5607\n",
+ "Epoch 152/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 12.0153 - root_mean_squared_error: 3.4627 - val_loss: 11.9677 - val_root_mean_squared_error: 3.4553\n",
+ "Epoch 153/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 11.9949 - root_mean_squared_error: 3.4595 - val_loss: 12.3309 - val_root_mean_squared_error: 3.5073\n",
+ "Epoch 154/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 12.2917 - root_mean_squared_error: 3.5027 - val_loss: 11.8275 - val_root_mean_squared_error: 3.4345\n",
+ "Epoch 155/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 12.5561 - root_mean_squared_error: 3.5394 - val_loss: 11.0467 - val_root_mean_squared_error: 3.3191\n",
+ "Epoch 156/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 12.5082 - root_mean_squared_error: 3.5327 - val_loss: 11.6160 - val_root_mean_squared_error: 3.4045\n",
+ "Epoch 157/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 11.1876 - root_mean_squared_error: 3.3405 - val_loss: 11.4853 - val_root_mean_squared_error: 3.3845\n",
+ "Epoch 158/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 11.6028 - root_mean_squared_error: 3.4027 - val_loss: 11.5544 - val_root_mean_squared_error: 3.3947\n",
+ "Epoch 159/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 12.0451 - root_mean_squared_error: 3.4672 - val_loss: 11.1705 - val_root_mean_squared_error: 3.3385\n",
+ "Epoch 160/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 11.5716 - root_mean_squared_error: 3.3977 - val_loss: 10.2429 - val_root_mean_squared_error: 3.1956\n",
+ "Epoch 161/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 11.1465 - root_mean_squared_error: 3.3342 - val_loss: 10.9106 - val_root_mean_squared_error: 3.2992\n",
+ "Epoch 162/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 11.1903 - root_mean_squared_error: 3.3410 - val_loss: 9.6892 - val_root_mean_squared_error: 3.1080\n",
+ "Epoch 163/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 10.5706 - root_mean_squared_error: 3.2465 - val_loss: 10.9300 - val_root_mean_squared_error: 3.3021\n",
+ "Epoch 164/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 10.9836 - root_mean_squared_error: 3.3099 - val_loss: 11.2225 - val_root_mean_squared_error: 3.3446\n",
+ "Epoch 165/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 10.1484 - root_mean_squared_error: 3.1813 - val_loss: 10.2744 - val_root_mean_squared_error: 3.2003\n",
+ "Epoch 166/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 10.2213 - root_mean_squared_error: 3.1923 - val_loss: 10.5869 - val_root_mean_squared_error: 3.2498\n",
+ "Epoch 167/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 10.4147 - root_mean_squared_error: 3.2222 - val_loss: 9.7714 - val_root_mean_squared_error: 3.1218\n",
+ "Epoch 168/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 10.9415 - root_mean_squared_error: 3.3028 - val_loss: 10.0797 - val_root_mean_squared_error: 3.1711\n",
+ "Epoch 169/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 10.2099 - root_mean_squared_error: 3.1904 - val_loss: 9.9081 - val_root_mean_squared_error: 3.1429\n",
+ "Epoch 170/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 10.2230 - root_mean_squared_error: 3.1922 - val_loss: 10.0554 - val_root_mean_squared_error: 3.1654\n",
+ "Epoch 171/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 10.0789 - root_mean_squared_error: 3.1705 - val_loss: 9.2104 - val_root_mean_squared_error: 3.0299\n",
+ "Epoch 172/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 9.2213 - root_mean_squared_error: 3.0318 - val_loss: 8.8115 - val_root_mean_squared_error: 2.9644\n",
+ "Epoch 173/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 9.4275 - root_mean_squared_error: 3.0656 - val_loss: 9.2080 - val_root_mean_squared_error: 3.0290\n",
+ "Epoch 174/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 9.0314 - root_mean_squared_error: 3.0003 - val_loss: 9.2009 - val_root_mean_squared_error: 3.0281\n",
+ "Epoch 175/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 9.5477 - root_mean_squared_error: 3.0854 - val_loss: 8.6904 - val_root_mean_squared_error: 2.9423\n",
+ "Epoch 176/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 9.2999 - root_mean_squared_error: 3.0450 - val_loss: 8.1755 - val_root_mean_squared_error: 2.8547\n",
+ "Epoch 177/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 9.3138 - root_mean_squared_error: 3.0468 - val_loss: 8.6634 - val_root_mean_squared_error: 2.9386\n",
+ "Epoch 178/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 8.4299 - root_mean_squared_error: 2.8979 - val_loss: 8.0855 - val_root_mean_squared_error: 2.8388\n",
+ "Epoch 179/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 9.2482 - root_mean_squared_error: 3.0361 - val_loss: 8.7413 - val_root_mean_squared_error: 2.9514\n",
+ "Epoch 180/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 9.4816 - root_mean_squared_error: 3.0742 - val_loss: 7.9207 - val_root_mean_squared_error: 2.8096\n",
+ "Epoch 181/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 8.3382 - root_mean_squared_error: 2.8830 - val_loss: 7.3657 - val_root_mean_squared_error: 2.7083\n",
+ "Epoch 182/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 9.2579 - root_mean_squared_error: 3.0381 - val_loss: 8.4433 - val_root_mean_squared_error: 2.9002\n",
+ "Epoch 183/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 8.7381 - root_mean_squared_error: 2.9511 - val_loss: 7.6804 - val_root_mean_squared_error: 2.7672\n",
+ "Epoch 184/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 8.1768 - root_mean_squared_error: 2.8543 - val_loss: 8.1322 - val_root_mean_squared_error: 2.8463\n",
+ "Epoch 185/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 7.7178 - root_mean_squared_error: 2.7733 - val_loss: 8.6524 - val_root_mean_squared_error: 2.9359\n",
+ "Epoch 186/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 7.2317 - root_mean_squared_error: 2.6836 - val_loss: 7.4022 - val_root_mean_squared_error: 2.7155\n",
+ "Epoch 187/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 8.0545 - root_mean_squared_error: 2.8329 - val_loss: 6.4824 - val_root_mean_squared_error: 2.5394\n",
+ "Epoch 188/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 7.5644 - root_mean_squared_error: 2.7453 - val_loss: 7.4433 - val_root_mean_squared_error: 2.7221\n",
+ "Epoch 189/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 6.7420 - root_mean_squared_error: 2.5909 - val_loss: 6.7884 - val_root_mean_squared_error: 2.6004\n",
+ "Epoch 190/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 6.6862 - root_mean_squared_error: 2.5798 - val_loss: 6.8858 - val_root_mean_squared_error: 2.6186\n",
+ "Epoch 191/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 7.6462 - root_mean_squared_error: 2.7598 - val_loss: 6.5038 - val_root_mean_squared_error: 2.5437\n",
+ "Epoch 192/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 6.6282 - root_mean_squared_error: 2.5682 - val_loss: 7.1302 - val_root_mean_squared_error: 2.6633\n",
+ "Epoch 193/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 6.6691 - root_mean_squared_error: 2.5767 - val_loss: 7.1483 - val_root_mean_squared_error: 2.6680\n",
+ "Epoch 194/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 6.7153 - root_mean_squared_error: 2.5859 - val_loss: 6.5858 - val_root_mean_squared_error: 2.5603\n",
+ "Epoch 195/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 6.2824 - root_mean_squared_error: 2.5006 - val_loss: 6.5737 - val_root_mean_squared_error: 2.5581\n",
+ "Epoch 196/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 6.4096 - root_mean_squared_error: 2.5252 - val_loss: 6.7345 - val_root_mean_squared_error: 2.5892\n",
+ "Epoch 197/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 7.0609 - root_mean_squared_error: 2.6521 - val_loss: 5.9300 - val_root_mean_squared_error: 2.4287\n",
+ "Epoch 198/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 6.3157 - root_mean_squared_error: 2.5072 - val_loss: 5.8065 - val_root_mean_squared_error: 2.4043\n",
+ "Epoch 199/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 5.8763 - root_mean_squared_error: 2.4176 - val_loss: 5.4865 - val_root_mean_squared_error: 2.3365\n",
+ "Epoch 200/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 5.7583 - root_mean_squared_error: 2.3942 - val_loss: 5.7027 - val_root_mean_squared_error: 2.3826\n",
+ "Epoch 201/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 5.3550 - root_mean_squared_error: 2.3077 - val_loss: 5.9821 - val_root_mean_squared_error: 2.4396\n",
+ "Epoch 202/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 5.8802 - root_mean_squared_error: 2.4186 - val_loss: 5.5093 - val_root_mean_squared_error: 2.3404\n",
+ "Epoch 203/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 5.9334 - root_mean_squared_error: 2.4301 - val_loss: 4.1049 - val_root_mean_squared_error: 2.0198\n",
+ "Epoch 204/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 5.6824 - root_mean_squared_error: 2.3778 - val_loss: 5.2165 - val_root_mean_squared_error: 2.2775\n",
+ "Epoch 205/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 5.5183 - root_mean_squared_error: 2.3421 - val_loss: 5.3573 - val_root_mean_squared_error: 2.3073\n",
+ "Epoch 206/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 4.9171 - root_mean_squared_error: 2.2098 - val_loss: 4.7854 - val_root_mean_squared_error: 2.1814\n",
+ "Epoch 207/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 4.8806 - root_mean_squared_error: 2.2027 - val_loss: 4.9441 - val_root_mean_squared_error: 2.2176\n",
+ "Epoch 208/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 4.4776 - root_mean_squared_error: 2.1089 - val_loss: 4.5645 - val_root_mean_squared_error: 2.1297\n",
+ "Epoch 209/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 4.5509 - root_mean_squared_error: 2.1263 - val_loss: 3.9549 - val_root_mean_squared_error: 1.9806\n",
+ "Epoch 210/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 4.5692 - root_mean_squared_error: 2.1308 - val_loss: 3.6825 - val_root_mean_squared_error: 1.9107\n",
+ "Epoch 211/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 4.5901 - root_mean_squared_error: 2.1360 - val_loss: 4.7644 - val_root_mean_squared_error: 2.1756\n",
+ "Epoch 212/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 3.7254 - root_mean_squared_error: 1.9226 - val_loss: 4.6476 - val_root_mean_squared_error: 2.1484\n",
+ "Epoch 213/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 4.1601 - root_mean_squared_error: 2.0323 - val_loss: 3.9025 - val_root_mean_squared_error: 1.9675\n",
+ "Epoch 214/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 4.0721 - root_mean_squared_error: 2.0104 - val_loss: 4.5698 - val_root_mean_squared_error: 2.1318\n",
+ "Epoch 215/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 4.4908 - root_mean_squared_error: 2.1123 - val_loss: 4.2339 - val_root_mean_squared_error: 2.0498\n",
+ "Epoch 216/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 3.7456 - root_mean_squared_error: 1.9271 - val_loss: 3.0880 - val_root_mean_squared_error: 1.7467\n",
+ "Epoch 217/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 3.8544 - root_mean_squared_error: 1.9558 - val_loss: 3.7808 - val_root_mean_squared_error: 1.9365\n",
+ "Epoch 218/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 4.3509 - root_mean_squared_error: 2.0782 - val_loss: 3.1646 - val_root_mean_squared_error: 1.7707\n",
+ "Epoch 219/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 4.2766 - root_mean_squared_error: 2.0614 - val_loss: 3.3612 - val_root_mean_squared_error: 1.8249\n",
+ "Epoch 220/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 3.1580 - root_mean_squared_error: 1.7681 - val_loss: 3.6604 - val_root_mean_squared_error: 1.9053\n",
+ "Epoch 221/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 4.0203 - root_mean_squared_error: 1.9978 - val_loss: 2.9766 - val_root_mean_squared_error: 1.7172\n",
+ "Epoch 222/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 3.4552 - root_mean_squared_error: 1.8514 - val_loss: 3.5258 - val_root_mean_squared_error: 1.8685\n",
+ "Epoch 223/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 3.1628 - root_mean_squared_error: 1.7699 - val_loss: 2.8967 - val_root_mean_squared_error: 1.6941\n",
+ "Epoch 224/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 2.9762 - root_mean_squared_error: 1.7163 - val_loss: 2.4124 - val_root_mean_squared_error: 1.5434\n",
+ "Epoch 225/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 3.2710 - root_mean_squared_error: 1.8005 - val_loss: 3.1914 - val_root_mean_squared_error: 1.7778\n",
+ "Epoch 226/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 2.7753 - root_mean_squared_error: 1.6564 - val_loss: 2.5063 - val_root_mean_squared_error: 1.5745\n",
+ "Epoch 227/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 2.5760 - root_mean_squared_error: 1.5949 - val_loss: 2.4899 - val_root_mean_squared_error: 1.5679\n",
+ "Epoch 228/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 2.9668 - root_mean_squared_error: 1.7139 - val_loss: 2.2793 - val_root_mean_squared_error: 1.5005\n",
+ "Epoch 229/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 3.4415 - root_mean_squared_error: 1.8462 - val_loss: 2.6341 - val_root_mean_squared_error: 1.6140\n",
+ "Epoch 230/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 2.4956 - root_mean_squared_error: 1.5697 - val_loss: 2.3406 - val_root_mean_squared_error: 1.5202\n",
+ "Epoch 231/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 2.7327 - root_mean_squared_error: 1.6446 - val_loss: 2.3558 - val_root_mean_squared_error: 1.5268\n",
+ "Epoch 232/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 1.9456 - root_mean_squared_error: 1.3834 - val_loss: 1.9990 - val_root_mean_squared_error: 1.4028\n",
+ "Epoch 233/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 2.4681 - root_mean_squared_error: 1.5619 - val_loss: 1.7766 - val_root_mean_squared_error: 1.3222\n",
+ "Epoch 234/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.9332 - root_mean_squared_error: 1.3789 - val_loss: 2.2641 - val_root_mean_squared_error: 1.4941\n",
+ "Epoch 235/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 2.6213 - root_mean_squared_error: 1.6087 - val_loss: 1.5658 - val_root_mean_squared_error: 1.2385\n",
+ "Epoch 236/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.9243 - root_mean_squared_error: 1.3777 - val_loss: 2.0133 - val_root_mean_squared_error: 1.4086\n",
+ "Epoch 237/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 1.7400 - root_mean_squared_error: 1.3077 - val_loss: 2.5270 - val_root_mean_squared_error: 1.5791\n",
+ "Epoch 238/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.7342 - root_mean_squared_error: 1.3059 - val_loss: 1.7905 - val_root_mean_squared_error: 1.3261\n",
+ "Epoch 239/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 2.2728 - root_mean_squared_error: 1.4968 - val_loss: 1.8633 - val_root_mean_squared_error: 1.3519\n",
+ "Epoch 240/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 1.9659 - root_mean_squared_error: 1.3924 - val_loss: 2.1322 - val_root_mean_squared_error: 1.4487\n",
+ "Epoch 241/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.8993 - root_mean_squared_error: 1.3671 - val_loss: 1.7111 - val_root_mean_squared_error: 1.2963\n",
+ "Epoch 242/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.3633 - root_mean_squared_error: 1.1537 - val_loss: 1.1117 - val_root_mean_squared_error: 1.0385\n",
+ "Epoch 243/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.8904 - root_mean_squared_error: 1.3645 - val_loss: 1.4145 - val_root_mean_squared_error: 1.1752\n",
+ "Epoch 244/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 2.0334 - root_mean_squared_error: 1.4155 - val_loss: 1.3338 - val_root_mean_squared_error: 1.1411\n",
+ "Epoch 245/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 1.6040 - root_mean_squared_error: 1.2535 - val_loss: 1.9589 - val_root_mean_squared_error: 1.3881\n",
+ "Epoch 246/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.5015 - root_mean_squared_error: 1.2124 - val_loss: 1.5129 - val_root_mean_squared_error: 1.2170\n",
+ "Epoch 247/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.7780 - root_mean_squared_error: 1.3221 - val_loss: 1.1408 - val_root_mean_squared_error: 1.0529\n",
+ "Epoch 248/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.4319 - root_mean_squared_error: 1.1834 - val_loss: 1.7733 - val_root_mean_squared_error: 1.3191\n",
+ "Epoch 249/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.3746 - root_mean_squared_error: 1.1600 - val_loss: 1.2148 - val_root_mean_squared_error: 1.0880\n",
+ "Epoch 250/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 1.2237 - root_mean_squared_error: 1.0927 - val_loss: 1.2998 - val_root_mean_squared_error: 1.1265\n",
+ "Epoch 251/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.2686 - root_mean_squared_error: 1.1119 - val_loss: 1.3742 - val_root_mean_squared_error: 1.1589\n",
+ "Epoch 252/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.2953 - root_mean_squared_error: 1.1245 - val_loss: 1.4705 - val_root_mean_squared_error: 1.1994\n",
+ "Epoch 253/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.0202 - root_mean_squared_error: 0.9941 - val_loss: 1.5974 - val_root_mean_squared_error: 1.2527\n",
+ "Epoch 254/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.4037 - root_mean_squared_error: 1.1727 - val_loss: 1.6144 - val_root_mean_squared_error: 1.2592\n",
+ "Epoch 255/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 1.4677 - root_mean_squared_error: 1.1999 - val_loss: 1.0819 - val_root_mean_squared_error: 1.0247\n",
+ "Epoch 256/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.9700 - root_mean_squared_error: 0.9684 - val_loss: 0.9931 - val_root_mean_squared_error: 0.9794\n",
+ "Epoch 257/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 1.1138 - root_mean_squared_error: 1.0403 - val_loss: 1.1167 - val_root_mean_squared_error: 1.0436\n",
+ "Epoch 258/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.3040 - root_mean_squared_error: 1.1270 - val_loss: 1.2793 - val_root_mean_squared_error: 1.1182\n",
+ "Epoch 259/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 1.2131 - root_mean_squared_error: 1.0872 - val_loss: 0.8645 - val_root_mean_squared_error: 0.9134\n",
+ "Epoch 260/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.0912 - root_mean_squared_error: 1.0290 - val_loss: 0.8498 - val_root_mean_squared_error: 0.9060\n",
+ "Epoch 261/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.9726 - root_mean_squared_error: 0.9696 - val_loss: 0.9099 - val_root_mean_squared_error: 0.9377\n",
+ "Epoch 262/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 0.9301 - root_mean_squared_error: 0.9474 - val_loss: 1.7797 - val_root_mean_squared_error: 1.3216\n",
+ "Epoch 263/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.9814 - root_mean_squared_error: 0.9755 - val_loss: 0.8853 - val_root_mean_squared_error: 0.9245\n",
+ "Epoch 264/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.1899 - root_mean_squared_error: 1.0776 - val_loss: 1.1311 - val_root_mean_squared_error: 1.0479\n",
+ "Epoch 265/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.1768 - root_mean_squared_error: 1.0721 - val_loss: 0.9160 - val_root_mean_squared_error: 0.9419\n",
+ "Epoch 266/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 1.0009 - root_mean_squared_error: 0.9846 - val_loss: 0.9238 - val_root_mean_squared_error: 0.9451\n",
+ "Epoch 267/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.9160 - root_mean_squared_error: 0.9409 - val_loss: 0.8561 - val_root_mean_squared_error: 0.9079\n",
+ "Epoch 268/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.9431 - root_mean_squared_error: 0.9548 - val_loss: 0.9663 - val_root_mean_squared_error: 0.9675\n",
+ "Epoch 269/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8485 - root_mean_squared_error: 0.9037 - val_loss: 1.0307 - val_root_mean_squared_error: 1.0027\n",
+ "Epoch 270/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 1.0311 - root_mean_squared_error: 1.0009 - val_loss: 0.9047 - val_root_mean_squared_error: 0.9373\n",
+ "Epoch 271/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8807 - root_mean_squared_error: 0.9211 - val_loss: 0.8334 - val_root_mean_squared_error: 0.8958\n",
+ "Epoch 272/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8829 - root_mean_squared_error: 0.9226 - val_loss: 0.9294 - val_root_mean_squared_error: 0.9483\n",
+ "Epoch 273/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8981 - root_mean_squared_error: 0.9330 - val_loss: 0.9881 - val_root_mean_squared_error: 0.9783\n",
+ "Epoch 274/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.9361 - root_mean_squared_error: 0.9520 - val_loss: 0.8773 - val_root_mean_squared_error: 0.9202\n",
+ "Epoch 275/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8934 - root_mean_squared_error: 0.9294 - val_loss: 0.9074 - val_root_mean_squared_error: 0.9350\n",
+ "Epoch 276/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8466 - root_mean_squared_error: 0.9030 - val_loss: 0.8607 - val_root_mean_squared_error: 0.9118\n",
+ "Epoch 277/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8603 - root_mean_squared_error: 0.9112 - val_loss: 0.9530 - val_root_mean_squared_error: 0.9592\n",
+ "Epoch 278/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8542 - root_mean_squared_error: 0.9061 - val_loss: 1.0390 - val_root_mean_squared_error: 1.0045\n",
+ "Epoch 279/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.9364 - root_mean_squared_error: 0.9523 - val_loss: 0.8574 - val_root_mean_squared_error: 0.9091\n",
+ "Epoch 280/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7772 - root_mean_squared_error: 0.8657 - val_loss: 0.8227 - val_root_mean_squared_error: 0.8896\n",
+ "Epoch 281/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8404 - root_mean_squared_error: 0.9009 - val_loss: 0.8694 - val_root_mean_squared_error: 0.9161\n",
+ "Epoch 282/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 0.9451 - root_mean_squared_error: 0.9578 - val_loss: 0.8427 - val_root_mean_squared_error: 0.8996\n",
+ "Epoch 283/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8735 - root_mean_squared_error: 0.9207 - val_loss: 0.8784 - val_root_mean_squared_error: 0.9207\n",
+ "Epoch 284/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8795 - root_mean_squared_error: 0.9230 - val_loss: 0.8963 - val_root_mean_squared_error: 0.9289\n",
+ "Epoch 285/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.9196 - root_mean_squared_error: 0.9443 - val_loss: 0.8696 - val_root_mean_squared_error: 0.9160\n",
+ "Epoch 286/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8769 - root_mean_squared_error: 0.9192 - val_loss: 0.8439 - val_root_mean_squared_error: 0.9005\n",
+ "Epoch 287/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.9885 - root_mean_squared_error: 0.9803 - val_loss: 0.8304 - val_root_mean_squared_error: 0.8941\n",
+ "Epoch 288/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8943 - root_mean_squared_error: 0.9303 - val_loss: 0.8848 - val_root_mean_squared_error: 0.9233\n",
+ "Epoch 289/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8559 - root_mean_squared_error: 0.9085 - val_loss: 0.8719 - val_root_mean_squared_error: 0.9174\n",
+ "Epoch 290/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8717 - root_mean_squared_error: 0.9202 - val_loss: 0.8596 - val_root_mean_squared_error: 0.9096\n",
+ "Epoch 291/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8160 - root_mean_squared_error: 0.8869 - val_loss: 0.8449 - val_root_mean_squared_error: 0.9024\n",
+ "Epoch 292/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8907 - root_mean_squared_error: 0.9287 - val_loss: 0.8087 - val_root_mean_squared_error: 0.8841\n",
+ "Epoch 293/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7982 - root_mean_squared_error: 0.8753 - val_loss: 0.7915 - val_root_mean_squared_error: 0.8732\n",
+ "Epoch 294/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8432 - root_mean_squared_error: 0.9006 - val_loss: 0.8336 - val_root_mean_squared_error: 0.8959\n",
+ "Epoch 295/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8847 - root_mean_squared_error: 0.9259 - val_loss: 0.8626 - val_root_mean_squared_error: 0.9113\n",
+ "Epoch 296/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8218 - root_mean_squared_error: 0.8915 - val_loss: 0.8999 - val_root_mean_squared_error: 0.9327\n",
+ "Epoch 297/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 0.8519 - root_mean_squared_error: 0.9076 - val_loss: 0.8292 - val_root_mean_squared_error: 0.8956\n",
+ "Epoch 298/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8427 - root_mean_squared_error: 0.9011 - val_loss: 0.8571 - val_root_mean_squared_error: 0.9092\n",
+ "Epoch 299/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7611 - root_mean_squared_error: 0.8552 - val_loss: 0.8657 - val_root_mean_squared_error: 0.9137\n",
+ "Epoch 300/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8126 - root_mean_squared_error: 0.8876 - val_loss: 0.8427 - val_root_mean_squared_error: 0.9054\n",
+ "Epoch 301/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8605 - root_mean_squared_error: 0.9128 - val_loss: 0.8255 - val_root_mean_squared_error: 0.8938\n",
+ "Epoch 302/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7714 - root_mean_squared_error: 0.8601 - val_loss: 0.8563 - val_root_mean_squared_error: 0.9112\n",
+ "Epoch 303/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7957 - root_mean_squared_error: 0.8761 - val_loss: 0.9085 - val_root_mean_squared_error: 0.9375\n",
+ "Epoch 304/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7844 - root_mean_squared_error: 0.8712 - val_loss: 0.8425 - val_root_mean_squared_error: 0.9030\n",
+ "Epoch 305/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7842 - root_mean_squared_error: 0.8677 - val_loss: 0.9684 - val_root_mean_squared_error: 0.9689\n",
+ "Epoch 306/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8297 - root_mean_squared_error: 0.8958 - val_loss: 0.8300 - val_root_mean_squared_error: 0.8966\n",
+ "Epoch 307/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8642 - root_mean_squared_error: 0.9154 - val_loss: 0.8095 - val_root_mean_squared_error: 0.8850\n",
+ "Epoch 308/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7821 - root_mean_squared_error: 0.8680 - val_loss: 0.8482 - val_root_mean_squared_error: 0.9025\n",
+ "Epoch 309/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8451 - root_mean_squared_error: 0.9028 - val_loss: 0.8435 - val_root_mean_squared_error: 0.9028\n",
+ "Epoch 310/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8444 - root_mean_squared_error: 0.9037 - val_loss: 0.9656 - val_root_mean_squared_error: 0.9663\n",
+ "Epoch 311/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8242 - root_mean_squared_error: 0.8916 - val_loss: 0.8069 - val_root_mean_squared_error: 0.8841\n",
+ "Epoch 312/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8191 - root_mean_squared_error: 0.8903 - val_loss: 0.8780 - val_root_mean_squared_error: 0.9213\n",
+ "Epoch 313/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7556 - root_mean_squared_error: 0.8556 - val_loss: 0.9358 - val_root_mean_squared_error: 0.9521\n",
+ "Epoch 314/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8293 - root_mean_squared_error: 0.8942 - val_loss: 0.8641 - val_root_mean_squared_error: 0.9132\n",
+ "Epoch 315/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8204 - root_mean_squared_error: 0.8866 - val_loss: 0.8725 - val_root_mean_squared_error: 0.9171\n",
+ "Epoch 316/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7977 - root_mean_squared_error: 0.8785 - val_loss: 0.8018 - val_root_mean_squared_error: 0.8809\n",
+ "Epoch 317/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8145 - root_mean_squared_error: 0.8848 - val_loss: 0.8642 - val_root_mean_squared_error: 0.9146\n",
+ "Epoch 318/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7636 - root_mean_squared_error: 0.8587 - val_loss: 0.8679 - val_root_mean_squared_error: 0.9153\n",
+ "Epoch 319/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7634 - root_mean_squared_error: 0.8587 - val_loss: 0.8585 - val_root_mean_squared_error: 0.9104\n",
+ "Epoch 320/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7867 - root_mean_squared_error: 0.8713 - val_loss: 0.8654 - val_root_mean_squared_error: 0.9139\n",
+ "Epoch 321/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7826 - root_mean_squared_error: 0.8708 - val_loss: 0.9020 - val_root_mean_squared_error: 0.9398\n",
+ "Epoch 322/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7988 - root_mean_squared_error: 0.8779 - val_loss: 0.8505 - val_root_mean_squared_error: 0.9057\n",
+ "Epoch 323/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8049 - root_mean_squared_error: 0.8802 - val_loss: 0.8888 - val_root_mean_squared_error: 0.9291\n",
+ "Epoch 324/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8355 - root_mean_squared_error: 0.8995 - val_loss: 0.8538 - val_root_mean_squared_error: 0.9084\n",
+ "Epoch 325/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8064 - root_mean_squared_error: 0.8816 - val_loss: 0.8332 - val_root_mean_squared_error: 0.8968\n",
+ "Epoch 326/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8232 - root_mean_squared_error: 0.8943 - val_loss: 0.8273 - val_root_mean_squared_error: 0.8933\n",
+ "Epoch 327/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7938 - root_mean_squared_error: 0.8760 - val_loss: 0.8022 - val_root_mean_squared_error: 0.8778\n",
+ "Epoch 328/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8227 - root_mean_squared_error: 0.8932 - val_loss: 0.8291 - val_root_mean_squared_error: 0.8995\n",
+ "Epoch 329/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8229 - root_mean_squared_error: 0.8928 - val_loss: 0.8054 - val_root_mean_squared_error: 0.8829\n",
+ "Epoch 330/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7957 - root_mean_squared_error: 0.8758 - val_loss: 0.8101 - val_root_mean_squared_error: 0.8828\n",
+ "Epoch 331/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8638 - root_mean_squared_error: 0.9140 - val_loss: 0.8627 - val_root_mean_squared_error: 0.9137\n",
+ "Epoch 332/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8050 - root_mean_squared_error: 0.8823 - val_loss: 0.8326 - val_root_mean_squared_error: 0.8969\n",
+ "Epoch 333/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7702 - root_mean_squared_error: 0.8631 - val_loss: 0.8225 - val_root_mean_squared_error: 0.8900\n",
+ "Epoch 334/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8861 - root_mean_squared_error: 0.9259 - val_loss: 0.9168 - val_root_mean_squared_error: 0.9442\n",
+ "Epoch 335/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8093 - root_mean_squared_error: 0.8851 - val_loss: 0.8255 - val_root_mean_squared_error: 0.8948\n",
+ "Epoch 336/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8370 - root_mean_squared_error: 0.8983 - val_loss: 0.8110 - val_root_mean_squared_error: 0.8856\n",
+ "Epoch 337/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7753 - root_mean_squared_error: 0.8653 - val_loss: 0.7939 - val_root_mean_squared_error: 0.8760\n",
+ "Epoch 338/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8356 - root_mean_squared_error: 0.8985 - val_loss: 0.8574 - val_root_mean_squared_error: 0.9119\n",
+ "Epoch 339/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8365 - root_mean_squared_error: 0.9017 - val_loss: 0.8560 - val_root_mean_squared_error: 0.9095\n",
+ "Epoch 340/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8059 - root_mean_squared_error: 0.8823 - val_loss: 0.8184 - val_root_mean_squared_error: 0.8885\n",
+ "Epoch 341/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8240 - root_mean_squared_error: 0.8910 - val_loss: 0.7526 - val_root_mean_squared_error: 0.8532\n",
+ "Epoch 342/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8019 - root_mean_squared_error: 0.8818 - val_loss: 0.8179 - val_root_mean_squared_error: 0.8909\n",
+ "Epoch 343/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7642 - root_mean_squared_error: 0.8587 - val_loss: 0.8273 - val_root_mean_squared_error: 0.8940\n",
+ "Epoch 344/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8141 - root_mean_squared_error: 0.8884 - val_loss: 0.8006 - val_root_mean_squared_error: 0.8808\n",
+ "Epoch 345/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7686 - root_mean_squared_error: 0.8603 - val_loss: 0.7803 - val_root_mean_squared_error: 0.8691\n",
+ "Epoch 346/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.9464 - root_mean_squared_error: 0.9597 - val_loss: 0.7958 - val_root_mean_squared_error: 0.8756\n",
+ "Epoch 347/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8453 - root_mean_squared_error: 0.9054 - val_loss: 0.8060 - val_root_mean_squared_error: 0.8816\n",
+ "Epoch 348/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 0.7978 - root_mean_squared_error: 0.8778 - val_loss: 0.8319 - val_root_mean_squared_error: 0.8973\n",
+ "Epoch 349/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7762 - root_mean_squared_error: 0.8649 - val_loss: 0.8201 - val_root_mean_squared_error: 0.8882\n",
+ "Epoch 350/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7811 - root_mean_squared_error: 0.8686 - val_loss: 0.8433 - val_root_mean_squared_error: 0.9006\n",
+ "Epoch 351/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7815 - root_mean_squared_error: 0.8691 - val_loss: 0.8250 - val_root_mean_squared_error: 0.8974\n",
+ "Epoch 352/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8195 - root_mean_squared_error: 0.8913 - val_loss: 0.7830 - val_root_mean_squared_error: 0.8675\n",
+ "Epoch 353/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7549 - root_mean_squared_error: 0.8537 - val_loss: 0.8058 - val_root_mean_squared_error: 0.8827\n",
+ "Epoch 354/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8039 - root_mean_squared_error: 0.8821 - val_loss: 0.8344 - val_root_mean_squared_error: 0.8998\n",
+ "Epoch 355/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7958 - root_mean_squared_error: 0.8759 - val_loss: 0.7928 - val_root_mean_squared_error: 0.8747\n",
+ "Epoch 356/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7770 - root_mean_squared_error: 0.8648 - val_loss: 0.8218 - val_root_mean_squared_error: 0.8909\n",
+ "Epoch 357/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7814 - root_mean_squared_error: 0.8691 - val_loss: 0.7876 - val_root_mean_squared_error: 0.8725\n",
+ "Epoch 358/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7551 - root_mean_squared_error: 0.8551 - val_loss: 0.8051 - val_root_mean_squared_error: 0.8836\n",
+ "Epoch 359/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8334 - root_mean_squared_error: 0.8967 - val_loss: 0.8573 - val_root_mean_squared_error: 0.9122\n",
+ "Epoch 360/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7956 - root_mean_squared_error: 0.8769 - val_loss: 0.8637 - val_root_mean_squared_error: 0.9155\n",
+ "Epoch 361/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7380 - root_mean_squared_error: 0.8429 - val_loss: 0.8381 - val_root_mean_squared_error: 0.9007\n",
+ "Epoch 362/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8270 - root_mean_squared_error: 0.8942 - val_loss: 0.8321 - val_root_mean_squared_error: 0.8980\n",
+ "Epoch 363/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7946 - root_mean_squared_error: 0.8780 - val_loss: 0.8302 - val_root_mean_squared_error: 0.8948\n",
+ "Epoch 364/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8029 - root_mean_squared_error: 0.8816 - val_loss: 0.7778 - val_root_mean_squared_error: 0.8675\n",
+ "Epoch 365/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7732 - root_mean_squared_error: 0.8644 - val_loss: 0.8464 - val_root_mean_squared_error: 0.9059\n",
+ "Epoch 366/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8335 - root_mean_squared_error: 0.8984 - val_loss: 0.8341 - val_root_mean_squared_error: 0.8970\n",
+ "Epoch 367/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.8165 - root_mean_squared_error: 0.8884 - val_loss: 0.8166 - val_root_mean_squared_error: 0.8876\n",
+ "Epoch 368/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7938 - root_mean_squared_error: 0.8756 - val_loss: 0.8025 - val_root_mean_squared_error: 0.8813\n",
+ "Epoch 369/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7805 - root_mean_squared_error: 0.8693 - val_loss: 0.7811 - val_root_mean_squared_error: 0.8666\n",
+ "Epoch 370/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7623 - root_mean_squared_error: 0.8585 - val_loss: 0.7603 - val_root_mean_squared_error: 0.8543\n",
+ "Epoch 371/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8636 - root_mean_squared_error: 0.9157 - val_loss: 0.8131 - val_root_mean_squared_error: 0.8855\n",
+ "Epoch 372/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7517 - root_mean_squared_error: 0.8521 - val_loss: 0.7903 - val_root_mean_squared_error: 0.8754\n",
+ "Epoch 373/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8239 - root_mean_squared_error: 0.8927 - val_loss: 0.7908 - val_root_mean_squared_error: 0.8763\n",
+ "Epoch 374/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8482 - root_mean_squared_error: 0.9055 - val_loss: 0.7890 - val_root_mean_squared_error: 0.8740\n",
+ "Epoch 375/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7743 - root_mean_squared_error: 0.8651 - val_loss: 0.7905 - val_root_mean_squared_error: 0.8748\n",
+ "Epoch 376/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8366 - root_mean_squared_error: 0.8995 - val_loss: 0.7512 - val_root_mean_squared_error: 0.8529\n",
+ "Epoch 377/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 0.7907 - root_mean_squared_error: 0.8737 - val_loss: 0.7654 - val_root_mean_squared_error: 0.8597\n",
+ "Epoch 378/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7412 - root_mean_squared_error: 0.8438 - val_loss: 0.7772 - val_root_mean_squared_error: 0.8686\n",
+ "Epoch 379/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 0.7975 - root_mean_squared_error: 0.8777 - val_loss: 0.7919 - val_root_mean_squared_error: 0.8729\n",
+ "Epoch 380/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8022 - root_mean_squared_error: 0.8808 - val_loss: 0.7692 - val_root_mean_squared_error: 0.8625\n",
+ "Epoch 381/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.8045 - root_mean_squared_error: 0.8816 - val_loss: 0.7767 - val_root_mean_squared_error: 0.8652\n",
+ "Epoch 382/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7206 - root_mean_squared_error: 0.8338 - val_loss: 0.7482 - val_root_mean_squared_error: 0.8494\n",
+ "Epoch 383/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7976 - root_mean_squared_error: 0.8801 - val_loss: 0.7686 - val_root_mean_squared_error: 0.8612\n",
+ "Epoch 384/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7643 - root_mean_squared_error: 0.8580 - val_loss: 0.7632 - val_root_mean_squared_error: 0.8590\n",
+ "Epoch 385/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7427 - root_mean_squared_error: 0.8477 - val_loss: 0.7812 - val_root_mean_squared_error: 0.8699\n",
+ "Epoch 386/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7780 - root_mean_squared_error: 0.8666 - val_loss: 0.8091 - val_root_mean_squared_error: 0.8863\n",
+ "Epoch 387/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8136 - root_mean_squared_error: 0.8862 - val_loss: 0.7614 - val_root_mean_squared_error: 0.8556\n",
+ "Epoch 388/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7549 - root_mean_squared_error: 0.8534 - val_loss: 0.7648 - val_root_mean_squared_error: 0.8582\n",
+ "Epoch 389/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7507 - root_mean_squared_error: 0.8496 - val_loss: 0.7481 - val_root_mean_squared_error: 0.8518\n",
+ "Epoch 390/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 0.7831 - root_mean_squared_error: 0.8714 - val_loss: 0.7516 - val_root_mean_squared_error: 0.8515\n",
+ "Epoch 391/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8101 - root_mean_squared_error: 0.8840 - val_loss: 0.7700 - val_root_mean_squared_error: 0.8642\n",
+ "Epoch 392/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7828 - root_mean_squared_error: 0.8699 - val_loss: 0.7782 - val_root_mean_squared_error: 0.8692\n",
+ "Epoch 393/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7754 - root_mean_squared_error: 0.8654 - val_loss: 0.7783 - val_root_mean_squared_error: 0.8671\n",
+ "Epoch 394/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.6976 - root_mean_squared_error: 0.8207 - val_loss: 0.7357 - val_root_mean_squared_error: 0.8391\n",
+ "Epoch 395/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7639 - root_mean_squared_error: 0.8584 - val_loss: 0.8244 - val_root_mean_squared_error: 0.8937\n",
+ "Epoch 396/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7241 - root_mean_squared_error: 0.8336 - val_loss: 0.7628 - val_root_mean_squared_error: 0.8562\n",
+ "Epoch 397/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7493 - root_mean_squared_error: 0.8508 - val_loss: 0.7743 - val_root_mean_squared_error: 0.8677\n",
+ "Epoch 398/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7429 - root_mean_squared_error: 0.8471 - val_loss: 0.7921 - val_root_mean_squared_error: 0.8729\n",
+ "Epoch 399/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7505 - root_mean_squared_error: 0.8507 - val_loss: 0.9588 - val_root_mean_squared_error: 0.9676\n",
+ "Epoch 400/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7425 - root_mean_squared_error: 0.8478 - val_loss: 0.8502 - val_root_mean_squared_error: 0.9094\n",
+ "Epoch 401/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7389 - root_mean_squared_error: 0.8437 - val_loss: 0.7949 - val_root_mean_squared_error: 0.8759\n",
+ "Epoch 402/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7479 - root_mean_squared_error: 0.8535 - val_loss: 0.7907 - val_root_mean_squared_error: 0.8771\n",
+ "Epoch 403/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7445 - root_mean_squared_error: 0.8482 - val_loss: 0.7599 - val_root_mean_squared_error: 0.8553\n",
+ "Epoch 404/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7453 - root_mean_squared_error: 0.8484 - val_loss: 0.8323 - val_root_mean_squared_error: 0.8994\n",
+ "Epoch 405/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7652 - root_mean_squared_error: 0.8604 - val_loss: 0.7581 - val_root_mean_squared_error: 0.8564\n",
+ "Epoch 406/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7527 - root_mean_squared_error: 0.8512 - val_loss: 0.7761 - val_root_mean_squared_error: 0.8663\n",
+ "Epoch 407/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8044 - root_mean_squared_error: 0.8810 - val_loss: 0.7412 - val_root_mean_squared_error: 0.8460\n",
+ "Epoch 408/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7275 - root_mean_squared_error: 0.8385 - val_loss: 0.7300 - val_root_mean_squared_error: 0.8388\n",
+ "Epoch 409/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7792 - root_mean_squared_error: 0.8681 - val_loss: 0.7162 - val_root_mean_squared_error: 0.8285\n",
+ "Epoch 410/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7079 - root_mean_squared_error: 0.8241 - val_loss: 0.7341 - val_root_mean_squared_error: 0.8399\n",
+ "Epoch 411/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7654 - root_mean_squared_error: 0.8613 - val_loss: 0.7662 - val_root_mean_squared_error: 0.8598\n",
+ "Epoch 412/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7122 - root_mean_squared_error: 0.8308 - val_loss: 0.7708 - val_root_mean_squared_error: 0.8618\n",
+ "Epoch 413/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.8058 - root_mean_squared_error: 0.8814 - val_loss: 0.7567 - val_root_mean_squared_error: 0.8545\n",
+ "Epoch 414/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7657 - root_mean_squared_error: 0.8596 - val_loss: 0.7682 - val_root_mean_squared_error: 0.8618\n",
+ "Epoch 415/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7407 - root_mean_squared_error: 0.8469 - val_loss: 0.8288 - val_root_mean_squared_error: 0.8955\n",
+ "Epoch 416/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7746 - root_mean_squared_error: 0.8645 - val_loss: 0.7498 - val_root_mean_squared_error: 0.8532\n",
+ "Epoch 417/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7307 - root_mean_squared_error: 0.8402 - val_loss: 0.7358 - val_root_mean_squared_error: 0.8437\n",
+ "Epoch 418/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7624 - root_mean_squared_error: 0.8591 - val_loss: 0.7737 - val_root_mean_squared_error: 0.8651\n",
+ "Epoch 419/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7474 - root_mean_squared_error: 0.8512 - val_loss: 0.7960 - val_root_mean_squared_error: 0.8762\n",
+ "Epoch 420/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.6921 - root_mean_squared_error: 0.8148 - val_loss: 0.7599 - val_root_mean_squared_error: 0.8568\n",
+ "Epoch 421/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7265 - root_mean_squared_error: 0.8362 - val_loss: 0.8229 - val_root_mean_squared_error: 0.8924\n",
+ "Epoch 422/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7629 - root_mean_squared_error: 0.8572 - val_loss: 0.7627 - val_root_mean_squared_error: 0.8572\n",
+ "Epoch 423/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7308 - root_mean_squared_error: 0.8405 - val_loss: 0.7685 - val_root_mean_squared_error: 0.8634\n",
+ "Epoch 424/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.8174 - root_mean_squared_error: 0.8899 - val_loss: 0.7959 - val_root_mean_squared_error: 0.8773\n",
+ "Epoch 425/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7645 - root_mean_squared_error: 0.8586 - val_loss: 0.7177 - val_root_mean_squared_error: 0.8335\n",
+ "Epoch 426/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7355 - root_mean_squared_error: 0.8428 - val_loss: 0.8012 - val_root_mean_squared_error: 0.8832\n",
+ "Epoch 427/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7742 - root_mean_squared_error: 0.8641 - val_loss: 0.6973 - val_root_mean_squared_error: 0.8205\n",
+ "Epoch 428/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7364 - root_mean_squared_error: 0.8433 - val_loss: 0.7549 - val_root_mean_squared_error: 0.8547\n",
+ "Epoch 429/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7565 - root_mean_squared_error: 0.8556 - val_loss: 0.7335 - val_root_mean_squared_error: 0.8410\n",
+ "Epoch 430/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7132 - root_mean_squared_error: 0.8286 - val_loss: 0.7741 - val_root_mean_squared_error: 0.8641\n",
+ "Epoch 431/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7265 - root_mean_squared_error: 0.8365 - val_loss: 0.7497 - val_root_mean_squared_error: 0.8494\n",
+ "Epoch 432/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7734 - root_mean_squared_error: 0.8635 - val_loss: 0.7308 - val_root_mean_squared_error: 0.8393\n",
+ "Epoch 433/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7017 - root_mean_squared_error: 0.8211 - val_loss: 0.8711 - val_root_mean_squared_error: 0.9197\n",
+ "Epoch 434/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7643 - root_mean_squared_error: 0.8597 - val_loss: 0.7315 - val_root_mean_squared_error: 0.8402\n",
+ "Epoch 435/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7076 - root_mean_squared_error: 0.8245 - val_loss: 0.7836 - val_root_mean_squared_error: 0.8706\n",
+ "Epoch 436/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.6618 - root_mean_squared_error: 0.7967 - val_loss: 0.7725 - val_root_mean_squared_error: 0.8634\n",
+ "Epoch 437/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7410 - root_mean_squared_error: 0.8439 - val_loss: 0.7092 - val_root_mean_squared_error: 0.8266\n",
+ "Epoch 438/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.6737 - root_mean_squared_error: 0.8034 - val_loss: 0.7741 - val_root_mean_squared_error: 0.8645\n",
+ "Epoch 439/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7576 - root_mean_squared_error: 0.8559 - val_loss: 0.7706 - val_root_mean_squared_error: 0.8638\n",
+ "Epoch 440/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 0.6968 - root_mean_squared_error: 0.8187 - val_loss: 0.8011 - val_root_mean_squared_error: 0.8797\n",
+ "Epoch 441/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7431 - root_mean_squared_error: 0.8499 - val_loss: 0.7224 - val_root_mean_squared_error: 0.8342\n",
+ "Epoch 442/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7131 - root_mean_squared_error: 0.8285 - val_loss: 0.7628 - val_root_mean_squared_error: 0.8579\n",
+ "Epoch 443/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7243 - root_mean_squared_error: 0.8362 - val_loss: 0.7491 - val_root_mean_squared_error: 0.8512\n",
+ "Epoch 444/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7039 - root_mean_squared_error: 0.8225 - val_loss: 0.7340 - val_root_mean_squared_error: 0.8404\n",
+ "Epoch 445/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.6880 - root_mean_squared_error: 0.8140 - val_loss: 0.7309 - val_root_mean_squared_error: 0.8378\n",
+ "Epoch 446/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 0.7294 - root_mean_squared_error: 0.8397 - val_loss: 0.7872 - val_root_mean_squared_error: 0.8736\n",
+ "Epoch 447/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7333 - root_mean_squared_error: 0.8408 - val_loss: 0.7372 - val_root_mean_squared_error: 0.8448\n",
+ "Epoch 448/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7214 - root_mean_squared_error: 0.8355 - val_loss: 0.7831 - val_root_mean_squared_error: 0.8723\n",
+ "Epoch 449/500\n",
+ "5/5 [==============================] - 0s 28ms/step - loss: 0.6966 - root_mean_squared_error: 0.8212 - val_loss: 0.7574 - val_root_mean_squared_error: 0.8567\n",
+ "Epoch 450/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7110 - root_mean_squared_error: 0.8270 - val_loss: 0.7232 - val_root_mean_squared_error: 0.8352\n",
+ "Epoch 451/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7144 - root_mean_squared_error: 0.8294 - val_loss: 0.7323 - val_root_mean_squared_error: 0.8424\n",
+ "Epoch 452/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7804 - root_mean_squared_error: 0.8681 - val_loss: 0.7405 - val_root_mean_squared_error: 0.8469\n",
+ "Epoch 453/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7456 - root_mean_squared_error: 0.8479 - val_loss: 0.7313 - val_root_mean_squared_error: 0.8390\n",
+ "Epoch 454/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.6589 - root_mean_squared_error: 0.7969 - val_loss: 0.7293 - val_root_mean_squared_error: 0.8384\n",
+ "Epoch 455/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7256 - root_mean_squared_error: 0.8369 - val_loss: 0.7270 - val_root_mean_squared_error: 0.8350\n",
+ "Epoch 456/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7633 - root_mean_squared_error: 0.8564 - val_loss: 0.6895 - val_root_mean_squared_error: 0.8145\n",
+ "Epoch 457/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7487 - root_mean_squared_error: 0.8503 - val_loss: 0.7474 - val_root_mean_squared_error: 0.8491\n",
+ "Epoch 458/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.6566 - root_mean_squared_error: 0.7934 - val_loss: 0.7253 - val_root_mean_squared_error: 0.8374\n",
+ "Epoch 459/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7292 - root_mean_squared_error: 0.8379 - val_loss: 0.6837 - val_root_mean_squared_error: 0.8111\n",
+ "Epoch 460/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.6782 - root_mean_squared_error: 0.8091 - val_loss: 0.7685 - val_root_mean_squared_error: 0.8608\n",
+ "Epoch 461/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7348 - root_mean_squared_error: 0.8419 - val_loss: 0.7494 - val_root_mean_squared_error: 0.8503\n",
+ "Epoch 462/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.6886 - root_mean_squared_error: 0.8140 - val_loss: 0.7291 - val_root_mean_squared_error: 0.8385\n",
+ "Epoch 463/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7805 - root_mean_squared_error: 0.8687 - val_loss: 0.7260 - val_root_mean_squared_error: 0.8380\n",
+ "Epoch 464/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7480 - root_mean_squared_error: 0.8505 - val_loss: 0.7243 - val_root_mean_squared_error: 0.8356\n",
+ "Epoch 465/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7482 - root_mean_squared_error: 0.8505 - val_loss: 0.7415 - val_root_mean_squared_error: 0.8480\n",
+ "Epoch 466/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7471 - root_mean_squared_error: 0.8492 - val_loss: 0.7026 - val_root_mean_squared_error: 0.8282\n",
+ "Epoch 467/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7071 - root_mean_squared_error: 0.8262 - val_loss: 0.7448 - val_root_mean_squared_error: 0.8489\n",
+ "Epoch 468/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7759 - root_mean_squared_error: 0.8665 - val_loss: 0.7197 - val_root_mean_squared_error: 0.8320\n",
+ "Epoch 469/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7428 - root_mean_squared_error: 0.8454 - val_loss: 0.7367 - val_root_mean_squared_error: 0.8443\n",
+ "Epoch 470/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.6782 - root_mean_squared_error: 0.8072 - val_loss: 0.7085 - val_root_mean_squared_error: 0.8260\n",
+ "Epoch 471/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7049 - root_mean_squared_error: 0.8225 - val_loss: 0.7204 - val_root_mean_squared_error: 0.8349\n",
+ "Epoch 472/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.6491 - root_mean_squared_error: 0.7883 - val_loss: 0.7155 - val_root_mean_squared_error: 0.8292\n",
+ "Epoch 473/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.6897 - root_mean_squared_error: 0.8150 - val_loss: 0.6887 - val_root_mean_squared_error: 0.8135\n",
+ "Epoch 474/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.6964 - root_mean_squared_error: 0.8196 - val_loss: 0.7141 - val_root_mean_squared_error: 0.8310\n",
+ "Epoch 475/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7585 - root_mean_squared_error: 0.8556 - val_loss: 0.7135 - val_root_mean_squared_error: 0.8275\n",
+ "Epoch 476/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7021 - root_mean_squared_error: 0.8225 - val_loss: 0.7421 - val_root_mean_squared_error: 0.8456\n",
+ "Epoch 477/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.6938 - root_mean_squared_error: 0.8173 - val_loss: 0.7160 - val_root_mean_squared_error: 0.8315\n",
+ "Epoch 478/500\n",
+ "5/5 [==============================] - 0s 29ms/step - loss: 0.7404 - root_mean_squared_error: 0.8442 - val_loss: 0.7335 - val_root_mean_squared_error: 0.8408\n",
+ "Epoch 479/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7401 - root_mean_squared_error: 0.8469 - val_loss: 0.6884 - val_root_mean_squared_error: 0.8150\n",
+ "Epoch 480/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7076 - root_mean_squared_error: 0.8242 - val_loss: 0.7114 - val_root_mean_squared_error: 0.8268\n",
+ "Epoch 481/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7180 - root_mean_squared_error: 0.8313 - val_loss: 0.7051 - val_root_mean_squared_error: 0.8240\n",
+ "Epoch 482/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7148 - root_mean_squared_error: 0.8312 - val_loss: 0.7308 - val_root_mean_squared_error: 0.8386\n",
+ "Epoch 483/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.7098 - root_mean_squared_error: 0.8251 - val_loss: 0.6752 - val_root_mean_squared_error: 0.8055\n",
+ "Epoch 484/500\n",
+ "5/5 [==============================] - 0s 30ms/step - loss: 0.6497 - root_mean_squared_error: 0.7903 - val_loss: 0.7359 - val_root_mean_squared_error: 0.8441\n",
+ "Epoch 485/500\n",
+ "5/5 [==============================] - 0s 36ms/step - loss: 0.6704 - root_mean_squared_error: 0.8047 - val_loss: 0.6974 - val_root_mean_squared_error: 0.8177\n",
+ "Epoch 486/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.7476 - root_mean_squared_error: 0.8502 - val_loss: 0.7195 - val_root_mean_squared_error: 0.8328\n",
+ "Epoch 487/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 0.7330 - root_mean_squared_error: 0.8407 - val_loss: 0.6829 - val_root_mean_squared_error: 0.8082\n",
+ "Epoch 488/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 0.6270 - root_mean_squared_error: 0.7761 - val_loss: 0.7291 - val_root_mean_squared_error: 0.8374\n",
+ "Epoch 489/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 0.7055 - root_mean_squared_error: 0.8251 - val_loss: 0.6826 - val_root_mean_squared_error: 0.8109\n",
+ "Epoch 490/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.6910 - root_mean_squared_error: 0.8147 - val_loss: 0.7298 - val_root_mean_squared_error: 0.8388\n",
+ "Epoch 491/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 0.7084 - root_mean_squared_error: 0.8262 - val_loss: 0.7792 - val_root_mean_squared_error: 0.8680\n",
+ "Epoch 492/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.6939 - root_mean_squared_error: 0.8176 - val_loss: 0.7059 - val_root_mean_squared_error: 0.8249\n",
+ "Epoch 493/500\n",
+ "5/5 [==============================] - 0s 36ms/step - loss: 0.6629 - root_mean_squared_error: 0.7994 - val_loss: 0.7607 - val_root_mean_squared_error: 0.8549\n",
+ "Epoch 494/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.7003 - root_mean_squared_error: 0.8204 - val_loss: 0.6696 - val_root_mean_squared_error: 0.8023\n",
+ "Epoch 495/500\n",
+ "5/5 [==============================] - 0s 31ms/step - loss: 0.6613 - root_mean_squared_error: 0.7970 - val_loss: 0.7362 - val_root_mean_squared_error: 0.8450\n",
+ "Epoch 496/500\n",
+ "5/5 [==============================] - 0s 32ms/step - loss: 0.6838 - root_mean_squared_error: 0.8071 - val_loss: 0.7198 - val_root_mean_squared_error: 0.8309\n",
+ "Epoch 497/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 0.7360 - root_mean_squared_error: 0.8416 - val_loss: 0.7094 - val_root_mean_squared_error: 0.8279\n",
+ "Epoch 498/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 0.7539 - root_mean_squared_error: 0.8541 - val_loss: 0.6967 - val_root_mean_squared_error: 0.8191\n",
+ "Epoch 499/500\n",
+ "5/5 [==============================] - 0s 33ms/step - loss: 0.7041 - root_mean_squared_error: 0.8237 - val_loss: 0.7500 - val_root_mean_squared_error: 0.8498\n",
+ "Epoch 500/500\n",
+ "5/5 [==============================] - 0s 34ms/step - loss: 0.7026 - root_mean_squared_error: 0.8223 - val_loss: 0.7973 - val_root_mean_squared_error: 0.8806\n",
+ "Model training finished.\n",
+ "Train RMSE: 0.851\n",
+ "Evaluating model performance...\n",
+ "Test RMSE: 0.849\n"
+ ]
+ }
+ ],
+ "source": [
+ "num_epochs = 500\n",
+ "train_sample_size = int(train_size * 0.3)\n",
+ "small_train_dataset = train_dataset.unbatch().take(train_sample_size).batch(batch_size)\n",
+ "\n",
+ "bnn_model_small = create_bnn_model(train_sample_size)\n",
+ "run_experiment(bnn_model_small, mse_loss, small_train_dataset, test_dataset)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fO-VvjydJZX9"
+ },
+ "source": [
+ "Since we have trained a BNN model, the model produces a different output each time\n",
+ "we call it with the same input, since each time a new set of weights are sampled\n",
+ "from the distributions to construct the network and produce an output.\n",
+ "The less certain the mode weights are, the more variability (wider range) we will\n",
+ "see in the outputs of the same inputs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "id": "oDLpALs7JZX-"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "5SdzlMuvJZYA"
- },
- "outputs": [],
- "source": [
- "\n",
- "def negative_loglikelihood(targets, estimated_distribution):\n",
- " return -estimated_distribution.log_prob(targets)\n",
- "\n",
- "\n",
- "num_epochs = 1000\n",
- "prob_bnn_model = create_probablistic_bnn_model(train_size)\n",
- "run_experiment(prob_bnn_model, negative_loglikelihood, train_dataset, test_dataset)"
- ]
- },
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Predictions mean: 5.74, min: 5.14, max: 6.27, range: 1.13 - Actual: 6.0\n",
+ "Predictions mean: 6.1, min: 5.56, max: 6.33, range: 0.77 - Actual: 7.0\n",
+ "Predictions mean: 5.84, min: 5.34, max: 6.34, range: 1.0 - Actual: 7.0\n",
+ "Predictions mean: 6.15, min: 5.61, max: 6.39, range: 0.78 - Actual: 6.0\n",
+ "Predictions mean: 6.11, min: 5.58, max: 6.37, range: 0.79 - Actual: 5.0\n",
+ "Predictions mean: 6.01, min: 5.37, max: 6.36, range: 0.99 - Actual: 7.0\n",
+ "Predictions mean: 6.04, min: 5.51, max: 6.41, range: 0.91 - Actual: 6.0\n",
+ "Predictions mean: 5.96, min: 5.42, max: 6.32, range: 0.9 - Actual: 6.0\n",
+ "Predictions mean: 6.14, min: 5.65, max: 6.43, range: 0.78 - Actual: 8.0\n",
+ "Predictions mean: 5.66, min: 4.99, max: 6.2, range: 1.21 - Actual: 6.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "\n",
+ "def compute_predictions(model, iterations=100):\n",
+ " predicted = []\n",
+ " for _ in range(iterations):\n",
+ " predicted.append(model(examples).numpy())\n",
+ " predicted = np.concatenate(predicted, axis=1)\n",
+ "\n",
+ " prediction_mean = np.mean(predicted, axis=1).tolist()\n",
+ " prediction_min = np.min(predicted, axis=1).tolist()\n",
+ " prediction_max = np.max(predicted, axis=1).tolist()\n",
+ " prediction_range = (np.max(predicted, axis=1) - np.min(predicted, axis=1)).tolist()\n",
+ "\n",
+ " for idx in range(sample):\n",
+ " print(\n",
+ " f\"Predictions mean: {round(prediction_mean[idx], 2)}, \"\n",
+ " f\"min: {round(prediction_min[idx], 2)}, \"\n",
+ " f\"max: {round(prediction_max[idx], 2)}, \"\n",
+ " f\"range: {round(prediction_range[idx], 2)} - \"\n",
+ " f\"Actual: {targets[idx]}\"\n",
+ " )\n",
+ "\n",
+ "\n",
+ "compute_predictions(bnn_model_small)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Mh1cMJ1VJZX-"
+ },
+ "source": [
+ "### Train BNN with the whole training set."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "id": "_e8b8DCJJZX-"
+ },
+ "outputs": [
{
- "cell_type": "markdown",
- "metadata": {
- "id": "53qcYDKyJZYA"
- },
- "source": [
- "Now let's produce an output from the model given the test examples.\n",
- "The output is now a distribution, and we can use its mean and variance\n",
- "to compute the confidence intervals (CI) of the prediction."
- ]
- },
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Start training the model...\n",
+ "Epoch 1/500\n",
+ "17/17 [==============================] - 2s 35ms/step - loss: 40.0905 - root_mean_squared_error: 6.3314 - val_loss: 35.8348 - val_root_mean_squared_error: 5.9858\n",
+ "Epoch 2/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 37.6488 - root_mean_squared_error: 6.1355 - val_loss: 37.0272 - val_root_mean_squared_error: 6.0846\n",
+ "Epoch 3/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 36.3662 - root_mean_squared_error: 6.0301 - val_loss: 37.7250 - val_root_mean_squared_error: 6.1417\n",
+ "Epoch 4/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 34.3783 - root_mean_squared_error: 5.8630 - val_loss: 31.5982 - val_root_mean_squared_error: 5.6208\n",
+ "Epoch 5/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 35.5805 - root_mean_squared_error: 5.9646 - val_loss: 30.3964 - val_root_mean_squared_error: 5.5129\n",
+ "Epoch 6/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 32.8945 - root_mean_squared_error: 5.7350 - val_loss: 30.7139 - val_root_mean_squared_error: 5.5416\n",
+ "Epoch 7/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 32.4754 - root_mean_squared_error: 5.6983 - val_loss: 30.3086 - val_root_mean_squared_error: 5.5048\n",
+ "Epoch 8/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 31.0565 - root_mean_squared_error: 5.5724 - val_loss: 31.1866 - val_root_mean_squared_error: 5.5840\n",
+ "Epoch 9/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 27.9851 - root_mean_squared_error: 5.2897 - val_loss: 28.6839 - val_root_mean_squared_error: 5.3552\n",
+ "Epoch 10/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 28.2430 - root_mean_squared_error: 5.3141 - val_loss: 30.2928 - val_root_mean_squared_error: 5.5035\n",
+ "Epoch 11/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 26.6376 - root_mean_squared_error: 5.1607 - val_loss: 25.9014 - val_root_mean_squared_error: 5.0888\n",
+ "Epoch 12/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 25.2912 - root_mean_squared_error: 5.0285 - val_loss: 23.2093 - val_root_mean_squared_error: 4.8172\n",
+ "Epoch 13/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 24.8960 - root_mean_squared_error: 4.9891 - val_loss: 25.5103 - val_root_mean_squared_error: 5.0504\n",
+ "Epoch 14/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 24.3532 - root_mean_squared_error: 4.9344 - val_loss: 22.8375 - val_root_mean_squared_error: 4.7782\n",
+ "Epoch 15/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 22.4276 - root_mean_squared_error: 4.7352 - val_loss: 20.9428 - val_root_mean_squared_error: 4.5758\n",
+ "Epoch 16/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 21.1903 - root_mean_squared_error: 4.6028 - val_loss: 19.6403 - val_root_mean_squared_error: 4.4311\n",
+ "Epoch 17/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 20.1841 - root_mean_squared_error: 4.4921 - val_loss: 18.8207 - val_root_mean_squared_error: 4.3375\n",
+ "Epoch 18/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 18.6136 - root_mean_squared_error: 4.3137 - val_loss: 18.9530 - val_root_mean_squared_error: 4.3529\n",
+ "Epoch 19/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 18.0773 - root_mean_squared_error: 4.2511 - val_loss: 16.2860 - val_root_mean_squared_error: 4.0348\n",
+ "Epoch 20/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 16.7276 - root_mean_squared_error: 4.0893 - val_loss: 16.4384 - val_root_mean_squared_error: 4.0537\n",
+ "Epoch 21/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 16.1143 - root_mean_squared_error: 4.0135 - val_loss: 13.6043 - val_root_mean_squared_error: 3.6876\n",
+ "Epoch 22/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 15.5216 - root_mean_squared_error: 3.9390 - val_loss: 14.0286 - val_root_mean_squared_error: 3.7447\n",
+ "Epoch 23/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 14.7735 - root_mean_squared_error: 3.8429 - val_loss: 13.6101 - val_root_mean_squared_error: 3.6885\n",
+ "Epoch 24/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 14.6718 - root_mean_squared_error: 3.8297 - val_loss: 13.0984 - val_root_mean_squared_error: 3.6185\n",
+ "Epoch 25/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 12.2290 - root_mean_squared_error: 3.4960 - val_loss: 12.7084 - val_root_mean_squared_error: 3.5642\n",
+ "Epoch 26/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 11.5957 - root_mean_squared_error: 3.4043 - val_loss: 10.6381 - val_root_mean_squared_error: 3.2604\n",
+ "Epoch 27/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 11.4028 - root_mean_squared_error: 3.3759 - val_loss: 10.7183 - val_root_mean_squared_error: 3.2729\n",
+ "Epoch 28/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 9.9945 - root_mean_squared_error: 3.1604 - val_loss: 9.1325 - val_root_mean_squared_error: 3.0211\n",
+ "Epoch 29/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 9.3494 - root_mean_squared_error: 3.0565 - val_loss: 8.5997 - val_root_mean_squared_error: 2.9314\n",
+ "Epoch 30/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 8.7994 - root_mean_squared_error: 2.9653 - val_loss: 8.8903 - val_root_mean_squared_error: 2.9805\n",
+ "Epoch 31/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 8.2323 - root_mean_squared_error: 2.8680 - val_loss: 7.1276 - val_root_mean_squared_error: 2.6684\n",
+ "Epoch 32/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 7.7751 - root_mean_squared_error: 2.7870 - val_loss: 8.6531 - val_root_mean_squared_error: 2.9405\n",
+ "Epoch 33/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 6.5677 - root_mean_squared_error: 2.5613 - val_loss: 6.9584 - val_root_mean_squared_error: 2.6366\n",
+ "Epoch 34/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 6.4013 - root_mean_squared_error: 2.5287 - val_loss: 5.7653 - val_root_mean_squared_error: 2.3997\n",
+ "Epoch 35/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 5.6532 - root_mean_squared_error: 2.3760 - val_loss: 5.1107 - val_root_mean_squared_error: 2.2591\n",
+ "Epoch 36/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 5.3516 - root_mean_squared_error: 2.3118 - val_loss: 4.6135 - val_root_mean_squared_error: 2.1461\n",
+ "Epoch 37/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 4.3631 - root_mean_squared_error: 2.0869 - val_loss: 4.0978 - val_root_mean_squared_error: 2.0225\n",
+ "Epoch 38/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 4.2535 - root_mean_squared_error: 2.0606 - val_loss: 3.8108 - val_root_mean_squared_error: 1.9502\n",
+ "Epoch 39/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 3.7561 - root_mean_squared_error: 1.9362 - val_loss: 3.3581 - val_root_mean_squared_error: 1.8305\n",
+ "Epoch 40/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 3.4173 - root_mean_squared_error: 1.8466 - val_loss: 4.4214 - val_root_mean_squared_error: 2.1009\n",
+ "Epoch 41/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.9929 - root_mean_squared_error: 1.7276 - val_loss: 2.6899 - val_root_mean_squared_error: 1.6373\n",
+ "Epoch 42/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.6413 - root_mean_squared_error: 1.6226 - val_loss: 2.7743 - val_root_mean_squared_error: 1.6630\n",
+ "Epoch 43/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.3123 - root_mean_squared_error: 1.5178 - val_loss: 1.9119 - val_root_mean_squared_error: 1.3792\n",
+ "Epoch 44/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.9747 - root_mean_squared_error: 1.4020 - val_loss: 1.6839 - val_root_mean_squared_error: 1.2938\n",
+ "Epoch 45/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.7826 - root_mean_squared_error: 1.3317 - val_loss: 1.9360 - val_root_mean_squared_error: 1.3882\n",
+ "Epoch 46/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.5861 - root_mean_squared_error: 1.2557 - val_loss: 1.2034 - val_root_mean_squared_error: 1.0923\n",
+ "Epoch 47/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.4216 - root_mean_squared_error: 1.1884 - val_loss: 1.2900 - val_root_mean_squared_error: 1.1311\n",
+ "Epoch 48/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3748 - root_mean_squared_error: 1.1686 - val_loss: 1.0753 - val_root_mean_squared_error: 1.0327\n",
+ "Epoch 49/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1092 - root_mean_squared_error: 1.0487 - val_loss: 0.9962 - val_root_mean_squared_error: 0.9933\n",
+ "Epoch 50/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.0277 - root_mean_squared_error: 1.0096 - val_loss: 0.8349 - val_root_mean_squared_error: 0.9079\n",
+ "Epoch 51/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.8958 - root_mean_squared_error: 0.9413 - val_loss: 0.7852 - val_root_mean_squared_error: 0.8797\n",
+ "Epoch 52/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.8349 - root_mean_squared_error: 0.9081 - val_loss: 0.7919 - val_root_mean_squared_error: 0.8840\n",
+ "Epoch 53/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7924 - root_mean_squared_error: 0.8849 - val_loss: 0.7981 - val_root_mean_squared_error: 0.8879\n",
+ "Epoch 54/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.8176 - root_mean_squared_error: 0.8987 - val_loss: 0.7778 - val_root_mean_squared_error: 0.8759\n",
+ "Epoch 55/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.7833 - root_mean_squared_error: 0.8795 - val_loss: 0.7974 - val_root_mean_squared_error: 0.8873\n",
+ "Epoch 56/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7784 - root_mean_squared_error: 0.8765 - val_loss: 0.7856 - val_root_mean_squared_error: 0.8804\n",
+ "Epoch 57/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7977 - root_mean_squared_error: 0.8873 - val_loss: 0.7858 - val_root_mean_squared_error: 0.8799\n",
+ "Epoch 58/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7723 - root_mean_squared_error: 0.8732 - val_loss: 0.7984 - val_root_mean_squared_error: 0.8882\n",
+ "Epoch 59/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7682 - root_mean_squared_error: 0.8707 - val_loss: 0.8088 - val_root_mean_squared_error: 0.8933\n",
+ "Epoch 60/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7653 - root_mean_squared_error: 0.8695 - val_loss: 0.7920 - val_root_mean_squared_error: 0.8846\n",
+ "Epoch 61/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7327 - root_mean_squared_error: 0.8500 - val_loss: 0.8002 - val_root_mean_squared_error: 0.8885\n",
+ "Epoch 62/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7430 - root_mean_squared_error: 0.8560 - val_loss: 0.7864 - val_root_mean_squared_error: 0.8806\n",
+ "Epoch 63/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.7344 - root_mean_squared_error: 0.8509 - val_loss: 0.7464 - val_root_mean_squared_error: 0.8574\n",
+ "Epoch 64/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7413 - root_mean_squared_error: 0.8551 - val_loss: 0.7623 - val_root_mean_squared_error: 0.8674\n",
+ "Epoch 65/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7648 - root_mean_squared_error: 0.8690 - val_loss: 0.7748 - val_root_mean_squared_error: 0.8751\n",
+ "Epoch 66/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7379 - root_mean_squared_error: 0.8532 - val_loss: 0.7547 - val_root_mean_squared_error: 0.8637\n",
+ "Epoch 67/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7404 - root_mean_squared_error: 0.8547 - val_loss: 0.7129 - val_root_mean_squared_error: 0.8385\n",
+ "Epoch 68/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7299 - root_mean_squared_error: 0.8486 - val_loss: 0.7736 - val_root_mean_squared_error: 0.8734\n",
+ "Epoch 69/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.7297 - root_mean_squared_error: 0.8483 - val_loss: 0.7134 - val_root_mean_squared_error: 0.8381\n",
+ "Epoch 70/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7320 - root_mean_squared_error: 0.8498 - val_loss: 0.7225 - val_root_mean_squared_error: 0.8441\n",
+ "Epoch 71/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7264 - root_mean_squared_error: 0.8465 - val_loss: 0.7558 - val_root_mean_squared_error: 0.8633\n",
+ "Epoch 72/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7204 - root_mean_squared_error: 0.8426 - val_loss: 0.7297 - val_root_mean_squared_error: 0.8478\n",
+ "Epoch 73/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7168 - root_mean_squared_error: 0.8408 - val_loss: 0.7133 - val_root_mean_squared_error: 0.8379\n",
+ "Epoch 74/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7172 - root_mean_squared_error: 0.8410 - val_loss: 0.6978 - val_root_mean_squared_error: 0.8286\n",
+ "Epoch 75/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7218 - root_mean_squared_error: 0.8438 - val_loss: 0.7328 - val_root_mean_squared_error: 0.8500\n",
+ "Epoch 76/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7195 - root_mean_squared_error: 0.8423 - val_loss: 0.7435 - val_root_mean_squared_error: 0.8556\n",
+ "Epoch 77/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.7103 - root_mean_squared_error: 0.8370 - val_loss: 0.7232 - val_root_mean_squared_error: 0.8444\n",
+ "Epoch 78/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.7142 - root_mean_squared_error: 0.8393 - val_loss: 0.6810 - val_root_mean_squared_error: 0.8193\n",
+ "Epoch 79/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7055 - root_mean_squared_error: 0.8343 - val_loss: 0.7465 - val_root_mean_squared_error: 0.8581\n",
+ "Epoch 80/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7222 - root_mean_squared_error: 0.8437 - val_loss: 0.7288 - val_root_mean_squared_error: 0.8471\n",
+ "Epoch 81/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6885 - root_mean_squared_error: 0.8235 - val_loss: 0.7576 - val_root_mean_squared_error: 0.8640\n",
+ "Epoch 82/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.7015 - root_mean_squared_error: 0.8310 - val_loss: 0.6959 - val_root_mean_squared_error: 0.8280\n",
+ "Epoch 83/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6836 - root_mean_squared_error: 0.8202 - val_loss: 0.6933 - val_root_mean_squared_error: 0.8261\n",
+ "Epoch 84/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7103 - root_mean_squared_error: 0.8369 - val_loss: 0.7498 - val_root_mean_squared_error: 0.8604\n",
+ "Epoch 85/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6946 - root_mean_squared_error: 0.8272 - val_loss: 0.6811 - val_root_mean_squared_error: 0.8198\n",
+ "Epoch 86/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6860 - root_mean_squared_error: 0.8223 - val_loss: 0.6788 - val_root_mean_squared_error: 0.8175\n",
+ "Epoch 87/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6896 - root_mean_squared_error: 0.8242 - val_loss: 0.7371 - val_root_mean_squared_error: 0.8527\n",
+ "Epoch 88/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6928 - root_mean_squared_error: 0.8261 - val_loss: 0.6733 - val_root_mean_squared_error: 0.8136\n",
+ "Epoch 89/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6757 - root_mean_squared_error: 0.8159 - val_loss: 0.6769 - val_root_mean_squared_error: 0.8159\n",
+ "Epoch 90/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.7093 - root_mean_squared_error: 0.8362 - val_loss: 0.7251 - val_root_mean_squared_error: 0.8456\n",
+ "Epoch 91/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6809 - root_mean_squared_error: 0.8188 - val_loss: 0.7372 - val_root_mean_squared_error: 0.8525\n",
+ "Epoch 92/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6952 - root_mean_squared_error: 0.8278 - val_loss: 0.6925 - val_root_mean_squared_error: 0.8256\n",
+ "Epoch 93/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6842 - root_mean_squared_error: 0.8208 - val_loss: 0.6772 - val_root_mean_squared_error: 0.8166\n",
+ "Epoch 94/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6940 - root_mean_squared_error: 0.8267 - val_loss: 0.6893 - val_root_mean_squared_error: 0.8231\n",
+ "Epoch 95/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6815 - root_mean_squared_error: 0.8192 - val_loss: 0.6660 - val_root_mean_squared_error: 0.8102\n",
+ "Epoch 96/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6785 - root_mean_squared_error: 0.8174 - val_loss: 0.6472 - val_root_mean_squared_error: 0.7979\n",
+ "Epoch 97/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6784 - root_mean_squared_error: 0.8171 - val_loss: 0.6699 - val_root_mean_squared_error: 0.8113\n",
+ "Epoch 98/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6850 - root_mean_squared_error: 0.8214 - val_loss: 0.7340 - val_root_mean_squared_error: 0.8498\n",
+ "Epoch 99/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6689 - root_mean_squared_error: 0.8117 - val_loss: 0.6540 - val_root_mean_squared_error: 0.8029\n",
+ "Epoch 100/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6590 - root_mean_squared_error: 0.8052 - val_loss: 0.6731 - val_root_mean_squared_error: 0.8142\n",
+ "Epoch 101/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6725 - root_mean_squared_error: 0.8129 - val_loss: 0.6356 - val_root_mean_squared_error: 0.7909\n",
+ "Epoch 102/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6864 - root_mean_squared_error: 0.8223 - val_loss: 0.6675 - val_root_mean_squared_error: 0.8114\n",
+ "Epoch 103/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6541 - root_mean_squared_error: 0.8022 - val_loss: 0.6522 - val_root_mean_squared_error: 0.8008\n",
+ "Epoch 104/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6557 - root_mean_squared_error: 0.8030 - val_loss: 0.7328 - val_root_mean_squared_error: 0.8498\n",
+ "Epoch 105/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6714 - root_mean_squared_error: 0.8128 - val_loss: 0.6436 - val_root_mean_squared_error: 0.7951\n",
+ "Epoch 106/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6510 - root_mean_squared_error: 0.8005 - val_loss: 0.6327 - val_root_mean_squared_error: 0.7881\n",
+ "Epoch 107/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6779 - root_mean_squared_error: 0.8167 - val_loss: 0.6784 - val_root_mean_squared_error: 0.8183\n",
+ "Epoch 108/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6606 - root_mean_squared_error: 0.8062 - val_loss: 0.6541 - val_root_mean_squared_error: 0.8016\n",
+ "Epoch 109/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6551 - root_mean_squared_error: 0.8029 - val_loss: 0.6597 - val_root_mean_squared_error: 0.8048\n",
+ "Epoch 110/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6641 - root_mean_squared_error: 0.8082 - val_loss: 0.6723 - val_root_mean_squared_error: 0.8127\n",
+ "Epoch 111/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6512 - root_mean_squared_error: 0.8000 - val_loss: 0.6601 - val_root_mean_squared_error: 0.8052\n",
+ "Epoch 112/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6576 - root_mean_squared_error: 0.8040 - val_loss: 0.6180 - val_root_mean_squared_error: 0.7786\n",
+ "Epoch 113/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6459 - root_mean_squared_error: 0.7972 - val_loss: 0.6315 - val_root_mean_squared_error: 0.7876\n",
+ "Epoch 114/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6574 - root_mean_squared_error: 0.8041 - val_loss: 0.6554 - val_root_mean_squared_error: 0.8028\n",
+ "Epoch 115/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6632 - root_mean_squared_error: 0.8077 - val_loss: 0.6444 - val_root_mean_squared_error: 0.7963\n",
+ "Epoch 116/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6509 - root_mean_squared_error: 0.8000 - val_loss: 0.6670 - val_root_mean_squared_error: 0.8099\n",
+ "Epoch 117/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6706 - root_mean_squared_error: 0.8122 - val_loss: 0.6167 - val_root_mean_squared_error: 0.7788\n",
+ "Epoch 118/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6500 - root_mean_squared_error: 0.7994 - val_loss: 0.6699 - val_root_mean_squared_error: 0.8121\n",
+ "Epoch 119/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6423 - root_mean_squared_error: 0.7945 - val_loss: 0.6709 - val_root_mean_squared_error: 0.8122\n",
+ "Epoch 120/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6441 - root_mean_squared_error: 0.7958 - val_loss: 0.6749 - val_root_mean_squared_error: 0.8148\n",
+ "Epoch 121/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6335 - root_mean_squared_error: 0.7889 - val_loss: 0.6620 - val_root_mean_squared_error: 0.8080\n",
+ "Epoch 122/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6433 - root_mean_squared_error: 0.7952 - val_loss: 0.6356 - val_root_mean_squared_error: 0.7896\n",
+ "Epoch 123/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6346 - root_mean_squared_error: 0.7896 - val_loss: 0.6454 - val_root_mean_squared_error: 0.7963\n",
+ "Epoch 124/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6613 - root_mean_squared_error: 0.8068 - val_loss: 0.6316 - val_root_mean_squared_error: 0.7876\n",
+ "Epoch 125/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6347 - root_mean_squared_error: 0.7898 - val_loss: 0.6229 - val_root_mean_squared_error: 0.7822\n",
+ "Epoch 126/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6565 - root_mean_squared_error: 0.8036 - val_loss: 0.6353 - val_root_mean_squared_error: 0.7903\n",
+ "Epoch 127/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6380 - root_mean_squared_error: 0.7915 - val_loss: 0.6073 - val_root_mean_squared_error: 0.7712\n",
+ "Epoch 128/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6282 - root_mean_squared_error: 0.7853 - val_loss: 0.6753 - val_root_mean_squared_error: 0.8152\n",
+ "Epoch 129/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6351 - root_mean_squared_error: 0.7899 - val_loss: 0.6560 - val_root_mean_squared_error: 0.8028\n",
+ "Epoch 130/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6255 - root_mean_squared_error: 0.7837 - val_loss: 0.6456 - val_root_mean_squared_error: 0.7968\n",
+ "Epoch 131/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6413 - root_mean_squared_error: 0.7937 - val_loss: 0.6177 - val_root_mean_squared_error: 0.7789\n",
+ "Epoch 132/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6243 - root_mean_squared_error: 0.7829 - val_loss: 0.6131 - val_root_mean_squared_error: 0.7752\n",
+ "Epoch 133/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6407 - root_mean_squared_error: 0.7936 - val_loss: 0.6725 - val_root_mean_squared_error: 0.8125\n",
+ "Epoch 134/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6414 - root_mean_squared_error: 0.7943 - val_loss: 0.6329 - val_root_mean_squared_error: 0.7885\n",
+ "Epoch 135/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6362 - root_mean_squared_error: 0.7904 - val_loss: 0.6183 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 136/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6454 - root_mean_squared_error: 0.7966 - val_loss: 0.6360 - val_root_mean_squared_error: 0.7898\n",
+ "Epoch 137/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6254 - root_mean_squared_error: 0.7838 - val_loss: 0.6453 - val_root_mean_squared_error: 0.7958\n",
+ "Epoch 138/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6510 - root_mean_squared_error: 0.8002 - val_loss: 0.6138 - val_root_mean_squared_error: 0.7765\n",
+ "Epoch 139/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6270 - root_mean_squared_error: 0.7846 - val_loss: 0.6286 - val_root_mean_squared_error: 0.7858\n",
+ "Epoch 140/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6285 - root_mean_squared_error: 0.7853 - val_loss: 0.6319 - val_root_mean_squared_error: 0.7880\n",
+ "Epoch 141/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6334 - root_mean_squared_error: 0.7883 - val_loss: 0.6409 - val_root_mean_squared_error: 0.7935\n",
+ "Epoch 142/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6468 - root_mean_squared_error: 0.7974 - val_loss: 0.6535 - val_root_mean_squared_error: 0.8020\n",
+ "Epoch 143/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6257 - root_mean_squared_error: 0.7834 - val_loss: 0.6293 - val_root_mean_squared_error: 0.7870\n",
+ "Epoch 144/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6448 - root_mean_squared_error: 0.7958 - val_loss: 0.6359 - val_root_mean_squared_error: 0.7900\n",
+ "Epoch 145/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6309 - root_mean_squared_error: 0.7869 - val_loss: 0.6649 - val_root_mean_squared_error: 0.8078\n",
+ "Epoch 146/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6202 - root_mean_squared_error: 0.7804 - val_loss: 0.6253 - val_root_mean_squared_error: 0.7840\n",
+ "Epoch 147/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6309 - root_mean_squared_error: 0.7867 - val_loss: 0.6408 - val_root_mean_squared_error: 0.7949\n",
+ "Epoch 148/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6538 - root_mean_squared_error: 0.8018 - val_loss: 0.6251 - val_root_mean_squared_error: 0.7833\n",
+ "Epoch 149/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6287 - root_mean_squared_error: 0.7859 - val_loss: 0.6172 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 150/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6430 - root_mean_squared_error: 0.7944 - val_loss: 0.6174 - val_root_mean_squared_error: 0.7778\n",
+ "Epoch 151/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6242 - root_mean_squared_error: 0.7829 - val_loss: 0.6273 - val_root_mean_squared_error: 0.7856\n",
+ "Epoch 152/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6305 - root_mean_squared_error: 0.7868 - val_loss: 0.6293 - val_root_mean_squared_error: 0.7860\n",
+ "Epoch 153/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6368 - root_mean_squared_error: 0.7908 - val_loss: 0.6316 - val_root_mean_squared_error: 0.7875\n",
+ "Epoch 154/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6538 - root_mean_squared_error: 0.8013 - val_loss: 0.6363 - val_root_mean_squared_error: 0.7902\n",
+ "Epoch 155/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6380 - root_mean_squared_error: 0.7916 - val_loss: 0.6193 - val_root_mean_squared_error: 0.7792\n",
+ "Epoch 156/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6361 - root_mean_squared_error: 0.7905 - val_loss: 0.6198 - val_root_mean_squared_error: 0.7803\n",
+ "Epoch 157/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6249 - root_mean_squared_error: 0.7829 - val_loss: 0.6306 - val_root_mean_squared_error: 0.7867\n",
+ "Epoch 158/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6341 - root_mean_squared_error: 0.7891 - val_loss: 0.6101 - val_root_mean_squared_error: 0.7737\n",
+ "Epoch 159/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6191 - root_mean_squared_error: 0.7793 - val_loss: 0.6225 - val_root_mean_squared_error: 0.7823\n",
+ "Epoch 160/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6303 - root_mean_squared_error: 0.7866 - val_loss: 0.6174 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 161/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6233 - root_mean_squared_error: 0.7825 - val_loss: 0.6164 - val_root_mean_squared_error: 0.7772\n",
+ "Epoch 162/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6171 - root_mean_squared_error: 0.7779 - val_loss: 0.6148 - val_root_mean_squared_error: 0.7761\n",
+ "Epoch 163/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6298 - root_mean_squared_error: 0.7860 - val_loss: 0.6183 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 164/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6436 - root_mean_squared_error: 0.7952 - val_loss: 0.6155 - val_root_mean_squared_error: 0.7760\n",
+ "Epoch 165/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6283 - root_mean_squared_error: 0.7854 - val_loss: 0.6547 - val_root_mean_squared_error: 0.8017\n",
+ "Epoch 166/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6247 - root_mean_squared_error: 0.7828 - val_loss: 0.6404 - val_root_mean_squared_error: 0.7929\n",
+ "Epoch 167/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6230 - root_mean_squared_error: 0.7816 - val_loss: 0.6111 - val_root_mean_squared_error: 0.7749\n",
+ "Epoch 168/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6295 - root_mean_squared_error: 0.7859 - val_loss: 0.5989 - val_root_mean_squared_error: 0.7648\n",
+ "Epoch 169/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6377 - root_mean_squared_error: 0.7912 - val_loss: 0.6127 - val_root_mean_squared_error: 0.7752\n",
+ "Epoch 170/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6264 - root_mean_squared_error: 0.7838 - val_loss: 0.6186 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 171/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6328 - root_mean_squared_error: 0.7877 - val_loss: 0.6280 - val_root_mean_squared_error: 0.7851\n",
+ "Epoch 172/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6366 - root_mean_squared_error: 0.7902 - val_loss: 0.6232 - val_root_mean_squared_error: 0.7813\n",
+ "Epoch 173/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6327 - root_mean_squared_error: 0.7879 - val_loss: 0.6155 - val_root_mean_squared_error: 0.7775\n",
+ "Epoch 174/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6185 - root_mean_squared_error: 0.7786 - val_loss: 0.6130 - val_root_mean_squared_error: 0.7745\n",
+ "Epoch 175/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6270 - root_mean_squared_error: 0.7842 - val_loss: 0.6335 - val_root_mean_squared_error: 0.7882\n",
+ "Epoch 176/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6190 - root_mean_squared_error: 0.7792 - val_loss: 0.6283 - val_root_mean_squared_error: 0.7849\n",
+ "Epoch 177/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6340 - root_mean_squared_error: 0.7886 - val_loss: 0.6016 - val_root_mean_squared_error: 0.7679\n",
+ "Epoch 178/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6209 - root_mean_squared_error: 0.7804 - val_loss: 0.6259 - val_root_mean_squared_error: 0.7840\n",
+ "Epoch 179/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6278 - root_mean_squared_error: 0.7848 - val_loss: 0.6519 - val_root_mean_squared_error: 0.8005\n",
+ "Epoch 180/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6182 - root_mean_squared_error: 0.7785 - val_loss: 0.6094 - val_root_mean_squared_error: 0.7732\n",
+ "Epoch 181/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6242 - root_mean_squared_error: 0.7823 - val_loss: 0.6422 - val_root_mean_squared_error: 0.7930\n",
+ "Epoch 182/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6099 - root_mean_squared_error: 0.7729 - val_loss: 0.6315 - val_root_mean_squared_error: 0.7876\n",
+ "Epoch 183/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6106 - root_mean_squared_error: 0.7734 - val_loss: 0.6259 - val_root_mean_squared_error: 0.7836\n",
+ "Epoch 184/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6246 - root_mean_squared_error: 0.7826 - val_loss: 0.6501 - val_root_mean_squared_error: 0.7982\n",
+ "Epoch 185/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6371 - root_mean_squared_error: 0.7906 - val_loss: 0.6247 - val_root_mean_squared_error: 0.7824\n",
+ "Epoch 186/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6139 - root_mean_squared_error: 0.7757 - val_loss: 0.6108 - val_root_mean_squared_error: 0.7729\n",
+ "Epoch 187/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6216 - root_mean_squared_error: 0.7811 - val_loss: 0.6034 - val_root_mean_squared_error: 0.7686\n",
+ "Epoch 188/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6278 - root_mean_squared_error: 0.7847 - val_loss: 0.6175 - val_root_mean_squared_error: 0.7775\n",
+ "Epoch 189/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6152 - root_mean_squared_error: 0.7765 - val_loss: 0.5986 - val_root_mean_squared_error: 0.7653\n",
+ "Epoch 190/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6149 - root_mean_squared_error: 0.7766 - val_loss: 0.5915 - val_root_mean_squared_error: 0.7611\n",
+ "Epoch 191/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6160 - root_mean_squared_error: 0.7772 - val_loss: 0.6220 - val_root_mean_squared_error: 0.7806\n",
+ "Epoch 192/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6178 - root_mean_squared_error: 0.7785 - val_loss: 0.6133 - val_root_mean_squared_error: 0.7755\n",
+ "Epoch 193/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6196 - root_mean_squared_error: 0.7797 - val_loss: 0.6121 - val_root_mean_squared_error: 0.7744\n",
+ "Epoch 194/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6260 - root_mean_squared_error: 0.7838 - val_loss: 0.6043 - val_root_mean_squared_error: 0.7690\n",
+ "Epoch 195/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6237 - root_mean_squared_error: 0.7818 - val_loss: 0.5896 - val_root_mean_squared_error: 0.7595\n",
+ "Epoch 196/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6129 - root_mean_squared_error: 0.7751 - val_loss: 0.6037 - val_root_mean_squared_error: 0.7684\n",
+ "Epoch 197/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6079 - root_mean_squared_error: 0.7717 - val_loss: 0.6243 - val_root_mean_squared_error: 0.7820\n",
+ "Epoch 198/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6228 - root_mean_squared_error: 0.7812 - val_loss: 0.6170 - val_root_mean_squared_error: 0.7778\n",
+ "Epoch 199/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6292 - root_mean_squared_error: 0.7851 - val_loss: 0.6019 - val_root_mean_squared_error: 0.7697\n",
+ "Epoch 200/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6254 - root_mean_squared_error: 0.7828 - val_loss: 0.6176 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 201/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6240 - root_mean_squared_error: 0.7822 - val_loss: 0.6444 - val_root_mean_squared_error: 0.7945\n",
+ "Epoch 202/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6249 - root_mean_squared_error: 0.7822 - val_loss: 0.6267 - val_root_mean_squared_error: 0.7844\n",
+ "Epoch 203/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6121 - root_mean_squared_error: 0.7745 - val_loss: 0.6211 - val_root_mean_squared_error: 0.7805\n",
+ "Epoch 204/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6132 - root_mean_squared_error: 0.7751 - val_loss: 0.6050 - val_root_mean_squared_error: 0.7699\n",
+ "Epoch 205/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6221 - root_mean_squared_error: 0.7808 - val_loss: 0.6202 - val_root_mean_squared_error: 0.7809\n",
+ "Epoch 206/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6202 - root_mean_squared_error: 0.7800 - val_loss: 0.6130 - val_root_mean_squared_error: 0.7758\n",
+ "Epoch 207/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6191 - root_mean_squared_error: 0.7789 - val_loss: 0.6030 - val_root_mean_squared_error: 0.7694\n",
+ "Epoch 208/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6086 - root_mean_squared_error: 0.7721 - val_loss: 0.5941 - val_root_mean_squared_error: 0.7631\n",
+ "Epoch 209/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6078 - root_mean_squared_error: 0.7716 - val_loss: 0.6019 - val_root_mean_squared_error: 0.7677\n",
+ "Epoch 210/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6178 - root_mean_squared_error: 0.7783 - val_loss: 0.6327 - val_root_mean_squared_error: 0.7879\n",
+ "Epoch 211/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6261 - root_mean_squared_error: 0.7831 - val_loss: 0.6458 - val_root_mean_squared_error: 0.7962\n",
+ "Epoch 212/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6392 - root_mean_squared_error: 0.7920 - val_loss: 0.6051 - val_root_mean_squared_error: 0.7698\n",
+ "Epoch 213/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6103 - root_mean_squared_error: 0.7730 - val_loss: 0.6241 - val_root_mean_squared_error: 0.7819\n",
+ "Epoch 214/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6146 - root_mean_squared_error: 0.7757 - val_loss: 0.6144 - val_root_mean_squared_error: 0.7754\n",
+ "Epoch 215/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6124 - root_mean_squared_error: 0.7744 - val_loss: 0.6328 - val_root_mean_squared_error: 0.7879\n",
+ "Epoch 216/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6089 - root_mean_squared_error: 0.7722 - val_loss: 0.6447 - val_root_mean_squared_error: 0.7950\n",
+ "Epoch 217/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6082 - root_mean_squared_error: 0.7719 - val_loss: 0.6186 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 218/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6033 - root_mean_squared_error: 0.7695 - val_loss: 0.6124 - val_root_mean_squared_error: 0.7747\n",
+ "Epoch 219/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6052 - root_mean_squared_error: 0.7700 - val_loss: 0.6248 - val_root_mean_squared_error: 0.7828\n",
+ "Epoch 220/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6232 - root_mean_squared_error: 0.7816 - val_loss: 0.6246 - val_root_mean_squared_error: 0.7817\n",
+ "Epoch 221/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6087 - root_mean_squared_error: 0.7720 - val_loss: 0.6211 - val_root_mean_squared_error: 0.7807\n",
+ "Epoch 222/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6237 - root_mean_squared_error: 0.7818 - val_loss: 0.6280 - val_root_mean_squared_error: 0.7837\n",
+ "Epoch 223/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6061 - root_mean_squared_error: 0.7704 - val_loss: 0.6298 - val_root_mean_squared_error: 0.7861\n",
+ "Epoch 224/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6324 - root_mean_squared_error: 0.7876 - val_loss: 0.6057 - val_root_mean_squared_error: 0.7697\n",
+ "Epoch 225/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6220 - root_mean_squared_error: 0.7806 - val_loss: 0.6157 - val_root_mean_squared_error: 0.7765\n",
+ "Epoch 226/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6224 - root_mean_squared_error: 0.7810 - val_loss: 0.6458 - val_root_mean_squared_error: 0.7961\n",
+ "Epoch 227/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6082 - root_mean_squared_error: 0.7717 - val_loss: 0.6249 - val_root_mean_squared_error: 0.7826\n",
+ "Epoch 228/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6186 - root_mean_squared_error: 0.7784 - val_loss: 0.6111 - val_root_mean_squared_error: 0.7736\n",
+ "Epoch 229/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6212 - root_mean_squared_error: 0.7800 - val_loss: 0.6161 - val_root_mean_squared_error: 0.7777\n",
+ "Epoch 230/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6158 - root_mean_squared_error: 0.7769 - val_loss: 0.6092 - val_root_mean_squared_error: 0.7715\n",
+ "Epoch 231/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6089 - root_mean_squared_error: 0.7723 - val_loss: 0.6109 - val_root_mean_squared_error: 0.7747\n",
+ "Epoch 232/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6198 - root_mean_squared_error: 0.7793 - val_loss: 0.5931 - val_root_mean_squared_error: 0.7625\n",
+ "Epoch 233/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6107 - root_mean_squared_error: 0.7733 - val_loss: 0.6446 - val_root_mean_squared_error: 0.7945\n",
+ "Epoch 234/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6248 - root_mean_squared_error: 0.7826 - val_loss: 0.5931 - val_root_mean_squared_error: 0.7622\n",
+ "Epoch 235/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6186 - root_mean_squared_error: 0.7781 - val_loss: 0.6535 - val_root_mean_squared_error: 0.8011\n",
+ "Epoch 236/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6246 - root_mean_squared_error: 0.7821 - val_loss: 0.5929 - val_root_mean_squared_error: 0.7621\n",
+ "Epoch 237/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6198 - root_mean_squared_error: 0.7790 - val_loss: 0.6115 - val_root_mean_squared_error: 0.7738\n",
+ "Epoch 238/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6149 - root_mean_squared_error: 0.7762 - val_loss: 0.6072 - val_root_mean_squared_error: 0.7718\n",
+ "Epoch 239/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6010 - root_mean_squared_error: 0.7670 - val_loss: 0.6032 - val_root_mean_squared_error: 0.7677\n",
+ "Epoch 240/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5993 - root_mean_squared_error: 0.7656 - val_loss: 0.5866 - val_root_mean_squared_error: 0.7581\n",
+ "Epoch 241/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6046 - root_mean_squared_error: 0.7694 - val_loss: 0.5988 - val_root_mean_squared_error: 0.7656\n",
+ "Epoch 242/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6241 - root_mean_squared_error: 0.7821 - val_loss: 0.6067 - val_root_mean_squared_error: 0.7705\n",
+ "Epoch 243/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6263 - root_mean_squared_error: 0.7831 - val_loss: 0.6044 - val_root_mean_squared_error: 0.7693\n",
+ "Epoch 244/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6069 - root_mean_squared_error: 0.7709 - val_loss: 0.5945 - val_root_mean_squared_error: 0.7621\n",
+ "Epoch 245/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6208 - root_mean_squared_error: 0.7797 - val_loss: 0.6179 - val_root_mean_squared_error: 0.7780\n",
+ "Epoch 246/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6215 - root_mean_squared_error: 0.7803 - val_loss: 0.6072 - val_root_mean_squared_error: 0.7719\n",
+ "Epoch 247/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6343 - root_mean_squared_error: 0.7884 - val_loss: 0.5996 - val_root_mean_squared_error: 0.7661\n",
+ "Epoch 248/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6119 - root_mean_squared_error: 0.7743 - val_loss: 0.6259 - val_root_mean_squared_error: 0.7828\n",
+ "Epoch 249/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6124 - root_mean_squared_error: 0.7742 - val_loss: 0.6367 - val_root_mean_squared_error: 0.7908\n",
+ "Epoch 250/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6144 - root_mean_squared_error: 0.7757 - val_loss: 0.6139 - val_root_mean_squared_error: 0.7741\n",
+ "Epoch 251/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6109 - root_mean_squared_error: 0.7735 - val_loss: 0.5904 - val_root_mean_squared_error: 0.7596\n",
+ "Epoch 252/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6128 - root_mean_squared_error: 0.7744 - val_loss: 0.6337 - val_root_mean_squared_error: 0.7876\n",
+ "Epoch 253/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6133 - root_mean_squared_error: 0.7745 - val_loss: 0.6500 - val_root_mean_squared_error: 0.7985\n",
+ "Epoch 254/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6157 - root_mean_squared_error: 0.7761 - val_loss: 0.5994 - val_root_mean_squared_error: 0.7666\n",
+ "Epoch 255/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5992 - root_mean_squared_error: 0.7656 - val_loss: 0.6389 - val_root_mean_squared_error: 0.7915\n",
+ "Epoch 256/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6231 - root_mean_squared_error: 0.7812 - val_loss: 0.5971 - val_root_mean_squared_error: 0.7637\n",
+ "Epoch 257/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6166 - root_mean_squared_error: 0.7768 - val_loss: 0.6054 - val_root_mean_squared_error: 0.7701\n",
+ "Epoch 258/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6035 - root_mean_squared_error: 0.7686 - val_loss: 0.5935 - val_root_mean_squared_error: 0.7617\n",
+ "Epoch 259/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6177 - root_mean_squared_error: 0.7776 - val_loss: 0.6155 - val_root_mean_squared_error: 0.7771\n",
+ "Epoch 260/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6233 - root_mean_squared_error: 0.7813 - val_loss: 0.6246 - val_root_mean_squared_error: 0.7826\n",
+ "Epoch 261/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6152 - root_mean_squared_error: 0.7759 - val_loss: 0.6074 - val_root_mean_squared_error: 0.7716\n",
+ "Epoch 262/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6083 - root_mean_squared_error: 0.7712 - val_loss: 0.6176 - val_root_mean_squared_error: 0.7770\n",
+ "Epoch 263/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6006 - root_mean_squared_error: 0.7667 - val_loss: 0.6158 - val_root_mean_squared_error: 0.7765\n",
+ "Epoch 264/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6229 - root_mean_squared_error: 0.7807 - val_loss: 0.6189 - val_root_mean_squared_error: 0.7792\n",
+ "Epoch 265/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6056 - root_mean_squared_error: 0.7695 - val_loss: 0.5977 - val_root_mean_squared_error: 0.7649\n",
+ "Epoch 266/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6105 - root_mean_squared_error: 0.7731 - val_loss: 0.6329 - val_root_mean_squared_error: 0.7876\n",
+ "Epoch 267/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6191 - root_mean_squared_error: 0.7783 - val_loss: 0.5993 - val_root_mean_squared_error: 0.7657\n",
+ "Epoch 268/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6237 - root_mean_squared_error: 0.7818 - val_loss: 0.5856 - val_root_mean_squared_error: 0.7562\n",
+ "Epoch 269/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6014 - root_mean_squared_error: 0.7671 - val_loss: 0.6008 - val_root_mean_squared_error: 0.7666\n",
+ "Epoch 270/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6040 - root_mean_squared_error: 0.7688 - val_loss: 0.6047 - val_root_mean_squared_error: 0.7692\n",
+ "Epoch 271/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5910 - root_mean_squared_error: 0.7604 - val_loss: 0.6058 - val_root_mean_squared_error: 0.7704\n",
+ "Epoch 272/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6049 - root_mean_squared_error: 0.7694 - val_loss: 0.6012 - val_root_mean_squared_error: 0.7669\n",
+ "Epoch 273/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6143 - root_mean_squared_error: 0.7750 - val_loss: 0.5990 - val_root_mean_squared_error: 0.7656\n",
+ "Epoch 274/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6143 - root_mean_squared_error: 0.7754 - val_loss: 0.6109 - val_root_mean_squared_error: 0.7733\n",
+ "Epoch 275/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6083 - root_mean_squared_error: 0.7712 - val_loss: 0.5930 - val_root_mean_squared_error: 0.7612\n",
+ "Epoch 276/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6161 - root_mean_squared_error: 0.7768 - val_loss: 0.6183 - val_root_mean_squared_error: 0.7772\n",
+ "Epoch 277/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6120 - root_mean_squared_error: 0.7740 - val_loss: 0.6157 - val_root_mean_squared_error: 0.7758\n",
+ "Epoch 278/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6034 - root_mean_squared_error: 0.7677 - val_loss: 0.6090 - val_root_mean_squared_error: 0.7715\n",
+ "Epoch 279/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6198 - root_mean_squared_error: 0.7789 - val_loss: 0.5872 - val_root_mean_squared_error: 0.7573\n",
+ "Epoch 280/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6089 - root_mean_squared_error: 0.7718 - val_loss: 0.6231 - val_root_mean_squared_error: 0.7812\n",
+ "Epoch 281/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6115 - root_mean_squared_error: 0.7738 - val_loss: 0.5920 - val_root_mean_squared_error: 0.7609\n",
+ "Epoch 282/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6164 - root_mean_squared_error: 0.7768 - val_loss: 0.6025 - val_root_mean_squared_error: 0.7675\n",
+ "Epoch 283/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6100 - root_mean_squared_error: 0.7725 - val_loss: 0.5931 - val_root_mean_squared_error: 0.7626\n",
+ "Epoch 284/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6061 - root_mean_squared_error: 0.7704 - val_loss: 0.6282 - val_root_mean_squared_error: 0.7841\n",
+ "Epoch 285/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6024 - root_mean_squared_error: 0.7679 - val_loss: 0.6013 - val_root_mean_squared_error: 0.7667\n",
+ "Epoch 286/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6118 - root_mean_squared_error: 0.7739 - val_loss: 0.6005 - val_root_mean_squared_error: 0.7660\n",
+ "Epoch 287/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6082 - root_mean_squared_error: 0.7717 - val_loss: 0.6110 - val_root_mean_squared_error: 0.7736\n",
+ "Epoch 288/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6039 - root_mean_squared_error: 0.7683 - val_loss: 0.6300 - val_root_mean_squared_error: 0.7855\n",
+ "Epoch 289/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6129 - root_mean_squared_error: 0.7743 - val_loss: 0.5945 - val_root_mean_squared_error: 0.7619\n",
+ "Epoch 290/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6082 - root_mean_squared_error: 0.7715 - val_loss: 0.6012 - val_root_mean_squared_error: 0.7677\n",
+ "Epoch 291/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6094 - root_mean_squared_error: 0.7727 - val_loss: 0.6037 - val_root_mean_squared_error: 0.7684\n",
+ "Epoch 292/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6069 - root_mean_squared_error: 0.7706 - val_loss: 0.6193 - val_root_mean_squared_error: 0.7790\n",
+ "Epoch 293/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6112 - root_mean_squared_error: 0.7734 - val_loss: 0.6064 - val_root_mean_squared_error: 0.7705\n",
+ "Epoch 294/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6106 - root_mean_squared_error: 0.7729 - val_loss: 0.6066 - val_root_mean_squared_error: 0.7698\n",
+ "Epoch 295/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6236 - root_mean_squared_error: 0.7814 - val_loss: 0.6156 - val_root_mean_squared_error: 0.7762\n",
+ "Epoch 296/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6217 - root_mean_squared_error: 0.7797 - val_loss: 0.6119 - val_root_mean_squared_error: 0.7736\n",
+ "Epoch 297/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6062 - root_mean_squared_error: 0.7703 - val_loss: 0.6054 - val_root_mean_squared_error: 0.7695\n",
+ "Epoch 298/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6107 - root_mean_squared_error: 0.7726 - val_loss: 0.6136 - val_root_mean_squared_error: 0.7749\n",
+ "Epoch 299/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6285 - root_mean_squared_error: 0.7844 - val_loss: 0.5835 - val_root_mean_squared_error: 0.7548\n",
+ "Epoch 300/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6031 - root_mean_squared_error: 0.7679 - val_loss: 0.5896 - val_root_mean_squared_error: 0.7594\n",
+ "Epoch 301/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6076 - root_mean_squared_error: 0.7706 - val_loss: 0.5964 - val_root_mean_squared_error: 0.7630\n",
+ "Epoch 302/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6160 - root_mean_squared_error: 0.7759 - val_loss: 0.6156 - val_root_mean_squared_error: 0.7761\n",
+ "Epoch 303/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6089 - root_mean_squared_error: 0.7720 - val_loss: 0.6008 - val_root_mean_squared_error: 0.7668\n",
+ "Epoch 304/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6153 - root_mean_squared_error: 0.7758 - val_loss: 0.5969 - val_root_mean_squared_error: 0.7650\n",
+ "Epoch 305/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5977 - root_mean_squared_error: 0.7644 - val_loss: 0.6282 - val_root_mean_squared_error: 0.7846\n",
+ "Epoch 306/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6074 - root_mean_squared_error: 0.7711 - val_loss: 0.6018 - val_root_mean_squared_error: 0.7670\n",
+ "Epoch 307/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6073 - root_mean_squared_error: 0.7705 - val_loss: 0.6219 - val_root_mean_squared_error: 0.7796\n",
+ "Epoch 308/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6004 - root_mean_squared_error: 0.7663 - val_loss: 0.6140 - val_root_mean_squared_error: 0.7741\n",
+ "Epoch 309/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6199 - root_mean_squared_error: 0.7787 - val_loss: 0.6346 - val_root_mean_squared_error: 0.7885\n",
+ "Epoch 310/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6157 - root_mean_squared_error: 0.7759 - val_loss: 0.6078 - val_root_mean_squared_error: 0.7716\n",
+ "Epoch 311/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6085 - root_mean_squared_error: 0.7714 - val_loss: 0.6082 - val_root_mean_squared_error: 0.7723\n",
+ "Epoch 312/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5999 - root_mean_squared_error: 0.7659 - val_loss: 0.5895 - val_root_mean_squared_error: 0.7595\n",
+ "Epoch 313/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6055 - root_mean_squared_error: 0.7693 - val_loss: 0.5959 - val_root_mean_squared_error: 0.7625\n",
+ "Epoch 314/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6133 - root_mean_squared_error: 0.7742 - val_loss: 0.5851 - val_root_mean_squared_error: 0.7560\n",
+ "Epoch 315/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6058 - root_mean_squared_error: 0.7695 - val_loss: 0.6100 - val_root_mean_squared_error: 0.7724\n",
+ "Epoch 316/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6029 - root_mean_squared_error: 0.7674 - val_loss: 0.6042 - val_root_mean_squared_error: 0.7686\n",
+ "Epoch 317/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5990 - root_mean_squared_error: 0.7655 - val_loss: 0.6118 - val_root_mean_squared_error: 0.7737\n",
+ "Epoch 318/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6078 - root_mean_squared_error: 0.7712 - val_loss: 0.6200 - val_root_mean_squared_error: 0.7786\n",
+ "Epoch 319/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6117 - root_mean_squared_error: 0.7734 - val_loss: 0.6076 - val_root_mean_squared_error: 0.7710\n",
+ "Epoch 320/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6160 - root_mean_squared_error: 0.7766 - val_loss: 0.6059 - val_root_mean_squared_error: 0.7701\n",
+ "Epoch 321/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6045 - root_mean_squared_error: 0.7688 - val_loss: 0.6065 - val_root_mean_squared_error: 0.7702\n",
+ "Epoch 322/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6198 - root_mean_squared_error: 0.7783 - val_loss: 0.5969 - val_root_mean_squared_error: 0.7634\n",
+ "Epoch 323/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6069 - root_mean_squared_error: 0.7704 - val_loss: 0.6192 - val_root_mean_squared_error: 0.7783\n",
+ "Epoch 324/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5978 - root_mean_squared_error: 0.7643 - val_loss: 0.6034 - val_root_mean_squared_error: 0.7678\n",
+ "Epoch 325/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6080 - root_mean_squared_error: 0.7709 - val_loss: 0.5874 - val_root_mean_squared_error: 0.7577\n",
+ "Epoch 326/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6072 - root_mean_squared_error: 0.7706 - val_loss: 0.5869 - val_root_mean_squared_error: 0.7571\n",
+ "Epoch 327/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6022 - root_mean_squared_error: 0.7669 - val_loss: 0.6110 - val_root_mean_squared_error: 0.7720\n",
+ "Epoch 328/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6127 - root_mean_squared_error: 0.7742 - val_loss: 0.6033 - val_root_mean_squared_error: 0.7678\n",
+ "Epoch 329/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6200 - root_mean_squared_error: 0.7784 - val_loss: 0.5943 - val_root_mean_squared_error: 0.7618\n",
+ "Epoch 330/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6117 - root_mean_squared_error: 0.7737 - val_loss: 0.6379 - val_root_mean_squared_error: 0.7900\n",
+ "Epoch 331/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6095 - root_mean_squared_error: 0.7721 - val_loss: 0.6168 - val_root_mean_squared_error: 0.7773\n",
+ "Epoch 332/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6127 - root_mean_squared_error: 0.7739 - val_loss: 0.6001 - val_root_mean_squared_error: 0.7661\n",
+ "Epoch 333/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6002 - root_mean_squared_error: 0.7659 - val_loss: 0.6029 - val_root_mean_squared_error: 0.7674\n",
+ "Epoch 334/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6075 - root_mean_squared_error: 0.7709 - val_loss: 0.6149 - val_root_mean_squared_error: 0.7754\n",
+ "Epoch 335/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6043 - root_mean_squared_error: 0.7688 - val_loss: 0.5903 - val_root_mean_squared_error: 0.7601\n",
+ "Epoch 336/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6089 - root_mean_squared_error: 0.7715 - val_loss: 0.6202 - val_root_mean_squared_error: 0.7793\n",
+ "Epoch 337/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5981 - root_mean_squared_error: 0.7646 - val_loss: 0.6002 - val_root_mean_squared_error: 0.7663\n",
+ "Epoch 338/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6008 - root_mean_squared_error: 0.7664 - val_loss: 0.6187 - val_root_mean_squared_error: 0.7775\n",
+ "Epoch 339/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6238 - root_mean_squared_error: 0.7814 - val_loss: 0.6011 - val_root_mean_squared_error: 0.7666\n",
+ "Epoch 340/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5990 - root_mean_squared_error: 0.7648 - val_loss: 0.6086 - val_root_mean_squared_error: 0.7714\n",
+ "Epoch 341/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6147 - root_mean_squared_error: 0.7752 - val_loss: 0.6017 - val_root_mean_squared_error: 0.7666\n",
+ "Epoch 342/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6031 - root_mean_squared_error: 0.7676 - val_loss: 0.6086 - val_root_mean_squared_error: 0.7711\n",
+ "Epoch 343/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6010 - root_mean_squared_error: 0.7666 - val_loss: 0.6205 - val_root_mean_squared_error: 0.7786\n",
+ "Epoch 344/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6039 - root_mean_squared_error: 0.7679 - val_loss: 0.5987 - val_root_mean_squared_error: 0.7644\n",
+ "Epoch 345/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5976 - root_mean_squared_error: 0.7636 - val_loss: 0.5957 - val_root_mean_squared_error: 0.7637\n",
+ "Epoch 346/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6030 - root_mean_squared_error: 0.7676 - val_loss: 0.5989 - val_root_mean_squared_error: 0.7650\n",
+ "Epoch 347/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6088 - root_mean_squared_error: 0.7714 - val_loss: 0.6070 - val_root_mean_squared_error: 0.7706\n",
+ "Epoch 348/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6051 - root_mean_squared_error: 0.7691 - val_loss: 0.5846 - val_root_mean_squared_error: 0.7550\n",
+ "Epoch 349/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6131 - root_mean_squared_error: 0.7740 - val_loss: 0.5942 - val_root_mean_squared_error: 0.7615\n",
+ "Epoch 350/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6026 - root_mean_squared_error: 0.7671 - val_loss: 0.5993 - val_root_mean_squared_error: 0.7650\n",
+ "Epoch 351/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6118 - root_mean_squared_error: 0.7730 - val_loss: 0.6113 - val_root_mean_squared_error: 0.7734\n",
+ "Epoch 352/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6004 - root_mean_squared_error: 0.7660 - val_loss: 0.5842 - val_root_mean_squared_error: 0.7547\n",
+ "Epoch 353/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6104 - root_mean_squared_error: 0.7724 - val_loss: 0.6276 - val_root_mean_squared_error: 0.7830\n",
+ "Epoch 354/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6054 - root_mean_squared_error: 0.7690 - val_loss: 0.5951 - val_root_mean_squared_error: 0.7625\n",
+ "Epoch 355/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6132 - root_mean_squared_error: 0.7743 - val_loss: 0.6059 - val_root_mean_squared_error: 0.7701\n",
+ "Epoch 356/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6159 - root_mean_squared_error: 0.7754 - val_loss: 0.6036 - val_root_mean_squared_error: 0.7682\n",
+ "Epoch 357/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6068 - root_mean_squared_error: 0.7700 - val_loss: 0.5966 - val_root_mean_squared_error: 0.7636\n",
+ "Epoch 358/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6055 - root_mean_squared_error: 0.7691 - val_loss: 0.5908 - val_root_mean_squared_error: 0.7604\n",
+ "Epoch 359/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5985 - root_mean_squared_error: 0.7644 - val_loss: 0.6057 - val_root_mean_squared_error: 0.7694\n",
+ "Epoch 360/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6061 - root_mean_squared_error: 0.7700 - val_loss: 0.6253 - val_root_mean_squared_error: 0.7820\n",
+ "Epoch 361/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6107 - root_mean_squared_error: 0.7727 - val_loss: 0.5946 - val_root_mean_squared_error: 0.7620\n",
+ "Epoch 362/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5993 - root_mean_squared_error: 0.7653 - val_loss: 0.6020 - val_root_mean_squared_error: 0.7676\n",
+ "Epoch 363/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6092 - root_mean_squared_error: 0.7716 - val_loss: 0.6007 - val_root_mean_squared_error: 0.7660\n",
+ "Epoch 364/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6093 - root_mean_squared_error: 0.7717 - val_loss: 0.6002 - val_root_mean_squared_error: 0.7665\n",
+ "Epoch 365/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6039 - root_mean_squared_error: 0.7682 - val_loss: 0.5976 - val_root_mean_squared_error: 0.7644\n",
+ "Epoch 366/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6158 - root_mean_squared_error: 0.7763 - val_loss: 0.6506 - val_root_mean_squared_error: 0.7976\n",
+ "Epoch 367/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6181 - root_mean_squared_error: 0.7770 - val_loss: 0.6022 - val_root_mean_squared_error: 0.7673\n",
+ "Epoch 368/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6177 - root_mean_squared_error: 0.7769 - val_loss: 0.6054 - val_root_mean_squared_error: 0.7691\n",
+ "Epoch 369/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5951 - root_mean_squared_error: 0.7622 - val_loss: 0.6127 - val_root_mean_squared_error: 0.7750\n",
+ "Epoch 370/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5987 - root_mean_squared_error: 0.7648 - val_loss: 0.6192 - val_root_mean_squared_error: 0.7778\n",
+ "Epoch 371/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6058 - root_mean_squared_error: 0.7692 - val_loss: 0.5930 - val_root_mean_squared_error: 0.7609\n",
+ "Epoch 372/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6061 - root_mean_squared_error: 0.7698 - val_loss: 0.6082 - val_root_mean_squared_error: 0.7705\n",
+ "Epoch 373/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6153 - root_mean_squared_error: 0.7759 - val_loss: 0.5898 - val_root_mean_squared_error: 0.7594\n",
+ "Epoch 374/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6041 - root_mean_squared_error: 0.7682 - val_loss: 0.6071 - val_root_mean_squared_error: 0.7700\n",
+ "Epoch 375/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6064 - root_mean_squared_error: 0.7699 - val_loss: 0.5995 - val_root_mean_squared_error: 0.7658\n",
+ "Epoch 376/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5993 - root_mean_squared_error: 0.7657 - val_loss: 0.6180 - val_root_mean_squared_error: 0.7769\n",
+ "Epoch 377/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6081 - root_mean_squared_error: 0.7712 - val_loss: 0.6074 - val_root_mean_squared_error: 0.7714\n",
+ "Epoch 378/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6125 - root_mean_squared_error: 0.7734 - val_loss: 0.6092 - val_root_mean_squared_error: 0.7713\n",
+ "Epoch 379/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6073 - root_mean_squared_error: 0.7707 - val_loss: 0.5841 - val_root_mean_squared_error: 0.7553\n",
+ "Epoch 380/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6095 - root_mean_squared_error: 0.7718 - val_loss: 0.5785 - val_root_mean_squared_error: 0.7510\n",
+ "Epoch 381/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6058 - root_mean_squared_error: 0.7694 - val_loss: 0.6216 - val_root_mean_squared_error: 0.7797\n",
+ "Epoch 382/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6057 - root_mean_squared_error: 0.7692 - val_loss: 0.6089 - val_root_mean_squared_error: 0.7717\n",
+ "Epoch 383/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6095 - root_mean_squared_error: 0.7720 - val_loss: 0.6071 - val_root_mean_squared_error: 0.7698\n",
+ "Epoch 384/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5963 - root_mean_squared_error: 0.7630 - val_loss: 0.6205 - val_root_mean_squared_error: 0.7784\n",
+ "Epoch 385/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5917 - root_mean_squared_error: 0.7601 - val_loss: 0.6022 - val_root_mean_squared_error: 0.7669\n",
+ "Epoch 386/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6215 - root_mean_squared_error: 0.7796 - val_loss: 0.6245 - val_root_mean_squared_error: 0.7818\n",
+ "Epoch 387/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6043 - root_mean_squared_error: 0.7681 - val_loss: 0.5981 - val_root_mean_squared_error: 0.7641\n",
+ "Epoch 388/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5974 - root_mean_squared_error: 0.7640 - val_loss: 0.6051 - val_root_mean_squared_error: 0.7683\n",
+ "Epoch 389/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6012 - root_mean_squared_error: 0.7664 - val_loss: 0.5977 - val_root_mean_squared_error: 0.7636\n",
+ "Epoch 390/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6030 - root_mean_squared_error: 0.7675 - val_loss: 0.5977 - val_root_mean_squared_error: 0.7643\n",
+ "Epoch 391/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5993 - root_mean_squared_error: 0.7648 - val_loss: 0.6225 - val_root_mean_squared_error: 0.7802\n",
+ "Epoch 392/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6086 - root_mean_squared_error: 0.7712 - val_loss: 0.5826 - val_root_mean_squared_error: 0.7543\n",
+ "Epoch 393/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6071 - root_mean_squared_error: 0.7698 - val_loss: 0.6022 - val_root_mean_squared_error: 0.7659\n",
+ "Epoch 394/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6076 - root_mean_squared_error: 0.7703 - val_loss: 0.5958 - val_root_mean_squared_error: 0.7626\n",
+ "Epoch 395/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6064 - root_mean_squared_error: 0.7693 - val_loss: 0.5982 - val_root_mean_squared_error: 0.7639\n",
+ "Epoch 396/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6185 - root_mean_squared_error: 0.7774 - val_loss: 0.6004 - val_root_mean_squared_error: 0.7668\n",
+ "Epoch 397/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6048 - root_mean_squared_error: 0.7685 - val_loss: 0.6336 - val_root_mean_squared_error: 0.7870\n",
+ "Epoch 398/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6013 - root_mean_squared_error: 0.7661 - val_loss: 0.6033 - val_root_mean_squared_error: 0.7672\n",
+ "Epoch 399/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6050 - root_mean_squared_error: 0.7685 - val_loss: 0.6296 - val_root_mean_squared_error: 0.7844\n",
+ "Epoch 400/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5957 - root_mean_squared_error: 0.7625 - val_loss: 0.6341 - val_root_mean_squared_error: 0.7886\n",
+ "Epoch 401/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5985 - root_mean_squared_error: 0.7650 - val_loss: 0.6014 - val_root_mean_squared_error: 0.7660\n",
+ "Epoch 402/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6039 - root_mean_squared_error: 0.7679 - val_loss: 0.6088 - val_root_mean_squared_error: 0.7715\n",
+ "Epoch 403/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5972 - root_mean_squared_error: 0.7640 - val_loss: 0.5884 - val_root_mean_squared_error: 0.7585\n",
+ "Epoch 404/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6047 - root_mean_squared_error: 0.7687 - val_loss: 0.6100 - val_root_mean_squared_error: 0.7721\n",
+ "Epoch 405/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5990 - root_mean_squared_error: 0.7643 - val_loss: 0.5989 - val_root_mean_squared_error: 0.7641\n",
+ "Epoch 406/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6114 - root_mean_squared_error: 0.7726 - val_loss: 0.6069 - val_root_mean_squared_error: 0.7700\n",
+ "Epoch 407/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6080 - root_mean_squared_error: 0.7706 - val_loss: 0.5884 - val_root_mean_squared_error: 0.7591\n",
+ "Epoch 408/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6026 - root_mean_squared_error: 0.7672 - val_loss: 0.6055 - val_root_mean_squared_error: 0.7695\n",
+ "Epoch 409/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6074 - root_mean_squared_error: 0.7704 - val_loss: 0.5968 - val_root_mean_squared_error: 0.7628\n",
+ "Epoch 410/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6088 - root_mean_squared_error: 0.7711 - val_loss: 0.5814 - val_root_mean_squared_error: 0.7523\n",
+ "Epoch 411/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6117 - root_mean_squared_error: 0.7729 - val_loss: 0.6238 - val_root_mean_squared_error: 0.7797\n",
+ "Epoch 412/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5967 - root_mean_squared_error: 0.7634 - val_loss: 0.5913 - val_root_mean_squared_error: 0.7592\n",
+ "Epoch 413/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6112 - root_mean_squared_error: 0.7727 - val_loss: 0.6035 - val_root_mean_squared_error: 0.7666\n",
+ "Epoch 414/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6071 - root_mean_squared_error: 0.7699 - val_loss: 0.6227 - val_root_mean_squared_error: 0.7797\n",
+ "Epoch 415/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6091 - root_mean_squared_error: 0.7713 - val_loss: 0.6041 - val_root_mean_squared_error: 0.7675\n",
+ "Epoch 416/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6055 - root_mean_squared_error: 0.7691 - val_loss: 0.6089 - val_root_mean_squared_error: 0.7711\n",
+ "Epoch 417/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6058 - root_mean_squared_error: 0.7696 - val_loss: 0.5916 - val_root_mean_squared_error: 0.7597\n",
+ "Epoch 418/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5928 - root_mean_squared_error: 0.7607 - val_loss: 0.5833 - val_root_mean_squared_error: 0.7550\n",
+ "Epoch 419/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5965 - root_mean_squared_error: 0.7631 - val_loss: 0.5861 - val_root_mean_squared_error: 0.7550\n",
+ "Epoch 420/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6066 - root_mean_squared_error: 0.7694 - val_loss: 0.6149 - val_root_mean_squared_error: 0.7755\n",
+ "Epoch 421/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6052 - root_mean_squared_error: 0.7688 - val_loss: 0.5987 - val_root_mean_squared_error: 0.7641\n",
+ "Epoch 422/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5982 - root_mean_squared_error: 0.7644 - val_loss: 0.6369 - val_root_mean_squared_error: 0.7893\n",
+ "Epoch 423/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5907 - root_mean_squared_error: 0.7595 - val_loss: 0.6039 - val_root_mean_squared_error: 0.7683\n",
+ "Epoch 424/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6018 - root_mean_squared_error: 0.7665 - val_loss: 0.5959 - val_root_mean_squared_error: 0.7624\n",
+ "Epoch 425/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5964 - root_mean_squared_error: 0.7633 - val_loss: 0.6098 - val_root_mean_squared_error: 0.7711\n",
+ "Epoch 426/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6091 - root_mean_squared_error: 0.7710 - val_loss: 0.6124 - val_root_mean_squared_error: 0.7725\n",
+ "Epoch 427/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6032 - root_mean_squared_error: 0.7674 - val_loss: 0.5915 - val_root_mean_squared_error: 0.7598\n",
+ "Epoch 428/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6047 - root_mean_squared_error: 0.7687 - val_loss: 0.6030 - val_root_mean_squared_error: 0.7674\n",
+ "Epoch 429/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6013 - root_mean_squared_error: 0.7662 - val_loss: 0.6091 - val_root_mean_squared_error: 0.7720\n",
+ "Epoch 430/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5925 - root_mean_squared_error: 0.7605 - val_loss: 0.6025 - val_root_mean_squared_error: 0.7659\n",
+ "Epoch 431/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6014 - root_mean_squared_error: 0.7659 - val_loss: 0.5879 - val_root_mean_squared_error: 0.7565\n",
+ "Epoch 432/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6101 - root_mean_squared_error: 0.7717 - val_loss: 0.5789 - val_root_mean_squared_error: 0.7512\n",
+ "Epoch 433/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6000 - root_mean_squared_error: 0.7650 - val_loss: 0.5961 - val_root_mean_squared_error: 0.7633\n",
+ "Epoch 434/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6015 - root_mean_squared_error: 0.7661 - val_loss: 0.6059 - val_root_mean_squared_error: 0.7692\n",
+ "Epoch 435/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6022 - root_mean_squared_error: 0.7662 - val_loss: 0.5894 - val_root_mean_squared_error: 0.7587\n",
+ "Epoch 436/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6009 - root_mean_squared_error: 0.7656 - val_loss: 0.5948 - val_root_mean_squared_error: 0.7614\n",
+ "Epoch 437/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5943 - root_mean_squared_error: 0.7614 - val_loss: 0.5980 - val_root_mean_squared_error: 0.7645\n",
+ "Epoch 438/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5984 - root_mean_squared_error: 0.7639 - val_loss: 0.5967 - val_root_mean_squared_error: 0.7637\n",
+ "Epoch 439/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5943 - root_mean_squared_error: 0.7614 - val_loss: 0.5959 - val_root_mean_squared_error: 0.7633\n",
+ "Epoch 440/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5969 - root_mean_squared_error: 0.7632 - val_loss: 0.6065 - val_root_mean_squared_error: 0.7694\n",
+ "Epoch 441/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6065 - root_mean_squared_error: 0.7694 - val_loss: 0.6003 - val_root_mean_squared_error: 0.7650\n",
+ "Epoch 442/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5988 - root_mean_squared_error: 0.7644 - val_loss: 0.6035 - val_root_mean_squared_error: 0.7681\n",
+ "Epoch 443/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5955 - root_mean_squared_error: 0.7620 - val_loss: 0.6097 - val_root_mean_squared_error: 0.7711\n",
+ "Epoch 444/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6046 - root_mean_squared_error: 0.7685 - val_loss: 0.6135 - val_root_mean_squared_error: 0.7727\n",
+ "Epoch 445/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5960 - root_mean_squared_error: 0.7630 - val_loss: 0.6084 - val_root_mean_squared_error: 0.7705\n",
+ "Epoch 446/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6062 - root_mean_squared_error: 0.7692 - val_loss: 0.5952 - val_root_mean_squared_error: 0.7622\n",
+ "Epoch 447/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6018 - root_mean_squared_error: 0.7665 - val_loss: 0.6144 - val_root_mean_squared_error: 0.7740\n",
+ "Epoch 448/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6192 - root_mean_squared_error: 0.7776 - val_loss: 0.6194 - val_root_mean_squared_error: 0.7785\n",
+ "Epoch 449/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6018 - root_mean_squared_error: 0.7664 - val_loss: 0.5825 - val_root_mean_squared_error: 0.7534\n",
+ "Epoch 450/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6003 - root_mean_squared_error: 0.7653 - val_loss: 0.5851 - val_root_mean_squared_error: 0.7553\n",
+ "Epoch 451/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6002 - root_mean_squared_error: 0.7653 - val_loss: 0.5984 - val_root_mean_squared_error: 0.7645\n",
+ "Epoch 452/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6059 - root_mean_squared_error: 0.7695 - val_loss: 0.5861 - val_root_mean_squared_error: 0.7558\n",
+ "Epoch 453/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6108 - root_mean_squared_error: 0.7723 - val_loss: 0.6044 - val_root_mean_squared_error: 0.7689\n",
+ "Epoch 454/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6039 - root_mean_squared_error: 0.7678 - val_loss: 0.5888 - val_root_mean_squared_error: 0.7588\n",
+ "Epoch 455/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5928 - root_mean_squared_error: 0.7602 - val_loss: 0.6128 - val_root_mean_squared_error: 0.7732\n",
+ "Epoch 456/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6099 - root_mean_squared_error: 0.7718 - val_loss: 0.5932 - val_root_mean_squared_error: 0.7604\n",
+ "Epoch 457/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6058 - root_mean_squared_error: 0.7687 - val_loss: 0.6141 - val_root_mean_squared_error: 0.7742\n",
+ "Epoch 458/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5931 - root_mean_squared_error: 0.7608 - val_loss: 0.6086 - val_root_mean_squared_error: 0.7698\n",
+ "Epoch 459/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6062 - root_mean_squared_error: 0.7694 - val_loss: 0.5917 - val_root_mean_squared_error: 0.7596\n",
+ "Epoch 460/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5960 - root_mean_squared_error: 0.7627 - val_loss: 0.5878 - val_root_mean_squared_error: 0.7570\n",
+ "Epoch 461/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5941 - root_mean_squared_error: 0.7613 - val_loss: 0.6085 - val_root_mean_squared_error: 0.7707\n",
+ "Epoch 462/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6018 - root_mean_squared_error: 0.7663 - val_loss: 0.5911 - val_root_mean_squared_error: 0.7597\n",
+ "Epoch 463/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6093 - root_mean_squared_error: 0.7713 - val_loss: 0.6088 - val_root_mean_squared_error: 0.7712\n",
+ "Epoch 464/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5958 - root_mean_squared_error: 0.7621 - val_loss: 0.5931 - val_root_mean_squared_error: 0.7614\n",
+ "Epoch 465/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5933 - root_mean_squared_error: 0.7609 - val_loss: 0.6055 - val_root_mean_squared_error: 0.7695\n",
+ "Epoch 466/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6021 - root_mean_squared_error: 0.7662 - val_loss: 0.5812 - val_root_mean_squared_error: 0.7527\n",
+ "Epoch 467/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6056 - root_mean_squared_error: 0.7687 - val_loss: 0.5885 - val_root_mean_squared_error: 0.7578\n",
+ "Epoch 468/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5996 - root_mean_squared_error: 0.7652 - val_loss: 0.5939 - val_root_mean_squared_error: 0.7610\n",
+ "Epoch 469/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6086 - root_mean_squared_error: 0.7706 - val_loss: 0.5928 - val_root_mean_squared_error: 0.7599\n",
+ "Epoch 470/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6121 - root_mean_squared_error: 0.7731 - val_loss: 0.6056 - val_root_mean_squared_error: 0.7706\n",
+ "Epoch 471/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6000 - root_mean_squared_error: 0.7654 - val_loss: 0.6039 - val_root_mean_squared_error: 0.7694\n",
+ "Epoch 472/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6000 - root_mean_squared_error: 0.7654 - val_loss: 0.5965 - val_root_mean_squared_error: 0.7637\n",
+ "Epoch 473/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5985 - root_mean_squared_error: 0.7641 - val_loss: 0.5940 - val_root_mean_squared_error: 0.7618\n",
+ "Epoch 474/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5947 - root_mean_squared_error: 0.7623 - val_loss: 0.6021 - val_root_mean_squared_error: 0.7674\n",
+ "Epoch 475/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6104 - root_mean_squared_error: 0.7719 - val_loss: 0.5842 - val_root_mean_squared_error: 0.7558\n",
+ "Epoch 476/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6012 - root_mean_squared_error: 0.7661 - val_loss: 0.5945 - val_root_mean_squared_error: 0.7606\n",
+ "Epoch 477/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5993 - root_mean_squared_error: 0.7644 - val_loss: 0.5845 - val_root_mean_squared_error: 0.7549\n",
+ "Epoch 478/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6030 - root_mean_squared_error: 0.7674 - val_loss: 0.5942 - val_root_mean_squared_error: 0.7604\n",
+ "Epoch 479/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5937 - root_mean_squared_error: 0.7611 - val_loss: 0.6035 - val_root_mean_squared_error: 0.7676\n",
+ "Epoch 480/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5932 - root_mean_squared_error: 0.7605 - val_loss: 0.6074 - val_root_mean_squared_error: 0.7708\n",
+ "Epoch 481/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6053 - root_mean_squared_error: 0.7682 - val_loss: 0.5996 - val_root_mean_squared_error: 0.7654\n",
+ "Epoch 482/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5897 - root_mean_squared_error: 0.7586 - val_loss: 0.6033 - val_root_mean_squared_error: 0.7671\n",
+ "Epoch 483/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6057 - root_mean_squared_error: 0.7688 - val_loss: 0.5989 - val_root_mean_squared_error: 0.7643\n",
+ "Epoch 484/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5934 - root_mean_squared_error: 0.7611 - val_loss: 0.5921 - val_root_mean_squared_error: 0.7605\n",
+ "Epoch 485/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.6002 - root_mean_squared_error: 0.7653 - val_loss: 0.5965 - val_root_mean_squared_error: 0.7625\n",
+ "Epoch 486/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5941 - root_mean_squared_error: 0.7612 - val_loss: 0.5825 - val_root_mean_squared_error: 0.7541\n",
+ "Epoch 487/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6036 - root_mean_squared_error: 0.7678 - val_loss: 0.5812 - val_root_mean_squared_error: 0.7527\n",
+ "Epoch 488/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5981 - root_mean_squared_error: 0.7642 - val_loss: 0.6232 - val_root_mean_squared_error: 0.7803\n",
+ "Epoch 489/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5991 - root_mean_squared_error: 0.7643 - val_loss: 0.6011 - val_root_mean_squared_error: 0.7665\n",
+ "Epoch 490/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5951 - root_mean_squared_error: 0.7620 - val_loss: 0.6077 - val_root_mean_squared_error: 0.7692\n",
+ "Epoch 491/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5976 - root_mean_squared_error: 0.7636 - val_loss: 0.5999 - val_root_mean_squared_error: 0.7646\n",
+ "Epoch 492/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6045 - root_mean_squared_error: 0.7682 - val_loss: 0.6030 - val_root_mean_squared_error: 0.7673\n",
+ "Epoch 493/500\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 0.5950 - root_mean_squared_error: 0.7614 - val_loss: 0.5833 - val_root_mean_squared_error: 0.7542\n",
+ "Epoch 494/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5940 - root_mean_squared_error: 0.7611 - val_loss: 0.5883 - val_root_mean_squared_error: 0.7570\n",
+ "Epoch 495/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6024 - root_mean_squared_error: 0.7666 - val_loss: 0.5930 - val_root_mean_squared_error: 0.7608\n",
+ "Epoch 496/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6024 - root_mean_squared_error: 0.7666 - val_loss: 0.5829 - val_root_mean_squared_error: 0.7534\n",
+ "Epoch 497/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6062 - root_mean_squared_error: 0.7695 - val_loss: 0.5980 - val_root_mean_squared_error: 0.7637\n",
+ "Epoch 498/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6116 - root_mean_squared_error: 0.7725 - val_loss: 0.5880 - val_root_mean_squared_error: 0.7570\n",
+ "Epoch 499/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.6067 - root_mean_squared_error: 0.7692 - val_loss: 0.6026 - val_root_mean_squared_error: 0.7668\n",
+ "Epoch 500/500\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 0.5948 - root_mean_squared_error: 0.7613 - val_loss: 0.5912 - val_root_mean_squared_error: 0.7592\n",
+ "Model training finished.\n",
+ "Train RMSE: 0.768\n",
+ "Evaluating model performance...\n",
+ "Test RMSE: 0.753\n",
+ "Predictions mean: 5.72, min: 5.15, max: 6.12, range: 0.97 - Actual: 6.0\n",
+ "Predictions mean: 6.18, min: 5.93, max: 6.37, range: 0.44 - Actual: 7.0\n",
+ "Predictions mean: 6.02, min: 5.7, max: 6.21, range: 0.51 - Actual: 7.0\n",
+ "Predictions mean: 6.52, min: 6.32, max: 6.61, range: 0.29 - Actual: 6.0\n",
+ "Predictions mean: 6.37, min: 6.15, max: 6.53, range: 0.39 - Actual: 5.0\n",
+ "Predictions mean: 6.42, min: 6.21, max: 6.56, range: 0.35 - Actual: 7.0\n",
+ "Predictions mean: 5.89, min: 5.55, max: 6.18, range: 0.62 - Actual: 6.0\n",
+ "Predictions mean: 5.77, min: 5.37, max: 6.12, range: 0.74 - Actual: 6.0\n",
+ "Predictions mean: 6.58, min: 6.43, max: 6.64, range: 0.21 - Actual: 8.0\n",
+ "Predictions mean: 5.52, min: 5.09, max: 5.82, range: 0.72 - Actual: 6.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "num_epochs = 500\n",
+ "bnn_model_full = create_bnn_model(train_size)\n",
+ "run_experiment(bnn_model_full, mse_loss, train_dataset, test_dataset)\n",
+ "\n",
+ "compute_predictions(bnn_model_full)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Zd0ET93XJZX-"
+ },
+ "source": [
+ "Notice that the model trained with the full training dataset shows smaller range\n",
+ "(uncertainty) in the prediction values for the same inputs, compared to the model\n",
+ "trained with a subset of the training dataset."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2b2sbxYRJZX-"
+ },
+ "source": [
+ "## Experiment 3: probabilistic Bayesian neural network\n",
+ "\n",
+ "So far, the output of the standard and the Bayesian NN models that we built is\n",
+ "deterministic, that is, produces a point estimate as a prediction for a given example.\n",
+ "We can create a probabilistic NN by letting the model output a distribution.\n",
+ "In this case, the model captures the *aleatoric uncertainty* as well,\n",
+ "which is due to irreducible noise in the data, or to the stochastic nature of the\n",
+ "process generating the data.\n",
+ "\n",
+ "In this example, we model the output as a `IndependentNormal` distribution,\n",
+ "with learnable mean and variance parameters. If the task was classification,\n",
+ "we would have used `IndependentBernoulli` with binary classes, and `OneHotCategorical`\n",
+ "with multiple classes, to model distribution of the model output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "id": "9nzDZQedJZX_"
+ },
+ "outputs": [],
+ "source": [
+ "\n",
+ "def create_probablistic_bnn_model(train_size):\n",
+ " inputs = create_model_inputs()\n",
+ " features = keras.layers.concatenate(list(inputs.values()))\n",
+ " features = layers.BatchNormalization()(features)\n",
+ "\n",
+ " # Create hidden layers with weight uncertainty using the DenseVariational layer.\n",
+ " for units in hidden_units:\n",
+ " features = tfp.layers.DenseVariational(\n",
+ " units=units,\n",
+ " make_prior_fn=prior,\n",
+ " make_posterior_fn=posterior,\n",
+ " kl_weight=1 / train_size,\n",
+ " activation=\"sigmoid\",\n",
+ " )(features)\n",
+ "\n",
+ " # Create a probabilisticå output (Normal distribution), and use the `Dense` layer\n",
+ " # to produce the parameters of the distribution.\n",
+ " # We set units=2 to learn both the mean and the variance of the Normal distribution.\n",
+ " distribution_params = layers.Dense(units=2)(features)\n",
+ " outputs = tfp.layers.IndependentNormal(1)(distribution_params)\n",
+ "\n",
+ " model = keras.Model(inputs=inputs, outputs=outputs)\n",
+ " return model\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qUFOwXTyJZX_"
+ },
+ "source": [
+ "Since the output of the model is a distribution, rather than a point estimate,\n",
+ "we use the [negative loglikelihood](https://en.wikipedia.org/wiki/Likelihood_function)\n",
+ "as our loss function to compute how likely to see the true data (targets) from the\n",
+ "estimated distribution produced by the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "id": "5SdzlMuvJZYA"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "Dv_RwLyFJZYA"
- },
- "outputs": [],
- "source": [
- "prediction_distribution = prob_bnn_model(examples)\n",
- "prediction_mean = prediction_distribution.mean().numpy().tolist()\n",
- "prediction_stdv = prediction_distribution.stddev().numpy()\n",
- "\n",
- "# The 95% CI is computed as mean ± (1.96 * stdv)\n",
- "upper = (prediction_mean + (1.96 * prediction_stdv)).tolist()\n",
- "lower = (prediction_mean - (1.96 * prediction_stdv)).tolist()\n",
- "prediction_stdv = prediction_stdv.tolist()\n",
- "\n",
- "for idx in range(sample):\n",
- " print(\n",
- " f\"Prediction mean: {round(prediction_mean[idx][0], 2)}, \"\n",
- " f\"stddev: {round(prediction_stdv[idx][0], 2)}, \"\n",
- " f\"95% CI: [{round(upper[idx][0], 2)} - {round(lower[idx][0], 2)}]\"\n",
- " f\" - Actual: {targets[idx]}\"\n",
- " )"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Start training the model...\n",
+ "Epoch 1/1000\n",
+ "17/17 [==============================] - 3s 55ms/step - loss: 49.4791 - root_mean_squared_error: 6.0334 - val_loss: 47.2343 - val_root_mean_squared_error: 6.0839\n",
+ "Epoch 2/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 43.4683 - root_mean_squared_error: 5.8431 - val_loss: 41.7599 - val_root_mean_squared_error: 5.6779\n",
+ "Epoch 3/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 40.1974 - root_mean_squared_error: 5.8785 - val_loss: 26.8484 - val_root_mean_squared_error: 5.5150\n",
+ "Epoch 4/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 26.8967 - root_mean_squared_error: 5.8974 - val_loss: 19.8879 - val_root_mean_squared_error: 5.5704\n",
+ "Epoch 5/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 26.5412 - root_mean_squared_error: 5.6827 - val_loss: 20.3914 - val_root_mean_squared_error: 5.5372\n",
+ "Epoch 6/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 27.7963 - root_mean_squared_error: 5.8320 - val_loss: 29.7995 - val_root_mean_squared_error: 5.7415\n",
+ "Epoch 7/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 18.9358 - root_mean_squared_error: 5.4316 - val_loss: 18.4710 - val_root_mean_squared_error: 5.7641\n",
+ "Epoch 8/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 16.4066 - root_mean_squared_error: 5.5915 - val_loss: 14.1811 - val_root_mean_squared_error: 5.4152\n",
+ "Epoch 9/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 16.0122 - root_mean_squared_error: 5.4757 - val_loss: 11.5630 - val_root_mean_squared_error: 5.3809\n",
+ "Epoch 10/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 12.9110 - root_mean_squared_error: 5.2266 - val_loss: 15.7345 - val_root_mean_squared_error: 5.2081\n",
+ "Epoch 11/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 9.9049 - root_mean_squared_error: 5.2066 - val_loss: 8.7508 - val_root_mean_squared_error: 5.4685\n",
+ "Epoch 12/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 12.1668 - root_mean_squared_error: 5.2535 - val_loss: 9.3646 - val_root_mean_squared_error: 4.9539\n",
+ "Epoch 13/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 9.1198 - root_mean_squared_error: 5.1449 - val_loss: 8.0804 - val_root_mean_squared_error: 5.3199\n",
+ "Epoch 14/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 8.3575 - root_mean_squared_error: 5.2122 - val_loss: 7.5787 - val_root_mean_squared_error: 4.9549\n",
+ "Epoch 15/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 7.8478 - root_mean_squared_error: 5.0685 - val_loss: 7.3819 - val_root_mean_squared_error: 4.5496\n",
+ "Epoch 16/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 7.2835 - root_mean_squared_error: 5.0197 - val_loss: 5.5337 - val_root_mean_squared_error: 4.6588\n",
+ "Epoch 17/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 5.8864 - root_mean_squared_error: 4.8764 - val_loss: 5.2507 - val_root_mean_squared_error: 4.9555\n",
+ "Epoch 18/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 5.4269 - root_mean_squared_error: 4.7535 - val_loss: 5.1980 - val_root_mean_squared_error: 4.7492\n",
+ "Epoch 19/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 4.7675 - root_mean_squared_error: 4.6357 - val_loss: 4.4826 - val_root_mean_squared_error: 4.6135\n",
+ "Epoch 20/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 4.7597 - root_mean_squared_error: 4.6966 - val_loss: 4.1850 - val_root_mean_squared_error: 4.6720\n",
+ "Epoch 21/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 4.0850 - root_mean_squared_error: 4.4740 - val_loss: 4.3002 - val_root_mean_squared_error: 4.4141\n",
+ "Epoch 22/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 4.1690 - root_mean_squared_error: 4.5988 - val_loss: 3.4871 - val_root_mean_squared_error: 4.7396\n",
+ "Epoch 23/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 3.8374 - root_mean_squared_error: 4.6603 - val_loss: 4.0281 - val_root_mean_squared_error: 4.7955\n",
+ "Epoch 24/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 3.9443 - root_mean_squared_error: 4.4598 - val_loss: 4.1184 - val_root_mean_squared_error: 4.7453\n",
+ "Epoch 25/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 3.3186 - root_mean_squared_error: 4.3831 - val_loss: 3.2485 - val_root_mean_squared_error: 4.6034\n",
+ "Epoch 26/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 3.1653 - root_mean_squared_error: 4.2772 - val_loss: 3.4270 - val_root_mean_squared_error: 4.2072\n",
+ "Epoch 27/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 3.0534 - root_mean_squared_error: 4.2967 - val_loss: 3.1200 - val_root_mean_squared_error: 4.0117\n",
+ "Epoch 28/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 2.8901 - root_mean_squared_error: 4.1737 - val_loss: 3.0920 - val_root_mean_squared_error: 4.0898\n",
+ "Epoch 29/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 2.8258 - root_mean_squared_error: 4.1288 - val_loss: 2.7379 - val_root_mean_squared_error: 4.0551\n",
+ "Epoch 30/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.6813 - root_mean_squared_error: 3.9338 - val_loss: 2.5755 - val_root_mean_squared_error: 3.7008\n",
+ "Epoch 31/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.7103 - root_mean_squared_error: 4.1127 - val_loss: 2.6971 - val_root_mean_squared_error: 4.2257\n",
+ "Epoch 32/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 2.6148 - root_mean_squared_error: 4.0079 - val_loss: 2.5960 - val_root_mean_squared_error: 3.7971\n",
+ "Epoch 33/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.4886 - root_mean_squared_error: 3.8210 - val_loss: 2.6642 - val_root_mean_squared_error: 4.1584\n",
+ "Epoch 34/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.5031 - root_mean_squared_error: 3.8983 - val_loss: 2.4248 - val_root_mean_squared_error: 4.0141\n",
+ "Epoch 35/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.4476 - root_mean_squared_error: 3.8152 - val_loss: 2.4816 - val_root_mean_squared_error: 3.9046\n",
+ "Epoch 36/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.3846 - root_mean_squared_error: 3.6896 - val_loss: 2.3603 - val_root_mean_squared_error: 3.8712\n",
+ "Epoch 37/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.4445 - root_mean_squared_error: 3.7208 - val_loss: 2.3956 - val_root_mean_squared_error: 3.9012\n",
+ "Epoch 38/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.3448 - root_mean_squared_error: 3.6869 - val_loss: 2.3151 - val_root_mean_squared_error: 3.4838\n",
+ "Epoch 39/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 2.2703 - root_mean_squared_error: 3.4491 - val_loss: 2.1790 - val_root_mean_squared_error: 3.2574\n",
+ "Epoch 40/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.2453 - root_mean_squared_error: 3.3830 - val_loss: 2.2611 - val_root_mean_squared_error: 3.5903\n",
+ "Epoch 41/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 2.1681 - root_mean_squared_error: 3.1830 - val_loss: 2.1688 - val_root_mean_squared_error: 3.2343\n",
+ "Epoch 42/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.1464 - root_mean_squared_error: 3.1410 - val_loss: 2.0790 - val_root_mean_squared_error: 2.9768\n",
+ "Epoch 43/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.0773 - root_mean_squared_error: 2.9002 - val_loss: 2.1042 - val_root_mean_squared_error: 3.1225\n",
+ "Epoch 44/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.0558 - root_mean_squared_error: 2.8647 - val_loss: 2.0106 - val_root_mean_squared_error: 2.7401\n",
+ "Epoch 45/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 2.0222 - root_mean_squared_error: 2.8982 - val_loss: 2.0344 - val_root_mean_squared_error: 2.7835\n",
+ "Epoch 46/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.9585 - root_mean_squared_error: 2.6959 - val_loss: 1.8660 - val_root_mean_squared_error: 2.5219\n",
+ "Epoch 47/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.9363 - root_mean_squared_error: 2.6122 - val_loss: 1.8248 - val_root_mean_squared_error: 2.2971\n",
+ "Epoch 48/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.8718 - root_mean_squared_error: 2.4994 - val_loss: 1.8952 - val_root_mean_squared_error: 2.4322\n",
+ "Epoch 49/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.7604 - root_mean_squared_error: 2.2322 - val_loss: 1.7443 - val_root_mean_squared_error: 2.0142\n",
+ "Epoch 50/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.7532 - root_mean_squared_error: 2.2011 - val_loss: 1.7838 - val_root_mean_squared_error: 2.3775\n",
+ "Epoch 51/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.7096 - root_mean_squared_error: 2.1454 - val_loss: 1.6807 - val_root_mean_squared_error: 1.9999\n",
+ "Epoch 52/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.5657 - root_mean_squared_error: 1.8387 - val_loss: 1.5407 - val_root_mean_squared_error: 1.7301\n",
+ "Epoch 53/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.5655 - root_mean_squared_error: 1.8442 - val_loss: 1.5510 - val_root_mean_squared_error: 1.8079\n",
+ "Epoch 54/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.5263 - root_mean_squared_error: 1.7567 - val_loss: 1.5527 - val_root_mean_squared_error: 1.7713\n",
+ "Epoch 55/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.5102 - root_mean_squared_error: 1.7039 - val_loss: 1.4269 - val_root_mean_squared_error: 1.5772\n",
+ "Epoch 56/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.4842 - root_mean_squared_error: 1.6800 - val_loss: 1.4029 - val_root_mean_squared_error: 1.4576\n",
+ "Epoch 57/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.4071 - root_mean_squared_error: 1.4799 - val_loss: 1.4325 - val_root_mean_squared_error: 1.4910\n",
+ "Epoch 58/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.3981 - root_mean_squared_error: 1.5214 - val_loss: 1.4305 - val_root_mean_squared_error: 1.6696\n",
+ "Epoch 59/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.4090 - root_mean_squared_error: 1.4474 - val_loss: 1.3516 - val_root_mean_squared_error: 1.3792\n",
+ "Epoch 60/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.3999 - root_mean_squared_error: 1.4882 - val_loss: 1.3528 - val_root_mean_squared_error: 1.2550\n",
+ "Epoch 61/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3593 - root_mean_squared_error: 1.3733 - val_loss: 1.2630 - val_root_mean_squared_error: 1.2267\n",
+ "Epoch 62/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3897 - root_mean_squared_error: 1.3679 - val_loss: 1.2686 - val_root_mean_squared_error: 1.3015\n",
+ "Epoch 63/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3372 - root_mean_squared_error: 1.3199 - val_loss: 1.3184 - val_root_mean_squared_error: 1.3445\n",
+ "Epoch 64/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3327 - root_mean_squared_error: 1.3463 - val_loss: 1.3474 - val_root_mean_squared_error: 1.3826\n",
+ "Epoch 65/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3314 - root_mean_squared_error: 1.3077 - val_loss: 1.3613 - val_root_mean_squared_error: 1.3066\n",
+ "Epoch 66/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.3267 - root_mean_squared_error: 1.2709 - val_loss: 1.2979 - val_root_mean_squared_error: 1.1779\n",
+ "Epoch 67/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3340 - root_mean_squared_error: 1.3261 - val_loss: 1.3534 - val_root_mean_squared_error: 1.1973\n",
+ "Epoch 68/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2930 - root_mean_squared_error: 1.2444 - val_loss: 1.3576 - val_root_mean_squared_error: 1.3215\n",
+ "Epoch 69/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3195 - root_mean_squared_error: 1.2489 - val_loss: 1.3498 - val_root_mean_squared_error: 1.2839\n",
+ "Epoch 70/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3049 - root_mean_squared_error: 1.2541 - val_loss: 1.3202 - val_root_mean_squared_error: 1.1756\n",
+ "Epoch 71/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3159 - root_mean_squared_error: 1.2633 - val_loss: 1.3334 - val_root_mean_squared_error: 1.2451\n",
+ "Epoch 72/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3132 - root_mean_squared_error: 1.2740 - val_loss: 1.3323 - val_root_mean_squared_error: 1.0962\n",
+ "Epoch 73/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3110 - root_mean_squared_error: 1.2432 - val_loss: 1.3192 - val_root_mean_squared_error: 1.3352\n",
+ "Epoch 74/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2994 - root_mean_squared_error: 1.2210 - val_loss: 1.2992 - val_root_mean_squared_error: 1.2611\n",
+ "Epoch 75/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2884 - root_mean_squared_error: 1.2601 - val_loss: 1.3147 - val_root_mean_squared_error: 1.1548\n",
+ "Epoch 76/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2681 - root_mean_squared_error: 1.2061 - val_loss: 1.3288 - val_root_mean_squared_error: 1.1821\n",
+ "Epoch 77/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3250 - root_mean_squared_error: 1.2457 - val_loss: 1.3163 - val_root_mean_squared_error: 1.3217\n",
+ "Epoch 78/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2892 - root_mean_squared_error: 1.2262 - val_loss: 1.2869 - val_root_mean_squared_error: 1.2102\n",
+ "Epoch 79/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3471 - root_mean_squared_error: 1.2687 - val_loss: 1.2676 - val_root_mean_squared_error: 1.2697\n",
+ "Epoch 80/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.3072 - root_mean_squared_error: 1.2520 - val_loss: 1.2947 - val_root_mean_squared_error: 1.2536\n",
+ "Epoch 81/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2659 - root_mean_squared_error: 1.1922 - val_loss: 1.2640 - val_root_mean_squared_error: 1.1866\n",
+ "Epoch 82/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2763 - root_mean_squared_error: 1.2246 - val_loss: 1.3086 - val_root_mean_squared_error: 1.1779\n",
+ "Epoch 83/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2802 - root_mean_squared_error: 1.2484 - val_loss: 1.2653 - val_root_mean_squared_error: 1.2458\n",
+ "Epoch 84/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2759 - root_mean_squared_error: 1.2011 - val_loss: 1.2514 - val_root_mean_squared_error: 1.2203\n",
+ "Epoch 85/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2810 - root_mean_squared_error: 1.2443 - val_loss: 1.2476 - val_root_mean_squared_error: 1.1833\n",
+ "Epoch 86/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2695 - root_mean_squared_error: 1.1964 - val_loss: 1.2856 - val_root_mean_squared_error: 1.2245\n",
+ "Epoch 87/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2716 - root_mean_squared_error: 1.2282 - val_loss: 1.2865 - val_root_mean_squared_error: 1.1881\n",
+ "Epoch 88/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2640 - root_mean_squared_error: 1.2045 - val_loss: 1.3174 - val_root_mean_squared_error: 1.2492\n",
+ "Epoch 89/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2707 - root_mean_squared_error: 1.1940 - val_loss: 1.2369 - val_root_mean_squared_error: 1.1885\n",
+ "Epoch 90/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2684 - root_mean_squared_error: 1.2222 - val_loss: 1.2394 - val_root_mean_squared_error: 1.1854\n",
+ "Epoch 91/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2693 - root_mean_squared_error: 1.1987 - val_loss: 1.2374 - val_root_mean_squared_error: 1.2061\n",
+ "Epoch 92/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2684 - root_mean_squared_error: 1.1897 - val_loss: 1.2313 - val_root_mean_squared_error: 1.1366\n",
+ "Epoch 93/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2632 - root_mean_squared_error: 1.2303 - val_loss: 1.2459 - val_root_mean_squared_error: 1.2218\n",
+ "Epoch 94/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2378 - root_mean_squared_error: 1.1726 - val_loss: 1.3026 - val_root_mean_squared_error: 1.1871\n",
+ "Epoch 95/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2422 - root_mean_squared_error: 1.1629 - val_loss: 1.2598 - val_root_mean_squared_error: 1.2099\n",
+ "Epoch 96/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2530 - root_mean_squared_error: 1.1729 - val_loss: 1.2735 - val_root_mean_squared_error: 1.1526\n",
+ "Epoch 97/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2354 - root_mean_squared_error: 1.1864 - val_loss: 1.2383 - val_root_mean_squared_error: 1.1757\n",
+ "Epoch 98/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2634 - root_mean_squared_error: 1.1810 - val_loss: 1.2321 - val_root_mean_squared_error: 1.2313\n",
+ "Epoch 99/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2459 - root_mean_squared_error: 1.1912 - val_loss: 1.2358 - val_root_mean_squared_error: 1.1996\n",
+ "Epoch 100/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2546 - root_mean_squared_error: 1.1995 - val_loss: 1.2306 - val_root_mean_squared_error: 1.1915\n",
+ "Epoch 101/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2463 - root_mean_squared_error: 1.1990 - val_loss: 1.2091 - val_root_mean_squared_error: 1.1948\n",
+ "Epoch 102/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2359 - root_mean_squared_error: 1.1922 - val_loss: 1.2461 - val_root_mean_squared_error: 1.1776\n",
+ "Epoch 103/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2384 - root_mean_squared_error: 1.1686 - val_loss: 1.2511 - val_root_mean_squared_error: 1.2230\n",
+ "Epoch 104/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2512 - root_mean_squared_error: 1.1776 - val_loss: 1.2456 - val_root_mean_squared_error: 1.1916\n",
+ "Epoch 105/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2488 - root_mean_squared_error: 1.1655 - val_loss: 1.2081 - val_root_mean_squared_error: 1.1427\n",
+ "Epoch 106/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2272 - root_mean_squared_error: 1.1978 - val_loss: 1.2451 - val_root_mean_squared_error: 1.1563\n",
+ "Epoch 107/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2243 - root_mean_squared_error: 1.1549 - val_loss: 1.2384 - val_root_mean_squared_error: 1.1053\n",
+ "Epoch 108/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2400 - root_mean_squared_error: 1.1624 - val_loss: 1.1971 - val_root_mean_squared_error: 1.1448\n",
+ "Epoch 109/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2178 - root_mean_squared_error: 1.1521 - val_loss: 1.2323 - val_root_mean_squared_error: 1.1580\n",
+ "Epoch 110/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2308 - root_mean_squared_error: 1.1490 - val_loss: 1.2220 - val_root_mean_squared_error: 1.1602\n",
+ "Epoch 111/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2245 - root_mean_squared_error: 1.1660 - val_loss: 1.2184 - val_root_mean_squared_error: 1.1655\n",
+ "Epoch 112/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2313 - root_mean_squared_error: 1.1536 - val_loss: 1.2299 - val_root_mean_squared_error: 1.1700\n",
+ "Epoch 113/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2097 - root_mean_squared_error: 1.1543 - val_loss: 1.2055 - val_root_mean_squared_error: 1.1187\n",
+ "Epoch 114/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2263 - root_mean_squared_error: 1.1647 - val_loss: 1.2424 - val_root_mean_squared_error: 1.2083\n",
+ "Epoch 115/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2432 - root_mean_squared_error: 1.1450 - val_loss: 1.2150 - val_root_mean_squared_error: 1.1525\n",
+ "Epoch 116/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2279 - root_mean_squared_error: 1.1592 - val_loss: 1.2287 - val_root_mean_squared_error: 1.1360\n",
+ "Epoch 117/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2369 - root_mean_squared_error: 1.1444 - val_loss: 1.2080 - val_root_mean_squared_error: 1.1718\n",
+ "Epoch 118/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2325 - root_mean_squared_error: 1.1640 - val_loss: 1.2231 - val_root_mean_squared_error: 1.1656\n",
+ "Epoch 119/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2084 - root_mean_squared_error: 1.1373 - val_loss: 1.2237 - val_root_mean_squared_error: 1.1586\n",
+ "Epoch 120/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2258 - root_mean_squared_error: 1.1462 - val_loss: 1.2104 - val_root_mean_squared_error: 1.1480\n",
+ "Epoch 121/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2262 - root_mean_squared_error: 1.1687 - val_loss: 1.2350 - val_root_mean_squared_error: 1.1346\n",
+ "Epoch 122/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2277 - root_mean_squared_error: 1.1622 - val_loss: 1.1852 - val_root_mean_squared_error: 1.1470\n",
+ "Epoch 123/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2127 - root_mean_squared_error: 1.1596 - val_loss: 1.2250 - val_root_mean_squared_error: 1.1541\n",
+ "Epoch 124/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2058 - root_mean_squared_error: 1.1271 - val_loss: 1.2022 - val_root_mean_squared_error: 1.1989\n",
+ "Epoch 125/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2157 - root_mean_squared_error: 1.1667 - val_loss: 1.2109 - val_root_mean_squared_error: 1.0976\n",
+ "Epoch 126/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2070 - root_mean_squared_error: 1.1464 - val_loss: 1.2010 - val_root_mean_squared_error: 1.1606\n",
+ "Epoch 127/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2121 - root_mean_squared_error: 1.1448 - val_loss: 1.1947 - val_root_mean_squared_error: 1.1438\n",
+ "Epoch 128/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2316 - root_mean_squared_error: 1.1858 - val_loss: 1.2310 - val_root_mean_squared_error: 1.1150\n",
+ "Epoch 129/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2073 - root_mean_squared_error: 1.1584 - val_loss: 1.1832 - val_root_mean_squared_error: 1.0845\n",
+ "Epoch 130/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2129 - root_mean_squared_error: 1.1442 - val_loss: 1.1806 - val_root_mean_squared_error: 1.1193\n",
+ "Epoch 131/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2094 - root_mean_squared_error: 1.1404 - val_loss: 1.2245 - val_root_mean_squared_error: 1.1459\n",
+ "Epoch 132/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2096 - root_mean_squared_error: 1.1124 - val_loss: 1.1952 - val_root_mean_squared_error: 1.1283\n",
+ "Epoch 133/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2136 - root_mean_squared_error: 1.1442 - val_loss: 1.2135 - val_root_mean_squared_error: 1.1296\n",
+ "Epoch 134/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2162 - root_mean_squared_error: 1.1520 - val_loss: 1.2023 - val_root_mean_squared_error: 1.1253\n",
+ "Epoch 135/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2084 - root_mean_squared_error: 1.1399 - val_loss: 1.2253 - val_root_mean_squared_error: 1.1238\n",
+ "Epoch 136/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2067 - root_mean_squared_error: 1.1213 - val_loss: 1.1823 - val_root_mean_squared_error: 1.1564\n",
+ "Epoch 137/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2155 - root_mean_squared_error: 1.1623 - val_loss: 1.2044 - val_root_mean_squared_error: 1.0579\n",
+ "Epoch 138/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2118 - root_mean_squared_error: 1.1336 - val_loss: 1.1835 - val_root_mean_squared_error: 1.1689\n",
+ "Epoch 139/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2081 - root_mean_squared_error: 1.1062 - val_loss: 1.2060 - val_root_mean_squared_error: 1.1103\n",
+ "Epoch 140/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2030 - root_mean_squared_error: 1.1400 - val_loss: 1.2258 - val_root_mean_squared_error: 1.1392\n",
+ "Epoch 141/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2068 - root_mean_squared_error: 1.1296 - val_loss: 1.2109 - val_root_mean_squared_error: 1.1720\n",
+ "Epoch 142/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2204 - root_mean_squared_error: 1.1383 - val_loss: 1.2119 - val_root_mean_squared_error: 1.1423\n",
+ "Epoch 143/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2239 - root_mean_squared_error: 1.1335 - val_loss: 1.1849 - val_root_mean_squared_error: 1.1230\n",
+ "Epoch 144/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2023 - root_mean_squared_error: 1.1353 - val_loss: 1.1841 - val_root_mean_squared_error: 1.0775\n",
+ "Epoch 145/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2235 - root_mean_squared_error: 1.1427 - val_loss: 1.1954 - val_root_mean_squared_error: 1.1936\n",
+ "Epoch 146/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2198 - root_mean_squared_error: 1.1436 - val_loss: 1.2075 - val_root_mean_squared_error: 1.1604\n",
+ "Epoch 147/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1913 - root_mean_squared_error: 1.1203 - val_loss: 1.2001 - val_root_mean_squared_error: 1.1086\n",
+ "Epoch 148/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1986 - root_mean_squared_error: 1.1317 - val_loss: 1.2273 - val_root_mean_squared_error: 1.1061\n",
+ "Epoch 149/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2034 - root_mean_squared_error: 1.1290 - val_loss: 1.1827 - val_root_mean_squared_error: 1.1081\n",
+ "Epoch 150/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1907 - root_mean_squared_error: 1.1319 - val_loss: 1.1592 - val_root_mean_squared_error: 1.1205\n",
+ "Epoch 151/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2164 - root_mean_squared_error: 1.1208 - val_loss: 1.1742 - val_root_mean_squared_error: 1.1139\n",
+ "Epoch 152/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2034 - root_mean_squared_error: 1.1413 - val_loss: 1.2134 - val_root_mean_squared_error: 1.1101\n",
+ "Epoch 153/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2181 - root_mean_squared_error: 1.1359 - val_loss: 1.2168 - val_root_mean_squared_error: 1.1827\n",
+ "Epoch 154/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1948 - root_mean_squared_error: 1.1220 - val_loss: 1.2341 - val_root_mean_squared_error: 1.1373\n",
+ "Epoch 155/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2302 - root_mean_squared_error: 1.1181 - val_loss: 1.2092 - val_root_mean_squared_error: 1.2125\n",
+ "Epoch 156/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2046 - root_mean_squared_error: 1.1507 - val_loss: 1.2227 - val_root_mean_squared_error: 1.1695\n",
+ "Epoch 157/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2060 - root_mean_squared_error: 1.1659 - val_loss: 1.1801 - val_root_mean_squared_error: 1.0554\n",
+ "Epoch 158/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1885 - root_mean_squared_error: 1.1229 - val_loss: 1.2039 - val_root_mean_squared_error: 1.1068\n",
+ "Epoch 159/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2089 - root_mean_squared_error: 1.1165 - val_loss: 1.1850 - val_root_mean_squared_error: 1.1714\n",
+ "Epoch 160/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1930 - root_mean_squared_error: 1.0992 - val_loss: 1.2189 - val_root_mean_squared_error: 1.0974\n",
+ "Epoch 161/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1922 - root_mean_squared_error: 1.1013 - val_loss: 1.1908 - val_root_mean_squared_error: 1.1607\n",
+ "Epoch 162/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1882 - root_mean_squared_error: 1.1603 - val_loss: 1.1877 - val_root_mean_squared_error: 1.1408\n",
+ "Epoch 163/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1974 - root_mean_squared_error: 1.1437 - val_loss: 1.1777 - val_root_mean_squared_error: 1.1516\n",
+ "Epoch 164/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1976 - root_mean_squared_error: 1.1135 - val_loss: 1.1963 - val_root_mean_squared_error: 1.1311\n",
+ "Epoch 165/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1992 - root_mean_squared_error: 1.1014 - val_loss: 1.2034 - val_root_mean_squared_error: 1.1244\n",
+ "Epoch 166/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1944 - root_mean_squared_error: 1.1278 - val_loss: 1.1985 - val_root_mean_squared_error: 1.1509\n",
+ "Epoch 167/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1873 - root_mean_squared_error: 1.1057 - val_loss: 1.2090 - val_root_mean_squared_error: 1.1225\n",
+ "Epoch 168/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1921 - root_mean_squared_error: 1.1212 - val_loss: 1.2009 - val_root_mean_squared_error: 1.0578\n",
+ "Epoch 169/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2019 - root_mean_squared_error: 1.1216 - val_loss: 1.1953 - val_root_mean_squared_error: 1.1160\n",
+ "Epoch 170/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1909 - root_mean_squared_error: 1.1164 - val_loss: 1.2071 - val_root_mean_squared_error: 1.1517\n",
+ "Epoch 171/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1956 - root_mean_squared_error: 1.1059 - val_loss: 1.1841 - val_root_mean_squared_error: 1.1115\n",
+ "Epoch 172/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1840 - root_mean_squared_error: 1.1164 - val_loss: 1.2000 - val_root_mean_squared_error: 1.1125\n",
+ "Epoch 173/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1970 - root_mean_squared_error: 1.1168 - val_loss: 1.1861 - val_root_mean_squared_error: 1.1363\n",
+ "Epoch 174/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2013 - root_mean_squared_error: 1.1144 - val_loss: 1.1914 - val_root_mean_squared_error: 1.1642\n",
+ "Epoch 175/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1943 - root_mean_squared_error: 1.1144 - val_loss: 1.1764 - val_root_mean_squared_error: 1.0702\n",
+ "Epoch 176/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1918 - root_mean_squared_error: 1.1267 - val_loss: 1.1820 - val_root_mean_squared_error: 1.1426\n",
+ "Epoch 177/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1960 - root_mean_squared_error: 1.1254 - val_loss: 1.1902 - val_root_mean_squared_error: 1.1146\n",
+ "Epoch 178/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1851 - root_mean_squared_error: 1.1044 - val_loss: 1.1797 - val_root_mean_squared_error: 1.1398\n",
+ "Epoch 179/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1982 - root_mean_squared_error: 1.1420 - val_loss: 1.1875 - val_root_mean_squared_error: 1.0962\n",
+ "Epoch 180/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1859 - root_mean_squared_error: 1.1051 - val_loss: 1.1930 - val_root_mean_squared_error: 1.1487\n",
+ "Epoch 181/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1854 - root_mean_squared_error: 1.1078 - val_loss: 1.2124 - val_root_mean_squared_error: 1.1381\n",
+ "Epoch 182/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1888 - root_mean_squared_error: 1.1301 - val_loss: 1.2062 - val_root_mean_squared_error: 1.1431\n",
+ "Epoch 183/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1854 - root_mean_squared_error: 1.1168 - val_loss: 1.2014 - val_root_mean_squared_error: 1.0789\n",
+ "Epoch 184/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1944 - root_mean_squared_error: 1.1265 - val_loss: 1.1764 - val_root_mean_squared_error: 1.0568\n",
+ "Epoch 185/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1952 - root_mean_squared_error: 1.0824 - val_loss: 1.1812 - val_root_mean_squared_error: 1.1614\n",
+ "Epoch 186/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1933 - root_mean_squared_error: 1.1276 - val_loss: 1.1977 - val_root_mean_squared_error: 1.1059\n",
+ "Epoch 187/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1826 - root_mean_squared_error: 1.1147 - val_loss: 1.1983 - val_root_mean_squared_error: 1.0683\n",
+ "Epoch 188/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2211 - root_mean_squared_error: 1.1411 - val_loss: 1.2042 - val_root_mean_squared_error: 1.1878\n",
+ "Epoch 189/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1933 - root_mean_squared_error: 1.1095 - val_loss: 1.1822 - val_root_mean_squared_error: 1.1439\n",
+ "Epoch 190/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2058 - root_mean_squared_error: 1.1336 - val_loss: 1.1848 - val_root_mean_squared_error: 1.1157\n",
+ "Epoch 191/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1932 - root_mean_squared_error: 1.1280 - val_loss: 1.2083 - val_root_mean_squared_error: 1.1368\n",
+ "Epoch 192/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1878 - root_mean_squared_error: 1.1082 - val_loss: 1.1921 - val_root_mean_squared_error: 1.1090\n",
+ "Epoch 193/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1815 - root_mean_squared_error: 1.1210 - val_loss: 1.1944 - val_root_mean_squared_error: 1.1072\n",
+ "Epoch 194/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2004 - root_mean_squared_error: 1.1141 - val_loss: 1.1911 - val_root_mean_squared_error: 1.1529\n",
+ "Epoch 195/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2008 - root_mean_squared_error: 1.1186 - val_loss: 1.2018 - val_root_mean_squared_error: 1.1702\n",
+ "Epoch 196/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1952 - root_mean_squared_error: 1.1062 - val_loss: 1.1851 - val_root_mean_squared_error: 1.0483\n",
+ "Epoch 197/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1933 - root_mean_squared_error: 1.1235 - val_loss: 1.1928 - val_root_mean_squared_error: 1.1171\n",
+ "Epoch 198/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1908 - root_mean_squared_error: 1.1276 - val_loss: 1.1781 - val_root_mean_squared_error: 1.1241\n",
+ "Epoch 199/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1875 - root_mean_squared_error: 1.1236 - val_loss: 1.2027 - val_root_mean_squared_error: 1.1211\n",
+ "Epoch 200/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1775 - root_mean_squared_error: 1.0999 - val_loss: 1.1738 - val_root_mean_squared_error: 1.0956\n",
+ "Epoch 201/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1811 - root_mean_squared_error: 1.1134 - val_loss: 1.1927 - val_root_mean_squared_error: 1.1208\n",
+ "Epoch 202/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1812 - root_mean_squared_error: 1.0942 - val_loss: 1.1840 - val_root_mean_squared_error: 1.1067\n",
+ "Epoch 203/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2106 - root_mean_squared_error: 1.1393 - val_loss: 1.1782 - val_root_mean_squared_error: 1.0711\n",
+ "Epoch 204/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1898 - root_mean_squared_error: 1.1323 - val_loss: 1.1989 - val_root_mean_squared_error: 1.0981\n",
+ "Epoch 205/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1823 - root_mean_squared_error: 1.1045 - val_loss: 1.1784 - val_root_mean_squared_error: 1.1053\n",
+ "Epoch 206/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1744 - root_mean_squared_error: 1.0884 - val_loss: 1.1758 - val_root_mean_squared_error: 1.0866\n",
+ "Epoch 207/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1791 - root_mean_squared_error: 1.1049 - val_loss: 1.1802 - val_root_mean_squared_error: 1.1169\n",
+ "Epoch 208/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1870 - root_mean_squared_error: 1.0868 - val_loss: 1.2096 - val_root_mean_squared_error: 1.1027\n",
+ "Epoch 209/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1929 - root_mean_squared_error: 1.1418 - val_loss: 1.1594 - val_root_mean_squared_error: 1.0801\n",
+ "Epoch 210/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1880 - root_mean_squared_error: 1.0929 - val_loss: 1.2016 - val_root_mean_squared_error: 1.1052\n",
+ "Epoch 211/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1883 - root_mean_squared_error: 1.1050 - val_loss: 1.1827 - val_root_mean_squared_error: 1.1161\n",
+ "Epoch 212/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1989 - root_mean_squared_error: 1.1125 - val_loss: 1.1948 - val_root_mean_squared_error: 1.0822\n",
+ "Epoch 213/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1820 - root_mean_squared_error: 1.0987 - val_loss: 1.1814 - val_root_mean_squared_error: 1.0877\n",
+ "Epoch 214/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1801 - root_mean_squared_error: 1.0952 - val_loss: 1.1617 - val_root_mean_squared_error: 1.1302\n",
+ "Epoch 215/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1756 - root_mean_squared_error: 1.0984 - val_loss: 1.1907 - val_root_mean_squared_error: 1.1271\n",
+ "Epoch 216/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1871 - root_mean_squared_error: 1.1008 - val_loss: 1.1581 - val_root_mean_squared_error: 1.1008\n",
+ "Epoch 217/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1798 - root_mean_squared_error: 1.1097 - val_loss: 1.1599 - val_root_mean_squared_error: 1.0878\n",
+ "Epoch 218/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1852 - root_mean_squared_error: 1.0912 - val_loss: 1.1644 - val_root_mean_squared_error: 1.1282\n",
+ "Epoch 219/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1912 - root_mean_squared_error: 1.1297 - val_loss: 1.1814 - val_root_mean_squared_error: 1.0750\n",
+ "Epoch 220/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1946 - root_mean_squared_error: 1.1170 - val_loss: 1.1914 - val_root_mean_squared_error: 1.1267\n",
+ "Epoch 221/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1872 - root_mean_squared_error: 1.1253 - val_loss: 1.1883 - val_root_mean_squared_error: 1.1335\n",
+ "Epoch 222/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1850 - root_mean_squared_error: 1.1283 - val_loss: 1.1557 - val_root_mean_squared_error: 1.0604\n",
+ "Epoch 223/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1809 - root_mean_squared_error: 1.0841 - val_loss: 1.2018 - val_root_mean_squared_error: 1.0606\n",
+ "Epoch 224/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1798 - root_mean_squared_error: 1.1016 - val_loss: 1.1630 - val_root_mean_squared_error: 1.1225\n",
+ "Epoch 225/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1861 - root_mean_squared_error: 1.1009 - val_loss: 1.1671 - val_root_mean_squared_error: 1.0454\n",
+ "Epoch 226/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1936 - root_mean_squared_error: 1.1153 - val_loss: 1.1800 - val_root_mean_squared_error: 1.1330\n",
+ "Epoch 227/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1821 - root_mean_squared_error: 1.1324 - val_loss: 1.1642 - val_root_mean_squared_error: 1.1110\n",
+ "Epoch 228/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1895 - root_mean_squared_error: 1.1092 - val_loss: 1.1684 - val_root_mean_squared_error: 1.0900\n",
+ "Epoch 229/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1989 - root_mean_squared_error: 1.1055 - val_loss: 1.1872 - val_root_mean_squared_error: 1.1435\n",
+ "Epoch 230/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1695 - root_mean_squared_error: 1.0956 - val_loss: 1.1912 - val_root_mean_squared_error: 1.1097\n",
+ "Epoch 231/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1793 - root_mean_squared_error: 1.0943 - val_loss: 1.1833 - val_root_mean_squared_error: 1.0755\n",
+ "Epoch 232/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1787 - root_mean_squared_error: 1.0887 - val_loss: 1.1841 - val_root_mean_squared_error: 1.1092\n",
+ "Epoch 233/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1902 - root_mean_squared_error: 1.1247 - val_loss: 1.1691 - val_root_mean_squared_error: 1.0884\n",
+ "Epoch 234/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1813 - root_mean_squared_error: 1.0740 - val_loss: 1.2042 - val_root_mean_squared_error: 1.1572\n",
+ "Epoch 235/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1783 - root_mean_squared_error: 1.1131 - val_loss: 1.1915 - val_root_mean_squared_error: 1.0818\n",
+ "Epoch 236/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.2017 - root_mean_squared_error: 1.1137 - val_loss: 1.1807 - val_root_mean_squared_error: 1.1136\n",
+ "Epoch 237/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1902 - root_mean_squared_error: 1.1213 - val_loss: 1.1942 - val_root_mean_squared_error: 1.0907\n",
+ "Epoch 238/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1781 - root_mean_squared_error: 1.1146 - val_loss: 1.1973 - val_root_mean_squared_error: 1.1590\n",
+ "Epoch 239/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1908 - root_mean_squared_error: 1.1133 - val_loss: 1.1825 - val_root_mean_squared_error: 1.0850\n",
+ "Epoch 240/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.2001 - root_mean_squared_error: 1.1152 - val_loss: 1.1788 - val_root_mean_squared_error: 1.1508\n",
+ "Epoch 241/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1935 - root_mean_squared_error: 1.1132 - val_loss: 1.2114 - val_root_mean_squared_error: 1.1310\n",
+ "Epoch 242/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1837 - root_mean_squared_error: 1.1124 - val_loss: 1.1718 - val_root_mean_squared_error: 1.1131\n",
+ "Epoch 243/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1814 - root_mean_squared_error: 1.1023 - val_loss: 1.1837 - val_root_mean_squared_error: 1.1339\n",
+ "Epoch 244/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1810 - root_mean_squared_error: 1.0887 - val_loss: 1.1625 - val_root_mean_squared_error: 1.1192\n",
+ "Epoch 245/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1797 - root_mean_squared_error: 1.1091 - val_loss: 1.1853 - val_root_mean_squared_error: 1.1762\n",
+ "Epoch 246/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1928 - root_mean_squared_error: 1.1219 - val_loss: 1.1792 - val_root_mean_squared_error: 1.1165\n",
+ "Epoch 247/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1821 - root_mean_squared_error: 1.0873 - val_loss: 1.1917 - val_root_mean_squared_error: 1.1037\n",
+ "Epoch 248/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1871 - root_mean_squared_error: 1.1118 - val_loss: 1.1943 - val_root_mean_squared_error: 1.0770\n",
+ "Epoch 249/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1763 - root_mean_squared_error: 1.1166 - val_loss: 1.1829 - val_root_mean_squared_error: 1.1057\n",
+ "Epoch 250/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1834 - root_mean_squared_error: 1.1057 - val_loss: 1.1722 - val_root_mean_squared_error: 1.1041\n",
+ "Epoch 251/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1784 - root_mean_squared_error: 1.1018 - val_loss: 1.1916 - val_root_mean_squared_error: 1.0827\n",
+ "Epoch 252/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1764 - root_mean_squared_error: 1.0829 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0720\n",
+ "Epoch 253/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1823 - root_mean_squared_error: 1.0987 - val_loss: 1.1649 - val_root_mean_squared_error: 1.1399\n",
+ "Epoch 254/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1771 - root_mean_squared_error: 1.1063 - val_loss: 1.1628 - val_root_mean_squared_error: 1.0863\n",
+ "Epoch 255/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1753 - root_mean_squared_error: 1.1261 - val_loss: 1.1718 - val_root_mean_squared_error: 1.1181\n",
+ "Epoch 256/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1685 - root_mean_squared_error: 1.0730 - val_loss: 1.1788 - val_root_mean_squared_error: 1.0882\n",
+ "Epoch 257/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1907 - root_mean_squared_error: 1.0988 - val_loss: 1.1710 - val_root_mean_squared_error: 1.0730\n",
+ "Epoch 258/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1689 - root_mean_squared_error: 1.0859 - val_loss: 1.1987 - val_root_mean_squared_error: 1.0730\n",
+ "Epoch 259/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1871 - root_mean_squared_error: 1.0998 - val_loss: 1.1572 - val_root_mean_squared_error: 1.1101\n",
+ "Epoch 260/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1780 - root_mean_squared_error: 1.0908 - val_loss: 1.1728 - val_root_mean_squared_error: 1.0936\n",
+ "Epoch 261/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1824 - root_mean_squared_error: 1.1102 - val_loss: 1.1765 - val_root_mean_squared_error: 1.1021\n",
+ "Epoch 262/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1852 - root_mean_squared_error: 1.1049 - val_loss: 1.1777 - val_root_mean_squared_error: 1.0981\n",
+ "Epoch 263/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1753 - root_mean_squared_error: 1.1064 - val_loss: 1.1805 - val_root_mean_squared_error: 1.1038\n",
+ "Epoch 264/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1783 - root_mean_squared_error: 1.0966 - val_loss: 1.1725 - val_root_mean_squared_error: 1.1359\n",
+ "Epoch 265/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1712 - root_mean_squared_error: 1.0887 - val_loss: 1.1721 - val_root_mean_squared_error: 1.0962\n",
+ "Epoch 266/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1793 - root_mean_squared_error: 1.1142 - val_loss: 1.1757 - val_root_mean_squared_error: 1.0847\n",
+ "Epoch 267/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1636 - root_mean_squared_error: 1.0959 - val_loss: 1.1633 - val_root_mean_squared_error: 1.0590\n",
+ "Epoch 268/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1770 - root_mean_squared_error: 1.1208 - val_loss: 1.1706 - val_root_mean_squared_error: 1.1157\n",
+ "Epoch 269/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1670 - root_mean_squared_error: 1.0923 - val_loss: 1.1750 - val_root_mean_squared_error: 1.1057\n",
+ "Epoch 270/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1746 - root_mean_squared_error: 1.1025 - val_loss: 1.1597 - val_root_mean_squared_error: 1.0692\n",
+ "Epoch 271/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1773 - root_mean_squared_error: 1.0919 - val_loss: 1.1550 - val_root_mean_squared_error: 1.0526\n",
+ "Epoch 272/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1708 - root_mean_squared_error: 1.1092 - val_loss: 1.2143 - val_root_mean_squared_error: 1.0846\n",
+ "Epoch 273/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1775 - root_mean_squared_error: 1.0903 - val_loss: 1.1733 - val_root_mean_squared_error: 1.0970\n",
+ "Epoch 274/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1764 - root_mean_squared_error: 1.0898 - val_loss: 1.1654 - val_root_mean_squared_error: 1.0788\n",
+ "Epoch 275/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1835 - root_mean_squared_error: 1.1193 - val_loss: 1.1737 - val_root_mean_squared_error: 1.0875\n",
+ "Epoch 276/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1814 - root_mean_squared_error: 1.0842 - val_loss: 1.1481 - val_root_mean_squared_error: 1.0741\n",
+ "Epoch 277/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1743 - root_mean_squared_error: 1.1173 - val_loss: 1.1717 - val_root_mean_squared_error: 1.0776\n",
+ "Epoch 278/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1888 - root_mean_squared_error: 1.0920 - val_loss: 1.1697 - val_root_mean_squared_error: 1.1046\n",
+ "Epoch 279/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1810 - root_mean_squared_error: 1.1012 - val_loss: 1.1544 - val_root_mean_squared_error: 1.0986\n",
+ "Epoch 280/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1906 - root_mean_squared_error: 1.1010 - val_loss: 1.1923 - val_root_mean_squared_error: 1.1708\n",
+ "Epoch 281/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1759 - root_mean_squared_error: 1.1098 - val_loss: 1.1757 - val_root_mean_squared_error: 1.0905\n",
+ "Epoch 282/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1816 - root_mean_squared_error: 1.0949 - val_loss: 1.2022 - val_root_mean_squared_error: 1.1559\n",
+ "Epoch 283/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1675 - root_mean_squared_error: 1.0967 - val_loss: 1.1748 - val_root_mean_squared_error: 1.0909\n",
+ "Epoch 284/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1782 - root_mean_squared_error: 1.0952 - val_loss: 1.1833 - val_root_mean_squared_error: 1.0877\n",
+ "Epoch 285/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1850 - root_mean_squared_error: 1.1261 - val_loss: 1.1595 - val_root_mean_squared_error: 1.0474\n",
+ "Epoch 286/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1744 - root_mean_squared_error: 1.1012 - val_loss: 1.1642 - val_root_mean_squared_error: 1.0813\n",
+ "Epoch 287/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1760 - root_mean_squared_error: 1.0822 - val_loss: 1.1642 - val_root_mean_squared_error: 1.1394\n",
+ "Epoch 288/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1748 - root_mean_squared_error: 1.1051 - val_loss: 1.1630 - val_root_mean_squared_error: 1.0608\n",
+ "Epoch 289/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1773 - root_mean_squared_error: 1.1037 - val_loss: 1.1553 - val_root_mean_squared_error: 1.1545\n",
+ "Epoch 290/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1835 - root_mean_squared_error: 1.0870 - val_loss: 1.1754 - val_root_mean_squared_error: 1.1455\n",
+ "Epoch 291/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1784 - root_mean_squared_error: 1.1078 - val_loss: 1.1650 - val_root_mean_squared_error: 1.1261\n",
+ "Epoch 292/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1779 - root_mean_squared_error: 1.0905 - val_loss: 1.1509 - val_root_mean_squared_error: 1.0687\n",
+ "Epoch 293/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1757 - root_mean_squared_error: 1.0994 - val_loss: 1.1603 - val_root_mean_squared_error: 1.1427\n",
+ "Epoch 294/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1710 - root_mean_squared_error: 1.1132 - val_loss: 1.1524 - val_root_mean_squared_error: 1.0694\n",
+ "Epoch 295/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1776 - root_mean_squared_error: 1.1105 - val_loss: 1.1970 - val_root_mean_squared_error: 1.1538\n",
+ "Epoch 296/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1755 - root_mean_squared_error: 1.1085 - val_loss: 1.1700 - val_root_mean_squared_error: 1.1319\n",
+ "Epoch 297/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1733 - root_mean_squared_error: 1.0901 - val_loss: 1.1905 - val_root_mean_squared_error: 1.0399\n",
+ "Epoch 298/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1813 - root_mean_squared_error: 1.1075 - val_loss: 1.1658 - val_root_mean_squared_error: 1.1121\n",
+ "Epoch 299/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1659 - root_mean_squared_error: 1.0934 - val_loss: 1.1749 - val_root_mean_squared_error: 1.1276\n",
+ "Epoch 300/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1721 - root_mean_squared_error: 1.0843 - val_loss: 1.1681 - val_root_mean_squared_error: 1.1141\n",
+ "Epoch 301/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1810 - root_mean_squared_error: 1.1024 - val_loss: 1.1635 - val_root_mean_squared_error: 1.0973\n",
+ "Epoch 302/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1694 - root_mean_squared_error: 1.0966 - val_loss: 1.1676 - val_root_mean_squared_error: 1.0296\n",
+ "Epoch 303/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1751 - root_mean_squared_error: 1.0986 - val_loss: 1.1609 - val_root_mean_squared_error: 1.0818\n",
+ "Epoch 304/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1835 - root_mean_squared_error: 1.1010 - val_loss: 1.1913 - val_root_mean_squared_error: 1.0870\n",
+ "Epoch 305/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1838 - root_mean_squared_error: 1.1131 - val_loss: 1.1725 - val_root_mean_squared_error: 1.1260\n",
+ "Epoch 306/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1659 - root_mean_squared_error: 1.1083 - val_loss: 1.1610 - val_root_mean_squared_error: 1.0476\n",
+ "Epoch 307/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1790 - root_mean_squared_error: 1.1039 - val_loss: 1.1579 - val_root_mean_squared_error: 1.0666\n",
+ "Epoch 308/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1683 - root_mean_squared_error: 1.1111 - val_loss: 1.1778 - val_root_mean_squared_error: 1.1338\n",
+ "Epoch 309/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1716 - root_mean_squared_error: 1.0949 - val_loss: 1.1638 - val_root_mean_squared_error: 1.1131\n",
+ "Epoch 310/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1733 - root_mean_squared_error: 1.0914 - val_loss: 1.1650 - val_root_mean_squared_error: 1.0995\n",
+ "Epoch 311/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1666 - root_mean_squared_error: 1.0820 - val_loss: 1.1879 - val_root_mean_squared_error: 1.0796\n",
+ "Epoch 312/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1724 - root_mean_squared_error: 1.0870 - val_loss: 1.1722 - val_root_mean_squared_error: 1.1335\n",
+ "Epoch 313/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1818 - root_mean_squared_error: 1.0872 - val_loss: 1.1748 - val_root_mean_squared_error: 1.1180\n",
+ "Epoch 314/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1657 - root_mean_squared_error: 1.1082 - val_loss: 1.1744 - val_root_mean_squared_error: 1.1022\n",
+ "Epoch 315/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1754 - root_mean_squared_error: 1.0757 - val_loss: 1.1508 - val_root_mean_squared_error: 1.0767\n",
+ "Epoch 316/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1745 - root_mean_squared_error: 1.1189 - val_loss: 1.1729 - val_root_mean_squared_error: 1.1327\n",
+ "Epoch 317/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1607 - root_mean_squared_error: 1.0917 - val_loss: 1.1758 - val_root_mean_squared_error: 1.0690\n",
+ "Epoch 318/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1705 - root_mean_squared_error: 1.1138 - val_loss: 1.1764 - val_root_mean_squared_error: 1.1094\n",
+ "Epoch 319/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1684 - root_mean_squared_error: 1.0920 - val_loss: 1.1974 - val_root_mean_squared_error: 1.1454\n",
+ "Epoch 320/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1737 - root_mean_squared_error: 1.1050 - val_loss: 1.2253 - val_root_mean_squared_error: 1.1171\n",
+ "Epoch 321/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1743 - root_mean_squared_error: 1.1123 - val_loss: 1.1740 - val_root_mean_squared_error: 1.1561\n",
+ "Epoch 322/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1747 - root_mean_squared_error: 1.0984 - val_loss: 1.1840 - val_root_mean_squared_error: 1.1319\n",
+ "Epoch 323/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1661 - root_mean_squared_error: 1.0961 - val_loss: 1.1639 - val_root_mean_squared_error: 1.1270\n",
+ "Epoch 324/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1612 - root_mean_squared_error: 1.0898 - val_loss: 1.1739 - val_root_mean_squared_error: 1.1052\n",
+ "Epoch 325/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1706 - root_mean_squared_error: 1.0879 - val_loss: 1.1480 - val_root_mean_squared_error: 1.0402\n",
+ "Epoch 326/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1764 - root_mean_squared_error: 1.1048 - val_loss: 1.1641 - val_root_mean_squared_error: 1.1125\n",
+ "Epoch 327/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1812 - root_mean_squared_error: 1.1151 - val_loss: 1.1772 - val_root_mean_squared_error: 1.0707\n",
+ "Epoch 328/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1679 - root_mean_squared_error: 1.0996 - val_loss: 1.1527 - val_root_mean_squared_error: 1.0592\n",
+ "Epoch 329/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1670 - root_mean_squared_error: 1.0985 - val_loss: 1.1717 - val_root_mean_squared_error: 1.1010\n",
+ "Epoch 330/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1793 - root_mean_squared_error: 1.0967 - val_loss: 1.1526 - val_root_mean_squared_error: 1.1291\n",
+ "Epoch 331/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1805 - root_mean_squared_error: 1.1058 - val_loss: 1.1585 - val_root_mean_squared_error: 1.0970\n",
+ "Epoch 332/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1754 - root_mean_squared_error: 1.0903 - val_loss: 1.1577 - val_root_mean_squared_error: 1.1092\n",
+ "Epoch 333/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1738 - root_mean_squared_error: 1.0906 - val_loss: 1.1656 - val_root_mean_squared_error: 1.0954\n",
+ "Epoch 334/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1628 - root_mean_squared_error: 1.0877 - val_loss: 1.1533 - val_root_mean_squared_error: 1.0999\n",
+ "Epoch 335/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1694 - root_mean_squared_error: 1.0779 - val_loss: 1.1591 - val_root_mean_squared_error: 1.0850\n",
+ "Epoch 336/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1807 - root_mean_squared_error: 1.1147 - val_loss: 1.2272 - val_root_mean_squared_error: 1.1827\n",
+ "Epoch 337/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1701 - root_mean_squared_error: 1.0865 - val_loss: 1.1616 - val_root_mean_squared_error: 1.1028\n",
+ "Epoch 338/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1680 - root_mean_squared_error: 1.0873 - val_loss: 1.1711 - val_root_mean_squared_error: 1.0898\n",
+ "Epoch 339/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1804 - root_mean_squared_error: 1.1023 - val_loss: 1.1641 - val_root_mean_squared_error: 1.0451\n",
+ "Epoch 340/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1644 - root_mean_squared_error: 1.0893 - val_loss: 1.1629 - val_root_mean_squared_error: 1.1030\n",
+ "Epoch 341/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1767 - root_mean_squared_error: 1.1122 - val_loss: 1.1766 - val_root_mean_squared_error: 1.0824\n",
+ "Epoch 342/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1706 - root_mean_squared_error: 1.0906 - val_loss: 1.1682 - val_root_mean_squared_error: 1.0956\n",
+ "Epoch 343/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1718 - root_mean_squared_error: 1.1045 - val_loss: 1.1602 - val_root_mean_squared_error: 1.0723\n",
+ "Epoch 344/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1704 - root_mean_squared_error: 1.0955 - val_loss: 1.1450 - val_root_mean_squared_error: 1.0957\n",
+ "Epoch 345/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1661 - root_mean_squared_error: 1.0975 - val_loss: 1.1693 - val_root_mean_squared_error: 1.1012\n",
+ "Epoch 346/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1744 - root_mean_squared_error: 1.0858 - val_loss: 1.1580 - val_root_mean_squared_error: 1.1231\n",
+ "Epoch 347/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1750 - root_mean_squared_error: 1.0907 - val_loss: 1.1763 - val_root_mean_squared_error: 1.1144\n",
+ "Epoch 348/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1682 - root_mean_squared_error: 1.1104 - val_loss: 1.1925 - val_root_mean_squared_error: 1.0859\n",
+ "Epoch 349/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1690 - root_mean_squared_error: 1.0892 - val_loss: 1.1861 - val_root_mean_squared_error: 1.1038\n",
+ "Epoch 350/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1693 - root_mean_squared_error: 1.1088 - val_loss: 1.1673 - val_root_mean_squared_error: 1.0590\n",
+ "Epoch 351/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1701 - root_mean_squared_error: 1.0824 - val_loss: 1.1818 - val_root_mean_squared_error: 1.1086\n",
+ "Epoch 352/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1723 - root_mean_squared_error: 1.0754 - val_loss: 1.1485 - val_root_mean_squared_error: 1.0705\n",
+ "Epoch 353/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1639 - root_mean_squared_error: 1.0908 - val_loss: 1.1645 - val_root_mean_squared_error: 1.0712\n",
+ "Epoch 354/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1684 - root_mean_squared_error: 1.0880 - val_loss: 1.1560 - val_root_mean_squared_error: 1.1012\n",
+ "Epoch 355/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1706 - root_mean_squared_error: 1.0812 - val_loss: 1.1541 - val_root_mean_squared_error: 1.1048\n",
+ "Epoch 356/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1752 - root_mean_squared_error: 1.0939 - val_loss: 1.1823 - val_root_mean_squared_error: 1.1099\n",
+ "Epoch 357/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1713 - root_mean_squared_error: 1.0902 - val_loss: 1.1756 - val_root_mean_squared_error: 1.1049\n",
+ "Epoch 358/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1659 - root_mean_squared_error: 1.1003 - val_loss: 1.1686 - val_root_mean_squared_error: 1.0608\n",
+ "Epoch 359/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1710 - root_mean_squared_error: 1.0972 - val_loss: 1.1749 - val_root_mean_squared_error: 1.0863\n",
+ "Epoch 360/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1716 - root_mean_squared_error: 1.0863 - val_loss: 1.1798 - val_root_mean_squared_error: 1.1173\n",
+ "Epoch 361/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1672 - root_mean_squared_error: 1.0931 - val_loss: 1.1951 - val_root_mean_squared_error: 1.1276\n",
+ "Epoch 362/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1663 - root_mean_squared_error: 1.0978 - val_loss: 1.1738 - val_root_mean_squared_error: 1.0941\n",
+ "Epoch 363/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1761 - root_mean_squared_error: 1.0992 - val_loss: 1.1486 - val_root_mean_squared_error: 1.0913\n",
+ "Epoch 364/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1643 - root_mean_squared_error: 1.0851 - val_loss: 1.1557 - val_root_mean_squared_error: 1.0759\n",
+ "Epoch 365/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1602 - root_mean_squared_error: 1.0806 - val_loss: 1.1634 - val_root_mean_squared_error: 1.0977\n",
+ "Epoch 366/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1675 - root_mean_squared_error: 1.0830 - val_loss: 1.1800 - val_root_mean_squared_error: 1.1498\n",
+ "Epoch 367/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1662 - root_mean_squared_error: 1.0769 - val_loss: 1.1580 - val_root_mean_squared_error: 1.0609\n",
+ "Epoch 368/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1686 - root_mean_squared_error: 1.0848 - val_loss: 1.1530 - val_root_mean_squared_error: 1.1113\n",
+ "Epoch 369/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1615 - root_mean_squared_error: 1.0944 - val_loss: 1.1777 - val_root_mean_squared_error: 1.0814\n",
+ "Epoch 370/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1681 - root_mean_squared_error: 1.0827 - val_loss: 1.1689 - val_root_mean_squared_error: 1.0782\n",
+ "Epoch 371/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1640 - root_mean_squared_error: 1.1089 - val_loss: 1.1818 - val_root_mean_squared_error: 1.0902\n",
+ "Epoch 372/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1696 - root_mean_squared_error: 1.0932 - val_loss: 1.1847 - val_root_mean_squared_error: 1.0768\n",
+ "Epoch 373/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1690 - root_mean_squared_error: 1.0996 - val_loss: 1.1756 - val_root_mean_squared_error: 1.0760\n",
+ "Epoch 374/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1676 - root_mean_squared_error: 1.0737 - val_loss: 1.1377 - val_root_mean_squared_error: 1.1017\n",
+ "Epoch 375/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1686 - root_mean_squared_error: 1.0830 - val_loss: 1.1768 - val_root_mean_squared_error: 1.1312\n",
+ "Epoch 376/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1649 - root_mean_squared_error: 1.0877 - val_loss: 1.1725 - val_root_mean_squared_error: 1.1236\n",
+ "Epoch 377/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1846 - root_mean_squared_error: 1.0813 - val_loss: 1.1570 - val_root_mean_squared_error: 1.0769\n",
+ "Epoch 378/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1672 - root_mean_squared_error: 1.0842 - val_loss: 1.1695 - val_root_mean_squared_error: 1.0713\n",
+ "Epoch 379/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1629 - root_mean_squared_error: 1.0575 - val_loss: 1.1490 - val_root_mean_squared_error: 1.0835\n",
+ "Epoch 380/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1636 - root_mean_squared_error: 1.0910 - val_loss: 1.1738 - val_root_mean_squared_error: 1.0299\n",
+ "Epoch 381/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1733 - root_mean_squared_error: 1.0862 - val_loss: 1.1566 - val_root_mean_squared_error: 1.0909\n",
+ "Epoch 382/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1773 - root_mean_squared_error: 1.0944 - val_loss: 1.1665 - val_root_mean_squared_error: 1.0639\n",
+ "Epoch 383/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1705 - root_mean_squared_error: 1.0819 - val_loss: 1.1586 - val_root_mean_squared_error: 1.0924\n",
+ "Epoch 384/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1828 - root_mean_squared_error: 1.1027 - val_loss: 1.1642 - val_root_mean_squared_error: 1.0758\n",
+ "Epoch 385/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1699 - root_mean_squared_error: 1.0974 - val_loss: 1.1746 - val_root_mean_squared_error: 1.0597\n",
+ "Epoch 386/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1663 - root_mean_squared_error: 1.1103 - val_loss: 1.1829 - val_root_mean_squared_error: 1.1275\n",
+ "Epoch 387/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1732 - root_mean_squared_error: 1.0967 - val_loss: 1.1796 - val_root_mean_squared_error: 1.0975\n",
+ "Epoch 388/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1678 - root_mean_squared_error: 1.0653 - val_loss: 1.1515 - val_root_mean_squared_error: 1.0676\n",
+ "Epoch 389/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1639 - root_mean_squared_error: 1.1016 - val_loss: 1.1680 - val_root_mean_squared_error: 1.0487\n",
+ "Epoch 390/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1698 - root_mean_squared_error: 1.0786 - val_loss: 1.1961 - val_root_mean_squared_error: 1.0935\n",
+ "Epoch 391/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1755 - root_mean_squared_error: 1.0867 - val_loss: 1.1742 - val_root_mean_squared_error: 1.0876\n",
+ "Epoch 392/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1671 - root_mean_squared_error: 1.0934 - val_loss: 1.1625 - val_root_mean_squared_error: 1.1110\n",
+ "Epoch 393/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1685 - root_mean_squared_error: 1.0865 - val_loss: 1.1544 - val_root_mean_squared_error: 1.1083\n",
+ "Epoch 394/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1728 - root_mean_squared_error: 1.0911 - val_loss: 1.1548 - val_root_mean_squared_error: 1.1117\n",
+ "Epoch 395/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1587 - root_mean_squared_error: 1.0882 - val_loss: 1.1523 - val_root_mean_squared_error: 1.0723\n",
+ "Epoch 396/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1620 - root_mean_squared_error: 1.0899 - val_loss: 1.1969 - val_root_mean_squared_error: 1.1401\n",
+ "Epoch 397/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1635 - root_mean_squared_error: 1.0754 - val_loss: 1.1490 - val_root_mean_squared_error: 1.0133\n",
+ "Epoch 398/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1740 - root_mean_squared_error: 1.1029 - val_loss: 1.1692 - val_root_mean_squared_error: 1.0812\n",
+ "Epoch 399/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1640 - root_mean_squared_error: 1.0750 - val_loss: 1.1691 - val_root_mean_squared_error: 1.0565\n",
+ "Epoch 400/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1670 - root_mean_squared_error: 1.0845 - val_loss: 1.1621 - val_root_mean_squared_error: 1.0536\n",
+ "Epoch 401/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1674 - root_mean_squared_error: 1.0930 - val_loss: 1.1717 - val_root_mean_squared_error: 1.0662\n",
+ "Epoch 402/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1737 - root_mean_squared_error: 1.1074 - val_loss: 1.1724 - val_root_mean_squared_error: 1.0402\n",
+ "Epoch 403/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1745 - root_mean_squared_error: 1.0928 - val_loss: 1.1489 - val_root_mean_squared_error: 1.0671\n",
+ "Epoch 404/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1634 - root_mean_squared_error: 1.0787 - val_loss: 1.1636 - val_root_mean_squared_error: 1.0467\n",
+ "Epoch 405/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1600 - root_mean_squared_error: 1.0717 - val_loss: 1.1558 - val_root_mean_squared_error: 1.0909\n",
+ "Epoch 406/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1691 - root_mean_squared_error: 1.0631 - val_loss: 1.1651 - val_root_mean_squared_error: 1.1063\n",
+ "Epoch 407/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1674 - root_mean_squared_error: 1.0783 - val_loss: 1.1643 - val_root_mean_squared_error: 1.1224\n",
+ "Epoch 408/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1810 - root_mean_squared_error: 1.1094 - val_loss: 1.1834 - val_root_mean_squared_error: 1.1124\n",
+ "Epoch 409/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1654 - root_mean_squared_error: 1.0810 - val_loss: 1.1611 - val_root_mean_squared_error: 1.0532\n",
+ "Epoch 410/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1658 - root_mean_squared_error: 1.1057 - val_loss: 1.1933 - val_root_mean_squared_error: 1.0905\n",
+ "Epoch 411/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1672 - root_mean_squared_error: 1.0965 - val_loss: 1.1548 - val_root_mean_squared_error: 1.0754\n",
+ "Epoch 412/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1599 - root_mean_squared_error: 1.0710 - val_loss: 1.1484 - val_root_mean_squared_error: 1.0975\n",
+ "Epoch 413/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1743 - root_mean_squared_error: 1.1044 - val_loss: 1.1604 - val_root_mean_squared_error: 1.1014\n",
+ "Epoch 414/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1569 - root_mean_squared_error: 1.0781 - val_loss: 1.1680 - val_root_mean_squared_error: 1.0504\n",
+ "Epoch 415/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1724 - root_mean_squared_error: 1.1017 - val_loss: 1.1670 - val_root_mean_squared_error: 1.0489\n",
+ "Epoch 416/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1658 - root_mean_squared_error: 1.0932 - val_loss: 1.1651 - val_root_mean_squared_error: 1.0422\n",
+ "Epoch 417/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1734 - root_mean_squared_error: 1.0944 - val_loss: 1.1738 - val_root_mean_squared_error: 1.1122\n",
+ "Epoch 418/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1633 - root_mean_squared_error: 1.1025 - val_loss: 1.1677 - val_root_mean_squared_error: 1.0591\n",
+ "Epoch 419/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1683 - root_mean_squared_error: 1.0850 - val_loss: 1.1543 - val_root_mean_squared_error: 1.0725\n",
+ "Epoch 420/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1779 - root_mean_squared_error: 1.0999 - val_loss: 1.1661 - val_root_mean_squared_error: 1.0775\n",
+ "Epoch 421/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1641 - root_mean_squared_error: 1.1102 - val_loss: 1.1578 - val_root_mean_squared_error: 1.0298\n",
+ "Epoch 422/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1619 - root_mean_squared_error: 1.0956 - val_loss: 1.1614 - val_root_mean_squared_error: 1.0886\n",
+ "Epoch 423/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1631 - root_mean_squared_error: 1.0826 - val_loss: 1.1649 - val_root_mean_squared_error: 1.0768\n",
+ "Epoch 424/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1650 - root_mean_squared_error: 1.0913 - val_loss: 1.1870 - val_root_mean_squared_error: 1.0932\n",
+ "Epoch 425/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1687 - root_mean_squared_error: 1.0835 - val_loss: 1.2007 - val_root_mean_squared_error: 1.0963\n",
+ "Epoch 426/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1639 - root_mean_squared_error: 1.1121 - val_loss: 1.1643 - val_root_mean_squared_error: 1.0113\n",
+ "Epoch 427/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1630 - root_mean_squared_error: 1.0726 - val_loss: 1.1506 - val_root_mean_squared_error: 1.0226\n",
+ "Epoch 428/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1628 - root_mean_squared_error: 1.0543 - val_loss: 1.1696 - val_root_mean_squared_error: 1.0702\n",
+ "Epoch 429/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1794 - root_mean_squared_error: 1.0939 - val_loss: 1.1428 - val_root_mean_squared_error: 1.0545\n",
+ "Epoch 430/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1663 - root_mean_squared_error: 1.0878 - val_loss: 1.1644 - val_root_mean_squared_error: 1.1079\n",
+ "Epoch 431/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1655 - root_mean_squared_error: 1.0995 - val_loss: 1.1520 - val_root_mean_squared_error: 1.0712\n",
+ "Epoch 432/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1738 - root_mean_squared_error: 1.0925 - val_loss: 1.1539 - val_root_mean_squared_error: 1.0906\n",
+ "Epoch 433/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1665 - root_mean_squared_error: 1.0892 - val_loss: 1.1605 - val_root_mean_squared_error: 1.1270\n",
+ "Epoch 434/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1701 - root_mean_squared_error: 1.0928 - val_loss: 1.1606 - val_root_mean_squared_error: 1.0144\n",
+ "Epoch 435/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1705 - root_mean_squared_error: 1.0851 - val_loss: 1.1839 - val_root_mean_squared_error: 1.0902\n",
+ "Epoch 436/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1721 - root_mean_squared_error: 1.0853 - val_loss: 1.1678 - val_root_mean_squared_error: 1.0623\n",
+ "Epoch 437/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1566 - root_mean_squared_error: 1.0811 - val_loss: 1.1603 - val_root_mean_squared_error: 1.0661\n",
+ "Epoch 438/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1647 - root_mean_squared_error: 1.0788 - val_loss: 1.1704 - val_root_mean_squared_error: 1.1135\n",
+ "Epoch 439/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1673 - root_mean_squared_error: 1.0842 - val_loss: 1.1647 - val_root_mean_squared_error: 1.1072\n",
+ "Epoch 440/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1649 - root_mean_squared_error: 1.0650 - val_loss: 1.1566 - val_root_mean_squared_error: 1.0896\n",
+ "Epoch 441/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1640 - root_mean_squared_error: 1.0770 - val_loss: 1.1780 - val_root_mean_squared_error: 1.0574\n",
+ "Epoch 442/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1662 - root_mean_squared_error: 1.0780 - val_loss: 1.1729 - val_root_mean_squared_error: 1.0739\n",
+ "Epoch 443/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1708 - root_mean_squared_error: 1.0931 - val_loss: 1.1489 - val_root_mean_squared_error: 1.0832\n",
+ "Epoch 444/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1597 - root_mean_squared_error: 1.0756 - val_loss: 1.1715 - val_root_mean_squared_error: 1.0578\n",
+ "Epoch 445/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1679 - root_mean_squared_error: 1.0957 - val_loss: 1.1559 - val_root_mean_squared_error: 1.0926\n",
+ "Epoch 446/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1648 - root_mean_squared_error: 1.0944 - val_loss: 1.1519 - val_root_mean_squared_error: 1.0520\n",
+ "Epoch 447/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1585 - root_mean_squared_error: 1.0607 - val_loss: 1.1609 - val_root_mean_squared_error: 1.0529\n",
+ "Epoch 448/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1578 - root_mean_squared_error: 1.0852 - val_loss: 1.1672 - val_root_mean_squared_error: 1.0587\n",
+ "Epoch 449/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1596 - root_mean_squared_error: 1.0831 - val_loss: 1.1641 - val_root_mean_squared_error: 1.0725\n",
+ "Epoch 450/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1598 - root_mean_squared_error: 1.0623 - val_loss: 1.1958 - val_root_mean_squared_error: 1.0994\n",
+ "Epoch 451/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1622 - root_mean_squared_error: 1.0949 - val_loss: 1.1546 - val_root_mean_squared_error: 1.0990\n",
+ "Epoch 452/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1620 - root_mean_squared_error: 1.0843 - val_loss: 1.1697 - val_root_mean_squared_error: 1.0614\n",
+ "Epoch 453/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1657 - root_mean_squared_error: 1.0796 - val_loss: 1.1623 - val_root_mean_squared_error: 1.0683\n",
+ "Epoch 454/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1612 - root_mean_squared_error: 1.0956 - val_loss: 1.1795 - val_root_mean_squared_error: 1.0980\n",
+ "Epoch 455/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1623 - root_mean_squared_error: 1.0651 - val_loss: 1.1562 - val_root_mean_squared_error: 1.1370\n",
+ "Epoch 456/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1666 - root_mean_squared_error: 1.0940 - val_loss: 1.1493 - val_root_mean_squared_error: 1.0755\n",
+ "Epoch 457/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1609 - root_mean_squared_error: 1.0823 - val_loss: 1.1584 - val_root_mean_squared_error: 1.0985\n",
+ "Epoch 458/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1676 - root_mean_squared_error: 1.0987 - val_loss: 1.1502 - val_root_mean_squared_error: 1.0958\n",
+ "Epoch 459/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1654 - root_mean_squared_error: 1.0963 - val_loss: 1.1636 - val_root_mean_squared_error: 1.0613\n",
+ "Epoch 460/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1682 - root_mean_squared_error: 1.0889 - val_loss: 1.1555 - val_root_mean_squared_error: 1.0507\n",
+ "Epoch 461/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1566 - root_mean_squared_error: 1.0871 - val_loss: 1.1875 - val_root_mean_squared_error: 1.1143\n",
+ "Epoch 462/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1691 - root_mean_squared_error: 1.0926 - val_loss: 1.1926 - val_root_mean_squared_error: 1.1470\n",
+ "Epoch 463/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1580 - root_mean_squared_error: 1.0815 - val_loss: 1.1689 - val_root_mean_squared_error: 1.1151\n",
+ "Epoch 464/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1625 - root_mean_squared_error: 1.0883 - val_loss: 1.1668 - val_root_mean_squared_error: 1.0881\n",
+ "Epoch 465/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1651 - root_mean_squared_error: 1.0812 - val_loss: 1.1561 - val_root_mean_squared_error: 1.0960\n",
+ "Epoch 466/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1720 - root_mean_squared_error: 1.0953 - val_loss: 1.1705 - val_root_mean_squared_error: 1.0467\n",
+ "Epoch 467/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1648 - root_mean_squared_error: 1.0735 - val_loss: 1.1609 - val_root_mean_squared_error: 1.0683\n",
+ "Epoch 468/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1633 - root_mean_squared_error: 1.0946 - val_loss: 1.1790 - val_root_mean_squared_error: 1.0887\n",
+ "Epoch 469/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1662 - root_mean_squared_error: 1.0943 - val_loss: 1.1657 - val_root_mean_squared_error: 1.0825\n",
+ "Epoch 470/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1670 - root_mean_squared_error: 1.0905 - val_loss: 1.1667 - val_root_mean_squared_error: 1.0892\n",
+ "Epoch 471/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1634 - root_mean_squared_error: 1.0915 - val_loss: 1.1662 - val_root_mean_squared_error: 1.0956\n",
+ "Epoch 472/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1674 - root_mean_squared_error: 1.0770 - val_loss: 1.1524 - val_root_mean_squared_error: 1.0521\n",
+ "Epoch 473/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1590 - root_mean_squared_error: 1.0616 - val_loss: 1.1887 - val_root_mean_squared_error: 1.0815\n",
+ "Epoch 474/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1714 - root_mean_squared_error: 1.0703 - val_loss: 1.1622 - val_root_mean_squared_error: 1.0760\n",
+ "Epoch 475/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1623 - root_mean_squared_error: 1.0783 - val_loss: 1.1757 - val_root_mean_squared_error: 1.0876\n",
+ "Epoch 476/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1598 - root_mean_squared_error: 1.0871 - val_loss: 1.1558 - val_root_mean_squared_error: 1.0893\n",
+ "Epoch 477/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1701 - root_mean_squared_error: 1.0887 - val_loss: 1.1657 - val_root_mean_squared_error: 1.0804\n",
+ "Epoch 478/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1610 - root_mean_squared_error: 1.0699 - val_loss: 1.1640 - val_root_mean_squared_error: 1.1044\n",
+ "Epoch 479/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1693 - root_mean_squared_error: 1.1131 - val_loss: 1.1551 - val_root_mean_squared_error: 1.0661\n",
+ "Epoch 480/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1652 - root_mean_squared_error: 1.0780 - val_loss: 1.1784 - val_root_mean_squared_error: 1.0890\n",
+ "Epoch 481/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1665 - root_mean_squared_error: 1.0868 - val_loss: 1.1673 - val_root_mean_squared_error: 1.0974\n",
+ "Epoch 482/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1613 - root_mean_squared_error: 1.0757 - val_loss: 1.1672 - val_root_mean_squared_error: 1.0645\n",
+ "Epoch 483/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1748 - root_mean_squared_error: 1.0684 - val_loss: 1.1654 - val_root_mean_squared_error: 1.0787\n",
+ "Epoch 484/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1660 - root_mean_squared_error: 1.0886 - val_loss: 1.1966 - val_root_mean_squared_error: 1.0748\n",
+ "Epoch 485/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1613 - root_mean_squared_error: 1.0850 - val_loss: 1.1705 - val_root_mean_squared_error: 1.0734\n",
+ "Epoch 486/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1680 - root_mean_squared_error: 1.0805 - val_loss: 1.1714 - val_root_mean_squared_error: 1.0726\n",
+ "Epoch 487/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1624 - root_mean_squared_error: 1.0916 - val_loss: 1.1532 - val_root_mean_squared_error: 1.0743\n",
+ "Epoch 488/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1694 - root_mean_squared_error: 1.1050 - val_loss: 1.1563 - val_root_mean_squared_error: 1.1053\n",
+ "Epoch 489/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1566 - root_mean_squared_error: 1.0682 - val_loss: 1.1667 - val_root_mean_squared_error: 1.0838\n",
+ "Epoch 490/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1600 - root_mean_squared_error: 1.0807 - val_loss: 1.1627 - val_root_mean_squared_error: 1.1198\n",
+ "Epoch 491/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1578 - root_mean_squared_error: 1.0827 - val_loss: 1.1707 - val_root_mean_squared_error: 1.0678\n",
+ "Epoch 492/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1710 - root_mean_squared_error: 1.0701 - val_loss: 1.1707 - val_root_mean_squared_error: 1.0445\n",
+ "Epoch 493/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1639 - root_mean_squared_error: 1.0914 - val_loss: 1.1548 - val_root_mean_squared_error: 1.0918\n",
+ "Epoch 494/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1623 - root_mean_squared_error: 1.0948 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0688\n",
+ "Epoch 495/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1590 - root_mean_squared_error: 1.0801 - val_loss: 1.1792 - val_root_mean_squared_error: 1.1031\n",
+ "Epoch 496/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1623 - root_mean_squared_error: 1.0862 - val_loss: 1.1671 - val_root_mean_squared_error: 1.1219\n",
+ "Epoch 497/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1615 - root_mean_squared_error: 1.0739 - val_loss: 1.1659 - val_root_mean_squared_error: 1.0773\n",
+ "Epoch 498/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1679 - root_mean_squared_error: 1.0886 - val_loss: 1.1564 - val_root_mean_squared_error: 1.0725\n",
+ "Epoch 499/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1556 - root_mean_squared_error: 1.0971 - val_loss: 1.1580 - val_root_mean_squared_error: 1.0555\n",
+ "Epoch 500/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1694 - root_mean_squared_error: 1.0899 - val_loss: 1.1647 - val_root_mean_squared_error: 1.1243\n",
+ "Epoch 501/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1601 - root_mean_squared_error: 1.0823 - val_loss: 1.1635 - val_root_mean_squared_error: 1.0634\n",
+ "Epoch 502/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1593 - root_mean_squared_error: 1.0695 - val_loss: 1.1550 - val_root_mean_squared_error: 1.0966\n",
+ "Epoch 503/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1613 - root_mean_squared_error: 1.0714 - val_loss: 1.1572 - val_root_mean_squared_error: 1.1005\n",
+ "Epoch 504/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1615 - root_mean_squared_error: 1.0599 - val_loss: 1.1588 - val_root_mean_squared_error: 1.0677\n",
+ "Epoch 505/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1561 - root_mean_squared_error: 1.0793 - val_loss: 1.1731 - val_root_mean_squared_error: 1.1111\n",
+ "Epoch 506/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1664 - root_mean_squared_error: 1.0933 - val_loss: 1.1522 - val_root_mean_squared_error: 1.0468\n",
+ "Epoch 507/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1630 - root_mean_squared_error: 1.0989 - val_loss: 1.1569 - val_root_mean_squared_error: 1.0894\n",
+ "Epoch 508/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1682 - root_mean_squared_error: 1.0888 - val_loss: 1.1510 - val_root_mean_squared_error: 1.1122\n",
+ "Epoch 509/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1651 - root_mean_squared_error: 1.0630 - val_loss: 1.1753 - val_root_mean_squared_error: 1.0957\n",
+ "Epoch 510/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1603 - root_mean_squared_error: 1.0969 - val_loss: 1.1489 - val_root_mean_squared_error: 1.0804\n",
+ "Epoch 511/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1723 - root_mean_squared_error: 1.0951 - val_loss: 1.1640 - val_root_mean_squared_error: 1.0593\n",
+ "Epoch 512/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1599 - root_mean_squared_error: 1.0953 - val_loss: 1.1481 - val_root_mean_squared_error: 1.0105\n",
+ "Epoch 513/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1594 - root_mean_squared_error: 1.0591 - val_loss: 1.1826 - val_root_mean_squared_error: 1.0528\n",
+ "Epoch 514/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1670 - root_mean_squared_error: 1.0913 - val_loss: 1.1518 - val_root_mean_squared_error: 1.0715\n",
+ "Epoch 515/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1620 - root_mean_squared_error: 1.0845 - val_loss: 1.1672 - val_root_mean_squared_error: 1.1216\n",
+ "Epoch 516/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1627 - root_mean_squared_error: 1.0731 - val_loss: 1.1564 - val_root_mean_squared_error: 1.0803\n",
+ "Epoch 517/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1587 - root_mean_squared_error: 1.0832 - val_loss: 1.1518 - val_root_mean_squared_error: 1.0779\n",
+ "Epoch 518/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1555 - root_mean_squared_error: 1.0839 - val_loss: 1.1482 - val_root_mean_squared_error: 1.0693\n",
+ "Epoch 519/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0826 - val_loss: 1.1521 - val_root_mean_squared_error: 1.0596\n",
+ "Epoch 520/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1597 - root_mean_squared_error: 1.0847 - val_loss: 1.1579 - val_root_mean_squared_error: 1.0731\n",
+ "Epoch 521/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1606 - root_mean_squared_error: 1.0668 - val_loss: 1.1657 - val_root_mean_squared_error: 1.0874\n",
+ "Epoch 522/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1652 - root_mean_squared_error: 1.0876 - val_loss: 1.1598 - val_root_mean_squared_error: 1.0735\n",
+ "Epoch 523/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1656 - root_mean_squared_error: 1.0813 - val_loss: 1.1735 - val_root_mean_squared_error: 1.1153\n",
+ "Epoch 524/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1604 - root_mean_squared_error: 1.0770 - val_loss: 1.1767 - val_root_mean_squared_error: 1.0771\n",
+ "Epoch 525/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1578 - root_mean_squared_error: 1.0886 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0693\n",
+ "Epoch 526/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1653 - root_mean_squared_error: 1.0806 - val_loss: 1.1727 - val_root_mean_squared_error: 1.0715\n",
+ "Epoch 527/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1555 - root_mean_squared_error: 1.0772 - val_loss: 1.1745 - val_root_mean_squared_error: 1.0405\n",
+ "Epoch 528/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1585 - root_mean_squared_error: 1.0688 - val_loss: 1.1528 - val_root_mean_squared_error: 1.0850\n",
+ "Epoch 529/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1707 - root_mean_squared_error: 1.0797 - val_loss: 1.1642 - val_root_mean_squared_error: 1.1010\n",
+ "Epoch 530/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1528 - root_mean_squared_error: 1.0613 - val_loss: 1.1666 - val_root_mean_squared_error: 1.0957\n",
+ "Epoch 531/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1616 - root_mean_squared_error: 1.0873 - val_loss: 1.1734 - val_root_mean_squared_error: 1.0489\n",
+ "Epoch 532/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1652 - root_mean_squared_error: 1.0865 - val_loss: 1.1807 - val_root_mean_squared_error: 1.1281\n",
+ "Epoch 533/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1602 - root_mean_squared_error: 1.0554 - val_loss: 1.1623 - val_root_mean_squared_error: 1.0259\n",
+ "Epoch 534/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1572 - root_mean_squared_error: 1.0781 - val_loss: 1.1671 - val_root_mean_squared_error: 1.0891\n",
+ "Epoch 535/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1705 - root_mean_squared_error: 1.0794 - val_loss: 1.1708 - val_root_mean_squared_error: 1.0622\n",
+ "Epoch 536/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1607 - root_mean_squared_error: 1.0836 - val_loss: 1.1627 - val_root_mean_squared_error: 1.0867\n",
+ "Epoch 537/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1546 - root_mean_squared_error: 1.0977 - val_loss: 1.1588 - val_root_mean_squared_error: 1.0565\n",
+ "Epoch 538/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1637 - root_mean_squared_error: 1.0670 - val_loss: 1.1633 - val_root_mean_squared_error: 1.0638\n",
+ "Epoch 539/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1665 - root_mean_squared_error: 1.0641 - val_loss: 1.1551 - val_root_mean_squared_error: 1.0361\n",
+ "Epoch 540/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1709 - root_mean_squared_error: 1.0765 - val_loss: 1.1607 - val_root_mean_squared_error: 1.1138\n",
+ "Epoch 541/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1558 - root_mean_squared_error: 1.0820 - val_loss: 1.1606 - val_root_mean_squared_error: 1.0833\n",
+ "Epoch 542/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1660 - root_mean_squared_error: 1.0898 - val_loss: 1.1646 - val_root_mean_squared_error: 1.0779\n",
+ "Epoch 543/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1580 - root_mean_squared_error: 1.0879 - val_loss: 1.1760 - val_root_mean_squared_error: 1.0709\n",
+ "Epoch 544/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1732 - root_mean_squared_error: 1.0739 - val_loss: 1.1481 - val_root_mean_squared_error: 1.0456\n",
+ "Epoch 545/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1651 - root_mean_squared_error: 1.0873 - val_loss: 1.1628 - val_root_mean_squared_error: 1.0657\n",
+ "Epoch 546/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1578 - root_mean_squared_error: 1.0780 - val_loss: 1.1620 - val_root_mean_squared_error: 1.0965\n",
+ "Epoch 547/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1690 - root_mean_squared_error: 1.0880 - val_loss: 1.1514 - val_root_mean_squared_error: 1.0893\n",
+ "Epoch 548/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1560 - root_mean_squared_error: 1.0918 - val_loss: 1.1462 - val_root_mean_squared_error: 1.0672\n",
+ "Epoch 549/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1596 - root_mean_squared_error: 1.0684 - val_loss: 1.1778 - val_root_mean_squared_error: 1.0988\n",
+ "Epoch 550/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1612 - root_mean_squared_error: 1.0876 - val_loss: 1.1717 - val_root_mean_squared_error: 1.1014\n",
+ "Epoch 551/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1571 - root_mean_squared_error: 1.0694 - val_loss: 1.1473 - val_root_mean_squared_error: 1.1035\n",
+ "Epoch 552/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1602 - root_mean_squared_error: 1.0545 - val_loss: 1.1512 - val_root_mean_squared_error: 1.0871\n",
+ "Epoch 553/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1566 - root_mean_squared_error: 1.0853 - val_loss: 1.1663 - val_root_mean_squared_error: 1.0507\n",
+ "Epoch 554/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1635 - root_mean_squared_error: 1.0900 - val_loss: 1.1638 - val_root_mean_squared_error: 1.1135\n",
+ "Epoch 555/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1580 - root_mean_squared_error: 1.0784 - val_loss: 1.1656 - val_root_mean_squared_error: 1.1171\n",
+ "Epoch 556/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1534 - root_mean_squared_error: 1.0676 - val_loss: 1.1631 - val_root_mean_squared_error: 1.0846\n",
+ "Epoch 557/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1632 - root_mean_squared_error: 1.0819 - val_loss: 1.1542 - val_root_mean_squared_error: 1.1208\n",
+ "Epoch 558/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1600 - root_mean_squared_error: 1.0726 - val_loss: 1.1580 - val_root_mean_squared_error: 1.1077\n",
+ "Epoch 559/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1556 - root_mean_squared_error: 1.0737 - val_loss: 1.1683 - val_root_mean_squared_error: 1.1152\n",
+ "Epoch 560/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1613 - root_mean_squared_error: 1.0643 - val_loss: 1.1491 - val_root_mean_squared_error: 1.0473\n",
+ "Epoch 561/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1582 - root_mean_squared_error: 1.0816 - val_loss: 1.1559 - val_root_mean_squared_error: 1.0545\n",
+ "Epoch 562/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1685 - root_mean_squared_error: 1.0961 - val_loss: 1.1422 - val_root_mean_squared_error: 1.0735\n",
+ "Epoch 563/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1655 - root_mean_squared_error: 1.0781 - val_loss: 1.1745 - val_root_mean_squared_error: 1.0599\n",
+ "Epoch 564/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1552 - root_mean_squared_error: 1.1041 - val_loss: 1.1788 - val_root_mean_squared_error: 1.0620\n",
+ "Epoch 565/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1594 - root_mean_squared_error: 1.0665 - val_loss: 1.1717 - val_root_mean_squared_error: 1.0517\n",
+ "Epoch 566/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1605 - root_mean_squared_error: 1.0719 - val_loss: 1.1689 - val_root_mean_squared_error: 1.0853\n",
+ "Epoch 567/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1636 - root_mean_squared_error: 1.0895 - val_loss: 1.1573 - val_root_mean_squared_error: 1.0557\n",
+ "Epoch 568/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1669 - root_mean_squared_error: 1.0832 - val_loss: 1.1434 - val_root_mean_squared_error: 1.1346\n",
+ "Epoch 569/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1568 - root_mean_squared_error: 1.0810 - val_loss: 1.1721 - val_root_mean_squared_error: 1.1271\n",
+ "Epoch 570/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1548 - root_mean_squared_error: 1.0859 - val_loss: 1.1405 - val_root_mean_squared_error: 1.0838\n",
+ "Epoch 571/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1634 - root_mean_squared_error: 1.0806 - val_loss: 1.1558 - val_root_mean_squared_error: 1.0724\n",
+ "Epoch 572/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1600 - root_mean_squared_error: 1.0865 - val_loss: 1.1548 - val_root_mean_squared_error: 1.0891\n",
+ "Epoch 573/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1597 - root_mean_squared_error: 1.1015 - val_loss: 1.1587 - val_root_mean_squared_error: 1.0854\n",
+ "Epoch 574/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1602 - root_mean_squared_error: 1.0948 - val_loss: 1.1557 - val_root_mean_squared_error: 1.0843\n",
+ "Epoch 575/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1546 - root_mean_squared_error: 1.0790 - val_loss: 1.1484 - val_root_mean_squared_error: 1.0559\n",
+ "Epoch 576/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1595 - root_mean_squared_error: 1.0922 - val_loss: 1.1682 - val_root_mean_squared_error: 1.1132\n",
+ "Epoch 577/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1561 - root_mean_squared_error: 1.0903 - val_loss: 1.1451 - val_root_mean_squared_error: 1.0783\n",
+ "Epoch 578/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1599 - root_mean_squared_error: 1.0858 - val_loss: 1.1595 - val_root_mean_squared_error: 1.0641\n",
+ "Epoch 579/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1597 - root_mean_squared_error: 1.0522 - val_loss: 1.1794 - val_root_mean_squared_error: 1.1094\n",
+ "Epoch 580/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1609 - root_mean_squared_error: 1.0713 - val_loss: 1.1611 - val_root_mean_squared_error: 1.1173\n",
+ "Epoch 581/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1614 - root_mean_squared_error: 1.0934 - val_loss: 1.1607 - val_root_mean_squared_error: 1.1073\n",
+ "Epoch 582/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1532 - root_mean_squared_error: 1.0918 - val_loss: 1.1563 - val_root_mean_squared_error: 1.0832\n",
+ "Epoch 583/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1711 - root_mean_squared_error: 1.0713 - val_loss: 1.1500 - val_root_mean_squared_error: 1.0636\n",
+ "Epoch 584/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1506 - root_mean_squared_error: 1.0792 - val_loss: 1.1456 - val_root_mean_squared_error: 1.0688\n",
+ "Epoch 585/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1625 - root_mean_squared_error: 1.0897 - val_loss: 1.1663 - val_root_mean_squared_error: 1.1221\n",
+ "Epoch 586/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1589 - root_mean_squared_error: 1.0927 - val_loss: 1.1666 - val_root_mean_squared_error: 1.0804\n",
+ "Epoch 587/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1558 - root_mean_squared_error: 1.0765 - val_loss: 1.1751 - val_root_mean_squared_error: 1.0710\n",
+ "Epoch 588/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1660 - root_mean_squared_error: 1.0771 - val_loss: 1.1510 - val_root_mean_squared_error: 1.0701\n",
+ "Epoch 589/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1641 - root_mean_squared_error: 1.0761 - val_loss: 1.1729 - val_root_mean_squared_error: 1.1052\n",
+ "Epoch 590/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1587 - root_mean_squared_error: 1.0887 - val_loss: 1.1561 - val_root_mean_squared_error: 1.0983\n",
+ "Epoch 591/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1676 - root_mean_squared_error: 1.0930 - val_loss: 1.1603 - val_root_mean_squared_error: 1.0546\n",
+ "Epoch 592/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1660 - root_mean_squared_error: 1.1001 - val_loss: 1.1661 - val_root_mean_squared_error: 1.0704\n",
+ "Epoch 593/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1596 - root_mean_squared_error: 1.0890 - val_loss: 1.1597 - val_root_mean_squared_error: 1.0350\n",
+ "Epoch 594/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0745 - val_loss: 1.1639 - val_root_mean_squared_error: 1.0932\n",
+ "Epoch 595/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1574 - root_mean_squared_error: 1.0931 - val_loss: 1.1647 - val_root_mean_squared_error: 1.0579\n",
+ "Epoch 596/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1627 - root_mean_squared_error: 1.0878 - val_loss: 1.1702 - val_root_mean_squared_error: 1.1109\n",
+ "Epoch 597/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1563 - root_mean_squared_error: 1.0786 - val_loss: 1.1536 - val_root_mean_squared_error: 1.1091\n",
+ "Epoch 598/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1601 - root_mean_squared_error: 1.0639 - val_loss: 1.1454 - val_root_mean_squared_error: 1.0933\n",
+ "Epoch 599/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1571 - root_mean_squared_error: 1.0745 - val_loss: 1.1545 - val_root_mean_squared_error: 1.0784\n",
+ "Epoch 600/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1656 - root_mean_squared_error: 1.0740 - val_loss: 1.1686 - val_root_mean_squared_error: 1.1170\n",
+ "Epoch 601/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1584 - root_mean_squared_error: 1.0983 - val_loss: 1.1719 - val_root_mean_squared_error: 1.0628\n",
+ "Epoch 602/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1590 - root_mean_squared_error: 1.0751 - val_loss: 1.1712 - val_root_mean_squared_error: 1.0864\n",
+ "Epoch 603/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1613 - root_mean_squared_error: 1.0872 - val_loss: 1.1463 - val_root_mean_squared_error: 1.0829\n",
+ "Epoch 604/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1640 - root_mean_squared_error: 1.1084 - val_loss: 1.1701 - val_root_mean_squared_error: 1.0941\n",
+ "Epoch 605/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1588 - root_mean_squared_error: 1.0718 - val_loss: 1.1782 - val_root_mean_squared_error: 1.1237\n",
+ "Epoch 606/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1631 - root_mean_squared_error: 1.0892 - val_loss: 1.1624 - val_root_mean_squared_error: 1.0823\n",
+ "Epoch 607/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1586 - root_mean_squared_error: 1.0772 - val_loss: 1.1613 - val_root_mean_squared_error: 1.1258\n",
+ "Epoch 608/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1584 - root_mean_squared_error: 1.0901 - val_loss: 1.1523 - val_root_mean_squared_error: 1.0829\n",
+ "Epoch 609/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1600 - root_mean_squared_error: 1.0919 - val_loss: 1.1677 - val_root_mean_squared_error: 1.0809\n",
+ "Epoch 610/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0788 - val_loss: 1.1556 - val_root_mean_squared_error: 1.0344\n",
+ "Epoch 611/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1602 - root_mean_squared_error: 1.0736 - val_loss: 1.1601 - val_root_mean_squared_error: 1.0611\n",
+ "Epoch 612/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1642 - root_mean_squared_error: 1.0807 - val_loss: 1.1568 - val_root_mean_squared_error: 1.0514\n",
+ "Epoch 613/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1606 - root_mean_squared_error: 1.0730 - val_loss: 1.1775 - val_root_mean_squared_error: 1.0962\n",
+ "Epoch 614/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1547 - root_mean_squared_error: 1.0761 - val_loss: 1.1575 - val_root_mean_squared_error: 1.0986\n",
+ "Epoch 615/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1635 - root_mean_squared_error: 1.0887 - val_loss: 1.1677 - val_root_mean_squared_error: 1.0893\n",
+ "Epoch 616/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1539 - root_mean_squared_error: 1.0783 - val_loss: 1.1626 - val_root_mean_squared_error: 1.0739\n",
+ "Epoch 617/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1617 - root_mean_squared_error: 1.0933 - val_loss: 1.1522 - val_root_mean_squared_error: 1.0814\n",
+ "Epoch 618/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1658 - root_mean_squared_error: 1.0977 - val_loss: 1.1564 - val_root_mean_squared_error: 1.0838\n",
+ "Epoch 619/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1584 - root_mean_squared_error: 1.0750 - val_loss: 1.1622 - val_root_mean_squared_error: 1.1273\n",
+ "Epoch 620/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1519 - root_mean_squared_error: 1.0791 - val_loss: 1.1692 - val_root_mean_squared_error: 1.0446\n",
+ "Epoch 621/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1614 - root_mean_squared_error: 1.0646 - val_loss: 1.1713 - val_root_mean_squared_error: 1.0720\n",
+ "Epoch 622/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1657 - root_mean_squared_error: 1.0726 - val_loss: 1.1639 - val_root_mean_squared_error: 1.0001\n",
+ "Epoch 623/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1567 - root_mean_squared_error: 1.0891 - val_loss: 1.1420 - val_root_mean_squared_error: 1.0607\n",
+ "Epoch 624/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1675 - root_mean_squared_error: 1.0964 - val_loss: 1.1560 - val_root_mean_squared_error: 1.0931\n",
+ "Epoch 625/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1590 - root_mean_squared_error: 1.0852 - val_loss: 1.1597 - val_root_mean_squared_error: 1.0425\n",
+ "Epoch 626/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1569 - root_mean_squared_error: 1.0747 - val_loss: 1.1596 - val_root_mean_squared_error: 1.1053\n",
+ "Epoch 627/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1595 - root_mean_squared_error: 1.0583 - val_loss: 1.1614 - val_root_mean_squared_error: 1.0592\n",
+ "Epoch 628/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1550 - root_mean_squared_error: 1.0923 - val_loss: 1.1852 - val_root_mean_squared_error: 1.0854\n",
+ "Epoch 629/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1600 - root_mean_squared_error: 1.0838 - val_loss: 1.1386 - val_root_mean_squared_error: 1.0419\n",
+ "Epoch 630/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1554 - root_mean_squared_error: 1.0741 - val_loss: 1.1554 - val_root_mean_squared_error: 1.0676\n",
+ "Epoch 631/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1661 - root_mean_squared_error: 1.0891 - val_loss: 1.1598 - val_root_mean_squared_error: 1.1025\n",
+ "Epoch 632/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1650 - root_mean_squared_error: 1.0839 - val_loss: 1.1651 - val_root_mean_squared_error: 1.0885\n",
+ "Epoch 633/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1539 - root_mean_squared_error: 1.0990 - val_loss: 1.1494 - val_root_mean_squared_error: 1.0609\n",
+ "Epoch 634/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1603 - root_mean_squared_error: 1.1106 - val_loss: 1.1494 - val_root_mean_squared_error: 1.0507\n",
+ "Epoch 635/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1579 - root_mean_squared_error: 1.0728 - val_loss: 1.1655 - val_root_mean_squared_error: 1.1007\n",
+ "Epoch 636/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1629 - root_mean_squared_error: 1.0821 - val_loss: 1.1605 - val_root_mean_squared_error: 1.0823\n",
+ "Epoch 637/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1648 - root_mean_squared_error: 1.0926 - val_loss: 1.1586 - val_root_mean_squared_error: 1.0754\n",
+ "Epoch 638/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1531 - root_mean_squared_error: 1.0829 - val_loss: 1.1659 - val_root_mean_squared_error: 1.0785\n",
+ "Epoch 639/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1626 - root_mean_squared_error: 1.0927 - val_loss: 1.1580 - val_root_mean_squared_error: 1.0443\n",
+ "Epoch 640/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1610 - root_mean_squared_error: 1.1027 - val_loss: 1.1467 - val_root_mean_squared_error: 1.0720\n",
+ "Epoch 641/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1583 - root_mean_squared_error: 1.0856 - val_loss: 1.1516 - val_root_mean_squared_error: 1.0546\n",
+ "Epoch 642/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1558 - root_mean_squared_error: 1.0676 - val_loss: 1.1464 - val_root_mean_squared_error: 1.0917\n",
+ "Epoch 643/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1561 - root_mean_squared_error: 1.0632 - val_loss: 1.1707 - val_root_mean_squared_error: 1.1238\n",
+ "Epoch 644/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1548 - root_mean_squared_error: 1.0729 - val_loss: 1.1663 - val_root_mean_squared_error: 1.0619\n",
+ "Epoch 645/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1644 - root_mean_squared_error: 1.0570 - val_loss: 1.1595 - val_root_mean_squared_error: 1.0658\n",
+ "Epoch 646/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1631 - root_mean_squared_error: 1.0901 - val_loss: 1.1662 - val_root_mean_squared_error: 1.0725\n",
+ "Epoch 647/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1590 - root_mean_squared_error: 1.0837 - val_loss: 1.1442 - val_root_mean_squared_error: 1.0990\n",
+ "Epoch 648/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1546 - root_mean_squared_error: 1.0826 - val_loss: 1.1569 - val_root_mean_squared_error: 1.0523\n",
+ "Epoch 649/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1616 - root_mean_squared_error: 1.0619 - val_loss: 1.1559 - val_root_mean_squared_error: 1.0919\n",
+ "Epoch 650/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1551 - root_mean_squared_error: 1.0713 - val_loss: 1.1588 - val_root_mean_squared_error: 1.1394\n",
+ "Epoch 651/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1586 - root_mean_squared_error: 1.0851 - val_loss: 1.1582 - val_root_mean_squared_error: 1.1153\n",
+ "Epoch 652/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1498 - root_mean_squared_error: 1.0406 - val_loss: 1.1498 - val_root_mean_squared_error: 1.0551\n",
+ "Epoch 653/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1595 - root_mean_squared_error: 1.0822 - val_loss: 1.1459 - val_root_mean_squared_error: 1.0344\n",
+ "Epoch 654/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1605 - root_mean_squared_error: 1.0608 - val_loss: 1.1573 - val_root_mean_squared_error: 1.0935\n",
+ "Epoch 655/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1595 - root_mean_squared_error: 1.1004 - val_loss: 1.1373 - val_root_mean_squared_error: 1.0718\n",
+ "Epoch 656/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1538 - root_mean_squared_error: 1.0791 - val_loss: 1.1543 - val_root_mean_squared_error: 1.0576\n",
+ "Epoch 657/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1567 - root_mean_squared_error: 1.0638 - val_loss: 1.1594 - val_root_mean_squared_error: 1.1031\n",
+ "Epoch 658/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1621 - root_mean_squared_error: 1.0886 - val_loss: 1.1780 - val_root_mean_squared_error: 1.0982\n",
+ "Epoch 659/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1624 - root_mean_squared_error: 1.0934 - val_loss: 1.1464 - val_root_mean_squared_error: 1.0760\n",
+ "Epoch 660/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1594 - root_mean_squared_error: 1.0877 - val_loss: 1.1596 - val_root_mean_squared_error: 1.0505\n",
+ "Epoch 661/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1559 - root_mean_squared_error: 1.0696 - val_loss: 1.1506 - val_root_mean_squared_error: 1.1318\n",
+ "Epoch 662/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1514 - root_mean_squared_error: 1.0784 - val_loss: 1.1507 - val_root_mean_squared_error: 1.0255\n",
+ "Epoch 663/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1573 - root_mean_squared_error: 1.0825 - val_loss: 1.1622 - val_root_mean_squared_error: 1.0516\n",
+ "Epoch 664/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1520 - root_mean_squared_error: 1.0754 - val_loss: 1.1793 - val_root_mean_squared_error: 1.0720\n",
+ "Epoch 665/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1539 - root_mean_squared_error: 1.0805 - val_loss: 1.1645 - val_root_mean_squared_error: 1.0848\n",
+ "Epoch 666/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1610 - root_mean_squared_error: 1.0765 - val_loss: 1.1723 - val_root_mean_squared_error: 1.0881\n",
+ "Epoch 667/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1611 - root_mean_squared_error: 1.0971 - val_loss: 1.1663 - val_root_mean_squared_error: 1.1083\n",
+ "Epoch 668/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0516 - val_loss: 1.1538 - val_root_mean_squared_error: 1.0830\n",
+ "Epoch 669/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1623 - root_mean_squared_error: 1.0959 - val_loss: 1.1464 - val_root_mean_squared_error: 1.0698\n",
+ "Epoch 670/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1700 - root_mean_squared_error: 1.0838 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0175\n",
+ "Epoch 671/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1582 - root_mean_squared_error: 1.0908 - val_loss: 1.1521 - val_root_mean_squared_error: 1.0876\n",
+ "Epoch 672/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1545 - root_mean_squared_error: 1.0835 - val_loss: 1.1493 - val_root_mean_squared_error: 1.1087\n",
+ "Epoch 673/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1530 - root_mean_squared_error: 1.0538 - val_loss: 1.1644 - val_root_mean_squared_error: 1.1060\n",
+ "Epoch 674/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1565 - root_mean_squared_error: 1.0744 - val_loss: 1.1460 - val_root_mean_squared_error: 1.0380\n",
+ "Epoch 675/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1514 - root_mean_squared_error: 1.0771 - val_loss: 1.1584 - val_root_mean_squared_error: 1.1080\n",
+ "Epoch 676/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1573 - root_mean_squared_error: 1.0719 - val_loss: 1.1606 - val_root_mean_squared_error: 1.0900\n",
+ "Epoch 677/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1601 - root_mean_squared_error: 1.0848 - val_loss: 1.1642 - val_root_mean_squared_error: 1.1267\n",
+ "Epoch 678/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1523 - root_mean_squared_error: 1.0891 - val_loss: 1.1517 - val_root_mean_squared_error: 1.0389\n",
+ "Epoch 679/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1654 - root_mean_squared_error: 1.0672 - val_loss: 1.1614 - val_root_mean_squared_error: 1.0804\n",
+ "Epoch 680/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1590 - root_mean_squared_error: 1.0640 - val_loss: 1.1660 - val_root_mean_squared_error: 1.0533\n",
+ "Epoch 681/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1588 - root_mean_squared_error: 1.0907 - val_loss: 1.1611 - val_root_mean_squared_error: 1.0769\n",
+ "Epoch 682/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1540 - root_mean_squared_error: 1.0741 - val_loss: 1.1568 - val_root_mean_squared_error: 1.0704\n",
+ "Epoch 683/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1567 - root_mean_squared_error: 1.0804 - val_loss: 1.1713 - val_root_mean_squared_error: 1.0647\n",
+ "Epoch 684/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1596 - root_mean_squared_error: 1.0740 - val_loss: 1.1723 - val_root_mean_squared_error: 1.0500\n",
+ "Epoch 685/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1560 - root_mean_squared_error: 1.0927 - val_loss: 1.1627 - val_root_mean_squared_error: 1.0663\n",
+ "Epoch 686/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1532 - root_mean_squared_error: 1.0843 - val_loss: 1.1583 - val_root_mean_squared_error: 1.0502\n",
+ "Epoch 687/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1518 - root_mean_squared_error: 1.0700 - val_loss: 1.1461 - val_root_mean_squared_error: 1.0955\n",
+ "Epoch 688/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1551 - root_mean_squared_error: 1.0784 - val_loss: 1.1621 - val_root_mean_squared_error: 1.1132\n",
+ "Epoch 689/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1579 - root_mean_squared_error: 1.0777 - val_loss: 1.1518 - val_root_mean_squared_error: 1.0781\n",
+ "Epoch 690/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1568 - root_mean_squared_error: 1.0776 - val_loss: 1.1648 - val_root_mean_squared_error: 1.0887\n",
+ "Epoch 691/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1573 - root_mean_squared_error: 1.0821 - val_loss: 1.1562 - val_root_mean_squared_error: 1.0817\n",
+ "Epoch 692/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1612 - root_mean_squared_error: 1.1057 - val_loss: 1.1773 - val_root_mean_squared_error: 1.0851\n",
+ "Epoch 693/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1533 - root_mean_squared_error: 1.0875 - val_loss: 1.1609 - val_root_mean_squared_error: 1.1034\n",
+ "Epoch 694/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1650 - root_mean_squared_error: 1.0724 - val_loss: 1.1611 - val_root_mean_squared_error: 1.0918\n",
+ "Epoch 695/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1530 - root_mean_squared_error: 1.0861 - val_loss: 1.1670 - val_root_mean_squared_error: 1.1127\n",
+ "Epoch 696/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1551 - root_mean_squared_error: 1.0790 - val_loss: 1.1439 - val_root_mean_squared_error: 1.1343\n",
+ "Epoch 697/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1664 - root_mean_squared_error: 1.0799 - val_loss: 1.1374 - val_root_mean_squared_error: 1.0266\n",
+ "Epoch 698/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1556 - root_mean_squared_error: 1.0645 - val_loss: 1.1470 - val_root_mean_squared_error: 1.0958\n",
+ "Epoch 699/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1486 - root_mean_squared_error: 1.0771 - val_loss: 1.1621 - val_root_mean_squared_error: 1.0921\n",
+ "Epoch 700/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1536 - root_mean_squared_error: 1.0716 - val_loss: 1.1569 - val_root_mean_squared_error: 1.0902\n",
+ "Epoch 701/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1577 - root_mean_squared_error: 1.0749 - val_loss: 1.1443 - val_root_mean_squared_error: 1.0437\n",
+ "Epoch 702/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1503 - root_mean_squared_error: 1.0648 - val_loss: 1.1746 - val_root_mean_squared_error: 1.0363\n",
+ "Epoch 703/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1557 - root_mean_squared_error: 1.0931 - val_loss: 1.1757 - val_root_mean_squared_error: 1.0661\n",
+ "Epoch 704/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1558 - root_mean_squared_error: 1.0732 - val_loss: 1.1668 - val_root_mean_squared_error: 1.0516\n",
+ "Epoch 705/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1493 - root_mean_squared_error: 1.0714 - val_loss: 1.1642 - val_root_mean_squared_error: 1.0478\n",
+ "Epoch 706/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1611 - root_mean_squared_error: 1.0884 - val_loss: 1.1471 - val_root_mean_squared_error: 1.0897\n",
+ "Epoch 707/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1532 - root_mean_squared_error: 1.0735 - val_loss: 1.1546 - val_root_mean_squared_error: 1.0824\n",
+ "Epoch 708/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1549 - root_mean_squared_error: 1.0689 - val_loss: 1.1595 - val_root_mean_squared_error: 1.0933\n",
+ "Epoch 709/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1558 - root_mean_squared_error: 1.0766 - val_loss: 1.1540 - val_root_mean_squared_error: 1.1284\n",
+ "Epoch 710/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1528 - root_mean_squared_error: 1.0818 - val_loss: 1.1651 - val_root_mean_squared_error: 1.1171\n",
+ "Epoch 711/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1611 - root_mean_squared_error: 1.0658 - val_loss: 1.1491 - val_root_mean_squared_error: 1.0224\n",
+ "Epoch 712/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1681 - root_mean_squared_error: 1.0823 - val_loss: 1.1469 - val_root_mean_squared_error: 1.0984\n",
+ "Epoch 713/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1493 - root_mean_squared_error: 1.0890 - val_loss: 1.1602 - val_root_mean_squared_error: 1.0711\n",
+ "Epoch 714/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1568 - root_mean_squared_error: 1.0835 - val_loss: 1.1551 - val_root_mean_squared_error: 1.0567\n",
+ "Epoch 715/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0653 - val_loss: 1.1648 - val_root_mean_squared_error: 1.0970\n",
+ "Epoch 716/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1614 - root_mean_squared_error: 1.1001 - val_loss: 1.1571 - val_root_mean_squared_error: 1.0709\n",
+ "Epoch 717/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1512 - root_mean_squared_error: 1.0760 - val_loss: 1.1554 - val_root_mean_squared_error: 1.0990\n",
+ "Epoch 718/1000\n",
+ "17/17 [==============================] - 0s 9ms/step - loss: 1.1547 - root_mean_squared_error: 1.1029 - val_loss: 1.1571 - val_root_mean_squared_error: 1.0357\n",
+ "Epoch 719/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1487 - root_mean_squared_error: 1.0758 - val_loss: 1.1442 - val_root_mean_squared_error: 1.0829\n",
+ "Epoch 720/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1596 - root_mean_squared_error: 1.0875 - val_loss: 1.1583 - val_root_mean_squared_error: 1.1084\n",
+ "Epoch 721/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1592 - root_mean_squared_error: 1.0611 - val_loss: 1.1552 - val_root_mean_squared_error: 1.0535\n",
+ "Epoch 722/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1549 - root_mean_squared_error: 1.0589 - val_loss: 1.1450 - val_root_mean_squared_error: 1.0832\n",
+ "Epoch 723/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1581 - root_mean_squared_error: 1.0731 - val_loss: 1.1559 - val_root_mean_squared_error: 1.0878\n",
+ "Epoch 724/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1495 - root_mean_squared_error: 1.0643 - val_loss: 1.1495 - val_root_mean_squared_error: 0.9855\n",
+ "Epoch 725/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1585 - root_mean_squared_error: 1.0699 - val_loss: 1.1744 - val_root_mean_squared_error: 1.0407\n",
+ "Epoch 726/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1618 - root_mean_squared_error: 1.0700 - val_loss: 1.1572 - val_root_mean_squared_error: 1.0518\n",
+ "Epoch 727/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1592 - root_mean_squared_error: 1.0655 - val_loss: 1.1523 - val_root_mean_squared_error: 1.0968\n",
+ "Epoch 728/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1591 - root_mean_squared_error: 1.0875 - val_loss: 1.1696 - val_root_mean_squared_error: 1.0379\n",
+ "Epoch 729/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1620 - root_mean_squared_error: 1.0766 - val_loss: 1.1666 - val_root_mean_squared_error: 1.0949\n",
+ "Epoch 730/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1594 - root_mean_squared_error: 1.0878 - val_loss: 1.1529 - val_root_mean_squared_error: 1.0909\n",
+ "Epoch 731/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1540 - root_mean_squared_error: 1.0914 - val_loss: 1.1552 - val_root_mean_squared_error: 1.0710\n",
+ "Epoch 732/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1472 - root_mean_squared_error: 1.0673 - val_loss: 1.1623 - val_root_mean_squared_error: 1.1203\n",
+ "Epoch 733/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1574 - root_mean_squared_error: 1.0764 - val_loss: 1.1490 - val_root_mean_squared_error: 1.0823\n",
+ "Epoch 734/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1502 - root_mean_squared_error: 1.0770 - val_loss: 1.1820 - val_root_mean_squared_error: 1.1021\n",
+ "Epoch 735/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1725 - root_mean_squared_error: 1.1077 - val_loss: 1.1526 - val_root_mean_squared_error: 1.0736\n",
+ "Epoch 736/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1522 - root_mean_squared_error: 1.0748 - val_loss: 1.1607 - val_root_mean_squared_error: 1.0448\n",
+ "Epoch 737/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1514 - root_mean_squared_error: 1.0734 - val_loss: 1.1695 - val_root_mean_squared_error: 1.0716\n",
+ "Epoch 738/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1447 - root_mean_squared_error: 1.0602 - val_loss: 1.1587 - val_root_mean_squared_error: 1.0674\n",
+ "Epoch 739/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1497 - root_mean_squared_error: 1.0834 - val_loss: 1.1594 - val_root_mean_squared_error: 1.0777\n",
+ "Epoch 740/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1498 - root_mean_squared_error: 1.0664 - val_loss: 1.1542 - val_root_mean_squared_error: 1.0914\n",
+ "Epoch 741/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1510 - root_mean_squared_error: 1.0624 - val_loss: 1.1487 - val_root_mean_squared_error: 1.0863\n",
+ "Epoch 742/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1557 - root_mean_squared_error: 1.0778 - val_loss: 1.1468 - val_root_mean_squared_error: 1.0729\n",
+ "Epoch 743/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1497 - root_mean_squared_error: 1.0615 - val_loss: 1.1535 - val_root_mean_squared_error: 1.0493\n",
+ "Epoch 744/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1612 - root_mean_squared_error: 1.0752 - val_loss: 1.1485 - val_root_mean_squared_error: 1.0833\n",
+ "Epoch 745/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1503 - root_mean_squared_error: 1.0764 - val_loss: 1.1648 - val_root_mean_squared_error: 1.0824\n",
+ "Epoch 746/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1591 - root_mean_squared_error: 1.0630 - val_loss: 1.1766 - val_root_mean_squared_error: 1.0848\n",
+ "Epoch 747/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1587 - root_mean_squared_error: 1.0906 - val_loss: 1.1732 - val_root_mean_squared_error: 1.0573\n",
+ "Epoch 748/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1518 - root_mean_squared_error: 1.0650 - val_loss: 1.1634 - val_root_mean_squared_error: 1.0289\n",
+ "Epoch 749/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1488 - root_mean_squared_error: 1.0748 - val_loss: 1.1436 - val_root_mean_squared_error: 1.0396\n",
+ "Epoch 750/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1581 - root_mean_squared_error: 1.0890 - val_loss: 1.1378 - val_root_mean_squared_error: 1.0584\n",
+ "Epoch 751/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1497 - root_mean_squared_error: 1.0765 - val_loss: 1.1676 - val_root_mean_squared_error: 1.0532\n",
+ "Epoch 752/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1595 - root_mean_squared_error: 1.0994 - val_loss: 1.1580 - val_root_mean_squared_error: 1.0479\n",
+ "Epoch 753/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0810 - val_loss: 1.1438 - val_root_mean_squared_error: 1.0578\n",
+ "Epoch 754/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1491 - root_mean_squared_error: 1.0721 - val_loss: 1.1608 - val_root_mean_squared_error: 1.1034\n",
+ "Epoch 755/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1525 - root_mean_squared_error: 1.0782 - val_loss: 1.1838 - val_root_mean_squared_error: 1.0669\n",
+ "Epoch 756/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1443 - root_mean_squared_error: 1.0593 - val_loss: 1.1484 - val_root_mean_squared_error: 1.0261\n",
+ "Epoch 757/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1551 - root_mean_squared_error: 1.0538 - val_loss: 1.1620 - val_root_mean_squared_error: 1.0414\n",
+ "Epoch 758/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1541 - root_mean_squared_error: 1.0623 - val_loss: 1.1490 - val_root_mean_squared_error: 1.0953\n",
+ "Epoch 759/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1535 - root_mean_squared_error: 1.0755 - val_loss: 1.1763 - val_root_mean_squared_error: 1.0592\n",
+ "Epoch 760/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1566 - root_mean_squared_error: 1.0855 - val_loss: 1.1418 - val_root_mean_squared_error: 1.0730\n",
+ "Epoch 761/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1510 - root_mean_squared_error: 1.0865 - val_loss: 1.1489 - val_root_mean_squared_error: 1.0685\n",
+ "Epoch 762/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1569 - root_mean_squared_error: 1.0797 - val_loss: 1.1534 - val_root_mean_squared_error: 1.0711\n",
+ "Epoch 763/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1553 - root_mean_squared_error: 1.0596 - val_loss: 1.1425 - val_root_mean_squared_error: 1.0886\n",
+ "Epoch 764/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1597 - root_mean_squared_error: 1.0863 - val_loss: 1.1590 - val_root_mean_squared_error: 1.0850\n",
+ "Epoch 765/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1501 - root_mean_squared_error: 1.0665 - val_loss: 1.1559 - val_root_mean_squared_error: 1.0904\n",
+ "Epoch 766/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1623 - root_mean_squared_error: 1.0849 - val_loss: 1.1738 - val_root_mean_squared_error: 1.0581\n",
+ "Epoch 767/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1584 - root_mean_squared_error: 1.0706 - val_loss: 1.1511 - val_root_mean_squared_error: 1.0996\n",
+ "Epoch 768/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1513 - root_mean_squared_error: 1.0825 - val_loss: 1.1687 - val_root_mean_squared_error: 1.0788\n",
+ "Epoch 769/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1476 - root_mean_squared_error: 1.0634 - val_loss: 1.1562 - val_root_mean_squared_error: 1.0943\n",
+ "Epoch 770/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1580 - root_mean_squared_error: 1.0815 - val_loss: 1.1562 - val_root_mean_squared_error: 1.0771\n",
+ "Epoch 771/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1567 - root_mean_squared_error: 1.0865 - val_loss: 1.1609 - val_root_mean_squared_error: 1.0454\n",
+ "Epoch 772/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1493 - root_mean_squared_error: 1.0776 - val_loss: 1.1607 - val_root_mean_squared_error: 1.0315\n",
+ "Epoch 773/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1489 - root_mean_squared_error: 1.0657 - val_loss: 1.1416 - val_root_mean_squared_error: 1.0884\n",
+ "Epoch 774/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1505 - root_mean_squared_error: 1.0698 - val_loss: 1.1592 - val_root_mean_squared_error: 1.0538\n",
+ "Epoch 775/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1509 - root_mean_squared_error: 1.0840 - val_loss: 1.1623 - val_root_mean_squared_error: 1.0733\n",
+ "Epoch 776/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1501 - root_mean_squared_error: 1.0794 - val_loss: 1.1540 - val_root_mean_squared_error: 1.0360\n",
+ "Epoch 777/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1525 - root_mean_squared_error: 1.0910 - val_loss: 1.1716 - val_root_mean_squared_error: 1.1052\n",
+ "Epoch 778/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1543 - root_mean_squared_error: 1.0916 - val_loss: 1.1548 - val_root_mean_squared_error: 1.0513\n",
+ "Epoch 779/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1555 - root_mean_squared_error: 1.0677 - val_loss: 1.1735 - val_root_mean_squared_error: 1.1195\n",
+ "Epoch 780/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1540 - root_mean_squared_error: 1.0719 - val_loss: 1.1526 - val_root_mean_squared_error: 1.0512\n",
+ "Epoch 781/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1518 - root_mean_squared_error: 1.0673 - val_loss: 1.1560 - val_root_mean_squared_error: 1.0605\n",
+ "Epoch 782/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1557 - root_mean_squared_error: 1.0870 - val_loss: 1.1502 - val_root_mean_squared_error: 1.0673\n",
+ "Epoch 783/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0584 - val_loss: 1.1658 - val_root_mean_squared_error: 1.1114\n",
+ "Epoch 784/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1519 - root_mean_squared_error: 1.0676 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0975\n",
+ "Epoch 785/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1529 - root_mean_squared_error: 1.0806 - val_loss: 1.1553 - val_root_mean_squared_error: 1.0925\n",
+ "Epoch 786/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1520 - root_mean_squared_error: 1.0582 - val_loss: 1.1468 - val_root_mean_squared_error: 1.0568\n",
+ "Epoch 787/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1581 - root_mean_squared_error: 1.0896 - val_loss: 1.1596 - val_root_mean_squared_error: 1.0762\n",
+ "Epoch 788/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1530 - root_mean_squared_error: 1.0720 - val_loss: 1.1644 - val_root_mean_squared_error: 1.0461\n",
+ "Epoch 789/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1575 - root_mean_squared_error: 1.0777 - val_loss: 1.1452 - val_root_mean_squared_error: 1.0415\n",
+ "Epoch 790/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1537 - root_mean_squared_error: 1.0600 - val_loss: 1.1716 - val_root_mean_squared_error: 1.0558\n",
+ "Epoch 791/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1563 - root_mean_squared_error: 1.0823 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0830\n",
+ "Epoch 792/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1550 - root_mean_squared_error: 1.0735 - val_loss: 1.1591 - val_root_mean_squared_error: 1.1041\n",
+ "Epoch 793/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1607 - root_mean_squared_error: 1.0715 - val_loss: 1.1584 - val_root_mean_squared_error: 1.0552\n",
+ "Epoch 794/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1598 - root_mean_squared_error: 1.0681 - val_loss: 1.1714 - val_root_mean_squared_error: 1.1171\n",
+ "Epoch 795/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1535 - root_mean_squared_error: 1.0757 - val_loss: 1.1512 - val_root_mean_squared_error: 1.0579\n",
+ "Epoch 796/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1495 - root_mean_squared_error: 1.0649 - val_loss: 1.1603 - val_root_mean_squared_error: 1.0619\n",
+ "Epoch 797/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1507 - root_mean_squared_error: 1.0861 - val_loss: 1.1751 - val_root_mean_squared_error: 1.0662\n",
+ "Epoch 798/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1487 - root_mean_squared_error: 1.0572 - val_loss: 1.1579 - val_root_mean_squared_error: 1.0705\n",
+ "Epoch 799/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1554 - root_mean_squared_error: 1.0698 - val_loss: 1.1534 - val_root_mean_squared_error: 1.0480\n",
+ "Epoch 800/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1467 - root_mean_squared_error: 1.0684 - val_loss: 1.1646 - val_root_mean_squared_error: 1.0789\n",
+ "Epoch 801/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1525 - root_mean_squared_error: 1.0775 - val_loss: 1.1672 - val_root_mean_squared_error: 1.1225\n",
+ "Epoch 802/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1502 - root_mean_squared_error: 1.0799 - val_loss: 1.1587 - val_root_mean_squared_error: 1.0938\n",
+ "Epoch 803/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1474 - root_mean_squared_error: 1.0924 - val_loss: 1.1522 - val_root_mean_squared_error: 1.0875\n",
+ "Epoch 804/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1552 - root_mean_squared_error: 1.0822 - val_loss: 1.1761 - val_root_mean_squared_error: 1.0720\n",
+ "Epoch 805/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1626 - root_mean_squared_error: 1.0824 - val_loss: 1.1578 - val_root_mean_squared_error: 1.0955\n",
+ "Epoch 806/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1613 - root_mean_squared_error: 1.0931 - val_loss: 1.1700 - val_root_mean_squared_error: 1.1097\n",
+ "Epoch 807/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1569 - root_mean_squared_error: 1.0678 - val_loss: 1.1755 - val_root_mean_squared_error: 1.0606\n",
+ "Epoch 808/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1458 - root_mean_squared_error: 1.0760 - val_loss: 1.1530 - val_root_mean_squared_error: 1.0464\n",
+ "Epoch 809/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1493 - root_mean_squared_error: 1.0776 - val_loss: 1.1552 - val_root_mean_squared_error: 1.0568\n",
+ "Epoch 810/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1483 - root_mean_squared_error: 1.0745 - val_loss: 1.1490 - val_root_mean_squared_error: 1.0714\n",
+ "Epoch 811/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1508 - root_mean_squared_error: 1.0707 - val_loss: 1.1776 - val_root_mean_squared_error: 1.0803\n",
+ "Epoch 812/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1515 - root_mean_squared_error: 1.0577 - val_loss: 1.1508 - val_root_mean_squared_error: 1.0574\n",
+ "Epoch 813/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1483 - root_mean_squared_error: 1.0622 - val_loss: 1.1435 - val_root_mean_squared_error: 1.0670\n",
+ "Epoch 814/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1509 - root_mean_squared_error: 1.0838 - val_loss: 1.1729 - val_root_mean_squared_error: 1.1051\n",
+ "Epoch 815/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1541 - root_mean_squared_error: 1.0632 - val_loss: 1.1479 - val_root_mean_squared_error: 1.0972\n",
+ "Epoch 816/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1534 - root_mean_squared_error: 1.0768 - val_loss: 1.1702 - val_root_mean_squared_error: 1.1074\n",
+ "Epoch 817/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1447 - root_mean_squared_error: 1.0666 - val_loss: 1.1452 - val_root_mean_squared_error: 1.0358\n",
+ "Epoch 818/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1547 - root_mean_squared_error: 1.0819 - val_loss: 1.1465 - val_root_mean_squared_error: 1.0857\n",
+ "Epoch 819/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1475 - root_mean_squared_error: 1.0721 - val_loss: 1.1698 - val_root_mean_squared_error: 1.0620\n",
+ "Epoch 820/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1486 - root_mean_squared_error: 1.0704 - val_loss: 1.1707 - val_root_mean_squared_error: 1.0865\n",
+ "Epoch 821/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1541 - root_mean_squared_error: 1.0774 - val_loss: 1.1548 - val_root_mean_squared_error: 1.0515\n",
+ "Epoch 822/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1469 - root_mean_squared_error: 1.0691 - val_loss: 1.1596 - val_root_mean_squared_error: 1.0432\n",
+ "Epoch 823/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1477 - root_mean_squared_error: 1.0497 - val_loss: 1.1520 - val_root_mean_squared_error: 1.0791\n",
+ "Epoch 824/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1540 - root_mean_squared_error: 1.0768 - val_loss: 1.1455 - val_root_mean_squared_error: 1.0369\n",
+ "Epoch 825/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1495 - root_mean_squared_error: 1.0621 - val_loss: 1.1702 - val_root_mean_squared_error: 1.0605\n",
+ "Epoch 826/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1537 - root_mean_squared_error: 1.0556 - val_loss: 1.1537 - val_root_mean_squared_error: 1.0474\n",
+ "Epoch 827/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1473 - root_mean_squared_error: 1.0567 - val_loss: 1.1512 - val_root_mean_squared_error: 1.0840\n",
+ "Epoch 828/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1537 - root_mean_squared_error: 1.0621 - val_loss: 1.1505 - val_root_mean_squared_error: 1.0565\n",
+ "Epoch 829/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1547 - root_mean_squared_error: 1.0456 - val_loss: 1.1785 - val_root_mean_squared_error: 1.1291\n",
+ "Epoch 830/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1614 - root_mean_squared_error: 1.0711 - val_loss: 1.1458 - val_root_mean_squared_error: 1.0426\n",
+ "Epoch 831/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1468 - root_mean_squared_error: 1.0571 - val_loss: 1.1676 - val_root_mean_squared_error: 1.0938\n",
+ "Epoch 832/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1581 - root_mean_squared_error: 1.0839 - val_loss: 1.1471 - val_root_mean_squared_error: 1.0758\n",
+ "Epoch 833/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1534 - root_mean_squared_error: 1.0579 - val_loss: 1.1543 - val_root_mean_squared_error: 1.0906\n",
+ "Epoch 834/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1573 - root_mean_squared_error: 1.0854 - val_loss: 1.1529 - val_root_mean_squared_error: 1.0524\n",
+ "Epoch 835/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1514 - root_mean_squared_error: 1.0605 - val_loss: 1.1638 - val_root_mean_squared_error: 1.1072\n",
+ "Epoch 836/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1465 - root_mean_squared_error: 1.0785 - val_loss: 1.1448 - val_root_mean_squared_error: 1.0799\n",
+ "Epoch 837/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1492 - root_mean_squared_error: 1.0781 - val_loss: 1.1607 - val_root_mean_squared_error: 1.0275\n",
+ "Epoch 838/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1510 - root_mean_squared_error: 1.0721 - val_loss: 1.1455 - val_root_mean_squared_error: 1.0812\n",
+ "Epoch 839/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1552 - root_mean_squared_error: 1.0676 - val_loss: 1.1534 - val_root_mean_squared_error: 1.0939\n",
+ "Epoch 840/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1519 - root_mean_squared_error: 1.0791 - val_loss: 1.1621 - val_root_mean_squared_error: 1.0633\n",
+ "Epoch 841/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1483 - root_mean_squared_error: 1.0474 - val_loss: 1.1609 - val_root_mean_squared_error: 1.0873\n",
+ "Epoch 842/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1544 - root_mean_squared_error: 1.0762 - val_loss: 1.1660 - val_root_mean_squared_error: 1.0722\n",
+ "Epoch 843/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1557 - root_mean_squared_error: 1.0778 - val_loss: 1.1527 - val_root_mean_squared_error: 1.0805\n",
+ "Epoch 844/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1513 - root_mean_squared_error: 1.0834 - val_loss: 1.1617 - val_root_mean_squared_error: 1.0340\n",
+ "Epoch 845/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1496 - root_mean_squared_error: 1.0771 - val_loss: 1.1527 - val_root_mean_squared_error: 1.0453\n",
+ "Epoch 846/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1518 - root_mean_squared_error: 1.0968 - val_loss: 1.1535 - val_root_mean_squared_error: 1.1012\n",
+ "Epoch 847/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1536 - root_mean_squared_error: 1.0827 - val_loss: 1.1477 - val_root_mean_squared_error: 1.0254\n",
+ "Epoch 848/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1488 - root_mean_squared_error: 1.0729 - val_loss: 1.1583 - val_root_mean_squared_error: 1.0892\n",
+ "Epoch 849/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1637 - root_mean_squared_error: 1.0871 - val_loss: 1.1532 - val_root_mean_squared_error: 1.0968\n",
+ "Epoch 850/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1517 - root_mean_squared_error: 1.0692 - val_loss: 1.1598 - val_root_mean_squared_error: 1.0880\n",
+ "Epoch 851/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1588 - root_mean_squared_error: 1.0785 - val_loss: 1.1590 - val_root_mean_squared_error: 1.0805\n",
+ "Epoch 852/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1483 - root_mean_squared_error: 1.0960 - val_loss: 1.1519 - val_root_mean_squared_error: 1.0780\n",
+ "Epoch 853/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1479 - root_mean_squared_error: 1.0593 - val_loss: 1.1429 - val_root_mean_squared_error: 1.0310\n",
+ "Epoch 854/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1545 - root_mean_squared_error: 1.0740 - val_loss: 1.1464 - val_root_mean_squared_error: 1.0722\n",
+ "Epoch 855/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1543 - root_mean_squared_error: 1.0530 - val_loss: 1.1476 - val_root_mean_squared_error: 1.0845\n",
+ "Epoch 856/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1550 - root_mean_squared_error: 1.0617 - val_loss: 1.1571 - val_root_mean_squared_error: 1.0403\n",
+ "Epoch 857/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1534 - root_mean_squared_error: 1.0706 - val_loss: 1.1598 - val_root_mean_squared_error: 1.1306\n",
+ "Epoch 858/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1468 - root_mean_squared_error: 1.0814 - val_loss: 1.1543 - val_root_mean_squared_error: 1.0952\n",
+ "Epoch 859/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1542 - root_mean_squared_error: 1.0596 - val_loss: 1.1571 - val_root_mean_squared_error: 1.1005\n",
+ "Epoch 860/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1512 - root_mean_squared_error: 1.0657 - val_loss: 1.1535 - val_root_mean_squared_error: 1.0772\n",
+ "Epoch 861/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1500 - root_mean_squared_error: 1.0430 - val_loss: 1.1427 - val_root_mean_squared_error: 1.0633\n",
+ "Epoch 862/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1533 - root_mean_squared_error: 1.0585 - val_loss: 1.1499 - val_root_mean_squared_error: 1.0538\n",
+ "Epoch 863/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1529 - root_mean_squared_error: 1.0557 - val_loss: 1.1518 - val_root_mean_squared_error: 1.0621\n",
+ "Epoch 864/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1533 - root_mean_squared_error: 1.0733 - val_loss: 1.1528 - val_root_mean_squared_error: 1.0913\n",
+ "Epoch 865/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1470 - root_mean_squared_error: 1.0601 - val_loss: 1.1582 - val_root_mean_squared_error: 1.1139\n",
+ "Epoch 866/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1479 - root_mean_squared_error: 1.0604 - val_loss: 1.1585 - val_root_mean_squared_error: 1.0982\n",
+ "Epoch 867/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1527 - root_mean_squared_error: 1.0938 - val_loss: 1.1758 - val_root_mean_squared_error: 1.0906\n",
+ "Epoch 868/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1542 - root_mean_squared_error: 1.0797 - val_loss: 1.1519 - val_root_mean_squared_error: 1.0581\n",
+ "Epoch 869/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1510 - root_mean_squared_error: 1.0697 - val_loss: 1.1655 - val_root_mean_squared_error: 1.0789\n",
+ "Epoch 870/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1466 - root_mean_squared_error: 1.0721 - val_loss: 1.1685 - val_root_mean_squared_error: 1.0658\n",
+ "Epoch 871/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1479 - root_mean_squared_error: 1.0527 - val_loss: 1.1447 - val_root_mean_squared_error: 1.0718\n",
+ "Epoch 872/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1524 - root_mean_squared_error: 1.0541 - val_loss: 1.1465 - val_root_mean_squared_error: 1.0818\n",
+ "Epoch 873/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1486 - root_mean_squared_error: 1.0738 - val_loss: 1.1647 - val_root_mean_squared_error: 1.0660\n",
+ "Epoch 874/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1519 - root_mean_squared_error: 1.0743 - val_loss: 1.1621 - val_root_mean_squared_error: 1.0894\n",
+ "Epoch 875/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1503 - root_mean_squared_error: 1.0684 - val_loss: 1.1718 - val_root_mean_squared_error: 1.1284\n",
+ "Epoch 876/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1479 - root_mean_squared_error: 1.0898 - val_loss: 1.1588 - val_root_mean_squared_error: 1.0486\n",
+ "Epoch 877/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1510 - root_mean_squared_error: 1.0608 - val_loss: 1.1452 - val_root_mean_squared_error: 1.0559\n",
+ "Epoch 878/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1565 - root_mean_squared_error: 1.0775 - val_loss: 1.1515 - val_root_mean_squared_error: 1.0985\n",
+ "Epoch 879/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1546 - root_mean_squared_error: 1.0839 - val_loss: 1.1580 - val_root_mean_squared_error: 1.0261\n",
+ "Epoch 880/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1426 - root_mean_squared_error: 1.0581 - val_loss: 1.1683 - val_root_mean_squared_error: 1.1202\n",
+ "Epoch 881/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1532 - root_mean_squared_error: 1.0688 - val_loss: 1.1537 - val_root_mean_squared_error: 1.0960\n",
+ "Epoch 882/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1589 - root_mean_squared_error: 1.0818 - val_loss: 1.1541 - val_root_mean_squared_error: 1.0726\n",
+ "Epoch 883/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1539 - root_mean_squared_error: 1.0732 - val_loss: 1.1513 - val_root_mean_squared_error: 1.0318\n",
+ "Epoch 884/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1588 - root_mean_squared_error: 1.0679 - val_loss: 1.1449 - val_root_mean_squared_error: 1.1030\n",
+ "Epoch 885/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1511 - root_mean_squared_error: 1.0757 - val_loss: 1.1589 - val_root_mean_squared_error: 1.0615\n",
+ "Epoch 886/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1489 - root_mean_squared_error: 1.0784 - val_loss: 1.1434 - val_root_mean_squared_error: 1.0544\n",
+ "Epoch 887/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1469 - root_mean_squared_error: 1.0736 - val_loss: 1.1555 - val_root_mean_squared_error: 1.1109\n",
+ "Epoch 888/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1512 - root_mean_squared_error: 1.0657 - val_loss: 1.1590 - val_root_mean_squared_error: 1.0565\n",
+ "Epoch 889/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1520 - root_mean_squared_error: 1.0732 - val_loss: 1.1519 - val_root_mean_squared_error: 1.0727\n",
+ "Epoch 890/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1507 - root_mean_squared_error: 1.0841 - val_loss: 1.1537 - val_root_mean_squared_error: 1.0920\n",
+ "Epoch 891/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1469 - root_mean_squared_error: 1.0753 - val_loss: 1.1656 - val_root_mean_squared_error: 1.0887\n",
+ "Epoch 892/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1561 - root_mean_squared_error: 1.0882 - val_loss: 1.1579 - val_root_mean_squared_error: 1.0572\n",
+ "Epoch 893/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1512 - root_mean_squared_error: 1.0744 - val_loss: 1.1506 - val_root_mean_squared_error: 1.0516\n",
+ "Epoch 894/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1497 - root_mean_squared_error: 1.0763 - val_loss: 1.1534 - val_root_mean_squared_error: 1.0454\n",
+ "Epoch 895/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1506 - root_mean_squared_error: 1.0711 - val_loss: 1.1455 - val_root_mean_squared_error: 1.0380\n",
+ "Epoch 896/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1485 - root_mean_squared_error: 1.0675 - val_loss: 1.1522 - val_root_mean_squared_error: 1.0671\n",
+ "Epoch 897/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1472 - root_mean_squared_error: 1.0810 - val_loss: 1.1486 - val_root_mean_squared_error: 1.0970\n",
+ "Epoch 898/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1464 - root_mean_squared_error: 1.0791 - val_loss: 1.1479 - val_root_mean_squared_error: 1.0778\n",
+ "Epoch 899/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1510 - root_mean_squared_error: 1.0651 - val_loss: 1.1505 - val_root_mean_squared_error: 1.0505\n",
+ "Epoch 900/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1451 - root_mean_squared_error: 1.0713 - val_loss: 1.1611 - val_root_mean_squared_error: 1.0806\n",
+ "Epoch 901/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1475 - root_mean_squared_error: 1.0651 - val_loss: 1.1599 - val_root_mean_squared_error: 1.0719\n",
+ "Epoch 902/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1590 - root_mean_squared_error: 1.0711 - val_loss: 1.1576 - val_root_mean_squared_error: 1.0881\n",
+ "Epoch 903/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1505 - root_mean_squared_error: 1.0731 - val_loss: 1.1777 - val_root_mean_squared_error: 1.0583\n",
+ "Epoch 904/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1460 - root_mean_squared_error: 1.0558 - val_loss: 1.1446 - val_root_mean_squared_error: 1.0579\n",
+ "Epoch 905/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1590 - root_mean_squared_error: 1.0685 - val_loss: 1.1598 - val_root_mean_squared_error: 1.0478\n",
+ "Epoch 906/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1546 - root_mean_squared_error: 1.0695 - val_loss: 1.1457 - val_root_mean_squared_error: 1.1054\n",
+ "Epoch 907/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1477 - root_mean_squared_error: 1.0796 - val_loss: 1.1704 - val_root_mean_squared_error: 1.0432\n",
+ "Epoch 908/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1534 - root_mean_squared_error: 1.0523 - val_loss: 1.1467 - val_root_mean_squared_error: 1.0645\n",
+ "Epoch 909/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1534 - root_mean_squared_error: 1.0757 - val_loss: 1.1512 - val_root_mean_squared_error: 1.0563\n",
+ "Epoch 910/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1527 - root_mean_squared_error: 1.0979 - val_loss: 1.1734 - val_root_mean_squared_error: 1.1126\n",
+ "Epoch 911/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1516 - root_mean_squared_error: 1.0615 - val_loss: 1.1456 - val_root_mean_squared_error: 1.0961\n",
+ "Epoch 912/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1509 - root_mean_squared_error: 1.0708 - val_loss: 1.1542 - val_root_mean_squared_error: 1.0554\n",
+ "Epoch 913/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1558 - root_mean_squared_error: 1.0593 - val_loss: 1.1472 - val_root_mean_squared_error: 1.0778\n",
+ "Epoch 914/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1442 - root_mean_squared_error: 1.0677 - val_loss: 1.1453 - val_root_mean_squared_error: 1.0627\n",
+ "Epoch 915/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1492 - root_mean_squared_error: 1.0620 - val_loss: 1.1560 - val_root_mean_squared_error: 1.0605\n",
+ "Epoch 916/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1514 - root_mean_squared_error: 1.0745 - val_loss: 1.1494 - val_root_mean_squared_error: 1.1136\n",
+ "Epoch 917/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1547 - root_mean_squared_error: 1.0571 - val_loss: 1.1588 - val_root_mean_squared_error: 1.0802\n",
+ "Epoch 918/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1467 - root_mean_squared_error: 1.0846 - val_loss: 1.1660 - val_root_mean_squared_error: 1.0534\n",
+ "Epoch 919/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1515 - root_mean_squared_error: 1.0585 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0747\n",
+ "Epoch 920/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1481 - root_mean_squared_error: 1.0754 - val_loss: 1.1548 - val_root_mean_squared_error: 1.0574\n",
+ "Epoch 921/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1512 - root_mean_squared_error: 1.0799 - val_loss: 1.1706 - val_root_mean_squared_error: 1.0471\n",
+ "Epoch 922/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1531 - root_mean_squared_error: 1.0578 - val_loss: 1.1356 - val_root_mean_squared_error: 1.0099\n",
+ "Epoch 923/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1508 - root_mean_squared_error: 1.0768 - val_loss: 1.1604 - val_root_mean_squared_error: 1.0529\n",
+ "Epoch 924/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1510 - root_mean_squared_error: 1.0659 - val_loss: 1.1565 - val_root_mean_squared_error: 1.0588\n",
+ "Epoch 925/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1546 - root_mean_squared_error: 1.0821 - val_loss: 1.1621 - val_root_mean_squared_error: 1.1188\n",
+ "Epoch 926/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1514 - root_mean_squared_error: 1.0744 - val_loss: 1.1440 - val_root_mean_squared_error: 1.0390\n",
+ "Epoch 927/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1500 - root_mean_squared_error: 1.0973 - val_loss: 1.1518 - val_root_mean_squared_error: 1.0754\n",
+ "Epoch 928/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1543 - root_mean_squared_error: 1.0604 - val_loss: 1.1606 - val_root_mean_squared_error: 1.1325\n",
+ "Epoch 929/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1492 - root_mean_squared_error: 1.0670 - val_loss: 1.1495 - val_root_mean_squared_error: 1.0766\n",
+ "Epoch 930/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1461 - root_mean_squared_error: 1.0628 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0757\n",
+ "Epoch 931/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1455 - root_mean_squared_error: 1.0763 - val_loss: 1.1683 - val_root_mean_squared_error: 1.0727\n",
+ "Epoch 932/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1516 - root_mean_squared_error: 1.0621 - val_loss: 1.1554 - val_root_mean_squared_error: 1.0568\n",
+ "Epoch 933/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1553 - root_mean_squared_error: 1.0580 - val_loss: 1.1453 - val_root_mean_squared_error: 1.1282\n",
+ "Epoch 934/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1443 - root_mean_squared_error: 1.0661 - val_loss: 1.1492 - val_root_mean_squared_error: 1.0753\n",
+ "Epoch 935/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1520 - root_mean_squared_error: 1.0479 - val_loss: 1.1617 - val_root_mean_squared_error: 1.0633\n",
+ "Epoch 936/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1538 - root_mean_squared_error: 1.0802 - val_loss: 1.1570 - val_root_mean_squared_error: 1.0607\n",
+ "Epoch 937/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1453 - root_mean_squared_error: 1.0510 - val_loss: 1.1388 - val_root_mean_squared_error: 1.0623\n",
+ "Epoch 938/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1461 - root_mean_squared_error: 1.0557 - val_loss: 1.1559 - val_root_mean_squared_error: 1.0457\n",
+ "Epoch 939/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1499 - root_mean_squared_error: 1.0808 - val_loss: 1.1489 - val_root_mean_squared_error: 1.0595\n",
+ "Epoch 940/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1462 - root_mean_squared_error: 1.0769 - val_loss: 1.1443 - val_root_mean_squared_error: 1.0726\n",
+ "Epoch 941/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1508 - root_mean_squared_error: 1.0611 - val_loss: 1.1553 - val_root_mean_squared_error: 1.0577\n",
+ "Epoch 942/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1485 - root_mean_squared_error: 1.0707 - val_loss: 1.1697 - val_root_mean_squared_error: 1.0928\n",
+ "Epoch 943/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1493 - root_mean_squared_error: 1.0630 - val_loss: 1.1523 - val_root_mean_squared_error: 1.0634\n",
+ "Epoch 944/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1497 - root_mean_squared_error: 1.0902 - val_loss: 1.1602 - val_root_mean_squared_error: 1.0773\n",
+ "Epoch 945/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1478 - root_mean_squared_error: 1.0724 - val_loss: 1.1521 - val_root_mean_squared_error: 1.1038\n",
+ "Epoch 946/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1512 - root_mean_squared_error: 1.0721 - val_loss: 1.1712 - val_root_mean_squared_error: 1.1051\n",
+ "Epoch 947/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1483 - root_mean_squared_error: 1.0866 - val_loss: 1.1566 - val_root_mean_squared_error: 1.0565\n",
+ "Epoch 948/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1463 - root_mean_squared_error: 1.0590 - val_loss: 1.1393 - val_root_mean_squared_error: 1.1257\n",
+ "Epoch 949/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1502 - root_mean_squared_error: 1.0619 - val_loss: 1.1318 - val_root_mean_squared_error: 1.0559\n",
+ "Epoch 950/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1532 - root_mean_squared_error: 1.0804 - val_loss: 1.1631 - val_root_mean_squared_error: 1.1003\n",
+ "Epoch 951/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1493 - root_mean_squared_error: 1.0583 - val_loss: 1.1466 - val_root_mean_squared_error: 1.1310\n",
+ "Epoch 952/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1481 - root_mean_squared_error: 1.0689 - val_loss: 1.1725 - val_root_mean_squared_error: 1.0865\n",
+ "Epoch 953/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1533 - root_mean_squared_error: 1.0796 - val_loss: 1.1650 - val_root_mean_squared_error: 1.1011\n",
+ "Epoch 954/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1440 - root_mean_squared_error: 1.0720 - val_loss: 1.1518 - val_root_mean_squared_error: 1.0850\n",
+ "Epoch 955/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1545 - root_mean_squared_error: 1.0670 - val_loss: 1.1437 - val_root_mean_squared_error: 1.0817\n",
+ "Epoch 956/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1407 - root_mean_squared_error: 1.0622 - val_loss: 1.1535 - val_root_mean_squared_error: 1.0658\n",
+ "Epoch 957/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1456 - root_mean_squared_error: 1.0623 - val_loss: 1.1396 - val_root_mean_squared_error: 1.0663\n",
+ "Epoch 958/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1511 - root_mean_squared_error: 1.0595 - val_loss: 1.1648 - val_root_mean_squared_error: 1.0439\n",
+ "Epoch 959/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1439 - root_mean_squared_error: 1.0596 - val_loss: 1.1743 - val_root_mean_squared_error: 1.0477\n",
+ "Epoch 960/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1442 - root_mean_squared_error: 1.0780 - val_loss: 1.1526 - val_root_mean_squared_error: 1.0536\n",
+ "Epoch 961/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1522 - root_mean_squared_error: 1.0525 - val_loss: 1.1467 - val_root_mean_squared_error: 1.0698\n",
+ "Epoch 962/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1462 - root_mean_squared_error: 1.0574 - val_loss: 1.1556 - val_root_mean_squared_error: 1.1146\n",
+ "Epoch 963/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1542 - root_mean_squared_error: 1.0709 - val_loss: 1.1477 - val_root_mean_squared_error: 1.0528\n",
+ "Epoch 964/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1470 - root_mean_squared_error: 1.0508 - val_loss: 1.1493 - val_root_mean_squared_error: 1.0856\n",
+ "Epoch 965/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1457 - root_mean_squared_error: 1.0654 - val_loss: 1.1529 - val_root_mean_squared_error: 1.0817\n",
+ "Epoch 966/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1513 - root_mean_squared_error: 1.0860 - val_loss: 1.1431 - val_root_mean_squared_error: 1.0883\n",
+ "Epoch 967/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1498 - root_mean_squared_error: 1.0676 - val_loss: 1.1594 - val_root_mean_squared_error: 1.0449\n",
+ "Epoch 968/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1458 - root_mean_squared_error: 1.0735 - val_loss: 1.1475 - val_root_mean_squared_error: 1.0656\n",
+ "Epoch 969/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1521 - root_mean_squared_error: 1.0779 - val_loss: 1.1454 - val_root_mean_squared_error: 1.0747\n",
+ "Epoch 970/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1516 - root_mean_squared_error: 1.0534 - val_loss: 1.1370 - val_root_mean_squared_error: 1.0716\n",
+ "Epoch 971/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1525 - root_mean_squared_error: 1.0731 - val_loss: 1.1543 - val_root_mean_squared_error: 1.0773\n",
+ "Epoch 972/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1469 - root_mean_squared_error: 1.0810 - val_loss: 1.1636 - val_root_mean_squared_error: 1.0518\n",
+ "Epoch 973/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1514 - root_mean_squared_error: 1.1038 - val_loss: 1.1522 - val_root_mean_squared_error: 1.0699\n",
+ "Epoch 974/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1522 - root_mean_squared_error: 1.0844 - val_loss: 1.1650 - val_root_mean_squared_error: 1.0160\n",
+ "Epoch 975/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1481 - root_mean_squared_error: 1.0601 - val_loss: 1.1465 - val_root_mean_squared_error: 1.1098\n",
+ "Epoch 976/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1465 - root_mean_squared_error: 1.0581 - val_loss: 1.1566 - val_root_mean_squared_error: 1.0972\n",
+ "Epoch 977/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1485 - root_mean_squared_error: 1.0659 - val_loss: 1.1502 - val_root_mean_squared_error: 1.1010\n",
+ "Epoch 978/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1520 - root_mean_squared_error: 1.0884 - val_loss: 1.1578 - val_root_mean_squared_error: 1.0469\n",
+ "Epoch 979/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1481 - root_mean_squared_error: 1.0848 - val_loss: 1.1685 - val_root_mean_squared_error: 1.0593\n",
+ "Epoch 980/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1483 - root_mean_squared_error: 1.0659 - val_loss: 1.1509 - val_root_mean_squared_error: 1.0320\n",
+ "Epoch 981/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1489 - root_mean_squared_error: 1.0513 - val_loss: 1.1522 - val_root_mean_squared_error: 1.0920\n",
+ "Epoch 982/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1492 - root_mean_squared_error: 1.0659 - val_loss: 1.1607 - val_root_mean_squared_error: 1.1042\n",
+ "Epoch 983/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1500 - root_mean_squared_error: 1.0673 - val_loss: 1.1584 - val_root_mean_squared_error: 1.0993\n",
+ "Epoch 984/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1532 - root_mean_squared_error: 1.0899 - val_loss: 1.1539 - val_root_mean_squared_error: 1.0684\n",
+ "Epoch 985/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1542 - root_mean_squared_error: 1.0604 - val_loss: 1.1634 - val_root_mean_squared_error: 1.0304\n",
+ "Epoch 986/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1543 - root_mean_squared_error: 1.0853 - val_loss: 1.1463 - val_root_mean_squared_error: 1.0750\n",
+ "Epoch 987/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1518 - root_mean_squared_error: 1.0734 - val_loss: 1.1495 - val_root_mean_squared_error: 1.0874\n",
+ "Epoch 988/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1447 - root_mean_squared_error: 1.0682 - val_loss: 1.1549 - val_root_mean_squared_error: 1.0584\n",
+ "Epoch 989/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1383 - root_mean_squared_error: 1.0431 - val_loss: 1.1450 - val_root_mean_squared_error: 1.0868\n",
+ "Epoch 990/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1458 - root_mean_squared_error: 1.0664 - val_loss: 1.1688 - val_root_mean_squared_error: 1.0477\n",
+ "Epoch 991/1000\n",
+ "17/17 [==============================] - 0s 11ms/step - loss: 1.1513 - root_mean_squared_error: 1.0619 - val_loss: 1.1478 - val_root_mean_squared_error: 1.0577\n",
+ "Epoch 992/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1460 - root_mean_squared_error: 1.0573 - val_loss: 1.1404 - val_root_mean_squared_error: 1.0833\n",
+ "Epoch 993/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1480 - root_mean_squared_error: 1.0705 - val_loss: 1.1724 - val_root_mean_squared_error: 1.0904\n",
+ "Epoch 994/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1533 - root_mean_squared_error: 1.0837 - val_loss: 1.1587 - val_root_mean_squared_error: 1.1279\n",
+ "Epoch 995/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1484 - root_mean_squared_error: 1.0537 - val_loss: 1.1562 - val_root_mean_squared_error: 1.0265\n",
+ "Epoch 996/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1478 - root_mean_squared_error: 1.0612 - val_loss: 1.1727 - val_root_mean_squared_error: 1.0600\n",
+ "Epoch 997/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1469 - root_mean_squared_error: 1.0691 - val_loss: 1.1450 - val_root_mean_squared_error: 1.0739\n",
+ "Epoch 998/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1478 - root_mean_squared_error: 1.0760 - val_loss: 1.1716 - val_root_mean_squared_error: 1.0452\n",
+ "Epoch 999/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1435 - root_mean_squared_error: 1.0705 - val_loss: 1.1503 - val_root_mean_squared_error: 1.0454\n",
+ "Epoch 1000/1000\n",
+ "17/17 [==============================] - 0s 10ms/step - loss: 1.1476 - root_mean_squared_error: 1.0630 - val_loss: 1.1508 - val_root_mean_squared_error: 1.0186\n",
+ "Model training finished.\n",
+ "Train RMSE: 1.064\n",
+ "Evaluating model performance...\n",
+ "Test RMSE: 1.058\n"
+ ]
}
- ],
- "metadata": {
- "accelerator": "GPU",
- "colab": {
- "name": "bayesian_neural_networks_wine",
- "provenance": [],
- "toc_visible": true
- },
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.7.0"
+ ],
+ "source": [
+ "\n",
+ "def negative_loglikelihood(targets, estimated_distribution):\n",
+ " return -estimated_distribution.log_prob(targets)\n",
+ "\n",
+ "\n",
+ "num_epochs = 1000\n",
+ "prob_bnn_model = create_probablistic_bnn_model(train_size)\n",
+ "run_experiment(prob_bnn_model, negative_loglikelihood, train_dataset, test_dataset)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "53qcYDKyJZYA"
+ },
+ "source": [
+ "Now let's produce an output from the model given the test examples.\n",
+ "The output is now a distribution, and we can use its mean and variance\n",
+ "to compute the confidence intervals (CI) of the prediction."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "id": "Dv_RwLyFJZYA"
+ },
+ "outputs": [
+ {
+ "ename": "AttributeError",
+ "evalue": "'Independent' object has no attribute 'sddev'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn [25], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m prediction_distribution \u001b[38;5;241m=\u001b[39m prob_bnn_model(examples)\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mprediction_distribution\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msddev\u001b[49m())\n\u001b[1;32m 3\u001b[0m prediction_mean \u001b[38;5;241m=\u001b[39m prediction_distribution\u001b[38;5;241m.\u001b[39mmean()\u001b[38;5;241m.\u001b[39mnumpy()\u001b[38;5;241m.\u001b[39mtolist()\n\u001b[1;32m 4\u001b[0m prediction_stdv \u001b[38;5;241m=\u001b[39m prediction_distribution\u001b[38;5;241m.\u001b[39mstddev()\u001b[38;5;241m.\u001b[39mnumpy()\n",
+ "File \u001b[0;32m/p/project/training2305/sc_venv_template-bl/venv/lib/python3.10/site-packages/tensorflow_probability/python/layers/internal/distribution_tensor_coercible.py:87\u001b[0m, in \u001b[0;36m_TensorCoercible.__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;66;03m# Look for the attribute in `tensor_distribution`, unless it's a `_tracking`\u001b[39;00m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;66;03m# attribute accessed directly by `getattr` in the `Trackable` base class, in\u001b[39;00m\n\u001b[1;32m 85\u001b[0m \u001b[38;5;66;03m# which case the default passed to `getattr` should be returned.\u001b[39;00m\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtensor_distribution\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mvars\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_tracking\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m name:\n\u001b[0;32m---> 87\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mvars\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtensor_distribution\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 88\u001b[0m \u001b[38;5;66;03m# Otherwise invoke `__getattribute__`, which will return the default passed\u001b[39;00m\n\u001b[1;32m 89\u001b[0m \u001b[38;5;66;03m# to `getattr` if the attribute was not found.\u001b[39;00m\n\u001b[1;32m 90\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__getattribute__\u001b[39m(name)\n",
+ "\u001b[0;31mAttributeError\u001b[0m: 'Independent' object has no attribute 'sddev'"
+ ]
}
+ ],
+ "source": [
+ "prediction_distribution = prob_bnn_model(examples)\n",
+ "prediction_mean = prediction_distribution.mean().numpy().tolist()\n",
+ "prediction_stdv = prediction_distribution.stddev().numpy()\n",
+ "\n",
+ "# The 95% CI is computed as mean ± (1.96 * stdv)\n",
+ "upper = (prediction_mean + (1.96 * prediction_stdv)).tolist()\n",
+ "lower = (prediction_mean - (1.96 * prediction_stdv)).tolist()\n",
+ "prediction_stdv = prediction_stdv.tolist()\n",
+ "\n",
+ "for idx in range(sample):\n",
+ " print(\n",
+ " f\"Prediction mean: {round(prediction_mean[idx][0], 2)}, \"\n",
+ " f\"stddev: {round(prediction_stdv[idx][0], 2)}, \"\n",
+ " f\"95% CI: [{round(upper[idx][0], 2)} - {round(lower[idx][0], 2)}]\"\n",
+ " f\" - Actual: {targets[idx]}\"\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "name": "bayesian_neural_networks_wine",
+ "provenance": [],
+ "toc_visible": true
+ },
+ "kernelspec": {
+ "display_name": "sc_venv_template-bl",
+ "language": "python",
+ "name": "sc_venv_template-bl"
},
- "nbformat": 4,
- "nbformat_minor": 0
-}
\ No newline at end of file
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/BLcourse4/datasets/wine_quality/.config/metadata.json b/BLcourse4/datasets/wine_quality/.config/metadata.json
new file mode 100644
index 0000000000000000000000000000000000000000..151289f553a75e6fb88b490d3dac56df94afb636
--- /dev/null
+++ b/BLcourse4/datasets/wine_quality/.config/metadata.json
@@ -0,0 +1 @@
+{"default_config_name": "white"}
\ No newline at end of file
diff --git a/BLcourse4/datasets/wine_quality/white/1.0.0/dataset_info.json b/BLcourse4/datasets/wine_quality/white/1.0.0/dataset_info.json
new file mode 100644
index 0000000000000000000000000000000000000000..e076db86db3c992de0f98fdb451192048e902d58
--- /dev/null
+++ b/BLcourse4/datasets/wine_quality/white/1.0.0/dataset_info.json
@@ -0,0 +1,38 @@
+{
+ "citation": "@ONLINE {cortezpaulo;cerdeiraantonio;almeidafernando;matostelmo;reisjose1999,\n author = \"Cortez, Paulo; Cerdeira, Antonio; Almeida,Fernando; Matos, Telmo; Reis, Jose\",\n title = \"Modeling wine preferences by data mining from physicochemical properties.\",\n year = \"2009\",\n url = \"https://archive.ics.uci.edu/ml/datasets/wine+quality\"\n}",
+ "configDescription": "White Wine",
+ "configName": "white",
+ "description": "Two datasets were created, using red and white wine samples.\nThe inputs include objective tests (e.g. PH values) and the output is based on sensory data\n(median of at least 3 evaluations made by wine experts).\nEach expert graded the wine quality\nbetween 0 (very bad) and 10 (very excellent).\nSeveral data mining methods were applied to model\nthese datasets under a regression approach. The support vector machine model achieved the\nbest results. Several metrics were computed: MAD, confusion matrix for a fixed error tolerance (T),\netc. Also, we plot the relative importances of the input variables (as measured by a sensitivity\nanalysis procedure).\n\nThe two datasets are related to red and white variants of the Portuguese \"Vinho Verde\" wine.\nFor more details, consult: http://www.vinhoverde.pt/en/ or the reference [Cortez et al., 2009].\nDue to privacy and logistic issues, only physicochemical (inputs) and sensory (the output) variables\nare available (e.g. there is no data about grape types, wine brand, wine selling price, etc.).\n\nNumber of Instances: red wine - 1599; white wine - 4898\n\nInput variables (based on physicochemical tests):\n\n1. fixed acidity\n2. volatile acidity\n3. citric acid\n4. residual sugar\n5. chlorides\n6. free sulfur dioxide\n7. total sulfur dioxide\n8. density\n9. pH\n10. sulphates\n11. alcohol\n\nOutput variable (based on sensory data):\n\n12. quality (score between 0 and 10)",
+ "downloadSize": "264426",
+ "fileFormat": "tfrecord",
+ "location": {
+ "urls": [
+ "https://archive.ics.uci.edu/ml/datasets/wine+quality"
+ ]
+ },
+ "moduleName": "tensorflow_datasets.structured.wine_quality.wine_quality",
+ "name": "wine_quality",
+ "splits": [
+ {
+ "filepathTemplate": "{DATASET}-{SPLIT}.{FILEFORMAT}-{SHARD_X_OF_Y}",
+ "name": "train",
+ "numBytes": "1964098",
+ "shardLengths": [
+ "4898"
+ ]
+ }
+ ],
+ "supervisedKeys": {
+ "tuple": {
+ "items": [
+ {
+ "featureKey": "features"
+ },
+ {
+ "featureKey": "quality"
+ }
+ ]
+ }
+ },
+ "version": "1.0.0"
+}
\ No newline at end of file
diff --git a/BLcourse4/datasets/wine_quality/white/1.0.0/features.json b/BLcourse4/datasets/wine_quality/white/1.0.0/features.json
new file mode 100644
index 0000000000000000000000000000000000000000..b4b59267cbedbb6d7938b68f78ed2122dda9b489
--- /dev/null
+++ b/BLcourse4/datasets/wine_quality/white/1.0.0/features.json
@@ -0,0 +1,110 @@
+{
+ "pythonClassName": "tensorflow_datasets.core.features.features_dict.FeaturesDict",
+ "featuresDict": {
+ "features": {
+ "quality": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "int32",
+ "encoding": "none"
+ }
+ },
+ "features": {
+ "pythonClassName": "tensorflow_datasets.core.features.features_dict.FeaturesDict",
+ "featuresDict": {
+ "features": {
+ "alcohol": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "density": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "residual sugar": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "pH": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "fixed acidity": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "chlorides": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "total sulfur dioxide": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "free sulfur dioxide": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "volatile acidity": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "citric acid": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float32",
+ "encoding": "none"
+ }
+ },
+ "sulphates": {
+ "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+ "tensor": {
+ "shape": {},
+ "dtype": "float64",
+ "encoding": "none"
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/BLcourse4/datasets/wine_quality/white/1.0.0/wine_quality-train.tfrecord-00000-of-00001 b/BLcourse4/datasets/wine_quality/white/1.0.0/wine_quality-train.tfrecord-00000-of-00001
new file mode 100644
index 0000000000000000000000000000000000000000..9fdf820ab8864b57f41bf644daad08e52e94e036
Binary files /dev/null and b/BLcourse4/datasets/wine_quality/white/1.0.0/wine_quality-train.tfrecord-00000-of-00001 differ