第七课 看图回答VQA/1_7.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "1.7.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "npxgypQYMMz0",
        "colab_type": "text"
      },
      "source": [
        "### 第七课 VQA 视觉问答机器人"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pb_jeR9UMd72",
        "colab_type": "text"
      },
      "source": [
        "* 图灵测试"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7AjvhaG7XCAS",
        "colab_type": "text"
      },
      "source": [
        "### 实战"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "54PzBsgUXIXn",
        "colab_type": "text"
      },
      "source": [
        "这里我们用Keras来实现这么一个VQA的模型\n",
        "\n",
        "你可以自由选择keras的backend，或者是theano或者是tensorflow\n",
        "\n",
        "这个project涉及到大量图片，建议使用GPU。\n",
        "\n",
        "本教程使用的是python3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WVkoruYyXQpb",
        "colab_type": "text"
      },
      "source": [
        "#### 导入库"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XU7mVeoGL_jD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "ad330cb9-40ef-4fc5-e0d6-5799538f2666"
      },
      "source": [
        "import sys\n",
        "from random import shuffle\n",
        "import argparse\n",
        " \n",
        "import numpy as np\n",
        "import scipy.io\n",
        " \n",
        "from keras.models import Sequential\n",
        "from keras.layers.core import Dense, Dropout, Activation\n",
        "from keras.optimizers import SGD\n",
        "from keras.utils import np_utils, generic_utils\n",
        " \n",
        "from sklearn import preprocessing\n",
        "from sklearn.externals import joblib\n",
        " \n",
        "import spacy\n",
        "spacy.load('en_core_web_sm')\n",
        "from spacy.lang.en import English"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/externals/joblib/__init__.py:15: FutureWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S06pD8faY86c",
        "colab_type": "text"
      },
      "source": [
        "#### 下载并预处理素材\n",
        "\n",
        "训练VQA，首先得需要一套用来训练的材料。\n",
        "\n",
        "这里：http://www.visualqa.org/\n",
        "\n",
        "给出了所有所需的素材，数据，等等。\n",
        "\n",
        "所有的数据都是原始数据，所以我们需要做一点初始化，来把数据变成标准的结构，便于我们日后拿出来处理。\n",
        "\n",
        "`preprocess.py` 这个方法就是用来一步到位预处理所有数据的：（相关原理和方法，在NLP基础课上讲过，这里不赘述）\n",
        "\n",
        "通过这个方法，我们把所有问题/回答/对应图片给联系起来，用他们各自的“ID”代码来表示。\n",
        "\n",
        "这样，我们只需要三个txt文档，就可以存下这么一个对应关系了。\n",
        "\n",
        "data文件来源如：\n",
        "\n",
        "* https://github.com/deepsidhpura777/Visual-Question-Answering-Using-CNN-LSTM-based-Stacked-Attention-Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sC_lvvnSMRRY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "questions_train = open('/content/drive/My Drive/VQA/questions_train2014.txt', 'r').read().splitlines()\n",
        "answers_train = open('/content/drive/My Drive/VQA/answers_train2014_modal.txt', 'r').read().splitlines()\n",
        "images_train = open('/content/drive/My Drive/VQA/images_train2014.txt', 'r').read().splitlines()"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ppcduhhgC3W",
        "colab_type": "text"
      },
      "source": [
        "### 对应回答的处理\n",
        "\n",
        "根据课上讲解的内容，\n",
        "\n",
        "我们把“看到一个图就能回答所有问题”这么一个看起来玄幻的目标，\n",
        "\n",
        "简化成“从1000个最有可能的回答中，找到最符合图片的答案”这个样式。\n",
        "\n",
        "也就是把一个开放AI问题，转化成了`multi-class`的分类问题。\n",
        "\n",
        "好，我们来选取最popular的1000个问答："
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E78dN9glMRYn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import operator\n",
        "from collections import defaultdict"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "voUbSYHhMRhD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "max_answers = 1000# 设定最多选取多少个回答\n",
        "answer_fq= defaultdict(int)\n",
        "# 并为所有的问答，构造一个字典dict\n",
        "for answer in answers_train:\n",
        "    answer_fq[answer] += 1"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0G7e6FguMRkh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 按照出现次数，排序,选出前1000个出现频率最高的答案\n",
        "sorted_fq = sorted(answer_fq.items(), key=operator.itemgetter(1), reverse=True)[0:max_answers]\n",
        "top_answers, top_fq = zip(*sorted_fq)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lk87f8sRMRWR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "new_answers_train=[]\n",
        "new_questions_train=[]\n",
        "new_images_train=[]\n",
        "# 只提取top 1000问答相关\n",
        "for answer,question,image in zip(answers_train, questions_train, images_train):\n",
        "    if answer in top_answers:\n",
        "        new_answers_train.append(answer)\n",
        "        new_questions_train.append(question)\n",
        "        new_images_train.append(image)\n",
        " \n",
        "# 把新的数据赋值,这时候的数据由前1000个出现频率最高的答案所选出来\n",
        "questions_train = new_questions_train\n",
        "answers_train = new_answers_train\n",
        "images_train = new_images_train"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zclnSE83hzP6",
        "colab_type": "text"
      },
      "source": [
        "接下来，我们把所有的1000个答案给编号。\n",
        "\n",
        "这样我们选取某个答案的时候，就不用使用“全称”，可以使用他们的label。\n",
        "\n",
        "我们简单用到`sklearn`的`preprocessing`功能来赋值label。\n",
        "\n",
        "当然，我们之后一直需要使用这个一一对应的label，所以我们存下来。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NVZYxgWeMRUQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fdfb5d1f-42ef-482b-caa7-619374721feb"
      },
      "source": [
        "labelencoder = preprocessing.LabelEncoder()\n",
        "labelencoder.fit(answers_train)\n",
        "nb_classes = len(list(labelencoder.classes_))\n",
        "joblib.dump(labelencoder,'/content/drive/My Drive/VQA/labelencoder.pkl')"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['/content/drive/My Drive/VQA/labelencoder.pkl']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6lEYYATijlM",
        "colab_type": "text"
      },
      "source": [
        "这个labelencoder怎么用？\n",
        "\n",
        "我们写一个method，可以把所有的answers转化成数字化的label\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B5_aoKTHL_lu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_answers_matrix(answers, encoder):\n",
        "    # string转化成数字化表达\n",
        "    y = encoder.transform(answers) \n",
        "    nb_classes = encoder.classes_.shape[0]\n",
        "    Y = np_utils.to_categorical(y, nb_classes)\n",
        "    # 并构造成标准的matrix\n",
        "    return Y"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3kkcNSXGitwy",
        "colab_type": "text"
      },
      "source": [
        "### input图片的处理\n",
        "\n",
        "这里，我们使用工业/学术上都很耀眼的`VGG CNN`来提取图片的特征。\n",
        "\n",
        "我们这里，直接运用已经成熟训练好的VGG CNN模型，直接下载，并导入，\n",
        "\n",
        "因为我们用的是标准MSCOCO图片库，所以对应的标准VGG已经训练完备。\n",
        "\n",
        "详见：http://mscoco.org/\n",
        "\n",
        "http://cs.stanford.edu/people/karpathy/deepimagesent\n",
        "\n",
        "用这个方法，我们把input图片的features一步到位地取出来。\n",
        "\n",
        "文件地址：https://github.com/ZhenguoChen/Neural-Network-Image-Captioning"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OYCiIJcXL_qn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 导入下载好的vgg_fearures (这是个matlab的文档，没关系，scipy可以读取)\n",
        "vgg_model_path = '/content/drive/My Drive/VQA/vgg_feats.mat'"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_KgZd3XwmZuk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 读入VGG features\n",
        "features_struct = scipy.io.loadmat(vgg_model_path)\n",
        "VGGfeatures = features_struct['feats']"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KP0B2BPfjZPZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# data source:https://raw.githubusercontent.com/architsharma97/VisualQA/4c6da4cb73936ffa271139dda215fd4cd261c495/Data/Coco/coco_vgg_IDMap.txt\n",
        "# 跟图片一一对应\n",
        "image_ids = open('/content/drive/My Drive/VQA/coco_vgg_IDMap.txt').read().splitlines()"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iG8xScsAjZhE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "id_map = {}\n",
        "for ids in image_ids:\n",
        "    id_split = ids.split()\n",
        "    id_map[id_split[0]] = int(id_split[1])"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8KCNfVLnt3RN",
        "colab_type": "text"
      },
      "source": [
        "这时候，我们再写一个method，\n",
        "\n",
        "是用来取得任何一个input图片的“数字化表达形式”的，也就是一个matrix\n",
        "\n",
        "这个matrix是由vgg扫过/处理图片以后，再加一层flatten得到的4096维的数组，我们称之为CNN Features"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hXrP-yfYjZoX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_images_matrix(img_coco_ids, img_map, VGGfeatures):\n",
        "  nb_samples = len(img_coco_ids)\n",
        "  nb_dimensions = VGGfeatures.shape[0]\n",
        "  image_matrix = np.zeros((nb_samples, nb_dimensions))\n",
        "  for j in range(len(img_coco_ids)):\n",
        "    image_matrix[j,:] = VGGfeatures[:,img_map[img_coco_ids[j]]]\n",
        "  return image_matrix"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RTm-qUhzuDye",
        "colab_type": "text"
      },
      "source": [
        "#### 提问问题的处理\n",
        "\n",
        "接下来，是文字部分。\n",
        "\n",
        "我们用SpaCy自带的英文模型。\n",
        "\n",
        "把问句中的所有英文转化为vector，并平均化整个句子。\n",
        "\n",
        "这个本质上就是我们NLP基础课上讲过的word2vec"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "73lZH0lgjZmN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "nlp = English()# 载入Spacy的英语库\n",
        "img_dim = 4096# 图片的维度大小\n",
        "word_vec_dim = 300# 句子/单词的维度大小\n",
        " \n",
        "# 这个method就是用来计算句子中所有word vector的总和，\n",
        "# 目的在于把我们的文字用数字表示\n",
        "\n",
        "def get_questions_matrix_sum(questions, nlp):\n",
        "    # assert not isinstance(questions, basestring)\n",
        "    nb_samples = len(questions)\n",
        "    word_vec_dim = nlp(questions[0])[0].vector.shape[0]\n",
        "    questions_matrix = np.zeros((nb_samples, word_vec_dim))\n",
        "    for i in range(len(questions)):\n",
        "        tokens = nlp(questions[i])\n",
        "        for j in range(len(tokens)):\n",
        "            questions_matrix[i,:] += tokens[j].vector\n",
        "    return questions_matrix"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0HP0ww-ueKw",
        "colab_type": "text"
      },
      "source": [
        "#### VQA模型：MLP\n",
        "我们来建立我们最简单版本的MLP模型\n",
        "\n",
        "也就是普通的神经网络模型\n",
        "\n",
        "注意：我这里就跑了1个epoch，只是为了Demo，真实场景中，这显然是不够的, 大家可以试试100次。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ItsAgtfnjZkP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 参数们\n",
        "num_hidden_units = 1024\n",
        "num_hidden_layers = 3\n",
        "dropout = 0.5\n",
        "activation = 'tanh'\n",
        "# 注意：我这里就跑了1个epoch，\n",
        "# 只是为了Demo，\n",
        "# 真实场景中，\n",
        "# 这显然是不够的\n",
        "# 大家可以试试100次。\n",
        "num_epochs = 1\n",
        "model_save_interval = 10\n",
        "batch_size = 128\n",
        " \n",
        "# MLP之建造\n",
        "# 输入层\n",
        "model = Sequential()\n",
        "model.add(Dense(num_hidden_units, input_dim=img_dim+word_vec_dim, kernel_initializer='uniform'))\n",
        "model.add(Activation(activation))\n",
        "model.add(Dropout(dropout))\n",
        "# 中间层\n",
        "for i in range(num_hidden_layers-1):\n",
        "    model.add(Dense(num_hidden_units, kernel_initializer='uniform'))\n",
        "    model.add(Activation(activation))\n",
        "    model.add(Dropout(dropout))\n",
        "# 输出层\n",
        "model.add(Dense(nb_classes, kernel_initializer='uniform'))\n",
        "model.add(Activation('softmax'))"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N060wR1GuoVQ",
        "colab_type": "text"
      },
      "source": [
        "如果以上的代码还不够清晰的话，\n",
        " \n",
        "我们来吧构造的模型打印出来看看：\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W___2ebEjZfV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "cc44c32c-4358-4540-e52f-51c8ad8e1dbc"
      },
      "source": [
        "from keras.utils.vis_utils import plot_model\n",
        "plot_model(model, to_file='/content/drive/My Drive/VQA/model_mlp.png', show_shapes=True)\n",
        "from IPython.display import Image\n",
        "Image(filename='/content/drive/My Drive/VQA/model_mlp.png') "
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YEmTJESPu7qz",
        "colab_type": "text"
      },
      "source": [
        "好接下来，我们做一个保存的动作。\n",
        "\n",
        "训练大规模网络的时候，这是一种比较保险的举措，即可以让我们回测数据，也可以在紧急情况下及时返回保存过了的模型"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b7Li_jPdjZc1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "json_string = model.to_json()\n",
        "model_file_name = '/content/drive/My Drive/VQA/mlp_num_hidden_units_' + str(num_hidden_units) + '_num_hidden_layers_' + str(num_hidden_layers)\n",
        "open(model_file_name  + '.json', 'w').write(json_string)\n",
        "# compile模型\n",
        "model.compile(loss='categorical_crossentropy', optimizer='rmsprop')"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PzBmJFUSvINK",
        "colab_type": "text"
      },
      "source": [
        "在训练之前，我们还需要一个chunk list的方法，来把我们原始的数据分成一组一组的形式\n",
        "\n",
        "为了我们之后的batch training做准备"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pvqEVtF6jZaZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 这是一个标准的chunk list方法\n",
        "#  \"grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')\"\n",
        "from itertools import zip_longest\n",
        "def grouper(iterable, n, fillvalue=None):\n",
        "    args = [iter(iterable)] * n\n",
        "    return zip_longest(*args, fillvalue=fillvalue)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XDnzb4_yvczs",
        "colab_type": "text"
      },
      "source": [
        "可以开始训练了！\n",
        "\n",
        "代码非常直观："
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eG-UGmI0jZUp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "outputId": "9e977fe2-e9d2-4cfb-d378-e213297054b8"
      },
      "source": [
        "for k in range(num_epochs):\n",
        "    # 给数据洗个牌先\n",
        "    index_shuf = [i for i in range(len(questions_train))]\n",
        "    shuffle(index_shuf)\n",
        "    # 一一取出 问题，答案，和图片\n",
        "    questions_train = [questions_train[i] for i in index_shuf]\n",
        "    answers_train = [answers_train[i] for i in index_shuf]\n",
        "    images_train = [images_train[i] for i in index_shuf]\n",
        "    # 这就是个显示训练状态的bar，不写也没事，keras是默认有这个bar的\n",
        "    # 但是如果你需要做一些customize的话，就可以在这个progbar上做文章\n",
        "    progbar = generic_utils.Progbar(len(questions_train))\n",
        "    # batch分组\n",
        "    for qu_batch,an_batch,im_batch in zip(grouper(questions_train, batch_size, fillvalue=questions_train[-1]), \n",
        "                                        grouper(answers_train, batch_size, fillvalue=answers_train[-1]), \n",
        "                                        grouper(images_train, batch_size, fillvalue=images_train[-1])):\n",
        "        X_q_batch = get_questions_matrix_sum(qu_batch, nlp)\n",
        "        X_i_batch = get_images_matrix(im_batch, id_map, VGGfeatures)\n",
        "        X_batch = np.hstack((X_q_batch, X_i_batch))\n",
        "        Y_batch = get_answers_matrix(an_batch, labelencoder)\n",
        "        loss = model.train_on_batch(X_batch, Y_batch)\n",
        "        progbar.add(batch_size, values=[(\"train loss\", loss)])\n",
        "    # 并且告诉模型，隔多久，存一次模型，比如这里，model_save_interval是10\n",
        "    if k % model_save_interval == 0:\n",
        "        model.save_weights(model_file_name + '_epoch_{:02d}.hdf5'.format(k))\n",
        "# 顺手把最终的模型也存下来\n",
        "model.save_weights(model_file_name + '_epoch_{:02d}.hdf5'.format(k))"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-20-c46f22a8c711>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     15\u001b[0m                                         grouper(images_train, batch_size, fillvalue=images_train[-1])):\n\u001b[1;32m     16\u001b[0m         \u001b[0mX_q_batch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_questions_matrix_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqu_batch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnlp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m         \u001b[0mX_i_batch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_images_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim_batch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_map\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mVGGfeatures\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     18\u001b[0m         \u001b[0mX_batch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_q_batch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_i_batch\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     19\u001b[0m         \u001b[0mY_batch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_answers_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0man_batch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabelencoder\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-14-65937c59efd8>\u001b[0m in \u001b[0;36mget_images_matrix\u001b[0;34m(img_coco_ids, img_map, VGGfeatures)\u001b[0m\n\u001b[1;32m      4\u001b[0m   \u001b[0mimage_matrix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnb_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnb_dimensions\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      5\u001b[0m   \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg_coco_ids\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mimage_matrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mVGGfeatures\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mimg_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mimg_coco_ids\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\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[0m\u001b[1;32m      7\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mimage_matrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: index 81938 is out of bounds for axis 1 with size 8000"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NC43eIlG0Suw",
        "colab_type": "text"
      },
      "source": [
        "这里注意，我们一共存了两种文件。\n",
        "\n",
        "一种是json，是我们建立模型以后就存下来的东西，它代表了我们模型的龙骨（构架）\n",
        "\n",
        "一种是hdf5, 全称Hierarchical Data Format，是非常高效的一种存储格式，把我们训练好的权重（weights）都记录下来。\n",
        "\n",
        "那么，经过N轮的training之后，我们可以根据loss来监视效果。\n",
        "\n",
        "那么，同学们如果想做一下Evaluation，或者模型升级，等等，都可以改改代码试试。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VMwdiYaJ0U0N",
        "colab_type": "text"
      },
      "source": [
        "### 代码总结"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XbGijyCZjZSQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 导入相关库\n",
        "import sys\n",
        "from random import shuffle\n",
        "import argparse\n",
        "import numpy as np\n",
        "import scipy.io\n",
        "from keras.models import Sequential\n",
        "from keras.layers.core import Dense, Dropout, Activation\n",
        "from keras.optimizers import SGD\n",
        "from keras.utils import np_utils, generic_utils\n",
        "from sklearn import preprocessing\n",
        "from sklearn.externals import joblib\n",
        "from spacy.lang.en import English\n",
        "import operator\n",
        "from collections import defaultdict\n",
        "# 打印模型\n",
        "from keras.utils.vis_utils import plot_model\n",
        "from IPython.display import Image\n",
        "from itertools import zip_longest\n",
        " \n",
        "\"\"\"  读取数据  \"\"\"\n",
        "questions_train = open('data/questions_train2014.txt', 'r').read().splitlines()\n",
        "answers_train = open('data/answers_train2014_modal.txt','r').read().splitlines()\n",
        "images_train = open('data/images_train2014.txt','r').read().splitlines()\n",
        " \n",
        "\"\"\" 对应回答的处理  \"\"\"\n",
        " \n",
        "# 设定最多选取多少个回答\n",
        "max_answers = 1000\n",
        "answer_fq= defaultdict(int)\n",
        "# 并为所有的问答，构造一个字典dict\n",
        "for answer in answers_train:\n",
        "    answer_fq[answer] += 1\n",
        "# 按照出现次数，排序\n",
        "sorted_fq = sorted(answer_fq.items(), key=operator.itemgetter(1), reverse=True)[0:max_answers]\n",
        "top_answers, top_fq = zip(*sorted_fq)\n",
        "new_answers_train=[]\n",
        "new_questions_train=[]\n",
        "new_images_train=[]\n",
        "# 只提取top 1000问答相关\n",
        "for answer,question,image in zip(answers_train, questions_train, images_train):\n",
        "    if answer in top_answers:\n",
        "        new_answers_train.append(answer)\n",
        "        new_questions_train.append(question)\n",
        "        new_images_train.append(image)\n",
        " \n",
        "# 把新的数据赋值\n",
        "questions_train = new_questions_train\n",
        "answers_train = new_answers_train\n",
        "images_train = new_images_train\n",
        " \n",
        "# 接下来，我们把所有的1000个答案给编号 简单用到sklearn的preprocessing功能来赋值label\n",
        " \n",
        "labelencoder = preprocessing.LabelEncoder()\n",
        "labelencoder.fit(answers_train)\n",
        "nb_classes = len(list(labelencoder.classes_))\n",
        "joblib.dump(labelencoder,'data/labelencoder.pkl')\n",
        "# print(labelencoder.classes_)    # [...'yes' 'young' 'zebra' 'zebras' 'zoo']\n",
        "# print(labelencoder.transform(['yes']))  # [[... 1 0 0 0 0]]\n",
        " \n",
        " \n",
        "\"\"\" 我们写一个method，可以把所有的answers转化成数字化的label \"\"\"\n",
        " \n",
        " \n",
        "def get_answers_matrix(answers, encoder):\n",
        "    # string转化成数字化表达\n",
        "    y = encoder.transform(answers)\n",
        "    nb_classes = encoder.classes_.shape[0]\n",
        "    Y = np_utils.to_categorical(y, nb_classes)\n",
        "    # 并构造成标准的matrix\n",
        "    return Y\n",
        " \n",
        "# 我们把input图片的features一步到位地取出来\n",
        "vgg_model_path = 'mscoco/vgg_feats.mat'\n",
        " \n",
        "# 读入VGG features\n",
        "features_struct = scipy.io.loadmat(vgg_model_path)\n",
        "VGGfeatures = features_struct['feats']\n",
        "# 跟图片一一对应\n",
        "image_ids = open('data/coco_vgg_IDMap.txt').read().splitlines()\n",
        "id_map = {}\n",
        "for ids in image_ids:\n",
        "    id_split = ids.split()\n",
        "    id_map[id_split[0]] = int(id_split[1])\n",
        " \n",
        " \n",
        "\"\"\"\n",
        "是用来取得任何一个input图片的“数字化表达形式”的，也就是一个matrix\n",
        "这个matrix是由vgg扫过/处理图片以后，再加一层flatten得到的4096维的数组，\n",
        "我们称之为CNN Features\n",
        "\"\"\"\n",
        "def get_images_matrix(img_coco_ids, img_map, VGGfeatures):\n",
        "    nb_samples = len(img_coco_ids)\n",
        "    nb_dimensions = VGGfeatures.shape[0]\n",
        "    image_matrix = np.zeros((nb_samples, nb_dimensions))\n",
        "    for j in range(len(img_coco_ids)):\n",
        "        image_matrix[j,:] = VGGfeatures[:,img_map[img_coco_ids[j]]]\n",
        "    return image_matrix\n",
        " \n",
        "\"\"\"\n",
        "提问问题的处理\n",
        "接下来，是文字部分。\n",
        "我们用SpaCy自带的英文模型。把问句中的所有英文转化为vector，并平均化整个句子。\n",
        "这个本质上就是我们NLP基础课上讲过的word2vec\n",
        "\"\"\"\n",
        " \n",
        "# 载入Spacy的英语库\n",
        "nlp = English()\n",
        "# 图片的维度大小\n",
        "img_dim = 3796\n",
        "# 句子/单词的维度大小\n",
        "word_vec_dim = 300\n",
        " \n",
        "# 这个method就是用来计算句子中所有word vector的总和，\n",
        "# 目的在于把我们的文字用数字表示\n",
        "def get_questions_matrix_sum(questions, nlp):\n",
        "    # assert not isinstance(questions, basestring)\n",
        "    nb_samples = len(questions)\n",
        "    word_vec_dim = nlp(questions[0])[0].vector.shape[0]\n",
        "    questions_matrix = np.zeros((nb_samples, word_vec_dim))\n",
        "    for i in range(len(questions)):\n",
        "        tokens = nlp(questions[i])\n",
        "        for j in range(len(tokens)):\n",
        "            questions_matrix[i,:] += tokens[j].vector\n",
        "    return questions_matrix\n",
        " \n",
        "# VQA模型：MLP\n",
        "# 参数们\n",
        "num_hidden_units = 1024\n",
        "num_hidden_layers = 3\n",
        "dropout = 0.5\n",
        "activation = 'tanh'\n",
        "# 注意：我这里就跑了1个epoch，\n",
        "# 只是为了Demo，\n",
        "# 真实场景中，\n",
        "# 这显然是不够的\n",
        "# 大家可以试试100次。\n",
        "num_epochs = 1\n",
        "model_save_interval = 10\n",
        "batch_size = 128\n",
        " \n",
        "# MLP之建造\n",
        "# 输入层\n",
        "model = Sequential()\n",
        "model.add(Dense(num_hidden_units, input_dim=img_dim+word_vec_dim, kernel_initializer='uniform'))\n",
        "model.add(Activation(activation))\n",
        "model.add(Dropout(dropout))\n",
        "# 中间层\n",
        "for i in range(num_hidden_layers-1):\n",
        "    model.add(Dense(num_hidden_units, kernel_initializer='uniform'))\n",
        "    model.add(Activation(activation))\n",
        "    model.add(Dropout(dropout))\n",
        "# 输出层\n",
        "model.add(Dense(nb_classes, kernel_initializer='uniform'))\n",
        "model.add(Activation('softmax'))\n",
        " \n",
        "# 打印模型 -- windows 麻烦是多干脆不打印了\n",
        "# plot_model(model, to_file='data/model_mlp.peng', show_shapes=True)\n",
        "# Image(filename='data/model_mlp.peng')\n",
        " \n",
        "# 好接下来，我们做一个保存的动作\n",
        "json_string = model.to_json()\n",
        "model_file_name = 'data/mlp_num_hidden_units_' + str(num_hidden_units) + '_num_hidden_layers_' + str(num_hidden_layers)\n",
        "open(model_file_name  + '.json', 'w').write(json_string)\n",
        "# compile模型\n",
        "model.compile(loss='categorical_crossentropy', optimizer='rmsprop')\n",
        " \n",
        " \n",
        "# 在训练之前，我们还需要一个chunk list的方法，来把我们原始的数据分成一组一组的形式\n",
        "# 为了我们之后的batch training做准备\n",
        "# 这是一个标准的chunk list方法\n",
        "#  \"grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')\"\n",
        " \n",
        "def grouper(iterable, n, fillvalue=None):\n",
        "    args = [iter(iterable)] * n\n",
        "    return zip_longest(*args, fillvalue=fillvalue)\n",
        " \n",
        "# 开始训练\n",
        "for k in range(num_epochs):\n",
        "    # 给数据洗个牌先\n",
        "    index_shuf = [i for i in range(len(questions_train))]\n",
        "    shuffle(index_shuf)\n",
        "    # 一一取出 问题，答案，和图片\n",
        "    questions_train = [questions_train[i] for i in index_shuf]\n",
        "    answers_train = [answers_train[i] for i in index_shuf]\n",
        "    images_train = [images_train[i] for i in index_shuf]\n",
        "    # 这就是个显示训练状态的bar，不写也没事，keras是默认有这个bar的\n",
        "    # 但是如果你需要做一些customize的话，就可以在这个progbar上做文章\n",
        "    progbar = generic_utils.Progbar(len(questions_train))\n",
        "    # batch分组\n",
        "    for qu_batch,an_batch,im_batch in zip(grouper(questions_train, batch_size, fillvalue=questions_train[-1]),\n",
        "                                        grouper(answers_train, batch_size, fillvalue=answers_train[-1]),\n",
        "                                        grouper(images_train, batch_size, fillvalue=images_train[-1])):\n",
        "        X_q_batch = get_questions_matrix_sum(qu_batch, nlp)\n",
        "        X_i_batch = get_images_matrix(im_batch, id_map, VGGfeatures)\n",
        "        X_batch = np.hstack((X_q_batch, X_i_batch))\n",
        "        Y_batch = get_answers_matrix(an_batch, labelencoder)\n",
        "        loss = model.train_on_batch(X_batch, Y_batch)\n",
        "        progbar.add(batch_size, values=[(\"train loss\", loss)])\n",
        "    # 并且告诉模型，隔多久，存一次模型，比如这里，model_save_interval是10\n",
        "    if k%model_save_interval == 0:\n",
        "        model.save_weights(model_file_name + '_epoch_{:02d}.hdf5'.format(k))\n",
        "# 顺手把最终的模型也存下来\n",
        "model.save_weights(model_file_name + '_epoch_{:02d}.hdf5'.format(k))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EukfBGv00cxa",
        "colab_type": "text"
      },
      "source": [
        "### 第三章 \n",
        "道理上讲，这里训练的部分，跟前面依旧没啥区别，\n",
        "\n",
        "唯一的区别是，我们造语言部分的matrix的时候，使用timestep的方法，也就是我们刚刚上面改写的那个方法\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wt9Xog2d0uNF",
        "colab_type": "text"
      },
      "source": [
        "### 参考文献\n",
        "* https://blog.csdn.net/m0_37156901/article/details/94997517#t0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RcPr10_l0NZq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Csc2Dk8P0NXN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lva2wiCbL_oy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}