training_test.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled0.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "[View in Colaboratory](https://colab.research.google.com/github/plushvoxel/Project-Lernende-Agenten-colab/blob/master/training_test.ipynb)"
      ]
    },
    {
      "metadata": {
        "id": "IZ77XA21RRv2",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from __future__ import print_function\n",
        "\n",
        "import math\n",
        "\n",
        "from IPython import display\n",
        "from matplotlib import cm\n",
        "from matplotlib import gridspec\n",
        "from matplotlib import pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn import metrics\n",
        "import tensorflow as tf\n",
        "from tensorflow.python.data import Dataset\n",
        "from google.colab import files\n",
        "from google.colab import drive\n",
        "from os import walk\n",
        "from pandas import DataFrame\n",
        "from struct import unpack\n",
        "\n",
        "from IPython.display import HTML, display\n",
        "\n",
        "def progress(value, max=100):\n",
        "    return HTML(\"\"\"\n",
        "        <progress\n",
        "            value='{value}'\n",
        "            max='{max}',\n",
        "            style='width: 100%'\n",
        "        >\n",
        "            {value}\n",
        "        </progress>\n",
        "    \"\"\".format(value=value, max=max))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Zteo39PgbnSP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4238ae08-ea1d-4105-adf4-0df4845acb30"
      },
      "cell_type": "code",
      "source": [
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/gdrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "gaZUGM0eNEXo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0f513202-84b9-415a-aa48-8b5341bb6a71"
      },
      "cell_type": "code",
      "source": [
        "data_dict = {'label': [], 'in_phase': [], 'quadrature_phase': []}\n",
        "\n",
        "for subdirs, dirs, files in walk(\"/content/gdrive/My Drive/HAW/Project Lernende Agenten/samples/iq\"):\n",
        "  count = 0\n",
        "  out = display(progress(0, len(files)), display_id=True)\n",
        "  for file in files:\n",
        "    label = file[0:2]\n",
        "    with open(\"/content/gdrive/My Drive/HAW/Project Lernende Agenten/samples/iq/{}\".format(file), 'rb') as f:\n",
        "        buffer = f.read()\n",
        "        num_floats = len(buffer)//4\n",
        "        floats = unpack(\"f\"*num_floats, buffer)\n",
        "        i = floats[0::2]\n",
        "        q = floats[1::2]\n",
        "        data_dict['label'].append(label)\n",
        "        data_dict['in_phase'].append(i)\n",
        "        data_dict['quadrature_phase'].append(q)\n",
        "    count += 1\n",
        "    out.update(progress(count, len(files)))\n",
        "df = DataFrame(data=data_dict)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "        <progress\n",
              "            value='220'\n",
              "            max='220',\n",
              "            style='width: 100%'\n",
              "        >\n",
              "            220\n",
              "        </progress>\n",
              "    "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "o7V2vugQP7k9",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "training_set_size = 180 #@param {type:\"slider\", min:1, max:3000, step:1}\n",
        "validating_set_size = 20 #@param {type:\"slider\", min:1, max:1000, step:1}\n",
        "test_set_size = 20 #@param {type:\"slider\", min:1, max:1000, step:1}\n",
        "learning_rate = 0.3 #@param [\"3\", \"1\", \"0.3\", \"0.1\", \"0.03\", \"0.01\", \"0.003\", \"0.001\", \"0.0003\", \"0.0001\"] {type:\"raw\"}\n",
        "activation_function = \"RELU\" #@param [\"RELU\", \"Sigmoid\", \"Tanh\"]\n",
        "regression = \"None\" #@param [\"None\", \"L1\", \"L2\"]\n",
        "regression_rate = 3 #@param [\"3\", \"1\", \"0.3\", \"0.1\", \"0.03\", \"0.01\", \"0.003\", \"0.001\"] {type:\"raw\"}\n",
        "model = [3,1,5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "W16h6WIZQJiS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "tf.logging.set_verbosity(tf.logging.ERROR)\n",
        "pd.options.display.max_rows = 10\n",
        "pd.options.display.float_format = '{:.1f}'.format\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "DliVkbf0QRz3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "c5110929-38a6-49d6-ab07-d19c3ecb8ad7"
      },
      "cell_type": "code",
      "source": [
        "df = df.reindex(np.random.permutation(df.index))\n",
        "\n",
        "training_examples = df.head(training_set_size)[\"in_phase\"]\n",
        "training_targets = df.head(training_set_size)[\"label\"]\n",
        "\n",
        "validation_examples = df.tail(validating_set_size)[\"in_phase\"]\n",
        "validation_targets = df.tail(validating_set_size)[\"label\"]\n",
        "\n",
        "\n",
        "# Double-check that we've done the right thing.\n",
        "print(\"Training examples summary:\")\n",
        "display(training_examples.describe())\n",
        "print(\"Validation examples summary:\")\n",
        "display(validation_examples.describe())\n",
        "\n",
        "print(\"Training targets summary:\")\n",
        "display(training_targets.describe())\n",
        "print(\"Validation targets summary:\")\n",
        "display(validation_targets.describe())"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Training examples summary:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "count                                                   180\n",
              "unique                                                  180\n",
              "top       (0.12009622901678085, -0.9784194231033325, 0.6...\n",
              "freq                                                      1\n",
              "Name: in_phase, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Validation examples summary:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "count                                                    20\n",
              "unique                                                   20\n",
              "top       (1.0192893743515015, 1.0026243925094604, 1.003...\n",
              "freq                                                      1\n",
              "Name: in_phase, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Training targets summary:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "count     180\n",
              "unique      2\n",
              "top        am\n",
              "freq       94\n",
              "Name: label, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Validation targets summary:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "count     20\n",
              "unique     2\n",
              "top       fm\n",
              "freq      12\n",
              "Name: label, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "cL8hoEitTmcu",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def construct_feature_columns(input_features):\n",
        "  \"\"\"Construct the TensorFlow Feature Columns.\n",
        "\n",
        "  Args:\n",
        "    input_features: The names of the numerical input features to use.\n",
        "  Returns:\n",
        "    A set of feature columns\n",
        "  \"\"\" \n",
        "  return set([tf.feature_column.numeric_column(my_feature)\n",
        "              for my_feature in input_features])\n",
        "\n",
        "def my_input_fn(features, targets, batch_size=1, shuffle=True, num_epochs=None):\n",
        "    \"\"\"Trains a neural net regression model.\n",
        "  \n",
        "    Args:\n",
        "      features: pandas DataFrame of features\n",
        "      targets: pandas DataFrame of targets\n",
        "      batch_size: Size of batches to be passed to the model\n",
        "      shuffle: True or False. Whether to shuffle the data.\n",
        "      num_epochs: Number of epochs for which data should be repeated. None = repeat indefinitely\n",
        "    Returns:\n",
        "      Tuple of (features, labels) for next data batch\n",
        "    \"\"\"\n",
        "    \n",
        "    # Convert pandas data into a dict of np arrays.\n",
        "    features = {key:np.array(value) for key,value in dict(features).items()}                                             \n",
        " \n",
        "    # Construct a dataset, and configure batching/repeating.\n",
        "    ds = Dataset.from_tensor_slices((features,targets)) # warning: 2GB limit\n",
        "    ds = ds.batch(batch_size).repeat(num_epochs)\n",
        "    \n",
        "    # Shuffle the data, if specified.\n",
        "    if shuffle:\n",
        "      ds = ds.shuffle(10000)\n",
        "    \n",
        "    # Return the next batch of data.\n",
        "    features, labels = ds.make_one_shot_iterator().get_next()\n",
        "    return features, labels\n",
        "  \n",
        "def train_nn_regression_model(\n",
        "    learning_rate,\n",
        "    steps,\n",
        "    batch_size,\n",
        "    hidden_units,\n",
        "    training_examples,\n",
        "    training_targets,\n",
        "    validation_examples,\n",
        "    validation_targets):\n",
        "  \"\"\"Trains a neural network regression model.\n",
        "  \n",
        "  In addition to training, this function also prints training progress information,\n",
        "  as well as a plot of the training and validation loss over time.\n",
        "  \n",
        "  Args:\n",
        "    learning_rate: A `float`, the learning rate.\n",
        "    steps: A non-zero `int`, the total number of training steps. A training step\n",
        "      consists of a forward and backward pass using a single batch.\n",
        "    batch_size: A non-zero `int`, the batch size.\n",
        "    hidden_units: A `list` of int values, specifying the number of neurons in each layer.\n",
        "    training_examples: A `DataFrame` containing one or more columns from\n",
        "      `signal_dataframe` to use as input features for training.\n",
        "    training_targets: A `DataFrame` containing exactly one column from\n",
        "      `signal_dataframe` to use as target for training.\n",
        "    validation_examples: A `DataFrame` containing one or more columns from\n",
        "      `signal_dataframe` to use as input features for validation.\n",
        "    validation_targets: A `DataFrame` containing exactly one column from\n",
        "      `signal_dataframe` to use as target for validation.\n",
        "      \n",
        "  Returns:\n",
        "    A `DNNRegressor` object trained on the training data.\n",
        "  \"\"\"\n",
        "\n",
        "  periods = 10\n",
        "  steps_per_period = steps / periods\n",
        "  \n",
        "  # Create a DNNRegressor object.\n",
        "  my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)\n",
        "  my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\n",
        "  dnn_regressor = tf.estimator.DNNRegressor(\n",
        "      feature_columns=construct_feature_columns(training_examples),\n",
        "      hidden_units=hidden_units,\n",
        "      optimizer=my_optimizer,\n",
        "  )\n",
        "  \n",
        "  # Create input functions.\n",
        "  training_input_fn = lambda: my_input_fn(training_examples, \n",
        "                                          training_targets[\"classification\"], \n",
        "                                          batch_size=batch_size)\n",
        "  predict_training_input_fn = lambda: my_input_fn(training_examples, \n",
        "                                                  training_targets[\"classification\"], \n",
        "                                                  num_epochs=1, \n",
        "                                                  shuffle=False)\n",
        "  predict_validation_input_fn = lambda: my_input_fn(validation_examples, \n",
        "                                                    validation_targets[\"classification\"], \n",
        "                                                    num_epochs=1, \n",
        "                                                    shuffle=False)\n",
        "\n",
        "  # Train the model, but do so inside a loop so that we can periodically assess\n",
        "  # loss metrics.\n",
        "  print(\"Training model...\")\n",
        "  print(\"RMSE (on training data):\")\n",
        "  training_rmse = []\n",
        "  validation_rmse = []\n",
        "  for period in range (0, periods):\n",
        "    # Train the model, starting from the prior state.\n",
        "    dnn_regressor.train(\n",
        "        input_fn=training_input_fn,\n",
        "        steps=steps_per_period\n",
        "    )\n",
        "    # Take a break and compute predictions.\n",
        "    training_predictions = dnn_regressor.predict(input_fn=predict_training_input_fn)\n",
        "    training_predictions = np.array([item['predictions'][0] for item in training_predictions])\n",
        "    \n",
        "    validation_predictions = dnn_regressor.predict(input_fn=predict_validation_input_fn)\n",
        "    validation_predictions = np.array([item['predictions'][0] for item in validation_predictions])\n",
        "    \n",
        "    # Compute training and validation loss.\n",
        "    training_root_mean_squared_error = math.sqrt(\n",
        "        metrics.mean_squared_error(training_predictions, training_targets))\n",
        "    validation_root_mean_squared_error = math.sqrt(\n",
        "        metrics.mean_squared_error(validation_predictions, validation_targets))\n",
        "    # Occasionally print the current loss.\n",
        "    print(\"  period %02d : %0.2f\" % (period, training_root_mean_squared_error))\n",
        "    # Add the loss metrics from this period to our list.\n",
        "    training_rmse.append(training_root_mean_squared_error)\n",
        "    validation_rmse.append(validation_root_mean_squared_error)\n",
        "  print(\"Model training finished.\")\n",
        "\n",
        "  # Output a graph of loss metrics over periods.\n",
        "  plt.ylabel(\"RMSE\")\n",
        "  plt.xlabel(\"Periods\")\n",
        "  plt.title(\"Root Mean Squared Error vs. Periods\")\n",
        "  plt.tight_layout()\n",
        "  plt.plot(training_rmse, label=\"training\")\n",
        "  plt.plot(validation_rmse, label=\"validation\")\n",
        "  plt.legend()\n",
        "\n",
        "  print(\"Final RMSE (on training data):   %0.2f\" % training_root_mean_squared_error)\n",
        "  print(\"Final RMSE (on validation data): %0.2f\" % validation_root_mean_squared_error)\n",
        "\n",
        "  return dnn_regressor"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "eaY_MkCPTzbp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 830
        },
        "outputId": "f2e19e4d-cf3c-484c-b32f-531e132d64ef"
      },
      "cell_type": "code",
      "source": [
        "dnn_regressor = train_nn_regression_model(\n",
        "    learning_rate=0.001,\n",
        "    steps=2000,\n",
        "    batch_size=100,\n",
        "    hidden_units=[10, 10],\n",
        "    training_examples=training_examples,\n",
        "    training_targets=training_targets,\n",
        "    validation_examples=validation_examples,\n",
        "    validation_targets=validation_targets)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-21-cb61b7baeeb8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mtraining_targets\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtraining_targets\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mvalidation_examples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvalidation_examples\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     validation_targets=validation_targets)\n\u001b[0m",
            "\u001b[0;32m<ipython-input-20-0bc75ce410fa>\u001b[0m in \u001b[0;36mtrain_nn_regression_model\u001b[0;34m(learning_rate, steps, batch_size, hidden_units, training_examples, training_targets, validation_examples, validation_targets)\u001b[0m\n\u001b[1;32m     78\u001b[0m   \u001b[0mmy_optimizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontrib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclip_gradients_by_norm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_optimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     79\u001b[0m   dnn_regressor = tf.estimator.DNNRegressor(\n\u001b[0;32m---> 80\u001b[0;31m       \u001b[0mfeature_columns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mconstruct_feature_columns\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_examples\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     81\u001b[0m       \u001b[0mhidden_units\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mhidden_units\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     82\u001b[0m       \u001b[0moptimizer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmy_optimizer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-20-0bc75ce410fa>\u001b[0m in \u001b[0;36mconstruct_feature_columns\u001b[0;34m(input_features)\u001b[0m\n\u001b[1;32m      8\u001b[0m   \"\"\" \n\u001b[1;32m      9\u001b[0m   return set([tf.feature_column.numeric_column(my_feature)\n\u001b[0;32m---> 10\u001b[0;31m               for my_feature in input_features])\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmy_input_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshuffle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_epochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-20-0bc75ce410fa>\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      8\u001b[0m   \"\"\" \n\u001b[1;32m      9\u001b[0m   return set([tf.feature_column.numeric_column(my_feature)\n\u001b[0;32m---> 10\u001b[0;31m               for my_feature in input_features])\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmy_input_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshuffle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_epochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/feature_column/feature_column.py\u001b[0m in \u001b[0;36mnumeric_column\u001b[0;34m(key, shape, default_value, dtype, normalizer_fn)\u001b[0m\n\u001b[1;32m   1122\u001b[0m         'normalizer_fn must be a callable. Given: {}'.format(normalizer_fn))\n\u001b[1;32m   1123\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1124\u001b[0;31m   \u001b[0m_assert_key_is_string\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1125\u001b[0m   return _NumericColumn(\n\u001b[1;32m   1126\u001b[0m       \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/feature_column/feature_column.py\u001b[0m in \u001b[0;36m_assert_key_is_string\u001b[0;34m(key)\u001b[0m\n\u001b[1;32m   1225\u001b[0m     raise ValueError(\n\u001b[1;32m   1226\u001b[0m         'key must be a string. Got: type {}. Given key: {}.'.format(\n\u001b[0;32m-> 1227\u001b[0;31m             type(key), key))\n\u001b[0m\u001b[1;32m   1228\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1229\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: key must be a string. Got: type <class 'tuple'>. Given key: (0.27420493960380554, -0.9273516535758972, 0.48035722970962524, 0.930853009223938, 0.854324221611023, 0.4045507311820984, -0.048916324973106384, 1.002954125404358, -0.6343683004379272, -0.7683677077293396, -0.3769286572933197, 0.777446985244751, 0.5139727592468262, -0.9987035989761353, 0.9696865677833557, 0.8296384811401367, -0.17225885391235352, -0.0030388925224542618, -0.9823219180107117, -0.8830745220184326, 0.4072173535823822, 0.8065198063850403, 0.8038952350616455, 0.24188879132270813, -0.7827691435813904, -0.9942322373390198, -0.38757577538490295, 0.44109225273132324, 1.0049346685409546, 0.706554114818573, -0.19561436772346497, -0.8888877034187317, -0.8751202821731567, -0.12648020684719086, 0.7290380001068115, 0.9777687191963196, 0.4207572340965271, -0.4798165261745453, -0.986278772354126, -0.696667492389679, 0.18331727385520935, 0.8998295664787292, 0.875961184501648, 0.13408534228801727, -0.7087390422821045, -0.976896345615387, -0.43117284774780273, 0.47782328724861145, 0.981462836265564, 0.6961550712585449, -0.19035273790359497, -0.9013186097145081, -0.8721029162406921, -0.11923778057098389, 0.7293513417243958, 0.9933885335922241, 0.4364708364009857, -0.4880363643169403, -0.9980384707450867, -0.6922681331634521, 0.17829711735248566, 0.9024470448493958, 0.874083399772644, 0.1296432763338089, -0.7185502648353577, -0.9713664054870605, -0.4345686733722687, 0.48067334294319153, 0.99533897..."
          ]
        }
      ]
    }
  ]
}