RDAG CAP02 2025 VA06 PYTHON APLICACAO CNN

Como podemos
utilizar uma CNN

para classificar imagens
com o deep learning?

Nesse momento do curso,

você já conhece o que são
redes neurais artificiais,

o que é um deep learning
também e, sobretudo,

que existem diversas
arquiteturas

para trabalhar com redes
neurais profundas.

Aqui, vamos dar
um destaque na CNNs,

que são as bases para diversas
outras arquiteturas também,

inclusive para treinar outros
tipos de tarefas mais complexas,

como segmentação
e detecção de objetos.

Então, vamos começar o básico,
que é classificar imagens.

Será que, nessa imagem, nós
temos um objeto ou outro objeto?

Sem nos preocuparmos,
a princípio, onde eles estão,

em qual posição da imagem
eles estão, também,

o fato é saber a qual classe
essa imagem pertence.

Vamos para o código?

Bom, aqui no ambiente, eu estou
com o código já programado,

mas o meu ambiente
está desligado.

E, hoje, eu vou fazer
uma coisa diferente,

normalmente acabo
utilizando o código pronto

e vou executando
eles com vocês,

indicando, passo a passo,
o que está acontecendo.

Como esse código é um pouco
lento para ser reproduzido,

eu já vou trazer
o código executado

e vou fixar pontos de destaque
do código e da saída.

Convido vocês a pegarem
um código pronto,

reproduzirem no seu
ambiente, também,

testarem com outros parâmetros
e verificarem o impacto disso

em tempo de execução
e, também, nos resultados.

A primeira tarefa a ser executada
aqui é esse "pip install"

para nós estabelecemos as versões
do TensorFlow e do Keras.

É importante dar
esse destaque

para saber exatamente qual versão
das bibliotecas eu vou utilizar,

porque, dependendo do tipo
de versão que estamos utilizando,

pode haver alguma incompatibilidade
entre o código da versão antiga

e da versão nova, o que vai
quebrar nossa execução.

Quando a gente
estabelece exatamente

qual versão de biblioteca
nós vamos utilizar,

nós evitamos esse
tipo de problema.

É claro que, no desenvolvimento
padrão de bibliotecas,

a evolução é natural
e é constante,

mas os desenvolvedores
dessas bibliotecas

tendem a fazer uma versão
compatível com as anteriores.

No entanto, alterações podem
ocorrer quebrando códigos antigos,

então, nesse caso, é sempre
importante ficar de olho

nas versões das bibliotecas
que estamoso utilizando

para evitar problemas futuros
no nosso código também.

Esse comando vai instalar,
aqui no nosso ambiente,

o TensorFlow e o Keras
nas versões aqui indicadas.

Se a gente não fala nada
e nem executa essa célula aqui,

já vai ter uma versão do TensorFlow
e do Keras instalada previamente.

O que nós queremos
fazer aqui é o seguinte:

desinstalar a versão anterior

e instalar estas versões
no nosso ambiente.

Note pela saída
dessa célula

que é um tempinho para poder
instalar o que necessário.

Esse erro aqui é natural, faz parte
do processo de tentativa e erro.

Inclusive, esse erro vai aparecer
porque ele está falando o seguinte:

"olha só, você pegou
um ambiente já pronto,

você está desinstalando coisas
e instalando novamente",

ou seja, reinicie o ambiente,

vai aparecer uma mensagem na tela
pedindo "reinicie o ambiente".

É só dar "ok", reiniciar, dependendo
de como estiver na sua tela,

e ele vai ligar novamente
esse ambiente

e ligar novamente esse
ambiente de execução

já com as bibliotecas instaladas
nas versões que nós solicitamos.

Feito isso, nós podemos começar
com o código de verdade.

E, aqui, temos os imports
necessários

para esse tipo de trabalho.

Vamos importar
o TensorFlow, Numpy,

Seaborn para fazer
alguns gráficos também.

Da parte do sklearn, vamos
importar a matriz de confusão

para exibir melhor
os resultados.

Da parte de redes, vamos fazer
alguns imports de código específicos

para trabalhar
com o TensorFlow

para construir sistemas
com deep learning,

então redes sequenciais,
as camadas

das camadas, vamos importar várias
camadas que existem também.

O mecanismo
de Early Stopping,

