Deep Learning Brasilia - Lição 2

lucasosouza · March 27, 2018, 1:13am

Introdução

Na lição 2, vamos retomar alguns conceitos apresentados na aula 1 e explorar mais a fundo a metodologia e código apresentados no notebook lesson1.

Ao final, preparamos um desafio para testar nossas habilidades em deep learning usando a biblioteca fastai. Propositalmente escolhemos um desafio que não faz parte dos datasets padrões usados pelo fastai ou pelo Kaggle.

O papel do praticante de machine learning é conhecer as ferramentas, e entender o alcance da sua capacidade e suas limitações. Vamos colocar o framework do fastai a prova em um problema de mundo real apresentado como desafio em umas das principais conferências científicas de redes neurais, IJCNN, em 2011.

Agenda:
09:00-09:20 Dúvidas sobre a aula 1. Configuração dos espaços de trabalho no paperspace/crestle
09:20-10:40 Aula 2
10:40-10:50 Intervalo
10:50-12:00 Desafio!

Tópicos principais

Escolhendo uma learning rate: learning rate finder
Data augmentation (incremento de dados) através do módulo tfms
Learning rate scheduler padrão vs cosine annealing
Parâmetros num_cycle, cycle_len, cycle_mult (SGD com restart)
Fine-tuning e differential learning rate annealing
Walkthrough do projeto dog breeds classifier
Opcional: configurar uma máquina virtual na Amazon

Desafio

Baixe o desafio para sua máquina virtual no link: https://github.com/lucasosouza/fastai-projects/blob/master/DeepLearningBSB-Lesson2-Exercise.ipynb

git clone https://github.com/lucasosouza/fastai-projects
ou
wget https://raw.githubusercontent.com/lucasosouza/fastai-projects/master/DeepLearningBSB-Lesson2-Exercise.ipynb

Siga os passos no notebook. Descomente as linhas na célula 5 para baixar os dados (ou rode os comandos no terminal). Deve demorar cerca de 10 minutos para baixar os dados.

E boa sorte! Discuta sua solução no fórum, tire dúvidas, comente o porquê sua abordagem deu certo ou não deu certo. Vamos entender juntos como aplicar a metodologia fastai para resolver problemas diversos de aprendizado de máquina.

Quem bater o benchmark primeiro ganha uma cerveja no próximo happy hour Deep Learning BSB!! (pago pelo Christian)

E se achar qualquer erro, não hesite em comentar aqui, enviar uma mensagem direta ou enviar um pull request com a proposta de correção.

chris-redfield · March 27, 2018, 2:25am

Timeline dos vídeos

00:01:01 Revisão da Lição 1, classificador de imagem, estrutura PATH para training, learning rate, o que são as quatro colunas numéricas de output no Jupyter
00:04:45 O que é a Learning Rate (LR), LR Finder, mini-batch, ‘learn.sched.plot_lr()’ & ‘learn.sched.plot()’
00:15:00 Como melhorar seu modelo com mais dados, evitar overfitting, usar “different data augmentation” - 'aug_tfms
00:24:10 De volta ao Data Augmentation (DA), ‘tfms=’ and ‘precompute=True’, exemplos visuais de Layer detection and activation em redes pre-treinadas como a ImageNet. Diferença entre seu computador, AWS e Crestle. Por que usar ‘learn.precompute=False’ para Data Augmentation, impactos na Accuracy / Train Loss / Validation Loss
00:30:15 Por que usar ‘cycle_len=1’, learning rate annealing, cosine annealing, Stochastic Gradient Descent (SGD) with Restart approach, Ensemble; “superpoder do Jeremy”
00:40:35 Salve os pesos do seu modelo com ‘learn.save()’ e ‘learn.load()’, as pastas ‘tmp’ e ‘models’
00:43:45 Fine-tuning and differential learning rate, ‘learn.unfreeze()’, ‘lr=np.array()’, ‘learn.fit(lr, 3, cycle_len=1, cycle_mult=2)’
01:05:30 “A biblioteca Fast.ai, usada nesse curso, feita em cima do pytorch, é open-source ?” e “por que o Fast.ai trocou de Keras+TensorFlow para PyTorch, criando uma biblioteca de alto nível em cima dele ?”.

Pausa

01:11:45 Matriz de confusão - ‘plot_confusion_matrix()’ e rechecagem das fotos
01:13:45 8 passos fáceis para treinar um classificador de imagens “world-class”
01:16:30 New demo with Dog_Breeds_Identification competition on Kaggle, download/import data from Kaggle with ‘kaggle-cli’, using CSV files with Pandas. ‘pd.read_csv()’, ‘df.pivot_table()’, ‘val_idxs = get_cv_idxs()’
01:29:12 modelo inicial - “Dog_Breeds”, image_size = 64, CUDA Out Of Memory (OOM) error, ciclos
01:32:50 Dica “pro” do Jeremy: treine em um tamanho pequeno de imagem, depois use ‘learn.set_data()’ com um data set maior (como 299 por 224 pixels)
01:36:33 Usando “Test Time Augmentation” (‘learn.TTA()’) novamente
01:48:03 Como melhorar um modelo/notebook sobre raças de cachorros: aumente o tamanho da imagem e use uma arquitetura melhor. ResneXt (com um X) comparada com Resnet. Avertência para usuários de GPU: A versão “X” gasta de 2 a 4 vezes a memória, portanto necessita reduzir o Batch_Size para evitar OOM error

