train_bert.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "PyCharm (MultiModal-Movie-Genre-Analysis)",
      "language": "python",
      "name": "pycharm-90cbde0b"
    },
    "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.7"
    },
    "colab": {
      "name": "train_bert.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sc58E3LKbQS7"
      },
      "source": [
        "#### Get MM-IMDB Database - Extract to data folder"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qza7ybBvbQS8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "694e6b33-7a91-46a7-98b1-1c83006c5d61"
      },
      "source": [
        "!wget -nc http://www.cs.virginia.edu/~vicente/vislang/mmimdb-256.tar.gz\n",
        "!tar xf mmimdb-256.tar.gz -C ./data/mmimdb-256/"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "File ‘mmimdb-256.tar.gz’ already there; not retrieving.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "teerkk8bUjLt",
        "outputId": "85d31d7a-4422-497f-c4d6-3afe6e104e96"
      },
      "source": [
        "pip -q install -r requirements.txt"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "^C\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A8FSZ5suko2W"
      },
      "source": [
        "!pip install livelossplot --quiet\n",
        "!pip -q install transformers"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HgOK-jR1l4Nd"
      },
      "source": [
        "from zipfile import ZipFile \n",
        "\n",
        "\n",
        "with ZipFile('deep-text-recognition-benchmark.zip', 'r') as zipObj:\n",
        "   # Extract all the contents of zip file in current directory\n",
        "   zipObj.extractall()\n",
        "\n",
        "from zipfile import ZipFile \n",
        "\n",
        "\n",
        "with ZipFile('CRAFT-pytorch.zip', 'r') as zipObj:\n",
        "   # Extract all the contents of zip file in current directory\n",
        "   zipObj.extractall()"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "icPeXw2NmV5F"
      },
      "source": [
        "from transformers import BertForSequenceClassification"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7jofJRMzbQS8"
      },
      "source": [
        "import torch, os, json\n",
        "import matplotlib.pyplot as plt\n",
        "from transformers import BertTokenizer\n",
        "from PIL import Image\n",
        "from text_extractor import TextExtractor\n",
        "\n",
        "class MovieDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, folder = 'data/mmimdb-256/dataset-resized-256max', split = 'dev',\n",
        "                 image_transform = None):\n",
        "        self.json_dir = os.path.join(folder, split, 'metadata')\n",
        "        self.image_dir = os.path.join(folder, split, 'images')\n",
        "        self.image_transform = image_transform\n",
        "        self.tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
        "        self.text_extractor = TextExtractor(folder+\"/\"+split+\"/images/\",split+\"_\"+\"dataset_text_extract_output.txt\",split)\n",
        "        #insantiate a model to extract text\n",
        "\n",
        "        # Category definitions of movies.\n",
        "        self.categories = ['Action', 'Adult', 'Adventure', 'Animation', 'Biography', \n",
        "                           'Comedy', 'Crime', 'Documentary', 'Drama', \n",
        "                           'Family', 'Fantasy', 'Film-Noir', 'History', \n",
        "                           'Horror', 'Music', 'Musical', 'Mystery', 'News', \n",
        "                           'Reality-TV', 'Romance', 'Sci-Fi', 'Short', \n",
        "                           'Sport', 'Talk-Show', 'Thriller', 'War', 'Western']\n",
        "        self.categories2ids = {category: id for (id, category) \n",
        "                               in enumerate(self.categories)}\n",
        "\n",
        "        # Load JSON files.\n",
        "        #print('Loading %s ...' % self.json_dir, end = '')\n",
        "        print(\"extracting text and getting metadata\")\n",
        "        self.fdir = os.listdir(self.json_dir)\n",
        "        self.metadata = [(fname[:-5], json.load(open(os.path.join(self.json_dir, fname)))) \n",
        "                     for fname in sorted(self.fdir) if not fname.startswith('.')]\n",
        "        print(len(self.metadata))\n",
        "        self.text_extractor.extract_text()\n",
        "        \n",
        "        print(' finished')\n",
        "\n",
        "        # Pre-tokenizing all sentences.\n",
        "        \n",
        "        print('Tokenizing...', end = '')\n",
        "        self.tokenized_plots = list()\n",
        "        for i in range(0, len(self.metadata)):\n",
        "            text = self.text_extractor.get_item(i) #self.metadata[i][1]['plot'][0]\n",
        "            encoded_text = self.tokenizer.encode_plus(\n",
        "                text, add_special_tokens = True, truncation = True, \n",
        "                max_length = 256, padding = 'max_length',\n",
        "                return_attention_mask = True,\n",
        "                return_tensors = 'pt')\n",
        "            self.tokenized_plots.append(encoded_text)\n",
        "        print(' finished')\n",
        "        \n",
        "            \n",
        "    def __getitem__(self, index: int):\n",
        "        # Load images on the fly.\n",
        "        filename, movie_data = self.metadata[index]\n",
        "        img_path = os.path.join(self.image_dir, filename + '.jpeg')\n",
        "        image = Image.open(img_path).convert('RGB')\n",
        "        #TODO: ADD cacheing\n",
        "        text = self.tokenized_plots[index]['input_ids'][0]\n",
        "        text_mask = self.tokenized_plots[index]['attention_mask'][0]\n",
        "        genres = movie_data['genres']\n",
        "\n",
        "        if self.image_transform: image = self.image_transform(image)\n",
        "\n",
        "        # Encode labels in a binary vector.\n",
        "        label_vector = torch.zeros((len(self.categories)))\n",
        "        label_ids = [self.categories2ids[cat] for cat in genres]\n",
        "        label_vector[label_ids] = 1\n",
        "\n",
        "        return image, text, text_mask, label_vector\n",
        "\n",
        "    def load_image_only(self, index: int):\n",
        "        filename, movie_data = self.metadata[index]\n",
        "        img_path = os.path.join(self.image_dir, filename + '.jpeg')\n",
        "        image = Image.open(img_path).convert('RGB')\n",
        "        return image\n",
        "\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.metadata)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hPWeRgqrbQS9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 391
        },
        "outputId": "5b50b0cf-1856-4a8f-d7f3-27ddd7acce04"
      },
      "source": [
        "val_data = MovieDataset(split = 'dev_n')\n",
        "print('Data size: %d samples' % len(val_data))\n",
        "\n",
        "sample_movieID = 0\n",
        "img, text, text_mask, labels = val_data[sample_movieID]\n",
        "#print(text)\n",
        "#print(text_mask)\n",
        "\n",
        "print(val_data.tokenizer.convert_ids_to_tokens(text.numpy().tolist()))\n",
        "#print(val_data.tokenizer.convert_ids_to_tokens([100,0,1,2,3,4,5,6,7,8,9,10,101,102,103,104,105,106,107]))\n",
        "\n",
        "#labels = labels.numpy()\n",
        "# Is there a better way to do this?\n",
        "#print([val_data.categories[ind] for ind, val in enumerate(labels == 1) if val == 1])\n",
        "\n",
        "plt.imshow(img)\n",
        "plt.show()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "extracting text and getting metadata\n",
            "1\n",
            " finished\n",
            "Tokenizing... finished\n",
            "Data size: 1 samples\n",
            "['[CLS]', 'james', 'a', 'white', '[SEP]', 'ella', 'lola', '##s', '[SEP]', 'ala', 'tri', '##lby', '[SEP]', '1898', '[SEP]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]', '[PAD]']\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A7iDeGCYbQS9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "715aecb2-461c-400b-ca1f-3f6af9267ed9"
      },
      "source": [
        "# Let's setup the data loaders and preprocessing.\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# Batch size is a liming factor on constrained resources.\n",
        "# only GPUs with a large memory can hold large batches.\n",
        "batch_size = 10\n",
        "\n",
        "image_transform = transforms.Compose([\n",
        "        transforms.Resize(256),\n",
        "        transforms.CenterCrop((224, 224)),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                             std=[0.229, 0.224, 0.225])])\n",
        "\n",
        "trainset = MovieDataset(split = 'train', image_transform = image_transform)\n",
        "valset = MovieDataset(split = 'dev', image_transform = image_transform)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(trainset, \n",
        "                                           batch_size = batch_size, \n",
        "                                           shuffle = True, \n",
        "                                           pin_memory = True,\n",
        "                                           num_workers = 4)\n",
        "val_loader = torch.utils.data.DataLoader(valset, \n",
        "                                         batch_size = batch_size, \n",
        "                                         shuffle = False)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "extracting text and getting metadata\n",
            "15552\n",
            " finished\n",
            "Tokenizing... finished\n",
            "extracting text and getting metadata\n",
            "2608\n",
            " finished\n",
            "Tokenizing... finished\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Iw0ZEmtivDEK",
        "outputId": "edbeb575-8572-4427-f87e-2de5ab35578c"
      },
      "source": [
        "_, (imgs, texts, text_masks, labels) = next(enumerate(val_loader))\n",
        "print(imgs.shape, texts.shape, text_masks.shape, labels.shape)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([10, 3, 224, 224]) torch.Size([10, 256]) torch.Size([10, 256]) torch.Size([10, 27])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0WGYgNCAbQS9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb19767c-bdf4-4b9e-e3d2-89462b3a9c51"
      },
      "source": [
        "# Loading BERT...\n",
        "num_categories = len(trainset.categories)\n",
        "model = BertForSequenceClassification.from_pretrained('bert-base-uncased', \n",
        "    num_labels = num_categories,  output_attentions = False, \n",
        "    output_hidden_states = False)\n",
        "model.eval()\n",
        "# Let's run a quick test on this model on the CPU.\n",
        "predictions = model(texts, text_masks).logits\n",
        "print(predictions.shape)\n",
        "\n",
        "# Tell pytorch to run this model on the GPU.\n",
        "model.cuda();"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForSequenceClassification: ['cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias']\n",
            "- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
            "- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
            "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.weight', 'classifier.bias']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "torch.Size([10, 27])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VGnfLqOpbQS9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 687
        },
        "outputId": "2fc7923a-1e6f-4d0a-c928-0003537b7d0c"
      },
      "source": [
        "from transformers import AdamW  # optimizer that comes with this library.\n",
        "from transformers import get_linear_schedule_with_warmup\n",
        "from livelossplot import PlotLosses\n",
        "import torch.nn as nn\n",
        "\n",
        "num_epochs = 4\n",
        "\n",
        "# Following recommendations from the BERT paper and also this\n",
        "# blog post https://mccormickml.com/2019/07/22/BERT-fine-tuning/\n",
        "optimizer = AdamW(model.parameters(), lr = 2e-5, eps = 1e-8)\n",
        "total_steps = len(train_loader) * num_epochs\n",
        "scheduler = get_linear_schedule_with_warmup(\n",
        "    optimizer, num_warmup_steps = 0, num_training_steps = total_steps)\n",
        "\n",
        "# Binary Cross-Entroy Loss (BCE Loss).\n",
        "# Please see documentation here:\n",
        "# https://pytorch.org/docs/stable/generated/torch.nn.BCEWithLogitsLoss.html\n",
        "cost_function = nn.BCEWithLogitsLoss(reduction = 'none')\n",
        "\n",
        "# Are the top five scored labels accurate?\n",
        "def top5_accuracy(predicted, labels):\n",
        "    sorted_vals, sorted_ids = \\\n",
        "        predicted.data.sigmoid().sort(dim = 1, descending = True)\n",
        "    pred_vals = sorted_vals[:, :5] > 0.5 # Anything with sigmoid > 0.5 is 1.\n",
        "    true_vals = labels.data.gather(1, sorted_ids[:, :5]) # Find true values.\n",
        "    return (pred_vals == true_vals).sum(dim = 1) / 5.0\n",
        "\n",
        "# Training Loop. \n",
        "best_accuracy = 0\n",
        "liveloss = PlotLosses(); current_step = 0\n",
        "for epoch in range(0, num_epochs):\n",
        "    cumulative_accuracy = 0\n",
        "    cumulative_loss = 0\n",
        "    num_samples = 0\n",
        "    logs = {}\n",
        "    model.train()\n",
        "    for (batch_id, (imgs, texts, text_masks, labels)) in enumerate(train_loader):\n",
        "        # Move to GPU.\n",
        "        texts = texts.cuda()\n",
        "        text_masks = text_masks.cuda()\n",
        "        labels = labels.cuda()\n",
        "\n",
        "        # Compute predictions.\n",
        "        predicted = model(texts, text_masks).logits\n",
        "\n",
        "        # Compute loss.\n",
        "        loss = cost_function(predicted, labels)\n",
        "\n",
        "        # Compute cumulative loss and top-5 accuracy.\n",
        "        cumulative_loss += loss.data.sum().item()\n",
        "        cumulative_accuracy += top5_accuracy(predicted, labels).sum().item()\n",
        "        num_samples += texts.size(0)\n",
        "\n",
        "        # Backpropagation and SGD update step.\n",
        "        model.zero_grad()\n",
        "        loss.mean().backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        if batch_id % 100 == 0:\n",
        "            print(epoch, batch_id, cumulative_accuracy / num_samples)\n",
        "            logs['loss'] = cumulative_loss / num_samples\n",
        "            logs['accuracy'] = cumulative_accuracy / num_samples\n",
        "            liveloss.update(logs)\n",
        "            liveloss.send()\n",
        "            current_step += 1\n",
        "    \n",
        "    cumulative_accuracy = 0\n",
        "    cumulative_loss = 0\n",
        "    num_samples = 0\n",
        "    model.eval()\n",
        "    for (batch_id, (imgs, texts, text_masks, labels)) in enumerate(val_loader):\n",
        "        # Move to GPU.\n",
        "        texts = texts.cuda()\n",
        "        text_masks = text_masks.cuda()\n",
        "        labels = labels.cuda()\n",
        "\n",
        "        # Compute predictions.\n",
        "        predicted = model(texts, text_masks).logits\n",
        "\n",
        "        # Compute loss.\n",
        "        loss = cost_function(predicted, labels)\n",
        "\n",
        "        # Compute cumulative loss and top-5 accuracy.\n",
        "        cumulative_loss += loss.data.sum().item()\n",
        "        cumulative_accuracy += top5_accuracy(predicted, labels).sum().item()\n",
        "        num_samples += texts.size(0)\n",
        "\n",
        "        if (1 + batch_id) % 100 == 0:\n",
        "            logs['val_loss'] = cumulative_loss / num_samples\n",
        "            logs['val_accuracy'] = cumulative_accuracy / num_samples    \n",
        "            liveloss.update(logs, current_step)\n",
        "            liveloss.send()\n",
        "\n",
        "    # Advance scheduler.\n",
        "    if scheduler != -1:\n",
        "        scheduler.step()\n",
        "\n",
        "    # Save the parameters for the best accuracy on the validation set so far.\n",
        "    if logs['val_accuracy'] > best_accuracy:\n",
        "        best_accuracy = logs['val_accuracy']\n",
        "        torch.save(model.state_dict(), 'best_model_so_far.pth') "
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "accuracy\n",
            "\ttraining         \t (min:    0.120, max:    0.800, cur:    0.775)\n",
            "\tvalidation       \t (min:    0.712, max:    0.725, cur:    0.716)\n",
            "Loss\n",
            "\ttraining         \t (min:    4.332, max:   19.159, cur:    4.363)\n",
            "\tvalidation       \t (min:    5.826, max:    6.294, cur:    6.015)\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}