{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0123456789\n"
     ]
    }
   ],
   "source": [
    "from captcha.image import ImageCaptcha\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "import glob\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import string\n",
    "# characters = string.digits + string.ascii_uppercase\n",
    "characters = string.digits # 验证码字符集合\n",
    "print(characters)\n",
    "\n",
    "width, height, n_len, n_class = 100, 50, 6, len(characters) + 1  #图片宽、高，验证码最大长度，分类类别：字符集+1个空值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    " # 防止 tensorflow 占用所有显存\n",
    "import tensorflow as tf\n",
    "import tensorflow.keras.backend as K\n",
    "\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth=True  #True \n",
    "sess = tf.Session(config=config)\n",
    "K.set_session(sess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义 CTC Loss\n",
    "import tensorflow.keras.backend as K\n",
    "\n",
    "def ctc_lambda_func(args):\n",
    "    '''\n",
    "        定义ctc损失函数\n",
    "        参数：y_pred:预测值,labels:标签，input_length:lstm tiemstep,label_length:标签长度\n",
    "    '''    \n",
    "    y_pred, labels, input_length, label_length = args\n",
    "    return K.ctc_batch_cost(labels, y_pred, input_length, label_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义网络\n",
    "from tensorflow.keras.models import *\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "input_tensor = Input((height, width, 3))\n",
    "x = input_tensor\n",
    "\n",
    "for i, n_cnn in enumerate([2, 2, 2, 2]):    \n",
    "    for j in range(n_cnn):\n",
    "        x = Conv2D(32*2**min(i, 3), kernel_size=3, padding='same', kernel_initializer='he_uniform')(x)  # 32*2**min(i, 3)\n",
    "        x = BatchNormalization()(x)\n",
    "        x = Activation('relu')(x)\n",
    "    x = MaxPooling2D(2 if i < 3 else (2, 1))(x)\n",
    "\n",
    "x = Permute((2, 1, 3))(x)\n",
    "x = TimeDistributed(Flatten())(x)\n",
    "\n",
    "rnn_size = 64 # 128\n",
    "# x = Bidirectional(CuDNNGRU(rnn_size, return_sequences=True))(x)\n",
    "# x = Bidirectional(CuDNNGRU(rnn_size, return_sequences=True))(x)\n",
    "x = Bidirectional(GRU(rnn_size, return_sequences=True))(x)\n",
    "x = Bidirectional(GRU(rnn_size, return_sequences=True))(x)\n",
    "x = Dense(n_class, activation='softmax')(x)\n",
    "\n",
    "base_model = Model(inputs=input_tensor, outputs=x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = Input(name='the_labels', shape=[n_len], dtype='float32')\n",
    "input_length = Input(name='input_length', shape=[1], dtype='int64')\n",
    "label_length = Input(name='label_length', shape=[1], dtype='int64')\n",
    "loss_out = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')([x, labels, input_length, label_length])\n",
    "\n",
    "model = Model(inputs=[input_tensor, labels, input_length, label_length], outputs=loss_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 网络结构可视化\n",
    "# from tensorflow.keras.utils import plot_model\n",
    "# from IPython.display import Image\n",
    "\n",
    "# plot_model(model, to_file='ctc.png', show_shapes=True)\n",
    "# Image('ctc.png')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# base_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image, ImageFont, ImageDraw\n",
    "\n",
    "def random_color(start, end, opacity=None):\n",
    "    '''\n",
    "    随机颜色函数，返回指定范围随机颜色值\n",
    "    参数：start:颜色最低值，end:颜色最高值\n",
    "    '''\n",
    "    red = random.randint(start, end)\n",
    "    green = random.randint(start, end)\n",
    "    blue = random.randint(start, end)\n",
    "    if opacity is None:\n",
    "        return (red, green, blue)\n",
    "    return (red, green, blue, opacity)\n",
    "def random_xy(width,height):   \n",
    "    '''\n",
    "    随机位置函数，返回指定范围随机位置坐标\n",
    "    参数：width:图片宽，height:图片高\n",
    "    '''\n",
    "    x = random.randint(0, width)\n",
    "    y = random.randint(0, height)\n",
    "    return x, y\n",
    "    \n",
    "def generate_image(random_str, width=80, height=30):\n",
    "    '''\n",
    "    随机生成验证码，从四种字体随机抽取一种生成文字，加随机线干扰和点干扰\n",
    "    参数：random_str:要生成验证码的文字\n",
    "    返回：验证码图片\n",
    "    '''    \n",
    "    image = Image.new(mode='RGB', size=(width, height), color=(255,255,255))\n",
    "    fonts = ['/usr/share/fonts/WindowsFonts/fonts/ariali.ttf', '/usr/share/fonts/WindowsFonts/fonts/simhei.ttf',\n",
    "            '/usr/share/fonts/WindowsFonts/fonts/simsunb.ttf', '/usr/share/fonts/WindowsFonts/fonts/calibri.ttf']\n",
    "    font = ImageFont.truetype(font=random.choice(fonts), size=25)\n",
    "    draw = ImageDraw.Draw(image) \n",
    "    for _ in range(random.randint(50, 150)):\n",
    "        draw.line(xy=(random_xy(width,height),random_xy(width,height)),fill=random_color(180, 255))\n",
    "    for _ in range(random.randint(0,50)):\n",
    "        draw.point(xy=(random_xy(width,height)),fill=random_color(70, 200))\n",
    "#     draw.text(xy=(random.randint(0,10),random.randint(0,2)),text= random_str, fill=text_fill, font=font)\n",
    "    len_t = len(random_str)\n",
    "    for i in range(len_t):\n",
    "        draw.text(xy=(random.randint(0,2)+i*int(width/len_t),random.randint(1,6)),text= random_str[i], \n",
    "                  fill=random_color(0,180,opacity=80), font=font)\n",
    "    \n",
    "    return image.resize((100,50), Image.BILINEAR)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 重组验证码\n",
    "def rebuild_img(path):\n",
    "    '''\n",
    "    读取本地4-5位验证码图片进行裁剪分割为单个数字，从分割的字符随机抽取n个重组为新图片\n",
    "    参数：path：图片路径\n",
    "    返回：重组后图片\n",
    "    '''\n",
    "    label = path.split('_')[-1][:-4]\n",
    "    if label.isdigit() and len(label) > 3:\n",
    "        crop_n = len(label) \n",
    "        img = Image.open(path)\n",
    "        w, h = img.size\n",
    "        fig_size = int(w/crop_n)\n",
    "        fig_list = []\n",
    "        new_label = []\n",
    "        if crop_n == 4:\n",
    "            for i in range(crop_n):\n",
    "                fig_list.append(img.crop((i*fig_size+2, 2, (i+1)*fig_size-2, h-2 )))\n",
    "            for i in range(crop_n):\n",
    "                idx = random.randint(0,crop_n-1)\n",
    "                img.paste(fig_list[idx], (i*fig_size+2, 2, (i+1)*fig_size-2, h-2 ))\n",
    "                new_label.append(label[idx])\n",
    "        elif crop_n == 5:        \n",
    "            for i in range(crop_n):\n",
    "                fig_list.append(img.crop((i*fig_size, 0, (i+1)*fig_size, h )))\n",
    "            for i in range(crop_n):\n",
    "                idx = random.randint(0,crop_n-1)\n",
    "                img.paste(fig_list[idx], (i*fig_size, 0, (i+1)*fig_size, h ))\n",
    "                new_label.append(label[idx])\n",
    "        return img.resize((100,50), Image.BILINEAR), ''.join(new_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义数据生成器\n",
    "from tensorflow.keras.utils import Sequence\n",
    "\n",
    "class CaptchaSequence2(Sequence):\n",
    "    '''\n",
    "    继承Sequence的数据生成类，方便调用多CPU，加快生成训练及测试数据\n",
    "    参数：self.characters:验证码字符集合，self.batch_size：每批次样本数，self.steps：生成多少批数据，self.n_len：验证码长度，\n",
    "    self.width：图片宽度，self.height:图片高度，self.input_length：lstm time step长度，self.label_length：标签长度\n",
    "    返回：array类型训练或测试数据 \n",
    "    \n",
    "    '''    \n",
    "    def __init__(self, characters, batch_size, steps, n_len=6, width=100, height=50, \n",
    "                 input_length=12, label_length=6): #  width=128, height=64, input_length=16, label_length=4\n",
    "        self.characters = characters\n",
    "        self.batch_size = batch_size\n",
    "        self.steps = steps\n",
    "        self.n_len = n_len\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        self.input_length = input_length\n",
    "        self.label_length = label_length\n",
    "#         self.label_length = self.n_len\n",
    "        self.n_class = len(characters)\n",
    "        self.generator = ImageCaptcha(width=width, height=height)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.steps\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        X = np.zeros((self.batch_size, self.height, self.width, 3), dtype=np.float32)\n",
    "        y = np.zeros((self.batch_size, self.n_len), dtype=np.uint8)\n",
    "        input_length = np.ones(self.batch_size)*self.input_length\n",
    "        label_length = np.ones(self.batch_size)*self.label_length\n",
    "        bat_len = random.randint(5,5)\n",
    "#         bat_len = 4\n",
    "#         num = '0123456789'\n",
    "#         sign = '+*-'\n",
    "        for i in range(self.batch_size):\n",
    "        #             random_str = '{}{}{}='.format(random.choice(num), random.choice(sign), random.choice(num))  \n",
    "            if bat_len == 4:                \n",
    "                if i % 3 == 0:\n",
    "#                     print('bat_len == 4 if i % 3 == 0:')\n",
    "                    image, random_str = rebuild_img(random.choice(glob.glob('Digit4/*.jpg')))    \n",
    "                elif i % 3 == 1: \n",
    "#                     print('bat_len == 4 if i % 3 == 1:')\n",
    "                    random_str = ''.join([random.choice(self.characters) for j in range(bat_len)])\n",
    "                    image = generate_image(random_str, 80, 30)              \n",
    "                elif i % 3 == 2:\n",
    "#                     print('bat_len == 4 if i % 3 == 2:')\n",
    "                    random_str = ''.join([random.choice(self.characters) for j in range(bat_len)])\n",
    "                    image = self.generator.generate_image(random_str)                \n",
    "            elif bat_len == 5:                \n",
    "                if i % 3 == 0:\n",
    "#                     print('bat_len == 5 if i % 3 == 0:')\n",
    "                    image, random_str = rebuild_img(random.choice(glob.glob('Digit5/*.jpg')))  \n",
    "#                 elif i % 3 == 1:   \n",
    "# #                     print('bat_len == 5 if i % 3 == 1:')\n",
    "#                     random_str = ''.join([random.choice(self.characters) for j in range(bat_len)])\n",
    "#                     image =  generate_image(random_str, 100, 27)\n",
    "#                 elif i % 3 == 2:\n",
    "#                     print('bat_len == 5 if i % 3 == 2:')\n",
    "                else:\n",
    "                    random_str = ''.join([random.choice(self.characters) for j in range(bat_len)])\n",
    "                    image = self.generator.generate_image(random_str)              \n",
    "#             else:         \n",
    "# #                 print('else:')\n",
    "#                 random_str = ''.join([random.choice(self.characters) for j in range(bat_len)])\n",
    "#                 image = generate_image(random_str, 100, 50)           \n",
    "#                 elif i % 2 == 1:\n",
    "#                     random_str = ''.join([random.choice(self.characters) for j in range(bat_len)])\n",
    "#                     image = self.generator.generate_image(random_str)                \n",
    "#             print('i=',i,'bat_len=',bat_len)   \n",
    "            X[i] = np.array(image)/255.0\n",
    "            label = [self.characters.find(x) for x in random_str]\n",
    "            if len(random_str) < self.n_len:\n",
    "                label += [self.n_class]*(self.n_len-len(random_str)) \n",
    "            y[i] = label\n",
    "\n",
    "        return [X, y, input_length, label_length], np.ones(self.batch_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义数据生成器\n",
    "from tensorflow.keras.utils import Sequence\n",
    "\n",
    "class CaptchaSequence(Sequence):\n",
    "    '''\n",
    "    继承Sequence的数据生成类，方便调用多CPU，加快生成训练及测试数据\n",
    "    参数：self.characters:验证码字符集合，self.batch_size：每批次样本数，self.steps：生成多少批数据，self.n_len：验证码长度，\n",
    "    self.width：图片宽度，self.height:图片高度，self.input_length：lstm time step长度，self.label_length：标签长度\n",
    "    返回：array类型训练或测试数据 \n",
    "    \n",
    "    '''\n",
    "    def __init__(self, characters, batch_size, steps, n_len=6, width=100, height=50, \n",
    "                 input_length=12, label_length=6): #  width=128, height=64, input_length=16, label_length=4\n",
    "        self.characters = characters\n",
    "        self.batch_size = batch_size\n",
    "        self.steps = steps\n",
    "        self.n_len = n_len\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        self.input_length = input_length\n",
    "        self.label_length = label_length\n",
    "#         self.label_length = self.n_len\n",
    "        self.n_class = len(characters)\n",
    "        self.generator = ImageCaptcha(width=width, height=height)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.steps\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        X = np.zeros((self.batch_size, self.height, self.width, 3), dtype=np.float32)\n",
    "        y = np.zeros((self.batch_size, self.n_len), dtype=np.uint8)\n",
    "        input_length = np.ones(self.batch_size)*self.input_length\n",
    "        label_length = np.ones(self.batch_size)*self.label_length        \n",
    "        for i in range(self.batch_size):            \n",
    "            if i % 4 == 0:\n",
    "                image, random_str = rebuild_img(random.choice(glob.glob('Digit4/*.jpg')))    \n",
    "            elif i % 4 == 1: \n",
    "                random_str = ''.join([random.choice(self.characters) for j in range(random.randint(4, 6))])\n",
    "                image = generate_image(random_str, 80, 30)              \n",
    "            elif i % 4 == 2:\n",
    "                random_str = ''.join([random.choice(self.characters) for j in range(random.randint(4, 6))])\n",
    "                image = self.generator.generate_image(random_str)                           \n",
    "            elif i % 4 == 3:\n",
    "                image, random_str = rebuild_img(random.choice(glob.glob('Digit5/*.jpg')))   \n",
    "            X[i] = np.array(image)/255.0\n",
    "            label = [self.characters.find(x) for x in random_str]\n",
    "            if len(random_str) < self.n_len:\n",
    "                label += [self.n_class]*(self.n_len-len(random_str)) \n",
    "            y[i] = label\n",
    "\n",
    "        return [X, y, input_length, label_length], np.ones(self.batch_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, '927828')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 213,
       "width": 370
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 测试生成器\n",
    "data = CaptchaSequence(characters, batch_size=10, steps=5)\n",
    "[X_test, y_test, input_length, label_length], _  = data[3]\n",
    "idx = 5\n",
    "plt.imshow(X_test[idx])\n",
    "plt.title(''.join([characters[x] for x in y_test[idx] if x < len(characters)]))\n",
    "# print(input_length, label_length)\n",
    "# print(y_test)\n",
    "# print(X_test.shape)\n",
    "# print(n_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 30, 80, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fcdee58b978>"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 158,
       "width": 370
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 从现有图片生成测试数据\n",
    "def get_data(img_path):\n",
    "    img = Image.open(img_path)\n",
    "#     img = img.crop((0, height-25, width, height))\n",
    "    w, h = img.size\n",
    "    data = np.zeros((1,h, w, 3))\n",
    "    data[0] = np.array(img)/255.0\n",
    "    return data\n",
    "img_path = '../FileInfo/ffc510f4-f977-11e9-b970-408d5cd36814_5802.jpg'\n",
    "\n",
    "data = get_data(img_path)\n",
    "print(data.shape)\n",
    "plt.imshow(data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 准确率回调函数\n",
    "from tqdm import tqdm\n",
    "\n",
    "def evaluate(model, batch_size=128, steps=1):\n",
    "    '''\n",
    "    准确率验证函数，每批次的验证码长度必须一致\n",
    "    '''    \n",
    "    batch_acc = 0\n",
    "    valid_data = CaptchaSequence(characters, batch_size, steps)\n",
    "    for i in range(len(valid_data)):\n",
    "        [X_test, y_test, _, _], _ = valid_data[i]\n",
    "        y_pred = base_model.predict(X_test)\n",
    "        shape = y_pred.shape\n",
    "    #         out = K.get_value(K.ctc_decode(y_pred, input_length=np.ones(shape[0])*shape[1],)[0][0])[:, :4]\n",
    "        out = K.get_value(K.ctc_decode(y_pred, input_length=np.ones(shape[0])*shape[1],)[0][0])[:, :]\n",
    "    #     print(y_test)\n",
    "    #     print(type(y_test))\n",
    "    #     print(y_test[y_test<10, axis=1])\n",
    "    #     print(out)\n",
    "        if out.shape[1] >= 4:\n",
    "            batch_acc += (y_test[:,:out.shape[1]] == out).all(axis=1).mean()\n",
    "    return batch_acc / steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.27000000000000002"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# model.load_weights('digit4to6_ctc_best2.h5')\n",
    "evaluate(base_model,batch_size=1, steps=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import Callback\n",
    "\n",
    "class Evaluate(Callback):\n",
    "    '''\n",
    "    准确率验证的类，每批次的验证码长度必须一致\n",
    "    '''    \n",
    "    def __init__(self):\n",
    "        self.accs = []\n",
    "    \n",
    "    def on_epoch_end(self, epoch, logs=None):\n",
    "        logs = logs or {}\n",
    "        acc = evaluate(base_model, batch_size=128)  # evaluate(base_model)\n",
    "        logs['val_acc'] = acc\n",
    "        self.accs.append(acc)\n",
    "        print('\\nacc%.4f'%acc)\n",
    "#         print(f'\\nacc: {acc*100:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/200\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process ForkPoolWorker-149:\n",
      "Process ForkPoolWorker-150:\n",
      "Process ForkPoolWorker-147:\n",
      "Process ForkPoolWorker-148:\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/queues.py\", line 342, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/queues.py\", line 343, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/queues.py\", line 342, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/queues.py\", line 342, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "KeyboardInterrupt\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 407, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "KeyboardInterrupt\n",
      "KeyboardInterrupt\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-c81325713422>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;31m#                     callbacks=callbacks)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m model.fit_generator(train_data, epochs=200, validation_data=valid_data, workers=4, use_multiprocessing=True,\n\u001b[0;32m---> 16\u001b[0;31m                    callbacks=callbacks)\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mfit_generator\u001b[0;34m(self, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[1;32m   1777\u001b[0m         \u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1778\u001b[0m         \u001b[0mshuffle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshuffle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1779\u001b[0;31m         initial_epoch=initial_epoch)\n\u001b[0m\u001b[1;32m   1780\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1781\u001b[0m   def evaluate_generator(self,\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/engine/training_generator.py\u001b[0m in \u001b[0;36mfit_generator\u001b[0;34m(model, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[1;32m    202\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    203\u001b[0m         outs = model.train_on_batch(\n\u001b[0;32m--> 204\u001b[0;31m             x, y, sample_weight=sample_weight, class_weight=class_weight)\n\u001b[0m\u001b[1;32m    205\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    206\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mouts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mtrain_on_batch\u001b[0;34m(self, x, y, sample_weight, class_weight)\u001b[0m\n\u001b[1;32m   1549\u001b[0m         \u001b[0mins\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0msample_weights\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1550\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1551\u001b[0;31m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_train_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1552\u001b[0m       \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mins\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1553\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36m_make_train_function\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    596\u001b[0m           \u001b[0;31m# Training updates\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    597\u001b[0m           updates = self.optimizer.get_updates(\n\u001b[0;32m--> 598\u001b[0;31m               params=self._collected_trainable_weights, loss=self.total_loss)\n\u001b[0m\u001b[1;32m    599\u001b[0m         \u001b[0;31m# Unconditional updates\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    600\u001b[0m         \u001b[0mupdates\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_updates_for\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/optimizers.py\u001b[0m in \u001b[0;36mget_updates\u001b[0;34m(self, loss, params)\u001b[0m\n\u001b[1;32m    478\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    479\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvhat\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrads\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvhats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 480\u001b[0;31m       \u001b[0mm_t\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbeta_1\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1.\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbeta_1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    481\u001b[0m       \u001b[0mv_t\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbeta_2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1.\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbeta_2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmath_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    482\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mamsgrad\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/ops/resource_variable_ops.py\u001b[0m in \u001b[0;36m_run_op\u001b[0;34m(a, *args)\u001b[0m\n\u001b[1;32m    856\u001b[0m       \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    857\u001b[0m       \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_AsTensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 858\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mtensor_oper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    859\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    860\u001b[0m     \u001b[0;31m# Propagate __doc__ to wrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/ops/math_ops.py\u001b[0m in \u001b[0;36mr_binary_op_wrapper\u001b[0;34m(y, x)\u001b[0m\n\u001b[1;32m    876\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    877\u001b[0m       \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert_to_tensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbase_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"x\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 878\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    879\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    880\u001b[0m   \u001b[0;31m# Propagate func.__doc__ to the wrappers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/ops/gen_math_ops.py\u001b[0m in \u001b[0;36msub\u001b[0;34m(x, y, name)\u001b[0m\n\u001b[1;32m   8186\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0m_ctx\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0m_ctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_eager_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_eager\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   8187\u001b[0m     _, _, _op = _op_def_lib._apply_op_helper(\n\u001b[0;32m-> 8188\u001b[0;31m         \"Sub\", x=x, y=y, name=name)\n\u001b[0m\u001b[1;32m   8189\u001b[0m     \u001b[0m_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_op\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   8190\u001b[0m     \u001b[0m_inputs_flat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_op\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_apply_op_helper\u001b[0;34m(self, op_type_name, name, **keywords)\u001b[0m\n\u001b[1;32m    785\u001b[0m         op = g.create_op(op_type_name, inputs, output_types, name=scope,\n\u001b[1;32m    786\u001b[0m                          \u001b[0minput_types\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minput_types\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattr_protos\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 787\u001b[0;31m                          op_def=op_def)\n\u001b[0m\u001b[1;32m    788\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0moutput_structure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_stateful\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    789\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/util/deprecation.py\u001b[0m in \u001b[0;36mnew_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    425\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mis_in_graph_mode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIS_IN_GRAPH_MODE\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0m_PRINT_DEPRECATION_WARNINGS\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    426\u001b[0m         \u001b[0minvalid_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 427\u001b[0;31m         \u001b[0mnamed_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_inspect\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetcallargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    428\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0marg_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mspec\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdeprecated_positions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    429\u001b[0m           if (spec.position < len(args) and\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/util/tf_inspect.py\u001b[0m in \u001b[0;36mgetcallargs\u001b[0;34m(func, *positional, **named)\u001b[0m\n\u001b[1;32m    233\u001b[0m   \u001b[0margspec\u001b[0m \u001b[0mwill\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mused\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    234\u001b[0m   \"\"\"\n\u001b[0;32m--> 235\u001b[0;31m   \u001b[0margspec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetfullargspec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    236\u001b[0m   \u001b[0mcall_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnamed\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    237\u001b[0m   \u001b[0mthis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'im_self'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__self__'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/util/tf_inspect.py\u001b[0m in \u001b[0;36mgetfullargspec\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m    214\u001b[0m   return next((d.decorator_argspec\n\u001b[1;32m    215\u001b[0m                \u001b[0;32mfor\u001b[0m \u001b[0md\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdecorators\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 216\u001b[0;31m                if d.decorator_argspec is not None), _getfullargspec(target))\n\u001b[0m\u001b[1;32m    217\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/inspect.py\u001b[0m in \u001b[0;36mgetfullargspec\u001b[0;34m(func)\u001b[0m\n\u001b[1;32m   1086\u001b[0m                                        \u001b[0mfollow_wrapper_chains\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1087\u001b[0m                                        \u001b[0mskip_bound_arg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1088\u001b[0;31m                                        sigcls=Signature)\n\u001b[0m\u001b[1;32m   1089\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mex\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1090\u001b[0m         \u001b[0;31m# Most of the times 'signature' will raise ValueError.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/inspect.py\u001b[0m in \u001b[0;36m_signature_from_callable\u001b[0;34m(obj, follow_wrapper_chains, skip_bound_arg, sigcls)\u001b[0m\n\u001b[1;32m   2223\u001b[0m         \u001b[0;31m# If it's a pure Python function, or an object that is duck type\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2224\u001b[0m         \u001b[0;31m# of a Python function (Cython functions, for instance), then:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2225\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_signature_from_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msigcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2226\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2227\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0m_signature_is_builtin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/inspect.py\u001b[0m in \u001b[0;36m_signature_from_function\u001b[0;34m(cls, func)\u001b[0m\n\u001b[1;32m   2140\u001b[0m     return cls(parameters,\n\u001b[1;32m   2141\u001b[0m                \u001b[0mreturn_annotation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mannotations\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'return'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_empty\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2142\u001b[0;31m                __validate_parameters__=is_duck_function)\n\u001b[0m\u001b[1;32m   2143\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2144\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/inspect.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, parameters, return_annotation, __validate_parameters__)\u001b[0m\n\u001b[1;32m   2709\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2710\u001b[0m                 params = OrderedDict(((param.name, param)\n\u001b[0;32m-> 2711\u001b[0;31m                                                 for param in parameters))\n\u001b[0m\u001b[1;32m   2712\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2713\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parameters\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mMappingProxyType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Evaluate()\n",
    "# 模型训练\n",
    "from tensorflow.keras.callbacks import EarlyStopping, CSVLogger, ModelCheckpoint\n",
    "from tensorflow.keras.optimizers import *\n",
    "# model.load_weights('digit4to6_ctc_best.h5')\n",
    "\n",
    "train_data = CaptchaSequence(characters, batch_size=128, steps=1000) # (characters, batch_size=128, steps=1000)\n",
    "valid_data = CaptchaSequence(characters, batch_size=128, steps=100)  # (characters, batch_size=128, steps=100)\n",
    "# callbacks = [EarlyStopping(patience=5), Evaluate(), \n",
    "#              CSVLogger('ctc.csv'), ModelCheckpoint('ctc_best.h5', save_best_only=True)]\n",
    "callbacks = [EarlyStopping(patience=5),ModelCheckpoint('gru_digit4to6_ctc_best.h5', save_best_only=True)]\n",
    "model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=Adam(1e-3, amsgrad=True))\n",
    "# model.fit_generator(train_data, epochs=100, validation_data=valid_data,\n",
    "#                     callbacks=callbacks)\n",
    "model.fit_generator(train_data, epochs=200, validation_data=valid_data, workers=4, use_multiprocessing=True,\n",
    "                   callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/300\n",
      " 999/1000 [============================>.] - ETA: 0s - loss: 0.0117Epoch 1/300\n",
      "1000/1000 [==============================] - 212s 212ms/step - loss: 0.0117 - val_loss: 0.0123\n",
      "Epoch 2/300\n",
      "1000/1000 [==============================] - 178s 178ms/step - loss: 0.0089 - val_loss: 0.0094\n",
      "Epoch 3/300\n",
      "1000/1000 [==============================] - 185s 185ms/step - loss: 0.0090 - val_loss: 0.0110\n",
      "Epoch 4/300\n",
      "1000/1000 [==============================] - 189s 189ms/step - loss: 0.0076 - val_loss: 0.0105\n",
      "Epoch 5/300\n",
      "1000/1000 [==============================] - 178s 178ms/step - loss: 0.0089 - val_loss: 0.0098\n",
      "Epoch 6/300\n",
      "1000/1000 [==============================] - 195s 195ms/step - loss: 0.0079 - val_loss: 0.0113\n",
      "Epoch 7/300\n",
      "1000/1000 [==============================] - 193s 193ms/step - loss: 0.0058 - val_loss: 0.0083\n",
      "Epoch 8/300\n",
      "1000/1000 [==============================] - 188s 188ms/step - loss: 0.0072 - val_loss: 0.0074\n",
      "Epoch 9/300\n",
      "1000/1000 [==============================] - 189s 189ms/step - loss: 0.0062 - val_loss: 0.0062\n",
      "Epoch 10/300\n",
      "1000/1000 [==============================] - 180s 180ms/step - loss: 0.0064 - val_loss: 0.0078\n",
      "Epoch 11/300\n",
      "1000/1000 [==============================] - 180s 180ms/step - loss: 0.0056 - val_loss: 0.0052\n",
      "Epoch 12/300\n",
      "1000/1000 [==============================] - 184s 184ms/step - loss: 0.0059 - val_loss: 0.0064\n",
      "Epoch 13/300\n",
      "1000/1000 [==============================] - 186s 186ms/step - loss: 0.0052 - val_loss: 0.0063\n",
      "Epoch 14/300\n",
      "1000/1000 [==============================] - 185s 185ms/step - loss: 0.0056 - val_loss: 0.0055\n",
      "Epoch 15/300\n",
      "1000/1000 [==============================] - 172s 172ms/step - loss: 0.0044 - val_loss: 0.0039\n",
      "Epoch 16/300\n",
      "1000/1000 [==============================] - 199s 199ms/step - loss: 0.0055 - val_loss: 0.0047\n",
      "Epoch 17/300\n",
      "1000/1000 [==============================] - 186s 186ms/step - loss: 0.0048 - val_loss: 0.0040\n",
      "Epoch 18/300\n",
      "1000/1000 [==============================] - 183s 183ms/step - loss: 0.0052 - val_loss: 0.0065\n",
      "Epoch 19/300\n",
      "1000/1000 [==============================] - 180s 180ms/step - loss: 0.0048 - val_loss: 0.0055\n",
      "Epoch 20/300\n",
      "1000/1000 [==============================] - 177s 177ms/step - loss: 0.0051 - val_loss: 0.0042\n",
      "Epoch 21/300\n",
      "1000/1000 [==============================] - 181s 181ms/step - loss: 0.0044 - val_loss: 0.0021\n",
      "Epoch 22/300\n",
      "1000/1000 [==============================] - 180s 180ms/step - loss: 0.0047 - val_loss: 0.0036\n",
      "Epoch 23/300\n",
      "1000/1000 [==============================] - 182s 182ms/step - loss: 0.0045 - val_loss: 0.0052\n",
      "Epoch 24/300\n",
      "1000/1000 [==============================] - 169s 169ms/step - loss: 0.0045 - val_loss: 0.0044\n",
      "Epoch 25/300\n",
      "1000/1000 [==============================] - 157s 157ms/step - loss: 0.0048 - val_loss: 0.0030\n",
      "Epoch 26/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0042 - val_loss: 0.0060\n",
      "Epoch 27/300\n",
      "1000/1000 [==============================] - 148s 148ms/step - loss: 0.0047 - val_loss: 0.0067\n",
      "Epoch 28/300\n",
      "1000/1000 [==============================] - 173s 173ms/step - loss: 0.0036 - val_loss: 0.0056\n",
      "Epoch 29/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0049 - val_loss: 0.0025\n",
      "Epoch 30/300\n",
      "1000/1000 [==============================] - 154s 154ms/step - loss: 0.0045 - val_loss: 0.0043\n",
      "Epoch 31/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0041 - val_loss: 0.0023\n",
      "Epoch 32/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0036 - val_loss: 0.0044\n",
      "Epoch 33/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0036 - val_loss: 0.0024\n",
      "Epoch 34/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0041 - val_loss: 0.0018\n",
      "Epoch 35/300\n",
      "1000/1000 [==============================] - 142s 142ms/step - loss: 0.0043 - val_loss: 0.0043\n",
      "Epoch 36/300\n",
      "1000/1000 [==============================] - 188s 188ms/step - loss: 0.0036 - val_loss: 0.0030\n",
      "Epoch 37/300\n",
      "1000/1000 [==============================] - 147s 147ms/step - loss: 0.0042 - val_loss: 0.0033\n",
      "Epoch 38/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0040 - val_loss: 0.0039\n",
      "Epoch 39/300\n",
      "1000/1000 [==============================] - 147s 147ms/step - loss: 0.0033 - val_loss: 0.0049\n",
      "Epoch 40/300\n",
      "1000/1000 [==============================] - 155s 155ms/step - loss: 0.0039 - val_loss: 0.0035\n",
      "Epoch 41/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0033 - val_loss: 0.0019\n",
      "Epoch 42/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0039 - val_loss: 0.0021\n",
      "Epoch 43/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0040 - val_loss: 0.0040\n",
      "Epoch 44/300\n",
      "1000/1000 [==============================] - 165s 165ms/step - loss: 0.0034 - val_loss: 0.0024\n",
      "Epoch 45/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0039 - val_loss: 0.0036\n",
      "Epoch 46/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0038 - val_loss: 0.0033\n",
      "Epoch 47/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0040 - val_loss: 0.0055\n",
      "Epoch 48/300\n",
      "1000/1000 [==============================] - 157s 157ms/step - loss: 0.0042 - val_loss: 0.0030\n",
      "Epoch 49/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0039 - val_loss: 0.0031\n",
      "Epoch 50/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0031 - val_loss: 0.0028\n",
      "Epoch 51/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0031 - val_loss: 0.0019\n",
      "Epoch 52/300\n",
      "1000/1000 [==============================] - 154s 154ms/step - loss: 0.0028 - val_loss: 0.0045\n",
      "Epoch 53/300\n",
      "1000/1000 [==============================] - 141s 141ms/step - loss: 0.0040 - val_loss: 0.0035\n",
      "Epoch 54/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0029 - val_loss: 0.0028\n",
      "Epoch 55/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0031 - val_loss: 0.0023\n",
      "Epoch 56/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0030 - val_loss: 0.0027\n",
      "Epoch 57/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0034 - val_loss: 0.0062\n",
      "Epoch 58/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0030 - val_loss: 0.0028\n",
      "Epoch 59/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0030 - val_loss: 0.0024\n",
      "Epoch 60/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0031 - val_loss: 0.0019\n",
      "Epoch 61/300\n",
      "1000/1000 [==============================] - 180s 180ms/step - loss: 0.0032 - val_loss: 0.0022\n",
      "Epoch 62/300\n",
      "1000/1000 [==============================] - 196s 196ms/step - loss: 0.0026 - val_loss: 0.0027\n",
      "Epoch 63/300\n",
      "1000/1000 [==============================] - 147s 147ms/step - loss: 0.0036 - val_loss: 0.0020\n",
      "Epoch 64/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0030 - val_loss: 0.0030\n",
      "Epoch 65/300\n",
      "1000/1000 [==============================] - 183s 183ms/step - loss: 0.0029 - val_loss: 0.0022\n",
      "Epoch 66/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0034 - val_loss: 0.0047\n",
      "Epoch 67/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0029 - val_loss: 0.0032\n",
      "Epoch 68/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0027 - val_loss: 0.0045\n",
      "Epoch 69/300\n",
      "1000/1000 [==============================] - 168s 168ms/step - loss: 0.0026 - val_loss: 0.0033\n",
      "Epoch 70/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0030 - val_loss: 0.0019\n",
      "Epoch 71/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0030 - val_loss: 0.0024\n",
      "Epoch 72/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0032 - val_loss: 0.0041\n",
      "Epoch 73/300\n",
      "1000/1000 [==============================] - 150s 150ms/step - loss: 0.0027 - val_loss: 0.0028\n",
      "Epoch 74/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0029 - val_loss: 0.0037\n",
      "Epoch 75/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0024 - val_loss: 0.0041\n",
      "Epoch 76/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0022 - val_loss: 0.0011\n",
      "Epoch 77/300\n",
      "1000/1000 [==============================] - 154s 154ms/step - loss: 0.0027 - val_loss: 0.0043\n",
      "Epoch 78/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0027 - val_loss: 0.0029\n",
      "Epoch 79/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0033 - val_loss: 0.0021\n",
      "Epoch 80/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0023 - val_loss: 0.0022\n",
      "Epoch 81/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0028 - val_loss: 0.0022\n",
      "Epoch 82/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0032 - val_loss: 0.0017\n",
      "Epoch 83/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0025 - val_loss: 0.0010\n",
      "Epoch 84/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0025 - val_loss: 0.0023\n",
      "Epoch 85/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0031 - val_loss: 0.0018\n",
      "Epoch 86/300\n",
      "1000/1000 [==============================] - 159s 159ms/step - loss: 0.0021 - val_loss: 0.0025\n",
      "Epoch 87/300\n",
      "1000/1000 [==============================] - 175s 175ms/step - loss: 0.0026 - val_loss: 0.0022\n",
      "Epoch 88/300\n",
      "1000/1000 [==============================] - 182s 182ms/step - loss: 0.0027 - val_loss: 0.0020\n",
      "Epoch 89/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0025 - val_loss: 0.0035\n",
      "Epoch 90/300\n",
      "1000/1000 [==============================] - 139s 139ms/step - loss: 0.0022 - val_loss: 0.0026\n",
      "Epoch 91/300\n",
      "1000/1000 [==============================] - 150s 150ms/step - loss: 0.0023 - val_loss: 0.0018\n",
      "Epoch 92/300\n",
      "1000/1000 [==============================] - 176s 176ms/step - loss: 0.0027 - val_loss: 0.0020\n",
      "Epoch 93/300\n",
      "1000/1000 [==============================] - 169s 169ms/step - loss: 0.0027 - val_loss: 0.0036\n",
      "Epoch 94/300\n",
      "1000/1000 [==============================] - 179s 179ms/step - loss: 0.0021 - val_loss: 0.0050\n",
      "Epoch 95/300\n",
      "1000/1000 [==============================] - 190s 190ms/step - loss: 0.0021 - val_loss: 0.0033\n",
      "Epoch 96/300\n",
      "1000/1000 [==============================] - 175s 175ms/step - loss: 0.0028 - val_loss: 0.0024\n",
      "Epoch 97/300\n",
      "1000/1000 [==============================] - 182s 182ms/step - loss: 0.0028 - val_loss: 0.0030\n",
      "Epoch 98/300\n",
      "1000/1000 [==============================] - 179s 179ms/step - loss: 0.0025 - val_loss: 0.0019\n",
      "Epoch 99/300\n",
      "1000/1000 [==============================] - 139s 139ms/step - loss: 0.0019 - val_loss: 0.0024\n",
      "Epoch 100/300\n",
      "1000/1000 [==============================] - 138s 138ms/step - loss: 0.0020 - val_loss: 0.0022\n",
      "Epoch 101/300\n",
      "1000/1000 [==============================] - 179s 179ms/step - loss: 0.0025 - val_loss: 0.0015\n",
      "Epoch 102/300\n",
      "1000/1000 [==============================] - 170s 170ms/step - loss: 0.0020 - val_loss: 9.1135e-04\n",
      "Epoch 103/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0024 - val_loss: 0.0026\n",
      "Epoch 104/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0020 - val_loss: 0.0019\n",
      "Epoch 105/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0021 - val_loss: 0.0019\n",
      "Epoch 106/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0013\n",
      "Epoch 107/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0022 - val_loss: 0.0025\n",
      "Epoch 108/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0021 - val_loss: 0.0020\n",
      "Epoch 109/300\n",
      "1000/1000 [==============================] - 166s 166ms/step - loss: 0.0020 - val_loss: 0.0043\n",
      "Epoch 110/300\n",
      "1000/1000 [==============================] - 181s 181ms/step - loss: 0.0017 - val_loss: 0.0024\n",
      "Epoch 111/300\n",
      "1000/1000 [==============================] - 178s 178ms/step - loss: 0.0018 - val_loss: 0.0016\n",
      "Epoch 112/300\n",
      "1000/1000 [==============================] - 174s 174ms/step - loss: 0.0028 - val_loss: 0.0020\n",
      "Epoch 113/300\n",
      "1000/1000 [==============================] - 182s 182ms/step - loss: 0.0020 - val_loss: 0.0015\n",
      "Epoch 114/300\n",
      "1000/1000 [==============================] - 181s 181ms/step - loss: 0.0019 - val_loss: 0.0039\n",
      "Epoch 115/300\n",
      "1000/1000 [==============================] - 182s 182ms/step - loss: 0.0019 - val_loss: 0.0020\n",
      "Epoch 116/300\n",
      "1000/1000 [==============================] - 183s 183ms/step - loss: 0.0020 - val_loss: 0.0019\n",
      "Epoch 117/300\n",
      "1000/1000 [==============================] - 183s 183ms/step - loss: 0.0024 - val_loss: 0.0031\n",
      "Epoch 118/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0018 - val_loss: 0.0023\n",
      "Epoch 119/300\n",
      "1000/1000 [==============================] - 145s 145ms/step - loss: 0.0023 - val_loss: 0.0021\n",
      "Epoch 120/300\n",
      "1000/1000 [==============================] - 152s 152ms/step - loss: 0.0024 - val_loss: 0.0028\n",
      "Epoch 121/300\n",
      "1000/1000 [==============================] - 155s 155ms/step - loss: 0.0025 - val_loss: 0.0040\n",
      "Epoch 122/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0018 - val_loss: 9.9961e-04\n",
      "Epoch 123/300\n",
      "1000/1000 [==============================] - 139s 139ms/step - loss: 0.0021 - val_loss: 0.0035\n",
      "Epoch 124/300\n",
      "1000/1000 [==============================] - 178s 178ms/step - loss: 0.0024 - val_loss: 9.8802e-04\n",
      "Epoch 125/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0021 - val_loss: 0.0011\n",
      "Epoch 126/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0021 - val_loss: 0.0021\n",
      "Epoch 127/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0018 - val_loss: 0.0017\n",
      "Epoch 128/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0021 - val_loss: 8.7637e-04\n",
      "Epoch 129/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0022 - val_loss: 0.0023\n",
      "Epoch 130/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0024 - val_loss: 0.0017\n",
      "Epoch 131/300\n",
      "1000/1000 [==============================] - 133s 133ms/step - loss: 0.0014 - val_loss: 0.0016\n",
      "Epoch 132/300\n",
      "1000/1000 [==============================] - 171s 171ms/step - loss: 0.0017 - val_loss: 0.0017\n",
      "Epoch 133/300\n",
      "1000/1000 [==============================] - 189s 189ms/step - loss: 0.0015 - val_loss: 0.0012\n",
      "Epoch 134/300\n",
      "1000/1000 [==============================] - 192s 192ms/step - loss: 0.0017 - val_loss: 8.8747e-04\n",
      "Epoch 135/300\n",
      "1000/1000 [==============================] - 180s 180ms/step - loss: 0.0019 - val_loss: 0.0022\n",
      "Epoch 136/300\n",
      "1000/1000 [==============================] - 184s 184ms/step - loss: 0.0022 - val_loss: 0.0022\n",
      "Epoch 137/300\n",
      "1000/1000 [==============================] - 192s 192ms/step - loss: 0.0022 - val_loss: 0.0027\n",
      "Epoch 138/300\n",
      "1000/1000 [==============================] - 191s 191ms/step - loss: 0.0023 - val_loss: 0.0022\n",
      "Epoch 139/300\n",
      "1000/1000 [==============================] - 189s 189ms/step - loss: 0.0016 - val_loss: 0.0011\n",
      "Epoch 140/300\n",
      "1000/1000 [==============================] - 178s 178ms/step - loss: 0.0019 - val_loss: 0.0032\n",
      "Epoch 141/300\n",
      "1000/1000 [==============================] - 187s 187ms/step - loss: 0.0022 - val_loss: 0.1112\n",
      "Epoch 142/300\n",
      "1000/1000 [==============================] - 153s 153ms/step - loss: 0.0020 - val_loss: 0.0011\n",
      "Epoch 143/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0037\n",
      "Epoch 144/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0020 - val_loss: 0.0035\n",
      "Epoch 145/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0022\n",
      "Epoch 146/300\n",
      "1000/1000 [==============================] - 149s 149ms/step - loss: 0.0019 - val_loss: 0.0014\n",
      "Epoch 147/300\n",
      "1000/1000 [==============================] - 133s 133ms/step - loss: 0.0022 - val_loss: 0.0012\n",
      "Epoch 148/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0015\n",
      "Epoch 149/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0019 - val_loss: 0.0013\n",
      "Epoch 150/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0021\n",
      "Epoch 151/300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0019 - val_loss: 0.0018\n",
      "Epoch 152/300\n",
      "1000/1000 [==============================] - 133s 133ms/step - loss: 0.0024 - val_loss: 0.0021\n",
      "Epoch 153/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0019\n",
      "Epoch 154/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0023 - val_loss: 0.0014\n",
      "Epoch 155/300\n",
      "1000/1000 [==============================] - 154s 154ms/step - loss: 0.0015 - val_loss: 0.0026\n",
      "Epoch 156/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0019 - val_loss: 0.0020\n",
      "Epoch 157/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0025 - val_loss: 0.0044\n",
      "Epoch 158/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0018 - val_loss: 0.0039\n",
      "Epoch 159/300\n",
      "1000/1000 [==============================] - 159s 159ms/step - loss: 0.0022 - val_loss: 0.0019\n",
      "Epoch 160/300\n",
      "1000/1000 [==============================] - 144s 144ms/step - loss: 0.0025 - val_loss: 0.0016\n",
      "Epoch 161/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0011\n",
      "Epoch 162/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0018 - val_loss: 0.0013\n",
      "Epoch 163/300\n",
      "1000/1000 [==============================] - 141s 141ms/step - loss: 0.0017 - val_loss: 0.0012\n",
      "Epoch 164/300\n",
      "1000/1000 [==============================] - 169s 169ms/step - loss: 0.0019 - val_loss: 0.0023\n",
      "Epoch 165/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 9.8551e-04\n",
      "Epoch 166/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0019\n",
      "Epoch 167/300\n",
      "1000/1000 [==============================] - 137s 137ms/step - loss: 0.0012 - val_loss: 0.0014\n",
      "Epoch 168/300\n",
      "1000/1000 [==============================] - 164s 164ms/step - loss: 0.0015 - val_loss: 0.0020\n",
      "Epoch 169/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0017 - val_loss: 5.7275e-04\n",
      "Epoch 170/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0026\n",
      "Epoch 171/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0019 - val_loss: 0.0015\n",
      "Epoch 172/300\n",
      "1000/1000 [==============================] - 158s 158ms/step - loss: 0.0017 - val_loss: 7.7992e-04\n",
      "Epoch 173/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0017\n",
      "Epoch 174/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0020 - val_loss: 0.0022\n",
      "Epoch 175/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0022\n",
      "Epoch 176/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0016 - val_loss: 0.0016\n",
      "Epoch 177/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 0.0011\n",
      "Epoch 178/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 7.6523e-04\n",
      "Epoch 179/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0010\n",
      "Epoch 180/300\n",
      "1000/1000 [==============================] - 136s 136ms/step - loss: 0.0015 - val_loss: 5.9600e-04\n",
      "Epoch 181/300\n",
      "1000/1000 [==============================] - 167s 167ms/step - loss: 0.0015 - val_loss: 7.2295e-04\n",
      "Epoch 182/300\n",
      "1000/1000 [==============================] - 154s 154ms/step - loss: 0.0014 - val_loss: 0.0019\n",
      "Epoch 183/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0018 - val_loss: 0.0014\n",
      "Epoch 184/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0020 - val_loss: 0.0013\n",
      "Epoch 185/300\n",
      "1000/1000 [==============================] - 149s 149ms/step - loss: 0.0018 - val_loss: 0.0025\n",
      "Epoch 186/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0011\n",
      "Epoch 187/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0011\n",
      "Epoch 188/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0018 - val_loss: 0.0016\n",
      "Epoch 189/300\n",
      "1000/1000 [==============================] - 142s 142ms/step - loss: 0.0017 - val_loss: 0.0016\n",
      "Epoch 190/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0024 - val_loss: 6.4412e-04\n",
      "Epoch 191/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0017\n",
      "Epoch 192/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0026\n",
      "Epoch 193/300\n",
      "1000/1000 [==============================] - 142s 142ms/step - loss: 0.0016 - val_loss: 0.0010\n",
      "Epoch 194/300\n",
      "1000/1000 [==============================] - 136s 136ms/step - loss: 0.0021 - val_loss: 0.0017\n",
      "Epoch 195/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0020\n",
      "Epoch 196/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0018\n",
      "Epoch 197/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0013\n",
      "Epoch 198/300\n",
      "1000/1000 [==============================] - 140s 140ms/step - loss: 0.0014 - val_loss: 0.0011\n",
      "Epoch 199/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0014\n",
      "Epoch 200/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0011\n",
      "Epoch 201/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 9.8165e-04\n",
      "Epoch 202/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0011\n",
      "Epoch 203/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0025\n",
      "Epoch 204/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 7.7435e-04\n",
      "Epoch 205/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0020\n",
      "Epoch 206/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0025\n",
      "Epoch 207/300\n",
      "1000/1000 [==============================] - 152s 152ms/step - loss: 0.0017 - val_loss: 0.0023\n",
      "Epoch 208/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0022\n",
      "Epoch 209/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 9.4707e-04\n",
      "Epoch 210/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0014\n",
      "Epoch 211/300\n",
      "1000/1000 [==============================] - 148s 148ms/step - loss: 0.0014 - val_loss: 0.0012\n",
      "Epoch 212/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0022\n",
      "Epoch 213/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0017 - val_loss: 0.0019\n",
      "Epoch 214/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 9.4521e-04 - val_loss: 0.0017\n",
      "Epoch 215/300\n",
      "1000/1000 [==============================] - 145s 145ms/step - loss: 0.0011 - val_loss: 0.0013\n",
      "Epoch 216/300\n",
      "1000/1000 [==============================] - 138s 138ms/step - loss: 0.0014 - val_loss: 8.5960e-04\n",
      "Epoch 217/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 0.0016\n",
      "Epoch 218/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0019 - val_loss: 0.0016\n",
      "Epoch 219/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0010 - val_loss: 0.0018\n",
      "Epoch 220/300\n",
      "1000/1000 [==============================] - 138s 138ms/step - loss: 0.0013 - val_loss: 0.0017\n",
      "Epoch 221/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 0.0020\n",
      "Epoch 222/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0011 - val_loss: 0.0011\n",
      "Epoch 223/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0011 - val_loss: 0.0021\n",
      "Epoch 224/300\n",
      "1000/1000 [==============================] - 138s 138ms/step - loss: 0.0014 - val_loss: 5.4602e-04\n",
      "Epoch 225/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0021 - val_loss: 8.8988e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 226/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0012\n",
      "Epoch 227/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0013\n",
      "Epoch 228/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 9.6861e-04\n",
      "Epoch 229/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0016\n",
      "Epoch 230/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 6.1688e-04\n",
      "Epoch 231/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0015\n",
      "Epoch 232/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0014\n",
      "Epoch 233/300\n",
      "1000/1000 [==============================] - 137s 137ms/step - loss: 0.0013 - val_loss: 0.0013\n",
      "Epoch 234/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0019 - val_loss: 0.0019\n",
      "Epoch 235/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0023\n",
      "Epoch 236/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0013\n",
      "Epoch 237/300\n",
      "1000/1000 [==============================] - 137s 137ms/step - loss: 0.0016 - val_loss: 9.2824e-04\n",
      "Epoch 238/300\n",
      "1000/1000 [==============================] - 137s 137ms/step - loss: 0.0011 - val_loss: 9.0287e-04\n",
      "Epoch 239/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0019 - val_loss: 9.2114e-04\n",
      "Epoch 240/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 5.2642e-04\n",
      "Epoch 241/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0011 - val_loss: 0.0013\n",
      "Epoch 242/300\n",
      "1000/1000 [==============================] - 150s 150ms/step - loss: 0.0014 - val_loss: 0.0028\n",
      "Epoch 243/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0012\n",
      "Epoch 244/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0029\n",
      "Epoch 245/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 0.0014\n",
      "Epoch 246/300\n",
      "1000/1000 [==============================] - 152s 152ms/step - loss: 0.0016 - val_loss: 5.1604e-04\n",
      "Epoch 247/300\n",
      "1000/1000 [==============================] - 136s 136ms/step - loss: 0.0012 - val_loss: 0.0018\n",
      "Epoch 248/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0020\n",
      "Epoch 249/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0017 - val_loss: 3.4457e-04\n",
      "Epoch 250/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0017\n",
      "Epoch 251/300\n",
      "1000/1000 [==============================] - 141s 141ms/step - loss: 0.0013 - val_loss: 0.0014\n",
      "Epoch 252/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 6.7468e-04\n",
      "Epoch 253/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0018\n",
      "Epoch 254/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 6.8391e-04\n",
      "Epoch 255/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0010 - val_loss: 0.0020\n",
      "Epoch 256/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 0.0017\n",
      "Epoch 257/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0010 - val_loss: 0.0012\n",
      "Epoch 258/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 8.4647e-04\n",
      "Epoch 259/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0011 - val_loss: 0.0026\n",
      "Epoch 260/300\n",
      "1000/1000 [==============================] - 138s 138ms/step - loss: 0.0012 - val_loss: 0.0014\n",
      "Epoch 261/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 9.9913e-04\n",
      "Epoch 262/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0011\n",
      "Epoch 263/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0025\n",
      "Epoch 264/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0011 - val_loss: 9.0106e-04\n",
      "Epoch 265/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0013 - val_loss: 6.5029e-04\n",
      "Epoch 266/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0011 - val_loss: 0.0011\n",
      "Epoch 267/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 0.0016\n",
      "Epoch 268/300\n",
      "1000/1000 [==============================] - 141s 141ms/step - loss: 0.0013 - val_loss: 5.8865e-04\n",
      "Epoch 269/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0013 - val_loss: 6.9571e-04\n",
      "Epoch 270/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0010 - val_loss: 4.8008e-04\n",
      "Epoch 271/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 8.6520e-04\n",
      "Epoch 272/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 0.0014\n",
      "Epoch 273/300\n",
      "1000/1000 [==============================] - 146s 146ms/step - loss: 0.0011 - val_loss: 0.0016\n",
      "Epoch 274/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 9.6764e-04 - val_loss: 0.0013\n",
      "Epoch 275/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0016 - val_loss: 0.0015\n",
      "Epoch 276/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0015 - val_loss: 0.0011\n",
      "Epoch 277/300\n",
      "1000/1000 [==============================] - 139s 139ms/step - loss: 0.0012 - val_loss: 5.0505e-04\n",
      "Epoch 278/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0010\n",
      "Epoch 279/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0013 - val_loss: 2.5568e-04\n",
      "Epoch 280/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0014\n",
      "Epoch 281/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0011 - val_loss: 0.0062\n",
      "Epoch 282/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0011 - val_loss: 0.0022\n",
      "Epoch 283/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 0.0020\n",
      "Epoch 284/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0011 - val_loss: 4.4470e-04\n",
      "Epoch 285/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0018\n",
      "Epoch 286/300\n",
      "1000/1000 [==============================] - 148s 148ms/step - loss: 9.0743e-04 - val_loss: 0.0016\n",
      "Epoch 287/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0012 - val_loss: 0.0012\n",
      "Epoch 288/300\n",
      "1000/1000 [==============================] - 135s 135ms/step - loss: 0.0014 - val_loss: 4.8864e-04\n",
      "Epoch 289/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 3.8594e-04\n",
      "Epoch 290/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0013 - val_loss: 0.0012\n",
      "Epoch 291/300\n",
      "1000/1000 [==============================] - 136s 136ms/step - loss: 0.0010 - val_loss: 2.4477e-04\n",
      "Epoch 292/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 4.7540e-04\n",
      "Epoch 293/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0012 - val_loss: 4.7845e-04\n",
      "Epoch 294/300\n",
      "1000/1000 [==============================] - 134s 134ms/step - loss: 0.0014 - val_loss: 0.0018\n",
      "Epoch 295/300\n",
      "1000/1000 [==============================] - 142s 142ms/step - loss: 0.0014 - val_loss: 7.2145e-04\n",
      "Epoch 296/300\n",
      " 558/1000 [===============>..............] - ETA: 55s - loss: 8.3824e-04"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process ForkPoolWorker-3113:\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/queues.py\", line 343, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 407, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "KeyboardInterrupt\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-ee42fc2fa7f7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'ctc'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mAdam\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1e-4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mamsgrad\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m model.fit_generator(train_data, epochs=300, validation_data=valid_data, workers=4, use_multiprocessing=True,\n\u001b[0;32m---> 10\u001b[0;31m                     callbacks=callbacks)\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mfit_generator\u001b[0;34m(self, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[1;32m   1777\u001b[0m         \u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1778\u001b[0m         \u001b[0mshuffle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshuffle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1779\u001b[0;31m         initial_epoch=initial_epoch)\n\u001b[0m\u001b[1;32m   1780\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1781\u001b[0m   def evaluate_generator(self,\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/engine/training_generator.py\u001b[0m in \u001b[0;36mfit_generator\u001b[0;34m(model, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[1;32m    202\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    203\u001b[0m         outs = model.train_on_batch(\n\u001b[0;32m--> 204\u001b[0;31m             x, y, sample_weight=sample_weight, class_weight=class_weight)\n\u001b[0m\u001b[1;32m    205\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    206\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mouts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mtrain_on_batch\u001b[0;34m(self, x, y, sample_weight, class_weight)\u001b[0m\n\u001b[1;32m   1550\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1551\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_train_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1552\u001b[0;31m       \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mins\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1553\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1554\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/backend.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m   2912\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_callable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeed_arrays\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_symbols\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbol_vals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msession\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2913\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2914\u001b[0;31m     \u001b[0mfetched\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_callable_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0marray_vals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2915\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_fetch_callbacks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfetched\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fetches\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2916\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mfetched\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1380\u001b[0m           ret = tf_session.TF_SessionRunCallable(\n\u001b[1;32m   1381\u001b[0m               \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_handle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatus\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1382\u001b[0;31m               run_metadata_ptr)\n\u001b[0m\u001b[1;32m   1383\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1384\u001b[0m           \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process ForkPoolWorker-3114:\n",
      "Process ForkPoolWorker-3115:\n",
      "Process ForkPoolWorker-3116:\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 119, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 119, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/utils/data_utils.py\", line 432, in get_index\n",
      "    return _SHARED_SEQUENCES[uid][i]\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/site-packages/tensorflow/python/keras/utils/data_utils.py\", line 432, in get_index\n",
      "    return _SHARED_SEQUENCES[uid][i]\n",
      "  File \"<ipython-input-18-5ffa2f133b46>\", line 29, in __getitem__\n",
      "    image, random_str = rebuild_img(random.choice(glob.glob('Digit4/*.jpg')))\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"<ipython-input-18-5ffa2f133b46>\", line 29, in __getitem__\n",
      "    image, random_str = rebuild_img(random.choice(glob.glob('Digit4/*.jpg')))\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/glob.py\", line 20, in glob\n",
      "    return list(iglob(pathname, recursive=recursive))\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/glob.py\", line 20, in glob\n",
      "    return list(iglob(pathname, recursive=recursive))\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/glob.py\", line 64, in iglob\n",
      "    for name in glob_in_dir(dirname, basename):\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/glob.py\", line 65, in iglob\n",
      "    yield os.path.join(dirname, name)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/glob.py\", line 78, in glob1\n",
      "    names = os.listdir(dirname)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/queues.py\", line 342, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/posixpath.py\", line 81, in join\n",
      "    for b in p:\n",
      "KeyboardInterrupt\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "KeyboardInterrupt\n",
      "KeyboardInterrupt\n",
      "Process ForkPoolWorker-3125:\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 254, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/queues.py\", line 343, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 407, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/python/anaconda3/envs/dl_nlp/lib/python3.5/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "KeyboardInterrupt\n"
     ]
    }
   ],
   "source": [
    "# 载入最好的模型继续训练一会\n",
    "model.load_weights('gru_digit4to6_ctc_best.h5')\n",
    "\n",
    "# callbacks = [EarlyStopping(patience=5),\n",
    "#              CSVLogger('ctc.csv', append=True), ModelCheckpoint('ctc_best.h5', save_best_only=True)]\n",
    "callbacks = [CSVLogger('ctc.csv', append=True), ModelCheckpoint('gru_digit4to6_ctc_best.h5', save_best_only=True)]\n",
    "\n",
    "model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=Adam(1e-4, amsgrad=True))\n",
    "model.fit_generator(train_data, epochs=300, validation_data=valid_data, workers=4, use_multiprocessing=True,\n",
    "                    callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.load_weights('ctc_best.h5')\n",
    "base_model.save('gru_digit_base_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "总耗时： 1.0670440196990967\n",
      "128 0\n"
     ]
    }
   ],
   "source": [
    "# 测试模型\n",
    "characters2 = characters + ' '\n",
    "import time\n",
    "\n",
    "def get_test_data():\n",
    "    '''\n",
    "    从本地获取验证码图片并生成测试数据\n",
    "    '''    \n",
    "    X = []\n",
    "    Y = []\n",
    "    for path in glob.glob('../FileInfo/*.jpg'): #    Digit5/*.jpg\n",
    "        random_str = path.split('_')[-1][:-4] \n",
    "        if random_str.isdigit() and len(random_str) ==4:\n",
    "            img = Image.open(path)\n",
    "            X.append(np.array(img.resize((100,50), Image.BILINEAR))/255.0)\n",
    "            label_idx = [characters.find(x) for x in random_str]\n",
    "            if len(random_str) < n_len:\n",
    "                label_idx += [n_class-1]*(n_len-len(random_str)) \n",
    "            Y.append(label_idx)\n",
    "    return [np.array(X), np.array(Y), np.ones(len(X)), np.ones(len(X))],np.ones(len(X))\n",
    "\n",
    "# data = [get_test_data()]\n",
    "\n",
    "data = CaptchaSequence2(characters, batch_size=128, steps=1)\n",
    "\n",
    "pos = neg = 0\n",
    "t1 = time.time()\n",
    "for i in range(len(data)): \n",
    "    flag = False\n",
    "    [X_test, y_test, _, _], _  = data[i]\n",
    "    y_pred = base_model.predict(X_test)\n",
    "#     print(y_pred.shape)\n",
    "    out_pre = K.get_value(K.ctc_decode(y_pred, input_length=np.ones(y_pred.shape[0])*y_pred.shape[1])[0][0])[:, :6]\n",
    "#     print(out_pre.shape)\n",
    "#     print(out)\n",
    "    for j in range(out_pre.shape[0]):\n",
    "        out = ''.join([characters[x] for x in out_pre[j]])      \n",
    "        y_true = ''.join([characters[x] for x in y_test[j] if x < len(characters)])\n",
    "        if out != y_true:\n",
    "            plt.imshow(X_test[j])\n",
    "            plt.title('pred:' + str(out) + '\\ntrue: ' + str(y_true))\n",
    "            print('pred:' + str(out) + '\\ntrue: ' + str(y_true))\n",
    "            neg += 1\n",
    "            flag = True\n",
    "#             break\n",
    "#             time.sleep(1)\n",
    "#             argmax = np.argmax(y_pred, axis=2)[j]\n",
    "#             print(list(zip(argmax, ''.join([characters2[x] for x in argmax]))))\n",
    "        else:\n",
    "#             print('pred:' + str(out) + '\\ntrue: ' + str(y_true))\n",
    "            pos += 1 \n",
    "\n",
    "#     if flag:\n",
    "#         break\n",
    "t2 = time.time()\n",
    "print('总耗时：',t2-t1)\n",
    "print(pos,neg)\n",
    "# # plt.imshow(X_test[0])\n",
    "# # plt.title('pred:' + str(out) + '\\ntrue: ' + str(y_true))\n",
    "\n",
    "# argmax = np.argmax(y_pred, axis=2)[0]\n",
    "# list(zip(argmax, ''.join([characters2[x] for x in argmax])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluate(base_model,batch_size=128, steps=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f61db44d4e0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 展示损失下降图\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv('ctc.csv')\n",
    "df[['loss', 'val_loss']].plot()"
   ]
  }
 ],
 "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}