RDAG CAP02 2025 VA06 PYTHON APLICACAO CNN

Como podemos

utilizar uma CNN para classificar imagens
como deep learning?

Nesse momento do curso você já conhece

o que é de sinais artificiais,
o que é um pilar e também, e sobretudo,

que existem diversas arquiteturas
para trabalhar com regionais profundas.

Aqui vamos dar um destaque na CNN,
que são as bases para diversos

outros 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 se preocupar

a princípio, onde eles estão,
em qual posição da imagem estão também?

O fato é saber a qual classe
essa imagem pertence.

Vamos pro código.

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

mas como meu ambiente está desligado
e eu irei 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 o ponto aqui
de destaque do código e da saída.

Convido vocês a pegar um código pronto
e reproduzir no seu ambiente também,

testarem com outros parâmetros
e verificar o impacto disso na

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

a primeira tarefa a ser executada aqui
esse pipe install para nós

estabelecemos as versões
do TensorFlow e do caras.

É importante dar esse destaque
para saber exatamente

qual versão das bonecas vão utilizar,
porque dependendo da 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 boteco nós vamos

utilizar,
nós evitamos esse tipo de problema.

É claro que no desenvolvimento
padrão de proteínas,

a evolução é natural e é constante,
mas o desenvolvedor de 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 de bibliotecas

que estão utilizando
para evitar problemas futuros.

No nosso código também.

esse comando vai instalar

que no nosso ambiente o TensorFlow é o
queres nas versões aqui indicadas.

Se a gente não fala nada
e ninguém executa essa célula aqui

já vai ter uma versão do TensorFlow
e do queros instalados previamente.

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

a versão anterior
e instale estas versões em 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 vai aparecer para o que está falando

o seguinte
olha só, você pegou o ambiente já pronto,

você está desinstalando coisa,
instalando novamente, Ou seja, reinicie

o ambiente, vai aparecer uma mensagem
na tela pedindo, reinicie o ambiente

e tudo ok ou reiniciar
E como estiver na sua tela

ele vai ligar novamente seu ambiente
e ligar novamente esse ambiente.

Execução já com as teclas e 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 impostos necessários
para esse tipo de trabalho.

Vamos, portanto, insuflou.

Não parece bom para fazer alguns gráficos
também da parte desse Kalanick,

vamos importar a matriz de confusão
para exibir melhor

resultados da parte aqui de redes.

Vamos fazer alguns imports
de cor de código específicos

para trabalhar com pincel flow
para construir sistemas com de planning,

então rende sequenciais
as camadas das camadas.

Vamos importar várias camadas
que existem também.

O mecanismo de stopping scaling
para mudar a dimensão das imagens também.

E note que aqui estou importando também
a rede Ponto de VEJA de 16.

Poderia importar outra rede pré pronta
também.

Isto é importante aqui.

O pré

processamento das entradas
que vão alimentar essa rede.

Veja 16 Para pegar 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.

Agora começa com o código de verdade.

1/1 de nosso código,
Essa aqui é para carregar.

Ele está set para memória, ou seja,
eu não vou subir um arquivo de dados aqui.

Essa base de categorias de flores
são cinco alegorias possíveis.

Já está dentro do TensorFlow.

Isso é importante. Isso aqui para memória.

Então, estudando o Load,
carregar o TensorFlow Flowers

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

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 dados de treinamento, o dado de teste

e o labor 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
aqui desses arquivos, então

meu arquivo de treino
ele tem duas 1569 imagens

e a de teste tem 1101 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 quatro, quatro, dois por 1024 pixels

expressos em três canais RGB.

A mesma coisa para o treino,
a 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% e 50, ou seja,

eu não vou trabalhar com imagem
do tamanho original e vou escalá las

para ser tamanho de 150% e 50
a exportação sequência.

Mas Michel, a imagem é retangular.

Você está escalando em algo
quadrado, Não vai dar um problema

e não vai

ficar exatamente a mesma imagem
com a mesma proporção.

Mas você 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, dada essa
e essa tamanho desejado, 150% e 50,

eu vou fazer um resize
nos dados de treinamento,

passando o dado que eu
quero tanto na mente quanto o teste

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

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
a classe zero um, dois, três, quatro

cada, Lembo vai ser um vetor zinho com
cinco posições com valores entre 0 e 1.

Cada posição indica um tipo de flor.

Ou seja, deixei o lobo categórico
e mostrando aqui as novas dimensões.

Temos, por exemplo,
aqui para o treinamento

continuam as mesmas duas 1569 imagens

e agora escaladas em 150% de pixels,

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

E o leigo
fica exatamente como tinha previsto.

Cada lembo cada linha
aqui um Lembro 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 e com I0 no resto.

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