Rescaling para mudar a dimensão
das imagens também.

E note que, aqui, estou
importando também

a rede pronta do VGG16.

Poderia importar outra
rede pré-pronta também,

e estou importando aqui
o pré-processamento

das entradas que vão
alimentar essa rede VGG16.

Para treinar uma rede do zero,
isso ainda não será necessário,

mas guarde essa informação,
porque vamos voltar logo, logo,

quando falarmos
de transfer learning.

Pois bem, então temos, aqui,
as camadas, os modelos específicos,

e, agora, a gente começa
com o código de verdade.

A primeira parte do nosso
código, essa célula aqui,

é para carregar o dataset
para memória, ou seja,

eu não vou subir um arquivo
de dados aqui,

essa base de categorias de flores,
são 5 categorias possíveis,

já está dentro do TensorFlow, estou
importando isso aqui para memória.

Então, estou dando
um load, carregar,

o TensorFlow "flowers",
tipo de flores,

já na proporção
de treino e teste,

e ele já vai carregar para gente
uma divisão em duas tuplas:

a tupla de treinamento
e a tupla de teste.

Tanto do ponto de vista
do dado em si,

o dado de treinamento,
o dado de teste,

e os labels de treinamento
e de teste também.

Note que até esse processo,
também, demora um pouquinho,

não muito, mas demora
um pouquinho também

para ser carregado, porque
é uma base grande, de fato.

Aqui, eu posso mostrar
o tamanho desses arquivos,

então o meu arquivo de treino
ele tem duas 2.569 imagens

e a de teste tem 1.101 imagens.

Não importa se estou
no treino ou no teste,

nós temos as mesmas
dimensões desses dados,

ou seja, cada imagem é
expressa, originalmente,

em 442 por 1024 pixels
expressos em três canais, RGB.

Mesma coisa para o treino,
mesma coisa para o teste.

Agora, a gente começa
pré-processando esses dados.

Estou dizendo o seguinte:

eu vou trabalhar com
o tamanho de 150 por 150.

Ou seja, eu não vou trabalhar
com a imagem no tamanho original

e vou reescalá-las para esse
tamanho de 150 por 150.

Aí você pode estar pensando:
"mas Michel, a imagem é retangular,

você está escalando em algo
quadrado, não vai dar um problema?"

É, não vai ficar exatamente a mesma
imagem com a mesma proporção,

mas isso vai preservar
os elementos essenciais

que são necessários para
reconhecer se é uma rosa,

ou uma orquídea, ou qualquer
outro tipo de flor também.

Pois bem, dado esse tamanho
desejado, 150 por 150,

eu vou fazer um resizing
nos dados de treinamento,

passando o dado que eu quero,
tanto de trainamento quanto o teste,

e gerando novos dados,
digamos assim, já reescalados.

E, agora, eu estou transformando,
além de transformar o dado em si,

vou transformar o label
para um formato categórico.

Ou seja, em vez de falar
que temos as classes 0, 1, 2, 3, 4,

cada, label vai ser um vetorzinho
com 5 posições,

com valores entre 0 e 1.

Cada posição indica um tipo de flor,
ou seja, deixei o label categórico.

E mostrando, aqui,
as novas dimensões,

temos, por exemplo,
aqui para o treinamento

continuam as mesmas
2569 imagens,

agora rescaladas
em 150 por 150 pixels,

e também continuam
expressas em três canais, RGB.

E o label fica exatamente
como tinha previsto.

Cada linha aqui é um label
de uma imagem diferente,

então essa primeira coluna
representa uma classe,

a segunda, terceira, quarta,
quinta, e assim por diante.

Ou seja, estou ativando a terceira
classe, entre aspas, aqui,

com I e 0 no resto.

Nesse ponto, eu posso começar
a construir nossos modelos.

Então, eu vou fazer o primeiro
modelo treinando do zero,

eu vou definir a arquitetura
e vou treiná-la do zero

a partir dessas imagens.

Ou seja, eu vou começar
com uma rede

com pesos totalmente aleatórios

e vou treinar, do zero,
como posicionar esses pesos

para, de fato, aprender
a classificar se, nessa imagem,

tem uma flor do tipo 1, tipo 2,
tipo 3, tipo 4 ou tipo 5.

Vamos ver o processo
para isso.

