Deep Learning Brasilia - Lição 2


(Lucas O. Souza) #1

<<< Post: Lição 1Post: Lição 3 >>>

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.


Brasília part 1 group
Deep Learning Brasília - Revisão (lições 1, 2, 3 e 4)
(christian Miranda) #2

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


(Pierre Guillou) #3

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


(Pierre Guillou) #4

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


(Pierre Guillou) #5

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


(Pierre Guillou) #6

post What means cycle_mult. Interessante :slight_smile:


(Pierre Guillou) #7

Thread “Unofficial Deep Learning Lecture 2 Notes” Boa leitura :slight_smile:


(Pierre Guillou) #8

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


(thiago gomes) #9

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))


(Lucas O. Souza) #10

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


(christian Miranda) #11

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


(christian Miranda) #12

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


(Lucas O. Souza) #13

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


(Lucas O. Souza) #14

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


(Pierre Guillou) #15

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

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

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.


(Pierre Guillou) #16

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


(Pierre Guillou) #17

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 ? :wink:
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! :sunglasses::sunglasses::sunglasses:

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 !!! :slight_smile: "

  • 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 !

Wiki: Lesson 2
Deep Learning Brasilia - Lição 3
Deep Learning Brasília - Revisão (lições 1, 2, 3 e 4)