então vou fazer o primeiro modelo
tendendo 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 nessa imagem

de uma forma tipo um tipo dois,
tipo três, quatro, tipo cinco?

Vamos ao processo.

Para isso então, essa célula aqui está
um pouquinho grande, tem bastante código.

Vamos entender
ponto a ponto 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.

É nesse modelo sequencial
que eu chamo de rede módulo

rede modo,
porque é o modelo que vou fazer a mão.

Vou fazer do zero.

Outras abordagens são transfer
learning, fare tuning,

mas para o começo
vamos começar de uma rede

simples, treinada do zero desenhado,
uma captura a mão.

Então vamos lá, Eu vou desenhar a mão.

Essa arquitetura ela é sequencial.

Ela começa, vou adicionando camadas.

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

entra uma imagem de 150% e 50 pixels.

Só que eu vou dividir cada pixel
por dois, cinco, cinco

por quem vai fazer isso, lembra?

Cada pixel é expresso de zero até dois
cinco cinco, então quando eu divido

esse número por dois cinco cinco,
eu estou levando os dados da matriz

na matriz
aqui 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
congressional com 16 filtros

com ativação de linear
retificada em kernel tamanho dez.

Nessa janela deslizante
e vou engatar aqui uma camada de max,

porém depois faço uma outra camada
com personal, outra camada de max,

com outra camada com personal,
outra camada de Max Play.

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 com uma decisão,
mas fiz uma camada de extração de filters.

Será que essa é melhor
que tudo o que eu poderia fazer?

Não sei, provavelmente não.

Mas uma camada inicial
para indicar o seguinte arquitetura

é a gente que define.

Então eu decidi encadear
três relações seguidas aqui de display.

Em cada uma delas Poderia fazer diferente?

Poderia caricatura

tem as suas possibilidades
serem construídas com vantagens

e desvantagens
aqui que são criar uma textura simples.

Vá essa parte de distração.

Vamos a parte de decisão, Ou seja,

quando saímos dessa última camada,
nós temos uma ficha pronta.

Vamos então alimentar essa Fisher,
extrair dos dados de entrada

para fazer a classificação do modelo.

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

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

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

Depois eu vou trazer duas camadas
densas da camada densa,

fortemente conectadas
e totalmente conectadas,

que são uma camada oculta de uma RMN
tradicional.

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

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

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

Notem que minha função ativação aqui
é um soft max, Ou seja,

cada um dos neurônios da última camada
dos cinco neurônios vão ser ativados

alguma forma,
alguns muito pouco e outros bem mais.

Qual vai ser o legado final?

Max O que está mais ativado,
Mas eles são ativados.

Forma soft Cada um pode ser um pouquinho
ativado caso em alguma confusão

entre as classes, mas lembre, o final
é ativado pelo que foi mais ativado.

todas essas etapas aqui
eu defini a captura completa

da rede desde a etapa de CNN
Estação de turisticas

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

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

qual vai ser melhor,
qual vai ser a métrica que otimiza bem.

Na sequência
eu vou definir uma estratégia de stopping,

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

tendo uma paciência de cinco épocas

e quando o One Stopping for ativado eu vou

resgatar os melhores pesos

que isso quer dizer.

A gente quer dizer o seguinte

em tempo de treinamento
a gente está constantemente

olhando o dado da avaliação,
os acertos e os erros.

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

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

não estiver melhorando

de forma significativa por cinco épocas
consecutivas, eu vou parar o treinamento.

Ai mesmo.

Não importa em que época eu esteja, eu
vou parar porque não há sinais de melhora.

E depois que defino todas estratégias, aí
sim eu vou fazer o treinamento fitting

do modelo modelo aqui ensinado na mão,
definindo na mão de fato,

utilizando o mágico.

Eu aqui vou treinar utilizando dado
treinamento e seus lábios também.

Aqui só porque é um modelo que demora pra

rodar, eu coloquei bordar por no máximo
cinco épocas.

Eu poderia colocar 50 para colocar
as 500 aqui eu mantive pelo menos aqui.

Cinco
é o mínimo do mínimo para o seguinte.

O dado o treinamento, utilize 20%
para validação e selecione 32

entre duas imagens para fazer tamanho bate
e tem algum callback?

Você tem algo que modifica essa

sim uma estratégia de stop.

Note que aqui já está executado,
então também foi executando

a primeira época,
a segunda, terceira, quarta, quinta.

Notem que em minha lógica,
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 deixado

treinar por mais épocas,
com certeza esse modelo ficaria melhor.

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

porque já era o suficiente para entender
um pouco dos resultados que essa rede

definida do zero poderia trazer
enquanto 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.