Então, essa célula aqui
está um pouquinho grande,

tem bastante código,

vamos entender ponta a ponta
o que estamos fazendo.

Nós sabemos que, para
definir o modelo profundo,

nós temos que definir
a arquitetura desse modelo.

Então, ele vai ser
um modelo sequencial,

ou seja, sai de uma camada,
vai para a próxima,

para a próxima,
para a próxima.

E, nesse modelo sequencial,
que eu chamo de "hand model"...

"Hand model" porque é
o modelo que vou fazer a mão,

vou fazer do zero.

Outras abordagens são
transfer learning, fine tuning,

mas, para o começo, vamos por
uma rede simples, treinada do zero,

desenhada uma arquitetura a mão.

Então vamos lá, eu vou desenhar
a mão essa arquitetura.

Ela é sequencial, ela começa
e eu vou adicionando camadas.

A primeira camada é uma camada
de reescalar o dado, ou seja,

entra uma imagem
de 150 por 150 pixels,

só que eu vou dividir
cada pixel por 255.

Por que a gente
vai fazer isso?

Lembra, cada pixel é
expresso de 0 até 255,

então quando eu divido
esse número por 255,

eu estou levando
os dados da matriz,

a matriz de pixels
da imagem, entre 0 e 1.

E fica um valor mais estável para
a rede conseguir aprender melhor

onde posicionar esses pesos
que modelam esse problema.

Beleza.

Então, no fundo, essa camada aqui
é uma camada de normalização.

Depois, eu já vou passar
para uma camada convolucional,

com 16 filtros, com ativação
de linear retificada

em kernel de tamanho 10,
essa janela deslizante.

E vou engatar, aqui,
uma camada de max pooling.

Depois, eu faço uma outra
camada convolucional,

outra camada de max pooling,
outra camada convolucional,

outra camada de max pooling,

e, pronto, terminei aqui
a minha arquitetura CNN.

Ou seja, terminei, aqui,
o encadeamento de camadas

que extrai características
da minha imagem de entrada.

Não está a camada inteira ainda,
falta a camada de decisão,

mas eu fiz uma camada
de extração de features.

Será que essa é melhor
arquitetura que eu poderia fazer?

Não sei, provavelmente não.

Mas é uma camada inicial
para indicar o seguinte:

a arquitetura é
a gente que define,

então eu decidi encadear três
convoluções seguidas de pooling

em cada uma delas.

Poderia fazer diferente?

Poderia, cada arquitetura
tem as suas possibilidades

de serem construídas
com vantagens e desvantagens.

Aqui, eu quis criar
uma arquitetura simples.

Dada essa parte de extração,
vamos a parte de decisão,

ou seja, quando nós saímos
dessa última camada,

nós temos uma feature pronta.

Vamos, então,
alimentar essa feature,

extrair dos dados
de entrada,

para fazer a classificação
do modelo.

E eu vou começar com uma camada
de achatamento, ou seja,

não importa o que vai sair
dessa última camada,

eu quero que isso vire um vetor,
uma linha e tantas colunas.

Depois, eu vou trazer
duas camadas densas,

duas camadas densas fortemente
conectadas, totalmente conectadas,

que são uma camadas ocultas
de uma RNN tradicional.

E eu termino com uma outra camada
densa totalmente conectada, no caso,

com 5 neurônios, porque
nós temos 5 classes.

Então, vai ser alguma delas
que vai ser ativada.

Notem que a minha função
de ativação aqui é um softmax.

Ou seja, cada um dos neurônios
da última camada, dos 5 neurônios,

vai ser ativados
de alguma forma,

alguns muito pouco
e outros bem mais.

Qual vai ser o label final?

Max, o que está
mais ativado.

Mas eles são ativados
de forma soft, ou seja,

cada um pode ser
um pouquinho ativado

caso tenha alguma
confusão entre as classes,

mas o label final é ativado
pelo que foi mais ativado.

Em todas essas etapas aqui, eu
defini a captura completa da rede,

desde de a etapa de CNN,
extração de características,

até etapa de aprendizado, de fato,
o que significa as características.

Agora, eu vou compilar o modelo
indicando qual vai ser o otimizador,

qual vai ser a minha loss,

qual vai ser a métrica que eu
vou otimizar também.

