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
# 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:
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.
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ó.
Meu github:
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:
Obrigado, até a próxima e bons estudos. ;)
