Aula 31 – VGG 3 – Dropout – Data Augmentation – Batch Normalization

Voltar para página principal do blog

Todas as aulas desse curso

Aula 30                        Aula 32 (Ainda não disponível)

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

https://digitalinnovation.one/

Aproveito para deixar meus link de afiliados:

Hostinger

Digital Ocean

One.com

Automatize tarefas do dia a dia com python:

Curso Python Bot

Meus Canais no Youtube

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 31 – VGG 3 – Dropout – Data Augmentation – Batch Normalization

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 e na aula 30 misturamos Dropout com Data Augmentation.

Resultados:

VGG3 + Weight Decay – 74,84%
VGG3 + Dropout – 82,33%
VGG3 + Data Augmentation – 84,77%
VGG3 + Dropout + Data Augmentation – 83,79%

Nessa aula iremos misturar três técnicas: Dropout + Data Augmentation + Batch Normalization.

Normalização em lote ( Batch Normalization )

A normalização é uma ferramenta de pré-processamento de dados usada para trazer dados numéricos para uma escala comum, sem distorcer sua forma.

Geralmente, quando inserimos os dados em um algoritmo de aprendizado profundo, tendemos a alterar os valores para uma escala equilibrada.

A razão pela qual normalizamos é em parte, para garantir que nosso modelo possa generalizar adequadamente.

A normalização do lote é um processo de normalização para tornar as redes neurais mais rápidas e estáveis ​​por meio da adição de camadas extras em uma rede neural profunda.

A nova camada realiza as operações de padronização e normalização na entrada de uma camada proveniente de uma camada anterior.

Mas qual é a razão por trás do termo “Lote” na normalização de lote?

Uma rede neural típica é treinada usando um conjunto de dados de entrada chamado batch .

Da mesma forma, o processo de normalização na normalização em lote, ocorre em lotes, não como uma única entrada.

Treinar redes neurais profundas com dezenas de camadas é um desafio, pois elas podem ser sensíveis aos pesos aleatórios iniciais e à configuração do algoritmo de aprendizado.

Uma possível razão para esta dificuldade é que a distribuição das entradas para camadas profundas na rede pode mudar após cada mini lote, quando os pesos são atualizados.

Isso pode fazer com que o algoritmo de aprendizado persiga para sempre um alvo em movimento.

Essa mudança na distribuição das entradas para as camadas da rede é chamada de “deslocamento interno de covariáveis“.

A normalização de lote é uma técnica para treinar redes neurais muito profundas que padroniza as entradas para uma camada em cada mini lote.

Isso tem o efeito de estabilizar o processo de aprendizado e reduzir drasticamente o número de épocas de treinamento necessárias para treinar redes profundas.

O que vamos fazer então no nosso modelo?

Primeiro, vamos aumentar o número de épocas de treinamento de 200 para 400, para dar ao modelo mais oportunidade de melhorar.

Em seguida, podemos adicionar a normalização em lote em um esforço para estabilizar o aprendizado e talvez acelerar esse processo.

Para compensar essa aceleração, podemos aumentar a regularização deixando o dropout em um padrão crescente como fizemos na aula passada.

A definição do modelo vai ficar assim:

# 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(BatchNormalization())
    model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
    model.add(BatchNormalization())
    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(BatchNormalization())
    model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
    model.add(BatchNormalization())
    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(BatchNormalization())
    model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
    model.add(BatchNormalization())
    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(BatchNormalization())
    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 model

No ImageDataGenerator(), responsável pelo data augmentation, deixamos só: width_shift_range = 0.1, height_shift_range = 0.1 e horizontal_flip = True.

Veja como ficou:

# construct the training image generator for data augmentation
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"
)

O que mantivemos está em azul no código acima e o que foi retirado e que está comentado, está em vermelho.
Além disso, o que mudou foi apenas o número de épocas, então, na parte onde definimos o número de épocas fica assim:

# initialize the number of epochs and batch size
EPOCHS = 400
BS = 32

Vamos salvar o modelo para testar na próxima aula.

# save model
model.save('final_model.h5')

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.

Resultados Finais:

VGG3 + Weight Decay – 74,84%
VGG3 + Dropout – 82,33%
VGG3 + Data Augmentation – 84,77%
VGG3 + Dropout + Data Augmentation – 83,79%
VGG3 + Dropout + Data Augmentation + Batch Normalization – 89.85%

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 do VGG3 + Dropout + Data Augmentation + Batch Normalization ficou em 89.85%

Por essa aula é só.

Voltar para página principal do blog

Todas as aulas desse curso

Aula 30                        Aula 32 (Ainda não disponível)

Meu github:

https://github.com/toticavalcanti

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

Link do código fluente no Pinterest

Novamente deixo meus link de afiliados:

Hostinger

Digital Ocean

One.com

Obrigado, até a próxima e bons estudos. 😉