E, na sequência, eu vou definir
uma estratégia de early stopping,

ou seja, eu vou monitorar a acurácia
no conjunto de validação,

tendo uma paciência
de 5 épocas.

E, quando o early
stopping for ativado,

eu vou resgatar
os melhores pesos.

O que isso quer
dizer, gente?

Quer dizer o seguinte:
em tempo de treinamento,

a gente está constantemente
olhando o dado da validação,

os acertos e os erros.

Eu estou avaliando
a acurácia da validação.

Ou seja, se essa acurácia
no ______ de validação

não estiver melhorando
de forma significativa

por 5 épocas consecutivas, eu vou
parar o treinamento aí mesmo.

Não importa em que
época eu esteja,

eu vou parar porque não
há sinais de melhora.

E, depois que eu defino
todas as estratégias,

aí sim, eu vou fazer
o treinamento, fitting,

do meu modelo, modelo
aqui treinadona mão,

definindo na mão, de fato,
utilizando uma GPU.

Aqui, eu vou treinar utilizando
o dado treinamento

e seus labels também.

Aqui, só porque é um modelo
que demora para rodar,

eu coloquei que vou rodar
por, no máximo, 5 épocas.

Eu poderia colocar 50,
poderia colocar 500, tá?

Aqui, eu mantive pelo menos
5, é o mínimo do mínimo.

Falei o seguinte:

do dado de treinamento,
utilize 20% para a validação,

selecione 32 entre 2 imagens
para fazer tamanho do meu batch.

E tem algum callback?

Tem algo que modifica
esse treinamento?

Sim, uma estratégia
de early stopping.

Note que aqui já
está executado,

então ele foi executando
a primeira época,

a segunda, a terceira,
a quarta, a quinta.

Notem que a minha loss,
a função de perda, os erros,

foram melhorando, a minha
acurácia está aumentando,

a acurácia na validação
está aumentando também.

É o que eu esperava.

Essa pequena saída já mostra
que tem espaço para melhoria sim.

Se eu tivesse o deixado
treinar por mais épocas,

com certeza esse
modelo ficaria melhor.

Mas aí a gente parou
com 5 épocas mesmo,

porque já era o suficiente
para entender um pouco

dos resultados que essa
rede definida do zero

poderia trazer como vantagem
ou desvantagem

como classificador de imagem.

Dado esse momento que a rede
está treinada, temos que avaliá la.

Então vou dar um ponto evaluation
passando dados e os lembro de teste

indicando qual vai ser
e qual vai ser a acurácia.

Note a minha acurácia
no conjunto de teste foi 54%.

Não está muito bom.

Ok, ela aprendeu alguma coisa,
está um pouco acima do aleatório,

mas aprendeu

pouco, Ou seja, tem chance, tem chão
para poder conseguir aprender mais.

Só que como nós treinamos por pouco tempo,
o máximo que conseguiu aprender

foi para conseguir
fazer esse tipo de acerto. 54%.

No entanto, acurácia
pode ser uma métrica global meio vaga.

Ok, ela acertou 54% no teste,
mas será que acertou mais de uma classe?

Mas de outra?

Nós podemos tirar essa dúvida
com a matriz de confusão.

Aqui embaixo
temos a matriz de confusão cotada

e olhem só a distribuição
dos dados de teste nessa matriz.

Lembrem que a matriz,
que a diagonal principal são os acertos.

Então temos 220 acertos aqui

e 33 aqui, 130 nessa outra célula
e por aí vai.

Mas o que é fora da matriz
da diagonal principal são os erros.

E tem muito erro.

Tem muita confusão
entre as classes, ou seja,

não foi uma boa rede, não foi
um bom extrator de características.

Podemos fazer melhor?

Com certeza.

É aí que entra uma estratégia muito
importante, que é o Transfer Planning

Transfer Learning.

Eu transfiro o conhecimento de uma rede
pré treinada para outra tarefa de destino,

aproveitando de pesos que foram bem
escrutinados,

foram bem treinados,
que foram bem construídos e posicionados.

Vamos ver como isso funciona.

Então, aqui vou começar a trabalhar
com o transfer lane do modelo BG 16, então

eu vou voltar um pouquinho lá nos imports
para reforçar uma coisa importante

se eu vou fazer um transfer da VG 16,
é ela que eu tenho que importar,

