fastai - Lesson 1 - Deep Learning for Coders (2020)
Notes taken from the Deep Learning for Coders (2020) - Lesson 1 video
Notes taken from watching the Lesson 1 - Deep Learning for Coders (2020) video.
00:00 - Intro
- Course is "definitive version" after 4 years of Fastai
- Includes book and peer-reviewed paper on library.
- Syllabus of course based on the book
03:34 - Course format
- Book was written in notebook
- Course includes version of course without prose and output to run while learning
- Coauthors of course:
- Sylvain Gugger coauthor of book
- Rachael Thomas cofounder of fastai
06:31 - Misconceptions about requirements for Deep Learning
- What you don't need for DL:
- Don't need a lot of math: high school level is enough
- Don't need a lot of data: world class results can be obtained with < 50 examples
- Don't need expensive computers: can train state of the art models for free
- Course requires coding ability, preferably in Python (though can be picked up during the course)
08:38 - Deep learning best known approach in a number of areas
- Image classification, image segmentation, NLP, some structured data problems
- In some areas, equal or better than human performance
09:54 - Neural networks history
- Note: Deep Learning a type of neural network learning (a deep one)
- In 1943, neurophysiologist, Warren McCulloch, and logician, Walter Pitts created model of artificial neuron
- Declared that since brain activity had an "all-or-nothing" characteristic, they could be treated as "propositional logic"
-
In 1950s, Frank Rosenblatt made some subtle changes to model and oversaw the creation of the Mark 1 Perceptron
11:22 - First AI winter
- Marvin Minsky created book called Perceptrons about that invention
- Showed that a single layer could not learn critical function like XOR
- Paper showed that multiple layers could, however, people ignored that part of the book
12:14 Parallel Distributed Processing (PDP)
-
Released in 1986, described the foundations of modern deep learning:
13:38 The Age of Deep Learning
- 2nd layer of neurons added
- Shown that extra layer of neurons could approximate any function
- In practice, more layers are usually required
- Shown that extra layer of neurons could approximate any function
16:00 Top-down learning
- Unlike other ML courses, doesn't start with refresher on calculus, or lessons on Sigmoid function
- Approached based on Teaching the whole game by Professor David Perkins and others from Harvard.
23:09 Software stack
- Software used:
- fastai library, which is built on PyTorch built on Python
- Vast majority of Deep Learning researchers using PyTorch: industry still Tensorflow
- PyTorch not designed for beginner friendlyness
- fastai designed to be flexible but also useful for learning and teaching
27:36 GPUs
- GPU: Graphics Processing Unit
- Requires a Nvidia GPU: other brands aren't supported by Deep Learning libraries.
- Use existing platform setup for it: not worth your time building your own machine while learning
31:30 Juypter Notebooks overview
- Juypter Notebook is REPL with powerful features
- Course provides a notebook that shows Jupyter functionality
- If not familiar with notebooks, can be as awkward as moving from gui to command-line
- Has 2 modes: command-mode and edit-mode
- Can format text in Markdown
- Can access terminal from Jupyter
39:08 Repositories overview
- fastbook repo - prose for book
- coursev4 repo - notebooks with all book-related stuff removed
40:32 Questionaires
- Each lesson has a questionaire
- Lots of effort put into questions to help answer the question: have I learned everything before moving on
- If you get stuck on a single question, move on and consider coming back
42:20 Running the first notebook
In [18]:
# Doing this patches in a bunch of methods that are required for the training example below.
from fastai.vision.all import *
In [19]:
# These imports are redundant, but I'm using it to refresh my memory on the API.
from fastai.vision.data import ImageDataLoaders, get_image_files
from fastai.data.external import URLs, untar_data
untar_data takes in a URL to a gzipped tarfile, unzips it then returns the path (as a pathlib.Path object).
In [20]:
URLs.PETS
Out[20]:
'https://s3.amazonaws.com/fast-ai-imageclas/oxford-iiit-pet.tgz'
In [21]:
path = untar_data(URLs.PETS)/'images'
In the Oxford Pets dataset (or at least the one hosted by fastai), the files are named so that if it starts with a capital letter it's a cat. Here's a few examples:
In [22]:
get_image_files(path)
Out[22]:
(#7390) [Path('/root/.fastai/data/oxford-iiit-pet/images/beagle_115.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/boxer_18.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/Maine_Coon_157.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/scottish_terrier_28.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/english_setter_6.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/american_pit_bull_terrier_79.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/boxer_128.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/Persian_265.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/Maine_Coon_182.jpg'),Path('/root/.fastai/data/oxford-iiit-pet/images/keeshond_89.jpg')...]
So we can write a function that returns True if is starts with an uppercase char.
In [23]:
def is_cat(x):
return x[0].isupper()
In [24]:
assert is_cat('Persian_265.jpg')
assert is_cat('beagle_115.jpg') is False
We can use ImageDataLoaders to load each image and extract the labels. First argument is a path and second is the list of files to load.
It takes a number of additional arguments for preparing validation sets and passing item transforms.
In [25]:
from fastai.vision.augment import Resize
In [26]:
dataloaders = ImageDataLoaders.from_name_func(
path, get_image_files(path), valid_pct=0.2, seed=420,
label_func=is_cat, item_tfms=Resize(224))
In [27]:
dataloaders
Out[27]:
<fastai.data.core.DataLoaders at 0x7fe2cc09edd0>
We can then get a "learner" instance by passing the dataloaders and architecture function.
In [28]:
from torchvision.models.resnet import resnet34
from fastai.vision.learner import cnn_learner
from fastai.metrics import error_rate
In [29]:
learn = cnn_learner(dataloaders, resnet34, metrics=error_rate)
And fine-tune the top layers:
In [30]:
learn
Out[30]:
<fastai.learner.Learner at 0x7fe2cc01bb90>
In [31]:
learn.fine_tune(1)
| epoch | train_loss | valid_loss | error_rate | time |
|---|---|---|---|---|
| 0 | 0.139675 | 0.018890 | 0.005413 | 00:42 |
| epoch | train_loss | valid_loss | error_rate | time |
|---|---|---|---|---|
| 0 | 0.063200 | 0.014935 | 0.006089 | 00:44 |
Now to test the model.
In [32]:
from fastai.vision import widgets
from fastai.vision.core import PILImage
In [33]:
uploader = widgets.FileUpload()
In [34]:
uploader
FileUpload(value={}, description='Upload')
In [35]:
img = PILImage.create(uploader.data[0])
In [36]:
img
Out[36]:
In [37]:
is_cat, _, probs = learn.predict(img)
In [38]:
print(f"Is this a cat?: {is_cat}.")
Is this a cat?: False.
In [39]:
print(f"Dog probability: {1-probs[1].item():.6f}")
Dog probability: 1.000000
We know the model has only been trained on cat / dog photos. What happens if we try anime cats?
In [40]:
uploader
FileUpload(value={'doggo.jpg': {'metadata': {'name': 'doggo.jpg', 'type': 'image/jpeg', 'size': 42952, 'lastMo…
In [41]:
img = PILImage.create(uploader.data[0])
In [42]:
img
Out[42]:
In [43]:
is_cat, _, probs = learn.predict(img)
In [44]:
print(f"Is this a cat?: {is_cat}.")
print(f"Cat probability: {probs[1].item():.6f}")
Is this a cat?: True. Cat probability: 0.995966
Still works, but it's not very confident.
48:00 Machine Learning
- Deep learning is a kind of Machine Learning
- Without Machine Learning, it would be near impossible to write a program to classify cats and dogs
49:05 Machine Learning history
- In 1949, Arthur Samuel started looking at alternative methods of completing task
- Popularised the term: "Machine Learning"
- In 1962, wrote essay: "Artificial Intelligence: A Frontier of Automation" in it he describes the problem ML solves:
- "Programming a computer for such computations is, at best, a difficult task, not primarily because of any inherent complexity in the comptuer itself but, rather, because of the need to spell out every minute step of the process in the most exasperating detail. Computers, as any programmer will tell you, are giant morons, not giant brains."
- Idea was that instead of telling computer how to solve a problem, give computer examples of problem and have it figure it out
- Create a weight assigment to test effectiveness of problem, and provide mechanism of altering weights to maximise performance
- After training "model" you have something like: inputs -> model -> results
- When we use a model to do a task like playing checkers, we call it Inference
- Jargon: Machine Learning
- Training of programs developed by allowing computer to learn from experience, rather than manually coding the steps
- Jargon: Machine Learning
## 53:45 Neural networks & image classification
- Is there is a function so flexibilty that the weights can do anything? Yes, a neural network.
- Mathematical proof called Universal Approximation Theory
- Function can solve any problem to any level of accuracy if you just find the right set of weights (in theory)
- Stochasic Gradient Descent
- The "mechanism of altering weights to maximise performance" that Arthur Samuel referred to.
- Course will look at exactly how it works.
- Terminology used nowadays as compared to Samuel's:
- Functional form of model is Architecture
- Weights are called Parameters
- Predictions calculated from Independant Variable, which is the data that doesn't include the labels
- Results of model are called Predictions
- Loss depends on having Predictions and correct Labels
58:57 Limitations of Machine Learning
- Model can't be created without data.
- Model can only learn based on patterns in input data
- Learning creates predictions not recommended actions
- Model can only learn on patterns in input data used to train
- Model requires labels to learn
- Labels can be difficulty to get lots of dependant variables
01:01:32 Model operates in environment
- Consider the "environment" part of the PDP model
- Feedback loop of model can create vicious circle.
- Example:
- predictive policing model predicts where arrests are likely to occur.
- more police therefore go to the area, which leads to more arrests.
- that is fed into model, which creates more arrests.
- Consider that predicting arrests is an example of where Proxy Metrics for what you care about: reducing crime.
- Sometimes the difference between proxy and what you are actually trying to do can be significant
01:04:14 Dogs and Cats Notebook review
01:04:30 Use of import *
- In Python, you have to import everything you need.
- Python provides a convenience tool called
import *- Usually not recommended as it adds a whole bunch of stuff to your namespace
- Fastai is designed for Repls, therefore, thought has gone into making
import *safe- Question: why is it so hard to import what you need in a Repl?
- Can view location of symbol in Repl by putting symbol in a cell and pressing shift + enter
01:09:05 review continued
docfunction: Used to show documentation for a method or function in fastaiuntar_data: Downloads dataset, decompresses and puts on your computerlabel_func: Used to extract label from fileresnet34: good starting point model for image classificationvalid_pct: sets part of the dataside aside (size determined by %) for validation to check you aren't overfitting
01:11:56 Overfitting
- A function can particular data really well, but that doesn't mean it will generalise to new data.
- "Craft of Deep Learning is about creating models with proper fit"
- Only way to do it is to check the metrics on data the model wasn't trained on.
01:13:50 fastai will improve your programming skills
- May show you a style of coding (especially in Python) you're unfamiliar with
- Lots of times fastai doesn't follow traditional approach to Python
- If you use Python at work, likely want to follow a different style guide to fastai's
01:06:23 Fastai applications
- The same API used for classify Cats and Dogs can be used for:
- Segmentation (classifying pixels)
- Natural language processing (for example, sentiment analysis)
- Structured data
- Collaborative filtering