{ "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": [ "

class Learner[source][test]

\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`**:`PathOrStr`=***`'models'`***, **`callback_fns`**:`Collection`\\[`Callable`\\]=***`None`***, **`callbacks`**:`Collection`\\[[`Callback`](/callback.html#Callback)\\]=***``***, **`layer_groups`**:`ModuleList`=***`None`***, **`add_time`**:`bool`=***`True`***)\n", "\n", "
×

Tests found for Learner:

Some other tests where Learner is used:

  • pytest -sv tests/test_basic_train.py::test_memory [source]

To run tests please refer to this guide.

\n", "\n", "Trainer for `model` using `data` to minimize `loss_func` with optimizer `opt_func`. " ], "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 [`cnn_learner`](/vision.learner.html#cnn_learner) 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 = cnn_learner(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": [ "

lr_find[source][test]

\n", "\n", "> lr_find(**`learn`**:[`Learner`](/basic_train.html#Learner), **`start_lr`**:`Floats`=***`1e-07`***, **`end_lr`**:`Floats`=***`10`***, **`num_it`**:`int`=***`100`***, **`stop_div`**:`bool`=***`True`***, **`wd`**:`float`=***`None`***)\n", "\n", "
×

Tests found for lr_find:

  • pytest -sv tests/test_train.py::test_lr_find [source]
  • pytest -sv tests/test_vision_train.py::test_lrfind [source]

To run tests please refer to this guide.

\n", "\n", "Explore lr from `start_lr` to `end_lr` over `num_it` iterations in `learn`. If `stop_div`, stops when loss diverges. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.lr_find)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Runs the learning rate finder defined in [`LRFinder`](/callbacks.lr_finder.html#LRFinder), as discussed in [Cyclical Learning Rates for Training Neural Networks](https://arxiv.org/abs/1506.01186). " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ] } ], "source": [ "learn.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

fit[source][test]

\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", "
×

Tests found for fit:

  • pytest -sv tests/test_train.py::test_fit [source]

Some other tests where fit is used:

  • pytest -sv tests/test_basic_train.py::test_destroy [source]

To run tests please refer to this guide.

\n", "\n", "Fit the model on this learner with `lr` learning rate, `wd` weight decay for `epochs` with `callbacks`. " ], "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": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracytime
10.1353430.0831900.97203100:05
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn.fit(1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

fit_one_cycle[source][test]

\n", "\n", "> fit_one_cycle(**`learn`**:[`Learner`](/basic_train.html#Learner), **`cyc_len`**:`int`, **`max_lr`**:`Union`\\[`float`, `Collection`\\[`float`\\], `slice`\\]=***`slice(None, 0.003, None)`***, **`moms`**:`Point`=***`(0.95, 0.85)`***, **`div_factor`**:`float`=***`25.0`***, **`pct_start`**:`float`=***`0.3`***, **`final_div`**:`float`=***`None`***, **`wd`**:`float`=***`None`***, **`callbacks`**:`Optional`\\[`Collection`\\[[`Callback`](/callback.html#Callback)\\]\\]=***`None`***, **`tot_epochs`**:`int`=***`None`***, **`start_epoch`**:`int`=***`None`***)\n", "\n", "
×

Tests found for fit_one_cycle:

  • pytest -sv tests/test_train.py::test_fit_one_cycle [source]

Some other tests where fit_one_cycle is used:

  • pytest -sv tests/test_tabular_train.py::test_empty_cont [source]
  • pytest -sv tests/test_text_train.py::test_qrnn_works_if_split_fn_provided [source]
  • pytest -sv tests/test_text_train.py::test_qrnn_works_with_no_split [source]

To run tests please refer to this guide.

\n", "\n", "Fit a model following the 1cycle policy. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.fit_one_cycle)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use cycle length `cyc_len`, a per cycle maximal learning rate `max_lr`, momentum `moms`, division factor `div_factor`, weight decay `wd`, and optional callbacks [`callbacks`](/callbacks.html#callbacks). Uses the [`OneCycleScheduler`](/callbacks.one_cycle.html#OneCycleScheduler) callback. Please refer to [What is 1-cycle](/callbacks.one_cycle.html#What-is-1cycle?) for a conceptual background of 1-cycle training policy and more technical details on what do the method's arguments do." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracytime
10.0758380.0618690.97988200:05
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn.fit_one_cycle(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### See results" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

predict[source][test]

\n", "\n", "> predict(**`item`**:[`ItemBase`](/core.html#ItemBase), **\\*\\*`kwargs`**)\n", "\n", "
×

Tests found for predict:

  • pytest -sv tests/test_vision_train.py::test_models_meta [source]
  • pytest -sv tests/test_vision_train.py::test_preds [source]

To run tests please refer to this guide.

\n", "\n", "Return predicted class, label and probabilities for `item`. " ], "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), )" ] }, "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+vtr4ff8G5v/BaH4o/D/Q/ih4L/AGH9Tn0bxHDHNpM114t0W1mkikyUkeCe9SaFGA3BpEUbSrZwwJ+Ja/fD/g13+Dtzq/w6l/b6/ae/4Kna9o+gaP4jTSNL+GUnxZezs3a32LGNVWeYfuzJND5VsuFdSu8usnl0AfjV+2R+wp+1l/wT9+J8Pwc/a/8Ag1feDPEFzp6X1nbXF5bXcN1buSBJFcWsssEoBBVtjkqwKtg8V5JX6a/8HYmq/tMt/wAFVb7w5+0L8RtB1nT7bwta3XgDTPDaSxwaPo000yxwTRykkXbNC0krbmDl1ZdqFY0/MqgAr9b/APgkv+xl8Hf+Cb/7Jeuf8Fwv+CjHw1g1KbRV8v4BfC3Xo2t7nV9XWVEj1FoZk5VZGTy5MOI1WSbaWWGvyQr2f9rD/goV+2T+3DpPhHw/+1H8cb7xTp3gPR10zwlpp0+0s7bT7dVVRiK0iiR5CqqpmcNIyqoLEAAAGX+2p+2F8Zf29f2mPFP7Vfx71G1uPEvim8WS4jsbcRW9rDGixQW0S8kRxRIkalizEICzMSSfLKKKAP/Z\n", "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAYAAAByDd+UAAAABHNCSVQICAgIfAhkiAAAAbBJREFUSInt1rGKwkAQBuBfuUJMRK0FQbYxoGBpLQimDAg+goVPIFrY29iYykoQfAEraxFDhBRW2lmJVqaV7Fxl0BPNrp42dwtTJOzOl1lmk4QAED44wp/E/sE/AubzebRaLXDOwTkHEWGxWMCyLP8e5xyNRkMYpUfRbrfJ87zAOB6PVKvVHuYCQF9BT2PbNvr9vn9dKpWgadrNPFVVwRh7vcKfwRijYrFI1Wr1qsL5fE6pVEokhxwIgDRNo9VqdQUWCgXR9eJQLBYj0zRpu9360G63o2w2S5FI5PfBwWBw0yyu61K32xXdTnGw0+nQ6XS626Wz2Uwoj/DBVxQF4fD96fF4XChP4LE4j2aziWQy6Sfu9XrI5XIwTRMAYFmWaCr5LgVAiqKQbdvv7dJzZDKZK8xxHEqn0+8BE4kELZdLH1uv18QYk8khB14eDcdxZDE50DAMOhwO5HkebTYbmW2UB3VdJ9d1/eoMw3iq2YRAVVVpNBr52GQyoWg0+h5Q13Uaj8c+NhwOqVKpPIsFg5cf4P1+T+Vy+RVM/NUGAPV6HdPpVGbJzQidy/zU+Phf2zcGKKJjocPzywAAAABJRU5ErkJggg==\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": [ "(, tensor(0), tensor([0.5748, 0.4252]))" ] }, "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": [ "

get_preds[source][test]

\n", "\n", "> get_preds(**`ds_type`**:[`DatasetType`](/basic_data.html#DatasetType)=***``***, **`with_loss`**:`bool`=***`False`***, **`n_batch`**:`Optional`\\[`int`\\]=***`None`***, **`pbar`**:`Union`\\[`MasterBar`, `ProgressBar`, `NoneType`\\]=***`None`***) → `List`\\[`Tensor`\\]\n", "\n", "
×

Tests found for get_preds:

  • pytest -sv tests/test_basic_train.py::test_get_preds [source]

To run tests please refer to this guide.

\n", "\n", "Return predictions and targets on `ds_type` dataset. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.get_preds)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It will run inference using the learner on all the data in the `ds_type` dataset and return the predictions; if `n_batch` is not specified, it will run the predictions on the default batch size. If `with_loss`, it will also return the loss on each prediction." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is how you check the default batch size." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "64" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.data.batch_size" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[tensor([[9.9925e-01, 7.4895e-04],\n", " [9.8333e-01, 1.6672e-02],\n", " [9.9996e-01, 3.8919e-05],\n", " ...,\n", " [1.6180e-04, 9.9984e-01],\n", " [2.5164e-02, 9.7484e-01],\n", " [1.8179e-02, 9.8182e-01]]), tensor([0, 0, 0, ..., 1, 1, 1])]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "preds = learn.get_preds()\n", "preds" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first element of the tuple is a tensor that contains all the predictions." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[9.9925e-01, 7.4895e-04],\n", " [9.8333e-01, 1.6672e-02],\n", " [9.9996e-01, 3.8919e-05],\n", " ...,\n", " [1.6180e-04, 9.9984e-01],\n", " [2.5164e-02, 9.7484e-01],\n", " [1.8179e-02, 9.8182e-01]])" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "preds[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While the second element of the tuple is a tensor that contains all the target labels." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([0, 0, 0, ..., 1, 1, 1])" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "preds[1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor(0)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "preds[1][0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For more details about what each number mean, refer to the documentation of [`predict`](/basic_train.html#predict).\n", "\n", "Since [`get_preds`](/basic_train.html#get_preds) gets predictions on all the data in the `ds_type` dataset, here the number of predictions will be equal to the number of data in the validation dataset." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2038" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(learn.data.valid_ds)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2038, 2038)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(preds[0]), len(preds[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To get predictions on the entire training dataset, simply set the `ds_type` argument accordingly." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[tensor([[9.9801e-01, 1.9876e-03],\n", " [1.7900e-06, 1.0000e+00],\n", " [1.3191e-03, 9.9868e-01],\n", " ...,\n", " [9.9991e-01, 8.6866e-05],\n", " [1.6420e-04, 9.9984e-01],\n", " [2.2937e-03, 9.9771e-01]]), tensor([0, 1, 1, ..., 0, 1, 1])]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.get_preds(ds_type=DatasetType.Train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To also get prediction loss along with the predictions and the targets, set `with_loss=True` in the arguments." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[tensor([[9.9925e-01, 7.4895e-04],\n", " [9.8333e-01, 1.6672e-02],\n", " [9.9996e-01, 3.8919e-05],\n", " ...,\n", " [1.6180e-04, 9.9984e-01],\n", " [2.5164e-02, 9.7484e-01],\n", " [1.8179e-02, 9.8182e-01]]),\n", " tensor([0, 0, 0, ..., 1, 1, 1]),\n", " tensor([7.4911e-04, 1.6813e-02, 3.8624e-05, ..., 1.6165e-04, 2.5486e-02,\n", " 1.8347e-02])]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.get_preds(with_loss=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the third tensor in the output tuple contains the losses." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

validate[source][test]

\n", "\n", "> validate(**`dl`**=***`None`***, **`callbacks`**=***`None`***, **`metrics`**=***`None`***)\n", "\n", "
×

Tests found for validate:

  • pytest -sv tests/test_collab_train.py::test_val_loss [source]
  • pytest -sv tests/test_text_train.py::test_val_loss [source]

To run tests please refer to this guide.

\n", "\n", "Validate on `dl` with potential `callbacks` and `metrics`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.validate)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Return the calculated loss and the metrics of the current model on the given data loader `dl`. The default data loader `dl` is the validation dataloader." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can check the default metrics of the learner using:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'[]'" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "str(learn.metrics)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.061868817, tensor(0.9799)]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.validate()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.061868817, tensor(0.9799)]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.validate(learn.data.valid_dl)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.036164965, tensor(0.9887)]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.validate(learn.data.train_dl)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

show_results[source][test]

\n", "\n", "> show_results(**`ds_type`**=***``***, **`rows`**:`int`=***`5`***, **\\*\\*`kwargs`**)\n", "\n", "
×

No tests found for show_results. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Show `rows` result of predictions on `ds_type` dataset. " ], "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": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.show_results()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.show_results(ds_type=DatasetType.Train)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

pred_batch[source][test]

\n", "\n", "> pred_batch(**`ds_type`**:[`DatasetType`](/basic_data.html#DatasetType)=***``***, **`batch`**:`Tuple`=***`None`***, **`reconstruct`**:`bool`=***`False`***) → `List`\\[`Tensor`\\]\n", "\n", "
×

No tests found for pred_batch. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Return output of the model on one batch from `ds_type` dataset. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.pred_batch)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the number of predictions given equals to the batch size." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "64" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.data.batch_size" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "64" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "preds = learn.pred_batch()\n", "len(preds)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since the total number of predictions is too large, we will only look at a part of them." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[9.9925e-01, 7.4895e-04],\n", " [9.8333e-01, 1.6672e-02],\n", " [9.9996e-01, 3.8919e-05],\n", " [9.9998e-01, 1.7812e-05],\n", " [9.9993e-01, 6.8040e-05],\n", " [9.9533e-01, 4.6744e-03],\n", " [9.9838e-01, 1.6157e-03],\n", " [1.0000e+00, 1.4298e-06],\n", " [9.9942e-01, 5.8188e-04],\n", " [9.9999e-01, 1.2754e-05]])" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "preds[:10]" ] }, { "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+vtr4ff8G5v/BaH4o/D/Q/ih4L/AGH9Tn0bxHDHNpM114t0W1mkikyUkeCe9SaFGA3BpEUbSrZwwJ+Ja/fD/g13+Dtzq/w6l/b6/ae/4Kna9o+gaP4jTSNL+GUnxZezs3a32LGNVWeYfuzJND5VsuFdSu8usnl0AfjV+2R+wp+1l/wT9+J8Pwc/a/8Ag1feDPEFzp6X1nbXF5bXcN1buSBJFcWsssEoBBVtjkqwKtg8V5JX6a/8HYmq/tMt/wAFVb7w5+0L8RtB1nT7bwta3XgDTPDaSxwaPo000yxwTRykkXbNC0krbmDl1ZdqFY0/MqgAr9b/APgkv+xl8Hf+Cb/7Jeuf8Fwv+CjHw1g1KbRV8v4BfC3Xo2t7nV9XWVEj1FoZk5VZGTy5MOI1WSbaWWGvyQr2f9rD/goV+2T+3DpPhHw/+1H8cb7xTp3gPR10zwlpp0+0s7bT7dVVRiK0iiR5CqqpmcNIyqoLEAAAGX+2p+2F8Zf29f2mPFP7Vfx71G1uPEvim8WS4jsbcRW9rDGixQW0S8kRxRIkalizEICzMSSfLKKKAP/Z\n", "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAYAAAByDd+UAAAABHNCSVQICAgIfAhkiAAAAbBJREFUSInt1rGKwkAQBuBfuUJMRK0FQbYxoGBpLQimDAg+goVPIFrY29iYykoQfAEraxFDhBRW2lmJVqaV7Fxl0BPNrp42dwtTJOzOl1lmk4QAED44wp/E/sE/AubzebRaLXDOwTkHEWGxWMCyLP8e5xyNRkMYpUfRbrfJ87zAOB6PVKvVHuYCQF9BT2PbNvr9vn9dKpWgadrNPFVVwRh7vcKfwRijYrFI1Wr1qsL5fE6pVEokhxwIgDRNo9VqdQUWCgXR9eJQLBYj0zRpu9360G63o2w2S5FI5PfBwWBw0yyu61K32xXdTnGw0+nQ6XS626Wz2Uwoj/DBVxQF4fD96fF4XChP4LE4j2aziWQy6Sfu9XrI5XIwTRMAYFmWaCr5LgVAiqKQbdvv7dJzZDKZK8xxHEqn0+8BE4kELZdLH1uv18QYk8khB14eDcdxZDE50DAMOhwO5HkebTYbmW2UB3VdJ9d1/eoMw3iq2YRAVVVpNBr52GQyoWg0+h5Q13Uaj8c+NhwOqVKpPIsFg5cf4P1+T+Vy+RVM/NUGAPV6HdPpVGbJzQidy/zU+Phf2zcGKKJjocPzywAAAABJRU5ErkJggg==\n", "text/plain": [ "Image (3, 28, 28)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "item = learn.data.train_ds[0][0]\n", "item" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(tensor([[[[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]],\n", " \n", " [[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]],\n", " \n", " [[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]]]], device='cuda:0'),\n", " tensor([0], device='cuda:0'))" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "batch = learn.data.one_item(item)\n", "batch" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[0.5748, 0.4252]])" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.pred_batch(batch=batch)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

interpret[source][test]

\n", "\n", "> interpret(**`learn`**:[`Learner`](/basic_train.html#Learner), **`ds_type`**:[`DatasetType`](/basic_data.html#DatasetType)=***``***, **`tta`**=***`False`***)\n", "\n", "
×

Tests found for _learner_interpret:

  • pytest -sv tests/test_vision_train.py::test_interp_shortcut [source]

To run tests please refer to this guide.

\n", "\n", "Create a [`ClassificationInterpretation`](/train.html#ClassificationInterpretation) object from `learner` on `ds_type` with `tta`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.interpret, full_name='interpret')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "
Note: This function only works in the vision application.
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "jekyll_note('This function only works in the vision application.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For more details, refer to [ClassificationInterpretation](/vision.learner.html#ClassificationInterpretation)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Model summary" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

model_summary[source][test]

\n", "\n", "> model_summary(**`m`**:[`Learner`](/basic_train.html#Learner), **`n`**:`int`=***`70`***)\n", "\n", "
×

Tests found for model_summary:

  • pytest -sv tests/test_basic_train.py::test_export_load_learner [source]
  • pytest -sv tests/test_callbacks_hooks.py::test_model_summary_collab [source]
  • pytest -sv tests/test_callbacks_hooks.py::test_model_summary_tabular [source]
  • pytest -sv tests/test_callbacks_hooks.py::test_model_summary_text [source]
  • pytest -sv tests/test_callbacks_hooks.py::test_model_summary_vision [source]

To run tests please refer to this guide.

\n", "\n", "Print a summary of `m` using a output text width of `n` chars " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.summary)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Test time augmentation" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

TTA[source][test]

\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", "
×

No tests found for _TTA. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Applies TTA to predict on `ds_type` dataset. " ], "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": [ "

clip_grad[source][test]

\n", "\n", "> clip_grad(**`learn`**:[`Learner`](/basic_train.html#Learner), **`clip`**:`float`=***`0.1`***) → [`Learner`](/basic_train.html#Learner)\n", "\n", "
×

No tests found for clip_grad. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Add gradient clipping of `clip` during training. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.clip_grad)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Mixed precision training" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

to_fp16[source][test]

\n", "\n", "> to_fp16(**`learn`**:[`Learner`](/basic_train.html#Learner), **`loss_scale`**:`float`=***`None`***, **`max_noskip`**:`int`=***`1000`***, **`dynamic`**:`bool`=***`False`***, **`clip`**:`float`=***`None`***, **`flat_master`**:`bool`=***`False`***, **`max_scale`**:`float`=***`16777216`***) → [`Learner`](/basic_train.html#Learner)\n", "\n", "
×

No tests found for to_fp16. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Put `learn` in FP16 precision mode. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.to_fp16)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Uses the [`MixedPrecision`](/callbacks.fp16.html#MixedPrecision) callback to train in mixed precision (i.e. forward and backward passes using fp16, with weight updates using fp32), using all [NVIDIA recommendations](https://docs.nvidia.com/deeplearning/sdk/mixed-precision-training/index.html) for ensuring speed and accuracy." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

to_fp32[source][test]

\n", "\n", "> to_fp32(**`learn`**:[`Learner`](/basic_train.html#Learner))\n", "\n", "
×

No tests found for to_fp32. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Put `learn` back to FP32 precision mode. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.to_fp32)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Distributed training" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you want to use ditributed training or [`torch.nn.DataParallel`](https://pytorch.org/docs/stable/nn.html#torch.nn.DataParallel) these will directly wrap the model for you." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

to_distributed[source][test]

\n", "\n", "> to_distributed(**`learn`**:[`Learner`](/basic_train.html#Learner), **`cuda_id`**:`int`, **`cache_dir`**:`PathOrStr`=***`'tmp'`***)\n", "\n", "
×

No tests found for _learner_distributed. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Put `learn` on distributed training with `cuda_id`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.to_distributed, full_name='to_distributed')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

to_parallel[source][test]

\n", "\n", "> to_parallel(**`learn`**:[`Learner`](/basic_train.html#Learner))\n", "\n", "
×

No tests found for _learner_parallel. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Use nn.DataParallel when training and remove when done " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.to_parallel, full_name='to_parallel')" ] }, { "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": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracytime
10.0596130.0546040.98184500:05
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn.fit_one_cycle(1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracytime
10.0263790.0087630.99803700:07
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# all layers now trainable\n", "learn.unfreeze()\n", "# optionally, separate LR and WD for each group\n", "learn.fit_one_cycle(1, max_lr=(1e-4, 1e-3, 1e-2), wd=(1e-4,1e-4,1e-1))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

lr_range[source][test]

\n", "\n", "> lr_range(**`lr`**:`Union`\\[`float`, `slice`\\]) → `ndarray`\n", "\n", "
×

No tests found for lr_range. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Build differential learning rates from `lr`. " ], "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": [ "

unfreeze[source][test]

\n", "\n", "> unfreeze()\n", "\n", "
×

Tests found for unfreeze:

  • pytest -sv tests/test_basic_train.py::test_unfreeze [source]

To run tests please refer to this guide.

\n", "\n", "Unfreeze entire model. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.unfreeze)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sets every layer group to *trainable* (i.e. `requires_grad=True`)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

freeze[source][test]

\n", "\n", "> freeze()\n", "\n", "
×

Tests found for freeze:

  • pytest -sv tests/test_basic_train.py::test_freeze [source]

To run tests please refer to this guide.

\n", "\n", "Freeze up to last layer group. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.freeze)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sets every layer group except the last to *untrainable* (i.e. `requires_grad=False`)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

freeze_to[source][test]

\n", "\n", "> freeze_to(**`n`**:`int`)\n", "\n", "
×

Tests found for freeze_to:

  • pytest -sv tests/test_basic_train.py::test_freeze_to [source]

To run tests please refer to this guide.

\n", "\n", "Freeze layers up to layer group `n`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.freeze_to)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

split[source][test]

\n", "\n", "> split(**`split_on`**:`SplitFuncOrIdxList`)\n", "\n", "
×

No tests found for split. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Split the model at `split_on`. " ], "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": [ "

save[source][test]

\n", "\n", "> save(**`name`**:`PathOrStr`, **`return_path`**:`bool`=***`False`***, **`with_opt`**:`bool`=***`True`***)\n", "\n", "
×

Tests found for save:

  • pytest -sv tests/test_basic_train.py::test_memory [source]
  • pytest -sv tests/test_basic_train.py::test_save_load [source]

Some other tests where save is used:

  • pytest -sv tests/test_basic_train.py::test_model_load_mem_leak [source]

To run tests please refer to this guide.

\n", "\n", "Save model and optimizer state (if `with_opt`) with `name` to `self.model_dir`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.save)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If agument `name` is a pathlib object that's an absolute path, it'll override the default base directory (`learn.path`), otherwise the model will be saved in a file relative to `learn.path`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn.save(\"trained_model\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "PosixPath('/home/ubuntu/.fastai/data/mnist_sample/models/trained_model.pth')" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.save(\"trained_model\", return_path=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

load[source][test]

\n", "\n", "> load(**`name`**:`PathOrStr`, **`device`**:[`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch-device)=***`None`***, **`strict`**:`bool`=***`True`***, **`with_opt`**:`bool`=***`None`***, **`purge`**:`bool`=***`True`***, **`remove_module`**:`bool`=***`False`***)\n", "\n", "
×

