Relatório Rede Neural Convolucional Carro Autônomo
Relatório Rede Neural Convolucional Carro Autônomo
Relatório Rede Neural Convolucional Carro Autônomo
O objetivo deste trabalho é utilizar um framework de deep learning para treinar redes
neurais profundas a fim de controlar veículos ou robôs através da clonagem
comportamental.
1. Implementação 2
Arquivos implementados para o projeto: 2
Explicando o funcionamento 3
5. Considerações Finais 21
6. Referências bibliográficas 21
1
1. Implementação
O simulador escolhido foi o CarRacing-v0.
Disponível em: https://gym.openai.com/envs/CarRacing-v0/
2
Para gravar uma corrida manualmente para armazenar o lote de
imagens e rótulos
Digite: ```python3 grava_imagens.py pastaX```
Explicando o funcionamento
3
Rede Neural Convolucional com 4 camadas:
Net2 (
(conv1): Conv2d(3, 20, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(20, 40, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear(in_features=9000, out_features=100, bias=True)
(out): Linear(in_features=100, out_features=3, bias=True)
)
Esta rede neural conta com duas camadas convolucionais com 5 kernels, a primeira
camada tem 3 entradas e 20 saídas, a segunda camada convolucional tem 20 entradas e
40 saídas, a terceira camada é linear e contém 9000 features de entrada e 100 de saída e a
última camada contém 100 features de entrada e 3 de saída. Essa rede conta com
ativações do tipo RELU e camadas Max Pooling para condensar a figura.
Rede Neural Convolucional com 5 camadas:
Net(
(conv1): Conv2d(3, 20, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(20, 40, kernel_size=(5, 5), stride=(1, 1))
(dropout1): Dropout(p=0.5, inplace=False)
(fc1): Linear(in_features=9000, out_features=1000, bias=True)
(dropout2): Dropout(p=0.5, inplace=False)
(fc2): Linear(in_features=1000, out_features=1000, bias=True)
(dropout3): Dropout(p=0.5, inplace=False)
(out): Linear(in_features=1000, out_features=3, bias=True)
)
4
Onde, “treino”X é a pasta dos modelos treinados e “treinoXX_X.pt” é o último modelo
salvo pelo treinamento.
5
Tabela resumo dos dados obtidos referentes aos testes
Segue descrição dos treinos da “tabela resumo dos dados obtidos referentes aos
testes”. Nos treinos estão descritos o otimizador utilizado, a quantidade de épocas, o lote de
imagens é de 32 imagens, a taxa de aprendizagem e momentum, foi como forma de métrica
utilizou-se os dados da primeira e da última época de treinamento do custo de treinamento
e de validação, a acurácia de de cada um deles, a melhor acurácia encontrada. Nos
gráficos temos o primeiro gráfico que representa o Custo ao longo do treinamento por época
do treino em azul e em laranja da validação e no segundo gráfico, a Acuracidade ao longo
do treinamento por época, do treino em azul e em laranja a validação.
6
Treino com otimizador ADAM: clássico descida do gradiente
estocástico
Adam (Adaptive Moment Estimation) é um algoritmo de otimização que pode ser
usado para atualizar os pesos da rede de forma iterativa com base nos dados de
treinamento.
Treino 1
Épocas de treinamento = 20
Lote = 32 imagens
Taxa de aprendizagem = 1e-4
Otimizador = Adam
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 4 camadas
custo treinar: 31.8516 Acuracia: 18.3750 custo treinar: 6.0410 Acuracia: 29.1875
custo validar: 28.9976 Acuracia: 20.8125 custo validar: 5.2366 Acuracia: 29.6250
7
Treino 2
Como esse treinamento apresentava possibilidades positivas, foi realizado o
treinamento para 200 épocas:
8
Treino 3
Épocas de treinamento = 1000
Lote = 30 imagens
Taxa de aprendizagem = 1e-4
Otimizador = Adam
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 4 camadas
custo treinar: 32.3834 Acuracia: 19.3125 custo treinar: 0.0002 Acuracia: 31.500
custo validar: 29.4074 Acuracia: 21.1875 custo validar: 0.0001 Acuracia: 31.500
9
Treino 4
Como esse treinamento apresentava possibilidades positivas, foi realizado o
treinamento para 100 épocas:
Épocas de treinamento = 20
Lote = 32 imagens
Taxa de aprendizagem = 1e-4
Otimizador = Adam
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 5 camadas
custo treinar: 32.0055 Acuracia: 17.6250 custo treinar: 0.5788 Acuracia: 31.3125
custo validar: 27.9601 Acuracia: 20.8750 custo validar: 0.3064 Acuracia: 31.4375
10
Treino 5
Épocas de treinamento = 20
Lote = 32 imagens
Taxa de aprendizagem = 1e-4
Otimizador = Adam
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 5 camadas
custo treinar: 32.5690 Acuracia: 15.5000 custo treinar: 4.0257 Acuracia: 29.8125
custo validar: 29.4074 Acuracia: 21.1250 custo validar: 2.6711 Acuracia: 30.6250
11
Treino com otimizador descendente de gradiente estocástico SGD
No gradiente descendente estocástico (SDG - Stochastic Gradient Descent),
algumas amostras são selecionadas aleatoriamente em vez de todo o conjunto de dados
para cada iteração.
Treino 6
Épocas de treinamento = 20
Lote = 32 imagens
Taxa de aprendizagem = 1e-4
Otimizador = SGD
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 5 camadas
custo treinar: 34.5904 Acuracia: 11.4375 custo treinar: 34.0836 Acuracia: 14.3750
custo validar: 34.5260 Acuracia: 12.5625 custo validar: 33.9940 Acuracia: 16.8125
12
Treino 7
Épocas de treinamento = 100
Lote = 32 imagens
Taxa de aprendizagem = 1e-4
Otimizador = SGD, momentum = 0.09
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 5 camadas
custo treinar: 34.7849 Acuracia: 8.0625 custo treinar: 30.7290 Acuracia: 19.1875
custo validar: 34.7258 Acuracia: 6.5000 custo validar: 29.9203 Acuracia: 20.5625
13
Treino 8
Alguns autores sugerem que “O intervalo de valores a considerar para a taxa de
aprendizagem é menor que 1,0 e maior que 10 ^ -6. Taxas de aprendizado menores
exigirão mais períodos de treinamento. Por outro lado, maiores taxas de aprendizagem
exigirão menos períodos de treinamento. Além disso, tamanhos de lote menores são mais
adequados para taxas de aprendizado menores, dada a estimativa ruidosa do gradiente de
erro” (BENGIO, 2012) .
Sendo assim, ajustando os hiperparâmetros: taxa de aprendizado para 0.01 e
ajustando novamente o momentum para 0.3 em 30 épocas, percebeu-se que ao ajustar a
taxa do momentum houve uma redução nas oscilações existentes no custo de treinamento
e validação.
14
Treino 9
Épocas de treinamento = 100
Lote = 32 imagens
Taxa de aprendizagem = 0.01
Otimizador = SGD momentum = 0.3
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 5 camadas
custo treinar: 34.3847 Acuracia: 12.0625 custo treinar: 6.3303 Acuracia: 29.3125
custo validar: 34.0912 Acuracia: 17.0625 custo validar: 3.5900 Acuracia: 30.312
Podemos ver nas figuras que, apesar de 100 épocas não serem o suficiente, o custo
e a acurácia melhoraram significativamente. E com o modelo treinado do lote 97 o carro
autônomo consegue dar várias voltas na pista, mostrando-se promissor para o aumento de
épocas de treinamento.
15
Treino 10
Épocas de treinamento = 2000
Lote = 32 imagens
Taxa de aprendizagem = 1e-4
Otimizador = SGD momentum = 0.3
Função de custo = CrossEntropyLoss() (entropia cruzada)
Rede convolucional: 4 camadas
custo treinar: 34.6679 Acuracia: 6.5625 custo treinar: 6.7790 Acuracia: 29.3750
custo validar: 34.6545 Acuracia: 6.5625 custo validar: 6.7247 Acuracia: 29.3125
16
Treino 11 - Com alteração de comportamento
Para esse treino foi realizado um novo comportamento do tipo zig-zag, fora da pista
e com rodopio, com um novo grupo de imagens para treino.
custo treinar: 34.6679 Acuracia: 6.5625 custo treinar: 6.6400 Acuracia: 29.4375
custo validar: 34.6545 Acuracia: 6.5625 custo validar: 6.6194 Acuracia: 29.4375
17
4. Resultados obtidos do agente
Após os treinamentos com as duas redes neurais convolucionais escolheu-se os
modelos dos treinos considerados com melhor acurácia, ou seja, com maiores acertos e os
menores falsos negativos e falsos positivos em todas as épocas de validação para medir o
desempenho do agente. Para todas as simulações reduzimos a intervenção de aceleração
no agente em 50%, para que o mesmo conseguisse completar o percurso.
18
Rodando 10 simulações seguidas com o agente, podemos perceber que, em 30
segundos, esse modelo tem 50% de pontuação positiva e 50% de pontuação negativa. E a
média total dos 10 treinamentos foi de -983.924 pontos.
19
Modelo do Treino 11 para simulações com o agente (SDG com
2000 épocas)
O treinamento salvou ao total 170 modelos, considerando o de melhor acurácia é o
modelo 1993. Observando o gráfico do treino 10, isso fica claro, pois a curva do treinamento
cresce lentamente, a estabilização se daria com mais épocas de treinamento, mas pela
demora do treinamento não realizamos essa tarefa.
Observando o desempenho do agente (carro autônomo) no simulador, com esse
modelo, em todos os treinos foi um ótimo desempenho, sai pouco da pista e faz curvas,
como segue a tabela com alguns testes.
Para os testes limitamos a 30 segundos de simulação, avaliamos o total de pontos e
fizemos uma média de total de pontos por segundos.
20
5. Considerações Finais
Pode-se concluir que, ao realizar mudanças nos hiperparâmetros houve melhora nos
resultados obtidos.
Os testes com baixo número de épocas foram importantes para perceber alterações
de convergências nos gráficos de custo de treinamento e validação, bem como na evolução
da acurácia da rede, para então realizar novos testes alterando hiperparâmetros, com
maiores épocas.
Alterações no número de camadas nos modelos testados influenciaram no resultado
do aprendizado, concluindo-se que menos camadas resultaram em modelos mais precisos.
Com relação ao uso de otimizadores, vai depender da necessidade, o otimizador
ADAM alcança o mínimo global mais rapidamente mas para o nosso caso, o otimizador
SDG, com taxa de aprendizagem e momentum adequados foram mais eficazes. O
momentum ajuda a saber qual a direção do próximo passo com o conhecimento dos passos
anteriores, evitando as oscilações.
Comparando os modelos salvos ao longo dos treinamentos, para a posterior
inferência no agente, observou-se que entre os otimizadores Adam e SGD, o primeiro
chega a um nível de acurácia ótima no início do treinamento. Já o SGD evolui o valor da
acurácia até o fim do seu treinamento, tendo seu ápice entre as últimas épocas.
Também concluiu-se que o comportamento das entradas da simulação podem
conter distorções, pois elas não influenciam no resultado da rede neural.
Em conclusão, para que haja bom desempenho de um modelo, no desenvolvimento
de uma rede neural convolucional, o ajuste de parâmetros em relação ao número de
camadas, quantidade de kernel, otimizadores, taxa de aprendizagem, momentum, dropout,
como a quantidade de épocas a serem treinadas irão depender do tipo e quantidade de
informação que será interpretada e os resultados esperados.
6. Referências bibliográficas
Bishop, Christopher M. Pattern recognition and machine learning. Springer, 2006.
BROWNLEE, J. PyTorch Tutorial: How to Develop Deep Learning Models with Python.
Disponível em:
https://machinelearningmastery.com/pytorch-tutorial-develop-deep-learning-models/
21
SALU. (2017) Kaggle Dogs vs. Cats Redux on Floydhub. Disponível em:
https://shaoanlu.wordpress.com/2017/04/22/deep-learning-on-floyd-dogs-vs-cats-redux-kagg
le-competition/ and
https://github.com/shaoanlu/dogs-vs-cats-redux/blob/master/opt_experiment.ipynb
Hastie, Trevor, Robert Tibshirani, and Jerome Friedman. The elements of statistical learning:
data mining, inference, and prediction. Springer Science & Business Media, 2009.
Disponível em: https://web.stanford.edu/~hastie/Papers/ESLII.pdf
KINGMA, D. & BA, J. (2014) Adam: A Method for Stochastic Optimization. Disponível em:
https://arxiv.org/abs/1412.6980
22