Se vou trabalhar com uma outra rede,
tipo uma marionete?

Ela ela seria
ela queria importar aqui no caso

eu estou importando o pré processamento,
não de uma rede qualquer,

mas da rede de 16,
afinal é essa criatura que me interessa.

Dado isso,

vamos
ver o processo de construção do transfer.

Pronto,

o primeiro passo

Eu estou reconstruindo internamente
o teste e fazendo um pré processamento

dos dados de entrada
do treinamento e do teste.

O que esse método faz?

Essa pré
processando essas imagens da sua tarefa

na mesma escala daqueles dados grandes

que foram utilizados para treinar
a rede de origem do transfer learning.

vamos lá.

Aí está o básico
de fazer uma normalização dos dados

de treinamento e teste da nossa tarefa,
levando os parâmetros de distribuição

dos dados que foram utilizados
para determinar essa rede.

Nossa tarefa original.

E agora eu vou começar a fazer o transfer.

Aí de fato, eu vou criar o novo modelo,
o modelo de base

que ele vem
tendo de base, vendo que da BGG.

Ou seja, eu vou importar os pesos

que peso da rede vigente 16 pré treinado?

Imaginemos,
eu vou incluir a tarefa de classificação.

As últimas camadas
não devo defini la para minha tarefa?

E qual vai ser o input das imagens?

Qual o tamanho das imagens aqui no caso
e o tamanho do conjunto de treinamento,

por exemplo?

Pegando o jeito, essa para ser condizente,
de fato é outra coisa importante.

Meu bem, esse módulo é treinado,
Ele é treinável?

Não, não é.

O que isso quer dizer?

Esse aqui é um ponto muito importante,
que é a essência do transfer learning.

Eu peguei aquela mesma

rede, as mesmas camadas,
copiando os mesmos pesos já pré treinados.

Imaginei ET e falei essa rede
pode aprender.

Não, não pode.

Assim como você copiou esses pesos,
mantém como estão

e vão utilizar esses pesos pré treinados
para fazer uma extração de fichas

da minha data e meu dado de entrada,
que é o conjunto de imagens de flores.

Eu posso inclusive verificar
o resumo da arquitetura de base

e olha só que interessante,
bem maior do que a outra é o modelo DDG,

então ele parte de um conjunto de entrada,
no caso aqui

já em 150% e 50 pixels em três canais.

E aí começam no caso de duas camadas
convencionais,

uma camada e mais duas convencionais,
outro smartphone e assim sucessivamente.

Ou seja, eu não definir nada disso veio
pronto da BGG.

Ele tem um total de mais de

14 milhões de parâmetros de pesos
quando são treinava nenhum.

Ou seja, copia e cola
usa esses pesos já bem avaliados,

bem construídos, uma rede bem treinada
para extrair fichas para notas.

Nossa tarefa de destino.

O que
falta fazer é colocar a camada de decisão,

porque minha tarefa de classificação
é outra.

Lembra que eu imaginei que nós tínhamos
20.000 classes, mais de 20.000

classes aqui eu tenho só cinco,
então a decisão vai ser diferente mesmo.

Vou definir na camada de decisão,
inclusive da mesma forma

que eu fiz anteriormente.

E uma camada de entrada de achatamento
precisa criar um vetor de fichas,

duas camadas densas que são ocultas

e uma camada densa também
com cinco neurônios, também soft max.

Ou seja, é a mesma camada do modelo
feita a mão.

Aqui eu só mudei um pouquinho
o formato fim dele.

Olha só, cada camada
foi salva e uma variável.

O meu modelo de fato
com transfer learning,

ele é composto
do que uma sequência de camadas.

Eu tenho várias camadas no meu Buys módulo

que veio da BG 16,
então aquelas várias camadas estão aqui.

Passo para uma camada de achatamento
a camada densa um,

a segunda e a última
é a camada de predição.

Pronto, estou com meu modelo
pronto aqui eu mostro agora o resumo dele.

Olha como fica interessante

é a Veja 16 funcional.

Dizemos isso porque é exatamente
a mesma arquitetura dela

passando para as camadas aqui de decisão.

Ele tem mais parâmetros
ainda para serem aprendidos.

Passou de 14 milhões para 15 milhões.

Aqui, no caso, são 410.

