Multi_output.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Multi_output.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOgUp+IpOEz1t/CCAuutCJ1",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/armeh429/A-journey-for-learning-advanced-tensorflow/blob/main/Multi_output.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6LunNrVIeh0d"
      },
      "source": [
        "we'll show how you can build models with more than one output. The dataset we will be working on is available from the UCI Machine Learning Repository. It is an Energy Efficiency dataset which uses the bulding features (e.g. wall area, roof area) as inputs and has two outputs: Cooling Load and Heating Load. Let's see how we can build a model to train on this data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JryPUoUReku0"
      },
      "source": [
        "**Imports**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ulUEuu6Na7b1"
      },
      "source": [
        "try: \n",
        "  %tensorflow_version 2.x\n",
        "except Expection:\n",
        "  pass\n",
        "\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "#import matplotlib.pyplot as plt\n",
        "from matplotlib import pyplot as plt\n",
        "import pandas as pd\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.layers import Dense , Input\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JpzHPSRkfkCq"
      },
      "source": [
        "Utilities\n",
        "\n",
        "We define a few utilities for data conversion and visualization to make our code more neat."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NeGhkERTe0HD"
      },
      "source": [
        "def format_output(data):\n",
        "  y1 = data.pop('Y1')\n",
        "  yi = np.array(y1)\n",
        "  y2 = data.pop('Y2')\n",
        "  y2 = np.array(y2)\n",
        "  return y1 , y2\n",
        "\n",
        "def norm(x):\n",
        "    return(x - train_stats['mean'])/train_stats['std']\n",
        "\n",
        "def plot_diff(y_true , y_pred , title = ''):\n",
        "  plt.scatter(y_true, y_pred)\n",
        "  plt.title(title)\n",
        "  plt.xlable('True Value')\n",
        "  plt.ylable('Predictions')\n",
        "  plt.axis('equal')\n",
        "  plt.axis('square')\n",
        "  plt.xlim(plt.xlim())\n",
        "  plt.ylim(plt.ylim())\n",
        "  plt.plot([-100, 100], [-100, 100])\n",
        "  plt.show()\n",
        "\n",
        "def plot_metrics( metric_name ,title , ylim = 5):\n",
        "  plt.title(title)\n",
        "  plt.ylim(0 , ylim)\n",
        "  plt.plot(history.history[metric_name],color = 'blue' , lable = metric_name)\n",
        "  plt.plot(history.history['val_' + metric_name], color='green', label='val_' + metric_name)\n",
        "  plt.show()"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zlYdfFOmiv_v"
      },
      "source": [
        "Prepare the Data\n",
        "\n",
        "We download the dataset and format it for training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WyJsm9BJio6s"
      },
      "source": [
        "# Get the data from UCI dataset\n",
        "URL = 'https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx'\n",
        "#use pandas excel reader\n",
        "df = pd.read_excel(URL)\n",
        "df = df.sample(frac = 1).reset_index(drop = True)\n",
        "#split the data into train and test with 80 train / 20 train\n",
        "train , test = train_test_split(df , test_size = 0.2)\n",
        "train_stats = train.describe()\n",
        "# Get Y1 and Y2 as the 2 outputs and format them as np arrays\n",
        "train_stats.pop('Y1')\n",
        "train_stats.pop('Y2')\n",
        "train_stats = train_stats.transpose()\n",
        "train_Y = format_output(train)\n",
        "test_Y = format_output(test)\n",
        "\n",
        "# Normalize the training and test data\n",
        "norm_train_X = norm(train)\n",
        "norm_test_X = norm(test)"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qmYmB6t0kDym"
      },
      "source": [
        "Build the Model\n",
        "\n",
        "Here is how we'll build the model using the functional syntax. Notice that we can specify a list of outputs (i.e. [y1_output, y2_output]) when we instantiate the Model() class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TXV4ywsBkICM",
        "outputId": "603c5bf9-7385-4116-fced-f405bdd334d0"
      },
      "source": [
        "#Define model layers\n",
        "input_layer = Input(shape=(len(train.columns),))\n",
        "first_dense = Dense(units='128', activation='relu')(input_layer)\n",
        "second_dense = Dense(units='128',activation='relu')(first_dense)\n",
        "\n",
        "#y1 output will be fed directly from the second dense layer\n",
        "y1_output = Dense(units=1 , name= 'y1_output')(second_dense)\n",
        "third_dense = Dense(units=64 , activation='relu')(second_dense)\n",
        "# Y2 output will come via the third dense\n",
        "y2_output = Dense(units='1', name='y2_output')(third_dense)\n",
        "# Define the model with the input layer and a list of output layers\n",
        "model = Model(inputs=input_layer, outputs=[y1_output, y2_output])\n",
        "\n",
        "print(model.summary())"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_3\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_4 (InputLayer)            [(None, 8)]          0                                            \n",
            "__________________________________________________________________________________________________\n",
            "dense_9 (Dense)                 (None, 128)          1152        input_4[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "dense_10 (Dense)                (None, 128)          16512       dense_9[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "dense_11 (Dense)                (None, 64)           8256        dense_10[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "y1_output (Dense)               (None, 1)            129         dense_10[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "y2_output (Dense)               (None, 1)            65          dense_11[0][0]                   \n",
            "==================================================================================================\n",
            "Total params: 26,114\n",
            "Trainable params: 26,114\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbh1F8XOloDM"
      },
      "source": [
        "Configure parameters\n",
        "\n",
        "We specify the optimizer as well as the loss and metrics for each output"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eDC4VNe_lgX0",
        "outputId": "b1f3fdb7-3389-4cd6-aef5-44dab16d8b48"
      },
      "source": [
        "# Specify the optimizer, and compile the model with loss functions for both outputs\n",
        "optimizer = tf.keras.optimizers.SGD(lr=0.001)\n",
        "model.compile(optimizer=optimizer,\n",
        "              loss={'y1_output': 'mse', 'y2_output': 'mse'},\n",
        "              metrics={'y1_output': tf.keras.metrics.RootMeanSquaredError(),\n",
        "                       'y2_output': tf.keras.metrics.RootMeanSquaredError()})"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  \"The `lr` argument is deprecated, use `learning_rate` instead.\")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IWJGxjEOl0yq"
      },
      "source": [
        "Train the model "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wPPJ-KnVlylV",
        "outputId": "1a7e6270-03ee-48a7-8f20-f7990f42ecfe"
      },
      "source": [
        "#train the model for 500 epochs\n",
        "history = model.fit(norm_train_X , train_Y,\n",
        "                    epochs = 500 , batch_size = 10 , validation_data = (norm_test_X , test_Y))"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/500\n",
            "62/62 [==============================] - 1s 6ms/step - loss: 210.4502 - y1_output_loss: 99.8709 - y2_output_loss: 110.5793 - y1_output_root_mean_squared_error: 9.9935 - y2_output_root_mean_squared_error: 10.5157 - val_loss: 36.7541 - val_y1_output_loss: 17.2910 - val_y2_output_loss: 19.4631 - val_y1_output_root_mean_squared_error: 4.1582 - val_y2_output_root_mean_squared_error: 4.4117\n",
            "Epoch 2/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 35.7710 - y1_output_loss: 13.1795 - y2_output_loss: 22.5916 - y1_output_root_mean_squared_error: 3.6304 - y2_output_root_mean_squared_error: 4.7531 - val_loss: 25.7414 - val_y1_output_loss: 11.2060 - val_y2_output_loss: 14.5354 - val_y1_output_root_mean_squared_error: 3.3475 - val_y2_output_root_mean_squared_error: 3.8125\n",
            "Epoch 3/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 24.3079 - y1_output_loss: 9.6112 - y2_output_loss: 14.6967 - y1_output_root_mean_squared_error: 3.1002 - y2_output_root_mean_squared_error: 3.8336 - val_loss: 148.4575 - val_y1_output_loss: 32.3580 - val_y2_output_loss: 116.0995 - val_y1_output_root_mean_squared_error: 5.6884 - val_y2_output_root_mean_squared_error: 10.7749\n",
            "Epoch 4/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 27.5576 - y1_output_loss: 10.0788 - y2_output_loss: 17.4788 - y1_output_root_mean_squared_error: 3.1747 - y2_output_root_mean_squared_error: 4.1808 - val_loss: 38.5647 - val_y1_output_loss: 11.5365 - val_y2_output_loss: 27.0282 - val_y1_output_root_mean_squared_error: 3.3965 - val_y2_output_root_mean_squared_error: 5.1989\n",
            "Epoch 5/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 26.0322 - y1_output_loss: 9.7180 - y2_output_loss: 16.3141 - y1_output_root_mean_squared_error: 3.1174 - y2_output_root_mean_squared_error: 4.0391 - val_loss: 62.2595 - val_y1_output_loss: 14.9722 - val_y2_output_loss: 47.2873 - val_y1_output_root_mean_squared_error: 3.8694 - val_y2_output_root_mean_squared_error: 6.8766\n",
            "Epoch 6/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 24.8858 - y1_output_loss: 9.1603 - y2_output_loss: 15.7255 - y1_output_root_mean_squared_error: 3.0266 - y2_output_root_mean_squared_error: 3.9655 - val_loss: 22.7262 - val_y1_output_loss: 9.7694 - val_y2_output_loss: 12.9568 - val_y1_output_root_mean_squared_error: 3.1256 - val_y2_output_root_mean_squared_error: 3.5996\n",
            "Epoch 7/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 21.2133 - y1_output_loss: 8.4078 - y2_output_loss: 12.8055 - y1_output_root_mean_squared_error: 2.8996 - y2_output_root_mean_squared_error: 3.5785 - val_loss: 26.6306 - val_y1_output_loss: 10.6282 - val_y2_output_loss: 16.0024 - val_y1_output_root_mean_squared_error: 3.2601 - val_y2_output_root_mean_squared_error: 4.0003\n",
            "Epoch 8/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 21.3738 - y1_output_loss: 8.5814 - y2_output_loss: 12.7924 - y1_output_root_mean_squared_error: 2.9294 - y2_output_root_mean_squared_error: 3.5767 - val_loss: 24.9046 - val_y1_output_loss: 8.3764 - val_y2_output_loss: 16.5281 - val_y1_output_root_mean_squared_error: 2.8942 - val_y2_output_root_mean_squared_error: 4.0655\n",
            "Epoch 9/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 21.6984 - y1_output_loss: 8.4447 - y2_output_loss: 13.2537 - y1_output_root_mean_squared_error: 2.9060 - y2_output_root_mean_squared_error: 3.6406 - val_loss: 34.1286 - val_y1_output_loss: 13.2798 - val_y2_output_loss: 20.8488 - val_y1_output_root_mean_squared_error: 3.6441 - val_y2_output_root_mean_squared_error: 4.5660\n",
            "Epoch 10/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 22.4166 - y1_output_loss: 8.7046 - y2_output_loss: 13.7120 - y1_output_root_mean_squared_error: 2.9504 - y2_output_root_mean_squared_error: 3.7030 - val_loss: 18.8608 - val_y1_output_loss: 7.8243 - val_y2_output_loss: 11.0365 - val_y1_output_root_mean_squared_error: 2.7972 - val_y2_output_root_mean_squared_error: 3.3221\n",
            "Epoch 11/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 19.7692 - y1_output_loss: 8.0285 - y2_output_loss: 11.7407 - y1_output_root_mean_squared_error: 2.8335 - y2_output_root_mean_squared_error: 3.4265 - val_loss: 17.3787 - val_y1_output_loss: 6.8909 - val_y2_output_loss: 10.4877 - val_y1_output_root_mean_squared_error: 2.6251 - val_y2_output_root_mean_squared_error: 3.2385\n",
            "Epoch 12/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 18.8102 - y1_output_loss: 7.7034 - y2_output_loss: 11.1068 - y1_output_root_mean_squared_error: 2.7755 - y2_output_root_mean_squared_error: 3.3327 - val_loss: 20.8119 - val_y1_output_loss: 7.3577 - val_y2_output_loss: 13.4542 - val_y1_output_root_mean_squared_error: 2.7125 - val_y2_output_root_mean_squared_error: 3.6680\n",
            "Epoch 13/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 20.7333 - y1_output_loss: 7.7253 - y2_output_loss: 13.0080 - y1_output_root_mean_squared_error: 2.7794 - y2_output_root_mean_squared_error: 3.6067 - val_loss: 18.9320 - val_y1_output_loss: 7.7236 - val_y2_output_loss: 11.2084 - val_y1_output_root_mean_squared_error: 2.7791 - val_y2_output_root_mean_squared_error: 3.3479\n",
            "Epoch 14/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 18.8359 - y1_output_loss: 7.6219 - y2_output_loss: 11.2139 - y1_output_root_mean_squared_error: 2.7608 - y2_output_root_mean_squared_error: 3.3487 - val_loss: 20.5025 - val_y1_output_loss: 8.9189 - val_y2_output_loss: 11.5836 - val_y1_output_root_mean_squared_error: 2.9865 - val_y2_output_root_mean_squared_error: 3.4035\n",
            "Epoch 15/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 17.0497 - y1_output_loss: 6.9615 - y2_output_loss: 10.0882 - y1_output_root_mean_squared_error: 2.6385 - y2_output_root_mean_squared_error: 3.1762 - val_loss: 40.0282 - val_y1_output_loss: 9.0060 - val_y2_output_loss: 31.0222 - val_y1_output_root_mean_squared_error: 3.0010 - val_y2_output_root_mean_squared_error: 5.5698\n",
            "Epoch 16/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 19.6078 - y1_output_loss: 7.1463 - y2_output_loss: 12.4615 - y1_output_root_mean_squared_error: 2.6733 - y2_output_root_mean_squared_error: 3.5301 - val_loss: 22.2453 - val_y1_output_loss: 9.0668 - val_y2_output_loss: 13.1785 - val_y1_output_root_mean_squared_error: 3.0111 - val_y2_output_root_mean_squared_error: 3.6302\n",
            "Epoch 17/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 19.4780 - y1_output_loss: 7.6585 - y2_output_loss: 11.8195 - y1_output_root_mean_squared_error: 2.7674 - y2_output_root_mean_squared_error: 3.4380 - val_loss: 30.9287 - val_y1_output_loss: 9.3386 - val_y2_output_loss: 21.5902 - val_y1_output_root_mean_squared_error: 3.0559 - val_y2_output_root_mean_squared_error: 4.6465\n",
            "Epoch 18/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 19.0389 - y1_output_loss: 6.9700 - y2_output_loss: 12.0690 - y1_output_root_mean_squared_error: 2.6401 - y2_output_root_mean_squared_error: 3.4740 - val_loss: 35.2699 - val_y1_output_loss: 13.0039 - val_y2_output_loss: 22.2660 - val_y1_output_root_mean_squared_error: 3.6061 - val_y2_output_root_mean_squared_error: 4.7187\n",
            "Epoch 19/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 14.9551 - y1_output_loss: 6.2998 - y2_output_loss: 8.6553 - y1_output_root_mean_squared_error: 2.5099 - y2_output_root_mean_squared_error: 2.9420 - val_loss: 16.5224 - val_y1_output_loss: 7.5521 - val_y2_output_loss: 8.9703 - val_y1_output_root_mean_squared_error: 2.7481 - val_y2_output_root_mean_squared_error: 2.9951\n",
            "Epoch 20/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 16.8062 - y1_output_loss: 6.6649 - y2_output_loss: 10.1413 - y1_output_root_mean_squared_error: 2.5817 - y2_output_root_mean_squared_error: 3.1845 - val_loss: 15.8666 - val_y1_output_loss: 6.3701 - val_y2_output_loss: 9.4965 - val_y1_output_root_mean_squared_error: 2.5239 - val_y2_output_root_mean_squared_error: 3.0816\n",
            "Epoch 21/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 15.8541 - y1_output_loss: 6.1460 - y2_output_loss: 9.7081 - y1_output_root_mean_squared_error: 2.4791 - y2_output_root_mean_squared_error: 3.1158 - val_loss: 13.6813 - val_y1_output_loss: 6.1746 - val_y2_output_loss: 7.5067 - val_y1_output_root_mean_squared_error: 2.4849 - val_y2_output_root_mean_squared_error: 2.7398\n",
            "Epoch 22/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 14.0789 - y1_output_loss: 5.6652 - y2_output_loss: 8.4137 - y1_output_root_mean_squared_error: 2.3802 - y2_output_root_mean_squared_error: 2.9006 - val_loss: 25.1468 - val_y1_output_loss: 8.2807 - val_y2_output_loss: 16.8661 - val_y1_output_root_mean_squared_error: 2.8776 - val_y2_output_root_mean_squared_error: 4.1068\n",
            "Epoch 23/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 14.2491 - y1_output_loss: 5.6002 - y2_output_loss: 8.6489 - y1_output_root_mean_squared_error: 2.3665 - y2_output_root_mean_squared_error: 2.9409 - val_loss: 16.9917 - val_y1_output_loss: 6.5402 - val_y2_output_loss: 10.4515 - val_y1_output_root_mean_squared_error: 2.5574 - val_y2_output_root_mean_squared_error: 3.2329\n",
            "Epoch 24/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 15.5104 - y1_output_loss: 6.0178 - y2_output_loss: 9.4926 - y1_output_root_mean_squared_error: 2.4531 - y2_output_root_mean_squared_error: 3.0810 - val_loss: 12.0734 - val_y1_output_loss: 4.6865 - val_y2_output_loss: 7.3869 - val_y1_output_root_mean_squared_error: 2.1648 - val_y2_output_root_mean_squared_error: 2.7179\n",
            "Epoch 25/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 15.4944 - y1_output_loss: 5.7355 - y2_output_loss: 9.7590 - y1_output_root_mean_squared_error: 2.3949 - y2_output_root_mean_squared_error: 3.1239 - val_loss: 54.5373 - val_y1_output_loss: 16.0368 - val_y2_output_loss: 38.5006 - val_y1_output_root_mean_squared_error: 4.0046 - val_y2_output_root_mean_squared_error: 6.2049\n",
            "Epoch 26/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 15.1459 - y1_output_loss: 5.6532 - y2_output_loss: 9.4927 - y1_output_root_mean_squared_error: 2.3776 - y2_output_root_mean_squared_error: 3.0810 - val_loss: 12.1024 - val_y1_output_loss: 4.9939 - val_y2_output_loss: 7.1084 - val_y1_output_root_mean_squared_error: 2.2347 - val_y2_output_root_mean_squared_error: 2.6662\n",
            "Epoch 27/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 14.4511 - y1_output_loss: 5.3566 - y2_output_loss: 9.0945 - y1_output_root_mean_squared_error: 2.3144 - y2_output_root_mean_squared_error: 3.0157 - val_loss: 12.3143 - val_y1_output_loss: 5.1452 - val_y2_output_loss: 7.1691 - val_y1_output_root_mean_squared_error: 2.2683 - val_y2_output_root_mean_squared_error: 2.6775\n",
            "Epoch 28/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 12.0785 - y1_output_loss: 4.8721 - y2_output_loss: 7.2064 - y1_output_root_mean_squared_error: 2.2073 - y2_output_root_mean_squared_error: 2.6845 - val_loss: 41.5498 - val_y1_output_loss: 9.6132 - val_y2_output_loss: 31.9366 - val_y1_output_root_mean_squared_error: 3.1005 - val_y2_output_root_mean_squared_error: 5.6512\n",
            "Epoch 29/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 12.7066 - y1_output_loss: 4.8898 - y2_output_loss: 7.8168 - y1_output_root_mean_squared_error: 2.2113 - y2_output_root_mean_squared_error: 2.7959 - val_loss: 14.0806 - val_y1_output_loss: 4.5130 - val_y2_output_loss: 9.5676 - val_y1_output_root_mean_squared_error: 2.1244 - val_y2_output_root_mean_squared_error: 3.0931\n",
            "Epoch 30/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 12.5976 - y1_output_loss: 4.6227 - y2_output_loss: 7.9749 - y1_output_root_mean_squared_error: 2.1500 - y2_output_root_mean_squared_error: 2.8240 - val_loss: 12.3154 - val_y1_output_loss: 4.0816 - val_y2_output_loss: 8.2338 - val_y1_output_root_mean_squared_error: 2.0203 - val_y2_output_root_mean_squared_error: 2.8695\n",
            "Epoch 31/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 11.9093 - y1_output_loss: 4.4328 - y2_output_loss: 7.4765 - y1_output_root_mean_squared_error: 2.1054 - y2_output_root_mean_squared_error: 2.7343 - val_loss: 50.8640 - val_y1_output_loss: 8.8010 - val_y2_output_loss: 42.0629 - val_y1_output_root_mean_squared_error: 2.9667 - val_y2_output_root_mean_squared_error: 6.4856\n",
            "Epoch 32/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 10.6481 - y1_output_loss: 4.0501 - y2_output_loss: 6.5980 - y1_output_root_mean_squared_error: 2.0125 - y2_output_root_mean_squared_error: 2.5687 - val_loss: 16.1247 - val_y1_output_loss: 5.0206 - val_y2_output_loss: 11.1042 - val_y1_output_root_mean_squared_error: 2.2407 - val_y2_output_root_mean_squared_error: 3.3323\n",
            "Epoch 33/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 11.7892 - y1_output_loss: 4.2220 - y2_output_loss: 7.5672 - y1_output_root_mean_squared_error: 2.0547 - y2_output_root_mean_squared_error: 2.7509 - val_loss: 25.6367 - val_y1_output_loss: 8.4959 - val_y2_output_loss: 17.1408 - val_y1_output_root_mean_squared_error: 2.9148 - val_y2_output_root_mean_squared_error: 4.1401\n",
            "Epoch 34/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 12.3538 - y1_output_loss: 4.2057 - y2_output_loss: 8.1482 - y1_output_root_mean_squared_error: 2.0508 - y2_output_root_mean_squared_error: 2.8545 - val_loss: 8.3049 - val_y1_output_loss: 2.8444 - val_y2_output_loss: 5.4605 - val_y1_output_root_mean_squared_error: 1.6865 - val_y2_output_root_mean_squared_error: 2.3368\n",
            "Epoch 35/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 9.8636 - y1_output_loss: 3.7494 - y2_output_loss: 6.1141 - y1_output_root_mean_squared_error: 1.9363 - y2_output_root_mean_squared_error: 2.4727 - val_loss: 9.1501 - val_y1_output_loss: 3.4662 - val_y2_output_loss: 5.6839 - val_y1_output_root_mean_squared_error: 1.8618 - val_y2_output_root_mean_squared_error: 2.3841\n",
            "Epoch 36/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 9.8073 - y1_output_loss: 3.6058 - y2_output_loss: 6.2015 - y1_output_root_mean_squared_error: 1.8989 - y2_output_root_mean_squared_error: 2.4903 - val_loss: 13.6251 - val_y1_output_loss: 4.8019 - val_y2_output_loss: 8.8232 - val_y1_output_root_mean_squared_error: 2.1913 - val_y2_output_root_mean_squared_error: 2.9704\n",
            "Epoch 37/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 10.2905 - y1_output_loss: 3.5243 - y2_output_loss: 6.7662 - y1_output_root_mean_squared_error: 1.8773 - y2_output_root_mean_squared_error: 2.6012 - val_loss: 21.3991 - val_y1_output_loss: 6.5400 - val_y2_output_loss: 14.8591 - val_y1_output_root_mean_squared_error: 2.5573 - val_y2_output_root_mean_squared_error: 3.8548\n",
            "Epoch 38/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 8.9326 - y1_output_loss: 3.2818 - y2_output_loss: 5.6508 - y1_output_root_mean_squared_error: 1.8116 - y2_output_root_mean_squared_error: 2.3771 - val_loss: 12.9821 - val_y1_output_loss: 3.1220 - val_y2_output_loss: 9.8601 - val_y1_output_root_mean_squared_error: 1.7669 - val_y2_output_root_mean_squared_error: 3.1401\n",
            "Epoch 39/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 10.0124 - y1_output_loss: 3.4673 - y2_output_loss: 6.5451 - y1_output_root_mean_squared_error: 1.8621 - y2_output_root_mean_squared_error: 2.5583 - val_loss: 9.9232 - val_y1_output_loss: 3.1360 - val_y2_output_loss: 6.7872 - val_y1_output_root_mean_squared_error: 1.7709 - val_y2_output_root_mean_squared_error: 2.6052\n",
            "Epoch 40/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 8.6588 - y1_output_loss: 2.9569 - y2_output_loss: 5.7019 - y1_output_root_mean_squared_error: 1.7196 - y2_output_root_mean_squared_error: 2.3879 - val_loss: 8.2815 - val_y1_output_loss: 2.8945 - val_y2_output_loss: 5.3870 - val_y1_output_root_mean_squared_error: 1.7013 - val_y2_output_root_mean_squared_error: 2.3210\n",
            "Epoch 41/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 8.9584 - y1_output_loss: 3.0490 - y2_output_loss: 5.9094 - y1_output_root_mean_squared_error: 1.7461 - y2_output_root_mean_squared_error: 2.4309 - val_loss: 9.4084 - val_y1_output_loss: 3.1801 - val_y2_output_loss: 6.2283 - val_y1_output_root_mean_squared_error: 1.7833 - val_y2_output_root_mean_squared_error: 2.4957\n",
            "Epoch 42/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 9.6346 - y1_output_loss: 2.9701 - y2_output_loss: 6.6645 - y1_output_root_mean_squared_error: 1.7234 - y2_output_root_mean_squared_error: 2.5816 - val_loss: 11.7531 - val_y1_output_loss: 3.8729 - val_y2_output_loss: 7.8802 - val_y1_output_root_mean_squared_error: 1.9680 - val_y2_output_root_mean_squared_error: 2.8072\n",
            "Epoch 43/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.2558 - y1_output_loss: 2.4542 - y2_output_loss: 4.8015 - y1_output_root_mean_squared_error: 1.5666 - y2_output_root_mean_squared_error: 2.1912 - val_loss: 10.1245 - val_y1_output_loss: 2.7195 - val_y2_output_loss: 7.4049 - val_y1_output_root_mean_squared_error: 1.6491 - val_y2_output_root_mean_squared_error: 2.7212\n",
            "Epoch 44/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.9451 - y1_output_loss: 2.7440 - y2_output_loss: 5.2010 - y1_output_root_mean_squared_error: 1.6565 - y2_output_root_mean_squared_error: 2.2806 - val_loss: 16.8929 - val_y1_output_loss: 3.3645 - val_y2_output_loss: 13.5284 - val_y1_output_root_mean_squared_error: 1.8342 - val_y2_output_root_mean_squared_error: 3.6781\n",
            "Epoch 45/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.6276 - y1_output_loss: 2.4338 - y2_output_loss: 5.1938 - y1_output_root_mean_squared_error: 1.5600 - y2_output_root_mean_squared_error: 2.2790 - val_loss: 8.5653 - val_y1_output_loss: 2.8318 - val_y2_output_loss: 5.7334 - val_y1_output_root_mean_squared_error: 1.6828 - val_y2_output_root_mean_squared_error: 2.3945\n",
            "Epoch 46/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.2263 - y1_output_loss: 2.5285 - y2_output_loss: 4.6977 - y1_output_root_mean_squared_error: 1.5901 - y2_output_root_mean_squared_error: 2.1674 - val_loss: 6.5583 - val_y1_output_loss: 1.8534 - val_y2_output_loss: 4.7049 - val_y1_output_root_mean_squared_error: 1.3614 - val_y2_output_root_mean_squared_error: 2.1691\n",
            "Epoch 47/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.0195 - y1_output_loss: 2.3771 - y2_output_loss: 4.6425 - y1_output_root_mean_squared_error: 1.5418 - y2_output_root_mean_squared_error: 2.1546 - val_loss: 7.5132 - val_y1_output_loss: 2.3128 - val_y2_output_loss: 5.2003 - val_y1_output_root_mean_squared_error: 1.5208 - val_y2_output_root_mean_squared_error: 2.2804\n",
            "Epoch 48/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 6.4497 - y1_output_loss: 2.0833 - y2_output_loss: 4.3664 - y1_output_root_mean_squared_error: 1.4434 - y2_output_root_mean_squared_error: 2.0896 - val_loss: 17.3555 - val_y1_output_loss: 4.3769 - val_y2_output_loss: 12.9786 - val_y1_output_root_mean_squared_error: 2.0921 - val_y2_output_root_mean_squared_error: 3.6026\n",
            "Epoch 49/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.1581 - y1_output_loss: 2.2825 - y2_output_loss: 4.8756 - y1_output_root_mean_squared_error: 1.5108 - y2_output_root_mean_squared_error: 2.2081 - val_loss: 8.2107 - val_y1_output_loss: 2.9390 - val_y2_output_loss: 5.2717 - val_y1_output_root_mean_squared_error: 1.7144 - val_y2_output_root_mean_squared_error: 2.2960\n",
            "Epoch 50/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.0214 - y1_output_loss: 2.0650 - y2_output_loss: 4.9564 - y1_output_root_mean_squared_error: 1.4370 - y2_output_root_mean_squared_error: 2.2263 - val_loss: 6.8132 - val_y1_output_loss: 1.9475 - val_y2_output_loss: 4.8657 - val_y1_output_root_mean_squared_error: 1.3955 - val_y2_output_root_mean_squared_error: 2.2058\n",
            "Epoch 51/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.3921 - y1_output_loss: 2.2087 - y2_output_loss: 5.1835 - y1_output_root_mean_squared_error: 1.4862 - y2_output_root_mean_squared_error: 2.2767 - val_loss: 8.1429 - val_y1_output_loss: 1.9524 - val_y2_output_loss: 6.1905 - val_y1_output_root_mean_squared_error: 1.3973 - val_y2_output_root_mean_squared_error: 2.4881\n",
            "Epoch 52/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 6.3734 - y1_output_loss: 1.9417 - y2_output_loss: 4.4317 - y1_output_root_mean_squared_error: 1.3934 - y2_output_root_mean_squared_error: 2.1052 - val_loss: 7.0063 - val_y1_output_loss: 2.1379 - val_y2_output_loss: 4.8684 - val_y1_output_root_mean_squared_error: 1.4622 - val_y2_output_root_mean_squared_error: 2.2064\n",
            "Epoch 53/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 8.2468 - y1_output_loss: 2.4999 - y2_output_loss: 5.7469 - y1_output_root_mean_squared_error: 1.5811 - y2_output_root_mean_squared_error: 2.3973 - val_loss: 6.7667 - val_y1_output_loss: 2.0795 - val_y2_output_loss: 4.6872 - val_y1_output_root_mean_squared_error: 1.4420 - val_y2_output_root_mean_squared_error: 2.1650\n",
            "Epoch 54/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 6.0437 - y1_output_loss: 1.8686 - y2_output_loss: 4.1750 - y1_output_root_mean_squared_error: 1.3670 - y2_output_root_mean_squared_error: 2.0433 - val_loss: 6.6941 - val_y1_output_loss: 1.5645 - val_y2_output_loss: 5.1296 - val_y1_output_root_mean_squared_error: 1.2508 - val_y2_output_root_mean_squared_error: 2.2649\n",
            "Epoch 55/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 8.2096 - y1_output_loss: 2.4820 - y2_output_loss: 5.7277 - y1_output_root_mean_squared_error: 1.5754 - y2_output_root_mean_squared_error: 2.3933 - val_loss: 17.3262 - val_y1_output_loss: 3.0283 - val_y2_output_loss: 14.2979 - val_y1_output_root_mean_squared_error: 1.7402 - val_y2_output_root_mean_squared_error: 3.7813\n",
            "Epoch 56/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 6.1602 - y1_output_loss: 1.8266 - y2_output_loss: 4.3336 - y1_output_root_mean_squared_error: 1.3515 - y2_output_root_mean_squared_error: 2.0817 - val_loss: 7.5108 - val_y1_output_loss: 2.4376 - val_y2_output_loss: 5.0732 - val_y1_output_root_mean_squared_error: 1.5613 - val_y2_output_root_mean_squared_error: 2.2524\n",
            "Epoch 57/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 5.9644 - y1_output_loss: 1.8064 - y2_output_loss: 4.1580 - y1_output_root_mean_squared_error: 1.3440 - y2_output_root_mean_squared_error: 2.0391 - val_loss: 14.0177 - val_y1_output_loss: 3.3288 - val_y2_output_loss: 10.6889 - val_y1_output_root_mean_squared_error: 1.8245 - val_y2_output_root_mean_squared_error: 3.2694\n",
            "Epoch 58/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 5.9585 - y1_output_loss: 1.7277 - y2_output_loss: 4.2309 - y1_output_root_mean_squared_error: 1.3144 - y2_output_root_mean_squared_error: 2.0569 - val_loss: 5.7035 - val_y1_output_loss: 1.4838 - val_y2_output_loss: 4.2196 - val_y1_output_root_mean_squared_error: 1.2181 - val_y2_output_root_mean_squared_error: 2.0542\n",
            "Epoch 59/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 5.0712 - y1_output_loss: 1.5082 - y2_output_loss: 3.5631 - y1_output_root_mean_squared_error: 1.2281 - y2_output_root_mean_squared_error: 1.8876 - val_loss: 6.9326 - val_y1_output_loss: 1.2303 - val_y2_output_loss: 5.7023 - val_y1_output_root_mean_squared_error: 1.1092 - val_y2_output_root_mean_squared_error: 2.3880\n",
            "Epoch 60/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.7851 - y1_output_loss: 2.1974 - y2_output_loss: 5.5877 - y1_output_root_mean_squared_error: 1.4824 - y2_output_root_mean_squared_error: 2.3638 - val_loss: 6.1226 - val_y1_output_loss: 1.6634 - val_y2_output_loss: 4.4593 - val_y1_output_root_mean_squared_error: 1.2897 - val_y2_output_root_mean_squared_error: 2.1117\n",
            "Epoch 61/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 6.5711 - y1_output_loss: 2.1159 - y2_output_loss: 4.4552 - y1_output_root_mean_squared_error: 1.4546 - y2_output_root_mean_squared_error: 2.1107 - val_loss: 9.2024 - val_y1_output_loss: 1.9065 - val_y2_output_loss: 7.2959 - val_y1_output_root_mean_squared_error: 1.3808 - val_y2_output_root_mean_squared_error: 2.7011\n",
            "Epoch 62/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 5.5480 - y1_output_loss: 1.4861 - y2_output_loss: 4.0620 - y1_output_root_mean_squared_error: 1.2190 - y2_output_root_mean_squared_error: 2.0154 - val_loss: 5.9491 - val_y1_output_loss: 1.5628 - val_y2_output_loss: 4.3864 - val_y1_output_root_mean_squared_error: 1.2501 - val_y2_output_root_mean_squared_error: 2.0944\n",
            "Epoch 63/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 5.0037 - y1_output_loss: 1.5840 - y2_output_loss: 3.4196 - y1_output_root_mean_squared_error: 1.2586 - y2_output_root_mean_squared_error: 1.8492 - val_loss: 5.6064 - val_y1_output_loss: 1.2647 - val_y2_output_loss: 4.3417 - val_y1_output_root_mean_squared_error: 1.1246 - val_y2_output_root_mean_squared_error: 2.0837\n",
            "Epoch 64/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.6878 - y1_output_loss: 1.3727 - y2_output_loss: 3.3152 - y1_output_root_mean_squared_error: 1.1716 - y2_output_root_mean_squared_error: 1.8208 - val_loss: 10.6640 - val_y1_output_loss: 2.0492 - val_y2_output_loss: 8.6148 - val_y1_output_root_mean_squared_error: 1.4315 - val_y2_output_root_mean_squared_error: 2.9351\n",
            "Epoch 65/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 7.0068 - y1_output_loss: 1.9080 - y2_output_loss: 5.0989 - y1_output_root_mean_squared_error: 1.3813 - y2_output_root_mean_squared_error: 2.2581 - val_loss: 18.5295 - val_y1_output_loss: 3.4653 - val_y2_output_loss: 15.0642 - val_y1_output_root_mean_squared_error: 1.8615 - val_y2_output_root_mean_squared_error: 3.8813\n",
            "Epoch 66/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 5.3792 - y1_output_loss: 1.4994 - y2_output_loss: 3.8798 - y1_output_root_mean_squared_error: 1.2245 - y2_output_root_mean_squared_error: 1.9697 - val_loss: 5.8016 - val_y1_output_loss: 1.4413 - val_y2_output_loss: 4.3603 - val_y1_output_root_mean_squared_error: 1.2005 - val_y2_output_root_mean_squared_error: 2.0881\n",
            "Epoch 67/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 5.7749 - y1_output_loss: 1.7944 - y2_output_loss: 3.9805 - y1_output_root_mean_squared_error: 1.3396 - y2_output_root_mean_squared_error: 1.9951 - val_loss: 11.2695 - val_y1_output_loss: 3.0248 - val_y2_output_loss: 8.2446 - val_y1_output_root_mean_squared_error: 1.7392 - val_y2_output_root_mean_squared_error: 2.8713\n",
            "Epoch 68/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.8388 - y1_output_loss: 1.3622 - y2_output_loss: 3.4767 - y1_output_root_mean_squared_error: 1.1671 - y2_output_root_mean_squared_error: 1.8646 - val_loss: 4.9875 - val_y1_output_loss: 1.0159 - val_y2_output_loss: 3.9716 - val_y1_output_root_mean_squared_error: 1.0079 - val_y2_output_root_mean_squared_error: 1.9929\n",
            "Epoch 69/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.0408 - y1_output_loss: 1.0907 - y2_output_loss: 2.9501 - y1_output_root_mean_squared_error: 1.0444 - y2_output_root_mean_squared_error: 1.7176 - val_loss: 32.0292 - val_y1_output_loss: 3.9893 - val_y2_output_loss: 28.0399 - val_y1_output_root_mean_squared_error: 1.9973 - val_y2_output_root_mean_squared_error: 5.2953\n",
            "Epoch 70/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 5.3085 - y1_output_loss: 1.4606 - y2_output_loss: 3.8479 - y1_output_root_mean_squared_error: 1.2086 - y2_output_root_mean_squared_error: 1.9616 - val_loss: 7.3302 - val_y1_output_loss: 2.3775 - val_y2_output_loss: 4.9528 - val_y1_output_root_mean_squared_error: 1.5419 - val_y2_output_root_mean_squared_error: 2.2255\n",
            "Epoch 71/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.8846 - y1_output_loss: 1.1729 - y2_output_loss: 2.7117 - y1_output_root_mean_squared_error: 1.0830 - y2_output_root_mean_squared_error: 1.6467 - val_loss: 4.1976 - val_y1_output_loss: 0.7766 - val_y2_output_loss: 3.4210 - val_y1_output_root_mean_squared_error: 0.8812 - val_y2_output_root_mean_squared_error: 1.8496\n",
            "Epoch 72/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 3.6733 - y1_output_loss: 1.0067 - y2_output_loss: 2.6666 - y1_output_root_mean_squared_error: 1.0033 - y2_output_root_mean_squared_error: 1.6330 - val_loss: 4.4839 - val_y1_output_loss: 1.0385 - val_y2_output_loss: 3.4453 - val_y1_output_root_mean_squared_error: 1.0191 - val_y2_output_root_mean_squared_error: 1.8562\n",
            "Epoch 73/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.5308 - y1_output_loss: 1.2620 - y2_output_loss: 3.2688 - y1_output_root_mean_squared_error: 1.1234 - y2_output_root_mean_squared_error: 1.8080 - val_loss: 9.2418 - val_y1_output_loss: 1.8958 - val_y2_output_loss: 7.3460 - val_y1_output_root_mean_squared_error: 1.3769 - val_y2_output_root_mean_squared_error: 2.7103\n",
            "Epoch 74/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.2542 - y1_output_loss: 1.1120 - y2_output_loss: 3.1422 - y1_output_root_mean_squared_error: 1.0545 - y2_output_root_mean_squared_error: 1.7726 - val_loss: 4.7358 - val_y1_output_loss: 0.9216 - val_y2_output_loss: 3.8142 - val_y1_output_root_mean_squared_error: 0.9600 - val_y2_output_root_mean_squared_error: 1.9530\n",
            "Epoch 75/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.3215 - y1_output_loss: 1.2506 - y2_output_loss: 3.0709 - y1_output_root_mean_squared_error: 1.1183 - y2_output_root_mean_squared_error: 1.7524 - val_loss: 6.0844 - val_y1_output_loss: 1.5303 - val_y2_output_loss: 4.5541 - val_y1_output_root_mean_squared_error: 1.2371 - val_y2_output_root_mean_squared_error: 2.1340\n",
            "Epoch 76/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.5251 - y1_output_loss: 1.0415 - y2_output_loss: 3.4836 - y1_output_root_mean_squared_error: 1.0205 - y2_output_root_mean_squared_error: 1.8664 - val_loss: 16.5189 - val_y1_output_loss: 2.9122 - val_y2_output_loss: 13.6067 - val_y1_output_root_mean_squared_error: 1.7065 - val_y2_output_root_mean_squared_error: 3.6887\n",
            "Epoch 77/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.2272 - y1_output_loss: 1.0340 - y2_output_loss: 3.1933 - y1_output_root_mean_squared_error: 1.0168 - y2_output_root_mean_squared_error: 1.7870 - val_loss: 13.9712 - val_y1_output_loss: 5.1387 - val_y2_output_loss: 8.8325 - val_y1_output_root_mean_squared_error: 2.2669 - val_y2_output_root_mean_squared_error: 2.9720\n",
            "Epoch 78/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 4.0215 - y1_output_loss: 1.0583 - y2_output_loss: 2.9632 - y1_output_root_mean_squared_error: 1.0287 - y2_output_root_mean_squared_error: 1.7214 - val_loss: 3.8301 - val_y1_output_loss: 0.5731 - val_y2_output_loss: 3.2570 - val_y1_output_root_mean_squared_error: 0.7570 - val_y2_output_root_mean_squared_error: 1.8047\n",
            "Epoch 79/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.1153 - y1_output_loss: 0.7124 - y2_output_loss: 2.4029 - y1_output_root_mean_squared_error: 0.8440 - y2_output_root_mean_squared_error: 1.5501 - val_loss: 61.3842 - val_y1_output_loss: 23.4234 - val_y2_output_loss: 37.9608 - val_y1_output_root_mean_squared_error: 4.8398 - val_y2_output_root_mean_squared_error: 6.1612\n",
            "Epoch 80/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 6.5442 - y1_output_loss: 1.9272 - y2_output_loss: 4.6170 - y1_output_root_mean_squared_error: 1.3882 - y2_output_root_mean_squared_error: 2.1487 - val_loss: 9.6967 - val_y1_output_loss: 1.2929 - val_y2_output_loss: 8.4038 - val_y1_output_root_mean_squared_error: 1.1370 - val_y2_output_root_mean_squared_error: 2.8989\n",
            "Epoch 81/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.9874 - y1_output_loss: 0.9549 - y2_output_loss: 3.0325 - y1_output_root_mean_squared_error: 0.9772 - y2_output_root_mean_squared_error: 1.7414 - val_loss: 5.3888 - val_y1_output_loss: 1.3827 - val_y2_output_loss: 4.0061 - val_y1_output_root_mean_squared_error: 1.1759 - val_y2_output_root_mean_squared_error: 2.0015\n",
            "Epoch 82/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 3.1694 - y1_output_loss: 0.7539 - y2_output_loss: 2.4155 - y1_output_root_mean_squared_error: 0.8683 - y2_output_root_mean_squared_error: 1.5542 - val_loss: 4.1362 - val_y1_output_loss: 0.7821 - val_y2_output_loss: 3.3542 - val_y1_output_root_mean_squared_error: 0.8843 - val_y2_output_root_mean_squared_error: 1.8314\n",
            "Epoch 83/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 3.4394 - y1_output_loss: 0.7780 - y2_output_loss: 2.6613 - y1_output_root_mean_squared_error: 0.8821 - y2_output_root_mean_squared_error: 1.6314 - val_loss: 3.3450 - val_y1_output_loss: 0.5408 - val_y2_output_loss: 2.8042 - val_y1_output_root_mean_squared_error: 0.7354 - val_y2_output_root_mean_squared_error: 1.6746\n",
            "Epoch 84/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.9487 - y1_output_loss: 0.6422 - y2_output_loss: 2.3066 - y1_output_root_mean_squared_error: 0.8014 - y2_output_root_mean_squared_error: 1.5187 - val_loss: 6.9129 - val_y1_output_loss: 2.4392 - val_y2_output_loss: 4.4737 - val_y1_output_root_mean_squared_error: 1.5618 - val_y2_output_root_mean_squared_error: 2.1151\n",
            "Epoch 85/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 4.8487 - y1_output_loss: 1.2540 - y2_output_loss: 3.5947 - y1_output_root_mean_squared_error: 1.1198 - y2_output_root_mean_squared_error: 1.8960 - val_loss: 3.4944 - val_y1_output_loss: 0.6703 - val_y2_output_loss: 2.8241 - val_y1_output_root_mean_squared_error: 0.8187 - val_y2_output_root_mean_squared_error: 1.6805\n",
            "Epoch 86/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.1488 - y1_output_loss: 0.7041 - y2_output_loss: 2.4447 - y1_output_root_mean_squared_error: 0.8391 - y2_output_root_mean_squared_error: 1.5635 - val_loss: 4.0798 - val_y1_output_loss: 0.6503 - val_y2_output_loss: 3.4295 - val_y1_output_root_mean_squared_error: 0.8064 - val_y2_output_root_mean_squared_error: 1.8519\n",
            "Epoch 87/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.3412 - y1_output_loss: 0.8444 - y2_output_loss: 2.4968 - y1_output_root_mean_squared_error: 0.9189 - y2_output_root_mean_squared_error: 1.5801 - val_loss: 4.3733 - val_y1_output_loss: 0.7895 - val_y2_output_loss: 3.5838 - val_y1_output_root_mean_squared_error: 0.8886 - val_y2_output_root_mean_squared_error: 1.8931\n",
            "Epoch 88/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 3.1705 - y1_output_loss: 0.8819 - y2_output_loss: 2.2886 - y1_output_root_mean_squared_error: 0.9391 - y2_output_root_mean_squared_error: 1.5128 - val_loss: 3.8861 - val_y1_output_loss: 1.1584 - val_y2_output_loss: 2.7277 - val_y1_output_root_mean_squared_error: 1.0763 - val_y2_output_root_mean_squared_error: 1.6516\n",
            "Epoch 89/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.5357 - y1_output_loss: 0.5783 - y2_output_loss: 1.9574 - y1_output_root_mean_squared_error: 0.7605 - y2_output_root_mean_squared_error: 1.3991 - val_loss: 4.0122 - val_y1_output_loss: 0.8890 - val_y2_output_loss: 3.1233 - val_y1_output_root_mean_squared_error: 0.9428 - val_y2_output_root_mean_squared_error: 1.7673\n",
            "Epoch 90/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.7245 - y1_output_loss: 0.6318 - y2_output_loss: 2.0927 - y1_output_root_mean_squared_error: 0.7948 - y2_output_root_mean_squared_error: 1.4466 - val_loss: 7.3834 - val_y1_output_loss: 1.5985 - val_y2_output_loss: 5.7849 - val_y1_output_root_mean_squared_error: 1.2643 - val_y2_output_root_mean_squared_error: 2.4052\n",
            "Epoch 91/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.0454 - y1_output_loss: 0.6140 - y2_output_loss: 2.4314 - y1_output_root_mean_squared_error: 0.7836 - y2_output_root_mean_squared_error: 1.5593 - val_loss: 3.4952 - val_y1_output_loss: 0.6491 - val_y2_output_loss: 2.8461 - val_y1_output_root_mean_squared_error: 0.8057 - val_y2_output_root_mean_squared_error: 1.6870\n",
            "Epoch 92/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.6950 - y1_output_loss: 0.8280 - y2_output_loss: 2.8671 - y1_output_root_mean_squared_error: 0.9099 - y2_output_root_mean_squared_error: 1.6932 - val_loss: 6.2460 - val_y1_output_loss: 2.2415 - val_y2_output_loss: 4.0044 - val_y1_output_root_mean_squared_error: 1.4972 - val_y2_output_root_mean_squared_error: 2.0011\n",
            "Epoch 93/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.1020 - y1_output_loss: 0.7233 - y2_output_loss: 2.3787 - y1_output_root_mean_squared_error: 0.8505 - y2_output_root_mean_squared_error: 1.5423 - val_loss: 3.2957 - val_y1_output_loss: 0.6316 - val_y2_output_loss: 2.6642 - val_y1_output_root_mean_squared_error: 0.7947 - val_y2_output_root_mean_squared_error: 1.6322\n",
            "Epoch 94/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.4495 - y1_output_loss: 0.8188 - y2_output_loss: 2.6308 - y1_output_root_mean_squared_error: 0.9049 - y2_output_root_mean_squared_error: 1.6220 - val_loss: 3.4058 - val_y1_output_loss: 0.6462 - val_y2_output_loss: 2.7596 - val_y1_output_root_mean_squared_error: 0.8039 - val_y2_output_root_mean_squared_error: 1.6612\n",
            "Epoch 95/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.9413 - y1_output_loss: 0.6685 - y2_output_loss: 2.2728 - y1_output_root_mean_squared_error: 0.8176 - y2_output_root_mean_squared_error: 1.5076 - val_loss: 4.4578 - val_y1_output_loss: 0.7114 - val_y2_output_loss: 3.7464 - val_y1_output_root_mean_squared_error: 0.8435 - val_y2_output_root_mean_squared_error: 1.9356\n",
            "Epoch 96/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.9637 - y1_output_loss: 0.6934 - y2_output_loss: 2.2703 - y1_output_root_mean_squared_error: 0.8327 - y2_output_root_mean_squared_error: 1.5067 - val_loss: 8.3168 - val_y1_output_loss: 2.0078 - val_y2_output_loss: 6.3091 - val_y1_output_root_mean_squared_error: 1.4170 - val_y2_output_root_mean_squared_error: 2.5118\n",
            "Epoch 97/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.6608 - y1_output_loss: 0.7780 - y2_output_loss: 2.8828 - y1_output_root_mean_squared_error: 0.8820 - y2_output_root_mean_squared_error: 1.6979 - val_loss: 5.2805 - val_y1_output_loss: 1.3917 - val_y2_output_loss: 3.8887 - val_y1_output_root_mean_squared_error: 1.1797 - val_y2_output_root_mean_squared_error: 1.9720\n",
            "Epoch 98/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.4739 - y1_output_loss: 0.5415 - y2_output_loss: 1.9324 - y1_output_root_mean_squared_error: 0.7359 - y2_output_root_mean_squared_error: 1.3901 - val_loss: 5.3067 - val_y1_output_loss: 0.8355 - val_y2_output_loss: 4.4712 - val_y1_output_root_mean_squared_error: 0.9140 - val_y2_output_root_mean_squared_error: 2.1145\n",
            "Epoch 99/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.9722 - y1_output_loss: 0.6767 - y2_output_loss: 2.2955 - y1_output_root_mean_squared_error: 0.8226 - y2_output_root_mean_squared_error: 1.5151 - val_loss: 2.8998 - val_y1_output_loss: 0.5707 - val_y2_output_loss: 2.3291 - val_y1_output_root_mean_squared_error: 0.7554 - val_y2_output_root_mean_squared_error: 1.5262\n",
            "Epoch 100/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.2537 - y1_output_loss: 0.4960 - y2_output_loss: 1.7577 - y1_output_root_mean_squared_error: 0.7043 - y2_output_root_mean_squared_error: 1.3258 - val_loss: 3.2119 - val_y1_output_loss: 0.4202 - val_y2_output_loss: 2.7917 - val_y1_output_root_mean_squared_error: 0.6482 - val_y2_output_root_mean_squared_error: 1.6708\n",
            "Epoch 101/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 3.6612 - y1_output_loss: 0.7628 - y2_output_loss: 2.8984 - y1_output_root_mean_squared_error: 0.8734 - y2_output_root_mean_squared_error: 1.7025 - val_loss: 10.5527 - val_y1_output_loss: 2.3329 - val_y2_output_loss: 8.2198 - val_y1_output_root_mean_squared_error: 1.5274 - val_y2_output_root_mean_squared_error: 2.8670\n",
            "Epoch 102/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.3449 - y1_output_loss: 0.8108 - y2_output_loss: 2.5341 - y1_output_root_mean_squared_error: 0.9005 - y2_output_root_mean_squared_error: 1.5919 - val_loss: 2.9404 - val_y1_output_loss: 0.6481 - val_y2_output_loss: 2.2923 - val_y1_output_root_mean_squared_error: 0.8051 - val_y2_output_root_mean_squared_error: 1.5140\n",
            "Epoch 103/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.4843 - y1_output_loss: 0.5222 - y2_output_loss: 1.9621 - y1_output_root_mean_squared_error: 0.7226 - y2_output_root_mean_squared_error: 1.4007 - val_loss: 4.5222 - val_y1_output_loss: 0.8486 - val_y2_output_loss: 3.6736 - val_y1_output_root_mean_squared_error: 0.9212 - val_y2_output_root_mean_squared_error: 1.9167\n",
            "Epoch 104/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.4659 - y1_output_loss: 0.9024 - y2_output_loss: 2.5635 - y1_output_root_mean_squared_error: 0.9500 - y2_output_root_mean_squared_error: 1.6011 - val_loss: 3.4694 - val_y1_output_loss: 0.5903 - val_y2_output_loss: 2.8791 - val_y1_output_root_mean_squared_error: 0.7683 - val_y2_output_root_mean_squared_error: 1.6968\n",
            "Epoch 105/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.7989 - y1_output_loss: 1.0758 - y2_output_loss: 2.7231 - y1_output_root_mean_squared_error: 1.0372 - y2_output_root_mean_squared_error: 1.6502 - val_loss: 3.1059 - val_y1_output_loss: 0.6779 - val_y2_output_loss: 2.4280 - val_y1_output_root_mean_squared_error: 0.8233 - val_y2_output_root_mean_squared_error: 1.5582\n",
            "Epoch 106/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.7567 - y1_output_loss: 0.6044 - y2_output_loss: 2.1522 - y1_output_root_mean_squared_error: 0.7775 - y2_output_root_mean_squared_error: 1.4670 - val_loss: 4.5164 - val_y1_output_loss: 1.1472 - val_y2_output_loss: 3.3693 - val_y1_output_root_mean_squared_error: 1.0711 - val_y2_output_root_mean_squared_error: 1.8356\n",
            "Epoch 107/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.3388 - y1_output_loss: 0.5057 - y2_output_loss: 1.8330 - y1_output_root_mean_squared_error: 0.7112 - y2_output_root_mean_squared_error: 1.3539 - val_loss: 5.5476 - val_y1_output_loss: 1.0283 - val_y2_output_loss: 4.5194 - val_y1_output_root_mean_squared_error: 1.0140 - val_y2_output_root_mean_squared_error: 2.1259\n",
            "Epoch 108/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.5496 - y1_output_loss: 0.5233 - y2_output_loss: 2.0263 - y1_output_root_mean_squared_error: 0.7234 - y2_output_root_mean_squared_error: 1.4235 - val_loss: 3.4693 - val_y1_output_loss: 0.7344 - val_y2_output_loss: 2.7350 - val_y1_output_root_mean_squared_error: 0.8569 - val_y2_output_root_mean_squared_error: 1.6538\n",
            "Epoch 109/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.8296 - y1_output_loss: 0.6466 - y2_output_loss: 2.1830 - y1_output_root_mean_squared_error: 0.8041 - y2_output_root_mean_squared_error: 1.4775 - val_loss: 5.2194 - val_y1_output_loss: 1.8178 - val_y2_output_loss: 3.4016 - val_y1_output_root_mean_squared_error: 1.3483 - val_y2_output_root_mean_squared_error: 1.8443\n",
            "Epoch 110/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 3.9404 - y1_output_loss: 1.0952 - y2_output_loss: 2.8452 - y1_output_root_mean_squared_error: 1.0465 - y2_output_root_mean_squared_error: 1.6868 - val_loss: 12.9588 - val_y1_output_loss: 4.5815 - val_y2_output_loss: 8.3773 - val_y1_output_root_mean_squared_error: 2.1404 - val_y2_output_root_mean_squared_error: 2.8944\n",
            "Epoch 111/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.6512 - y1_output_loss: 0.6722 - y2_output_loss: 1.9790 - y1_output_root_mean_squared_error: 0.8199 - y2_output_root_mean_squared_error: 1.4068 - val_loss: 4.1557 - val_y1_output_loss: 1.3048 - val_y2_output_loss: 2.8509 - val_y1_output_root_mean_squared_error: 1.1423 - val_y2_output_root_mean_squared_error: 1.6885\n",
            "Epoch 112/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.5081 - y1_output_loss: 0.6668 - y2_output_loss: 1.8413 - y1_output_root_mean_squared_error: 0.8166 - y2_output_root_mean_squared_error: 1.3569 - val_loss: 2.8947 - val_y1_output_loss: 0.7155 - val_y2_output_loss: 2.1792 - val_y1_output_root_mean_squared_error: 0.8459 - val_y2_output_root_mean_squared_error: 1.4762\n",
            "Epoch 113/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.0943 - y1_output_loss: 0.4496 - y2_output_loss: 1.6447 - y1_output_root_mean_squared_error: 0.6706 - y2_output_root_mean_squared_error: 1.2825 - val_loss: 4.0928 - val_y1_output_loss: 1.0981 - val_y2_output_loss: 2.9947 - val_y1_output_root_mean_squared_error: 1.0479 - val_y2_output_root_mean_squared_error: 1.7305\n",
            "Epoch 114/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.0344 - y1_output_loss: 0.4554 - y2_output_loss: 1.5791 - y1_output_root_mean_squared_error: 0.6748 - y2_output_root_mean_squared_error: 1.2566 - val_loss: 6.7469 - val_y1_output_loss: 1.2606 - val_y2_output_loss: 5.4863 - val_y1_output_root_mean_squared_error: 1.1228 - val_y2_output_root_mean_squared_error: 2.3423\n",
            "Epoch 115/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.9624 - y1_output_loss: 0.7843 - y2_output_loss: 2.1781 - y1_output_root_mean_squared_error: 0.8856 - y2_output_root_mean_squared_error: 1.4758 - val_loss: 3.4756 - val_y1_output_loss: 0.5949 - val_y2_output_loss: 2.8807 - val_y1_output_root_mean_squared_error: 0.7713 - val_y2_output_root_mean_squared_error: 1.6973\n",
            "Epoch 116/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.2632 - y1_output_loss: 0.5058 - y2_output_loss: 1.7574 - y1_output_root_mean_squared_error: 0.7112 - y2_output_root_mean_squared_error: 1.3257 - val_loss: 2.8323 - val_y1_output_loss: 0.4772 - val_y2_output_loss: 2.3551 - val_y1_output_root_mean_squared_error: 0.6908 - val_y2_output_root_mean_squared_error: 1.5346\n",
            "Epoch 117/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 3.1630 - y1_output_loss: 0.6835 - y2_output_loss: 2.4795 - y1_output_root_mean_squared_error: 0.8267 - y2_output_root_mean_squared_error: 1.5746 - val_loss: 3.2909 - val_y1_output_loss: 0.9680 - val_y2_output_loss: 2.3229 - val_y1_output_root_mean_squared_error: 0.9839 - val_y2_output_root_mean_squared_error: 1.5241\n",
            "Epoch 118/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.3447 - y1_output_loss: 0.5594 - y2_output_loss: 1.7853 - y1_output_root_mean_squared_error: 0.7479 - y2_output_root_mean_squared_error: 1.3362 - val_loss: 2.6678 - val_y1_output_loss: 0.4602 - val_y2_output_loss: 2.2076 - val_y1_output_root_mean_squared_error: 0.6783 - val_y2_output_root_mean_squared_error: 1.4858\n",
            "Epoch 119/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.8062 - y1_output_loss: 0.3829 - y2_output_loss: 1.4233 - y1_output_root_mean_squared_error: 0.6188 - y2_output_root_mean_squared_error: 1.1930 - val_loss: 4.5868 - val_y1_output_loss: 0.5745 - val_y2_output_loss: 4.0123 - val_y1_output_root_mean_squared_error: 0.7580 - val_y2_output_root_mean_squared_error: 2.0031\n",
            "Epoch 120/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.3902 - y1_output_loss: 0.5772 - y2_output_loss: 1.8130 - y1_output_root_mean_squared_error: 0.7598 - y2_output_root_mean_squared_error: 1.3465 - val_loss: 4.3535 - val_y1_output_loss: 0.6359 - val_y2_output_loss: 3.7176 - val_y1_output_root_mean_squared_error: 0.7974 - val_y2_output_root_mean_squared_error: 1.9281\n",
            "Epoch 121/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.5287 - y1_output_loss: 0.6160 - y2_output_loss: 1.9128 - y1_output_root_mean_squared_error: 0.7848 - y2_output_root_mean_squared_error: 1.3830 - val_loss: 2.4766 - val_y1_output_loss: 0.5290 - val_y2_output_loss: 1.9476 - val_y1_output_root_mean_squared_error: 0.7273 - val_y2_output_root_mean_squared_error: 1.3956\n",
            "Epoch 122/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.9082 - y1_output_loss: 0.4158 - y2_output_loss: 1.4924 - y1_output_root_mean_squared_error: 0.6448 - y2_output_root_mean_squared_error: 1.2216 - val_loss: 5.9233 - val_y1_output_loss: 1.1776 - val_y2_output_loss: 4.7457 - val_y1_output_root_mean_squared_error: 1.0852 - val_y2_output_root_mean_squared_error: 2.1785\n",
            "Epoch 123/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.7235 - y1_output_loss: 0.6696 - y2_output_loss: 2.0538 - y1_output_root_mean_squared_error: 0.8183 - y2_output_root_mean_squared_error: 1.4331 - val_loss: 2.9463 - val_y1_output_loss: 0.5282 - val_y2_output_loss: 2.4181 - val_y1_output_root_mean_squared_error: 0.7268 - val_y2_output_root_mean_squared_error: 1.5550\n",
            "Epoch 124/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.3859 - y1_output_loss: 0.4841 - y2_output_loss: 1.9018 - y1_output_root_mean_squared_error: 0.6958 - y2_output_root_mean_squared_error: 1.3791 - val_loss: 16.9910 - val_y1_output_loss: 5.7873 - val_y2_output_loss: 11.2037 - val_y1_output_root_mean_squared_error: 2.4057 - val_y2_output_root_mean_squared_error: 3.3472\n",
            "Epoch 125/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.5460 - y1_output_loss: 0.6986 - y2_output_loss: 1.8474 - y1_output_root_mean_squared_error: 0.8358 - y2_output_root_mean_squared_error: 1.3592 - val_loss: 3.4803 - val_y1_output_loss: 0.6112 - val_y2_output_loss: 2.8691 - val_y1_output_root_mean_squared_error: 0.7818 - val_y2_output_root_mean_squared_error: 1.6938\n",
            "Epoch 126/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.0238 - y1_output_loss: 0.4151 - y2_output_loss: 1.6088 - y1_output_root_mean_squared_error: 0.6443 - y2_output_root_mean_squared_error: 1.2684 - val_loss: 3.1266 - val_y1_output_loss: 0.8158 - val_y2_output_loss: 2.3108 - val_y1_output_root_mean_squared_error: 0.9032 - val_y2_output_root_mean_squared_error: 1.5201\n",
            "Epoch 127/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.8154 - y1_output_loss: 0.4163 - y2_output_loss: 1.3991 - y1_output_root_mean_squared_error: 0.6452 - y2_output_root_mean_squared_error: 1.1828 - val_loss: 2.1698 - val_y1_output_loss: 0.3547 - val_y2_output_loss: 1.8151 - val_y1_output_root_mean_squared_error: 0.5956 - val_y2_output_root_mean_squared_error: 1.3473\n",
            "Epoch 128/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.9138 - y1_output_loss: 0.3920 - y2_output_loss: 1.5218 - y1_output_root_mean_squared_error: 0.6261 - y2_output_root_mean_squared_error: 1.2336 - val_loss: 4.8164 - val_y1_output_loss: 0.6620 - val_y2_output_loss: 4.1544 - val_y1_output_root_mean_squared_error: 0.8136 - val_y2_output_root_mean_squared_error: 2.0382\n",
            "Epoch 129/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.8253 - y1_output_loss: 0.3920 - y2_output_loss: 1.4333 - y1_output_root_mean_squared_error: 0.6261 - y2_output_root_mean_squared_error: 1.1972 - val_loss: 2.6220 - val_y1_output_loss: 0.7740 - val_y2_output_loss: 1.8480 - val_y1_output_root_mean_squared_error: 0.8798 - val_y2_output_root_mean_squared_error: 1.3594\n",
            "Epoch 130/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.8181 - y1_output_loss: 0.3597 - y2_output_loss: 1.4584 - y1_output_root_mean_squared_error: 0.5997 - y2_output_root_mean_squared_error: 1.2077 - val_loss: 5.4024 - val_y1_output_loss: 0.5118 - val_y2_output_loss: 4.8905 - val_y1_output_root_mean_squared_error: 0.7154 - val_y2_output_root_mean_squared_error: 2.2115\n",
            "Epoch 131/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.7119 - y1_output_loss: 0.7517 - y2_output_loss: 1.9602 - y1_output_root_mean_squared_error: 0.8670 - y2_output_root_mean_squared_error: 1.4001 - val_loss: 2.5830 - val_y1_output_loss: 0.5846 - val_y2_output_loss: 1.9984 - val_y1_output_root_mean_squared_error: 0.7646 - val_y2_output_root_mean_squared_error: 1.4137\n",
            "Epoch 132/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.5916 - y1_output_loss: 0.3524 - y2_output_loss: 1.2393 - y1_output_root_mean_squared_error: 0.5936 - y2_output_root_mean_squared_error: 1.1132 - val_loss: 3.0213 - val_y1_output_loss: 0.7096 - val_y2_output_loss: 2.3117 - val_y1_output_root_mean_squared_error: 0.8424 - val_y2_output_root_mean_squared_error: 1.5204\n",
            "Epoch 133/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.4438 - y1_output_loss: 0.6742 - y2_output_loss: 1.7696 - y1_output_root_mean_squared_error: 0.8211 - y2_output_root_mean_squared_error: 1.3303 - val_loss: 4.5864 - val_y1_output_loss: 0.5042 - val_y2_output_loss: 4.0823 - val_y1_output_root_mean_squared_error: 0.7101 - val_y2_output_root_mean_squared_error: 2.0205\n",
            "Epoch 134/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.6258 - y1_output_loss: 0.5590 - y2_output_loss: 2.0668 - y1_output_root_mean_squared_error: 0.7476 - y2_output_root_mean_squared_error: 1.4376 - val_loss: 2.3933 - val_y1_output_loss: 0.3987 - val_y2_output_loss: 1.9946 - val_y1_output_root_mean_squared_error: 0.6314 - val_y2_output_root_mean_squared_error: 1.4123\n",
            "Epoch 135/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.6138 - y1_output_loss: 0.3676 - y2_output_loss: 1.2463 - y1_output_root_mean_squared_error: 0.6063 - y2_output_root_mean_squared_error: 1.1164 - val_loss: 3.0030 - val_y1_output_loss: 0.5713 - val_y2_output_loss: 2.4318 - val_y1_output_root_mean_squared_error: 0.7558 - val_y2_output_root_mean_squared_error: 1.5594\n",
            "Epoch 136/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.8632 - y1_output_loss: 0.6504 - y2_output_loss: 2.2128 - y1_output_root_mean_squared_error: 0.8065 - y2_output_root_mean_squared_error: 1.4875 - val_loss: 2.2006 - val_y1_output_loss: 0.4260 - val_y2_output_loss: 1.7745 - val_y1_output_root_mean_squared_error: 0.6527 - val_y2_output_root_mean_squared_error: 1.3321\n",
            "Epoch 137/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.5731 - y1_output_loss: 0.3782 - y2_output_loss: 1.1949 - y1_output_root_mean_squared_error: 0.6150 - y2_output_root_mean_squared_error: 1.0931 - val_loss: 2.0363 - val_y1_output_loss: 0.3927 - val_y2_output_loss: 1.6436 - val_y1_output_root_mean_squared_error: 0.6266 - val_y2_output_root_mean_squared_error: 1.2820\n",
            "Epoch 138/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.2726 - y1_output_loss: 0.4464 - y2_output_loss: 1.8263 - y1_output_root_mean_squared_error: 0.6681 - y2_output_root_mean_squared_error: 1.3514 - val_loss: 2.7491 - val_y1_output_loss: 0.7970 - val_y2_output_loss: 1.9521 - val_y1_output_root_mean_squared_error: 0.8928 - val_y2_output_root_mean_squared_error: 1.3972\n",
            "Epoch 139/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.5719 - y1_output_loss: 0.2979 - y2_output_loss: 1.2740 - y1_output_root_mean_squared_error: 0.5458 - y2_output_root_mean_squared_error: 1.1287 - val_loss: 2.0318 - val_y1_output_loss: 0.3859 - val_y2_output_loss: 1.6459 - val_y1_output_root_mean_squared_error: 0.6212 - val_y2_output_root_mean_squared_error: 1.2829\n",
            "Epoch 140/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.6988 - y1_output_loss: 0.3512 - y2_output_loss: 1.3475 - y1_output_root_mean_squared_error: 0.5927 - y2_output_root_mean_squared_error: 1.1608 - val_loss: 2.0300 - val_y1_output_loss: 0.3937 - val_y2_output_loss: 1.6364 - val_y1_output_root_mean_squared_error: 0.6274 - val_y2_output_root_mean_squared_error: 1.2792\n",
            "Epoch 141/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.6754 - y1_output_loss: 0.4045 - y2_output_loss: 1.2709 - y1_output_root_mean_squared_error: 0.6360 - y2_output_root_mean_squared_error: 1.1274 - val_loss: 2.3640 - val_y1_output_loss: 0.4838 - val_y2_output_loss: 1.8801 - val_y1_output_root_mean_squared_error: 0.6956 - val_y2_output_root_mean_squared_error: 1.3712\n",
            "Epoch 142/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.8572 - y1_output_loss: 0.4804 - y2_output_loss: 1.3769 - y1_output_root_mean_squared_error: 0.6931 - y2_output_root_mean_squared_error: 1.1734 - val_loss: 2.5490 - val_y1_output_loss: 0.7542 - val_y2_output_loss: 1.7947 - val_y1_output_root_mean_squared_error: 0.8685 - val_y2_output_root_mean_squared_error: 1.3397\n",
            "Epoch 143/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.8342 - y1_output_loss: 0.3906 - y2_output_loss: 1.4436 - y1_output_root_mean_squared_error: 0.6250 - y2_output_root_mean_squared_error: 1.2015 - val_loss: 1.9410 - val_y1_output_loss: 0.3737 - val_y2_output_loss: 1.5674 - val_y1_output_root_mean_squared_error: 0.6113 - val_y2_output_root_mean_squared_error: 1.2519\n",
            "Epoch 144/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.7129 - y1_output_loss: 0.3352 - y2_output_loss: 1.3777 - y1_output_root_mean_squared_error: 0.5790 - y2_output_root_mean_squared_error: 1.1738 - val_loss: 1.9777 - val_y1_output_loss: 0.4175 - val_y2_output_loss: 1.5601 - val_y1_output_root_mean_squared_error: 0.6462 - val_y2_output_root_mean_squared_error: 1.2490\n",
            "Epoch 145/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.5396 - y1_output_loss: 0.3391 - y2_output_loss: 1.2006 - y1_output_root_mean_squared_error: 0.5823 - y2_output_root_mean_squared_error: 1.0957 - val_loss: 2.0590 - val_y1_output_loss: 0.4536 - val_y2_output_loss: 1.6055 - val_y1_output_root_mean_squared_error: 0.6735 - val_y2_output_root_mean_squared_error: 1.2671\n",
            "Epoch 146/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.5807 - y1_output_loss: 0.3790 - y2_output_loss: 1.2017 - y1_output_root_mean_squared_error: 0.6156 - y2_output_root_mean_squared_error: 1.0962 - val_loss: 3.9972 - val_y1_output_loss: 1.2430 - val_y2_output_loss: 2.7542 - val_y1_output_root_mean_squared_error: 1.1149 - val_y2_output_root_mean_squared_error: 1.6596\n",
            "Epoch 147/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 3.0177 - y1_output_loss: 0.6913 - y2_output_loss: 2.3264 - y1_output_root_mean_squared_error: 0.8315 - y2_output_root_mean_squared_error: 1.5252 - val_loss: 2.5817 - val_y1_output_loss: 0.8049 - val_y2_output_loss: 1.7768 - val_y1_output_root_mean_squared_error: 0.8972 - val_y2_output_root_mean_squared_error: 1.3330\n",
            "Epoch 148/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.3179 - y1_output_loss: 0.5386 - y2_output_loss: 1.7793 - y1_output_root_mean_squared_error: 0.7339 - y2_output_root_mean_squared_error: 1.3339 - val_loss: 4.6341 - val_y1_output_loss: 1.1554 - val_y2_output_loss: 3.4787 - val_y1_output_root_mean_squared_error: 1.0749 - val_y2_output_root_mean_squared_error: 1.8651\n",
            "Epoch 149/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.8138 - y1_output_loss: 0.3584 - y2_output_loss: 1.4554 - y1_output_root_mean_squared_error: 0.5987 - y2_output_root_mean_squared_error: 1.2064 - val_loss: 2.1222 - val_y1_output_loss: 0.4518 - val_y2_output_loss: 1.6704 - val_y1_output_root_mean_squared_error: 0.6722 - val_y2_output_root_mean_squared_error: 1.2924\n",
            "Epoch 150/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.6780 - y1_output_loss: 0.3494 - y2_output_loss: 1.3286 - y1_output_root_mean_squared_error: 0.5911 - y2_output_root_mean_squared_error: 1.1526 - val_loss: 2.4469 - val_y1_output_loss: 0.3627 - val_y2_output_loss: 2.0843 - val_y1_output_root_mean_squared_error: 0.6022 - val_y2_output_root_mean_squared_error: 1.4437\n",
            "Epoch 151/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.5631 - y1_output_loss: 0.3169 - y2_output_loss: 1.2462 - y1_output_root_mean_squared_error: 0.5629 - y2_output_root_mean_squared_error: 1.1163 - val_loss: 2.1635 - val_y1_output_loss: 0.3400 - val_y2_output_loss: 1.8235 - val_y1_output_root_mean_squared_error: 0.5831 - val_y2_output_root_mean_squared_error: 1.3504\n",
            "Epoch 152/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.6751 - y1_output_loss: 0.3557 - y2_output_loss: 1.3194 - y1_output_root_mean_squared_error: 0.5964 - y2_output_root_mean_squared_error: 1.1486 - val_loss: 3.0837 - val_y1_output_loss: 0.7841 - val_y2_output_loss: 2.2995 - val_y1_output_root_mean_squared_error: 0.8855 - val_y2_output_root_mean_squared_error: 1.5164\n",
            "Epoch 153/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.7989 - y1_output_loss: 0.3726 - y2_output_loss: 1.4263 - y1_output_root_mean_squared_error: 0.6104 - y2_output_root_mean_squared_error: 1.1943 - val_loss: 4.7288 - val_y1_output_loss: 0.6896 - val_y2_output_loss: 4.0392 - val_y1_output_root_mean_squared_error: 0.8304 - val_y2_output_root_mean_squared_error: 2.0098\n",
            "Epoch 154/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.2593 - y1_output_loss: 0.5224 - y2_output_loss: 1.7369 - y1_output_root_mean_squared_error: 0.7228 - y2_output_root_mean_squared_error: 1.3179 - val_loss: 2.2828 - val_y1_output_loss: 0.6339 - val_y2_output_loss: 1.6489 - val_y1_output_root_mean_squared_error: 0.7962 - val_y2_output_root_mean_squared_error: 1.2841\n",
            "Epoch 155/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3964 - y1_output_loss: 0.3404 - y2_output_loss: 1.0560 - y1_output_root_mean_squared_error: 0.5835 - y2_output_root_mean_squared_error: 1.0276 - val_loss: 4.4464 - val_y1_output_loss: 1.3262 - val_y2_output_loss: 3.1202 - val_y1_output_root_mean_squared_error: 1.1516 - val_y2_output_root_mean_squared_error: 1.7664\n",
            "Epoch 156/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.9828 - y1_output_loss: 0.4716 - y2_output_loss: 1.5112 - y1_output_root_mean_squared_error: 0.6868 - y2_output_root_mean_squared_error: 1.2293 - val_loss: 2.1868 - val_y1_output_loss: 0.4961 - val_y2_output_loss: 1.6907 - val_y1_output_root_mean_squared_error: 0.7044 - val_y2_output_root_mean_squared_error: 1.3003\n",
            "Epoch 157/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.5495 - y1_output_loss: 0.3047 - y2_output_loss: 1.2448 - y1_output_root_mean_squared_error: 0.5520 - y2_output_root_mean_squared_error: 1.1157 - val_loss: 1.8628 - val_y1_output_loss: 0.3487 - val_y2_output_loss: 1.5141 - val_y1_output_root_mean_squared_error: 0.5905 - val_y2_output_root_mean_squared_error: 1.2305\n",
            "Epoch 158/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.4290 - y1_output_loss: 0.3429 - y2_output_loss: 1.0861 - y1_output_root_mean_squared_error: 0.5855 - y2_output_root_mean_squared_error: 1.0422 - val_loss: 1.7142 - val_y1_output_loss: 0.3416 - val_y2_output_loss: 1.3727 - val_y1_output_root_mean_squared_error: 0.5844 - val_y2_output_root_mean_squared_error: 1.1716\n",
            "Epoch 159/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 2.2319 - y1_output_loss: 0.4814 - y2_output_loss: 1.7505 - y1_output_root_mean_squared_error: 0.6938 - y2_output_root_mean_squared_error: 1.3231 - val_loss: 2.2408 - val_y1_output_loss: 0.5736 - val_y2_output_loss: 1.6672 - val_y1_output_root_mean_squared_error: 0.7573 - val_y2_output_root_mean_squared_error: 1.2912\n",
            "Epoch 160/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4344 - y1_output_loss: 0.3009 - y2_output_loss: 1.1335 - y1_output_root_mean_squared_error: 0.5485 - y2_output_root_mean_squared_error: 1.0647 - val_loss: 1.8835 - val_y1_output_loss: 0.4594 - val_y2_output_loss: 1.4240 - val_y1_output_root_mean_squared_error: 0.6778 - val_y2_output_root_mean_squared_error: 1.1933\n",
            "Epoch 161/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.4051 - y1_output_loss: 0.2998 - y2_output_loss: 1.1053 - y1_output_root_mean_squared_error: 0.5476 - y2_output_root_mean_squared_error: 1.0513 - val_loss: 2.3921 - val_y1_output_loss: 0.4489 - val_y2_output_loss: 1.9431 - val_y1_output_root_mean_squared_error: 0.6700 - val_y2_output_root_mean_squared_error: 1.3940\n",
            "Epoch 162/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.9754 - y1_output_loss: 0.4380 - y2_output_loss: 1.5374 - y1_output_root_mean_squared_error: 0.6618 - y2_output_root_mean_squared_error: 1.2399 - val_loss: 2.2739 - val_y1_output_loss: 0.4032 - val_y2_output_loss: 1.8707 - val_y1_output_root_mean_squared_error: 0.6350 - val_y2_output_root_mean_squared_error: 1.3677\n",
            "Epoch 163/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2960 - y1_output_loss: 0.2635 - y2_output_loss: 1.0324 - y1_output_root_mean_squared_error: 0.5134 - y2_output_root_mean_squared_error: 1.0161 - val_loss: 1.7656 - val_y1_output_loss: 0.4477 - val_y2_output_loss: 1.3179 - val_y1_output_root_mean_squared_error: 0.6691 - val_y2_output_root_mean_squared_error: 1.1480\n",
            "Epoch 164/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1726 - y1_output_loss: 0.2581 - y2_output_loss: 0.9144 - y1_output_root_mean_squared_error: 0.5081 - y2_output_root_mean_squared_error: 0.9563 - val_loss: 1.9204 - val_y1_output_loss: 0.4288 - val_y2_output_loss: 1.4916 - val_y1_output_root_mean_squared_error: 0.6548 - val_y2_output_root_mean_squared_error: 1.2213\n",
            "Epoch 165/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4479 - y1_output_loss: 0.2659 - y2_output_loss: 1.1820 - y1_output_root_mean_squared_error: 0.5156 - y2_output_root_mean_squared_error: 1.0872 - val_loss: 28.0092 - val_y1_output_loss: 8.8989 - val_y2_output_loss: 19.1103 - val_y1_output_root_mean_squared_error: 2.9831 - val_y2_output_root_mean_squared_error: 4.3715\n",
            "Epoch 166/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.2571 - y1_output_loss: 0.6207 - y2_output_loss: 1.6363 - y1_output_root_mean_squared_error: 0.7879 - y2_output_root_mean_squared_error: 1.2792 - val_loss: 6.6425 - val_y1_output_loss: 0.5789 - val_y2_output_loss: 6.0637 - val_y1_output_root_mean_squared_error: 0.7608 - val_y2_output_root_mean_squared_error: 2.4625\n",
            "Epoch 167/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.5660 - y1_output_loss: 0.3890 - y2_output_loss: 1.1769 - y1_output_root_mean_squared_error: 0.6237 - y2_output_root_mean_squared_error: 1.0849 - val_loss: 2.0712 - val_y1_output_loss: 0.3020 - val_y2_output_loss: 1.7693 - val_y1_output_root_mean_squared_error: 0.5495 - val_y2_output_root_mean_squared_error: 1.3301\n",
            "Epoch 168/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.3340 - y1_output_loss: 0.2490 - y2_output_loss: 1.0850 - y1_output_root_mean_squared_error: 0.4990 - y2_output_root_mean_squared_error: 1.0416 - val_loss: 1.9334 - val_y1_output_loss: 0.3752 - val_y2_output_loss: 1.5583 - val_y1_output_root_mean_squared_error: 0.6125 - val_y2_output_root_mean_squared_error: 1.2483\n",
            "Epoch 169/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 2.5134 - y1_output_loss: 0.5944 - y2_output_loss: 1.9191 - y1_output_root_mean_squared_error: 0.7710 - y2_output_root_mean_squared_error: 1.3853 - val_loss: 2.4546 - val_y1_output_loss: 0.6002 - val_y2_output_loss: 1.8544 - val_y1_output_root_mean_squared_error: 0.7748 - val_y2_output_root_mean_squared_error: 1.3617\n",
            "Epoch 170/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2722 - y1_output_loss: 0.2759 - y2_output_loss: 0.9963 - y1_output_root_mean_squared_error: 0.5252 - y2_output_root_mean_squared_error: 0.9982 - val_loss: 1.6152 - val_y1_output_loss: 0.3124 - val_y2_output_loss: 1.3028 - val_y1_output_root_mean_squared_error: 0.5589 - val_y2_output_root_mean_squared_error: 1.1414\n",
            "Epoch 171/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2150 - y1_output_loss: 0.2510 - y2_output_loss: 0.9640 - y1_output_root_mean_squared_error: 0.5010 - y2_output_root_mean_squared_error: 0.9819 - val_loss: 5.4692 - val_y1_output_loss: 1.2521 - val_y2_output_loss: 4.2172 - val_y1_output_root_mean_squared_error: 1.1190 - val_y2_output_root_mean_squared_error: 2.0536\n",
            "Epoch 172/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.2604 - y1_output_loss: 0.2581 - y2_output_loss: 1.0023 - y1_output_root_mean_squared_error: 0.5080 - y2_output_root_mean_squared_error: 1.0011 - val_loss: 2.0205 - val_y1_output_loss: 0.3723 - val_y2_output_loss: 1.6482 - val_y1_output_root_mean_squared_error: 0.6102 - val_y2_output_root_mean_squared_error: 1.2838\n",
            "Epoch 173/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.6332 - y1_output_loss: 0.3702 - y2_output_loss: 1.2631 - y1_output_root_mean_squared_error: 0.6084 - y2_output_root_mean_squared_error: 1.1239 - val_loss: 2.8758 - val_y1_output_loss: 0.4879 - val_y2_output_loss: 2.3879 - val_y1_output_root_mean_squared_error: 0.6985 - val_y2_output_root_mean_squared_error: 1.5453\n",
            "Epoch 174/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4281 - y1_output_loss: 0.3211 - y2_output_loss: 1.1070 - y1_output_root_mean_squared_error: 0.5667 - y2_output_root_mean_squared_error: 1.0521 - val_loss: 30.3908 - val_y1_output_loss: 9.1339 - val_y2_output_loss: 21.2569 - val_y1_output_root_mean_squared_error: 3.0222 - val_y2_output_root_mean_squared_error: 4.6105\n",
            "Epoch 175/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4432 - y1_output_loss: 0.3210 - y2_output_loss: 1.1222 - y1_output_root_mean_squared_error: 0.5666 - y2_output_root_mean_squared_error: 1.0593 - val_loss: 1.6658 - val_y1_output_loss: 0.3254 - val_y2_output_loss: 1.3404 - val_y1_output_root_mean_squared_error: 0.5704 - val_y2_output_root_mean_squared_error: 1.1577\n",
            "Epoch 176/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1839 - y1_output_loss: 0.2235 - y2_output_loss: 0.9604 - y1_output_root_mean_squared_error: 0.4727 - y2_output_root_mean_squared_error: 0.9800 - val_loss: 2.1386 - val_y1_output_loss: 0.4326 - val_y2_output_loss: 1.7060 - val_y1_output_root_mean_squared_error: 0.6577 - val_y2_output_root_mean_squared_error: 1.3061\n",
            "Epoch 177/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2277 - y1_output_loss: 0.2442 - y2_output_loss: 0.9835 - y1_output_root_mean_squared_error: 0.4942 - y2_output_root_mean_squared_error: 0.9917 - val_loss: 1.7176 - val_y1_output_loss: 0.3395 - val_y2_output_loss: 1.3782 - val_y1_output_root_mean_squared_error: 0.5826 - val_y2_output_root_mean_squared_error: 1.1740\n",
            "Epoch 178/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2818 - y1_output_loss: 0.2385 - y2_output_loss: 1.0433 - y1_output_root_mean_squared_error: 0.4884 - y2_output_root_mean_squared_error: 1.0214 - val_loss: 2.2125 - val_y1_output_loss: 0.4748 - val_y2_output_loss: 1.7377 - val_y1_output_root_mean_squared_error: 0.6891 - val_y2_output_root_mean_squared_error: 1.3182\n",
            "Epoch 179/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3400 - y1_output_loss: 0.2658 - y2_output_loss: 1.0742 - y1_output_root_mean_squared_error: 0.5156 - y2_output_root_mean_squared_error: 1.0365 - val_loss: 2.3238 - val_y1_output_loss: 0.4599 - val_y2_output_loss: 1.8639 - val_y1_output_root_mean_squared_error: 0.6782 - val_y2_output_root_mean_squared_error: 1.3652\n",
            "Epoch 180/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.3074 - y1_output_loss: 0.2789 - y2_output_loss: 1.0285 - y1_output_root_mean_squared_error: 0.5281 - y2_output_root_mean_squared_error: 1.0142 - val_loss: 2.0255 - val_y1_output_loss: 0.4705 - val_y2_output_loss: 1.5550 - val_y1_output_root_mean_squared_error: 0.6860 - val_y2_output_root_mean_squared_error: 1.2470\n",
            "Epoch 181/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3586 - y1_output_loss: 0.2942 - y2_output_loss: 1.0644 - y1_output_root_mean_squared_error: 0.5424 - y2_output_root_mean_squared_error: 1.0317 - val_loss: 1.6933 - val_y1_output_loss: 0.3473 - val_y2_output_loss: 1.3460 - val_y1_output_root_mean_squared_error: 0.5893 - val_y2_output_root_mean_squared_error: 1.1602\n",
            "Epoch 182/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2722 - y1_output_loss: 0.2327 - y2_output_loss: 1.0395 - y1_output_root_mean_squared_error: 0.4824 - y2_output_root_mean_squared_error: 1.0196 - val_loss: 1.5800 - val_y1_output_loss: 0.3458 - val_y2_output_loss: 1.2341 - val_y1_output_root_mean_squared_error: 0.5881 - val_y2_output_root_mean_squared_error: 1.1109\n",
            "Epoch 183/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.9002 - y1_output_loss: 0.4236 - y2_output_loss: 1.4766 - y1_output_root_mean_squared_error: 0.6508 - y2_output_root_mean_squared_error: 1.2152 - val_loss: 1.8140 - val_y1_output_loss: 0.3831 - val_y2_output_loss: 1.4310 - val_y1_output_root_mean_squared_error: 0.6189 - val_y2_output_root_mean_squared_error: 1.1962\n",
            "Epoch 184/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.3535 - y1_output_loss: 0.2834 - y2_output_loss: 1.0701 - y1_output_root_mean_squared_error: 0.5324 - y2_output_root_mean_squared_error: 1.0345 - val_loss: 2.2843 - val_y1_output_loss: 0.3350 - val_y2_output_loss: 1.9493 - val_y1_output_root_mean_squared_error: 0.5788 - val_y2_output_root_mean_squared_error: 1.3962\n",
            "Epoch 185/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1387 - y1_output_loss: 0.2393 - y2_output_loss: 0.8994 - y1_output_root_mean_squared_error: 0.4892 - y2_output_root_mean_squared_error: 0.9484 - val_loss: 7.8772 - val_y1_output_loss: 2.6592 - val_y2_output_loss: 5.2180 - val_y1_output_root_mean_squared_error: 1.6307 - val_y2_output_root_mean_squared_error: 2.2843\n",
            "Epoch 186/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4485 - y1_output_loss: 0.3111 - y2_output_loss: 1.1373 - y1_output_root_mean_squared_error: 0.5578 - y2_output_root_mean_squared_error: 1.0665 - val_loss: 3.2253 - val_y1_output_loss: 0.5651 - val_y2_output_loss: 2.6602 - val_y1_output_root_mean_squared_error: 0.7517 - val_y2_output_root_mean_squared_error: 1.6310\n",
            "Epoch 187/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.5095 - y1_output_loss: 0.3160 - y2_output_loss: 1.1935 - y1_output_root_mean_squared_error: 0.5621 - y2_output_root_mean_squared_error: 1.0925 - val_loss: 1.7082 - val_y1_output_loss: 0.3431 - val_y2_output_loss: 1.3651 - val_y1_output_root_mean_squared_error: 0.5857 - val_y2_output_root_mean_squared_error: 1.1684\n",
            "Epoch 188/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 1.1402 - y1_output_loss: 0.2139 - y2_output_loss: 0.9263 - y1_output_root_mean_squared_error: 0.4625 - y2_output_root_mean_squared_error: 0.9624 - val_loss: 1.9773 - val_y1_output_loss: 0.4643 - val_y2_output_loss: 1.5129 - val_y1_output_root_mean_squared_error: 0.6814 - val_y2_output_root_mean_squared_error: 1.2300\n",
            "Epoch 189/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9870 - y1_output_loss: 0.2046 - y2_output_loss: 0.7824 - y1_output_root_mean_squared_error: 0.4524 - y2_output_root_mean_squared_error: 0.8845 - val_loss: 1.6799 - val_y1_output_loss: 0.3704 - val_y2_output_loss: 1.3094 - val_y1_output_root_mean_squared_error: 0.6086 - val_y2_output_root_mean_squared_error: 1.1443\n",
            "Epoch 190/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 0.9617 - y1_output_loss: 0.2138 - y2_output_loss: 0.7479 - y1_output_root_mean_squared_error: 0.4624 - y2_output_root_mean_squared_error: 0.8648 - val_loss: 1.7600 - val_y1_output_loss: 0.3546 - val_y2_output_loss: 1.4054 - val_y1_output_root_mean_squared_error: 0.5955 - val_y2_output_root_mean_squared_error: 1.1855\n",
            "Epoch 191/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2570 - y1_output_loss: 0.2398 - y2_output_loss: 1.0173 - y1_output_root_mean_squared_error: 0.4897 - y2_output_root_mean_squared_error: 1.0086 - val_loss: 8.5497 - val_y1_output_loss: 2.1754 - val_y2_output_loss: 6.3743 - val_y1_output_root_mean_squared_error: 1.4749 - val_y2_output_root_mean_squared_error: 2.5247\n",
            "Epoch 192/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4482 - y1_output_loss: 0.3421 - y2_output_loss: 1.1061 - y1_output_root_mean_squared_error: 0.5849 - y2_output_root_mean_squared_error: 1.0517 - val_loss: 2.3617 - val_y1_output_loss: 0.4346 - val_y2_output_loss: 1.9271 - val_y1_output_root_mean_squared_error: 0.6592 - val_y2_output_root_mean_squared_error: 1.3882\n",
            "Epoch 193/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2389 - y1_output_loss: 0.2599 - y2_output_loss: 0.9790 - y1_output_root_mean_squared_error: 0.5098 - y2_output_root_mean_squared_error: 0.9894 - val_loss: 1.8387 - val_y1_output_loss: 0.4559 - val_y2_output_loss: 1.3827 - val_y1_output_root_mean_squared_error: 0.6752 - val_y2_output_root_mean_squared_error: 1.1759\n",
            "Epoch 194/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9967 - y1_output_loss: 0.2223 - y2_output_loss: 0.7744 - y1_output_root_mean_squared_error: 0.4715 - y2_output_root_mean_squared_error: 0.8800 - val_loss: 2.4412 - val_y1_output_loss: 0.3399 - val_y2_output_loss: 2.1013 - val_y1_output_root_mean_squared_error: 0.5830 - val_y2_output_root_mean_squared_error: 1.4496\n",
            "Epoch 195/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3939 - y1_output_loss: 0.3057 - y2_output_loss: 1.0882 - y1_output_root_mean_squared_error: 0.5529 - y2_output_root_mean_squared_error: 1.0432 - val_loss: 1.5521 - val_y1_output_loss: 0.3451 - val_y2_output_loss: 1.2070 - val_y1_output_root_mean_squared_error: 0.5874 - val_y2_output_root_mean_squared_error: 1.0986\n",
            "Epoch 196/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2220 - y1_output_loss: 0.2402 - y2_output_loss: 0.9818 - y1_output_root_mean_squared_error: 0.4901 - y2_output_root_mean_squared_error: 0.9909 - val_loss: 4.1760 - val_y1_output_loss: 1.2063 - val_y2_output_loss: 2.9697 - val_y1_output_root_mean_squared_error: 1.0983 - val_y2_output_root_mean_squared_error: 1.7233\n",
            "Epoch 197/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.5005 - y1_output_loss: 0.3030 - y2_output_loss: 1.1975 - y1_output_root_mean_squared_error: 0.5504 - y2_output_root_mean_squared_error: 1.0943 - val_loss: 1.6097 - val_y1_output_loss: 0.3995 - val_y2_output_loss: 1.2101 - val_y1_output_root_mean_squared_error: 0.6321 - val_y2_output_root_mean_squared_error: 1.1001\n",
            "Epoch 198/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9090 - y1_output_loss: 0.2189 - y2_output_loss: 0.6901 - y1_output_root_mean_squared_error: 0.4679 - y2_output_root_mean_squared_error: 0.8307 - val_loss: 1.8573 - val_y1_output_loss: 0.3314 - val_y2_output_loss: 1.5259 - val_y1_output_root_mean_squared_error: 0.5757 - val_y2_output_root_mean_squared_error: 1.2353\n",
            "Epoch 199/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1886 - y1_output_loss: 0.2392 - y2_output_loss: 0.9494 - y1_output_root_mean_squared_error: 0.4890 - y2_output_root_mean_squared_error: 0.9744 - val_loss: 1.5047 - val_y1_output_loss: 0.3121 - val_y2_output_loss: 1.1927 - val_y1_output_root_mean_squared_error: 0.5586 - val_y2_output_root_mean_squared_error: 1.0921\n",
            "Epoch 200/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1491 - y1_output_loss: 0.2129 - y2_output_loss: 0.9362 - y1_output_root_mean_squared_error: 0.4614 - y2_output_root_mean_squared_error: 0.9676 - val_loss: 6.1112 - val_y1_output_loss: 0.5151 - val_y2_output_loss: 5.5961 - val_y1_output_root_mean_squared_error: 0.7177 - val_y2_output_root_mean_squared_error: 2.3656\n",
            "Epoch 201/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0967 - y1_output_loss: 0.2399 - y2_output_loss: 0.8568 - y1_output_root_mean_squared_error: 0.4898 - y2_output_root_mean_squared_error: 0.9256 - val_loss: 1.7069 - val_y1_output_loss: 0.4194 - val_y2_output_loss: 1.2875 - val_y1_output_root_mean_squared_error: 0.6476 - val_y2_output_root_mean_squared_error: 1.1347\n",
            "Epoch 202/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8974 - y1_output_loss: 0.1768 - y2_output_loss: 0.7207 - y1_output_root_mean_squared_error: 0.4204 - y2_output_root_mean_squared_error: 0.8489 - val_loss: 1.9983 - val_y1_output_loss: 0.5189 - val_y2_output_loss: 1.4793 - val_y1_output_root_mean_squared_error: 0.7204 - val_y2_output_root_mean_squared_error: 1.2163\n",
            "Epoch 203/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2295 - y1_output_loss: 0.2441 - y2_output_loss: 0.9853 - y1_output_root_mean_squared_error: 0.4941 - y2_output_root_mean_squared_error: 0.9926 - val_loss: 2.0943 - val_y1_output_loss: 0.5110 - val_y2_output_loss: 1.5833 - val_y1_output_root_mean_squared_error: 0.7149 - val_y2_output_root_mean_squared_error: 1.2583\n",
            "Epoch 204/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2521 - y1_output_loss: 0.2839 - y2_output_loss: 0.9682 - y1_output_root_mean_squared_error: 0.5328 - y2_output_root_mean_squared_error: 0.9840 - val_loss: 2.3611 - val_y1_output_loss: 0.5927 - val_y2_output_loss: 1.7684 - val_y1_output_root_mean_squared_error: 0.7699 - val_y2_output_root_mean_squared_error: 1.3298\n",
            "Epoch 205/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2208 - y1_output_loss: 0.2914 - y2_output_loss: 0.9294 - y1_output_root_mean_squared_error: 0.5398 - y2_output_root_mean_squared_error: 0.9640 - val_loss: 5.5593 - val_y1_output_loss: 1.2297 - val_y2_output_loss: 4.3296 - val_y1_output_root_mean_squared_error: 1.1089 - val_y2_output_root_mean_squared_error: 2.0808\n",
            "Epoch 206/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0079 - y1_output_loss: 0.2153 - y2_output_loss: 0.7925 - y1_output_root_mean_squared_error: 0.4640 - y2_output_root_mean_squared_error: 0.8902 - val_loss: 1.5048 - val_y1_output_loss: 0.2918 - val_y2_output_loss: 1.2130 - val_y1_output_root_mean_squared_error: 0.5402 - val_y2_output_root_mean_squared_error: 1.1014\n",
            "Epoch 207/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1896 - y1_output_loss: 0.2834 - y2_output_loss: 0.9063 - y1_output_root_mean_squared_error: 0.5323 - y2_output_root_mean_squared_error: 0.9520 - val_loss: 4.3027 - val_y1_output_loss: 1.0615 - val_y2_output_loss: 3.2412 - val_y1_output_root_mean_squared_error: 1.0303 - val_y2_output_root_mean_squared_error: 1.8003\n",
            "Epoch 208/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1727 - y1_output_loss: 0.2216 - y2_output_loss: 0.9511 - y1_output_root_mean_squared_error: 0.4707 - y2_output_root_mean_squared_error: 0.9752 - val_loss: 5.3970 - val_y1_output_loss: 0.7067 - val_y2_output_loss: 4.6902 - val_y1_output_root_mean_squared_error: 0.8407 - val_y2_output_root_mean_squared_error: 2.1657\n",
            "Epoch 209/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2383 - y1_output_loss: 0.3267 - y2_output_loss: 0.9115 - y1_output_root_mean_squared_error: 0.5716 - y2_output_root_mean_squared_error: 0.9547 - val_loss: 1.9898 - val_y1_output_loss: 0.4962 - val_y2_output_loss: 1.4936 - val_y1_output_root_mean_squared_error: 0.7044 - val_y2_output_root_mean_squared_error: 1.2221\n",
            "Epoch 210/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4631 - y1_output_loss: 0.3717 - y2_output_loss: 1.0914 - y1_output_root_mean_squared_error: 0.6097 - y2_output_root_mean_squared_error: 1.0447 - val_loss: 1.8503 - val_y1_output_loss: 0.3618 - val_y2_output_loss: 1.4885 - val_y1_output_root_mean_squared_error: 0.6015 - val_y2_output_root_mean_squared_error: 1.2200\n",
            "Epoch 211/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3387 - y1_output_loss: 0.2770 - y2_output_loss: 1.0617 - y1_output_root_mean_squared_error: 0.5263 - y2_output_root_mean_squared_error: 1.0304 - val_loss: 1.8301 - val_y1_output_loss: 0.3362 - val_y2_output_loss: 1.4939 - val_y1_output_root_mean_squared_error: 0.5799 - val_y2_output_root_mean_squared_error: 1.2223\n",
            "Epoch 212/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0371 - y1_output_loss: 0.2064 - y2_output_loss: 0.8306 - y1_output_root_mean_squared_error: 0.4543 - y2_output_root_mean_squared_error: 0.9114 - val_loss: 1.7698 - val_y1_output_loss: 0.3304 - val_y2_output_loss: 1.4394 - val_y1_output_root_mean_squared_error: 0.5748 - val_y2_output_root_mean_squared_error: 1.1998\n",
            "Epoch 213/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9893 - y1_output_loss: 0.2131 - y2_output_loss: 0.7762 - y1_output_root_mean_squared_error: 0.4616 - y2_output_root_mean_squared_error: 0.8810 - val_loss: 1.6734 - val_y1_output_loss: 0.3884 - val_y2_output_loss: 1.2849 - val_y1_output_root_mean_squared_error: 0.6232 - val_y2_output_root_mean_squared_error: 1.1335\n",
            "Epoch 214/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9301 - y1_output_loss: 0.2052 - y2_output_loss: 0.7249 - y1_output_root_mean_squared_error: 0.4530 - y2_output_root_mean_squared_error: 0.8514 - val_loss: 2.4828 - val_y1_output_loss: 1.0470 - val_y2_output_loss: 1.4358 - val_y1_output_root_mean_squared_error: 1.0232 - val_y2_output_root_mean_squared_error: 1.1983\n",
            "Epoch 215/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9461 - y1_output_loss: 0.2231 - y2_output_loss: 0.7230 - y1_output_root_mean_squared_error: 0.4724 - y2_output_root_mean_squared_error: 0.8503 - val_loss: 2.8881 - val_y1_output_loss: 0.5666 - val_y2_output_loss: 2.3215 - val_y1_output_root_mean_squared_error: 0.7528 - val_y2_output_root_mean_squared_error: 1.5237\n",
            "Epoch 216/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3165 - y1_output_loss: 0.3368 - y2_output_loss: 0.9797 - y1_output_root_mean_squared_error: 0.5803 - y2_output_root_mean_squared_error: 0.9898 - val_loss: 1.4408 - val_y1_output_loss: 0.2952 - val_y2_output_loss: 1.1456 - val_y1_output_root_mean_squared_error: 0.5433 - val_y2_output_root_mean_squared_error: 1.0703\n",
            "Epoch 217/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0335 - y1_output_loss: 0.1977 - y2_output_loss: 0.8357 - y1_output_root_mean_squared_error: 0.4447 - y2_output_root_mean_squared_error: 0.9142 - val_loss: 2.1186 - val_y1_output_loss: 0.4414 - val_y2_output_loss: 1.6772 - val_y1_output_root_mean_squared_error: 0.6644 - val_y2_output_root_mean_squared_error: 1.2951\n",
            "Epoch 218/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3832 - y1_output_loss: 0.3602 - y2_output_loss: 1.0230 - y1_output_root_mean_squared_error: 0.6002 - y2_output_root_mean_squared_error: 1.0114 - val_loss: 1.5197 - val_y1_output_loss: 0.4100 - val_y2_output_loss: 1.1096 - val_y1_output_root_mean_squared_error: 0.6403 - val_y2_output_root_mean_squared_error: 1.0534\n",
            "Epoch 219/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1836 - y1_output_loss: 0.2325 - y2_output_loss: 0.9511 - y1_output_root_mean_squared_error: 0.4822 - y2_output_root_mean_squared_error: 0.9752 - val_loss: 1.7804 - val_y1_output_loss: 0.4314 - val_y2_output_loss: 1.3490 - val_y1_output_root_mean_squared_error: 0.6568 - val_y2_output_root_mean_squared_error: 1.1615\n",
            "Epoch 220/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9442 - y1_output_loss: 0.2220 - y2_output_loss: 0.7222 - y1_output_root_mean_squared_error: 0.4712 - y2_output_root_mean_squared_error: 0.8498 - val_loss: 1.6174 - val_y1_output_loss: 0.3207 - val_y2_output_loss: 1.2967 - val_y1_output_root_mean_squared_error: 0.5663 - val_y2_output_root_mean_squared_error: 1.1387\n",
            "Epoch 221/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9840 - y1_output_loss: 0.2207 - y2_output_loss: 0.7633 - y1_output_root_mean_squared_error: 0.4698 - y2_output_root_mean_squared_error: 0.8737 - val_loss: 1.4844 - val_y1_output_loss: 0.3327 - val_y2_output_loss: 1.1517 - val_y1_output_root_mean_squared_error: 0.5768 - val_y2_output_root_mean_squared_error: 1.0732\n",
            "Epoch 222/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3433 - y1_output_loss: 0.2724 - y2_output_loss: 1.0709 - y1_output_root_mean_squared_error: 0.5220 - y2_output_root_mean_squared_error: 1.0348 - val_loss: 2.0548 - val_y1_output_loss: 0.3509 - val_y2_output_loss: 1.7039 - val_y1_output_root_mean_squared_error: 0.5924 - val_y2_output_root_mean_squared_error: 1.3053\n",
            "Epoch 223/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0435 - y1_output_loss: 0.2537 - y2_output_loss: 0.7898 - y1_output_root_mean_squared_error: 0.5037 - y2_output_root_mean_squared_error: 0.8887 - val_loss: 3.0168 - val_y1_output_loss: 0.7793 - val_y2_output_loss: 2.2375 - val_y1_output_root_mean_squared_error: 0.8828 - val_y2_output_root_mean_squared_error: 1.4958\n",
            "Epoch 224/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2396 - y1_output_loss: 0.3139 - y2_output_loss: 0.9257 - y1_output_root_mean_squared_error: 0.5602 - y2_output_root_mean_squared_error: 0.9621 - val_loss: 1.6620 - val_y1_output_loss: 0.3504 - val_y2_output_loss: 1.3116 - val_y1_output_root_mean_squared_error: 0.5919 - val_y2_output_root_mean_squared_error: 1.1453\n",
            "Epoch 225/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.6565 - y1_output_loss: 0.3711 - y2_output_loss: 1.2855 - y1_output_root_mean_squared_error: 0.6091 - y2_output_root_mean_squared_error: 1.1338 - val_loss: 1.7054 - val_y1_output_loss: 0.4350 - val_y2_output_loss: 1.2704 - val_y1_output_root_mean_squared_error: 0.6595 - val_y2_output_root_mean_squared_error: 1.1271\n",
            "Epoch 226/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8912 - y1_output_loss: 0.2043 - y2_output_loss: 0.6868 - y1_output_root_mean_squared_error: 0.4520 - y2_output_root_mean_squared_error: 0.8287 - val_loss: 1.7070 - val_y1_output_loss: 0.3419 - val_y2_output_loss: 1.3651 - val_y1_output_root_mean_squared_error: 0.5847 - val_y2_output_root_mean_squared_error: 1.1684\n",
            "Epoch 227/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3719 - y1_output_loss: 0.2868 - y2_output_loss: 1.0851 - y1_output_root_mean_squared_error: 0.5355 - y2_output_root_mean_squared_error: 1.0417 - val_loss: 1.6635 - val_y1_output_loss: 0.3847 - val_y2_output_loss: 1.2788 - val_y1_output_root_mean_squared_error: 0.6202 - val_y2_output_root_mean_squared_error: 1.1309\n",
            "Epoch 228/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0254 - y1_output_loss: 0.2246 - y2_output_loss: 0.8007 - y1_output_root_mean_squared_error: 0.4740 - y2_output_root_mean_squared_error: 0.8948 - val_loss: 65.7321 - val_y1_output_loss: 17.5016 - val_y2_output_loss: 48.2305 - val_y1_output_root_mean_squared_error: 4.1835 - val_y2_output_root_mean_squared_error: 6.9448\n",
            "Epoch 229/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 7.3865 - y1_output_loss: 2.3417 - y2_output_loss: 5.0448 - y1_output_root_mean_squared_error: 1.5303 - y2_output_root_mean_squared_error: 2.2461 - val_loss: 1.5389 - val_y1_output_loss: 0.3144 - val_y2_output_loss: 1.2246 - val_y1_output_root_mean_squared_error: 0.5607 - val_y2_output_root_mean_squared_error: 1.1066\n",
            "Epoch 230/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.4417 - y1_output_loss: 0.3801 - y2_output_loss: 1.0616 - y1_output_root_mean_squared_error: 0.6165 - y2_output_root_mean_squared_error: 1.0303 - val_loss: 2.9297 - val_y1_output_loss: 0.4206 - val_y2_output_loss: 2.5091 - val_y1_output_root_mean_squared_error: 0.6486 - val_y2_output_root_mean_squared_error: 1.5840\n",
            "Epoch 231/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0983 - y1_output_loss: 0.2337 - y2_output_loss: 0.8645 - y1_output_root_mean_squared_error: 0.4835 - y2_output_root_mean_squared_error: 0.9298 - val_loss: 1.6489 - val_y1_output_loss: 0.3843 - val_y2_output_loss: 1.2647 - val_y1_output_root_mean_squared_error: 0.6199 - val_y2_output_root_mean_squared_error: 1.1246\n",
            "Epoch 232/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8052 - y1_output_loss: 0.1634 - y2_output_loss: 0.6418 - y1_output_root_mean_squared_error: 0.4043 - y2_output_root_mean_squared_error: 0.8011 - val_loss: 3.2199 - val_y1_output_loss: 0.6815 - val_y2_output_loss: 2.5384 - val_y1_output_root_mean_squared_error: 0.8255 - val_y2_output_root_mean_squared_error: 1.5932\n",
            "Epoch 233/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.9143 - y1_output_loss: 0.3561 - y2_output_loss: 1.5581 - y1_output_root_mean_squared_error: 0.5968 - y2_output_root_mean_squared_error: 1.2483 - val_loss: 1.5533 - val_y1_output_loss: 0.3276 - val_y2_output_loss: 1.2257 - val_y1_output_root_mean_squared_error: 0.5724 - val_y2_output_root_mean_squared_error: 1.1071\n",
            "Epoch 234/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9364 - y1_output_loss: 0.1880 - y2_output_loss: 0.7484 - y1_output_root_mean_squared_error: 0.4336 - y2_output_root_mean_squared_error: 0.8651 - val_loss: 1.6342 - val_y1_output_loss: 0.2787 - val_y2_output_loss: 1.3556 - val_y1_output_root_mean_squared_error: 0.5279 - val_y2_output_root_mean_squared_error: 1.1643\n",
            "Epoch 235/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9133 - y1_output_loss: 0.1948 - y2_output_loss: 0.7185 - y1_output_root_mean_squared_error: 0.4413 - y2_output_root_mean_squared_error: 0.8477 - val_loss: 2.2080 - val_y1_output_loss: 0.3815 - val_y2_output_loss: 1.8265 - val_y1_output_root_mean_squared_error: 0.6176 - val_y2_output_root_mean_squared_error: 1.3515\n",
            "Epoch 236/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9569 - y1_output_loss: 0.1650 - y2_output_loss: 0.7920 - y1_output_root_mean_squared_error: 0.4061 - y2_output_root_mean_squared_error: 0.8899 - val_loss: 1.5694 - val_y1_output_loss: 0.3095 - val_y2_output_loss: 1.2599 - val_y1_output_root_mean_squared_error: 0.5563 - val_y2_output_root_mean_squared_error: 1.1225\n",
            "Epoch 237/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7877 - y1_output_loss: 0.1926 - y2_output_loss: 0.5951 - y1_output_root_mean_squared_error: 0.4389 - y2_output_root_mean_squared_error: 0.7714 - val_loss: 1.3875 - val_y1_output_loss: 0.3106 - val_y2_output_loss: 1.0770 - val_y1_output_root_mean_squared_error: 0.5573 - val_y2_output_root_mean_squared_error: 1.0378\n",
            "Epoch 238/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0963 - y1_output_loss: 0.1991 - y2_output_loss: 0.8973 - y1_output_root_mean_squared_error: 0.4462 - y2_output_root_mean_squared_error: 0.9472 - val_loss: 8.0295 - val_y1_output_loss: 0.6651 - val_y2_output_loss: 7.3644 - val_y1_output_root_mean_squared_error: 0.8155 - val_y2_output_root_mean_squared_error: 2.7137\n",
            "Epoch 239/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0389 - y1_output_loss: 0.2124 - y2_output_loss: 0.8264 - y1_output_root_mean_squared_error: 0.4609 - y2_output_root_mean_squared_error: 0.9091 - val_loss: 1.7289 - val_y1_output_loss: 0.2810 - val_y2_output_loss: 1.4479 - val_y1_output_root_mean_squared_error: 0.5301 - val_y2_output_root_mean_squared_error: 1.2033\n",
            "Epoch 240/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3471 - y1_output_loss: 0.2893 - y2_output_loss: 1.0578 - y1_output_root_mean_squared_error: 0.5379 - y2_output_root_mean_squared_error: 1.0285 - val_loss: 1.7413 - val_y1_output_loss: 0.3195 - val_y2_output_loss: 1.4218 - val_y1_output_root_mean_squared_error: 0.5653 - val_y2_output_root_mean_squared_error: 1.1924\n",
            "Epoch 241/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8400 - y1_output_loss: 0.1644 - y2_output_loss: 0.6756 - y1_output_root_mean_squared_error: 0.4055 - y2_output_root_mean_squared_error: 0.8219 - val_loss: 1.3832 - val_y1_output_loss: 0.2807 - val_y2_output_loss: 1.1025 - val_y1_output_root_mean_squared_error: 0.5298 - val_y2_output_root_mean_squared_error: 1.0500\n",
            "Epoch 242/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8193 - y1_output_loss: 0.1850 - y2_output_loss: 0.6343 - y1_output_root_mean_squared_error: 0.4301 - y2_output_root_mean_squared_error: 0.7964 - val_loss: 2.1079 - val_y1_output_loss: 0.3678 - val_y2_output_loss: 1.7401 - val_y1_output_root_mean_squared_error: 0.6065 - val_y2_output_root_mean_squared_error: 1.3191\n",
            "Epoch 243/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9674 - y1_output_loss: 0.1895 - y2_output_loss: 0.7779 - y1_output_root_mean_squared_error: 0.4353 - y2_output_root_mean_squared_error: 0.8820 - val_loss: 1.4922 - val_y1_output_loss: 0.3188 - val_y2_output_loss: 1.1735 - val_y1_output_root_mean_squared_error: 0.5646 - val_y2_output_root_mean_squared_error: 1.0833\n",
            "Epoch 244/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8352 - y1_output_loss: 0.1912 - y2_output_loss: 0.6440 - y1_output_root_mean_squared_error: 0.4373 - y2_output_root_mean_squared_error: 0.8025 - val_loss: 2.3014 - val_y1_output_loss: 0.4243 - val_y2_output_loss: 1.8770 - val_y1_output_root_mean_squared_error: 0.6514 - val_y2_output_root_mean_squared_error: 1.3700\n",
            "Epoch 245/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9163 - y1_output_loss: 0.1897 - y2_output_loss: 0.7266 - y1_output_root_mean_squared_error: 0.4355 - y2_output_root_mean_squared_error: 0.8524 - val_loss: 1.9072 - val_y1_output_loss: 0.3243 - val_y2_output_loss: 1.5829 - val_y1_output_root_mean_squared_error: 0.5695 - val_y2_output_root_mean_squared_error: 1.2581\n",
            "Epoch 246/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9639 - y1_output_loss: 0.2432 - y2_output_loss: 0.7206 - y1_output_root_mean_squared_error: 0.4932 - y2_output_root_mean_squared_error: 0.8489 - val_loss: 4.1808 - val_y1_output_loss: 0.8335 - val_y2_output_loss: 3.3473 - val_y1_output_root_mean_squared_error: 0.9130 - val_y2_output_root_mean_squared_error: 1.8296\n",
            "Epoch 247/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9389 - y1_output_loss: 0.1804 - y2_output_loss: 0.7586 - y1_output_root_mean_squared_error: 0.4247 - y2_output_root_mean_squared_error: 0.8710 - val_loss: 1.3347 - val_y1_output_loss: 0.2903 - val_y2_output_loss: 1.0444 - val_y1_output_root_mean_squared_error: 0.5388 - val_y2_output_root_mean_squared_error: 1.0220\n",
            "Epoch 248/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0690 - y1_output_loss: 0.2189 - y2_output_loss: 0.8501 - y1_output_root_mean_squared_error: 0.4678 - y2_output_root_mean_squared_error: 0.9220 - val_loss: 1.3844 - val_y1_output_loss: 0.3014 - val_y2_output_loss: 1.0830 - val_y1_output_root_mean_squared_error: 0.5490 - val_y2_output_root_mean_squared_error: 1.0407\n",
            "Epoch 249/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0265 - y1_output_loss: 0.1797 - y2_output_loss: 0.8467 - y1_output_root_mean_squared_error: 0.4240 - y2_output_root_mean_squared_error: 0.9202 - val_loss: 2.7417 - val_y1_output_loss: 0.4321 - val_y2_output_loss: 2.3096 - val_y1_output_root_mean_squared_error: 0.6573 - val_y2_output_root_mean_squared_error: 1.5197\n",
            "Epoch 250/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8404 - y1_output_loss: 0.2350 - y2_output_loss: 0.6054 - y1_output_root_mean_squared_error: 0.4848 - y2_output_root_mean_squared_error: 0.7781 - val_loss: 1.3244 - val_y1_output_loss: 0.3035 - val_y2_output_loss: 1.0209 - val_y1_output_root_mean_squared_error: 0.5509 - val_y2_output_root_mean_squared_error: 1.0104\n",
            "Epoch 251/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0130 - y1_output_loss: 0.1747 - y2_output_loss: 0.8382 - y1_output_root_mean_squared_error: 0.4180 - y2_output_root_mean_squared_error: 0.9156 - val_loss: 2.2955 - val_y1_output_loss: 0.2780 - val_y2_output_loss: 2.0175 - val_y1_output_root_mean_squared_error: 0.5272 - val_y2_output_root_mean_squared_error: 1.4204\n",
            "Epoch 252/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8864 - y1_output_loss: 0.1797 - y2_output_loss: 0.7067 - y1_output_root_mean_squared_error: 0.4239 - y2_output_root_mean_squared_error: 0.8407 - val_loss: 1.5592 - val_y1_output_loss: 0.3145 - val_y2_output_loss: 1.2447 - val_y1_output_root_mean_squared_error: 0.5608 - val_y2_output_root_mean_squared_error: 1.1157\n",
            "Epoch 253/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0385 - y1_output_loss: 0.2413 - y2_output_loss: 0.7971 - y1_output_root_mean_squared_error: 0.4913 - y2_output_root_mean_squared_error: 0.8928 - val_loss: 1.5231 - val_y1_output_loss: 0.4130 - val_y2_output_loss: 1.1101 - val_y1_output_root_mean_squared_error: 0.6427 - val_y2_output_root_mean_squared_error: 1.0536\n",
            "Epoch 254/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7265 - y1_output_loss: 0.1658 - y2_output_loss: 0.5607 - y1_output_root_mean_squared_error: 0.4072 - y2_output_root_mean_squared_error: 0.7488 - val_loss: 1.4353 - val_y1_output_loss: 0.2731 - val_y2_output_loss: 1.1623 - val_y1_output_root_mean_squared_error: 0.5225 - val_y2_output_root_mean_squared_error: 1.0781\n",
            "Epoch 255/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8578 - y1_output_loss: 0.2263 - y2_output_loss: 0.6316 - y1_output_root_mean_squared_error: 0.4757 - y2_output_root_mean_squared_error: 0.7947 - val_loss: 1.3278 - val_y1_output_loss: 0.2990 - val_y2_output_loss: 1.0289 - val_y1_output_root_mean_squared_error: 0.5468 - val_y2_output_root_mean_squared_error: 1.0143\n",
            "Epoch 256/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.3063 - y1_output_loss: 0.2994 - y2_output_loss: 1.0069 - y1_output_root_mean_squared_error: 0.5472 - y2_output_root_mean_squared_error: 1.0034 - val_loss: 1.3031 - val_y1_output_loss: 0.2866 - val_y2_output_loss: 1.0166 - val_y1_output_root_mean_squared_error: 0.5353 - val_y2_output_root_mean_squared_error: 1.0082\n",
            "Epoch 257/500\n",
            "62/62 [==============================] - 0s 2ms/step - loss: 0.7947 - y1_output_loss: 0.2080 - y2_output_loss: 0.5867 - y1_output_root_mean_squared_error: 0.4561 - y2_output_root_mean_squared_error: 0.7660 - val_loss: 2.1212 - val_y1_output_loss: 0.3935 - val_y2_output_loss: 1.7277 - val_y1_output_root_mean_squared_error: 0.6273 - val_y2_output_root_mean_squared_error: 1.3144\n",
            "Epoch 258/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7371 - y1_output_loss: 0.1596 - y2_output_loss: 0.5776 - y1_output_root_mean_squared_error: 0.3995 - y2_output_root_mean_squared_error: 0.7600 - val_loss: 1.4234 - val_y1_output_loss: 0.3449 - val_y2_output_loss: 1.0786 - val_y1_output_root_mean_squared_error: 0.5873 - val_y2_output_root_mean_squared_error: 1.0385\n",
            "Epoch 259/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7958 - y1_output_loss: 0.1678 - y2_output_loss: 0.6280 - y1_output_root_mean_squared_error: 0.4096 - y2_output_root_mean_squared_error: 0.7924 - val_loss: 1.4271 - val_y1_output_loss: 0.3190 - val_y2_output_loss: 1.1081 - val_y1_output_root_mean_squared_error: 0.5648 - val_y2_output_root_mean_squared_error: 1.0527\n",
            "Epoch 260/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7586 - y1_output_loss: 0.2041 - y2_output_loss: 0.5546 - y1_output_root_mean_squared_error: 0.4517 - y2_output_root_mean_squared_error: 0.7447 - val_loss: 1.4979 - val_y1_output_loss: 0.3860 - val_y2_output_loss: 1.1119 - val_y1_output_root_mean_squared_error: 0.6213 - val_y2_output_root_mean_squared_error: 1.0545\n",
            "Epoch 261/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8378 - y1_output_loss: 0.1839 - y2_output_loss: 0.6539 - y1_output_root_mean_squared_error: 0.4289 - y2_output_root_mean_squared_error: 0.8086 - val_loss: 1.5699 - val_y1_output_loss: 0.4798 - val_y2_output_loss: 1.0901 - val_y1_output_root_mean_squared_error: 0.6927 - val_y2_output_root_mean_squared_error: 1.0441\n",
            "Epoch 262/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7453 - y1_output_loss: 0.1480 - y2_output_loss: 0.5972 - y1_output_root_mean_squared_error: 0.3847 - y2_output_root_mean_squared_error: 0.7728 - val_loss: 1.8649 - val_y1_output_loss: 0.3045 - val_y2_output_loss: 1.5605 - val_y1_output_root_mean_squared_error: 0.5518 - val_y2_output_root_mean_squared_error: 1.2492\n",
            "Epoch 263/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7955 - y1_output_loss: 0.1589 - y2_output_loss: 0.6366 - y1_output_root_mean_squared_error: 0.3986 - y2_output_root_mean_squared_error: 0.7979 - val_loss: 1.5298 - val_y1_output_loss: 0.3602 - val_y2_output_loss: 1.1696 - val_y1_output_root_mean_squared_error: 0.6002 - val_y2_output_root_mean_squared_error: 1.0815\n",
            "Epoch 264/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6460 - y1_output_loss: 0.1400 - y2_output_loss: 0.5061 - y1_output_root_mean_squared_error: 0.3741 - y2_output_root_mean_squared_error: 0.7114 - val_loss: 2.7280 - val_y1_output_loss: 0.4955 - val_y2_output_loss: 2.2325 - val_y1_output_root_mean_squared_error: 0.7039 - val_y2_output_root_mean_squared_error: 1.4941\n",
            "Epoch 265/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8402 - y1_output_loss: 0.1656 - y2_output_loss: 0.6746 - y1_output_root_mean_squared_error: 0.4069 - y2_output_root_mean_squared_error: 0.8213 - val_loss: 1.3926 - val_y1_output_loss: 0.3205 - val_y2_output_loss: 1.0721 - val_y1_output_root_mean_squared_error: 0.5662 - val_y2_output_root_mean_squared_error: 1.0354\n",
            "Epoch 266/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7283 - y1_output_loss: 0.1689 - y2_output_loss: 0.5594 - y1_output_root_mean_squared_error: 0.4110 - y2_output_root_mean_squared_error: 0.7479 - val_loss: 1.9465 - val_y1_output_loss: 0.7528 - val_y2_output_loss: 1.1937 - val_y1_output_root_mean_squared_error: 0.8676 - val_y2_output_root_mean_squared_error: 1.0926\n",
            "Epoch 267/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8170 - y1_output_loss: 0.1664 - y2_output_loss: 0.6505 - y1_output_root_mean_squared_error: 0.4079 - y2_output_root_mean_squared_error: 0.8066 - val_loss: 2.1122 - val_y1_output_loss: 0.5885 - val_y2_output_loss: 1.5237 - val_y1_output_root_mean_squared_error: 0.7671 - val_y2_output_root_mean_squared_error: 1.2344\n",
            "Epoch 268/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8744 - y1_output_loss: 0.1720 - y2_output_loss: 0.7024 - y1_output_root_mean_squared_error: 0.4147 - y2_output_root_mean_squared_error: 0.8381 - val_loss: 1.3640 - val_y1_output_loss: 0.2711 - val_y2_output_loss: 1.0930 - val_y1_output_root_mean_squared_error: 0.5206 - val_y2_output_root_mean_squared_error: 1.0454\n",
            "Epoch 269/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7766 - y1_output_loss: 0.1812 - y2_output_loss: 0.5954 - y1_output_root_mean_squared_error: 0.4257 - y2_output_root_mean_squared_error: 0.7716 - val_loss: 1.8590 - val_y1_output_loss: 0.2697 - val_y2_output_loss: 1.5893 - val_y1_output_root_mean_squared_error: 0.5194 - val_y2_output_root_mean_squared_error: 1.2607\n",
            "Epoch 270/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8074 - y1_output_loss: 0.1908 - y2_output_loss: 0.6166 - y1_output_root_mean_squared_error: 0.4369 - y2_output_root_mean_squared_error: 0.7852 - val_loss: 1.4624 - val_y1_output_loss: 0.3383 - val_y2_output_loss: 1.1241 - val_y1_output_root_mean_squared_error: 0.5816 - val_y2_output_root_mean_squared_error: 1.0602\n",
            "Epoch 271/500\n",
            "62/62 [==============================] - 0s 4ms/step - loss: 0.7737 - y1_output_loss: 0.1903 - y2_output_loss: 0.5835 - y1_output_root_mean_squared_error: 0.4362 - y2_output_root_mean_squared_error: 0.7638 - val_loss: 1.2055 - val_y1_output_loss: 0.2524 - val_y2_output_loss: 0.9531 - val_y1_output_root_mean_squared_error: 0.5024 - val_y2_output_root_mean_squared_error: 0.9763\n",
            "Epoch 272/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6820 - y1_output_loss: 0.1476 - y2_output_loss: 0.5344 - y1_output_root_mean_squared_error: 0.3842 - y2_output_root_mean_squared_error: 0.7310 - val_loss: 1.2793 - val_y1_output_loss: 0.2757 - val_y2_output_loss: 1.0036 - val_y1_output_root_mean_squared_error: 0.5251 - val_y2_output_root_mean_squared_error: 1.0018\n",
            "Epoch 273/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7733 - y1_output_loss: 0.1680 - y2_output_loss: 0.6053 - y1_output_root_mean_squared_error: 0.4099 - y2_output_root_mean_squared_error: 0.7780 - val_loss: 3.3071 - val_y1_output_loss: 1.1906 - val_y2_output_loss: 2.1165 - val_y1_output_root_mean_squared_error: 1.0911 - val_y2_output_root_mean_squared_error: 1.4548\n",
            "Epoch 274/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8897 - y1_output_loss: 0.1969 - y2_output_loss: 0.6928 - y1_output_root_mean_squared_error: 0.4437 - y2_output_root_mean_squared_error: 0.8324 - val_loss: 1.7654 - val_y1_output_loss: 0.2566 - val_y2_output_loss: 1.5088 - val_y1_output_root_mean_squared_error: 0.5065 - val_y2_output_root_mean_squared_error: 1.2283\n",
            "Epoch 275/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8383 - y1_output_loss: 0.1645 - y2_output_loss: 0.6737 - y1_output_root_mean_squared_error: 0.4056 - y2_output_root_mean_squared_error: 0.8208 - val_loss: 1.5207 - val_y1_output_loss: 0.3161 - val_y2_output_loss: 1.2047 - val_y1_output_root_mean_squared_error: 0.5622 - val_y2_output_root_mean_squared_error: 1.0976\n",
            "Epoch 276/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7316 - y1_output_loss: 0.1589 - y2_output_loss: 0.5727 - y1_output_root_mean_squared_error: 0.3987 - y2_output_root_mean_squared_error: 0.7567 - val_loss: 1.2296 - val_y1_output_loss: 0.2653 - val_y2_output_loss: 0.9643 - val_y1_output_root_mean_squared_error: 0.5151 - val_y2_output_root_mean_squared_error: 0.9820\n",
            "Epoch 277/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8351 - y1_output_loss: 0.1754 - y2_output_loss: 0.6596 - y1_output_root_mean_squared_error: 0.4189 - y2_output_root_mean_squared_error: 0.8122 - val_loss: 1.4885 - val_y1_output_loss: 0.4245 - val_y2_output_loss: 1.0640 - val_y1_output_root_mean_squared_error: 0.6515 - val_y2_output_root_mean_squared_error: 1.0315\n",
            "Epoch 278/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0129 - y1_output_loss: 0.2736 - y2_output_loss: 0.7393 - y1_output_root_mean_squared_error: 0.5231 - y2_output_root_mean_squared_error: 0.8598 - val_loss: 1.4387 - val_y1_output_loss: 0.3558 - val_y2_output_loss: 1.0828 - val_y1_output_root_mean_squared_error: 0.5965 - val_y2_output_root_mean_squared_error: 1.0406\n",
            "Epoch 279/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8730 - y1_output_loss: 0.1781 - y2_output_loss: 0.6949 - y1_output_root_mean_squared_error: 0.4221 - y2_output_root_mean_squared_error: 0.8336 - val_loss: 1.7623 - val_y1_output_loss: 0.2682 - val_y2_output_loss: 1.4941 - val_y1_output_root_mean_squared_error: 0.5179 - val_y2_output_root_mean_squared_error: 1.2223\n",
            "Epoch 280/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8836 - y1_output_loss: 0.1889 - y2_output_loss: 0.6947 - y1_output_root_mean_squared_error: 0.4346 - y2_output_root_mean_squared_error: 0.8335 - val_loss: 2.8071 - val_y1_output_loss: 0.3903 - val_y2_output_loss: 2.4167 - val_y1_output_root_mean_squared_error: 0.6248 - val_y2_output_root_mean_squared_error: 1.5546\n",
            "Epoch 281/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1967 - y1_output_loss: 0.2794 - y2_output_loss: 0.9173 - y1_output_root_mean_squared_error: 0.5286 - y2_output_root_mean_squared_error: 0.9578 - val_loss: 2.3401 - val_y1_output_loss: 0.5462 - val_y2_output_loss: 1.7938 - val_y1_output_root_mean_squared_error: 0.7391 - val_y2_output_root_mean_squared_error: 1.3393\n",
            "Epoch 282/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9365 - y1_output_loss: 0.1954 - y2_output_loss: 0.7412 - y1_output_root_mean_squared_error: 0.4420 - y2_output_root_mean_squared_error: 0.8609 - val_loss: 1.7623 - val_y1_output_loss: 0.3226 - val_y2_output_loss: 1.4396 - val_y1_output_root_mean_squared_error: 0.5680 - val_y2_output_root_mean_squared_error: 1.1998\n",
            "Epoch 283/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8724 - y1_output_loss: 0.2407 - y2_output_loss: 0.6317 - y1_output_root_mean_squared_error: 0.4906 - y2_output_root_mean_squared_error: 0.7948 - val_loss: 1.2589 - val_y1_output_loss: 0.3045 - val_y2_output_loss: 0.9543 - val_y1_output_root_mean_squared_error: 0.5518 - val_y2_output_root_mean_squared_error: 0.9769\n",
            "Epoch 284/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7055 - y1_output_loss: 0.1638 - y2_output_loss: 0.5417 - y1_output_root_mean_squared_error: 0.4047 - y2_output_root_mean_squared_error: 0.7360 - val_loss: 1.7535 - val_y1_output_loss: 0.4241 - val_y2_output_loss: 1.3293 - val_y1_output_root_mean_squared_error: 0.6513 - val_y2_output_root_mean_squared_error: 1.1530\n",
            "Epoch 285/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8794 - y1_output_loss: 0.1745 - y2_output_loss: 0.7048 - y1_output_root_mean_squared_error: 0.4178 - y2_output_root_mean_squared_error: 0.8395 - val_loss: 2.4955 - val_y1_output_loss: 0.6084 - val_y2_output_loss: 1.8871 - val_y1_output_root_mean_squared_error: 0.7800 - val_y2_output_root_mean_squared_error: 1.3737\n",
            "Epoch 286/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7568 - y1_output_loss: 0.1615 - y2_output_loss: 0.5953 - y1_output_root_mean_squared_error: 0.4019 - y2_output_root_mean_squared_error: 0.7716 - val_loss: 2.0201 - val_y1_output_loss: 0.3947 - val_y2_output_loss: 1.6255 - val_y1_output_root_mean_squared_error: 0.6282 - val_y2_output_root_mean_squared_error: 1.2749\n",
            "Epoch 287/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6966 - y1_output_loss: 0.1493 - y2_output_loss: 0.5472 - y1_output_root_mean_squared_error: 0.3865 - y2_output_root_mean_squared_error: 0.7398 - val_loss: 3.1234 - val_y1_output_loss: 0.3726 - val_y2_output_loss: 2.7508 - val_y1_output_root_mean_squared_error: 0.6104 - val_y2_output_root_mean_squared_error: 1.6586\n",
            "Epoch 288/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7379 - y1_output_loss: 0.1589 - y2_output_loss: 0.5790 - y1_output_root_mean_squared_error: 0.3986 - y2_output_root_mean_squared_error: 0.7609 - val_loss: 1.4780 - val_y1_output_loss: 0.3221 - val_y2_output_loss: 1.1559 - val_y1_output_root_mean_squared_error: 0.5675 - val_y2_output_root_mean_squared_error: 1.0751\n",
            "Epoch 289/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6422 - y1_output_loss: 0.1319 - y2_output_loss: 0.5104 - y1_output_root_mean_squared_error: 0.3631 - y2_output_root_mean_squared_error: 0.7144 - val_loss: 1.2626 - val_y1_output_loss: 0.3255 - val_y2_output_loss: 0.9371 - val_y1_output_root_mean_squared_error: 0.5705 - val_y2_output_root_mean_squared_error: 0.9680\n",
            "Epoch 290/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6359 - y1_output_loss: 0.1664 - y2_output_loss: 0.4695 - y1_output_root_mean_squared_error: 0.4079 - y2_output_root_mean_squared_error: 0.6852 - val_loss: 1.1228 - val_y1_output_loss: 0.2431 - val_y2_output_loss: 0.8797 - val_y1_output_root_mean_squared_error: 0.4931 - val_y2_output_root_mean_squared_error: 0.9379\n",
            "Epoch 291/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6354 - y1_output_loss: 0.1487 - y2_output_loss: 0.4867 - y1_output_root_mean_squared_error: 0.3856 - y2_output_root_mean_squared_error: 0.6976 - val_loss: 1.2355 - val_y1_output_loss: 0.3017 - val_y2_output_loss: 0.9338 - val_y1_output_root_mean_squared_error: 0.5493 - val_y2_output_root_mean_squared_error: 0.9663\n",
            "Epoch 292/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7140 - y1_output_loss: 0.1499 - y2_output_loss: 0.5642 - y1_output_root_mean_squared_error: 0.3871 - y2_output_root_mean_squared_error: 0.7511 - val_loss: 1.3420 - val_y1_output_loss: 0.2657 - val_y2_output_loss: 1.0762 - val_y1_output_root_mean_squared_error: 0.5155 - val_y2_output_root_mean_squared_error: 1.0374\n",
            "Epoch 293/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6791 - y1_output_loss: 0.1638 - y2_output_loss: 0.5154 - y1_output_root_mean_squared_error: 0.4047 - y2_output_root_mean_squared_error: 0.7179 - val_loss: 18.5895 - val_y1_output_loss: 6.7939 - val_y2_output_loss: 11.7955 - val_y1_output_root_mean_squared_error: 2.6065 - val_y2_output_root_mean_squared_error: 3.4345\n",
            "Epoch 294/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.1957 - y1_output_loss: 0.3200 - y2_output_loss: 0.8757 - y1_output_root_mean_squared_error: 0.5657 - y2_output_root_mean_squared_error: 0.9358 - val_loss: 1.3030 - val_y1_output_loss: 0.3379 - val_y2_output_loss: 0.9651 - val_y1_output_root_mean_squared_error: 0.5813 - val_y2_output_root_mean_squared_error: 0.9824\n",
            "Epoch 295/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6782 - y1_output_loss: 0.1458 - y2_output_loss: 0.5324 - y1_output_root_mean_squared_error: 0.3818 - y2_output_root_mean_squared_error: 0.7296 - val_loss: 1.1854 - val_y1_output_loss: 0.2577 - val_y2_output_loss: 0.9277 - val_y1_output_root_mean_squared_error: 0.5076 - val_y2_output_root_mean_squared_error: 0.9632\n",
            "Epoch 296/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6301 - y1_output_loss: 0.1673 - y2_output_loss: 0.4628 - y1_output_root_mean_squared_error: 0.4091 - y2_output_root_mean_squared_error: 0.6803 - val_loss: 1.3306 - val_y1_output_loss: 0.3316 - val_y2_output_loss: 0.9990 - val_y1_output_root_mean_squared_error: 0.5758 - val_y2_output_root_mean_squared_error: 0.9995\n",
            "Epoch 297/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5801 - y1_output_loss: 0.1556 - y2_output_loss: 0.4245 - y1_output_root_mean_squared_error: 0.3945 - y2_output_root_mean_squared_error: 0.6515 - val_loss: 1.2468 - val_y1_output_loss: 0.3586 - val_y2_output_loss: 0.8881 - val_y1_output_root_mean_squared_error: 0.5988 - val_y2_output_root_mean_squared_error: 0.9424\n",
            "Epoch 298/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7086 - y1_output_loss: 0.1811 - y2_output_loss: 0.5274 - y1_output_root_mean_squared_error: 0.4256 - y2_output_root_mean_squared_error: 0.7262 - val_loss: 1.1828 - val_y1_output_loss: 0.2851 - val_y2_output_loss: 0.8977 - val_y1_output_root_mean_squared_error: 0.5339 - val_y2_output_root_mean_squared_error: 0.9475\n",
            "Epoch 299/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7519 - y1_output_loss: 0.1806 - y2_output_loss: 0.5713 - y1_output_root_mean_squared_error: 0.4249 - y2_output_root_mean_squared_error: 0.7559 - val_loss: 1.3544 - val_y1_output_loss: 0.2983 - val_y2_output_loss: 1.0561 - val_y1_output_root_mean_squared_error: 0.5462 - val_y2_output_root_mean_squared_error: 1.0276\n",
            "Epoch 300/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5598 - y1_output_loss: 0.1340 - y2_output_loss: 0.4258 - y1_output_root_mean_squared_error: 0.3660 - y2_output_root_mean_squared_error: 0.6526 - val_loss: 1.3074 - val_y1_output_loss: 0.3391 - val_y2_output_loss: 0.9683 - val_y1_output_root_mean_squared_error: 0.5823 - val_y2_output_root_mean_squared_error: 0.9840\n",
            "Epoch 301/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7612 - y1_output_loss: 0.1578 - y2_output_loss: 0.6033 - y1_output_root_mean_squared_error: 0.3973 - y2_output_root_mean_squared_error: 0.7768 - val_loss: 1.3863 - val_y1_output_loss: 0.2522 - val_y2_output_loss: 1.1341 - val_y1_output_root_mean_squared_error: 0.5022 - val_y2_output_root_mean_squared_error: 1.0649\n",
            "Epoch 302/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7218 - y1_output_loss: 0.1589 - y2_output_loss: 0.5629 - y1_output_root_mean_squared_error: 0.3986 - y2_output_root_mean_squared_error: 0.7503 - val_loss: 1.2121 - val_y1_output_loss: 0.2875 - val_y2_output_loss: 0.9247 - val_y1_output_root_mean_squared_error: 0.5362 - val_y2_output_root_mean_squared_error: 0.9616\n",
            "Epoch 303/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6690 - y1_output_loss: 0.1562 - y2_output_loss: 0.5128 - y1_output_root_mean_squared_error: 0.3952 - y2_output_root_mean_squared_error: 0.7161 - val_loss: 1.5944 - val_y1_output_loss: 0.3224 - val_y2_output_loss: 1.2720 - val_y1_output_root_mean_squared_error: 0.5678 - val_y2_output_root_mean_squared_error: 1.1278\n",
            "Epoch 304/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8134 - y1_output_loss: 0.1931 - y2_output_loss: 0.6203 - y1_output_root_mean_squared_error: 0.4394 - y2_output_root_mean_squared_error: 0.7876 - val_loss: 1.3535 - val_y1_output_loss: 0.2986 - val_y2_output_loss: 1.0549 - val_y1_output_root_mean_squared_error: 0.5464 - val_y2_output_root_mean_squared_error: 1.0271\n",
            "Epoch 305/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6765 - y1_output_loss: 0.1660 - y2_output_loss: 0.5105 - y1_output_root_mean_squared_error: 0.4074 - y2_output_root_mean_squared_error: 0.7145 - val_loss: 1.2691 - val_y1_output_loss: 0.2951 - val_y2_output_loss: 0.9740 - val_y1_output_root_mean_squared_error: 0.5432 - val_y2_output_root_mean_squared_error: 0.9869\n",
            "Epoch 306/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8556 - y1_output_loss: 0.1732 - y2_output_loss: 0.6823 - y1_output_root_mean_squared_error: 0.4162 - y2_output_root_mean_squared_error: 0.8260 - val_loss: 1.1842 - val_y1_output_loss: 0.2616 - val_y2_output_loss: 0.9226 - val_y1_output_root_mean_squared_error: 0.5115 - val_y2_output_root_mean_squared_error: 0.9605\n",
            "Epoch 307/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6650 - y1_output_loss: 0.1536 - y2_output_loss: 0.5114 - y1_output_root_mean_squared_error: 0.3919 - y2_output_root_mean_squared_error: 0.7151 - val_loss: 1.3247 - val_y1_output_loss: 0.2947 - val_y2_output_loss: 1.0300 - val_y1_output_root_mean_squared_error: 0.5428 - val_y2_output_root_mean_squared_error: 1.0149\n",
            "Epoch 308/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7117 - y1_output_loss: 0.1723 - y2_output_loss: 0.5394 - y1_output_root_mean_squared_error: 0.4151 - y2_output_root_mean_squared_error: 0.7344 - val_loss: 4.0386 - val_y1_output_loss: 0.4405 - val_y2_output_loss: 3.5981 - val_y1_output_root_mean_squared_error: 0.6637 - val_y2_output_root_mean_squared_error: 1.8969\n",
            "Epoch 309/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.2023 - y1_output_loss: 0.3022 - y2_output_loss: 0.9001 - y1_output_root_mean_squared_error: 0.5498 - y2_output_root_mean_squared_error: 0.9487 - val_loss: 1.2447 - val_y1_output_loss: 0.3290 - val_y2_output_loss: 0.9157 - val_y1_output_root_mean_squared_error: 0.5736 - val_y2_output_root_mean_squared_error: 0.9569\n",
            "Epoch 310/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6125 - y1_output_loss: 0.1404 - y2_output_loss: 0.4721 - y1_output_root_mean_squared_error: 0.3747 - y2_output_root_mean_squared_error: 0.6871 - val_loss: 1.2628 - val_y1_output_loss: 0.3008 - val_y2_output_loss: 0.9621 - val_y1_output_root_mean_squared_error: 0.5484 - val_y2_output_root_mean_squared_error: 0.9809\n",
            "Epoch 311/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6925 - y1_output_loss: 0.1622 - y2_output_loss: 0.5302 - y1_output_root_mean_squared_error: 0.4028 - y2_output_root_mean_squared_error: 0.7282 - val_loss: 1.2565 - val_y1_output_loss: 0.2640 - val_y2_output_loss: 0.9925 - val_y1_output_root_mean_squared_error: 0.5138 - val_y2_output_root_mean_squared_error: 0.9963\n",
            "Epoch 312/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6319 - y1_output_loss: 0.1463 - y2_output_loss: 0.4856 - y1_output_root_mean_squared_error: 0.3824 - y2_output_root_mean_squared_error: 0.6969 - val_loss: 1.4288 - val_y1_output_loss: 0.3239 - val_y2_output_loss: 1.1050 - val_y1_output_root_mean_squared_error: 0.5691 - val_y2_output_root_mean_squared_error: 1.0512\n",
            "Epoch 313/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6483 - y1_output_loss: 0.1637 - y2_output_loss: 0.4846 - y1_output_root_mean_squared_error: 0.4047 - y2_output_root_mean_squared_error: 0.6961 - val_loss: 1.2911 - val_y1_output_loss: 0.2927 - val_y2_output_loss: 0.9984 - val_y1_output_root_mean_squared_error: 0.5410 - val_y2_output_root_mean_squared_error: 0.9992\n",
            "Epoch 314/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6357 - y1_output_loss: 0.1261 - y2_output_loss: 0.5096 - y1_output_root_mean_squared_error: 0.3551 - y2_output_root_mean_squared_error: 0.7138 - val_loss: 1.1918 - val_y1_output_loss: 0.2722 - val_y2_output_loss: 0.9196 - val_y1_output_root_mean_squared_error: 0.5217 - val_y2_output_root_mean_squared_error: 0.9589\n",
            "Epoch 315/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6706 - y1_output_loss: 0.1529 - y2_output_loss: 0.5178 - y1_output_root_mean_squared_error: 0.3910 - y2_output_root_mean_squared_error: 0.7196 - val_loss: 1.1680 - val_y1_output_loss: 0.2492 - val_y2_output_loss: 0.9188 - val_y1_output_root_mean_squared_error: 0.4992 - val_y2_output_root_mean_squared_error: 0.9586\n",
            "Epoch 316/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6590 - y1_output_loss: 0.1896 - y2_output_loss: 0.4694 - y1_output_root_mean_squared_error: 0.4354 - y2_output_root_mean_squared_error: 0.6851 - val_loss: 1.1435 - val_y1_output_loss: 0.2631 - val_y2_output_loss: 0.8804 - val_y1_output_root_mean_squared_error: 0.5130 - val_y2_output_root_mean_squared_error: 0.9383\n",
            "Epoch 317/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6812 - y1_output_loss: 0.1662 - y2_output_loss: 0.5150 - y1_output_root_mean_squared_error: 0.4077 - y2_output_root_mean_squared_error: 0.7176 - val_loss: 1.6128 - val_y1_output_loss: 0.4948 - val_y2_output_loss: 1.1180 - val_y1_output_root_mean_squared_error: 0.7034 - val_y2_output_root_mean_squared_error: 1.0574\n",
            "Epoch 318/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6775 - y1_output_loss: 0.1713 - y2_output_loss: 0.5062 - y1_output_root_mean_squared_error: 0.4138 - y2_output_root_mean_squared_error: 0.7115 - val_loss: 1.4010 - val_y1_output_loss: 0.3177 - val_y2_output_loss: 1.0833 - val_y1_output_root_mean_squared_error: 0.5636 - val_y2_output_root_mean_squared_error: 1.0408\n",
            "Epoch 319/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5798 - y1_output_loss: 0.1409 - y2_output_loss: 0.4390 - y1_output_root_mean_squared_error: 0.3753 - y2_output_root_mean_squared_error: 0.6625 - val_loss: 1.0257 - val_y1_output_loss: 0.2566 - val_y2_output_loss: 0.7691 - val_y1_output_root_mean_squared_error: 0.5066 - val_y2_output_root_mean_squared_error: 0.8770\n",
            "Epoch 320/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5872 - y1_output_loss: 0.1393 - y2_output_loss: 0.4479 - y1_output_root_mean_squared_error: 0.3733 - y2_output_root_mean_squared_error: 0.6692 - val_loss: 1.2798 - val_y1_output_loss: 0.4222 - val_y2_output_loss: 0.8576 - val_y1_output_root_mean_squared_error: 0.6498 - val_y2_output_root_mean_squared_error: 0.9261\n",
            "Epoch 321/500\n",
            "62/62 [==============================] - 0s 4ms/step - loss: 0.6853 - y1_output_loss: 0.1666 - y2_output_loss: 0.5187 - y1_output_root_mean_squared_error: 0.4081 - y2_output_root_mean_squared_error: 0.7202 - val_loss: 1.8058 - val_y1_output_loss: 0.2697 - val_y2_output_loss: 1.5361 - val_y1_output_root_mean_squared_error: 0.5193 - val_y2_output_root_mean_squared_error: 1.2394\n",
            "Epoch 322/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6930 - y1_output_loss: 0.1670 - y2_output_loss: 0.5260 - y1_output_root_mean_squared_error: 0.4087 - y2_output_root_mean_squared_error: 0.7252 - val_loss: 1.2652 - val_y1_output_loss: 0.3118 - val_y2_output_loss: 0.9534 - val_y1_output_root_mean_squared_error: 0.5584 - val_y2_output_root_mean_squared_error: 0.9764\n",
            "Epoch 323/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0094 - y1_output_loss: 0.2390 - y2_output_loss: 0.7704 - y1_output_root_mean_squared_error: 0.4889 - y2_output_root_mean_squared_error: 0.8777 - val_loss: 2.2984 - val_y1_output_loss: 0.5556 - val_y2_output_loss: 1.7428 - val_y1_output_root_mean_squared_error: 0.7454 - val_y2_output_root_mean_squared_error: 1.3201\n",
            "Epoch 324/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5972 - y1_output_loss: 0.1456 - y2_output_loss: 0.4516 - y1_output_root_mean_squared_error: 0.3815 - y2_output_root_mean_squared_error: 0.6720 - val_loss: 1.3197 - val_y1_output_loss: 0.3165 - val_y2_output_loss: 1.0033 - val_y1_output_root_mean_squared_error: 0.5626 - val_y2_output_root_mean_squared_error: 1.0016\n",
            "Epoch 325/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6651 - y1_output_loss: 0.1395 - y2_output_loss: 0.5255 - y1_output_root_mean_squared_error: 0.3735 - y2_output_root_mean_squared_error: 0.7249 - val_loss: 1.2075 - val_y1_output_loss: 0.2729 - val_y2_output_loss: 0.9346 - val_y1_output_root_mean_squared_error: 0.5224 - val_y2_output_root_mean_squared_error: 0.9667\n",
            "Epoch 326/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7762 - y1_output_loss: 0.1927 - y2_output_loss: 0.5835 - y1_output_root_mean_squared_error: 0.4389 - y2_output_root_mean_squared_error: 0.7639 - val_loss: 1.6546 - val_y1_output_loss: 0.3816 - val_y2_output_loss: 1.2730 - val_y1_output_root_mean_squared_error: 0.6178 - val_y2_output_root_mean_squared_error: 1.1283\n",
            "Epoch 327/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5266 - y1_output_loss: 0.1432 - y2_output_loss: 0.3834 - y1_output_root_mean_squared_error: 0.3785 - y2_output_root_mean_squared_error: 0.6192 - val_loss: 1.0862 - val_y1_output_loss: 0.2860 - val_y2_output_loss: 0.8002 - val_y1_output_root_mean_squared_error: 0.5348 - val_y2_output_root_mean_squared_error: 0.8945\n",
            "Epoch 328/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6173 - y1_output_loss: 0.1747 - y2_output_loss: 0.4426 - y1_output_root_mean_squared_error: 0.4180 - y2_output_root_mean_squared_error: 0.6653 - val_loss: 1.1205 - val_y1_output_loss: 0.3078 - val_y2_output_loss: 0.8127 - val_y1_output_root_mean_squared_error: 0.5548 - val_y2_output_root_mean_squared_error: 0.9015\n",
            "Epoch 329/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5127 - y1_output_loss: 0.1225 - y2_output_loss: 0.3902 - y1_output_root_mean_squared_error: 0.3500 - y2_output_root_mean_squared_error: 0.6247 - val_loss: 1.1976 - val_y1_output_loss: 0.3190 - val_y2_output_loss: 0.8786 - val_y1_output_root_mean_squared_error: 0.5648 - val_y2_output_root_mean_squared_error: 0.9373\n",
            "Epoch 330/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7046 - y1_output_loss: 0.1602 - y2_output_loss: 0.5444 - y1_output_root_mean_squared_error: 0.4003 - y2_output_root_mean_squared_error: 0.7378 - val_loss: 1.4455 - val_y1_output_loss: 0.3931 - val_y2_output_loss: 1.0524 - val_y1_output_root_mean_squared_error: 0.6270 - val_y2_output_root_mean_squared_error: 1.0259\n",
            "Epoch 331/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7214 - y1_output_loss: 0.1697 - y2_output_loss: 0.5517 - y1_output_root_mean_squared_error: 0.4119 - y2_output_root_mean_squared_error: 0.7428 - val_loss: 3.1432 - val_y1_output_loss: 0.4341 - val_y2_output_loss: 2.7091 - val_y1_output_root_mean_squared_error: 0.6588 - val_y2_output_root_mean_squared_error: 1.6459\n",
            "Epoch 332/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.9581 - y1_output_loss: 0.2424 - y2_output_loss: 0.7157 - y1_output_root_mean_squared_error: 0.4924 - y2_output_root_mean_squared_error: 0.8460 - val_loss: 19.5262 - val_y1_output_loss: 2.0759 - val_y2_output_loss: 17.4503 - val_y1_output_root_mean_squared_error: 1.4408 - val_y2_output_root_mean_squared_error: 4.1774\n",
            "Epoch 333/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 1.0545 - y1_output_loss: 0.2198 - y2_output_loss: 0.8346 - y1_output_root_mean_squared_error: 0.4689 - y2_output_root_mean_squared_error: 0.9136 - val_loss: 1.5649 - val_y1_output_loss: 0.2819 - val_y2_output_loss: 1.2830 - val_y1_output_root_mean_squared_error: 0.5310 - val_y2_output_root_mean_squared_error: 1.1327\n",
            "Epoch 334/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5583 - y1_output_loss: 0.1324 - y2_output_loss: 0.4259 - y1_output_root_mean_squared_error: 0.3639 - y2_output_root_mean_squared_error: 0.6526 - val_loss: 1.1341 - val_y1_output_loss: 0.2542 - val_y2_output_loss: 0.8798 - val_y1_output_root_mean_squared_error: 0.5042 - val_y2_output_root_mean_squared_error: 0.9380\n",
            "Epoch 335/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5457 - y1_output_loss: 0.1356 - y2_output_loss: 0.4101 - y1_output_root_mean_squared_error: 0.3683 - y2_output_root_mean_squared_error: 0.6404 - val_loss: 1.2230 - val_y1_output_loss: 0.3117 - val_y2_output_loss: 0.9113 - val_y1_output_root_mean_squared_error: 0.5583 - val_y2_output_root_mean_squared_error: 0.9546\n",
            "Epoch 336/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7516 - y1_output_loss: 0.1821 - y2_output_loss: 0.5695 - y1_output_root_mean_squared_error: 0.4267 - y2_output_root_mean_squared_error: 0.7546 - val_loss: 1.0708 - val_y1_output_loss: 0.3026 - val_y2_output_loss: 0.7682 - val_y1_output_root_mean_squared_error: 0.5501 - val_y2_output_root_mean_squared_error: 0.8765\n",
            "Epoch 337/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5526 - y1_output_loss: 0.1307 - y2_output_loss: 0.4219 - y1_output_root_mean_squared_error: 0.3616 - y2_output_root_mean_squared_error: 0.6495 - val_loss: 1.8636 - val_y1_output_loss: 0.4674 - val_y2_output_loss: 1.3962 - val_y1_output_root_mean_squared_error: 0.6837 - val_y2_output_root_mean_squared_error: 1.1816\n",
            "Epoch 338/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7402 - y1_output_loss: 0.1809 - y2_output_loss: 0.5593 - y1_output_root_mean_squared_error: 0.4253 - y2_output_root_mean_squared_error: 0.7479 - val_loss: 1.1312 - val_y1_output_loss: 0.2711 - val_y2_output_loss: 0.8601 - val_y1_output_root_mean_squared_error: 0.5207 - val_y2_output_root_mean_squared_error: 0.9274\n",
            "Epoch 339/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6289 - y1_output_loss: 0.1498 - y2_output_loss: 0.4791 - y1_output_root_mean_squared_error: 0.3871 - y2_output_root_mean_squared_error: 0.6921 - val_loss: 2.8067 - val_y1_output_loss: 0.9304 - val_y2_output_loss: 1.8763 - val_y1_output_root_mean_squared_error: 0.9646 - val_y2_output_root_mean_squared_error: 1.3698\n",
            "Epoch 340/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5590 - y1_output_loss: 0.1654 - y2_output_loss: 0.3937 - y1_output_root_mean_squared_error: 0.4066 - y2_output_root_mean_squared_error: 0.6274 - val_loss: 1.2154 - val_y1_output_loss: 0.2404 - val_y2_output_loss: 0.9750 - val_y1_output_root_mean_squared_error: 0.4903 - val_y2_output_root_mean_squared_error: 0.9874\n",
            "Epoch 341/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5101 - y1_output_loss: 0.1202 - y2_output_loss: 0.3899 - y1_output_root_mean_squared_error: 0.3467 - y2_output_root_mean_squared_error: 0.6244 - val_loss: 1.2102 - val_y1_output_loss: 0.2493 - val_y2_output_loss: 0.9609 - val_y1_output_root_mean_squared_error: 0.4993 - val_y2_output_root_mean_squared_error: 0.9803\n",
            "Epoch 342/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6758 - y1_output_loss: 0.1493 - y2_output_loss: 0.5264 - y1_output_root_mean_squared_error: 0.3864 - y2_output_root_mean_squared_error: 0.7255 - val_loss: 1.4400 - val_y1_output_loss: 0.4119 - val_y2_output_loss: 1.0281 - val_y1_output_root_mean_squared_error: 0.6418 - val_y2_output_root_mean_squared_error: 1.0140\n",
            "Epoch 343/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7545 - y1_output_loss: 0.1942 - y2_output_loss: 0.5603 - y1_output_root_mean_squared_error: 0.4406 - y2_output_root_mean_squared_error: 0.7486 - val_loss: 1.1322 - val_y1_output_loss: 0.2321 - val_y2_output_loss: 0.9001 - val_y1_output_root_mean_squared_error: 0.4818 - val_y2_output_root_mean_squared_error: 0.9488\n",
            "Epoch 344/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5827 - y1_output_loss: 0.1270 - y2_output_loss: 0.4558 - y1_output_root_mean_squared_error: 0.3563 - y2_output_root_mean_squared_error: 0.6751 - val_loss: 1.1867 - val_y1_output_loss: 0.2893 - val_y2_output_loss: 0.8975 - val_y1_output_root_mean_squared_error: 0.5378 - val_y2_output_root_mean_squared_error: 0.9474\n",
            "Epoch 345/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7885 - y1_output_loss: 0.1896 - y2_output_loss: 0.5989 - y1_output_root_mean_squared_error: 0.4354 - y2_output_root_mean_squared_error: 0.7739 - val_loss: 1.7797 - val_y1_output_loss: 0.6228 - val_y2_output_loss: 1.1570 - val_y1_output_root_mean_squared_error: 0.7892 - val_y2_output_root_mean_squared_error: 1.0756\n",
            "Epoch 346/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6212 - y1_output_loss: 0.1610 - y2_output_loss: 0.4602 - y1_output_root_mean_squared_error: 0.4013 - y2_output_root_mean_squared_error: 0.6784 - val_loss: 1.5872 - val_y1_output_loss: 0.3774 - val_y2_output_loss: 1.2099 - val_y1_output_root_mean_squared_error: 0.6143 - val_y2_output_root_mean_squared_error: 1.0999\n",
            "Epoch 347/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6696 - y1_output_loss: 0.1508 - y2_output_loss: 0.5188 - y1_output_root_mean_squared_error: 0.3883 - y2_output_root_mean_squared_error: 0.7203 - val_loss: 1.6469 - val_y1_output_loss: 0.4073 - val_y2_output_loss: 1.2396 - val_y1_output_root_mean_squared_error: 0.6382 - val_y2_output_root_mean_squared_error: 1.1134\n",
            "Epoch 348/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6658 - y1_output_loss: 0.1639 - y2_output_loss: 0.5020 - y1_output_root_mean_squared_error: 0.4048 - y2_output_root_mean_squared_error: 0.7085 - val_loss: 1.0571 - val_y1_output_loss: 0.2338 - val_y2_output_loss: 0.8233 - val_y1_output_root_mean_squared_error: 0.4835 - val_y2_output_root_mean_squared_error: 0.9074\n",
            "Epoch 349/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6761 - y1_output_loss: 0.1644 - y2_output_loss: 0.5117 - y1_output_root_mean_squared_error: 0.4054 - y2_output_root_mean_squared_error: 0.7154 - val_loss: 1.1274 - val_y1_output_loss: 0.2568 - val_y2_output_loss: 0.8706 - val_y1_output_root_mean_squared_error: 0.5068 - val_y2_output_root_mean_squared_error: 0.9331\n",
            "Epoch 350/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5834 - y1_output_loss: 0.1620 - y2_output_loss: 0.4214 - y1_output_root_mean_squared_error: 0.4025 - y2_output_root_mean_squared_error: 0.6491 - val_loss: 1.1248 - val_y1_output_loss: 0.2957 - val_y2_output_loss: 0.8291 - val_y1_output_root_mean_squared_error: 0.5438 - val_y2_output_root_mean_squared_error: 0.9105\n",
            "Epoch 351/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6782 - y1_output_loss: 0.1649 - y2_output_loss: 0.5132 - y1_output_root_mean_squared_error: 0.4061 - y2_output_root_mean_squared_error: 0.7164 - val_loss: 1.2725 - val_y1_output_loss: 0.3024 - val_y2_output_loss: 0.9701 - val_y1_output_root_mean_squared_error: 0.5500 - val_y2_output_root_mean_squared_error: 0.9849\n",
            "Epoch 352/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5519 - y1_output_loss: 0.1459 - y2_output_loss: 0.4060 - y1_output_root_mean_squared_error: 0.3820 - y2_output_root_mean_squared_error: 0.6372 - val_loss: 1.0518 - val_y1_output_loss: 0.2751 - val_y2_output_loss: 0.7767 - val_y1_output_root_mean_squared_error: 0.5245 - val_y2_output_root_mean_squared_error: 0.8813\n",
            "Epoch 353/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5635 - y1_output_loss: 0.1228 - y2_output_loss: 0.4407 - y1_output_root_mean_squared_error: 0.3504 - y2_output_root_mean_squared_error: 0.6638 - val_loss: 1.9526 - val_y1_output_loss: 0.3308 - val_y2_output_loss: 1.6218 - val_y1_output_root_mean_squared_error: 0.5752 - val_y2_output_root_mean_squared_error: 1.2735\n",
            "Epoch 354/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5445 - y1_output_loss: 0.1334 - y2_output_loss: 0.4110 - y1_output_root_mean_squared_error: 0.3653 - y2_output_root_mean_squared_error: 0.6411 - val_loss: 1.0531 - val_y1_output_loss: 0.2227 - val_y2_output_loss: 0.8304 - val_y1_output_root_mean_squared_error: 0.4719 - val_y2_output_root_mean_squared_error: 0.9113\n",
            "Epoch 355/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5197 - y1_output_loss: 0.1350 - y2_output_loss: 0.3847 - y1_output_root_mean_squared_error: 0.3674 - y2_output_root_mean_squared_error: 0.6202 - val_loss: 1.0863 - val_y1_output_loss: 0.2573 - val_y2_output_loss: 0.8290 - val_y1_output_root_mean_squared_error: 0.5072 - val_y2_output_root_mean_squared_error: 0.9105\n",
            "Epoch 356/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5721 - y1_output_loss: 0.1579 - y2_output_loss: 0.4142 - y1_output_root_mean_squared_error: 0.3974 - y2_output_root_mean_squared_error: 0.6436 - val_loss: 2.6081 - val_y1_output_loss: 0.3189 - val_y2_output_loss: 2.2892 - val_y1_output_root_mean_squared_error: 0.5647 - val_y2_output_root_mean_squared_error: 1.5130\n",
            "Epoch 357/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5224 - y1_output_loss: 0.1330 - y2_output_loss: 0.3894 - y1_output_root_mean_squared_error: 0.3648 - y2_output_root_mean_squared_error: 0.6240 - val_loss: 1.0576 - val_y1_output_loss: 0.2692 - val_y2_output_loss: 0.7883 - val_y1_output_root_mean_squared_error: 0.5189 - val_y2_output_root_mean_squared_error: 0.8879\n",
            "Epoch 358/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4771 - y1_output_loss: 0.1340 - y2_output_loss: 0.3431 - y1_output_root_mean_squared_error: 0.3660 - y2_output_root_mean_squared_error: 0.5858 - val_loss: 0.9852 - val_y1_output_loss: 0.2472 - val_y2_output_loss: 0.7380 - val_y1_output_root_mean_squared_error: 0.4972 - val_y2_output_root_mean_squared_error: 0.8590\n",
            "Epoch 359/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8297 - y1_output_loss: 0.1847 - y2_output_loss: 0.6449 - y1_output_root_mean_squared_error: 0.4298 - y2_output_root_mean_squared_error: 0.8031 - val_loss: 1.2082 - val_y1_output_loss: 0.3029 - val_y2_output_loss: 0.9053 - val_y1_output_root_mean_squared_error: 0.5504 - val_y2_output_root_mean_squared_error: 0.9515\n",
            "Epoch 360/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6012 - y1_output_loss: 0.1424 - y2_output_loss: 0.4588 - y1_output_root_mean_squared_error: 0.3773 - y2_output_root_mean_squared_error: 0.6773 - val_loss: 1.0908 - val_y1_output_loss: 0.2395 - val_y2_output_loss: 0.8513 - val_y1_output_root_mean_squared_error: 0.4894 - val_y2_output_root_mean_squared_error: 0.9226\n",
            "Epoch 361/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6270 - y1_output_loss: 0.1572 - y2_output_loss: 0.4699 - y1_output_root_mean_squared_error: 0.3964 - y2_output_root_mean_squared_error: 0.6855 - val_loss: 1.4292 - val_y1_output_loss: 0.3660 - val_y2_output_loss: 1.0632 - val_y1_output_root_mean_squared_error: 0.6050 - val_y2_output_root_mean_squared_error: 1.0311\n",
            "Epoch 362/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6722 - y1_output_loss: 0.1692 - y2_output_loss: 0.5030 - y1_output_root_mean_squared_error: 0.4113 - y2_output_root_mean_squared_error: 0.7092 - val_loss: 1.0702 - val_y1_output_loss: 0.2823 - val_y2_output_loss: 0.7879 - val_y1_output_root_mean_squared_error: 0.5313 - val_y2_output_root_mean_squared_error: 0.8876\n",
            "Epoch 363/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5536 - y1_output_loss: 0.1361 - y2_output_loss: 0.4175 - y1_output_root_mean_squared_error: 0.3690 - y2_output_root_mean_squared_error: 0.6461 - val_loss: 1.0057 - val_y1_output_loss: 0.2439 - val_y2_output_loss: 0.7618 - val_y1_output_root_mean_squared_error: 0.4939 - val_y2_output_root_mean_squared_error: 0.8728\n",
            "Epoch 364/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5585 - y1_output_loss: 0.1242 - y2_output_loss: 0.4343 - y1_output_root_mean_squared_error: 0.3525 - y2_output_root_mean_squared_error: 0.6590 - val_loss: 1.1687 - val_y1_output_loss: 0.3149 - val_y2_output_loss: 0.8538 - val_y1_output_root_mean_squared_error: 0.5612 - val_y2_output_root_mean_squared_error: 0.9240\n",
            "Epoch 365/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6128 - y1_output_loss: 0.1600 - y2_output_loss: 0.4528 - y1_output_root_mean_squared_error: 0.3999 - y2_output_root_mean_squared_error: 0.6729 - val_loss: 1.0278 - val_y1_output_loss: 0.2457 - val_y2_output_loss: 0.7821 - val_y1_output_root_mean_squared_error: 0.4956 - val_y2_output_root_mean_squared_error: 0.8844\n",
            "Epoch 366/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4860 - y1_output_loss: 0.1385 - y2_output_loss: 0.3475 - y1_output_root_mean_squared_error: 0.3722 - y2_output_root_mean_squared_error: 0.5895 - val_loss: 1.1301 - val_y1_output_loss: 0.2456 - val_y2_output_loss: 0.8845 - val_y1_output_root_mean_squared_error: 0.4956 - val_y2_output_root_mean_squared_error: 0.9405\n",
            "Epoch 367/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4444 - y1_output_loss: 0.1202 - y2_output_loss: 0.3242 - y1_output_root_mean_squared_error: 0.3467 - y2_output_root_mean_squared_error: 0.5694 - val_loss: 2.1991 - val_y1_output_loss: 0.2896 - val_y2_output_loss: 1.9094 - val_y1_output_root_mean_squared_error: 0.5382 - val_y2_output_root_mean_squared_error: 1.3818\n",
            "Epoch 368/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6193 - y1_output_loss: 0.1441 - y2_output_loss: 0.4752 - y1_output_root_mean_squared_error: 0.3796 - y2_output_root_mean_squared_error: 0.6893 - val_loss: 1.1024 - val_y1_output_loss: 0.3040 - val_y2_output_loss: 0.7984 - val_y1_output_root_mean_squared_error: 0.5513 - val_y2_output_root_mean_squared_error: 0.8935\n",
            "Epoch 369/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5428 - y1_output_loss: 0.1341 - y2_output_loss: 0.4088 - y1_output_root_mean_squared_error: 0.3661 - y2_output_root_mean_squared_error: 0.6394 - val_loss: 1.2305 - val_y1_output_loss: 0.3796 - val_y2_output_loss: 0.8508 - val_y1_output_root_mean_squared_error: 0.6161 - val_y2_output_root_mean_squared_error: 0.9224\n",
            "Epoch 370/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5185 - y1_output_loss: 0.1314 - y2_output_loss: 0.3871 - y1_output_root_mean_squared_error: 0.3625 - y2_output_root_mean_squared_error: 0.6221 - val_loss: 1.0395 - val_y1_output_loss: 0.2275 - val_y2_output_loss: 0.8120 - val_y1_output_root_mean_squared_error: 0.4770 - val_y2_output_root_mean_squared_error: 0.9011\n",
            "Epoch 371/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4404 - y1_output_loss: 0.1151 - y2_output_loss: 0.3253 - y1_output_root_mean_squared_error: 0.3393 - y2_output_root_mean_squared_error: 0.5704 - val_loss: 1.4036 - val_y1_output_loss: 0.3886 - val_y2_output_loss: 1.0150 - val_y1_output_root_mean_squared_error: 0.6234 - val_y2_output_root_mean_squared_error: 1.0075\n",
            "Epoch 372/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5496 - y1_output_loss: 0.1387 - y2_output_loss: 0.4110 - y1_output_root_mean_squared_error: 0.3724 - y2_output_root_mean_squared_error: 0.6411 - val_loss: 1.3268 - val_y1_output_loss: 0.4239 - val_y2_output_loss: 0.9029 - val_y1_output_root_mean_squared_error: 0.6511 - val_y2_output_root_mean_squared_error: 0.9502\n",
            "Epoch 373/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4456 - y1_output_loss: 0.1171 - y2_output_loss: 0.3285 - y1_output_root_mean_squared_error: 0.3422 - y2_output_root_mean_squared_error: 0.5732 - val_loss: 1.5858 - val_y1_output_loss: 0.6867 - val_y2_output_loss: 0.8990 - val_y1_output_root_mean_squared_error: 0.8287 - val_y2_output_root_mean_squared_error: 0.9482\n",
            "Epoch 374/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4838 - y1_output_loss: 0.1290 - y2_output_loss: 0.3548 - y1_output_root_mean_squared_error: 0.3592 - y2_output_root_mean_squared_error: 0.5956 - val_loss: 0.9815 - val_y1_output_loss: 0.2625 - val_y2_output_loss: 0.7190 - val_y1_output_root_mean_squared_error: 0.5123 - val_y2_output_root_mean_squared_error: 0.8479\n",
            "Epoch 375/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6440 - y1_output_loss: 0.1462 - y2_output_loss: 0.4978 - y1_output_root_mean_squared_error: 0.3824 - y2_output_root_mean_squared_error: 0.7055 - val_loss: 1.1397 - val_y1_output_loss: 0.3157 - val_y2_output_loss: 0.8240 - val_y1_output_root_mean_squared_error: 0.5619 - val_y2_output_root_mean_squared_error: 0.9077\n",
            "Epoch 376/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4129 - y1_output_loss: 0.1201 - y2_output_loss: 0.2928 - y1_output_root_mean_squared_error: 0.3465 - y2_output_root_mean_squared_error: 0.5411 - val_loss: 1.1410 - val_y1_output_loss: 0.2516 - val_y2_output_loss: 0.8894 - val_y1_output_root_mean_squared_error: 0.5016 - val_y2_output_root_mean_squared_error: 0.9431\n",
            "Epoch 377/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5516 - y1_output_loss: 0.1409 - y2_output_loss: 0.4107 - y1_output_root_mean_squared_error: 0.3754 - y2_output_root_mean_squared_error: 0.6409 - val_loss: 1.3665 - val_y1_output_loss: 0.2951 - val_y2_output_loss: 1.0715 - val_y1_output_root_mean_squared_error: 0.5432 - val_y2_output_root_mean_squared_error: 1.0351\n",
            "Epoch 378/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5506 - y1_output_loss: 0.1381 - y2_output_loss: 0.4125 - y1_output_root_mean_squared_error: 0.3716 - y2_output_root_mean_squared_error: 0.6422 - val_loss: 1.1010 - val_y1_output_loss: 0.2821 - val_y2_output_loss: 0.8189 - val_y1_output_root_mean_squared_error: 0.5312 - val_y2_output_root_mean_squared_error: 0.9049\n",
            "Epoch 379/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.7353 - y1_output_loss: 0.1856 - y2_output_loss: 0.5498 - y1_output_root_mean_squared_error: 0.4308 - y2_output_root_mean_squared_error: 0.7415 - val_loss: 0.9784 - val_y1_output_loss: 0.2551 - val_y2_output_loss: 0.7234 - val_y1_output_root_mean_squared_error: 0.5051 - val_y2_output_root_mean_squared_error: 0.8505\n",
            "Epoch 380/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6281 - y1_output_loss: 0.1542 - y2_output_loss: 0.4738 - y1_output_root_mean_squared_error: 0.3927 - y2_output_root_mean_squared_error: 0.6884 - val_loss: 1.2365 - val_y1_output_loss: 0.4895 - val_y2_output_loss: 0.7471 - val_y1_output_root_mean_squared_error: 0.6996 - val_y2_output_root_mean_squared_error: 0.8643\n",
            "Epoch 381/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4950 - y1_output_loss: 0.1309 - y2_output_loss: 0.3641 - y1_output_root_mean_squared_error: 0.3618 - y2_output_root_mean_squared_error: 0.6034 - val_loss: 1.2250 - val_y1_output_loss: 0.3508 - val_y2_output_loss: 0.8742 - val_y1_output_root_mean_squared_error: 0.5923 - val_y2_output_root_mean_squared_error: 0.9350\n",
            "Epoch 382/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5076 - y1_output_loss: 0.1378 - y2_output_loss: 0.3698 - y1_output_root_mean_squared_error: 0.3712 - y2_output_root_mean_squared_error: 0.6081 - val_loss: 1.2284 - val_y1_output_loss: 0.2346 - val_y2_output_loss: 0.9937 - val_y1_output_root_mean_squared_error: 0.4844 - val_y2_output_root_mean_squared_error: 0.9969\n",
            "Epoch 383/500\n",
            "62/62 [==============================] - 0s 4ms/step - loss: 0.4861 - y1_output_loss: 0.1238 - y2_output_loss: 0.3623 - y1_output_root_mean_squared_error: 0.3518 - y2_output_root_mean_squared_error: 0.6019 - val_loss: 1.6227 - val_y1_output_loss: 0.5402 - val_y2_output_loss: 1.0825 - val_y1_output_root_mean_squared_error: 0.7350 - val_y2_output_root_mean_squared_error: 1.0404\n",
            "Epoch 384/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8381 - y1_output_loss: 0.2100 - y2_output_loss: 0.6282 - y1_output_root_mean_squared_error: 0.4582 - y2_output_root_mean_squared_error: 0.7926 - val_loss: 1.1700 - val_y1_output_loss: 0.2391 - val_y2_output_loss: 0.9309 - val_y1_output_root_mean_squared_error: 0.4889 - val_y2_output_root_mean_squared_error: 0.9649\n",
            "Epoch 385/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4271 - y1_output_loss: 0.1163 - y2_output_loss: 0.3108 - y1_output_root_mean_squared_error: 0.3411 - y2_output_root_mean_squared_error: 0.5575 - val_loss: 1.0227 - val_y1_output_loss: 0.2489 - val_y2_output_loss: 0.7739 - val_y1_output_root_mean_squared_error: 0.4989 - val_y2_output_root_mean_squared_error: 0.8797\n",
            "Epoch 386/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5438 - y1_output_loss: 0.1224 - y2_output_loss: 0.4214 - y1_output_root_mean_squared_error: 0.3499 - y2_output_root_mean_squared_error: 0.6492 - val_loss: 1.0027 - val_y1_output_loss: 0.2288 - val_y2_output_loss: 0.7739 - val_y1_output_root_mean_squared_error: 0.4783 - val_y2_output_root_mean_squared_error: 0.8797\n",
            "Epoch 387/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5818 - y1_output_loss: 0.1480 - y2_output_loss: 0.4339 - y1_output_root_mean_squared_error: 0.3847 - y2_output_root_mean_squared_error: 0.6587 - val_loss: 1.0718 - val_y1_output_loss: 0.2618 - val_y2_output_loss: 0.8100 - val_y1_output_root_mean_squared_error: 0.5117 - val_y2_output_root_mean_squared_error: 0.9000\n",
            "Epoch 388/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5049 - y1_output_loss: 0.1391 - y2_output_loss: 0.3658 - y1_output_root_mean_squared_error: 0.3730 - y2_output_root_mean_squared_error: 0.6048 - val_loss: 1.8535 - val_y1_output_loss: 0.6249 - val_y2_output_loss: 1.2286 - val_y1_output_root_mean_squared_error: 0.7905 - val_y2_output_root_mean_squared_error: 1.1084\n",
            "Epoch 389/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5287 - y1_output_loss: 0.1369 - y2_output_loss: 0.3918 - y1_output_root_mean_squared_error: 0.3700 - y2_output_root_mean_squared_error: 0.6259 - val_loss: 0.9785 - val_y1_output_loss: 0.2435 - val_y2_output_loss: 0.7350 - val_y1_output_root_mean_squared_error: 0.4934 - val_y2_output_root_mean_squared_error: 0.8573\n",
            "Epoch 390/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5888 - y1_output_loss: 0.1381 - y2_output_loss: 0.4507 - y1_output_root_mean_squared_error: 0.3716 - y2_output_root_mean_squared_error: 0.6713 - val_loss: 1.6802 - val_y1_output_loss: 0.3602 - val_y2_output_loss: 1.3200 - val_y1_output_root_mean_squared_error: 0.6002 - val_y2_output_root_mean_squared_error: 1.1489\n",
            "Epoch 391/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6147 - y1_output_loss: 0.1627 - y2_output_loss: 0.4520 - y1_output_root_mean_squared_error: 0.4033 - y2_output_root_mean_squared_error: 0.6723 - val_loss: 1.2518 - val_y1_output_loss: 0.2676 - val_y2_output_loss: 0.9843 - val_y1_output_root_mean_squared_error: 0.5173 - val_y2_output_root_mean_squared_error: 0.9921\n",
            "Epoch 392/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5400 - y1_output_loss: 0.1291 - y2_output_loss: 0.4109 - y1_output_root_mean_squared_error: 0.3594 - y2_output_root_mean_squared_error: 0.6410 - val_loss: 1.5703 - val_y1_output_loss: 0.4993 - val_y2_output_loss: 1.0710 - val_y1_output_root_mean_squared_error: 0.7066 - val_y2_output_root_mean_squared_error: 1.0349\n",
            "Epoch 393/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8090 - y1_output_loss: 0.2136 - y2_output_loss: 0.5954 - y1_output_root_mean_squared_error: 0.4622 - y2_output_root_mean_squared_error: 0.7716 - val_loss: 0.9282 - val_y1_output_loss: 0.2666 - val_y2_output_loss: 0.6615 - val_y1_output_root_mean_squared_error: 0.5164 - val_y2_output_root_mean_squared_error: 0.8133\n",
            "Epoch 394/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4164 - y1_output_loss: 0.1204 - y2_output_loss: 0.2960 - y1_output_root_mean_squared_error: 0.3470 - y2_output_root_mean_squared_error: 0.5440 - val_loss: 1.1937 - val_y1_output_loss: 0.3531 - val_y2_output_loss: 0.8405 - val_y1_output_root_mean_squared_error: 0.5943 - val_y2_output_root_mean_squared_error: 0.9168\n",
            "Epoch 395/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4471 - y1_output_loss: 0.1186 - y2_output_loss: 0.3285 - y1_output_root_mean_squared_error: 0.3443 - y2_output_root_mean_squared_error: 0.5732 - val_loss: 0.9799 - val_y1_output_loss: 0.2314 - val_y2_output_loss: 0.7485 - val_y1_output_root_mean_squared_error: 0.4810 - val_y2_output_root_mean_squared_error: 0.8651\n",
            "Epoch 396/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4320 - y1_output_loss: 0.1186 - y2_output_loss: 0.3134 - y1_output_root_mean_squared_error: 0.3445 - y2_output_root_mean_squared_error: 0.5598 - val_loss: 1.3412 - val_y1_output_loss: 0.3064 - val_y2_output_loss: 1.0348 - val_y1_output_root_mean_squared_error: 0.5536 - val_y2_output_root_mean_squared_error: 1.0172\n",
            "Epoch 397/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4347 - y1_output_loss: 0.1113 - y2_output_loss: 0.3235 - y1_output_root_mean_squared_error: 0.3335 - y2_output_root_mean_squared_error: 0.5688 - val_loss: 1.1599 - val_y1_output_loss: 0.2552 - val_y2_output_loss: 0.9047 - val_y1_output_root_mean_squared_error: 0.5052 - val_y2_output_root_mean_squared_error: 0.9512\n",
            "Epoch 398/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6549 - y1_output_loss: 0.1687 - y2_output_loss: 0.4862 - y1_output_root_mean_squared_error: 0.4107 - y2_output_root_mean_squared_error: 0.6973 - val_loss: 1.1697 - val_y1_output_loss: 0.2874 - val_y2_output_loss: 0.8823 - val_y1_output_root_mean_squared_error: 0.5361 - val_y2_output_root_mean_squared_error: 0.9393\n",
            "Epoch 399/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4396 - y1_output_loss: 0.1264 - y2_output_loss: 0.3132 - y1_output_root_mean_squared_error: 0.3556 - y2_output_root_mean_squared_error: 0.5596 - val_loss: 1.7478 - val_y1_output_loss: 0.4306 - val_y2_output_loss: 1.3171 - val_y1_output_root_mean_squared_error: 0.6562 - val_y2_output_root_mean_squared_error: 1.1477\n",
            "Epoch 400/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6187 - y1_output_loss: 0.1637 - y2_output_loss: 0.4549 - y1_output_root_mean_squared_error: 0.4046 - y2_output_root_mean_squared_error: 0.6745 - val_loss: 6.5962 - val_y1_output_loss: 1.8624 - val_y2_output_loss: 4.7339 - val_y1_output_root_mean_squared_error: 1.3647 - val_y2_output_root_mean_squared_error: 2.1757\n",
            "Epoch 401/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6412 - y1_output_loss: 0.1365 - y2_output_loss: 0.5048 - y1_output_root_mean_squared_error: 0.3694 - y2_output_root_mean_squared_error: 0.7105 - val_loss: 0.8451 - val_y1_output_loss: 0.2294 - val_y2_output_loss: 0.6157 - val_y1_output_root_mean_squared_error: 0.4790 - val_y2_output_root_mean_squared_error: 0.7846\n",
            "Epoch 402/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6863 - y1_output_loss: 0.1728 - y2_output_loss: 0.5135 - y1_output_root_mean_squared_error: 0.4157 - y2_output_root_mean_squared_error: 0.7166 - val_loss: 1.2802 - val_y1_output_loss: 0.4292 - val_y2_output_loss: 0.8510 - val_y1_output_root_mean_squared_error: 0.6551 - val_y2_output_root_mean_squared_error: 0.9225\n",
            "Epoch 403/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3922 - y1_output_loss: 0.1275 - y2_output_loss: 0.2647 - y1_output_root_mean_squared_error: 0.3571 - y2_output_root_mean_squared_error: 0.5145 - val_loss: 1.5639 - val_y1_output_loss: 0.5326 - val_y2_output_loss: 1.0314 - val_y1_output_root_mean_squared_error: 0.7298 - val_y2_output_root_mean_squared_error: 1.0156\n",
            "Epoch 404/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4528 - y1_output_loss: 0.1132 - y2_output_loss: 0.3396 - y1_output_root_mean_squared_error: 0.3365 - y2_output_root_mean_squared_error: 0.5827 - val_loss: 1.0674 - val_y1_output_loss: 0.2829 - val_y2_output_loss: 0.7845 - val_y1_output_root_mean_squared_error: 0.5318 - val_y2_output_root_mean_squared_error: 0.8857\n",
            "Epoch 405/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4951 - y1_output_loss: 0.1494 - y2_output_loss: 0.3457 - y1_output_root_mean_squared_error: 0.3865 - y2_output_root_mean_squared_error: 0.5879 - val_loss: 1.1750 - val_y1_output_loss: 0.2840 - val_y2_output_loss: 0.8910 - val_y1_output_root_mean_squared_error: 0.5329 - val_y2_output_root_mean_squared_error: 0.9439\n",
            "Epoch 406/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5539 - y1_output_loss: 0.1639 - y2_output_loss: 0.3900 - y1_output_root_mean_squared_error: 0.4049 - y2_output_root_mean_squared_error: 0.6245 - val_loss: 1.5158 - val_y1_output_loss: 0.4329 - val_y2_output_loss: 1.0829 - val_y1_output_root_mean_squared_error: 0.6579 - val_y2_output_root_mean_squared_error: 1.0406\n",
            "Epoch 407/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4924 - y1_output_loss: 0.1373 - y2_output_loss: 0.3550 - y1_output_root_mean_squared_error: 0.3706 - y2_output_root_mean_squared_error: 0.5958 - val_loss: 0.9827 - val_y1_output_loss: 0.2892 - val_y2_output_loss: 0.6935 - val_y1_output_root_mean_squared_error: 0.5378 - val_y2_output_root_mean_squared_error: 0.8328\n",
            "Epoch 408/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5839 - y1_output_loss: 0.1634 - y2_output_loss: 0.4204 - y1_output_root_mean_squared_error: 0.4043 - y2_output_root_mean_squared_error: 0.6484 - val_loss: 1.1715 - val_y1_output_loss: 0.2800 - val_y2_output_loss: 0.8915 - val_y1_output_root_mean_squared_error: 0.5292 - val_y2_output_root_mean_squared_error: 0.9442\n",
            "Epoch 409/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5227 - y1_output_loss: 0.1348 - y2_output_loss: 0.3880 - y1_output_root_mean_squared_error: 0.3671 - y2_output_root_mean_squared_error: 0.6229 - val_loss: 1.4112 - val_y1_output_loss: 0.3900 - val_y2_output_loss: 1.0212 - val_y1_output_root_mean_squared_error: 0.6245 - val_y2_output_root_mean_squared_error: 1.0105\n",
            "Epoch 410/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4667 - y1_output_loss: 0.1101 - y2_output_loss: 0.3565 - y1_output_root_mean_squared_error: 0.3319 - y2_output_root_mean_squared_error: 0.5971 - val_loss: 0.9976 - val_y1_output_loss: 0.2443 - val_y2_output_loss: 0.7533 - val_y1_output_root_mean_squared_error: 0.4942 - val_y2_output_root_mean_squared_error: 0.8679\n",
            "Epoch 411/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5074 - y1_output_loss: 0.1463 - y2_output_loss: 0.3610 - y1_output_root_mean_squared_error: 0.3825 - y2_output_root_mean_squared_error: 0.6009 - val_loss: 1.3387 - val_y1_output_loss: 0.2789 - val_y2_output_loss: 1.0598 - val_y1_output_root_mean_squared_error: 0.5282 - val_y2_output_root_mean_squared_error: 1.0295\n",
            "Epoch 412/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5079 - y1_output_loss: 0.1327 - y2_output_loss: 0.3752 - y1_output_root_mean_squared_error: 0.3643 - y2_output_root_mean_squared_error: 0.6125 - val_loss: 5.0076 - val_y1_output_loss: 0.7135 - val_y2_output_loss: 4.2941 - val_y1_output_root_mean_squared_error: 0.8447 - val_y2_output_root_mean_squared_error: 2.0722\n",
            "Epoch 413/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5392 - y1_output_loss: 0.1246 - y2_output_loss: 0.4146 - y1_output_root_mean_squared_error: 0.3530 - y2_output_root_mean_squared_error: 0.6439 - val_loss: 3.7256 - val_y1_output_loss: 1.6184 - val_y2_output_loss: 2.1071 - val_y1_output_root_mean_squared_error: 1.2722 - val_y2_output_root_mean_squared_error: 1.4516\n",
            "Epoch 414/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5928 - y1_output_loss: 0.1545 - y2_output_loss: 0.4383 - y1_output_root_mean_squared_error: 0.3931 - y2_output_root_mean_squared_error: 0.6620 - val_loss: 0.9001 - val_y1_output_loss: 0.2518 - val_y2_output_loss: 0.6483 - val_y1_output_root_mean_squared_error: 0.5018 - val_y2_output_root_mean_squared_error: 0.8052\n",
            "Epoch 415/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5265 - y1_output_loss: 0.1430 - y2_output_loss: 0.3835 - y1_output_root_mean_squared_error: 0.3782 - y2_output_root_mean_squared_error: 0.6193 - val_loss: 0.9667 - val_y1_output_loss: 0.2430 - val_y2_output_loss: 0.7237 - val_y1_output_root_mean_squared_error: 0.4930 - val_y2_output_root_mean_squared_error: 0.8507\n",
            "Epoch 416/500\n",
            "62/62 [==============================] - 0s 4ms/step - loss: 0.4673 - y1_output_loss: 0.1234 - y2_output_loss: 0.3439 - y1_output_root_mean_squared_error: 0.3512 - y2_output_root_mean_squared_error: 0.5865 - val_loss: 1.0254 - val_y1_output_loss: 0.2738 - val_y2_output_loss: 0.7515 - val_y1_output_root_mean_squared_error: 0.5233 - val_y2_output_root_mean_squared_error: 0.8669\n",
            "Epoch 417/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3928 - y1_output_loss: 0.1202 - y2_output_loss: 0.2726 - y1_output_root_mean_squared_error: 0.3468 - y2_output_root_mean_squared_error: 0.5221 - val_loss: 2.1788 - val_y1_output_loss: 0.6160 - val_y2_output_loss: 1.5627 - val_y1_output_root_mean_squared_error: 0.7849 - val_y2_output_root_mean_squared_error: 1.2501\n",
            "Epoch 418/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5693 - y1_output_loss: 0.1561 - y2_output_loss: 0.4131 - y1_output_root_mean_squared_error: 0.3952 - y2_output_root_mean_squared_error: 0.6428 - val_loss: 0.8981 - val_y1_output_loss: 0.2495 - val_y2_output_loss: 0.6487 - val_y1_output_root_mean_squared_error: 0.4995 - val_y2_output_root_mean_squared_error: 0.8054\n",
            "Epoch 419/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4121 - y1_output_loss: 0.1440 - y2_output_loss: 0.2681 - y1_output_root_mean_squared_error: 0.3795 - y2_output_root_mean_squared_error: 0.5178 - val_loss: 0.9336 - val_y1_output_loss: 0.2332 - val_y2_output_loss: 0.7003 - val_y1_output_root_mean_squared_error: 0.4830 - val_y2_output_root_mean_squared_error: 0.8368\n",
            "Epoch 420/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4076 - y1_output_loss: 0.1145 - y2_output_loss: 0.2931 - y1_output_root_mean_squared_error: 0.3384 - y2_output_root_mean_squared_error: 0.5413 - val_loss: 0.8782 - val_y1_output_loss: 0.2257 - val_y2_output_loss: 0.6525 - val_y1_output_root_mean_squared_error: 0.4751 - val_y2_output_root_mean_squared_error: 0.8078\n",
            "Epoch 421/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4067 - y1_output_loss: 0.1282 - y2_output_loss: 0.2784 - y1_output_root_mean_squared_error: 0.3581 - y2_output_root_mean_squared_error: 0.5277 - val_loss: 1.0407 - val_y1_output_loss: 0.2982 - val_y2_output_loss: 0.7425 - val_y1_output_root_mean_squared_error: 0.5461 - val_y2_output_root_mean_squared_error: 0.8617\n",
            "Epoch 422/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4638 - y1_output_loss: 0.1186 - y2_output_loss: 0.3452 - y1_output_root_mean_squared_error: 0.3444 - y2_output_root_mean_squared_error: 0.5875 - val_loss: 0.8844 - val_y1_output_loss: 0.2349 - val_y2_output_loss: 0.6495 - val_y1_output_root_mean_squared_error: 0.4846 - val_y2_output_root_mean_squared_error: 0.8059\n",
            "Epoch 423/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4418 - y1_output_loss: 0.1236 - y2_output_loss: 0.3181 - y1_output_root_mean_squared_error: 0.3516 - y2_output_root_mean_squared_error: 0.5640 - val_loss: 0.8356 - val_y1_output_loss: 0.2398 - val_y2_output_loss: 0.5958 - val_y1_output_root_mean_squared_error: 0.4897 - val_y2_output_root_mean_squared_error: 0.7719\n",
            "Epoch 424/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4129 - y1_output_loss: 0.1114 - y2_output_loss: 0.3015 - y1_output_root_mean_squared_error: 0.3338 - y2_output_root_mean_squared_error: 0.5491 - val_loss: 0.9939 - val_y1_output_loss: 0.2585 - val_y2_output_loss: 0.7354 - val_y1_output_root_mean_squared_error: 0.5084 - val_y2_output_root_mean_squared_error: 0.8576\n",
            "Epoch 425/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4662 - y1_output_loss: 0.1185 - y2_output_loss: 0.3477 - y1_output_root_mean_squared_error: 0.3443 - y2_output_root_mean_squared_error: 0.5897 - val_loss: 0.9299 - val_y1_output_loss: 0.2277 - val_y2_output_loss: 0.7022 - val_y1_output_root_mean_squared_error: 0.4772 - val_y2_output_root_mean_squared_error: 0.8380\n",
            "Epoch 426/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5880 - y1_output_loss: 0.1632 - y2_output_loss: 0.4248 - y1_output_root_mean_squared_error: 0.4040 - y2_output_root_mean_squared_error: 0.6517 - val_loss: 1.5914 - val_y1_output_loss: 0.2345 - val_y2_output_loss: 1.3569 - val_y1_output_root_mean_squared_error: 0.4843 - val_y2_output_root_mean_squared_error: 1.1648\n",
            "Epoch 427/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4028 - y1_output_loss: 0.1193 - y2_output_loss: 0.2835 - y1_output_root_mean_squared_error: 0.3453 - y2_output_root_mean_squared_error: 0.5325 - val_loss: 0.8772 - val_y1_output_loss: 0.2193 - val_y2_output_loss: 0.6579 - val_y1_output_root_mean_squared_error: 0.4683 - val_y2_output_root_mean_squared_error: 0.8111\n",
            "Epoch 428/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4409 - y1_output_loss: 0.1286 - y2_output_loss: 0.3123 - y1_output_root_mean_squared_error: 0.3585 - y2_output_root_mean_squared_error: 0.5588 - val_loss: 2.1383 - val_y1_output_loss: 0.8206 - val_y2_output_loss: 1.3178 - val_y1_output_root_mean_squared_error: 0.9058 - val_y2_output_root_mean_squared_error: 1.1479\n",
            "Epoch 429/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4681 - y1_output_loss: 0.1267 - y2_output_loss: 0.3414 - y1_output_root_mean_squared_error: 0.3559 - y2_output_root_mean_squared_error: 0.5843 - val_loss: 1.5378 - val_y1_output_loss: 0.2646 - val_y2_output_loss: 1.2732 - val_y1_output_root_mean_squared_error: 0.5144 - val_y2_output_root_mean_squared_error: 1.1284\n",
            "Epoch 430/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5244 - y1_output_loss: 0.1306 - y2_output_loss: 0.3938 - y1_output_root_mean_squared_error: 0.3613 - y2_output_root_mean_squared_error: 0.6276 - val_loss: 1.7705 - val_y1_output_loss: 0.3475 - val_y2_output_loss: 1.4230 - val_y1_output_root_mean_squared_error: 0.5895 - val_y2_output_root_mean_squared_error: 1.1929\n",
            "Epoch 431/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4916 - y1_output_loss: 0.1403 - y2_output_loss: 0.3513 - y1_output_root_mean_squared_error: 0.3745 - y2_output_root_mean_squared_error: 0.5927 - val_loss: 0.9152 - val_y1_output_loss: 0.2213 - val_y2_output_loss: 0.6939 - val_y1_output_root_mean_squared_error: 0.4704 - val_y2_output_root_mean_squared_error: 0.8330\n",
            "Epoch 432/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3496 - y1_output_loss: 0.1063 - y2_output_loss: 0.2433 - y1_output_root_mean_squared_error: 0.3260 - y2_output_root_mean_squared_error: 0.4933 - val_loss: 1.0165 - val_y1_output_loss: 0.2418 - val_y2_output_loss: 0.7747 - val_y1_output_root_mean_squared_error: 0.4917 - val_y2_output_root_mean_squared_error: 0.8802\n",
            "Epoch 433/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4677 - y1_output_loss: 0.1344 - y2_output_loss: 0.3332 - y1_output_root_mean_squared_error: 0.3667 - y2_output_root_mean_squared_error: 0.5773 - val_loss: 1.2615 - val_y1_output_loss: 0.2267 - val_y2_output_loss: 1.0347 - val_y1_output_root_mean_squared_error: 0.4762 - val_y2_output_root_mean_squared_error: 1.0172\n",
            "Epoch 434/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4370 - y1_output_loss: 0.1266 - y2_output_loss: 0.3104 - y1_output_root_mean_squared_error: 0.3558 - y2_output_root_mean_squared_error: 0.5572 - val_loss: 1.5666 - val_y1_output_loss: 0.5292 - val_y2_output_loss: 1.0375 - val_y1_output_root_mean_squared_error: 0.7274 - val_y2_output_root_mean_squared_error: 1.0186\n",
            "Epoch 435/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4815 - y1_output_loss: 0.1505 - y2_output_loss: 0.3310 - y1_output_root_mean_squared_error: 0.3879 - y2_output_root_mean_squared_error: 0.5753 - val_loss: 1.0622 - val_y1_output_loss: 0.2727 - val_y2_output_loss: 0.7896 - val_y1_output_root_mean_squared_error: 0.5222 - val_y2_output_root_mean_squared_error: 0.8886\n",
            "Epoch 436/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3995 - y1_output_loss: 0.1237 - y2_output_loss: 0.2758 - y1_output_root_mean_squared_error: 0.3517 - y2_output_root_mean_squared_error: 0.5252 - val_loss: 0.9446 - val_y1_output_loss: 0.2392 - val_y2_output_loss: 0.7054 - val_y1_output_root_mean_squared_error: 0.4890 - val_y2_output_root_mean_squared_error: 0.8399\n",
            "Epoch 437/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4949 - y1_output_loss: 0.1223 - y2_output_loss: 0.3726 - y1_output_root_mean_squared_error: 0.3497 - y2_output_root_mean_squared_error: 0.6104 - val_loss: 0.9246 - val_y1_output_loss: 0.2279 - val_y2_output_loss: 0.6966 - val_y1_output_root_mean_squared_error: 0.4774 - val_y2_output_root_mean_squared_error: 0.8346\n",
            "Epoch 438/500\n",
            "62/62 [==============================] - 0s 4ms/step - loss: 0.4294 - y1_output_loss: 0.1343 - y2_output_loss: 0.2951 - y1_output_root_mean_squared_error: 0.3665 - y2_output_root_mean_squared_error: 0.5432 - val_loss: 0.9246 - val_y1_output_loss: 0.2383 - val_y2_output_loss: 0.6863 - val_y1_output_root_mean_squared_error: 0.4882 - val_y2_output_root_mean_squared_error: 0.8284\n",
            "Epoch 439/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4103 - y1_output_loss: 0.1025 - y2_output_loss: 0.3078 - y1_output_root_mean_squared_error: 0.3202 - y2_output_root_mean_squared_error: 0.5548 - val_loss: 1.4567 - val_y1_output_loss: 0.2606 - val_y2_output_loss: 1.1961 - val_y1_output_root_mean_squared_error: 0.5105 - val_y2_output_root_mean_squared_error: 1.0937\n",
            "Epoch 440/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3695 - y1_output_loss: 0.1090 - y2_output_loss: 0.2604 - y1_output_root_mean_squared_error: 0.3302 - y2_output_root_mean_squared_error: 0.5103 - val_loss: 1.0344 - val_y1_output_loss: 0.2985 - val_y2_output_loss: 0.7359 - val_y1_output_root_mean_squared_error: 0.5464 - val_y2_output_root_mean_squared_error: 0.8578\n",
            "Epoch 441/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3455 - y1_output_loss: 0.1157 - y2_output_loss: 0.2298 - y1_output_root_mean_squared_error: 0.3402 - y2_output_root_mean_squared_error: 0.4793 - val_loss: 0.9456 - val_y1_output_loss: 0.2814 - val_y2_output_loss: 0.6642 - val_y1_output_root_mean_squared_error: 0.5305 - val_y2_output_root_mean_squared_error: 0.8150\n",
            "Epoch 442/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4165 - y1_output_loss: 0.1322 - y2_output_loss: 0.2842 - y1_output_root_mean_squared_error: 0.3636 - y2_output_root_mean_squared_error: 0.5331 - val_loss: 0.9219 - val_y1_output_loss: 0.2835 - val_y2_output_loss: 0.6384 - val_y1_output_root_mean_squared_error: 0.5324 - val_y2_output_root_mean_squared_error: 0.7990\n",
            "Epoch 443/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4216 - y1_output_loss: 0.1218 - y2_output_loss: 0.2998 - y1_output_root_mean_squared_error: 0.3490 - y2_output_root_mean_squared_error: 0.5475 - val_loss: 1.5452 - val_y1_output_loss: 0.2625 - val_y2_output_loss: 1.2827 - val_y1_output_root_mean_squared_error: 0.5123 - val_y2_output_root_mean_squared_error: 1.1326\n",
            "Epoch 444/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5630 - y1_output_loss: 0.1444 - y2_output_loss: 0.4186 - y1_output_root_mean_squared_error: 0.3800 - y2_output_root_mean_squared_error: 0.6470 - val_loss: 0.9049 - val_y1_output_loss: 0.2515 - val_y2_output_loss: 0.6534 - val_y1_output_root_mean_squared_error: 0.5015 - val_y2_output_root_mean_squared_error: 0.8083\n",
            "Epoch 445/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3814 - y1_output_loss: 0.1291 - y2_output_loss: 0.2523 - y1_output_root_mean_squared_error: 0.3593 - y2_output_root_mean_squared_error: 0.5023 - val_loss: 1.6013 - val_y1_output_loss: 0.2397 - val_y2_output_loss: 1.3615 - val_y1_output_root_mean_squared_error: 0.4896 - val_y2_output_root_mean_squared_error: 1.1669\n",
            "Epoch 446/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5057 - y1_output_loss: 0.1251 - y2_output_loss: 0.3806 - y1_output_root_mean_squared_error: 0.3537 - y2_output_root_mean_squared_error: 0.6170 - val_loss: 0.9944 - val_y1_output_loss: 0.2383 - val_y2_output_loss: 0.7561 - val_y1_output_root_mean_squared_error: 0.4881 - val_y2_output_root_mean_squared_error: 0.8696\n",
            "Epoch 447/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6685 - y1_output_loss: 0.1442 - y2_output_loss: 0.5243 - y1_output_root_mean_squared_error: 0.3797 - y2_output_root_mean_squared_error: 0.7241 - val_loss: 0.9653 - val_y1_output_loss: 0.3371 - val_y2_output_loss: 0.6282 - val_y1_output_root_mean_squared_error: 0.5806 - val_y2_output_root_mean_squared_error: 0.7926\n",
            "Epoch 448/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3869 - y1_output_loss: 0.1052 - y2_output_loss: 0.2817 - y1_output_root_mean_squared_error: 0.3243 - y2_output_root_mean_squared_error: 0.5307 - val_loss: 0.9731 - val_y1_output_loss: 0.2318 - val_y2_output_loss: 0.7413 - val_y1_output_root_mean_squared_error: 0.4814 - val_y2_output_root_mean_squared_error: 0.8610\n",
            "Epoch 449/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3375 - y1_output_loss: 0.1056 - y2_output_loss: 0.2319 - y1_output_root_mean_squared_error: 0.3249 - y2_output_root_mean_squared_error: 0.4815 - val_loss: 0.9728 - val_y1_output_loss: 0.2589 - val_y2_output_loss: 0.7139 - val_y1_output_root_mean_squared_error: 0.5088 - val_y2_output_root_mean_squared_error: 0.8449\n",
            "Epoch 450/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6317 - y1_output_loss: 0.1842 - y2_output_loss: 0.4476 - y1_output_root_mean_squared_error: 0.4291 - y2_output_root_mean_squared_error: 0.6690 - val_loss: 1.2455 - val_y1_output_loss: 0.2057 - val_y2_output_loss: 1.0398 - val_y1_output_root_mean_squared_error: 0.4535 - val_y2_output_root_mean_squared_error: 1.0197\n",
            "Epoch 451/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4932 - y1_output_loss: 0.1270 - y2_output_loss: 0.3662 - y1_output_root_mean_squared_error: 0.3564 - y2_output_root_mean_squared_error: 0.6051 - val_loss: 1.4199 - val_y1_output_loss: 0.5045 - val_y2_output_loss: 0.9154 - val_y1_output_root_mean_squared_error: 0.7103 - val_y2_output_root_mean_squared_error: 0.9568\n",
            "Epoch 452/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4344 - y1_output_loss: 0.1379 - y2_output_loss: 0.2965 - y1_output_root_mean_squared_error: 0.3714 - y2_output_root_mean_squared_error: 0.5445 - val_loss: 2.2755 - val_y1_output_loss: 0.3522 - val_y2_output_loss: 1.9233 - val_y1_output_root_mean_squared_error: 0.5935 - val_y2_output_root_mean_squared_error: 1.3868\n",
            "Epoch 453/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4556 - y1_output_loss: 0.1178 - y2_output_loss: 0.3378 - y1_output_root_mean_squared_error: 0.3432 - y2_output_root_mean_squared_error: 0.5812 - val_loss: 2.2339 - val_y1_output_loss: 0.4507 - val_y2_output_loss: 1.7832 - val_y1_output_root_mean_squared_error: 0.6713 - val_y2_output_root_mean_squared_error: 1.3354\n",
            "Epoch 454/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4802 - y1_output_loss: 0.1364 - y2_output_loss: 0.3438 - y1_output_root_mean_squared_error: 0.3693 - y2_output_root_mean_squared_error: 0.5863 - val_loss: 1.8470 - val_y1_output_loss: 0.3549 - val_y2_output_loss: 1.4921 - val_y1_output_root_mean_squared_error: 0.5958 - val_y2_output_root_mean_squared_error: 1.2215\n",
            "Epoch 455/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5905 - y1_output_loss: 0.1911 - y2_output_loss: 0.3993 - y1_output_root_mean_squared_error: 0.4372 - y2_output_root_mean_squared_error: 0.6319 - val_loss: 1.3127 - val_y1_output_loss: 0.3570 - val_y2_output_loss: 0.9557 - val_y1_output_root_mean_squared_error: 0.5975 - val_y2_output_root_mean_squared_error: 0.9776\n",
            "Epoch 456/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3511 - y1_output_loss: 0.1132 - y2_output_loss: 0.2378 - y1_output_root_mean_squared_error: 0.3365 - y2_output_root_mean_squared_error: 0.4877 - val_loss: 0.9820 - val_y1_output_loss: 0.2331 - val_y2_output_loss: 0.7489 - val_y1_output_root_mean_squared_error: 0.4828 - val_y2_output_root_mean_squared_error: 0.8654\n",
            "Epoch 457/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4086 - y1_output_loss: 0.1071 - y2_output_loss: 0.3015 - y1_output_root_mean_squared_error: 0.3273 - y2_output_root_mean_squared_error: 0.5491 - val_loss: 0.9871 - val_y1_output_loss: 0.2664 - val_y2_output_loss: 0.7206 - val_y1_output_root_mean_squared_error: 0.5162 - val_y2_output_root_mean_squared_error: 0.8489\n",
            "Epoch 458/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4542 - y1_output_loss: 0.1374 - y2_output_loss: 0.3168 - y1_output_root_mean_squared_error: 0.3706 - y2_output_root_mean_squared_error: 0.5628 - val_loss: 1.4221 - val_y1_output_loss: 0.4785 - val_y2_output_loss: 0.9437 - val_y1_output_root_mean_squared_error: 0.6917 - val_y2_output_root_mean_squared_error: 0.9714\n",
            "Epoch 459/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3740 - y1_output_loss: 0.1124 - y2_output_loss: 0.2616 - y1_output_root_mean_squared_error: 0.3353 - y2_output_root_mean_squared_error: 0.5114 - val_loss: 0.9425 - val_y1_output_loss: 0.2261 - val_y2_output_loss: 0.7165 - val_y1_output_root_mean_squared_error: 0.4755 - val_y2_output_root_mean_squared_error: 0.8464\n",
            "Epoch 460/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4727 - y1_output_loss: 0.1220 - y2_output_loss: 0.3507 - y1_output_root_mean_squared_error: 0.3493 - y2_output_root_mean_squared_error: 0.5922 - val_loss: 0.9762 - val_y1_output_loss: 0.2319 - val_y2_output_loss: 0.7443 - val_y1_output_root_mean_squared_error: 0.4816 - val_y2_output_root_mean_squared_error: 0.8627\n",
            "Epoch 461/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4107 - y1_output_loss: 0.1263 - y2_output_loss: 0.2844 - y1_output_root_mean_squared_error: 0.3554 - y2_output_root_mean_squared_error: 0.5333 - val_loss: 1.3151 - val_y1_output_loss: 0.2571 - val_y2_output_loss: 1.0581 - val_y1_output_root_mean_squared_error: 0.5070 - val_y2_output_root_mean_squared_error: 1.0286\n",
            "Epoch 462/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3151 - y1_output_loss: 0.1071 - y2_output_loss: 0.2080 - y1_output_root_mean_squared_error: 0.3273 - y2_output_root_mean_squared_error: 0.4561 - val_loss: 1.4716 - val_y1_output_loss: 0.5389 - val_y2_output_loss: 0.9327 - val_y1_output_root_mean_squared_error: 0.7341 - val_y2_output_root_mean_squared_error: 0.9658\n",
            "Epoch 463/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.8123 - y1_output_loss: 0.2071 - y2_output_loss: 0.6052 - y1_output_root_mean_squared_error: 0.4551 - y2_output_root_mean_squared_error: 0.7779 - val_loss: 0.9246 - val_y1_output_loss: 0.2450 - val_y2_output_loss: 0.6796 - val_y1_output_root_mean_squared_error: 0.4950 - val_y2_output_root_mean_squared_error: 0.8244\n",
            "Epoch 464/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3686 - y1_output_loss: 0.0982 - y2_output_loss: 0.2704 - y1_output_root_mean_squared_error: 0.3134 - y2_output_root_mean_squared_error: 0.5200 - val_loss: 1.2981 - val_y1_output_loss: 0.3109 - val_y2_output_loss: 0.9873 - val_y1_output_root_mean_squared_error: 0.5575 - val_y2_output_root_mean_squared_error: 0.9936\n",
            "Epoch 465/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5021 - y1_output_loss: 0.1309 - y2_output_loss: 0.3712 - y1_output_root_mean_squared_error: 0.3618 - y2_output_root_mean_squared_error: 0.6093 - val_loss: 0.9178 - val_y1_output_loss: 0.2597 - val_y2_output_loss: 0.6581 - val_y1_output_root_mean_squared_error: 0.5096 - val_y2_output_root_mean_squared_error: 0.8112\n",
            "Epoch 466/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4511 - y1_output_loss: 0.1242 - y2_output_loss: 0.3269 - y1_output_root_mean_squared_error: 0.3524 - y2_output_root_mean_squared_error: 0.5718 - val_loss: 0.9986 - val_y1_output_loss: 0.2940 - val_y2_output_loss: 0.7046 - val_y1_output_root_mean_squared_error: 0.5423 - val_y2_output_root_mean_squared_error: 0.8394\n",
            "Epoch 467/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4145 - y1_output_loss: 0.1126 - y2_output_loss: 0.3018 - y1_output_root_mean_squared_error: 0.3356 - y2_output_root_mean_squared_error: 0.5494 - val_loss: 1.3552 - val_y1_output_loss: 0.4974 - val_y2_output_loss: 0.8578 - val_y1_output_root_mean_squared_error: 0.7053 - val_y2_output_root_mean_squared_error: 0.9262\n",
            "Epoch 468/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.6819 - y1_output_loss: 0.1573 - y2_output_loss: 0.5246 - y1_output_root_mean_squared_error: 0.3966 - y2_output_root_mean_squared_error: 0.7243 - val_loss: 0.9633 - val_y1_output_loss: 0.2890 - val_y2_output_loss: 0.6743 - val_y1_output_root_mean_squared_error: 0.5376 - val_y2_output_root_mean_squared_error: 0.8212\n",
            "Epoch 469/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3676 - y1_output_loss: 0.1048 - y2_output_loss: 0.2628 - y1_output_root_mean_squared_error: 0.3237 - y2_output_root_mean_squared_error: 0.5126 - val_loss: 1.3649 - val_y1_output_loss: 0.2958 - val_y2_output_loss: 1.0692 - val_y1_output_root_mean_squared_error: 0.5438 - val_y2_output_root_mean_squared_error: 1.0340\n",
            "Epoch 470/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5117 - y1_output_loss: 0.1280 - y2_output_loss: 0.3838 - y1_output_root_mean_squared_error: 0.3577 - y2_output_root_mean_squared_error: 0.6195 - val_loss: 0.8420 - val_y1_output_loss: 0.2235 - val_y2_output_loss: 0.6184 - val_y1_output_root_mean_squared_error: 0.4728 - val_y2_output_root_mean_squared_error: 0.7864\n",
            "Epoch 471/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3346 - y1_output_loss: 0.1096 - y2_output_loss: 0.2249 - y1_output_root_mean_squared_error: 0.3311 - y2_output_root_mean_squared_error: 0.4743 - val_loss: 1.0962 - val_y1_output_loss: 0.3672 - val_y2_output_loss: 0.7290 - val_y1_output_root_mean_squared_error: 0.6060 - val_y2_output_root_mean_squared_error: 0.8538\n",
            "Epoch 472/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4576 - y1_output_loss: 0.1358 - y2_output_loss: 0.3218 - y1_output_root_mean_squared_error: 0.3685 - y2_output_root_mean_squared_error: 0.5673 - val_loss: 1.1161 - val_y1_output_loss: 0.2727 - val_y2_output_loss: 0.8434 - val_y1_output_root_mean_squared_error: 0.5222 - val_y2_output_root_mean_squared_error: 0.9184\n",
            "Epoch 473/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4769 - y1_output_loss: 0.1170 - y2_output_loss: 0.3598 - y1_output_root_mean_squared_error: 0.3421 - y2_output_root_mean_squared_error: 0.5998 - val_loss: 0.8227 - val_y1_output_loss: 0.2346 - val_y2_output_loss: 0.5881 - val_y1_output_root_mean_squared_error: 0.4844 - val_y2_output_root_mean_squared_error: 0.7669\n",
            "Epoch 474/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4473 - y1_output_loss: 0.1364 - y2_output_loss: 0.3109 - y1_output_root_mean_squared_error: 0.3693 - y2_output_root_mean_squared_error: 0.5576 - val_loss: 1.8098 - val_y1_output_loss: 0.3346 - val_y2_output_loss: 1.4752 - val_y1_output_root_mean_squared_error: 0.5785 - val_y2_output_root_mean_squared_error: 1.2146\n",
            "Epoch 475/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4454 - y1_output_loss: 0.1245 - y2_output_loss: 0.3209 - y1_output_root_mean_squared_error: 0.3528 - y2_output_root_mean_squared_error: 0.5665 - val_loss: 1.2253 - val_y1_output_loss: 0.2684 - val_y2_output_loss: 0.9569 - val_y1_output_root_mean_squared_error: 0.5181 - val_y2_output_root_mean_squared_error: 0.9782\n",
            "Epoch 476/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4905 - y1_output_loss: 0.1516 - y2_output_loss: 0.3389 - y1_output_root_mean_squared_error: 0.3894 - y2_output_root_mean_squared_error: 0.5821 - val_loss: 2.9066 - val_y1_output_loss: 0.2627 - val_y2_output_loss: 2.6439 - val_y1_output_root_mean_squared_error: 0.5125 - val_y2_output_root_mean_squared_error: 1.6260\n",
            "Epoch 477/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4330 - y1_output_loss: 0.1261 - y2_output_loss: 0.3069 - y1_output_root_mean_squared_error: 0.3551 - y2_output_root_mean_squared_error: 0.5540 - val_loss: 0.9165 - val_y1_output_loss: 0.2358 - val_y2_output_loss: 0.6807 - val_y1_output_root_mean_squared_error: 0.4856 - val_y2_output_root_mean_squared_error: 0.8250\n",
            "Epoch 478/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3850 - y1_output_loss: 0.1064 - y2_output_loss: 0.2786 - y1_output_root_mean_squared_error: 0.3262 - y2_output_root_mean_squared_error: 0.5278 - val_loss: 0.8656 - val_y1_output_loss: 0.2533 - val_y2_output_loss: 0.6123 - val_y1_output_root_mean_squared_error: 0.5032 - val_y2_output_root_mean_squared_error: 0.7825\n",
            "Epoch 479/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3962 - y1_output_loss: 0.1109 - y2_output_loss: 0.2853 - y1_output_root_mean_squared_error: 0.3330 - y2_output_root_mean_squared_error: 0.5341 - val_loss: 1.3367 - val_y1_output_loss: 0.2696 - val_y2_output_loss: 1.0671 - val_y1_output_root_mean_squared_error: 0.5192 - val_y2_output_root_mean_squared_error: 1.0330\n",
            "Epoch 480/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3342 - y1_output_loss: 0.1010 - y2_output_loss: 0.2332 - y1_output_root_mean_squared_error: 0.3179 - y2_output_root_mean_squared_error: 0.4829 - val_loss: 0.9353 - val_y1_output_loss: 0.2745 - val_y2_output_loss: 0.6607 - val_y1_output_root_mean_squared_error: 0.5240 - val_y2_output_root_mean_squared_error: 0.8129\n",
            "Epoch 481/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3647 - y1_output_loss: 0.1083 - y2_output_loss: 0.2564 - y1_output_root_mean_squared_error: 0.3291 - y2_output_root_mean_squared_error: 0.5064 - val_loss: 1.3898 - val_y1_output_loss: 0.6357 - val_y2_output_loss: 0.7540 - val_y1_output_root_mean_squared_error: 0.7973 - val_y2_output_root_mean_squared_error: 0.8683\n",
            "Epoch 482/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3354 - y1_output_loss: 0.1012 - y2_output_loss: 0.2341 - y1_output_root_mean_squared_error: 0.3182 - y2_output_root_mean_squared_error: 0.4839 - val_loss: 0.8297 - val_y1_output_loss: 0.2364 - val_y2_output_loss: 0.5933 - val_y1_output_root_mean_squared_error: 0.4862 - val_y2_output_root_mean_squared_error: 0.7702\n",
            "Epoch 483/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.2991 - y1_output_loss: 0.0931 - y2_output_loss: 0.2060 - y1_output_root_mean_squared_error: 0.3051 - y2_output_root_mean_squared_error: 0.4539 - val_loss: 0.9852 - val_y1_output_loss: 0.2514 - val_y2_output_loss: 0.7338 - val_y1_output_root_mean_squared_error: 0.5014 - val_y2_output_root_mean_squared_error: 0.8566\n",
            "Epoch 484/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4683 - y1_output_loss: 0.1307 - y2_output_loss: 0.3376 - y1_output_root_mean_squared_error: 0.3615 - y2_output_root_mean_squared_error: 0.5810 - val_loss: 1.1127 - val_y1_output_loss: 0.2190 - val_y2_output_loss: 0.8937 - val_y1_output_root_mean_squared_error: 0.4680 - val_y2_output_root_mean_squared_error: 0.9454\n",
            "Epoch 485/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3763 - y1_output_loss: 0.1088 - y2_output_loss: 0.2675 - y1_output_root_mean_squared_error: 0.3298 - y2_output_root_mean_squared_error: 0.5172 - val_loss: 0.8441 - val_y1_output_loss: 0.2180 - val_y2_output_loss: 0.6262 - val_y1_output_root_mean_squared_error: 0.4669 - val_y2_output_root_mean_squared_error: 0.7913\n",
            "Epoch 486/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3179 - y1_output_loss: 0.1141 - y2_output_loss: 0.2038 - y1_output_root_mean_squared_error: 0.3377 - y2_output_root_mean_squared_error: 0.4515 - val_loss: 0.9979 - val_y1_output_loss: 0.2936 - val_y2_output_loss: 0.7043 - val_y1_output_root_mean_squared_error: 0.5419 - val_y2_output_root_mean_squared_error: 0.8392\n",
            "Epoch 487/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3394 - y1_output_loss: 0.1057 - y2_output_loss: 0.2338 - y1_output_root_mean_squared_error: 0.3251 - y2_output_root_mean_squared_error: 0.4835 - val_loss: 0.8445 - val_y1_output_loss: 0.2207 - val_y2_output_loss: 0.6237 - val_y1_output_root_mean_squared_error: 0.4698 - val_y2_output_root_mean_squared_error: 0.7898\n",
            "Epoch 488/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3536 - y1_output_loss: 0.1088 - y2_output_loss: 0.2448 - y1_output_root_mean_squared_error: 0.3298 - y2_output_root_mean_squared_error: 0.4948 - val_loss: 3.3784 - val_y1_output_loss: 0.5266 - val_y2_output_loss: 2.8518 - val_y1_output_root_mean_squared_error: 0.7257 - val_y2_output_root_mean_squared_error: 1.6887\n",
            "Epoch 489/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.5394 - y1_output_loss: 0.1665 - y2_output_loss: 0.3729 - y1_output_root_mean_squared_error: 0.4080 - y2_output_root_mean_squared_error: 0.6106 - val_loss: 0.9014 - val_y1_output_loss: 0.2475 - val_y2_output_loss: 0.6539 - val_y1_output_root_mean_squared_error: 0.4975 - val_y2_output_root_mean_squared_error: 0.8087\n",
            "Epoch 490/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3230 - y1_output_loss: 0.0930 - y2_output_loss: 0.2300 - y1_output_root_mean_squared_error: 0.3050 - y2_output_root_mean_squared_error: 0.4796 - val_loss: 3.9455 - val_y1_output_loss: 0.3434 - val_y2_output_loss: 3.6021 - val_y1_output_root_mean_squared_error: 0.5860 - val_y2_output_root_mean_squared_error: 1.8979\n",
            "Epoch 491/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4381 - y1_output_loss: 0.1301 - y2_output_loss: 0.3079 - y1_output_root_mean_squared_error: 0.3607 - y2_output_root_mean_squared_error: 0.5549 - val_loss: 2.0383 - val_y1_output_loss: 0.7078 - val_y2_output_loss: 1.3305 - val_y1_output_root_mean_squared_error: 0.8413 - val_y2_output_root_mean_squared_error: 1.1535\n",
            "Epoch 492/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4388 - y1_output_loss: 0.1342 - y2_output_loss: 0.3046 - y1_output_root_mean_squared_error: 0.3663 - y2_output_root_mean_squared_error: 0.5519 - val_loss: 0.8301 - val_y1_output_loss: 0.2349 - val_y2_output_loss: 0.5952 - val_y1_output_root_mean_squared_error: 0.4847 - val_y2_output_root_mean_squared_error: 0.7715\n",
            "Epoch 493/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3929 - y1_output_loss: 0.1121 - y2_output_loss: 0.2808 - y1_output_root_mean_squared_error: 0.3348 - y2_output_root_mean_squared_error: 0.5299 - val_loss: 0.9476 - val_y1_output_loss: 0.2535 - val_y2_output_loss: 0.6941 - val_y1_output_root_mean_squared_error: 0.5035 - val_y2_output_root_mean_squared_error: 0.8331\n",
            "Epoch 494/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3355 - y1_output_loss: 0.1117 - y2_output_loss: 0.2238 - y1_output_root_mean_squared_error: 0.3343 - y2_output_root_mean_squared_error: 0.4730 - val_loss: 1.0206 - val_y1_output_loss: 0.3545 - val_y2_output_loss: 0.6662 - val_y1_output_root_mean_squared_error: 0.5954 - val_y2_output_root_mean_squared_error: 0.8162\n",
            "Epoch 495/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4140 - y1_output_loss: 0.1118 - y2_output_loss: 0.3022 - y1_output_root_mean_squared_error: 0.3343 - y2_output_root_mean_squared_error: 0.5497 - val_loss: 1.0871 - val_y1_output_loss: 0.2350 - val_y2_output_loss: 0.8522 - val_y1_output_root_mean_squared_error: 0.4847 - val_y2_output_root_mean_squared_error: 0.9231\n",
            "Epoch 496/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3685 - y1_output_loss: 0.1151 - y2_output_loss: 0.2534 - y1_output_root_mean_squared_error: 0.3393 - y2_output_root_mean_squared_error: 0.5034 - val_loss: 0.8887 - val_y1_output_loss: 0.2268 - val_y2_output_loss: 0.6619 - val_y1_output_root_mean_squared_error: 0.4763 - val_y2_output_root_mean_squared_error: 0.8136\n",
            "Epoch 497/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4092 - y1_output_loss: 0.1120 - y2_output_loss: 0.2972 - y1_output_root_mean_squared_error: 0.3346 - y2_output_root_mean_squared_error: 0.5452 - val_loss: 1.0397 - val_y1_output_loss: 0.2922 - val_y2_output_loss: 0.7475 - val_y1_output_root_mean_squared_error: 0.5406 - val_y2_output_root_mean_squared_error: 0.8646\n",
            "Epoch 498/500\n",
            "62/62 [==============================] - 0s 4ms/step - loss: 0.3589 - y1_output_loss: 0.1248 - y2_output_loss: 0.2341 - y1_output_root_mean_squared_error: 0.3532 - y2_output_root_mean_squared_error: 0.4839 - val_loss: 1.5461 - val_y1_output_loss: 0.3385 - val_y2_output_loss: 1.2076 - val_y1_output_root_mean_squared_error: 0.5818 - val_y2_output_root_mean_squared_error: 1.0989\n",
            "Epoch 499/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.3624 - y1_output_loss: 0.1166 - y2_output_loss: 0.2459 - y1_output_root_mean_squared_error: 0.3414 - y2_output_root_mean_squared_error: 0.4959 - val_loss: 2.2769 - val_y1_output_loss: 0.4775 - val_y2_output_loss: 1.7995 - val_y1_output_root_mean_squared_error: 0.6910 - val_y2_output_root_mean_squared_error: 1.3414\n",
            "Epoch 500/500\n",
            "62/62 [==============================] - 0s 3ms/step - loss: 0.4985 - y1_output_loss: 0.1634 - y2_output_loss: 0.3351 - y1_output_root_mean_squared_error: 0.4043 - y2_output_root_mean_squared_error: 0.5789 - val_loss: 1.0468 - val_y1_output_loss: 0.4274 - val_y2_output_loss: 0.6194 - val_y1_output_root_mean_squared_error: 0.6538 - val_y2_output_root_mean_squared_error: 0.7871\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NKBLFVlQsCgN"
      },
      "source": [
        "Evaluate the Model and Plot Metrics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KlYwqxhFrwL2",
        "outputId": "0cac1531-0b26-4f10-bb43-4e19ea763584"
      },
      "source": [
        "# Test the model and print loss and mse for both outputs\n",
        "loss, Y1_loss, Y2_loss, Y1_rmse, Y2_rmse = model.evaluate(x=norm_test_X, y=test_Y)\n",
        "print(\"Loss = {}, Y1_loss = {}, Y1_mse = {}, Y2_loss = {}, Y2_mse = {}\".format(loss, Y1_loss, Y1_rmse, Y2_loss, Y2_rmse))"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5/5 [==============================] - 0s 3ms/step - loss: 1.0468 - y1_output_loss: 0.4274 - y2_output_loss: 0.6194 - y1_output_root_mean_squared_error: 0.6538 - y2_output_root_mean_squared_error: 0.7871\n",
            "Loss = 1.0468388795852661, Y1_loss = 0.42739084362983704, Y1_mse = 0.6537513732910156, Y2_loss = 0.6194481253623962, Y2_mse = 0.7870502471923828\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 621
        },
        "id": "9KYHLk3KsL65",
        "outputId": "ef06ee7e-6670-41b6-cea3-d433b0e63844"
      },
      "source": [
        "# Plot the loss and mse\n",
        "Y_pred = model.predict(norm_test_X)\n",
        "plot_diff(test_Y[0], Y_pred[0], title='Y1')\n",
        "plot_diff(test_Y[1], Y_pred[1], title='Y2')\n",
        "plot_metrics(metric_name='y1_output_root_mean_squared_error', title='Y1 RMSE', ylim=6)\n",
        "plot_metrics(metric_name='y2_output_root_mean_squared_error', title='Y2 RMSE', ylim=7)"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-37-c2d0e7a29d09>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Plot the loss and mse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mY_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnorm_test_X\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mplot_diff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_Y\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Y1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mplot_diff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_Y\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Y2'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mplot_metrics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmetric_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'y1_output_root_mean_squared_error'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Y1 RMSE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mylim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-31-ec7004b48a39>\u001b[0m in \u001b[0;36mplot_diff\u001b[0;34m(y_true, y_pred, title)\u001b[0m\n\u001b[1;32m     12\u001b[0m   \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m   \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m   \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'True Value'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m   \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Predictions'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m   \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'equal'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: module 'matplotlib.pyplot' has no attribute 'xlable'"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vcFLQakbsK7a"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}