Aula 30 – CIFAR-10 – VGG 3 – Dropout – Data Augmentation
Aula 30 – CIFAR-10 – VGG 3 – Dropout – Data Augmentation
Voltar para página principal do blog
Todas as aulas desse curso
Aula 29 Aula 31
Meu github:
https://github.com/toticavalcanti
Documentação oficial do TensorFlow:
https://www.tensorflow.org/
Quer aprender python3 de graça e com certificado? Acesse então:
https://workover.com.br/python-codigo-fluente
Python com Tensorflow
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook.
Sigam o Código Fluente no Instagram.
Código Fluente no Pinterest.
https://digitalinnovation.one/
Aproveito para deixar meus link de afiliados:
Hostinger
Digital Ocean
One.com
Toti:
https://www.youtube.com/channel/UCUEtjLuDpcOvR3mIUr-viOA
Backing track / Play-along:
https://www.youtube.com/channel/UCT3TryVMqTqYBjf5g5WAHfA
Código Fluente
https://www.youtube.com/channel/UCgn-O-88XBAwdG9gUWkkb0w
Putz!
https://www.youtube.com/channel/UCZXop2-CECwyFYmHbhnAkAw
Fiquem a vontade para me adicionar ao linkedin.
Notebook da aula
PIX para doações
PIX Nubank
Se quiser copiar o código do PIX:
00020126580014BR.GOV.BCB.PIX013643c5f950-535b-4658-b91f-1f1d135fe4105204000053039865802BR5925Antonio Cavalcante de Pau6009SAO PAULO61080540900062070503***6304946B
Aula 30 – CIFAR-10 – VGG 3 – Dropout – Data Augmentation
CIFAR-10
Recapitulando o que já fizemos
Partimos de um modelo base, um base line, que é a arquitetura VGG3.
Depois aplicamos as técnicas de regularização: Dropout na aula 27, Weight Decay na aula 28 e Data Augmentation na aula 29.
Resultados:
VGG3 + Weight Decay – 74,84%
VGG3 + Dropout – 82,33%
VGG3 + Data Augmentation – 84,77%
Nessa aula iremos misturar duas técnicas: Dropout + Data Augmentation.
Dropout + Data Augmentation
Nas aulas anterior, descobrimos que tanto o abandono(Dropout) quanto o aumento de dados(Data Augmentation) resultaram em uma melhoria significativa no desempenho do modelo.
Agora vamos experimentar a combinação dessas duas técnicas no modelo, para ver se o uso de ambas regularizações juntas, resultam em um melhor desempenho do modelo.
O código abaixo, do notebook dessa aula, completa do código de um modelo com dropout.
# define cnn model
def define_model():
model = Sequential()
#bloco 1
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=(32, 32, 3)))
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.2))
#bloco 2
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.3))
#bloco 3
model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(128, activation='relu', kernel_initializer='he_uniform'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
# compile model
opt = SGD(learning_rate=0.001, momentum=0.9)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])
return modelAumento de dados
# constrói o gerador de imagem de treinamento para aumento de dados
aug = ImageDataGenerator(
rotation_range = 20,
zoom_range = 0.15,
width_shift_range = 0.1,
height_shift_range = 0.1,
shear_range = 0.15,
horizontal_flip = True,
fill_mode = "nearest"
)
Dessa vez vamos rodar o treinamento com 200 épocas.
Usaremos o aug, EPOCHS e BS no treinamento, isto é, no model.fit().
Vamos passar o aug para a função model.fit(), chamando o método flow().
O método flow() cria um iterador.
Podemos facilmente iterar e gerar os lotes de dados através dele.
model.fit(
aug.flow(
trainX, trainY, batch_size = BS
),
validation_data = (testX, testY),
steps_per_epoch = len(trainX) // BS,
epochs = EPOCHS
)
Definiremos o batch_size como 32 e o número de épocas 200.
Lembrando que batch_size é o número de amostras que serão propagadas pela rede.
# initialize the number of epochs and batch size
EPOCHS = 200
BS = 32
Anaconda
O código dessa aula, eu rodei o código usando meu processamento local, já que o colab impõe limites de processamento e tempo em seu plano free.
Para isso, usei o jupyter notebook do Anaconda, criei um ambiente chamado tensorflow, instalei tudo que precisamos nele: o jupyter, o CMD.exe, o matplotlib, o tensorflow, o tensorboard…
Antes de executar o notebook localmente
Antes de rodar o notebook localmente, no painel do anaconda:
Painel do Anaconda
Abra o prompt no ambiente que você criou, no meu caso, o ambiente tensorflow, e rode na mesma pasta do notebook, o seguinte comando:
tensorboard --logdir logs --port 6006
O comando acima cria a pasta logs na pasta do notebook, e é onde serão colocados os dados gerados durante o treinamento da rede, dados relativos a como a rede evoluiu durante o treinamento, baseado nas precisões nos dados de treino e validação.
É onde o tensorboard vai ler os dados para plotar os gráficos, e também definimos a porta como 6006.
OBS. Na aula https://www.codigofluente.com.br/aula-03-computacao-quantica-instalando-o-anaconda-e-o-qiskit/ de computação quântica, eu mostro como instalar o Anaconda.
Conclusões
Lembre-se que os resultados podem variar devido à natureza estocástica do algoritmo ou procedimento de avaliação, ou por diferenças na precisão numérica.
Considere executar o exemplo algumas vezes e compare o resultado médio.
Neste caso, vemos não houve uma melhoria no desempenho do modelo, acabou ficando muito parecido com o que vimos com o VGG3 + Data Augmentation.
A precisão foi de: 83,79%.
Os gráficos mostram que o modelo chegou a 85% na época 197, mas depois caiu.