pierreguillou · March 27, 2018, 12:38pm

Uma boa explicação sobre como escolher um Learning Rate usando a função learn.lr_find() : What should my learning rate be?

pierreguillou · March 27, 2018, 12:48pm

Minha compreensão de “precompute = True” : “precompute = True”

pierreguillou · March 27, 2018, 1:02pm

Um thread para entender melhor a lição 2 : “Wiki: Lesson 2”

pierreguillou · March 27, 2018, 1:24pm

post What means cycle_mult. Interessante

pierreguillou · March 27, 2018, 1:29pm

Thread “Unofficial Deep Learning Lecture 2 Notes” Boa leitura

pierreguillou · March 27, 2018, 1:42pm

Blog “How (and why) to create a good validation set” da @rachel.

thgomes · March 27, 2018, 5:43pm

Boa tarde, galera.

Estou com o tempo corrido pra subir pro github mas segue o código com 93% na validação.

tfms = tfms_from_model(architecture, sz=32, sz_y=32, aug_tfms=transforms_basic, max_zoom=1.0)
data = ImageClassifierData.from_arrays(path=data_path,trn=(X_train, y_train),val=(X_val,y_val),test=(X_test),bs=64,classes=class_names,tfms=transformer)
learn.precompute=False
learn.fit(1e-2, 3, cycle_len=1)

Predict in test set

log_preds = learn.predict(is_test=True)
preds = np.argmax(log_preds, axis=1)

Evaluate

acc = sum(preds==y_test)/preds.shape[0]
print(“Accuracy in test set: {:.4f}”.format(acc))

lucasosouza · March 27, 2018, 7:20pm

Pessoal

Dica para quem é estudante:

Se inscreva no github student pack, aqui: https://education.github.com/pack

Um dos benefícios é $110 dolares de bonus na AWS:

Student Developer Pack members receive up to $110 in bonus AWS credits for a total of $75-$150

Abra uma conta na AWS, pegue o bônus (no github student pack tem instruções como) e veja no final da lição 2 como configurar sua instância para rodar o fastai em 5 minutos:https://youtu.be/JNxcznsrRb8?t=1h56m30s

Infelizmente na rede do TCU não será possível fazer acesso via SSH ou pela porta 8888 a instancia da Amazon, porque o IP não é estático. Mas pode usar pela rede do celular lá e em casa

abs

chris-redfield · March 29, 2018, 8:09pm

Iae galera, tentei a abordagem dos 8 passos sugerida, não deu muito certo…

Tentei agora a abordagem do @thgomes, rodei 3 epochs com as camadas congeladas, depois mais 3 com elas descongeladas, o resultado foi sinistro mesmo @_@

Se ainda der tempo quero minha cerveja @lucasosouza u.u

chris-redfield · March 29, 2018, 8:14pm

Em tempo, tá no GH: https://github.com/chris-redfield/fast.ai/blob/master/lesson2-DeepLearningBSB%20-%20exercise.ipynb

lucasosouza · March 29, 2018, 8:22pm

O benchmark é 97%. Você bateu 93%… por enquanto leva no máximo uma dose de 51

lucasosouza · April 3, 2018, 9:46pm

Coloque seu resultado no nosso leaderboard: https://bit.ly/2IrcRpC

pierreguillou · April 4, 2018, 9:23pm

Done (test accuracy : 0.9229 | 14 minutos de treinamento com 20 epochas)

E meu “GPU online service” preferido - hoje - é… Google Colab ! e é de graça

Nota : leia o passo-a-passo seguinte Fastest way to setup Fast.ai course notebooks , for free — using Google Colab and Clouderizer para usar a livraria Fastai no Google Colab.

pierreguillou · April 7, 2018, 10:37pm

Fotos do sábado 07/04/2018 com o Christian e o Lucas como instrutores. Legal

pierreguillou · April 14, 2018, 2:57am

Verifique a sua compreensão da lição 2

<<< Verifique a sua compreensão da lição 1 | Verifique a sua compreensão da lição 3 >>>

Oi pessoal,

Eu assisti novamente ao video da lição 2 (parte 1) para melhorar meu entendimento dela e tomei notas do vocabulário usado pelo @jeremy.

Vamos jogar um pouquinho ! Concorda ?
Você pode dar uma definição / uma URL / uma explicação para todos os termos e expressões a seguir?

