Aula 28 – Tensor Flow – Keras – Conjunto de dados CIFAR-10 – VGG 3 – Weight Decay
Aula 28 – Tensor Flow – Keras – Conjunto de dados CIFAR-10 – VGG 3 – Weight Decay
Voltar para página principal do blog
Todas as aulas desse curso
Aula 27 Aula 29
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
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 28 – Tensor Flow – Keras – Conjunto de dados CIFAR-10 – VGG 3 – Weight Decay
CIFAR-10
Melhorando o Modelo
Na aula passada usamos a técnica de regularização chamada Dropout.
O Dropout não depende da modificação da função de custo ou perda.
Já o Weight Decay ou Redução de Peso, que é a técnica que vamos explorar nessa aula, precisa da atualização da função de perda para penalizar o modelo em proporção ao tamanho dos pesos do modelo.
Assim como o Dropout, o Weight Decay ou Redução de Peso, é um tipo de regularização usado para controlar overfitting do modelo.
Origem do Weight Decay
Classificação de imagens é um trabalho complexo para uma máquina, e em geral, dados do mundo real são bem complexos, com muitas variáveis envolvidas, e para resolver problemas complexos, precisamos de soluções complexas.
Ter menos parâmetros ou variáveis é apenas uma maneira de evitar que o modelo fique excessivamente complexo, mas, na verdade, é uma estratégia muito limitadora, porque não podemos perder informações importantes.
Mais parâmetros significam mais interações entre várias partes de nossa rede neural e mais interações significam mais não linearidades.
Essas não linearidades nos ajudam a resolver problemas complexos.
No entanto, não queremos que essas interações saiam do controle.
Então, se penalizarmos a complexidade, ainda usaremos muitos parâmetros, mas, evitaremos que nosso modelo se torne muito complexo.
Foi assim que surgiu a ideia da Redução de Peso.
Já testamos 100 épocas com Dropout, agora vamos testar 100 épocas com Weight Decay, e na próxima vamos usar a técnica de regularização Data Augmentation, e vamos comparar as 3 técnicas, para ver qual delas deu mais certo.
Definição do modelo
Veja que tiramos os Dropouts()
Eles estão comentados, mas, pode tirar ele, deixei só como referência.
O que tá em azul, é a parte que estamos mudando nessa aula.
# define cnn model
def define_model():
model = Sequential()
#bloco 1
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', kernel_regularizer=l2(0.001), input_shape=(32, 32, 3)))
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', kernel_regularizer=l2(0.001)))
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', kernel_regularizer=l2(0.001)))
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', kernel_regularizer=l2(0.001)))
model.add(MaxPooling2D((2, 2)))
#model.add(Dropout(0.2))
#bloco 3
model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', kernel_regularizer=l2(0.001)))
model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', kernel_regularizer=l2(0.001)))
model.add(MaxPooling2D((2, 2)))
#model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation='relu', kernel_initializer='he_uniform', kernel_regularizer=l2(0.001)))
#model.add(Dropout(0.2))
model.add(Dense(10, activation=tf.nn.softmax, name='logits'))
return model
Agora acesse o notebook para rodar o código:
Notebook da aula
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 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.
Antes de rodar o treinamento da rede, exclua a pasta de log que tá na mesma pasta do notebook, pra ter certeza que a pasta será criada do zero, limpinha, sem nenhum vestígio de algum log anterior.