São três novas, porque só quatro de dez
são três naves, um conjunto de 15 milhões.

Porque a maior parte desses conjuntos
de parâmetros nesses pisos e baias

vieram depois dizer já está pronta, já
treinada, já não é treinável, está fixa.

Agora essa parte tem de ser aprendida.

É da tarefa de classificação.

Então, Então agora tem que compilar
o modelo também.

Ou seja, vou dizer qual o seu otimizador
Allons a métrica a ser acompanhada.

Também vou definir meu stop
da mesma forma que fiz anteriormente.

É aí que eu vou de fato treinar o modelo.

note até antes de treinar o modelo.

As configurações são as mesmas do modelo
feito à mão

para fazer uma comparação justa.

Ou seja, eu mudei a extração da fichas.

No primeiro modelo
eu criei um estrutura de filters

feito por mim,
uma captura que acabei de definir

e no segundo modelo
eu vou utilizar uma extrator de filtros

da BG 16 já treinada por muito tempo,
muito bem

construída, em cima de uma base de dados
muito grande.

Agora sim, faço o treinamento
também utilizando a CPU,

então vou treinar com os ensinamentos
os leigos também para cinco épocas,

para ser uma comparação justa,
mesmo esquema de validação

bet size e qual callback vou utilizar?

E aqui nós temos a saída também por cinco
épocas.

Novamente essa saída de cinco épocas

nos mostram que tem espaço, melhoria.

Se eu tivesse deixado mais tempo
para treinar essa rede,

provavelmente o resultado
ficaria ainda melhor.

Notem Alonso está diminuindo a perda.

Acurácia está aumentando, A acurácia
na validação também está aumentando.

Ou seja, quanto mais tempo o treinamento
poderia melhorar, ainda mais.

Mas mesmo assim,
mesmo com apenas cinco épocas,

esse modelo, quando avaliado,

é o mesmo código na essência.

Mas aqui eu estou verificando

capacidade preditiva do meu modelo
feito por transport learning.

Olha a minha acurácia subiu para 92,
ou seja, pensado muito melhor do que eu

tinha anteriormente, então eu tinha 54%,
agora tem 92 inclusive.

Notem como ficou me uma grande confusão,

com muito mais acertos
e muito menos erros.

Portanto, é modelo muito mais
bem estável, digamos assim.

E qual é

de onde vem essa vantagem,
essa estabilidade, esse poder punitivo,

desse modelo de utilizar a força
do aprendizado de uma rede mais profunda,

que foi treinada numa base muito grande
por muito tempo.

Quando nós utilizamos a BG 16
como um extrator de fichas por modelo,

nós nos aproveitamos dos pesos e Bayes
bem treinados para fazer esse benefício

muito mais poderoso
do que aquele que eu defini anteriormente.

Então, só o fato de fazer
transfer learning já gerou um resultado

muito melhor
do que o modelo treinado do zero.

A última criatura é muito mais rasa.

Muito bom.

Nesse ponto nós temos a diferenciação
entre treinar o modelo sem ir do zero

ou utilizar estratégia

de transfer learning para criar modelos
mais sofisticados, com pouco esforço

daria para fazer algo diferente.

Sim, dá para combinar
transfer, learning, coffee tuning.

O que isso quer dizer?

Quando nós fizemos o transfer Planning,
nós pegamos a rede pré treinada

teve de 16 pontos a camada
extração de sítios e congelamos os pesos.

Nós podemos falar o seguinte olha,
até certa camada fica congelada.

Daí em diante pode refinar um pouquinho
mais, ou seja, vou fazer um vale

tuning,
um ajuste fino do modelo pré treinado

para minha tarefa de destino,
no caso, classificação de flores.

Como nós implementamos isso
da seguinte forma.

Aqui tem que dizer o seguinte
O meu modelo baseline

modelo de base aqui que é uma engine 16,
ela é treinável porque sim, Mas cuidado,

isso equilibraria o treinamento
de todas as camadas.

Aqui eu posso falar o seguinte
qual camada

nós vamos travar o treinamento é o modelo
possui 19 camadas.

Vou fazer um fake tuning na camada

13 daí em diante, ou seja,
eu vou pegar o Benz Model,

vou acionar
quanto layers todas as camadas dele

