Wiki103_from_scratch_fastai_v1_raw_articles-backward_tokens.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai import *\n",
    "from fastai.text import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python code Examples (testing out tokenizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading the texts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = Path('/home/farzin/rnn_python_code/wiki103_from_download')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/farzin/anaconda3/envs/fastaiv1_dev/lib/python3.7/site-packages/ipykernel_launcher.py:1: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "all_texts_df = pd.read_csv('/home/farzin/fast_ai/fastai_v1/courses/dl2/imdb_scripts/data/wiki/en/train.csv',sep='%$#')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_texts = all_texts_df.values.squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#all_texts = np.concatenate([train_texts,valid_texts])\n",
    "idx = np.random.permutation(len(all_texts))\n",
    "cut = int(0.1 * len(idx))\n",
    "train_df = pd.DataFrame({'text':all_texts[idx[cut:]], 'labels':[0] * (len(all_texts)-cut)}, columns=['labels','text'])\n",
    "valid_df = pd.DataFrame({'text':all_texts[idx[:cut]], 'labels':[0] * cut}, columns=['labels','text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def sub_br(t:str) -> str:\n",
    "    \"Replaces the <br /> by \\n\"\n",
    "    re_br = re.compile(r'<\\s*br\\s*/?>', re.IGNORECASE)\n",
    "    return re_br.sub(\"\\n\", t)\n",
    "\n",
    "def spec_add_spaces(t:str) -> str:\n",
    "    \"Add spaces between special characters\"\n",
    "    return re.sub(r'([/#])', r' \\1 ', t)\n",
    "\n",
    "def rm_useless_spaces(t:str) -> str:\n",
    "    \"Remove multiple spaces\"\n",
    "    return re.sub(' {2,}', ' ', t)\n",
    "\n",
    "def replace_rep(t:str) -> str:\n",
    "    \"Replace repetitions at the character level\"\n",
    "    def _replace_rep(m:Collection[str]) -> str:\n",
    "        c,cc = m.groups()\n",
    "        return f' {TK_REP} {len(cc)+1} {c} '\n",
    "    re_rep = re.compile(r'(\\S)(\\1{3,})')\n",
    "    return re_rep.sub(_replace_rep, t)\n",
    "    \n",
    "def replace_wrep(t:str) -> str:\n",
    "    \"Replace word repetitions\"\n",
    "    def _replace_wrep(m:Collection[str]) -> str:\n",
    "        c,cc = m.groups()\n",
    "        return f' {TK_WREP} {len(cc.split())+1} {c} '\n",
    "    re_wrep = re.compile(r'(\\b\\w+\\W+)(\\1{3,})')\n",
    "    return re_wrep.sub(_replace_wrep, t)\n",
    "\n",
    "def deal_caps(t:str) -> str:\n",
    "    \"Replace words in all caps\"\n",
    "    res = []\n",
    "    for s in re.findall(r'\\w+|\\W+', t):\n",
    "        res += ([f' {TK_UP} ',s.lower()] if (s.isupper() and (len(s)>2)) else [s.lower()])\n",
    "    return ''.join(res)\n",
    "\n",
    "def fixup(x:str) -> str:\n",
    "    \"List of replacements from html strings\"\n",
    "    re1 = re.compile(r'  +')\n",
    "    x = x.replace('#39;', \"'\").replace('amp;', '&').replace('#146;', \"'\").replace(\n",
    "        'nbsp;', ' ').replace('#36;', '$').replace('\\\\n', \"\\n\").replace('quot;', \"'\").replace(\n",
    "        '<br />', \"\\n\").replace('\\\\\"', '\"').replace('<unk>',UNK).replace(' @.@ ','.').replace(\n",
    "        ' @-@ ','-').replace('\\\\', ' \\\\ ')\n",
    "    return re1.sub(' ', html.unescape(x))\n",
    "\n",
    "default_rules = [fixup, replace_rep, replace_wrep, deal_caps, spec_add_spaces, rm_useless_spaces, sub_br]\n",
    "default_spec_tok = [BOS, FLD, UNK, PAD]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "My custom change to Tokenizer to reverse the returned tokens:\n",
    "\n",
    "    \n",
    "Init signature:\n",
    "Tokenizer(\n",
    "    [\"tok_func: Callable = <class 'fastai.text.transform.SpacyTokenizer'>\", \"lang: str = 'en'\", 'pre_rules: Collection[Callable[[str], str]] = None', 'post_rules: Collection[Callable[[str], str]] = None', 'special_cases: Collection[str] = None', 'n_cpus: int = None', 'bwd_toks=False'],\n",
    ")\n",
    "Source:        \n",
    "class Tokenizer():\n",
    "    \"Put together rules and a tokenizer function to tokenize text with multiprocessing.\"\n",
    "    def __init__(self, tok_func:Callable=SpacyTokenizer, lang:str='en', pre_rules:ListRules=None,\n",
    "                 post_rules:ListRules=None, special_cases:Collection[str]=None, n_cpus:int=None,bwd_toks=False):\n",
    "        self.tok_func,self.lang,self.special_cases = tok_func,lang,special_cases\n",
    "        self.pre_rules  = ifnone(pre_rules,  defaults.text_pre_rules )\n",
    "        self.post_rules = ifnone(post_rules, defaults.text_post_rules)\n",
    "        self.special_cases = special_cases if special_cases else defaults.text_spec_tok\n",
    "        self.n_cpus = ifnone(n_cpus, defaults.cpus)\n",
    "        self.bwd_toks = bwd_toks\n",
    "        \n",
    "...\n",
    "\n",
    "    def process_text(self, t:str, tok:BaseTokenizer) -> List[str]:\n",
    "        \"Process one text `t` with tokenizer `tok`.\"\n",
    "        for rule in self.pre_rules: t = rule(t)\n",
    "        toks = tok.tokenizer(t)\n",
    "        for rule in self.post_rules: toks = rule(toks)\n",
    "        return listify(toks[0])+toks[1:][::-1] if self.bwd_toks else toks  # <-- Just one line changed!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = Tokenizer(pre_rules=default_rules, special_cases=[BOS, FLD, 'xxunk', 'xxpad'], n_cpus=4,bwd_toks=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tokenizer SpacyTokenizer in en with the following rules:\n",
       " - fixup\n",
       " - replace_rep\n",
       " - replace_wrep\n",
       " - deal_caps\n",
       " - spec_add_spaces\n",
       " - rm_useless_spaces\n",
       " - sub_br\n",
       " - replace_all_caps\n",
       " - deal_caps"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = train_df.dropna()\n",
    "valid_df = valid_df.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_vocab = 60000 #can we make this the full possible vocab at 260k?\n",
    "batch_size = 32\n",
    "\n",
    "keyword_args = {'max_vocab':max_vocab,'bs':batch_size}\n",
    "data = TextLMDataBunch.from_df(PATH, train_df, valid_df, tokenizer=tokenizer,\n",
    "                               text_cols='text', label_cols='labels',**keyword_args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BMW used Nikasil- an aluminium, nickel, and silicon alloy- to line the cylinders of the M60 engines. In fuels with high sulfur content (such as used fuels sold in the United States, UK and South America), the sulfur damages the Nikasil bore lining, causing the engine to lose compression.'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.iloc[0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "## BOS + backward tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   2,   10, 8869, 3806, ...,    0,   89, 9029,    5])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.train_ds.x[0].data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xxbos . compression lose to engine the causing , lining bore xxunk the damages sulfur the , ) america south and uk , states united the in sold fuels used as such ( content sulfur high with fuels in . engines m60 xxup the of cylinders the line to xxunk silicon and , nickel , aluminium an xxunk used bmw xxup'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.train_ds.x[0].text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60004"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data.vocab.itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.save('tmp_bwd')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#Save/load data object. \n",
    "data.save()\n",
    "data.load(PATH)\n",
    "#!ls -lhart {PATH}/tmp/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 1.2G\r\n",
      "drwxrwxr-x 6 farzin farzin 4.0K Jan 23 10:22 ..\r\n",
      "-rw-rw-r-- 1 farzin farzin 999K Jan 23 10:22 itos.pkl\r\n",
      "-rw-rw-r-- 1 farzin farzin 1.1G Jan 23 10:23 train_ids.npy\r\n",
      "-rw-rw-r-- 1 farzin farzin  20M Jan 23 10:23 train_lbl.npy\r\n",
      "-rw-rw-r-- 1 farzin farzin 119M Jan 23 10:23 valid_ids.npy\r\n",
      "-rw-rw-r-- 1 farzin farzin 2.2M Jan 23 10:23 valid_lbl.npy\r\n",
      "-rw-rw-r-- 1 farzin farzin    2 Jan 23 10:23 classes.txt\r\n",
      "drwxrwxr-x 2 farzin farzin 4.0K Jan 23 10:23 .\r\n"
     ]
    }
   ],
   "source": [
    "!ls -lhart {PATH}/tmp_bwd/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SequentialRNN(\n",
       "  (0): RNNCore(\n",
       "    (encoder): Embedding(60004, 400, padding_idx=1)\n",
       "    (encoder_dp): EmbeddingDropout(\n",
       "      (emb): Embedding(60004, 400, padding_idx=1)\n",
       "    )\n",
       "    (rnns): ModuleList(\n",
       "      (0): QRNNLayer(\n",
       "        (linear): WeightDropout(\n",
       "          (module): Linear(in_features=800, out_features=3333, bias=True)\n",
       "        )\n",
       "      )\n",
       "      (1): QRNNLayer(\n",
       "        (linear): WeightDropout(\n",
       "          (module): Linear(in_features=1111, out_features=3333, bias=True)\n",
       "        )\n",
       "      )\n",
       "      (2): QRNNLayer(\n",
       "        (linear): WeightDropout(\n",
       "          (module): Linear(in_features=1111, out_features=3333, bias=True)\n",
       "        )\n",
       "      )\n",
       "      (3): QRNNLayer(\n",
       "        (linear): WeightDropout(\n",
       "          (module): Linear(in_features=1111, out_features=1200, bias=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (input_dp): RNNDropout()\n",
       "    (hidden_dps): ModuleList(\n",
       "      (0): RNNDropout()\n",
       "      (1): RNNDropout()\n",
       "      (2): RNNDropout()\n",
       "      (3): RNNDropout()\n",
       "    )\n",
       "  )\n",
       "  (1): LinearDecoder(\n",
       "    (decoder): Linear(in_features=400, out_features=60004, bias=True)\n",
       "    (output_dp): RNNDropout()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bptt = 140\n",
    "emb_sz,nh,nl = 400,1111,4\n",
    "\n",
    "learn = language_model_learner(data,bptt,emb_sz,nh,nl,drop_mult=0.5,qrnn=True)\n",
    "learn.unfreeze()\n",
    "learn.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    },
    {
     "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": [
    "lr_find(learn)\n",
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 27:04:59 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>4.599080</th>\n",
       "    <th>4.494251</th>\n",
       "    <th>0.305755</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>4.744382</th>\n",
       "    <th>4.640317</th>\n",
       "    <th>0.291409</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>4.770506</th>\n",
       "    <th>4.658196</th>\n",
       "    <th>0.289946</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>4.748968</th>\n",
       "    <th>4.617092</th>\n",
       "    <th>0.293294</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>4.677838</th>\n",
       "    <th>4.555842</th>\n",
       "    <th>0.297624</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>4.597003</th>\n",
       "    <th>4.466496</th>\n",
       "    <th>0.306344</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>4.471542</th>\n",
       "    <th>4.359515</th>\n",
       "    <th>0.315975</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>4.368707</th>\n",
       "    <th>4.241202</th>\n",
       "    <th>0.327871</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>4.281856</th>\n",
       "    <th>4.142269</th>\n",
       "    <th>0.339645</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>10</th>\n",
       "    <th>4.265164</th>\n",
       "    <th>4.105095</th>\n",
       "    <th>0.344774</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(10, 1e-2, moms=(0.8,0.7), wd=0.03, pct_start=0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "learn.recorder.plot_losses()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.recorder.plot_lr(show_moms=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59.14546984988227"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(4.08)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>  <col width='5%'>  <col width='95%'>  <tr>\n",
       "    <th>idx</th>\n",
       "    <th>text</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>0</th>\n",
       "    <th>xxbos . entrepreneur xxbos . leadership xxbos bridge covered walker xxunk \" xxbos > \" \" 1 \" \" = midi \" \" 1 \" \" = xxunk score < xxbos \" xxbos utilities xxbos : conditions following the with associated is it xxbos . instead destruction and mayhem cause to manages generally he , unfortunately ; others helping is he believes cockroach the xxunk his of most in xxbos</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>both as characterised been has he . structure song experimental an have occasionally they and , melodies unconventional feature , xxunk often are compositions his . production the in section rhythm subdued a by backed is and , himself ocean by performed often , keyboard electronic the includes generally music 's ocean . style in idiosyncratic as writers music by characterized been has music 's ocean xxbos . hyderabad from</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>, lock first the in resulted 1809 in scheme modified a . cut lock ambitious an with 1805 in was lock a for plan first the . effects tidal minor had locally river the downstream xxunk much caused which ) 1831 - xxunk ( bridge london old of period the in , sunbury the in flats and shoals many of because times medieval since place in were locally weirs such</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>provide to order in , estates earning and revenues with endowed church a is church collegiate a . myra of nicholas and , xxunk of erasmus , tarsus of paul , peter simon , cross holy the , nazareth of ) xxunk to dedicated \" \" nicolai . st und xxunk . st , pauli und petri . st , xxunk xxunk des , xxunk xxunk xxunk xxunk zu xxunk</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>personal exercise to authorized was ohio where , \" \" patterson v. . inc , xxunk \" \" in defendant the of those with actions and website 's king contrasted court the , specifically . state particular one any at directed purposefully was that act an not was website informational an of creation mere the that and , offered york new that benefits any of himself avail purposefully not did</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.show_batch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save(\"wiki103_raw_articles_spacy_BWD_20190123\")\n",
    "learn.save_encoder('wiki103_spacy_enc_BWD')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7 fasta.ai1 DEV",
   "language": "python",
   "name": "fastai1_dev"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}