Untitled_linzhuo_maskedlm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = 'all'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import seaborn as sns\n",
    "import os\n",
    "import json\n",
    "\n",
    "import numpy as np\n",
    "import math\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import rcParams\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from pytorch_pretrained_bert import tokenization, BertTokenizer, BertModel, BertForMaskedLM, BertForPreTraining, BertConfig\n",
    "from examples.extract_features import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "01/17/2019 18:31:04 - INFO - pytorch_pretrained_bert.tokenization -   loading vocabulary file /nas/pretrain-bert/pretrain-tensorflow/uncased_L-12_H-768_A-12/vocab.txt\n",
      "01/17/2019 18:31:04 - INFO - pytorch_pretrained_bert.modeling -   loading archive file /nas/pretrain-bert/pretrain-tensorflow/uncased_L-12_H-768_A-12/\n",
      "01/17/2019 18:31:04 - INFO - pytorch_pretrained_bert.modeling -   Model config {\n",
      "  \"attention_probs_dropout_prob\": 0.1,\n",
      "  \"hidden_act\": \"gelu\",\n",
      "  \"hidden_dropout_prob\": 0.1,\n",
      "  \"hidden_size\": 768,\n",
      "  \"initializer_range\": 0.02,\n",
      "  \"intermediate_size\": 3072,\n",
      "  \"max_position_embeddings\": 512,\n",
      "  \"num_attention_heads\": 12,\n",
      "  \"num_hidden_layers\": 12,\n",
      "  \"type_vocab_size\": 2,\n",
      "  \"vocab_size\": 30522\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Args:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "args = Args()\n",
    "args.no_cuda = True\n",
    "\n",
    "CONFIG_NAME = 'bert_config.json'\n",
    "BERT_DIR = '/nas/pretrain-bert/pretrain-tensorflow/uncased_L-12_H-768_A-12/'\n",
    "config_file = os.path.join(BERT_DIR, CONFIG_NAME)\n",
    "config = BertConfig.from_json_file(config_file)\n",
    "\n",
    "tokenizer = BertTokenizer.from_pretrained(os.path.join(BERT_DIR, 'vocab.txt'))\n",
    "model = BertForPreTraining.from_pretrained(BERT_DIR)\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() and not args.no_cuda else \"cpu\")\n",
    "_ = model.to(device)\n",
    "_ = model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def convert_text_to_examples(text):\n",
    "    examples = []\n",
    "    unique_id = 0\n",
    "    if True:\n",
    "        for line in text:\n",
    "            line = line.strip()\n",
    "            text_a = None\n",
    "            text_b = None\n",
    "            m = re.match(r\"^(.*) \\|\\|\\| (.*)$\", line)\n",
    "            if m is None:\n",
    "                text_a = line\n",
    "            else:\n",
    "                text_a = m.group(1)\n",
    "                text_b = m.group(2)\n",
    "            examples.append(\n",
    "                InputExample(unique_id=unique_id, text_a=text_a, text_b=text_b))\n",
    "            unique_id += 1\n",
    "    return examples\n",
    "\n",
    "def convert_examples_to_features(examples, tokenizer, append_special_tokens=True, replace_mask=True, print_info=False):\n",
    "    features = []\n",
    "    for (ex_index, example) in enumerate(examples):\n",
    "        tokens_a = tokenizer.tokenize(example.text_a)\n",
    "        tokens_b = None\n",
    "        if example.text_b:\n",
    "            tokens_b = tokenizer.tokenize(example.text_b)\n",
    "\n",
    "        tokens = []\n",
    "        input_type_ids = []\n",
    "        if append_special_tokens:\n",
    "            tokens.append(\"[CLS]\")\n",
    "            input_type_ids.append(0)\n",
    "        for token in tokens_a:\n",
    "            if replace_mask and token == '_':  # XD\n",
    "                token = \"[MASK]\"\n",
    "            tokens.append(token)\n",
    "            input_type_ids.append(0)\n",
    "        if append_special_tokens:\n",
    "            tokens.append(\"[SEP]\")\n",
    "            input_type_ids.append(0)\n",
    "\n",
    "        if tokens_b:\n",
    "            for token in tokens_b:\n",
    "                if replace_mask and token == '_':  # XD\n",
    "                    token = \"[MASK]\"\n",
    "                tokens.append(token)\n",
    "                input_type_ids.append(1)\n",
    "            if append_special_tokens:\n",
    "                tokens.append(\"[SEP]\")\n",
    "                input_type_ids.append(1)\n",
    "\n",
    "        input_ids = tokenizer.convert_tokens_to_ids(tokens)\n",
    "        input_mask = [1] * len(input_ids)\n",
    "\n",
    "        if ex_index < 5:\n",
    "#             logger.info(\"*** Example ***\")\n",
    "#             logger.info(\"unique_id: %s\" % (example.unique_id))\n",
    "            logger.info(\"tokens: %s\" % \" \".join([str(x) for x in tokens]))\n",
    "#             logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n",
    "#             logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n",
    "#             logger.info(\n",
    "#                 \"input_type_ids: %s\" % \" \".join([str(x) for x in input_type_ids]))\n",
    "            \n",
    "        features.append(\n",
    "            InputFeatures(\n",
    "                unique_id=example.unique_id,\n",
    "                tokens=tokens,\n",
    "                input_ids=input_ids,\n",
    "                input_mask=input_mask,\n",
    "                input_type_ids=input_type_ids))\n",
    "    return features\n",
    "\n",
    "def copy_and_mask_feature(feature, masked_tokens=None):\n",
    "    import copy\n",
    "    tokens = feature.tokens\n",
    "    masked_positions = [tokens.index(t) for t in masked_tokens if t in tokens] \\\n",
    "        if masked_tokens is not None else range(len(tokens))\n",
    "    assert len(masked_positions) > 0\n",
    "    masked_feature_copies = []\n",
    "    for masked_pos in masked_positions:\n",
    "        feature_copy = copy.deepcopy(feature)\n",
    "        feature_copy.input_ids[masked_pos] = tokenizer.vocab[\"[MASK]\"]\n",
    "        masked_feature_copies.append(feature_copy)\n",
    "    return masked_feature_copies, masked_positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_lm_probs(tokens, input_ids, probs, topk=5, firstk=20):\n",
    "    def print_pair(token, prob, end_str='', hit_mark=' '):\n",
    "        if i < firstk:\n",
    "            # token = token.replace('</w>', '').replace('\\n', '/n')\n",
    "            print('{}{: >3} | {: <12}'.format(hit_mark, int(round(prob*100)), token), end=end_str)\n",
    "    \n",
    "    ret = None\n",
    "    for i in range(len(tokens)):\n",
    "        ind_ = input_ids[i].item() if input_ids is not None else tokenizer.vocab[tokens[i]]\n",
    "        prob_ = probs[i][ind_].item()\n",
    "        print_pair(tokens[i], prob_, end_str='\\t')\n",
    "        values, indices = probs[i].topk(topk)\n",
    "        top_pairs = []\n",
    "        for j in range(topk):\n",
    "            ind, prob = indices[j].item(), values[j].item()\n",
    "            hit_mark = '*' if ind == ind_ else ' '\n",
    "            token = tokenizer.ids_to_tokens[ind]\n",
    "            print_pair(token, prob, hit_mark=hit_mark, end_str='' if j < topk - 1 else '\\n')\n",
    "            top_pairs.append((token, prob))\n",
    "        if tokens[i] == \"[MASK]\":\n",
    "            ret = top_pairs\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "import colored\n",
    "from colored import stylize\n",
    "\n",
    "def show_abnormals(tokens, probs, show_suggestions=False):\n",
    "    def gap2color(gap):\n",
    "        if gap <= 5:\n",
    "            return 'yellow_1'\n",
    "        elif gap <= 10:\n",
    "            return 'orange_1'\n",
    "        else:\n",
    "            return 'red_1'\n",
    "        \n",
    "    def print_token(token, suggestion, gap):\n",
    "        if gap == 0:\n",
    "            print(stylize(token + ' ', colored.fg('white') + colored.bg('black')), end='')\n",
    "        else:\n",
    "            print(stylize(token, colored.fg(gap2color(gap)) + colored.bg('black')), end='')\n",
    "            if show_suggestions and gap > 5:\n",
    "                print(stylize('/' + suggestion + ' ', colored.fg('green' if gap > 10 else 'cyan') + colored.bg('black')), end='')\n",
    "            else:\n",
    "                print(stylize(' ', colored.fg(gap2color(gap)) + colored.bg('black')), end='')\n",
    "                # print('/' + suggestion, end=' ')\n",
    "            # print('%.2f' % gap, end=' ')\n",
    "        \n",
    "    avg_gap = 0.\n",
    "    for i in range(1, len(tokens) - 1):  # skip first [CLS] and last [SEP]\n",
    "        ind_ = tokenizer.vocab[tokens[i]]\n",
    "        prob_ = probs[i][ind_].item()\n",
    "        top_prob = probs[i].max().item()\n",
    "        top_ind = probs[i].argmax().item()\n",
    "        gap = math.log(top_prob) - math.log(prob_)\n",
    "        suggestion = tokenizer.ids_to_tokens[top_ind]\n",
    "        print_token(tokens[i], suggestion, gap)\n",
    "        avg_gap += gap\n",
    "    avg_gap /= (len(tokens) - 2)\n",
    "    print()\n",
    "    print(avg_gap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "analyzed_cache = {}\n",
    "\n",
    "def analyze_text(text, masked_tokens=None, show_suggestions=False, show_firstk_probs=20):\n",
    "    if text[0] in analyzed_cache:\n",
    "        features, mlm_probs = analyzed_cache[text[0]]\n",
    "        given_mask = \"[MASK]\" in features[0].tokens\n",
    "        tokens = features[0].tokens\n",
    "    else:\n",
    "        examples = convert_text_to_examples(text)\n",
    "        features = convert_examples_to_features(examples, tokenizer, print_info=False)\n",
    "        given_mask = \"[MASK]\" in features[0].tokens\n",
    "        if not given_mask or masked_tokens is not None:\n",
    "            assert len(features) == 1\n",
    "            features, masked_positions = copy_and_mask_feature(features[0], masked_tokens=masked_tokens)\n",
    "\n",
    "        input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)\n",
    "        input_type_ids = torch.tensor([f.input_type_ids for f in features], dtype=torch.long)\n",
    "        input_ids = input_ids.to(device)\n",
    "        input_type_ids = input_type_ids.to(device)\n",
    "\n",
    "        mlm_logits, _ = model(input_ids, input_type_ids)\n",
    "        mlm_probs = F.softmax(mlm_logits, dim=-1)\n",
    "\n",
    "        tokens = features[0].tokens\n",
    "        if not given_mask or masked_tokens is not None:\n",
    "            bsz, seq_len, vocab_size = mlm_probs.size()\n",
    "            assert bsz == len(masked_positions)\n",
    "            # reduced_mlm_probs = torch.Tensor(1, seq_len, vocab_size)\n",
    "            # for i in range(seq_len):\n",
    "            #    reduced_mlm_probs[0, i] = mlm_probs[i, i]\n",
    "            reduced_mlm_probs = torch.Tensor(1, len(masked_positions), vocab_size)\n",
    "            for i, pos in enumerate(masked_positions):\n",
    "                reduced_mlm_probs[0, i] = mlm_probs[i, pos]\n",
    "            mlm_probs = reduced_mlm_probs\n",
    "            tokens = [tokens[i] for i in masked_positions]\n",
    "        \n",
    "        analyzed_cache[text[0]] = (features, mlm_probs)\n",
    "        \n",
    "    top_pairs = show_lm_probs(tokens, None, mlm_probs[0], firstk=show_firstk_probs)\n",
    "    if not given_mask:\n",
    "        show_abnormals(tokens, mlm_probs[0], show_suggestions=show_suggestions)\n",
    "    return top_pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/qsj/miniconda3/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110300"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train =pd.read_csv('/nas/xd/data/gan_prompt_remain_OPENAI_TOKENED_new2.txt',delimiter='\\t',header=None,quotechar='&')\n",
    "len(df_train)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss = [row[0]+' '+row[1] for row in df_train[[3,4]].values]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Why didn't the skeleton go to the dance? He had no-BODY to go with.\""
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sss=ss[22]\n",
    "sss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "sss =\"why didn ' t the girls come to the party ? i had no - one to party with .\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "01/17/2019 19:40:30 - INFO - examples.extract_features -   tokens: [CLS] why didn ' t the girls come to the party ? i had no - one to party with . [SEP]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0 | [CLS]       \t   3 | .              1 | the            1 | )              1 | ,              1 | \"           \n",
      " 100 | why         \t*100 | why            0 | and            0 | but            0 | \"              0 | '           \n",
      "  63 | didn        \t* 63 | didn          15 | couldn         9 | wouldn         5 | don            3 | hadn        \n",
      " 100 | '           \t*100 | '              0 | -              0 | ,              0 | =              0 | `           \n",
      " 100 | t           \t*100 | t              0 | d              0 | s              0 | n              0 | ts          \n",
      "  69 | the         \t* 69 | the            9 | other          6 | my             3 | these          2 | any         \n",
      "  32 | girls       \t* 32 | girls          8 | boys           7 | guys           4 | police         4 | others      \n",
      "  73 | come        \t* 73 | come          25 | go             0 | get            0 | stay           0 | came        \n",
      "  98 | to          \t* 98 | to             1 | for            0 | into           0 | at             0 | after       \n",
      "  42 | the         \t* 42 | the           40 | my             5 | this           3 | our            3 | that        \n",
      "  83 | party       \t* 83 | party          3 | house          2 | club           2 | parties        1 | dance       \n",
      "  99 | ?           \t* 99 | ?              0 | when           0 | .              0 | because        0 | ,           \n",
      "  38 | i           \t* 38 | i             20 | she           16 | they          10 | we             5 | he          \n",
      "  81 | had         \t* 81 | had           17 | have           0 | was            0 | saw            0 | has         \n",
      " 100 | no          \t*100 | no             0 | twenty         0 | number         0 | non            0 | zero        \n",
      "  88 | -           \t* 88 | -              4 | other          2 | '              1 | real           1 | .           \n",
      "  99 | one         \t* 99 | one            0 | ones           0 | friends        0 | girls          0 | girl        \n",
      " 100 | to          \t*100 | to             0 | i              0 | they           0 | a              0 | the         \n",
      "  15 | party       \t* 15 | party          9 | be             8 | celebrate      8 | dance          7 | play        \n",
      "  97 | with        \t* 97 | with           1 | to             1 | for            0 | tonight        0 | around      \n",
      "  96 | .           \t* 96 | .              2 | !              2 | ;              0 | ?              0 | |           \n",
      "   0 | [SEP]       \t   5 | i              5 | \"              2 | and            2 | the            2 | .           \n",
      "\u001b[38;5;15m\u001b[48;5;0mwhy \u001b[0m\u001b[38;5;15m\u001b[48;5;0mdidn \u001b[0m\u001b[38;5;15m\u001b[48;5;0m' \u001b[0m\u001b[38;5;15m\u001b[48;5;0mt \u001b[0m\u001b[38;5;15m\u001b[48;5;0mthe \u001b[0m\u001b[38;5;15m\u001b[48;5;0mgirls \u001b[0m\u001b[38;5;15m\u001b[48;5;0mcome \u001b[0m\u001b[38;5;15m\u001b[48;5;0mto \u001b[0m\u001b[38;5;15m\u001b[48;5;0mthe \u001b[0m\u001b[38;5;15m\u001b[48;5;0mparty \u001b[0m\u001b[38;5;15m\u001b[48;5;0m? \u001b[0m\u001b[38;5;15m\u001b[48;5;0mi \u001b[0m\u001b[38;5;15m\u001b[48;5;0mhad \u001b[0m\u001b[38;5;15m\u001b[48;5;0mno \u001b[0m\u001b[38;5;15m\u001b[48;5;0m- \u001b[0m\u001b[38;5;15m\u001b[48;5;0mone \u001b[0m\u001b[38;5;15m\u001b[48;5;0mto \u001b[0m\u001b[38;5;15m\u001b[48;5;0mparty \u001b[0m\u001b[38;5;15m\u001b[48;5;0mwith \u001b[0m\u001b[38;5;15m\u001b[48;5;0m. \u001b[0m\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "# text = [\"Who was Jim Henson? Jim Henson _ a puppeteer.\"]\n",
    "text = [\"I went to school by myself. I had no seat on the bus.\"]\n",
    "# text = [\"I thought that John defeated Mary. I was wrong. _ beat _.\"]\n",
    "# text = [\"Did John defeat Mary? No, _ beat _.\"]\n",
    "# text = [\"That mary defeated John contradicts the fact that _ beat _.\"]\n",
    "# text = [\"After the outbreak of the disease, the Ministry of Agriculture and rural areas immediately sent a supervision team to the local. Local Emergency Response Mechanism has been activated in accordance with the requirements, to take blockade, culling, harmless treatment, disinfection and other treatment measures to all disease and culling of pigs for harmless treatment. At the same time, all live pigs and their products are prohibited from transferring out of the blockade area, and live pigs are not allowed to be transported into the blockade area. At present, all the above measures have been implemented.\"]\n",
    "# text = [\"Early critics of Emily Dickinson's poetry mistook for simplemindedness the surface of artlessness that in fact she constructed with such innocence.\"]\n",
    "\n",
    "text = [sss] #\n",
    "analyze_text(text, show_firstk_probs=100)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def words2heads(attns, tokens, words):\n",
    "    positions = [tokens.index(word) for word in words]\n",
    "\n",
    "    for layer in range(config.num_hidden_layers):\n",
    "        for head in range(config.num_attention_heads):\n",
    "            for pos_indices in [(0, 1), (1, 0)]:\n",
    "                from_pos, to_pos = positions[pos_indices[0]], positions[pos_indices[1]]\n",
    "                if attns[layer][head][from_pos].max(0)[1].item() == to_pos:\n",
    "                    print('Layer %d, head %d: %s -> %s' % (layer, head, tokens[from_pos], tokens[to_pos]), end='\\t')\n",
    "                    print(attns[layer][head][from_pos].topk(5)[0].data)\n",
    "\n",
    "def head2words(attns, tokens, layer, head):\n",
    "    for from_pos in range(len(tokens)):\n",
    "        to_pos = attns[layer][head][from_pos].max(0)[1].item()\n",
    "        from_word, to_word = tokens[from_pos], tokens[to_pos]\n",
    "        if from_word.isalpha() and to_word.isalpha():\n",
    "            print('%s @ %d -> %s @ %d' % (from_word, from_pos, to_word, to_pos), end='\\t')\n",
    "            print(attns[layer][head][from_pos].topk(5)[0].data)\n",
    "      \n",
    "special_tokens = ['[CLS]', '[SEP]']\n",
    "\n",
    "def get_salient_heads(attns, tokens, attn_thld=0.5):\n",
    "    for layer in range(config.num_hidden_layers):\n",
    "        for head in range(config.num_attention_heads):\n",
    "            pos_pairs = []\n",
    "            for from_pos in range(1, len(tokens) - 1):  # skip [CLS] and [SEP]\n",
    "                top_attn, to_pos = attns[layer][head][from_pos].max(0)\n",
    "                top_attn, to_pos = top_attn.item(), to_pos.item()\n",
    "                from_word, to_word = tokens[from_pos], tokens[to_pos]\n",
    "#                 if from_word.isalpha() and to_word.isalpha() and top_attn >= attn_thld:\n",
    "                if abs(from_pos - to_pos) <= 1:\n",
    "#                     print('Layer %d, head %d: %s @ %d -> %s @ %d' % (layer, head, from_word, from_pos, to_word, to_pos), end='\\t')\n",
    "#                     print(attns[layer][head][from_pos].topk(5)[0].data)\n",
    "                    pos_pairs.append((from_pos, to_pos))\n",
    "    \n",
    "            ratio = len(pos_pairs) / (len(tokens) - 2)\n",
    "            if ratio > 0.5:\n",
    "                print(ratio)\n",
    "                for from_pos, to_pos in pos_pairs:\n",
    "                    print('Layer %d, head %d: %s @ %d -> %s @ %d' % (layer, head, tokens[from_pos], from_pos, tokens[to_pos], to_pos), end='\\t')\n",
    "                    print(attns[layer][head][from_pos].topk(5)[0].data)\n",
    "                    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "01/10/2019 21:46:20 - INFO - examples.extract_features -   tokens: [CLS] jim laughed because he was so happy . [SEP]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jim @ 1 -> jim @ 1\ttensor([0.7248, 0.0842, 0.0656, 0.0407, 0.0319], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "# text, words = [\"The trophy doesn't fit into the brown suitcase because the it is too large.\"], ['fit', 'large']\n",
    "# text, words = [\"Mary couldn't beat John in the match because he was too strong.\"], ['beat', 'strong']\n",
    "text, words = [\"John is taller than Mary because he is older.\"], ['taller', 'older']\n",
    "# text, words = [\"The red ball is heavier than the blue ball because the red ball is bigger.\"], ['heavier', 'bigger']\n",
    "text, words = [\"Jim laughed because he was so happy.\"], ['cried', 'sad']\n",
    "# text, words = [\"Jim ate the cake quickly because he was so hungry.\"], ['ate', 'hungry']\n",
    "# text, words = [\"Jim drank the juice quickly because he was so thirsty.\"], ['drank', 'thirsty']\n",
    "# text, words = [\"Tom's drawing hangs high. It is above Susan's drawing\"], ['high', 'above']\n",
    "# text, words = [\"Tom's drawing hangs low. It is below Susan's drawing\"], ['low', 'below']\n",
    "# text, words = [\"John is taller than Mary . Mary is shorter than John.\"], ['taller', 'shorter']\n",
    "# text, words = [\"The drawing is above the cabinet. The cabinet is below the drawing\"], ['above', 'below']\n",
    "# text, words = [\"Jim is very thin . He is not fat.\"], ['thin', 'fat']\n",
    "\n",
    "features = convert_examples_to_features(convert_text_to_examples(text), tokenizer, print_info=False)\n",
    "input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long).to(device)\n",
    "input_type_ids = torch.tensor([f.input_type_ids for f in features], dtype=torch.long).to(device)\n",
    "mlm_logits, _ = model(input_ids, input_type_ids)\n",
    "mlm_probs = F.softmax(mlm_logits, dim=-1)\n",
    "tokens = features[0].tokens\n",
    "# top_pairs = show_lm_probs(tokens, None, mlm_probs[0], firstk=100)\n",
    "\n",
    "attn_name = 'enc_self_attns'\n",
    "hypo = {attn_name: [model.bert.encoder.layer[i].attention.self.attention_probs[0] for i in range(config.num_hidden_layers)]}\n",
    "key_labels = query_labels = tokens\n",
    "labels_dict = {attn_name: (key_labels, query_labels)}\n",
    "result_tuple = (hypo, config.num_attention_heads, labels_dict)\n",
    "# plot_layer_attn(result_tuple, attn_name=attn_name, layer=10, heads=None)\n",
    "\n",
    "attns = hypo[attn_name]\n",
    "    \n",
    "# words2heads(attns, tokens, words)\n",
    "head2words(attns, tokens, 2, 10)\n",
    "# get_salient_heads(attns, tokens, attn_thld=0.0)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "0，2\t-1\n",
    "0，3\t-1\n",
    "0，10\t+1  动宾\n",
    "1，1\t+1  动介\n",
    "1，4\t-1\n",
    "1，11\t0\n",
    "2，0\t+1**\n",
    "2，6\t0**\n",
    "2，9\t+1**\n",
    "3，5\t-1\n",
    "7，4\t-1\n",
    "11，8\t0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f75ce34a978>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head_size = config.hidden_size // config.num_attention_heads\n",
    "layer = 1\n",
    "head = 1 # 2, 3, 10\n",
    "wq = model.bert.encoder.layer[layer].attention.self.query.weight.data.view(-1, config.num_attention_heads, head_size).permute(1, 0, 2)\n",
    "wk = model.bert.encoder.layer[layer].attention.self.key.weight.data.view(-1, config.num_attention_heads, head_size).permute(1, 0, 2)\n",
    "\n",
    "wqk = torch.bmm(wq, wk.transpose(-1, -2))\n",
    "# (wqk * wqk.transpose(-1, -2)).sum((1, 2)) / (wqk * wqk).sum((1, 2))\n",
    "plt.imshow(wqk[head]*wqk[head])\n",
    "plt.show()\n",
    "\n",
    "# q = torch.matmul(pos_emb, wq)\n",
    "# k = torch.matmul(pos_emb_prev, wk)\n",
    "# (q * k).sum((-2, -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_emb = model.bert.embeddings.position_embeddings.weight.data\n",
    "pos_emb_prev = torch.zeros_like(pos_emb)\n",
    "pos_emb_next = torch.zeros_like(pos_emb)\n",
    "pos_emb_prev[1:] = pos_emb[:-1]\n",
    "pos_emb_next[:-1] = pos_emb[1:]\n",
    "pos_emb, pos_emb_prev, pos_emb_next = pos_emb[1:-1], pos_emb_prev[1:-1], pos_emb_next[1:-1]\n",
    "\n",
    "# pos_q = torch.matmul(pos_emb, wk[head])\n",
    "# plt.imshow(pos_q[:32])\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\n",
       "  \"attention_probs_dropout_prob\": 0.1,\n",
       "  \"hidden_act\": \"gelu\",\n",
       "  \"hidden_dropout_prob\": 0.1,\n",
       "  \"hidden_size\": 768,\n",
       "  \"initializer_range\": 0.02,\n",
       "  \"intermediate_size\": 3072,\n",
       "  \"max_position_embeddings\": 512,\n",
       "  \"num_attention_heads\": 12,\n",
       "  \"num_hidden_layers\": 12,\n",
       "  \"type_vocab_size\": 2,\n",
       "  \"vocab_size\": 30522\n",
       "}"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Tom has black hair. Mary has black hair. John has yellow hair. _  and Mary have the same hair color.',\n",
       " 'Tom has black hair. Mary has black hair. John has yellow hair. _  and Mary have different hair colors.']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = [\n",
    "    # same / different\n",
    "    \"Tom has black hair. Mary has black hair. John has yellow hair. _  and Mary have the same hair color.\",\n",
    "    \"Tom has black hair. Mary has black hair. John has yellow hair. _  and Mary have different hair colors.\",\n",
    "    \"Tom has yellow hair. Mary has black hair. John has black hair. Mary and _ have the same hair color.\",\n",
    "    # because / although\n",
    "    \"John is taller/shorter than Mary because/although _ is older/younger.\",\n",
    "    \"The red ball is heavier/lighter than the blue ball because/although the _ ball is bigger/smaller.\",\n",
    "    \"Charles did a lot better/worse than his good friend Nancy on the test because/although _ had/hadn't studied so hard.\",\n",
    "    \"The trophy doesn't fit into the brown suitcase because/although the _ is too small/large.\",\n",
    "    \"John thought that he would arrive earlier than Susan, but/and indeed _ was the first to arrive.\",\n",
    "    # reverse\n",
    "    \"John came then Mary came. They left in reverse order. _ left then _ left.\",\n",
    "    \"John came after Mary. They left in reverse order. _ left after _ .\",\n",
    "    \"John came first, then came Mary. They left in reverse order: _ left first, then left _ .\",\n",
    "    # compare sentences with same / opposite meaning, 2nd order\n",
    "    \"Though John is tall, Tom is taller than John. So John is _ than Tom.\",\n",
    "    \"Tom is taller than John. So _ is shorter than _.\",\n",
    "    # WSC-style: before /after\n",
    "    # \"Mary came before/after John. _ was late/early .\",\n",
    "    # yes / no, 2nd order\n",
    "    \"Was Tom taller than Susan? Yes, _ was taller.\",\n",
    "    # right / wrong, epistemic modality, 2nd order\n",
    "    \"John said/thought that the red ball was heavier than the blue ball. He was wrong. The _ ball was heavier\",\n",
    "    \"John was wrong in saying/thinking that the red ball was heavier than the blue ball. The _ ball was heavier\",\n",
    "    \"John said the rain was about to stop. Mary said the rain would continue. Later the rain stopped. _ was wrong/right.\",\n",
    "    \n",
    "    \"The trophy doesn't fit into the brown suitcase because/although the _ is too small/large.\",\n",
    "    \"John thanked Mary because  _ had given help to _ . \",\n",
    "    \"John felt vindicated/crushed when his longtime rival Mary revealed that _ was the winner of the competition.\",\n",
    "    \"John couldn't see the stage with Mary in front of him because _ is so short/tall.\",\n",
    "    \"Although they ran at about the same speed, John beat Sally because _ had such a bad start.\",\n",
    "    \"The fish ate the worm. The _ was hungry/tasty.\",\n",
    "    \n",
    "    \"John beat Mary. _ won the game/e winner.\",\n",
    "]\n",
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('WSC_switched_label.json') as f:\n",
    "    examples = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('WSC_child_problem.json') as f:\n",
    "    cexamples = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ce in cexamples:\n",
    "    for s in ce['sentences']:\n",
    "        for a in s['answer0'] + s['answer1']:\n",
    "            a = a.lower()\n",
    "            if a not in tokenizer.vocab:\n",
    "                ce\n",
    "                print(a, 'not in vocab!!!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ce in cexamples:\n",
    "    if len(ce['sentences']) > 0:\n",
    "        e = examples[ce['index']]\n",
    "        assert ce['index'] == e['index']\n",
    "        e['score'] = all([s['score'] for s in ce['sentences']])\n",
    "        assert len(set([s['adjacent_ref'] for s in ce['sentences']])) == 1, 'adjcent_refs are different!'\n",
    "        e['adjacent_ref'] = ce['sentences'][0]['adjacent_ref']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "groups = defaultdict(list)\n",
    "for e in examples:\n",
    "    if 'score' in e:\n",
    "        index = e['index']\n",
    "        if index < 252:\n",
    "            if index % 2 == 1:\n",
    "                index -= 1\n",
    "        elif index in [252, 253, 254]:\n",
    "            index = 252\n",
    "        else:\n",
    "            if index % 2 == 0:\n",
    "                index -= 1\n",
    "        groups[index].append(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(\"The trophy doesn't fit into the brown suitcase because [it] is too large.\",\n",
       "  'fit into:large/small'),\n",
       " ('Joan made sure to thank Susan for all the help [she] had recieved.',\n",
       "  'thank:receive/give'),\n",
       " ('The delivery truck zoomed by the school bus because [it] was going so fast.',\n",
       "  'zoom by:fast/slow'),\n",
       " ('Frank felt vindicated when his longtime rival Bill revealed that [he] was the winner of the competition.',\n",
       "  'vindicated/crushed:be the winner'),\n",
       " ('The large ball crashed right through the table because [it] was made of steel.',\n",
       "  'crash through:[hard]/[soft]'),\n",
       " (\"John couldn't see the stage with Billy in front of him because [he] is so short.\",\n",
       "  '[block]:short/tall'),\n",
       " ('Tom threw his schoolbag down to Ray after [he] reached the top of the stairs.',\n",
       "  'down to:top/bottom'),\n",
       " ('Although they ran at about the same speed, Sue beat Sally because [she] had such a good start.',\n",
       "  'beat:good/bad'),\n",
       " (\"Sam's drawing was hung just above Tina's and [it] did look much better with another one below it.\",\n",
       "  'above/below'),\n",
       " ('Anna did a lot better than her good friend Lucy on the test because [she] had studied so hard.',\n",
       "  'better/worse:study hard'),\n",
       " ('The firemen arrived after the police because [they] were coming from so far away.',\n",
       "  'after/before:far away'),\n",
       " (\"Frank was upset with Tom because the toaster [he] had bought from him didn't work.\",\n",
       "  'be upset with:buy from not work/sell not work'),\n",
       " ('The sack of potatoes had been placed above the bag of flour, so [it] had to be moved first.',\n",
       "  'above/below:moved first'),\n",
       " ('Pete envies Martin although [he] is very successful.', 'although/because'),\n",
       " ('I poured water from the bottle into the cup until [it] was empty.',\n",
       "  'pour:empty/full'),\n",
       " (\"Sid explained his theory to Mark but [he] couldn't convince him.\",\n",
       "  'explain:convince/understand'),\n",
       " (\"Susan knew that Ann's son had been in a car accident, so [she] told her about it.\",\n",
       "  '?know tell:so/because'),\n",
       " (\"Joe's uncle can still beat him at tennis, even though [he] is 30 years younger.\",\n",
       "  'beat:younger/older'),\n",
       " ('In the middle of the outdoor concert, the rain started falling, but [it] continued until 10.',\n",
       "  'but/and'),\n",
       " ('Ann asked Mary what time the library closes, because [she] had forgotten.',\n",
       "  'because/but'),\n",
       " ('If the con artist has succeeded in fooling Sam, [he] would have gotten a lot of money.',\n",
       "  'fool:get/lose'),\n",
       " ('Alice tried frantically to stop her daughter from chatting at the party, leaving us to wonder why [she] was behaving so strangely.',\n",
       "  '?stop normal/stop abnormal:strange'),\n",
       " (\"I was trying to open the lock with the key, but someone had filled the  keyhole with chewing gum, and I couldn't get [it] in.\",\n",
       "  'put ... into filled with ... :get in/get out'),\n",
       " ('The dog chased the cat, which ran up a tree. [It] waited at the bottom.',\n",
       "  'up:at the bottom/at the top'),\n",
       " ('John was doing research in the library when he heard a man humming and  whistling. [He] was very annoyed.',\n",
       "  'hear ... humming and whistling:annoyed/annoying'),\n",
       " ('John was jogging through the park when he saw a man juggling watermelons. [He] was very impressed.',\n",
       "  'see ... juggling watermelons:impressed/impressive'),\n",
       " ('Jane knocked on the door, and Susan answered it. [She] invited her to come out.',\n",
       "  'visit:invite come out/invite come in'),\n",
       " ('Jackson was greatly influenced by Arnold, though [he] lived two centuries later.',\n",
       "  'influence:later/earlier'),\n",
       " ('The actress used to be named Terpsichore, but she changed it to Tina a  few years ago, because she figured [it] was too hard to pronounce.',\n",
       "  'change:hard/easy'),\n",
       " ('Fred is the only man still alive who remembers my great-grandfather. [He] is a remarkable man.',\n",
       "  'alive:is/was'),\n",
       " (\"In July, Kamtchatka declared war on Yakutsk. Since Yakutsk's army was much  better equipped and ten times larger, [they] were defeated within weeks.\",\n",
       "  'better equipped and large:defeated/victorious'),\n",
       " ('When the sponsors of the bill got to the town hall, they were surprised to find that the room was full of opponents. [They] were very much in the minority.',\n",
       "  'be full of:minority/majority'),\n",
       " ('Everyone really loved the oatmeal cookies; only a few people liked the  chocolate chip cookies. Next time, we should make more of [them] .',\n",
       "  'like over:more/fewer'),\n",
       " ('We had hoped to place copies of our newsletter on all the chairs in the auditorium, but there were simply not enough of [them] .',\n",
       "  'place on all:not enough/too many'),\n",
       " (\"Steve follows Fred's example in everything. [He] admires him hugely.\",\n",
       "  'follow:admire/influence'),\n",
       " (\"The table won't fit through the doorway because [it] is too wide.\",\n",
       "  'fit through:wide/narrow'),\n",
       " ('Grace was happy to trade me her sweater for my jacket. She thinks [it] looks dowdy on her.',\n",
       "  'trade:dowdy/great'),\n",
       " ('John hired Bill to take care of [him] .',\n",
       "  'hire/hire oneself to:take care of'),\n",
       " ('John promised Bill to leave, so an hour later [he] left.', 'promise/order'),\n",
       " (\"Jane knocked on Susan's door but [she] did not get an answer.\",\n",
       "  'knock:get an answer/answer'),\n",
       " ('Joe paid the detective after [he] received the final report on the case.',\n",
       "  'pay:receive/deliver'),\n",
       " ('Bill passed the half-empty plate to John because [he] was full.',\n",
       "  'pass the plate:full/hungry'),\n",
       " ('George got free tickets to the play, but he gave them to Eric, even though [he] was particularly eager to see it.',\n",
       "  'even though/because/not'),\n",
       " (\"Jane gave Joan candy because [she] wasn't hungry.\",\n",
       "  'give:not hungry/hungry'),\n",
       " ('James asked Robert for a favor but [he] was refused.',\n",
       "  'ask for a favor:refuse/be refused`'),\n",
       " ('Kirilov ceded the presidency to Shatov because [he] was less popular.',\n",
       "  'cede:less popular/more popular'),\n",
       " ('Emma did not pass the ball to Janie although [she] saw that she was open.',\n",
       "  'not pass although:see open/open')]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def filter_dict(d, keys=['index', 'sentence', 'correct_answer', 'relational_word', 'is_associative', 'score']):\n",
    "    return {k: d[k] for k in d if k in keys}\n",
    "\n",
    "# ([[filter_dict(e) for e in eg] for eg in groups.values() if eg[0]['relational_word'] != 'none' and all([e['score'] for e in eg])])# / len([eg for eg in groups.values() if eg[0]['relational_word'] != 'none'])\n",
    "# [(index, eg[0]['relational_word'], all([e['score'] for e in eg])) for index, eg in groups.items() if eg[0]['relational_word'] != 'none']\n",
    "# len([filter_dict(e) for e in examples if 'score' in e and not e['score'] and e['adjacent_ref']])\n",
    "# for e in examples:\n",
    "#     if e['index'] % 2 == 0:\n",
    "#         print(e['sentence'])\n",
    "[(eg[0]['sentence'], eg[0]['relational_word']) for index, eg in groups.items() if '/' in eg[0]['relational_word']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "179"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(['because' in e['sentence'] for e in examples]) + \\\n",
    "sum(['so ' in e['sentence'] for e in examples]) + \\\n",
    "sum(['but ' in e['sentence'] for e in examples]) + \\\n",
    "sum(['though' in e['sentence'] for e in examples])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('WSC_switched_label.json', 'w') as f:\n",
    "#     json.dump(examples, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "vis_attn_topk = 3\n",
    "\n",
    "def has_chinese_label(labels):\n",
    "    labels = [label.split('->')[0].strip() for label in labels]\n",
    "    r = sum([len(label) > 1 for label in labels if label not in ['BOS', 'EOS']]) * 1. / (len(labels) - 1)\n",
    "    return 0 < r < 0.5  # r == 0 means empty query labels used in self attention\n",
    "\n",
    "def _plot_attn(ax1, attn_name, attn, key_labels, query_labels, col, color='b'):\n",
    "    assert len(query_labels) == attn.size(0)\n",
    "    assert len(key_labels) == attn.size(1)\n",
    "\n",
    "    ax1.set_xlim([-1, 1])\n",
    "    ax1.set_xticks([])\n",
    "    ax2 = ax1.twinx()\n",
    "    nlabels = max(len(key_labels), len(query_labels))\n",
    "    pos = range(nlabels)\n",
    "    \n",
    "    if 'self' in attn_name and col < ncols - 1:\n",
    "        query_labels = ['' for _ in query_labels]\n",
    "\n",
    "    for ax, labels in [(ax1, key_labels), (ax2, query_labels)]:\n",
    "        ax.set_yticks(pos)\n",
    "        if has_chinese_label(labels):\n",
    "            ax.set_yticklabels(labels, fontproperties=zhfont)\n",
    "        else:\n",
    "            ax.set_yticklabels(labels)\n",
    "        ax.set_ylim([nlabels - 1, 0])\n",
    "        ax.tick_params(width=0, labelsize='xx-large')\n",
    "\n",
    "        for spine in ax.spines.values():\n",
    "            spine.set_visible(False)\n",
    "\n",
    "#     mask, attn = filter_attn(attn)\n",
    "    for qi in range(attn.size(0)):\n",
    "#         if not mask[qi]:\n",
    "#             continue\n",
    "#         for ki in range(attn.size(1)):\n",
    "        for ki in attn[qi].topk(vis_attn_topk)[1]:\n",
    "            a = attn[qi, ki]\n",
    "            ax1.plot((-1, 1), (ki, qi), color, alpha=a)\n",
    "#     print(attn.mean(dim=0).topk(5)[0])\n",
    "#     ax1.barh(pos, attn.mean(dim=0).data.cpu().numpy())\n",
    "\n",
    "def plot_layer_attn(result_tuple, attn_name='dec_self_attns', layer=0, heads=None):\n",
    "    hypo, nheads, labels_dict = result_tuple\n",
    "    key_labels, query_labels = labels_dict[attn_name]\n",
    "    if heads is None:\n",
    "        heads = range(nheads)\n",
    "    else:\n",
    "        nheads = len(heads)\n",
    "    \n",
    "    stride = 2 if attn_name == 'dec_enc_attns' else 1\n",
    "    nlabels = max(len(key_labels), len(query_labels))\n",
    "    rcParams['figure.figsize'] = 20, int(round(nlabels * stride * nheads / 8 * 1.0))\n",
    "    \n",
    "    rows = nheads // ncols * stride\n",
    "    fig, axes = plt.subplots(rows, ncols)\n",
    "    \n",
    "    # for head in range(nheads):\n",
    "    for head_i, head in enumerate(heads):\n",
    "        row, col = head_i * stride // ncols, head_i * stride % ncols\n",
    "        ax1 = axes[row, col]\n",
    "        attn = hypo[attn_name][layer][head]\n",
    "        _plot_attn(ax1, attn_name, attn, key_labels, query_labels, col)\n",
    "        if attn_name == 'dec_enc_attns':\n",
    "            col = col + 1\n",
    "            axes[row, col].axis('off')  # next subfig acts as blank place holder\n",
    "    # plt.suptitle('%s with %d heads, Layer %d' % (attn_name, nheads, layer), fontsize=20)\n",
    "    plt.show()  \n",
    "            \n",
    "ncols = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\n",
       "  \"attention_probs_dropout_prob\": 0.1,\n",
       "  \"hidden_act\": \"gelu\",\n",
       "  \"hidden_dropout_prob\": 0.1,\n",
       "  \"hidden_size\": 768,\n",
       "  \"initializer_range\": 0.02,\n",
       "  \"intermediate_size\": 3072,\n",
       "  \"max_position_embeddings\": 512,\n",
       "  \"num_attention_heads\": 12,\n",
       "  \"num_hidden_layers\": 12,\n",
       "  \"type_vocab_size\": 2,\n",
       "  \"vocab_size\": 30522\n",
       "}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config.num"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}