{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Basic training functionality"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [],
"source": [
"from fastai.basic_train import *\n",
"from fastai.gen_doc.nbdoc import *\n",
"from fastai.vision import *\n",
"from fastai.distributed import *"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[`basic_train`](/basic_train.html#basic_train) wraps together the data (in a [`DataBunch`](/basic_data.html#DataBunch) object) with a PyTorch model to define a [`Learner`](/basic_train.html#Learner) object. Here the basic training loop is defined for the [`fit`](/basic_train.html#fit) method. The [`Learner`](/basic_train.html#Learner) object is the entry point of most of the [`Callback`](/callback.html#Callback) objects that will customize this training loop in different ways. Some of the most commonly used customizations are available through the [`train`](/train.html#train) module, notably:\n",
"\n",
" - [`Learner.lr_find`](/train.html#lr_find) will launch an LR range test that will help you select a good learning rate.\n",
" - [`Learner.fit_one_cycle`](/train.html#fit_one_cycle) will launch a training using the 1cycle policy to help you train your model faster.\n",
" - [`Learner.to_fp16`](/train.html#to_fp16) will convert your model to half precision and help you launch a training in mixed precision."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> Learner(**`data`**:[`DataBunch`](/basic_data.html#DataBunch), **`model`**:[`Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module), **`opt_func`**:`Callable`=***`'Adam'`***, **`loss_func`**:`Callable`=***`None`***, **`metrics`**:`Collection`\\[`Callable`\\]=***`None`***, **`true_wd`**:`bool`=***`True`***, **`bn_wd`**:`bool`=***`True`***, **`wd`**:`Floats`=***`0.01`***, **`train_bn`**:`bool`=***`True`***, **`path`**:`str`=***`None`***, **`model_dir`**:`str`=***`'models'`***, **`callback_fns`**:`Collection`\\[`Callable`\\]=***`None`***, **`callbacks`**:`Collection`\\[[`Callback`](/callback.html#Callback)\\]=***``***, **`layer_groups`**:`ModuleList`=***`None`***, **`add_time`**:`bool`=***`True`***)\n",
"\n",
"Trainer for `model` using `data` to minimize `loss_func` with optimizer `opt_func`. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner, title_level=2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The main purpose of [`Learner`](/basic_train.html#Learner) is to train `model` using [`Learner.fit`](/basic_train.html#Learner.fit). After every epoch, all *metrics* will be printed and also made available to callbacks.\n",
"\n",
"The default weight decay will be `wd`, which will be handled using the method from [Fixing Weight Decay Regularization in Adam](https://arxiv.org/abs/1711.05101) if `true_wd` is set (otherwise it's L2 regularization). If `bn_wd` is `False`, then weight decay will be removed from batchnorm layers, as recommended in [Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour](https://arxiv.org/abs/1706.02677). If `train_bn`, batchnorm layer learnable params are trained even for frozen layer groups.\n",
"\n",
"To use [discriminative layer training](#Discriminative-layer-training), pass a list of [`nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) as `layer_groups`; each [`nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) will be used to customize the optimization of the corresponding layer group.\n",
"\n",
"If `path` is provided, all the model files created will be saved in `path`/`model_dir`; if not, then they will be saved in `data.path`/`model_dir`.\n",
"\n",
"You can pass a list of [`callback`](/callback.html#callback)s that you have already created, or (more commonly) simply pass a list of callback functions to `callback_fns` and each function will be called (passing `self`) on object initialization, with the results stored as callback objects. For a walk-through, see the [training overview](/training.html) page. You may also want to use an [application](applications.html) specific model. For example, if you are dealing with a vision dataset, here the MNIST, you might want to use the [`create_cnn`](/vision.learner.html#create_cnn) method:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": false
},
"outputs": [],
"source": [
"path = untar_data(URLs.MNIST_SAMPLE)\n",
"data = ImageDataBunch.from_folder(path)\n",
"learn = create_cnn(data, models.resnet18, metrics=accuracy)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Model fitting methods"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> fit(**`epochs`**:`int`, **`lr`**:`Union`\\[`float`, `Collection`\\[`float`\\], `slice`\\]=***`slice(None, 0.003, None)`***, **`wd`**:`Floats`=***`None`***, **`callbacks`**:`Collection`\\[[`Callback`](/callback.html#Callback)\\]=***`None`***)\n",
"\n",
"Fit the model on this learner with `lr` learning rate, `wd` weight decay for `epochs` with `callbacks`. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner.fit)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Uses [discriminative layer training](#Discriminative-layer-training) if multiple learning rates or weight decay values are passed. To control training behaviour, use the [`callback`](/callback.html#callback) system or one or more of the pre-defined [`callbacks`](/callbacks.html#callbacks)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"Total time: 00:04
\n",
"\n",
"> predict(**`item`**:[`ItemBase`](/core.html#ItemBase), **\\*\\*`kwargs`**)\n",
"\n",
"Return predicted class, label and probabilities for `item`. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner.predict)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`predict` can be used to get a single prediction from the trained learner on one specific piece of data you are interested in."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Image (3, 28, 28), Category 3)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"learn.data.train_ds[0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Each element of the dataset is a tuple, where the first element is the data itself, while the second element is the target label. So to get the data, we need to index one more time."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"data = learn.data.train_ds[0][0]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/jpeg": "/9j/4AAQSkZJRgABAQEAZABkAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYGBwkIBgcJBwYGCAsICQoKCgoKBggLDAsKDAkKCgr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wAARCAAcABwDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD+f+vc/wDgnb+xNcft+ftLWPwEk+NfhT4eaaNNuNU17xf4xv1gtNPsLcKZnBYqHkww2oWQHnLKATXhlfoV+z5/wSO/Ya8EfCzwl+0p/wAFKv8Agq58NfB/hvxHZWup23w9+F923iPxPPayosnkzJAjCxl2kgny51jJAY7soADQ+IP/AAQ5/Zii+FPx0+K/7PP/AAVn8DfE1Pgx4Wm8Qy6b4X8FX0sd1aCZ4oopr/zPskE8jKqokckxYlmA2ruP5y1+oP8AwWN/aB+Hvh/9i/4cfBL/AIJXPpmhfseeJNYv1kbSre+t9Y8R+KbIWzXg15rxVlnZFmtpYQpaIo6DgwJHD+X1AH2L/wAE3/2W/wDgkp+0B8OtZ1D9vn/gopr3wc8WWmtSR6Votn4Gnv7W604QwFbg3McbgSNK8yeUQCFhDc7uPr7w98Bv+DQj9mayfWPiR+1v8WPjtqCWCv8A2Lpmm39nBPJkAiPyLW02NlSQslzgK/JJwa/HyigD6/8A+CnP/BUXRP20NB8Lfs1fs2/s9aH8JPgH8Nbm4f4e+ArCCOe8WWYnzr27u2BkeaUksyByoJ+ZpWHmn5AoooA//9k=\n",
"image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAYAAAByDd+UAAAABHNCSVQICAgIfAhkiAAAAlhJREFUSIntVj1rKlEQPUZDUoiF0SR2FomWIRGRRLCwDhK2EdE/YJE/INhaWiVNSCWI1TZRi4BVTBMswoJFwEZsJGyz2gjKvec1j+Vp1u/3AoE3MLB775w5d2bP7qwNAPGNtvOdZD+P8ODgABcXF2thHJuSxWIxFAoFhEIh3N3dQdd17O3tIZVKAQBUVUU+n7fEcl2/vb3lYDCgEMJ0KeXU/fPzsyV2owrPzs7gdDoBAJ1OB09PT9B1Haqq4vLyEqVSCZ+fn5bYjQhfX18xGo1QqVTQarUwmUwAAPv7+8hkMgCAdrs9F792S63c5XKx2+1SSsn393ceHR3Ni92OyOFw0OPxsNvtUghBTdPo8/kWYTYn8/l8LBaLpmg0TePx8fEy3GZEmUyGhmGYqnx4eFhW2foqTafTUBQFV1dXODw8nNr7+PhAv99fKc9SMdzf31NKaTpJ9no9NptN1mo1qqpKkszlcqt0aHFAJBLheDymEILD4ZDNZpPX19f0er1TcalUisPhkCcnJ9s/w3g8zkQisTBZNBqlEIKJROLvi8bK397eKIRgNpul3W6fG7f1eAqHw1BVFeFwGABwfn6OnZ3FaVeuwu/3MxqN8vHxkS8vL+aXRUrJwWDAbDa7NIft9wUA4ObmBoFA4MuJFEWBy+WC1+uF2+2GzWYDacJgGAaSySQajcZKXTHZZ0eM1diZXSuXy3S73St3aerFr1arCAaDOD09tTxZp9OBEAK6rqNer6PRaEDTNEgpV6oMAKZaCgC7u7umAGbtz1G0qX0h/Nf2s/7a/hNa2S/tek2pzxDJXQAAAABJRU5ErkJggg==\n",
"text/plain": [
"Image (3, 28, 28)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Category 3, tensor(0), tensor([9.9979e-01, 2.0649e-04]))"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pred = learn.predict(data)\n",
"pred"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The first two elements of the tuple are, respectively, the predicted class and label. Label here is essentially an internal representation of each class, since class name is a string and cannot be used in computation. To check what each label corresponds to, run:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['3', '7']"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"learn.data.classes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So category 0 is 3 while category 1 is 7."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"probs = pred[2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The last element in the tuple is the predicted probabilities. For a categorization dataset, the number of probabilities returned is the same as the number of classes; `probs[i]` is the probability that the `item` belongs to `learn.data.classes[i]`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/jpeg": "/9j/4AAQSkZJRgABAQEAZABkAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYGBwkIBgcJBwYGCAsICQoKCgoKBggLDAsKDAkKCgr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wAARCAAcABwDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD+f+vSvC/7Gf7YHjjwBF8V/BX7KXxK1jwtO4SDxLpfgXULjT5GIJAW4jhMZOFY4Dfwn0rz7RdQt9J1m01S70e21GK2uY5ZdPvTIIblVYExSeU6PsYDadjK2CcMDgj9d9T+GP8Awd8+HfHui+J/DV58Wre21sQPoFr4N8VabN4asraSONYUS3tZ3sLS2SN0A3qkaBS2flZgAfkHdWtzY3Mlle28kM0MhSaGVCrIwOCpB5BB4INR19xf8HB/7Q/gv9ob/goEkvhrxF4f8S6x4L+HWg+FfHnj7wysQtPF/iK0tydQ1NTCqo376U24KjaVtV2/Livh2gAr7N/4IZftP/tK/Cz/AIKW/BX4bfC/x1rdx4f8Z/ELTPDXi3wi081zp2o6LqFzFbX6TWmTG6rbs8m4r+7MSyfwV8ZV7r+zr/wUA+KP7Knhu8T4HfDbwJo3jG40S60iz+KMegyHxDptncpLHOtrL532eGV4ppIjciA3ARsCUYGADiv2svBHgX4Z/tT/ABL+HHwvvRc+GfD/AMQNZ03w7crdLOJbGC+mit38xflkzGiHcOGzkda8/pWZnYu7EknJJPWkoA//2Q==\n",
"image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAYAAAByDd+UAAAABHNCSVQICAgIfAhkiAAAAdJJREFUSIntVbGq4kAUvW9ZUZCQIqjBzlohhWAsLEQLwdZUNn6AkEbQD7AJthZWFnYWWgj+gKRIpRZiK1hpIYoY1BSZ86q12SUm8T2L5V04zcyZOffMvZf5ICLQG+PXO8V+BH8EfcVvN6RCoUC1Wo1yuRwlEgmaTqd0Op1ot9vRZDIhwzA8icIJqqrCsizYtg3GGGzbfoAxBsuysNlsIMuy4z1/8EEOg8/zPK3XaxqPx9Tv9x/roVCIKpUKxeNxKpVKJAgCzedzymQyrznUNA35fN4xY0mSHo7dOHz6pM8gSRIYY9B13RX/5S4tFosEgDqdjuszjhlxHAdRFBEMBv/a43ke+/0e2+0WHMe5cvh0LGazGUmSRIvFgo7HI41GI7rf70REpGkaRSIRqtfrdLlcvsZht9sFY+yfOBwOUBTFa92dCYFAALFYDNlsFo1GA+12G6ZpwrZt9Ho9P43mvTNlWcb1esX5fIYgCN8vSERoNptgjKFarb5HkIjAGMNyufR05uU5BOCJ////h0Q+69dqtQDgPU0TjUZxu91gGAbC4fDXCyaTSaiqClEUUS6Xoes6TNNEOp328zruiIqiYDAYYLVaYTgcIpVK+SqF44//HfEJXkMk1eKRk3QAAAAASUVORK5CYII=\n",
"text/plain": [
"Image (3, 28, 28)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"learn.data.valid_ds[0][0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You could always check yourself if the probabilities given make sense."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> show_results(**`ds_type`**=***``***, **`rows`**:`int`=***`5`***, **\\*\\*`kwargs`**)\n",
"\n",
"Show `rows` result of predictions on `ds_type` dataset. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner.show_results)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that the text number on the top is the ground truth, or the target label, the one in the middle is the prediction, while the image number on the bottom is the image data itself."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
\n",
"\n",
"> TTA(**`learn`**:[`Learner`](/basic_train.html#Learner), **`beta`**:`float`=***`0.4`***, **`scale`**:`float`=***`1.35`***, **`ds_type`**:[`DatasetType`](/basic_data.html#DatasetType)=***``***, **`with_loss`**:`bool`=***`False`***) → `Tensors`\n",
"\n",
"Applies TTA to predict on `ds_type` dataset. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner.TTA, full_name = 'TTA')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Applies Test Time Augmentation to `learn` on the dataset `ds_type`. We take the average of our regular predictions (with a weight `beta`) with the average of predictions obtained through augmented versions of the training set (with a weight `1-beta`). The transforms decided for the training set are applied with a few changes `scale` controls the scale for zoom (which isn't random), the cropping isn't random but we make sure to get the four corners of the image. Flipping isn't random but applied once on each of those corner images (so that makes 8 augmented versions total)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Gradient clipping"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> distributed(**`learn`**:[`Learner`](/basic_train.html#Learner), **`cuda_id`**:`int`, **`cache_dir`**:`PathOrStr`=***`'tmp'`***)\n",
"\n",
"Put `learn` on distributed training with `cuda_id`. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner.distributed, full_name='distributed')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Discriminative layer training"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When fitting a model you can pass a list of learning rates (and/or weight decay amounts), which will apply a different rate to each *layer group* (i.e. the parameters of each module in `self.layer_groups`). See the [Universal Language Model Fine-tuning for Text Classification](https://arxiv.org/abs/1801.06146) paper for details and experimental results in NLP (we also frequently use them successfully in computer vision, but have not published a paper on this topic yet). When working with a [`Learner`](/basic_train.html#Learner) on which you've called `split`, you can set hyperparameters in four ways:\n",
"\n",
"1. `param = [val1, val2 ..., valn]` (n = number of layer groups)\n",
"2. `param = val`\n",
"3. `param = slice(start,end)`\n",
"4. `param = slice(end)`\n",
"\n",
"If we chose to set it in way 1, we must specify a number of values exactly equal to the number of layer groups. If we chose to set it in way 2, the chosen value will be repeated for all layer groups. See [`Learner.lr_range`](/basic_train.html#Learner.lr_range) for an explanation of the `slice` syntax).\n",
"\n",
"Here's an example of how to use discriminative learning rates (note that you don't actually need to manually call [`Learner.split`](/basic_train.html#Learner.split) in this case, since fastai uses this exact function as the default split for `resnet18`; this is just to show how to customize it):"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# creates 3 layer groups\n",
"learn.split(lambda m: (m[0][6], m[1]))\n",
"# only randomly initialized head now trainable\n",
"learn.freeze()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"Total time: 00:04
\n",
"\n",
"> lr_range(**`lr`**:`Union`\\[`float`, `slice`\\]) → `ndarray`\n",
"\n",
"Build differential learning rates from `lr`. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner.lr_range)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Rather than manually setting an LR for every group, it's often easier to use [`Learner.lr_range`](/basic_train.html#Learner.lr_range). This is a convenience method that returns one learning rate for each layer group. If you pass `slice(start,end)` then the first group's learning rate is `start`, the last is `end`, and the remaining are evenly geometrically spaced.\n",
"\n",
"If you pass just `slice(end)` then the last group's learning rate is `end`, and all the other groups are `end/10`. For instance (for our learner that has 3 layer groups):"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([1.e-05, 1.e-04, 1.e-03]), array([0.0001, 0.0001, 0.001 ]))"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"learn.lr_range(slice(1e-5,1e-3)), learn.lr_range(slice(1e-3))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> split(**`split_on`**:`SplitFuncOrIdxList`)\n",
"\n",
"Split the model at `split_on`. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Learner.split)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A convenience method that sets `layer_groups` based on the result of [`split_model`](/torch_core.html#split_model). If `split_on` is a function, it calls that function and passes the result to [`split_model`](/torch_core.html#split_model) (see above for example)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Saving and loading models"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Simply call [`Learner.save`](/basic_train.html#Learner.save) and [`Learner.load`](/basic_train.html#Learner.load) to save and load models. Only the parameters are saved, not the actual architecture (so you'll need to create your model in the same way before loading weights back in). Models are saved to the `path`/`model_dir` directory."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> load_learner(**`path`**:`PathOrStr`, **`fname`**:`PathOrStr`=***`'export.pkl'`***, **`test`**:[`ItemList`](/data_block.html#ItemList)=***`None`***)\n",
"\n",
"Load a [`Learner`](/basic_train.html#Learner) object saved with `export_state` in `path/fn` with empty data, optionally add `test` and load on `cpu`. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(load_learner)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"learn = load_learner(path)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"learn = load_learner(path, fname='trained_model.pkl')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"WARNING: If you used any customized classes when creating your learner, you must first define these classes first before executing [`load_learner`](/basic_train.html#load_learner).\n",
"\n",
"You can find more information and multiple examples in [this tutorial](/tutorial.inference.html)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Freeing memory\n",
"\n",
"If you want to be able to do more without needing to restart your notebook, the following methods are designed to free memory when it's no longer needed. \n",
"\n",
"Refer to [this tutorial](/tutorial.resources.html) to learn how and when to use these methods."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> Recorder(**`learn`**:[`Learner`](/basic_train.html#Learner), **`add_time`**:`bool`=***`True`***) :: [`LearnerCallback`](/basic_train.html#LearnerCallback)\n",
"\n",
"A [`LearnerCallback`](/basic_train.html#LearnerCallback) that records epoch, loss, opt and metric data during training. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Recorder, title_level=2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A [`Learner`](/basic_train.html#Learner) creates a [`Recorder`](/basic_train.html#Recorder) object automatically - you do not need to explicitly pass it to `callback_fns` - because other callbacks rely on it being available. It stores the smoothed loss, hyperparameter values, and metrics for each batch, and provides plotting methods for each. Note that [`Learner`](/basic_train.html#Learner) automatically sets an attribute with the snake-cased name of each callback, so you can access this through `Learner.recorder`, as shown below."
]
},
{
"cell_type": "markdown",
"metadata": {
"hide_input": true
},
"source": [
"### Plotting methods"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> on_train_begin(**`pbar`**:`PBar`, **`metrics_names`**:`StrList`, **\\*\\*`kwargs`**:`Any`)\n",
"\n",
"Initialize recording status at beginning of training. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Recorder.on_train_begin)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Inner functions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The following functions are used along the way by the [`Recorder`](/basic_train.html#Recorder) or can be called by other callbacks."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> format_stats(**`stats`**:`MetricsList`)\n",
"\n",
"Format stats before printing. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(Recorder.format_stats)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Module functions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Generally you'll want to use a [`Learner`](/basic_train.html#Learner) to train your model, since they provide a lot of functionality and make things easier. However, for ultimate flexibility, you can call the same underlying functions that [`Learner`](/basic_train.html#Learner) calls behind the scenes:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"
\n",
"\n",
"> loss_batch(**`model`**:[`Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module), **`xb`**:`Tensor`, **`yb`**:`Tensor`, **`loss_func`**:`OptLossFunc`=***`None`***, **`opt`**:`OptOptimizer`=***`None`***, **`cb_handler`**:`Optional`\\[[`CallbackHandler`](/callback.html#CallbackHandler)\\]=***`None`***) → `Tuple`\\[`Union`\\[`Tensor`, `int`, `float`, `str`\\]\\]\n",
"\n",
"Calculate loss and metrics for a batch, call out to callbacks as necessary. \n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"show_doc(loss_batch)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You won't generally need to call this yourself - it's what [`fit`](/basic_train.html#fit) and [`validate`](/basic_train.html#validate) call for each batch. It only does a backward pass if you set `opt`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Other classes"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"text/markdown": [
"