Optimized_Thesis_Code.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    },
    "colab": {
      "name": "Optimized Thesis Code.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "66y9gz9UlXTm",
        "colab_type": "text"
      },
      "source": [
        "## 1. Imports and Code useful Snippets"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LeNa39Syu8RD",
        "colab_type": "text"
      },
      "source": [
        "### 1.1 uncomment to Install Magenta library in the environment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LUcyz6Bqt2bx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# !pip install magenta\n",
        "!pip list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghg3F1DulXUc",
        "colab_type": "text"
      },
      "source": [
        "### 1.2 Code block to filter warnings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p_uwXSXNlXUf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D3OiClX9ybxj",
        "colab_type": "text"
      },
      "source": [
        "### 1.3 Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ld6ah7D0tvrR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fe70d49c-1e96-44d9-f175-8f47c6374d32"
      },
      "source": [
        "import sys\n",
        "import functools\n",
        "import warnings\n",
        "import numpy as np\n",
        "import time\n",
        "import matplotlib.pyplot as plt\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Magenta Imports\n",
        "import magenta.music as mm\n",
        "from magenta.models.music_vae.data import GrooveConverter\n",
        "from magenta.models.music_vae import configs\n",
        "from magenta.models.music_vae import data\n",
        "from magenta.models.music_vae.data import *\n",
        "\n",
        "#Tensorflow Imports\n",
        "import tensorflow as tf\n",
        "#!pip install tensorflow_datasets\n",
        "import tensorflow_datasets as tfds\n",
        "print(tf.__version__)\n",
        "\n",
        "#Enable Eager Execution\n",
        "tf.enable_eager_execution()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.15.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F0Xfce7LlXZ3",
        "colab_type": "text"
      },
      "source": [
        "### 1.4 Disable Eager Execution(Uncomment if to run in graph mode)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LlwSNUEJlXZ6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# tf.compat.v1.disable_eager_execution()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xaxSvz10w0Ib",
        "colab_type": "text"
      },
      "source": [
        "### 1.5 GPU Accelerator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bwf3w4tdwzgs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# device_name = tf.test.gpu_device_name()\n",
        "# # if device_name != '/device:GPU:0':\n",
        "# #   raise SystemError('GPU device not found')\n",
        "# print(device_name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gYJOelMSwJuM",
        "colab_type": "text"
      },
      "source": [
        "## 2. Data Processing Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K6gZNe_cxE2g",
        "colab_type": "text"
      },
      "source": [
        "### 2.1 Load available configs for GrooVAE Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SbWNzwy9w9SZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Load available configurations for available tasks\n",
        "config_2_bar = configs.CONFIG_MAP['groovae_2bar_humanize']\n",
        "config_tap_fixed_velocity = configs.CONFIG_MAP['groovae_2bar_tap_fixed_velocity']\n",
        "config_tap_fixed_velocity_dropout = configs.CONFIG_MAP['groovae_2bar_tap_fixed_velocity_note_dropout']\n",
        "configs_add_closed_hh = configs.CONFIG_MAP['groovae_2bar_add_closed_hh']\n",
        "configs_hit_control = configs.CONFIG_MAP['groovae_2bar_hits_control_tfds']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSMP2KWXzaTg",
        "colab_type": "text"
      },
      "source": [
        "### 2.2 Get Dataset from TFDS and store in a tf.Data Object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_SF6qWaTzZf0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def Initialize_dataset_as_iterator(config, batch_size, is_training=False, cache_dataset=True):\n",
        "\n",
        "    data_converter = config.data_converter\n",
        "    data_converter.set_mode('train' if is_training else 'eval')\n",
        "\n",
        "    tf.logging.info('Reading examples from TFDS: %s',config.tfds_name)\n",
        "    dataset = tfds.load(\n",
        "        config.tfds_name,\n",
        "        split=tfds.Split.TRAIN if is_training else tfds.Split.VALIDATION,\n",
        "        shuffle_files=is_training,\n",
        "        try_gcs=False\n",
        "    )\n",
        "    \n",
        "    print(\"The number of elements is this dataset is: {}\".format(tf.compat.v2.data.experimental.cardinality(dataset)))\n",
        "\n",
        "    # print(dataset)\n",
        "\n",
        "    midi_to_note = lambda x:[mm.midi_to_note_sequence(x.numpy()).SerializeToString()]\n",
        "\n",
        "#### FUNCTION 1\n",
        "    def _tf_midi_to_notesequence(ex):\n",
        "        return tf.py_function(\n",
        "            midi_to_note,\n",
        "            inp = [ex['midi']],\n",
        "            Tout= tf.string,\n",
        "            name='midi_to_note_sequence')\n",
        "\n",
        "####FUNCTION 2\n",
        "    def _binary_to_decimal_2(inputs,outputs,_,__):\n",
        "    \n",
        "      sequence_length = 32\n",
        "      drum_features = 9\n",
        "      prev = 0\n",
        "\n",
        "      inputs = tf.squeeze(inputs)\n",
        "      outputs = tf.squeeze(outputs)\n",
        "      \n",
        "      def binary_logic(x):\n",
        "        \n",
        "        result = tf.reduce_sum(\n",
        "        tf.cast( x, dtype=tf.int64)\n",
        "        * 2 ** tf.range(tf.cast(tf.size(x), dtype=tf.int64)))\n",
        "        return result\n",
        "    \n",
        "      input_digit = [binary_logic(inputs[i][:9]) for i in range(sequence_length)]\n",
        "      output_digit = [binary_logic(outputs[i][:9]) for i in range(sequence_length)]\n",
        "\n",
        "      #If required to return a tensor\n",
        "      input_tensor_digit = tf.convert_to_tensor(input_digit, dtype=tf.int64)\n",
        "      output_tensor_digit = tf.convert_to_tensor(output_digit, dtype=tf.int64)\n",
        "\n",
        "      return input_tensor_digit, output_tensor_digit\n",
        "\n",
        "#### FUNCTION 3\n",
        "    def _remove_pad_fn(padded_seq_1, padded_seq_2, padded_seq_3, length):\n",
        "        if length.shape.ndims == 0:\n",
        "            return (padded_seq_1[0:length], padded_seq_2[0:length],\n",
        "                    padded_seq_3[0:length], length)\n",
        "        else:\n",
        "            # Don't remove padding for hierarchical examples.\n",
        "            return padded_seq_1, padded_seq_2, padded_seq_3, length\n",
        "\n",
        "#### MAP FUNCTION 1\n",
        "    dataset = (dataset.map(\n",
        "        _tf_midi_to_notesequence,\n",
        "        num_parallel_calls=tf.data.experimental.AUTOTUNE))\n",
        "\n",
        "    # print(dataset)\n",
        "\n",
        "#### MAP TO TENSORS\n",
        "    dataset = dataset.map(\n",
        "      tf.autograph.experimental.do_not_convert(\n",
        "          functools.partial(convert_to_tensors_op, converter=data_converter)),\n",
        "      num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "####\n",
        "    dataset = dataset.unbatch()\n",
        "\n",
        "\n",
        "#### MAP FUNCTION 2\n",
        "    dataset = dataset.map(_binary_to_decimal_2,\n",
        "                          num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "#### MAP FUNCTION3       \n",
        "    # dataset = dataset.map(\n",
        "    #   _remove_pad_fn, num_parallel_calls=tf.data.experimental.AUTOTUNE)\n",
        "    \n",
        "    # print(dataset)\n",
        "\n",
        "#### SHUFFLE IF IS_TRAINING\n",
        "    if is_training:\n",
        "        dataset =dataset.shuffle(buffer_size=10 * batch_size)\n",
        "\n",
        "\n",
        "#### MAKE THE DATASET INTO A BATCH\n",
        "    # dataset = dataset.padded_batch(\n",
        "    #     1,\n",
        "    #     dataset.output_shapes,\n",
        "    #     drop_remainder=True\n",
        "    # ).prefetch(tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "    dataset = dataset.padded_batch(\n",
        "      batch_size,\n",
        "      tf.data.get_output_shapes(dataset),\n",
        "      drop_remainder=True).prefetch(tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "\n",
        "\n",
        "#### MAKE DATASET AN ITERATOR\n",
        "    # dataset = iter(dataset)\n",
        "    \n",
        "    # print(dataset)\n",
        "\n",
        "    return dataset"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sSJ-Wtda9Z8c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# val_dataset = Initialize_dataset_as_iterator(configs_add_closed_hh,64)\n",
        "\n",
        "# train_dataset = Initialize_dataset_as_iterator(configs_add_closed_hh,64,is_training=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K5BBzSfxoS-z",
        "colab_type": "text"
      },
      "source": [
        "## 3. Transformer Code"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XyY2ha3Uii2j",
        "colab_type": "text"
      },
      "source": [
        "### 3.1 Positional encoding\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cL6dk8NS1-nI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_angles(pos, i, d_model):\n",
        "  angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model))\n",
        "  return pos * angle_rates\n",
        "\n",
        "\n",
        "def positional_encoding(position, d_model):\n",
        "  angle_rads = get_angles(np.arange(position)[:, np.newaxis],\n",
        "                          np.arange(d_model)[np.newaxis, :],\n",
        "                          d_model)\n",
        "  \n",
        "  # apply sin to even indices in the array; 2i\n",
        "  angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])\n",
        "  \n",
        "  # apply cos to odd indices in the array; 2i+1\n",
        "  angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])\n",
        "    \n",
        "  pos_encoding = angle_rads[np.newaxis, ...]\n",
        "    \n",
        "  return tf.cast(pos_encoding, dtype=tf.float32)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "drlwfmtQjCqU",
        "colab_type": "text"
      },
      "source": [
        "### 3.2 Masking"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KiZG9gCZlXUy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_padding_mask(seq):\n",
        "  seq = tf.cast(tf.math.equal(seq, 0), tf.float32)\n",
        "  \n",
        "  # add extra dimensions to add the padding\n",
        "  # to the attention logits.\n",
        "  return seq[:, tf.newaxis, tf.newaxis, :]  # (batch_size, 1, 1, seq_len)\n",
        "\n",
        "def create_look_ahead_mask(size):\n",
        "  mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0)\n",
        "  return mask  # (seq_len, seq_len)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mUXZD-HpjZi5",
        "colab_type": "text"
      },
      "source": [
        "### 3.3 Attention"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xHc04uQtzREw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def scaled_dot_product_attention(q, k, v, mask):\n",
        "  \"\"\"Calculate the attention weights.\n",
        "  q, k, v must have matching leading dimensions.\n",
        "  k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.\n",
        "  The mask has different shapes depending on its type(padding or look ahead) \n",
        "  but it must be broadcastable for addition.\n",
        "  \n",
        "  Args:\n",
        "    q: query shape == (..., seq_len_q, depth)\n",
        "    k: key shape == (..., seq_len_k, depth)\n",
        "    v: value shape == (..., seq_len_v, depth_v)\n",
        "    mask: Float tensor with shape broadcastable \n",
        "          to (..., seq_len_q, seq_len_k). Defaults to None.\n",
        "    \n",
        "  Returns:\n",
        "    output, attention_weights\n",
        "  \"\"\"\n",
        "\n",
        "  matmul_qk = tf.matmul(q, k, transpose_b=True)  # (..., seq_len_q, seq_len_k)\n",
        "  \n",
        "  # scale matmul_qk\n",
        "  dk = tf.cast(tf.shape(k)[-1], tf.float32)\n",
        "  scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)\n",
        "\n",
        "  # add the mask to the scaled tensor.\n",
        "  if mask is not None:\n",
        "    scaled_attention_logits += (mask * -1e9)  \n",
        "\n",
        "  # softmax is normalized on the last axis (seq_len_k) so that the scores\n",
        "  # add up to 1.\n",
        "  attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)  # (..., seq_len_q, seq_len_k)\n",
        "\n",
        "  output = tf.matmul(attention_weights, v)  # (..., seq_len_q, depth_v)\n",
        "\n",
        "  return output, attention_weights\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kPrTtYxH3ylL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def print_out(q, k, v):\n",
        "  temp_out, temp_attn = scaled_dot_product_attention(\n",
        "      q, k, v, None)\n",
        "  print ('Attention weights are:')\n",
        "  print (temp_attn)\n",
        "  print ('Output is:')\n",
        "  print (temp_out)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Xg9wmSA4U3-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class MultiHeadAttention(tf.keras.layers.Layer):\n",
        "  def __init__(self, d_model, num_heads):\n",
        "    super(MultiHeadAttention, self).__init__()\n",
        "    self.num_heads = num_heads\n",
        "    self.d_model = d_model\n",
        "    \n",
        "    assert d_model % self.num_heads == 0\n",
        "    \n",
        "    self.depth = d_model // self.num_heads\n",
        "    \n",
        "    self.wq = tf.keras.layers.Dense(d_model)\n",
        "    self.wk = tf.keras.layers.Dense(d_model)\n",
        "    self.wv = tf.keras.layers.Dense(d_model)\n",
        "    \n",
        "    self.dense = tf.keras.layers.Dense(d_model)\n",
        "        \n",
        "  def split_heads(self, x, batch_size):\n",
        "    \"\"\"Split the last dimension into (num_heads, depth).\n",
        "    Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth)\n",
        "    \"\"\"\n",
        "    x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))\n",
        "    return tf.transpose(x, perm=[0, 2, 1, 3])\n",
        "    \n",
        "  def call(self, v, k, q, mask):\n",
        "    batch_size = tf.shape(q)[0]\n",
        "    \n",
        "    q = self.wq(q)  # (batch_size, seq_len, d_model)\n",
        "    k = self.wk(k)  # (batch_size, seq_len, d_model)\n",
        "    v = self.wv(v)  # (batch_size, seq_len, d_model)\n",
        "    \n",
        "    q = self.split_heads(q, batch_size)  # (batch_size, num_heads, seq_len_q, depth)\n",
        "    k = self.split_heads(k, batch_size)  # (batch_size, num_heads, seq_len_k, depth)\n",
        "    v = self.split_heads(v, batch_size)  # (batch_size, num_heads, seq_len_v, depth)\n",
        "    \n",
        "    # scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth)\n",
        "    # attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k)\n",
        "    scaled_attention, attention_weights = scaled_dot_product_attention(\n",
        "        q, k, v, mask)\n",
        "    \n",
        "    scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])  # (batch_size, seq_len_q, num_heads, depth)\n",
        "\n",
        "    concat_attention = tf.reshape(scaled_attention, \n",
        "                                  (batch_size, -1, self.d_model))  # (batch_size, seq_len_q, d_model)\n",
        "\n",
        "    output = self.dense(concat_attention)  # (batch_size, seq_len_q, d_model)\n",
        "        \n",
        "    return output, attention_weights"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y1zppPSajjBE",
        "colab_type": "text"
      },
      "source": [
        "### 3.4 Point wise feed forward layer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VbNhC0Vg8RBN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def point_wise_feed_forward_network(d_model, dff):\n",
        "  return tf.keras.Sequential([\n",
        "      tf.keras.layers.Dense(dff, activation='relu'),  # (batch_size, seq_len, dff)\n",
        "      tf.keras.layers.Dense(d_model)  # (batch_size, seq_len, d_model)\n",
        "  ])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jMnySmOBjznu",
        "colab_type": "text"
      },
      "source": [
        "### 3.5 Encoder"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mT-9kPSIlXVQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class EncoderLayer(tf.keras.layers.Layer):\n",
        "  def __init__(self, d_model, num_heads, dff, rate=0.1):\n",
        "    super(EncoderLayer, self).__init__()\n",
        "\n",
        "    self.mha = MultiHeadAttention(d_model, num_heads)\n",
        "    self.ffn = point_wise_feed_forward_network(d_model, dff)\n",
        "\n",
        "    self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n",
        "    self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n",
        "    \n",
        "    self.dropout1 = tf.keras.layers.Dropout(rate)\n",
        "    self.dropout2 = tf.keras.layers.Dropout(rate)\n",
        "    \n",
        "  def call(self, x, training, mask):\n",
        "\n",
        "    attn_output, _ = self.mha(x, x, x, mask)  # (batch_size, input_seq_len, d_model)\n",
        "    attn_output = self.dropout1(attn_output, training=training)\n",
        "    out1 = self.layernorm1(x + attn_output)  # (batch_size, input_seq_len, d_model)\n",
        "    \n",
        "    ffn_output = self.ffn(out1)  # (batch_size, input_seq_len, d_model)\n",
        "    ffn_output = self.dropout2(ffn_output, training=training)\n",
        "    out2 = self.layernorm2(out1 + ffn_output)  # (batch_size, input_seq_len, d_model)\n",
        "    \n",
        "    return out2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXqWvCrulXV4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "class Encoder(tf.keras.layers.Layer):\n",
        "  def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size,\n",
        "               maximum_position_encoding, rate=0.1):\n",
        "    super(Encoder, self).__init__()\n",
        "\n",
        "    self.d_model = d_model\n",
        "    self.num_layers = num_layers\n",
        "    \n",
        "    self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model)\n",
        "    self.pos_encoding = positional_encoding(maximum_position_encoding, \n",
        "                                            self.d_model)\n",
        "    \n",
        "    \n",
        "    self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) \n",
        "                       for _ in range(num_layers)]\n",
        "  \n",
        "    self.dropout = tf.keras.layers.Dropout(rate)\n",
        "        \n",
        "  def call(self, x, training, mask):\n",
        "\n",
        "    seq_len = tf.shape(x)[1]\n",
        "    \n",
        "    # adding embedding and position encoding.\n",
        "    x = self.embedding(x)  # (batch_size, input_seq_len, d_model)\n",
        "    x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n",
        "    x += self.pos_encoding[:, :seq_len, :]\n",
        "\n",
        "    x = self.dropout(x, training=training)\n",
        "    \n",
        "    for i in range(self.num_layers):\n",
        "      x = self.enc_layers[i](x, training, mask)\n",
        "    \n",
        "    return x  # (batch_size, input_seq_len, d_model)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H_R8M6jjkMjx",
        "colab_type": "text"
      },
      "source": [
        "### 3.6 Decoder"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sg9xbDCFlXWC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class DecoderLayer(tf.keras.layers.Layer):\n",
        "  def __init__(self, d_model, num_heads, dff, rate=0.1):\n",
        "    super(DecoderLayer, self).__init__()\n",
        "\n",
        "    self.mha1 = MultiHeadAttention(d_model, num_heads)\n",
        "    self.mha2 = MultiHeadAttention(d_model, num_heads)\n",
        "\n",
        "    self.ffn = point_wise_feed_forward_network(d_model, dff)\n",
        " \n",
        "    self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n",
        "    self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n",
        "    self.layernorm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n",
        "    \n",
        "    self.dropout1 = tf.keras.layers.Dropout(rate)\n",
        "    self.dropout2 = tf.keras.layers.Dropout(rate)\n",
        "    self.dropout3 = tf.keras.layers.Dropout(rate)\n",
        "    \n",
        "    \n",
        "  def call(self, x, enc_output, training, \n",
        "           look_ahead_mask, padding_mask):\n",
        "    # enc_output.shape == (batch_size, input_seq_len, d_model)\n",
        "\n",
        "    attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask)  # (batch_size, target_seq_len, d_model)\n",
        "    attn1 = self.dropout1(attn1, training=training)\n",
        "    out1 = self.layernorm1(attn1 + x)\n",
        "    \n",
        "    attn2, attn_weights_block2 = self.mha2(\n",
        "        enc_output, enc_output, out1, padding_mask)  # (batch_size, target_seq_len, d_model)\n",
        "    attn2 = self.dropout2(attn2, training=training)\n",
        "    out2 = self.layernorm2(attn2 + out1)  # (batch_size, target_seq_len, d_model)\n",
        "    \n",
        "    ffn_output = self.ffn(out2)  # (batch_size, target_seq_len, d_model)\n",
        "    ffn_output = self.dropout3(ffn_output, training=training)\n",
        "    out3 = self.layernorm3(ffn_output + out2)  # (batch_size, target_seq_len, d_model)\n",
        "    \n",
        "    return out3, attn_weights_block1, attn_weights_block2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DejcXMCJlXWv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Decoder(tf.keras.layers.Layer):\n",
        "  def __init__(self, num_layers, d_model, num_heads, dff, target_vocab_size,\n",
        "               maximum_position_encoding, rate=0.1):\n",
        "    super(Decoder, self).__init__()\n",
        "\n",
        "    self.d_model = d_model\n",
        "    self.num_layers = num_layers\n",
        "    \n",
        "    self.embedding = tf.keras.layers.Embedding(target_vocab_size, d_model)\n",
        "    self.pos_encoding = positional_encoding(maximum_position_encoding, d_model)\n",
        "    \n",
        "    self.dec_layers = [DecoderLayer(d_model, num_heads, dff, rate) \n",
        "                       for _ in range(num_layers)]\n",
        "    self.dropout = tf.keras.layers.Dropout(rate)\n",
        "    \n",
        "  def call(self, x, enc_output, training, \n",
        "           look_ahead_mask, padding_mask):\n",
        "\n",
        "    seq_len = tf.shape(x)[1]\n",
        "    attention_weights = {}\n",
        "    \n",
        "    x = self.embedding(x)  # (batch_size, target_seq_len, d_model)\n",
        "    x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n",
        "    x += self.pos_encoding[:, :seq_len, :]\n",
        "    \n",
        "    x = self.dropout(x, training=training)\n",
        "\n",
        "    for i in range(self.num_layers):\n",
        "      x, block1, block2 = self.dec_layers[i](x, enc_output, training,\n",
        "                                             look_ahead_mask, padding_mask)\n",
        "      \n",
        "      attention_weights['decoder_layer{}_block1'.format(i+1)] = block1\n",
        "      attention_weights['decoder_layer{}_block2'.format(i+1)] = block2\n",
        "    \n",
        "    # x.shape == (batch_size, target_seq_len, d_model)\n",
        "    return x, attention_weights\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "COJ3RgDikhCJ",
        "colab_type": "text"
      },
      "source": [
        "### 3.7 Assemble the transformer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MgE4sR7glXXF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Transformer(tf.keras.Model):\n",
        "  def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, \n",
        "               target_vocab_size, pe_input, pe_target, rate=0.1):\n",
        "    super(Transformer, self).__init__()\n",
        "\n",
        "    self.encoder = Encoder(num_layers, d_model, num_heads, dff, \n",
        "                           input_vocab_size, pe_input, rate)\n",
        "\n",
        "    self.decoder = Decoder(num_layers, d_model, num_heads, dff, \n",
        "                           target_vocab_size, pe_target, rate)\n",
        "\n",
        "    self.final_layer = tf.keras.layers.Dense(target_vocab_size)\n",
        "    \n",
        "  def call(self, inp, tar, training, enc_padding_mask, \n",
        "           look_ahead_mask, dec_padding_mask):\n",
        "\n",
        "    enc_output = self.encoder(inp, training, enc_padding_mask)  # (batch_size, inp_seq_len, d_model)\n",
        "    \n",
        "    # dec_output.shape == (batch_size, tar_seq_len, d_model)\n",
        "    dec_output, attention_weights = self.decoder(\n",
        "        tar, enc_output, training, look_ahead_mask, dec_padding_mask)\n",
        "    \n",
        "    final_output = self.final_layer(dec_output)  # (batch_size, tar_seq_len, target_vocab_size)\n",
        "    \n",
        "    return final_output, attention_weights\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-MOylKjzk77P",
        "colab_type": "text"
      },
      "source": [
        "### 3.8 Optimizer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g7P7GruklXXN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):\n",
        "  def __init__(self, d_model, warmup_steps=4000):\n",
        "    super(CustomSchedule, self).__init__()\n",
        "    \n",
        "    self.d_model = d_model\n",
        "    self.d_model = tf.cast(self.d_model, tf.float32)\n",
        "\n",
        "    self.warmup_steps = warmup_steps\n",
        "    \n",
        "  def __call__(self, step):\n",
        "    arg1 = tf.math.rsqrt(step)\n",
        "    arg2 = step * (self.warmup_steps ** -1.5)\n",
        "    \n",
        "    return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VmQTXZGDlXXV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "learning_rate = CustomSchedule(d_model)\n",
        "\n",
        "optimizer = tf.keras.optimizers.Adam(learning_rate, beta_1=0.9, beta_2=0.98, \n",
        "                                     epsilon=1e-9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5flu0WJHlXXe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp_learning_rate_schedule = CustomSchedule(d_model)\n",
        "\n",
        "# plt.plot(temp_learning_rate_schedule(tf.range(40000, dtype=tf.float32)))\n",
        "# plt.ylabel(\"Learning Rate\")\n",
        "# plt.xlabel(\"Train Step\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GlZ6DOLOlXZR",
        "colab_type": "text"
      },
      "source": [
        "### 3.9 Loss"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XED99FAslXXl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "loss_object = tf.keras.losses.SparseCategoricalCrossentropy(\n",
        "    from_logits=True, reduction='none')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JGLXMBwmlXX9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def loss_function(real, pred):\n",
        "  mask = tf.math.logical_not(tf.math.equal(real, 0))\n",
        "  loss_ = loss_object(real, pred)\n",
        "\n",
        "  mask = tf.cast(mask, dtype=loss_.dtype)\n",
        "  loss_ *= mask\n",
        "  \n",
        "  return tf.reduce_sum(loss_)/tf.reduce_sum(mask)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OmWmo0qrh5J3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_loss = tf.keras.metrics.Mean(name='train_loss')\n",
        "\n",
        "train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(\n",
        "    name='train_accuracy')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7dH8AsjpexgL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "val_loss = tf.keras.metrics.Mean(name='val_loss')\n",
        "\n",
        "val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(\n",
        "    name='val_accuracy')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yksyGszhlXZa",
        "colab_type": "text"
      },
      "source": [
        "## 4. Training and Experiments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i-qBtM06l5CX",
        "colab_type": "text"
      },
      "source": [
        "### 4.1 Data Loading"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2dStUDpJlXY7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# tensors = Initialize_dataset_as_iterator(configs_add_closed_hh,64,is_training = True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LXKbEKJbm17A",
        "colab_type": "text"
      },
      "source": [
        "### 4.2 Hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6nXb4Pp0lXZK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "num_layers = 2\n",
        "d_model = 128\n",
        "dff = 512\n",
        "num_heads = 8\n",
        "\n",
        "input_vocab_size = 512 + 2\n",
        "target_vocab_size = 512 + 2\n",
        "dropout_rate = 0.25\n",
        "\n",
        "EPOCHS = 80"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pCXpm13FmAFF",
        "colab_type": "text"
      },
      "source": [
        "### 4.3 Create the Transformer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WR5KWK7dlXZT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "transformer = Transformer(num_layers, d_model, num_heads, dff,\n",
        "                          input_vocab_size, target_vocab_size, \n",
        "                          pe_input=input_vocab_size, \n",
        "                          pe_target=target_vocab_size,\n",
        "                          rate=dropout_rate)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zk--rAyInh5X",
        "colab_type": "text"
      },
      "source": [
        "### 4.4 Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aQXZZMP3lXZc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_masks(inp, tar):\n",
        "  # Encoder padding mask\n",
        "  enc_padding_mask = create_padding_mask(inp)\n",
        "  \n",
        "  # Used in the 2nd attention block in the decoder.\n",
        "  # This padding mask is used to mask the encoder outputs.\n",
        "  dec_padding_mask = create_padding_mask(inp)\n",
        "  \n",
        "  # Used in the 1st attention block in the decoder.\n",
        "  # It is used to pad and mask future tokens in the input received by \n",
        "  # the decoder.\n",
        "  look_ahead_mask = create_look_ahead_mask(tf.shape(tar)[1])\n",
        "  dec_target_padding_mask = create_padding_mask(tar)\n",
        "  combined_mask = tf.maximum(dec_target_padding_mask, look_ahead_mask)\n",
        "  \n",
        "  return enc_padding_mask, combined_mask, dec_padding_mask\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m_FbdYUPn5R2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "checkpoint_path = \"./checkpoints/train\"\n",
        "\n",
        "ckpt = tf.train.Checkpoint(transformer=transformer,\n",
        "                           optimizer=optimizer)\n",
        "\n",
        "ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5)\n",
        "\n",
        "# if a checkpoint exists, restore the latest checkpoint.\n",
        "if ckpt_manager.latest_checkpoint:\n",
        "  ckpt.restore(ckpt_manager.latest_checkpoint)\n",
        "  print ('Latest checkpoint restored!!')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OO2_qTs1n73_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The @tf.function trace-compiles train_step into a TF graph for faster\n",
        "# execution. The function specializes to the precise shape of the argument\n",
        "# tensors. To avoid re-tracing due to the variable sequence lengths or variable\n",
        "# batch sizes (the last batch is smaller), use input_signature to specify\n",
        "# more generic shapes.\n",
        "\n",
        "train_step_signature = [\n",
        "    tf.TensorSpec(shape=(None, None), dtype=tf.int64),\n",
        "    tf.TensorSpec(shape=(None, None), dtype=tf.int64),\n",
        "]\n",
        "\n",
        "@tf.function(input_signature=train_step_signature)\n",
        "def train_step(inp, tar):\n",
        "  tar_inp = tar[:, :-1]\n",
        "  tar_real = tar[:, 1:]\n",
        "  \n",
        "  enc_padding_mask, combined_mask, dec_padding_mask = create_masks(inp, tar_inp)\n",
        "  \n",
        "  with tf.GradientTape() as tape:\n",
        "    predictions, _ = transformer(inp, tar_inp, \n",
        "                                 True, \n",
        "                                 enc_padding_mask, \n",
        "                                 combined_mask, \n",
        "                                 dec_padding_mask)\n",
        "    loss = loss_function(tar_real, predictions)\n",
        "\n",
        "  gradients = tape.gradient(loss, transformer.trainable_variables)    \n",
        "  optimizer.apply_gradients(zip(gradients, transformer.trainable_variables))\n",
        "  \n",
        "  train_loss(loss)\n",
        "  train_accuracy(tar_real, predictions)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tfYHRtFVhJd-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "92135449-00b3-44f1-cfb3-d6782aff1117"
      },
      "source": [
        "transformer.call"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<bound method Transformer.call of <__main__.Transformer object at 0x7f3fa8f5a438>>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3PwRpp0Nc-_o",
        "colab_type": "text"
      },
      "source": [
        "Validation step"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p4BoIUk1bE5t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "val_step_signature = [\n",
        "    tf.TensorSpec(shape=(None, None), dtype=tf.int64),\n",
        "    tf.TensorSpec(shape=(None, None), dtype=tf.int64),\n",
        "]\n",
        "\n",
        "@tf.function(input_signature=val_step_signature)\n",
        "def val_step(inp, tar):\n",
        "  tar_inp = tar[:, :-1]\n",
        "  tar_real = tar[:, 1:]\n",
        "  \n",
        "  enc_padding_mask, combined_mask, dec_padding_mask = create_masks(inp, tar_inp)\n",
        "  \n",
        "\n",
        "  predictions, _ = transformer(inp, tar_inp, \n",
        "                                False, \n",
        "                                enc_padding_mask, \n",
        "                                combined_mask, \n",
        "                                dec_padding_mask)\n",
        "  loss = loss_function(tar_real, predictions)\n",
        "  \n",
        "  val_loss(loss)\n",
        "  val_accuracy(tar_real, predictions)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_crJFGGrkM1F",
        "colab_type": "text"
      },
      "source": [
        "Train Loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q1gZOCv4oB87",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "de86e317-e382-4143-c490-62e75d5a30c5"
      },
      "source": [
        "loss = []\n",
        "val_Loss = []\n",
        "for epoch in range(EPOCHS):\n",
        "\n",
        "  import os\n",
        "  os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
        "  start = time.time()\n",
        "\n",
        "  loss.append(train_loss.result().numpy())\n",
        "  val_Loss.append(val_loss.result().numpy())\n",
        "  \n",
        "  train_loss.reset_states()\n",
        "  train_accuracy.reset_states()\n",
        "  val_loss.reset_states()\n",
        "  val_accuracy.reset_states()\n",
        "\n",
        "  train_dataset = Initialize_dataset_as_iterator(configs_add_closed_hh,64,is_training = True)\n",
        "  val_dataset = Initialize_dataset_as_iterator(configs_add_closed_hh,64)\n",
        "\n",
        "  for (batch,(inp,tar)) in enumerate(train_dataset):\n",
        "    train_step(inp, tar)\n",
        "    if batch % 50 == 0:\n",
        "      print ('Epoch {} Batch {} Loss {:.4f} Accuracy {:.4f}'.format(\n",
        "          epoch + 1, batch, train_loss.result(), train_accuracy.result()))\n",
        "\n",
        "  for (batch,(inp,tar)) in enumerate(val_dataset):\n",
        "    val_step(inp, tar)\n",
        "    if batch % 50 == 0:\n",
        "      print ('Validation: Epoch {} Batch {} Loss {:.4f} Accuracy {:.4f}'.format(\n",
        "          epoch + 1, batch, val_loss.result(), val_accuracy.result()))\n",
        "  \n",
        "\n",
        "  if (epoch + 1) % 2 == 0:\n",
        "    ckpt_save_path = ckpt_manager.save()\n",
        "    print ('Saving checkpoint for epoch {} at {}'.format(epoch+1,\n",
        "                                                         ckpt_save_path))\n",
        "    \n",
        "  print ('Epoch {} Loss {:.4f} Accuracy {:.4f}'.format(epoch + 1, \n",
        "                                                train_loss.result(), \n",
        "                                                train_accuracy.result()))\n",
        "\n",
        "  print ('Time taken for 1 epoch: {} secs\\n'.format(time.time() - start))\n",
        "    \n",
        "  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 1 Batch 0 Loss 6.2847 Accuracy 0.0005\n",
            "Epoch 1 Batch 50 Loss 6.1369 Accuracy 0.0031\n",
            "Epoch 1 Batch 100 Loss 5.8467 Accuracy 0.0480\n",
            "Epoch 1 Batch 150 Loss 5.5312 Accuracy 0.0858\n",
            "Epoch 1 Batch 200 Loss 5.2671 Accuracy 0.1047\n",
            "Epoch 1 Batch 250 Loss 5.0437 Accuracy 0.1167\n",
            "Validation: Epoch 1 Batch 0 Loss 3.5928 Accuracy 0.2147\n",
            "Epoch 1 Loss 5.0225 Accuracy 0.1181\n",
            "Time taken for 1 epoch: 235.01060366630554 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 2 Batch 0 Loss 3.8843 Accuracy 0.1981\n",
            "Epoch 2 Batch 50 Loss 3.7836 Accuracy 0.2033\n",
            "Epoch 2 Batch 100 Loss 3.6314 Accuracy 0.2159\n",
            "Epoch 2 Batch 150 Loss 3.4984 Accuracy 0.2202\n",
            "Epoch 2 Batch 200 Loss 3.3746 Accuracy 0.2231\n",
            "Epoch 2 Batch 250 Loss 3.2623 Accuracy 0.2260\n",
            "Validation: Epoch 2 Batch 0 Loss 2.3630 Accuracy 0.2692\n",
            "Saving checkpoint for epoch 2 at ./checkpoints/train/ckpt-1\n",
            "Epoch 2 Loss 3.2527 Accuracy 0.2259\n",
            "Time taken for 1 epoch: 222.9841480255127 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 3 Batch 0 Loss 2.7064 Accuracy 0.2651\n",
            "Epoch 3 Batch 50 Loss 2.6393 Accuracy 0.2436\n",
            "Epoch 3 Batch 100 Loss 2.5680 Accuracy 0.2488\n",
            "Epoch 3 Batch 150 Loss 2.5103 Accuracy 0.2516\n",
            "Epoch 3 Batch 200 Loss 2.4572 Accuracy 0.2547\n",
            "Epoch 3 Batch 250 Loss 2.4129 Accuracy 0.2568\n",
            "Validation: Epoch 3 Batch 0 Loss 1.9337 Accuracy 0.3191\n",
            "Epoch 3 Loss 2.4096 Accuracy 0.2569\n",
            "Time taken for 1 epoch: 226.29851651191711 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 4 Batch 0 Loss 2.1864 Accuracy 0.2787\n",
            "Epoch 4 Batch 50 Loss 2.1708 Accuracy 0.2727\n",
            "Epoch 4 Batch 100 Loss 2.1412 Accuracy 0.2763\n",
            "Epoch 4 Batch 150 Loss 2.1202 Accuracy 0.2780\n",
            "Epoch 4 Batch 200 Loss 2.0951 Accuracy 0.2807\n",
            "Epoch 4 Batch 250 Loss 2.0741 Accuracy 0.2828\n",
            "Validation: Epoch 4 Batch 0 Loss 1.7399 Accuracy 0.3382\n",
            "Saving checkpoint for epoch 4 at ./checkpoints/train/ckpt-2\n",
            "Epoch 4 Loss 2.0719 Accuracy 0.2832\n",
            "Time taken for 1 epoch: 226.02564072608948 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 5 Batch 0 Loss 1.9935 Accuracy 0.3039\n",
            "Epoch 5 Batch 50 Loss 1.9342 Accuracy 0.3001\n",
            "Epoch 5 Batch 100 Loss 1.9164 Accuracy 0.3036\n",
            "Epoch 5 Batch 150 Loss 1.8990 Accuracy 0.3058\n",
            "Epoch 5 Batch 200 Loss 1.8783 Accuracy 0.3083\n",
            "Epoch 5 Batch 250 Loss 1.8541 Accuracy 0.3122\n",
            "Validation: Epoch 5 Batch 0 Loss 1.4592 Accuracy 0.3891\n",
            "Epoch 5 Loss 1.8528 Accuracy 0.3123\n",
            "Time taken for 1 epoch: 224.35000777244568 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 6 Batch 0 Loss 1.7898 Accuracy 0.3301\n",
            "Epoch 6 Batch 50 Loss 1.7123 Accuracy 0.3335\n",
            "Epoch 6 Batch 100 Loss 1.6777 Accuracy 0.3414\n",
            "Epoch 6 Batch 150 Loss 1.6470 Accuracy 0.3473\n",
            "Epoch 6 Batch 200 Loss 1.6097 Accuracy 0.3535\n",
            "Epoch 6 Batch 250 Loss 1.5720 Accuracy 0.3609\n",
            "Validation: Epoch 6 Batch 0 Loss 1.0623 Accuracy 0.4768\n",
            "Saving checkpoint for epoch 6 at ./checkpoints/train/ckpt-3\n",
            "Epoch 6 Loss 1.5680 Accuracy 0.3619\n",
            "Time taken for 1 epoch: 225.05543088912964 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 7 Batch 0 Loss 1.3968 Accuracy 0.3805\n",
            "Epoch 7 Batch 50 Loss 1.3280 Accuracy 0.4101\n",
            "Epoch 7 Batch 100 Loss 1.2827 Accuracy 0.4222\n",
            "Epoch 7 Batch 150 Loss 1.2434 Accuracy 0.4297\n",
            "Epoch 7 Batch 200 Loss 1.2033 Accuracy 0.4372\n",
            "Epoch 7 Batch 250 Loss 1.1655 Accuracy 0.4449\n",
            "Validation: Epoch 7 Batch 0 Loss 0.7432 Accuracy 0.5605\n",
            "Epoch 7 Loss 1.1618 Accuracy 0.4457\n",
            "Time taken for 1 epoch: 226.06606602668762 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 8 Batch 0 Loss 0.9980 Accuracy 0.4808\n",
            "Epoch 8 Batch 50 Loss 0.9588 Accuracy 0.4914\n",
            "Epoch 8 Batch 100 Loss 0.9325 Accuracy 0.4985\n",
            "Epoch 8 Batch 150 Loss 0.9085 Accuracy 0.5042\n",
            "Epoch 8 Batch 200 Loss 0.8860 Accuracy 0.5071\n",
            "Epoch 8 Batch 250 Loss 0.8655 Accuracy 0.5116\n",
            "Validation: Epoch 8 Batch 0 Loss 0.5892 Accuracy 0.6048\n",
            "Saving checkpoint for epoch 8 at ./checkpoints/train/ckpt-4\n",
            "Epoch 8 Loss 0.8633 Accuracy 0.5119\n",
            "Time taken for 1 epoch: 225.05215167999268 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 9 Batch 0 Loss 0.7419 Accuracy 0.5348\n",
            "Epoch 9 Batch 50 Loss 0.7534 Accuracy 0.5389\n",
            "Epoch 9 Batch 100 Loss 0.7380 Accuracy 0.5436\n",
            "Epoch 9 Batch 150 Loss 0.7226 Accuracy 0.5474\n",
            "Epoch 9 Batch 200 Loss 0.7094 Accuracy 0.5493\n",
            "Epoch 9 Batch 250 Loss 0.6972 Accuracy 0.5513\n",
            "Validation: Epoch 9 Batch 0 Loss 0.5671 Accuracy 0.6079\n",
            "Epoch 9 Loss 0.6963 Accuracy 0.5518\n",
            "Time taken for 1 epoch: 225.05846691131592 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 10 Batch 0 Loss 0.6414 Accuracy 0.5625\n",
            "Epoch 10 Batch 50 Loss 0.6332 Accuracy 0.5705\n",
            "Epoch 10 Batch 100 Loss 0.6237 Accuracy 0.5740\n",
            "Epoch 10 Batch 150 Loss 0.6151 Accuracy 0.5754\n",
            "Epoch 10 Batch 200 Loss 0.6043 Accuracy 0.5764\n",
            "Epoch 10 Batch 250 Loss 0.5954 Accuracy 0.5786\n",
            "Validation: Epoch 10 Batch 0 Loss 0.4807 Accuracy 0.6310\n",
            "Saving checkpoint for epoch 10 at ./checkpoints/train/ckpt-5\n",
            "Epoch 10 Loss 0.5945 Accuracy 0.5788\n",
            "Time taken for 1 epoch: 225.62926411628723 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 11 Batch 0 Loss 0.5969 Accuracy 0.5575\n",
            "Epoch 11 Batch 50 Loss 0.5412 Accuracy 0.5965\n",
            "Epoch 11 Batch 100 Loss 0.5323 Accuracy 0.5994\n",
            "Epoch 11 Batch 150 Loss 0.5282 Accuracy 0.6004\n",
            "Epoch 11 Batch 200 Loss 0.5213 Accuracy 0.6007\n",
            "Epoch 11 Batch 250 Loss 0.5144 Accuracy 0.6018\n",
            "Validation: Epoch 11 Batch 0 Loss 0.4313 Accuracy 0.6482\n",
            "Epoch 11 Loss 0.5142 Accuracy 0.6020\n",
            "Time taken for 1 epoch: 225.08886694908142 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 12 Batch 0 Loss 0.4763 Accuracy 0.6094\n",
            "Epoch 12 Batch 50 Loss 0.4776 Accuracy 0.6124\n",
            "Epoch 12 Batch 100 Loss 0.4710 Accuracy 0.6173\n",
            "Epoch 12 Batch 150 Loss 0.4660 Accuracy 0.6191\n",
            "Epoch 12 Batch 200 Loss 0.4592 Accuracy 0.6188\n",
            "Epoch 12 Batch 250 Loss 0.4527 Accuracy 0.6203\n",
            "Validation: Epoch 12 Batch 0 Loss 0.3915 Accuracy 0.6598\n",
            "Saving checkpoint for epoch 12 at ./checkpoints/train/ckpt-6\n",
            "Epoch 12 Loss 0.4522 Accuracy 0.6201\n",
            "Time taken for 1 epoch: 225.65525579452515 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 13 Batch 0 Loss 0.3962 Accuracy 0.6482\n",
            "Epoch 13 Batch 50 Loss 0.4219 Accuracy 0.6294\n",
            "Epoch 13 Batch 100 Loss 0.4212 Accuracy 0.6336\n",
            "Epoch 13 Batch 150 Loss 0.4173 Accuracy 0.6328\n",
            "Epoch 13 Batch 200 Loss 0.4121 Accuracy 0.6328\n",
            "Epoch 13 Batch 250 Loss 0.4082 Accuracy 0.6329\n",
            "Validation: Epoch 13 Batch 0 Loss 0.3663 Accuracy 0.6658\n",
            "Epoch 13 Loss 0.4077 Accuracy 0.6331\n",
            "Time taken for 1 epoch: 226.32786059379578 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 14 Batch 0 Loss 0.3490 Accuracy 0.5993\n",
            "Epoch 14 Batch 50 Loss 0.3848 Accuracy 0.6418\n",
            "Epoch 14 Batch 100 Loss 0.3843 Accuracy 0.6439\n",
            "Epoch 14 Batch 150 Loss 0.3810 Accuracy 0.6435\n",
            "Epoch 14 Batch 200 Loss 0.3771 Accuracy 0.6429\n",
            "Epoch 14 Batch 250 Loss 0.3751 Accuracy 0.6427\n",
            "Validation: Epoch 14 Batch 0 Loss 0.3423 Accuracy 0.6689\n",
            "Saving checkpoint for epoch 14 at ./checkpoints/train/ckpt-7\n",
            "Epoch 14 Loss 0.3753 Accuracy 0.6423\n",
            "Time taken for 1 epoch: 228.98754453659058 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 15 Batch 0 Loss 0.3051 Accuracy 0.6109\n",
            "Epoch 15 Batch 50 Loss 0.3616 Accuracy 0.6475\n",
            "Epoch 15 Batch 100 Loss 0.3579 Accuracy 0.6501\n",
            "Epoch 15 Batch 150 Loss 0.3542 Accuracy 0.6509\n",
            "Epoch 15 Batch 200 Loss 0.3519 Accuracy 0.6486\n",
            "Epoch 15 Batch 250 Loss 0.3495 Accuracy 0.6491\n",
            "Validation: Epoch 15 Batch 0 Loss 0.3328 Accuracy 0.6724\n",
            "Epoch 15 Loss 0.3491 Accuracy 0.6491\n",
            "Time taken for 1 epoch: 228.10313320159912 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 16 Batch 0 Loss 0.2866 Accuracy 0.6598\n",
            "Epoch 16 Batch 50 Loss 0.3451 Accuracy 0.6525\n",
            "Epoch 16 Batch 100 Loss 0.3384 Accuracy 0.6554\n",
            "Epoch 16 Batch 150 Loss 0.3358 Accuracy 0.6556\n",
            "Epoch 16 Batch 200 Loss 0.3332 Accuracy 0.6541\n",
            "Epoch 16 Batch 250 Loss 0.3321 Accuracy 0.6542\n",
            "Validation: Epoch 16 Batch 0 Loss 0.3573 Accuracy 0.6648\n",
            "Saving checkpoint for epoch 16 at ./checkpoints/train/ckpt-8\n",
            "Epoch 16 Loss 0.3321 Accuracy 0.6541\n",
            "Time taken for 1 epoch: 229.3412573337555 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 17 Batch 0 Loss 0.3091 Accuracy 0.6623\n",
            "Epoch 17 Batch 50 Loss 0.3221 Accuracy 0.6557\n",
            "Epoch 17 Batch 100 Loss 0.3228 Accuracy 0.6588\n",
            "Epoch 17 Batch 150 Loss 0.3203 Accuracy 0.6596\n",
            "Epoch 17 Batch 200 Loss 0.3190 Accuracy 0.6581\n",
            "Epoch 17 Batch 250 Loss 0.3167 Accuracy 0.6579\n",
            "Validation: Epoch 17 Batch 0 Loss 0.3550 Accuracy 0.6714\n",
            "Epoch 17 Loss 0.3169 Accuracy 0.6580\n",
            "Time taken for 1 epoch: 227.206533908844 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 18 Batch 0 Loss 0.2845 Accuracy 0.6416\n",
            "Epoch 18 Batch 50 Loss 0.3160 Accuracy 0.6585\n",
            "Epoch 18 Batch 100 Loss 0.3104 Accuracy 0.6636\n",
            "Epoch 18 Batch 150 Loss 0.3091 Accuracy 0.6622\n",
            "Epoch 18 Batch 200 Loss 0.3055 Accuracy 0.6614\n",
            "Epoch 18 Batch 250 Loss 0.3038 Accuracy 0.6613\n",
            "Validation: Epoch 18 Batch 0 Loss 0.3159 Accuracy 0.6759\n",
            "Saving checkpoint for epoch 18 at ./checkpoints/train/ckpt-9\n",
            "Epoch 18 Loss 0.3040 Accuracy 0.6613\n",
            "Time taken for 1 epoch: 227.1257073879242 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 19 Batch 0 Loss 0.2911 Accuracy 0.6578\n",
            "Epoch 19 Batch 50 Loss 0.2956 Accuracy 0.6648\n",
            "Epoch 19 Batch 100 Loss 0.2970 Accuracy 0.6670\n",
            "Epoch 19 Batch 150 Loss 0.2950 Accuracy 0.6667\n",
            "Epoch 19 Batch 200 Loss 0.2930 Accuracy 0.6655\n",
            "Epoch 19 Batch 250 Loss 0.2922 Accuracy 0.6648\n",
            "Validation: Epoch 19 Batch 0 Loss 0.3319 Accuracy 0.6739\n",
            "Epoch 19 Loss 0.2926 Accuracy 0.6647\n",
            "Time taken for 1 epoch: 226.48089599609375 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 20 Batch 0 Loss 0.2980 Accuracy 0.6411\n",
            "Epoch 20 Batch 50 Loss 0.2890 Accuracy 0.6670\n",
            "Epoch 20 Batch 100 Loss 0.2890 Accuracy 0.6692\n",
            "Epoch 20 Batch 150 Loss 0.2872 Accuracy 0.6688\n",
            "Epoch 20 Batch 200 Loss 0.2851 Accuracy 0.6677\n",
            "Epoch 20 Batch 250 Loss 0.2840 Accuracy 0.6672\n",
            "Validation: Epoch 20 Batch 0 Loss 0.3217 Accuracy 0.6890\n",
            "Saving checkpoint for epoch 20 at ./checkpoints/train/ckpt-10\n",
            "Epoch 20 Loss 0.2846 Accuracy 0.6668\n",
            "Time taken for 1 epoch: 225.20926523208618 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 21 Batch 0 Loss 0.2789 Accuracy 0.6532\n",
            "Epoch 21 Batch 50 Loss 0.2818 Accuracy 0.6686\n",
            "Epoch 21 Batch 100 Loss 0.2802 Accuracy 0.6722\n",
            "Epoch 21 Batch 150 Loss 0.2794 Accuracy 0.6712\n",
            "Epoch 21 Batch 200 Loss 0.2772 Accuracy 0.6700\n",
            "Epoch 21 Batch 250 Loss 0.2778 Accuracy 0.6688\n",
            "Validation: Epoch 21 Batch 0 Loss 0.3332 Accuracy 0.6754\n",
            "Epoch 21 Loss 0.2780 Accuracy 0.6688\n",
            "Time taken for 1 epoch: 224.12966394424438 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 22 Batch 0 Loss 0.2913 Accuracy 0.6613\n",
            "Epoch 22 Batch 50 Loss 0.2727 Accuracy 0.6701\n",
            "Epoch 22 Batch 100 Loss 0.2730 Accuracy 0.6716\n",
            "Epoch 22 Batch 150 Loss 0.2723 Accuracy 0.6722\n",
            "Epoch 22 Batch 200 Loss 0.2710 Accuracy 0.6711\n",
            "Epoch 22 Batch 250 Loss 0.2707 Accuracy 0.6703\n",
            "Validation: Epoch 22 Batch 0 Loss 0.3369 Accuracy 0.6749\n",
            "Saving checkpoint for epoch 22 at ./checkpoints/train/ckpt-11\n",
            "Epoch 22 Loss 0.2709 Accuracy 0.6702\n",
            "Time taken for 1 epoch: 224.81525802612305 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 23 Batch 0 Loss 0.2748 Accuracy 0.6855\n",
            "Epoch 23 Batch 50 Loss 0.2657 Accuracy 0.6722\n",
            "Epoch 23 Batch 100 Loss 0.2663 Accuracy 0.6761\n",
            "Epoch 23 Batch 150 Loss 0.2644 Accuracy 0.6747\n",
            "Epoch 23 Batch 200 Loss 0.2638 Accuracy 0.6732\n",
            "Epoch 23 Batch 250 Loss 0.2641 Accuracy 0.6723\n",
            "Validation: Epoch 23 Batch 0 Loss 0.3149 Accuracy 0.6850\n",
            "Epoch 23 Loss 0.2641 Accuracy 0.6722\n",
            "Time taken for 1 epoch: 223.49860215187073 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 24 Batch 0 Loss 0.2674 Accuracy 0.6557\n",
            "Epoch 24 Batch 50 Loss 0.2638 Accuracy 0.6731\n",
            "Epoch 24 Batch 100 Loss 0.2602 Accuracy 0.6766\n",
            "Epoch 24 Batch 150 Loss 0.2610 Accuracy 0.6750\n",
            "Epoch 24 Batch 200 Loss 0.2590 Accuracy 0.6737\n",
            "Epoch 24 Batch 250 Loss 0.2589 Accuracy 0.6735\n",
            "Validation: Epoch 24 Batch 0 Loss 0.3252 Accuracy 0.6865\n",
            "Saving checkpoint for epoch 24 at ./checkpoints/train/ckpt-12\n",
            "Epoch 24 Loss 0.2585 Accuracy 0.6736\n",
            "Time taken for 1 epoch: 223.83625960350037 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 25 Batch 0 Loss 0.2693 Accuracy 0.6769\n",
            "Epoch 25 Batch 50 Loss 0.2625 Accuracy 0.6714\n",
            "Epoch 25 Batch 100 Loss 0.2588 Accuracy 0.6769\n",
            "Epoch 25 Batch 150 Loss 0.2575 Accuracy 0.6761\n",
            "Epoch 25 Batch 200 Loss 0.2563 Accuracy 0.6753\n",
            "Epoch 25 Batch 250 Loss 0.2560 Accuracy 0.6743\n",
            "Validation: Epoch 25 Batch 0 Loss 0.3271 Accuracy 0.6764\n",
            "Epoch 25 Loss 0.2558 Accuracy 0.6746\n",
            "Time taken for 1 epoch: 225.2371175289154 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 26 Batch 0 Loss 0.2421 Accuracy 0.6875\n",
            "Epoch 26 Batch 50 Loss 0.2549 Accuracy 0.6745\n",
            "Epoch 26 Batch 100 Loss 0.2557 Accuracy 0.6783\n",
            "Epoch 26 Batch 150 Loss 0.2527 Accuracy 0.6782\n",
            "Epoch 26 Batch 200 Loss 0.2512 Accuracy 0.6766\n",
            "Epoch 26 Batch 250 Loss 0.2518 Accuracy 0.6755\n",
            "Validation: Epoch 26 Batch 0 Loss 0.3128 Accuracy 0.6809\n",
            "Saving checkpoint for epoch 26 at ./checkpoints/train/ckpt-13\n",
            "Epoch 26 Loss 0.2523 Accuracy 0.6752\n",
            "Time taken for 1 epoch: 223.2407205104828 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 27 Batch 0 Loss 0.2525 Accuracy 0.7006\n",
            "Epoch 27 Batch 50 Loss 0.2512 Accuracy 0.6773\n",
            "Epoch 27 Batch 100 Loss 0.2500 Accuracy 0.6800\n",
            "Epoch 27 Batch 150 Loss 0.2503 Accuracy 0.6788\n",
            "Epoch 27 Batch 200 Loss 0.2488 Accuracy 0.6771\n",
            "Epoch 27 Batch 250 Loss 0.2484 Accuracy 0.6767\n",
            "Validation: Epoch 27 Batch 0 Loss 0.3205 Accuracy 0.6860\n",
            "Epoch 27 Loss 0.2484 Accuracy 0.6764\n",
            "Time taken for 1 epoch: 224.45982694625854 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 28 Batch 0 Loss 0.2173 Accuracy 0.6850\n",
            "Epoch 28 Batch 50 Loss 0.2462 Accuracy 0.6768\n",
            "Epoch 28 Batch 100 Loss 0.2490 Accuracy 0.6794\n",
            "Epoch 28 Batch 150 Loss 0.2473 Accuracy 0.6798\n",
            "Epoch 28 Batch 200 Loss 0.2456 Accuracy 0.6779\n",
            "Epoch 28 Batch 250 Loss 0.2454 Accuracy 0.6770\n",
            "Validation: Epoch 28 Batch 0 Loss 0.3164 Accuracy 0.6875\n",
            "Saving checkpoint for epoch 28 at ./checkpoints/train/ckpt-14\n",
            "Epoch 28 Loss 0.2450 Accuracy 0.6774\n",
            "Time taken for 1 epoch: 223.79877924919128 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 29 Batch 0 Loss 0.2774 Accuracy 0.6835\n",
            "Epoch 29 Batch 50 Loss 0.2436 Accuracy 0.6780\n",
            "Epoch 29 Batch 100 Loss 0.2438 Accuracy 0.6810\n",
            "Epoch 29 Batch 150 Loss 0.2448 Accuracy 0.6804\n",
            "Epoch 29 Batch 200 Loss 0.2426 Accuracy 0.6781\n",
            "Epoch 29 Batch 250 Loss 0.2429 Accuracy 0.6782\n",
            "Validation: Epoch 29 Batch 0 Loss 0.3237 Accuracy 0.6840\n",
            "Epoch 29 Loss 0.2430 Accuracy 0.6781\n",
            "Time taken for 1 epoch: 222.30528807640076 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 30 Batch 0 Loss 0.2229 Accuracy 0.6905\n",
            "Epoch 30 Batch 50 Loss 0.2423 Accuracy 0.6791\n",
            "Epoch 30 Batch 100 Loss 0.2410 Accuracy 0.6804\n",
            "Epoch 30 Batch 150 Loss 0.2403 Accuracy 0.6810\n",
            "Epoch 30 Batch 200 Loss 0.2387 Accuracy 0.6793\n",
            "Epoch 30 Batch 250 Loss 0.2389 Accuracy 0.6785\n",
            "Validation: Epoch 30 Batch 0 Loss 0.3128 Accuracy 0.6860\n",
            "Saving checkpoint for epoch 30 at ./checkpoints/train/ckpt-15\n",
            "Epoch 30 Loss 0.2390 Accuracy 0.6787\n",
            "Time taken for 1 epoch: 222.82980680465698 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 31 Batch 0 Loss 0.2389 Accuracy 0.6426\n",
            "Epoch 31 Batch 50 Loss 0.2397 Accuracy 0.6802\n",
            "Epoch 31 Batch 100 Loss 0.2385 Accuracy 0.6832\n",
            "Epoch 31 Batch 150 Loss 0.2370 Accuracy 0.6823\n",
            "Epoch 31 Batch 200 Loss 0.2365 Accuracy 0.6807\n",
            "Epoch 31 Batch 250 Loss 0.2362 Accuracy 0.6801\n",
            "Validation: Epoch 31 Batch 0 Loss 0.3248 Accuracy 0.6799\n",
            "Epoch 31 Loss 0.2366 Accuracy 0.6798\n",
            "Time taken for 1 epoch: 222.9881751537323 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 32 Batch 0 Loss 0.2419 Accuracy 0.6673\n",
            "Epoch 32 Batch 50 Loss 0.2321 Accuracy 0.6799\n",
            "Epoch 32 Batch 100 Loss 0.2322 Accuracy 0.6838\n",
            "Epoch 32 Batch 150 Loss 0.2341 Accuracy 0.6823\n",
            "Epoch 32 Batch 200 Loss 0.2334 Accuracy 0.6811\n",
            "Epoch 32 Batch 250 Loss 0.2331 Accuracy 0.6809\n",
            "Validation: Epoch 32 Batch 0 Loss 0.3229 Accuracy 0.6900\n",
            "Saving checkpoint for epoch 32 at ./checkpoints/train/ckpt-16\n",
            "Epoch 32 Loss 0.2330 Accuracy 0.6806\n",
            "Time taken for 1 epoch: 221.01109790802002 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 33 Batch 0 Loss 0.2518 Accuracy 0.6643\n",
            "Epoch 33 Batch 50 Loss 0.2311 Accuracy 0.6804\n",
            "Epoch 33 Batch 100 Loss 0.2305 Accuracy 0.6846\n",
            "Epoch 33 Batch 150 Loss 0.2298 Accuracy 0.6841\n",
            "Epoch 33 Batch 200 Loss 0.2284 Accuracy 0.6820\n",
            "Epoch 33 Batch 250 Loss 0.2283 Accuracy 0.6819\n",
            "Validation: Epoch 33 Batch 0 Loss 0.3065 Accuracy 0.6895\n",
            "Epoch 33 Loss 0.2285 Accuracy 0.6819\n",
            "Time taken for 1 epoch: 229.75016617774963 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 34 Batch 0 Loss 0.2607 Accuracy 0.6724\n",
            "Epoch 34 Batch 50 Loss 0.2227 Accuracy 0.6822\n",
            "Epoch 34 Batch 100 Loss 0.2224 Accuracy 0.6864\n",
            "Epoch 34 Batch 150 Loss 0.2228 Accuracy 0.6855\n",
            "Epoch 34 Batch 200 Loss 0.2212 Accuracy 0.6847\n",
            "Epoch 34 Batch 250 Loss 0.2215 Accuracy 0.6836\n",
            "Validation: Epoch 34 Batch 0 Loss 0.3196 Accuracy 0.6910\n",
            "Saving checkpoint for epoch 34 at ./checkpoints/train/ckpt-17\n",
            "Epoch 34 Loss 0.2218 Accuracy 0.6835\n",
            "Time taken for 1 epoch: 230.7215645313263 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 35 Batch 0 Loss 0.2310 Accuracy 0.6809\n",
            "Epoch 35 Batch 50 Loss 0.2184 Accuracy 0.6831\n",
            "Epoch 35 Batch 100 Loss 0.2221 Accuracy 0.6867\n",
            "Epoch 35 Batch 150 Loss 0.2213 Accuracy 0.6855\n",
            "Epoch 35 Batch 200 Loss 0.2200 Accuracy 0.6844\n",
            "Epoch 35 Batch 250 Loss 0.2191 Accuracy 0.6837\n",
            "Validation: Epoch 35 Batch 0 Loss 0.3182 Accuracy 0.6865\n",
            "Epoch 35 Loss 0.2193 Accuracy 0.6837\n",
            "Time taken for 1 epoch: 230.84742069244385 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 36 Batch 0 Loss 0.2080 Accuracy 0.7122\n",
            "Epoch 36 Batch 50 Loss 0.2170 Accuracy 0.6862\n",
            "Epoch 36 Batch 100 Loss 0.2176 Accuracy 0.6875\n",
            "Epoch 36 Batch 150 Loss 0.2156 Accuracy 0.6878\n",
            "Epoch 36 Batch 200 Loss 0.2148 Accuracy 0.6863\n",
            "Epoch 36 Batch 250 Loss 0.2148 Accuracy 0.6855\n",
            "Validation: Epoch 36 Batch 0 Loss 0.3148 Accuracy 0.6880\n",
            "Saving checkpoint for epoch 36 at ./checkpoints/train/ckpt-18\n",
            "Epoch 36 Loss 0.2150 Accuracy 0.6854\n",
            "Time taken for 1 epoch: 223.55265498161316 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 37 Batch 0 Loss 0.2159 Accuracy 0.6961\n",
            "Epoch 37 Batch 50 Loss 0.2124 Accuracy 0.6867\n",
            "Epoch 37 Batch 100 Loss 0.2116 Accuracy 0.6903\n",
            "Epoch 37 Batch 150 Loss 0.2117 Accuracy 0.6890\n",
            "Epoch 37 Batch 200 Loss 0.2110 Accuracy 0.6873\n",
            "Epoch 37 Batch 250 Loss 0.2113 Accuracy 0.6866\n",
            "Validation: Epoch 37 Batch 0 Loss 0.3125 Accuracy 0.6910\n",
            "Epoch 37 Loss 0.2112 Accuracy 0.6863\n",
            "Time taken for 1 epoch: 223.32363033294678 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 38 Batch 0 Loss 0.2224 Accuracy 0.6830\n",
            "Epoch 38 Batch 50 Loss 0.2088 Accuracy 0.6889\n",
            "Epoch 38 Batch 100 Loss 0.2088 Accuracy 0.6898\n",
            "Epoch 38 Batch 150 Loss 0.2094 Accuracy 0.6894\n",
            "Epoch 38 Batch 200 Loss 0.2080 Accuracy 0.6879\n",
            "Epoch 38 Batch 250 Loss 0.2076 Accuracy 0.6876\n",
            "Validation: Epoch 38 Batch 0 Loss 0.3173 Accuracy 0.6910\n",
            "Saving checkpoint for epoch 38 at ./checkpoints/train/ckpt-19\n",
            "Epoch 38 Loss 0.2074 Accuracy 0.6873\n",
            "Time taken for 1 epoch: 221.05740571022034 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 39 Batch 0 Loss 0.2050 Accuracy 0.6663\n",
            "Epoch 39 Batch 50 Loss 0.2063 Accuracy 0.6874\n",
            "Epoch 39 Batch 100 Loss 0.2050 Accuracy 0.6917\n",
            "Epoch 39 Batch 150 Loss 0.2047 Accuracy 0.6906\n",
            "Epoch 39 Batch 200 Loss 0.2036 Accuracy 0.6882\n",
            "Epoch 39 Batch 250 Loss 0.2038 Accuracy 0.6879\n",
            "Validation: Epoch 39 Batch 0 Loss 0.3194 Accuracy 0.6935\n",
            "Epoch 39 Loss 0.2038 Accuracy 0.6879\n",
            "Time taken for 1 epoch: 222.90049195289612 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 40 Batch 0 Loss 0.2369 Accuracy 0.6845\n",
            "Epoch 40 Batch 50 Loss 0.2027 Accuracy 0.6901\n",
            "Epoch 40 Batch 100 Loss 0.2022 Accuracy 0.6922\n",
            "Epoch 40 Batch 150 Loss 0.2020 Accuracy 0.6915\n",
            "Epoch 40 Batch 200 Loss 0.2003 Accuracy 0.6896\n",
            "Epoch 40 Batch 250 Loss 0.2006 Accuracy 0.6887\n",
            "Validation: Epoch 40 Batch 0 Loss 0.3110 Accuracy 0.6840\n",
            "Saving checkpoint for epoch 40 at ./checkpoints/train/ckpt-20\n",
            "Epoch 40 Loss 0.2005 Accuracy 0.6890\n",
            "Time taken for 1 epoch: 223.35162115097046 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 41 Batch 0 Loss 0.2016 Accuracy 0.6996\n",
            "Epoch 41 Batch 50 Loss 0.1981 Accuracy 0.6919\n",
            "Epoch 41 Batch 100 Loss 0.1985 Accuracy 0.6927\n",
            "Epoch 41 Batch 150 Loss 0.1989 Accuracy 0.6920\n",
            "Epoch 41 Batch 200 Loss 0.1983 Accuracy 0.6898\n",
            "Epoch 41 Batch 250 Loss 0.1973 Accuracy 0.6899\n",
            "Validation: Epoch 41 Batch 0 Loss 0.3221 Accuracy 0.6860\n",
            "Epoch 41 Loss 0.1975 Accuracy 0.6898\n",
            "Time taken for 1 epoch: 223.72390937805176 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 42 Batch 0 Loss 0.1640 Accuracy 0.6895\n",
            "Epoch 42 Batch 50 Loss 0.1950 Accuracy 0.6898\n",
            "Epoch 42 Batch 100 Loss 0.1959 Accuracy 0.6942\n",
            "Epoch 42 Batch 150 Loss 0.1953 Accuracy 0.6931\n",
            "Epoch 42 Batch 200 Loss 0.1945 Accuracy 0.6910\n",
            "Epoch 42 Batch 250 Loss 0.1946 Accuracy 0.6905\n",
            "Validation: Epoch 42 Batch 0 Loss 0.3144 Accuracy 0.6890\n",
            "Saving checkpoint for epoch 42 at ./checkpoints/train/ckpt-21\n",
            "Epoch 42 Loss 0.1945 Accuracy 0.6906\n",
            "Time taken for 1 epoch: 226.73653149604797 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 43 Batch 0 Loss 0.1888 Accuracy 0.6537\n",
            "Epoch 43 Batch 50 Loss 0.1920 Accuracy 0.6950\n",
            "Epoch 43 Batch 100 Loss 0.1918 Accuracy 0.6934\n",
            "Epoch 43 Batch 150 Loss 0.1930 Accuracy 0.6932\n",
            "Epoch 43 Batch 200 Loss 0.1912 Accuracy 0.6920\n",
            "Epoch 43 Batch 250 Loss 0.1916 Accuracy 0.6913\n",
            "Validation: Epoch 43 Batch 0 Loss 0.3105 Accuracy 0.6900\n",
            "Epoch 43 Loss 0.1916 Accuracy 0.6912\n",
            "Time taken for 1 epoch: 224.2961287498474 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 44 Batch 0 Loss 0.1654 Accuracy 0.7016\n",
            "Epoch 44 Batch 50 Loss 0.1892 Accuracy 0.6913\n",
            "Epoch 44 Batch 100 Loss 0.1899 Accuracy 0.6951\n",
            "Epoch 44 Batch 150 Loss 0.1901 Accuracy 0.6945\n",
            "Epoch 44 Batch 200 Loss 0.1889 Accuracy 0.6923\n",
            "Epoch 44 Batch 250 Loss 0.1884 Accuracy 0.6923\n",
            "Validation: Epoch 44 Batch 0 Loss 0.3061 Accuracy 0.6910\n",
            "Saving checkpoint for epoch 44 at ./checkpoints/train/ckpt-22\n",
            "Epoch 44 Loss 0.1883 Accuracy 0.6921\n",
            "Time taken for 1 epoch: 224.24905967712402 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 45 Batch 0 Loss 0.1864 Accuracy 0.6744\n",
            "Epoch 45 Batch 50 Loss 0.1888 Accuracy 0.6920\n",
            "Epoch 45 Batch 100 Loss 0.1875 Accuracy 0.6951\n",
            "Epoch 45 Batch 150 Loss 0.1870 Accuracy 0.6944\n",
            "Epoch 45 Batch 200 Loss 0.1859 Accuracy 0.6937\n",
            "Epoch 45 Batch 250 Loss 0.1864 Accuracy 0.6925\n",
            "Validation: Epoch 45 Batch 0 Loss 0.3208 Accuracy 0.6870\n",
            "Epoch 45 Loss 0.1863 Accuracy 0.6924\n",
            "Time taken for 1 epoch: 223.6235978603363 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 46 Batch 0 Loss 0.1552 Accuracy 0.6880\n",
            "Epoch 46 Batch 50 Loss 0.1844 Accuracy 0.6939\n",
            "Epoch 46 Batch 100 Loss 0.1853 Accuracy 0.6961\n",
            "Epoch 46 Batch 150 Loss 0.1858 Accuracy 0.6951\n",
            "Epoch 46 Batch 200 Loss 0.1843 Accuracy 0.6941\n",
            "Epoch 46 Batch 250 Loss 0.1844 Accuracy 0.6932\n",
            "Validation: Epoch 46 Batch 0 Loss 0.3319 Accuracy 0.6880\n",
            "Saving checkpoint for epoch 46 at ./checkpoints/train/ckpt-23\n",
            "Epoch 46 Loss 0.1844 Accuracy 0.6933\n",
            "Time taken for 1 epoch: 225.07270169258118 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 47 Batch 0 Loss 0.1687 Accuracy 0.7283\n",
            "Epoch 47 Batch 50 Loss 0.1817 Accuracy 0.6927\n",
            "Epoch 47 Batch 100 Loss 0.1820 Accuracy 0.6970\n",
            "Epoch 47 Batch 150 Loss 0.1827 Accuracy 0.6966\n",
            "Epoch 47 Batch 200 Loss 0.1824 Accuracy 0.6941\n",
            "Epoch 47 Batch 250 Loss 0.1823 Accuracy 0.6942\n",
            "Validation: Epoch 47 Batch 0 Loss 0.3041 Accuracy 0.6925\n",
            "Epoch 47 Loss 0.1824 Accuracy 0.6939\n",
            "Time taken for 1 epoch: 226.90287446975708 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 48 Batch 0 Loss 0.2104 Accuracy 0.7051\n",
            "Epoch 48 Batch 50 Loss 0.1741 Accuracy 0.6972\n",
            "Epoch 48 Batch 100 Loss 0.1792 Accuracy 0.6977\n",
            "Epoch 48 Batch 150 Loss 0.1801 Accuracy 0.6965\n",
            "Epoch 48 Batch 200 Loss 0.1793 Accuracy 0.6954\n",
            "Epoch 48 Batch 250 Loss 0.1792 Accuracy 0.6946\n",
            "Validation: Epoch 48 Batch 0 Loss 0.3193 Accuracy 0.6880\n",
            "Saving checkpoint for epoch 48 at ./checkpoints/train/ckpt-24\n",
            "Epoch 48 Loss 0.1795 Accuracy 0.6945\n",
            "Time taken for 1 epoch: 224.6450653076172 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 49 Batch 0 Loss 0.1882 Accuracy 0.6930\n",
            "Epoch 49 Batch 50 Loss 0.1798 Accuracy 0.6945\n",
            "Epoch 49 Batch 100 Loss 0.1787 Accuracy 0.6973\n",
            "Epoch 49 Batch 150 Loss 0.1796 Accuracy 0.6971\n",
            "Epoch 49 Batch 200 Loss 0.1786 Accuracy 0.6957\n",
            "Epoch 49 Batch 250 Loss 0.1780 Accuracy 0.6951\n",
            "Validation: Epoch 49 Batch 0 Loss 0.3188 Accuracy 0.6850\n",
            "Epoch 49 Loss 0.1783 Accuracy 0.6949\n",
            "Time taken for 1 epoch: 225.5461494922638 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 50 Batch 0 Loss 0.1651 Accuracy 0.7031\n",
            "Epoch 50 Batch 50 Loss 0.1745 Accuracy 0.6948\n",
            "Epoch 50 Batch 100 Loss 0.1771 Accuracy 0.6980\n",
            "Epoch 50 Batch 150 Loss 0.1776 Accuracy 0.6969\n",
            "Epoch 50 Batch 200 Loss 0.1765 Accuracy 0.6960\n",
            "Epoch 50 Batch 250 Loss 0.1764 Accuracy 0.6953\n",
            "Validation: Epoch 50 Batch 0 Loss 0.3102 Accuracy 0.6900\n",
            "Saving checkpoint for epoch 50 at ./checkpoints/train/ckpt-25\n",
            "Epoch 50 Loss 0.1763 Accuracy 0.6953\n",
            "Time taken for 1 epoch: 226.41031432151794 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 51 Batch 0 Loss 0.1930 Accuracy 0.6719\n",
            "Epoch 51 Batch 50 Loss 0.1739 Accuracy 0.6963\n",
            "Epoch 51 Batch 100 Loss 0.1747 Accuracy 0.6989\n",
            "Epoch 51 Batch 150 Loss 0.1758 Accuracy 0.6976\n",
            "Epoch 51 Batch 200 Loss 0.1744 Accuracy 0.6971\n",
            "Epoch 51 Batch 250 Loss 0.1749 Accuracy 0.6959\n",
            "Validation: Epoch 51 Batch 0 Loss 0.3211 Accuracy 0.6860\n",
            "Epoch 51 Loss 0.1752 Accuracy 0.6956\n",
            "Time taken for 1 epoch: 224.65119242668152 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 52 Batch 0 Loss 0.1805 Accuracy 0.6840\n",
            "Epoch 52 Batch 50 Loss 0.1726 Accuracy 0.6985\n",
            "Epoch 52 Batch 100 Loss 0.1723 Accuracy 0.6993\n",
            "Epoch 52 Batch 150 Loss 0.1734 Accuracy 0.6983\n",
            "Epoch 52 Batch 200 Loss 0.1721 Accuracy 0.6970\n",
            "Epoch 52 Batch 250 Loss 0.1721 Accuracy 0.6962\n",
            "Validation: Epoch 52 Batch 0 Loss 0.3350 Accuracy 0.6845\n",
            "Saving checkpoint for epoch 52 at ./checkpoints/train/ckpt-26\n",
            "Epoch 52 Loss 0.1724 Accuracy 0.6963\n",
            "Time taken for 1 epoch: 225.7683835029602 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 53 Batch 0 Loss 0.1630 Accuracy 0.7177\n",
            "Epoch 53 Batch 50 Loss 0.1703 Accuracy 0.6976\n",
            "Epoch 53 Batch 100 Loss 0.1713 Accuracy 0.6990\n",
            "Epoch 53 Batch 150 Loss 0.1723 Accuracy 0.6988\n",
            "Epoch 53 Batch 200 Loss 0.1703 Accuracy 0.6974\n",
            "Epoch 53 Batch 250 Loss 0.1708 Accuracy 0.6965\n",
            "Validation: Epoch 53 Batch 0 Loss 0.3220 Accuracy 0.6900\n",
            "Epoch 53 Loss 0.1710 Accuracy 0.6966\n",
            "Time taken for 1 epoch: 225.70827221870422 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 54 Batch 0 Loss 0.1635 Accuracy 0.7339\n",
            "Epoch 54 Batch 50 Loss 0.1703 Accuracy 0.6969\n",
            "Epoch 54 Batch 100 Loss 0.1705 Accuracy 0.7002\n",
            "Epoch 54 Batch 150 Loss 0.1711 Accuracy 0.7001\n",
            "Epoch 54 Batch 200 Loss 0.1697 Accuracy 0.6980\n",
            "Epoch 54 Batch 250 Loss 0.1697 Accuracy 0.6973\n",
            "Validation: Epoch 54 Batch 0 Loss 0.3268 Accuracy 0.6870\n",
            "Saving checkpoint for epoch 54 at ./checkpoints/train/ckpt-27\n",
            "Epoch 54 Loss 0.1697 Accuracy 0.6972\n",
            "Time taken for 1 epoch: 226.6697347164154 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 55 Batch 0 Loss 0.1735 Accuracy 0.7097\n",
            "Epoch 55 Batch 50 Loss 0.1695 Accuracy 0.6972\n",
            "Epoch 55 Batch 100 Loss 0.1691 Accuracy 0.7003\n",
            "Epoch 55 Batch 150 Loss 0.1691 Accuracy 0.7002\n",
            "Epoch 55 Batch 200 Loss 0.1676 Accuracy 0.6980\n",
            "Epoch 55 Batch 250 Loss 0.1679 Accuracy 0.6972\n",
            "Validation: Epoch 55 Batch 0 Loss 0.3198 Accuracy 0.6885\n",
            "Epoch 55 Loss 0.1681 Accuracy 0.6975\n",
            "Time taken for 1 epoch: 220.83043789863586 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 56 Batch 0 Loss 0.1390 Accuracy 0.7298\n",
            "Epoch 56 Batch 50 Loss 0.1628 Accuracy 0.6977\n",
            "Epoch 56 Batch 100 Loss 0.1656 Accuracy 0.7009\n",
            "Epoch 56 Batch 150 Loss 0.1679 Accuracy 0.7002\n",
            "Epoch 56 Batch 200 Loss 0.1663 Accuracy 0.6991\n",
            "Epoch 56 Batch 250 Loss 0.1667 Accuracy 0.6983\n",
            "Validation: Epoch 56 Batch 0 Loss 0.3133 Accuracy 0.6885\n",
            "Saving checkpoint for epoch 56 at ./checkpoints/train/ckpt-28\n",
            "Epoch 56 Loss 0.1667 Accuracy 0.6981\n",
            "Time taken for 1 epoch: 223.55752277374268 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 57 Batch 0 Loss 0.1771 Accuracy 0.6961\n",
            "Epoch 57 Batch 50 Loss 0.1627 Accuracy 0.6991\n",
            "Epoch 57 Batch 100 Loss 0.1654 Accuracy 0.7017\n",
            "Epoch 57 Batch 150 Loss 0.1658 Accuracy 0.7009\n",
            "Epoch 57 Batch 200 Loss 0.1646 Accuracy 0.6991\n",
            "Epoch 57 Batch 250 Loss 0.1647 Accuracy 0.6986\n",
            "Validation: Epoch 57 Batch 0 Loss 0.3117 Accuracy 0.6875\n",
            "Epoch 57 Loss 0.1648 Accuracy 0.6985\n",
            "Time taken for 1 epoch: 223.29029512405396 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 58 Batch 0 Loss 0.1717 Accuracy 0.7223\n",
            "Epoch 58 Batch 50 Loss 0.1619 Accuracy 0.6981\n",
            "Epoch 58 Batch 100 Loss 0.1633 Accuracy 0.7014\n",
            "Epoch 58 Batch 150 Loss 0.1640 Accuracy 0.7012\n",
            "Epoch 58 Batch 200 Loss 0.1635 Accuracy 0.6989\n",
            "Epoch 58 Batch 250 Loss 0.1631 Accuracy 0.6988\n",
            "Validation: Epoch 58 Batch 0 Loss 0.3274 Accuracy 0.6855\n",
            "Saving checkpoint for epoch 58 at ./checkpoints/train/ckpt-29\n",
            "Epoch 58 Loss 0.1632 Accuracy 0.6986\n",
            "Time taken for 1 epoch: 225.576500415802 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 59 Batch 0 Loss 0.1446 Accuracy 0.6769\n",
            "Epoch 59 Batch 50 Loss 0.1602 Accuracy 0.7009\n",
            "Epoch 59 Batch 100 Loss 0.1616 Accuracy 0.7024\n",
            "Epoch 59 Batch 150 Loss 0.1629 Accuracy 0.7010\n",
            "Epoch 59 Batch 200 Loss 0.1612 Accuracy 0.6999\n",
            "Epoch 59 Batch 250 Loss 0.1613 Accuracy 0.6991\n",
            "Validation: Epoch 59 Batch 0 Loss 0.3140 Accuracy 0.6855\n",
            "Epoch 59 Loss 0.1613 Accuracy 0.6992\n",
            "Time taken for 1 epoch: 226.3380949497223 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 60 Batch 0 Loss 0.1704 Accuracy 0.6915\n",
            "Epoch 60 Batch 50 Loss 0.1573 Accuracy 0.7027\n",
            "Epoch 60 Batch 100 Loss 0.1601 Accuracy 0.7032\n",
            "Epoch 60 Batch 150 Loss 0.1610 Accuracy 0.7018\n",
            "Epoch 60 Batch 200 Loss 0.1604 Accuracy 0.6998\n",
            "Epoch 60 Batch 250 Loss 0.1603 Accuracy 0.6996\n",
            "Validation: Epoch 60 Batch 0 Loss 0.3228 Accuracy 0.6809\n",
            "Saving checkpoint for epoch 60 at ./checkpoints/train/ckpt-30\n",
            "Epoch 60 Loss 0.1605 Accuracy 0.6995\n",
            "Time taken for 1 epoch: 223.87007331848145 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 61 Batch 0 Loss 0.1668 Accuracy 0.7117\n",
            "Epoch 61 Batch 50 Loss 0.1617 Accuracy 0.6988\n",
            "Epoch 61 Batch 100 Loss 0.1596 Accuracy 0.7023\n",
            "Epoch 61 Batch 150 Loss 0.1600 Accuracy 0.7019\n",
            "Epoch 61 Batch 200 Loss 0.1588 Accuracy 0.7004\n",
            "Epoch 61 Batch 250 Loss 0.1587 Accuracy 0.6998\n",
            "Validation: Epoch 61 Batch 0 Loss 0.3203 Accuracy 0.6875\n",
            "Epoch 61 Loss 0.1589 Accuracy 0.6998\n",
            "Time taken for 1 epoch: 223.66655826568604 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 62 Batch 0 Loss 0.1764 Accuracy 0.6966\n",
            "Epoch 62 Batch 50 Loss 0.1585 Accuracy 0.7002\n",
            "Epoch 62 Batch 100 Loss 0.1581 Accuracy 0.7022\n",
            "Epoch 62 Batch 150 Loss 0.1594 Accuracy 0.7022\n",
            "Epoch 62 Batch 200 Loss 0.1580 Accuracy 0.7011\n",
            "Epoch 62 Batch 250 Loss 0.1580 Accuracy 0.7000\n",
            "Validation: Epoch 62 Batch 0 Loss 0.3320 Accuracy 0.6845\n",
            "Saving checkpoint for epoch 62 at ./checkpoints/train/ckpt-31\n",
            "Epoch 62 Loss 0.1582 Accuracy 0.6998\n",
            "Time taken for 1 epoch: 222.8333704471588 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 63 Batch 0 Loss 0.1690 Accuracy 0.6815\n",
            "Epoch 63 Batch 50 Loss 0.1549 Accuracy 0.7012\n",
            "Epoch 63 Batch 100 Loss 0.1560 Accuracy 0.7035\n",
            "Epoch 63 Batch 150 Loss 0.1570 Accuracy 0.7031\n",
            "Epoch 63 Batch 200 Loss 0.1555 Accuracy 0.7015\n",
            "Epoch 63 Batch 250 Loss 0.1561 Accuracy 0.7007\n",
            "Validation: Epoch 63 Batch 0 Loss 0.3264 Accuracy 0.6865\n",
            "Epoch 63 Loss 0.1562 Accuracy 0.7006\n",
            "Time taken for 1 epoch: 224.87813067436218 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 64 Batch 0 Loss 0.1556 Accuracy 0.6991\n",
            "Epoch 64 Batch 50 Loss 0.1565 Accuracy 0.6997\n",
            "Epoch 64 Batch 100 Loss 0.1566 Accuracy 0.7044\n",
            "Epoch 64 Batch 150 Loss 0.1566 Accuracy 0.7036\n",
            "Epoch 64 Batch 200 Loss 0.1553 Accuracy 0.7022\n",
            "Epoch 64 Batch 250 Loss 0.1553 Accuracy 0.7009\n",
            "Validation: Epoch 64 Batch 0 Loss 0.3265 Accuracy 0.6830\n",
            "Saving checkpoint for epoch 64 at ./checkpoints/train/ckpt-32\n",
            "Epoch 64 Loss 0.1556 Accuracy 0.7009\n",
            "Time taken for 1 epoch: 225.2217526435852 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 65 Batch 0 Loss 0.1791 Accuracy 0.6578\n",
            "Epoch 65 Batch 50 Loss 0.1546 Accuracy 0.7024\n",
            "Epoch 65 Batch 100 Loss 0.1529 Accuracy 0.7045\n",
            "Epoch 65 Batch 150 Loss 0.1544 Accuracy 0.7033\n",
            "Epoch 65 Batch 200 Loss 0.1533 Accuracy 0.7026\n",
            "Epoch 65 Batch 250 Loss 0.1537 Accuracy 0.7015\n",
            "Validation: Epoch 65 Batch 0 Loss 0.3286 Accuracy 0.6835\n",
            "Epoch 65 Loss 0.1540 Accuracy 0.7013\n",
            "Time taken for 1 epoch: 223.61333012580872 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 66 Batch 0 Loss 0.1716 Accuracy 0.6935\n",
            "Epoch 66 Batch 50 Loss 0.1518 Accuracy 0.7022\n",
            "Epoch 66 Batch 100 Loss 0.1517 Accuracy 0.7049\n",
            "Epoch 66 Batch 150 Loss 0.1544 Accuracy 0.7040\n",
            "Epoch 66 Batch 200 Loss 0.1534 Accuracy 0.7021\n",
            "Epoch 66 Batch 250 Loss 0.1536 Accuracy 0.7014\n",
            "Validation: Epoch 66 Batch 0 Loss 0.3264 Accuracy 0.6875\n",
            "Saving checkpoint for epoch 66 at ./checkpoints/train/ckpt-33\n",
            "Epoch 66 Loss 0.1539 Accuracy 0.7012\n",
            "Time taken for 1 epoch: 224.93972659111023 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 67 Batch 0 Loss 0.1668 Accuracy 0.6658\n",
            "Epoch 67 Batch 50 Loss 0.1498 Accuracy 0.7028\n",
            "Epoch 67 Batch 100 Loss 0.1490 Accuracy 0.7058\n",
            "Epoch 67 Batch 150 Loss 0.1511 Accuracy 0.7035\n",
            "Epoch 67 Batch 200 Loss 0.1500 Accuracy 0.7026\n",
            "Epoch 67 Batch 250 Loss 0.1502 Accuracy 0.7021\n",
            "Validation: Epoch 67 Batch 0 Loss 0.3287 Accuracy 0.6850\n",
            "Epoch 67 Loss 0.1504 Accuracy 0.7020\n",
            "Time taken for 1 epoch: 227.75531125068665 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 68 Batch 0 Loss 0.1269 Accuracy 0.7036\n",
            "Epoch 68 Batch 50 Loss 0.1503 Accuracy 0.7014\n",
            "Epoch 68 Batch 100 Loss 0.1496 Accuracy 0.7060\n",
            "Epoch 68 Batch 150 Loss 0.1507 Accuracy 0.7052\n",
            "Epoch 68 Batch 200 Loss 0.1499 Accuracy 0.7031\n",
            "Epoch 68 Batch 250 Loss 0.1499 Accuracy 0.7024\n",
            "Validation: Epoch 68 Batch 0 Loss 0.3329 Accuracy 0.6845\n",
            "Saving checkpoint for epoch 68 at ./checkpoints/train/ckpt-34\n",
            "Epoch 68 Loss 0.1502 Accuracy 0.7021\n",
            "Time taken for 1 epoch: 225.03728127479553 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 69 Batch 0 Loss 0.1351 Accuracy 0.7182\n",
            "Epoch 69 Batch 50 Loss 0.1489 Accuracy 0.7024\n",
            "Epoch 69 Batch 100 Loss 0.1487 Accuracy 0.7061\n",
            "Epoch 69 Batch 150 Loss 0.1497 Accuracy 0.7051\n",
            "Epoch 69 Batch 200 Loss 0.1486 Accuracy 0.7029\n",
            "Epoch 69 Batch 250 Loss 0.1492 Accuracy 0.7025\n",
            "Validation: Epoch 69 Batch 0 Loss 0.3368 Accuracy 0.6784\n",
            "Epoch 69 Loss 0.1493 Accuracy 0.7024\n",
            "Time taken for 1 epoch: 224.42177867889404 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 70 Batch 0 Loss 0.1463 Accuracy 0.7273\n",
            "Epoch 70 Batch 50 Loss 0.1489 Accuracy 0.7027\n",
            "Epoch 70 Batch 100 Loss 0.1482 Accuracy 0.7060\n",
            "Epoch 70 Batch 150 Loss 0.1492 Accuracy 0.7052\n",
            "Epoch 70 Batch 200 Loss 0.1477 Accuracy 0.7035\n",
            "Epoch 70 Batch 250 Loss 0.1482 Accuracy 0.7024\n",
            "Validation: Epoch 70 Batch 0 Loss 0.3312 Accuracy 0.6845\n",
            "Saving checkpoint for epoch 70 at ./checkpoints/train/ckpt-35\n",
            "Epoch 70 Loss 0.1482 Accuracy 0.7027\n",
            "Time taken for 1 epoch: 221.34894633293152 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 71 Batch 0 Loss 0.1430 Accuracy 0.7394\n",
            "Epoch 71 Batch 50 Loss 0.1490 Accuracy 0.7036\n",
            "Epoch 71 Batch 100 Loss 0.1470 Accuracy 0.7058\n",
            "Epoch 71 Batch 150 Loss 0.1485 Accuracy 0.7049\n",
            "Epoch 71 Batch 200 Loss 0.1478 Accuracy 0.7032\n",
            "Epoch 71 Batch 250 Loss 0.1471 Accuracy 0.7027\n",
            "Validation: Epoch 71 Batch 0 Loss 0.3264 Accuracy 0.6880\n",
            "Epoch 71 Loss 0.1473 Accuracy 0.7026\n",
            "Time taken for 1 epoch: 221.34000492095947 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 72 Batch 0 Loss 0.1502 Accuracy 0.6840\n",
            "Epoch 72 Batch 50 Loss 0.1463 Accuracy 0.7028\n",
            "Epoch 72 Batch 100 Loss 0.1465 Accuracy 0.7060\n",
            "Epoch 72 Batch 150 Loss 0.1474 Accuracy 0.7059\n",
            "Epoch 72 Batch 200 Loss 0.1455 Accuracy 0.7042\n",
            "Epoch 72 Batch 250 Loss 0.1454 Accuracy 0.7034\n",
            "Validation: Epoch 72 Batch 0 Loss 0.3291 Accuracy 0.6870\n",
            "Saving checkpoint for epoch 72 at ./checkpoints/train/ckpt-36\n",
            "Epoch 72 Loss 0.1456 Accuracy 0.7034\n",
            "Time taken for 1 epoch: 219.71165013313293 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 73 Batch 0 Loss 0.1533 Accuracy 0.7490\n",
            "Epoch 73 Batch 50 Loss 0.1441 Accuracy 0.7038\n",
            "Epoch 73 Batch 100 Loss 0.1439 Accuracy 0.7070\n",
            "Epoch 73 Batch 150 Loss 0.1450 Accuracy 0.7064\n",
            "Epoch 73 Batch 200 Loss 0.1447 Accuracy 0.7040\n",
            "Epoch 73 Batch 250 Loss 0.1451 Accuracy 0.7035\n",
            "Validation: Epoch 73 Batch 0 Loss 0.3451 Accuracy 0.6835\n",
            "Epoch 73 Loss 0.1452 Accuracy 0.7034\n",
            "Time taken for 1 epoch: 218.9493305683136 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 74 Batch 0 Loss 0.1451 Accuracy 0.6991\n",
            "Epoch 74 Batch 50 Loss 0.1441 Accuracy 0.7028\n",
            "Epoch 74 Batch 100 Loss 0.1437 Accuracy 0.7077\n",
            "Epoch 74 Batch 150 Loss 0.1447 Accuracy 0.7058\n",
            "Epoch 74 Batch 200 Loss 0.1437 Accuracy 0.7043\n",
            "Epoch 74 Batch 250 Loss 0.1435 Accuracy 0.7038\n",
            "Validation: Epoch 74 Batch 0 Loss 0.3412 Accuracy 0.6830\n",
            "Saving checkpoint for epoch 74 at ./checkpoints/train/ckpt-37\n",
            "Epoch 74 Loss 0.1437 Accuracy 0.7038\n",
            "Time taken for 1 epoch: 222.7282009124756 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 75 Batch 0 Loss 0.1379 Accuracy 0.7293\n",
            "Epoch 75 Batch 50 Loss 0.1413 Accuracy 0.7038\n",
            "Epoch 75 Batch 100 Loss 0.1419 Accuracy 0.7071\n",
            "Epoch 75 Batch 150 Loss 0.1433 Accuracy 0.7062\n",
            "Epoch 75 Batch 200 Loss 0.1422 Accuracy 0.7048\n",
            "Epoch 75 Batch 250 Loss 0.1422 Accuracy 0.7042\n",
            "Validation: Epoch 75 Batch 0 Loss 0.3354 Accuracy 0.6920\n",
            "Epoch 75 Loss 0.1423 Accuracy 0.7041\n",
            "Time taken for 1 epoch: 224.21716451644897 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 76 Batch 0 Loss 0.1461 Accuracy 0.6739\n",
            "Epoch 76 Batch 50 Loss 0.1418 Accuracy 0.7050\n",
            "Epoch 76 Batch 100 Loss 0.1412 Accuracy 0.7074\n",
            "Epoch 76 Batch 150 Loss 0.1427 Accuracy 0.7071\n",
            "Epoch 76 Batch 200 Loss 0.1418 Accuracy 0.7052\n",
            "Epoch 76 Batch 250 Loss 0.1415 Accuracy 0.7046\n",
            "Validation: Epoch 76 Batch 0 Loss 0.3390 Accuracy 0.6895\n",
            "Saving checkpoint for epoch 76 at ./checkpoints/train/ckpt-38\n",
            "Epoch 76 Loss 0.1415 Accuracy 0.7044\n",
            "Time taken for 1 epoch: 226.31323432922363 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 77 Batch 0 Loss 0.1536 Accuracy 0.6673\n",
            "Epoch 77 Batch 50 Loss 0.1396 Accuracy 0.7049\n",
            "Epoch 77 Batch 100 Loss 0.1397 Accuracy 0.7075\n",
            "Epoch 77 Batch 150 Loss 0.1413 Accuracy 0.7068\n",
            "Epoch 77 Batch 200 Loss 0.1404 Accuracy 0.7051\n",
            "Epoch 77 Batch 250 Loss 0.1404 Accuracy 0.7045\n",
            "Validation: Epoch 77 Batch 0 Loss 0.3444 Accuracy 0.6825\n",
            "Epoch 77 Loss 0.1405 Accuracy 0.7047\n",
            "Time taken for 1 epoch: 224.6056957244873 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 78 Batch 0 Loss 0.1409 Accuracy 0.6910\n",
            "Epoch 78 Batch 50 Loss 0.1377 Accuracy 0.7059\n",
            "Epoch 78 Batch 100 Loss 0.1397 Accuracy 0.7082\n",
            "Epoch 78 Batch 150 Loss 0.1401 Accuracy 0.7066\n",
            "Epoch 78 Batch 200 Loss 0.1398 Accuracy 0.7053\n",
            "Epoch 78 Batch 250 Loss 0.1395 Accuracy 0.7051\n",
            "Validation: Epoch 78 Batch 0 Loss 0.3494 Accuracy 0.6840\n",
            "Saving checkpoint for epoch 78 at ./checkpoints/train/ckpt-39\n",
            "Epoch 78 Loss 0.1397 Accuracy 0.7049\n",
            "Time taken for 1 epoch: 228.56453704833984 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 79 Batch 0 Loss 0.1409 Accuracy 0.7097\n",
            "Epoch 79 Batch 50 Loss 0.1381 Accuracy 0.7064\n",
            "Epoch 79 Batch 100 Loss 0.1375 Accuracy 0.7093\n",
            "Epoch 79 Batch 150 Loss 0.1389 Accuracy 0.7080\n",
            "Epoch 79 Batch 200 Loss 0.1376 Accuracy 0.7061\n",
            "Epoch 79 Batch 250 Loss 0.1380 Accuracy 0.7055\n",
            "Validation: Epoch 79 Batch 0 Loss 0.3457 Accuracy 0.6820\n",
            "Epoch 79 Loss 0.1380 Accuracy 0.7055\n",
            "Time taken for 1 epoch: 231.22347593307495 secs\n",
            "\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Reading examples from TFDS: groove/2bar-midionly\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "The number of elements is this dataset is: -2\n",
            "Epoch 80 Batch 0 Loss 0.1415 Accuracy 0.7122\n",
            "Epoch 80 Batch 50 Loss 0.1353 Accuracy 0.7073\n",
            "Epoch 80 Batch 100 Loss 0.1372 Accuracy 0.7089\n",
            "Epoch 80 Batch 150 Loss 0.1377 Accuracy 0.7080\n",
            "Epoch 80 Batch 200 Loss 0.1374 Accuracy 0.7062\n",
            "Epoch 80 Batch 250 Loss 0.1376 Accuracy 0.7053\n",
            "Validation: Epoch 80 Batch 0 Loss 0.3599 Accuracy 0.6855\n",
            "Saving checkpoint for epoch 80 at ./checkpoints/train/ckpt-40\n",
            "Epoch 80 Loss 0.1376 Accuracy 0.7053\n",
            "Time taken for 1 epoch: 226.84688353538513 secs\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0cxkqPCGUNH2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "outputId": "103473ce-5d55-40e0-8f95-68e4cb1b3e68"
      },
      "source": [
        "N = np.arange(0, EPOCHS)\n",
        "plt.style.use(\"ggplot\")\n",
        "plt.figure()\n",
        "plt.plot(N, loss, label=\"train_loss\")\n",
        "plt.plot(N, val_Loss, label=\"val_loss\")\n",
        "plt.title(\"Training Loss\")\n",
        "plt.xlabel(\"Epoch #\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend(loc=\"lower left\")\n",
        "plt.savefig(\"losses.png\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kiPtZ3q6VjTH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(loss)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HNYnTAlgjfil",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 274
        },
        "outputId": "6cca12b5-101c-40fe-abde-3405c8aad4d0"
      },
      "source": [
        "transformer.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"transformer\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "encoder (Encoder)            multiple                  462336    \n",
            "_________________________________________________________________\n",
            "decoder (Decoder)            multiple                  594944    \n",
            "_________________________________________________________________\n",
            "dense_32 (Dense)             multiple                  66306     \n",
            "=================================================================\n",
            "Total params: 1,123,586\n",
            "Trainable params: 1,123,586\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "quYuPxNoP66d",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 55
        },
        "outputId": "16652eba-6f96-4138-ac11-a3486f4c07e1"
      },
      "source": [
        "print(dir(transformer.layers[2]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['_TF_MODULE_IGNORED_PROPERTIES', '__call__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_activity_regularizer', '_add_inbound_node', '_add_variable_with_custom_getter', '_autocast', '_call_accepts_kwargs', '_call_arg_was_passed', '_call_fn_args', '_callable_losses', '_checkpoint_dependencies', '_clear_losses', '_collect_input_masks', '_compute_dtype', '_deferred_dependencies', '_dtype', '_dtype_defaulted_to_floatx', '_dtype_policy', '_dynamic', '_eager_add_metric', '_eager_losses', '_expects_mask_arg', '_expects_training_arg', '_flatten', '_gather_children_attribute', '_gather_saveables_for_checkpoint', '_get_call_arg_value', '_get_existing_metric', '_get_node_attribute_at_index', '_get_trainable_state', '_handle_activity_regularization', '_handle_deferred_dependencies', '_handle_weight_regularization', '_inbound_nodes', '_init_call_fn_args', '_init_set_name', '_initial_weights', '_input_spec', '_is_layer', '_keras_api_names', '_keras_api_names_v1', '_layers', '_list_extra_dependencies_for_serialization', '_list_functions_for_serialization', '_lookup_dependency', '_losses', '_maybe_build', '_maybe_cast_inputs', '_maybe_create_attribute', '_maybe_initialize_trackable', '_metrics', '_name', '_name_based_attribute_restore', '_name_based_restores', '_name_scope', '_no_dependency', '_non_trainable_weights', '_obj_reference_counts', '_obj_reference_counts_dict', '_object_identifier', '_outbound_nodes', '_preload_simple_restoration', '_restore_from_checkpoint_position', '_self_name_based_restores', '_self_setattr_tracking', '_self_unconditional_checkpoint_dependencies', '_self_unconditional_deferred_dependencies', '_self_unconditional_dependency_names', '_self_update_uid', '_set_connectivity_metadata_', '_set_dtype_policy', '_set_mask_metadata', '_set_trainable_state', '_setattr_tracking', '_should_compute_mask', '_single_restoration_from_checkpoint_position', '_symbolic_add_metric', '_symbolic_call', '_tf_api_names', '_tf_api_names_v1', '_thread_local', '_track_trackable', '_tracking_metadata', '_trainable', '_trainable_weights', '_unconditional_checkpoint_dependencies', '_unconditional_dependency_names', '_unique_trainable_weights', '_update_uid', '_updates', '_warn_about_input_casting', 'activation', 'activity_regularizer', 'add_loss', 'add_metric', 'add_update', 'add_variable', 'add_weight', 'apply', 'bias', 'bias_constraint', 'bias_initializer', 'bias_regularizer', 'build', 'built', 'call', 'compute_mask', 'compute_output_shape', 'compute_output_signature', 'count_params', 'dtype', 'dynamic', 'from_config', 'get_config', 'get_input_at', 'get_input_mask_at', 'get_input_shape_at', 'get_losses_for', 'get_output_at', 'get_output_mask_at', 'get_output_shape_at', 'get_updates_for', 'get_weights', 'inbound_nodes', 'input', 'input_mask', 'input_shape', 'input_spec', 'kernel', 'kernel_constraint', 'kernel_initializer', 'kernel_regularizer', 'losses', 'metrics', 'name', 'name_scope', 'non_trainable_variables', 'non_trainable_weights', 'outbound_nodes', 'output', 'output_mask', 'output_shape', 'set_weights', 'stateful', 'submodules', 'supports_masking', 'trainable', 'trainable_variables', 'trainable_weights', 'units', 'updates', 'use_bias', 'variables', 'weights', 'with_name_scope']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UEpiO1FpiBr6",
        "colab_type": "text"
      },
      "source": [
        "### To be done\n",
        "\n",
        "\n",
        "* Design and run two/three experiments\n",
        "\n",
        "* Add Tokenzed -> Tensor function\n",
        "* Add Tensor -> MIDI function(WIthout the expressive features)\n",
        "\n",
        "* Add tensorboard visualisation for embedding layer\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4jOD43OF5Qv9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a8074d2c-d237-4e08-f83e-91ea12c19045"
      },
      "source": [
        "ls"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[0m\u001b[01;34mcheckpoints\u001b[0m/  \u001b[01;34msample_data\u001b[0m/\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YV1didm7N6Lh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i0R4EpgeN-Li",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DaOgZosgOAOS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}