Se sim, você entendeu perfeitamente a segunda lição!

PS: se você não quiser se testar ou se quiser checar as suas respostas, vá para o post “Deep Learning 2: Part 1 Lesson 2” do blog de @hiromi : " super travail !!! "

Image classifier
3 lines of code
the key point to train the model is the PATH to data
particular structure of the data folder with train, validation, test folders
each folder with subfolders cats and dogs
pretty standard data folder stucture
validation accuracy
image vizualisation
learning rate
epoch
dataset
training set loss
validation set loss
Deep Learning
minimum point of a function
function which has hundreds of million parameters
algorithm
what is the loss or error at this point choosen at random
what is the gradient at this point
learning rate
learning rate finder
mini batch
GPU
parallel processing power of the GPU effectively (generally 64 or 128 images at a time)
mini batch = iteration
learn.lr_find()
learn.sched.plot()
10-1 = 1e-1
we are not looking at the point with the lowest learning rate
hyper parameters
fastai library
Adam
momentum
learning rate optimizer
dynamic learning rate
make your model better : give more data
overfitting
specialization of the model
the model hast to generalize
more labeled data
data augmentation
rotation, flip, zoom
aug_tfms
tfms_from_model
transforms_side_on
transforms_top_down
each type of image has a particular data ugmentation
learning rate versus loss
the higher learning rate that gives the lower loss
all local mimina are the same
unfreezing layers
precompute=True
activation is a number (feature, level of confidence, probability)
save the activations for all images of the dataset
first time you train the model, it is longer than after when precompute=True
when precompute=true, data augmentation does not have an impact
learn.precompue=False
overfitting = your model does not generalize
stochastisc gradient descent with restarts
cycle_len=1
learning rate annealing
cosine annealing
learning rate schedule
learn.sched.plot_lr()
with SGDR, you do not need to retrain your model with new random values of the model parameters
even better for generalization, you can save parameters values befor the restart and get the average of them (cycle_save_name)
learn.save()
learn.load()
each time you create a new object learn, you start with a new model with new sets of weights
weights / parameters
fine tuning
pretrained model
we’ve learned new layers on top of the pretrained model
frozen layers are layers not trained
learn.unfreeze()
layer 1 looks for edges and gradients
the early layers need no training or a little
diferential learning rates
lr = array([lr1,lr2,lr3])
if images look like the imagenet ones, divide by 10. If not, divide by 3.
learn.fit(lr, 3, cycle_len=1, cycle_mult=2)
size of images
learn.freeze_to (if you want to freeze a particular layer)
number of cycles
cycle_mult multiplies the length of a cycle after each training through a cycle
hyper parameters
all our inout images mut be squared in terms of dimensions as the dimensions have to be consistent to be computed by the GPU
predictions on validation set
TTA : Test Time Augmentation on validation or test data set when you want to get the prediction values (take the average of predictions after data augmentation)
log_preds,y=learn.TTA()
accuracy(log_preds,y)
cropping images is not recommended
fastai library is Open Source
pytorch
library on top of pytorch because pytorch is not so easy to use
model to phone, tensorflow
confusion matrix
plot_confusion_matrix(cm, data.classes)
training a world class image classifier in 8 steps (there are 3 main steps in fact)
dogbreed kaggle competition
kaggle cli script
pandas
csv files
label_df = pd.read_csv(label_csv)
a pivot table
max_zoom : random zoom up to the choosen number (like 1.1)
cross validation indexes
val_idxs = get_cv_idxs(n)
mostly imagenet images size is 224 x 224 or 299 x 299
dictionary comprehension
list comprenhension
matplotlib
histogram
size of validation set
when I start training a model, I want to do it very fast : so, I need small images (like 224 x 224 or smaller)
CUDA memory error (you should decrease your batch size)
Kernel restart
the more classes you have and the more difficult to get an accuracy very high
if you train something on a smaller size, you can call learn.set_data(get_data(299,bz)) and pass in a larger dataset
learn.freeze()
fully convolutional architectures can handle pretty much arbitrary sizes
underfitting means that cycle_len is too short
dataset balanced or unbalanced
mainly 3 steps : search for the learning rate, train with frozen layers, train with unfrozen layers
improve the training by increasing image sizes and get a better architecture
deconvolution
resnet34
resnext50
satelite images (Planet dataset)
learn.sched.plot_loss()
Crestle
Paperspace
AWS, AWS credit
AWS setup : console, EC2, launch an instance, Community AMIs, fastai, p2.xlarge, launch, key pair, Public Ip adress, ssh
cd fastai
git pull
conda env update
don’t forget stopping your GPU on Crestle/Paperspace/AWS !

fredguth · May 29, 2018, 1:48am

Eu só fiquei sabendo hoje deste grupo de estudo aqui em Brasília. Muito legal! Estou seguindo o curso da Fast.ai sozinho, mas espero poder me juntar a vocês na parte 2.