e da primeira
até esse ponto de corte até 13.ª.

Ela é treinável, não?

Ou seja, o que nós fizemos?

A princípio eu falei o seguinte 19
camadas, todas são três naves.

Depois eu voltei
corrigindo da primeira até a 13.ª.

Ela não é treinável
não só para ser treinável.

A 13.ª em diante até as últimas.

Ou seja,
o ajuste fino está nas últimas camadas.

Extração de características
e porque eu quero fazer isso.

Porque eu quero dar liberdade para rede,
ajustar extração de fichas,

não uma base qualquer, grande, robusta,
como a imaginemos, mas para mim

é tarefa de destino, que é simplesmente
classificar tipos de flores.

A partir disso, a gente.

Nós definimos também as mesmas camadas.

Aquele transfer comentado para falar
vou utilizar exatamente

as que eu tinha anteriormente,
nem preciso redefinir.

É o meu modelo com fine tuning

também modelo sequencial, ou seja,
sai de uma camada para a próxima.

Ele parte de base
modo que nós acabamos de alterar

conforme tuning e seguimos aqui
para a camada de achatamento dos sítios,

as camadas ocultas e a camada de decisão.

Quando eu exploro o que que é esse resumo?

É uma leitura parecida,
porque também temos aqui

a BGG como extrator de fichas

e também as camadas aqui de decisão.

E depois eu preciso
fazer os mesmos processo anteriormente,

ou seja, não vou entrar detalhes aqui
é o mesmo processo de comprar o modelo,

criar estratégia de stop e aí
sim vou treinar essa rede.

Ou seja, vamos treinar essa

ideia do modelo com finitude também,
com modelo, com condicionamento.

Esses leigos mesmo estratégia de épocas,
mesmo divisão de validação

também de eu utilizando o histórico
também.

E aqui, novamente,
para ser uma comparação justa, eu

deixei assim de treinar por cinco épocas
apenas.

De novo a Loss está melhorando

a acurácia na validação
está aumentando também,

mas tem chão,
tem bem espaço aqui para melhorar mais.

Se nós estivermos treinados
para, por exemplo, 50 épocas,

porque então as épocas?

Quanto mais tempo pode ser
que tenha refinado,

mais e menos tivesse colocado,
Por exemplo, 5000 épocas.

É exagero.

A partir do momento que a rede
percebe que ela não está melhorando mais,

o aprendizado, o mecanismo de estoque
interromperia o treinamento antes

mesmo de chegar nesse nível exarcebado
aqui de épocas, vou manter como cinco.

Quando nós testamos isso, nós

vemos que para aquele conjunto de teste
nós temos o quê?

Que foi essa?

Mas a acurácia foi 62 um.

Pode parecer um pouco frustrante

porque ficou pior do que o modelo
transform Learning.

Então vamos recapitular um pouquinho
as métricas que nós temos aqui.

O modelo treinado do zero,
com uma textura profunda,

mas não muito rebuscada
e gerou uma couraça de 54%.

O modelo de transfer planning
jogou esse estado para o 90,

mais de 90% de acerto
e agora o transfer lane com o Facetune

e derrubou um pouquinho
essa performance para 62%.

62 é melhor que 54.

Ou seja, fazer um transfer lane com tuning

é melhor do que treinar uma rede do zero.

No entanto, faltou
tempo para refinar essa rede, ou seja,

quando eu vou fazer um transfer learning

com fine tuning eu tenho que ajustar
os pesos, E o que isso quer dizer?

Que eu não consigo ajustar

todos esses pesos dessa rede profunda
com apenas cinco épocas,

eu precisaria de mais tempo.

De fato, de forma geral,
a medida performance

tende a ser, em teoria,
da seguinte forma você treinar

uma rede do zero vai te dar uma resposta,
uma certa taxa de acerto.

Quando você faz transfer learning
de uma rede profunda,

bem treinada,
esse resultado tende a melhorar bastante.

Quando você faz transfer lane
conforme tune, o resultado melhora

um pouquinho mais.

Não vai ser um salto de área tão grande
quanto do modelo simples para o transfer,

mas ele melhora um pouquinho.

No entanto, para verificarmos
se é feito na prática, é necessário

tempo, ou seja, temos que deixar a rede
treinando por mais tempo.

Portanto, por mais épocas.