diff --git a/tutorials/notebook/customized_debugging_information.ipynb b/tutorials/notebook/customized_debugging_information.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ee24b878115b48f5cb9b89011220188a47e99dd0 --- /dev/null +++ b/tutorials/notebook/customized_debugging_information.ipynb @@ -0,0 +1,617 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#
自定义调试体验文档" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概述" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "本文将使用[快速入门](https://gitee.com/mindspore/docs/blob/master/tutorials/tutorial_code/lenet.py)作为样例,并通过构建自定义调试函数:`Callback`、`metrics`、`Print算子`、日志打印等,同时将构建的自定义调试函数添加进代码中,通过运行效果来展示具体如何使用MindSpore提供给我们的自定义调试能力,帮助快速调试训练网络。\n", + "体验过程如下:\n", + "1. 数据集准备。\n", + "2. 定义深度学习网络LeNet5。\n", + "3. 使用Callback回调函数构建StopAtTime类来控制训练停止时间。\n", + "4. 设置日志环境变量。\n", + "5. 定义模型并执行训练。\n", + "6. 执行测试。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 数据集准备" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据集的下载" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "这里我们需要将MNIST数据集中随机取出一张图片,并增强成适合LeNet网络的数据格式(如何处理请参考[quick_start.ipynb](https://gitee.com/mindspore/docs/blob/master/tutorials/notebook/quick_start.ipynb)),训练数据集下载地址:{\"http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\", \"http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\"} 。\n", + "
数据集放在----`Jupyter工作目录+\\MNIST_Data\\train\\`,如下图结构:" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "MNIST\n", + "├── test\n", + "│   ├── t10k-images-idx3-ubyte\n", + "│   └── t10k-labels-idx1-ubyte\n", + "└── train\n", + " ├── train-images-idx3-ubyte\n", + " └── train-labels-idx1-ubyte" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据集的增强操作" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "下载的数据集,需要通过`mindspore.dataset`处理成适用于MindSpore框架的数据,再使用一系列框架中提供的工具进行数据增强操作来适应LeNet网络的数据处理需求。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import mindspore.dataset as ds\n", + "import mindspore.dataset.transforms.vision.c_transforms as CV\n", + "import mindspore.dataset.transforms.c_transforms as C\n", + "from mindspore.dataset.transforms.vision import Inter\n", + "from mindspore.common import dtype as mstype\n", + "\n", + "def create_dataset(data_path, batch_size=32, repeat_size=1,\n", + " num_parallel_workers=1):\n", + " \"\"\" create dataset for train or test\n", + " Args:\n", + " data_path (str): Data path\n", + " batch_size (int): The number of data records in each group\n", + " repeat_size (int): The number of replicated data records\n", + " num_parallel_workers (int): The number of parallel workers\n", + " \"\"\"\n", + " # define dataset\n", + " mnist_ds = ds.MnistDataset(data_path)\n", + "\n", + " # define operation parameters\n", + " resize_height, resize_width = 32, 32\n", + " rescale = 1.0 / 255.0\n", + " shift = 0.0\n", + " rescale_nml = 1 / 0.3081\n", + " shift_nml = -1 * 0.1307 / 0.3081\n", + "\n", + " # define map operations\n", + " resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\n", + " rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)\n", + " rescale_op = CV.Rescale(rescale, shift)\n", + " hwc2chw_op = CV.HWC2CHW() \n", + " type_cast_op = C.TypeCast(mstype.int32)\n", + "\n", + " # apply map operations on images\n", + " mnist_ds = mnist_ds.map(input_columns=\"label\", operations=type_cast_op, num_parallel_workers=num_parallel_workers)\n", + " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=resize_op, num_parallel_workers=num_parallel_workers)\n", + " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=rescale_op, num_parallel_workers=num_parallel_workers)\n", + " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)\n", + " mnist_ds = mnist_ds.map(input_columns=\"image\", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)\n", + "\n", + " # apply DatasetOps\n", + " buffer_size = 10000\n", + " mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)\n", + " mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)\n", + " mnist_ds = mnist_ds.repeat(repeat_size)\n", + "\n", + " return mnist_ds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 定义深度学习网络LeNet" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "针对MNIST数据集我们采用的是LeNet5网络,先对卷积函数和全连接函数初始化,然后`construct`构建神经网络。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from mindspore.common.initializer import TruncatedNormal\n", + "import mindspore.nn as nn\n", + "from mindspore.ops import operations as P\n", + "\n", + "def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):\n", + " \"\"\"Conv layer weight initial.\"\"\"\n", + " weight = weight_variable()\n", + " return nn.Conv2d(in_channels, out_channels,\n", + " kernel_size=kernel_size, stride=stride, padding=padding,\n", + " weight_init=weight, has_bias=False, pad_mode=\"valid\")\n", + "\n", + "\n", + "def fc_with_initialize(input_channels, out_channels):\n", + " \"\"\"Fc layer weight initial.\"\"\"\n", + " weight = weight_variable()\n", + " bias = weight_variable()\n", + " return nn.Dense(input_channels, out_channels, weight, bias)\n", + "\n", + "\n", + "def weight_variable():\n", + " \"\"\"Weight initial.\"\"\"\n", + " return TruncatedNormal(0.02)\n", + "\n", + "\n", + "class LeNet5(nn.Cell):\n", + " \"\"\"Lenet network structure.\"\"\"\n", + " def __init__(self):\n", + " super(LeNet5, self).__init__()\n", + " self.batch_size = 32\n", + " self.conv1 = conv(1, 6, 5)\n", + " self.conv2 = conv(6, 16, 5)\n", + " self.fc1 = fc_with_initialize(16 * 5 * 5, 120)\n", + " self.fc2 = fc_with_initialize(120, 84)\n", + " self.fc3 = fc_with_initialize(84, 10)\n", + " self.relu = nn.ReLU()\n", + " self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n", + " self.flatten = nn.Flatten()\n", + " \n", + " def construct(self, x):\n", + " x = self.conv1(x)\n", + " x = self.relu(x)\n", + " x = self.max_pool2d(x)\n", + " x = self.conv2(x)\n", + " x = self.relu(x)\n", + " x = self.max_pool2d(x)\n", + " x = self.flatten(x)\n", + " x = self.fc1(x)\n", + " x = self.relu(x)\n", + " x = self.fc2(x)\n", + " x = self.relu(x)\n", + " x = self.fc3(x)\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 构建自定义回调函数StopAtTime" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用回调函数的基类Callback,构建训练定时器`StopAtTime`,其基类(可在源码中找到位置在`/mindspore/nn/callback`)为:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "class Callback():\n", + " def begin(self, run_context):\n", + " pass\n", + " def epoch_begin(self, run_context):\n", + " pass\n", + " def epoch_end(self, run_context):\n", + " pass\n", + " def step_begin(self, run_context): \n", + " pass\n", + " def step_end(self, run_context):\n", + " pass\n", + " def end(self, run_context):\n", + " pass\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- `begin`:表示训练开始时执行。\n", + "- `epoch_begin`:表示每个epoch开始时执行。\n", + "- `epoch_end`:表示每个epoch结束时执行。\n", + "- `step_begin`:表示每个step刚开始时执行。\n", + "- `step_end`:表示每个step结束时执行。\n", + "- `end`:表示训练结束时执行。\n", + "\n", + "了解上述基类的用法后,还有一个参数`run_context`,这是一个类,存储了模型训练中的各种参数,我们在这里使用`print(cb_params.list_callback)`将其放在`end`中打印(当然也可以使用`print(cb_param)`打印所有参数信息,由于参数信息太多,我们这里只选了一个参数举例),后续在执行完训练后,根据打印信息,会简单介绍`run_context`类中各参数的意义,我们开始构建训练定时器,如下:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from mindspore.train.callback import Callback\n", + "import time\n", + "\n", + "class StopAtTime(Callback):\n", + " def __init__(self, run_time):\n", + " super(StopAtTime, self).__init__()\n", + " self.run_time = run_time*60\n", + "\n", + " def begin(self, run_context):\n", + " cb_params = run_context.original_args()\n", + " cb_params.init_time = time.time()\n", + " \n", + " def step_end(self, run_context):\n", + " cb_params = run_context.original_args()\n", + " epoch_num = cb_params.cur_epoch_num\n", + " step_num = cb_params.cur_step_num\n", + " loss = cb_params.net_outputs\n", + " cur_time = time.time()\n", + " if (cur_time - cb_params.init_time) > self.run_time:\n", + " print(\"epoch: \", epoch_num, \" step: \", step_num, \" loss: \", loss)\n", + " run_context.request_stop()\n", + " def end(self, run_context):\n", + " cb_params = run_context.original_args()\n", + " print(cb_params.list_callback)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 设置日志环境变量" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "MindSpore采用`glog`来输出日志,我们这里将日志输出到屏幕:\n", + "\n", + "`GlOG_v`:控制日志的级别,默认值为2,即WARNING级别,对应关系如下:0-DEBUG、1-INFO、2-WARNING、3-ERROR。本次设置为1。\n", + "\n", + "`GLOG_logtostderr`:控制日志输出方式,设置为`1`时,日志输出到屏幕;值设置为`0`时,日志输出到文件。设置输出屏幕时,日志部分的信息会显示成红色,设置成输出到文件时,会在`GLOG_log_dir`路径下生成`mindspore.log`文件。\n", + "\n", + "> 更多设置请参考官网:https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/customized_debugging_information.html" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'GLOG_v': '1', 'GLOG_logtostderr': '1'}\n" + ] + } + ], + "source": [ + "import os\n", + "from mindspore import log as logger\n", + "\n", + "os.environ['GLOG_v'] = '1'\n", + "os.environ['GLOG_logtostderr'] = '1'\n", + "os.environ['GLOG_log_dir'] = 'D:/' if os.name==\"nt\" else '/var/log/mindspore'\n", + "os.environ['logger_maxBytes'] = '5242880'\n", + "os.environ['logger_backupCount'] = '10'\n", + "print(logger.get_log_config())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "打印信息为`GLOG_v`的等级:`INFO`级别。\n", + "\n", + "输出方式`GLOG_logtostderr`:`1`表示屏幕输出。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 定义网络模型并执行训练" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 定义网络模型" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "此过程中先将之前生成的模型文件`.ckpt`和`.meta`的数据删除,并将模型需要用到的参数配置到`Model`。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from mindspore import context\n", + "from mindspore.train import Model\n", + "from mindspore.nn.metrics import Accuracy\n", + "from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits\n", + "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor\n", + "\n", + "# clean files\n", + "if os.name == \"nt\":\n", + " os.system('del/f/s/q *.ckpt *.meta')\n", + "else:\n", + " os.system('rm -f *.ckpt *.meta *.pb')\n", + "\n", + "context.set_context(mode=context.GRAPH_MODE, device_target=\"CPU\")\n", + "lr = 0.01\n", + "momentum = 0.9 \n", + "epoch_size = 3\n", + "train_data_path = \"./MNIST_Data/train\"\n", + "eval_data_path = \"./MNIST_Data/train\"\n", + "\n", + "net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')\n", + "repeat_size = epoch_size\n", + "network = LeNet5()\n", + "\n", + "metrics = {\n", + " 'accuracy': nn.Accuracy(),\n", + " 'loss': nn.Loss(),\n", + " 'precision': nn.Precision(),\n", + " 'recall': nn.Recall(),\n", + " 'f1_score': nn.F1()\n", + " }\n", + "net_opt = nn.Momentum(network.trainable_params(), lr, momentum)\n", + "\n", + "config_ck = CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)\n", + "\n", + "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_lenet\", config=config_ck)\n", + "\n", + "model = Model(network, net_loss, net_opt, metrics=metrics)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 执行训练" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在构建训练网络中,给`model.train`传入了三个回调函数,分别是`ckpoint_cb`,`LossMonitor`,`stop_cb`;其分别代表如下:\n", + "\n", + "`ckpoint_cb`:即是`ModelCheckpoint`,设置模型保存的回调函数。\n", + "\n", + "`LossMonitor`:loss值监视器,打印训练过程每步的loss值。\n", + "\n", + "`stop_cb`:即是`StopAtTime`,上面刚构建的训练定时器。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们将训练定时器`StopAtTime`设置成18秒,即`run_time=0.3`。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============== Starting Training ==============\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO] ME(10004:11540,MainProcess):2020-07-22-16:52:22.904.779 [mindspore\\train\\serialization.py:308] Execute save the graph process.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 1 step 375, loss is 2.3015153408050537\n", + "epoch: 1 step 750, loss is 2.2981557846069336\n", + "epoch: 1 step 1125, loss is 2.304901361465454\n", + "epoch: 1 step 1500, loss is 0.27651622891426086\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO] ME(10004:11540,MainProcess):2020-07-22-16:52:33.315.965 [mindspore\\train\\serialization.py:119] Execute save checkpoint process.\n", + "[INFO] ME(10004:11540,MainProcess):2020-07-22-16:52:33.325.978 [mindspore\\train\\serialization.py:147] Save checkpoint process finish.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 1 step 1875, loss is 0.263612300157547\n", + "Epoch time: 11051.060, per step time: 5.894, avg loss: 1.702\n", + "************************************************************\n", + "epoch: 2 step 375, loss is 0.22589832544326782\n", + "epoch: 2 step 750, loss is 0.12003941088914871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO] ME(10004:11540,MainProcess):2020-07-22-16:52:40.282.209 [mindspore\\train\\serialization.py:119] Execute save checkpoint process.\n", + "[INFO] ME(10004:11540,MainProcess):2020-07-22-16:52:40.297.275 [mindspore\\train\\serialization.py:147] Save checkpoint process finish.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 2 step: 2927 loss: 0.26415202\n", + "Epoch time: 6953.909, per step time: 3.709, avg loss: 0.130\n", + "************************************************************\n", + "[, , <__main__.StopAtTime object at 0x000001ACBD016148>]\n" + ] + } + ], + "source": [ + "print(\"============== Starting Training ==============\")\n", + "ds_train = create_dataset(train_data_path, repeat_size = repeat_size)\n", + "stop_cb = StopAtTime(run_time=0.3)\n", + "model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(375), stop_cb], dataset_sink_mode=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "以上打印信息中,主要分为两部分:\n", + "- 日志信息部分:\n", + " - `[INFO]`部分信息即为日志输出的信息,由于没有Warning信息,目前主要记录的是训练的几个重要步骤。\n", + " \n", + "- 回调函数信息部分:\n", + " - `LossMonitor`:每步的loss值。\n", + " - `StopAtTime`:在每个epoch结束及训练时间结束时,打印当前epoch的训练总时间(单位为毫秒),每步训练花费的时间以及平均loss值,另外在训练结束时还打印了`run_context.list_callback`的信息,这条信息表示本次训练过程中使用的回调函数;另外`run_conext.original_args`中还包含以下参数:\n", + " - `train_network`:网络的各类参数。\n", + " - `epoch_num`:训练的epoch数。\n", + " - `batch_num`:一个epoch的step数。\n", + " - `mode`:MODEL的模式。\n", + " - `loss_fn`:使用的损失函数。\n", + " - `optimizer`:使用的优化器。\n", + " - `parallel_mode`:并行模式。\n", + " - `device_number`:训练卡的数量。\n", + " - `train_dataset`:训练的数据集。\n", + " - `list_callback`:使用的回调函数。\n", + " - `train_dataset_element`:打印当前batch的数据集。\n", + " - `cur_step_num`:当前训练的step数。\n", + " - `cur_epoch_num`:当前的epoch。\n", + " - `net_outputs`:网络返回值。\n", + "\n", + " 几乎在训练中的所有重要数据,都可以从Callback中取得,所以Callback也是在自定义调试中比较常用的功能。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 执行测试" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "测试网络中我们的自定义函数`metrics`将在`model.eval`中被调用,除了模型的预测正确率外`recall`,`F1`等不同的检验标准下的预测正确率也会打印出来:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============== Starting Testing ==============\n", + "============== Accuracy:{'accuracy': 0.9712666666666666, 'loss': 0.0918103571044902, 'precision': array([0.979007 , 0.9815034 , 0.9695254 , 0.99006449, 0.97207177,\n", + " 0.9750469 , 0.97660037, 0.9832609 , 0.91311292, 0.97466828]), 'recall': array([0.99206483, 0.98383269, 0.97717355, 0.92643941, 0.98305375,\n", + " 0.95867921, 0.9873268 , 0.97509976, 0.97709793, 0.95074802]), 'f1_score': array([0.98549266, 0.98266667, 0.97333445, 0.95719582, 0.97753191,\n", + " 0.96679379, 0.98193429, 0.97916333, 0.94402246, 0.96255956])} ==============\n" + ] + } + ], + "source": [ + "print(\"============== Starting Testing ==============\")\n", + "ds_eval = create_dataset(eval_data_path, repeat_size=repeat_size)\n", + "acc = model.eval(ds_eval,dataset_sink_mode = False)\n", + "print(\"============== Accuracy:{} ==============\".format(acc))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`[INFO]`部分为日志信息。\n", + "\n", + "`Accuracy`部分的信息即为`metric`控制输出的信息,模型的预测值正确率和其他标准下验证(0-9)的正确率值,至于不同的验证标准计算方法,大家可以去官网搜索`mindspore.nn`查找,这里就不多介绍了。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 总结\n", + "\n", + "我们使用了MNIST数据集,通过LeNet5神经网络进行训练,将自定义调试函数结合进其代码中进行调试,展示了使用方法和部分功能,并在过程中展示了训练过程中我们能够通过自定义调试函数输出的数据,来更好的认识自定义调试函数的方便性,以上就是本次的体验内容。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/notebook/quick_start.ipynb b/tutorials/notebook/quick_start.ipynb index 558fd5bc0b20632de3236e16cebec89127e90ab4..8f425891f317ab34f53d1164e076343d890f39a1 100644 --- a/tutorials/notebook/quick_start.ipynb +++ b/tutorials/notebook/quick_start.ipynb @@ -204,7 +204,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -387,7 +387,7 @@ "text": [ "dict_keys(['label', 'image'])\n", "Tensor of image: (32, 1, 32, 32)\n", - "labels: [6 3 5 8 9 0 1 8 1 6 8 9 1 3 0 9 0 4 0 2 2 6 7 9 4 9 1 4 1 4 3 3]\n" + "labels: [7 4 0 6 6 6 5 8 3 5 4 8 5 3 2 9 3 7 3 0 9 2 0 6 3 3 6 2 5 9 2 0]\n" ] } ], @@ -414,7 +414,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAADsCAYAAABKZHxbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydeXhU5d33P7+ZhCwkJCSsYTEESYhFBYxQFDS0L+CGDypSKcgDSmNBtMpi7StXtRZebVVoKW6IQBGkAo9LcSnYR6GyFB5EUR4DAcIiixBCiIQsJDP3+8eZmcxkZpJJMjNngvfnuriYOXOWb865z+/c575/iyil0Gg0Gk34sZgtQKPRaH6oaAOs0Wg0JqENsEaj0ZiENsAajUZjEtoAazQajUloA6zRaDQmoQ2wRqPRmEREG2ARuUdE8kXkgogcFJEhZmvyhYisEJGTIvK9iBSIyGSzNflDRDaKSKWIlDn+7TNbky9EJF1EPhSREhH5TkQWikiU2bp8ISLZIvKJiJSKyAERucNsTf4QkRQRecdxTx0RkZ+brckfIjJNRHaKSJWILDNbjz+a01Yj1gCLyDDgD8AkIBG4ASg0VZR/ngHSlVJtgNuBOSJyjcma6mOaUirB8S/LbDF+eAk4DXQG+gI3AlNNVeQDx432HvA+kALkAStEJNNUYf55EbgIdATGAS+LyI/MleSXE8AcYInZQhqg6W1VKVXvP+AwMBP4CigF3gJigYnA5jrrKuByx+dlDmEfAWXAFqAT8CegBNgL9KvnuFuB+xvSFwla6+w3CzgJjIlErcBGYHKkn1MgH7jF7ftzwKuRphXo49hG3JZtAH4fgVpbYxjfTLdlbwDPRprWOvucAyy7lNqq81+gPeAxwE1AD+Aqxx8U6HazgXZAFbAN2OX4vhaY51xRRF4SkZccn61ADtDe8Up3zNGtj4s0rXWWlWNcrJPAh5GqFXhGRM6IyBYRyY1QnX8G7hGReBHpAtwM/CMCtYqPfQmGYY40rZmATSlV4Lav3UAgPWCz2mpjaUltNWADvEApdUIpdRZYh9HNDoR3lFKfK6UqgXeASqXUcqWUDePp1M+5olJqqlLK2W3vCEQDo4EhjuP1wzhBkabVtQxjqGQI8DbGRYxErb8GMoAuwCJgnYj0jECdmzAMw/fAMWAn8G4Axwy31r0Yr5+zRCRaRIZjvILGR6DWBIyeoTulGO020rQ2lZbUVgM2wN+5fS7HuJCBcMrtc4WP7/72U+H4/y9KqZNKqTMYT6BbIlCrC6WUTSm1GegKTAngmGHXqpTarpQ6r5SqUkr9FeN1q6HzGladImIB1mM8yFpj9ELaYswJNERYtSqlqoFRwK2OY88AVmPciBGlFeP1uk2dZW2A8wEc07T7qpG0pLbarEm4C7g95UWkUzP25YFSqgSjAQcrVVvItPohCmioV+mPcGtV+H6NbohQ6kwBugELHQ+KYmApgT2AfRHSc6qU+kopdaNSKlUpNQLjDWNHE3cXSq0FQJSI9HJbdjXwv03cX7jbalOJ2LbaHAO8G/iRiPQVkVjgqWbsyxdLgYdEpIOItAUewZhpbgoh0+rQd4+IJIiIVURGAGOBTyJQa7KIjBCRWBGJEpFxGN4l6yNJp+ON5xAwxaEzGfhPxzGbQkjbqohc5Tin8SIyE2M2fFkTdxfK83oBo6f2tIi0FpHrgf/AmIhrCqE+r1GO/VoBq7PdRpLO5rbVJhtgx0D+08A/gf3A5qbuC0BEXhGRV9wW/R74H4yndj7wBTA3ArUqjOGGYxgzps8Djyil3otArdEYM8pFwBngIWCUUqrRvsBhuP53YkymFAEHgBrg0absOwxa78WYeD0N/BQYppQKZA7ADK1TgTiH1lXAFKVUk3rAYdA6G+P1/3FgvONzIPNA4dbZ5LYqDrcJjUaj0YSZiA3E0Gg0mksdbYA1Go3GJLQB1mg0GpPQBlij0WhMQhtgjUajMYmAfOqGWe6OKFeJj+1rfAYOtBSdoLU2h0tBa0vRCVprc6hPK+gesEaj0ZiGKQmuC58dRJf+Jz2WHTnajszJO82Qo9FoNKZgigHu0v8kG/vUJgt67mxP3vz7iLBqODHzOsqyLza4Xrd1FuLebWpYv0aj0fgn7Ab49LTr+HmakXrgd0VXALD2jVzSFm4Nq47U4Sf4uk/DGeNu6HoHR/teB0CbQkXy8m2hlqbRXHJY4uM5+qu+2GOM7102VmLduMtcURGAHgPWaDQakwhbD1hiYjh3dz9+8/BKxiQYOaGX7TR6lpnPh7f32xj+deU7cKXxecbJ/uwoG0j829vNFRUAURnpnL6xc73rJJyoptX60I67+9PRbtc57LvzQ3rsSwl1fV9KMgMpCGMQjmsbKNb27Tk5phfrp/yRrlFGWt1sNZXuG83V1RDldw6kMsl3H9VarUhe8wWqqkk5l1yExQBbEhMpz81m1dzn6RFtXIAN5dG0+i46HIf3yZGj7djRq5oBMbUaTtsusKiktpbmmKTPyYxu7fr+QuddzHmqnM/ejg2r1kCw9OlNTWrtDVo4NI78vPqru+TuGdW0RJQNYO2VQXVaUr06sl+dSvemJpcMIu5a6xK16wD284HkKg8tlj69OTGrit0DlgW8zfjDuZwp7oPauSd0wgKk+oqufPHESwQ/93pokKgo7AP7cO/cdeQlnfC5Tv7FcmZ8PArbqdPNOlZYDHBN/8vZ9Ooi3C/Ar974Bem/M6/nmzl5J/e8OI0Pbp3vWjbv1HCODrzg+r7m3clsvOZ12loDqS4TXiQqCktqiuu7fcF5Pu79NxMV1ZL/eAqHbl5c7zq2OIUl0aiEY4aRs6amQFQU+55M4uBPlvpcZ9jYSUTvLoSYGM8famqwFZ8Ng0pDp33BeXb3/qBR261I38hzy3ry6dAMbGfOgM56GBASFYUlM4MFb77o0fkKFaZ4QUQKWY9/w4ynR9UuqKnBSJ5v0GXiCXIWPuj3BjUT+8A+zF9Z27PsFmXBKADbMtg87nl+nDgdgF4Phn9Ip8uHVUzv+D6drFBf+bbjy9L4W9/XPZbNOzWMowNDq89Jlw+rmN/lQ5pybR9uu5deW0+x6LpB2IqKgi/uEsQ+sA8L3nyRnlGBD/c0h5Ab4PI7B3Lv3HUey7IXTSVjyVFqQn3wBrCfPw/19L5s50qxV1nDqKh+Tk8zxszvyvuEDtEbyG7VuJ559qKptOpbwu4Bq0IhD4CCxTm89ZOXMXK/GywqTWPlY7exbOE81xBUB2tr/nbLQgA2fHUl7x29ipTbCnztMqhYU1Po8mEVc9M20MHacA+nbXyF13m+LK6Yo2F62F0WV0yCpWnHipFobo4vYf+nhfz3xEERMRwRyThtVd2eb4+/57k+H7p9UVCPGXIDXJlk8RhHyV40lYzlJ6j5NpCahRp3KlON/2e329vgujNO9udfCz27aRmbTlD9cTLXZhr1QhNOVAOHg6avYHEOS4cu8RhXn3GyPx+v/DFpjx6hvdWzuTnXGxCzlzFJn3P3u5PpMvEEtnN1C/cGB0uf3tgXnGd+lw9JsPg3vsdqyhj5h8fo/M1+al64jGGPjeTj7HV+148Usj6b4Pq8b8hywDDCs1IOsntBN47/LidiJuYikbq2CiDjnQfoveh7Do9qG5JjhswAV4waAEDyeE9D2/XTCmoKD4fqsEHlxMzrmJiz0WwZAJy9bxA/vvlrn7/1+Hsesd95Xso2hYqUOj7LNYAUQsqW0Gi8f8BmcuPsAEw6OgSAb17qQ8cjFfxj5gc4X6OzPpvAdZcdYmn3z1zbZka35m99X2dGzCiv/QaLmtQ4xzi5Z4/SqfXf/zDcXSxV0H3pl9jKy2m1voiCMTmQHTJZPrEkJrLv2Sv4feJC3N8m6t0mP4EuGysByGKCywiDMSY87LFEKuIGhDWwSF3fl9OPVnr/0JQysGGmx9/z6L3oe85ck+z33msuITHAFaMGwBRjzMnZcyixlZOz6UGyTpRSPGEQiUerTHfErhg1gKK+/k/BfaPXMyvlYBgV+efM9dUeBsudy1dVY9kUWdF6G/83C4DM5duw9sqgx0eTXb/1WlLDnqw+THK82fn7u4KJ5epsCsZ6GrJh+SM5cLgj7bYYy7svqZ0UtodcUf1IfBwf3DrfY/jDGbjkdN+0xNjYeeOLHpPEznvqsuq+XB0z1mO46ePsdWT3nUr3huOPgkZJZlyjvDfMwJbbH4Dvb7rg9dvhO9ry45u+9mijO6qquefDR8kq/6bZx9aBGBqNRmMSIekBfzvSzqEr3/FYdkHZabMtjqLBsdwwbTvvH+hDmx6DXL/HltrDGuBwcUQOMQ+dJL+RY3uZsSd5f/zYoDhhB8rFETlcnn7K7+/HhsaRkGGcy7YFFQDIli/Dos0fTr0XRxjjjpn3F3r83pa+bD3Sw/gShh7wmf7JHLr9ZY9l51Z0JXNpw6HlCfmteG5gTwCujTvE6zsGk0noxlKt7dtzcvTlJFo8++GuwKX7jWNbk5PIXXY/a/otNiaO3DzNZMuXpJX25qYFt7I2879cE3n27DLU9X1d65hGBHnFHb/RODf7hnj6q/uacNtYYWHSp1PIfHB7UN6Sgm6ALX160ybVuyvfNSrB4Yxt8ELnXTCk9vdFpWmsKTYS8oTDAV7NONOkiZUxCaVcO/d5JpZOJ35jfsh1Sk4fujx5gBXpG/2u4x7ocPWOsQCklfbGvqfhybpg8t7Rq1zBK85zO/7JXE5V9vNa9/Sjlexzez0+bbvAvFPDHa6AwUd83PC+lvmi23vf8dLlPwXg+qsKuPwNG+r6vli270GFQK+/wAXnfWXpY1xb27lSOo0qZfVX1/icmLXv2Yt1bAe+3W4nu5WxbN+Q5fQoM4aDMkM0F+BOoOe4pfDUwduDmrUx6Aa4Yl4lu+tJcnOouoz21igv15q8pBPkrTL8bYeNnYRl0xfBltZojtWUcd5uIdVqtCKn21KP6AQ2vbqIGx/II27D7pD2hAcv2RmQ14MT55hf7rxRxAwPlSrfpNxWwN11gldWpG+EVRsb3PavpVdx/LZ4bGfPhFakG9WtBUt8PPby8nrXMwJL3HpDqzYakVADmx8J1Ric1/amBbdivTvFFQxypCKV/IvlWHwl97Mr9lV3ICO6hBgxL/I0UrEkJmKLq/8pcdp2gWKbMWtYUh5Hp2AeP4j7CoiJ06YzuuCucB+2SYz8w2PMGDiKwStnMnjlTK/fly2cx7m7vXt3P2S6TDxBzqYHG73dw233krd1G9Z27UKgyjfrfv1Hjv6qb9iOFyzWZv4XXT6sfegfvyWGGQNH0f3P3kMKtjNnWHTdIBaU9A6nxBbDvmevYPO459k87nm/6wxeOZMZA0cxY+Aoukz0HZrcVMISCbeoNI01vzSGF+J35cOhLgxLneT6/VgAeQuCTdz0WA8Nvuj8zX5sRUX0etF4f8uunOqhs0d0Avao0PjTOAMG8tpuAeoPGOj/9BSumJBf7zBFuGhq8EqMRJMVfRosoTmf7T44QP/YKez6be04cNeoBObf/xoPJRiv5OlPtIxUowmWWI9gkHrDopXCVlRElT1yer+REogFoGJtfgNy+j89hdT8SnoVfktNiN50gmqACxbnsLTnEo9lM072Z8fca4nfZEyw2QH27PXoejsnkMKJvY4GX9gc/zuDRjKWR5GNpxFWofJnjIpiesf3fTaOukEWnd4/wLE7k0MkpHEUPjuIOYNXeyxbXZbEc8/83O82xTl2Cu94lW5RFuyrorE8HPzxa1tREan5Xb2WD4+v5rejDb2vXTvEqzKLv79n3tO/JPlcaIbJor85Rr+5U1n369rsYXUZk/Q5/9wwDjA6E+Ee72+IcxOMe3rIQ94T6wlHVIsIxErNr8Sy6YuQPiiCaoDdHfGdfF7c3ZT0jWfvG8SZ66sBYxY7LQgpL2sKD9P107aQ1/C6zUWdL2P0qzOZf/9rDI83/g734Ab3IAvjQRH6xCGB0KX/ScYlFru+P3e2J2++MoIOS+s7/4PgDqNn94/eHzAsdVJIxsZaFRaRuXwKm8c97/Fgc+od1+dddvSq5mevT3H9Nmfwao+/B6CgsjNJK/4dsol8W1ERndcK52d5ngXn9d96pAf7hix3VZVp7PmamGNci7Uzc4NyX/ji+wyjZ/JC58hNuu4v0Oq07QKDV840er4h1mBaMh73IAh7dlnQ93/m+mpXRq7nBvbkzcoRdGhm1Q1fzvyhwl5eTtdntvJQwmQudjIMsDNgoG6Em3uVkUjBzGon/qj59hg955by48TpqFgbcwa/42VcB8REN5jJzWzsh1rTo2yyKxCjsTzZ3ggg+HR4Jvgf+rzkSR1+wnUu3Cm2CZfPPxiyYQd3dCCGRqPRmETIe8DXpB5lx521VSScWeaTxx9rdBBEU5mVcpDLHl7JcxeMccj27x8IOD2feyWC4hw7h25/NWQ6fVHfxJCvKiORQqRWO7GfP+9Kf/nUs2N4rf9Jbk0z4vwjJewcgKoq7vnSLciC2pDtGcMusGPutSR+sp/cZfeTVlzRqKCAleeNrE7Hd3UmI4jJmDy4xPx/Q0VQDbC7I76TFzrvYtHc71xBFvVlma9S1Swo6Y31QnWzr1+r76LZUG68sg+Pr2ZMQilj5hoz4P1jpvickPHF6Ucr/cayLypNI7Y0fFkDoroZmi9mtDf+bxPtUWXEbCSnD10TGj+5YpazfsbjxsPtzWlG27zM8SBztsP/TPoqoJSVoaC+IAvnPbV28nA6j96DvZ5gEGd1hw7RG1zLZm++A4DMx0Pj9WHtlUFl53o0aePsIqgGOOW2AvI2jPMoOQ+eQRa+KLNX8m2NnX3VHfh0aAaqqPl5S9Of2MavLv4CgPwHPF3c3F2RmoJN2TlYU8HaycOJ3xLaCUZn5QaA/Q92A6Bggrt+T+NbYjOCCoLtMB4I7kEjlhhjatCanOQ3vaQl3gjWqG5tbmos59zAvHNjuXLOPFc7LHi/E/O7/HeT8/EGgyMVqZTZK30GLuW++SKP3DwJe0Ghz4i8cFd3cOIVuKLxS0RUxBhdcBeWsdVgV0b5lAjnYE0Fj9w8CUvBnpC/aTkrNwCuiLz6PB6cQRBZ0wpdbnRm4Jwcyl12P51G+TbAziCI9VP+SCTUC0te8wUzPh7laofHb2nL6DV38Y9GlgMKJsdvifGroWdUHH/6aCnTfv6gz7wO4a7uoGk8QTfAgQQ4eIkorsB2Kvh+jBlLjgIwbOMkirNjm93zHX84l1O/6YHUKMP4hipvQU4fBi8xfFHz2m4J+DW4x9/zyH7BeICFKql5fWy+L4fxCzqxIn2jKxR5Tb/FrP7qGo5UpHL8lhiK/tqO/+j+FQAD4l8DcPm6HqouY+K06cTvyjclHaSqqvIILbYVn6WqJt0EJbXYis9iebg3V88Z61XJxCoWMqNbM3rxBk5Xt/HatkP0Bp/VHVxtJHSyNQESdAMcSICD1zbBFuHA6ext+fYYnb5pz7VVUxrYon4STlTTapNhGEPZ87W1jnYb92vY+GYvmkrCEUXvXeew7S9scP1QoXbu4fjvchj2WKIrGU9mdGtmt9tLmb2S0WvuYmXPpT5fh13BDRu+wB6mLHMtBfuevXR8ri9ZDxsVL9wTrQOOOZWGQ2Sd1R3MbCPZi6aS8a8TEREFFwlExBBEOLAVFZGy9NIoTPjc2Z4sWTvC9T3j9aPUfHvM9CTiAK3W76QibgA3TDEmev7lSEvqDLJwf6C4V6KIPQMdVmyNuMnzihWdmTR1iEdC7uGJX7PkxWlkPf5N2Co6y5Yv6RZtJA6vW+0iEJzVHey780Mhz4Nu6yxkfzvV52/OthqpbCiP5tHXZ9L9fHhSdf5gDHBLIvpEqUcFibok5Leiu5t7V6T1JuLe3UEFRkmqHiP9/x2+KlFEGsnLt7EnapBH9Y4BMdF8cOt8o6J2mAwweFa7cKaUDJTsF86Erecb9+4Ov1U3IqmtFm9Io8e3nuex1XfRpD+zNWydGR2IodFoNCahe8ARiG1/oVcFiZaGs/BjZhjrj4WKlCXb+KbGSC6TO94IYigpj6NLVXBTEwaKbPmy0cnU9YSbN6HKg9EYtAHWaAIg2Zl/wzH02glt1DTNRw9BaDQajUmIUpE276zRaDQ/DHQPWKPRaExCG2CNRqMxCW2ANRqNxiS0AdZoNBqT0AZYo9FoTCJiDbCITBORnSJSJSLLzNbTECJyj4jki8gFETkoIkPM1uQLEUkXkQ9FpEREvhORhSISkf7gIpItIp+ISKmIHBCRO8zW5IuW1FZFZIWInBSR70WkQEQaF9McRkQkRUTecdxTR0TEf2ltk2lqW41YA4yR3mkOsKShFc1GRIYBfwAmAYnADUCkhrK9BJwGOgN9gRsB35lTTMTxUHgPeB9IwahFvUJEMk0V5psW01aBZ4B0pVQb4HZgjohcY7Imf7wIXAQ6AuOAl0XkR+ZK8qZZbVUpVe8/4DAwE/gKKAXeAmKBicDmOusq4HLH52UYN/tHQBmwBSOA6E9ACbAX6BfA8ecAyxpaz0ytwFbg/kA0RoDWfOAWt+/PAa9Gmlagj2MbcVu2Afh9JOlsaW21zn6zgJPAmEjTipE27yKQ6bbsDeDZCNTa6Lbq/BdoD3gMcBPQA7jK8ccEut1soB1QBWwDdjm+rwXmOVcUkZdE5CVfO2kkYdUqIlYgB2jvePU45nitD6QMgRnn9c/APSISLyJdgJuBf0SgVl91igSjsUeSzuZgilbHsnIMo3IS+DACtWYCNqVUgdu+dgOB9IBbSlsN2AAvUEqdUEqdBdZhvLoGwjtKqc+VUpXAO0ClUmq5UsqG8WTq51xRKTVVKRWMV+Fwa+0IRAOjgSGO4/XDuJCRphVgE0Yj/h44BuwEAkmZE26tezGGSmaJSLSIDMcYLomPMJ3NwRStju+JGO31bQxjE2laEzB6sO6UOnRHmtamttWADfB3bp/LCbyA1ym3zxU+voeiEFi4tVY4/v+LUuqkUuoMxpPylkjTKiIWYD3GTdca48neFmP8OqK0KqWqgVHArY5jzwBWYzw0IkZnMzFNq1LKppTaDHQFAikVE26tZUDdOkttgEASMLeUttqsSbgLuFl4EQl3Ed7GEDKtSqkSjBMdrKQaoTyvKUA3YKFSqkopVQwsJbCHhS9C2gaUUl8ppW5USqUqpUYAGcCOJuxKt1X/RAE9m7htKLUWAFEi0stt2dXA/zZxfxHZVptjgHcDPxKRviISCzzVjH15ISJRjv1aAauIxDbDXSqkWjGM2EMi0kFE2gKPYMyINoWQaXX0zg8BUxznNxn4T8cxm0Ko28BVjuseLyIzMTw3ljVhV7qtGjo7ONwlE0TEKiIjgLHAJ5GmVSl1AeNN7WkRaS0i1wP/gTER1xQisq022QA7BsefBv4J7Ac2N3VfACLyioi84rZoNka3/3FgvONzIOOqZmj9PfA/GE/tfOALYG6Ear0TY4KiCDiAUSXm0QjVei/GJNFp4KfAMKVUoyt26rbq0qowhhuOYczsPw88opR6LwK1guEeGYdx/VcBU5RSTeoBR2pb1ekoNRqNxiQiORBDo9FoLmm0AdZoNBqT0AZYo9FoTEIbYI1GozEJbYA1Go3GJALyVRxmuTuiXCU+tq/xFXvdYnSC1tocLgWtLUUnaK3NoT6toHvAGo1GYxoRmYjbDNT1fdl/n+fp6LWkBtnypUmKNBrNpc4P3gDbcvsD8O2UGg4NWezx27Wbp5CyxQxVmkjg9LTrqGznvTz2DHRYuDX8gi4Rzk0YxPcZ/t/MM14/Ss23DeaxCQlR3bpSeH93v7+3KVQkL98WtOPpIQiNRqMxCVN6wBdH5FCWFu213FqtSF7zBaqq0eH+Teb4jbEA7BsSjPzaocHf+apLu13nsO/Od323tm9P0W2Xu7532HSSmsLDoZB4SSExMZy7ux+/eXglYxLqpqSFOWd689nCWBOU1VL32gaCmdffeU5t0cIN07bzQuddftfNZioZy6PCrjUqI53CCWnk5/m3BTNO9mdH2UDi394enGMGZS+NQHL60OXJA6xI3+j1W/7FcmZ8PArbqdMh12Hp05ua1DgqO9f4/H1RaRqxpfaQ6/CHREVhH9gHFSV+z1ddevw9j+wXMowv587z3V2Xs+u3L7t+H/B/p9BWG+AGsSQnsXTOPLJbNZhPO2xYe2VQnZbk+l6UHetxbQPBrOtvSUykPDebVXOfp0d0w6l58/NeYsDh8Gh1P6+FQ+PqNb4AL3TexaK537GmeAQAUbsOYD8fSIpi34TPAItgbdeOocu2MSvlYNgO64+KeZVs7PM3r+U2ZedgTQVrJw8nfktwnnJNwZKawvyVL/k0AmX2SopsNV6N+dDti+iZMAmANts68cUTtY3pUHUZlprwe+hITAyW5KSGV6ypwVZ8NvSCWiDW5CT2PZnEwZ8sNVtKQFgSE5H42opcFwaks+nVRdTNZ15iKwfgOxvEij0g4xxs8h9P4dDNi+td57TtAsU2Y8w60WInL+kEeauMazFs7CQsm75o8vHDZoCt7dqRt3UbN8eXYFTwiUwO1lTwyM2TsBTsCVqG9WAzuuAuKuZ3cTRqT3be+CIAF26w497gJ06bTvKGL8L+N527ux9L58xrcL15p4ZxdGAYBLVAji9LY+c1LxJAhZuIYN+zV/DBrfNd32PFsy06ydn0IABZM467GenIY/DKmVw+3+g0nhx9uUfHprmErwdsEbKiTxMj5jeis+9nsjJrKUZVnloWlaaxdvJww/jW+B6aMJOrd4wFIG22Iv5IPsPGTvL4/fSjlewesAow6gyB0fOdOG068RvzsYdxbP30tOsA+M3DKwN6lb8srpijmDuuCsYQ2dBl28iIjpxOQtv4Ctpam3bfOK9/q++raffNAWxB1laXgsU5vPXThQ1ec2O47AwAtlOnafV9F4/fZ/7fN3kmYVxIvU0KFufw1k9exl+HsP/TU0jNr6RX4bfUOIZFoy80tXiIb35QbmjW5CSOL0tjzZWLyYz2NL4zTvbn45U/JuXJExhlsvxTUh5Hl4knsJ3znqAJFvZzpUyaPZ3pv13lmgh6LHsDAK/NG8KRo1lkTt7pWr/w2UE8lf13r/1UKgutdxzG1oxxqsZyYuZ1TBomWeAAACAASURBVJi4HsDnJJYvxiR9zpp3J4f8vDaErXW0Y4gscgywL1aXJfHcMz93ffc3seW6/qdOh9z4AlzW/QwDYvyfu+xFU0k4oui96xy2/YV+1xuTUMqTqaFQaFCwOIelQ5f41HqspoyRf3iMzv+1H1tREe5dMVXHe67jM4c4/rscWq3fSVMImwFW58sY/epM5t//GsPjq71+31AezaOvz6T7+RAGPsTE8Le+r3sZX4D+CUf45w1ZbOzTcIHgEls5OQsfJOt3pfU2ouagqqpIWvFvnkkex5FfrmdWykHGJRYDMK7Pu8zp1JvPHD3Gw3MH8dQdq12/Azx3tidL1o7AUkVoz2kdTsy8jtH3bmz0OH9mdGs2XvN6yM9rS6RiRWcmTR3C0u6fAca1ffOVEXRYavQOD88dRP+EI17bheWecuPw3EH89rLVPn87bbvA4JUz6eXw8Q1oerveIN6mYUlMZN+zV/DWTxf6NL7GOXuM7ku/xFZe3uD+VqRv5Nq0bFKaqCdsBtheXk7XZ7byUMJkfjva01isPJ/K02vHkP7M1sAuTAgYl1jMOMfre0O0tcZz8CdL6VGWR++XYzxcv4JNh4VbWR47gvJ7N/Jk+29cywfEH2TlU78A4C8/q32o/a7oCgDWvpFL9+eNGzRc5/T0NKPnW9f47qiq5mefeBbenZiz1ePvgdrzOuy1SVj2h1xuiyF5+Tb2RA2ix/VZACTkt6L7e0cpfMoY5nG//k7MuKfuHfmpx33tTrFNuHz+QdervFlIfBwf3Drf5xCJGedMB2JoNBqNSYR9DLjD53Z23XSZx5PytSNDSH8ieOF9wWLGyf58XlwblnhN6lGPcbZDty/i2u1TSGlqTeEASXt+K2vJJX6iMYk2K+Ugw+OrvXwWnzvbk7Vv5Lq2CTd35X3i1fvdWGFh0qdTPMarL47IYXN6T6jTAzabqIx0CofGNbyiCaQs2UbKEuNzVEY6hfd393n9PzhxJQDHd3UmI0z3lDPIIjPW9xtkQfUF7vlyMl2qTgS8zxkn+9OmMLw+O/XZIcvV2QAU5wS3bxw2A+wMLLh37jrykgK/EOGmSlWzoKQ3VfZodsy91iPiZcedA1k09zsP/WWXCR26dQ157Hra81tZ0tpw/p71gLcbzOqyJN58ZQRpJuQocF7bDtEbvH576uDtZE7eGVBgifPcWy9Um+ICWHRD5wYd8QuqL/De0atIoSBMqrzxp3PJmhF0/51x/TM4HDY99QWuFFRfYNzXk+g0Kr9Rk4Cf/WUgbYOYc8EfG8qj2VFueDYcOdqOzDrnzRmwVTDWGC8+dPurXvuQZjTWsBlgX4EFTkfskvI4OoVLSD1UqWo+Km/Lp0MzsBUVEY9nIEb829tZe2o4uW++SM+oOKxiIT/vJbLVVLr/LrQG2JKYiC3O/5V+5s/j6LT0S1PG0Ou7tuXV0cR37ACpySx480WfE6BOCqur+fSnPVGn9oRcc1PJ2zeOlNvMM77+OFZThuWi2SpqcV7/u7+YTKdR9c+RSEwMF9uY43Uybe1kl49vNkehYweP3+0LzvNxb++ALSfNDXAy1Q3N5Yg9rTAsLjINsaCkt2F8z5zxu45l+x4euXkSf/poab3GJNjse/YK/n37845v3sdd9+s/MqLNY3R9JjKydDmvbfK/Ynlh+1+xiqJnVGS+3l8KjPyDMXNvXvC8J425t8/d3Y9Vc5/HV7BGqNk87nmK7/HvbtEtygL1+Kc3N8ApLAbYl3O7hyO2iX6f7lTZo7EVFdW7jqqpgeJz2Oo6BIYQp3N7B2ut4V1UmsbKx25j2cJ59IhOoGtUAvPvf42HEiYDmD6mvup6I6rp8IB2EZVToS6H5w7i3pGfApAZ+6bJappO9AWFPQC3qWDjL3DFXmUFAru37VFiShgyQAdrazpYm759q++rm5U8LOReEBdH5NBuwTFmpRwkRmovUuzJKGz7CyPK33NM0udUbUinakM6lj69fa5j6dMb+6pox5MRMt55gPR3S0KmyZfD+IyT/XnjiZHEbdjN2CdmsrrMyLUwPL6a345ezW9Hr6bw2UEh01QXZ9CIUwfAgJhoBsREBxyIsbosiUmzp2MP48O48NlB/Hb0ama328vsdnvr1TosfyTD8kciL/hIEBxmfD37hzy0nXMTwnfNnTgDV9zv7azPJtBrSQ29ltQfTXpuwiDOTRjEkIc8h/qyF02l/b9OhkSvr7ZqJiHrAVeMGgBAzEMnvSZcsj6bQLdNlaE6dJPJjG7tCsQYljrJ6+mkru/LiVlV7O79Ac7XktSdlpD6Ad8/YDO5ccaL5aSjQwD45qU+JL+9DQUkrfg3BY91BofxcHqXvNY/NA3YF76CRuridMRfOHqxz0CcgsrOJK34d9gm33wFr9THgcMdAchsYsRTqHmh8y6yM35MstlCAEt+ArKl/qGws/cNok+eMdZfN4Kv66cVIUtFGUhbDSchM8BFfY1d52ev81h+9Y6xXLbAgmzxnw80VKjyCm794FH+dot3FMzK86nM3nyH63v2ibOusSv3qhn7AgzWCAUb/9dwxM+sMzv8xrqh9Bhd5GFMbk37mjenjQhr5QZn0MhL2d6zQVJpJWvuHnbc0pPh8Xs9flt5PpU31g0lnfANm9QXNFCXSUeH0G5L5IQmty2o4OodY115P5y0H3TS1fGJe3eHGdIC4twEw/g6I/uclNjKydn0IFknSkM+J1RfW3Xy1k9e9htWHSytOhBDo9FoTCIkPWB1fV/s2WU+f7v4ZVtKMhVkDqJtQQVA2Apf2s+fp9eD29nw1ZUMiPHshe0qu4x2m2ufdkWDO8Jg47Xz+5suALBvyPKw6PTFc2d7kpDfyudv6U9s4ynrGHB7pZ6VcpCqvE/CXrnBXwCIxMRQUsdZf+V5I9vKU++MCVvQQFP490dX0n2JOd4l5XcOpDLJ4lHtRLZ8SVppb25acCtrM/+LBItxjf915Tv0GGlMwmY2nNIkdNQzjlR+50AG/8o7cVBB9QXu/mKy4TURpnkAX23VvdLI4SHtGBDjrSWYWoNugC19enNiVpXfV3WnA/mG8mgeessxYx/mwpfvHb2KMUmfe7iRvdB5F8wNbFjEPVgjXFUzlqwZ4crt4IuMx7cxu/0djGsgubRZ+HLWdw75ZD4eucZ3dVkSsYGNVAQNS2IiNf0NI+AMXMp+dSrd3SMujxynYn42RQtrSIjw91hff09dVpde0+hgjWDgXhEjqriC6tQ4/meu/0ojTQ0s8UdQDbA1NQX7gvOOSapaqlQ1R2ou0jMqjqM15VQqC4++PpN0k3xWU24rIG/DuIAyn9WloWCNUGGLU1gSEwF8lkCxJidhiYkEb2pvJCoKUpOxuoUMnbZdQCqb4f8TJp7/fz+nw7LwttOa/pfz8ara6hfOIAtLvPHwksQEn1UmIuWc2uIUVreABn/J1t0rYhypSAUuhEsi4F1p5Ka9t3Jxfhuf6zYmsKQxBNUAd/mwivldPqSu4/KCkt58OuYa/vTRUn4xbTqtdxym+/nIcRpvDIEEa4SCzeOe58eJ0wHo9aC30Y/kqgn2gX1Y4IgedDJ45Uyy5hqz4C2xHYQTZ5DF0V/1BWDtA8/7rDIRKee0bnBDIBUxqKkh3Aa47j2zNvO/KFpYQ71agxw0FhQDbE1NocuHVcxN20CCxTtKq8oejb2gkGk/f5D4r/LDmhzcH3HTYxmWOokDrhhv/+VQnJUoOsyPNfIUFIU/VLaDtTV/u2UhAD9bPIWsVyoZvKTWJWpM0mLaugVqjD+cy5mHuwLmh/WqKPGKGrRWSLOKGYaD/k9PodMHoa8i4U75nQO5d66n51D0BUXhE1fzl5+9BuAzsCV70VQj124EnNOGghuyF02l66cVZJ0wxk/DUYTXF3UrjSRYYr2Gc7y0Bnl8Ojg94Kgopnd83yNSqy6qpgbZEjm9XvuevViA3ueMLEfXbp/id92OrsnC8NdUW//UjZQ8Ec8LnXe5XGKWDl3C4ituYHY794lE49wPyx8JQM0fO9JqZ2T6rGa88wBZ75ZETFvwR2p+ZYORkcGmMsniNUY65KHt9E844uU/7azcEFWuyNh0IuQJoXwR/c0x+s2dyrpf/5GuUf6j2by0Fh6OiPQD9ZG9aCoZy0OrNWR+wM6ggX//40piz0AHIiNHQV2cM8uhTinZVOLf3s7nv0wHt1nj3Dg7uT6yid3w9R3wcnsA4tZHhh+our4vpx/1DLoJdfBKIPzXop+wst1P6l0no/AokVAZ0FepIffKDfbyctN02oqK6LT0AiPaPIY9xv96lipM11qXihWdyc6Y6vf3DEf1jlASFAPsDHBQsbXPCafjulnuO5cSxRvS6PHt5AbX67bOEnEO+CWZcewesMxsGV4EEqBihqFoW1BBj48avtatvos2tYKMO85qNw2uFwYtjSF5+bZ6IwfDcf0j3IFFo9FoLl2C0gN2BjhoQoMZ1S005iBbviQzzH7xGvP4QZWl14Sf2FI7c8709lqm0Wi0AdaEmPi3t/PZ255+4eEKXtFoIh1RyozqWxqNRqPRk3AajUZjEtoAazQajUloA6zRaDQmoQ2wRqPRmIQ2wBqNRmMS2gBrNBqNSUSsARaRFBF5R0QuiMgREfm52ZoaQkR6iUiliKwwW4s/Wsp5FZEYEXndofG8iHwhIjebrasuLUWnOyJyj4jkO9rAQREZYrYmX4hIWZ1/NhH5i9m6fCEi2SLyiYiUisgBEbmj4a0iOxDjReAi0BHoC3wgIruVUv9rrqx6eRH4H7NFNEBLOa9RwLfAjcBR4BZgtYhcqZQ6bKawOrQUnQCIyDDgD8DPgB1AZ3MV+Ucp5cpvKSKtgVPAGvMU+UZEooD3gFeAYRhtYZ2I9FNKFdS7sVKq3n/AYWAm8BVQCryFUfJiIrC5zroKuNzxeRnwEvARUAZsAToBfwJKgL1APz/HbI1hJDLdlr0BPBtpWt32dw+wGngKWKHPa3DOa519fwXc1dJ1mqkV2ArcH+jfEinnFfhPoBBH8FgkaQX6OLYRt2UbgN839HcFOgQxBrgJ6AFc5fhjAt1uNtAOqAK2Absc39cC85wrishLIvKS42smYFOeT4/dwI8iUCsi0gZ4GpgR4LHM0tqizqs7ItLRob+hnnpL0Rl2rSJiBXKA9o7X5GMislBE4uoewGytPvhPYLlyWLcI0yp4IxiGuV4CNcALlFInlFJngXUYr66B8I5S6nOlVCXwDlCplFqulLJhPJn6OVdUSk1VSjmzIydgPL3cKQUSI1ArwO+B15VS3wZ4LLO0trTzCoCIRAMrgb8qpfbW/b2F6jRDa0cgGhgNDHEcrx+G0Yk0rS5EpDvGa/1fAzxmuLXuBU4Ds0QkWkSGO/Q2WKAxUAP8ndvncnxVrfPNKbfPFT6++9tPGVC3PGkbIJCCV2HVKiJ9gf8DzA/wOO7o89rAfkTEgjFMchGYFsDxWopOCL/WCsf/f1FKnVRKncHo1d0SgVrdmYAxfHAowGOGVatSqhoYBdzqOPYMjOHIBstpNGcS7gJuFl5EOjVjX3UpAKJEpJdSar9j2dUE9lrni1BqzQXSgaMiAsZFsorIFUqp/k3Ynz6vtfsT4HWMntstjobeFFqKTgihVqVUiYgcg6CVNgzpeXVjAvBsM/cRUq1Kqa8wer3O/W8lgB57c9zQdgM/EpG+IhKLMfkUFJRSF4C3gadFpLWIXA/8B0YPoymETCuwCOiJ8ZrTF2Mm9ANgRBP3p89rLS8D2cBIpVRFQyvXQ0vRCaHXuhR4SEQ6iEhb4BHg/SbuK9RaEZHrgC403/shpFpF5CoRiRWReBGZieFdsqyh7ZpsgB0TOU8D/wT2A5ubui8AEXlFRF5xWzQViMMYW1kFTFFNdJUKpValVLlS6jvnP4zX/EqlVJPK6erzamgVkcuABzAeat+5+YKOu1R1hlqrg99juEoWAPnAF8DcCNUKxuTb20qpQIbJ/BIGrfcCJzHuq58Cw5RSVQ3uJ7BJRY1Go9EEm4iNhNNoNJpLHW2ANRqNxiS0AdZoNBqT0AZYo9FoTCIgP+BhlrsjaqbuY/saX6F/LUYnaK3N4VLQ2lJ0gtbaHOrTCroHrNFoNKahDbBGo9GYRCTnA9ZoNPVgSUxk37NXoGJtXr8l5Lci7fmtJqjSNAZtgFsA5yYM4vuMeoeSSH+nBPvu/DApurSw5RopO47nxnr9Fonn1XJ1NofvaIstVvHv25+ng7W11zq53UbB8yaI0zQKPQSh0Wg0JhGSHrC6vi8lmYHkeDZIOFFNq/U7QyHlkiBu/Em293m33nUy2j9A6s5BHstiS+3Ev709lNL8Yrk6G4Az/ZMbXNeM619+50Aqk4z+x/c3XQBg3xDvXODO89q2wMixI1u+DJ/IOjjP6b68NhTe4dTq3fvVtBxCYoD33xfFoZtfDnj98YdzOVPcB7VzTyjk+MXaK4PqtCQAooorsO/xzqHtvg6A9UJ1WHVKTh+6JjSYVpTCO16FOmUAF5WmsfbUcCzb96BqakKk0BNLn97UpMZRMDYagEO3N9wOzLj+I57axOx2DedMd57XHh9NBiBzS6iV+cbaK4P8KUbe/EO3v+r1++qyJAoqa8u7HTnajkwOh0veJYuzPddH9DfHsBU1KfdWZIwBr0jfyJwlvfnsKu8xuFCS/3gKh25eDEDunlHEDK9/HYA5Z8Krc/CSnV6Gosxeybc1dtf3jOhoYiTaa9u8pBPkvvkij9w8CXtBYciNsDU1BfuC83zc+2+N2s6s699SsCYnse/JJA79ZJHHcpuyc7CmApsS5j39S5JW/Nv1WybheaOQqCgsqSlB3ae9+GzYOgz1EWh77jd3Kp2WXsBeXt7oY0SEAdY0jtEFd2EZW5vze+h/H2RWykGf6/aMiuNPHy1l2s8fDPnrc5cPq5jf5UOMGoiaYHF8WRo7r3mRuhVuDtZU8MjNk6D4HMnnvghalvXGYB/Yh/kr/ZVxaxq/GjfV1KEeJ4G253W//iMj2jxG12ca73XygzXABYtzeOsnL2OUyGr6OqHCmppClw+ryGu7hbrjfJU10cScOu76/t8TB7Gh9Q2cfrSS3QNWee5HLGRGt0ZFic/KgcHksrhiEizejXVRaRprfumdn/6Aa5hiEXltP+fI9uEcvyUGW/HZECuFzfflMH5BJ1akb3QtG384l1O/6cHFNtEsWziPHtG1FWiMdgA/WzyFzMnhHa9uG19BW6t3eTGbEig+h+3U6bDqcVJ+50DunbuO7FYNlj5rFOFoq74ov3MgI57a5Pqe13YLCRbvMfZFpWmsfOw2VxvpGpWAvVXTjhl0A1z47CDmDF4d7N0Gncu6n2FATP2GNZB1QoGlT2/sC84zv8uHHg1gWP5IAOSFduA2vqd27sECdKzpS9bDEwDYN2S5xz47PnOI47/LCelk1/qnbqTkiXhe6LzLY/np6jZYNn3htX5s7nWuzx2srZne8WNmRI0KmT531M49HP9dDtemZbuWJZyoptWmnbTu2IFK5ekg5GwHl3U/ExZ9TgoW57C05xKv5avLkpj39C9JPud9XsNFZZKFvKQTQd9vONqqO+cmGJPXg3+1vc5wn3HvZX02gTb/MD4X59j5x23zePvR47S3GuYz450HyHq3BDuNJ+gGuEv/k4xLLPZYtqE8ml+t+AUAfx7/GsPjm1My69KnJjXOMe5U25u84es74OX2AMSt3+FzO9nyJZZhDqM2xPO3FekbuTYtm+CO1nkS//Z2NicMIjvjxx7LY89AB2pfz07MvI6y7Ivk/ujrEKppmFbrd4b0fASD+wdsJjfO89Z+7mxP3nxlBB1WbDVl2MFJu13nyF7kVcTYi8pONRy6fVGD6znZ8lUmvb873ySD1ljO3jeIPnnG5K+z43DadoHBK2dirTT64d02VmLduM2xxSAy72jNP3p/gPP+TN1pabKveFAN8Olp1/HztPVey3eU96T7U8YNuOPOngyP9559HhB/kFW/+QXd//xlkwazm6vz1rSvWfKU52vyfXXWWXk+lTfWDSWdbYSbom2d6f5uw2NM7b80Ji+G5Y/k4+x1oZblRfLybdTneHZ62nVMmLje75i12UR168r+B7uRao2onC4efHDiSjosND/Kzb47n+67G17P2iuDHtGTXd/nDH7Hq5MGUGIrJ2fTg2S/cAbb/sJgSvXJuQmG8V3a/TPXsh1V1dzz4XSy5u7Bfr62CpIzWMfpshgsdCCGRqPRmERQe8B35X3i1bPZWGHh9R2DG3SLGR5fzdoHnmfGklEQ4h6wL52zUg4yK6/+2dzXjgwh/YnQ9n6jMtIpHOrpdzjjZH/aFAbWI4t71xieuFiRw/gncz0mmcKJv0CM3zy8kjEJpWZIapCojHQKJ6RRMOEl6k58rjyfCsDxXZ3JCIN/rcTEcO7ufmTGrmp45QjHtr+QzPuNHm35nQPZ1fcynz3g72yQNeN42CYV48af9Oj9bqywMOnTKWQ+uN01/HFxRA5ladFuwTqecyvjD+eScKLpQ6pBMcASFYV9YB86RG9wLdtRZYia9KnnrPF7R69yfR4QbxhB55hwrNi5MCCd+I0VHt3/HxJFN3Qmv86D4LO/DKTt8sYZ/lbrd3Kqsh+s2uhaJmF6q/YMGgg8IMd5/Vt936VZzu2NJapbVwAKJ6R5nXsnszcbUS6Zj4dn+MmSnMTSOfOC7mFgFk4bce/cdT4n7k7bLjDv1HAIk/+ve4CTP1sFoGac4X/qiUI99ZsetNrU9MnCoBhgS2oK81e+5Gosp20XuOfD6QBkPugZCptyWwGfOQavV/3GmJhbP+WPdI1KoEd0ApteXcSwsZN8zpqHEmdwg1UUPaPisErt6EyJzeiRl5TH0SlEx7fEG+euurWnA86h6jIsNZE7HlkXf0EDgeC8/mA4t3de63YuqqqwnQt+z9mSmMj+B7sBOHq+3py2XUAqrUE/dr3YFfuqO5ARXeIzyKYlIVFRWDIzWPDmi2RGe7t1ldkreeLEcI4OvAAEd4zVW4xgbdeOocu2ud6Cf/bJFIBa4+tYB4sQGxVah4GQ+AEPXjmTrLnGzGJ9M5nd/2w4W4/8/jG+eCK4ztyNxRXckJrMnz5a6tFQcjY9CEDWtEK8E/8Fh6O/6gsYDyOo9T+dOG06yRvMcbJvCv6CBhrLul//kfOzah+C93x5P51GBd8A73v2Cv59uzNtmO+8CoG252BiO3OGRdcNYv+nhRE7YRko9oF9WPDmi/SM8h3SO7rgLix3VxBy4wtY27Ujb+s2bo4vwZ9/v3OdrOjTdIuyEMrAomYbYMnpw9Bl28iIrv1jrBUS0BCC09sh+kJ4zcvm+3IY1tozcU1UcQW2U3ux4nBwd8NeZfR+QtEDcx3D4cjdNSrBY3mr76tRVVWN3p/TST4cOINGLosrZkzSYtr6SI/YWOqeh7bxFc3eJ3hqBfh94kKf6Rw9tqmnPZ99P5P/6P4VAG+sGwoQnHkCpbAVFVFlb9m9XzACK3z1fK/eMRaAtNkKW/Fxr99DgkXIij5NjBgdhB5/zyP7BcO320atPbs5vsS1Tl3cA4uidh1o1kO52QbY1jra8YRuekNRYQ57cQYuuGOnNgDCeOqFl/R3SwDI6PCAkQCmmfhykg/ZeY6KYnrH9x1DUI03vjNO9udfCwe6vs/6zZuMSSj1cIA3JjoON0umZ4CLs1fTtHZrTU7i+LI01ly52GVcXu80uFn6mkrB4pyAAkTkhXYRlXXw+2LjvHXaY56mqYP/mw8yrnR8S6drwrF67dmMk/3ZMfda4jcZQ6vNfSMK+hBE1mcT6LapMti7DQv+AiC6rQu9QXY6cqfuHOSR1ez0o5V0rOkbEbHxvrD2ymDfk0l0auQQ6Q1f30HRNiN7V5tCRYrbJOMzrcfxZLu6DvDNQ13flxOzqtjt5kAfKD+++Ws2ds/xWGaJsbHzmheD0ttvLL+47DNmv17bSN76ycsBRWwOe2wkFXEDXJ4y4UBd35fTj3rbg3DdV156zpcx+tWZzL/fCAibleI/j4o7k44akU3fvNSH5LeDNxEbdAPc5h+tA75pQuXcHEwCDYAIFbsHrCLr4Ql0i+6PdeOuetetGDWAor7GJbVnl3n8dvWOsXQsCM5rvDvVaUkc/MlSGjPmOyx/JLzc3u95DUWQQUlmHLsHLGvStku7fwZu7kq1hN5D4Y11Q+kxusjDbWtcYjHj3DL0BdqL/zh7Hdl9p9K9/tTSQcF5b387pYZ9dfKTOK9/OB8ETuzl5XR9Zis7xvoOCKvLsPyRHDjckXZbjHOc0khvpIbQgRgajUZjEqZmQzt+o/Eq6KxEUGavZHTBXUZy9DBraW4ARLBIOFHN+MOeART7hiwniwm06THItU7dsbyLI3KIeegk+X7CjzvMj0W2mJe4xcn4w7nU/LGj33wWZrKxwsLiUzeYFrzii/QntvGUdQzcsdpn8EJdnAEjrx0ZQteEc95/S5iac917251zK7qS8m74w/ndeX3HYP7ZvTdgpCEAvIYinG01M4Tj5kE3wGWXCck39iP6hOEx4C+m29org8rOnk7X39bYsYytxnaq4VeDYBOsAIjm4iuAAhwROI4EO+MP5xrruNHlyQMRZTjqUqWqWVDSmzMPd6XVzvBPusSW2llUmuY1MbmhPJod5T0B46bMeqWSOUuMGzOv7ecNeki476fVd6HxWMh4fBtP28bQ/mfGsEN9yaz+mG9UFegwP5ZvsjvDbzeGRFN9+Lq3nSwqTSO2NNzdK2/cAy6WPGl4NMx6wPP+b26QRSA03w2tRlFQfcEVvJCf9xLkuZVwud/bAPty1q9S1eyr7gD28PY4/QVARDIr0jd6GWh/OKsmiEnBHM4Al33VHfh0aAaqKLxlp5zEv72dtaeGM6RO8vBHX5/pSqSdyU4UuCpzHNk+nOkdP6aTFa98vO7VKJz7SW9CQu5ASX9iG4+WeQYu+cKVD9rEF7riqwAAFQRJREFUCGajiozvQJw1vxzh8iAwG2tyEsTEYIurvTeqVDWF1cYDLhz3TLMNsGX7Hh65eZJX8EJ9+HLWX1DSm0+HZmA7E958q/4CIC4VnFUTLAV7TAnmcAW42FXYr21dLNv3MGOgZ77h7ue/9DvcdfyWGGZEjWLfC10cE421uFejaGg/wSKSApcuBY4vS+NvfV93y3zX2rBDPzXeiCzFob9nmm2AVU2NkZW/jpOps4LAhq+u9NqmrrP++MO5nHm4qym9I38BEP2fnkKnDw6ELPKtPqJ2HeDGB/K8qjI0Bmd1B6lRhvENUYy9L609/p7H5auMXoQzwCUSUDU1jUr04qzMkfW7BIa9Nsnjt1CfV184A5c6r97PsD2eejo+cygihqD8VZE5VF3GxGnTid+VH/b5HV+cfT/Tw4cb3OzQqfDZoaCMAdvPlTJp9nSm/3aVK9OV0y9xQIyvm8/4o50VHmr+2NGUccH6SM2vDFsymLrYz58nbsNuxj4x0+OcNoZjZcnEOPJphPIp7q7VFm08hHvvOufya46Em6252PYXYtnvvdys8HBbURGWTZ5ts251D3+k72pa5YZA8VdFplJZaL3jMDaTk2z5CqBxcqwsmZgwV2YPigFWVVUkrfg3zyQbDvQ/vulrjzRvvgikwkNYqDP068yG36vwW8ysy1r3nDaWNoWKmDCVJXdqdXIpGN2WRqDVPX7I18YZNFQ3gMYZZFGxonPY7hknQfWCcDrQ7zk6iB7XZ9W7brd1FlMcsRui2CZcPv8gNSYVOqxLJFQ+0Giag1Fl4lGyyr8xVUfdoKFQB1kEgg7E0Gg0GpMISSBGypJtpHgXco1InIEWuXuM2fGS8ji6VAW/0qtG80Nlw/kr6eVWZcIsooorXPc5GMmJQhlkEQimRsJFAsnO1w5HpZFOYIrng0ZzKXDkaDvmdOrtsey9o1eRQoFJimqx79lLzHD3JYdNUlLLD94AazSa4JE5eaer4o2TSDC+kYoo1VJqLWg0Gs2lhZ6E02g0GpPQBlij0WhMQhtgjUajMQltgDUajcYktAHWaDQak4h4AywivUSkUkRWmK3FHyKSLSKfiEipiBwQkTsa3socRGSaiOwUkSoRWWa2nkCI9Dagz2loEJEVInJSRL4XkQIRmWy2Jn80VWvEG2DgReB/zBbhDxGJAt4D3gdSgDxghYhkmirMPyeAOUALiVUEIrwNoM9pqHgGSFdKtQFuB+aIyDUma/JHk7Q2aIBF5LCIzBSRrxw9vLdEJFZEJorI5jrrKhG53PF5mYi8JCIfiUiZiGwRkU4i8icRKRGRvSLSz/dRXfu7BzgH/HdDOk3U2htIA+YrpWxKqU+ALcC9EagVpdTbSql3gYYLjJms1bGPgNuAPqeX1H2FUup/lVJVzq+Ofz0vFa0QeA94DHAT0AO4CpjYiO1mA+2AKmAbsMvxfS0wz7mi449/ye17G+BpYEaAxzJLq69aRgL0iUCtzaGltAF9Ti+N+8p9WTmwFzgJfHgpaQ3UAC9QSp1QSp0F1gF9A9zuHaXU50qpSuAdoFIptVwpZQPeAlxPFKXUVKXUVLdtfw+8rpT6NsBjmaV1L3AamCUi0SIyHLgR93pLkaO1ObSUNqDP6aVxX7mWAYkYJWnfxjCMl4zWQA3wd26fywm8eNopt88VPr773I+I9AX+DzA/wOO4E1atSqlqYBRwq+PYM4DVwLFI09pMWkob0Of0Eriv3HEM7W0GugJTAjhmi9HanGQ8F3Dr5YlIp2bsqy65QDpwVETA+MOtInKFUqp/E/YXSq0opb7C6PU6978V+GsTdxdSrUGmpbQBfU4NcmlB95UPoghgXNUPEam1OV4Qu4EfiUhfEYkFnmrGvuqyCEN8X8e/V4APgBFN3F8otSIiVzkG+uNFZCbQGVjWxN2FWmuUY79WjJsvVgxPjqbQUtqAPqcGLea+EpEOInKPiCSIiFVERgBjgU8uJa1NNsBKqQKMwfx/AvuBzfVvUT8i8oqIvOLYd7lS6jvnP6AMYzymSVUyQ6nVwb0Yg+6ngZ8Cw9xmRCNN62yM16nHgfGOz7MjTWsw24A+py3yvlIYr/DHgBLgeeARpdR7l5JWnY5So9FoTKIlBGJoNBrNJYk2wBqNRmMS2gBrNBqNSWgDrNFoNCahDbBGo9GYREC+isMsd0eUq8TH9jW+8i+0GJ2gtTaHS0FrS9EJWmtzqE8r6B6wRqPRmIY2wBqNRmMS2gBrNBqNSTQnGY8mQjg97Toq20GXjZVYN+4yWw4VowZQ1Le2acWegQ4Lt5qoqH5suUYemuO5sR7LM14/Ss23gSS101wKWK7O5vAdbX3+1v7LGgDi3t0R3GMGdW8ajUajCRjdA27BSEwM5+7ux28eXsmYhFKysidwWbWRe1q2fGmarm9H2jl0c22xgDlnevPZwth6tjCX4zca2vLzPItcDPt0EpYW0gO+OCKHsrRo1/eEE9W0Wr/TND2Wq7MBONM/OaD1Y0vtxL+9PZSSfKKu70tJZhwAxTl2Cu/wXehkWP5IAC5W5AT1vIbcAFvbt6f6iq61B9x1APv58/VuIzl9sLWO9lgWVVyBfc/ekGh0YklMpKb/5Q2uJzUKy/Y9qJqakOppCEtyEkvnzCO7lZHmdN+Q5fQoM4qxZm4xU5km2Fh7Zbg+2/YXevwmOX3o8uQBVqRvdC3L3TMK1odLXS2WPr2pSY2jYKxx/x66/eWAtptzpjefvR3+h/T++6I4dHPDGj/OXgdA7ozgnteQG+Azt17Ojv9X+wcOGzsJy6Yv6t1m8JKdzG7naWxz94wiZnhwtVkSE5H4ONf3CwPS2fTqoga3K6i+wCM3T8JeUGi6EY40rMlJWGJsZsu4pLAmJ7HvySTX96xpSdjOlbq+u98vJbZy4//yOMzIOl8xr5KNff7W6O1iLNVY23fDduYMmJyh0absHKyp4LKoVsRIdMMbNIMf9BDEvmev4INba6uzxIqdQKqX9IyK408fLWXazx809VU/Ejm+LI2d17xIYCXxNIFQe04NcpfdT6dRpT7Xzdn0IABZ0wppSY/Bh9vupdfWUyy6bhC2oialJw4aB2sqeOTmSQxd/TmzUg6G9FghM8Cnp10HwG8eXhnwNtbUFLp8WEVe2y1AawCu3jEWgLTZCnsQ9RUszuGtny50vb7Xpf/TU0jNr/RYdmxoHPl5L2EVC5nRrVFR4rMk8g+Vs+9nsubKxbS1tnYtG384lzMPdwX2mCesidz9ynreeGKkKWOT7rSNr6Cttbadrum3mHHvTyLltgIANt+Xw/gFnViRvhF7lRXAo4ccSfR/egpXTMj3GC4BiJFosqJPgyW8d1T2s2cZtnySxzKp+f/tnXtwVNUdxz+7m01CshAgD15JCIl5rAM1KoIBUsGOUKdDZTTQUpABZKKgjqMgtcOMr06KFZBpVGzDcxB8IE6x1lbodIiGR2UiIlIySWwSE0gMgaDkwcbd7PaPm7u7N7ubLOTu3hs8n3+Se/fu7G/uPed3z/md3/f8XBirztDlDO3oF0LkgBvXTGPJUilQssAiNYRzjnbm/nEtY85W+30zGyfm4CxuY/O4f2AxejrwlUvS/6PPqLugMD71IlOilDd4X3scG9b/Rvq9v3/t8ya2pOepaoPaZJctIXOHdiGR+1JPk2WWnpe8aOF4eRSR5dotBg2EwrhGtsYZdTeWzzLHcl/qacqQYqaVj0TzzKhPNbZKwrApgXvWznXHTMG3X527P7iFuXDQXV2DsVp5zjQ8jvP7M1kQtw15ICi3Z8OmBKBOtd9X3QE3rplGwYOliqH7oU4zT25fS+rOU3R3dvp8xzU9l8anu/gy5yPoaVTZZUswVlhIOaW+Q6kryuPZ8fsAWFafD8B/Pp4k5avulPJVB9P0TcZYYcFwNPz5tsahQ6l86WZ+P/Q1QHqpfV03CoCsIFaMXdNzqV7uaYrWl1p9FppCyiCbxmxozeD9krtJQnrWD005wswhas4Pr5/Ig+VcHTIFa66nYrt3v/qfV9/TI6bMdCqfi6P89tcVM7lrac/XguoOOH52I88lnnUf722L58X9C0hbf8wnhCAnwDesdFA55W33+VtOLGR8sVF1Z2KMiaH+iVxe/dVWZsfYASj9bzYAWc8H/i3Zzis/71DVnoEQkZJM9aMpxJu033vEEDOEj36x2R3OWVafT8LR/qdv3s+/Nn8bl7s73TFMQWA+apyka2HLkAMnSD2gPOev7+kFbyGObbSD2rtLCNcahhBiCAQCgUaoMgKWBQHdZgM/jVcuWGz9Jp+0dcd9vuOankvDSim8UJm/W/FZ0uZoDEf7TlW7LjuHWtj/8Eb3SG1DawaWisg+v+PPznanjYKqB6TcZNWtDI4f0hOpWvIGcoxqddNtDKsJ/2jYlJhIU8FNDDU63Xac3TKRkbt9n3lvZAFEZb6U/P5tN2SvPk9384XQGewH+b6tbrqNTWO0l3LfaJgSE2lakMnBlS+THOE/y6jK3sGvT61gXFdjWG1T9m//IgyAm9KaAWhdlqeqaEQVB9xbEABwokuaZnxTn0CWn6B19fIIavO3Kc51uewUX87B1GEnHK5ky5GfYf3gWyBwzLe3nRe6O1jXOBvj/Kt0XzofBiuDo+zVqYwIwumpjf3mZL5YtwU5fS9YO0yZ6djGKOP70QYnHVPSiLwyDoDImpaw7MUwvMfeMmMe/EHpgA3aR3gGHabMdOxjPXnLLdZoRRuRkX3EobZJfFD/E0bPqwjb2oss9rrwpE0R/gyEe1GxCEq+H8v+5tmqiLEG7IANEREQPxxTr5a68GghANZ19RA/ku5Lre7P/CXrd7ns/LNzBIdnpeNqCVHKktNFpT2JdPNlogxman9ZQoZFSkHJXp2kvPRSK0ZLrMLOdqeNdY2zqZ/aAegnHqwn7LEGjDExOP0stsrIwgIp1uZhgtniFsKcc7Qz5421JK8fHFJggYeKZ0ZSe++2fq+TfUT2YzWM/K4q1GZJGAyYEhKYtev4def4FsY1kr93C6unzhvwbG3ADtg5dSLFb71ORsQQxfnyu6TE8W8/g1ea76F+quczf8n6xZdzODwrXVLChIjuixcpmZZH9eEa9833ttObJxatounpLoWdBVUPYJx/FeF8A/Phb19mzrC1JK8PvEgUjFhj7h+lrBl9rO0LQoHc9/oSlqiNKSGBwmPHuTfmMnLGjpYM2AG7Igzu3E9v5MTxESYoGnuIktO3uz9bEKdM1gfocppDr4BxuehuaeHfS/P4sjiFPWmlCju9Kdh2iJkx1Qo7bQ4zUToKO+iBiJNfc9fDhex67RUmmC0kR1jY/NBWHrdIe1KkrTuOYfJEZuzwpO/4e/4l34/lvUfmuI/HnK32m7IogJLsvezz6k+FIz5HXgsYTMh9r7ewJKQYDWSbLxBl8H35L66bSfPvJvT5dVmMpRZhkSInmWJ77e3g21gWxH3OewdWMG5pY8hVPK7yM5x/YTJ3jLW6U8t6LwQWxjUS6iRsNXFplMvqbGsj9kQdNpcnoWZ2jJ1nC6Rcz6135JNsOdfn81/ddBsniu4g5hPPNESLPOzET5uwlqxSdLD8xz/jiDPPHSfWA1nm/vuTlmTucJBtWQL49it/ZJlj2TtpJ/PD1P97oxANfdJ3nq/aYqwBO+DImhaydq/kyKKNJJmuvyFkmWN5J3c7q6PmDdSkoIg8WM5IIK5WygG0VqxSfP6nxZ58xVAlYd8ouNraKfjLGjY/5Llni4Zekv5OPOBzfXbZEqaNr2VnahkAn19K1VzuC+CoqSP58Ago9JzbNOYk1vQ70VK7dXXPGKzpnvbptLYH5di0wnD0FCnm/vuVN+Hq/3JbdUZ5zrk3Wz8YeLP1q/OmADB8sbprEgN2wI6Gc2QUfc+dQ5/CFe1/3DIsvoMv/aw0vtByMwC7yqV9Iww2E9mdZ32uCyVyBYnUUuX5E/dnMDsmtNtf3ig4OztJXn+Mxy0r+GF0/0n2mTsclC7Phh4HrHcS85rcHVDtigjBMHz3ccULwDU9173tKMC7d7/hI6vXGr32K7mtXityhZcKL4m1GgghhkAgEGiEKjFgZ1sbmY8GnkI677oVeg2AN7RmsP/NmQBkbfS8kcSq9+DFn+AmIMsnh84Qlfl00l+ZMLdno3vfiErYMRw9pdhw/9DpSUyJ0sdsLVBlDlmslRXtP+dWSyGGXBEjUBUR1/RcnNb2kPx+WCpitFiVO93va4/jrT/PYayO9eyDDSEYEGiNv8oci+tm0my7lR+GmXm7aCMTzL5KuCp7B4u+WhZWIYaMd0UMf1VEjBNzaHy6KyixxvUQlooYJ5/1VMSotbfzyouPkLRHOF/B4OBCdwcGm6n/C3+s9CFu2JNWCm+X9hwpna9cvWP+FysYPa8i9Hb2Q3SEHeOoXoKs4raeXRol2p02GhxOKu1J4Bz4qCfsFTGWPvYUww99ERapsUCgBjP2riG7SFJnihCZL9crbtBb9Y79We/T8JnyCadEGJG3yIUeMdZCOzhdqojGwl4RI/KKHVdXV6h+dsD0rsox4W+FWDdJN1oPjQSg8/6pPFik7mqsIDCmq4Z+C8n+WDFMnsisXZLzvZb6aYp+pZPqHRZjNNa+9+aSxFjN6omxQuaAbfHS32ArYugBf1U5opsiwrs5eBAMO9XM5nfnUeglGNBKiCH4cdMda+4JOwTnfK0lq7B84yLn5He661eByC5bwrCPJX9gabSj64oYAK3L87jz3q/cx/1VxNALjvgh/CvnHbynHHqsluCoqSN9uwMrniT3tJOXB9X0OOVDI9YGyf5hNS6idKIwjKxpwVqiFA+M+8QW4GpBsEKsC90dzNi7hszt9TgazummrXq3w4DXlNowlYZGCRkSB3xxut2tcgI40ZlBsp+KGHrCeIuVqoXKt/g9FXPdKhm94Wg4R+rzHlWOnu+tP/xVTdADve/rYODND2exffQMgKAqkahJMEIs6BFZFZ3BobNQjtbtUAgxBAKBQCNCMgK2VEQyM8Wj6ZY2Zdf3Pgq20bGMT78g5QL2YNiU0Kc+XCDQA9ckgAkB/Qmx3NeFwZbBRkgc8NiNx2Cj59hfRQy9EXmw3CcJW687nwkEghsDEYIQCAQCjTC4XEISIRAIBFogRsACgUCgEcIBCwQCgUYIBywQCAQaIRywQCAQaIRwwAKBQKARwgELBAKBRvwfOqb6K0s6FLEAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -637,7 +637,7 @@ "metadata": {}, "source": [ "构建完成神经网络后,就可以着手进行训练网络的构建,模型训练函数为`Model.train`,参数主要包含:\n", - "1. 圈数`epoch size`(每圈需要遍历完成1875组图片);\n", + "1. 每个`epoch`需要遍历完成图片的`batch`数:`epoch_size`;\n", "2. 数据集`ds_train`;\n", "3. 回调函数`callbacks`包含`ModelCheckpoint`、`LossMonitor`和`Callback`模型检测参数;\n", "4. 数据下沉模式`dataset_sink_mode`,此参数默认`True`需设置成`False`,因为此功能不支持CPU模式。" @@ -661,7 +661,7 @@ " print(\"============== Starting Training ==============\")\n", " # load training dataset\n", " ds_train = create_dataset(os.path.join(mnist_path, \"train\"), 32, repeat_size)\n", - " model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(), step_loss_info], dataset_sink_mode=False)" + " model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(125), step_loss_info], dataset_sink_mode=False)" ] }, { @@ -717,1942 +717,22 @@ "output_type": "stream", "text": [ "============== Starting Training ==============\n", - "epoch: 1 step 1, loss is 2.3036417961120605\n", - "epoch: 1 step 2, loss is 2.298630714416504\n", - "epoch: 1 step 3, loss is 2.302391529083252\n", - "epoch: 1 step 4, loss is 2.304328441619873\n", - "epoch: 1 step 5, loss is 2.3027987480163574\n", - "epoch: 1 step 6, loss is 2.2987725734710693\n", - "epoch: 1 step 7, loss is 2.298673629760742\n", - "epoch: 1 step 8, loss is 2.30534029006958\n", - "epoch: 1 step 9, loss is 2.303036689758301\n", - "epoch: 1 step 10, loss is 2.2993321418762207\n", - "epoch: 1 step 11, loss is 2.305026054382324\n", - "epoch: 1 step 12, loss is 2.302748918533325\n", - "epoch: 1 step 13, loss is 2.3028924465179443\n", - "epoch: 1 step 14, loss is 2.2981364727020264\n", - "epoch: 1 step 15, loss is 2.3044252395629883\n", - "epoch: 1 step 16, loss is 2.2937963008880615\n", - "epoch: 1 step 17, loss is 2.302947759628296\n", - "epoch: 1 step 18, loss is 2.301767587661743\n", - "epoch: 1 step 19, loss is 2.302520275115967\n", - "epoch: 1 step 20, loss is 2.2997517585754395\n", - "epoch: 1 step 21, loss is 2.300358533859253\n", - "epoch: 1 step 22, loss is 2.296435832977295\n", - "epoch: 1 step 23, loss is 2.3037216663360596\n", - "epoch: 1 step 24, loss is 2.3002805709838867\n", - "epoch: 1 step 25, loss is 2.3053646087646484\n", - "epoch: 1 step 26, loss is 2.296821355819702\n", - "epoch: 1 step 27, loss is 2.2995078563690186\n", - "epoch: 1 step 28, loss is 2.305546760559082\n", - "epoch: 1 step 29, loss is 2.305027484893799\n", - "epoch: 1 step 30, loss is 2.3053534030914307\n", - "epoch: 1 step 31, loss is 2.3146908283233643\n", - "epoch: 1 step 32, loss is 2.2932584285736084\n", - "epoch: 1 step 33, loss is 2.303548574447632\n", - "epoch: 1 step 34, loss is 2.3062822818756104\n", - "epoch: 1 step 35, loss is 2.307175397872925\n", - "epoch: 1 step 36, loss is 2.3170557022094727\n", - "epoch: 1 step 37, loss is 2.29900860786438\n", - "epoch: 1 step 38, loss is 2.301845073699951\n", - "epoch: 1 step 39, loss is 2.2978885173797607\n", - "epoch: 1 step 40, loss is 2.3042001724243164\n", - "epoch: 1 step 41, loss is 2.303277015686035\n", - "epoch: 1 step 42, loss is 2.2995805740356445\n", - "epoch: 1 step 43, loss is 2.307396411895752\n", - "epoch: 1 step 44, loss is 2.3049159049987793\n", - "epoch: 1 step 45, loss is 2.304211378097534\n", - "epoch: 1 step 46, loss is 2.300304651260376\n", - "epoch: 1 step 47, loss is 2.30509614944458\n", - "epoch: 1 step 48, loss is 2.2977967262268066\n", - "epoch: 1 step 49, loss is 2.2965590953826904\n", - "epoch: 1 step 50, loss is 2.300846815109253\n", - "epoch: 1 step 51, loss is 2.3011419773101807\n", - "epoch: 1 step 52, loss is 2.291372537612915\n", - "epoch: 1 step 53, loss is 2.3017473220825195\n", - "epoch: 1 step 54, loss is 2.302234649658203\n", - "epoch: 1 step 55, loss is 2.3049476146698\n", - "epoch: 1 step 56, loss is 2.296499252319336\n", - "epoch: 1 step 57, loss is 2.3119330406188965\n", - "epoch: 1 step 58, loss is 2.29875111579895\n", - "epoch: 1 step 59, loss is 2.299650192260742\n", - "epoch: 1 step 60, loss is 2.295192241668701\n", - "epoch: 1 step 61, loss is 2.2914061546325684\n", - "epoch: 1 step 62, loss is 2.312401294708252\n", - "epoch: 1 step 63, loss is 2.3097002506256104\n", - "epoch: 1 step 64, loss is 2.299806594848633\n", - "epoch: 1 step 65, loss is 2.302612543106079\n", - "epoch: 1 step 66, loss is 2.2979307174682617\n", - "epoch: 1 step 67, loss is 2.31546950340271\n", - "epoch: 1 step 68, loss is 2.3103079795837402\n", - "epoch: 1 step 69, loss is 2.309143304824829\n", - "epoch: 1 step 70, loss is 2.305349349975586\n", - "epoch: 1 step 71, loss is 2.3021116256713867\n", - "epoch: 1 step 72, loss is 2.302931547164917\n", - "epoch: 1 step 73, loss is 2.299171209335327\n", - "epoch: 1 step 74, loss is 2.3023552894592285\n", - "epoch: 1 step 75, loss is 2.297666311264038\n", - "epoch: 1 step 76, loss is 2.2955446243286133\n", - "epoch: 1 step 77, loss is 2.303368091583252\n", - "epoch: 1 step 78, loss is 2.2970433235168457\n", - "epoch: 1 step 79, loss is 2.3118627071380615\n", - "epoch: 1 step 80, loss is 2.2917704582214355\n", - "epoch: 1 step 81, loss is 2.3150627613067627\n", - "epoch: 1 step 82, loss is 2.3017776012420654\n", - "epoch: 1 step 83, loss is 2.3065297603607178\n", - "epoch: 1 step 84, loss is 2.318979024887085\n", - "epoch: 1 step 85, loss is 2.3001444339752197\n", - "epoch: 1 step 86, loss is 2.3014917373657227\n", - "epoch: 1 step 87, loss is 2.309880018234253\n", - "epoch: 1 step 88, loss is 2.294804096221924\n", - "epoch: 1 step 89, loss is 2.3006980419158936\n", - "epoch: 1 step 90, loss is 2.308440685272217\n", - "epoch: 1 step 91, loss is 2.3000504970550537\n", - "epoch: 1 step 92, loss is 2.3011293411254883\n", - "epoch: 1 step 93, loss is 2.3041226863861084\n", - "epoch: 1 step 94, loss is 2.289018392562866\n", - "epoch: 1 step 95, loss is 2.3014912605285645\n", - "epoch: 1 step 96, loss is 2.302461862564087\n", - "epoch: 1 step 97, loss is 2.3085408210754395\n", - "epoch: 1 step 98, loss is 2.296156167984009\n", - "epoch: 1 step 99, loss is 2.29742169380188\n", - "epoch: 1 step 100, loss is 2.304044246673584\n", - "epoch: 1 step 101, loss is 2.3033947944641113\n", - "epoch: 1 step 102, loss is 2.304230213165283\n", - "epoch: 1 step 103, loss is 2.306795358657837\n", - "epoch: 1 step 104, loss is 2.3009331226348877\n", - "epoch: 1 step 105, loss is 2.2976226806640625\n", - "epoch: 1 step 106, loss is 2.294156551361084\n", - "epoch: 1 step 107, loss is 2.299952507019043\n", - "epoch: 1 step 108, loss is 2.309349298477173\n", - "epoch: 1 step 109, loss is 2.300881862640381\n", - "epoch: 1 step 110, loss is 2.311763048171997\n", - "epoch: 1 step 111, loss is 2.3041746616363525\n", - "epoch: 1 step 112, loss is 2.296386241912842\n", - "epoch: 1 step 113, loss is 2.3057456016540527\n", - "epoch: 1 step 114, loss is 2.2932939529418945\n", - "epoch: 1 step 115, loss is 2.3116936683654785\n", - "epoch: 1 step 116, loss is 2.2911524772644043\n", - "epoch: 1 step 117, loss is 2.3195571899414062\n", - "epoch: 1 step 118, loss is 2.3009743690490723\n", - "epoch: 1 step 119, loss is 2.2873072624206543\n", - "epoch: 1 step 120, loss is 2.3133697509765625\n", - "epoch: 1 step 121, loss is 2.30419659614563\n", - "epoch: 1 step 122, loss is 2.2948532104492188\n", - "epoch: 1 step 123, loss is 2.3005154132843018\n", - "epoch: 1 step 124, loss is 2.302123785018921\n", - "epoch: 1 step 125, loss is 2.3159165382385254\n", - "epoch: 1 step 126, loss is 2.299440383911133\n", - "epoch: 1 step 127, loss is 2.294107437133789\n", - "epoch: 1 step 128, loss is 2.3011081218719482\n", - "epoch: 1 step 129, loss is 2.2969794273376465\n", - "epoch: 1 step 130, loss is 2.3207995891571045\n", - "epoch: 1 step 131, loss is 2.312513589859009\n", - "epoch: 1 step 132, loss is 2.3004298210144043\n", - "epoch: 1 step 133, loss is 2.3079676628112793\n", - "epoch: 1 step 134, loss is 2.291200637817383\n", - "epoch: 1 step 135, loss is 2.3006200790405273\n", - "epoch: 1 step 136, loss is 2.310053586959839\n", - "epoch: 1 step 137, loss is 2.305415630340576\n", - "epoch: 1 step 138, loss is 2.2974250316619873\n", - "epoch: 1 step 139, loss is 2.3018136024475098\n", - "epoch: 1 step 140, loss is 2.2954070568084717\n", - "epoch: 1 step 141, loss is 2.3027243614196777\n", - "epoch: 1 step 142, loss is 2.3045427799224854\n", - "epoch: 1 step 143, loss is 2.2927889823913574\n", - "epoch: 1 step 144, loss is 2.3079490661621094\n", - "epoch: 1 step 145, loss is 2.308187484741211\n", - "epoch: 1 step 146, loss is 2.2903213500976562\n", - "epoch: 1 step 147, loss is 2.3045201301574707\n", - "epoch: 1 step 148, loss is 2.2987563610076904\n", - "epoch: 1 step 149, loss is 2.3156399726867676\n", - "epoch: 1 step 150, loss is 2.298570394515991\n", - "epoch: 1 step 151, loss is 2.328263521194458\n", - "epoch: 1 step 152, loss is 2.3073980808258057\n", - "epoch: 1 step 153, loss is 2.29105281829834\n", - "epoch: 1 step 154, loss is 2.3087775707244873\n", - "epoch: 1 step 155, loss is 2.308013439178467\n", - "epoch: 1 step 156, loss is 2.3050355911254883\n", - "epoch: 1 step 157, loss is 2.292358636856079\n", - "epoch: 1 step 158, loss is 2.3048012256622314\n", - "epoch: 1 step 159, loss is 2.3068573474884033\n", - "epoch: 1 step 160, loss is 2.3111112117767334\n", - "epoch: 1 step 161, loss is 2.2875633239746094\n", - "epoch: 1 step 162, loss is 2.2821505069732666\n", - "epoch: 1 step 163, loss is 2.2968549728393555\n", - "epoch: 1 step 164, loss is 2.283661127090454\n", - "epoch: 1 step 165, loss is 2.305659532546997\n", - "epoch: 1 step 166, loss is 2.302140712738037\n", - "epoch: 1 step 167, loss is 2.295464038848877\n", - "epoch: 1 step 168, loss is 2.279547691345215\n", - "epoch: 1 step 169, loss is 2.2998762130737305\n", - "epoch: 1 step 170, loss is 2.2972824573516846\n", - "epoch: 1 step 171, loss is 2.306971549987793\n", - "epoch: 1 step 172, loss is 2.3028149604797363\n", - "epoch: 1 step 173, loss is 2.2961080074310303\n", - "epoch: 1 step 174, loss is 2.306591033935547\n", - "epoch: 1 step 175, loss is 2.294856309890747\n", - "epoch: 1 step 176, loss is 2.3139917850494385\n", - "epoch: 1 step 177, loss is 2.3160483837127686\n", - "epoch: 1 step 178, loss is 2.288738250732422\n", - "epoch: 1 step 179, loss is 2.3248589038848877\n", - "epoch: 1 step 180, loss is 2.2906830310821533\n", - "epoch: 1 step 181, loss is 2.295781373977661\n", - "epoch: 1 step 182, loss is 2.2896437644958496\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 183, loss is 2.309624433517456\n", - "epoch: 1 step 184, loss is 2.323194742202759\n", - "epoch: 1 step 185, loss is 2.311706781387329\n", - "epoch: 1 step 186, loss is 2.3111326694488525\n", - "epoch: 1 step 187, loss is 2.3091180324554443\n", - "epoch: 1 step 188, loss is 2.2965402603149414\n", - "epoch: 1 step 189, loss is 2.295259475708008\n", - "epoch: 1 step 190, loss is 2.296231269836426\n", - "epoch: 1 step 191, loss is 2.303983211517334\n", - "epoch: 1 step 192, loss is 2.306814432144165\n", - "epoch: 1 step 193, loss is 2.2905185222625732\n", - "epoch: 1 step 194, loss is 2.308838367462158\n", - "epoch: 1 step 195, loss is 2.2948405742645264\n", - "epoch: 1 step 196, loss is 2.298696994781494\n", - "epoch: 1 step 197, loss is 2.2964284420013428\n", - "epoch: 1 step 198, loss is 2.3125040531158447\n", - "epoch: 1 step 199, loss is 2.2885444164276123\n", - "epoch: 1 step 200, loss is 2.306826114654541\n", - "epoch: 1 step 201, loss is 2.309328079223633\n", - "epoch: 1 step 202, loss is 2.2883524894714355\n", - "epoch: 1 step 203, loss is 2.304533004760742\n", - "epoch: 1 step 204, loss is 2.301948308944702\n", - "epoch: 1 step 205, loss is 2.3106493949890137\n", - "epoch: 1 step 206, loss is 2.305791139602661\n", - "epoch: 1 step 207, loss is 2.3050265312194824\n", - "epoch: 1 step 208, loss is 2.2933125495910645\n", - "epoch: 1 step 209, loss is 2.30745792388916\n", - "epoch: 1 step 210, loss is 2.312147855758667\n", - "epoch: 1 step 211, loss is 2.3021814823150635\n", - "epoch: 1 step 212, loss is 2.282095432281494\n", - "epoch: 1 step 213, loss is 2.2988312244415283\n", - "epoch: 1 step 214, loss is 2.299859046936035\n", - "epoch: 1 step 215, loss is 2.2955031394958496\n", - "epoch: 1 step 216, loss is 2.288876533508301\n", - "epoch: 1 step 217, loss is 2.2997374534606934\n", - "epoch: 1 step 218, loss is 2.2835824489593506\n", - "epoch: 1 step 219, loss is 2.3038642406463623\n", - "epoch: 1 step 220, loss is 2.298015594482422\n", - "epoch: 1 step 221, loss is 2.2944860458374023\n", - "epoch: 1 step 222, loss is 2.2981929779052734\n", - "epoch: 1 step 223, loss is 2.3046724796295166\n", - "epoch: 1 step 224, loss is 2.3166990280151367\n", - "epoch: 1 step 225, loss is 2.2997946739196777\n", - "epoch: 1 step 226, loss is 2.2982776165008545\n", - "epoch: 1 step 227, loss is 2.304516553878784\n", - "epoch: 1 step 228, loss is 2.294159173965454\n", - "epoch: 1 step 229, loss is 2.2979888916015625\n", - "epoch: 1 step 230, loss is 2.3228976726531982\n", - "epoch: 1 step 231, loss is 2.300828695297241\n", - "epoch: 1 step 232, loss is 2.3062961101531982\n", - "epoch: 1 step 233, loss is 2.3068461418151855\n", - "epoch: 1 step 234, loss is 2.2954905033111572\n", - "epoch: 1 step 235, loss is 2.315176486968994\n", - "epoch: 1 step 236, loss is 2.2987992763519287\n", - "epoch: 1 step 237, loss is 2.3124282360076904\n", - "epoch: 1 step 238, loss is 2.298109292984009\n", - "epoch: 1 step 239, loss is 2.305518865585327\n", - "epoch: 1 step 240, loss is 2.302560329437256\n", - "epoch: 1 step 241, loss is 2.303983211517334\n", - "epoch: 1 step 242, loss is 2.320657253265381\n", - "epoch: 1 step 243, loss is 2.3005549907684326\n", - "epoch: 1 step 244, loss is 2.2985103130340576\n", - "epoch: 1 step 245, loss is 2.304802894592285\n", - "epoch: 1 step 246, loss is 2.300941228866577\n", - "epoch: 1 step 247, loss is 2.323657989501953\n", - "epoch: 1 step 248, loss is 2.286917209625244\n", - "epoch: 1 step 249, loss is 2.3042843341827393\n", - "epoch: 1 step 250, loss is 2.3197810649871826\n", - "epoch: 1 step 251, loss is 2.2893900871276855\n", - "epoch: 1 step 252, loss is 2.301969289779663\n", - "epoch: 1 step 253, loss is 2.311122417449951\n", - "epoch: 1 step 254, loss is 2.2994332313537598\n", - "epoch: 1 step 255, loss is 2.306812047958374\n", - "epoch: 1 step 256, loss is 2.303797721862793\n", - "epoch: 1 step 257, loss is 2.3182919025421143\n", - "epoch: 1 step 258, loss is 2.2994771003723145\n", - "epoch: 1 step 259, loss is 2.2922940254211426\n", - "epoch: 1 step 260, loss is 2.2942943572998047\n", - "epoch: 1 step 261, loss is 2.311457395553589\n", - "epoch: 1 step 262, loss is 2.3056118488311768\n", - "epoch: 1 step 263, loss is 2.2893776893615723\n", - "epoch: 1 step 264, loss is 2.3056020736694336\n", - "epoch: 1 step 265, loss is 2.300929307937622\n", - "epoch: 1 step 266, loss is 2.2821691036224365\n", - "epoch: 1 step 267, loss is 2.3025898933410645\n", - "epoch: 1 step 268, loss is 2.3109312057495117\n", - "epoch: 1 step 269, loss is 2.3037710189819336\n", - "epoch: 1 step 270, loss is 2.300994873046875\n", - "epoch: 1 step 271, loss is 2.3064684867858887\n", - "epoch: 1 step 272, loss is 2.306129217147827\n", - "epoch: 1 step 273, loss is 2.302043914794922\n", - "epoch: 1 step 274, loss is 2.2923431396484375\n", - "epoch: 1 step 275, loss is 2.301884889602661\n", - "epoch: 1 step 276, loss is 2.291098117828369\n", - "epoch: 1 step 277, loss is 2.3073880672454834\n", - "epoch: 1 step 278, loss is 2.3108322620391846\n", - "epoch: 1 step 279, loss is 2.3005025386810303\n", - "epoch: 1 step 280, loss is 2.309103012084961\n", - "epoch: 1 step 281, loss is 2.31179141998291\n", - "epoch: 1 step 282, loss is 2.277594566345215\n", - "epoch: 1 step 283, loss is 2.31227707862854\n", - "epoch: 1 step 284, loss is 2.290104627609253\n", - "epoch: 1 step 285, loss is 2.3200223445892334\n", - "epoch: 1 step 286, loss is 2.297940254211426\n", - "epoch: 1 step 287, loss is 2.2998781204223633\n", - "epoch: 1 step 288, loss is 2.3022446632385254\n", - "epoch: 1 step 289, loss is 2.32137131690979\n", - "epoch: 1 step 290, loss is 2.303280830383301\n", - "epoch: 1 step 291, loss is 2.298297166824341\n", - "epoch: 1 step 292, loss is 2.306844472885132\n", - "epoch: 1 step 293, loss is 2.3117358684539795\n", - "epoch: 1 step 294, loss is 2.299665927886963\n", - "epoch: 1 step 295, loss is 2.305180788040161\n", - "epoch: 1 step 296, loss is 2.3082194328308105\n", - "epoch: 1 step 297, loss is 2.3148446083068848\n", - "epoch: 1 step 298, loss is 2.304473400115967\n", - "epoch: 1 step 299, loss is 2.2927048206329346\n", - "epoch: 1 step 300, loss is 2.297117233276367\n", - "epoch: 1 step 301, loss is 2.301973581314087\n", - "epoch: 1 step 302, loss is 2.299013614654541\n", - "epoch: 1 step 303, loss is 2.3000245094299316\n", - "epoch: 1 step 304, loss is 2.311347484588623\n", - "epoch: 1 step 305, loss is 2.3053359985351562\n", - "epoch: 1 step 306, loss is 2.3081910610198975\n", - "epoch: 1 step 307, loss is 2.3169445991516113\n", - "epoch: 1 step 308, loss is 2.297750949859619\n", - "epoch: 1 step 309, loss is 2.30489444732666\n", - "epoch: 1 step 310, loss is 2.29947829246521\n", - "epoch: 1 step 311, loss is 2.301111936569214\n", - "epoch: 1 step 312, loss is 2.322146415710449\n", - "epoch: 1 step 313, loss is 2.3110451698303223\n", - "epoch: 1 step 314, loss is 2.3123786449432373\n", - "epoch: 1 step 315, loss is 2.3374645709991455\n", - "epoch: 1 step 316, loss is 2.3028552532196045\n", - "epoch: 1 step 317, loss is 2.2909250259399414\n", - "epoch: 1 step 318, loss is 2.3044238090515137\n", - "epoch: 1 step 319, loss is 2.295652389526367\n", - "epoch: 1 step 320, loss is 2.3132457733154297\n", - "epoch: 1 step 321, loss is 2.299982786178589\n", - "epoch: 1 step 322, loss is 2.2876060009002686\n", - "epoch: 1 step 323, loss is 2.305941343307495\n", - "epoch: 1 step 324, loss is 2.287879705429077\n", - "epoch: 1 step 325, loss is 2.2931158542633057\n", - "epoch: 1 step 326, loss is 2.3060152530670166\n", - "epoch: 1 step 327, loss is 2.3094165325164795\n", - "epoch: 1 step 328, loss is 2.2952308654785156\n", - "epoch: 1 step 329, loss is 2.301609516143799\n", - "epoch: 1 step 330, loss is 2.3078248500823975\n", - "epoch: 1 step 331, loss is 2.307288408279419\n", - "epoch: 1 step 332, loss is 2.3012943267822266\n", - "epoch: 1 step 333, loss is 2.2988827228546143\n", - "epoch: 1 step 334, loss is 2.293768882751465\n", - "epoch: 1 step 335, loss is 2.3158555030822754\n", - "epoch: 1 step 336, loss is 2.323178768157959\n", - "epoch: 1 step 337, loss is 2.309025526046753\n", - "epoch: 1 step 338, loss is 2.3028969764709473\n", - "epoch: 1 step 339, loss is 2.2952795028686523\n", - "epoch: 1 step 340, loss is 2.307999610900879\n", - "epoch: 1 step 341, loss is 2.297755479812622\n", - "epoch: 1 step 342, loss is 2.3044004440307617\n", - "epoch: 1 step 343, loss is 2.288539409637451\n", - "epoch: 1 step 344, loss is 2.2831764221191406\n", - "epoch: 1 step 345, loss is 2.2872886657714844\n", - "epoch: 1 step 346, loss is 2.306870460510254\n", - "epoch: 1 step 347, loss is 2.312478542327881\n", - "epoch: 1 step 348, loss is 2.2926058769226074\n", - "epoch: 1 step 349, loss is 2.309343099594116\n", - "epoch: 1 step 350, loss is 2.291848659515381\n", - "epoch: 1 step 351, loss is 2.3049778938293457\n", - "epoch: 1 step 352, loss is 2.305189371109009\n", - "epoch: 1 step 353, loss is 2.294496774673462\n", - "epoch: 1 step 354, loss is 2.308093309402466\n", - "epoch: 1 step 355, loss is 2.3015782833099365\n", - "epoch: 1 step 356, loss is 2.2906839847564697\n", - "epoch: 1 step 357, loss is 2.305084705352783\n", - "epoch: 1 step 358, loss is 2.310594081878662\n", - "epoch: 1 step 359, loss is 2.291069507598877\n", - "epoch: 1 step 360, loss is 2.299825668334961\n", - "epoch: 1 step 361, loss is 2.3010685443878174\n", - "epoch: 1 step 362, loss is 2.299398183822632\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 363, loss is 2.316545009613037\n", - "epoch: 1 step 364, loss is 2.2973861694335938\n", - "epoch: 1 step 365, loss is 2.298579454421997\n", - "epoch: 1 step 366, loss is 2.299386978149414\n", - "epoch: 1 step 367, loss is 2.28235125541687\n", - "epoch: 1 step 368, loss is 2.312197208404541\n", - "epoch: 1 step 369, loss is 2.3015496730804443\n", - "epoch: 1 step 370, loss is 2.306972026824951\n", - "epoch: 1 step 371, loss is 2.300973892211914\n", - "epoch: 1 step 372, loss is 2.2951574325561523\n", - "epoch: 1 step 373, loss is 2.297781467437744\n", - "epoch: 1 step 374, loss is 2.2964324951171875\n", - "epoch: 1 step 375, loss is 2.3094630241394043\n", - "epoch: 1 step 376, loss is 2.3110594749450684\n", - "epoch: 1 step 377, loss is 2.316398859024048\n", - "epoch: 1 step 378, loss is 2.2969913482666016\n", - "epoch: 1 step 379, loss is 2.2993545532226562\n", - "epoch: 1 step 380, loss is 2.2793471813201904\n", - "epoch: 1 step 381, loss is 2.321284294128418\n", - "epoch: 1 step 382, loss is 2.308730363845825\n", - "epoch: 1 step 383, loss is 2.311279773712158\n", - "epoch: 1 step 384, loss is 2.2807345390319824\n", - "epoch: 1 step 385, loss is 2.298273801803589\n", - "epoch: 1 step 386, loss is 2.2840373516082764\n", - "epoch: 1 step 387, loss is 2.302661657333374\n", - "epoch: 1 step 388, loss is 2.2877776622772217\n", - "epoch: 1 step 389, loss is 2.2820465564727783\n", - "epoch: 1 step 390, loss is 2.3102872371673584\n", - "epoch: 1 step 391, loss is 2.3036928176879883\n", - "epoch: 1 step 392, loss is 2.3042521476745605\n", - "epoch: 1 step 393, loss is 2.3074333667755127\n", - "epoch: 1 step 394, loss is 2.3111190795898438\n", - "epoch: 1 step 395, loss is 2.294706106185913\n", - "epoch: 1 step 396, loss is 2.2674827575683594\n", - "epoch: 1 step 397, loss is 2.317141056060791\n", - "epoch: 1 step 398, loss is 2.307194471359253\n", - "epoch: 1 step 399, loss is 2.3064684867858887\n", - "epoch: 1 step 400, loss is 2.29667067527771\n", - "epoch: 1 step 401, loss is 2.316262722015381\n", - "epoch: 1 step 402, loss is 2.2922985553741455\n", - "epoch: 1 step 403, loss is 2.30635666847229\n", - "epoch: 1 step 404, loss is 2.293581008911133\n", - "epoch: 1 step 405, loss is 2.3163130283355713\n", - "epoch: 1 step 406, loss is 2.2864110469818115\n", - "epoch: 1 step 407, loss is 2.292649269104004\n", - "epoch: 1 step 408, loss is 2.3108510971069336\n", - "epoch: 1 step 409, loss is 2.3138904571533203\n", - "epoch: 1 step 410, loss is 2.3124492168426514\n", - "epoch: 1 step 411, loss is 2.286383867263794\n", - "epoch: 1 step 412, loss is 2.305741310119629\n", - "epoch: 1 step 413, loss is 2.328089952468872\n", - "epoch: 1 step 414, loss is 2.2838659286499023\n", - "epoch: 1 step 415, loss is 2.297269582748413\n", - "epoch: 1 step 416, loss is 2.3035154342651367\n", - "epoch: 1 step 417, loss is 2.327326536178589\n", - "epoch: 1 step 418, loss is 2.310253381729126\n", - "epoch: 1 step 419, loss is 2.3029470443725586\n", - "epoch: 1 step 420, loss is 2.319157123565674\n", - "epoch: 1 step 421, loss is 2.280348777770996\n", - "epoch: 1 step 422, loss is 2.3144636154174805\n", - "epoch: 1 step 423, loss is 2.309483766555786\n", - "epoch: 1 step 424, loss is 2.305119752883911\n", - "epoch: 1 step 425, loss is 2.293011426925659\n", - "epoch: 1 step 426, loss is 2.3073065280914307\n", - "epoch: 1 step 427, loss is 2.2898974418640137\n", - "epoch: 1 step 428, loss is 2.2863576412200928\n", - "epoch: 1 step 429, loss is 2.3259050846099854\n", - "epoch: 1 step 430, loss is 2.293931245803833\n", - "epoch: 1 step 431, loss is 2.3190293312072754\n", - "epoch: 1 step 432, loss is 2.3019421100616455\n", - "epoch: 1 step 433, loss is 2.29414963722229\n", - "epoch: 1 step 434, loss is 2.3056304454803467\n", - "epoch: 1 step 435, loss is 2.297004461288452\n", - "epoch: 1 step 436, loss is 2.3015122413635254\n", - "epoch: 1 step 437, loss is 2.3112151622772217\n", - "epoch: 1 step 438, loss is 2.3200738430023193\n", - "epoch: 1 step 439, loss is 2.2920126914978027\n", - "epoch: 1 step 440, loss is 2.3166749477386475\n", - "epoch: 1 step 441, loss is 2.3098225593566895\n", - "epoch: 1 step 442, loss is 2.3176872730255127\n", - "epoch: 1 step 443, loss is 2.2913010120391846\n", - "epoch: 1 step 444, loss is 2.304748296737671\n", - "epoch: 1 step 445, loss is 2.30777645111084\n", - "epoch: 1 step 446, loss is 2.301826238632202\n", - "epoch: 1 step 447, loss is 2.3115742206573486\n", - "epoch: 1 step 448, loss is 2.2836520671844482\n", - "epoch: 1 step 449, loss is 2.3101956844329834\n", - "epoch: 1 step 450, loss is 2.3099701404571533\n", - "epoch: 1 step 451, loss is 2.2856247425079346\n", - "epoch: 1 step 452, loss is 2.301503896713257\n", - "epoch: 1 step 453, loss is 2.30840802192688\n", - "epoch: 1 step 454, loss is 2.294261932373047\n", - "epoch: 1 step 455, loss is 2.306784152984619\n", - "epoch: 1 step 456, loss is 2.312567949295044\n", - "epoch: 1 step 457, loss is 2.301384687423706\n", - "epoch: 1 step 458, loss is 2.3095791339874268\n", - "epoch: 1 step 459, loss is 2.30721378326416\n", - "epoch: 1 step 460, loss is 2.2918553352355957\n", - "epoch: 1 step 461, loss is 2.297912836074829\n", - "epoch: 1 step 462, loss is 2.293703317642212\n", - "epoch: 1 step 463, loss is 2.3068270683288574\n", - "epoch: 1 step 464, loss is 2.308913469314575\n", - "epoch: 1 step 465, loss is 2.2927842140197754\n", - "epoch: 1 step 466, loss is 2.298229217529297\n", - "epoch: 1 step 467, loss is 2.3053324222564697\n", - "epoch: 1 step 468, loss is 2.311330795288086\n", - "epoch: 1 step 469, loss is 2.3048853874206543\n", - "epoch: 1 step 470, loss is 2.3125648498535156\n", - "epoch: 1 step 471, loss is 2.291192054748535\n", - "epoch: 1 step 472, loss is 2.304387092590332\n", - "epoch: 1 step 473, loss is 2.2949419021606445\n", - "epoch: 1 step 474, loss is 2.292856454849243\n", - "epoch: 1 step 475, loss is 2.3045504093170166\n", - "epoch: 1 step 476, loss is 2.3035783767700195\n", - "epoch: 1 step 477, loss is 2.3078746795654297\n", - "epoch: 1 step 478, loss is 2.2975947856903076\n", - "epoch: 1 step 479, loss is 2.2870256900787354\n", - "epoch: 1 step 480, loss is 2.3047573566436768\n", - "epoch: 1 step 481, loss is 2.288184881210327\n", - "epoch: 1 step 482, loss is 2.29794979095459\n", - "epoch: 1 step 483, loss is 2.3161563873291016\n", - "epoch: 1 step 484, loss is 2.3217427730560303\n", - "epoch: 1 step 485, loss is 2.31135892868042\n", - "epoch: 1 step 486, loss is 2.2933225631713867\n", - "epoch: 1 step 487, loss is 2.2972028255462646\n", - "epoch: 1 step 488, loss is 2.3297030925750732\n", - "epoch: 1 step 489, loss is 2.3047773838043213\n", - "epoch: 1 step 490, loss is 2.2950005531311035\n", - "epoch: 1 step 491, loss is 2.301220655441284\n", - "epoch: 1 step 492, loss is 2.294806480407715\n", - "epoch: 1 step 493, loss is 2.3060131072998047\n", - "epoch: 1 step 494, loss is 2.2895150184631348\n", - "epoch: 1 step 495, loss is 2.3064186573028564\n", - "epoch: 1 step 496, loss is 2.2900142669677734\n", - "epoch: 1 step 497, loss is 2.3137834072113037\n", - "epoch: 1 step 498, loss is 2.2951085567474365\n", - "epoch: 1 step 499, loss is 2.2993836402893066\n", - "epoch: 1 step 500, loss is 2.292905330657959\n", - "epoch: 1 step 501, loss is 2.3023834228515625\n", - "epoch: 1 step 502, loss is 2.3147432804107666\n", - "epoch: 1 step 503, loss is 2.299447536468506\n", - "epoch: 1 step 504, loss is 2.306694984436035\n", - "epoch: 1 step 505, loss is 2.3031160831451416\n", - "epoch: 1 step 506, loss is 2.2977864742279053\n", - "epoch: 1 step 507, loss is 2.308394432067871\n", - "epoch: 1 step 508, loss is 2.3073339462280273\n", - "epoch: 1 step 509, loss is 2.3020577430725098\n", - "epoch: 1 step 510, loss is 2.3010921478271484\n", - "epoch: 1 step 511, loss is 2.300612688064575\n", - "epoch: 1 step 512, loss is 2.299712657928467\n", - "epoch: 1 step 513, loss is 2.302595853805542\n", - "epoch: 1 step 514, loss is 2.2898383140563965\n", - "epoch: 1 step 515, loss is 2.3039684295654297\n", - "epoch: 1 step 516, loss is 2.292846202850342\n", - "epoch: 1 step 517, loss is 2.291675329208374\n", - "epoch: 1 step 518, loss is 2.309509038925171\n", - "epoch: 1 step 519, loss is 2.31687068939209\n", - "epoch: 1 step 520, loss is 2.3104724884033203\n", - "epoch: 1 step 521, loss is 2.307936191558838\n", - "epoch: 1 step 522, loss is 2.3007776737213135\n", - "epoch: 1 step 523, loss is 2.293004035949707\n", - "epoch: 1 step 524, loss is 2.2929527759552\n", - "epoch: 1 step 525, loss is 2.302025079727173\n", - "epoch: 1 step 526, loss is 2.305783271789551\n", - "epoch: 1 step 527, loss is 2.31724214553833\n", - "epoch: 1 step 528, loss is 2.284543514251709\n", - "epoch: 1 step 529, loss is 2.3059749603271484\n", - "epoch: 1 step 530, loss is 2.294578790664673\n", - "epoch: 1 step 531, loss is 2.2919039726257324\n", - "epoch: 1 step 532, loss is 2.308917760848999\n", - "epoch: 1 step 533, loss is 2.293203115463257\n", - "epoch: 1 step 534, loss is 2.2920308113098145\n", - "epoch: 1 step 535, loss is 2.2818307876586914\n", - "epoch: 1 step 536, loss is 2.311978816986084\n", - "epoch: 1 step 537, loss is 2.3023197650909424\n", - "epoch: 1 step 538, loss is 2.3081576824188232\n", - "epoch: 1 step 539, loss is 2.291484832763672\n", - "epoch: 1 step 540, loss is 2.316416025161743\n", - "epoch: 1 step 541, loss is 2.30479097366333\n", - "epoch: 1 step 542, loss is 2.3058624267578125\n", - "epoch: 1 step 543, loss is 2.3109488487243652\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 544, loss is 2.2846484184265137\n", - "epoch: 1 step 545, loss is 2.303199052810669\n", - "epoch: 1 step 546, loss is 2.2937982082366943\n", - "epoch: 1 step 547, loss is 2.290144443511963\n", - "epoch: 1 step 548, loss is 2.292776346206665\n", - "epoch: 1 step 549, loss is 2.3142309188842773\n", - "epoch: 1 step 550, loss is 2.302577257156372\n", - "epoch: 1 step 551, loss is 2.2937214374542236\n", - "epoch: 1 step 552, loss is 2.298457145690918\n", - "epoch: 1 step 553, loss is 2.3043863773345947\n", - "epoch: 1 step 554, loss is 2.3041136264801025\n", - "epoch: 1 step 555, loss is 2.304441213607788\n", - "epoch: 1 step 556, loss is 2.2959136962890625\n", - "epoch: 1 step 557, loss is 2.287644624710083\n", - "epoch: 1 step 558, loss is 2.2996888160705566\n", - "epoch: 1 step 559, loss is 2.303114652633667\n", - "epoch: 1 step 560, loss is 2.3127856254577637\n", - "epoch: 1 step 561, loss is 2.2931501865386963\n", - "epoch: 1 step 562, loss is 2.3102290630340576\n", - "epoch: 1 step 563, loss is 2.3031444549560547\n", - "epoch: 1 step 564, loss is 2.3256449699401855\n", - "epoch: 1 step 565, loss is 2.3089632987976074\n", - "epoch: 1 step 566, loss is 2.296027898788452\n", - "epoch: 1 step 567, loss is 2.3051443099975586\n", - "epoch: 1 step 568, loss is 2.314303159713745\n", - "epoch: 1 step 569, loss is 2.298060178756714\n", - "epoch: 1 step 570, loss is 2.3200125694274902\n", - "epoch: 1 step 571, loss is 2.3035120964050293\n", - "epoch: 1 step 572, loss is 2.301438093185425\n", - "epoch: 1 step 573, loss is 2.309084177017212\n", - "epoch: 1 step 574, loss is 2.2914998531341553\n", - "epoch: 1 step 575, loss is 2.3038980960845947\n", - "epoch: 1 step 576, loss is 2.2964913845062256\n", - "epoch: 1 step 577, loss is 2.3185367584228516\n", - "epoch: 1 step 578, loss is 2.294168472290039\n", - "epoch: 1 step 579, loss is 2.2987618446350098\n", - "epoch: 1 step 580, loss is 2.307744026184082\n", - "epoch: 1 step 581, loss is 2.3152453899383545\n", - "epoch: 1 step 582, loss is 2.2944529056549072\n", - "epoch: 1 step 583, loss is 2.2912003993988037\n", - "epoch: 1 step 584, loss is 2.3099448680877686\n", - "epoch: 1 step 585, loss is 2.2975735664367676\n", - "epoch: 1 step 586, loss is 2.303675889968872\n", - "epoch: 1 step 587, loss is 2.304849624633789\n", - "epoch: 1 step 588, loss is 2.2880008220672607\n", - "epoch: 1 step 589, loss is 2.2954723834991455\n", - "epoch: 1 step 590, loss is 2.3061351776123047\n", - "epoch: 1 step 591, loss is 2.2987239360809326\n", - "epoch: 1 step 592, loss is 2.2963337898254395\n", - "epoch: 1 step 593, loss is 2.302501678466797\n", - "epoch: 1 step 594, loss is 2.306896686553955\n", - "epoch: 1 step 595, loss is 2.2986130714416504\n", - "epoch: 1 step 596, loss is 2.296274423599243\n", - "epoch: 1 step 597, loss is 2.285633087158203\n", - "epoch: 1 step 598, loss is 2.31473970413208\n", - "epoch: 1 step 599, loss is 2.3005778789520264\n", - "epoch: 1 step 600, loss is 2.302191734313965\n", - "epoch: 1 step 601, loss is 2.304725408554077\n", - "epoch: 1 step 602, loss is 2.3023934364318848\n", - "epoch: 1 step 603, loss is 2.318779468536377\n", - "epoch: 1 step 604, loss is 2.278282880783081\n", - "epoch: 1 step 605, loss is 2.296987533569336\n", - "epoch: 1 step 606, loss is 2.287036657333374\n", - "epoch: 1 step 607, loss is 2.296092987060547\n", - "epoch: 1 step 608, loss is 2.285728931427002\n", - "epoch: 1 step 609, loss is 2.277315139770508\n", - "epoch: 1 step 610, loss is 2.310730218887329\n", - "epoch: 1 step 611, loss is 2.2932069301605225\n", - "epoch: 1 step 612, loss is 2.2998502254486084\n", - "epoch: 1 step 613, loss is 2.33337140083313\n", - "epoch: 1 step 614, loss is 2.2876906394958496\n", - "epoch: 1 step 615, loss is 2.3134958744049072\n", - "epoch: 1 step 616, loss is 2.298297882080078\n", - "epoch: 1 step 617, loss is 2.2938692569732666\n", - "epoch: 1 step 618, loss is 2.2808151245117188\n", - "epoch: 1 step 619, loss is 2.3081531524658203\n", - "epoch: 1 step 620, loss is 2.2881011962890625\n", - "epoch: 1 step 621, loss is 2.288402795791626\n", - "epoch: 1 step 622, loss is 2.2903871536254883\n", - "epoch: 1 step 623, loss is 2.310781478881836\n", - "epoch: 1 step 624, loss is 2.3198704719543457\n", - "epoch: 1 step 625, loss is 2.291807174682617\n", - "epoch: 1 step 626, loss is 2.2885937690734863\n", - "epoch: 1 step 627, loss is 2.3097026348114014\n", - "epoch: 1 step 628, loss is 2.2967135906219482\n", - "epoch: 1 step 629, loss is 2.291393995285034\n", - "epoch: 1 step 630, loss is 2.300400733947754\n", - "epoch: 1 step 631, loss is 2.3118598461151123\n", - "epoch: 1 step 632, loss is 2.3007006645202637\n", - "epoch: 1 step 633, loss is 2.300248622894287\n", - "epoch: 1 step 634, loss is 2.320274829864502\n", - "epoch: 1 step 635, loss is 2.2868380546569824\n", - "epoch: 1 step 636, loss is 2.3002429008483887\n", - "epoch: 1 step 637, loss is 2.2873823642730713\n", - "epoch: 1 step 638, loss is 2.307615041732788\n", - "epoch: 1 step 639, loss is 2.3079922199249268\n", - "epoch: 1 step 640, loss is 2.2916922569274902\n", - "epoch: 1 step 641, loss is 2.279951572418213\n", - "epoch: 1 step 642, loss is 2.321791172027588\n", - "epoch: 1 step 643, loss is 2.2927591800689697\n", - "epoch: 1 step 644, loss is 2.3093457221984863\n", - "epoch: 1 step 645, loss is 2.305617570877075\n", - "epoch: 1 step 646, loss is 2.3011748790740967\n", - "epoch: 1 step 647, loss is 2.2950925827026367\n", - "epoch: 1 step 648, loss is 2.2976534366607666\n", - "epoch: 1 step 649, loss is 2.305446147918701\n", - "epoch: 1 step 650, loss is 2.3264527320861816\n", - "epoch: 1 step 651, loss is 2.2816526889801025\n", - "epoch: 1 step 652, loss is 2.2895913124084473\n", - "epoch: 1 step 653, loss is 2.2928690910339355\n", - "epoch: 1 step 654, loss is 2.2872660160064697\n", - "epoch: 1 step 655, loss is 2.2978932857513428\n", - "epoch: 1 step 656, loss is 2.298518657684326\n", - "epoch: 1 step 657, loss is 2.2940309047698975\n", - "epoch: 1 step 658, loss is 2.3062477111816406\n", - "epoch: 1 step 659, loss is 2.2833542823791504\n", - "epoch: 1 step 660, loss is 2.297724723815918\n", - "epoch: 1 step 661, loss is 2.290584087371826\n", - "epoch: 1 step 662, loss is 2.3093016147613525\n", - "epoch: 1 step 663, loss is 2.2913601398468018\n", - "epoch: 1 step 664, loss is 2.2878904342651367\n", - "epoch: 1 step 665, loss is 2.2982962131500244\n", - "epoch: 1 step 666, loss is 2.30412220954895\n", - "epoch: 1 step 667, loss is 2.2898168563842773\n", - "epoch: 1 step 668, loss is 2.3147521018981934\n", - "epoch: 1 step 669, loss is 2.308183193206787\n", - "epoch: 1 step 670, loss is 2.2994282245635986\n", - "epoch: 1 step 671, loss is 2.312607765197754\n", - "epoch: 1 step 672, loss is 2.3106467723846436\n", - "epoch: 1 step 673, loss is 2.292339563369751\n", - "epoch: 1 step 674, loss is 2.2949345111846924\n", - "epoch: 1 step 675, loss is 2.300790309906006\n", - "epoch: 1 step 676, loss is 2.304965019226074\n", - "epoch: 1 step 677, loss is 2.2852847576141357\n", - "epoch: 1 step 678, loss is 2.3012306690216064\n", - "epoch: 1 step 679, loss is 2.312943458557129\n", - "epoch: 1 step 680, loss is 2.2971394062042236\n", - "epoch: 1 step 681, loss is 2.2854537963867188\n", - "epoch: 1 step 682, loss is 2.2959823608398438\n", - "epoch: 1 step 683, loss is 2.3153486251831055\n", - "epoch: 1 step 684, loss is 2.2996137142181396\n", - "epoch: 1 step 685, loss is 2.2879552841186523\n", - "epoch: 1 step 686, loss is 2.292052745819092\n", - "epoch: 1 step 687, loss is 2.28926157951355\n", - "epoch: 1 step 688, loss is 2.302530527114868\n", - "epoch: 1 step 689, loss is 2.2990405559539795\n", - "epoch: 1 step 690, loss is 2.3113174438476562\n", - "epoch: 1 step 691, loss is 2.311800003051758\n", - "epoch: 1 step 692, loss is 2.2938122749328613\n", - "epoch: 1 step 693, loss is 2.281641721725464\n", - "epoch: 1 step 694, loss is 2.315920114517212\n", - "epoch: 1 step 695, loss is 2.3154196739196777\n", - "epoch: 1 step 696, loss is 2.29622220993042\n", - "epoch: 1 step 697, loss is 2.3036105632781982\n", - "epoch: 1 step 698, loss is 2.291242837905884\n", - "epoch: 1 step 699, loss is 2.2951271533966064\n", - "epoch: 1 step 700, loss is 2.299222230911255\n", - "epoch: 1 step 701, loss is 2.290109157562256\n", - "epoch: 1 step 702, loss is 2.2930047512054443\n", - "epoch: 1 step 703, loss is 2.280167579650879\n", - "epoch: 1 step 704, loss is 2.315762996673584\n", - "epoch: 1 step 705, loss is 2.3222908973693848\n", - "epoch: 1 step 706, loss is 2.2864747047424316\n", - "epoch: 1 step 707, loss is 2.267042636871338\n", - "epoch: 1 step 708, loss is 2.3018813133239746\n", - "epoch: 1 step 709, loss is 2.281364917755127\n", - "epoch: 1 step 710, loss is 2.307040214538574\n", - "epoch: 1 step 711, loss is 2.308441162109375\n", - "epoch: 1 step 712, loss is 2.322699785232544\n", - "epoch: 1 step 713, loss is 2.2905800342559814\n", - "epoch: 1 step 714, loss is 2.284076690673828\n", - "epoch: 1 step 715, loss is 2.3076560497283936\n", - "epoch: 1 step 716, loss is 2.29257869720459\n", - "epoch: 1 step 717, loss is 2.282029628753662\n", - "epoch: 1 step 718, loss is 2.312410831451416\n", - "epoch: 1 step 719, loss is 2.298229932785034\n", - "epoch: 1 step 720, loss is 2.259955883026123\n", - "epoch: 1 step 721, loss is 2.310192584991455\n", - "epoch: 1 step 722, loss is 2.317457675933838\n", - "epoch: 1 step 723, loss is 2.2887001037597656\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 724, loss is 2.311528205871582\n", - "epoch: 1 step 725, loss is 2.2796037197113037\n", - "epoch: 1 step 726, loss is 2.2791337966918945\n", - "epoch: 1 step 727, loss is 2.2870848178863525\n", - "epoch: 1 step 728, loss is 2.2893407344818115\n", - "epoch: 1 step 729, loss is 2.3080923557281494\n", - "epoch: 1 step 730, loss is 2.281989574432373\n", - "epoch: 1 step 731, loss is 2.287876844406128\n", - "epoch: 1 step 732, loss is 2.2949070930480957\n", - "epoch: 1 step 733, loss is 2.3051536083221436\n", - "epoch: 1 step 734, loss is 2.2933919429779053\n", - "epoch: 1 step 735, loss is 2.2848522663116455\n", - "epoch: 1 step 736, loss is 2.296999216079712\n", - "epoch: 1 step 737, loss is 2.283834934234619\n", - "epoch: 1 step 738, loss is 2.313833475112915\n", - "epoch: 1 step 739, loss is 2.289297580718994\n", - "epoch: 1 step 740, loss is 2.3047103881835938\n", - "epoch: 1 step 741, loss is 2.310509443283081\n", - "epoch: 1 step 742, loss is 2.300405502319336\n", - "epoch: 1 step 743, loss is 2.2882189750671387\n", - "epoch: 1 step 744, loss is 2.2621119022369385\n", - "epoch: 1 step 745, loss is 2.298179864883423\n", - "epoch: 1 step 746, loss is 2.293515920639038\n", - "epoch: 1 step 747, loss is 2.3081891536712646\n", - "epoch: 1 step 748, loss is 2.289299726486206\n", - "epoch: 1 step 749, loss is 2.294929027557373\n", - "epoch: 1 step 750, loss is 2.2733545303344727\n", - "epoch: 1 step 751, loss is 2.27662992477417\n", - "epoch: 1 step 752, loss is 2.291785955429077\n", - "epoch: 1 step 753, loss is 2.2820146083831787\n", - "epoch: 1 step 754, loss is 2.2796335220336914\n", - "epoch: 1 step 755, loss is 2.300360918045044\n", - "epoch: 1 step 756, loss is 2.285766839981079\n", - "epoch: 1 step 757, loss is 2.275282382965088\n", - "epoch: 1 step 758, loss is 2.289869785308838\n", - "epoch: 1 step 759, loss is 2.288311243057251\n", - "epoch: 1 step 760, loss is 2.2835910320281982\n", - "epoch: 1 step 761, loss is 2.2774996757507324\n", - "epoch: 1 step 762, loss is 2.2717692852020264\n", - "epoch: 1 step 763, loss is 2.2631680965423584\n", - "epoch: 1 step 764, loss is 2.2731502056121826\n", - "epoch: 1 step 765, loss is 2.281693458557129\n", - "epoch: 1 step 766, loss is 2.2641055583953857\n", - "epoch: 1 step 767, loss is 2.271340847015381\n", - "epoch: 1 step 768, loss is 2.275526285171509\n", - "epoch: 1 step 769, loss is 2.2647759914398193\n", - "epoch: 1 step 770, loss is 2.2564775943756104\n", - "epoch: 1 step 771, loss is 2.2807374000549316\n", - "epoch: 1 step 772, loss is 2.2322680950164795\n", - "epoch: 1 step 773, loss is 2.2390637397766113\n", - "epoch: 1 step 774, loss is 2.254652261734009\n", - "epoch: 1 step 775, loss is 2.2351579666137695\n", - "epoch: 1 step 776, loss is 2.2300965785980225\n", - "epoch: 1 step 777, loss is 2.263421058654785\n", - "epoch: 1 step 778, loss is 2.2214722633361816\n", - "epoch: 1 step 779, loss is 2.220160484313965\n", - "epoch: 1 step 780, loss is 2.224086284637451\n", - "epoch: 1 step 781, loss is 2.1890642642974854\n", - "epoch: 1 step 782, loss is 2.212411880493164\n", - "epoch: 1 step 783, loss is 2.2310309410095215\n", - "epoch: 1 step 784, loss is 2.215427875518799\n", - "epoch: 1 step 785, loss is 2.181779623031616\n", - "epoch: 1 step 786, loss is 2.1368837356567383\n", - "epoch: 1 step 787, loss is 2.200275421142578\n", - "epoch: 1 step 788, loss is 2.0769481658935547\n", - "epoch: 1 step 789, loss is 2.0798652172088623\n", - "epoch: 1 step 790, loss is 1.9962787628173828\n", - "epoch: 1 step 791, loss is 2.085353374481201\n", - "epoch: 1 step 792, loss is 2.023948907852173\n", - "epoch: 1 step 793, loss is 1.9775162935256958\n", - "epoch: 1 step 794, loss is 2.0264859199523926\n", - "epoch: 1 step 795, loss is 1.8990428447723389\n", - "epoch: 1 step 796, loss is 1.8507258892059326\n", - "epoch: 1 step 797, loss is 1.8836371898651123\n", - "epoch: 1 step 798, loss is 1.8537689447402954\n", - "epoch: 1 step 799, loss is 1.5868067741394043\n", - "epoch: 1 step 800, loss is 1.6315590143203735\n", - "epoch: 1 step 801, loss is 1.4959402084350586\n", - "epoch: 1 step 802, loss is 1.581732988357544\n", - "epoch: 1 step 803, loss is 1.3930209875106812\n", - "epoch: 1 step 804, loss is 1.8094263076782227\n", - "epoch: 1 step 805, loss is 1.2004598379135132\n", - "epoch: 1 step 806, loss is 1.5204395055770874\n", - "epoch: 1 step 807, loss is 1.0562299489974976\n", - "epoch: 1 step 808, loss is 1.1175340414047241\n", - "epoch: 1 step 809, loss is 1.110710620880127\n", - "epoch: 1 step 810, loss is 1.22267746925354\n", - "epoch: 1 step 811, loss is 0.9916217923164368\n", - "epoch: 1 step 812, loss is 1.3536423444747925\n", - "epoch: 1 step 813, loss is 1.3294962644577026\n", - "epoch: 1 step 814, loss is 1.222076416015625\n", - "epoch: 1 step 815, loss is 1.1926804780960083\n", - "epoch: 1 step 816, loss is 1.2677249908447266\n", - "epoch: 1 step 817, loss is 0.7866724729537964\n", - "epoch: 1 step 818, loss is 1.2224595546722412\n", - "epoch: 1 step 819, loss is 1.3521312475204468\n", - "epoch: 1 step 820, loss is 1.3983004093170166\n", - "epoch: 1 step 821, loss is 1.2548807859420776\n", - "epoch: 1 step 822, loss is 1.1634089946746826\n", - "epoch: 1 step 823, loss is 1.2329490184783936\n", - "epoch: 1 step 824, loss is 0.927302896976471\n", - "epoch: 1 step 825, loss is 1.3058924674987793\n", - "epoch: 1 step 826, loss is 0.88958340883255\n", - "epoch: 1 step 827, loss is 1.2157689332962036\n", - "epoch: 1 step 828, loss is 0.7676456570625305\n", - "epoch: 1 step 829, loss is 1.3338539600372314\n", - "epoch: 1 step 830, loss is 1.210726022720337\n", - "epoch: 1 step 831, loss is 1.4619954824447632\n", - "epoch: 1 step 832, loss is 1.070967674255371\n", - "epoch: 1 step 833, loss is 1.2459098100662231\n", - "epoch: 1 step 834, loss is 1.0285723209381104\n", - "epoch: 1 step 835, loss is 1.5987755060195923\n", - "epoch: 1 step 836, loss is 1.3421015739440918\n", - "epoch: 1 step 837, loss is 1.0287829637527466\n", - "epoch: 1 step 838, loss is 0.8404675722122192\n", - "epoch: 1 step 839, loss is 0.8053593635559082\n", - "epoch: 1 step 840, loss is 1.134331226348877\n", - "epoch: 1 step 841, loss is 0.8719921708106995\n", - "epoch: 1 step 842, loss is 0.981346607208252\n", - "epoch: 1 step 843, loss is 0.8902426958084106\n", - "epoch: 1 step 844, loss is 1.1104727983474731\n", - "epoch: 1 step 845, loss is 0.9911269545555115\n", - "epoch: 1 step 846, loss is 1.0488018989562988\n", - "epoch: 1 step 847, loss is 0.7992566227912903\n", - "epoch: 1 step 848, loss is 0.7287769317626953\n", - "epoch: 1 step 849, loss is 0.577411413192749\n", - "epoch: 1 step 850, loss is 0.8648281097412109\n", - "epoch: 1 step 851, loss is 1.8254376649856567\n", - "epoch: 1 step 852, loss is 0.9343538880348206\n", - "epoch: 1 step 853, loss is 1.118343472480774\n", - "epoch: 1 step 854, loss is 0.7372920513153076\n", - "epoch: 1 step 855, loss is 0.7415173053741455\n", - "epoch: 1 step 856, loss is 0.733338475227356\n", - "epoch: 1 step 857, loss is 0.7452120780944824\n", - "epoch: 1 step 858, loss is 0.7284213304519653\n", - "epoch: 1 step 859, loss is 0.7050371170043945\n", - "epoch: 1 step 860, loss is 0.6951356530189514\n", - "epoch: 1 step 861, loss is 0.9011646509170532\n", - "epoch: 1 step 862, loss is 0.5518014430999756\n", - "epoch: 1 step 863, loss is 0.5539737343788147\n", - "epoch: 1 step 864, loss is 0.8515357971191406\n", - "epoch: 1 step 865, loss is 0.8021255731582642\n", - "epoch: 1 step 866, loss is 0.8317680358886719\n", - "epoch: 1 step 867, loss is 0.7628864049911499\n", - "epoch: 1 step 868, loss is 1.076028823852539\n", - "epoch: 1 step 869, loss is 0.8407242298126221\n", - "epoch: 1 step 870, loss is 0.9949799180030823\n", - "epoch: 1 step 871, loss is 0.740688681602478\n", - "epoch: 1 step 872, loss is 0.8933119773864746\n", - "epoch: 1 step 873, loss is 0.606465220451355\n", - "epoch: 1 step 874, loss is 0.7506833672523499\n", - "epoch: 1 step 875, loss is 0.683668315410614\n", - "epoch: 1 step 876, loss is 0.40669941902160645\n", - "epoch: 1 step 877, loss is 0.8291460275650024\n", - "epoch: 1 step 878, loss is 0.3711823523044586\n", - "epoch: 1 step 879, loss is 0.7083078622817993\n", - "epoch: 1 step 880, loss is 0.6440669894218445\n", - "epoch: 1 step 881, loss is 1.1711574792861938\n", - "epoch: 1 step 882, loss is 0.8168731331825256\n", - "epoch: 1 step 883, loss is 0.7596681714057922\n", - "epoch: 1 step 884, loss is 0.6600638628005981\n", - "epoch: 1 step 885, loss is 0.711455225944519\n", - "epoch: 1 step 886, loss is 0.4803568124771118\n", - "epoch: 1 step 887, loss is 0.5074321627616882\n", - "epoch: 1 step 888, loss is 0.5216010212898254\n", - "epoch: 1 step 889, loss is 0.5154662132263184\n", - "epoch: 1 step 890, loss is 0.8748500943183899\n", - "epoch: 1 step 891, loss is 0.6415078043937683\n", - "epoch: 1 step 892, loss is 0.331193208694458\n", - "epoch: 1 step 893, loss is 0.48383283615112305\n", - "epoch: 1 step 894, loss is 0.3206727206707001\n", - "epoch: 1 step 895, loss is 0.33423829078674316\n", - "epoch: 1 step 896, loss is 0.5230504274368286\n", - "epoch: 1 step 897, loss is 0.5705544352531433\n", - "epoch: 1 step 898, loss is 0.6121129393577576\n", - "epoch: 1 step 899, loss is 0.3681733310222626\n", - "epoch: 1 step 900, loss is 0.32715505361557007\n", - "epoch: 1 step 901, loss is 0.7740625739097595\n", - "epoch: 1 step 902, loss is 0.37605494260787964\n", - "epoch: 1 step 903, loss is 0.2818998396396637\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 904, loss is 0.8959805369377136\n", - "epoch: 1 step 905, loss is 0.35969066619873047\n", - "epoch: 1 step 906, loss is 0.5569093823432922\n", - "epoch: 1 step 907, loss is 0.6490380167961121\n", - "epoch: 1 step 908, loss is 0.4854198098182678\n", - "epoch: 1 step 909, loss is 0.681684136390686\n", - "epoch: 1 step 910, loss is 0.5594454407691956\n", - "epoch: 1 step 911, loss is 0.28246811032295227\n", - "epoch: 1 step 912, loss is 0.564134955406189\n", - "epoch: 1 step 913, loss is 0.3480125367641449\n", - "epoch: 1 step 914, loss is 0.30245739221572876\n", - "epoch: 1 step 915, loss is 0.3057793080806732\n", - "epoch: 1 step 916, loss is 0.40296462178230286\n", - "epoch: 1 step 917, loss is 0.5620078444480896\n", - "epoch: 1 step 918, loss is 0.3885918855667114\n", - "epoch: 1 step 919, loss is 0.3405517637729645\n", - "epoch: 1 step 920, loss is 0.5268466472625732\n", - "epoch: 1 step 921, loss is 0.11871110647916794\n", - "epoch: 1 step 922, loss is 0.4030132293701172\n", - "epoch: 1 step 923, loss is 0.44585901498794556\n", - "epoch: 1 step 924, loss is 0.42256829142570496\n", - "epoch: 1 step 925, loss is 0.05742168426513672\n", - "epoch: 1 step 926, loss is 0.43707379698753357\n", - "epoch: 1 step 927, loss is 0.31248682737350464\n", - "epoch: 1 step 928, loss is 0.48477858304977417\n", - "epoch: 1 step 929, loss is 0.22904114425182343\n", - "epoch: 1 step 930, loss is 0.6515914797782898\n", - "epoch: 1 step 931, loss is 0.38605231046676636\n", - "epoch: 1 step 932, loss is 0.5625531673431396\n", - "epoch: 1 step 933, loss is 0.39168664813041687\n", - "epoch: 1 step 934, loss is 0.20879001915454865\n", - "epoch: 1 step 935, loss is 0.2718164324760437\n", - "epoch: 1 step 936, loss is 0.5753874778747559\n", - "epoch: 1 step 937, loss is 0.4230019152164459\n", - "epoch: 1 step 938, loss is 0.4174725115299225\n", - "epoch: 1 step 939, loss is 0.8505776524543762\n", - "epoch: 1 step 940, loss is 0.25025784969329834\n", - "epoch: 1 step 941, loss is 0.711872398853302\n", - "epoch: 1 step 942, loss is 0.1983395218849182\n", - "epoch: 1 step 943, loss is 0.3040161728858948\n", - "epoch: 1 step 944, loss is 0.4821297824382782\n", - "epoch: 1 step 945, loss is 0.5496278405189514\n", - "epoch: 1 step 946, loss is 0.3190930187702179\n", - "epoch: 1 step 947, loss is 0.3668420910835266\n", - "epoch: 1 step 948, loss is 0.3687497675418854\n", - "epoch: 1 step 949, loss is 0.15128424763679504\n", - "epoch: 1 step 950, loss is 0.474439412355423\n", - "epoch: 1 step 951, loss is 0.4503163993358612\n", - "epoch: 1 step 952, loss is 0.3093399405479431\n", - "epoch: 1 step 953, loss is 0.2081325352191925\n", - "epoch: 1 step 954, loss is 0.564822256565094\n", - "epoch: 1 step 955, loss is 0.6963821053504944\n", - "epoch: 1 step 956, loss is 0.516822874546051\n", - "epoch: 1 step 957, loss is 0.08782825618982315\n", - "epoch: 1 step 958, loss is 0.7355473041534424\n", - "epoch: 1 step 959, loss is 0.3020493984222412\n", - "epoch: 1 step 960, loss is 0.17054177820682526\n", - "epoch: 1 step 961, loss is 0.29689866304397583\n", - "epoch: 1 step 962, loss is 0.2564084529876709\n", - "epoch: 1 step 963, loss is 0.32002487778663635\n", - "epoch: 1 step 964, loss is 0.6085982322692871\n", - "epoch: 1 step 965, loss is 0.2022058367729187\n", - "epoch: 1 step 966, loss is 0.28568506240844727\n", - "epoch: 1 step 967, loss is 0.40296539664268494\n", - "epoch: 1 step 968, loss is 0.7496739029884338\n", - "epoch: 1 step 969, loss is 0.20458398759365082\n", - "epoch: 1 step 970, loss is 0.2953733801841736\n", - "epoch: 1 step 971, loss is 0.5422435998916626\n", - "epoch: 1 step 972, loss is 0.29642194509506226\n", - "epoch: 1 step 973, loss is 0.3858273923397064\n", - "epoch: 1 step 974, loss is 0.3633837401866913\n", - "epoch: 1 step 975, loss is 0.25124484300613403\n", - "epoch: 1 step 976, loss is 0.20992040634155273\n", - "epoch: 1 step 977, loss is 0.13602547347545624\n", - "epoch: 1 step 978, loss is 0.1998327523469925\n", - "epoch: 1 step 979, loss is 0.30320289731025696\n", - "epoch: 1 step 980, loss is 0.33806726336479187\n", - "epoch: 1 step 981, loss is 0.6388981938362122\n", - "epoch: 1 step 982, loss is 0.36718547344207764\n", - "epoch: 1 step 983, loss is 0.2681766450405121\n", - "epoch: 1 step 984, loss is 0.26537206768989563\n", - "epoch: 1 step 985, loss is 0.3361125588417053\n", - "epoch: 1 step 986, loss is 0.6573469638824463\n", - "epoch: 1 step 987, loss is 0.24379801750183105\n", - "epoch: 1 step 988, loss is 0.31784507632255554\n", - "epoch: 1 step 989, loss is 0.27742987871170044\n", - "epoch: 1 step 990, loss is 0.5038543343544006\n", - "epoch: 1 step 991, loss is 0.09328068047761917\n", - "epoch: 1 step 992, loss is 0.40782731771469116\n", - "epoch: 1 step 993, loss is 0.08224949240684509\n", - "epoch: 1 step 994, loss is 0.2283739447593689\n", - "epoch: 1 step 995, loss is 0.2058914601802826\n", - "epoch: 1 step 996, loss is 0.5321757793426514\n", - "epoch: 1 step 997, loss is 0.15863986313343048\n", - "epoch: 1 step 998, loss is 0.2732018828392029\n", - "epoch: 1 step 999, loss is 0.21776258945465088\n", - "epoch: 1 step 1000, loss is 0.3760163187980652\n", - "epoch: 1 step 1001, loss is 0.2683853507041931\n", - "epoch: 1 step 1002, loss is 0.2589399218559265\n", - "epoch: 1 step 1003, loss is 0.04534674063324928\n", - "epoch: 1 step 1004, loss is 0.5600655674934387\n", - "epoch: 1 step 1005, loss is 0.2572353780269623\n", - "epoch: 1 step 1006, loss is 0.7334855198860168\n", - "epoch: 1 step 1007, loss is 0.2793818712234497\n", - "epoch: 1 step 1008, loss is 0.11112275719642639\n", - "epoch: 1 step 1009, loss is 0.4475588798522949\n", - "epoch: 1 step 1010, loss is 0.27338021993637085\n", - "epoch: 1 step 1011, loss is 0.20580638945102692\n", - "epoch: 1 step 1012, loss is 0.40580126643180847\n", - "epoch: 1 step 1013, loss is 0.07276472449302673\n", - "epoch: 1 step 1014, loss is 0.3398958146572113\n", - "epoch: 1 step 1015, loss is 0.6265392303466797\n", - "epoch: 1 step 1016, loss is 0.08471273630857468\n", - "epoch: 1 step 1017, loss is 0.31604471802711487\n", - "epoch: 1 step 1018, loss is 0.338906854391098\n", - "epoch: 1 step 1019, loss is 0.49559280276298523\n", - "epoch: 1 step 1020, loss is 0.27650532126426697\n", - "epoch: 1 step 1021, loss is 0.6406198740005493\n", - "epoch: 1 step 1022, loss is 0.3085279166698456\n", - "epoch: 1 step 1023, loss is 0.4372611939907074\n", - "epoch: 1 step 1024, loss is 0.5810808539390564\n", - "epoch: 1 step 1025, loss is 0.4246627688407898\n", - "epoch: 1 step 1026, loss is 0.3712407648563385\n", - "epoch: 1 step 1027, loss is 0.3081851303577423\n", - "epoch: 1 step 1028, loss is 0.21821783483028412\n", - "epoch: 1 step 1029, loss is 0.5841119885444641\n", - "epoch: 1 step 1030, loss is 0.3688592314720154\n", - "epoch: 1 step 1031, loss is 0.31897640228271484\n", - "epoch: 1 step 1032, loss is 0.2769280970096588\n", - "epoch: 1 step 1033, loss is 0.5379514098167419\n", - "epoch: 1 step 1034, loss is 0.25380346179008484\n", - "epoch: 1 step 1035, loss is 0.34640347957611084\n", - "epoch: 1 step 1036, loss is 0.16768336296081543\n", - "epoch: 1 step 1037, loss is 0.3480660319328308\n", - "epoch: 1 step 1038, loss is 0.38453879952430725\n", - "epoch: 1 step 1039, loss is 0.3001658022403717\n", - "epoch: 1 step 1040, loss is 0.7822790145874023\n", - "epoch: 1 step 1041, loss is 0.2834794819355011\n", - "epoch: 1 step 1042, loss is 0.3137734830379486\n", - "epoch: 1 step 1043, loss is 0.5421685576438904\n", - "epoch: 1 step 1044, loss is 0.18315750360488892\n", - "epoch: 1 step 1045, loss is 0.05776865780353546\n", - "epoch: 1 step 1046, loss is 0.27788466215133667\n", - "epoch: 1 step 1047, loss is 0.3679546117782593\n", - "epoch: 1 step 1048, loss is 0.4025610387325287\n", - "epoch: 1 step 1049, loss is 0.4029242694377899\n", - "epoch: 1 step 1050, loss is 0.16425970196723938\n", - "epoch: 1 step 1051, loss is 0.14769382774829865\n", - "epoch: 1 step 1052, loss is 0.1314668357372284\n", - "epoch: 1 step 1053, loss is 0.2774055004119873\n", - "epoch: 1 step 1054, loss is 0.6040791869163513\n", - "epoch: 1 step 1055, loss is 0.15977488458156586\n", - "epoch: 1 step 1056, loss is 0.3691514730453491\n", - "epoch: 1 step 1057, loss is 0.28412625193595886\n", - "epoch: 1 step 1058, loss is 0.5344435572624207\n", - "epoch: 1 step 1059, loss is 0.4580501317977905\n", - "epoch: 1 step 1060, loss is 0.12012836337089539\n", - "epoch: 1 step 1061, loss is 0.18099641799926758\n", - "epoch: 1 step 1062, loss is 0.08387185633182526\n", - "epoch: 1 step 1063, loss is 0.4229600131511688\n", - "epoch: 1 step 1064, loss is 0.23241564631462097\n", - "epoch: 1 step 1065, loss is 0.6064302921295166\n", - "epoch: 1 step 1066, loss is 0.617723286151886\n", - "epoch: 1 step 1067, loss is 0.08103369176387787\n", - "epoch: 1 step 1068, loss is 0.2632162868976593\n", - "epoch: 1 step 1069, loss is 0.09751598536968231\n", - "epoch: 1 step 1070, loss is 0.09698432683944702\n", - "epoch: 1 step 1071, loss is 0.2307710200548172\n", - "epoch: 1 step 1072, loss is 0.24673278629779816\n", - "epoch: 1 step 1073, loss is 0.47342631220817566\n", - "epoch: 1 step 1074, loss is 0.26532411575317383\n", - "epoch: 1 step 1075, loss is 0.17981591820716858\n", - "epoch: 1 step 1076, loss is 0.21233554184436798\n", - "epoch: 1 step 1077, loss is 0.1286160945892334\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 1078, loss is 0.22428953647613525\n", - "epoch: 1 step 1079, loss is 0.19300851225852966\n", - "epoch: 1 step 1080, loss is 0.13316313922405243\n", - "epoch: 1 step 1081, loss is 0.33551234006881714\n", - "epoch: 1 step 1082, loss is 0.6692869067192078\n", - "epoch: 1 step 1083, loss is 0.18172471225261688\n", - "epoch: 1 step 1084, loss is 0.44903361797332764\n", - "epoch: 1 step 1085, loss is 0.22222338616847992\n", - "epoch: 1 step 1086, loss is 0.23797328770160675\n", - "epoch: 1 step 1087, loss is 0.540205717086792\n", - "epoch: 1 step 1088, loss is 0.3685106635093689\n", - "epoch: 1 step 1089, loss is 0.34796908497810364\n", - "epoch: 1 step 1090, loss is 0.06477059423923492\n", - "epoch: 1 step 1091, loss is 0.2196572870016098\n", - "epoch: 1 step 1092, loss is 0.31783750653266907\n", - "epoch: 1 step 1093, loss is 0.4156820774078369\n", - "epoch: 1 step 1094, loss is 0.5367379784584045\n", - "epoch: 1 step 1095, loss is 0.2490120530128479\n", - "epoch: 1 step 1096, loss is 0.2063281387090683\n", - "epoch: 1 step 1097, loss is 0.3062203824520111\n", - "epoch: 1 step 1098, loss is 0.5498185753822327\n", - "epoch: 1 step 1099, loss is 0.24774104356765747\n", - "epoch: 1 step 1100, loss is 0.17051738500595093\n", - "epoch: 1 step 1101, loss is 0.23986303806304932\n", - "epoch: 1 step 1102, loss is 0.4491817057132721\n", - "epoch: 1 step 1103, loss is 0.3186136484146118\n", - "epoch: 1 step 1104, loss is 0.3498857617378235\n", - "epoch: 1 step 1105, loss is 0.28111812472343445\n", - "epoch: 1 step 1106, loss is 0.32438984513282776\n", - "epoch: 1 step 1107, loss is 0.073697529733181\n", - "epoch: 1 step 1108, loss is 0.6178018450737\n", - "epoch: 1 step 1109, loss is 0.3223627805709839\n", - "epoch: 1 step 1110, loss is 0.4303666353225708\n", - "epoch: 1 step 1111, loss is 0.35319793224334717\n", - "epoch: 1 step 1112, loss is 0.15253594517707825\n", - "epoch: 1 step 1113, loss is 0.1582525074481964\n", - "epoch: 1 step 1114, loss is 0.29381710290908813\n", - "epoch: 1 step 1115, loss is 0.40499237179756165\n", - "epoch: 1 step 1116, loss is 0.2567298114299774\n", - "epoch: 1 step 1117, loss is 0.1395392268896103\n", - "epoch: 1 step 1118, loss is 0.1815434694290161\n", - "epoch: 1 step 1119, loss is 0.1104380339384079\n", - "epoch: 1 step 1120, loss is 0.19085386395454407\n", - "epoch: 1 step 1121, loss is 0.2832586467266083\n", - "epoch: 1 step 1122, loss is 0.0957142785191536\n", - "epoch: 1 step 1123, loss is 0.06894905865192413\n", - "epoch: 1 step 1124, loss is 0.09497775882482529\n", - "epoch: 1 step 1125, loss is 0.09656362980604172\n", - "epoch: 1 step 1126, loss is 0.20896317064762115\n", - "epoch: 1 step 1127, loss is 0.07586798071861267\n", - "epoch: 1 step 1128, loss is 0.31554341316223145\n", - "epoch: 1 step 1129, loss is 0.30824175477027893\n", - "epoch: 1 step 1130, loss is 0.32638534903526306\n", - "epoch: 1 step 1131, loss is 0.46965035796165466\n", - "epoch: 1 step 1132, loss is 0.40726661682128906\n", - "epoch: 1 step 1133, loss is 0.23672117292881012\n", - "epoch: 1 step 1134, loss is 0.6298201680183411\n", - "epoch: 1 step 1135, loss is 0.20049166679382324\n", - "epoch: 1 step 1136, loss is 0.4530198574066162\n", - "epoch: 1 step 1137, loss is 0.06658273190259933\n", - "epoch: 1 step 1138, loss is 0.03635825589299202\n", - "epoch: 1 step 1139, loss is 0.4011572003364563\n", - "epoch: 1 step 1140, loss is 0.3976319432258606\n", - "epoch: 1 step 1141, loss is 0.282844603061676\n", - "epoch: 1 step 1142, loss is 0.45697933435440063\n", - "epoch: 1 step 1143, loss is 0.15638460218906403\n", - "epoch: 1 step 1144, loss is 0.28267666697502136\n", - "epoch: 1 step 1145, loss is 0.12315250933170319\n", - "epoch: 1 step 1146, loss is 0.27250251173973083\n", - "epoch: 1 step 1147, loss is 0.2064804881811142\n", - "epoch: 1 step 1148, loss is 0.29979947209358215\n", - "epoch: 1 step 1149, loss is 0.4557610750198364\n", - "epoch: 1 step 1150, loss is 0.3270760774612427\n", - "epoch: 1 step 1151, loss is 0.41850700974464417\n", - "epoch: 1 step 1152, loss is 0.1860130876302719\n", - "epoch: 1 step 1153, loss is 0.27925026416778564\n", - "epoch: 1 step 1154, loss is 0.4810539484024048\n", - "epoch: 1 step 1155, loss is 0.12464289367198944\n", - "epoch: 1 step 1156, loss is 0.16106286644935608\n", - "epoch: 1 step 1157, loss is 0.16907911002635956\n", - "epoch: 1 step 1158, loss is 0.06749197095632553\n", - "epoch: 1 step 1159, loss is 0.29827752709388733\n", - "epoch: 1 step 1160, loss is 0.24341711401939392\n", - "epoch: 1 step 1161, loss is 0.08036495745182037\n", - "epoch: 1 step 1162, loss is 0.24053184688091278\n", - "epoch: 1 step 1163, loss is 0.11434865742921829\n", - "epoch: 1 step 1164, loss is 0.13994774222373962\n", - "epoch: 1 step 1165, loss is 0.045894984155893326\n", - "epoch: 1 step 1166, loss is 0.18184658885002136\n", - "epoch: 1 step 1167, loss is 0.1025833785533905\n", - "epoch: 1 step 1168, loss is 0.29611027240753174\n", - "epoch: 1 step 1169, loss is 0.14438430964946747\n", - "epoch: 1 step 1170, loss is 0.29945775866508484\n", - "epoch: 1 step 1171, loss is 0.2431691586971283\n", - "epoch: 1 step 1172, loss is 0.2653314769268036\n", - "epoch: 1 step 1173, loss is 0.23848384618759155\n", - "epoch: 1 step 1174, loss is 0.42164602875709534\n", - "epoch: 1 step 1175, loss is 0.11151123046875\n", - "epoch: 1 step 1176, loss is 0.42921751737594604\n", - "epoch: 1 step 1177, loss is 0.12506745755672455\n", - "epoch: 1 step 1178, loss is 0.3728172183036804\n", - "epoch: 1 step 1179, loss is 0.22415082156658173\n", - "epoch: 1 step 1180, loss is 0.3576843738555908\n", - "epoch: 1 step 1181, loss is 0.40304967761039734\n", - "epoch: 1 step 1182, loss is 0.40224263072013855\n", - "epoch: 1 step 1183, loss is 0.1798265278339386\n", - "epoch: 1 step 1184, loss is 0.5039652585983276\n", - "epoch: 1 step 1185, loss is 0.13534842431545258\n", - "epoch: 1 step 1186, loss is 0.10237590968608856\n", - "epoch: 1 step 1187, loss is 0.11380477249622345\n", - "epoch: 1 step 1188, loss is 0.33532029390335083\n", - "epoch: 1 step 1189, loss is 0.37075909972190857\n", - "epoch: 1 step 1190, loss is 0.2595348656177521\n", - "epoch: 1 step 1191, loss is 0.5487306714057922\n", - "epoch: 1 step 1192, loss is 0.23060090839862823\n", - "epoch: 1 step 1193, loss is 0.20298916101455688\n", - "epoch: 1 step 1194, loss is 0.167954221367836\n", - "epoch: 1 step 1195, loss is 0.31161487102508545\n", - "epoch: 1 step 1196, loss is 0.294167160987854\n", - "epoch: 1 step 1197, loss is 0.19163778424263\n", - "epoch: 1 step 1198, loss is 0.15200237929821014\n", - "epoch: 1 step 1199, loss is 0.32278865575790405\n", - "epoch: 1 step 1200, loss is 0.7320305705070496\n", - "epoch: 1 step 1201, loss is 0.2634473145008087\n", - "epoch: 1 step 1202, loss is 0.1496431529521942\n", - "epoch: 1 step 1203, loss is 0.33701348304748535\n", - "epoch: 1 step 1204, loss is 0.1080637201666832\n", - "epoch: 1 step 1205, loss is 0.41639846563339233\n", - "epoch: 1 step 1206, loss is 0.11405153572559357\n", - "epoch: 1 step 1207, loss is 0.11913920938968658\n", - "epoch: 1 step 1208, loss is 0.31337475776672363\n", - "epoch: 1 step 1209, loss is 0.08249074965715408\n", - "epoch: 1 step 1210, loss is 0.1016281247138977\n", - "epoch: 1 step 1211, loss is 0.1404246836900711\n", - "epoch: 1 step 1212, loss is 0.34405234456062317\n", - "epoch: 1 step 1213, loss is 0.19854076206684113\n", - "epoch: 1 step 1214, loss is 0.12035379558801651\n", - "epoch: 1 step 1215, loss is 0.13874436914920807\n", - "epoch: 1 step 1216, loss is 0.06980980932712555\n", - "epoch: 1 step 1217, loss is 0.12272334098815918\n", - "epoch: 1 step 1218, loss is 0.11663737148046494\n", - "epoch: 1 step 1219, loss is 0.22052861750125885\n", - "epoch: 1 step 1220, loss is 0.15443752706050873\n", - "epoch: 1 step 1221, loss is 0.20201179385185242\n", - "epoch: 1 step 1222, loss is 0.2150571197271347\n", - "epoch: 1 step 1223, loss is 0.21844343841075897\n", - "epoch: 1 step 1224, loss is 0.030694296583533287\n", - "epoch: 1 step 1225, loss is 0.04256812483072281\n", - "epoch: 1 step 1226, loss is 0.0408121682703495\n", - "epoch: 1 step 1227, loss is 0.22226330637931824\n", - "epoch: 1 step 1228, loss is 0.0520462691783905\n", - "epoch: 1 step 1229, loss is 0.1642502397298813\n", - "epoch: 1 step 1230, loss is 0.4938809275627136\n", - "epoch: 1 step 1231, loss is 0.07367879152297974\n", - "epoch: 1 step 1232, loss is 0.19636599719524384\n", - "epoch: 1 step 1233, loss is 0.05613357201218605\n", - "epoch: 1 step 1234, loss is 0.18221279978752136\n", - "epoch: 1 step 1235, loss is 0.17399460077285767\n", - "epoch: 1 step 1236, loss is 0.21953904628753662\n", - "epoch: 1 step 1237, loss is 0.12992781400680542\n", - "epoch: 1 step 1238, loss is 0.21823962032794952\n", - "epoch: 1 step 1239, loss is 0.06261825561523438\n", - "epoch: 1 step 1240, loss is 0.059050578624010086\n", - "epoch: 1 step 1241, loss is 0.05838501825928688\n", - "epoch: 1 step 1242, loss is 0.38619691133499146\n", - "epoch: 1 step 1243, loss is 0.07106852531433105\n", - "epoch: 1 step 1244, loss is 0.15589046478271484\n", - "epoch: 1 step 1245, loss is 0.04772113263607025\n", - "epoch: 1 step 1246, loss is 0.21523457765579224\n", - "epoch: 1 step 1247, loss is 0.5234687924385071\n", - "epoch: 1 step 1248, loss is 0.4725988507270813\n", - "epoch: 1 step 1249, loss is 0.10416189581155777\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 1250, loss is 0.524069607257843\n", - "epoch: 1 step 1251, loss is 0.2652841806411743\n", - "epoch: 1 step 1252, loss is 0.2759210765361786\n", - "epoch: 1 step 1253, loss is 0.18665245175361633\n", - "epoch: 1 step 1254, loss is 0.30893442034721375\n", - "epoch: 1 step 1255, loss is 0.23022381961345673\n", - "epoch: 1 step 1256, loss is 0.12406717985868454\n", - "epoch: 1 step 1257, loss is 0.35657501220703125\n", - "epoch: 1 step 1258, loss is 0.1813289225101471\n", - "epoch: 1 step 1259, loss is 0.19929412007331848\n", - "epoch: 1 step 1260, loss is 0.3767518401145935\n", - "epoch: 1 step 1261, loss is 0.045815952122211456\n", - "epoch: 1 step 1262, loss is 0.3493342995643616\n", - "epoch: 1 step 1263, loss is 0.2095005214214325\n", - "epoch: 1 step 1264, loss is 0.038586486130952835\n", - "epoch: 1 step 1265, loss is 0.21155467629432678\n", - "epoch: 1 step 1266, loss is 0.1904488503932953\n", - "epoch: 1 step 1267, loss is 0.30973947048187256\n", - "epoch: 1 step 1268, loss is 0.0544302798807621\n", - "epoch: 1 step 1269, loss is 0.06591106206178665\n", - "epoch: 1 step 1270, loss is 0.48256736993789673\n", - "epoch: 1 step 1271, loss is 0.13080522418022156\n", - "epoch: 1 step 1272, loss is 0.19014829397201538\n", - "epoch: 1 step 1273, loss is 0.22884391248226166\n", - "epoch: 1 step 1274, loss is 0.08307930827140808\n", - "epoch: 1 step 1275, loss is 0.3609071373939514\n", - "epoch: 1 step 1276, loss is 0.03559282049536705\n", - "epoch: 1 step 1277, loss is 0.1531498283147812\n", - "epoch: 1 step 1278, loss is 0.18672996759414673\n", - "epoch: 1 step 1279, loss is 0.2806112468242645\n", - "epoch: 1 step 1280, loss is 0.27941325306892395\n", - "epoch: 1 step 1281, loss is 0.3150455355644226\n", - "epoch: 1 step 1282, loss is 0.42465540766716003\n", - "epoch: 1 step 1283, loss is 0.06855327636003494\n", - "epoch: 1 step 1284, loss is 0.07230948656797409\n", - "epoch: 1 step 1285, loss is 0.2690505385398865\n", - "epoch: 1 step 1286, loss is 0.24108488857746124\n", - "epoch: 1 step 1287, loss is 0.15547722578048706\n", - "epoch: 1 step 1288, loss is 0.13465237617492676\n", - "epoch: 1 step 1289, loss is 0.6730027794837952\n", - "epoch: 1 step 1290, loss is 0.13007678091526031\n", - "epoch: 1 step 1291, loss is 0.02121412381529808\n", - "epoch: 1 step 1292, loss is 0.049784980714321136\n", - "epoch: 1 step 1293, loss is 0.11070896685123444\n", - "epoch: 1 step 1294, loss is 0.2565460205078125\n", - "epoch: 1 step 1295, loss is 0.05546726658940315\n", - "epoch: 1 step 1296, loss is 0.11611609905958176\n", - "epoch: 1 step 1297, loss is 0.09831753373146057\n", - "epoch: 1 step 1298, loss is 0.05479292571544647\n", - "epoch: 1 step 1299, loss is 0.21358942985534668\n", - "epoch: 1 step 1300, loss is 0.325830340385437\n", - "epoch: 1 step 1301, loss is 0.5012524127960205\n", - "epoch: 1 step 1302, loss is 0.294604629278183\n", - "epoch: 1 step 1303, loss is 0.15517286956310272\n", - "epoch: 1 step 1304, loss is 0.039048220962285995\n", - "epoch: 1 step 1305, loss is 0.0981094092130661\n", - "epoch: 1 step 1306, loss is 0.17601901292800903\n", - "epoch: 1 step 1307, loss is 0.1788097769021988\n", - "epoch: 1 step 1308, loss is 0.27252811193466187\n", - "epoch: 1 step 1309, loss is 0.2025330811738968\n", - "epoch: 1 step 1310, loss is 0.3006960153579712\n", - "epoch: 1 step 1311, loss is 0.2401321530342102\n", - "epoch: 1 step 1312, loss is 0.11384464800357819\n", - "epoch: 1 step 1313, loss is 0.13461089134216309\n", - "epoch: 1 step 1314, loss is 0.12387176603078842\n", - "epoch: 1 step 1315, loss is 0.034613706171512604\n", - "epoch: 1 step 1316, loss is 0.191122904419899\n", - "epoch: 1 step 1317, loss is 0.03321123495697975\n", - "epoch: 1 step 1318, loss is 0.13519324362277985\n", - "epoch: 1 step 1319, loss is 0.23534858226776123\n", - "epoch: 1 step 1320, loss is 0.036745283752679825\n", - "epoch: 1 step 1321, loss is 0.37704044580459595\n", - "epoch: 1 step 1322, loss is 0.4474242031574249\n", - "epoch: 1 step 1323, loss is 0.26421141624450684\n", - "epoch: 1 step 1324, loss is 0.4650835692882538\n", - "epoch: 1 step 1325, loss is 0.1605958789587021\n", - "epoch: 1 step 1326, loss is 0.09721336513757706\n", - "epoch: 1 step 1327, loss is 0.23781290650367737\n", - "epoch: 1 step 1328, loss is 0.2742028534412384\n", - "epoch: 1 step 1329, loss is 0.2173849642276764\n", - "epoch: 1 step 1330, loss is 0.13021768629550934\n", - "epoch: 1 step 1331, loss is 0.13957762718200684\n", - "epoch: 1 step 1332, loss is 0.05297097936272621\n", - "epoch: 1 step 1333, loss is 0.2608557343482971\n", - "epoch: 1 step 1334, loss is 0.34402093291282654\n", - "epoch: 1 step 1335, loss is 0.11400490254163742\n", - "epoch: 1 step 1336, loss is 0.25951486825942993\n", - "epoch: 1 step 1337, loss is 0.31313174962997437\n", - "epoch: 1 step 1338, loss is 0.19678816199302673\n", - "epoch: 1 step 1339, loss is 0.14140719175338745\n", - "epoch: 1 step 1340, loss is 0.06490781158208847\n", - "epoch: 1 step 1341, loss is 0.2738936245441437\n", - "epoch: 1 step 1342, loss is 0.14719265699386597\n", - "epoch: 1 step 1343, loss is 0.13369572162628174\n", - "epoch: 1 step 1344, loss is 0.18537528812885284\n", - "epoch: 1 step 1345, loss is 0.1548815816640854\n", - "epoch: 1 step 1346, loss is 0.20167259871959686\n", - "epoch: 1 step 1347, loss is 0.04860328882932663\n", - "epoch: 1 step 1348, loss is 0.26139897108078003\n", - "epoch: 1 step 1349, loss is 0.27616557478904724\n", - "epoch: 1 step 1350, loss is 0.09206501394510269\n", - "epoch: 1 step 1351, loss is 0.1818128377199173\n", - "epoch: 1 step 1352, loss is 0.12076954543590546\n", - "epoch: 1 step 1353, loss is 0.21239732205867767\n", - "epoch: 1 step 1354, loss is 0.3705439865589142\n", - "epoch: 1 step 1355, loss is 0.35355713963508606\n", - "epoch: 1 step 1356, loss is 0.231022447347641\n", - "epoch: 1 step 1357, loss is 0.22299233078956604\n", - "epoch: 1 step 1358, loss is 0.014381278306245804\n", - "epoch: 1 step 1359, loss is 0.19613440334796906\n", - "epoch: 1 step 1360, loss is 0.45969653129577637\n", - "epoch: 1 step 1361, loss is 0.07987777143716812\n", - "epoch: 1 step 1362, loss is 0.2917234003543854\n", - "epoch: 1 step 1363, loss is 0.21176476776599884\n", - "epoch: 1 step 1364, loss is 0.15656745433807373\n", - "epoch: 1 step 1365, loss is 0.1705927699804306\n", - "epoch: 1 step 1366, loss is 0.28086960315704346\n", - "epoch: 1 step 1367, loss is 0.27005940675735474\n", - "epoch: 1 step 1368, loss is 0.14511409401893616\n", - "epoch: 1 step 1369, loss is 0.09363985061645508\n", - "epoch: 1 step 1370, loss is 0.18109314143657684\n", - "epoch: 1 step 1371, loss is 0.22667500376701355\n", - "epoch: 1 step 1372, loss is 0.4181455969810486\n", - "epoch: 1 step 1373, loss is 0.060120873153209686\n", - "epoch: 1 step 1374, loss is 0.37927189469337463\n", - "epoch: 1 step 1375, loss is 0.21917177736759186\n", - "epoch: 1 step 1376, loss is 0.554511547088623\n", - "epoch: 1 step 1377, loss is 0.430952787399292\n", - "epoch: 1 step 1378, loss is 0.5707189440727234\n", - "epoch: 1 step 1379, loss is 0.304430216550827\n", - "epoch: 1 step 1380, loss is 0.15270961821079254\n", - "epoch: 1 step 1381, loss is 0.12651991844177246\n", - "epoch: 1 step 1382, loss is 0.15000121295452118\n", - "epoch: 1 step 1383, loss is 0.1347784847021103\n", - "epoch: 1 step 1384, loss is 0.13474896550178528\n", - "epoch: 1 step 1385, loss is 0.1895076185464859\n", - "epoch: 1 step 1386, loss is 0.19797468185424805\n", - "epoch: 1 step 1387, loss is 0.378776490688324\n", - "epoch: 1 step 1388, loss is 0.3142922818660736\n", - "epoch: 1 step 1389, loss is 0.18020403385162354\n", - "epoch: 1 step 1390, loss is 0.20521847903728485\n", - "epoch: 1 step 1391, loss is 0.15917985141277313\n", - "epoch: 1 step 1392, loss is 0.12527571618556976\n", - "epoch: 1 step 1393, loss is 0.07082045078277588\n", - "epoch: 1 step 1394, loss is 0.0378243662416935\n", - "epoch: 1 step 1395, loss is 0.3067173957824707\n", - "epoch: 1 step 1396, loss is 0.09532315284013748\n", - "epoch: 1 step 1397, loss is 0.22564195096492767\n", - "epoch: 1 step 1398, loss is 0.06700921058654785\n", - "epoch: 1 step 1399, loss is 0.19249945878982544\n", - "epoch: 1 step 1400, loss is 0.09617947787046432\n", - "epoch: 1 step 1401, loss is 0.39516302943229675\n", - "epoch: 1 step 1402, loss is 0.09691809862852097\n", - "epoch: 1 step 1403, loss is 0.048507556319236755\n", - "epoch: 1 step 1404, loss is 0.33102044463157654\n", - "epoch: 1 step 1405, loss is 0.07082463055849075\n", - "epoch: 1 step 1406, loss is 0.12862513959407806\n", - "epoch: 1 step 1407, loss is 0.42798691987991333\n", - "epoch: 1 step 1408, loss is 0.20406198501586914\n", - "epoch: 1 step 1409, loss is 0.23511460423469543\n", - "epoch: 1 step 1410, loss is 0.2709139585494995\n", - "epoch: 1 step 1411, loss is 0.19246803224086761\n", - "epoch: 1 step 1412, loss is 0.20838122069835663\n", - "epoch: 1 step 1413, loss is 0.21794021129608154\n", - "epoch: 1 step 1414, loss is 0.08478481322526932\n", - "epoch: 1 step 1415, loss is 0.012655519880354404\n", - "epoch: 1 step 1416, loss is 0.14444799721240997\n", - "epoch: 1 step 1417, loss is 0.037335995584726334\n", - "epoch: 1 step 1418, loss is 0.06604143232107162\n", - "epoch: 1 step 1419, loss is 0.14586074650287628\n", - "epoch: 1 step 1420, loss is 0.1347969025373459\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 1421, loss is 0.2732638716697693\n", - "epoch: 1 step 1422, loss is 0.28914135694503784\n", - "epoch: 1 step 1423, loss is 0.18879273533821106\n", - "epoch: 1 step 1424, loss is 0.13441845774650574\n", - "epoch: 1 step 1425, loss is 0.09011184424161911\n", - "epoch: 1 step 1426, loss is 0.1790235936641693\n", - "epoch: 1 step 1427, loss is 0.18365859985351562\n", - "epoch: 1 step 1428, loss is 0.030408916994929314\n", - "epoch: 1 step 1429, loss is 0.24467791616916656\n", - "epoch: 1 step 1430, loss is 0.29295310378074646\n", - "epoch: 1 step 1431, loss is 0.07330065965652466\n", - "epoch: 1 step 1432, loss is 0.11970701068639755\n", - "epoch: 1 step 1433, loss is 0.19104799628257751\n", - "epoch: 1 step 1434, loss is 0.22241932153701782\n", - "epoch: 1 step 1435, loss is 0.2240758091211319\n", - "epoch: 1 step 1436, loss is 0.10165629535913467\n", - "epoch: 1 step 1437, loss is 0.20622384548187256\n", - "epoch: 1 step 1438, loss is 0.22979219257831573\n", - "epoch: 1 step 1439, loss is 0.4825741946697235\n", - "epoch: 1 step 1440, loss is 0.34842449426651\n", - "epoch: 1 step 1441, loss is 0.24044188857078552\n", - "epoch: 1 step 1442, loss is 0.11065179854631424\n", - "epoch: 1 step 1443, loss is 0.11732476949691772\n", - "epoch: 1 step 1444, loss is 0.17063923180103302\n", - "epoch: 1 step 1445, loss is 0.14149747788906097\n", - "epoch: 1 step 1446, loss is 0.17800576984882355\n", - "epoch: 1 step 1447, loss is 0.12914671003818512\n", - "epoch: 1 step 1448, loss is 0.287578821182251\n", - "epoch: 1 step 1449, loss is 0.1374102085828781\n", - "epoch: 1 step 1450, loss is 0.16122445464134216\n", - "epoch: 1 step 1451, loss is 0.09191429615020752\n", - "epoch: 1 step 1452, loss is 0.08258654922246933\n", - "epoch: 1 step 1453, loss is 0.026686370372772217\n", - "epoch: 1 step 1454, loss is 0.14997930824756622\n", - "epoch: 1 step 1455, loss is 0.2664296329021454\n", - "epoch: 1 step 1456, loss is 0.2523840069770813\n", - "epoch: 1 step 1457, loss is 0.26017773151397705\n", - "epoch: 1 step 1458, loss is 0.18211503326892853\n", - "epoch: 1 step 1459, loss is 0.039881281554698944\n", - "epoch: 1 step 1460, loss is 0.1660570502281189\n", - "epoch: 1 step 1461, loss is 0.3116016089916229\n", - "epoch: 1 step 1462, loss is 0.14994260668754578\n", - "epoch: 1 step 1463, loss is 0.3222777545452118\n", - "epoch: 1 step 1464, loss is 0.1977226287126541\n", - "epoch: 1 step 1465, loss is 0.11967132985591888\n", - "epoch: 1 step 1466, loss is 0.10561515390872955\n", - "epoch: 1 step 1467, loss is 0.2444068342447281\n", - "epoch: 1 step 1468, loss is 0.2793606221675873\n", - "epoch: 1 step 1469, loss is 0.031023547053337097\n", - "epoch: 1 step 1470, loss is 0.025633910670876503\n", - "epoch: 1 step 1471, loss is 0.18152564764022827\n", - "epoch: 1 step 1472, loss is 0.06083272397518158\n", - "epoch: 1 step 1473, loss is 0.2525058686733246\n", - "epoch: 1 step 1474, loss is 0.15242691338062286\n", - "epoch: 1 step 1475, loss is 0.07130670547485352\n", - "epoch: 1 step 1476, loss is 0.0347457155585289\n", - "epoch: 1 step 1477, loss is 0.147914320230484\n", - "epoch: 1 step 1478, loss is 0.060940198600292206\n", - "epoch: 1 step 1479, loss is 0.4348907768726349\n", - "epoch: 1 step 1480, loss is 0.2367706149816513\n", - "epoch: 1 step 1481, loss is 0.3024718463420868\n", - "epoch: 1 step 1482, loss is 0.11994308233261108\n", - "epoch: 1 step 1483, loss is 0.05357520282268524\n", - "epoch: 1 step 1484, loss is 0.31533414125442505\n", - "epoch: 1 step 1485, loss is 0.3344602882862091\n", - "epoch: 1 step 1486, loss is 0.08471953123807907\n", - "epoch: 1 step 1487, loss is 0.0591905303299427\n", - "epoch: 1 step 1488, loss is 0.12241467088460922\n", - "epoch: 1 step 1489, loss is 0.1028100997209549\n", - "epoch: 1 step 1490, loss is 0.0971469059586525\n", - "epoch: 1 step 1491, loss is 0.17085614800453186\n", - "epoch: 1 step 1492, loss is 0.20307905972003937\n", - "epoch: 1 step 1493, loss is 0.15554949641227722\n", - "epoch: 1 step 1494, loss is 0.152117058634758\n", - "epoch: 1 step 1495, loss is 0.036166153848171234\n", - "epoch: 1 step 1496, loss is 0.0663430467247963\n", - "epoch: 1 step 1497, loss is 0.06434255093336105\n", - "epoch: 1 step 1498, loss is 0.028085848316550255\n", - "epoch: 1 step 1499, loss is 0.10241769999265671\n", - "epoch: 1 step 1500, loss is 0.22307536005973816\n", - "epoch: 1 step 1501, loss is 0.016080163419246674\n", - "epoch: 1 step 1502, loss is 0.2076130211353302\n", - "epoch: 1 step 1503, loss is 0.14079713821411133\n", - "epoch: 1 step 1504, loss is 0.17134781181812286\n", - "epoch: 1 step 1505, loss is 0.24002285301685333\n", - "epoch: 1 step 1506, loss is 0.07507986575365067\n", - "epoch: 1 step 1507, loss is 0.015371493995189667\n", - "epoch: 1 step 1508, loss is 0.35458993911743164\n", - "epoch: 1 step 1509, loss is 0.13178271055221558\n", - "epoch: 1 step 1510, loss is 0.07642673701047897\n", - "epoch: 1 step 1511, loss is 0.24822889268398285\n", - "epoch: 1 step 1512, loss is 0.16871564090251923\n", - "epoch: 1 step 1513, loss is 0.40745192766189575\n", - "epoch: 1 step 1514, loss is 0.2804504632949829\n", - "epoch: 1 step 1515, loss is 0.1647489070892334\n", - "epoch: 1 step 1516, loss is 0.2085198163986206\n", - "epoch: 1 step 1517, loss is 0.011187231168150902\n", - "epoch: 1 step 1518, loss is 0.06131260469555855\n", - "epoch: 1 step 1519, loss is 0.13793037831783295\n", - "epoch: 1 step 1520, loss is 0.08268798887729645\n", - "epoch: 1 step 1521, loss is 0.2918003499507904\n", - "epoch: 1 step 1522, loss is 0.1475374847650528\n", - "epoch: 1 step 1523, loss is 0.05017763748764992\n", - "epoch: 1 step 1524, loss is 0.4219624102115631\n", - "epoch: 1 step 1525, loss is 0.07047577202320099\n", - "epoch: 1 step 1526, loss is 0.36795493960380554\n", - "epoch: 1 step 1527, loss is 0.205402672290802\n", - "epoch: 1 step 1528, loss is 0.3113693594932556\n", - "epoch: 1 step 1529, loss is 0.018939964473247528\n", - "epoch: 1 step 1530, loss is 0.11963711678981781\n", - "epoch: 1 step 1531, loss is 0.26485997438430786\n", - "epoch: 1 step 1532, loss is 0.11608637869358063\n", - "epoch: 1 step 1533, loss is 0.038664810359478\n", - "epoch: 1 step 1534, loss is 0.16135820746421814\n", - "epoch: 1 step 1535, loss is 0.027460472658276558\n", - "epoch: 1 step 1536, loss is 0.10712457448244095\n", - "epoch: 1 step 1537, loss is 0.2344018816947937\n", - "epoch: 1 step 1538, loss is 0.535405158996582\n", - "epoch: 1 step 1539, loss is 0.22821743786334991\n", - "epoch: 1 step 1540, loss is 0.1968739926815033\n", - "epoch: 1 step 1541, loss is 0.29195213317871094\n", - "epoch: 1 step 1542, loss is 0.025655176490545273\n", - "epoch: 1 step 1543, loss is 0.07978092133998871\n", - "epoch: 1 step 1544, loss is 0.1264479160308838\n", - "epoch: 1 step 1545, loss is 0.22964981198310852\n", - "epoch: 1 step 1546, loss is 0.12184898555278778\n", - "epoch: 1 step 1547, loss is 0.4731254279613495\n", - "epoch: 1 step 1548, loss is 0.03339137136936188\n", - "epoch: 1 step 1549, loss is 0.014725659042596817\n", - "epoch: 1 step 1550, loss is 0.34388190507888794\n", - "epoch: 1 step 1551, loss is 0.2549399733543396\n", - "epoch: 1 step 1552, loss is 0.24979887902736664\n", - "epoch: 1 step 1553, loss is 0.19499702751636505\n", - "epoch: 1 step 1554, loss is 0.1645338535308838\n", - "epoch: 1 step 1555, loss is 0.24743524193763733\n", - "epoch: 1 step 1556, loss is 0.03985191136598587\n", - "epoch: 1 step 1557, loss is 0.07091329246759415\n", - "epoch: 1 step 1558, loss is 0.052609167993068695\n", - "epoch: 1 step 1559, loss is 0.07124129682779312\n", - "epoch: 1 step 1560, loss is 0.0961894765496254\n", - "epoch: 1 step 1561, loss is 0.0910254493355751\n", - "epoch: 1 step 1562, loss is 0.11323731392621994\n", - "epoch: 1 step 1563, loss is 0.17447282373905182\n", - "epoch: 1 step 1564, loss is 0.27797597646713257\n", - "epoch: 1 step 1565, loss is 0.12834854423999786\n", - "epoch: 1 step 1566, loss is 0.04837791621685028\n", - "epoch: 1 step 1567, loss is 0.23610715568065643\n", - "epoch: 1 step 1568, loss is 0.00686205830425024\n", - "epoch: 1 step 1569, loss is 0.18006019294261932\n", - "epoch: 1 step 1570, loss is 0.0256658885627985\n", - "epoch: 1 step 1571, loss is 0.15297570824623108\n", - "epoch: 1 step 1572, loss is 0.1414184272289276\n", - "epoch: 1 step 1573, loss is 0.17526394128799438\n", - "epoch: 1 step 1574, loss is 0.08118576556444168\n", - "epoch: 1 step 1575, loss is 0.10771070420742035\n", - "epoch: 1 step 1576, loss is 0.03570283204317093\n", - "epoch: 1 step 1577, loss is 0.11714303493499756\n", - "epoch: 1 step 1578, loss is 0.1816290020942688\n", - "epoch: 1 step 1579, loss is 0.021464530378580093\n", - "epoch: 1 step 1580, loss is 0.11372466385364532\n", - "epoch: 1 step 1581, loss is 0.17419934272766113\n", - "epoch: 1 step 1582, loss is 0.011160505935549736\n", - "epoch: 1 step 1583, loss is 0.24291273951530457\n", - "epoch: 1 step 1584, loss is 0.010671941563487053\n", - "epoch: 1 step 1585, loss is 0.017322441563010216\n", - "epoch: 1 step 1586, loss is 0.2335474044084549\n", - "epoch: 1 step 1587, loss is 0.2556104063987732\n", - "epoch: 1 step 1588, loss is 0.0648474395275116\n", - "epoch: 1 step 1589, loss is 0.22502899169921875\n", - "epoch: 1 step 1590, loss is 0.47354650497436523\n", - "epoch: 1 step 1591, loss is 0.2790185511112213\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 1592, loss is 0.037289269268512726\n", - "epoch: 1 step 1593, loss is 0.6669546961784363\n", - "epoch: 1 step 1594, loss is 0.027973078191280365\n", - "epoch: 1 step 1595, loss is 0.3043333888053894\n", - "epoch: 1 step 1596, loss is 0.26716819405555725\n", - "epoch: 1 step 1597, loss is 0.3676808476448059\n", - "epoch: 1 step 1598, loss is 0.04774334654211998\n", - "epoch: 1 step 1599, loss is 0.1505802571773529\n", - "epoch: 1 step 1600, loss is 0.060209549963474274\n", - "epoch: 1 step 1601, loss is 0.1517183780670166\n", - "epoch: 1 step 1602, loss is 0.03348312899470329\n", - "epoch: 1 step 1603, loss is 0.2172851860523224\n", - "epoch: 1 step 1604, loss is 0.16908381879329681\n", - "epoch: 1 step 1605, loss is 0.4056672155857086\n", - "epoch: 1 step 1606, loss is 0.3545580506324768\n", - "epoch: 1 step 1607, loss is 0.0785195454955101\n", - "epoch: 1 step 1608, loss is 0.06628265231847763\n", - "epoch: 1 step 1609, loss is 0.17911334335803986\n", - "epoch: 1 step 1610, loss is 0.30736130475997925\n", - "epoch: 1 step 1611, loss is 0.22257380187511444\n", - "epoch: 1 step 1612, loss is 0.14600497484207153\n", - "epoch: 1 step 1613, loss is 0.05811571329832077\n", - "epoch: 1 step 1614, loss is 0.2594680190086365\n", - "epoch: 1 step 1615, loss is 0.14777813851833344\n", - "epoch: 1 step 1616, loss is 0.21176908910274506\n", - "epoch: 1 step 1617, loss is 0.08806657046079636\n", - "epoch: 1 step 1618, loss is 0.08265901356935501\n", - "epoch: 1 step 1619, loss is 0.06283356994390488\n", - "epoch: 1 step 1620, loss is 0.244098961353302\n", - "epoch: 1 step 1621, loss is 0.16140873730182648\n", - "epoch: 1 step 1622, loss is 0.4248126149177551\n", - "epoch: 1 step 1623, loss is 0.5076652765274048\n", - "epoch: 1 step 1624, loss is 0.12746888399124146\n", - "epoch: 1 step 1625, loss is 0.1834188550710678\n", - "epoch: 1 step 1626, loss is 0.14382439851760864\n", - "epoch: 1 step 1627, loss is 0.19014105200767517\n", - "epoch: 1 step 1628, loss is 0.30281925201416016\n", - "epoch: 1 step 1629, loss is 0.09651453047990799\n", - "epoch: 1 step 1630, loss is 0.2950707972049713\n", - "epoch: 1 step 1631, loss is 0.033858783543109894\n", - "epoch: 1 step 1632, loss is 0.08982428908348083\n", - "epoch: 1 step 1633, loss is 0.18717190623283386\n", - "epoch: 1 step 1634, loss is 0.22012434899806976\n", - "epoch: 1 step 1635, loss is 0.23406831920146942\n", - "epoch: 1 step 1636, loss is 0.19017261266708374\n", - "epoch: 1 step 1637, loss is 0.10751032829284668\n", - "epoch: 1 step 1638, loss is 0.020188376307487488\n", - "epoch: 1 step 1639, loss is 0.027881013229489326\n", - "epoch: 1 step 1640, loss is 0.07523792237043381\n", - "epoch: 1 step 1641, loss is 0.29369279742240906\n", - "epoch: 1 step 1642, loss is 0.21822905540466309\n", - "epoch: 1 step 1643, loss is 0.29793232679367065\n", - "epoch: 1 step 1644, loss is 0.043750420212745667\n", - "epoch: 1 step 1645, loss is 0.09380664676427841\n", - "epoch: 1 step 1646, loss is 0.28589677810668945\n", - "epoch: 1 step 1647, loss is 0.026868261396884918\n", - "epoch: 1 step 1648, loss is 0.18957915902137756\n", - "epoch: 1 step 1649, loss is 0.17896448075771332\n", - "epoch: 1 step 1650, loss is 0.10533048212528229\n", - "epoch: 1 step 1651, loss is 0.19312293827533722\n", - "epoch: 1 step 1652, loss is 0.047780029475688934\n", - "epoch: 1 step 1653, loss is 0.043677132576704025\n", - "epoch: 1 step 1654, loss is 0.12250451743602753\n", - "epoch: 1 step 1655, loss is 0.24486027657985687\n", - "epoch: 1 step 1656, loss is 0.047279682010412216\n", - "epoch: 1 step 1657, loss is 0.06328191608190536\n", - "epoch: 1 step 1658, loss is 0.08435419946908951\n", - "epoch: 1 step 1659, loss is 0.043745022267103195\n", - "epoch: 1 step 1660, loss is 0.2011641561985016\n", - "epoch: 1 step 1661, loss is 0.36145713925361633\n", - "epoch: 1 step 1662, loss is 0.10772320628166199\n", - "epoch: 1 step 1663, loss is 0.08749391883611679\n", - "epoch: 1 step 1664, loss is 0.30133727192878723\n", - "epoch: 1 step 1665, loss is 0.10319367796182632\n", - "epoch: 1 step 1666, loss is 0.09821230173110962\n", - "epoch: 1 step 1667, loss is 0.016956666484475136\n", - "epoch: 1 step 1668, loss is 0.0710502415895462\n", - "epoch: 1 step 1669, loss is 0.007008133456110954\n", - "epoch: 1 step 1670, loss is 0.21395447850227356\n", - "epoch: 1 step 1671, loss is 0.128061443567276\n", - "epoch: 1 step 1672, loss is 0.20678196847438812\n", - "epoch: 1 step 1673, loss is 0.22415968775749207\n", - "epoch: 1 step 1674, loss is 0.08397642523050308\n", - "epoch: 1 step 1675, loss is 0.18893855810165405\n", - "epoch: 1 step 1676, loss is 0.20789159834384918\n", - "epoch: 1 step 1677, loss is 0.3421628773212433\n", - "epoch: 1 step 1678, loss is 0.08329568058252335\n", - "epoch: 1 step 1679, loss is 0.10777005553245544\n", - "epoch: 1 step 1680, loss is 0.28770652413368225\n", - "epoch: 1 step 1681, loss is 0.16173502802848816\n", - "epoch: 1 step 1682, loss is 0.08911692351102829\n", - "epoch: 1 step 1683, loss is 0.09613072127103806\n", - "epoch: 1 step 1684, loss is 0.0196407288312912\n", - "epoch: 1 step 1685, loss is 0.14691004157066345\n", - "epoch: 1 step 1686, loss is 0.16538022458553314\n", - "epoch: 1 step 1687, loss is 0.17081548273563385\n", - "epoch: 1 step 1688, loss is 0.16752029955387115\n", - "epoch: 1 step 1689, loss is 0.07556203007698059\n", - "epoch: 1 step 1690, loss is 0.05724847689270973\n", - "epoch: 1 step 1691, loss is 0.07723591476678848\n", - "epoch: 1 step 1692, loss is 0.22748827934265137\n", - "epoch: 1 step 1693, loss is 0.20023450255393982\n", - "epoch: 1 step 1694, loss is 0.045707911252975464\n", - "epoch: 1 step 1695, loss is 0.11219199001789093\n", - "epoch: 1 step 1696, loss is 0.17740048468112946\n", - "epoch: 1 step 1697, loss is 0.058840714395046234\n", - "epoch: 1 step 1698, loss is 0.22153080999851227\n", - "epoch: 1 step 1699, loss is 0.07449723035097122\n", - "epoch: 1 step 1700, loss is 0.3810114860534668\n", - "epoch: 1 step 1701, loss is 0.08629638701677322\n", - "epoch: 1 step 1702, loss is 0.2227892279624939\n", - "epoch: 1 step 1703, loss is 0.16094565391540527\n", - "epoch: 1 step 1704, loss is 0.18608491122722626\n", - "epoch: 1 step 1705, loss is 0.12596172094345093\n", - "epoch: 1 step 1706, loss is 0.20060348510742188\n", - "epoch: 1 step 1707, loss is 0.2897909879684448\n", - "epoch: 1 step 1708, loss is 0.14372855424880981\n", - "epoch: 1 step 1709, loss is 0.09452032297849655\n", - "epoch: 1 step 1710, loss is 0.1649545133113861\n", - "epoch: 1 step 1711, loss is 0.13143958151340485\n", - "epoch: 1 step 1712, loss is 0.08895035833120346\n", - "epoch: 1 step 1713, loss is 0.28394749760627747\n", - "epoch: 1 step 1714, loss is 0.1974935084581375\n", - "epoch: 1 step 1715, loss is 0.10568737238645554\n", - "epoch: 1 step 1716, loss is 0.01058405451476574\n", - "epoch: 1 step 1717, loss is 0.1257704347372055\n", - "epoch: 1 step 1718, loss is 0.0896354541182518\n", - "epoch: 1 step 1719, loss is 0.3377484083175659\n", - "epoch: 1 step 1720, loss is 0.17294782400131226\n", - "epoch: 1 step 1721, loss is 0.11671129614114761\n", - "epoch: 1 step 1722, loss is 0.06993158161640167\n", - "epoch: 1 step 1723, loss is 0.08449213206768036\n", - "epoch: 1 step 1724, loss is 0.0490744486451149\n", - "epoch: 1 step 1725, loss is 0.1778782606124878\n", - "epoch: 1 step 1726, loss is 0.016006093472242355\n", - "epoch: 1 step 1727, loss is 0.07804140448570251\n", - "epoch: 1 step 1728, loss is 0.09830362349748611\n", - "epoch: 1 step 1729, loss is 0.4913692772388458\n", - "epoch: 1 step 1730, loss is 0.11207643896341324\n", - "epoch: 1 step 1731, loss is 0.044747576117515564\n", - "epoch: 1 step 1732, loss is 0.0635237842798233\n", - "epoch: 1 step 1733, loss is 0.036319926381111145\n", - "epoch: 1 step 1734, loss is 0.22375133633613586\n", - "epoch: 1 step 1735, loss is 0.12693189084529877\n", - "epoch: 1 step 1736, loss is 0.1794988363981247\n", - "epoch: 1 step 1737, loss is 0.0602247416973114\n", - "epoch: 1 step 1738, loss is 0.37853333353996277\n", - "epoch: 1 step 1739, loss is 0.2785823345184326\n", - "epoch: 1 step 1740, loss is 0.11330924183130264\n", - "epoch: 1 step 1741, loss is 0.24572473764419556\n", - "epoch: 1 step 1742, loss is 0.13654503226280212\n", - "epoch: 1 step 1743, loss is 0.08993854373693466\n", - "epoch: 1 step 1744, loss is 0.14939749240875244\n", - "epoch: 1 step 1745, loss is 0.25143638253211975\n", - "epoch: 1 step 1746, loss is 0.19276076555252075\n", - "epoch: 1 step 1747, loss is 0.1520737111568451\n", - "epoch: 1 step 1748, loss is 0.21680326759815216\n", - "epoch: 1 step 1749, loss is 0.2511528730392456\n", - "epoch: 1 step 1750, loss is 0.11513651907444\n", - "epoch: 1 step 1751, loss is 0.10224784165620804\n", - "epoch: 1 step 1752, loss is 0.20663639903068542\n", - "epoch: 1 step 1753, loss is 0.061586134135723114\n", - "epoch: 1 step 1754, loss is 0.039487749338150024\n", - "epoch: 1 step 1755, loss is 0.2036251574754715\n", - "epoch: 1 step 1756, loss is 0.03966877609491348\n", - "epoch: 1 step 1757, loss is 0.027231315150856972\n", - "epoch: 1 step 1758, loss is 0.11806073784828186\n", - "epoch: 1 step 1759, loss is 0.043962445110082626\n", - "epoch: 1 step 1760, loss is 0.20480386912822723\n", - "epoch: 1 step 1761, loss is 0.1087326630949974\n", - "epoch: 1 step 1762, loss is 0.0780656635761261\n", - "epoch: 1 step 1763, loss is 0.19735795259475708\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1 step 1764, loss is 0.18277199566364288\n", - "epoch: 1 step 1765, loss is 0.1360340714454651\n", - "epoch: 1 step 1766, loss is 0.017330918461084366\n", - "epoch: 1 step 1767, loss is 0.13024410605430603\n", - "epoch: 1 step 1768, loss is 0.29709434509277344\n", - "epoch: 1 step 1769, loss is 0.10498026013374329\n", - "epoch: 1 step 1770, loss is 0.11527147144079208\n", - "epoch: 1 step 1771, loss is 0.345134437084198\n", - "epoch: 1 step 1772, loss is 0.2717594802379608\n", - "epoch: 1 step 1773, loss is 0.2283378392457962\n", - "epoch: 1 step 1774, loss is 0.0384673997759819\n", - "epoch: 1 step 1775, loss is 0.176451176404953\n", - "epoch: 1 step 1776, loss is 0.09406087547540665\n", - "epoch: 1 step 1777, loss is 0.10655457526445389\n", - "epoch: 1 step 1778, loss is 0.11743699014186859\n", - "epoch: 1 step 1779, loss is 0.20475371181964874\n", - "epoch: 1 step 1780, loss is 0.11362048238515854\n", - "epoch: 1 step 1781, loss is 0.16925252974033356\n", - "epoch: 1 step 1782, loss is 0.1613941192626953\n", - "epoch: 1 step 1783, loss is 0.16446731984615326\n", - "epoch: 1 step 1784, loss is 0.2628989517688751\n", - "epoch: 1 step 1785, loss is 0.2599729597568512\n", - "epoch: 1 step 1786, loss is 0.07843288779258728\n", - "epoch: 1 step 1787, loss is 0.00616246834397316\n", - "epoch: 1 step 1788, loss is 0.14303813874721527\n", - "epoch: 1 step 1789, loss is 0.09004691243171692\n", - "epoch: 1 step 1790, loss is 0.0073612225241959095\n", - "epoch: 1 step 1791, loss is 0.11986434459686279\n", - "epoch: 1 step 1792, loss is 0.37537509202957153\n", - "epoch: 1 step 1793, loss is 0.03435497358441353\n", - "epoch: 1 step 1794, loss is 0.17364943027496338\n", - "epoch: 1 step 1795, loss is 0.09953322261571884\n", - "epoch: 1 step 1796, loss is 0.06589128077030182\n", - "epoch: 1 step 1797, loss is 0.06567772477865219\n", - "epoch: 1 step 1798, loss is 0.030495651066303253\n", - "epoch: 1 step 1799, loss is 0.13174638152122498\n", - "epoch: 1 step 1800, loss is 0.12769488990306854\n", - "epoch: 1 step 1801, loss is 0.1406596601009369\n", - "epoch: 1 step 1802, loss is 0.01889662630856037\n", - "epoch: 1 step 1803, loss is 0.1025170162320137\n", - "epoch: 1 step 1804, loss is 0.1047017052769661\n", - "epoch: 1 step 1805, loss is 0.10653477162122726\n", - "epoch: 1 step 1806, loss is 0.2483469694852829\n", - "epoch: 1 step 1807, loss is 0.4505705237388611\n", - "epoch: 1 step 1808, loss is 0.08267026394605637\n", - "epoch: 1 step 1809, loss is 0.04931456968188286\n", - "epoch: 1 step 1810, loss is 0.18475544452667236\n", - "epoch: 1 step 1811, loss is 0.0898744985461235\n", - "epoch: 1 step 1812, loss is 0.06011299043893814\n", - "epoch: 1 step 1813, loss is 0.0558500699698925\n", - "epoch: 1 step 1814, loss is 0.2750040590763092\n", - "epoch: 1 step 1815, loss is 0.08818687498569489\n", - "epoch: 1 step 1816, loss is 0.1620287448167801\n", - "epoch: 1 step 1817, loss is 0.006809838116168976\n", - "epoch: 1 step 1818, loss is 0.04070911556482315\n", - "epoch: 1 step 1819, loss is 0.029029523953795433\n", - "epoch: 1 step 1820, loss is 0.1900891661643982\n", - "epoch: 1 step 1821, loss is 0.3131425380706787\n", - "epoch: 1 step 1822, loss is 0.12208942323923111\n", - "epoch: 1 step 1823, loss is 0.008195384405553341\n", - "epoch: 1 step 1824, loss is 0.20186489820480347\n", - "epoch: 1 step 1825, loss is 0.10134484618902206\n", - "epoch: 1 step 1826, loss is 0.15988561511039734\n", - "epoch: 1 step 1827, loss is 0.055812690407037735\n", - "epoch: 1 step 1828, loss is 0.14566737413406372\n", - "epoch: 1 step 1829, loss is 0.11692202836275101\n", - "epoch: 1 step 1830, loss is 0.057336632162332535\n", - "epoch: 1 step 1831, loss is 0.13866601884365082\n", - "epoch: 1 step 1832, loss is 0.3332042098045349\n", - "epoch: 1 step 1833, loss is 0.26320505142211914\n", - "epoch: 1 step 1834, loss is 0.06900594383478165\n", - "epoch: 1 step 1835, loss is 0.02555154450237751\n", - "epoch: 1 step 1836, loss is 0.03933090716600418\n", - "epoch: 1 step 1837, loss is 0.021902436390519142\n", - "epoch: 1 step 1838, loss is 0.1975776106119156\n", - "epoch: 1 step 1839, loss is 0.2500876486301422\n", - "epoch: 1 step 1840, loss is 0.21521836519241333\n", - "epoch: 1 step 1841, loss is 0.10229639708995819\n", - "epoch: 1 step 1842, loss is 0.04220893234014511\n", - "epoch: 1 step 1843, loss is 0.055768031626939774\n", - "epoch: 1 step 1844, loss is 0.2947942316532135\n", - "epoch: 1 step 1845, loss is 0.12519270181655884\n", - "epoch: 1 step 1846, loss is 0.03666522726416588\n", - "epoch: 1 step 1847, loss is 0.06074002757668495\n", - "epoch: 1 step 1848, loss is 0.0761866495013237\n", - "epoch: 1 step 1849, loss is 0.23314397037029266\n", - "epoch: 1 step 1850, loss is 0.029110223054885864\n", - "epoch: 1 step 1851, loss is 0.31116774678230286\n", - "epoch: 1 step 1852, loss is 0.055939022451639175\n", - "epoch: 1 step 1853, loss is 0.2014581859111786\n", - "epoch: 1 step 1854, loss is 0.019982852041721344\n", - "epoch: 1 step 1855, loss is 0.052759602665901184\n", - "epoch: 1 step 1856, loss is 0.21708421409130096\n", - "epoch: 1 step 1857, loss is 0.03414442390203476\n", - "epoch: 1 step 1858, loss is 0.037223730236291885\n", - "epoch: 1 step 1859, loss is 0.01988343521952629\n", - "epoch: 1 step 1860, loss is 0.03718801960349083\n", - "epoch: 1 step 1861, loss is 0.47103869915008545\n", - "epoch: 1 step 1862, loss is 0.0968848392367363\n", - "epoch: 1 step 1863, loss is 0.06905733793973923\n", - "epoch: 1 step 1864, loss is 0.13268259167671204\n", - "epoch: 1 step 1865, loss is 0.3494003713130951\n", - "epoch: 1 step 1866, loss is 0.0347442626953125\n", - "epoch: 1 step 1867, loss is 0.08115438371896744\n", - "epoch: 1 step 1868, loss is 0.12732252478599548\n", - "epoch: 1 step 1869, loss is 0.08057542145252228\n", - "epoch: 1 step 1870, loss is 0.05422119051218033\n", - "epoch: 1 step 1871, loss is 0.09048718959093094\n", - "epoch: 1 step 1872, loss is 0.13636641204357147\n", - "epoch: 1 step 1873, loss is 0.2992154359817505\n", - "epoch: 1 step 1874, loss is 0.30933624505996704\n", - "epoch: 1 step 1875, loss is 0.06503278017044067\n", - "Epoch time: 22519.637, per step time: 12.010, avg loss: 1.140\n", + "epoch: 1 step 125, loss is 2.3136098384857178\n", + "epoch: 1 step 250, loss is 2.303882598876953\n", + "epoch: 1 step 375, loss is 2.3046326637268066\n", + "epoch: 1 step 500, loss is 2.3024802207946777\n", + "epoch: 1 step 625, loss is 2.3106091022491455\n", + "epoch: 1 step 750, loss is 2.298833131790161\n", + "epoch: 1 step 875, loss is 2.3070852756500244\n", + "epoch: 1 step 1000, loss is 2.284291982650757\n", + "epoch: 1 step 1125, loss is 0.7130898237228394\n", + "epoch: 1 step 1250, loss is 0.17307262122631073\n", + "epoch: 1 step 1375, loss is 0.3248927891254425\n", + "epoch: 1 step 1500, loss is 0.09352534264326096\n", + "epoch: 1 step 1625, loss is 0.025928258895874023\n", + "epoch: 1 step 1750, loss is 0.0918595939874649\n", + "epoch: 1 step 1875, loss is 0.20610764622688293\n", + "Epoch time: 15709.893, per step time: 8.379, avg loss: 1.440\n", "************************************************************\n" ] } @@ -2721,7 +801,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2788,7 +868,7 @@ "output_type": "stream", "text": [ "============== Starting Testing ==============\n", - "============== Accuracy:{'Accuracy': 0.9613381410256411} ==============\n" + "============== Accuracy:{'Accuracy': 0.9553285256410257} ==============\n" ] } ], @@ -2831,7 +911,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2915,19 +995,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Row 2, column 5 is incorrectly identified as 8, the correct value should be 3 \n", - "\n", - "Row 3, column 3 is incorrectly identified as 5, the correct value should be 8 \n", + "Row 1, column 7 is incorrectly identified as 2, the correct value should be 3 \n", "\n", - "Row 4, column 6 is incorrectly identified as 6, the correct value should be 0 \n", + "Row 4, column 3 is incorrectly identified as 0, the correct value should be 8 \n", "\n", - "[8 0 5 4 9 1 8 7 0 5 2 4 8 2 4 1 2 1 5 3 9 8 5 7 1 9 3 8 2 6 0 1] <--Predicted figures\n", - "[8 0 5 4 9 1 8 7 0 5 2 4 3 2 4 1 2 1 8 3 9 8 5 7 1 9 3 8 2 0 0 1] <--The right number\n" + "[2 7 7 0 6 3 2 3 2 5 2 1 8 7 8 3 0 5 2 1 0 8 2 2 1 8 0 3 6 8 8 2] <--Predicted figures\n", + "[2 7 7 0 6 3 3 3 2 5 2 1 8 7 8 3 0 5 2 1 0 8 2 2 1 8 8 3 6 8 8 2] <--The right number\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2959,7 +1037,7 @@ " index = 0\n", " print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n", "if index:\n", - " print(\"All the figures in this group are predicted correctly!\")\n", + " print(\"All the figures in this group are predicted correctly!\")\n", "print(pred, \"<--Predicted figures\") \n", "print(labels, \"<--The right number\")\n", "plt.show()" @@ -2984,13 +1062,13 @@ "output_type": "stream", "text": [ "Figure 1 probability of corresponding numbers [0-9]:\n", - " [-3.4469228 2.0546532 -3.5465317 -1.3858355 -0.28758872 1.1322775\n", - " -0.8353202 -3.6402948 8.3553 1.3656969 ]\n" + " [-0.48477417 2.0016153 11.054499 2.3544474 -2.7436607 -3.630352\n", + " -3.7523592 0.9330094 2.6389365 -6.602851 ]\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAD3CAYAAAC+eIeLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd5iU1dnH8e89u0tH6i4gSlFRitIcUGwjqLFi10QxFrAk+hrEFvTNayDGJNZoLElsGExiIGos0RgVdRBEcUB6b0oRWHpbdqec94/zrCywuDs75Uy5P9c11y47z5y5d4DfnDnPec4RYwxKKaXSw+e6AKWUyicaukoplUYaukoplUYaukoplUYaukoplUYaukoplUYauiqjiMgnInJ9itruICI7RKTA+3MbEZkoIttF5FERuVdEnk/B8w4RkfeT3a7KToWuC1DJJSIrgOuNMR+6riXTGGO+AZpU+dGNwAbgIJOkCesi0glYDhQZYyLe8/4N+Fsy2lfZT3u6Kp91BOYlK3CVqg0N3RwmIteKyGQR+b2IbBGRZSJygvfzlSKyXkSuqXL8uSLylYhs8+4ftU97V4vI1yKyUUT+T0RWiMjp3n0+ERkpIku9+8eLSMvvqe0CEZnhPddSETmrmmMOF5GPvPY2iMjfRKR5lft/LiKrveGBhSJymvfz/iIS8tpeJyKPeT/vJCJGRApF5CXgGuBub8jhdBEZJSJ/rdL+SSLymffarRSRa2vxOk30vm7x2h3gvd6TqrR7goh8KSJbva8nVLnvExG53/t72y4i74tI6wP/Latso6Gb+44DZgGtgL8D/wD6AUcAVwFPiUjlR+6dwNVAc+Bc4KciciGAiHQHngGGAO2AZkD7Ks/zM+BCIAAcDGwGnq6uIBHpD4wF7vKe6xRgRXWHAr/12usGHAqM8to4CvgfoJ8xpilwZpU2ngCeMMYcBBwOjN+3YWPMtdiP/A8ZY5rsOxwjIh2A/wBPAsVAb2BGTa+T97sANPfanbJPuy2Bd4A/YP9OHgPeEZFWVQ67ErgOKAHqAXdW89qoLKWhm/uWG2PGGGOiwDhscP3KGFNujHkfqMAGMMaYT4wxs40xMWPMLOAVbIgCXAq8bYyZZIypAO4Dqn4svwn4X2PMKmNMOTYcLxWR6s4bDANeNMZ84D3XamPMgn0PMsYs8Y4pN8aUYgOqsp4oUB/oLiJFxpgVxpil3n1h4AgRaW2M2WGM+bwOr9sQ4ENjzCvGmLAxZqMxZkYtXqeanAssNsa8bIyJGGNeARYAg6scM8YYs8gYU4Z9w+hdh/pVhtLQzX3rqnxfBmCM2fdnTQBE5DgR+VhESkVkK/AToPKj7cHAysoHGWN2ARurtNMR+Jf3UXwLMB8bjG2qqelQYGk1P9+LiJSIyD+8IYRtwF8r6zHGLAFuw4b7eu+4g72HDgOOBBZ4H9/Pq+m54qmxhtepJgcDX+/zs6/Z+1PD2irf72Lvk38qy2noqqr+DrwFHGqMaQb8CfsRH+Bb4JDKA0WkIfbjcaWVwNnGmOZVbg2MMaureZ6V2I/9Nfkttjfd0xsquKpKPRhj/m6MOQkb+AZ40Pv5YmPMFdiP5w8Cr4pI41o8X21r/L7XqaaTcmu8eqvqAFT3OqkcpKGrqmoKbDLG7PbGXa+sct+rwGDvJFA9YDRVAhAbPA+ISEcAESkWkQsO8DwvANeJyGneCbj2ItL1APXswJ6Uao8dA8Zr/ygRGSQi9YHd2B571LvvKhEpNsbEgC3eQ6JxvRJ2vPd0EbncO/HWSkQqP+Z/3+tUCsSAww7Q7rvAkSJypdfuD4HuwL/jrE9lKQ1dVdXNwK9EZDt2zPa7E1DGmLnArdgTcd8C24H1QLl3yBPY3t/73uM/x57E248xZir2RNHvga1AkP17f2CDva93zDvA61Xuqw/8DjvPdi22V3uvd99ZwFwR2eHV9SNjzO7avghejd8A5wB3AJuwJ9F6eXd/3+u0C3gAmOwNtRy/T7sbgfO8djcCdwPnGWM2xFOfyl6iUxRVXXgzHrYAXYwxy13Xo1S20J6uqjURGSwijbzx0UeA2VQ/1UspdQAauioeF2BPBK0BumA/tutHJaXioMMLSimVRtrTVUqpNNLQVUqpNNLQVUqpNNLQVSpJRGS4iMwRkbkicpvrelRm0tBVKglE5GjgBqA/9iKK80Ski9uqVCbS0FUqOboBnxtjdnk7RgSBixzXpDKQbtejVHLMwa490Qq7DsQ5QMhtSdlt2rRpJYWFhc8DR5OZHcQYMCcSiVx/7LHHrq/tgzR0lUoCY8x8EXkQ+AC7SM9MIOK2quxWWFj4fNu2bbsVFxdv9vl8GXdBQSwWk9LS0u5r1659Hji/to/LxHcPpbKSMeYFY0xfY8wp2EVyFruuKcsdXVxcvC0TAxfA5/OZ4uLirdieeK1pT1epJBGREmPMem+rn4uBAa5rynK+TA3cSl59cXVeNXRzkIi8iF0+cL0xJq53YZWQ17wx3TBwizFms+uCVObR0M1NLwFPYTd/zA4ijYBO2HV122A3fWwOtKjyfUOgAChoyrbNO2h6EHZx8gh2W5sN2EXE1+/ztRQoNSbuhczjYow5OZXt5z2RY5PanjHTajrksssu6zRhwoRmrVq1iixevHhuMp5WQzcHGWMmikgn13XsR0SwOyr09m5HYoO2E3YR8lrbTYNVVNk+qBbCIiwC5gLzvK9zgcXG6AkvVb2hQ4duGD58+Prrrruuc7La1NBVqWO32DkVe8FAH+xFAwc5qqYI6OHdqqrwwngmdm7tx8awJN3Fqcx09tln71i4cGG9ZLapoauSR6QEGFjldqTbgmqlHvbs89HYbdcRYRXwsXf7yJj9du9Vqs40dFVi7IaSl2DP1vd1XE2yHAL82LshwnLs/NvXsCGswxGqzjR0VfzsrriXeLdujqtJh87Ajd5tkwhvAOOACak+Oadyj14ckYNE5BVgCnCUiKwSkWFJaLQVIiMQmQN8BfyC/AjcfbUEhgL/BVaK8JhIzvTwVRpoTzcHGWOuSEpDdrbBIOB67OIt9ZPSbu5oB4wARogwDXgcGGcMYbdl5ahaTPFKtsGDB3f+/PPPm27evLmwTZs2PUeOHLlmxIgRGxJpU0NX7U+kIbY3dxtwhONqssWxwMvAgyI8BfzZGDY5rkkl6O23316e7DZ1eEHtIdICkV8AX2MvrtDAjd/BwG+wQw9/FOEo1wWpzKKhq0CkHSKPYMP2fqDYcUW5oBHwE2C+CG+L0NN1QSozaOjmM9uzfRBYCtwBNHVcUS4S7DoYX4nwkgiHui5IuaWhm49E6iNyF7AMuBu7poFKLR9wDbBIhIdEaO66IOWGhm6+EbkMmA88BPof34EGwF3AUhHuENEZIflGQzdfiByGyH+B8djJ/sqtlsAjwAIRznRdjEofnTKW60QKseO1v0SHETJRJ+A9EcYAtxvDFsf1ZCwZndylHc0va5732759+2MaN24c9fl8FBYWmjlz5sxP9Hk1dHOZSD/gOezqXiqzXQecKcJPjOFt18WoPYLB4KJ27dolbb0NHV7IRSKFiDwAfI4GbjY5GHhLhL+J0Mp1MSo1NHRzjUhn4FPgXvTvN1tdCcwT4WLXhSg47bTTuvTo0aPbI4880joZ7enwQi4RGQI8g7uFwlXylACvifA0dqy3wnVB+Wjy5MkLOnXqFF69enXhoEGDjuzRo8fus88+e0cibWpPKBeINEZkLPBXNHBzzS3AJBE6ui4kH3Xq1CkM0L59+8i55567ZcqUKY0TbVNDN9uJdAQm4y24rXJSv5OO2f4ngqEfuC4kn2zbts23efNmX+X3H3/88UE9e/YsS7RdHV7IZiInAa+jayXktGaNI3M+fGzRIOAMgqF7Cfgfcl2TC7WZ4pVMq1atKrzooouOAIhGo3LJJZdsvPTSS7cl2q6GbrYSuR54GrvHl8pRPjGls16c16p+kan8e36QYOhoYBgBv67bm0Ldu3evWLhw4bxkt6vDC9lGxIfI49j5txq4Oc1EX79/6eoObSra7XPHj4F/Eww1cVGVSoyGbjYRKcKeLBvuuhSVejcO3jDpgpO29D7A3T8AggRDbdJZk0qchm62sLs5vAEkZyseldGOaL97yp/v+DpQw2F9gSkEQ9mw1b3yaOhmA5GDsBshnuO6FJV6DerFlk5/bt4xtTy8MzCZYOhAPWKVYTR0M51Ia+AT4GTHlai0MNun/mm+r2mjWDzjta2BDwmGdHeKLKChm8lEmgHvA31cl6LS45kR38w95rCyuiy92QqY4M1sUBlMp4xlKpHGwLto4OaNc47b8slPLyg9NYEmWmOD91QC/oSXIMw4wVBSl3Yk4K9x3u/o0aNLXn755WIRoWvXrrvGjRu3olGjRiaRp9WebiYSqY89aXaC61JUepQ0D09/8zdLkjGEVAJ8RDCkuxAnaPny5UXPPvtsmxkzZsxbvHjx3Gg0Ks8//3zLRNvV0M00dtHx8cDprktR6VHgM2tmvTi3Q2EBBUlqsi3wnk4nS1w0GpWdO3f6wuEwZWVlvkMOOSThC1I0dDPPs8D5rotQ6WLKP3xs4ZY2LSNJWTawik7A2wRDjZLcbt7o3Llz+JZbblnbuXPnniUlJb2aNm0avfjiixO+DFhDN5OI3I3dQUDliXuGrJ16au8d3VPUfD/gFYIh/X9eB6WlpQXvvPNO8yVLlsxeu3btrF27dvmeeeYZHV7IGSLnA791XYZKnz5ddn76mxtWp3oq4PnA4yl+jpz09ttvH9ShQ4fygw8+OFK/fn1z4YUXbvnss88SvvRaQzcTiPQE/ob+feSNJg2j8yc/taBfmp7uVoKhW9P0XDmjU6dOFdOnT2+yfft2XywW46OPPmrarVu33Ym2q1PGXBMpAd4GdPGSPCFiNs14fl7ThvVNgzQ+7aMEQyEC/ilpfM7kqsUUr2QaNGjQzsGDB2/u2bNnt8LCQnr06LHr9ttvL020XTEmoSlnKhEiPuzFD6e5LiXbFFGxKkLRIa7riJ+Jjfvlsq8uH7g5uXNOa2cl0JeAf4OD547bzJkzV/Tq1Svja505c2brXr16dart8fpx1q170MBNoqHYaapVL8raBJwBdPG+bj7AY7/BLtzVDegOrPB+PgToid3ns9L9wJt1qvCqMzZNdBS4AIcCf9UTa27pi++KyInAKNdl5JZrgff2+dnvsO9ri72vvzvAY68G7gLmA1Ox4T3Lu28WdoPlrcC33v0XxF1dxzblX/zl3uU1rRyWamcC/+u4hrymoeuCSAvg7+iYepKdAuw7o+dN4Brv+2uwF/rtax4QwfaEwQ6vNwKKgDIgBlQABcB9wK/irqxeYWzFjBfmdfUJEveDk28UwZDr8M9bGrpuvAB0cF1EflgHVG680A5YX80xi4DmwMXYpS7uAqLYoYYO2GVrLweWAIb4l8MwOyc/vSDcvEm0Wdzlp4YPGKM7T7ihoZtuItcAF7kuozrVjYiOAtoDvb3buwd47BPe43qw96TQn2NHRK+u8rOXveMzRwQ7fPAI8CWwDHjJu+9xYAZwB/B/2F7uA9gQfq5WrT9686qZ/qN2dUlqyYnrDDzouoh8pKGbTiJtgd+7LuNArmX/EVGAEdjYmUH1q6jPwcbPVGAm8G/sCOpW4DPsiGgUmI39sP4ScHNSK/8+bbDjsHhfS6o55hBs7/Uw7IjPhcD0fY55E/ADO7G/8Xjs28eu7332gX22BW+/fF2mLlz0U4Khga6LyDc6pphGowOM/L8gzTP1ne4U9pyzj8d84HjsKChAAPgX8FPsSKjBhm0R8DDwM+/79Dgf+Asw0vta3QmwfthZDaXY3ew/wgZspTC2b175dlI5LFs51lv98gYtm0Zm/vfhRScm/CukjgAvEgwdQ8C/w3UxNREhqbM+jKHGeb/3339/ydixY4uNMVx99dWl9913X3XjU3HJ1P//OUdGy4WjBjK85G5mzi2uU7Y58xR2iGAo1U+4OhqYCGzE9vvexU4IbQpcgu1DdgaaYT+8x3/ev7auAAYAC7G91xewYfsBdsrYB96fAULA9d73BdihhdOAY7BvEzdUafdp7Em4RthXwnjHnYgdC96fz2fWzRozt11RYcZ3bDpx4Ckdee3LL79sMHbs2OLp06fPnz9//tz33nuv+ezZs+sn2q6GbhrIaGkCPAmwsRG9j76ZttdcSDDsI+K4tBr9FFiKHVpohx3Z3Fc37NjtGcBZQC/2fIS623vso+wZEX0eOyL666RX+wp2CCEMrAKGUbmhgu2hTmDP7Aa/V0mlM7ADIbOxAyBVd7e/jT0zIMR7ntkceEjUhN99cPH69q3D1Y1lZKKf6h5r+5s9e3bDvn377mjatGmsqKiIE088cfu4ceOqf5eNg4ZueozCdr0socHY3gSaj2Tppx3I6BX+22D7gT5s32/qAY4bhh0FnYiNtX3PGn3lfT0SGIsdEZ2DjcJcM/yS9VPO7LetthtLZgIfmXZuMwP07t277Isvvmi6du3agu3bt/s++OCDZitXrqxX8yO/n4Zuislo6QxUu9jIrnocdcp1HPmDHxPcWVTDGRlHvq3y/b/Ye2ZDVZUDXd8Ar7P/PvGVvdww9qQa2H98GflLJ6B7x7LJj9+68hTXddTBKQRDl7suIpP07dt39/Dhw9cOGjToyIEDB3bp3r37rsLCxEeLNHRT7wH2/qy6N6Hgg8MJtBjJhn923++UeVpVNyJ6N3b0sifwMXumXqxh75kMl2Avnh2MHQFtUeW+N7Cnqg7GjoAO8NoU7FBErmhYP7po6p/nZ/Oedg8TDDV0XUQmGTFixIZ58+bND4VCC1u2bBnt0qWLrjKWyWS0+IEf1ebYcAEdLr+cDr3WMmnCXzi6VdkBztCk0CvV/GzYAY49mL3n7H76Pe1e6N0qPeLdcolgtk5/bn79xg1i2bxTQwfs++xo14VkitWrVxe2b98+snjx4nrvvPNO86lTpy5ItE0N3dR6GOK77HNmW04quYvSx/7LlOFfMCBFdamkMmbMyBWLunbYna71cVPpLoKhZwj4E17CMNlqM8Ur2c4///zDt2zZUlhYWGgef/zxb4qLi6M1P+r7aeimiIyWc4FT6/LYmI/i286m+LEBTP30RQ7tsO2761hVBrrklC3Ba87aeKrrOpKkMXAndkJK3ps2bdrCZLepY7qp85tEG/imOf07jqDxnWcwMWYnh6oMc3CritC4UUuz8cTZ97mFYCjZG2Uqj4ZuCshoOQd77ikJjXHQoydySuufM3tmG5YlpU2VFIUFsZWzxsw9osCXc/+PGlP9lGyVBLn2jyVT3J3sBjc3pGfvn9D+yksIVvgIJ7t9FS9TNvEPC3e1Oiia9hOeafI/BEOtHNcQi8VimbAU5gF59cXieYyGbpLJaOmPXX4gBY1T/5VjCDS/hxUfd2JuSp5D1cqvh62eNqDHzqNc15FCTYDbHdcwp7S0tFmmBm8sFpPS0tJm2Ot8ak33SEsyGS2vYRdmTS1DbOAKPn3r7/ibhGmc8ufLMC73SBvQY8fEz55ekGvjuNXZBBxKwO/kGpZp06aVFBYWPo+9JicTO4gxYE4kErn+2GOPrfVCOBq6SSSjpQuwgDT+AymMsmrsv1h7xZy9lsXKea5Ct1njyJx1b8w8sn6RSfhy0CxxEwH/s66LyCWZ+O6RzUaQ5tc0UsAhV16K/+ibmVzaiE3pfO584xNTOuvFea3yKHDhAJewq7rT0E0SGS0NgStdPf/cEk5scxexh0/gM1c15DYTff3+pas7tKnItznTRxMMney6iFyioZs8F2OXjHXGCK3v/gEnHHI7Xy5rzmqXteSaG87bMOmCk7bk6/KHP3FdQC7R0PWIyAoRmS0iM0QkVIcmhia9qDpafRD9Dh9Os9vOYmJU4pvOovZ3RPvdU5698+t83j33EoKhfbdZVnWkobu3gcaY3saYuE5KyWjpBGTWXlNCkyeO55RWP2fuV21Z6rqcbNWgXmzp9OfmZdPauKlQH7uQnEoCDd3kuJY4F7ZJl60NOKbvTRx6+WUEywuocF1PdjHbp/5pvq9po5huVb7/EsmqjjR09zDA+yIyTURurO2DZLQIe/ZyyUxCvX/2INB8JCs/OIzZrsvJFs+M+GbuMYeVdXZdR4YIEAzl20nElNDQ3eNEY0xf4GzgFhGp7eT3/tjN/TLe7iIO/8GP6XHydQS31yPjd3916Zzjtnzy0wtKj3ddRwbxYbe2UwnS0PUYY9Z4X9djd6bpX8uHXpSyolJB8E3qSKDFSLaN7cmXrsvJRCXNw9Pf/M0SnSa1Px1iSAINXUBEGotI08rvgR9Q++upsyt0PVEfB19zMf263cJn6xqzwXU9maLAZ9bMenFuh8ICClzXkoGOIxjq4LqIbKeha7UBJonITOyGt+8YY96r6UEyWo7CbnCbtRYUc0K7O/H99iQmu67FPVP+4WMLt7RpGdG1ZA/sLNcFZDsNXcAYs8wY08u79TDGPFDLh56b0sLSxAgt7z2dE9vdQWhJS1a5rseVe4asnXpq7x3dXdeR4c50XUC209BNTE6EbqW1TfF3uZUWN59DMN8uqujTZeenv7lhtY7j1mwQwZAOvSRAVxmrI2+thS183/bqWaxpOXMn/IV6/dbQxXUt1UnmKmNNGkbnr39jRueG9U2DZLSXB04k4Nc1PupIe7p1158cDVyA7fXp0f8GOl30Qz7ZXUC563pSRcRsmvH8vKYauHHRIYYEaOjW3YmuC0g5oeiNbpza/B5Wv3sEs1yXk3wm9o/7li0/vH25k8XQs9jprgvIZhq6dZf7oespL+Swc4dwzIBhfLq1Pttc15MsQ87Y9OnlAzcf67qOLNSXYKjQdRHZSsd068C79Hcj0CKtTzwFmO593wa4ACiqcv8W4A1gN3YjkdOxE9q+Af4NFGKXLWkFlAGvAlcR16oRBTG+ffYtVg6dUeuLR1Ii0THdDiXlU5ePm93PJ5m5ZkYWOJaAf3rNh6l9aU+3brqR7sDdBnwB3Ajcgrc70z7HTAR6YFc/vRR4x/v5Z8APgdOAUJVjTybuZXqiPtoNu5D+R97KlDVNKI3798gA9QpjK2a+OO8oDdyEOH3TzWYaunXjZmghBoSBqPe16T73C3x3yqu8yv0F3vFh7N/4JmyId6p7KYtbMeCQOygcHWBS3Vtxweyc/PSCcPMmUacLzueAfq4LyFYaunWT/h0EDgJOAH4PPAo0AI7Y55hTgVne/X8DzvF+fhLwNvA5tn8yARiUeElGaDFqICe1uZPpC1vxTeItpt6jN6+a6T9qV0ZOg8sy2tOtIw3duumW9mcsw+4zfBtwB1ABzNznmNnYt4M7gCHA69jecTvgBuyqv5uxPWAD/BN4DRJdb2x9E/p2/R9a3ziYYESIJtZa6gzssy14++XrTnBdR47oTjDU0HUR2UhDt266pv0Zl2FHkRtjhwu6ASv3OeYr7JguwKFABNhV5X6DHcsNAEFsz7gndqw4UUKj544l0GIkiz5vz8IktJhULZtGZv734UV5M+MkDXzs/1lL1YKGbpxktDTD9h3TqxmwCtvDNcByoLiaY5Z535diQ7dxlftnYGczNMSO74p3CyevzB316Tbgeg4/7wqCZYXsTl7LdefzmXWzxsxtV1SITnNKLh2mqQMN3filv5cLcAjQHfgz8Aw2eI8FPsIOO4BdkHI68EfsdLAL2TM7oXI4ovL0xwBgPHZ8N64d4WpBKHznKALNR7L2rSOZkeTW42TC7z64eH371uESt3XkJA3dOtB5unGS0XItMMZ1HVnDYPqtYdL7Y+nZvDx5W9TXdp7u8EvWTXz81pW13QVExecFAv7rXReRbbSnG7+sXj837QT5sj0nt/45Zc8em5TR41rr3rFssgZuSmlPtw40dON3sOsCslHUR9ubBnPc4T/j81VNWZfq52tYP7po6p/n90n18+Q5PZFWBxq68WvjuoBstqwlx3e4nQa/GMinqXoOwWyd/tz8+o0bxBql6jkUACUEQ3pVX5w0dOOnJ2QSZIRmDwQ4ufguvprfmq+T3LoZM3LFoq4ddndMbruqGoWk+3L4HKChGz/t6SbJhsb06X4LJUMvIBj2EUlGmxefsmXiNWdt1EtU02ffiYuqBhq68dOebjIJDcf0IdBiJEsmHcr8RJpq16oiNH7UUt1yJ710E884aejGQUZLC/ZeTFElyc56dD15KEeedRWf7CqkLN7HFxbEVs4eM/eIAp/+m04z7enGSf+BxqeV6wJymlDw3yM4tfk9rH+9K1/V/oGmbOIfFu5qdVC0eeqKUwegPd04aejGR8+Gp0G4gI6X/Ig+fW5i0saGbKnp+PuHrpk2oMfOo9JRm9pP45oPUVVp6MZHNy9MoxntOKnkLiqe6s+UAx0zoMeOib+4+tuT0lmX2ouuZxEnfcHicG6rkwoa+upPL49V+MpjFQXlsXBBuQkXlMcqCipi4YIKEy6siIUL7ddIYYUJF4ZNpCgcixRFiRW4rj8bxXyU3HoOJY8O4IuJY+h46DbaVt7XrHFkzsePLzzeZX1Kz3HES0M3Dv8+5vcNgL51eayxi1yEgbCBCJhwDBMxxkQMJhojFokZE42aWDRKLBo10WjUxGJRE41GTDQWNpFYxERN2ERiYRMx4VjYVJiIqYiFTYUJUxELm3L7lfJYBeWxsJSbCnbHwlIeq6i8+XYb+7U8Fvbt3vPm4Ss39k2kIlZRUG7fPKq8iUQKK2LeG4iJFEVMNO3/bla04LgOI9h692Q+/e2HnNSwMLxl1otLWtUvMvXSXYvai2ZInPQFi0+dh2NERIB6QD17CY/YxrL0eh5jTOUGQGGDiRhMJGa8r5hozMSiMWIR+8Zh30QiJhrbc4vEwvbNxIRN2FTEIqbChE1FLEzl1/JYmHITxnvDsG8knStk/HkF73xUtKR9hzYV6V9iU+1LMyRO+oLFR8fAPSJShPfRsnJ/x4K0voFUpPPJ1IHp8EKcNETio//TldpbzHUB2UZDNz47XRegVIZJcIe9/KOhGx/9B6bU3vT/RJw0dOOjPV2l9qahGycN3fho6Cq1t+2uC8g2Grrx0Xd1pfam/yfipKEbj4C/Au3tKlXVVtcFZBsN3fitdjuzRrcAAArRSURBVF2AUhlkresCso2GbvxWuS5AqQzyresCso2Gbvy0p6uUtcEbclNx0NCNn/Z0lbKSvKloftDQjZ+GrlKWhm4daOjGb4XrApTKEMtdF5CNNHTjN891AUplCP2/UAcauvH7Gr0KRymA2a4LyEYauvEK+A0w13UZSjkWQ/8f1ImGbt3McV2AUo4tI+Df5bqIbKShWzcauirf6dBCHWno1s1M1wUo5ZiGbh1p6NbNVOymjErlqymuC8hWGrp1YceyprsuQylHosBk10VkKw3dupvougClHJlBwK/TJutIQ7fuPnVdgFKOaIcjARq6dTcZMK6LUMoBDd0EaOjWVcC/CT2Dq/KPQT/lJURDNzH/dl2AUmn2JQH/RtdFZDMN3cS85boApdLsDdcFZDsN3cRMRbcrUflFQzdBGrqJsIvfvO26DKXSZBEB/3zXRWQ7Dd3E6RCDyhdvui4gF2joJm4CsM11EUqlgQ4tJIGGbqIC/t3AeNdlKJViS9H1FpJCQzc5xrguQKkUe8k7h6ESpKGbDAH/Z8Ai12UolSIx4CXXReQKDd3kecl1AUqlyAcE/KtcF5ErNHSTZyy2R6BUrtHhsyTS0E2WgH818K7rMpRKso3orIWk0tBNrsdcF6BUkv2RgL/cdRG5REM3mQL+j4FprstQKkl2A0+6LiLXaOgm36OuC1AqScYS8K93XUSu0dBNvn8CX7suQqkExdAOREpo6CZbwB8BnnBdhlIJeouAX+eep4CGbmo8C+jHMpXNfue6gFyloZsKAf9O4Leuy1Cqjv5FwP+F6yJylYZu6vwR0Kt4VLaJAve6LiKXaeimip3bOMp1GUrF6SUC/gWui8hlGrqp9RIwx3URStXSbrSjkHIauqkU8EeBu12XoVQtPakL26Sehm6qBfz/Qa9dd2rL9u1cet/P6frjS+l29WVMmTvru/se+cfLyKn92LBly36P+/irEL2HXfndrcEZJ/LGp58AMOTXv6Dn0Cu497mnvzv+/rHP8+akYMp/nxRZDdzvuoh8UOi6gDzxM+B0oInrQvLR8Kce5az+A3j1Vw9SEQ6za/duAFauX8sH06bSoU3bah83sI+fGS/8HYBN27ZyxJCL+UG/45m1dDEAs158hZNvvYGtO3awq3w3U+fP5f+uvj49v1TyDSfg3+66iHygPd10CPhXomNlTmzbuYOJM79i2LkXAFCvqIjmTZsCMOKp3/PQTbciSI3tvBqcwNnHDaBRgwYUFRZSVl5OLBajIhKmwOfjvhf/xK+G/iSlv0sKvUPA/5rrIvKFhm76PAHMqvEolVTL1qymuHlzrvvdaPpcP4TrH/o1O8vKeGtykPbFxfQ64shatfOPjz7gikFnAtCtY2c6lLSl7w1Xcfmpp7Nk9UqMgT5djkrlr5Iqu4BbXBeRT3R4IV0C/gjB0E+AyVCLrpVKikg0yvRFC3nyZ3dxXPejGf7kI4x66VkmzvqK9x9+qlZtfLtxA7OXLeHM/gO++9njt97x3feD7xnBn++4lwdefpGZSxdzhr8/N5x3UdJ/lxT5FQG/rhWSRtrTTaeAfwq65m5aHVJcwiHFJRzX/WgALg2cxvTFC1j+7Rp6DbuSTj88n1Wl6+l741Ws3bih2jbGf/wBF518KkWF+/dR3pwUxH9Ud3buLmPO8qWMH/VbXn7/P9+NG2e4aeiiNmmnoZt+9wIzXReRL9q2as2hJW1Y+M0KACZM+5K+Xbqy/o33WTHuLVaMe4tDikuY/uxfaduqdbVtvDLhfa447cz9fh6ORHjitX9w149+zK7duxGxH2BisRgV4XDKfqckKQOu8hZoUmmkoZtuAX8FcCV2IrpKgyd/didDfn0fPYdewYwli7j3qusOeGxowTyuf+jX3/15xbdrWFm6jkCvvvsd+/S/xnPNmefSqEEDeh7eBWMMx1z3I048ptd3J+sy2N165ZkbYoxuZe9EMHQr8AfXZai89G8C/sGui8hX2tN1JeB/EnjPdRkq76wBDtzVVymnoevW1cA3rotQeSMCXEnAX/0ZQ5UWGrouBfylwEXYkxpKpdptBPxZe51yrtDQdS3gnw4Mc12GynnPEfA/XfNhKtU0dDNBwP8K8LDrMlTOmoRedZYxNHQzx0jgv66LUDlnJXAJAX/GTxzOFxq6mSLgjwGXAdNdl6JyxlZgMAG/bpKaQTR0M4ldWu9sYLHrUlTWKwPOI+DXqx8zjIZuprG9kjOwi0orVRdh4FIC/kmuC1H709DNRHbVpzOBTa5LUVnHANcS8L/ruhBVPQ3dTBXwzwXOBba5LkVllZ8R8P/ddRHqwHTthUwXDPXDzmpo4boUldEMcDMB/59cF6K+n4ZuNgiGegIfACWuS1EZKQpcR8D/sutCVM00dLNFMNQV+BBo77oUlVEqgCsI+F93XYiqHQ3dbBIMHYYN3s6uS1EZoQy4mIBfV6vLInoiLZsE/MuA44EprktRzq0DBmngZh8N3Wxj5/EOBPQMdf6aBfQn4P/cdSEqfjq8kM2CofuAUejuwvnkbeyauDtcF6LqRnu62Szg/xVwBboeb754GLhQAze7aU83FwRDRwPjgW6uS1EpsRW4kYB/vOtCVOK0p5sLAv45gB8Y47oUlXRTgT4auLlDe7q5Jhi6Cvgj0MR1KSohBngE+F9dCze3aOjmomDoSOBv2N6vyj7rsIvW6HSwHKTDC7ko4F+Enc97D1DuuBoVnzFANw3c3KU93VxnLx9+FjjZdSnqey0FbiLgn+C6EJVa2tPNdQH/AiAA3AhscVyN2l8UO3Z7jAZuftCebj4JhlpjL6a4CSh0W4zCrqNxp26pk180dPORHXJ4CBjsupQ8NRe4i4D/P64LUemnoZvPgqFBwKNAb9el5Im1wC+BFwj4o66LUW5o6Oa7YEiAi4F7gb6Oq8lV67Fvbs/oJbxKQ1ftEQydhQ1fnemQHCuBx4BnCfh3uS5GZQYNXbW/YOhkYCRwFjrDpS5mYxeneYWAP+K6GJVZNHTVgQVDnYAbgKFAW7fFZLwy7KJDzxLwf+a6GJW5NHRVzYKhIuAC7FSz09D1e6uag7345GUCfp0HrWqkoaviEwx1BC71bseRnwG8DHgNeJWAf6rrYlR20dBVdRcMHcqeAB5AbgfwIuBV4DUC/umJNiYiI4DrsauJzQauM8bsTrRdlfk0dFVyBEMl2L3bTvNuh7ktKGGbgE+Aj4AJ3uXUSSEi7YFJQHdjTJmIjAfeNca8lKznUJlLLwVVyWE3zBzn3SpPwp0GnAIcC3QFChxVVxsrgenARGzQziTgT2WPpBBoKCJhoBGwJoXPpTKI9nRVegRDDYFe2Asw+njfHwa0SnMlZcBy7I6604GvgK8I+DemswgRGQ484NXzvjFmSDqfX7mjoavcCoaaAp2xAdwZ6ASUYMO4FdAcOMi71TtAK2HsPmJb9rltBL7GhuwK77YuxT3YGolIC+yJuB9i6/wn8Kox5q8u61LpoaGrVJqJyGXAWcaYYd6frwaON8bc7LYylQ56tZFS6fcNcLyINBIRwY59z3dck0oTDV2l0swY8wV2+tl07HQxH/YCC5UHdHhBKaXSSHu6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRhq6SimVRv8PxQO2cgY9S64AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3003,13 +1081,13 @@ "output_type": "stream", "text": [ "Figure 2 probability of corresponding numbers [0-9]:\n", - " [10.008167 -5.861808 1.4555234 -1.482836 -2.721113 -0.8507886\n", - " 3.199972 -2.2156045 0.32849124 -1.4580953 ]\n" + " [-1.916862 -0.16948226 -0.2352289 -0.5903556 0.8726251 -0.41480547\n", + " -3.0238853 4.210627 -0.70848167 1.8492212 ]\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAD3CAYAAAC+eIeLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd5iU1dnH8e+9LF16R6T3Lrs2LGshiqLRoIICryWWJBqNUdM0BDXWJAaNLTFqEo0hGmI0amJJlImCbVBQAZVelrZLWWDr7M79/nEGXXFhd3bKmXJ/rmuuhZmn3Duwvz1znvOcI6qKMcaY5MjxXYAxxmQTC11jjEkiC11jjEkiC11jjEkiC11jjEkiC11jjEkiC12TUkRknohcmqBj9xaRPSLSJPL3biLyPxHZLSJ3i8gNIvJIAs47XUReifdxTXrK9V2AiS8RWQNcqqr/8V1LqlHVdcBBtZ66HCgG2mqcBqyLSF9gNdBUVasj530SeDIexzfpz1q6Jpv1AZbGK3CNaQgL3QwmIheJyHwRmS0iO0VklYiMjzy/XkS2isiFtbafJCIfiMiuyOs37XO8C0RkrYhsE5GZIrJGRCZEXssRkR+LyMrI60+LSMcD1HamiCyKnGuliEysY5sBIvJa5HjFIvKkiLSv9fqPRKQw0j3wqYicFHn+cBEJRo69RUR+HXm+r4ioiOSKyB+BC4EfRrocJojITSLy51rHP0ZEFkTeu/UiclED3qf/Rb7ujBz3qMj7/Wat444XkfdEpCTydXyt1+aJyM8j/267ReQVEem8/39lk24sdDPfEcCHQCfgL8BfgcOAgcAM4H4R2fuRuxS4AGgPTAK+IyJnAYjIcOBBYDrQA2gHHFzrPFcDZwEFQE9gB/BAXQWJyOHA48APIuc6DlhT16bAHZHjDQMOAW6KHGMI8F3gMFVtA5xS6xj3AveqaltgAPD0vgdW1YtwH/l/oaoH7dsdIyK9gX8D9wFdgLHAovrep8j3AtA+cty39jluR+BF4De4f5NfAy+KSKdam00DLga6As2A6+t4b0yastDNfKtV9Q+qWgM8hQuuW1S1UlVfAapwAYyqzlPVj1Q1rKofAnNwIQpwDvC8qr6pqlXAz4DaH8u/BdyoqhtUtRIXjueISF3XDS4BHlPVVyPnKlTVT/bdSFVXRLapVNUiXEDtracGaA4MF5GmqrpGVVdGXgsBA0Wks6ruUdW3G/G+TQf+o6pzVDWkqttUdVED3qf6TAKWq+oTqlqtqnOAT4Azam3zB1X9TFXLcb8wxjaifpOiLHQz35Zafy4HUNV9nzsIQESOEJHXRaRIREqAbwN7P9r2BNbv3UlVy4BttY7TB/hH5KP4TmAZLhi71VHTIcDKOp7/EhHpKiJ/jXQh7AL+vLceVV0BXIML962R7XpGdr0EGAx8Evn4fnp954qmxnrep/r0BNbu89xavvypYXOtP5fx5Yt/Js1Z6Jra/gL8EzhEVdsBv8V9xAfYBPTau6GItMR9PN5rPXCqqrav9WihqoV1nGc97mN/fe7AtaZHR7oKZtSqB1X9i6oegwt8Be6KPL9cVc/HfTy/C5grIq0bcL6G1nig96m+i3IbI/XW1huo630yGchC19TWBtiuqhWRftdptV6bC5wRuQjUDLiZWgGIC57bRKQPgIh0EZEz93OeR4GLReSkyAW4g0Vk6H7q2YO7KHUwrg+YyPGHiMiJItIcqMC12Gsir80QkS6qGgZ2RnapieqdcP29E0RkSuTCWycR2fsx/0DvUxEQBvrv57j/AgaLyLTIcacCw4EXoqzPpCkLXVPbFcAtIrIb12f7+QUoVV0CXIW7ELcJ2A1sBSojm9yLa/29Etn/bdxFvK9Q1XdxF4pmAyVAgK+2/sAF+7jINi8Cz9R6rTlwJ26c7WZcq/aGyGsTgSUisidS13mqWtHQNyFS4zrgNOA6YDvuItqYyMsHep/KgNuA+ZGuliP3Oe424PTIcbcBPwROV9XiaOoz6UtsiKJpjMiIh53AIFVd7bseY9KFtXRNg4nIGSLSKtI/+ivgI+oe6pUSROT7IrJERD4WkTki0sJ3TcZY6JponIm7ELQRGIT72J6SH5UifcBXA/mqOhJoApzntypjbO4FEwVVvRRIyGQ0CZILtBSRENAK98vCGK+spWsyUmSo2q+AdbgLfyWRm0GM8cpC12QkEemA6w7ph7shobWIzPBblTEWuiZzTcDdAl2kqiHccLPx9exjTMJZ6JpMtQ44MjLaQoCTcLcmG+OVha7JSKr6Du4uuvdxQ9tygIe9FmUMdnOEMcYklQ0ZM8akpIULF3bNzc19BBhJan4qDwMfV1dXX5qXl7e1oTtZ6BpjUlJubu4j3bt3H9alS5cdOTk5KfeRPBwOS1FR0fDNmzc/Any9oful4m8PY4wBGNmlS5ddqRi4ADk5OdqlS5cSXEu84fslqB5jjIlVTqoG7l6R+qLKUQtdY4xJIuvTNalBpCnQN/Loglv0scM+j9a4iWuaHM2baxZwdF/c5OTVuMUid+Hm3t2Bm2e3CDfn71pgvSrVSft+TPyJ5MX1eKoL69tk7ty5ba+//vre4XCYGTNmFN9+++2b69unPha6JrncOmZ5wGjccjj9cbfq9iKKT14ltJsPHB3FmWtaNg8vLH/l/V3Ap7UeiynI33LgXU02qq6u5vvf/37vl19++bP+/fuHxowZM+zss8/emZeXF9WE+Puy0DWJI9IFOAoXsnsf3T1V06Rtq5pc3O3BE770SiC4ClgAvBX5+hEF+dEu72MyzLx581r36dOncvjw4VUAkydP3j537tz2eXl5MbV2LXRN/LjFKo/DhdrXcK1ZOeA+SdS3e2Xpfl7qH3nsnRBnN4Hgu7gA/i/wpoVw9lm/fn2zgw8+uGrv33v16lX1zjvvxLwys4WuiY1IX+Ac4FTcx/3mPss5kFH9yxsanG1wczWcBMwEigkEnweeBV6hID+mj5cmPdR1t66IxDyawkLXRE+kF3AuMJX9LD6ZivKGlDV2uZ7OuIU0LwZKCQRfAv4BvEhB/s4D7mnSVu/evasKCwub7f37hg0bmvXs2TMU63EtdE3DiLQFpuOWGz+aFOo2aKhDB5V1jMNhWgNnRx4hAsEXgIeA/1CQn9JjSk10CgoKStesWdPik08+ada3b9/QM8880/HJJ59cFetxLXTNgYmMwi05PgOIuT/LpxF9y3vG+ZBNgW9EHisIBH8L/IGC/O1xPo+BBg3xiqemTZty9913r5s4ceLgmpoapk2bVpyfH3vXkoWu+SqRZriW3BXAMZ6riYsc0aI2rcJdEniKgbjlgW4lEHwaeIiC/LcTeD6TBFOnTi2ZOnVqSTyPaXekmS+ItETke8Bq4C9kSOACtG1dsylJp2oBXAC8RSC4kEDwrCSd16QJC10DIq0QuRZYBdyDW1MsoxzStWq3h9OOA/5BIBgkEDzNw/lNCrLQzWYirRH5Ia5lezf+blxIuBF9y2O+6hyDPOBFAsG3CAQn1Lu1yWgWutlIJAeRS4DlwF1AV88VJdy4wWXN6t8q4Y4EXiUQDBAIHue7GOOHhW62ESkAFgKPAD08V5M0+UPK2vmuoZbjgACB4N8JBA/2XYxJLgvdbCFyMCJzgHnAWM/VJN3IfnEfLhYPk4FlBILfIxBs4rsYkxw2ZCzTueXHrwTuIM3H2TaWoCVd2ld38F3HfrTBXbz8PwLBb1GQn9SxqOlEbo7v1I4668DjflesWNF0+vTp/YqKiprm5ORw4YUXFs2cObPBa6Htj7V0M5lIP+A14D6yNHABWrcMb/RdQwPkAe8QCN5LINjGdzHm85sjNqxatWrJe++9t+zRRx/tunDhwsbeSv45C91MJCKIfAf4EDjeczXe9ewc2uG7hgZqAlwNfEIgeLLvYrJdnz59Qsccc0wZQIcOHcIDBgwoX7duXcwXZC10M41Ib+BV4EGyuHVb29DeFT6HizVGT+AlAsHbrK83NXz66afNli5d2qqgoGBPrMey0M0kIqcBH+CmJDQR4waVpmNwCXADMI9AsJfvYrJZSUlJzuTJkwfceeed6zt27BiO9XgWupnAjbu9FXgBiMdMWhklb3BZOveRHgMsSsQdbSLSXkTmisgnIrJMRI6K9znSXWVlpUyaNGnAueeeu/3CCy+MyzSeFrrpzi2J8zJwI2k43WIyjB5Q3s13DTHqBLxAIPhLAsF4jji6F3hJVYcCY4BlcTx22guHw5x33nl9Bg8eXHHTTTfFbR09GzKWzkSOBP6GW9TR1EnLe3WtSvfQBfcL9XpgPIHgmRTkF8d0MDc/8nHARQCqWgVUHWgf3+ob4hVvr7766kHPPvtsp0GDBpUPHTp0OMDNN99cGOusYxa66UrkbODPuFmtzH60aKaFOcJA33XE0XhgAYHgRAryY5lQuz9uifo/iMgY3F2K31PV/a0jl3VOOeWUPZqAOXyteyEdiVwDPI0Fbr26dQht811DAgzCTR15WAzHyMXNgvaQqh4KlAI/jkdx5sAsdNOJG387G5iN/ds1yKBelZm6iGRX3MiG0xu5/wZgg6q+E/n7XFwImwSzH9x0IdIC17q9xncp6WTswLJMvrjYCniWQPDyaHdU1c3AehEZEnnqJGBpPIszdbPQTQciLYHncUudmyjkDSnN9BtEmgC/IxC8tRH7XgU8KSIf4iZBuj2ulZk62YW0VOcC95+ATX7dCIcOKuvsu4YkuZFAsAUF+dc3dAdVXQTkJ7AmUwdr6aYyC9wYaWhAz8psmq/2OgLBO30XYQ7MWrqpygXuc1jgNlrTXN2Y24Q+vutIsh8RCIYoyJ/pu5C4CwTjOrVjQ6bRLC4ubjJjxow+n376aUsR4eGHH14zYcKEmIbVWUs3Fbkl0J8Dvua7lHTWuV11TDcQpLGfEgj+wHcRmeDyyy8/5OSTT961evXqJUuXLl06duzYmEfDWOimGjfp+B+wwI1Z/x6V2TzQ/xcEgpf6LiKdbd++Peedd95pc8011xQDtGjRQjt37lwT63EtdFPPbcA030VkgtEDytV3DZ79jkDQRrw00ieffNK8Y8eO1eeee27fYcOGDZ86dWqfXbt2xZyZFrqpRORy4Ce+y8gU+UNKW/quwbMc4Im494Vmierqalm2bFmrK6+8smjZsmVLW7VqFZ45c2b3WI9roZsqRE7FTTxu4uTQQWWdfNeQAloA/yAQ7Oq7kHTTt2/fqm7dulWdeOKJpQBTp07dsXjx4laxHtdCNxWIjMLdbZaOk20nzHrgBGAYMAI3D+FXPQmMjjzGA4sjz2/VK2ZP6zfyoqk8+8a8z7c+88br2FhclLiiU9MhwFwCwaa+C0knvXv3ru7evXvV4sWLmwO88sorbYcMGRLzhTQbMuabm2Lv79jSOl+RC9yNmxBgN27lxq8Bw7+0VT8gAHQA/g1cDryDyJ92f/O009ued+LJTPzh1Zx17PE8v+B/jBs0lJ6duyTz20gVx+JWHb7SdyGN5mGl5Pvuu2/d9OnT+1dVVUnv3r0r58yZsybWY1ro+vcobtYos48ekQe4dcqHAYXsG7rja/35SNw8LtCyWc2u8srKtpVVIXIkh+rqau6ZO4fnb5+d8LpT2BUEgu9TkP+o70LSxfjx48s//vjjuE7ubt0LPrkpGu3qcgOswS3+dsQBt3oUOBWAgb2mrXv5vbeZ+MOruemiy3jwublccPIkWrXI+tkwHyAQPNJ3EdnMQtcXtx7VL3yXkQ72AGfjPhu33e9Wr+NC9y4Axg5sFXrxznsIPvw44wYP5YW33uTs407ksl/eyjk/+xFvLfkwCZWnpObA3wkEbS09Tyx0fRDpiLtwZhc26hHCBe50YPJ+t/oQuBR3E58bsJA3uKzZ3ldv+dMj3DjjYua89jJ5g4fx2I9mcsPvs3qgSE/gft9FZCsLXT9+g61rVi8FLsH15V67363W4eL4CWDw58+OG1zWAWD5hnVs3FZEwdg8yioqyMkRRISKqpReDiwZzicQPNt3EdnIQjfZRM7ENdxMPebjovQ13GSvY4F/Ab8FingkMkj9FmAbcEVkCzdT4ah+5T0BbnzkIW695DsAnH/SKfzxpRc48oqLuX7qjCR+JynrIQLBrBzK4ZOoZvudkknkuhWWADHf1ZLtRvLR/CWMPLqu10R0W/j1hXZjRMM8Q0F+SrZ4Fy9evGbMmDEpP2nR4sWLO48ZM6ZvQ7e3IWPJ9RsscBOubauaTezt3DX1mUwgOI2C/L/4LqQ+IsT1dmZV6h33e/PNN3d94oknuogIQ4cOLXvqqafWtGrVKqaWqnUvJIvI17FuhaQ4uEtol+8a0sz9BII96t8su6xevbrpww8/3G3RokVLly9fvqSmpkYeeeSRmEd9WOgmg0hr4AHfZWSL4X3Ks/4qWZQ6sL+7rLNcTU2NlJaW5oRCIcrLy3N69eoVivWYFrrJcSM2WiFpxg0us6F40TuXQLDOPvJs1a9fv9CVV165uV+/fqO7du06pk2bNjWTJ0+O+VOUhW6iiQzkQCOeTNzlDynb/z0U5kDuJhDM5CXro1JUVNTkxRdfbL9ixYqPNm/e/GFZWVnOgw8+aN0LaeCXuLuATJKM6l9m/ZONcwRwnu8iUsXzzz/ftnfv3pU9e/asbt68uZ511lk7FyxYEPPEVBa6iSRyHHCW7zKyi+7u3rE6W5ZdT4Q7CASzfoIKcPPpvv/++wft3r07JxwO89prr7UZNmyYTe2Y4u72XUC2adUivBEY4ruONNYHuAZIuaXcGzLEK55OPPHE0jPOOGPH6NGjh+Xm5jJixIiya6+9NubJmC10E0XkDPbeHmWSpkfH0A7fNWSAnxAIPkpBftbN9r6v2bNnb5w9e/bGeB7TuhcSZ6bvArLRkEMqYv74V5f1WzdzwjXfZtgF5zLioincO3cOAH+b9x9GXDSFnBMOJ/jJ0jr3rais5PBvX8iYS6Yx4qIpzPrD7z5/bfqtP2X0N8/nht9/MaLw548/wnNvBhLxbTRUW+CnPgvIZNbSTQS33tlhvsvIRmMHlSVkyaPcJrncfcU1jBs8lN1lpeRdfgFfyz+Ckf0G8Mwtv+Bbd9+x332bN2vGa79+iINatSJUXc0xV13KqYeP/3xu3w8fm8OxV11GyZ49lFVW8O6yJcy8wPvq6ZcSCN5MQf5234VkGmvpJoa1cj3JH1KWkGWPenTqzLjBQwFo06o1w/r0pbC4iGF9+jGkd98D7isiHNTKrWcYqq4mVF2NiNA0N5fyykrC4TBV1SGa5OTws8d+yy3f/HYivoVotcLNIuRTOBwOp/QQtkh94Wj2sdCNN5EJwFG+y8hWYwaUdUv0OdZs2sgHyz/liGEjGrxPTU0NYy+ZRtezTuZr+UdwxPCRDOvTj95duzPushlMOX4CKwrXowqHDkqZ64BXeR7J8HFRUVG7VA3ecDgsRUVF7YCPo9nPuhfi7wbfBWQvrezTvSqhEwrtKSvj7Fk/4p7vXkvb1g1vVDdp0oRFj/6Fnbt3842ZP+DjVSsY2X8g91x13efbnPGT7/O7627gticeY/HK5Xwt/3AuO/0bifg2GqorcAHwsI+TV1dXX7p58+ZHNm/ePJLUbCCGgY+rq6uj6guy0I0nkeG4VcONB82bamGTHPon6vih6mrOnvUjpk+YyOTjTmzUMdq3acPxY/N46d23GNl/4OfPP/dmgPwhwymtKOfj1St5+qY7OO7qy5k+4VTf67pdSyD4ewrykz4HbF5e3lbg68k+b6Kl4m+PdPYd3wVksy7tqxM296qqcskvfs6w3n25dkp0k8UV7dzBzt27ASivrOA/C99laK1+4FB1Nff+/a/84Lz/o6yiAhH3aTocDlMVinl+lVgNIQODzydr6caLm0nsAt9lZLOBBydmuBjA/I8W88Qr/2JU/4GMvWQaALdfdiWVoSquuvdXFJXsYNJPvs/YgYN5+Zf3sbG4iEt/eSv/uuteNm0r5sI7bqImHCYcDjPlhAmcPv7Yz4/9wD+e5sJT3ErFowcMQlUZdfF5nHbk0bRv0yZR31I0rsctQGfiwFaOiBeRy4Hf1budiYu6Vo645pwtgdnfXV/gq6YMN5yC/GW+i8gE1r0QP76H12S9vCGlrX3XkMFsAv44sdCNB5HDgDG+y8h2hw4qs4luEmeaTfsYHxa68XG+7wKM1gzqVXmw7yoyWD/AJjmPAwvdWLlLzef6LiPb5TbRjc1y1VaMSCzrYogDC93YjceW4vGuY9uarJ8RKwmmEAjaL7YYWejGborvAgz0615Z6ruGLNARONV3EenOQjcWIjnAOb7LMDBqQHlUk46YRpvmu4B0Z6Ebm6OAnr6LMJA/uNSWmEmOUwgELTdiYG9ebCb6LsA44waXxbxKq2mQ9tiKKDGx0I3NBN8FGGd43wobLpY89v8+Bha6jSXSFlsdIiXk5OiW1i3CrXzXkUUsdGNgodt4JwAJWRrGRKdd65otvmvIMuMJBO2XXCNZ6Dae/bZPEb27Vu3yXUOWaQ4cW+9Wpk4Wuo13ku8CjDOiX3mN7xqykDU6GslCtzFE2gFDfZdhnLzBZXaXVPI1bukMY6HbSOMAm3EpRYwbXNredw1ZaJTdEtw4FrqNM853AeYLo/qX2w0qydcU+7TXKBa6jZPnuwDjiOjOTm1rrKXrx2jfBaQjC93GsZZuijioZXij7xqymIVuI1joRkukDTDYdxnG6dmpaqfvGrLYKN8FpCML3egNwy6ipYyhfSq8r1Gexayl2wgWutHr57sA84Vxg8rsrkB/DiYQ7OC7iHRjoRs9C90UkjekrK3vGrKctXajZKEbvf6+CzBfGDOgrJvvGrKcNUKiZKEbPftPljK0rFeXkIWuXzalZpQsdKNnoZsiWjbXQt81GAvdaFnoRsMtt97bdxnG6dYhtN13DdlOVe1uwCjl+i4gzbTB3f5oUsDgQyoqfNeQiVQ1HEa3VYQrd+yqLt1dFNpRXlhZVLO2YhOrKgqbrizf0HJ1xcY2Gyq3diwO7ewePt7WBI2GhW50bHhMChk7sMw+qTWQqqqiOyrDoR27a0p3FYdKyjZWFVWvrdjEqvLCJqsqCluuLt940PrKzR23VG3vWEO4C9ClAYfumujaM42FbnTsHv8Ukj+krLXvGnwLq+4KaWjbnpqyXdtCJWUbq4qr1lVsZnXFxpxV5YUtVlUUtllbsand5qptnUNa3RGI9wKeneN8vIxnoRsdC90UMmZgWUa2slS1NKTVxaU15bu2V+8q3Vy1rWp9xRZdVVGYs7J8Q/PVFRtbr63Y1G5jVVHninBVW8DnWOU2crM001la5bGGtGKhGx3rXkgRTaUm3L9HqIfvOhpKVSuqtWZbWbhi587q3aVbqrZXrq/cEl5dXigrKwqbrS4vbL2mYlO7DZVbO5WGy1sD6dSKbwlY6DaQhW50rKWbIvp3KinLbdLK6y3AqhqqIbytvKZyR0nNnj1bXZBWr63YlLOyvLDp6orCVqsrNrZdX7GlY0nNnna44VWZOMTKciQK9mZFp6XvAowzuveuEMR/Qdp9rtzvKgrtqCys3BpaU7FZVlVsaLqyfEPLNRWb2q6v3NJhW2hnB4XuuEc2sxyJgr1Z0bHJVVJE3pCKBo9cqHXlfvuumtJd20I7Kwori0JrKzfpqvKNTVeVb2ixpmJjm7WVmzturdreMYw29Mq9cSxHomBvVnRsiFKKyBtV3SKsWlKloe17aspKtodKyjdWFYfWVmwOr64ozF1ZvqHF6vKNrddVbu6wqaq4c7XWJOLKvXEsR6Jgb5ZJS7t+Pa3/kTP003XtOdx3LcY+AUbDWm7RqfFdgHGGFGvftfdw+N//ygctQ3zmu54sZ423KFjoRsdCN8VM/oRDd9/OwJ+8wRs5YYp815Ol1HcB6cRCNzq2NEwKaqLk3P5fjt1+F80nLieA2pjRJCvxXUA6sdCNjv3nSmHtKmn77ycpWHY/m/rt4B3f9WQR+7mIgqjaJ4MGEzkR+K/vMkzDPDeERdPOpmVZM4b4riWDVegstfHrUbCWbnR2+C7ANNyZnzJ21x0MmjmPN62/N2GslRslC93o2KTZaaaJknPLPI7ZcSctJn1KAKXSd00ZZqfvAtKNdS9EQ6Qt9ps9rX3WkfWTplO4ohNHeivibWBh5M/jgKP2eX0+8GHkz2GgGPgBbozAX4EK4ERgWGSbOcAkfM019q7O0iO8nDlN2fi6aKjuQqQae9/S1uDtHLL8Pg55cRCLp55Ls9Jmn0dXcmzBBe5luFsK/gwMBjrV2uboyAPgU+At3DQTbwNjgZGR/YZFXu+Bz8kdraUbJeteiN4m3wWY2E1azpiSOxhy0+u8mRNmS9JOXAz0AprhQrcvsOwA238EjIr8uQlu0GI1ILhR428D4xNUa8Os83r2NGShG71Vvgsw8dFEyZkV4Jidd9L6zGUEUBK/5lpXYC1QhpuBdjmwaz/bVgEr+KIbYRSwEtfKPR54DxiDC3B/Vno9exqy0I2e/SfLMG2qOOjZpyhY8RuKBxfzVkJP1gU4BngcF57d2P9P4We4taf3zmDZApgOfAvXpfAZLpD/CTwFrE9Y1QdiPw9RstCNnrV0M9SAHfT69H6O+vcTfNimkqUJO9E44NvAN3EzNO9v7rOPcf23dQkAx0W26QGcia8R5Ba6UbLQjZ79J8twE1cyeucdDLvtv8xvEk5AH/6eyNeduP7cUXVsUwGsAYbW8do2YDeuPziE698VXF9v8q3wctY0ZkPGoiVyONgtptliT1NKL/oG7/19GEcgcVo55DFcn24T4BSgP65/FuCwyNcPcHF2bh37Pw2chBvxsAc3jKwSOAEYHpcKG6pYZ6lN9h4lC91oibTH7kzLOqvbs3HSdNYs68xRCOK7nhTxjs5Sf+Od05R1L0RLdSew2ncZJrn67aTn0gcY/+rjLGlbwRLf9aSIT3wXkI4sdBtnYf2bmEw0YTUjd9zJ8LteZUFC+nvTi/0cNIKFbuMEfRdg/MkB+eF8xpfcQbspHxNAKfNdkycN+jkQkUNE5HURWSYiS0Tke4kuLJVZn25jiEwAXvVdhkkN69qy6bQZrFrShfFZ1N9bDbTVWVpe34Yi0gPooarvi0gbXAv5LFVN3KwgRVUAAAtMSURBVLC8FGah2xgiHbAZx8w+Xu/Lkm+cR7ikRZ2DwDLNQp2l+Y3ZUUSeA+5X1axsuFj3QmOo7sDG65p9nLCGETvvZNTdL/FWbg2FvutJsAWN2UlE+gKHksXDLi10G+913wWY1HTt2xxVcgcdp31IAKXUdz0JMj/aHUTkIODvwDWqur8ZJzKehW7jZeVHI9Mwrapp+eQzFKz/NXtGb2Y+mnEr5r4ZzcYi0hQXuE+q6jOJKSk9WJ9uY4l0ArZiv7hMA7zRm2Vnnk9oR0tG+64lDj7SWdrg70NEBPgTsF1Vr0lcWenBAqOxVLcB7/s49U7gHNxt+cPg82mx7gOGACOAH+5n39mR10cC58PncxlOB0YDN9Ta9ufAc/EsPIsdu45h2+9i9D3/5q3cGjb4ridGL0S5/dHA/wEnisiiyOO0BNSVFmwFhNi8CjTqCm4svgdMBObiplwtw3UwP4db5aU5rgm+r0LgN8BS3ORWU3C37Y+LvP4hcCxuPaIy4F1gZqK+iSz1vXc46vKFVHz7dOY9PoZ8hIN819QIUYWuqr4JWTOUrl7W0o3NK8k+4S7gf8Alkb83A9oDDwE/xgUuuLmy61INlEe+lgE9gaaR58K4EG8C/Ay4Jf7lG6BlNS3+9CzHb/g1ZYdu5E2UsO+aolCMW6/CNJKFbmzm4ybaS5pVuHmwL8aNu7kUKMXNZ/0GcARQwBeTVtV2MHA9bl7sHkA74GRcF0VvXIt3Cm5yK40c3yTOwbvp+v7DHDP/MT7rVMYi3/U00L90lqbTL4mUY6EbC9UQkNQrsdW4juTv4Gb/aw3cGXl+B64J8ktceO57iXQHrgtiNbARF9Z/jrx2D7AIuA7XpXALcFvkOL9P2HdjAMavZ2jxLxj7wIu83bQm5dcci7Y/1+zDQjd2TyXzZL0ij71rXp+DC+FewGRcx9nhuH/Y4n32/Q/QD9dSbhrZft8R7s/hOqlLcYsSPA08AVk7uUAyXfEeR+66nW4Xf0AAZbfveuoQAl72XUS6s9CN3TxI3mqy3YFDcCtvg1uhZThwFvBa5LnPcH2znffZtzeuJVyGawX/F760/ngIuBf4QWSbvVc+9vb1msRrUUPzx56jYNOvqDiskDdSrL/3BZ2VvTc1xIuFbqxUa3ADCZLmPr4Y4rUIN8zrm7j+3pHAebhBkYLrRtg7NucIXMt4HG6FmDBwea3jPgBciFsHcTQumEfhxvu0T+Q3ZL6ieyld3v09x771CMs7l/KB73oiHvNdQCawmyPiQeQY3HUsYxLi4XG8+91JdAs1oY+nEjYBh+gsrfF0/oxhLd34mA8s912EyVyXv8/hu2+nx2ULCaCUeCjhcQvc+LDQjQf3ceEh32WYzNa8hmYPP0/B5l8ROmIDb6AkMwStayFOrHshXtyClYW4LlFjEi7Yg+WTprN760Gf31SYKPN1lh6T4HNkDWvpxotbsHKO7zJM9sjfxKAtv2Lco8/yXrPqhC6Waq3cOLKWbjyJHIqnSXBMdqvKIXTNRBb89jDGqtAujofeAvTVWVpR75amQSx0401kAXCU7zJMdipqxfazzuPjBYdwNEKTOBzyJzpL74zDcUyEhW68iUzGTdZsjDfv92DFpGmUbG5DXgyHKQF62w0R8WWhG29uwubFkBWLE5oU9/ho3rv863SqzKV/I3a/XWfpjXEvKstZ6CaCyDnA33yXYQxAKIfq605mwf1HMEqFDg3crRzoo7O0KJG1ZSML3URwrd0PcXflGpMSiluy4+ypfPS/PoxH6l3A4H6dpVclpbAsY6GbKCJTSPIMZMY0xOJurDptOts3tt3vqichYJDO0rXJrCtbWOgmikgOrrU7wncpxtTlyVEEL/06HSqaMmCfl+7VWbaAZKJY6CaSyOnA877LMGZ/QjlU/3gCC2YfxUgVOuLWPR2oszSpK6JkEwvdRBN5FZjguwxjDmRHC0rOnsKiN/vwz6pb9Ne+68lkFrqJJjIKt7JOPAaqG5NIK4CRqFb6LiST2dwLURKRiSLyqYisEJEf17uD6kfYDGQmPVxrgZt41tKNgog0wa2G8zVgA27R3fNVdWk9O7aP7Ncl0TUa00gvoXqq7yKygbV0o3M4sEJVV6lqFfBX4Mx693IzkP0gwbUZ01h7cAtMmySw0I3OwcD6Wn/fEHmufqp/Av6VgJqMidWPUV3ju4hsYaEbHanjuWj6Zy7DDckxJlUEgAd9F5FNLHSjswG3AvpevXAL7jaM6kbg6jjXZExjlQGXYBd2kspCNzrvAYNEpJ+INMOtdv7PqI6g+gTwXAJqMyZaN6K60ncR2cZGL0RJRE4D7sGNu31MVW9rxEG6AUuATvGtzpgG+y9wMqph34VkGwtdX0ROBV6k7n5iYxJpEzAW1a2+C8lG1r3gi+q/gVt9l2GyTg1wngWuPxa6ft0EvOq7CJNVforq/3wXkc2se8E3kc64FYQPqW9TY2L0InCGjVbwy0I3FYgcDrwBNPNdislYK4AjUN3uu5BsZ90LqUD1XeAS32WYjFUMnGqBmxosdFOF6p8BW3nVxFsFcCaqK3wXYhwL3VSiejvwO99lmIyhwAWoLvBdiPmChW7quRJ4wXcRJiP8GNW/+S7CfJldSEtFIq2A13FTSRrTGLNRvdZ3EearrKWbilTLgInAQt+lmLT0Gwvc1GWhm6pUd+AWtAz6LsWklftR/Z7vIsz+WeimMrfixATc7GbG1OdBVK/yXYQ5MAvdVKdagluT7V3fpZiU9lvgu76LMPWz0E0HXwSv3TNv6nIrqt+x23vTg4VuulDdhQvev/guxaSMGuBbqM70XYhpOAvddOJWIJ4B3O67FONdGXAWqg/7LsREx8bppiuRy3ALCub6LsUkXRFwemTODpNmLHTTmcgpwF+B9r5LMUnzAXA2qqt9F2Iax7oX0pnqy0Aebj5ek/keA8Zb4KY3C910p7oKGI9NlJPJKoBLUb0E1QrfxZjYWPdCJhGZgRuv2dp3KSZuVgPnoGqfZjKEtXQziZuT93DgQ9+lmLh4HBhngZtZLHQzjepSIB+4BQh5rsY0zhbcxOMXRm4FNxnEuhcymchY4I/AGM+VmIZ7CrgS1W2+CzGJYS3dTKa6CDgMt9S7tXpT21ZgCqrnWeBmNmvpZguREcB9wAm+SzFfUoO7yeVn1pWQHSx0s43IOcCvgD6+SzHMA65BdbHvQkzyWPdCtlGdCwwFfgLs8lxNtloJTEb1BAvc7GMt3Wwm0gW4AfgW0NJzNdlgLW6yoj+gan3sWcpC14BIV+A64ArgIM/VZKI1uLD9o4WtsdA1XxDpCFwDXA2081xNJliDha3Zh4Wu+SqRdsA3gW8Dgz1Xk24U+A/wAPACqjWe6zEpxkLX7J+IACcC3wHOxObuPZAS4E/AA6h+5rsYk7osdE3DiPQALgUuAAZ6riZVhIEAbgmlOaiWeq7HpAELXRM9kUOBKcC5wADP1fjwNjAH+Buqm3wXY9KLha6Jjcg4XAB/HRjmuZpEqQTmAy/hgnaN33JMOrPQNfEj0hM4qdajl9+CYrIUeCXyCKBa5rkekyEsdE3iiAwBCnBLCo0DRgHNvdZUt53AQuA9IAi8jWqh35JMprLQNckjkguMwAXwobgLcn0jj2TcEbcddwvuqsjXj4AgqiuScG5jAAtdkwrc0LRuuPDtB/TArXC899Eu8rUtbthaTuQRBqojj1JcqNZ+7MAtV74aWGmzeJlUYKFrjDFJZLOMGWNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMElnoGmNMEv0/mmN78qpP9KYAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/tutorials/source_zh_cn/advanced_use/customized_debugging_information.md b/tutorials/source_zh_cn/advanced_use/customized_debugging_information.md index 5df1e2da144f9a23353310778f83d36760d53431..1ad1416adb435c816444792446b600465af63990 100644 --- a/tutorials/source_zh_cn/advanced_use/customized_debugging_information.md +++ b/tutorials/source_zh_cn/advanced_use/customized_debugging_information.md @@ -14,6 +14,8 @@ +   + ## 概述