Tests found for load:

  • pytest -sv tests/test_basic_train.py::test_memory [source]
  • pytest -sv tests/test_basic_train.py::test_save_load [source]

Some other tests where load is used:

  • pytest -sv tests/test_basic_train.py::test_model_load_mem_leak [source]

To run tests please refer to this guide.

\n", "\n", "Load model and optimizer state (if `with_opt`) `name` from `self.model_dir` using `device`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.load)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If the `purge` argument is `True` (default) `load` internally calls `purge` with `clear_opt=False` to presever `learn.opt`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn = learn.load(\"trained_model\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Deploying your model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When you are ready to put your model in production, export the minimal state of your [`Learner`](/basic_train.html#Learner) with:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

export[source][test]

\n", "\n", "> export(**`fname`**:`PathOrStr`=***`'export.pkl'`***, **`destroy`**=***`False`***)\n", "\n", "
×

Tests found for export:

  • pytest -sv tests/test_basic_train.py::test_export_load_learner [source]

To run tests please refer to this guide.

\n", "\n", "Export the state of the [`Learner`](/basic_train.html#Learner) in `self.path/fname`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.export)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If agument `fname` is a pathlib object that's an absolute path, it'll override the default base directory (`learn.path`), otherwise the model will be saved in a file relative to `learn.path`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Passing `destroy=True` will destroy the [`Learner`](/basic_train.html#Learner), freeing most of its memory consumption. For specifics see [`Learner.destroy`](/basic_train.html#Learner.destroy).\n", "\n", "This method only works with the [`Learner`](/basic_train.html#Learner) whose [`data`](/vision.data.html#vision.data) was created through the [data block API](/data_block.html).\n", "\n", "Otherwise, you will have to create a [`Learner`](/basic_train.html#Learner) yourself at inference and load the model with [`Learner.load`](/basic_train.html#Learner.load)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn.export()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn.export('trained_model.pkl')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "PosixPath('/home/ubuntu/.fastai/data/mnist_sample')" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "path = learn.path\n", "path" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

load_learner[source][test]

\n", "\n", "> load_learner(**`path`**:`PathOrStr`, **`fname`**:`PathOrStr`=***`'export.pkl'`***, **`test`**:[`ItemList`](/data_block.html#ItemList)=***`None`***, **\\*\\*`db_kwargs`**)\n", "\n", "
×

Tests found for load_learner:

  • pytest -sv tests/test_basic_train.py::test_export_load_learner [source]

To run tests please refer to this guide.

\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`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(load_learner)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `db_kwargs` will be passed to the call to `databunch` so you can specify a `bs` for the test set, or `num_workers`." ] }, { "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": [ "

purge[source][test]

\n", "\n", "> purge(**`clear_opt`**:`bool`=***`True`***)\n", "\n", "
×

Tests found for purge:

  • pytest -sv tests/test_basic_train.py::test_memory [source]
  • pytest -sv tests/test_basic_train.py::test_purge [source]
  • pytest -sv tests/test_basic_train.py::test_save_load [source]

To run tests please refer to this guide.

\n", "\n", "Purge the [`Learner`](/basic_train.html#Learner) of all cached attributes to release some GPU memory. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.purge)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If `learn.path` is read-only, you can set `model_dir` attribute in Learner to a full `libpath` path that is writable (by setting `learn.model_dir` or passing `model_dir` argument in the [`Learner`](/basic_train.html#Learner) constructor)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

destroy[source][test]

\n", "\n", "> destroy()\n", "\n", "
×

Tests found for destroy:

  • pytest -sv tests/test_basic_train.py::test_destroy [source]
  • pytest -sv tests/test_basic_train.py::test_memory [source]

To run tests please refer to this guide.

\n", "\n", "Free the Learner internals, leaving just an empty shell that consumes no memory " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.destroy)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you need to free the memory consumed by the [`Learner`](/basic_train.html#Learner) object, call this method. \n", "\n", "It can also be automatically invoked through [`Learner.export`](/basic_train.html#Learner.export) via its `destroy=True` argument." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Other methods" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

init[source][test]

\n", "\n", "> init(**`init`**)\n", "\n", "
×

No tests found for init. To contribute a test please refer to this guide and this discussion.

" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.init)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Initializes all weights (except batchnorm) using function `init`, which will often be from PyTorch's [`nn.init`](https://pytorch.org/docs/stable/nn.html#torch-nn-init) module." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

mixup[source][test]

\n", "\n", "> mixup(**`learn`**:[`Learner`](/basic_train.html#Learner), **`alpha`**:`float`=***`0.4`***, **`stack_x`**:`bool`=***`False`***, **`stack_y`**:`bool`=***`True`***) → [`Learner`](/basic_train.html#Learner)\n", "\n", "
×

No tests found for mixup. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Add mixup https://arxiv.org/abs/1710.09412 to `learn`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.mixup)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Uses [`MixUpCallback`](/callbacks.mixup.html#MixUpCallback)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

backward[source][test]

\n", "\n", "> backward(**`item`**)\n", "\n", "
×

No tests found for backward. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Pass `item` through the model and computes the gradient. Useful if `backward_hooks` are attached. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.backward)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

create_opt[source][test]

\n", "\n", "> create_opt(**`lr`**:`Floats`, **`wd`**:`Floats`=***`0.0`***)\n", "\n", "
×

No tests found for create_opt. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Create optimizer with `lr` learning rate and `wd` weight decay. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.create_opt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You generally won't need to call this yourself - it's used to create the [`optim`](https://pytorch.org/docs/stable/optim.html#module-torch.optim) optimizer before fitting the model." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

dl[source][test]

\n", "\n", "> dl(**`ds_type`**:[`DatasetType`](/basic_data.html#DatasetType)=***``***)\n", "\n", "
×

No tests found for dl. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Return DataLoader for DatasetType `ds_type`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.dl)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "DeviceDataLoader(dl=, device=device(type='cuda'), tfms=[], collate_fn=)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.dl()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "DeviceDataLoader(dl=, device=device(type='cuda'), tfms=[], collate_fn=)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "learn.dl(DatasetType.Train)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

class Recorder[source][test]

\n", "\n", "> Recorder(**`learn`**:[`Learner`](/basic_train.html#Learner), **`add_time`**:`bool`=***`True`***) :: [`LearnerCallback`](/basic_train.html#LearnerCallback)\n", "\n", "
×

Tests found for Recorder:

  • pytest -sv tests/test_vision_train.py::test_1cycle_lrs [source]
  • pytest -sv tests/test_vision_train.py::test_1cycle_moms [source]

To run tests please refer to this guide.

\n", "\n", "A [`LearnerCallback`](/basic_train.html#LearnerCallback) that records epoch, loss, opt and metric data during training. " ], "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": [ "

plot[source][test]

\n", "\n", "> plot(**`skip_start`**:`int`=***`10`***, **`skip_end`**:`int`=***`5`***, **`suggestion`**:`bool`=***`False`***, **`return_fig`**:`bool`=***`None`***, **\\*\\*`kwargs`**) → `Optional`\\[`Figure`\\]\n", "\n", "
×

No tests found for plot. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Plot learning rate and losses, trimmed between `skip_start` and `skip_end`. Optionally plot and return min gradient " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.plot)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is mainly used with the learning rate finder, since it shows a scatterplot of loss vs learning rate." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "path = untar_data(URLs.MNIST_SAMPLE)\n", "data = ImageDataBunch.from_folder(path)\n", "learn = cnn_learner(data, models.resnet18, metrics=accuracy)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "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": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.lr_find()\n", "learn.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

plot_losses[source][test]

\n", "\n", "> plot_losses(**`skip_start`**:`int`=***`0`***, **`skip_end`**:`int`=***`0`***, **`return_fig`**:`bool`=***`None`***) → `Optional`\\[`Figure`\\]\n", "\n", "
×

No tests found for plot_losses. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Plot training and validation losses. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.plot_losses)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that validation losses are only calculated once per epoch, whereas training losses are calculated after every batch." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracytime
10.2285240.1222850.95878300:05
20.1188380.0752220.97105000:05
30.0667150.0549200.98135400:05
40.0481550.0486120.98331700:05
50.0375350.0460140.98233600:05
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.fit_one_cycle(5)\n", "learn.recorder.plot_losses()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

plot_lr[source][test]

\n", "\n", "> plot_lr(**`show_moms`**=***`False`***, **`skip_start`**:`int`=***`0`***, **`skip_end`**:`int`=***`0`***, **`return_fig`**:`bool`=***`None`***) → `Optional`\\[`Figure`\\]\n", "\n", "
×

No tests found for plot_lr. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Plot learning rate, `show_moms` to include momentum. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.plot_lr)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.recorder.plot_lr()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.recorder.plot_lr(show_moms=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

plot_metrics[source][test]

\n", "\n", "> plot_metrics(**`return_fig`**:`bool`=***`None`***) → `Optional`\\[`Figure`\\]\n", "\n", "
×

No tests found for plot_metrics. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Plot metrics collected during training. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.plot_metrics)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that metrics are only collected at the end of each epoch, so you'll need to train at least two epochs to have anything to show here." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.recorder.plot_metrics()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Callback methods" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You don't call these yourself - they're called by fastai's [`Callback`](/callback.html#Callback) system automatically to enable the class's functionality. Refer to [`Callback`](/callback.html#Callback) for more details." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

on_backward_begin[source][test]

\n", "\n", "> on_backward_begin(**`smooth_loss`**:`Tensor`, **\\*\\*`kwargs`**:`Any`)\n", "\n", "
×

No tests found for on_backward_begin. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Record the loss before any other callback has a chance to modify it. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.on_backward_begin)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

on_batch_begin[source][test]

\n", "\n", "> on_batch_begin(**`train`**, **\\*\\*`kwargs`**:`Any`)\n", "\n", "
×

No tests found for on_batch_begin. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Record learning rate and momentum at beginning of batch. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.on_batch_begin)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

on_epoch_end[source][test]

\n", "\n", "> on_epoch_end(**`epoch`**:`int`, **`num_batch`**:`int`, **`smooth_loss`**:`Tensor`, **`last_metrics`**=***`typing.Collection[typing.Union[torch.Tensor, numbers.Number]]`***, **\\*\\*`kwargs`**:`Any`) → `bool`\n", "\n", "
×

No tests found for on_epoch_end. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Save epoch info: num_batch, smooth_loss, metrics. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.on_epoch_end)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

on_train_begin[source][test]

\n", "\n", "> on_train_begin(**`pbar`**:`PBar`, **`metrics_names`**:`StrList`, **\\*\\*`kwargs`**:`Any`)\n", "\n", "
×

No tests found for on_train_begin. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Initialize recording status at beginning of training. " ], "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": [ "

add_metric_names[source][test]

\n", "\n", "> add_metric_names(**`names`**)\n", "\n", "
×

No tests found for add_metric_names. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Add `names` to the inner metric names. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Recorder.add_metric_names)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

format_stats[source][test]

\n", "\n", "> format_stats(**`stats`**:`MetricsList`)\n", "\n", "
×

No tests found for format_stats. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Format stats before printing. " ], "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": [ "

fit[source][test]

\n", "\n", "> fit(**`epochs`**:`int`, **`learn`**:[`BasicLearner`](/basic_train.html#BasicLearner), **`callbacks`**:`Optional`\\[`Collection`\\[[`Callback`](/callback.html#Callback)\\]\\]=***`None`***, **`metrics`**:`OptMetrics`=***`None`***)\n", "\n", "
×

Tests found for fit:

Some other tests where fit is used:

  • pytest -sv tests/test_basic_train.py::test_destroy [source]

To run tests please refer to this guide.

\n", "\n", "Fit the `model` on `data` and learn using `loss_func` and `opt`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(fit)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that you have to create the [`Optimizer`](https://pytorch.org/docs/stable/optim.html#torch.optim.Optimizer) yourself if you call this function, whereas [`Learn.fit`](/basic_train.html#fit) creates it for you automatically." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

train_epoch[source][test]

\n", "\n", "> train_epoch(**`model`**:[`Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module), **`dl`**:[`DataLoader`](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader), **`opt`**:[`Optimizer`](https://pytorch.org/docs/stable/optim.html#torch.optim.Optimizer), **`loss_func`**:`LossFunction`)\n", "\n", "
×

No tests found for train_epoch. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Simple training of `model` for 1 epoch of `dl` using optim `opt` and loss function `loss_func`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(train_epoch)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You won't generally need to call this yourself - it's what [`fit`](/basic_train.html#fit) calls for each epoch." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

validate[source][test]

\n", "\n", "> validate(**`model`**:[`Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module), **`dl`**:[`DataLoader`](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader), **`loss_func`**:`OptLossFunc`=***`None`***, **`cb_handler`**:`Optional`\\[[`CallbackHandler`](/callback.html#CallbackHandler)\\]=***`None`***, **`pbar`**:`Union`\\[`MasterBar`, `ProgressBar`, `NoneType`\\]=***`None`***, **`average`**=***`True`***, **`n_batch`**:`Optional`\\[`int`\\]=***`None`***) → `Iterator`\\[`Tuple`\\[`IntOrTensor`, `Ellipsis`\\]\\]\n", "\n", "
×

Tests found for validate:

  • pytest -sv tests/test_tabular_train.py::test_accuracy [source]

To run tests please refer to this guide.

\n", "\n", "Calculate `loss_func` of `model` on `dl` in evaluation mode. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(validate)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is what [`fit`](/basic_train.html#fit) calls after each epoch. You can call it if you want to run inference on a [`DataLoader`](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) manually." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

get_preds[source][test]

\n", "\n", "> get_preds(**`model`**:[`Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module), **`dl`**:[`DataLoader`](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader), **`pbar`**:`Union`\\[`MasterBar`, `ProgressBar`, `NoneType`\\]=***`None`***, **`cb_handler`**:`Optional`\\[[`CallbackHandler`](/callback.html#CallbackHandler)\\]=***`None`***, **`activ`**:[`Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)=***`None`***, **`loss_func`**:`OptLossFunc`=***`None`***, **`n_batch`**:`Optional`\\[`int`\\]=***`None`***) → `List`\\[`Tensor`\\]\n", "\n", "
×

Tests found for get_preds:

Some other tests where get_preds is used:

  • pytest -sv tests/test_basic_train.py::test_get_preds [source]

To run tests please refer to this guide.

\n", "\n", "Tuple of predictions and targets, and optional losses (if `loss_func`) using `dl`, max batches `n_batch`. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(get_preds)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

loss_batch[source][test]

\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", "
×

No tests found for loss_batch. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Calculate loss and metrics for a batch, call out to callbacks as necessary. " ], "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": [ "

class LearnerCallback[source][test]

\n", "\n", "> LearnerCallback(**`learn`**) :: [`Callback`](/callback.html#Callback)\n", "\n", "
×

No tests found for LearnerCallback. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Base class for creating callbacks for a [`Learner`](/basic_train.html#Learner). " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(LearnerCallback, title_level=3)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

class RecordOnCPU[source][test]

\n", "\n", "> RecordOnCPU() :: [`Callback`](/callback.html#Callback)\n", "\n", "
×

No tests found for RecordOnCPU. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Store the `input` and `target` going through the model on the CPU. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(RecordOnCPU, title_level=3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Undocumented Methods - Methods moved below this line will intentionally be hidden" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

_tta_only[source][test]

\n", "\n", "> _tta_only(**`learn`**:[`Learner`](/basic_train.html#Learner), **`ds_type`**:[`DatasetType`](/basic_data.html#DatasetType)=***``***, **`scale`**:`float`=***`1.35`***) → `Iterator`\\[`List`\\[`Tensor`\\]\\]\n", "\n", "
×

No tests found for _tta_only. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Computes the outputs for several augmented inputs for TTA " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.tta_only)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

_TTA[source][test]

\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", "
×

No tests found for _TTA. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Applies TTA to predict on `ds_type` dataset. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Learner.TTA)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide_input": true }, "outputs": [ { "data": { "text/markdown": [ "

on_batch_begin[source][test]

\n", "\n", "> on_batch_begin(**`last_input`**, **`last_target`**, **\\*\\*`kwargs`**)\n", "\n", "
×

No tests found for on_batch_begin. To contribute a test please refer to this guide and this discussion.

\n", "\n", "Set HP before the output and loss are computed. " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(RecordOnCPU.on_batch_begin)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## New Methods - Please document or move to the undocumented section" ] } ], "metadata": { "jekyll": { "keywords": "fastai", "summary": "Learner class and training loop", "title": "basic_train" }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" } }, "nbformat": 4, "nbformat_minor": 2 }