mirror of
https://github.com/fastai/fastbook.git
synced 2025-04-04 01:40:44 +00:00
781 lines
22 KiB
Plaintext
781 lines
22 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"#hide\n",
|
|
"!pip install -Uqq fastbook\n",
|
|
"import fastbook\n",
|
|
"fastbook.setup_book()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"#hide\n",
|
|
"from fastbook import *"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# A Language Model from Scratch"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## The Data"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"from fastai.text.all import *\n",
|
|
"path = untar_data(URLs.HUMAN_NUMBERS)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"#hide\n",
|
|
"Path.BASE_PATH = path"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"path.ls()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"lines = L()\n",
|
|
"with open(path/'train.txt') as f: lines += L(*f.readlines())\n",
|
|
"with open(path/'valid.txt') as f: lines += L(*f.readlines())\n",
|
|
"lines"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"text = ' . '.join([l.strip() for l in lines])\n",
|
|
"text[:100]"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"tokens = text.split(' ')\n",
|
|
"tokens[:10]"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"vocab = L(*tokens).unique()\n",
|
|
"vocab"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"word2idx = {w:i for i,w in enumerate(vocab)}\n",
|
|
"nums = L(word2idx[i] for i in tokens)\n",
|
|
"nums"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Our First Language Model from Scratch"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"L((tokens[i:i+3], tokens[i+3]) for i in range(0,len(tokens)-4,3))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"seqs = L((tensor(nums[i:i+3]), nums[i+3]) for i in range(0,len(nums)-4,3))\n",
|
|
"seqs"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bs = 64\n",
|
|
"cut = int(len(seqs) * 0.8)\n",
|
|
"dls = DataLoaders.from_dsets(seqs[:cut], seqs[cut:], bs=64, shuffle=False)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Our Language Model in PyTorch"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LMModel1(Module):\n",
|
|
" def __init__(self, vocab_sz, n_hidden):\n",
|
|
" self.i_h = nn.Embedding(vocab_sz, n_hidden) \n",
|
|
" self.h_h = nn.Linear(n_hidden, n_hidden) \n",
|
|
" self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
|
|
" \n",
|
|
" def forward(self, x):\n",
|
|
" h = F.relu(self.h_h(self.i_h(x[:,0])))\n",
|
|
" h = h + self.i_h(x[:,1])\n",
|
|
" h = F.relu(self.h_h(h))\n",
|
|
" h = h + self.i_h(x[:,2])\n",
|
|
" h = F.relu(self.h_h(h))\n",
|
|
" return self.h_o(h)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = Learner(dls, LMModel1(len(vocab), 64), loss_func=F.cross_entropy, \n",
|
|
" metrics=accuracy)\n",
|
|
"learn.fit_one_cycle(4, 1e-3)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"n,counts = 0,torch.zeros(len(vocab))\n",
|
|
"for x,y in dls.valid:\n",
|
|
" n += y.shape[0]\n",
|
|
" for i in range_of(vocab): counts[i] += (y==i).long().sum()\n",
|
|
"idx = torch.argmax(counts)\n",
|
|
"idx, vocab[idx.item()], counts[idx].item()/n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Our First Recurrent Neural Network"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LMModel2(Module):\n",
|
|
" def __init__(self, vocab_sz, n_hidden):\n",
|
|
" self.i_h = nn.Embedding(vocab_sz, n_hidden) \n",
|
|
" self.h_h = nn.Linear(n_hidden, n_hidden) \n",
|
|
" self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
|
|
" \n",
|
|
" def forward(self, x):\n",
|
|
" h = 0\n",
|
|
" for i in range(3):\n",
|
|
" h = h + self.i_h(x[:,i])\n",
|
|
" h = F.relu(self.h_h(h))\n",
|
|
" return self.h_o(h)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = Learner(dls, LMModel2(len(vocab), 64), loss_func=F.cross_entropy, \n",
|
|
" metrics=accuracy)\n",
|
|
"learn.fit_one_cycle(4, 1e-3)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Improving the RNN"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Maintaining the State of an RNN"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LMModel3(Module):\n",
|
|
" def __init__(self, vocab_sz, n_hidden):\n",
|
|
" self.i_h = nn.Embedding(vocab_sz, n_hidden) \n",
|
|
" self.h_h = nn.Linear(n_hidden, n_hidden) \n",
|
|
" self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
|
|
" self.h = 0\n",
|
|
" \n",
|
|
" def forward(self, x):\n",
|
|
" for i in range(3):\n",
|
|
" self.h = self.h + self.i_h(x[:,i])\n",
|
|
" self.h = F.relu(self.h_h(self.h))\n",
|
|
" out = self.h_o(self.h)\n",
|
|
" self.h = self.h.detach()\n",
|
|
" return out\n",
|
|
" \n",
|
|
" def reset(self): self.h = 0"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"m = len(seqs)//bs\n",
|
|
"m,bs,len(seqs)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def group_chunks(ds, bs):\n",
|
|
" m = len(ds) // bs\n",
|
|
" new_ds = L()\n",
|
|
" for i in range(m): new_ds += L(ds[i + m*j] for j in range(bs))\n",
|
|
" return new_ds"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"cut = int(len(seqs) * 0.8)\n",
|
|
"dls = DataLoaders.from_dsets(\n",
|
|
" group_chunks(seqs[:cut], bs), \n",
|
|
" group_chunks(seqs[cut:], bs), \n",
|
|
" bs=bs, drop_last=True, shuffle=False)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = Learner(dls, LMModel3(len(vocab), 64), loss_func=F.cross_entropy,\n",
|
|
" metrics=accuracy, cbs=ModelResetter)\n",
|
|
"learn.fit_one_cycle(10, 3e-3)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Creating More Signal"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"sl = 16\n",
|
|
"seqs = L((tensor(nums[i:i+sl]), tensor(nums[i+1:i+sl+1]))\n",
|
|
" for i in range(0,len(nums)-sl-1,sl))\n",
|
|
"cut = int(len(seqs) * 0.8)\n",
|
|
"dls = DataLoaders.from_dsets(group_chunks(seqs[:cut], bs),\n",
|
|
" group_chunks(seqs[cut:], bs),\n",
|
|
" bs=bs, drop_last=True, shuffle=False)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"[L(vocab[o] for o in s) for s in seqs[0]]"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LMModel4(Module):\n",
|
|
" def __init__(self, vocab_sz, n_hidden):\n",
|
|
" self.i_h = nn.Embedding(vocab_sz, n_hidden) \n",
|
|
" self.h_h = nn.Linear(n_hidden, n_hidden) \n",
|
|
" self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
|
|
" self.h = 0\n",
|
|
" \n",
|
|
" def forward(self, x):\n",
|
|
" outs = []\n",
|
|
" for i in range(sl):\n",
|
|
" self.h = self.h + self.i_h(x[:,i])\n",
|
|
" self.h = F.relu(self.h_h(self.h))\n",
|
|
" outs.append(self.h_o(self.h))\n",
|
|
" self.h = self.h.detach()\n",
|
|
" return torch.stack(outs, dim=1)\n",
|
|
" \n",
|
|
" def reset(self): self.h = 0"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def loss_func(inp, targ):\n",
|
|
" return F.cross_entropy(inp.view(-1, len(vocab)), targ.view(-1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = Learner(dls, LMModel4(len(vocab), 64), loss_func=loss_func,\n",
|
|
" metrics=accuracy, cbs=ModelResetter)\n",
|
|
"learn.fit_one_cycle(15, 3e-3)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Multilayer RNNs"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### The Model"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LMModel5(Module):\n",
|
|
" def __init__(self, vocab_sz, n_hidden, n_layers):\n",
|
|
" self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
|
|
" self.rnn = nn.RNN(n_hidden, n_hidden, n_layers, batch_first=True)\n",
|
|
" self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
|
|
" self.h = torch.zeros(n_layers, bs, n_hidden)\n",
|
|
" \n",
|
|
" def forward(self, x):\n",
|
|
" res,h = self.rnn(self.i_h(x), self.h)\n",
|
|
" self.h = h.detach()\n",
|
|
" return self.h_o(res)\n",
|
|
" \n",
|
|
" def reset(self): self.h.zero_()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = Learner(dls, LMModel5(len(vocab), 64, 2), \n",
|
|
" loss_func=CrossEntropyLossFlat(), \n",
|
|
" metrics=accuracy, cbs=ModelResetter)\n",
|
|
"learn.fit_one_cycle(15, 3e-3)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Exploding or Disappearing Activations"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## LSTM"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Building an LSTM from Scratch"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LSTMCell(Module):\n",
|
|
" def __init__(self, ni, nh):\n",
|
|
" self.forget_gate = nn.Linear(ni + nh, nh)\n",
|
|
" self.input_gate = nn.Linear(ni + nh, nh)\n",
|
|
" self.cell_gate = nn.Linear(ni + nh, nh)\n",
|
|
" self.output_gate = nn.Linear(ni + nh, nh)\n",
|
|
"\n",
|
|
" def forward(self, input, state):\n",
|
|
" h,c = state\n",
|
|
" h = torch.cat([h, input], dim=1)\n",
|
|
" forget = torch.sigmoid(self.forget_gate(h))\n",
|
|
" c = c * forget\n",
|
|
" inp = torch.sigmoid(self.input_gate(h))\n",
|
|
" cell = torch.tanh(self.cell_gate(h))\n",
|
|
" c = c + inp * cell\n",
|
|
" out = torch.sigmoid(self.output_gate(h))\n",
|
|
" h = out * torch.tanh(c)\n",
|
|
" return h, (h,c)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LSTMCell(Module):\n",
|
|
" def __init__(self, ni, nh):\n",
|
|
" self.ih = nn.Linear(ni,4*nh)\n",
|
|
" self.hh = nn.Linear(nh,4*nh)\n",
|
|
"\n",
|
|
" def forward(self, input, state):\n",
|
|
" h,c = state\n",
|
|
" # One big multiplication for all the gates is better than 4 smaller ones\n",
|
|
" gates = (self.ih(input) + self.hh(h)).chunk(4, 1)\n",
|
|
" ingate,forgetgate,outgate = map(torch.sigmoid, gates[:3])\n",
|
|
" cellgate = gates[3].tanh()\n",
|
|
"\n",
|
|
" c = (forgetgate*c) + (ingate*cellgate)\n",
|
|
" h = outgate * c.tanh()\n",
|
|
" return h, (h,c)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"t = torch.arange(0,10); t"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"t.chunk(2)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Training a Language Model Using LSTMs"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LMModel6(Module):\n",
|
|
" def __init__(self, vocab_sz, n_hidden, n_layers):\n",
|
|
" self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
|
|
" self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)\n",
|
|
" self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
|
|
" self.h = [torch.zeros(n_layers, bs, n_hidden) for _ in range(2)]\n",
|
|
" \n",
|
|
" def forward(self, x):\n",
|
|
" res,h = self.rnn(self.i_h(x), self.h)\n",
|
|
" self.h = [h_.detach() for h_ in h]\n",
|
|
" return self.h_o(res)\n",
|
|
" \n",
|
|
" def reset(self): \n",
|
|
" for h in self.h: h.zero_()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = Learner(dls, LMModel6(len(vocab), 64, 2), \n",
|
|
" loss_func=CrossEntropyLossFlat(), \n",
|
|
" metrics=accuracy, cbs=ModelResetter)\n",
|
|
"learn.fit_one_cycle(15, 1e-2)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Regularizing an LSTM"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Dropout"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class Dropout(Module):\n",
|
|
" def __init__(self, p): self.p = p\n",
|
|
" def forward(self, x):\n",
|
|
" if not self.training: return x\n",
|
|
" mask = x.new(*x.shape).bernoulli_(1-p)\n",
|
|
" return x * mask.div_(1-p)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Activation Regularization and Temporal Activation Regularization"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Training a Weight-Tied Regularized LSTM"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class LMModel7(Module):\n",
|
|
" def __init__(self, vocab_sz, n_hidden, n_layers, p):\n",
|
|
" self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
|
|
" self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)\n",
|
|
" self.drop = nn.Dropout(p)\n",
|
|
" self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
|
|
" self.h_o.weight = self.i_h.weight\n",
|
|
" self.h = [torch.zeros(n_layers, bs, n_hidden) for _ in range(2)]\n",
|
|
" \n",
|
|
" def forward(self, x):\n",
|
|
" raw,h = self.rnn(self.i_h(x), self.h)\n",
|
|
" out = self.drop(raw)\n",
|
|
" self.h = [h_.detach() for h_ in h]\n",
|
|
" return self.h_o(out),raw,out\n",
|
|
" \n",
|
|
" def reset(self): \n",
|
|
" for h in self.h: h.zero_()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = Learner(dls, LMModel7(len(vocab), 64, 2, 0.5),\n",
|
|
" loss_func=CrossEntropyLossFlat(), metrics=accuracy,\n",
|
|
" cbs=[ModelResetter, RNNRegularizer(alpha=2, beta=1)])"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn = TextLearner(dls, LMModel7(len(vocab), 64, 2, 0.4),\n",
|
|
" loss_func=CrossEntropyLossFlat(), metrics=accuracy)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"learn.fit_one_cycle(15, 1e-2, wd=0.1)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Conclusion"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Questionnaire"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"1. If the dataset for your project is so big and complicated that working with it takes a significant amount of time, what should you do?\n",
|
|
"1. Why do we concatenate the documents in our dataset before creating a language model?\n",
|
|
"1. To use a standard fully connected network to predict the fourth word given the previous three words, what two tweaks do we need to make to ou model?\n",
|
|
"1. How can we share a weight matrix across multiple layers in PyTorch?\n",
|
|
"1. Write a module that predicts the third word given the previous two words of a sentence, without peeking.\n",
|
|
"1. What is a recurrent neural network?\n",
|
|
"1. What is \"hidden state\"?\n",
|
|
"1. What is the equivalent of hidden state in ` LMModel1`?\n",
|
|
"1. To maintain the state in an RNN, why is it important to pass the text to the model in order?\n",
|
|
"1. What is an \"unrolled\" representation of an RNN?\n",
|
|
"1. Why can maintaining the hidden state in an RNN lead to memory and performance problems? How do we fix this problem?\n",
|
|
"1. What is \"BPTT\"?\n",
|
|
"1. Write code to print out the first few batches of the validation set, including converting the token IDs back into English strings, as we showed for batches of IMDb data in <<chapter_nlp>>.\n",
|
|
"1. What does the `ModelResetter` callback do? Why do we need it?\n",
|
|
"1. What are the downsides of predicting just one output word for each three input words?\n",
|
|
"1. Why do we need a custom loss function for `LMModel4`?\n",
|
|
"1. Why is the training of `LMModel4` unstable?\n",
|
|
"1. In the unrolled representation, we can see that a recurrent neural network actually has many layers. So why do we need to stack RNNs to get better results?\n",
|
|
"1. Draw a representation of a stacked (multilayer) RNN.\n",
|
|
"1. Why should we get better results in an RNN if we call `detach` less often? Why might this not happen in practice with a simple RNN?\n",
|
|
"1. Why can a deep network result in very large or very small activations? Why does this matter?\n",
|
|
"1. In a computer's floating-point representation of numbers, which numbers are the most precise?\n",
|
|
"1. Why do vanishing gradients prevent training?\n",
|
|
"1. Why does it help to have two hidden states in the LSTM architecture? What is the purpose of each one?\n",
|
|
"1. What are these two states called in an LSTM?\n",
|
|
"1. What is tanh, and how is it related to sigmoid?\n",
|
|
"1. What is the purpose of this code in `LSTMCell`: `h = torch.stack([h, input], dim=1)`\n",
|
|
"1. What does `chunk` do in PyTorch?\n",
|
|
"1. Study the refactored version of `LSTMCell` carefully to ensure you understand how and why it does the same thing as the non-refactored version.\n",
|
|
"1. Why can we use a higher learning rate for `LMModel6`?\n",
|
|
"1. What are the three regularization techniques used in an AWD-LSTM model?\n",
|
|
"1. What is \"dropout\"?\n",
|
|
"1. Why do we scale the weights with dropout? Is this applied during training, inference, or both?\n",
|
|
"1. What is the purpose of this line from `Dropout`: `if not self.training: return x`\n",
|
|
"1. Experiment with `bernoulli_` to understand how it works.\n",
|
|
"1. How do you set your model in training mode in PyTorch? In evaluation mode?\n",
|
|
"1. Write the equation for activation regularization (in math or code, as you prefer). How is it different from weight decay?\n",
|
|
"1. Write the equation for temporal activation regularization (in math or code, as you prefer). Why wouldn't we use this for computer vision problems?\n",
|
|
"1. What is \"weight tying\" in a language model?"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Further Research"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"1. In ` LMModel2`, why can `forward` start with `h=0`? Why don't we need to say `h=torch.zeros(...)`?\n",
|
|
"1. Write the code for an LSTM from scratch (you may refer to <<lstm>>).\n",
|
|
"1. Search the internet for the GRU architecture and implement it from scratch, and try training a model. See if you can get results similar to those we saw in this chapter. Compare you results to the results of PyTorch's built in `GRU` module.\n",
|
|
"1. Take a look at the source code for AWD-LSTM in fastai, and try to map each of the lines of code to the concepts shown in this chapter."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
}
|
|
],
|
|
"metadata": {
|
|
"jupytext": {
|
|
"split_at_heading": true
|
|
},
|
|
"kernelspec": {
|
|
"display_name": "Python 3",
|
|
"language": "python",
|
|
"name": "python3"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2
|
|
}
|