fastai

​​
​​
​​
​​
​​
​​
​See code examples​
​See results in Neptune​
​Run example on Google Colab​
​fastai is a deep learning library that provides practitioners with high-level components that can quickly and easily provide state-of-the-art results in standard deep learning domains and provides researchers with low-level components that can be mixed and matched to build new approaches. 
What you will get with this integration?
With Neptune + fastai integration the following metadata is logged automatically for you:
hyper-parameters
Losses & metrics
training code(Python scripts or Jupyter notebooks) and git information
Dataset version
Model Configuration, Architecture, and Weights
You can also log other metadata types like interactive charts, video, audio, and more. See What can you log and display?​
Installation
Before you start, make sure that:
You have Python 3.6+ in your system,
You are already registered user, so that you can log metadata to your private projects.
You have your NEPTUNE_API_TOKEN set to the environment variable: check this docs page.
Install fastai, and neptune-client[fastai]
Depending on your operating system open a terminal or CMD and run this command:
1
pip install fastai neptune-client[fastai]
Copied!
For more help see installing neptune-client.
This integration is tested with fastai==2.3.1and neptune-client[fastai]==0.9.18.
Quickstart
​​
​​
​​
​​
​​
​​
​See code examples​
​See results in Neptune​
​Run example on Google Colab​
Step 1: Initialize a Neptune Run
Place this code snippet at the beginning of your script or notebook cell
1
import neptune.new as neptune
2
​
3
run = neptune.init(project = '<YOUR_WORKSPACE/YOUR_PROJECT>', 
4
                         api_token = '<YOURR_API_TOKEN>', 
5
                         source_files=['*.py'])
Copied!
This opens a new Run in Neptune that allows you to log various objects.
You need to authenticate yourself and open an existing project.  Here is how:
You can use the api_token='ANONYMOUS' and project='common/fastai-integration' to explore without having to create a Neptune account. 
Step 2: Add NeptuneCallback to learner or fit method:
To log metadata,  you have to pass NeptuneCallback() to the callbacks argument of a learner or fit method.
Log a single training phase 
1
learn = learner(...)
2
learn.fit(..., cbs = NeptuneCallback(run=run))
Copied!
Log all training phases of the learner
1
learn = cnn_learner(..., cbs=NeptuneCallback(run=run))
2
learn.fit(...)
3
learn.fit(...)
Copied!
Step 3: Stop Run
Once you are done logging, you should stop tracking the run using the stop() method. This is needed only while logging from a notebook environment. While logging through a script, Neptune automatically stops tracking once the script has completed execution.
1
run.stop()
Copied!
Step 4: Run your training script or notebook cell and monitor your training in Neptune UI
Run your script or notebook cell as you normally would.
After running your script or notebook cell you will get a link similar to: https://app.neptune.ai/o/common/org/fastai-integration/e/FAS-61

with common/fastai-integration replaced by your project, and FAS-61 replaced by your run.
Click on the link to open the Run in Neptune to watch your model training live.  
Initially, it may be empty but keep the tab with the Run open to see your experiment metadata update in real-time.
More options 
Customizing NeptuneCallback
You can change or extend the default behavior of the NeptuneCallback() by passing callback a function to the constructor. For example:
1
def cb(self): 
2
    self.run['sys/name'] = 'Binary Classification'
3
    self.run['seed'] = 1000
4
            
5
neptune_cb = NeptuneCallback(before_fit=cb)
Copied!
Remember to specify the event you want to change. To learn more about the different events see the fastai Callback core page.
Log Model Architecture and Weights
Add SaveModelCallback()
You can log your model weight files during single training or all training phases add SavemodelCallback() to the callbacks' list of your learner or fit method.
Log Every N epochs
1
n = 4
2
learn = learner(..., cbs=[
3
            SaveModelCallback(every_epoch=n),
4
            NeptuneCallback(run=run, upload_saved_models='all')])
Copied!
Best Model 
1
learn = learner(..., cbs=[
2
           SaveModelCallback(), NeptuneCallback(run=run)])
Copied!
Log Images and predictions
Plotting images and predictions is always helpful in computer vision tasks because it allows you to visually inspect the model's predictions.
With Neptune + fast.ai you can log torch tensors and they will be displayed as images in the Neptune UI. 
1
from neptune.new.types import File
2
​
3
# Log image with predictions
4
img = torch.rand(30, 30, 3)
5
description = {"Predicted": pred, "Ground Truth": gt}
6
run['torch_tensor'].upload(File.as_image(img),
7
                                description = description)
Copied!
​​
​​
​​
​​
​​
​​
​See code examples​
​See results in Neptune​
​Run example on Google Colab​
How to ask for help?
Please visit the Getting help page. Everything regarding support is there.
Getting help
Other pages you may like
You may want to check out other integrations from the Pytorch ecosystem:
Catalyst
PyTorch Lightning
PyTorch Ignite
skorch