diff --git a/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb b/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb new file mode 100644 index 000000000..36e6fd4ef --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb @@ -0,0 +1,680 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import hifi_gan\n", + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import g2p_en" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "g2p = g2p_en.G2p()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "\n", + "def to_arpabet(g2p, text):\n", + " \"\"\"Convert a sentence in english to arpabet.\"\"\"\n", + " g2p_out = g2p(text)\n", + " current = 0\n", + " current_tokens = []\n", + " current_token_is_punc = False\n", + " output = []\n", + " while True:\n", + " if current >= len(g2p_out) or g2p_out[current] == \" \":\n", + " if current_token_is_punc:\n", + " output.append(\"\".join(current_tokens))\n", + " else:\n", + " output.append(\"{%s}\" % (\" \".join(current_tokens)))\n", + " current_tokens = []\n", + " if current >= len(g2p_out):\n", + " break\n", + " else:\n", + " if len(current_tokens) == 0:\n", + " current_token_is_punc = (\n", + " re.match(r\"[,'\\-!\\.?]+\", g2p_out[current]) is not None\n", + " )\n", + " current_tokens.append(g2p_out[current])\n", + " current += 1\n", + "\n", + " return \" \".join(output)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import hifi_gan\n", + "from hifi_gan.env import AttrDict\n", + "from hifi_gan.inference_e2e import load_checkpoint\n", + "from hifi_gan.meldataset import MAX_WAV_VALUE\n", + "from hifi_gan.models import Generator\n", + "\n", + "def load_hifi_gan(path, device=\"cpu\"):\n", + " dev = torch.device(device)\n", + " with open(os.path.join(path, \"config.json\"), \"r\") as f:\n", + " config = AttrDict(json.load(f))\n", + " generator = Generator(config).to(dev)\n", + " for file in os.listdir(path):\n", + " if file.startswith(\"g_\"):\n", + " gen_filename = file\n", + " state_dict_g = load_checkpoint(os.path.join(path, gen_filename), dev)\n", + " print(state_dict_g.keys())\n", + " generator.load_state_dict(state_dict_g['generator'])\n", + " generator.eval()\n", + " generator.remove_weight_norm()\n", + " return generator" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading '/home/ubuntu/UNIVERSAL_V1/g_02500000'\n", + "Complete.\n", + "dict_keys(['generator'])\n", + "Removing weight norm...\n" + ] + } + ], + "source": [ + "gen = load_hifi_gan(\"/home/ubuntu/UNIVERSAL_V1/\", device=\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /home/ubuntu/.cache/torch/hub/nvidia_DeepLearningExamples_torchhub\n" + ] + } + ], + "source": [ + "model = torch.hub.load(\n", + " \"nvidia/DeepLearningExamples:torchhub\", \n", + " \"nvidia_tacotron2\", \n", + " pretrained=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "michael rosen\n", + "checkpoint_Tacotron2_360.pt checkpoint_Tacotron2_600.pt\n", + "checkpoint_Tacotron2_380.pt checkpoint_Tacotron2_620.pt\n", + "checkpoint_Tacotron2_400.pt checkpoint_Tacotron2_640.pt\n", + "checkpoint_Tacotron2_420.pt checkpoint_Tacotron2_660.pt\n", + "checkpoint_Tacotron2_440.pt checkpoint_Tacotron2_680.pt\n", + "checkpoint_Tacotron2_460.pt checkpoint_Tacotron2_700.pt\n", + "checkpoint_Tacotron2_480.pt checkpoint_Tacotron2_720.pt\n", + "checkpoint_Tacotron2_500.pt checkpoint_Tacotron2_740.pt\n", + "checkpoint_Tacotron2_520.pt checkpoint_Tacotron2_760.pt\n", + "checkpoint_Tacotron2_540.pt checkpoint_Tacotron2_780.pt\n", + "checkpoint_Tacotron2_560.pt checkpoint_Tacotron2_last.pt\n", + "checkpoint_Tacotron2_580.pt nvlog.json\n", + "trebek\n", + "checkpoint_Tacotron2_350.pt checkpoint_Tacotron2_500.pt nvlog.json\n", + "checkpoint_Tacotron2_400.pt checkpoint_Tacotron2_550.pt\n", + "checkpoint_Tacotron2_450.pt checkpoint_Tacotron2_last.pt\n", + "lj\n", + "checkpoint_Tacotron2_0.pt checkpoint_Tacotron2_450.pt\n", + "checkpoint_Tacotron2_100.pt checkpoint_Tacotron2_50.pt\n", + "checkpoint_Tacotron2_150.pt checkpoint_Tacotron2_500.pt\n", + "checkpoint_Tacotron2_200.pt checkpoint_Tacotron2_550.pt\n", + "checkpoint_Tacotron2_250.pt checkpoint_Tacotron2_600.pt\n", + "checkpoint_Tacotron2_300.pt checkpoint_Tacotron2_650.pt\n", + "checkpoint_Tacotron2_350.pt checkpoint_Tacotron2_last.pt\n", + "checkpoint_Tacotron2_400.pt nvlog.json\n" + ] + } + ], + "source": [ + "print(\"michael rosen\")\n", + "!ls output_michaelrosen2/\n", + "print(\"trebek\")\n", + "!ls output_trebek/\n", + "print(\"lj\")\n", + "!ls output" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = torch.load(\"output_michaelrosen2/checkpoint_Tacotron2_last.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.load_state_dict(checkpoint[\"state_dict\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{AY1 M} {IH1 N F AH0 N AH0 T} . {Y UW1} {HH ER1 D} {AH1 V} {HH EH1 L} ? {W EH1 L} {AY1} {W AA1 Z} {S EH1 N T} {F R AH1 M} {IH1 T} .\n" + ] + } + ], + "source": [ + "arpabet = to_arpabet(\n", + " g2p,\n", + " # \"Never gonna give you up. Never gonna let you down. Never gonna run around and desert me.\"\n", + " # \"What the fuck did you just fucking say about me, you little bitch?\"\n", + " # \"Loads to eat, I had cod and chips, the cod was huge and there were hundreds of chips.\"\n", + " \"I'm infinite. You heard of hell? Well I was sent from it.\"\n", + " #\"I'd just like to interject for a moment. What you're referring to as Linux, is in fact, Windows Subsystem for Linux, or as I've recently taken to calling it, W S L.\"\n", + ")\n", + "print(arpabet)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from tacotron2.text import text_to_sequence\n", + "import numpy as np\n", + "model = model.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "seq = np.array(text_to_sequence(arpabet, [\"english_cleaners\"]))[None, :]\n", + "seq = torch.from_numpy(seq).to(device=\"cuda\", dtype=torch.int64)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "model.eval()\n", + "_, mel, _, alignments = model.infer(seq)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "MAX_WAV_VALUE = 30000.0\n", + "tensor_cls = torch.FloatTensor if not torch.cuda.is_available() else torch.cuda.FloatTensor\n", + "y_g_hat = gen(tensor_cls(mel).to(device=\"cuda\"))\n", + "audio = y_g_hat.squeeze()\n", + "audio = audio * MAX_WAV_VALUE\n", + "audio = audio.unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Audio" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(audio.data.cpu().numpy(), rate=22050)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(80, 352)\n", + "(53, 352)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pylab as pylab\n", + "\n", + "alignment_graph_width = 1800\n", + "alignment_graph_height = 720\n", + "graph_scale = 1\n", + "\n", + "def plot_data(data, info=None):\n", + " %matplotlib inline\n", + " fig, axes = pylab.subplots(1, len(data), figsize=(int(alignment_graph_width*graph_scale/100), int(alignment_graph_height * graph_scale / 100)))\n", + " for i in range(len(data)):\n", + " print(data[i].shape)\n", + " axes[i].imshow(data[i], aspect='auto', origin='bottom', \n", + " interpolation='none', cmap='inferno')\n", + " axes[0].set(xlabel=\"Frames\", ylabel=\"Channels\")\n", + " axes[1].set(xlabel=\"Decoder timestep\", ylabel=\"Encoder timestep\")\n", + " fig.canvas.draw()\n", + " pylab.show()\n", + "\n", + "plot_data([\n", + " mel[0].data.cpu().numpy(),\n", + " alignments[0].data.cpu().numpy().T,\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parse nvlog" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DLLL {\"timestamp\": \"1613260158.487929\", \"datetime\": \"2021-02-13 23:49:18.487929\", \"elapsedtime\": \"24111.014423\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"glob_iter/iters_per_epoch\": \"5708/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260159.993744\", \"datetime\": \"2021-02-13 23:49:19.993744\", \"elapsedtime\": \"24112.520238\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"train_loss\": 0.3499102294445038}}\r\n", + "DLLL {\"timestamp\": \"1613260161.941808\", \"datetime\": \"2021-02-13 23:49:21.941808\", \"elapsedtime\": \"24114.468302\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"train_items_per_sec\": 4538.938052832199}}\r\n", + "DLLL {\"timestamp\": \"1613260161.941942\", \"datetime\": \"2021-02-13 23:49:21.941942\", \"elapsedtime\": \"24114.468436\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"train_iter_time\": 3.453891597004258}}\r\n", + "DLLL {\"timestamp\": \"1613260161.951703\", \"datetime\": \"2021-02-13 23:49:21.951703\", \"elapsedtime\": \"24114.478197\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"glob_iter/iters_per_epoch\": \"5709/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260163.523834\", \"datetime\": \"2021-02-13 23:49:23.523834\", \"elapsedtime\": \"24116.050328\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"train_loss\": 0.3621940016746521}}\r\n", + "DLLL {\"timestamp\": \"1613260165.566278\", \"datetime\": \"2021-02-13 23:49:25.566278\", \"elapsedtime\": \"24118.092772\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"train_items_per_sec\": 4703.442347979841}}\r\n", + "DLLL {\"timestamp\": \"1613260165.566416\", \"datetime\": \"2021-02-13 23:49:25.566416\", \"elapsedtime\": \"24118.09291\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"train_iter_time\": 3.6145866669976385}}\r\n", + "DLLL {\"timestamp\": \"1613260165.573997\", \"datetime\": \"2021-02-13 23:49:25.573997\", \"elapsedtime\": \"24118.100491\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"glob_iter/iters_per_epoch\": \"5710/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260167.24385\", \"datetime\": \"2021-02-13 23:49:27.243850\", \"elapsedtime\": \"24119.770344\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"train_loss\": 0.34290337562561035}}\r\n", + "DLLL {\"timestamp\": \"1613260169.399331\", \"datetime\": \"2021-02-13 23:49:29.399331\", \"elapsedtime\": \"24121.925825\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"train_items_per_sec\": 4490.312452439713}}\r\n", + "DLLL {\"timestamp\": \"1613260169.399471\", \"datetime\": \"2021-02-13 23:49:29.399471\", \"elapsedtime\": \"24121.925965\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"train_iter_time\": 3.825346271987655}}\r\n", + "DLLL {\"timestamp\": \"1613260169.407979\", \"datetime\": \"2021-02-13 23:49:29.407979\", \"elapsedtime\": \"24121.934473\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"glob_iter/iters_per_epoch\": \"5711/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260171.037161\", \"datetime\": \"2021-02-13 23:49:31.037161\", \"elapsedtime\": \"24123.563655\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"train_loss\": 0.40105947852134705}}\r\n", + "DLLL {\"timestamp\": \"1613260173.156379\", \"datetime\": \"2021-02-13 23:49:33.156379\", \"elapsedtime\": \"24125.682873\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"train_items_per_sec\": 5208.0738733658145}}\r\n", + "DLLL {\"timestamp\": \"1613260173.156513\", \"datetime\": \"2021-02-13 23:49:33.156513\", \"elapsedtime\": \"24125.683007\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"train_iter_time\": 3.7484107320051407}}\r\n", + "DLLL {\"timestamp\": \"1613260173.168099\", \"datetime\": \"2021-02-13 23:49:33.168099\", \"elapsedtime\": \"24125.694593\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"glob_iter/iters_per_epoch\": \"5712/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260174.882324\", \"datetime\": \"2021-02-13 23:49:34.882324\", \"elapsedtime\": \"24127.408818\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"train_loss\": 0.3285461664199829}}\r\n", + "DLLL {\"timestamp\": \"1613260177.109261\", \"datetime\": \"2021-02-13 23:49:37.109261\", \"elapsedtime\": \"24129.635755\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"train_items_per_sec\": 4287.300545595056}}\r\n", + "DLLL {\"timestamp\": \"1613260177.109395\", \"datetime\": \"2021-02-13 23:49:37.109395\", \"elapsedtime\": \"24129.635889\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"train_iter_time\": 3.94117459699919}}\r\n", + "DLLL {\"timestamp\": \"1613260177.120371\", \"datetime\": \"2021-02-13 23:49:37.120371\", \"elapsedtime\": \"24129.646865\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"glob_iter/iters_per_epoch\": \"5713/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260178.652027\", \"datetime\": \"2021-02-13 23:49:38.652027\", \"elapsedtime\": \"24131.178521\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"train_loss\": 0.36544039845466614}}\r\n", + "DLLL {\"timestamp\": \"1613260180.626034\", \"datetime\": \"2021-02-13 23:49:40.626034\", \"elapsedtime\": \"24133.152528\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"train_items_per_sec\": 4819.044510659347}}\r\n", + "DLLL {\"timestamp\": \"1613260180.626165\", \"datetime\": \"2021-02-13 23:49:40.626165\", \"elapsedtime\": \"24133.152659\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"train_iter_time\": 3.5056741979933577}}\r\n", + "DLLL {\"timestamp\": \"1613260180.6374\", \"datetime\": \"2021-02-13 23:49:40.637400\", \"elapsedtime\": \"24133.163894\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"glob_iter/iters_per_epoch\": \"5714/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260182.290356\", \"datetime\": \"2021-02-13 23:49:42.290356\", \"elapsedtime\": \"24134.81685\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"train_loss\": 0.3259407877922058}}\r\n", + "DLLL {\"timestamp\": \"1613260184.44935\", \"datetime\": \"2021-02-13 23:49:44.449350\", \"elapsedtime\": \"24136.975844\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"train_items_per_sec\": 4270.241330126292}}\r\n", + "DLLL {\"timestamp\": \"1613260184.449486\", \"datetime\": \"2021-02-13 23:49:44.449486\", \"elapsedtime\": \"24136.97598\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"train_iter_time\": 3.8119625429972075}}\r\n", + "DLLL {\"timestamp\": \"1613260184.459236\", \"datetime\": \"2021-02-13 23:49:44.459236\", \"elapsedtime\": \"24136.98573\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"glob_iter/iters_per_epoch\": \"5715/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260185.95168\", \"datetime\": \"2021-02-13 23:49:45.951680\", \"elapsedtime\": \"24138.478174\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"train_loss\": 0.36399826407432556}}\r\n", + "DLLL {\"timestamp\": \"1613260187.88434\", \"datetime\": \"2021-02-13 23:49:47.884340\", \"elapsedtime\": \"24140.410834\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"train_items_per_sec\": 4748.453597589112}}\r\n", + "DLLL {\"timestamp\": \"1613260187.884482\", \"datetime\": \"2021-02-13 23:49:47.884482\", \"elapsedtime\": \"24140.410976\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"train_iter_time\": 3.4251150749914814}}\r\n", + "DLLL {\"timestamp\": \"1613260187.892197\", \"datetime\": \"2021-02-13 23:49:47.892197\", \"elapsedtime\": \"24140.418691\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"glob_iter/iters_per_epoch\": \"5716/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260189.549036\", \"datetime\": \"2021-02-13 23:49:49.549036\", \"elapsedtime\": \"24142.07553\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"train_loss\": 0.3610873818397522}}\r\n", + "DLLL {\"timestamp\": \"1613260191.700089\", \"datetime\": \"2021-02-13 23:49:51.700089\", \"elapsedtime\": \"24144.226583\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"train_items_per_sec\": 4673.174224536043}}\r\n", + "DLLL {\"timestamp\": \"1613260191.700224\", \"datetime\": \"2021-02-13 23:49:51.700224\", \"elapsedtime\": \"24144.226718\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"train_iter_time\": 3.8079042520112125}}\r\n", + "DLLL {\"timestamp\": \"1613260191.711165\", \"datetime\": \"2021-02-13 23:49:51.711165\", \"elapsedtime\": \"24144.237659\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"glob_iter/iters_per_epoch\": \"5717/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260193.472417\", \"datetime\": \"2021-02-13 23:49:53.472417\", \"elapsedtime\": \"24145.998911\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"train_loss\": 0.39527997374534607}}\r\n", + "DLLL {\"timestamp\": \"1613260195.784164\", \"datetime\": \"2021-02-13 23:49:55.784164\", \"elapsedtime\": \"24148.310658\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"train_items_per_sec\": 5025.766146731682}}\r\n", + "DLLL {\"timestamp\": \"1613260195.786309\", \"datetime\": \"2021-02-13 23:49:55.786309\", \"elapsedtime\": \"24148.312803\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"train_iter_time\": 4.07301084100618}}\r\n", + "DLLL {\"timestamp\": \"1613260195.7957\", \"datetime\": \"2021-02-13 23:49:55.795700\", \"elapsedtime\": \"24148.322194\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"glob_iter/iters_per_epoch\": \"5718/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260197.454689\", \"datetime\": \"2021-02-13 23:49:57.454689\", \"elapsedtime\": \"24149.981183\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"train_loss\": 0.3523614704608917}}\r\n", + "DLLL {\"timestamp\": \"1613260199.602739\", \"datetime\": \"2021-02-13 23:49:59.602739\", \"elapsedtime\": \"24152.129233\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"train_items_per_sec\": 4574.146695724187}}\r\n", + "DLLL {\"timestamp\": \"1613260199.602874\", \"datetime\": \"2021-02-13 23:49:59.602874\", \"elapsedtime\": \"24152.129368\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"train_iter_time\": 3.807048867995036}}\r\n", + "DLLL {\"timestamp\": \"1613260199.612983\", \"datetime\": \"2021-02-13 23:49:59.612983\", \"elapsedtime\": \"24152.139477\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"glob_iter/iters_per_epoch\": \"5719/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260201.371872\", \"datetime\": \"2021-02-13 23:50:01.371872\", \"elapsedtime\": \"24153.898366\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"train_loss\": 0.3457852602005005}}\r\n", + "DLLL {\"timestamp\": \"1613260203.641127\", \"datetime\": \"2021-02-13 23:50:03.641127\", \"elapsedtime\": \"24156.167621\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"train_items_per_sec\": 4514.223411973792}}\r\n", + "DLLL {\"timestamp\": \"1613260203.64126\", \"datetime\": \"2021-02-13 23:50:03.641260\", \"elapsedtime\": \"24156.167754\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"train_iter_time\": 4.028156858999864}}\r\n", + "DLLL {\"timestamp\": \"1613260203.679966\", \"datetime\": \"2021-02-13 23:50:03.679966\", \"elapsedtime\": \"24156.20646\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"train_items_per_sec\": 4642.715448482791}}\r\n", + "DLLL {\"timestamp\": \"1613260203.680104\", \"datetime\": \"2021-02-13 23:50:03.680104\", \"elapsedtime\": \"24156.206598\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"train_loss\": 0.3457852602005005}}\r\n", + "DLLL {\"timestamp\": \"1613260203.680167\", \"datetime\": \"2021-02-13 23:50:03.680167\", \"elapsedtime\": \"24156.206661\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"train_epoch_time\": 49.26070692999929}}\r\n", + "DLLL {\"timestamp\": \"1613260205.299704\", \"datetime\": \"2021-02-13 23:50:05.299704\", \"elapsedtime\": \"24157.826198\", \"type\": \"LOG\", \"step\": [790, 5720, 0], \"data\": {\"val_items_per_sec\": 13869.564672304557}}\r\n", + "DLLL {\"timestamp\": \"1613260206.703353\", \"datetime\": \"2021-02-13 23:50:06.703353\", \"elapsedtime\": \"24159.229847\", \"type\": \"LOG\", \"step\": [790, 5720, 1], \"data\": {\"val_items_per_sec\": 13407.354885992667}}\r\n", + "DLLL {\"timestamp\": \"1613260207.938711\", \"datetime\": \"2021-02-13 23:50:07.938711\", \"elapsedtime\": \"24160.465205\", \"type\": \"LOG\", \"step\": [790, 5720, 2], \"data\": {\"val_items_per_sec\": 14171.624377123939}}\r\n", + "DLLL {\"timestamp\": \"1613260208.929501\", \"datetime\": \"2021-02-13 23:50:08.929501\", \"elapsedtime\": \"24161.455995\", \"type\": \"LOG\", \"step\": [790, 5720, 3], \"data\": {\"val_items_per_sec\": 2154.5592796913575}}\r\n", + "DLLL {\"timestamp\": \"1613260208.966335\", \"datetime\": \"2021-02-13 23:50:08.966335\", \"elapsedtime\": \"24161.492829\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"val_loss\": 0.33910156041383743}}\r\n", + "DLLL {\"timestamp\": \"1613260208.966575\", \"datetime\": \"2021-02-13 23:50:08.966575\", \"elapsedtime\": \"24161.493069\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"val_items_per_sec\": 10900.77580377813}}\r\n", + "DLLL {\"timestamp\": \"1613260209.103941\", \"datetime\": \"2021-02-13 23:50:09.103941\", \"elapsedtime\": \"24161.630435\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"glob_iter/iters_per_epoch\": \"5720/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260210.771315\", \"datetime\": \"2021-02-13 23:50:10.771315\", \"elapsedtime\": \"24163.297809\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"train_loss\": 0.3610868752002716}}\r\n", + "DLLL {\"timestamp\": \"1613260212.833175\", \"datetime\": \"2021-02-13 23:50:12.833175\", \"elapsedtime\": \"24165.359669\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"train_items_per_sec\": 4533.820984057406}}\r\n", + "DLLL {\"timestamp\": \"1613260212.833315\", \"datetime\": \"2021-02-13 23:50:12.833315\", \"elapsedtime\": \"24165.359809\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"train_iter_time\": 3.729304720996879}}\r\n", + "DLLL {\"timestamp\": \"1613260212.843412\", \"datetime\": \"2021-02-13 23:50:12.843412\", \"elapsedtime\": \"24165.369906\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"glob_iter/iters_per_epoch\": \"5721/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260214.550588\", \"datetime\": \"2021-02-13 23:50:14.550588\", \"elapsedtime\": \"24167.077082\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"train_loss\": 0.3312675952911377}}\r\n", + "DLLL {\"timestamp\": \"1613260216.790641\", \"datetime\": \"2021-02-13 23:50:16.790641\", \"elapsedtime\": \"24169.317135\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"train_items_per_sec\": 4325.5516625175305}}\r\n", + "DLLL {\"timestamp\": \"1613260216.790779\", \"datetime\": \"2021-02-13 23:50:16.790779\", \"elapsedtime\": \"24169.317273\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"train_iter_time\": 3.947242185997311}}\r\n", + "DLLL {\"timestamp\": \"1613260216.800489\", \"datetime\": \"2021-02-13 23:50:16.800489\", \"elapsedtime\": \"24169.326983\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"glob_iter/iters_per_epoch\": \"5722/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260218.557104\", \"datetime\": \"2021-02-13 23:50:18.557104\", \"elapsedtime\": \"24171.083598\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"train_loss\": 0.3222716450691223}}\r\n", + "DLLL {\"timestamp\": \"1613260220.868867\", \"datetime\": \"2021-02-13 23:50:20.868867\", \"elapsedtime\": \"24173.395361\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"train_items_per_sec\": 4254.261188867131}}\r\n", + "DLLL {\"timestamp\": \"1613260220.868998\", \"datetime\": \"2021-02-13 23:50:20.868998\", \"elapsedtime\": \"24173.395492\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"train_iter_time\": 4.068391485998291}}\r\n", + "DLLL {\"timestamp\": \"1613260220.879207\", \"datetime\": \"2021-02-13 23:50:20.879207\", \"elapsedtime\": \"24173.405701\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"glob_iter/iters_per_epoch\": \"5723/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260222.533327\", \"datetime\": \"2021-02-13 23:50:22.533327\", \"elapsedtime\": \"24175.059821\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"train_loss\": 0.3352973461151123}}\r\n", + "DLLL {\"timestamp\": \"1613260224.683802\", \"datetime\": \"2021-02-13 23:50:24.683802\", \"elapsedtime\": \"24177.210296\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"train_items_per_sec\": 4236.181362637959}}\r\n", + "DLLL {\"timestamp\": \"1613260224.683935\", \"datetime\": \"2021-02-13 23:50:24.683935\", \"elapsedtime\": \"24177.210429\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"train_iter_time\": 3.8046057570027187}}\r\n", + "DLLL {\"timestamp\": \"1613260224.695678\", \"datetime\": \"2021-02-13 23:50:24.695678\", \"elapsedtime\": \"24177.222172\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"glob_iter/iters_per_epoch\": \"5724/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260226.314902\", \"datetime\": \"2021-02-13 23:50:26.314902\", \"elapsedtime\": \"24178.841396\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"train_loss\": 0.38849177956581116}}\r\n", + "DLLL {\"timestamp\": \"1613260228.414953\", \"datetime\": \"2021-02-13 23:50:28.414953\", \"elapsedtime\": \"24180.941447\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"train_items_per_sec\": 4996.925925311962}}\r\n", + "DLLL {\"timestamp\": \"1613260228.415085\", \"datetime\": \"2021-02-13 23:50:28.415085\", \"elapsedtime\": \"24180.941579\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"train_iter_time\": 3.7192866730038077}}\r\n", + "DLLL {\"timestamp\": \"1613260228.425829\", \"datetime\": \"2021-02-13 23:50:28.425829\", \"elapsedtime\": \"24180.952323\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"glob_iter/iters_per_epoch\": \"5725/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260230.076549\", \"datetime\": \"2021-02-13 23:50:30.076549\", \"elapsedtime\": \"24182.603043\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"train_loss\": 0.31019118428230286}}\r\n", + "DLLL {\"timestamp\": \"1613260232.249928\", \"datetime\": \"2021-02-13 23:50:32.249928\", \"elapsedtime\": \"24184.776422\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"train_items_per_sec\": 4035.7100851543955}}\r\n", + "DLLL {\"timestamp\": \"1613260232.250069\", \"datetime\": \"2021-02-13 23:50:32.250069\", \"elapsedtime\": \"24184.776563\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"train_iter_time\": 3.8241101750027156}}\r\n", + "DLLL {\"timestamp\": \"1613260232.262465\", \"datetime\": \"2021-02-13 23:50:32.262465\", \"elapsedtime\": \"24184.788959\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"glob_iter/iters_per_epoch\": \"5726/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260233.967236\", \"datetime\": \"2021-02-13 23:50:33.967236\", \"elapsedtime\": \"24186.49373\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"train_loss\": 0.38987359404563904}}\r\n", + "DLLL {\"timestamp\": \"1613260236.196505\", \"datetime\": \"2021-02-13 23:50:36.196505\", \"elapsedtime\": \"24188.722999\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"train_items_per_sec\": 5072.119490693871}}\r\n", + "DLLL {\"timestamp\": \"1613260236.196642\", \"datetime\": \"2021-02-13 23:50:36.196642\", \"elapsedtime\": \"24188.723136\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"train_iter_time\": 3.9340555829985533}}\r\n", + "DLLL {\"timestamp\": \"1613260236.208422\", \"datetime\": \"2021-02-13 23:50:36.208422\", \"elapsedtime\": \"24188.734916\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"glob_iter/iters_per_epoch\": \"5727/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260237.932468\", \"datetime\": \"2021-02-13 23:50:37.932468\", \"elapsedtime\": \"24190.458962\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"train_loss\": 0.3397759199142456}}\r\n", + "DLLL {\"timestamp\": \"1613260240.182758\", \"datetime\": \"2021-02-13 23:50:40.182758\", \"elapsedtime\": \"24192.709252\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"train_items_per_sec\": 4558.987183719765}}\r\n", + "DLLL {\"timestamp\": \"1613260240.182899\", \"datetime\": \"2021-02-13 23:50:40.182899\", \"elapsedtime\": \"24192.709393\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"train_iter_time\": 3.974347650000709}}\r\n", + "DLLL {\"timestamp\": \"1613260240.194154\", \"datetime\": \"2021-02-13 23:50:40.194154\", \"elapsedtime\": \"24192.720648\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"glob_iter/iters_per_epoch\": \"5728/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260241.853646\", \"datetime\": \"2021-02-13 23:50:41.853646\", \"elapsedtime\": \"24194.38014\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"train_loss\": 0.3450845777988434}}\r\n", + "DLLL {\"timestamp\": \"1613260244.01321\", \"datetime\": \"2021-02-13 23:50:44.013210\", \"elapsedtime\": \"24196.539704\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"train_items_per_sec\": 4461.5603411554175}}\r\n", + "DLLL {\"timestamp\": \"1613260244.013346\", \"datetime\": \"2021-02-13 23:50:44.013346\", \"elapsedtime\": \"24196.53984\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"train_iter_time\": 3.8190674779907567}}\r\n", + "DLLL {\"timestamp\": \"1613260244.023696\", \"datetime\": \"2021-02-13 23:50:44.023696\", \"elapsedtime\": \"24196.55019\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"glob_iter/iters_per_epoch\": \"5729/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260245.681414\", \"datetime\": \"2021-02-13 23:50:45.681414\", \"elapsedtime\": \"24198.207908\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"train_loss\": 0.3484034538269043}}\r\n", + "DLLL {\"timestamp\": \"1613260247.85958\", \"datetime\": \"2021-02-13 23:50:47.859580\", \"elapsedtime\": \"24200.386074\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"train_items_per_sec\": 4593.712355099718}}\r\n", + "DLLL {\"timestamp\": \"1613260247.859712\", \"datetime\": \"2021-02-13 23:50:47.859712\", \"elapsedtime\": \"24200.386206\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"train_iter_time\": 3.8358953800052404}}\r\n", + "DLLL {\"timestamp\": \"1613260247.872248\", \"datetime\": \"2021-02-13 23:50:47.872248\", \"elapsedtime\": \"24200.398742\", \"type\": \"LOG\", \"step\": [791, 10], \"data\": {\"glob_iter/iters_per_epoch\": \"5730/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260249.598021\", \"datetime\": \"2021-02-13 23:50:49.598021\", \"elapsedtime\": \"24202.124515\", \"type\": \"LOG\", \"step\": [791, 10], \"data\": {\"train_loss\": 0.30499666929244995}}\r\n", + "DLLL {\"timestamp\": \"1613260251.850263\", \"datetime\": \"2021-02-13 23:50:51.850263\", \"elapsedtime\": \"24204.376757\", \"type\": \"LOG\", \"step\": [791, 10], \"data\": {\"train_items_per_sec\": 3994.6926921589716}}\r\n" + ] + } + ], + "source": [ + "!tail -n100 output_michaelrosen2/nvlog.json" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "training_loss = []\n", + "val_loss = []\n", + "with open(\"output_michaelrosen2/nvlog.json\", \"r\") as f:\n", + " for line in f.readlines():\n", + " data = json.loads(line[5:])\n", + " if \"data\" in data and \"train_loss\" in data[\"data\"]:\n", + " training_loss.append(data)\n", + " if \"data\"in data and \"val_loss\" in data[\"data\"]:\n", + " val_loss.append(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6171" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(training_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "steps = [t[\"step\"][0] for t in training_loss]\n", + "loss = [t[\"data\"][\"train_loss\"] for t in training_loss]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd3hUVfoH8O+bBqEFhFADhA6hQ+gLgiBFFBQsgLroqriu/nDRVYNdUETZtWPBgmVVZFUUDYKCWOgEqQECAQKEIiF0AqSd3x9zZzLlzsydyUwmc/P9PE8eZu49M3O4mbz33PeUK0opEBFR+IsIdQWIiCgwGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMwlBAF5HhIpIhIpkikuKmzI0isl1E0kXks8BWk4iIvBFv49BFJBLALgBXAsgGsB7AeKXUdrsyrQDMB3CFUuqkiNRVSh0LXrWJiMiZkRZ6TwCZSqm9Sql8APMAjHYqcxeA2UqpkwDAYE5EVPaiDJRpBOCg3fNsAL2cyrQGABFZCSASwNNKqcXObyQikwBMAoCqVat2b9u2rT91xtZDp3W3d2wUZ9vXsVGcX+9NRFSebdiw4bhSKl5vn5GALjrbnPM0UQBaARgIIAHA7yLSQSl1yuFFSs0BMAcAkpOTVVpamoGPd5WYkqq7/ddnhqH9U0sAAGkzR/r13kRE5ZmI7He3z0jKJRtAY7vnCQAO65T5VilVoJTaByADlgBfpi4UFJX1RxIRlRtGAvp6AK1EpJmIxAAYB2ChU5lvAAwCABGpA0sKZm8gK2rEhXwGdCKquLwGdKVUIYD7ACwBsAPAfKVUuohME5FRWrElAHJFZDuA5QAeUkrlBqvS7vR/cTkAIEIvSUREZHJGcuhQSi0CsMhp25N2jxWAB7SfkIuNjgx1FYiIylxYzhStWSXa4/7KDOhEVAGFZUC/8y/NPO5nQCeiiigsA3qElyR5bAwDOhFVPGEZ0KO8BXS20ImoAgrLgB4hDOhERM7CMqB7a6FXZsqFiCqgsAzokZGeq105Kiz/W0REpRKWkS/SS8olhgGdiCqgsIx83lIu4iXgExGZUVgG9EjO7ScicmHagD57eSY+WLGvDGpDRFQ+GFrLpbzxFtC/23wY3222PP6bl1mlRERmYdoWOhFRRcOATkRkEmEZ0OvVqBzqKhARlTthGdBrVPY99f/5ugOY/PnGINSGiKh8CMuA7o+pX2/Fws3Ot0IlIjIP0wf0xJRUnM4rCHU1iIiCzvQBHQD2HD8X6ioQEQVdhQjoY95c5fD8YkERElNSkXnsbIhqREQUeBUioNu7VFiEt3/dAwAY8tJvIa4NEVHgVLiAnjx9KV5Zutv2PC+/0KXMr7ty8K//bbY9zzh6FoVFxWVSPyIif1W4gH72kmMALypWLmUmfrAOX27IBgAcPX0Rw175DQ/aBXgiovIoLAN6/bjATSz6dVeOx/255y8BAHb9yY5VIirfwjKgV4mJQnLTWgF5r/s+24jMY+eQmJKKV+1SMURE4SYsA3qg/ePTDQCAN5YzoBNR+ArbgB4RwLsSMZ1CRGZgKKCLyHARyRCRTBFJ0dl/m4jkiMgm7efOwFfV0bPXdQj2RxARhRWvq1yJSCSA2QCuBJANYL2ILFRKbXcq+oVS6r4g1FFX63rVy+qjiIjCgpEWek8AmUqpvUqpfADzAIwObrXKt/d+34vth8+EuhpERA6MBPRGAA7aPc/WtjkbKyJbRORLEWkckNqVsYIihWe+S9fdt+PIGSSmpCLj6Fk8m7oDV732u6H3TExJRevHfghkNYmIdBkJ6Hq9j86zcb4DkKiU6gRgKYCPdN9IZJKIpIlIWk6O5/HfoTJ3ZZbH/cNeKVkuoKCoGN9sPIRinclJ9vI5y5SIyoCRgJ4NwL7FnQDAYWFxpVSuUuqS9vRdAN313kgpNUcplayUSo6Pj/envmXKsoCX+xEwd32chn9+sQkvLsmAUp6DOhFRsBkJ6OsBtBKRZiISA2AcgIX2BUSkgd3TUQB2BK6KofXtJvc3xdifmwcAePvXPRj6Mhf6IqLQ8hrQlVKFAO4DsASWQD1fKZUuItNEZJRWbLKIpIvIZgCTAdwWrAqXtTb13Y+m2Xf8vO3x7mPncPBEHvbkcEw7EYWGoZtzKqUWAVjktO1Ju8dTAUwNbNXKh0gfJjD1f3E5ACBr5shgVYeIyK2wnSla0Ww6eAqJKan4SlsFkojIWVgH9CeuTgp1FcqMddx72v4TIa4JEZVXYR3Q7/hLs1BXQde5S643zSAiCrawDujlVYenlmDnUc4kJaKyxYDuxRvLM/163d6c894LEREFEAM6EZFJMKCHwM6jlnVhLhUWhboqRGQiDOgh8J8fdwEAfskon+vZEFF4YkAPojm/7Ql1FYioAjE0U5R8949P/wh1FYiogmELvYwkpqRyRUYiCioG9DJU5GXddCKi0mBAL0Mn8wpCmlef9t129J6xLGSfX9Es3nYEjy3YGupqUAXCgF6Gejy3FDMW7cTeEC2x+8HKfTh65qLL9gUbs5GYkorTeQUhqJV5/f2/f+DTtQdCXQ2qQEwV0OtUiwl1FQzZ42UW6TPfpWPq12XXspu3znLL2O1HuFwBUTgzTUDPmjkSaY9fGepq+OTuTzbobp+7Mgufr/Pcsjt+7hJyzl7yWKa8WZV5HBvCZLXI2cszsTLzeKirQeQT0wR0MzrvYdXG5GeXosdzSz2+PjElFYkpqYGult8mvLcWY99aHepqGDJrSQZufm9tqKtBZWTD/pO4WOD/zO28/EJsPHAygDXyDwN6Odb+qSXILyzGvZ/+gWIDQx735pxDYkoqVu05js0HT5VBDSumgqJiTP16i8Mw1Ds/SsPxc+F1xUQWuecuYexbq9xeMRtx0ztrcN2bq0p1UggEBvRy7pb31iJ16xF8sd6S5/5cy3frsaYIFm09gns/48SmYHn950x8vu4g/qfdPSot6wSW7vgTj3y5JcQ1c3Xs7MWQ1utiQRFOnM8PyWdnn8zDYwu2IjEl1WOf1NmLlivhrFz/V0i1vvZSYbHf7xEIDOgh1nXaj7hYUIQN+0+gWGec+rosS875fL779Mv077djS7Zji1zvvfSszzqBDftDf6nor1935eBkGQeMsxcLtH8tv5OLBZY/4ovlcLG1yZ9vxBdpB5Fx9Kzu/oGzluPGt4OXBus2/Sd0m/5TwN7vQn4RDuTmGSo78YN1tlFGv+2qGOsmmS6gPz+mY6ir4JOTeQX457xNGPvWasxenonvNh/26fVr9+bi/RX7MOqNlbZtp/IKcPi06/BEPTe8vRqFYTrh6dylQkz8YB3u+Gi9w/YDuXnlch2dtXtzy3xy2YV8y0nmgpYKSExJxX9+zLDtz8rNszUagiEvP7Anub99uB4DZi03VPb8Jf3PLi5WaP3YD5j0cRpm+3m/g/LKFAG9R2It2+PxPZsgLjYaAFC9cngsVWNt2f26Kwcv/bRLt4y7G2bcNGeNy7b0w8aGH/71g3WGyjl3riqlDAemxduOGv4cX1nzlfudWmyjZ6/AjEU7fQ6ewcx/7jx6BjfNWYNp36UH7TOMev3n8A1iq/fmlvo9bv1gLfKLivHj9j8xa0mG9xeUQuaxs0hMScWuP/WvkAIt7AP63hlXYf7dfXT3/f7wIGTNHIkVjwwq41r5pnplywkobf9JQ+u9WC/5S0Mp5fdlaPNHF6HFo4sMlf37fzcE7XI3X8tXRkc6fo3PaKkQpRRyz13CsbPer1ZmL89E2ycWl2rS18rMXN0TcmJKKn5K/xMAsM9guiDYElNS8ZcXfg51NUJiZWbpTwpGLdx8BACQuuVImXxe2Af0iAiBiHgsk1CrShnVpvSyDPzBd3z6R93t1svqfccdW/OJKakuIzB+3P6ny+vHv7vG1hpfsDHb7cnFnzXGCopKOosSU1KRX1iMA7l5SLO73P9+y2E0m2psmOWT327DES2tFB3l/vff/dml6Pmc43IHbR7/AVO/duwotPYjOB87T9IPn8Yxp5m3ry3brVv2642HHJ6vyjyObzcd0i0LAN9sPGSZvXsheLN3s09eCNp7B1tiSip+2v4nso6fd/hulTeFRdZGh+cYFShhH9DNYHeALsdmLNrpdt/OI46f4W2I1pQvNuP9FfsCUi8AaPXYDw7Pr3l9BQbMWo7r7TrkHv5yC5TyPP4esByvj1fvx10fpwEAYiK9f42//iPb9vhSYbHH0UJ68guLkZiS6hCwv/7jEAb++xef3sdqwntrcf+8TbonWwD4TOvM2+nD7N1Dpy6gz/PLcPBE+bgK8JXRzk6rN37ejYH//gV3fpQWpBo5mr080+3vyx1r/1SUge9oIDCglwM73YxACLXskxe8tpg/WbMfv+/2PaWSUYqTmPVKxDoczjnloueB+ZvxwPxNDtusE0EOn7qAQ15aqyfzLJ/13zX7HbYHotPvkS+32K6M7p+30WGfXh+JO1+mZePI6Yvo/2JJp2FBUdl1wloDnrcTsp41e3MxYNZyfLw6y/Brzmqf424ET6At22G5qt3vw/BG69VDVARb6BRAt7zv+6zH33bleE2vPPHNNtz6fmA7PXs/b0mRHDtzEb1mLMUdH67Hj+lH3ZaPiTL2Nf76D8cUh7UV3Hfmz25PMEop9Jv5M7J8SMUAcDtD97ddOS4t6GU7j9kef7vJMsrJnyGQeqkH6/o8vg7tPHbmIlbvycWfOou5ubNASysdPuV6cvx07X6Xbfasnf47/FxP6Nnvt2PbodN+vTaYCrUTqtHvaGkxoJNbzrF88bYjtmFwzk7nFWgTOEpy0/7e0MM6vvu5RTvw55lLWLbzGCZ9sgEnz+cjMSXVYYgmAGzJPq0bQFs6pXkAS0vQF+uzTuLQqQt4NIDL4E4yMCPROXe+/bDlxuKeppc7B3T7CT1nLhbg6YXGR9j0nLEM499dg14zlgVkCOhjC7YZLrtgY7bPN1B/b8U+XP36CgCW9Frf5x37Tc5eLAj4UhjtnliMV5fq95lYlbTQy1FAF5HhIpIhIpkikuKh3PUiokQkOXBVpPLihcUZaPfkYtvzXLtcYudplo7atftKOjnnpxnLU5+9WIA9TqNLnvhmm621avWbH6kdZ+PsUhgXCoq8/oHf+I4lxx/I4eNGgpVzQP95p+Vy/+PV+5GYkoqlOp3a9umVk+fzHeY0PJe6Ax+uyvKrvtsO6bea/7tmP4a/8ptf7+lOxtGzmPLFZjxsN7v1sQVbdSe/uVvu+YH5m13mYVhHPnlTXKx0v7cPzt+MPw5YJu/lnM1Ht+k/4UJBEV5eqj/M2Mr6Owlkg8ATrwFdRCIBzAYwAkASgPEikqRTrjqAyQC4olE5d/1bqwyV8zbio/uznhcHO37O2GV+x6d/xOD//Oqw7ZM1ni/RA+F7naFkd3yU5nMntXM6a+7K0nUmJ6ak4pRTsLIO0bSmFRbojJCxb6Hf8M5qPGXXIj9rMKB50vf5ZWhpN1z18W+2YefRs9iw/wSUUsg8Zjkp557Pt43u8GTwf35BYkoqiosVioot5a1B88CJPCSmpOKpb7fh07UHMFbnO5sboBnC+XZ1fWXZbjz85RYsST+Kl37aZbsi/cquU33Wkp0OVz+HT11we3wLix2Pw/bDZ2zHKRiMtNB7AshUSu1VSuUDmAdgtE656QBeBGA86RYkg9rEAwCqxJRMLNr85FCM79k4VFUqV9KCPNV/6tdbsGH/yYBP2vglw3sL/eCJvFLPxrzyZc+tzrkrszzuf+a77S7bHE6OPlYvMSUVm7Itgdy6SFslu5zsF+sPIDElFZvtln/wJfdt1OHTF1FYrJCYkurQDzD2rdVoNrUk0I+bswa3zV3v8nr7q6HiYmW7L0CXaT/iiW8d00HWK5TUrSV9J19tyIae/FIOWxyq/b735+bZRjHd/ckGvLZsN6anbsfWbMfcvPPXy37ZjacXpjsce/urzFWZx3HVa79jyEuOjZdAMhLQGwGwvwbJ1rbZiEhXAI2VUt97eiMRmSQiaSKSlpMTvLUVXhnXFVkzRzp0RMRVidYdj16zimVST/P4qkGrj1kYGaOtlGUBMb0WlTfeRows2Oh+3LaVNUVSnu31sYMVKFmLxNotUSkq0rZv3T7LCXqLXeDxp0We8tUW7DxqrFNyq5cOyBWZx9FvpuvEpZe1iVczF5cMsTWaDnnwf5t1t9u3lu2/d3p35/LVZ2sP4Jo3Vhguv2DjIfTSbvPo3Ic0oQyWYzYS0PXG29hqKiIRAF4G8KC3N1JKzVFKJSulkuPj443XMojqVKvk8PyZUe1DVBMqrTs+XG+bbGRWei10+3SAvxJTUjFv/UGMm7PGZeikHiPj4w/pjHZ5VWsBB+s2jGWx0Jxzw0bvgnD1nlzbsMqyZCSgZwOwz1UkALDvraoOoAOAX0QkC0BvAAvDoWO0f6s6iI2OdNhWIzY81n8pr3yZaRlo9sP/Ai2U/y971thRKdryp2t0Vc0LBtepOZVX4NIZDVhGnth7rRTrwSSmpGLpDs+/q+wT4TOL9d3f97psG//uGpw6736Wb36Qltk1EtDXA2glIs1EJAbAOAALrTuVUqeVUnWUUolKqUQAawCMUkqVzfStUvj3DZ29lrl/cCu0b1ijDGpD5J21f8Cacun49JIy+dwpX+inO4KltHnxsuTcgW3bfsF9p+2ULza53VcaXpujSqlCEbkPwBIAkQA+UEqli8g0AGlKqYWe36H8qF+jMgBg+rUdcGvvpgCA+OqWlEsNbYEsZ1OubI242GikH96Ozglx2Jxd/iYvUNk5FuL7uFrXX3lt2W7EV6+E8wFenlZPWa0UqCec7wJ10k2gB/zrRzHCUH5BKbUIwCKnbU+6KTuw9NUKjrHdEyACXNe1pE/39fFd8f2Ww1i9Jxeb3Ny27W9/aWb5+dC1554oVJ74xvhkndLQy4WTd6fyyv5OTRVupuiYbgkOqzNWrRSFm3o0cShjbbU7q+tmO5GZBWIMe0XkLhUTTBUuoLtjDfICwaqUK3TLPHF1Eh4f2a4sq0VEYeopH5ZaCBQGdM2DQ1sDAEZ0rO929b6qlaJwZ//mZVktIirnyssIKIAB3SahVhVkzRxpGz0wplsjPHddB4+vYWudiMoTDrp246Ubu7jdlzVzJADXsblERKHEFjoRkUkwoBMRmQQDegB1bVIz1FUgojAQrMlaDOgB9PHfeoa6CkQUBkq7xLM7DOil0Lpedbf7nFvrXJ6XiIKNAb0U2jeMw+7nRrhsr1YpCn2a19Z9TUKtWHRubAn2NyYnBLV+RFSxMKCXkrtJSM5qV40BACQ1qGFbQmBwu3pBqxcRVTwchx4AX0zq7XC7Oz1v3twdyzOO4ZpODTHZwA0EiIh8xYAeAL209MrZi+4X44mvXgk3Jvt+T9NmdaqWq6nFRFR+MeVCRGQSDOgBVK2S5YLn6TK6L2n3prXK5HOIKDwwoAeQiCBr5khc3z1wo1da1q3msi1r5khkzRyJqtoJpFkd90MioyP17vFNRGbEgB5kE/s0tS3m5Y9xPRrjh/v76+6zDo1s7iag92tZG3+/vIXfn01E4YUBPcjqavcx9ea2vokAgFGdGzps7928Nto1qIF1jw12ec09A1sga+ZINL6sitv3vWjwbu9EFP4Y0MuJp0e1R9bMkXhtfFekPT4EgGXsujWtUrd6ZVvQ98XFgvC4e/qLYzuFugqm5s93h8IPA3oYsQZ9X4RLC71yTGSoq2BaretVQ+/ml4W6GlQGGNBDoL6WhqlTLfg3nb5YaLyFfsdfmjk8t3a2xkQF52vy1T19bI/bN6xh6DWt67l2EhtVvVLpp13wRuFUnjGgh8CT1yRh1vWdymTYoV4LvZpOYOvfqg6euDrJYZt1+OW8Sb1dys+9rQdqVYm2Pb8yqR662S1IFmE3uKZV3Wq6n9m9aUmrsUW8fhlnP0653O0+b1cv8TWMB2N3Hc3ePHVNkvdCpfTbQ4N8fk2QFvcLmX8M9L+zv5uJl7lmQA+B6MgI3KDNGp1xXcegBnal84e87ZlhePZax/ulvvvXZADAkHZ1AQAiwOWt45E1cyS6NanlEiwHta2Lhff9xe3nNqwZa1t87MokY2vWvHVLN5dtzp3EgeBpmKfVnL929/l9+7Wsjdv7NcPr47v6Uy3DmtR23wmuJ0IE2SfzdPeN7NgA43t6nsFsPV4dG8Xh87tcT+5lwfn79/Dwtph+rf49f1Mnu/9ejunaCFd1bAAA+Fu/Zm7LhSsG9BCb0KsJvrqnb6neo0eiY350QOt422N3N7pOqBXr8LxytCWH/d7EHlgzdTDSnxnm8hrnkTb2o2uiIhzHuxcUFaNpbe+B88bkBHx4ew8AQP9W8S77XxvfFZOvaOn1fdzp0rim7YRiTSlN6NnEtn/vjKtcXjOxT1O0rFvda4vf3YnhGh9OQq+Oc3/vWl9EeJhu8PJNXRAh7gvonfTtVdJSbrHRkejTQn8VUWdjujZCG6flpesbHPHlTdv6lvetUVn/iq59wzi3r314eFvbYw+HRNfSBwbg+/9zf7KwN6ZbI9/ePEAY0IPkph6WVs91XX3/xVpTD86B2p2RnRrYHq94ZBCmjrB8aRvExaKeH39E9eMq6y42Vre6+/d60inVkO8hd//C2I54RPvDevH6zhjYpq6hek0Z0tprmRfGdnS7r061SsiaORJxsZZU0Q3dExChEwmfGV1yEpw9wfWqwV8dG7kGmtFdGuHxke18fi/nCWN7nx+JGdfp/9/bNaiBiX0TMfe2Hrr7p47w/Pmt61XH1Z0a4DUfrjxeuqkLlkwZ4NBwiI7yb5JbX+0kMrx9fTx1TRIW/3MAAKBGbLTb10we3Ep3e+XoCNsVcb+WjienkR0b6L3E5rKqlZDUwLWvp3OC6+/V/ibzn97Zy/b4rZsD933Sw4AeJE1rV0XWzJFoWDPWe2EnlaMjsWfGVbopCG8SalVBuwY18MaErm7/wEujbvVKeGOC6x92gzjH/2dBkbK17Kytf6ubejTBPaXIgVqtTLnClg/94LZk23tHemqu6nhPSzfpuUxb9ripj2kOPf+9o5f3QgZlTHddh9/TTVSiIyMwqK3+iTOuSjSmj/a8XMUbE7qhfpzlhO7peDlb8cgVtsfj7a6MfHFX/+YAgLdv7Y7b7dIkNSq7D+gPXNla94qgcnQkumopxCvaOqYCc89f8qt+bet77tDv17KO7XFskEdzGQroIjJcRDJEJFNEUnT2/11EtorIJhFZISLB7xkyucgIgfh6TWjn6k4NXUanvHRjZ4fWvFX/VnVctrmz7rEhuLqT95RCfmExbuubiD7NHWerbn16qMfXvX1LN8O38mtUMxZzb+uJfi1rY5DBVj4AdGtqOQkM1voLhiTVw8wxnk9+Mdq696X5g4yroh+ArOvif3tvP9u6+c5mjunoMAopIsKyzMTUEW1xe79EAJZJaFarp17h/BYejfMh2A5x0ycS72YEkHWpCusVZyMvjZxezRyvTHu7uVlMXKzvo5YqOf1N2I80Kyjyr+e48WWxDum3QIym8pfXgC4ikQBmAxgBIAnAeJ2A/ZlSqqNSqguAFwG8FPCakkc/3N8fL93YWXfft/f2w9zbe2BMtwSXFMKA1vH4pBQtx2ev7YBP7rAE4L4tSk4MDw5tjajICHw+qTdioiIwTWsBehvJMrxDAwxoHY/2DWvYWseexFWJxqd39vbp5GfNjw/vUHJy8xbQLqsag/E9m+Cj20t331i99EqzOparuc6Na+JOrTWq54mrk1zy+ndf3gJPXVPSuv7toUF4dVwXlysmb6IjI/waPWO169kRtlSWO9Yrp8aXxTp0rt7cy3LsrVeUa/edsO2rU62S25NoQq0qPgdPd9+TW3o3wSs3ee7PcD4ZWOUXKdi/6yrtZDr39h54aFgbh7LWFFSdat6/2/4wcjR6AshUSu0FABGZB2A0gO3WAkqpM3blqwIw2SCp8q9dgxpop5PfA2C75Z096x9fLTetRqNu6d3U9vhfw9rgX05fYKsx3RIwppvxRctSJ+uvXxNM43s2xob9Jx22ddGO3T8GtcTlrV07bY365V8DAQB39m+OZTuOYfXeXLw/0TV1cc/AFnhh8U4AwJqpg9H7+WU+fU6T2lVso2Den5jsku7y9tqHhrXBrCUZPn0mYGyuQtfGNdGmXnW8OLazw0id567riOeu64jiYoVHF2xFfPVKyDnrPf1ROToSW58ZhsSUVJ/raxUXG4Xj5y7hoaFt3V5BAZY0U9VKUSjWGf/Zul41XLLrM6qupYIGtanrcuXYIr4adj83wmMndWkYSbk0AnDQ7nm2ts2BiNwrIntgaaFP1nsjEZkkImkikpaTk+NPfSlAujaphSlDWmPmGE65t3p+TCeXce6xMZHImjnSr2B+V/+SFEmizoiYWDfBtnJ0BGpWibblrP01uF09h/wtAKxKsbQerR3nzu4dVDKi6I8nrgQATOzbVLesO+6GqYoIlkwZYAvmO6cPxxa7FFxEhGD5vwbiOw/DYX3RysAktM/u6o2pI0qC+dU6KUmgJM0UESF459aSIa1LHxiAqzs1REGRsQl8IoLoyAif+3mMMtJC1/tkl9OUUmo2gNkiMgHA4wAm6pSZA2AOACQnJ7MVH2L3D9EfCVDeDGxbF6/9nImBbYwF1QgBQr3ggTU18u7v+3x+7U6dDs9AaVgzFlkzR+JUXj6e/2GnLf+u57KqMX6tFPqwm6s0Z5WjI12uIIzMEfDE/qrn/Yk9cPBkHlrEV3Pbiq9XozLutuvjqerlVpIAMKx9fdvjlnUtQyjztYAerFSKUUZa6NkA7GceJAA47KH8PADXlqZSRPasE5vsU0eelk14f6L+8LxwFujRETWrWIJ1ssGhsc6mX9sBP00Z4LDtHi0w+jrxSY8vE5hWPFKS+7e/8XpMVARaxPu3VMSkAc2x+SnL1YOR7MiLYzuhbf3qWPvoEL8+L1CMtNDXA2glIs0AHAIwDsAE+wIi0koptVt7OhLAbhAFibdW44DW8fj6H30x5s1VQfn82/slYu7KLJ8nppRGMGbMlsatvV3TMGO7J2BsgG7u0qKu8ZZ6Qi3vJ5BVKVcgL7/Q8Hs2r1MVcSR6DC4AAAowSURBVLHRhq9Qhravj6F2LfdQ8dpCV0oVArgPwBIAOwDMV0qli8g0ERmlFbtPRNJFZBOAB6CTbiEym+u7JyAmMsLjbM9v7+2HdY+6rmVv1NCkeph/d59SDWElS6rJmh7xpH0jy8ACvTuFhQNDY36UUosALHLa9qTd4/sDXC+iUrEuRRDMW/BViorErudG4ECuZZ2Ubk1c1+TRG2Hkizk+TOKh0vtrn0QMTarvtUP614cG4vCpiz69t96M0kAL3Qh4oiDq2CgOSQ1qYNb1nfHST7sAAFUClIe2Dg+1LuXbpHYVbJ82zO2oFWdjuydg9d5ct8NMQ+3Nm7vpLlNQURgZXdS0dlVDaxVZleY2lL5gQCdTEhEs0u7FOv3aDigsLtZd/MsfNyY3Rt8WtR1yt3pr37hzffeEgN5IPNCu8rKmSXnF++cyoFMFEBcbjTdv9n05XE+MdMRR2SmrFnB5x4BORH6b0KsJeiQGfj3/eG1Y6tOjuCyUL0R5Www5SJKTk1VaWlpIPpuIKFyJyAallG5vOZfPJSIyCQZ0IiKTYEAnIjIJBnQiIpNgQCciMgkGdCIik2BAJyIyCQZ0IiKTYEAnIjIJBnQiIpNgQCciMgkGdCIik2BAJyIyCQZ0IiKTYEAnIjIJBnQiIpNgQCciMgkGdCIik2BAJyIyCQZ0IiKTYEAnIjIJBnQiIpMwFNBFZLiIZIhIpoik6Ox/QES2i8gWEVkmIk0DX1UiIvLEa0AXkUgAswGMAJAEYLyIJDkV2wggWSnVCcCXAF4MdEWJiMgzIy30ngAylVJ7lVL5AOYBGG1fQCm1XCmVpz1dAyAhsNUkIiJvjAT0RgAO2j3P1ra5cweAH/R2iMgkEUkTkbScnBzjtSQiIq+MBHTR2aZ0C4rcAiAZwCy9/UqpOUqpZKVUcnx8vPFaEhGRV1EGymQDaGz3PAHAYedCIjIEwGMALldKXQpM9YiIyCgjLfT1AFqJSDMRiQEwDsBC+wIi0hXAOwBGKaWOBb6aRETkjdeArpQqBHAfgCUAdgCYr5RKF5FpIjJKKzYLQDUA/xORTSKy0M3bERFRkBhJuUAptQjAIqdtT9o9HhLgehERkY84U5SIyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJAwFdBEZLiIZIpIpIik6+weIyB8iUigi1we+mkRE5I3XgC4ikQBmAxgBIAnAeBFJcip2AMBtAD4LdAWJiMiYKANlegLIVErtBQARmQdgNIDt1gJKqSxtX3EQ6khERAYYSbk0AnDQ7nm2to2IiMoRIwFddLYpfz5MRCaJSJqIpOXk5PjzFkRE5IaRgJ4NoLHd8wQAh/35MKXUHKVUslIqOT4+3p+3ICIiN4wE9PUAWolIMxGJATAOwMLgVouIiHzlNaArpQoB3AdgCYAdAOYrpdJFZJqIjAIAEekhItkAbgDwjoikB7PSRETkysgoFyilFgFY5LTtSbvH62FJxRARUYhwpigRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZhKGALiLDRSRDRDJFJEVnfyUR+ULbv1ZEEgNdUSIi8sxrQBeRSACzAYwAkARgvIgkORW7A8BJpVRLAC8DeCHQFSUiIs+MtNB7AshUSu1VSuUDmAdgtFOZ0QA+0h5/CWCwiEjgqklERN5EGSjTCMBBu+fZAHq5K6OUKhSR0wBqAzhuX0hEJgGYpD09JyIZ/lS6HKkDp/8j8Zi4wePiisfElZFj0tTdDiMBXa+lrfwoA6XUHABzDHxmWBCRNKVUcqjrUZ7wmOjjcXHFY+KqtMfESMolG0Bju+cJAA67KyMiUQDiAJzwt1JEROQ7IwF9PYBWItJMRGIAjAOw0KnMQgATtcfXA/hZKeXSQiciouDxmnLRcuL3AVgCIBLAB0qpdBGZBiBNKbUQwPsAPhGRTFha5uOCWelyxDTpowDiMdHH4+KKx8RVqY6JsCFNRGQOnClKRGQSDOhERCbBgO6FiESKyEYR+V573kxb3mC3ttxBjLa9wix/ICJZIrJVRDaJSJq27TIR+Uk7Lj+JSC1tu4jIa9px2SIi3UJb++AQkZoi8qWI7BSRHSLSpyIfExFpo30/rD9nROSfFfmYAICITBGRdBHZJiKfi0jlQMYUBnTv7geww+75CwBeVkq1AnASlmUPgIq3/MEgpVQXuzGzKQCWacdlmfYcsCwZ0Ur7mQTgrTKvadl4FcBipVRbAJ1h+c5U2GOilMrQvh9dAHQHkAdgASrwMRGRRgAmA0hWSnWAZZDJOAQypiil+OPmB5Yx98sAXAHge1gmUB0HEKXt7wNgifZ4CYA+2uMorZyE+v8QpOOSBaCO07YMAA20xw0AZGiP3wEwXq+cWX4A1ACwz/n3XZGPidNxGApgZUU/JiiZUX+ZFiO+BzAskDGFLXTPXgHwMIBi7XltAKeUUoXa82xYfkmA0/IHAKzLH5iRAvCjiGzQlnMAgHpKqSMAoP1bV9uut3REI5hLcwA5AOZq6bn3RKQqKvYxsTcOwOfa4wp7TJRShwD8G8ABAEdgiREbEMCYwoDuhohcDeCYUmqD/WadosrAPrPpp5TqBstl8r0iMsBD2YpwXKIAdAPwllKqK4DzKEkl6KkIxwQAoOWDRwH4n7eiOttMdUy0/oLRAJoBaAigKix/Q878jikM6O71AzBKRLJgWWHyClha7DW15Q0Ax2UQKszyB0qpw9q/x2DJi/YE8KeINAAA7d9jWnEjS0eEu2wA2UqptdrzL2EJ8BX5mFiNAPCHUupP7XlFPiZDAOxTSuUopQoAfA2gLwIYUxjQ3VBKTVVKJSilEmG5ZPxZKXUzgOWwLG8AWJY7+FZ7XCGWPxCRqiJS3foYlvzoNjj+/52Py1+1UQy9AZy2XnKbhVLqKICDItJG2zQYwHZU4GNiZzxK0i1AxT4mBwD0FpEqIiIo+Z4ELqaEuqMgHH4ADATwvfa4OYB1ADJhuYyspG2vrD3P1PY3D3W9g3QsmgPYrP2kA3hM214blg7k3dq/l2nbBZYbpOwBsBWWHv6Q/z+CcFy6AEgDsAXANwBq8ZigCoBcAHF22yr6MXkGwE5YGkGfAKgUyJjCqf9ERCbBlAsRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUn8P8TnjpgTr9ddAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "axis = plt.gca()\n", + "axis.set_ylim([0, 0.6])\n", + "plt.plot(steps, loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "steps = [t[\"step\"][0] for t in val_loss]\n", + "losses = [t[\"data\"][\"val_loss\"] for t in val_loss]" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "axis = plt.gca()\n", + "axis.set_ylim([0.3, 0.4])\n", + "plt.plot(steps, losses)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_pytorch_p36)", + "language": "python", + "name": "conda_pytorch_p36" + }, + "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.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/PyTorch/SpeechSynthesis/Tacotron2/TeacherForcing.ipynb b/PyTorch/SpeechSynthesis/Tacotron2/TeacherForcing.ipynb new file mode 100644 index 000000000..009062b2e --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/TeacherForcing.ipynb @@ -0,0 +1,5724 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 18G\r\n", + "4.0K drwxrwxr-x 2 ubuntu ubuntu 4.0K Feb 14 19:00 .\r\n", + "4.0K drwxrwxr-x 23 ubuntu ubuntu 4.0K Feb 15 20:08 ..\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 11:43 checkpoint_Tacotron2_1000.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:02 checkpoint_Tacotron2_1020.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:21 checkpoint_Tacotron2_1040.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:40 checkpoint_Tacotron2_1060.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:58 checkpoint_Tacotron2_1080.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 13:17 checkpoint_Tacotron2_1100.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 13:36 checkpoint_Tacotron2_1120.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 13:55 checkpoint_Tacotron2_1140.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 14:14 checkpoint_Tacotron2_1160.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 14:33 checkpoint_Tacotron2_1180.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 14:52 checkpoint_Tacotron2_1200.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 15:11 checkpoint_Tacotron2_1220.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 15:30 checkpoint_Tacotron2_1240.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 15:49 checkpoint_Tacotron2_1260.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 16:08 checkpoint_Tacotron2_1280.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 16:27 checkpoint_Tacotron2_1300.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 16:46 checkpoint_Tacotron2_1320.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 17:05 checkpoint_Tacotron2_1340.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 17:24 checkpoint_Tacotron2_1360.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 17:43 checkpoint_Tacotron2_1380.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 18:03 checkpoint_Tacotron2_1400.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 18:21 checkpoint_Tacotron2_1420.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 18:41 checkpoint_Tacotron2_1440.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 19:00 checkpoint_Tacotron2_1460.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 17:16 checkpoint_Tacotron2_360.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 17:34 checkpoint_Tacotron2_380.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 17:53 checkpoint_Tacotron2_400.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 18:11 checkpoint_Tacotron2_420.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 18:29 checkpoint_Tacotron2_440.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 00:43 checkpoint_Tacotron2_460.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:02 checkpoint_Tacotron2_480.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:21 checkpoint_Tacotron2_500.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:40 checkpoint_Tacotron2_520.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:58 checkpoint_Tacotron2_540.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 02:17 checkpoint_Tacotron2_560.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 02:35 checkpoint_Tacotron2_580.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 02:54 checkpoint_Tacotron2_600.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 03:13 checkpoint_Tacotron2_620.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 03:32 checkpoint_Tacotron2_640.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 03:50 checkpoint_Tacotron2_660.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 04:09 checkpoint_Tacotron2_680.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 04:28 checkpoint_Tacotron2_700.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 07:06 checkpoint_Tacotron2_720.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 07:24 checkpoint_Tacotron2_740.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 07:43 checkpoint_Tacotron2_760.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 08:02 checkpoint_Tacotron2_780.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 08:21 checkpoint_Tacotron2_800.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 08:51 checkpoint_Tacotron2_820.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 09:10 checkpoint_Tacotron2_840.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 09:29 checkpoint_Tacotron2_860.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 09:48 checkpoint_Tacotron2_880.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 10:07 checkpoint_Tacotron2_900.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 10:27 checkpoint_Tacotron2_920.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 10:46 checkpoint_Tacotron2_940.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 11:05 checkpoint_Tacotron2_960.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 11:24 checkpoint_Tacotron2_980.pt\r\n", + " 0 lrwxrwxrwx 1 ubuntu ubuntu 28 Feb 14 19:00 checkpoint_Tacotron2_last.pt -> checkpoint_Tacotron2_1460.pt\r\n", + "7.6M -rw-rw-r-- 1 ubuntu ubuntu 7.6M Feb 14 19:03 nvlog.json\r\n" + ] + } + ], + "source": [ + "!ls -lash output_michaelrosen2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "model_config = dict(\n", + " mask_padding=True,\n", + " n_mel_channels=80,\n", + " n_symbols=148,\n", + " symbols_embedding_dim=512,\n", + " #encoder\n", + " encoder_kernel_size=5,\n", + " encoder_n_convolutions=3,\n", + " encoder_embedding_dim=512,\n", + " # attention\n", + " attention_rnn_dim=1024,\n", + " attention_dim=128,\n", + " # attention location\n", + " attention_location_n_filters=32,\n", + " attention_location_kernel_size=31,\n", + " # decoder\n", + " n_frames_per_step=1,\n", + " decoder_rnn_dim=1024,\n", + " prenet_dim=256,\n", + " max_decoder_steps=2000,\n", + " gate_threshold=0.5,\n", + " p_attention_dropout=0.1,\n", + " p_decoder_dropout=0.1,\n", + " # postnet\n", + " postnet_embedding_dim=512,\n", + " postnet_kernel_size=5,\n", + " postnet_n_convolutions=5,\n", + " decoder_no_early_stopping=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "\n", + "import torch\n", + "from torch.utils.data import DataLoader\n", + "import numpy as np\n", + "\n", + "from common.utils import load_filepaths_and_text\n", + "from tacotron2.data_function import TextMelLoader, TextMelCollate, batch_to_gpu\n", + "import loss_functions\n", + "from train import parse_args as train_parse_args\n", + "\n", + "import models\n", + "from tacotron2.arg_parser import tacotron2_parser\n", + "from IPython.display import Audio\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_args(parser):\n", + " \"\"\"\n", + " Parse commandline arguments.\n", + " \"\"\"\n", + " parser.add_argument('--text-cleaners', nargs='*',\n", + " default=['english_cleaners'], type=str,\n", + " help='Type of text cleaners for input text')\n", + " parser.add_argument('--max-wav-value', default=32768.0, type=float,\n", + " help='Maximum audiowave value')\n", + " parser.add_argument('--sampling-rate', default=22050, type=int,\n", + " help='Sampling rate')\n", + " parser.add_argument('--filter-length', default=1024, type=int,\n", + " help='Filter length')\n", + " parser.add_argument('--hop-length', default=256, type=int,\n", + " help='Hop (stride) length')\n", + " parser.add_argument('--win-length', default=1024, type=int,\n", + " help='Window length')\n", + " parser.add_argument('--mel-fmin', default=0.0, type=float,\n", + " help='Minimum mel frequency')\n", + " parser.add_argument('--mel-fmax', default=8000.0, type=float,\n", + " help='Maximum mel frequency')\n", + " parser.add_argument('--n-mel-channels', default=80, type=int,\n", + " help='Number of bins in mel-spectrograms')\n", + "\n", + " return parser\n", + "\n", + "parser = argparse.ArgumentParser(description=\"Create mels with teacher forcing\")\n", + "parser = parse_args(parser)\n", + "#parser = train_parse_args(parser)\n", + "args = parser.parse_args([\n", + " #\"--output\", \"output\", \"--model-name\", \"Tacotron2\", \n", + " #\"--epochs\", \"100\", \"--learning-rate\", \"1e-4\",\n", + " #\"-bs\", \"10\"\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model = models.get_model(\"Tacotron2\", model_config, cpu_run=False)\n", + "# pretrained = torch.load(\"./output_michaelrosen2/checkpoint_Tacotron2_last.pt\")\n", + "pretrained = torch.load(\"./output_trebek/checkpoint_Tacotron2_last.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model ready\n" + ] + } + ], + "source": [ + "model.load_state_dict(pretrained[\"state_dict\"])\n", + "model.cuda()\n", + "model.eval()\n", + "print('model ready')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# dataset_path = \"/home/ubuntu/michael-rosen/\"\n", + "# audiopaths_and_text = \"/home/ubuntu/michael-rosen/michaelrosen_only_arpa_audio_text_train_filelist.txt\"\n", + "# melpaths_and_text = \"/home/ubuntu/michael-rosen/michaelrosen_only_arpa_mel_text_train_filelist.txt\"\n", + "dataset_path = \"/home/ubuntu/trebek/\"\n", + "audiopaths_and_text = \"/home/ubuntu/trebek/trebek_only_arpa_audio_text_train_filelist.txt\"\n", + "melpaths_and_text = \"/home/ubuntu/trebek/trebek_only_arpa_mel_text_train_filelist.txt\"\n", + "melpaths_and_text_list = load_filepaths_and_text(\n", + " dataset_path, \n", + " melpaths_and_text,\n", + ")\n", + "audiopaths_and_text_list = load_filepaths_and_text(\n", + " dataset_path, \n", + " audiopaths_and_text\n", + ")\n", + "args.load_mel_from_disk = True\n", + "mel_loader = TextMelLoader(dataset_path, melpaths_and_text, args)\n", + "data_loader = DataLoader(mel_loader, collate_fn=TextMelCollate(1), batch_size=2, shuffle=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_1346.npy\n", + "(1, 80, 809)\n", + "trebek_543.npy\n", + "(1, 80, 526)\n", + "trebek_2390.npy\n", + "(1, 80, 386)\n", + "trebek_1002.npy\n", + "(1, 80, 365)\n", + "trebek_1695.npy\n", + "(1, 80, 782)\n", + "trebek_1125.npy\n", + "(1, 80, 688)\n", + "trebek_1376.npy\n", + "(1, 80, 683)\n", + "trebek_1618.npy\n", + "(1, 80, 391)\n", + "trebek_1773.npy\n", + "(1, 80, 619)\n", + "trebek_1594.npy\n", + "(1, 80, 321)\n", + "trebek_2116.npy\n", + "(1, 80, 597)\n", + "trebek_2507.npy\n", + "(1, 80, 331)\n", + "trebek_2097.npy\n", + "(1, 80, 686)\n", + "trebek_658.npy\n", + "(1, 80, 692)\n", + "trebek_662.npy\n", + "(1, 80, 714)\n", + "trebek_600.npy\n", + "(1, 80, 510)\n", + "trebek_2324.npy\n", + "(1, 80, 672)\n", + "trebek_1772.npy\n", + "(1, 80, 321)\n", + "trebek_2545.npy\n", + "(1, 80, 401)\n", + "trebek_2553.npy\n", + "(1, 80, 313)\n", + "trebek_1467.npy\n", + "(1, 80, 789)\n", + "trebek_1204.npy\n", + "(1, 80, 523)\n", + "trebek_1756.npy\n", + "(1, 80, 469)\n", + "trebek_2546.npy\n", + "(1, 80, 241)\n", + "trebek_76.npy\n", + "(1, 80, 727)\n", + "trebek_886.npy\n", + "(1, 80, 628)\n", + "trebek_684.npy\n", + "(1, 80, 792)\n", + "trebek_292.npy\n", + "(1, 80, 554)\n", + "trebek_269.npy\n", + "(1, 80, 900)\n", + "trebek_1461.npy\n", + "(1, 80, 579)\n", + "trebek_961.npy\n", + "(1, 80, 644)\n", + "trebek_1607.npy\n", + "(1, 80, 466)\n", + "trebek_259.npy\n", + "(1, 80, 497)\n", + "trebek_1871.npy\n", + "(1, 80, 280)\n", + "trebek_2401.npy\n", + "(1, 80, 590)\n", + "trebek_53.npy\n", + "(1, 80, 551)\n", + "trebek_647.npy\n", + "(1, 80, 779)\n", + "trebek_266.npy\n", + "(1, 80, 752)\n", + "trebek_419.npy\n", + "(1, 80, 577)\n", + "trebek_1110.npy\n", + "(1, 80, 419)\n", + "trebek_1260.npy\n", + "(1, 80, 856)\n", + "trebek_803.npy\n", + "(1, 80, 566)\n", + "trebek_1042.npy\n", + "(1, 80, 671)\n", + "trebek_1538.npy\n", + "(1, 80, 628)\n", + "trebek_633.npy\n", + "(1, 80, 668)\n", + "trebek_1502.npy\n", + "(1, 80, 704)\n", + "trebek_2445.npy\n", + "(1, 80, 817)\n", + "trebek_1926.npy\n", + "(1, 80, 615)\n", + "trebek_27.npy\n", + "(1, 80, 782)\n", + "trebek_1906.npy\n", + "(1, 80, 564)\n", + "trebek_460.npy\n", + "(1, 80, 711)\n", + "trebek_1658.npy\n", + "(1, 80, 595)\n", + "trebek_362.npy\n", + "(1, 80, 662)\n", + "trebek_1466.npy\n", + "(1, 80, 370)\n", + "trebek_36.npy\n", + "(1, 80, 805)\n", + "trebek_1484.npy\n", + "(1, 80, 580)\n", + "trebek_2431.npy\n", + "(1, 80, 615)\n", + "trebek_1599.npy\n", + "(1, 80, 494)\n", + "trebek_577.npy\n", + "(1, 80, 760)\n", + "trebek_52.npy\n", + "(1, 80, 634)\n", + "trebek_1296.npy\n", + "(1, 80, 676)\n", + "trebek_1334.npy\n", + "(1, 80, 484)\n", + "trebek_2027.npy\n", + "(1, 80, 755)\n", + "trebek_1608.npy\n", + "(1, 80, 522)\n", + "trebek_122.npy\n", + "(1, 80, 827)\n", + "trebek_2094.npy\n", + "(1, 80, 680)\n", + "trebek_295.npy\n", + "(1, 80, 658)\n", + "trebek_1294.npy\n", + "(1, 80, 342)\n", + "trebek_1304.npy\n", + "(1, 80, 587)\n", + "trebek_698.npy\n", + "(1, 80, 528)\n", + "trebek_862.npy\n", + "(1, 80, 529)\n", + "trebek_821.npy\n", + "(1, 80, 533)\n", + "trebek_1147.npy\n", + "(1, 80, 671)\n", + "trebek_558.npy\n", + "(1, 80, 530)\n", + "trebek_1998.npy\n", + "(1, 80, 640)\n", + "trebek_16.npy\n", + "(1, 80, 642)\n", + "trebek_2170.npy\n", + "(1, 80, 747)\n", + "trebek_1251.npy\n", + "(1, 80, 552)\n", + "trebek_2289.npy\n", + "(1, 80, 649)\n", + "trebek_1211.npy\n", + "(1, 80, 639)\n", + "trebek_2285.npy\n", + "(1, 80, 663)\n", + "trebek_510.npy\n", + "(1, 80, 308)\n", + "trebek_1886.npy\n", + "(1, 80, 666)\n", + "trebek_1587.npy\n", + "(1, 80, 546)\n", + "trebek_562.npy\n", + "(1, 80, 627)\n", + "trebek_1566.npy\n", + "(1, 80, 574)\n", + "trebek_37.npy\n", + "(1, 80, 887)\n", + "trebek_1840.npy\n", + "(1, 80, 655)\n", + "trebek_859.npy\n", + "(1, 80, 628)\n", + "trebek_2478.npy\n", + "(1, 80, 419)\n", + "trebek_2522.npy\n", + "(1, 80, 520)\n", + "trebek_2416.npy\n", + "(1, 80, 533)\n", + "trebek_9.npy\n", + "(1, 80, 572)\n", + "trebek_374.npy\n", + "(1, 80, 287)\n", + "trebek_2550.npy\n", + "(1, 80, 476)\n", + "trebek_2051.npy\n", + "(1, 80, 497)\n", + "trebek_753.npy\n", + "(1, 80, 770)\n", + "trebek_1019.npy\n", + "(1, 80, 699)\n", + "trebek_112.npy\n", + "(1, 80, 696)\n", + "trebek_2530.npy\n", + "(1, 80, 282)\n", + "trebek_2409.npy\n", + "(1, 80, 595)\n", + "trebek_1436.npy\n", + "(1, 80, 515)\n", + "trebek_822.npy\n", + "(1, 80, 576)\n", + "trebek_2063.npy\n", + "(1, 80, 535)\n", + "trebek_1873.npy\n", + "(1, 80, 680)\n", + "trebek_1269.npy\n", + "(1, 80, 672)\n", + "trebek_2004.npy\n", + "(1, 80, 476)\n", + "trebek_1432.npy\n", + "(1, 80, 370)\n", + "trebek_1447.npy\n", + "(1, 80, 383)\n", + "trebek_1634.npy\n", + "(1, 80, 303)\n", + "trebek_2349.npy\n", + "(1, 80, 851)\n", + "trebek_657.npy\n", + "(1, 80, 535)\n", + "trebek_2519.npy\n", + "(1, 80, 546)\n", + "trebek_2468.npy\n", + "(1, 80, 329)\n", + "trebek_243.npy\n", + "(1, 80, 900)\n", + "trebek_222.npy\n", + "(1, 80, 551)\n", + "trebek_435.npy\n", + "(1, 80, 326)\n", + "trebek_2191.npy\n", + "(1, 80, 179)\n", + "trebek_405.npy\n", + "(1, 80, 569)\n", + "trebek_2267.npy\n", + "(1, 80, 362)\n", + "trebek_2424.npy\n", + "(1, 80, 541)\n", + "trebek_2454.npy\n", + "(1, 80, 145)\n", + "trebek_2016.npy\n", + "(1, 80, 727)\n", + "trebek_118.npy\n", + "(1, 80, 608)\n", + "trebek_757.npy\n", + "(1, 80, 508)\n", + "trebek_1655.npy\n", + "(1, 80, 455)\n", + "trebek_1816.npy\n", + "(1, 80, 562)\n", + "trebek_2121.npy\n", + "(1, 80, 486)\n", + "trebek_262.npy\n", + "(1, 80, 905)\n", + "trebek_31.npy\n", + "(1, 80, 944)\n", + "trebek_1289.npy\n", + "(1, 80, 771)\n", + "trebek_1617.npy\n", + "(1, 80, 368)\n", + "trebek_1264.npy\n", + "(1, 80, 621)\n", + "trebek_1881.npy\n", + "(1, 80, 559)\n", + "trebek_953.npy\n", + "(1, 80, 750)\n", + "trebek_795.npy\n", + "(1, 80, 238)\n", + "trebek_2203.npy\n", + "(1, 80, 698)\n", + "trebek_2003.npy\n", + "(1, 80, 378)\n", + "trebek_1081.npy\n", + "(1, 80, 758)\n", + "trebek_231.npy\n", + "(1, 80, 339)\n", + "trebek_2554.npy\n", + "(1, 80, 574)\n", + "trebek_1439.npy\n", + "(1, 80, 205)\n", + "trebek_1819.npy\n", + "(1, 80, 572)\n", + "trebek_1640.npy\n", + "(1, 80, 530)\n", + "trebek_1453.npy\n", + "(1, 80, 556)\n", + "trebek_1838.npy\n", + "(1, 80, 329)\n", + "trebek_999.npy\n", + "(1, 80, 561)\n", + "trebek_2291.npy\n", + "(1, 80, 459)\n", + "trebek_320.npy\n", + "(1, 80, 831)\n", + "trebek_288.npy\n", + "(1, 80, 430)\n", + "trebek_2484.npy\n", + "(1, 80, 584)\n", + "trebek_2327.npy\n", + "(1, 80, 666)\n", + "trebek_585.npy\n", + "(1, 80, 719)\n", + "trebek_1649.npy\n", + "(1, 80, 474)\n", + "trebek_546.npy\n", + "(1, 80, 714)\n", + "trebek_2347.npy\n", + "(1, 80, 603)\n", + "trebek_240.npy\n", + "(1, 80, 758)\n", + "trebek_830.npy\n", + "(1, 80, 605)\n", + "trebek_1766.npy\n", + "(1, 80, 787)\n", + "trebek_1190.npy\n", + "(1, 80, 658)\n", + "trebek_2523.npy\n", + "(1, 80, 476)\n", + "trebek_1638.npy\n", + "(1, 80, 393)\n", + "trebek_1320.npy\n", + "(1, 80, 566)\n", + "trebek_182.npy\n", + "(1, 80, 272)\n", + "trebek_678.npy\n", + "(1, 80, 590)\n", + "trebek_1956.npy\n", + "(1, 80, 432)\n", + "trebek_956.npy\n", + "(1, 80, 618)\n", + "trebek_1478.npy\n", + "(1, 80, 649)\n", + "trebek_524.npy\n", + "(1, 80, 650)\n", + "trebek_1138.npy\n", + "(1, 80, 581)\n", + "trebek_935.npy\n", + "(1, 80, 730)\n", + "trebek_2088.npy\n", + "(1, 80, 564)\n", + "trebek_626.npy\n", + "(1, 80, 585)\n", + "trebek_1677.npy\n", + "(1, 80, 339)\n", + "trebek_1580.npy\n", + "(1, 80, 518)\n", + "trebek_1637.npy\n", + "(1, 80, 556)\n", + "trebek_1273.npy\n", + "(1, 80, 628)\n", + "trebek_1628.npy\n", + "(1, 80, 564)\n", + "trebek_2253.npy\n", + "(1, 80, 667)\n", + "trebek_2421.npy\n", + "(1, 80, 551)\n", + "trebek_285.npy\n", + "(1, 80, 489)\n", + "trebek_233.npy\n", + "(1, 80, 445)\n", + "trebek_68.npy\n", + "(1, 80, 727)\n", + "trebek_1463.npy\n", + "(1, 80, 370)\n", + "trebek_2411.npy\n", + "(1, 80, 712)\n", + "trebek_1652.npy\n", + "(1, 80, 249)\n", + "trebek_642.npy\n", + "(1, 80, 779)\n", + "trebek_581.npy\n", + "(1, 80, 721)\n", + "trebek_2014.npy\n", + "(1, 80, 732)\n", + "trebek_1398.npy\n", + "(1, 80, 616)\n", + "trebek_773.npy\n", + "(1, 80, 486)\n", + "trebek_1855.npy\n", + "(1, 80, 471)\n", + "trebek_855.npy\n", + "(1, 80, 696)\n", + "trebek_181.npy\n", + "(1, 80, 644)\n", + "trebek_1924.npy\n", + "(1, 80, 665)\n", + "trebek_2374.npy\n", + "(1, 80, 504)\n", + "trebek_40.npy\n", + "(1, 80, 538)\n", + "trebek_44.npy\n", + "(1, 80, 510)\n", + "trebek_1548.npy\n", + "(1, 80, 639)\n", + "trebek_430.npy\n", + "(1, 80, 595)\n", + "trebek_1137.npy\n", + "(1, 80, 657)\n", + "trebek_2050.npy\n", + "(1, 80, 479)\n", + "trebek_2284.npy\n", + "(1, 80, 347)\n", + "trebek_2406.npy\n", + "(1, 80, 264)\n", + "trebek_712.npy\n", + "(1, 80, 738)\n", + "trebek_1219.npy\n", + "(1, 80, 443)\n", + "trebek_1073.npy\n", + "(1, 80, 740)\n", + "trebek_348.npy\n", + "(1, 80, 535)\n", + "trebek_256.npy\n", + "(1, 80, 590)\n", + "trebek_1144.npy\n", + "(1, 80, 743)\n", + "trebek_436.npy\n", + "(1, 80, 577)\n", + "trebek_86.npy\n", + "(1, 80, 450)\n", + "trebek_852.npy\n", + "(1, 80, 631)\n", + "trebek_2492.npy\n", + "(1, 80, 512)\n", + "trebek_397.npy\n", + "(1, 80, 601)\n", + "trebek_615.npy\n", + "(1, 80, 510)\n", + "trebek_851.npy\n", + "(1, 80, 549)\n", + "trebek_2174.npy\n", + "(1, 80, 557)\n", + "trebek_1099.npy\n", + "(1, 80, 702)\n", + "trebek_104.npy\n", + "(1, 80, 460)\n", + "trebek_2189.npy\n", + "(1, 80, 621)\n", + "trebek_1904.npy\n", + "(1, 80, 538)\n", + "trebek_1159.npy\n", + "(1, 80, 610)\n", + "trebek_843.npy\n", + "(1, 80, 724)\n", + "trebek_507.npy\n", + "(1, 80, 753)\n", + "trebek_2117.npy\n", + "(1, 80, 533)\n", + "trebek_503.npy\n", + "(1, 80, 663)\n", + "trebek_1744.npy\n", + "(1, 80, 192)\n", + "trebek_762.npy\n", + "(1, 80, 706)\n", + "trebek_2373.npy\n", + "(1, 80, 507)\n", + "trebek_1844.npy\n", + "(1, 80, 707)\n", + "trebek_165.npy\n", + "(1, 80, 427)\n", + "trebek_1851.npy\n", + "(1, 80, 698)\n", + "trebek_1817.npy\n", + "(1, 80, 546)\n", + "trebek_537.npy\n", + "(1, 80, 895)\n", + "trebek_2176.npy\n", + "(1, 80, 696)\n", + "trebek_424.npy\n", + "(1, 80, 747)\n", + "trebek_138.npy\n", + "(1, 80, 724)\n", + "trebek_2494.npy\n", + "(1, 80, 446)\n", + "trebek_769.npy\n", + "(1, 80, 500)\n", + "trebek_2036.npy\n", + "(1, 80, 559)\n", + "trebek_2261.npy\n", + "(1, 80, 401)\n", + "trebek_142.npy\n", + "(1, 80, 626)\n", + "trebek_780.npy\n", + "(1, 80, 427)\n", + "trebek_1825.npy\n", + "(1, 80, 639)\n", + "trebek_325.npy\n", + "(1, 80, 536)\n", + "trebek_468.npy\n", + "(1, 80, 950)\n", + "trebek_2297.npy\n", + "(1, 80, 267)\n", + "trebek_2247.npy\n", + "(1, 80, 694)\n", + "trebek_1990.npy\n", + "(1, 80, 517)\n", + "trebek_293.npy\n", + "(1, 80, 840)\n", + "trebek_1040.npy\n", + "(1, 80, 758)\n", + "trebek_2045.npy\n", + "(1, 80, 716)\n", + "trebek_467.npy\n", + "(1, 80, 683)\n", + "trebek_1987.npy\n", + "(1, 80, 823)\n", + "trebek_2221.npy\n", + "(1, 80, 566)\n", + "trebek_2162.npy\n", + "(1, 80, 592)\n", + "trebek_779.npy\n", + "(1, 80, 409)\n", + "trebek_2019.npy\n", + "(1, 80, 709)\n", + "trebek_594.npy\n", + "(1, 80, 383)\n", + "trebek_1035.npy\n", + "(1, 80, 569)\n", + "trebek_2236.npy\n", + "(1, 80, 228)\n", + "trebek_2222.npy\n", + "(1, 80, 583)\n", + "trebek_2498.npy\n", + "(1, 80, 228)\n", + "trebek_2331.npy\n", + "(1, 80, 675)\n", + "trebek_1916.npy\n", + "(1, 80, 437)\n", + "trebek_2087.npy\n", + "(1, 80, 569)\n", + "trebek_776.npy\n", + "(1, 80, 580)\n", + "trebek_1091.npy\n", + "(1, 80, 760)\n", + "trebek_5.npy\n", + "(1, 80, 631)\n", + "trebek_2276.npy\n", + "(1, 80, 789)\n", + "trebek_153.npy\n", + "(1, 80, 786)\n", + "trebek_2001.npy\n", + "(1, 80, 595)\n", + "trebek_10.npy\n", + "(1, 80, 489)\n", + "trebek_1511.npy\n", + "(1, 80, 771)\n", + "trebek_1542.npy\n", + "(1, 80, 732)\n", + "trebek_646.npy\n", + "(1, 80, 796)\n", + "trebek_2169.npy\n", + "(1, 80, 479)\n", + "trebek_560.npy\n", + "(1, 80, 833)\n", + "trebek_630.npy\n", + "(1, 80, 536)\n", + "trebek_407.npy\n", + "(1, 80, 835)\n", + "trebek_117.npy\n", + "(1, 80, 932)\n", + "trebek_730.npy\n", + "(1, 80, 685)\n", + "trebek_1518.npy\n", + "(1, 80, 411)\n", + "trebek_2282.npy\n", + "(1, 80, 626)\n", + "trebek_1070.npy\n", + "(1, 80, 479)\n", + "trebek_872.npy\n", + "(1, 80, 596)\n", + "trebek_78.npy\n", + "(1, 80, 688)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_433.npy\n", + "(1, 80, 825)\n", + "trebek_2463.npy\n", + "(1, 80, 272)\n", + "trebek_1185.npy\n", + "(1, 80, 709)\n", + "trebek_1066.npy\n", + "(1, 80, 618)\n", + "trebek_719.npy\n", + "(1, 80, 637)\n", + "trebek_2385.npy\n", + "(1, 80, 422)\n", + "trebek_709.npy\n", + "(1, 80, 380)\n", + "trebek_2560.npy\n", + "(1, 80, 318)\n", + "trebek_341.npy\n", + "(1, 80, 645)\n", + "trebek_1493.npy\n", + "(1, 80, 471)\n", + "trebek_607.npy\n", + "(1, 80, 670)\n", + "trebek_1043.npy\n", + "(1, 80, 507)\n", + "trebek_518.npy\n", + "(1, 80, 691)\n", + "trebek_2302.npy\n", + "(1, 80, 380)\n", + "trebek_39.npy\n", + "(1, 80, 1036)\n", + "trebek_1808.npy\n", + "(1, 80, 298)\n", + "trebek_1234.npy\n", + "(1, 80, 745)\n", + "trebek_2486.npy\n", + "(1, 80, 471)\n", + "trebek_71.npy\n", + "(1, 80, 920)\n", + "trebek_635.npy\n", + "(1, 80, 750)\n", + "trebek_1212.npy\n", + "(1, 80, 526)\n", + "trebek_1041.npy\n", + "(1, 80, 440)\n", + "trebek_327.npy\n", + "(1, 80, 786)\n", + "trebek_2314.npy\n", + "(1, 80, 597)\n", + "trebek_1516.npy\n", + "(1, 80, 672)\n", + "trebek_1799.npy\n", + "(1, 80, 504)\n", + "trebek_1176.npy\n", + "(1, 80, 668)\n", + "trebek_1833.npy\n", + "(1, 80, 510)\n", + "trebek_2326.npy\n", + "(1, 80, 713)\n", + "trebek_270.npy\n", + "(1, 80, 432)\n", + "trebek_720.npy\n", + "(1, 80, 796)\n", + "trebek_338.npy\n", + "(1, 80, 509)\n", + "trebek_213.npy\n", + "(1, 80, 694)\n", + "trebek_125.npy\n", + "(1, 80, 639)\n", + "trebek_367.npy\n", + "(1, 80, 650)\n", + "trebek_329.npy\n", + "(1, 80, 628)\n", + "trebek_481.npy\n", + "(1, 80, 755)\n", + "trebek_309.npy\n", + "(1, 80, 538)\n", + "trebek_1328.npy\n", + "(1, 80, 572)\n", + "trebek_1752.npy\n", + "(1, 80, 417)\n", + "trebek_1900.npy\n", + "(1, 80, 647)\n", + "trebek_1366.npy\n", + "(1, 80, 376)\n", + "trebek_416.npy\n", + "(1, 80, 760)\n", + "trebek_1743.npy\n", + "(1, 80, 689)\n", + "trebek_1648.npy\n", + "(1, 80, 701)\n", + "trebek_699.npy\n", + "(1, 80, 362)\n", + "trebek_343.npy\n", + "(1, 80, 584)\n", + "trebek_566.npy\n", + "(1, 80, 500)\n", + "trebek_1586.npy\n", + "(1, 80, 577)\n", + "trebek_345.npy\n", + "(1, 80, 336)\n", + "trebek_88.npy\n", + "(1, 80, 671)\n", + "trebek_1874.npy\n", + "(1, 80, 683)\n", + "trebek_997.npy\n", + "(1, 80, 615)\n", + "trebek_1707.npy\n", + "(1, 80, 486)\n", + "trebek_2064.npy\n", + "(1, 80, 665)\n", + "trebek_2317.npy\n", + "(1, 80, 603)\n", + "trebek_2033.npy\n", + "(1, 80, 724)\n", + "trebek_985.npy\n", + "(1, 80, 489)\n", + "trebek_871.npy\n", + "(1, 80, 856)\n", + "trebek_192.npy\n", + "(1, 80, 574)\n", + "trebek_1646.npy\n", + "(1, 80, 528)\n", + "trebek_726.npy\n", + "(1, 80, 473)\n", + "trebek_734.npy\n", + "(1, 80, 572)\n", + "trebek_1031.npy\n", + "(1, 80, 484)\n", + "trebek_1694.npy\n", + "(1, 80, 776)\n", + "trebek_2474.npy\n", + "(1, 80, 569)\n", + "trebek_155.npy\n", + "(1, 80, 508)\n", + "trebek_1864.npy\n", + "(1, 80, 274)\n", + "trebek_1853.npy\n", + "(1, 80, 608)\n", + "trebek_969.npy\n", + "(1, 80, 517)\n", + "trebek_443.npy\n", + "(1, 80, 641)\n", + "trebek_1848.npy\n", + "(1, 80, 357)\n", + "trebek_422.npy\n", + "(1, 80, 502)\n", + "trebek_1008.npy\n", + "(1, 80, 557)\n", + "trebek_1452.npy\n", + "(1, 80, 662)\n", + "trebek_399.npy\n", + "(1, 80, 450)\n", + "trebek_1733.npy\n", + "(1, 80, 640)\n", + "trebek_1105.npy\n", + "(1, 80, 367)\n", + "trebek_2480.npy\n", + "(1, 80, 464)\n", + "trebek_427.npy\n", + "(1, 80, 508)\n", + "trebek_2229.npy\n", + "(1, 80, 561)\n", + "trebek_996.npy\n", + "(1, 80, 277)\n", + "trebek_355.npy\n", + "(1, 80, 743)\n", + "trebek_1957.npy\n", + "(1, 80, 212)\n", + "trebek_1479.npy\n", + "(1, 80, 835)\n", + "trebek_1115.npy\n", + "(1, 80, 267)\n", + "trebek_2009.npy\n", + "(1, 80, 605)\n", + "trebek_346.npy\n", + "(1, 80, 502)\n", + "trebek_2238.npy\n", + "(1, 80, 696)\n", + "trebek_2525.npy\n", + "(1, 80, 197)\n", + "trebek_64.npy\n", + "(1, 80, 844)\n", + "trebek_439.npy\n", + "(1, 80, 440)\n", + "trebek_965.npy\n", + "(1, 80, 748)\n", + "trebek_1249.npy\n", + "(1, 80, 628)\n", + "trebek_791.npy\n", + "(1, 80, 448)\n", + "trebek_798.npy\n", + "(1, 80, 303)\n", + "trebek_1059.npy\n", + "(1, 80, 608)\n", + "trebek_2049.npy\n", + "(1, 80, 438)\n", + "trebek_1314.npy\n", + "(1, 80, 535)\n", + "trebek_1764.npy\n", + "(1, 80, 644)\n", + "trebek_166.npy\n", + "(1, 80, 644)\n", + "trebek_2372.npy\n", + "(1, 80, 375)\n", + "trebek_591.npy\n", + "(1, 80, 592)\n", + "trebek_2464.npy\n", + "(1, 80, 218)\n", + "trebek_1198.npy\n", + "(1, 80, 600)\n", + "trebek_1241.npy\n", + "(1, 80, 531)\n", + "trebek_1194.npy\n", + "(1, 80, 737)\n", + "trebek_351.npy\n", + "(1, 80, 590)\n", + "trebek_2558.npy\n", + "(1, 80, 587)\n", + "trebek_224.npy\n", + "(1, 80, 479)\n", + "trebek_1920.npy\n", + "(1, 80, 662)\n", + "trebek_1221.npy\n", + "(1, 80, 584)\n", + "trebek_2335.npy\n", + "(1, 80, 804)\n", + "trebek_2044.npy\n", + "(1, 80, 680)\n", + "trebek_557.npy\n", + "(1, 80, 693)\n", + "trebek_263.npy\n", + "(1, 80, 657)\n", + "trebek_1791.npy\n", + "(1, 80, 662)\n", + "trebek_1657.npy\n", + "(1, 80, 565)\n", + "trebek_1202.npy\n", + "(1, 80, 565)\n", + "trebek_1239.npy\n", + "(1, 80, 544)\n", + "trebek_986.npy\n", + "(1, 80, 709)\n", + "trebek_475.npy\n", + "(1, 80, 590)\n", + "trebek_1996.npy\n", + "(1, 80, 432)\n", + "trebek_1836.npy\n", + "(1, 80, 499)\n", + "trebek_1448.npy\n", + "(1, 80, 624)\n", + "trebek_2080.npy\n", + "(1, 80, 700)\n", + "trebek_1195.npy\n", + "(1, 80, 644)\n", + "trebek_2055.npy\n", + "(1, 80, 261)\n", + "trebek_639.npy\n", + "(1, 80, 771)\n", + "trebek_573.npy\n", + "(1, 80, 450)\n", + "trebek_232.npy\n", + "(1, 80, 698)\n", + "trebek_725.npy\n", + "(1, 80, 640)\n", + "trebek_732.npy\n", + "(1, 80, 835)\n", + "trebek_2488.npy\n", + "(1, 80, 566)\n", + "trebek_1577.npy\n", + "(1, 80, 650)\n", + "trebek_1626.npy\n", + "(1, 80, 228)\n", + "trebek_1598.npy\n", + "(1, 80, 678)\n", + "trebek_2429.npy\n", + "(1, 80, 381)\n", + "trebek_864.npy\n", + "(1, 80, 727)\n", + "trebek_2085.npy\n", + "(1, 80, 727)\n", + "trebek_922.npy\n", + "(1, 80, 621)\n", + "trebek_66.npy\n", + "(1, 80, 562)\n", + "trebek_670.npy\n", + "(1, 80, 688)\n", + "trebek_2156.npy\n", + "(1, 80, 453)\n", + "trebek_2487.npy\n", + "(1, 80, 501)\n", + "trebek_1934.npy\n", + "(1, 80, 468)\n", + "trebek_94.npy\n", + "(1, 80, 675)\n", + "trebek_652.npy\n", + "(1, 80, 440)\n", + "trebek_2277.npy\n", + "(1, 80, 603)\n", + "trebek_1267.npy\n", + "(1, 80, 481)\n", + "trebek_1017.npy\n", + "(1, 80, 592)\n", + "trebek_579.npy\n", + "(1, 80, 490)\n", + "trebek_1560.npy\n", + "(1, 80, 590)\n", + "trebek_673.npy\n", + "(1, 80, 476)\n", + "trebek_1805.npy\n", + "(1, 80, 805)\n", + "trebek_2073.npy\n", + "(1, 80, 497)\n", + "trebek_1378.npy\n", + "(1, 80, 551)\n", + "trebek_1537.npy\n", + "(1, 80, 636)\n", + "trebek_2521.npy\n", + "(1, 80, 684)\n", + "trebek_1639.npy\n", + "(1, 80, 255)\n", + "trebek_2440.npy\n", + "(1, 80, 622)\n", + "trebek_1476.npy\n", + "(1, 80, 538)\n", + "trebek_2448.npy\n", + "(1, 80, 566)\n", + "trebek_185.npy\n", + "(1, 80, 471)\n", + "trebek_784.npy\n", + "(1, 80, 634)\n", + "trebek_245.npy\n", + "(1, 80, 614)\n", + "trebek_159.npy\n", + "(1, 80, 641)\n", + "trebek_1152.npy\n", + "(1, 80, 582)\n", + "trebek_146.npy\n", + "(1, 80, 657)\n", + "trebek_2028.npy\n", + "(1, 80, 473)\n", + "trebek_2180.npy\n", + "(1, 80, 419)\n", + "trebek_1253.npy\n", + "(1, 80, 357)\n", + "trebek_2007.npy\n", + "(1, 80, 755)\n", + "trebek_1036.npy\n", + "(1, 80, 672)\n", + "trebek_1274.npy\n", + "(1, 80, 636)\n", + "trebek_2295.npy\n", + "(1, 80, 702)\n", + "trebek_1357.npy\n", + "(1, 80, 665)\n", + "trebek_145.npy\n", + "(1, 80, 517)\n", + "trebek_2422.npy\n", + "(1, 80, 559)\n", + "trebek_2386.npy\n", + "(1, 80, 380)\n", + "trebek_1867.npy\n", + "(1, 80, 569)\n", + "trebek_994.npy\n", + "(1, 80, 336)\n", + "trebek_458.npy\n", + "(1, 80, 698)\n", + "trebek_2439.npy\n", + "(1, 80, 541)\n", + "trebek_2265.npy\n", + "(1, 80, 652)\n", + "trebek_2017.npy\n", + "(1, 80, 680)\n", + "trebek_1814.npy\n", + "(1, 80, 706)\n", + "trebek_184.npy\n", + "(1, 80, 572)\n", + "trebek_1922.npy\n", + "(1, 80, 654)\n", + "trebek_794.npy\n", + "(1, 80, 517)\n", + "trebek_1277.npy\n", + "(1, 80, 548)\n", + "trebek_120.npy\n", + "(1, 80, 479)\n", + "trebek_2472.npy\n", + "(1, 80, 473)\n", + "trebek_604.npy\n", + "(1, 80, 393)\n", + "trebek_1341.npy\n", + "(1, 80, 900)\n", + "trebek_669.npy\n", + "(1, 80, 588)\n", + "trebek_491.npy\n", + "(1, 80, 652)\n", + "trebek_2131.npy\n", + "(1, 80, 652)\n", + "trebek_1213.npy\n", + "(1, 80, 672)\n", + "trebek_1032.npy\n", + "(1, 80, 566)\n", + "trebek_1435.npy\n", + "(1, 80, 473)\n", + "trebek_1919.npy\n", + "(1, 80, 461)\n", + "trebek_2339.npy\n", + "(1, 80, 719)\n", + "trebek_1324.npy\n", + "(1, 80, 631)\n", + "trebek_307.npy\n", + "(1, 80, 843)\n", + "trebek_2220.npy\n", + "(1, 80, 530)\n", + "trebek_324.npy\n", + "(1, 80, 756)\n", + "trebek_2371.npy\n", + "(1, 80, 398)\n", + "trebek_455.npy\n", + "(1, 80, 907)\n", + "trebek_2555.npy\n", + "(1, 80, 298)\n", + "trebek_1593.npy\n", + "(1, 80, 615)\n", + "trebek_1675.npy\n", + "(1, 80, 689)\n", + "trebek_1647.npy\n", + "(1, 80, 623)\n", + "trebek_1624.npy\n", + "(1, 80, 584)\n", + "trebek_1312.npy\n", + "(1, 80, 699)\n", + "trebek_1385.npy\n", + "(1, 80, 409)\n", + "trebek_2511.npy\n", + "(1, 80, 659)\n", + "trebek_428.npy\n", + "(1, 80, 590)\n", + "trebek_2541.npy\n", + "(1, 80, 417)\n", + "trebek_2436.npy\n", + "(1, 80, 424)\n", + "trebek_1055.npy\n", + "(1, 80, 553)\n", + "trebek_2346.npy\n", + "(1, 80, 293)\n", + "trebek_87.npy\n", + "(1, 80, 610)\n", + "trebek_918.npy\n", + "(1, 80, 507)\n", + "trebek_522.npy\n", + "(1, 80, 763)\n", + "trebek_478.npy\n", + "(1, 80, 714)\n", + "trebek_1815.npy\n", + "(1, 80, 587)\n", + "trebek_1523.npy\n", + "(1, 80, 560)\n", + "trebek_943.npy\n", + "(1, 80, 502)\n", + "trebek_878.npy\n", + "(1, 80, 445)\n", + "trebek_102.npy\n", + "(1, 80, 541)\n", + "trebek_1909.npy\n", + "(1, 80, 440)\n", + "trebek_847.npy\n", + "(1, 80, 758)\n", + "trebek_1897.npy\n", + "(1, 80, 740)\n", + "trebek_2337.npy\n", + "(1, 80, 745)\n", + "trebek_2062.npy\n", + "(1, 80, 560)\n", + "trebek_1984.npy\n", + "(1, 80, 720)\n", + "trebek_2184.npy\n", + "(1, 80, 673)\n", + "trebek_332.npy\n", + "(1, 80, 595)\n", + "trebek_1261.npy\n", + "(1, 80, 564)\n", + "trebek_417.npy\n", + "(1, 80, 491)\n", + "trebek_2452.npy\n", + "(1, 80, 313)\n", + "trebek_275.npy\n", + "(1, 80, 615)\n", + "trebek_799.npy\n", + "(1, 80, 419)\n", + "trebek_2270.npy\n", + "(1, 80, 746)\n", + "trebek_1392.npy\n", + "(1, 80, 631)\n", + "trebek_56.npy\n", + "(1, 80, 734)\n", + "trebek_2345.npy\n", + "(1, 80, 404)\n", + "trebek_437.npy\n", + "(1, 80, 631)\n", + "trebek_1262.npy\n", + "(1, 80, 378)\n", + "trebek_2163.npy\n", + "(1, 80, 701)\n", + "trebek_1205.npy\n", + "(1, 80, 559)\n", + "trebek_1372.npy\n", + "(1, 80, 709)\n", + "trebek_2128.npy\n", + "(1, 80, 422)\n", + "trebek_1368.npy\n", + "(1, 80, 670)\n", + "trebek_2415.npy\n", + "(1, 80, 490)\n", + "trebek_1006.npy\n", + "(1, 80, 732)\n", + "trebek_1584.npy\n", + "(1, 80, 487)\n", + "trebek_384.npy\n", + "(1, 80, 553)\n", + "trebek_801.npy\n", + "(1, 80, 471)\n", + "trebek_1653.npy\n", + "(1, 80, 575)\n", + "trebek_2533.npy\n", + "(1, 80, 367)\n", + "trebek_2035.npy\n", + "(1, 80, 681)\n", + "trebek_792.npy\n", + "(1, 80, 616)\n", + "trebek_1189.npy\n", + "(1, 80, 584)\n", + "trebek_1100.npy\n", + "(1, 80, 639)\n", + "trebek_770.npy\n", + "(1, 80, 750)\n", + "trebek_2005.npy\n", + "(1, 80, 522)\n", + "trebek_1293.npy\n", + "(1, 80, 632)\n", + "trebek_147.npy\n", + "(1, 80, 595)\n", + "trebek_1485.npy\n", + "(1, 80, 812)\n", + "trebek_1865.npy\n", + "(1, 80, 300)\n", + "trebek_824.npy\n", + "(1, 80, 634)\n", + "trebek_587.npy\n", + "(1, 80, 663)\n", + "trebek_493.npy\n", + "(1, 80, 603)\n", + "trebek_955.npy\n", + "(1, 80, 595)\n", + "trebek_178.npy\n", + "(1, 80, 572)\n", + "trebek_2559.npy\n", + "(1, 80, 339)\n", + "trebek_168.npy\n", + "(1, 80, 675)\n", + "trebek_237.npy\n", + "(1, 80, 497)\n", + "trebek_4.npy\n", + "(1, 80, 614)\n", + "trebek_1716.npy\n", + "(1, 80, 435)\n", + "trebek_2268.npy\n", + "(1, 80, 696)\n", + "trebek_1925.npy\n", + "(1, 80, 458)\n", + "trebek_2520.npy\n", + "(1, 80, 714)\n", + "trebek_2499.npy\n", + "(1, 80, 396)\n", + "trebek_2234.npy\n", + "(1, 80, 492)\n", + "trebek_1014.npy\n", + "(1, 80, 463)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_668.npy\n", + "(1, 80, 755)\n", + "trebek_1994.npy\n", + "(1, 80, 554)\n", + "trebek_1222.npy\n", + "(1, 80, 711)\n", + "trebek_793.npy\n", + "(1, 80, 572)\n", + "trebek_1444.npy\n", + "(1, 80, 728)\n", + "trebek_1475.npy\n", + "(1, 80, 654)\n", + "trebek_2078.npy\n", + "(1, 80, 603)\n", + "trebek_1403.npy\n", + "(1, 80, 473)\n", + "trebek_1092.npy\n", + "(1, 80, 601)\n", + "trebek_2497.npy\n", + "(1, 80, 409)\n", + "trebek_1116.npy\n", + "(1, 80, 572)\n", + "trebek_729.npy\n", + "(1, 80, 482)\n", + "trebek_1899.npy\n", + "(1, 80, 771)\n", + "trebek_2093.npy\n", + "(1, 80, 477)\n", + "trebek_268.npy\n", + "(1, 80, 810)\n", + "trebek_2086.npy\n", + "(1, 80, 567)\n", + "trebek_1578.npy\n", + "(1, 80, 577)\n", + "trebek_1044.npy\n", + "(1, 80, 432)\n", + "trebek_2338.npy\n", + "(1, 80, 690)\n", + "trebek_1986.npy\n", + "(1, 80, 450)\n", + "trebek_1330.npy\n", + "(1, 80, 471)\n", + "trebek_1308.npy\n", + "(1, 80, 340)\n", + "trebek_1969.npy\n", + "(1, 80, 639)\n", + "trebek_1474.npy\n", + "(1, 80, 533)\n", + "trebek_54.npy\n", + "(1, 80, 422)\n", + "trebek_1161.npy\n", + "(1, 80, 318)\n", + "trebek_889.npy\n", + "(1, 80, 729)\n", + "trebek_214.npy\n", + "(1, 80, 786)\n", + "trebek_931.npy\n", + "(1, 80, 608)\n", + "trebek_521.npy\n", + "(1, 80, 492)\n", + "trebek_1576.npy\n", + "(1, 80, 628)\n", + "trebek_1450.npy\n", + "(1, 80, 587)\n", + "trebek_1776.npy\n", + "(1, 80, 522)\n", + "trebek_979.npy\n", + "(1, 80, 499)\n", + "trebek_1268.npy\n", + "(1, 80, 564)\n", + "trebek_957.npy\n", + "(1, 80, 479)\n", + "trebek_1270.npy\n", + "(1, 80, 584)\n", + "trebek_1282.npy\n", + "(1, 80, 456)\n", + "trebek_2294.npy\n", + "(1, 80, 644)\n", + "trebek_2235.npy\n", + "(1, 80, 551)\n", + "trebek_411.npy\n", + "(1, 80, 572)\n", + "trebek_2398.npy\n", + "(1, 80, 564)\n", + "trebek_1145.npy\n", + "(1, 80, 709)\n", + "trebek_829.npy\n", + "(1, 80, 615)\n", + "trebek_723.npy\n", + "(1, 80, 690)\n", + "trebek_2466.npy\n", + "(1, 80, 455)\n", + "trebek_1895.npy\n", + "(1, 80, 652)\n", + "trebek_907.npy\n", + "(1, 80, 636)\n", + "trebek_1946.npy\n", + "(1, 80, 771)\n", + "trebek_1021.npy\n", + "(1, 80, 683)\n", + "trebek_1490.npy\n", + "(1, 80, 632)\n", + "trebek_333.npy\n", + "(1, 80, 569)\n", + "trebek_515.npy\n", + "(1, 80, 813)\n", + "trebek_1785.npy\n", + "(1, 80, 564)\n", + "trebek_624.npy\n", + "(1, 80, 497)\n", + "trebek_1411.npy\n", + "(1, 80, 336)\n", + "trebek_1688.npy\n", + "(1, 80, 758)\n", + "trebek_463.npy\n", + "(1, 80, 721)\n", + "trebek_46.npy\n", + "(1, 80, 799)\n", + "trebek_2237.npy\n", + "(1, 80, 230)\n", + "trebek_2256.npy\n", + "(1, 80, 406)\n", + "trebek_1954.npy\n", + "(1, 80, 296)\n", + "trebek_2433.npy\n", + "(1, 80, 646)\n", + "trebek_1755.npy\n", + "(1, 80, 579)\n", + "trebek_1446.npy\n", + "(1, 80, 750)\n", + "trebek_1449.npy\n", + "(1, 80, 666)\n", + "trebek_1049.npy\n", + "(1, 80, 781)\n", + "trebek_1180.npy\n", + "(1, 80, 693)\n", + "trebek_2410.npy\n", + "(1, 80, 696)\n", + "trebek_1514.npy\n", + "(1, 80, 688)\n", + "trebek_1892.npy\n", + "(1, 80, 704)\n", + "trebek_364.npy\n", + "(1, 80, 601)\n", + "trebek_1148.npy\n", + "(1, 80, 727)\n", + "trebek_2026.npy\n", + "(1, 80, 686)\n", + "trebek_1146.npy\n", + "(1, 80, 502)\n", + "trebek_1419.npy\n", + "(1, 80, 414)\n", + "trebek_568.npy\n", + "(1, 80, 424)\n", + "trebek_1973.npy\n", + "(1, 80, 280)\n", + "trebek_473.npy\n", + "(1, 80, 548)\n", + "trebek_616.npy\n", + "(1, 80, 445)\n", + "trebek_128.npy\n", + "(1, 80, 655)\n", + "trebek_1666.npy\n", + "(1, 80, 592)\n", + "trebek_2061.npy\n", + "(1, 80, 517)\n", + "trebek_1164.npy\n", + "(1, 80, 398)\n", + "trebek_2360.npy\n", + "(1, 80, 489)\n", + "trebek_1238.npy\n", + "(1, 80, 406)\n", + "trebek_1602.npy\n", + "(1, 80, 791)\n", + "trebek_1086.npy\n", + "(1, 80, 609)\n", + "trebek_201.npy\n", + "(1, 80, 693)\n", + "trebek_339.npy\n", + "(1, 80, 422)\n", + "trebek_844.npy\n", + "(1, 80, 606)\n", + "trebek_1117.npy\n", + "(1, 80, 615)\n", + "trebek_820.npy\n", + "(1, 80, 579)\n", + "trebek_2451.npy\n", + "(1, 80, 456)\n", + "trebek_1321.npy\n", + "(1, 80, 827)\n", + "trebek_1569.npy\n", + "(1, 80, 611)\n", + "trebek_2293.npy\n", + "(1, 80, 546)\n", + "trebek_893.npy\n", + "(1, 80, 587)\n", + "trebek_2490.npy\n", + "(1, 80, 665)\n", + "trebek_111.npy\n", + "(1, 80, 549)\n", + "trebek_12.npy\n", + "(1, 80, 497)\n", + "trebek_2133.npy\n", + "(1, 80, 422)\n", + "trebek_469.npy\n", + "(1, 80, 869)\n", + "trebek_2102.npy\n", + "(1, 80, 448)\n", + "trebek_1323.npy\n", + "(1, 80, 835)\n", + "trebek_1517.npy\n", + "(1, 80, 610)\n", + "trebek_55.npy\n", + "(1, 80, 693)\n", + "trebek_1197.npy\n", + "(1, 80, 564)\n", + "trebek_1425.npy\n", + "(1, 80, 683)\n", + "trebek_1861.npy\n", + "(1, 80, 618)\n", + "trebek_360.npy\n", + "(1, 80, 771)\n", + "trebek_462.npy\n", + "(1, 80, 363)\n", + "trebek_304.npy\n", + "(1, 80, 835)\n", + "trebek_2444.npy\n", + "(1, 80, 645)\n", + "trebek_1673.npy\n", + "(1, 80, 634)\n", + "trebek_1469.npy\n", + "(1, 80, 623)\n", + "trebek_91.npy\n", + "(1, 80, 543)\n", + "trebek_1410.npy\n", + "(1, 80, 371)\n", + "trebek_317.npy\n", + "(1, 80, 647)\n", + "trebek_1427.npy\n", + "(1, 80, 329)\n", + "trebek_1443.npy\n", + "(1, 80, 747)\n", + "trebek_2442.npy\n", + "(1, 80, 437)\n", + "trebek_1632.npy\n", + "(1, 80, 742)\n", + "trebek_448.npy\n", + "(1, 80, 574)\n", + "trebek_48.npy\n", + "(1, 80, 771)\n", + "trebek_1823.npy\n", + "(1, 80, 621)\n", + "trebek_1888.npy\n", + "(1, 80, 848)\n", + "trebek_1332.npy\n", + "(1, 80, 477)\n", + "trebek_2262.npy\n", + "(1, 80, 481)\n", + "trebek_1642.npy\n", + "(1, 80, 466)\n", + "trebek_1342.npy\n", + "(1, 80, 681)\n", + "trebek_2561.npy\n", + "(1, 80, 603)\n", + "trebek_1266.npy\n", + "(1, 80, 561)\n", + "trebek_756.npy\n", + "(1, 80, 491)\n", + "trebek_206.npy\n", + "(1, 80, 608)\n", + "trebek_1604.npy\n", + "(1, 80, 507)\n", + "trebek_2458.npy\n", + "(1, 80, 383)\n", + "trebek_1421.npy\n", + "(1, 80, 469)\n", + "trebek_837.npy\n", + "(1, 80, 800)\n", + "trebek_1363.npy\n", + "(1, 80, 502)\n", + "trebek_252.npy\n", + "(1, 80, 649)\n", + "trebek_2134.npy\n", + "(1, 80, 438)\n", + "trebek_2274.npy\n", + "(1, 80, 810)\n", + "trebek_1183.npy\n", + "(1, 80, 518)\n", + "trebek_2110.npy\n", + "(1, 80, 442)\n", + "trebek_710.npy\n", + "(1, 80, 422)\n", + "trebek_2046.npy\n", + "(1, 80, 611)\n", + "trebek_1845.npy\n", + "(1, 80, 432)\n", + "trebek_2122.npy\n", + "(1, 80, 728)\n", + "trebek_766.npy\n", + "(1, 80, 590)\n", + "trebek_1735.npy\n", + "(1, 80, 615)\n", + "trebek_1472.npy\n", + "(1, 80, 639)\n", + "trebek_991.npy\n", + "(1, 80, 674)\n", + "trebek_1.npy\n", + "(1, 80, 628)\n", + "trebek_1989.npy\n", + "(1, 80, 724)\n", + "trebek_826.npy\n", + "(1, 80, 460)\n", + "trebek_1244.npy\n", + "(1, 80, 784)\n", + "trebek_484.npy\n", + "(1, 80, 585)\n", + "trebek_2153.npy\n", + "(1, 80, 671)\n", + "trebek_1917.npy\n", + "(1, 80, 685)\n", + "trebek_1554.npy\n", + "(1, 80, 704)\n", + "trebek_2065.npy\n", + "(1, 80, 491)\n", + "trebek_322.npy\n", + "(1, 80, 864)\n", + "trebek_1506.npy\n", + "(1, 80, 491)\n", + "trebek_702.npy\n", + "(1, 80, 820)\n", + "trebek_1422.npy\n", + "(1, 80, 533)\n", + "trebek_1591.npy\n", + "(1, 80, 758)\n", + "trebek_1254.npy\n", + "(1, 80, 401)\n", + "trebek_440.npy\n", + "(1, 80, 714)\n", + "trebek_1220.npy\n", + "(1, 80, 502)\n", + "trebek_1826.npy\n", + "(1, 80, 714)\n", + "trebek_174.npy\n", + "(1, 80, 577)\n", + "trebek_674.npy\n", + "(1, 80, 497)\n", + "trebek_1709.npy\n", + "(1, 80, 425)\n", + "trebek_1806.npy\n", + "(1, 80, 701)\n", + "trebek_570.npy\n", + "(1, 80, 347)\n", + "trebek_2245.npy\n", + "(1, 80, 781)\n", + "trebek_2364.npy\n", + "(1, 80, 344)\n", + "trebek_2512.npy\n", + "(1, 80, 541)\n", + "trebek_884.npy\n", + "(1, 80, 502)\n", + "trebek_1740.npy\n", + "(1, 80, 641)\n", + "trebek_2408.npy\n", + "(1, 80, 559)\n", + "trebek_1525.npy\n", + "(1, 80, 362)\n", + "trebek_2503.npy\n", + "(1, 80, 502)\n", + "trebek_24.npy\n", + "(1, 80, 543)\n", + "trebek_1402.npy\n", + "(1, 80, 445)\n", + "trebek_239.npy\n", + "(1, 80, 735)\n", + "trebek_2032.npy\n", + "(1, 80, 712)\n", + "trebek_1736.npy\n", + "(1, 80, 704)\n", + "trebek_1679.npy\n", + "(1, 80, 432)\n", + "trebek_2459.npy\n", + "(1, 80, 388)\n", + "trebek_982.npy\n", + "(1, 80, 342)\n", + "trebek_618.npy\n", + "(1, 80, 468)\n", + "trebek_2183.npy\n", + "(1, 80, 199)\n", + "trebek_208.npy\n", + "(1, 80, 719)\n", + "trebek_1150.npy\n", + "(1, 80, 440)\n", + "trebek_347.npy\n", + "(1, 80, 758)\n", + "trebek_1595.npy\n", + "(1, 80, 548)\n", + "trebek_2412.npy\n", + "(1, 80, 582)\n", + "trebek_908.npy\n", + "(1, 80, 528)\n", + "trebek_1547.npy\n", + "(1, 80, 696)\n", + "trebek_43.npy\n", + "(1, 80, 680)\n", + "trebek_992.npy\n", + "(1, 80, 776)\n", + "trebek_140.npy\n", + "(1, 80, 484)\n", + "trebek_1079.npy\n", + "(1, 80, 691)\n", + "trebek_1714.npy\n", + "(1, 80, 267)\n", + "trebek_2287.npy\n", + "(1, 80, 649)\n", + "trebek_228.npy\n", + "(1, 80, 476)\n", + "trebek_73.npy\n", + "(1, 80, 810)\n", + "trebek_1420.npy\n", + "(1, 80, 652)\n", + "trebek_2039.npy\n", + "(1, 80, 686)\n", + "trebek_863.npy\n", + "(1, 80, 628)\n", + "trebek_974.npy\n", + "(1, 80, 685)\n", + "trebek_1011.npy\n", + "(1, 80, 719)\n", + "trebek_896.npy\n", + "(1, 80, 670)\n", + "trebek_1847.npy\n", + "(1, 80, 355)\n", + "trebek_617.npy\n", + "(1, 80, 626)\n", + "trebek_298.npy\n", + "(1, 80, 355)\n", + "trebek_380.npy\n", + "(1, 80, 662)\n", + "trebek_1275.npy\n", + "(1, 80, 645)\n", + "trebek_2052.npy\n", + "(1, 80, 657)\n", + "trebek_2232.npy\n", + "(1, 80, 473)\n", + "trebek_835.npy\n", + "(1, 80, 584)\n", + "trebek_1977.npy\n", + "(1, 80, 520)\n", + "trebek_1672.npy\n", + "(1, 80, 538)\n", + "trebek_131.npy\n", + "(1, 80, 653)\n", + "trebek_2155.npy\n", + "(1, 80, 641)\n", + "trebek_497.npy\n", + "(1, 80, 538)\n", + "trebek_2437.npy\n", + "(1, 80, 610)\n", + "trebek_149.npy\n", + "(1, 80, 597)\n", + "trebek_1075.npy\n", + "(1, 80, 676)\n", + "trebek_1574.npy\n", + "(1, 80, 658)\n", + "trebek_891.npy\n", + "(1, 80, 827)\n", + "trebek_2400.npy\n", + "(1, 80, 641)\n", + "trebek_287.npy\n", + "(1, 80, 683)\n", + "trebek_90.npy\n", + "(1, 80, 515)\n", + "trebek_2272.npy\n", + "(1, 80, 716)\n", + "trebek_2224.npy\n", + "(1, 80, 386)\n", + "trebek_1970.npy\n", + "(1, 80, 671)\n", + "trebek_205.npy\n", + "(1, 80, 662)\n", + "trebek_1299.npy\n", + "(1, 80, 618)\n", + "trebek_2329.npy\n", + "(1, 80, 639)\n", + "trebek_2149.npy\n", + "(1, 80, 698)\n", + "trebek_1883.npy\n", + "(1, 80, 616)\n", + "trebek_1697.npy\n", + "(1, 80, 595)\n", + "trebek_1811.npy\n", + "(1, 80, 538)\n", + "trebek_2396.npy\n", + "(1, 80, 458)\n", + "trebek_894.npy\n", + "(1, 80, 417)\n", + "trebek_294.npy\n", + "(1, 80, 605)\n", + "trebek_1750.npy\n", + "(1, 80, 324)\n", + "trebek_2435.npy\n", + "(1, 80, 600)\n", + "trebek_1830.npy\n", + "(1, 80, 572)\n", + "trebek_952.npy\n", + "(1, 80, 773)\n", + "trebek_1961.npy\n", + "(1, 80, 233)\n", + "trebek_599.npy\n", + "(1, 80, 652)\n", + "trebek_1670.npy\n", + "(1, 80, 409)\n", + "trebek_2322.npy\n", + "(1, 80, 711)\n", + "trebek_853.npy\n", + "(1, 80, 610)\n", + "trebek_331.npy\n", + "(1, 80, 424)\n", + "trebek_1798.npy\n", + "(1, 80, 337)\n", + "trebek_2266.npy\n", + "(1, 80, 683)\n", + "trebek_1121.npy\n", + "(1, 80, 709)\n", + "trebek_193.npy\n", + "(1, 80, 733)\n", + "trebek_580.npy\n", + "(1, 80, 380)\n", + "trebek_2308.npy\n", + "(1, 80, 402)\n", + "trebek_1953.npy\n", + "(1, 80, 321)\n", + "trebek_2286.npy\n", + "(1, 80, 778)\n", + "trebek_2096.npy\n", + "(1, 80, 520)\n", + "trebek_727.npy\n", + "(1, 80, 574)\n", + "trebek_377.npy\n", + "(1, 80, 484)\n", + "trebek_1846.npy\n", + "(1, 80, 396)\n", + "trebek_2413.npy\n", + "(1, 80, 280)\n", + "trebek_2119.npy\n", + "(1, 80, 611)\n", + "trebek_2465.npy\n", + "(1, 80, 295)\n", + "trebek_2070.npy\n", + "(1, 80, 502)\n", + "trebek_2132.npy\n", + "(1, 80, 393)\n", + "trebek_2060.npy\n", + "(1, 80, 584)\n", + "trebek_1000.npy\n", + "(1, 80, 492)\n", + "trebek_1803.npy\n", + "(1, 80, 574)\n", + "trebek_1754.npy\n", + "(1, 80, 530)\n", + "trebek_368.npy\n", + "(1, 80, 670)\n", + "trebek_1193.npy\n", + "(1, 80, 616)\n", + "trebek_353.npy\n", + "(1, 80, 838)\n", + "trebek_1708.npy\n", + "(1, 80, 311)\n", + "trebek_848.npy\n", + "(1, 80, 290)\n", + "trebek_1424.npy\n", + "(1, 80, 264)\n", + "trebek_1399.npy\n", + "(1, 80, 835)\n", + "trebek_1793.npy\n", + "(1, 80, 642)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2333.npy\n", + "(1, 80, 591)\n", + "trebek_2473.npy\n", + "(1, 80, 342)\n", + "trebek_1119.npy\n", + "(1, 80, 653)\n", + "trebek_1890.npy\n", + "(1, 80, 690)\n", + "trebek_1782.npy\n", + "(1, 80, 685)\n", + "trebek_2352.npy\n", + "(1, 80, 476)\n", + "trebek_1543.npy\n", + "(1, 80, 690)\n", + "trebek_1944.npy\n", + "(1, 80, 745)\n", + "trebek_1386.npy\n", + "(1, 80, 548)\n", + "trebek_1233.npy\n", + "(1, 80, 399)\n", + "trebek_1405.npy\n", + "(1, 80, 809)\n", + "trebek_2330.npy\n", + "(1, 80, 531)\n", + "trebek_805.npy\n", + "(1, 80, 603)\n", + "trebek_151.npy\n", + "(1, 80, 513)\n", + "trebek_771.npy\n", + "(1, 80, 719)\n", + "trebek_743.npy\n", + "(1, 80, 381)\n", + "trebek_2084.npy\n", + "(1, 80, 858)\n", + "trebek_2112.npy\n", + "(1, 80, 704)\n", + "trebek_701.npy\n", + "(1, 80, 931)\n", + "trebek_1069.npy\n", + "(1, 80, 564)\n", + "trebek_83.npy\n", + "(1, 80, 740)\n", + "trebek_1322.npy\n", + "(1, 80, 614)\n", + "trebek_746.npy\n", + "(1, 80, 623)\n", + "trebek_1656.npy\n", + "(1, 80, 569)\n", + "trebek_2551.npy\n", + "(1, 80, 546)\n", + "trebek_2188.npy\n", + "(1, 80, 671)\n", + "trebek_2092.npy\n", + "(1, 80, 468)\n", + "trebek_103.npy\n", + "(1, 80, 342)\n", + "trebek_1729.npy\n", + "(1, 80, 572)\n", + "trebek_2402.npy\n", + "(1, 80, 295)\n", + "trebek_1513.npy\n", + "(1, 80, 610)\n", + "trebek_2223.npy\n", + "(1, 80, 481)\n", + "trebek_2428.npy\n", + "(1, 80, 641)\n", + "trebek_744.npy\n", + "(1, 80, 628)\n", + "trebek_1383.npy\n", + "(1, 80, 651)\n", + "trebek_1377.npy\n", + "(1, 80, 455)\n", + "trebek_2562.npy\n", + "(1, 80, 900)\n", + "trebek_819.npy\n", + "(1, 80, 518)\n", + "trebek_1286.npy\n", + "(1, 80, 686)\n", + "trebek_1382.npy\n", + "(1, 80, 533)\n", + "trebek_1790.npy\n", + "(1, 80, 603)\n", + "trebek_2214.npy\n", + "(1, 80, 316)\n", + "trebek_1114.npy\n", + "(1, 80, 752)\n", + "trebek_129.npy\n", + "(1, 80, 703)\n", + "trebek_528.npy\n", + "(1, 80, 619)\n", + "trebek_2251.npy\n", + "(1, 80, 419)\n", + "trebek_811.npy\n", + "(1, 80, 804)\n", + "trebek_1522.npy\n", + "(1, 80, 460)\n", + "trebek_1033.npy\n", + "(1, 80, 634)\n", + "trebek_1809.npy\n", + "(1, 80, 513)\n", + "trebek_2425.npy\n", + "(1, 80, 486)\n", + "trebek_38.npy\n", + "(1, 80, 497)\n", + "trebek_890.npy\n", + "(1, 80, 503)\n", + "trebek_625.npy\n", + "(1, 80, 466)\n", + "trebek_253.npy\n", + "(1, 80, 693)\n", + "trebek_980.npy\n", + "(1, 80, 548)\n", + "trebek_378.npy\n", + "(1, 80, 640)\n", + "trebek_2334.npy\n", + "(1, 80, 189)\n", + "trebek_1023.npy\n", + "(1, 80, 554)\n", + "trebek_697.npy\n", + "(1, 80, 406)\n", + "trebek_1704.npy\n", + "(1, 80, 773)\n", + "trebek_858.npy\n", + "(1, 80, 691)\n", + "trebek_968.npy\n", + "(1, 80, 663)\n", + "trebek_2531.npy\n", + "(1, 80, 299)\n", + "trebek_1781.npy\n", + "(1, 80, 641)\n", + "trebek_2000.npy\n", + "(1, 80, 404)\n", + "trebek_2447.npy\n", + "(1, 80, 704)\n", + "trebek_1992.npy\n", + "(1, 80, 659)\n", + "trebek_471.npy\n", + "(1, 80, 712)\n", + "trebek_1157.npy\n", + "(1, 80, 473)\n", + "trebek_887.npy\n", + "(1, 80, 867)\n", + "trebek_754.npy\n", + "(1, 80, 668)\n", + "trebek_461.npy\n", + "(1, 80, 822)\n", + "trebek_2404.npy\n", + "(1, 80, 269)\n", + "trebek_1563.npy\n", + "(1, 80, 794)\n", + "trebek_278.npy\n", + "(1, 80, 805)\n", + "trebek_67.npy\n", + "(1, 80, 865)\n", + "trebek_945.npy\n", + "(1, 80, 396)\n", + "trebek_1078.npy\n", + "(1, 80, 683)\n", + "trebek_152.npy\n", + "(1, 80, 512)\n", + "trebek_418.npy\n", + "(1, 80, 577)\n", + "trebek_191.npy\n", + "(1, 80, 522)\n", + "trebek_1943.npy\n", + "(1, 80, 685)\n", + "trebek_1769.npy\n", + "(1, 80, 529)\n", + "trebek_1807.npy\n", + "(1, 80, 737)\n", + "trebek_2058.npy\n", + "(1, 80, 305)\n", + "trebek_681.npy\n", + "(1, 80, 662)\n", + "trebek_2534.npy\n", + "(1, 80, 404)\n", + "trebek_611.npy\n", + "(1, 80, 849)\n", + "trebek_485.npy\n", + "(1, 80, 626)\n", + "trebek_2047.npy\n", + "(1, 80, 742)\n", + "trebek_747.npy\n", + "(1, 80, 593)\n", + "trebek_1486.npy\n", + "(1, 80, 740)\n", + "trebek_1611.npy\n", + "(1, 80, 521)\n", + "trebek_1300.npy\n", + "(1, 80, 751)\n", + "trebek_1283.npy\n", + "(1, 80, 683)\n", + "trebek_1387.npy\n", + "(1, 80, 668)\n", + "trebek_2142.npy\n", + "(1, 80, 440)\n", + "trebek_25.npy\n", + "(1, 80, 714)\n", + "trebek_656.npy\n", + "(1, 80, 502)\n", + "trebek_2259.npy\n", + "(1, 80, 622)\n", + "trebek_450.npy\n", + "(1, 80, 564)\n", + "trebek_1462.npy\n", + "(1, 80, 751)\n", + "trebek_286.npy\n", + "(1, 80, 587)\n", + "trebek_2517.npy\n", + "(1, 80, 322)\n", + "trebek_2206.npy\n", + "(1, 80, 388)\n", + "trebek_30.npy\n", + "(1, 80, 782)\n", + "trebek_1730.npy\n", + "(1, 80, 652)\n", + "trebek_1696.npy\n", + "(1, 80, 615)\n", + "trebek_1096.npy\n", + "(1, 80, 628)\n", + "trebek_1483.npy\n", + "(1, 80, 729)\n", + "trebek_1434.npy\n", + "(1, 80, 494)\n", + "trebek_1417.npy\n", + "(1, 80, 531)\n", + "trebek_2106.npy\n", + "(1, 80, 639)\n", + "trebek_1389.npy\n", + "(1, 80, 721)\n", + "trebek_1468.npy\n", + "(1, 80, 577)\n", + "trebek_1887.npy\n", + "(1, 80, 708)\n", + "trebek_904.npy\n", + "(1, 80, 621)\n", + "trebek_2246.npy\n", + "(1, 80, 644)\n", + "trebek_1246.npy\n", + "(1, 80, 600)\n", + "trebek_716.npy\n", + "(1, 80, 510)\n", + "trebek_486.npy\n", + "(1, 80, 386)\n", + "trebek_221.npy\n", + "(1, 80, 680)\n", + "trebek_1028.npy\n", + "(1, 80, 592)\n", + "trebek_47.npy\n", + "(1, 80, 541)\n", + "trebek_489.npy\n", + "(1, 80, 388)\n", + "trebek_1016.npy\n", + "(1, 80, 615)\n", + "trebek_1949.npy\n", + "(1, 80, 601)\n", + "trebek_216.npy\n", + "(1, 80, 665)\n", + "trebek_1746.npy\n", + "(1, 80, 298)\n", + "trebek_2025.npy\n", + "(1, 80, 768)\n", + "trebek_724.npy\n", + "(1, 80, 610)\n", + "trebek_1111.npy\n", + "(1, 80, 645)\n", + "trebek_680.npy\n", + "(1, 80, 317)\n", + "trebek_938.npy\n", + "(1, 80, 609)\n", + "trebek_1530.npy\n", + "(1, 80, 324)\n", + "trebek_1380.npy\n", + "(1, 80, 517)\n", + "trebek_1533.npy\n", + "(1, 80, 397)\n", + "trebek_1339.npy\n", + "(1, 80, 671)\n", + "trebek_1668.npy\n", + "(1, 80, 535)\n", + "trebek_15.npy\n", + "(1, 80, 547)\n", + "trebek_1971.npy\n", + "(1, 80, 543)\n", + "trebek_576.npy\n", + "(1, 80, 512)\n", + "trebek_1379.npy\n", + "(1, 80, 469)\n", + "trebek_65.npy\n", + "(1, 80, 732)\n", + "trebek_1362.npy\n", + "(1, 80, 640)\n", + "trebek_496.npy\n", + "(1, 80, 765)\n", + "trebek_1571.npy\n", + "(1, 80, 274)\n", + "trebek_2430.npy\n", + "(1, 80, 639)\n", + "trebek_777.npy\n", + "(1, 80, 556)\n", + "trebek_504.npy\n", + "(1, 80, 435)\n", + "trebek_856.npy\n", + "(1, 80, 280)\n", + "trebek_1371.npy\n", + "(1, 80, 740)\n", + "trebek_1991.npy\n", + "(1, 80, 678)\n", + "trebek_768.npy\n", + "(1, 80, 623)\n", + "trebek_2369.npy\n", + "(1, 80, 696)\n", + "trebek_352.npy\n", + "(1, 80, 601)\n", + "trebek_1255.npy\n", + "(1, 80, 425)\n", + "trebek_28.npy\n", + "(1, 80, 747)\n", + "trebek_629.npy\n", + "(1, 80, 466)\n", + "trebek_459.npy\n", + "(1, 80, 787)\n", + "trebek_1026.npy\n", + "(1, 80, 686)\n", + "trebek_1558.npy\n", + "(1, 80, 535)\n", + "trebek_1644.npy\n", + "(1, 80, 260)\n", + "trebek_1359.npy\n", + "(1, 80, 486)\n", + "trebek_655.npy\n", + "(1, 80, 552)\n", + "trebek_1301.npy\n", + "(1, 80, 719)\n", + "trebek_408.npy\n", + "(1, 80, 512)\n", + "trebek_2509.npy\n", + "(1, 80, 782)\n", + "trebek_426.npy\n", + "(1, 80, 362)\n", + "trebek_645.npy\n", + "(1, 80, 758)\n", + "trebek_940.npy\n", + "(1, 80, 569)\n", + "trebek_903.npy\n", + "(1, 80, 530)\n", + "trebek_2483.npy\n", + "(1, 80, 365)\n", + "trebek_1179.npy\n", + "(1, 80, 624)\n", + "trebek_1913.npy\n", + "(1, 80, 515)\n", + "trebek_1087.npy\n", + "(1, 80, 639)\n", + "trebek_136.npy\n", + "(1, 80, 596)\n", + "trebek_410.npy\n", + "(1, 80, 833)\n", + "trebek_337.npy\n", + "(1, 80, 410)\n", + "trebek_1939.npy\n", + "(1, 80, 593)\n", + "trebek_1336.npy\n", + "(1, 80, 606)\n", + "trebek_109.npy\n", + "(1, 80, 685)\n", + "trebek_874.npy\n", + "(1, 80, 535)\n", + "trebek_209.npy\n", + "(1, 80, 605)\n", + "trebek_1610.npy\n", + "(1, 80, 316)\n", + "trebek_973.npy\n", + "(1, 80, 926)\n", + "trebek_1160.npy\n", + "(1, 80, 386)\n", + "trebek_909.npy\n", + "(1, 80, 734)\n", + "trebek_1120.npy\n", + "(1, 80, 502)\n", + "trebek_371.npy\n", + "(1, 80, 658)\n", + "trebek_592.npy\n", + "(1, 80, 522)\n", + "trebek_1801.npy\n", + "(1, 80, 592)\n", + "trebek_797.npy\n", + "(1, 80, 314)\n", + "trebek_382.npy\n", + "(1, 80, 565)\n", + "trebek_578.npy\n", + "(1, 80, 225)\n", + "trebek_2011.npy\n", + "(1, 80, 719)\n", + "trebek_613.npy\n", + "(1, 80, 659)\n", + "trebek_135.npy\n", + "(1, 80, 985)\n", + "trebek_315.npy\n", + "(1, 80, 709)\n", + "trebek_721.npy\n", + "(1, 80, 760)\n", + "trebek_2547.npy\n", + "(1, 80, 410)\n", + "trebek_2336.npy\n", + "(1, 80, 711)\n", + "trebek_2209.npy\n", + "(1, 80, 549)\n", + "trebek_267.npy\n", + "(1, 80, 864)\n", + "trebek_2377.npy\n", + "(1, 80, 520)\n", + "trebek_82.npy\n", + "(1, 80, 856)\n", + "trebek_1139.npy\n", + "(1, 80, 495)\n", + "trebek_2136.npy\n", + "(1, 80, 680)\n", + "trebek_2482.npy\n", + "(1, 80, 342)\n", + "trebek_261.npy\n", + "(1, 80, 569)\n", + "trebek_2557.npy\n", + "(1, 80, 187)\n", + "trebek_42.npy\n", + "(1, 80, 990)\n", + "trebek_45.npy\n", + "(1, 80, 791)\n", + "trebek_1149.npy\n", + "(1, 80, 590)\n", + "trebek_695.npy\n", + "(1, 80, 419)\n", + "trebek_1329.npy\n", + "(1, 80, 657)\n", + "trebek_1678.npy\n", + "(1, 80, 365)\n", + "trebek_1567.npy\n", + "(1, 80, 760)\n", + "trebek_683.npy\n", + "(1, 80, 409)\n", + "trebek_1131.npy\n", + "(1, 80, 683)\n", + "trebek_2476.npy\n", + "(1, 80, 442)\n", + "trebek_1230.npy\n", + "(1, 80, 670)\n", + "trebek_2168.npy\n", + "(1, 80, 579)\n", + "trebek_1701.npy\n", + "(1, 80, 473)\n", + "trebek_0.npy\n", + "(1, 80, 541)\n", + "trebek_1870.npy\n", + "(1, 80, 618)\n", + "trebek_686.npy\n", + "(1, 80, 502)\n", + "trebek_49.npy\n", + "(1, 80, 820)\n", + "trebek_650.npy\n", + "(1, 80, 587)\n", + "trebek_2307.npy\n", + "(1, 80, 584)\n", + "trebek_328.npy\n", + "(1, 80, 654)\n", + "trebek_396.npy\n", + "(1, 80, 522)\n", + "trebek_96.npy\n", + "(1, 80, 591)\n", + "trebek_144.npy\n", + "(1, 80, 652)\n", + "trebek_861.npy\n", + "(1, 80, 578)\n", + "trebek_519.npy\n", + "(1, 80, 845)\n", + "trebek_1082.npy\n", + "(1, 80, 425)\n", + "trebek_640.npy\n", + "(1, 80, 675)\n", + "trebek_183.npy\n", + "(1, 80, 468)\n", + "trebek_589.npy\n", + "(1, 80, 613)\n", + "trebek_376.npy\n", + "(1, 80, 636)\n", + "trebek_1236.npy\n", + "(1, 80, 574)\n", + "trebek_663.npy\n", + "(1, 80, 595)\n", + "trebek_582.npy\n", + "(1, 80, 564)\n", + "trebek_1409.npy\n", + "(1, 80, 398)\n", + "trebek_319.npy\n", + "(1, 80, 860)\n", + "trebek_35.npy\n", + "(1, 80, 442)\n", + "trebek_1217.npy\n", + "(1, 80, 701)\n", + "trebek_786.npy\n", + "(1, 80, 639)\n", + "trebek_100.npy\n", + "(1, 80, 577)\n", + "trebek_2264.npy\n", + "(1, 80, 555)\n", + "trebek_194.npy\n", + "(1, 80, 776)\n", + "trebek_1551.npy\n", + "(1, 80, 259)\n", + "trebek_742.npy\n", + "(1, 80, 615)\n", + "trebek_2370.npy\n", + "(1, 80, 205)\n", + "trebek_1630.npy\n", + "(1, 80, 497)\n", + "trebek_1168.npy\n", + "(1, 80, 486)\n", + "trebek_1582.npy\n", + "(1, 80, 737)\n", + "trebek_1052.npy\n", + "(1, 80, 584)\n", + "trebek_1257.npy\n", + "(1, 80, 600)\n", + "trebek_246.npy\n", + "(1, 80, 574)\n", + "trebek_834.npy\n", + "(1, 80, 857)\n", + "trebek_1930.npy\n", + "(1, 80, 515)\n", + "trebek_1689.npy\n", + "(1, 80, 631)\n", + "trebek_565.npy\n", + "(1, 80, 373)\n", + "trebek_1141.npy\n", + "(1, 80, 561)\n", + "trebek_2208.npy\n", + "(1, 80, 249)\n", + "trebek_924.npy\n", + "(1, 80, 636)\n", + "trebek_1831.npy\n", + "(1, 80, 584)\n", + "trebek_545.npy\n", + "(1, 80, 732)\n", + "trebek_1813.npy\n", + "(1, 80, 567)\n", + "trebek_2538.npy\n", + "(1, 80, 502)\n", + "trebek_2391.npy\n", + "(1, 80, 414)\n", + "trebek_22.npy\n", + "(1, 80, 814)\n", + "trebek_2344.npy\n", + "(1, 80, 414)\n", + "trebek_966.npy\n", + "(1, 80, 931)\n", + "trebek_735.npy\n", + "(1, 80, 634)\n", + "trebek_1457.npy\n", + "(1, 80, 590)\n", + "trebek_2356.npy\n", + "(1, 80, 533)\n", + "trebek_1979.npy\n", + "(1, 80, 719)\n", + "trebek_1911.npy\n", + "(1, 80, 507)\n", + "trebek_1053.npy\n", + "(1, 80, 727)\n", + "trebek_1199.npy\n", + "(1, 80, 649)\n", + "trebek_2477.npy\n", + "(1, 80, 466)\n", + "trebek_2366.npy\n", + "(1, 80, 515)\n", + "trebek_1126.npy\n", + "(1, 80, 577)\n", + "trebek_514.npy\n", + "(1, 80, 453)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_910.npy\n", + "(1, 80, 406)\n", + "trebek_1113.npy\n", + "(1, 80, 261)\n", + "trebek_1596.npy\n", + "(1, 80, 560)\n", + "trebek_1433.npy\n", + "(1, 80, 349)\n", + "trebek_1123.npy\n", + "(1, 80, 615)\n", + "trebek_1524.npy\n", + "(1, 80, 342)\n", + "trebek_1247.npy\n", + "(1, 80, 549)\n", + "trebek_627.npy\n", + "(1, 80, 541)\n", + "trebek_1592.npy\n", + "(1, 80, 681)\n", + "trebek_2165.npy\n", + "(1, 80, 641)\n", + "trebek_495.npy\n", + "(1, 80, 686)\n", + "trebek_1025.npy\n", + "(1, 80, 644)\n", + "trebek_340.npy\n", + "(1, 80, 584)\n", + "trebek_369.npy\n", + "(1, 80, 442)\n", + "trebek_1488.npy\n", + "(1, 80, 871)\n", + "trebek_722.npy\n", + "(1, 80, 598)\n", + "trebek_1622.npy\n", + "(1, 80, 530)\n", + "trebek_1863.npy\n", + "(1, 80, 466)\n", + "trebek_1214.npy\n", + "(1, 80, 479)\n", + "trebek_596.npy\n", + "(1, 80, 476)\n", + "trebek_2212.npy\n", + "(1, 80, 521)\n", + "trebek_603.npy\n", + "(1, 80, 414)\n", + "trebek_541.npy\n", + "(1, 80, 597)\n", + "trebek_2292.npy\n", + "(1, 80, 577)\n", + "trebek_800.npy\n", + "(1, 80, 427)\n", + "trebek_2535.npy\n", + "(1, 80, 352)\n", + "trebek_972.npy\n", + "(1, 80, 635)\n", + "trebek_841.npy\n", + "(1, 80, 525)\n", + "trebek_1491.npy\n", + "(1, 80, 794)\n", + "trebek_1203.npy\n", + "(1, 80, 556)\n", + "trebek_1849.npy\n", + "(1, 80, 632)\n", + "trebek_2423.npy\n", + "(1, 80, 610)\n", + "trebek_1822.npy\n", + "(1, 80, 603)\n", + "trebek_311.npy\n", + "(1, 80, 582)\n", + "trebek_6.npy\n", + "(1, 80, 900)\n", + "trebek_812.npy\n", + "(1, 80, 627)\n", + "trebek_1975.npy\n", + "(1, 80, 714)\n", + "trebek_914.npy\n", + "(1, 80, 393)\n", + "trebek_199.npy\n", + "(1, 80, 709)\n", + "trebek_947.npy\n", + "(1, 80, 504)\n", + "trebek_244.npy\n", + "(1, 80, 517)\n", + "trebek_691.npy\n", + "(1, 80, 414)\n", + "trebek_1659.npy\n", + "(1, 80, 740)\n", + "trebek_689.npy\n", + "(1, 80, 547)\n", + "trebek_2090.npy\n", + "(1, 80, 647)\n", + "trebek_1156.npy\n", + "(1, 80, 551)\n", + "trebek_202.npy\n", + "(1, 80, 569)\n", + "trebek_2089.npy\n", + "(1, 80, 497)\n", + "trebek_899.npy\n", + "(1, 80, 665)\n", + "trebek_2502.npy\n", + "(1, 80, 520)\n", + "trebek_479.npy\n", + "(1, 80, 714)\n", + "trebek_934.npy\n", + "(1, 80, 626)\n", + "trebek_873.npy\n", + "(1, 80, 771)\n", + "trebek_2081.npy\n", + "(1, 80, 621)\n", + "trebek_1030.npy\n", + "(1, 80, 446)\n", + "trebek_513.npy\n", + "(1, 80, 386)\n", + "trebek_1726.npy\n", + "(1, 80, 815)\n", + "trebek_2426.npy\n", + "(1, 80, 587)\n", + "trebek_2145.npy\n", + "(1, 80, 681)\n", + "trebek_1903.npy\n", + "(1, 80, 424)\n", + "trebek_1703.npy\n", + "(1, 80, 802)\n", + "trebek_218.npy\n", + "(1, 80, 608)\n", + "trebek_2564.npy\n", + "(1, 80, 491)\n", + "trebek_879.npy\n", + "(1, 80, 485)\n", + "trebek_920.npy\n", + "(1, 80, 659)\n", + "trebek_500.npy\n", + "(1, 80, 380)\n", + "trebek_1745.npy\n", + "(1, 80, 773)\n", + "trebek_1133.npy\n", + "(1, 80, 520)\n", + "trebek_682.npy\n", + "(1, 80, 584)\n", + "trebek_693.npy\n", + "(1, 80, 468)\n", + "trebek_2450.npy\n", + "(1, 80, 678)\n", + "trebek_1438.npy\n", + "(1, 80, 380)\n", + "trebek_2368.npy\n", + "(1, 80, 742)\n", + "trebek_18.npy\n", + "(1, 80, 580)\n", + "trebek_1550.npy\n", + "(1, 80, 565)\n", + "trebek_2159.npy\n", + "(1, 80, 675)\n", + "trebek_2405.npy\n", + "(1, 80, 510)\n", + "trebek_1001.npy\n", + "(1, 80, 373)\n", + "trebek_2195.npy\n", + "(1, 80, 626)\n", + "trebek_1725.npy\n", + "(1, 80, 484)\n", + "trebek_740.npy\n", + "(1, 80, 668)\n", + "trebek_2217.npy\n", + "(1, 80, 233)\n", + "trebek_1007.npy\n", + "(1, 80, 670)\n", + "trebek_163.npy\n", + "(1, 80, 468)\n", + "trebek_789.npy\n", + "(1, 80, 559)\n", + "trebek_2537.npy\n", + "(1, 80, 515)\n", + "trebek_1319.npy\n", + "(1, 80, 637)\n", + "trebek_2123.npy\n", + "(1, 80, 466)\n", + "trebek_170.npy\n", + "(1, 80, 972)\n", + "trebek_219.npy\n", + "(1, 80, 622)\n", + "trebek_2068.npy\n", + "(1, 80, 737)\n", + "trebek_2255.npy\n", + "(1, 80, 522)\n", + "trebek_454.npy\n", + "(1, 80, 729)\n", + "trebek_2095.npy\n", + "(1, 80, 644)\n", + "trebek_1948.npy\n", + "(1, 80, 659)\n", + "trebek_2177.npy\n", + "(1, 80, 471)\n", + "trebek_867.npy\n", + "(1, 80, 414)\n", + "trebek_2207.npy\n", + "(1, 80, 344)\n", + "trebek_51.npy\n", + "(1, 80, 493)\n", + "trebek_101.npy\n", + "(1, 80, 427)\n", + "trebek_1408.npy\n", + "(1, 80, 627)\n", + "trebek_2456.npy\n", + "(1, 80, 329)\n", + "trebek_810.npy\n", + "(1, 80, 851)\n", + "trebek_2357.npy\n", + "(1, 80, 336)\n", + "trebek_1231.npy\n", + "(1, 80, 600)\n", + "trebek_2381.npy\n", + "(1, 80, 623)\n", + "trebek_238.npy\n", + "(1, 80, 864)\n", + "trebek_271.npy\n", + "(1, 80, 822)\n", + "trebek_1071.npy\n", + "(1, 80, 849)\n", + "trebek_160.npy\n", + "(1, 80, 424)\n", + "trebek_906.npy\n", + "(1, 80, 481)\n", + "trebek_1777.npy\n", + "(1, 80, 463)\n", + "trebek_1664.npy\n", + "(1, 80, 650)\n", + "trebek_1581.npy\n", + "(1, 80, 525)\n", + "trebek_273.npy\n", + "(1, 80, 600)\n", + "trebek_2022.npy\n", + "(1, 80, 344)\n", + "trebek_1061.npy\n", + "(1, 80, 486)\n", + "trebek_1597.npy\n", + "(1, 80, 437)\n", + "trebek_126.npy\n", + "(1, 80, 539)\n", + "trebek_314.npy\n", + "(1, 80, 541)\n", + "trebek_1738.npy\n", + "(1, 80, 737)\n", + "trebek_121.npy\n", + "(1, 80, 480)\n", + "trebek_1775.npy\n", + "(1, 80, 615)\n", + "trebek_388.npy\n", + "(1, 80, 398)\n", + "trebek_622.npy\n", + "(1, 80, 748)\n", + "trebek_457.npy\n", + "(1, 80, 701)\n", + "trebek_1496.npy\n", + "(1, 80, 711)\n", + "trebek_2147.npy\n", + "(1, 80, 727)\n", + "trebek_1633.npy\n", + "(1, 80, 709)\n", + "trebek_1374.npy\n", + "(1, 80, 845)\n", + "trebek_787.npy\n", + "(1, 80, 603)\n", + "trebek_970.npy\n", + "(1, 80, 553)\n", + "trebek_200.npy\n", + "(1, 80, 735)\n", + "trebek_1665.npy\n", + "(1, 80, 608)\n", + "trebek_1058.npy\n", + "(1, 80, 615)\n", + "trebek_114.npy\n", + "(1, 80, 627)\n", + "trebek_1101.npy\n", + "(1, 80, 548)\n", + "trebek_1200.npy\n", + "(1, 80, 461)\n", + "trebek_1298.npy\n", + "(1, 80, 698)\n", + "trebek_50.npy\n", + "(1, 80, 548)\n", + "trebek_1182.npy\n", + "(1, 80, 553)\n", + "trebek_1215.npy\n", + "(1, 80, 450)\n", + "trebek_1641.npy\n", + "(1, 80, 419)\n", + "trebek_1601.npy\n", + "(1, 80, 194)\n", + "trebek_869.npy\n", + "(1, 80, 684)\n", + "trebek_1109.npy\n", + "(1, 80, 551)\n", + "trebek_356.npy\n", + "(1, 80, 445)\n", + "trebek_1136.npy\n", + "(1, 80, 314)\n", + "trebek_1297.npy\n", + "(1, 80, 533)\n", + "trebek_1660.npy\n", + "(1, 80, 595)\n", + "trebek_115.npy\n", + "(1, 80, 993)\n", + "trebek_1259.npy\n", + "(1, 80, 508)\n", + "trebek_2069.npy\n", + "(1, 80, 508)\n", + "trebek_2135.npy\n", + "(1, 80, 572)\n", + "trebek_1938.npy\n", + "(1, 80, 641)\n", + "trebek_1802.npy\n", + "(1, 80, 335)\n", + "trebek_602.npy\n", + "(1, 80, 520)\n", + "trebek_2544.npy\n", + "(1, 80, 280)\n", + "trebek_490.npy\n", + "(1, 80, 680)\n", + "trebek_2124.npy\n", + "(1, 80, 463)\n", + "trebek_1375.npy\n", + "(1, 80, 663)\n", + "trebek_1589.npy\n", + "(1, 80, 518)\n", + "trebek_2006.npy\n", + "(1, 80, 782)\n", + "trebek_1504.npy\n", + "(1, 80, 608)\n", + "trebek_882.npy\n", + "(1, 80, 654)\n", + "trebek_373.npy\n", + "(1, 80, 427)\n", + "trebek_1940.npy\n", + "(1, 80, 858)\n", + "trebek_718.npy\n", + "(1, 80, 763)\n", + "trebek_1020.npy\n", + "(1, 80, 548)\n", + "trebek_2196.npy\n", + "(1, 80, 448)\n", + "trebek_1893.npy\n", + "(1, 80, 674)\n", + "trebek_1683.npy\n", + "(1, 80, 690)\n", + "trebek_1209.npy\n", + "(1, 80, 610)\n", + "trebek_1337.npy\n", + "(1, 80, 507)\n", + "trebek_2038.npy\n", + "(1, 80, 662)\n", + "trebek_2160.npy\n", + "(1, 80, 572)\n", + "trebek_1549.npy\n", + "(1, 80, 597)\n", + "trebek_508.npy\n", + "(1, 80, 365)\n", + "trebek_420.npy\n", + "(1, 80, 339)\n", + "trebek_880.npy\n", + "(1, 80, 277)\n", + "trebek_2083.npy\n", + "(1, 80, 640)\n", + "trebek_1915.npy\n", + "(1, 80, 479)\n", + "trebek_1348.npy\n", + "(1, 80, 632)\n", + "trebek_1824.npy\n", + "(1, 80, 665)\n", + "trebek_1140.npy\n", + "(1, 80, 536)\n", + "trebek_1562.npy\n", + "(1, 80, 533)\n", + "trebek_2481.npy\n", + "(1, 80, 360)\n", + "trebek_1623.npy\n", + "(1, 80, 345)\n", + "trebek_531.npy\n", + "(1, 80, 792)\n", + "trebek_2020.npy\n", + "(1, 80, 667)\n", + "trebek_1690.npy\n", + "(1, 80, 791)\n", + "trebek_694.npy\n", + "(1, 80, 383)\n", + "trebek_113.npy\n", + "(1, 80, 745)\n", + "trebek_1734.npy\n", + "(1, 80, 613)\n", + "trebek_470.npy\n", + "(1, 80, 566)\n", + "trebek_1570.npy\n", + "(1, 80, 499)\n", + "trebek_2244.npy\n", + "(1, 80, 805)\n", + "trebek_1047.npy\n", + "(1, 80, 422)\n", + "trebek_2151.npy\n", + "(1, 80, 836)\n", + "trebek_1307.npy\n", + "(1, 80, 598)\n", + "trebek_2108.npy\n", + "(1, 80, 621)\n", + "trebek_750.npy\n", + "(1, 80, 609)\n", + "trebek_845.npy\n", + "(1, 80, 721)\n", + "trebek_60.npy\n", + "(1, 80, 411)\n", + "trebek_785.npy\n", + "(1, 80, 622)\n", + "trebek_1621.npy\n", + "(1, 80, 398)\n", + "trebek_2010.npy\n", + "(1, 80, 815)\n", + "trebek_282.npy\n", + "(1, 80, 765)\n", + "trebek_1739.npy\n", + "(1, 80, 701)\n", + "trebek_921.npy\n", + "(1, 80, 544)\n", + "trebek_2328.npy\n", + "(1, 80, 716)\n", + "trebek_782.npy\n", + "(1, 80, 541)\n", + "trebek_621.npy\n", + "(1, 80, 685)\n", + "trebek_981.npy\n", + "(1, 80, 440)\n", + "trebek_638.npy\n", + "(1, 80, 659)\n", + "trebek_1787.npy\n", + "(1, 80, 409)\n", + "trebek_1676.npy\n", + "(1, 80, 354)\n", + "trebek_84.npy\n", + "(1, 80, 385)\n", + "trebek_2082.npy\n", + "(1, 80, 603)\n", + "trebek_2348.npy\n", + "(1, 80, 536)\n", + "trebek_760.npy\n", + "(1, 80, 285)\n", + "trebek_1568.npy\n", + "(1, 80, 225)\n", + "trebek_235.npy\n", + "(1, 80, 1029)\n", + "trebek_395.npy\n", + "(1, 80, 657)\n", + "trebek_1130.npy\n", + "(1, 80, 827)\n", + "trebek_1692.npy\n", + "(1, 80, 419)\n", + "trebek_2524.npy\n", + "(1, 80, 404)\n", + "trebek_672.npy\n", + "(1, 80, 441)\n", + "trebek_619.npy\n", + "(1, 80, 605)\n", + "trebek_661.npy\n", + "(1, 80, 454)\n", + "trebek_901.npy\n", + "(1, 80, 645)\n", + "trebek_2542.npy\n", + "(1, 80, 365)\n", + "trebek_1927.npy\n", + "(1, 80, 717)\n", + "trebek_2059.npy\n", + "(1, 80, 789)\n", + "trebek_937.npy\n", + "(1, 80, 750)\n", + "trebek_1170.npy\n", + "(1, 80, 649)\n", + "trebek_1360.npy\n", + "(1, 80, 579)\n", + "trebek_1034.npy\n", + "(1, 80, 598)\n", + "trebek_2271.npy\n", + "(1, 80, 641)\n", + "trebek_1067.npy\n", + "(1, 80, 350)\n", + "trebek_564.npy\n", + "(1, 80, 817)\n", + "trebek_788.npy\n", + "(1, 80, 358)\n", + "trebek_588.npy\n", + "(1, 80, 685)\n", + "trebek_1108.npy\n", + "(1, 80, 639)\n", + "trebek_1349.npy\n", + "(1, 80, 843)\n", + "trebek_1951.npy\n", + "(1, 80, 398)\n", + "trebek_19.npy\n", + "(1, 80, 685)\n", + "trebek_1742.npy\n", + "(1, 80, 758)\n", + "trebek_2101.npy\n", + "(1, 80, 818)\n", + "trebek_1494.npy\n", + "(1, 80, 629)\n", + "trebek_1060.npy\n", + "(1, 80, 712)\n", + "trebek_1643.npy\n", + "(1, 80, 300)\n", + "trebek_738.npy\n", + "(1, 80, 590)\n", + "trebek_1651.npy\n", + "(1, 80, 497)\n", + "trebek_700.npy\n", + "(1, 80, 864)\n", + "trebek_1351.npy\n", + "(1, 80, 526)\n", + "trebek_520.npy\n", + "(1, 80, 590)\n", + "trebek_1532.npy\n", + "(1, 80, 471)\n", + "trebek_429.npy\n", + "(1, 80, 721)\n", + "trebek_517.npy\n", + "(1, 80, 703)\n", + "trebek_1313.npy\n", + "(1, 80, 613)\n", + "trebek_1492.npy\n", + "(1, 80, 579)\n", + "trebek_2002.npy\n", + "(1, 80, 443)\n", + "trebek_1619.npy\n", + "(1, 80, 205)\n", + "trebek_1353.npy\n", + "(1, 80, 484)\n", + "trebek_1487.npy\n", + "(1, 80, 518)\n", + "trebek_597.npy\n", + "(1, 80, 622)\n", + "trebek_2057.npy\n", + "(1, 80, 382)\n", + "trebek_737.npy\n", + "(1, 80, 758)\n", + "trebek_919.npy\n", + "(1, 80, 480)\n", + "trebek_631.npy\n", + "(1, 80, 657)\n", + "trebek_1757.npy\n", + "(1, 80, 491)\n", + "trebek_21.npy\n", + "(1, 80, 833)\n", + "trebek_1364.npy\n", + "(1, 80, 507)\n", + "trebek_2143.npy\n", + "(1, 80, 662)\n", + "trebek_2367.npy\n", + "(1, 80, 528)\n", + "trebek_1404.npy\n", + "(1, 80, 808)\n", + "trebek_739.npy\n", + "(1, 80, 559)\n", + "trebek_692.npy\n", + "(1, 80, 598)\n", + "trebek_817.npy\n", + "(1, 80, 463)\n", + "trebek_197.npy\n", + "(1, 80, 525)\n", + "trebek_1186.npy\n", + "(1, 80, 500)\n", + "trebek_1508.npy\n", + "(1, 80, 654)\n", + "trebek_556.npy\n", + "(1, 80, 565)\n", + "trebek_2311.npy\n", + "(1, 80, 796)\n", + "trebek_2041.npy\n", + "(1, 80, 313)\n", + "trebek_1907.npy\n", + "(1, 80, 1057)\n", + "trebek_1631.npy\n", + "(1, 80, 505)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2417.npy\n", + "(1, 80, 603)\n", + "trebek_827.npy\n", + "(1, 80, 575)\n", + "trebek_1521.npy\n", + "(1, 80, 665)\n", + "trebek_70.npy\n", + "(1, 80, 727)\n", + "trebek_383.npy\n", + "(1, 80, 791)\n", + "trebek_1210.npy\n", + "(1, 80, 507)\n", + "trebek_33.npy\n", + "(1, 80, 846)\n", + "trebek_677.npy\n", + "(1, 80, 719)\n", + "trebek_1473.npy\n", + "(1, 80, 764)\n", + "trebek_2407.npy\n", + "(1, 80, 306)\n", + "trebek_406.npy\n", + "(1, 80, 305)\n", + "trebek_763.npy\n", + "(1, 80, 293)\n", + "trebek_1999.npy\n", + "(1, 80, 587)\n", + "trebek_1669.npy\n", + "(1, 80, 442)\n", + "trebek_954.npy\n", + "(1, 80, 668)\n", + "trebek_1780.npy\n", + "(1, 80, 598)\n", + "trebek_20.npy\n", + "(1, 80, 899)\n", + "trebek_713.npy\n", + "(1, 80, 654)\n", + "trebek_2438.npy\n", + "(1, 80, 783)\n", + "trebek_308.npy\n", + "(1, 80, 547)\n", + "trebek_465.npy\n", + "(1, 80, 691)\n", + "trebek_2278.npy\n", + "(1, 80, 388)\n", + "trebek_1663.npy\n", + "(1, 80, 752)\n", + "trebek_1088.npy\n", + "(1, 80, 742)\n", + "trebek_139.npy\n", + "(1, 80, 685)\n", + "trebek_1834.npy\n", + "(1, 80, 467)\n", + "trebek_1857.npy\n", + "(1, 80, 634)\n", + "trebek_679.npy\n", + "(1, 80, 367)\n", + "trebek_2154.npy\n", + "(1, 80, 751)\n", + "trebek_401.npy\n", + "(1, 80, 587)\n", + "trebek_161.npy\n", + "(1, 80, 758)\n", + "trebek_2471.npy\n", + "(1, 80, 541)\n", + "trebek_2204.npy\n", + "(1, 80, 684)\n", + "trebek_127.npy\n", + "(1, 80, 261)\n", + "trebek_1869.npy\n", + "(1, 80, 628)\n", + "trebek_1128.npy\n", + "(1, 80, 639)\n", + "trebek_476.npy\n", + "(1, 80, 595)\n", + "trebek_666.npy\n", + "(1, 80, 458)\n", + "trebek_1343.npy\n", + "(1, 80, 783)\n", + "trebek_1896.npy\n", + "(1, 80, 507)\n", + "trebek_1338.npy\n", + "(1, 80, 843)\n", + "trebek_1394.npy\n", + "(1, 80, 503)\n", + "trebek_2353.npy\n", + "(1, 80, 747)\n", + "trebek_1706.npy\n", + "(1, 80, 468)\n", + "trebek_1556.npy\n", + "(1, 80, 711)\n", + "trebek_1615.npy\n", + "(1, 80, 858)\n", + "trebek_350.npy\n", + "(1, 80, 460)\n", + "trebek_2226.npy\n", + "(1, 80, 373)\n", + "trebek_326.npy\n", + "(1, 80, 861)\n", + "trebek_1908.npy\n", + "(1, 80, 658)\n", + "trebek_2192.npy\n", + "(1, 80, 722)\n", + "trebek_1256.npy\n", + "(1, 80, 251)\n", + "trebek_2528.npy\n", + "(1, 80, 398)\n", + "trebek_2567.npy\n", + "(1, 80, 331)\n", + "trebek_265.npy\n", + "(1, 80, 499)\n", + "trebek_2501.npy\n", + "(1, 80, 419)\n", + "trebek_446.npy\n", + "(1, 80, 623)\n", + "trebek_1454.npy\n", + "(1, 80, 683)\n", + "trebek_250.npy\n", + "(1, 80, 843)\n", + "trebek_1800.npy\n", + "(1, 80, 533)\n", + "trebek_1107.npy\n", + "(1, 80, 622)\n", + "trebek_1878.npy\n", + "(1, 80, 484)\n", + "trebek_881.npy\n", + "(1, 80, 463)\n", + "trebek_2240.npy\n", + "(1, 80, 256)\n", + "trebek_705.npy\n", + "(1, 80, 640)\n", + "trebek_1985.npy\n", + "(1, 80, 667)\n", + "trebek_1013.npy\n", + "(1, 80, 745)\n", + "trebek_1719.npy\n", + "(1, 80, 368)\n", + "trebek_1054.npy\n", + "(1, 80, 735)\n", + "trebek_1501.npy\n", + "(1, 80, 683)\n", + "trebek_2.npy\n", + "(1, 80, 913)\n", + "trebek_1271.npy\n", + "(1, 80, 539)\n", + "trebek_962.npy\n", + "(1, 80, 570)\n", + "trebek_425.npy\n", + "(1, 80, 450)\n", + "trebek_1216.npy\n", + "(1, 80, 668)\n", + "trebek_23.npy\n", + "(1, 80, 517)\n", + "trebek_29.npy\n", + "(1, 80, 634)\n", + "trebek_898.npy\n", + "(1, 80, 320)\n", + "trebek_2475.npy\n", + "(1, 80, 508)\n", + "trebek_569.npy\n", + "(1, 80, 510)\n", + "trebek_707.npy\n", + "(1, 80, 975)\n", + "trebek_316.npy\n", + "(1, 80, 897)\n", + "trebek_1456.npy\n", + "(1, 80, 724)\n", + "trebek_2461.npy\n", + "(1, 80, 236)\n", + "trebek_132.npy\n", + "(1, 80, 838)\n", + "trebek_612.npy\n", + "(1, 80, 747)\n", + "trebek_1258.npy\n", + "(1, 80, 698)\n", + "trebek_1983.npy\n", + "(1, 80, 703)\n", + "trebek_1089.npy\n", + "(1, 80, 784)\n", + "trebek_1154.npy\n", + "(1, 80, 547)\n", + "trebek_57.npy\n", + "(1, 80, 698)\n", + "trebek_1393.npy\n", + "(1, 80, 406)\n", + "trebek_2181.npy\n", + "(1, 80, 535)\n", + "trebek_230.npy\n", + "(1, 80, 437)\n", + "trebek_167.npy\n", + "(1, 80, 670)\n", + "trebek_1039.npy\n", + "(1, 80, 357)\n", + "trebek_1245.npy\n", + "(1, 80, 900)\n", + "trebek_660.npy\n", + "(1, 80, 688)\n", + "trebek_840.npy\n", + "(1, 80, 565)\n", + "trebek_1931.npy\n", + "(1, 80, 466)\n", + "trebek_2029.npy\n", + "(1, 80, 619)\n", + "trebek_511.npy\n", + "(1, 80, 507)\n", + "trebek_608.npy\n", + "(1, 80, 688)\n", + "trebek_1529.npy\n", + "(1, 80, 420)\n", + "trebek_354.npy\n", + "(1, 80, 683)\n", + "trebek_928.npy\n", + "(1, 80, 404)\n", + "trebek_99.npy\n", + "(1, 80, 603)\n", + "trebek_761.npy\n", + "(1, 80, 505)\n", + "trebek_2342.npy\n", + "(1, 80, 605)\n", + "trebek_1252.npy\n", + "(1, 80, 631)\n", + "trebek_1029.npy\n", + "(1, 80, 367)\n", + "trebek_2185.npy\n", + "(1, 80, 277)\n", + "trebek_958.npy\n", + "(1, 80, 556)\n", + "trebek_2166.npy\n", + "(1, 80, 450)\n", + "trebek_392.npy\n", + "(1, 80, 786)\n", + "trebek_492.npy\n", + "(1, 80, 702)\n", + "trebek_2283.npy\n", + "(1, 80, 533)\n", + "trebek_1276.npy\n", + "(1, 80, 380)\n", + "trebek_1722.npy\n", + "(1, 80, 631)\n", + "trebek_1797.npy\n", + "(1, 80, 367)\n", + "trebek_276.npy\n", + "(1, 80, 608)\n", + "trebek_2389.npy\n", + "(1, 80, 388)\n", + "trebek_529.npy\n", + "(1, 80, 600)\n", + "trebek_1588.npy\n", + "(1, 80, 324)\n", + "trebek_1365.npy\n", + "(1, 80, 680)\n", + "trebek_1579.npy\n", + "(1, 80, 688)\n", + "trebek_1877.npy\n", + "(1, 80, 587)\n", + "trebek_2305.npy\n", + "(1, 80, 587)\n", + "trebek_1242.npy\n", + "(1, 80, 786)\n", + "trebek_2320.npy\n", + "(1, 80, 751)\n", + "trebek_501.npy\n", + "(1, 80, 654)\n", + "trebek_1248.npy\n", + "(1, 80, 608)\n", + "trebek_2141.npy\n", + "(1, 80, 606)\n", + "trebek_2376.npy\n", + "(1, 80, 600)\n", + "trebek_2218.npy\n", + "(1, 80, 627)\n", + "trebek_728.npy\n", + "(1, 80, 644)\n", + "trebek_313.npy\n", + "(1, 80, 876)\n", + "trebek_842.npy\n", + "(1, 80, 365)\n", + "trebek_1541.npy\n", + "(1, 80, 663)\n", + "trebek_752.npy\n", + "(1, 80, 533)\n", + "trebek_764.npy\n", + "(1, 80, 669)\n", + "trebek_69.npy\n", + "(1, 80, 504)\n", + "trebek_2077.npy\n", + "(1, 80, 466)\n", + "trebek_1045.npy\n", + "(1, 80, 326)\n", + "trebek_258.npy\n", + "(1, 80, 851)\n", + "trebek_389.npy\n", + "(1, 80, 566)\n", + "trebek_644.npy\n", + "(1, 80, 892)\n", + "trebek_2178.npy\n", + "(1, 80, 371)\n", + "trebek_386.npy\n", + "(1, 80, 574)\n", + "trebek_807.npy\n", + "(1, 80, 510)\n", + "trebek_499.npy\n", + "(1, 80, 541)\n", + "trebek_839.npy\n", + "(1, 80, 497)\n", + "trebek_1354.npy\n", + "(1, 80, 603)\n", + "trebek_1829.npy\n", + "(1, 80, 463)\n", + "trebek_1700.npy\n", + "(1, 80, 590)\n", + "trebek_2296.npy\n", + "(1, 80, 355)\n", + "trebek_1627.npy\n", + "(1, 80, 867)\n", + "trebek_2242.npy\n", + "(1, 80, 391)\n", + "trebek_883.npy\n", + "(1, 80, 696)\n", + "trebek_2216.npy\n", + "(1, 80, 259)\n", + "trebek_225.npy\n", + "(1, 80, 892)\n", + "trebek_2100.npy\n", + "(1, 80, 233)\n", + "trebek_1228.npy\n", + "(1, 80, 579)\n", + "trebek_2446.npy\n", + "(1, 80, 515)\n", + "trebek_1531.npy\n", + "(1, 80, 721)\n", + "trebek_1606.npy\n", + "(1, 80, 396)\n", + "trebek_445.npy\n", + "(1, 80, 727)\n", + "trebek_571.npy\n", + "(1, 80, 220)\n", + "trebek_913.npy\n", + "(1, 80, 604)\n", + "trebek_1470.npy\n", + "(1, 80, 624)\n", + "trebek_2187.npy\n", + "(1, 80, 672)\n", + "trebek_2362.npy\n", + "(1, 80, 399)\n", + "trebek_272.npy\n", + "(1, 80, 667)\n", + "trebek_1889.npy\n", + "(1, 80, 745)\n", + "trebek_533.npy\n", + "(1, 80, 667)\n", + "trebek_649.npy\n", + "(1, 80, 621)\n", + "trebek_1749.npy\n", + "(1, 80, 652)\n", + "trebek_62.npy\n", + "(1, 80, 734)\n", + "trebek_2316.npy\n", + "(1, 80, 727)\n", + "trebek_1097.npy\n", + "(1, 80, 509)\n", + "trebek_210.npy\n", + "(1, 80, 557)\n", + "trebek_950.npy\n", + "(1, 80, 318)\n", + "trebek_539.npy\n", + "(1, 80, 742)\n", + "trebek_960.npy\n", + "(1, 80, 388)\n", + "trebek_2420.npy\n", + "(1, 80, 742)\n", + "trebek_1732.npy\n", + "(1, 80, 603)\n", + "trebek_415.npy\n", + "(1, 80, 624)\n", + "trebek_1515.npy\n", + "(1, 80, 529)\n", + "trebek_509.npy\n", + "(1, 80, 864)\n", + "trebek_2042.npy\n", + "(1, 80, 541)\n", + "trebek_2175.npy\n", + "(1, 80, 479)\n", + "trebek_1250.npy\n", + "(1, 80, 422)\n", + "trebek_2172.npy\n", + "(1, 80, 709)\n", + "trebek_512.npy\n", + "(1, 80, 584)\n", + "trebek_89.npy\n", + "(1, 80, 714)\n", + "trebek_431.npy\n", + "(1, 80, 430)\n", + "trebek_1751.npy\n", + "(1, 80, 559)\n", + "trebek_1163.npy\n", + "(1, 80, 448)\n", + "trebek_838.npy\n", + "(1, 80, 773)\n", + "trebek_402.npy\n", + "(1, 80, 636)\n", + "trebek_2107.npy\n", + "(1, 80, 587)\n", + "trebek_1331.npy\n", + "(1, 80, 665)\n", + "trebek_2249.npy\n", + "(1, 80, 871)\n", + "trebek_187.npy\n", + "(1, 80, 556)\n", + "trebek_850.npy\n", + "(1, 80, 556)\n", + "trebek_540.npy\n", + "(1, 80, 526)\n", + "trebek_466.npy\n", + "(1, 80, 675)\n", + "trebek_1048.npy\n", + "(1, 80, 334)\n", + "trebek_2034.npy\n", + "(1, 80, 1096)\n", + "trebek_1866.npy\n", + "(1, 80, 701)\n", + "trebek_1698.npy\n", + "(1, 80, 443)\n", + "trebek_41.npy\n", + "(1, 80, 598)\n", + "trebek_951.npy\n", + "(1, 80, 632)\n", + "trebek_2098.npy\n", + "(1, 80, 587)\n", + "trebek_1561.npy\n", + "(1, 80, 492)\n", + "trebek_2556.npy\n", + "(1, 80, 366)\n", + "trebek_892.npy\n", + "(1, 80, 572)\n", + "trebek_1306.npy\n", + "(1, 80, 388)\n", + "trebek_1804.npy\n", + "(1, 80, 768)\n", + "trebek_141.npy\n", + "(1, 80, 522)\n", + "trebek_2263.npy\n", + "(1, 80, 699)\n", + "trebek_93.npy\n", + "(1, 80, 634)\n", + "trebek_1705.npy\n", + "(1, 80, 746)\n", + "trebek_1765.npy\n", + "(1, 80, 618)\n", + "trebek_936.npy\n", + "(1, 80, 732)\n", + "trebek_527.npy\n", + "(1, 80, 528)\n", + "trebek_665.npy\n", + "(1, 80, 777)\n", + "trebek_1923.npy\n", + "(1, 80, 626)\n", + "trebek_130.npy\n", + "(1, 80, 597)\n", + "trebek_2354.npy\n", + "(1, 80, 592)\n", + "trebek_1978.npy\n", + "(1, 80, 653)\n", + "trebek_2018.npy\n", + "(1, 80, 665)\n", + "trebek_483.npy\n", + "(1, 80, 504)\n", + "trebek_1835.npy\n", + "(1, 80, 328)\n", + "trebek_63.npy\n", + "(1, 80, 546)\n", + "trebek_2514.npy\n", + "(1, 80, 318)\n", + "trebek_651.npy\n", + "(1, 80, 702)\n", + "trebek_1905.npy\n", + "(1, 80, 725)\n", + "trebek_77.npy\n", + "(1, 80, 747)\n", + "trebek_1310.npy\n", + "(1, 80, 466)\n", + "trebek_2164.npy\n", + "(1, 80, 727)\n", + "trebek_1482.npy\n", + "(1, 80, 212)\n", + "trebek_1010.npy\n", + "(1, 80, 548)\n", + "trebek_978.npy\n", + "(1, 80, 523)\n", + "trebek_207.npy\n", + "(1, 80, 820)\n", + "trebek_574.npy\n", + "(1, 80, 525)\n", + "trebek_1056.npy\n", + "(1, 80, 768)\n", + "trebek_105.npy\n", + "(1, 80, 649)\n", + "trebek_204.npy\n", + "(1, 80, 810)\n", + "trebek_593.npy\n", + "(1, 80, 735)\n", + "trebek_609.npy\n", + "(1, 80, 797)\n", + "trebek_1287.npy\n", + "(1, 80, 641)\n", + "trebek_1972.npy\n", + "(1, 80, 628)\n", + "trebek_595.npy\n", + "(1, 80, 587)\n", + "trebek_1783.npy\n", + "(1, 80, 592)\n", + "trebek_1947.npy\n", + "(1, 80, 623)\n", + "trebek_2157.npy\n", + "(1, 80, 655)\n", + "trebek_2269.npy\n", + "(1, 80, 538)\n", + "trebek_1686.npy\n", + "(1, 80, 721)\n", + "trebek_1471.npy\n", + "(1, 80, 615)\n", + "trebek_808.npy\n", + "(1, 80, 542)\n", + "trebek_2355.npy\n", + "(1, 80, 587)\n", + "trebek_1856.npy\n", + "(1, 80, 746)\n", + "trebek_2515.npy\n", + "(1, 80, 342)\n", + "trebek_98.npy\n", + "(1, 80, 696)\n", + "trebek_2227.npy\n", + "(1, 80, 541)\n", + "trebek_1852.npy\n", + "(1, 80, 572)\n", + "trebek_1988.npy\n", + "(1, 80, 445)\n", + "trebek_832.npy\n", + "(1, 80, 502)\n", + "trebek_1407.npy\n", + "(1, 80, 479)\n", + "trebek_963.npy\n", + "(1, 80, 486)\n", + "trebek_2021.npy\n", + "(1, 80, 409)\n", + "trebek_1976.npy\n", + "(1, 80, 794)\n", + "trebek_72.npy\n", + "(1, 80, 406)\n", + "trebek_302.npy\n", + "(1, 80, 529)\n", + "trebek_1465.npy\n", + "(1, 80, 449)\n", + "trebek_61.npy\n", + "(1, 80, 862)\n", + "trebek_809.npy\n", + "(1, 80, 715)\n", + "trebek_977.npy\n", + "(1, 80, 665)\n", + "trebek_606.npy\n", + "(1, 80, 546)\n", + "trebek_116.npy\n", + "(1, 80, 634)\n", + "trebek_1498.npy\n", + "(1, 80, 303)\n", + "trebek_1794.npy\n", + "(1, 80, 551)\n", + "trebek_1540.npy\n", + "(1, 80, 530)\n", + "trebek_2493.npy\n", + "(1, 80, 380)\n", + "trebek_1102.npy\n", + "(1, 80, 530)\n", + "trebek_2275.npy\n", + "(1, 80, 685)\n", + "trebek_1388.npy\n", + "(1, 80, 556)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_150.npy\n", + "(1, 80, 711)\n", + "trebek_488.npy\n", + "(1, 80, 495)\n", + "trebek_1536.npy\n", + "(1, 80, 773)\n", + "trebek_1347.npy\n", + "(1, 80, 724)\n", + "trebek_1062.npy\n", + "(1, 80, 605)\n", + "trebek_180.npy\n", + "(1, 80, 479)\n", + "trebek_379.npy\n", + "(1, 80, 584)\n", + "trebek_1535.npy\n", + "(1, 80, 515)\n", + "trebek_1279.npy\n", + "(1, 80, 722)\n", + "trebek_2449.npy\n", + "(1, 80, 525)\n", + "trebek_1784.npy\n", + "(1, 80, 750)\n", + "trebek_967.npy\n", + "(1, 80, 657)\n", + "trebek_1901.npy\n", + "(1, 80, 699)\n", + "trebek_1178.npy\n", + "(1, 80, 502)\n", + "trebek_659.npy\n", + "(1, 80, 659)\n", + "trebek_2150.npy\n", + "(1, 80, 729)\n", + "trebek_2273.npy\n", + "(1, 80, 779)\n", + "trebek_1527.npy\n", + "(1, 80, 388)\n", + "trebek_1227.npy\n", + "(1, 80, 603)\n", + "trebek_1442.npy\n", + "(1, 80, 342)\n", + "trebek_1552.npy\n", + "(1, 80, 701)\n", + "trebek_2467.npy\n", + "(1, 80, 316)\n", + "trebek_2105.npy\n", + "(1, 80, 637)\n", + "trebek_404.npy\n", + "(1, 80, 616)\n", + "trebek_97.npy\n", + "(1, 80, 706)\n", + "trebek_1788.npy\n", + "(1, 80, 525)\n", + "trebek_283.npy\n", + "(1, 80, 517)\n", + "trebek_2301.npy\n", + "(1, 80, 349)\n", + "trebek_2130.npy\n", + "(1, 80, 730)\n", + "trebek_749.npy\n", + "(1, 80, 649)\n", + "trebek_1431.npy\n", + "(1, 80, 814)\n", + "trebek_944.npy\n", + "(1, 80, 680)\n", + "trebek_1224.npy\n", + "(1, 80, 597)\n", + "trebek_1964.npy\n", + "(1, 80, 432)\n", + "trebek_1510.npy\n", + "(1, 80, 538)\n", + "trebek_2363.npy\n", + "(1, 80, 497)\n", + "trebek_1747.npy\n", + "(1, 80, 482)\n", + "trebek_1710.npy\n", + "(1, 80, 491)\n", + "trebek_1891.npy\n", + "(1, 80, 721)\n", + "trebek_664.npy\n", + "(1, 80, 295)\n", + "trebek_1272.npy\n", + "(1, 80, 517)\n", + "trebek_2173.npy\n", + "(1, 80, 547)\n", + "trebek_1613.npy\n", + "(1, 80, 737)\n", + "trebek_280.npy\n", + "(1, 80, 491)\n", + "trebek_281.npy\n", + "(1, 80, 698)\n", + "trebek_1645.npy\n", + "(1, 80, 220)\n", + "trebek_119.npy\n", + "(1, 80, 515)\n", + "trebek_1426.npy\n", + "(1, 80, 407)\n", + "trebek_1400.npy\n", + "(1, 80, 773)\n", + "trebek_290.npy\n", + "(1, 80, 507)\n", + "trebek_1012.npy\n", + "(1, 80, 624)\n", + "trebek_929.npy\n", + "(1, 80, 321)\n", + "trebek_1720.npy\n", + "(1, 80, 610)\n", + "trebek_1303.npy\n", + "(1, 80, 733)\n", + "trebek_474.npy\n", + "(1, 80, 707)\n", + "trebek_472.npy\n", + "(1, 80, 807)\n", + "trebek_2233.npy\n", + "(1, 80, 636)\n", + "trebek_1124.npy\n", + "(1, 80, 768)\n", + "trebek_279.npy\n", + "(1, 80, 741)\n", + "trebek_241.npy\n", + "(1, 80, 760)\n", + "trebek_2309.npy\n", + "(1, 80, 445)\n", + "trebek_32.npy\n", + "(1, 80, 362)\n", + "trebek_1512.npy\n", + "(1, 80, 665)\n", + "trebek_1396.npy\n", + "(1, 80, 569)\n", + "trebek_1966.npy\n", + "(1, 80, 631)\n", + "trebek_942.npy\n", + "(1, 80, 471)\n", + "trebek_169.npy\n", + "(1, 80, 650)\n", + "trebek_2325.npy\n", + "(1, 80, 455)\n", + "trebek_1381.npy\n", + "(1, 80, 633)\n", + "trebek_1959.npy\n", + "(1, 80, 554)\n", + "trebek_1929.npy\n", + "(1, 80, 711)\n", + "trebek_1369.npy\n", + "(1, 80, 619)\n", + "trebek_2074.npy\n", + "(1, 80, 954)\n", + "trebek_1693.npy\n", + "(1, 80, 365)\n", + "trebek_413.npy\n", + "(1, 80, 450)\n", + "trebek_1600.npy\n", + "(1, 80, 280)\n", + "trebek_157.npy\n", + "(1, 80, 794)\n", + "trebek_1818.npy\n", + "(1, 80, 727)\n", + "trebek_248.npy\n", + "(1, 80, 492)\n", + "trebek_1165.npy\n", + "(1, 80, 404)\n", + "trebek_1727.npy\n", + "(1, 80, 807)\n", + "trebek_2457.npy\n", + "(1, 80, 210)\n", + "trebek_284.npy\n", + "(1, 80, 495)\n", + "trebek_2460.npy\n", + "(1, 80, 347)\n", + "trebek_831.npy\n", + "(1, 80, 536)\n", + "trebek_806.npy\n", + "(1, 80, 518)\n", + "trebek_1074.npy\n", + "(1, 80, 386)\n", + "trebek_2312.npy\n", + "(1, 80, 410)\n", + "trebek_2211.npy\n", + "(1, 80, 657)\n", + "trebek_172.npy\n", + "(1, 80, 640)\n", + "trebek_1401.npy\n", + "(1, 80, 598)\n", + "trebek_765.npy\n", + "(1, 80, 531)\n", + "trebek_1225.npy\n", + "(1, 80, 510)\n", + "trebek_2126.npy\n", + "(1, 80, 487)\n", + "trebek_1941.npy\n", + "(1, 80, 559)\n", + "trebek_2462.npy\n", + "(1, 80, 218)\n", + "trebek_2037.npy\n", + "(1, 80, 437)\n", + "trebek_2479.npy\n", + "(1, 80, 279)\n", + "trebek_2313.npy\n", + "(1, 80, 613)\n", + "trebek_2397.npy\n", + "(1, 80, 567)\n", + "trebek_636.npy\n", + "(1, 80, 890)\n", + "trebek_857.npy\n", + "(1, 80, 737)\n", + "trebek_676.npy\n", + "(1, 80, 534)\n", + "trebek_1713.npy\n", + "(1, 80, 479)\n", + "trebek_1397.npy\n", + "(1, 80, 835)\n", + "trebek_1789.npy\n", + "(1, 80, 652)\n", + "trebek_17.npy\n", + "(1, 80, 641)\n", + "trebek_505.npy\n", + "(1, 80, 530)\n", + "trebek_1995.npy\n", + "(1, 80, 427)\n", + "trebek_1172.npy\n", + "(1, 80, 332)\n", + "trebek_1555.npy\n", + "(1, 80, 670)\n", + "trebek_598.npy\n", + "(1, 80, 608)\n", + "trebek_814.npy\n", + "(1, 80, 610)\n", + "trebek_759.npy\n", + "(1, 80, 535)\n", + "trebek_312.npy\n", + "(1, 80, 862)\n", + "trebek_1112.npy\n", + "(1, 80, 406)\n", + "trebek_1910.npy\n", + "(1, 80, 672)\n", + "trebek_948.npy\n", + "(1, 80, 349)\n", + "trebek_1430.npy\n", + "(1, 80, 552)\n", + "trebek_1315.npy\n", + "(1, 80, 614)\n", + "trebek_2303.npy\n", + "(1, 80, 587)\n", + "trebek_1077.npy\n", + "(1, 80, 566)\n", + "trebek_1724.npy\n", + "(1, 80, 466)\n", + "trebek_2299.npy\n", + "(1, 80, 391)\n", + "trebek_641.npy\n", + "(1, 80, 530)\n", + "trebek_2485.npy\n", + "(1, 80, 306)\n", + "trebek_816.npy\n", + "(1, 80, 647)\n", + "trebek_156.npy\n", + "(1, 80, 504)\n", + "trebek_215.npy\n", + "(1, 80, 662)\n", + "trebek_393.npy\n", + "(1, 80, 696)\n", + "trebek_745.npy\n", + "(1, 80, 659)\n", + "trebek_1445.npy\n", + "(1, 80, 595)\n", + "trebek_1902.npy\n", + "(1, 80, 817)\n", + "trebek_1993.npy\n", + "(1, 80, 626)\n", + "trebek_398.npy\n", + "(1, 80, 541)\n", + "trebek_1718.npy\n", + "(1, 80, 530)\n", + "trebek_1370.npy\n", + "(1, 80, 799)\n", + "trebek_989.npy\n", + "(1, 80, 473)\n", + "trebek_2321.npy\n", + "(1, 80, 595)\n", + "trebek_1395.npy\n", + "(1, 80, 419)\n", + "trebek_1037.npy\n", + "(1, 80, 634)\n", + "trebek_442.npy\n", + "(1, 80, 274)\n", + "trebek_1503.npy\n", + "(1, 80, 853)\n", + "trebek_1460.npy\n", + "(1, 80, 747)\n", + "trebek_714.npy\n", + "(1, 80, 724)\n", + "trebek_2252.npy\n", + "(1, 80, 468)\n", + "trebek_1821.npy\n", + "(1, 80, 517)\n", + "trebek_2513.npy\n", + "(1, 80, 370)\n", + "trebek_305.npy\n", + "(1, 80, 712)\n", + "trebek_1027.npy\n", + "(1, 80, 460)\n", + "trebek_179.npy\n", + "(1, 80, 795)\n", + "trebek_888.npy\n", + "(1, 80, 619)\n", + "trebek_1129.npy\n", + "(1, 80, 740)\n", + "trebek_1711.npy\n", + "(1, 80, 318)\n", + "trebek_696.npy\n", + "(1, 80, 756)\n", + "trebek_1565.npy\n", + "(1, 80, 691)\n", + "trebek_264.npy\n", + "(1, 80, 574)\n", + "trebek_2403.npy\n", + "(1, 80, 510)\n", + "trebek_1413.npy\n", + "(1, 80, 448)\n", + "trebek_1876.npy\n", + "(1, 80, 205)\n", + "trebek_171.npy\n", + "(1, 80, 484)\n", + "trebek_1918.npy\n", + "(1, 80, 561)\n", + "trebek_2194.npy\n", + "(1, 80, 479)\n", + "trebek_1361.npy\n", + "(1, 80, 230)\n", + "trebek_381.npy\n", + "(1, 80, 670)\n", + "trebek_2215.npy\n", + "(1, 80, 321)\n", + "trebek_2198.npy\n", + "(1, 80, 608)\n", + "trebek_1311.npy\n", + "(1, 80, 212)\n", + "trebek_59.npy\n", + "(1, 80, 910)\n", + "trebek_1860.npy\n", + "(1, 80, 541)\n", + "trebek_1885.npy\n", + "(1, 80, 647)\n", + "trebek_1153.npy\n", + "(1, 80, 608)\n", + "trebek_2125.npy\n", + "(1, 80, 776)\n", + "trebek_2379.npy\n", + "(1, 80, 598)\n", + "trebek_177.npy\n", + "(1, 80, 641)\n", + "trebek_444.npy\n", + "(1, 80, 582)\n", + "trebek_1768.npy\n", + "(1, 80, 747)\n", + "trebek_226.npy\n", + "(1, 80, 715)\n", + "trebek_1858.npy\n", + "(1, 80, 639)\n", + "trebek_297.npy\n", + "(1, 80, 626)\n", + "trebek_1191.npy\n", + "(1, 80, 871)\n", + "trebek_1005.npy\n", + "(1, 80, 417)\n", + "trebek_2213.npy\n", + "(1, 80, 657)\n", + "trebek_2399.npy\n", + "(1, 80, 499)\n", + "trebek_1770.npy\n", + "(1, 80, 479)\n", + "trebek_1935.npy\n", + "(1, 80, 225)\n", + "trebek_1004.npy\n", + "(1, 80, 866)\n", + "trebek_2304.npy\n", + "(1, 80, 500)\n", + "trebek_628.npy\n", + "(1, 80, 649)\n", + "trebek_675.npy\n", + "(1, 80, 466)\n", + "trebek_1292.npy\n", + "(1, 80, 548)\n", + "trebek_1340.npy\n", + "(1, 80, 533)\n", + "trebek_335.npy\n", + "(1, 80, 590)\n", + "trebek_2280.npy\n", + "(1, 80, 399)\n", + "trebek_2071.npy\n", + "(1, 80, 783)\n", + "trebek_1629.npy\n", + "(1, 80, 535)\n", + "trebek_1612.npy\n", + "(1, 80, 778)\n", + "trebek_711.npy\n", + "(1, 80, 481)\n", + "trebek_813.npy\n", + "(1, 80, 675)\n", + "trebek_544.npy\n", + "(1, 80, 401)\n", + "trebek_2510.npy\n", + "(1, 80, 512)\n", + "trebek_1796.npy\n", + "(1, 80, 473)\n", + "trebek_865.npy\n", + "(1, 80, 609)\n", + "trebek_1880.npy\n", + "(1, 80, 440)\n", + "trebek_1080.npy\n", + "(1, 80, 631)\n", + "trebek_2186.npy\n", + "(1, 80, 499)\n", + "trebek_1352.npy\n", + "(1, 80, 608)\n", + "trebek_2340.npy\n", + "(1, 80, 420)\n", + "trebek_690.npy\n", + "(1, 80, 683)\n", + "trebek_2015.npy\n", + "(1, 80, 727)\n", + "trebek_195.npy\n", + "(1, 80, 734)\n", + "trebek_1763.npy\n", + "(1, 80, 588)\n", + "trebek_1974.npy\n", + "(1, 80, 559)\n", + "trebek_1507.npy\n", + "(1, 80, 486)\n", + "trebek_387.npy\n", + "(1, 80, 476)\n", + "trebek_220.npy\n", + "(1, 80, 349)\n", + "trebek_927.npy\n", + "(1, 80, 689)\n", + "trebek_289.npy\n", + "(1, 80, 608)\n", + "trebek_300.npy\n", + "(1, 80, 905)\n", + "trebek_506.npy\n", + "(1, 80, 530)\n", + "trebek_75.npy\n", + "(1, 80, 659)\n", + "trebek_1528.npy\n", + "(1, 80, 417)\n", + "trebek_1499.npy\n", + "(1, 80, 623)\n", + "trebek_516.npy\n", + "(1, 80, 512)\n", + "trebek_1792.npy\n", + "(1, 80, 851)\n", + "trebek_2179.npy\n", + "(1, 80, 450)\n", + "trebek_1325.npy\n", + "(1, 80, 686)\n", + "trebek_703.npy\n", + "(1, 80, 335)\n", + "trebek_2115.npy\n", + "(1, 80, 815)\n", + "trebek_2231.npy\n", + "(1, 80, 613)\n", + "trebek_2048.npy\n", + "(1, 80, 812)\n", + "trebek_755.npy\n", + "(1, 80, 703)\n", + "trebek_535.npy\n", + "(1, 80, 727)\n", + "trebek_1761.npy\n", + "(1, 80, 709)\n", + "trebek_299.npy\n", + "(1, 80, 598)\n", + "trebek_385.npy\n", + "(1, 80, 396)\n", + "trebek_391.npy\n", + "(1, 80, 659)\n", + "trebek_2139.npy\n", + "(1, 80, 584)\n", + "trebek_487.npy\n", + "(1, 80, 437)\n", + "trebek_2351.npy\n", + "(1, 80, 487)\n", + "trebek_1175.npy\n", + "(1, 80, 634)\n", + "trebek_1603.npy\n", + "(1, 80, 264)\n", + "trebek_2310.npy\n", + "(1, 80, 331)\n", + "trebek_502.npy\n", + "(1, 80, 370)\n", + "trebek_434.npy\n", + "(1, 80, 565)\n", + "trebek_1635.npy\n", + "(1, 80, 513)\n", + "trebek_2012.npy\n", + "(1, 80, 888)\n", + "trebek_349.npy\n", + "(1, 80, 504)\n", + "trebek_1218.npy\n", + "(1, 80, 675)\n", + "trebek_1305.npy\n", + "(1, 80, 432)\n", + "trebek_988.npy\n", + "(1, 80, 318)\n", + "trebek_995.npy\n", + "(1, 80, 243)\n", + "trebek_1290.npy\n", + "(1, 80, 690)\n", + "trebek_525.npy\n", + "(1, 80, 553)\n", + "trebek_1169.npy\n", + "(1, 80, 657)\n", + "trebek_2031.npy\n", + "(1, 80, 610)\n", + "trebek_249.npy\n", + "(1, 80, 827)\n", + "trebek_198.npy\n", + "(1, 80, 502)\n", + "trebek_2171.npy\n", + "(1, 80, 624)\n", + "trebek_1862.npy\n", + "(1, 80, 316)\n", + "trebek_536.npy\n", + "(1, 80, 608)\n", + "trebek_2013.npy\n", + "(1, 80, 471)\n", + "trebek_106.npy\n", + "(1, 80, 515)\n", + "trebek_1003.npy\n", + "(1, 80, 321)\n", + "trebek_2201.npy\n", + "(1, 80, 458)\n", + "trebek_110.npy\n", + "(1, 80, 375)\n", + "trebek_1760.npy\n", + "(1, 80, 639)\n", + "trebek_154.npy\n", + "(1, 80, 515)\n", + "trebek_498.npy\n", + "(1, 80, 479)\n", + "trebek_915.npy\n", + "(1, 80, 481)\n", + "trebek_1654.npy\n", + "(1, 80, 693)\n", + "trebek_796.npy\n", + "(1, 80, 406)\n", + "trebek_1184.npy\n", + "(1, 80, 732)\n", + "trebek_453.npy\n", + "(1, 80, 536)\n", + "trebek_1345.npy\n", + "(1, 80, 781)\n", + "trebek_1680.npy\n", + "(1, 80, 344)\n", + "trebek_334.npy\n", + "(1, 80, 629)\n", + "trebek_321.npy\n", + "(1, 80, 553)\n", + "trebek_1355.npy\n", + "(1, 80, 585)\n", + "trebek_854.npy\n", + "(1, 80, 623)\n", + "trebek_1335.npy\n", + "(1, 80, 636)\n", + "trebek_875.npy\n", + "(1, 80, 564)\n", + "trebek_984.npy\n", + "(1, 80, 561)\n", + "trebek_1681.npy\n", + "(1, 80, 357)\n", + "trebek_987.npy\n", + "(1, 80, 437)\n", + "trebek_2257.npy\n", + "(1, 80, 373)\n", + "trebek_1812.npy\n", + "(1, 80, 820)\n", + "trebek_2375.npy\n", + "(1, 80, 407)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_572.npy\n", + "(1, 80, 649)\n", + "trebek_1737.npy\n", + "(1, 80, 486)\n", + "trebek_1837.npy\n", + "(1, 80, 615)\n", + "trebek_912.npy\n", + "(1, 80, 422)\n", + "trebek_575.npy\n", + "(1, 80, 647)\n", + "trebek_1406.npy\n", + "(1, 80, 494)\n", + "trebek_409.npy\n", + "(1, 80, 626)\n", + "trebek_2434.npy\n", + "(1, 80, 446)\n", + "trebek_2054.npy\n", + "(1, 80, 538)\n", + "trebek_1412.npy\n", + "(1, 80, 404)\n", + "trebek_2359.npy\n", + "(1, 80, 890)\n", + "trebek_1285.npy\n", + "(1, 80, 587)\n", + "trebek_1573.npy\n", + "(1, 80, 538)\n", + "trebek_1429.npy\n", + "(1, 80, 409)\n", + "trebek_876.npy\n", + "(1, 80, 670)\n", + "trebek_1952.npy\n", + "(1, 80, 339)\n", + "trebek_175.npy\n", + "(1, 80, 614)\n", + "trebek_959.npy\n", + "(1, 80, 507)\n", + "trebek_234.npy\n", + "(1, 80, 714)\n", + "trebek_1691.npy\n", + "(1, 80, 565)\n", + "trebek_1882.npy\n", + "(1, 80, 804)\n", + "trebek_92.npy\n", + "(1, 80, 425)\n", + "trebek_1980.npy\n", + "(1, 80, 569)\n", + "trebek_81.npy\n", + "(1, 80, 282)\n", + "trebek_2066.npy\n", + "(1, 80, 647)\n", + "trebek_403.npy\n", + "(1, 80, 541)\n", + "trebek_1778.npy\n", + "(1, 80, 752)\n", + "trebek_8.npy\n", + "(1, 80, 632)\n", + "trebek_1384.npy\n", + "(1, 80, 548)\n", + "trebek_1481.npy\n", + "(1, 80, 360)\n", + "trebek_2469.npy\n", + "(1, 80, 427)\n", + "trebek_291.npy\n", + "(1, 80, 393)\n", + "trebek_1879.npy\n", + "(1, 80, 678)\n", + "trebek_2193.npy\n", + "(1, 80, 613)\n", + "trebek_1605.npy\n", + "(1, 80, 505)\n", + "trebek_412.npy\n", + "(1, 80, 466)\n", + "trebek_2043.npy\n", + "(1, 80, 640)\n", + "trebek_1155.npy\n", + "(1, 80, 522)\n", + "trebek_902.npy\n", + "(1, 80, 654)\n", + "trebek_2495.npy\n", + "(1, 80, 383)\n", + "trebek_1390.npy\n", + "(1, 80, 578)\n", + "trebek_414.npy\n", + "(1, 80, 491)\n", + "trebek_1158.npy\n", + "(1, 80, 459)\n", + "trebek_917.npy\n", + "(1, 80, 474)\n", + "trebek_748.npy\n", + "(1, 80, 701)\n", + "trebek_323.npy\n", + "(1, 80, 497)\n", + "trebek_2504.npy\n", + "(1, 80, 487)\n", + "trebek_2563.npy\n", + "(1, 80, 362)\n", + "trebek_1758.npy\n", + "(1, 80, 747)\n", + "trebek_2225.npy\n", + "(1, 80, 424)\n", + "trebek_905.npy\n", + "(1, 80, 751)\n", + "trebek_1820.npy\n", + "(1, 80, 373)\n", + "trebek_1489.npy\n", + "(1, 80, 636)\n", + "trebek_1585.npy\n", + "(1, 80, 308)\n", + "trebek_1093.npy\n", + "(1, 80, 683)\n", + "trebek_123.npy\n", + "(1, 80, 743)\n", + "trebek_2024.npy\n", + "(1, 80, 796)\n", + "trebek_653.npy\n", + "(1, 80, 621)\n", + "trebek_1495.npy\n", + "(1, 80, 424)\n", + "trebek_567.npy\n", + "(1, 80, 440)\n", + "trebek_190.npy\n", + "(1, 80, 730)\n", + "trebek_1898.npy\n", + "(1, 80, 474)\n", + "trebek_897.npy\n", + "(1, 80, 531)\n", + "trebek_2318.npy\n", + "(1, 80, 267)\n", + "trebek_1135.npy\n", + "(1, 80, 445)\n", + "trebek_733.npy\n", + "(1, 80, 414)\n", + "trebek_330.npy\n", + "(1, 80, 521)\n", + "trebek_1753.npy\n", + "(1, 80, 370)\n", + "trebek_13.npy\n", + "(1, 80, 779)\n", + "trebek_708.npy\n", + "(1, 80, 438)\n", + "trebek_1575.npy\n", + "(1, 80, 709)\n", + "trebek_1064.npy\n", + "(1, 80, 562)\n", + "trebek_926.npy\n", + "(1, 80, 696)\n", + "trebek_685.npy\n", + "(1, 80, 424)\n", + "trebek_523.npy\n", + "(1, 80, 822)\n", + "trebek_2202.npy\n", + "(1, 80, 463)\n", + "trebek_1118.npy\n", + "(1, 80, 771)\n", + "trebek_925.npy\n", + "(1, 80, 898)\n", + "trebek_1326.npy\n", + "(1, 80, 603)\n", + "trebek_1955.npy\n", + "(1, 80, 582)\n", + "trebek_438.npy\n", + "(1, 80, 580)\n", + "trebek_1085.npy\n", + "(1, 80, 504)\n", + "trebek_1545.npy\n", + "(1, 80, 913)\n", + "trebek_1104.npy\n", + "(1, 80, 471)\n", + "trebek_2076.npy\n", + "(1, 80, 678)\n", + "trebek_2281.npy\n", + "(1, 80, 398)\n", + "trebek_530.npy\n", + "(1, 80, 972)\n", + "trebek_2190.npy\n", + "(1, 80, 515)\n", + "trebek_1557.npy\n", + "(1, 80, 622)\n", + "trebek_2288.npy\n", + "(1, 80, 637)\n", + "trebek_1827.npy\n", + "(1, 80, 704)\n", + "trebek_916.npy\n", + "(1, 80, 409)\n", + "trebek_482.npy\n", + "(1, 80, 706)\n", + "trebek_2506.npy\n", + "(1, 80, 592)\n", + "trebek_494.npy\n", + "(1, 80, 781)\n", + "trebek_1731.npy\n", + "(1, 80, 432)\n", + "trebek_2350.npy\n", + "(1, 80, 683)\n", + "trebek_254.npy\n", + "(1, 80, 590)\n", + "trebek_1544.npy\n", + "(1, 80, 505)\n", + "trebek_274.npy\n", + "(1, 80, 381)\n", + "trebek_1795.npy\n", + "(1, 80, 590)\n", + "trebek_2230.npy\n", + "(1, 80, 618)\n", + "trebek_372.npy\n", + "(1, 80, 786)\n", + "trebek_2114.npy\n", + "(1, 80, 365)\n", + "trebek_2118.npy\n", + "(1, 80, 807)\n", + "trebek_2526.npy\n", + "(1, 80, 575)\n", + "trebek_336.npy\n", + "(1, 80, 827)\n", + "trebek_1391.npy\n", + "(1, 80, 396)\n", + "trebek_687.npy\n", + "(1, 80, 665)\n", + "trebek_2319.npy\n", + "(1, 80, 528)\n", + "trebek_236.npy\n", + "(1, 80, 839)\n", + "trebek_2137.npy\n", + "(1, 80, 460)\n", + "trebek_1057.npy\n", + "(1, 80, 720)\n", + "trebek_2040.npy\n", + "(1, 80, 367)\n", + "trebek_2099.npy\n", + "(1, 80, 711)\n", + "trebek_818.npy\n", + "(1, 80, 530)\n", + "trebek_1072.npy\n", + "(1, 80, 468)\n", + "trebek_1046.npy\n", + "(1, 80, 497)\n", + "trebek_1302.npy\n", + "(1, 80, 610)\n", + "trebek_223.npy\n", + "(1, 80, 516)\n", + "trebek_1850.npy\n", + "(1, 80, 556)\n", + "trebek_1022.npy\n", + "(1, 80, 551)\n", + "trebek_2127.npy\n", + "(1, 80, 541)\n", + "trebek_363.npy\n", + "(1, 80, 560)\n", + "trebek_452.npy\n", + "(1, 80, 683)\n", + "trebek_124.npy\n", + "(1, 80, 479)\n", + "trebek_1779.npy\n", + "(1, 80, 644)\n", + "trebek_2182.npy\n", + "(1, 80, 298)\n", + "trebek_74.npy\n", + "(1, 80, 716)\n", + "trebek_2113.npy\n", + "(1, 80, 491)\n", + "trebek_2365.npy\n", + "(1, 80, 621)\n", + "trebek_1534.npy\n", + "(1, 80, 422)\n", + "trebek_736.npy\n", + "(1, 80, 667)\n", + "trebek_137.npy\n", + "(1, 80, 629)\n", + "trebek_2067.npy\n", + "(1, 80, 584)\n", + "trebek_946.npy\n", + "(1, 80, 335)\n", + "trebek_586.npy\n", + "(1, 80, 610)\n", + "trebek_2394.npy\n", + "(1, 80, 592)\n", + "trebek_1963.npy\n", + "(1, 80, 689)\n", + "trebek_1636.npy\n", + "(1, 80, 644)\n", + "trebek_2144.npy\n", + "(1, 80, 662)\n", + "trebek_447.npy\n", + "(1, 80, 564)\n", + "trebek_1356.npy\n", + "(1, 80, 848)\n", + "trebek_1616.npy\n", + "(1, 80, 502)\n", + "trebek_2290.npy\n", + "(1, 80, 652)\n", + "trebek_1464.npy\n", + "(1, 80, 406)\n", + "trebek_2384.npy\n", + "(1, 80, 676)\n", + "trebek_1414.npy\n", + "(1, 80, 486)\n", + "trebek_1280.npy\n", + "(1, 80, 590)\n", + "trebek_2536.npy\n", + "(1, 80, 461)\n", + "trebek_2161.npy\n", + "(1, 80, 574)\n", + "trebek_971.npy\n", + "(1, 80, 543)\n", + "trebek_400.npy\n", + "(1, 80, 805)\n", + "trebek_2414.npy\n", + "(1, 80, 543)\n", + "trebek_58.npy\n", + "(1, 80, 736)\n", + "trebek_1699.npy\n", + "(1, 80, 605)\n", + "trebek_2250.npy\n", + "(1, 80, 683)\n", + "trebek_1497.npy\n", + "(1, 80, 453)\n", + "trebek_1505.npy\n", + "(1, 80, 423)\n", + "trebek_990.npy\n", + "(1, 80, 382)\n", + "trebek_1684.npy\n", + "(1, 80, 484)\n", + "trebek_2008.npy\n", + "(1, 80, 473)\n", + "trebek_601.npy\n", + "(1, 80, 601)\n", + "trebek_870.npy\n", + "(1, 80, 608)\n", + "trebek_1546.npy\n", + "(1, 80, 665)\n", + "trebek_1614.npy\n", + "(1, 80, 601)\n", + "trebek_833.npy\n", + "(1, 80, 791)\n", + "trebek_1859.npy\n", + "(1, 80, 694)\n", + "trebek_277.npy\n", + "(1, 80, 689)\n", + "trebek_1715.npy\n", + "(1, 80, 429)\n", + "trebek_2300.npy\n", + "(1, 80, 557)\n", + "trebek_1318.npy\n", + "(1, 80, 553)\n", + "trebek_1519.npy\n", + "(1, 80, 554)\n", + "trebek_1095.npy\n", + "(1, 80, 640)\n", + "trebek_26.npy\n", + "(1, 80, 835)\n", + "trebek_296.npy\n", + "(1, 80, 747)\n", + "trebek_229.npy\n", + "(1, 80, 784)\n", + "trebek_825.npy\n", + "(1, 80, 649)\n", + "trebek_1841.npy\n", + "(1, 80, 654)\n", + "trebek_1671.npy\n", + "(1, 80, 494)\n", + "trebek_538.npy\n", + "(1, 80, 683)\n", + "trebek_2508.npy\n", + "(1, 80, 553)\n", + "trebek_983.npy\n", + "(1, 80, 665)\n", + "trebek_1009.npy\n", + "(1, 80, 569)\n", + "trebek_1024.npy\n", + "(1, 80, 624)\n", + "trebek_1455.npy\n", + "(1, 80, 608)\n", + "trebek_1702.npy\n", + "(1, 80, 707)\n", + "trebek_2505.npy\n", + "(1, 80, 448)\n", + "trebek_1415.npy\n", + "(1, 80, 740)\n", + "trebek_1564.npy\n", + "(1, 80, 292)\n", + "trebek_1428.npy\n", + "(1, 80, 590)\n", + "trebek_741.npy\n", + "(1, 80, 600)\n", + "trebek_2552.npy\n", + "(1, 80, 577)\n", + "trebek_2140.npy\n", + "(1, 80, 662)\n", + "trebek_532.npy\n", + "(1, 80, 813)\n", + "trebek_2205.npy\n", + "(1, 80, 497)\n", + "trebek_2146.npy\n", + "(1, 80, 732)\n", + "trebek_1967.npy\n", + "(1, 80, 570)\n", + "trebek_590.npy\n", + "(1, 80, 735)\n", + "trebek_2496.npy\n", + "(1, 80, 287)\n", + "trebek_162.npy\n", + "(1, 80, 738)\n", + "trebek_1933.npy\n", + "(1, 80, 662)\n", + "trebek_1162.npy\n", + "(1, 80, 429)\n", + "trebek_2491.npy\n", + "(1, 80, 352)\n", + "trebek_542.npy\n", + "(1, 80, 696)\n", + "trebek_1553.npy\n", + "(1, 80, 636)\n", + "trebek_211.npy\n", + "(1, 80, 693)\n", + "trebek_2387.npy\n", + "(1, 80, 458)\n", + "trebek_1759.npy\n", + "(1, 80, 593)\n", + "trebek_2358.npy\n", + "(1, 80, 608)\n", + "trebek_421.npy\n", + "(1, 80, 520)\n", + "trebek_1620.npy\n", + "(1, 80, 528)\n", + "trebek_2455.npy\n", + "(1, 80, 579)\n", + "trebek_2543.npy\n", + "(1, 80, 383)\n", + "trebek_1084.npy\n", + "(1, 80, 460)\n", + "trebek_1960.npy\n", + "(1, 80, 246)\n", + "trebek_964.npy\n", + "(1, 80, 546)\n", + "trebek_1132.npy\n", + "(1, 80, 371)\n", + "trebek_1106.npy\n", + "(1, 80, 690)\n", + "trebek_1181.npy\n", + "(1, 80, 515)\n", + "trebek_2075.npy\n", + "(1, 80, 640)\n", + "trebek_1015.npy\n", + "(1, 80, 701)\n", + "trebek_1667.npy\n", + "(1, 80, 642)\n", + "trebek_1477.npy\n", + "(1, 80, 497)\n", + "trebek_1945.npy\n", + "(1, 80, 437)\n", + "trebek_2104.npy\n", + "(1, 80, 525)\n", + "trebek_1962.npy\n", + "(1, 80, 758)\n", + "trebek_441.npy\n", + "(1, 80, 548)\n", + "trebek_790.npy\n", + "(1, 80, 812)\n", + "trebek_365.npy\n", + "(1, 80, 535)\n", + "trebek_1367.npy\n", + "(1, 80, 825)\n", + "trebek_480.npy\n", + "(1, 80, 569)\n", + "trebek_2332.npy\n", + "(1, 80, 450)\n", + "trebek_2243.npy\n", + "(1, 80, 277)\n", + "trebek_1090.npy\n", + "(1, 80, 742)\n", + "trebek_1441.npy\n", + "(1, 80, 373)\n", + "trebek_1295.npy\n", + "(1, 80, 724)\n", + "trebek_1440.npy\n", + "(1, 80, 376)\n", + "trebek_2516.npy\n", + "(1, 80, 701)\n", + "trebek_143.npy\n", + "(1, 80, 644)\n", + "trebek_2260.npy\n", + "(1, 80, 530)\n", + "trebek_2258.npy\n", + "(1, 80, 424)\n", + "trebek_610.npy\n", + "(1, 80, 714)\n", + "trebek_623.npy\n", + "(1, 80, 422)\n", + "trebek_1981.npy\n", + "(1, 80, 671)\n", + "trebek_1810.npy\n", + "(1, 80, 484)\n", + "trebek_301.npy\n", + "(1, 80, 685)\n", + "trebek_2152.npy\n", + "(1, 80, 750)\n", + "trebek_671.npy\n", + "(1, 80, 907)\n", + "trebek_366.npy\n", + "(1, 80, 618)\n", + "trebek_1065.npy\n", + "(1, 80, 740)\n", + "trebek_1712.npy\n", + "(1, 80, 579)\n", + "trebek_932.npy\n", + "(1, 80, 699)\n", + "trebek_423.npy\n", + "(1, 80, 479)\n", + "trebek_1201.npy\n", + "(1, 80, 685)\n", + "trebek_1717.npy\n", + "(1, 80, 414)\n", + "trebek_1728.npy\n", + "(1, 80, 809)\n", + "trebek_758.npy\n", + "(1, 80, 582)\n", + "trebek_85.npy\n", + "(1, 80, 919)\n", + "trebek_158.npy\n", + "(1, 80, 582)\n", + "trebek_1936.npy\n", + "(1, 80, 722)\n", + "trebek_584.npy\n", + "(1, 80, 365)\n", + "trebek_310.npy\n", + "(1, 80, 543)\n", + "trebek_2298.npy\n", + "(1, 80, 582)\n", + "trebek_1243.npy\n", + "(1, 80, 727)\n", + "trebek_107.npy\n", + "(1, 80, 746)\n", + "trebek_212.npy\n", + "(1, 80, 760)\n", + "trebek_1188.npy\n", + "(1, 80, 528)\n", + "trebek_2219.npy\n", + "(1, 80, 615)\n", + "trebek_2443.npy\n", + "(1, 80, 553)\n", + "trebek_1526.npy\n", + "(1, 80, 442)\n", + "trebek_1437.npy\n", + "(1, 80, 404)\n", + "trebek_2109.npy\n", + "(1, 80, 693)\n", + "trebek_1309.npy\n", + "(1, 80, 502)\n", + "trebek_1884.npy\n", + "(1, 80, 799)\n", + "trebek_176.npy\n", + "(1, 80, 608)\n", + "trebek_2248.npy\n", + "(1, 80, 768)\n", + "trebek_774.npy\n", + "(1, 80, 497)\n", + "trebek_1151.npy\n", + "(1, 80, 681)\n", + "trebek_2383.npy\n", + "(1, 80, 342)\n", + "trebek_688.npy\n", + "(1, 80, 410)\n", + "trebek_2540.npy\n", + "(1, 80, 305)\n", + "trebek_900.npy\n", + "(1, 80, 597)\n", + "trebek_2053.npy\n", + "(1, 80, 443)\n", + "trebek_823.npy\n", + "(1, 80, 536)\n", + "trebek_1583.npy\n", + "(1, 80, 448)\n", + "trebek_717.npy\n", + "(1, 80, 455)\n", + "trebek_1235.npy\n", + "(1, 80, 230)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2158.npy\n", + "(1, 80, 613)\n", + "trebek_1083.npy\n", + "(1, 80, 422)\n", + "trebek_836.npy\n", + "(1, 80, 649)\n", + "trebek_976.npy\n", + "(1, 80, 584)\n", + "trebek_1350.npy\n", + "(1, 80, 657)\n", + "trebek_2418.npy\n", + "(1, 80, 556)\n", + "trebek_1661.npy\n", + "(1, 80, 627)\n", + "trebek_133.npy\n", + "(1, 80, 484)\n", + "trebek_1223.npy\n", + "(1, 80, 815)\n", + "trebek_2441.npy\n", + "(1, 80, 525)\n", + "trebek_2030.npy\n", + "(1, 80, 634)\n", + "trebek_1762.npy\n", + "(1, 80, 553)\n", + "trebek_1774.npy\n", + "(1, 80, 892)\n", + "trebek_2489.npy\n", + "(1, 80, 461)\n", + "trebek_1226.npy\n", + "(1, 80, 596)\n", + "trebek_1868.npy\n", + "(1, 80, 709)\n", + "trebek_1237.npy\n", + "(1, 80, 601)\n", + "trebek_2138.npy\n", + "(1, 80, 487)\n", + "trebek_923.npy\n", + "(1, 80, 535)\n", + "trebek_781.npy\n", + "(1, 80, 451)\n", + "trebek_2120.npy\n", + "(1, 80, 662)\n", + "trebek_1572.npy\n", + "(1, 80, 336)\n", + "trebek_1786.npy\n", + "(1, 80, 764)\n", + "trebek_394.npy\n", + "(1, 80, 515)\n", + "trebek_804.npy\n", + "(1, 80, 533)\n", + "trebek_1520.npy\n", + "(1, 80, 349)\n", + "trebek_1278.npy\n", + "(1, 80, 535)\n", + "trebek_993.npy\n", + "(1, 80, 243)\n", + "trebek_583.npy\n", + "(1, 80, 614)\n", + "trebek_2527.npy\n", + "(1, 80, 489)\n", + "trebek_95.npy\n", + "(1, 80, 321)\n", + "trebek_251.npy\n", + "(1, 80, 336)\n", + "trebek_164.npy\n", + "(1, 80, 618)\n", + "trebek_1842.npy\n", + "(1, 80, 311)\n", + "trebek_2549.npy\n", + "(1, 80, 559)\n", + "trebek_1291.npy\n", + "(1, 80, 497)\n", + "trebek_1509.npy\n", + "(1, 80, 616)\n", + "trebek_456.npy\n", + "(1, 80, 606)\n", + "trebek_2395.npy\n", + "(1, 80, 559)\n", + "trebek_1018.npy\n", + "(1, 80, 355)\n", + "trebek_390.npy\n", + "(1, 80, 508)\n", + "trebek_667.npy\n", + "(1, 80, 525)\n", + "trebek_2341.npy\n", + "(1, 80, 765)\n", + "trebek_1590.npy\n", + "(1, 80, 693)\n", + "trebek_715.npy\n", + "(1, 80, 574)\n", + "trebek_1682.npy\n", + "(1, 80, 590)\n", + "trebek_1937.npy\n", + "(1, 80, 657)\n", + "trebek_648.npy\n", + "(1, 80, 512)\n", + "trebek_1327.npy\n", + "(1, 80, 747)\n", + "trebek_1418.npy\n", + "(1, 80, 481)\n", + "trebek_342.npy\n", + "(1, 80, 652)\n", + "trebek_949.npy\n", + "(1, 80, 445)\n", + "trebek_227.npy\n", + "(1, 80, 760)\n", + "trebek_1609.npy\n", + "(1, 80, 251)\n", + "trebek_464.npy\n", + "(1, 80, 913)\n", + "trebek_1459.npy\n", + "(1, 80, 373)\n", + "trebek_1767.npy\n", + "(1, 80, 752)\n", + "trebek_1559.npy\n", + "(1, 80, 424)\n", + "trebek_637.npy\n", + "(1, 80, 804)\n", + "trebek_1894.npy\n", + "(1, 80, 711)\n", + "trebek_2111.npy\n", + "(1, 80, 569)\n", + "trebek_526.npy\n", + "(1, 80, 675)\n", + "trebek_815.npy\n", + "(1, 80, 784)\n", + "trebek_2361.npy\n", + "(1, 80, 631)\n", + "trebek_1650.npy\n", + "(1, 80, 364)\n", + "trebek_1914.npy\n", + "(1, 80, 205)\n", + "trebek_605.npy\n", + "(1, 80, 634)\n", + "trebek_449.npy\n", + "(1, 80, 410)\n", + "trebek_620.npy\n", + "(1, 80, 693)\n", + "trebek_2197.npy\n", + "(1, 80, 339)\n", + "trebek_1192.npy\n", + "(1, 80, 592)\n", + "trebek_2279.npy\n", + "(1, 80, 184)\n", + "trebek_563.npy\n", + "(1, 80, 596)\n", + "trebek_1741.npy\n", + "(1, 80, 551)\n", + "trebek_1281.npy\n", + "(1, 80, 698)\n", + "trebek_1373.npy\n", + "(1, 80, 760)\n", + "trebek_357.npy\n", + "(1, 80, 654)\n", + "trebek_1423.npy\n", + "(1, 80, 339)\n", + "trebek_767.npy\n", + "(1, 80, 659)\n", + "trebek_930.npy\n", + "(1, 80, 595)\n", + "trebek_2315.npy\n", + "(1, 80, 678)\n", + "trebek_306.npy\n", + "(1, 80, 559)\n", + "trebek_1173.npy\n", + "(1, 80, 737)\n", + "trebek_2091.npy\n", + "(1, 80, 678)\n", + "trebek_2419.npy\n", + "(1, 80, 786)\n", + "trebek_2529.npy\n", + "(1, 80, 546)\n", + "trebek_79.npy\n", + "(1, 80, 938)\n", + "trebek_1068.npy\n", + "(1, 80, 393)\n", + "trebek_1316.npy\n", + "(1, 80, 515)\n", + "trebek_2382.npy\n", + "(1, 80, 414)\n", + "trebek_1344.npy\n", + "(1, 80, 670)\n", + "trebek_2210.npy\n", + "(1, 80, 752)\n", + "trebek_1333.npy\n", + "(1, 80, 528)\n", + "trebek_1263.npy\n", + "(1, 80, 308)\n", + "trebek_1982.npy\n", + "(1, 80, 752)\n", + "trebek_1063.npy\n", + "(1, 80, 678)\n", + "trebek_1854.npy\n", + "(1, 80, 582)\n", + "trebek_2539.npy\n", + "(1, 80, 393)\n", + "trebek_643.npy\n", + "(1, 80, 724)\n", + "trebek_2103.npy\n", + "(1, 80, 424)\n", + "trebek_80.npy\n", + "(1, 80, 843)\n", + "trebek_1828.npy\n", + "(1, 80, 618)\n", + "trebek_1872.npy\n", + "(1, 80, 747)\n", + "trebek_370.npy\n", + "(1, 80, 584)\n", + "trebek_939.npy\n", + "(1, 80, 678)\n", + "trebek_1958.npy\n", + "(1, 80, 448)\n", + "trebek_1950.npy\n", + "(1, 80, 752)\n", + "trebek_654.npy\n", + "(1, 80, 378)\n", + "trebek_477.npy\n", + "(1, 80, 658)\n", + "trebek_2378.npy\n", + "(1, 80, 409)\n", + "trebek_1050.npy\n", + "(1, 80, 684)\n", + "trebek_1997.npy\n", + "(1, 80, 714)\n", + "trebek_2148.npy\n", + "(1, 80, 725)\n", + "trebek_2200.npy\n", + "(1, 80, 570)\n", + "trebek_257.npy\n", + "(1, 80, 416)\n", + "trebek_885.npy\n", + "(1, 80, 452)\n", + "trebek_1284.npy\n", + "(1, 80, 586)\n", + "trebek_2393.npy\n", + "(1, 80, 389)\n", + "trebek_2518.npy\n", + "(1, 80, 344)\n", + "trebek_614.npy\n", + "(1, 80, 549)\n", + "trebek_375.npy\n", + "(1, 80, 629)\n", + "trebek_1207.npy\n", + "(1, 80, 507)\n", + "trebek_1229.npy\n", + "(1, 80, 706)\n", + "trebek_868.npy\n", + "(1, 80, 672)\n", + "trebek_778.npy\n", + "(1, 80, 574)\n", + "trebek_451.npy\n", + "(1, 80, 437)\n", + "trebek_242.npy\n", + "(1, 80, 826)\n", + "trebek_1167.npy\n", + "(1, 80, 391)\n", + "trebek_1076.npy\n", + "(1, 80, 481)\n", + "trebek_2392.npy\n", + "(1, 80, 473)\n", + "trebek_2532.npy\n", + "(1, 80, 556)\n", + "trebek_1134.npy\n", + "(1, 80, 639)\n", + "trebek_1416.npy\n", + "(1, 80, 572)\n", + "trebek_1098.npy\n", + "(1, 80, 484)\n", + "trebek_802.npy\n", + "(1, 80, 645)\n", + "trebek_1206.npy\n", + "(1, 80, 411)\n", + "trebek_1625.npy\n", + "(1, 80, 548)\n", + "trebek_2343.npy\n", + "(1, 80, 630)\n", + "trebek_1177.npy\n", + "(1, 80, 858)\n", + "trebek_173.npy\n", + "(1, 80, 657)\n", + "trebek_1094.npy\n", + "(1, 80, 719)\n", + "trebek_1166.npy\n", + "(1, 80, 352)\n", + "trebek_1921.npy\n", + "(1, 80, 787)\n", + "trebek_247.npy\n", + "(1, 80, 628)\n", + "trebek_632.npy\n", + "(1, 80, 747)\n", + "trebek_1685.npy\n", + "(1, 80, 756)\n" + ] + }, + { + "ename": "IndexError", + "evalue": "Dimension out of range (expected to be in range of [-1, 0], but got 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_items\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch_to_gpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\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 8\u001b[0m \u001b[0mmel_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmel_out_postnet\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgate_outs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malignments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 725\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 726\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 727\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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 728\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 729\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/DeepLearningExamples/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m 666\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 667\u001b[0m mel_outputs, gate_outputs, alignments = self.decoder(\n\u001b[0;32m--> 668\u001b[0;31m encoder_outputs, targets, memory_lengths=input_lengths)\n\u001b[0m\u001b[1;32m 669\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 670\u001b[0m \u001b[0mmel_outputs_postnet\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpostnet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmel_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 725\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 726\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 727\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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 728\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 729\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/DeepLearningExamples/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, memory, decoder_inputs, memory_lengths)\u001b[0m\n\u001b[1;32m 508\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmel_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 509\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgate_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 510\u001b[0;31m torch.stack(alignments))\n\u001b[0m\u001b[1;32m 511\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 512\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmel_outputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgate_outputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malignments\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/DeepLearningExamples/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py\u001b[0m in \u001b[0;36mparse_decoder_outputs\u001b[0;34m(self, mel_outputs, gate_outputs, alignments)\u001b[0m\n\u001b[1;32m 387\u001b[0m \u001b[0malignments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0malignments\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 388\u001b[0m \u001b[0;31m# (T_out, B) -> (B, T_out)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 389\u001b[0;31m \u001b[0mgate_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgate_outputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[0;34m(\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 390\u001b[0m \u001b[0;31m# (T_out, B, n_mel_channels) -> (B, T_out, n_mel_channels)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 391\u001b[0m \u001b[0mmel_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmel_outputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: Dimension out of range (expected to be in range of [-1, 0], but got 1)" + ] + } + ], + "source": [ + "idx = 0\n", + "model.eval()\n", + "tf_dir = \"/home/ubuntu/hg_tune_data/mels\"\n", + "with torch.no_grad():\n", + " for i, batch in enumerate(data_loader):\n", + " x, y, num_items = batch_to_gpu(batch)\n", + " out = model(x)\n", + " mel_out, mel_out_postnet, gate_outs, alignments = out\n", + " \n", + " lengths = np.array([len(mel_loader[i][0]) for i in range(idx, idx + mel_out.size(0))])\n", + " apt = np.array([mel_loader.audiopaths_and_text[i] for i in range(idx, idx + mel_out.size(0))])\n", + " apt = apt[np.argsort(lengths)[::-1]]\n", + " \n", + " output_lengths = batch[4]\n", + " for i, el in enumerate(apt):\n", + " filename = el[0].split(\"/\")[-1].replace(\".pt\", \".npy\")\n", + " print(filename) # filename\n", + " output_length = int(output_lengths[i].item())\n", + " mel = mel_out_postnet[i, :, :output_length].unsqueeze(0).data.cpu().numpy()\n", + " print(mel.shape)\n", + " np.save(os.path.join(tf_dir, filename), mel)\n", + " idx += mel_out.size(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import hifi_gan\n", + "from hifi_gan.env import AttrDict\n", + "from hifi_gan.inference_e2e import load_checkpoint\n", + "from hifi_gan.meldataset import MAX_WAV_VALUE\n", + "from hifi_gan.models import Generator\n", + "\n", + "def load_hifi_gan(path, device=\"cpu\"):\n", + " dev = torch.device(device)\n", + " with open(os.path.join(path, \"config.json\"), \"r\") as f:\n", + " config = AttrDict(json.load(f))\n", + " generator = Generator(config).to(dev)\n", + " for file in os.listdir(path):\n", + " if file.startswith(\"g_\"):\n", + " gen_filename = file\n", + " state_dict_g = load_checkpoint(os.path.join(path, gen_filename), dev)\n", + " print(state_dict_g.keys())\n", + " generator.load_state_dict(state_dict_g['generator'])\n", + " generator.eval()\n", + " generator.remove_weight_norm()\n", + " return generator" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading '/home/ubuntu/UNIVERSAL_V1/g_02500000'\n", + "Complete.\n", + "dict_keys(['generator'])\n", + "Removing weight norm...\n" + ] + } + ], + "source": [ + "gen = load_hifi_gan(\"/home/ubuntu/UNIVERSAL_V1/\", device=\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'output_lengths' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mMAX_WAV_VALUE\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m28000.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlength\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moutput_lengths\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\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 3\u001b[0m \u001b[0m_mel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmel_out_postnet\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0mlength\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mtensor_cls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloatTensor\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_available\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloatTensor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0my_g_hat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtensor_cls\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_mel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"cuda\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'output_lengths' is not defined" + ] + } + ], + "source": [ + "MAX_WAV_VALUE = 28000.0\n", + "length = output_lengths[1].item()\n", + "_mel = mel_out_postnet[1][:, :length].data\n", + "tensor_cls = torch.FloatTensor if not torch.cuda.is_available() else torch.cuda.FloatTensor\n", + "y_g_hat = gen(tensor_cls(_mel.unsqueeze(0)).to(device=\"cuda\"))\n", + "audio = y_g_hat.squeeze()\n", + "# audio = audio * MAX_WAV_VALUE\n", + "audio = audio.unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(audio.data.cpu().numpy(), rate=22050)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(\"/home/ubuntu/hg_tune_data/wavs/michaelrosen9-110.wav\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "melspec = torch.load(\"/home/ubuntu/michael-rosen/wavs/michaelrosen9-110.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "loaded = np.load(\"/home/ubuntu/hg_tune_data/mels/michaelrosen9-110.npy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "tensor_cls = torch.FloatTensor if not torch.cuda.is_available() else torch.cuda.FloatTensor\n", + "y_g_hat = gen(tensor_cls(loaded).to(device=\"cuda\"))\n", + "audio = y_g_hat.squeeze()\n", + "# audio = audio * MAX_WAV_VALUE\n", + "audio = audio.unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(audio.data.cpu().numpy(), rate=22050)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 80, 557)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loaded.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(\"/home/ubuntu/michael-rosen/wavs/michaelrosen7_582.wav\")" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "134400" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(557 - 32) * 256" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([296., 389., 96., 394., 174., 163., 401., 296., 437., 228.])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch[5]" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/ubuntu/michael-rosen/wavs/michaelrosen9-110.pt\r\n" + ] + } + ], + "source": [ + "ls ~/michael-rosen/wavs/michaelrosen9-110.pt" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([80, 450])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "melspec.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 80, 557)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loaded.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 80, 395)\n", + "torch.Size([80, 395])\n" + ] + } + ], + "source": [ + "print(np.load(\"/home/ubuntu/hg_tune_data/mels/michaelrosen9-107.npy\").shape)\n", + "print(torch.load(\"/home/ubuntu/michael-rosen/wavs/michaelrosen9-107.pt\").shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2381.pt\n", + "trebek_979.pt\n", + "trebek_1435.pt\n", + "trebek_1015.pt\n", + "trebek_861.pt\n", + "trebek_1024.pt\n", + "trebek_808.pt\n", + "trebek_533.pt\n", + "trebek_2032.pt\n", + "trebek_2075.pt\n", + "trebek_814.pt\n", + "trebek_1795.pt\n", + "trebek_2355.pt\n", + "trebek_759.pt\n", + "trebek_1919.pt\n", + "trebek_2230.pt\n", + "trebek_736.pt\n", + "trebek_137.pt\n", + "trebek_239.pt\n", + "trebek_1983.pt\n", + "trebek_1258.pt\n", + "trebek_1776.pt\n", + "trebek_1917.pt\n", + "trebek_649.pt\n", + "trebek_2153.pt\n", + "trebek_144.pt\n", + "trebek_1231.pt\n", + "trebek_1455.pt\n", + "2450 tries, 28 fails\n" + ] + } + ], + "source": [ + "tries = 0\n", + "fails = 0\n", + "for pt in os.listdir(\"/home/ubuntu/trebek/wavs/\"):\n", + " if not pt.endswith(\".pt\"):# or pt.startswith(\"michaelrosen_\"):\n", + " continue\n", + " try:\n", + " npmel = np.load(f\"/home/ubuntu/hg_tune_data/mels/{pt.replace('pt', 'npy')}\")\n", + " except Exception:\n", + " #print(f\"np version of {pt} probably doesn't exist\")\n", + " continue\n", + " tmel = torch.load(f\"/home/ubuntu/trebek/wavs/{pt}\").unsqueeze(0)\n", + " tries += 1\n", + " if npmel.shape != tmel.shape:\n", + " fails += 1\n", + " print(pt)\n", + " #print(npmel.shape)\n", + " #print(tmel.shape)\n", + "print(f\"{tries} tries, {fails} fails\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"422, 26\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_pytorch_p36)", + "language": "python", + "name": "conda_pytorch_p36" + }, + "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.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/PyTorch/SpeechSynthesis/Tacotron2/plotting_utils.py b/PyTorch/SpeechSynthesis/Tacotron2/plotting_utils.py new file mode 100644 index 000000000..0983212c9 --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/plotting_utils.py @@ -0,0 +1,44 @@ +import matplotlib +matplotlib.use("Agg") +import matplotlib.pylab as plt +import numpy as np + +def save_figure_to_numpy(fig): + # save it to a numpy array. + data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='') + data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,)) + return data + +def plot_alignment_to_numpy(alignment, info=None): + fig, ax = plt.subplots(figsize=(6, 4)) + im = ax.imshow(alignment, aspect='auto', origin='lower', + interpolation='none') + fig.colorbar(im, ax=ax) + xlabel = 'Decoder timestep' + if info is not None: + xlabel += '\n\n' + info + plt.xlabel(xlabel) + plt.ylabel('Encoder timestep') + plt.tight_layout() + + fig.canvas.draw() + data = save_figure_to_numpy(fig) + plt.close() + return data + +def plot_mel_to_numpy(alignment, info=None): + fig, ax = plt.subplots(figsize=(6, 4)) + im = ax.imshow(alignment, aspect='auto', origin='lower', + interpolation='none') + fig.colorbar(im, ax=ax) + xlabel = 'Timestep' + if info is not None: + xlabel += '\n\n' + info + plt.xlabel(xlabel) + plt.ylabel('Frequencies') + plt.tight_layout() + + fig.canvas.draw() + data = save_figure_to_numpy(fig) + plt.close() + return data diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 7119a5d04..bd0264fc2 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -30,9 +30,9 @@ import argparse import numpy as np from contextlib import contextmanager - import torch from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter from torch.autograd import Variable from torch.nn.parameter import Parameter @@ -45,6 +45,7 @@ import loss_functions import data_functions from common.utils import ParseFromConfigFile +from plotting_utils import plot_alignment_to_numpy, plot_mel_to_numpy import dllogger as DLLogger from dllogger import StdOutBackend, JSONStreamBackend, Verbosity @@ -76,6 +77,7 @@ def parse_args(parser): parser.add_argument('--config-file', action=ParseFromConfigFile, type=str, help='Path to configuration file') + parser.add_argument('--tensorboard-path', type=str, default="runs") # training training = parser.add_argument_group('training setup') @@ -97,6 +99,7 @@ def parse_args(parser): help='Run cudnn benchmark') training.add_argument('--disable-uniform-initialize-bn-weight', action='store_true', help='disable uniform initialization of batchnorm layer weight') + training.add_argument('--freeze-encoder', action='store_true', default=False) optimization = parser.add_argument_group('optimization setup') optimization.add_argument( @@ -230,14 +233,17 @@ def save_checkpoint(model, optimizer, epoch, config, amp_run, output_dir, model_ print("Updating symlink", symlink_dst, "to point to", symlink_src) os.remove(symlink_dst) - os.symlink(symlink_src, symlink_dst) + # os.symlink(symlink_src, symlink_dst) + torch.save(checkpoint, symlink_dst) def get_last_checkpoint_filename(output_dir, model_name): symlink = os.path.join(output_dir, "checkpoint_{}_last.pt".format(model_name)) if os.path.exists(symlink): - print("Loading checkpoint from symlink", symlink) - return os.path.join(output_dir, os.readlink(symlink)) + print("Loading last checkpoint") + return symlink + # print("Loading checkpoint from symlink", symlink) + # return os.path.join(output_dir, os.readlink(symlink)) else: print("No last checkpoint available - starting from epoch 0 ") return "" @@ -249,13 +255,15 @@ def load_checkpoint(model, optimizer, epoch, config, amp_run, filepath, local_ra epoch[0] = checkpoint['epoch']+1 device_id = local_rank % torch.cuda.device_count() - torch.cuda.set_rng_state(checkpoint['cuda_rng_state_all'][device_id]) + if "cuda_rng_state_all" in checkpoint: + torch.cuda.set_rng_state(checkpoint['cuda_rng_state_all'][device_id]) if 'random_rng_states_all' in checkpoint: torch.random.set_rng_state(checkpoint['random_rng_states_all'][device_id]) elif 'random_rng_state' in checkpoint: torch.random.set_rng_state(checkpoint['random_rng_state']) else: - raise Exception("Model checkpoint must have either 'random_rng_state' or 'random_rng_states_all' key.") + print("Loading model checkpoint even though rng states were not loaded!") + # raise Exception("Model checkpoint must have either 'random_rng_state' or 'random_rng_states_all' key.") config = checkpoint['config'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) @@ -280,7 +288,8 @@ def evaluating(model): def validate(model, criterion, valset, epoch, batch_iter, batch_size, - world_size, collate_fn, distributed_run, rank, batch_to_gpu): + world_size, collate_fn, distributed_run, rank, batch_to_gpu, + summary_writer=None): """Handles all the validation scoring and printing""" with evaluating(model), torch.no_grad(): val_sampler = DistributedSampler(valset) if distributed_run else None @@ -299,6 +308,20 @@ def validate(model, criterion, valset, epoch, batch_iter, batch_size, x, y, num_items = batch_to_gpu(batch) y_pred = model(x) loss = criterion(y_pred, y) + if i % 50 == 0 and summary_writer is not None: + _, mel_outputs_postnet, _, alignments = y_pred + summary_writer.add_image( + f'attention_weights_sample_{i}', + plot_alignment_to_numpy(alignments[0].data.cpu().numpy().T), + epoch, + dataformats='HWC', + ) + summary_writer.add_image( + f'mel_outputs_sample_{i}', + plot_mel_to_numpy(mel_outputs_postnet[0].data.cpu().numpy()), + epoch, + dataformats='HWC', + ) if distributed_run: reduced_val_loss = reduce_tensor(loss.data, world_size).item() reduced_num_items = reduce_tensor(num_items.data, 1).item() @@ -358,6 +381,12 @@ def main(): local_rank = args.rank world_size = args.world_size + if local_rank == 0: + writer = SummaryWriter(args.tensorboard_path) + else: + writer = None + + distributed_run = world_size > 1 if local_rank == 0: @@ -389,6 +418,10 @@ def main(): cpu_run=False, uniform_initialize_bn_weight=not args.disable_uniform_initialize_bn_weight) + if args.freeze_encoder: + for param in model.encoder.parameters(): + param.requires_grad = False + if not args.amp and distributed_run: model = DDP(model) @@ -407,12 +440,13 @@ def main(): start_epoch = [0] - if args.resume_from_last: - args.checkpoint_path = get_last_checkpoint_filename(args.output, model_name) - if args.checkpoint_path is not "": load_checkpoint(model, optimizer, start_epoch, model_config, args.amp, args.checkpoint_path, local_rank) + elif args.resume_from_last: + args.checkpoint_path = get_last_checkpoint_filename(args.output, model_name) + load_checkpoint(model, optimizer, start_epoch, model_config, + args.amp, args.checkpoint_path, local_rank) start_epoch = start_epoch[0] @@ -493,6 +527,8 @@ def main(): raise Exception("loss is NaN") DLLogger.log(step=(epoch,i), data={'train_loss': reduced_loss}) + if writer: + writer.add_scalar("train/loss", reduced_loss, iteration) num_iters += 1 @@ -534,7 +570,10 @@ def main(): iteration, args.batch_size, world_size, collate_fn, distributed_run, local_rank, - batch_to_gpu) + batch_to_gpu, + summary_writer=writer) + if writer: + writer.add_scalar("val/loss", val_loss, iteration) if (epoch % args.epochs_per_checkpoint == 0) and args.bench_class == "": save_checkpoint(model, optimizer, epoch, model_config, @@ -548,6 +587,8 @@ def main(): run_time = run_stop_time - run_start_time DLLogger.log(step=tuple(), data={'run_time': run_time}) DLLogger.log(step=tuple(), data={'val_loss': val_loss}) + if writer: + writer.add_scalar("val/loss", val_loss, iteration) DLLogger.log(step=tuple(), data={'train_items_per_sec': (train_epoch_items_per_sec/num_iters if num_iters > 0 else 0.0)}) DLLogger.log(step=tuple(), data={'val_items_per_sec': val_items_per_sec}) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py b/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py new file mode 100644 index 000000000..1d461efee --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py @@ -0,0 +1,88 @@ +# ***************************************************************************** +# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of the NVIDIA CORPORATION nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# ***************************************************************************** + +import sys +import subprocess + +import torch + + +def main(): + # NOTE(zach): this dumb hack will let us invoke train_multiproc.py while + # satisfying the Sagemaker SDK, since Sagemaker doesn't give us full + # control over the command which invokes the training script. + argslist = ["train.py"] + (list(sys.argv)[1:]) + world_size = torch.cuda.device_count() + + if '--world-size' in argslist: + argslist[argslist.index('--world-size') + 1] = str(world_size) + else: + argslist.append('--world-size') + argslist.append(str(world_size)) + + workers = [] + + for i in range(world_size): + if '--rank' in argslist: + argslist[argslist.index('--rank') + 1] = str(i) + else: + argslist.append('--rank') + argslist.append(str(i)) + stdout = None if i == 0 else subprocess.DEVNULL + worker = subprocess.Popen( + [str(sys.executable)] + argslist, stdout=stdout) + workers.append(worker) + + returncode = 0 + try: + pending = len(workers) + while pending > 0: + for worker in workers: + try: + worker_returncode = worker.wait(1) + except subprocess.TimeoutExpired: + continue + pending -= 1 + if worker_returncode != 0: + if returncode != 1: + for worker in workers: + worker.terminate() + returncode = 1 + + except KeyboardInterrupt: + print('Pressed CTRL-C, TERMINATING') + for worker in workers: + worker.terminate() + for worker in workers: + worker.wait() + raise + + sys.exit(returncode) + + +if __name__ == "__main__": + main()