‫Como é empolgante tudo isso, temos um longo caminho desde a batalha para obter nossas imagens e posturas, nossos rótulos em
‫tempos, preparando nosso dia na escolha de um modelo no hub tensor de fluxo, criando modelos de retorno de chamada.
‫Estamos finalmente no estágio em que estamos prontos para treinar nosso primeiro modelo de aprendizado profundo, então vamos criar
‫um treinamento de título, um modelo.
‫Agora vamos colocar um subconjunto de dados, porque se você se lembrar de
‫quando dividimos nossos dados, só vamos começar a treinar em 1000 imagens. Por que queremos fazer isso?
‫Então, vamos bem aqui, nosso primeiro modelo só vai treinar em mil imagens para ter certeza de que tudo está
‫funcionando.
‫Então é isso que estamos tentando fazer.
‫Estamos tentando minimizar nosso tempo entre os experimentos.
‫Portanto, começamos com um subconjunto de dados para ter certeza de que todo esse código, quero dizer, pode quebrar.
‫Direito.
‫Portanto, queremos ter certeza de que está funcionando antes de gastar muito tempo treinando em 10.000 imagens, porque o
‫treinamento em mil imagens irá muito mais rápido do que 10.000 imagens.
‫E você poderia imaginar que o mesmo aconteceria se você aumentasse para 100.000 imagens ou no caso de imagens líquidas
‫de catorze vírgula dois milhões.
‫Portanto, há mais uma variável que precisamos definir antes de entrar no treinamento de um modelo, que é o
‫número de épocas.
‫E assim, o número de épocas é quantas passagens de dados que gostaríamos que nosso modelo fizesse.
‫E um passe é, você pode imaginar, é equivalente ao nosso modelo, tentando encontrar padrões em cada imagem de cachorro
‫e ver quais padrões se relacionam com cada rótulo.
‫Vamos continuar com as épocas.
‫É igual a cem e vamos fazer algo legal aqui, vamos criar
‫um pequeno controle deslizante como fazíamos antes de Harran.
‫Em seguida, vamos criar o controle deslizante de tipo e os homens serão 10, os Macs poderão ser 100 e a etapa poderá
‫ser 10.
‫Olhe para isso.
‫Quão legal é isso?
‫Então, se quiséssemos fazer 10 épocas, poderíamos fazer 10.
‫Mas vamos mantê-lo em 100 porque obtivemos nosso retorno de chamada de parada precoce e veremos tudo isso
‫em ação em um segundo.
‫Mas, essencialmente, o que um passe de treinamento pode fazer se voltarmos ao nosso Keano, uma
‫época seria dar ao nosso modelo uma única chance de olhar todos os dados de treinamento e validá-los a partir deles.
‫100 épocas, então estamos dando ao nosso modelo até 100 chances de percorrer o conjunto de dados de treinamento e
‫descobrir os padrões.
‫Então vai para o que passa, vai passar por essas camadas.
‫Vamos passar nossas imagens de treinamento para nosso modelo.
‫Vai passar por essas camadas.
‫E então nosso modelo, à medida que aprende padrões, fará suposições sobre qual rótulo pertence a qual
‫imagem.
‫E quanto pior a suposição, maior será a perda.
‫Então é aí que entra Adam.
‫Lembre-se de que aquele cara no sopé da colina no International Hill Dissent Championships está dizendo
‫ao nosso modelo como ele pode melhorar seus palpites a cada época.
‫E então veremos como o nosso modelo está se saindo em um nível de precisão, porque temos aquele
‫juiz espectador na base da colina observando o desempenho do nosso modelo.
‫Então, novamente, se tudo isso não fizer sentido, fará mais sentido quando realmente começarmos a executar
‫um modelo.
‫Então, vamos fazer uma verificação final.
‫A verificação final é uma última vez para ter certeza de que estamos usando uma GPU, porque se não estivermos usando uma GPU,
‫esse treinamento do nosso modelo em imagens vai demorar muito, muito tempo.
‫Você viu logo no início que uma GPU pode acelerar nosso código em até 30 vezes e às vezes mais.
‫Vamos escrever esse código.
‫Certifique-se de que ainda estamos executando em uma GPU perent.
‫GPU.
‫Disponível e então vamos embora.
‫sim.
‫Se T. F. configuração, não menos dispositivos físicos.
‫E então queremos verificar G. P. UMA. caso contrário, não está disponível, então este é apenas o mesmo código que escrevemos acima.
‫Mas precisamos de uma GPU para executar isso em um período de tempo considerável.
‫Sim, também poderíamos ter verificado aqui.
‫Lembre-se, esse é um pequeno truque de atalho, mas adoro dizer esta impressão aqui agora.
‫Boom, temos um G. P. UMA. em execução, temos várias épocas configuradas, vamos
‫criar uma função simples que treina um modelo.
‫Então vamos corrigir isso aqui.
‫Vamos criar uma função que treina um modelo e a função vai criar um modelo usando criar modelo.
‫E então queremos configurar um décimo retorno de chamada da placa.
‫Usando nossa função daqui para frente, então crie.
‫Veja, é aqui que a criação de funções realmente entrou em jogo para nós aqui.
‫Caso contrário, teríamos que escrever o código ad hoc.
‫Mas, para começar, escrever funções leva um pouco mais de tempo, mas, a longo prazo, economizamos tempo.
‫Portanto, chame a função em nosso modelo, analisando os dados de treinamento e os dados de validação.
‫Várias épocas para treinar.
‫Que agora é uma caixa.
‫Justificamos isso com nosso pequeno controle deslizante doentio e os kovács, que são nossas funções auxiliares que
‫gostaríamos de usar e, finalmente, queremos que ele retorne o modelo, vamos mudar isso para redução.
‫Isso está parecendo fenomenal.
‫OK, vamos aqui.
‫Havia uma função para treinar e devolver um modelo treinado.
‫Então aqui estamos bem treinados.
‫Eu não posso acreditar que finalmente estamos fazendo isso.
‫Isso é incrível.
‫Estamos treinando nossa primeira rede de conhecimento e aprendizado profundo.
‫Assim, os trens recebem um modelo e retornam a versão treinada.
‫Bom e simples.
‫Lembre-se de que, embora estejamos entusiasmados, isso não significa que estamos perdendo nossos hábitos comunicativos,
‫então criaremos um modelo.
‫Então vamos modelar igual, digamos, é aqui que entra a função criar modelo.
‫Oh sim.
‫É tão gratificante escrever.
‫E então criamos uma nova sessão do conselho toda vez que treinamos uma modelo.
‫Porque lembre-se, com nossa placa Tensas, com nosso retorno de chamada de placa Tensas, na verdade chamamos apenas de Placa
‫Estancia.
‫Não precisamos daquele retorno de chamada que configuramos nossa função.
‫Portanto, se voltarmos aqui sempre que for chamado, será criada uma nova pasta no log's com a data
‫e hora atual.
‫Então, isso é importante porque toda vez que executamos nossas funções de modelo de trem, toda
‫vez que tentamos treinar um novo modelo, um novo experimento, estamos criando uma pasta de log, que podemos rastrear o desempenho de
‫nosso modelo.
‫Isso é muito útil mais tarde, quando tentarmos avaliar qual experimento se saiu melhor do que
‫outro.
‫E então ajustamos o modelo à passagem de dados nos callbacks que criamos.
‫Agora, novamente, provavelmente há uma maneira melhor de fazer essa função, mas estamos apenas tentando fazer
‫com que funcione.
‫E então podemos voltar depois de termos passado da fase de ajuste de um modelo pela primeira
‫vez e refiná-lo.
‫Vamos modelar para caber e vamos aprovar.
‫X é igual aos dados do trem, que é um lote de dados, se você se lembra, que contém as imagens e os rótulos.
‫Portanto, as épocas serão as épocas de Naameh, a. k. uma. quantas vezes nosso modelo tem permissão para ver os
‫dados de treinamento antes de parar?
‫Ou quantas chances nosso modelo teve de passar por todo o conjunto de dados de treinamento para encontrar padrões e, em seguida,
‫os dados de validação?
‫Ele vai ser um dado válido, que é um monte de dados também, ou lote de dados, desculpe, e a frequência de
‫validação é a frequência com que queremos testar os padrões que nosso modelo encontrou em nosso conjunto de validação.
‫E o definimos como um porque queremos que ele teste seus padrões encontrados no conjunto de treinamento nos
‫dados de validação a cada época.
‫Assim, uma vez que uma época e nossos retornos de chamada são a bordo de Bordewich, acabamos de criar
‫acima com nossa função e parar o whoof antecipadamente.
‫E então queremos voltar o modelo colocar um pouco.
‫Devolva o modelo ajustado.
‫Isso é legal e agora podemos ajustar nosso modelo aos dados.
‫Tão simples quanto ir.
‫Modelo, ECLSS, modelo de trem.
‫Você vê os benefícios da criação de funções, portanto, poderíamos executar essa função depois de fazer vários
‫experimentos diferentes posteriormente.
‫E então você está pronto agora?
‫Um pequeno petisco aqui.
‫Ao treinar um modelo pela primeira vez, especialmente em dados de imagem ou qualquer outro tipo
‫de dados de grande escala, a primeira época geralmente levará mais tempo em comparação com o resto.
‫Agora, isso ocorre porque as funções que escrevemos estão obtendo os dados e foram inicializadas.
‫Então, a. k. uma. carregando os dados na memória de nossa GPU.
‫Agora, usar mais dados geralmente leva mais tempo, por isso começamos com mil imagens e,
‫portanto, após a primeira época.
‫Certo, nós configuramos para que tenha um limite máximo de 100, o primeiro pode levar alguns minutos após
‫o primeiro parque aéreo, o APOC subsequente deve levar apenas alguns segundos.
‫Então você está pronto.
‫Vamos fazer isso juntos.
‫Os dedos cruzaram todas as nossas funções, porque na verdade isso depende de algumas linhas de código
‫aqui.
‫Digamos, se funcionar três para um.
‫Olha aquele prédio, um modelo com rede móvel V2.
‫Eu cruzei meus dedos.
‫Eu espero que você também.
‫Oh, sim, está começando.
‫Veja, lá vamos nós, época um de 100.
‫Porque a caixa está definida como 100.
‫Então, vai treinar para 25 etapas, o que significa o tamanho do nosso lote, então se formos teremos 800 imagens em nosso conjunto de
‫treinamento porque, lembre-se, começamos com mil.
‫Então, se dividirmos isso por 32, teremos vinte e cinco.
‫É por isso que o treinamento tem vinte e cinco etapas, porque há tamanho de lote trinta e dois e validação.
‫Se chegarmos a duzentos divididos por trinta e dois, vai ser arredondado.
‫Portanto, é arredondado para sete.
‫É por isso que temos validação.
‫Portanto, 200 imagens em relação a um bacharel são 30 a.
‫E veja isso.
‫Aqui vamos nós.
‫Cerca de cinco minutos, e aqui está o que estou falando com a perda, agora todas essas coisas
‫que criamos aqui em cima, então a perda.
‫Portanto, nosso objetivo é lembrar de minimizar a perda.
‫Porque estamos no topo do morro, temos medo de altura, queremos chegar ao fundo do
‫morro, quer minimizar a função de perda?
‫A perda é a altura do morro.
‫Nós descemos aqui.
‫Espero que esse número diminua, mas queremos maximizar a precisão.
‫Então é assim que saberemos se o nosso modelo está em treinamento ou não, se está aprendendo padrões,
‫essa perda deve diminuir, essa precisão deve aumentar.
‫Portanto, isso vai levar alguns minutos para superar a primeira época.
‫Vou esperar até que passe pela primeira época e, então, vou acelerar este vídeo e ver você assim
‫que passar da primeira época, porque você verá épocas subsequentes depois dessa.
‫Portanto, a Epoch dois em 100 vai ser bem rápida porque estamos usando uma GPU.
‫O único motivo pelo qual o primeiro demora um pouco é porque ele tem que carregar todas as imagens na memória da
‫GPU.
‫Verei você instantaneamente, mas para mim, levará cerca de três minutos.
‫Tudo bem, estou de volta.
‫Portanto, temos um ETA aqui, que representa o tempo estimado de chegada, faltam cerca de 12 segundos para a
‫primeira época, contanto que tudo corra conforme o planejado.
‫E então você pode ver que a perda diminuiu ligeiramente e a precisão aumentou.
‫Então, isso é uma coisa boa.
‫Agora, o que devemos ver no final desta primeira época, se estabelecermos corretamente, devemos dizer que isso se perde no
‫conjunto de treinamento e a precisão no conjunto de treinamento.
‫Devemos ver a perda nos dados de validação e a precisão no conjunto de validação aparecer a qualquer segundo agora.
‫Então, estamos apenas esperando.
‫Então, provavelmente o que ele está fazendo agora é um pouco mais de 12 segundos, mas
‫está carregando os dados de validação na memória para que possa calcular e avaliar o desempenho desse conjunto de dados.
‫Não acredito que estamos fazendo isso, somos como um modelo brilhando juntos em tempo real.
‫Isso é fenomenal.
‫Eu nunca fiz isso antes.
‫Contanto que seu código esteja funcionando.
‫Aqui vamos nós.
‫Olhe para isso.
‫Agora que temos isso, não estamos falando, temos essa métrica nos dados de treinamento e essa
‫métrica na validação.
‫Portanto, veja como nossa precisão está melhorando rapidamente.
‫Agora, eu disse a vocês que as épocas vão se acelerar.
‫Olhe para isso.
‫O primeiro demorou cerca de cinco minutos, mas estes demoram cinco segundos.
‫Já estamos em um ponto de precisão zero.
‫Isso é 100 por cento de precisão nos dados de treinamento.
‫Isso é uma loucura.
‫Então, o que isso está nos dizendo é que é uma coisa boa que nosso modelo está superdimensionando porque está tendo
‫um desempenho muito melhor nos dados de treinamento do que nos dados de validação.
‫Mas isso é ótimo, nosso modelo está funcionando, está encontrando padrões, está usando o que a rede móvel
‫V2 aprendeu e a rede de imagens e está aplicando em nossos cães.
‫A visão do cão do conjunto de dados está ganhando vida de tão arrojado.
‫Agora, espero que o seu esteja funcionando assim também, porque estamos treinando um modelo juntos em tempo real.
‫Isso é lindo.
‫Portanto, o que devemos ver é que, uma vez que a precisão da validação para de melhorar por várias épocas,
‫três, por causa de nosso retorno de chamada de parada antecipada, ele vai parar o treinamento.
‫Então, na verdade, não acho que chegaremos às 100 épocas, talvez nem mesmo perto, porque aqui estamos
‫obtendo um ponto zero de precisão com uma pequena perda em nossos dados de treinamento.
‫Aqui vamos nos.
‫Parou.
‫Meu coração está acelerando.
‫Isso foi fenomenal, então digo o que quis dizer, a primeira época demora um pouco porque
‫está carregando dados na memória depois de carregados, os dados iniciais na memória, a GPU está
‫indo, certo, hora de pisar no gás e ligará os pós-combustores ou o gás.
‫Sem freios, baby.
‫Portanto, alcançamos 18 de 100 épocas.
‫E podemos ver que nosso modelo em nosso conjunto de dados de treinamento está funcionando com 100 por cento de precisão.
‫Isso é muito louco.
‫1 0
‫Você tem que multiplicar esse número por 100.
‫A perda é bastante baixa.
‫Quer dizer, uma perda de zero é perfeita.
‫Mas podemos dizer que nosso modelo está superdimensionado porque tem um desempenho muito melhor nos dados de treinamento
‫do que nos dados de validação.
‫Portanto, se voltarmos, é como se nosso modelo tivesse memorizado os materiais do curso em vez dos princípios de solução de
‫problemas desses materiais do curso.
‫E está lutando para se adaptar a um conjunto de dados que não viu antes, também conhecido como um exame prático ou nosso conjunto de
‫validação.
‫Portanto, no momento, nosso modelo tem pouca capacidade de generalizar.
‫Acho que é o suficiente para um vídeo.
‫É muita emoção.
‫O que eu quero que você faça um pouco de lição de casa é antes de irmos verificar os logs do quadro
‫no próximo vídeo, porque já usamos nossa chamada do quadro Tenzer antes.
‫Eu quero que você verifique esta é uma pergunta é realmente importante depois que tentamos modelar.
‫Eu quero que você vá questionar.
‫Parece que nosso modelo está superalimentando porque está funcionando.
‫Muito melhor no conjunto de dados de treinamento do que no conjunto de dados de validação.
‫Quais são algumas maneiras de evitar o sobreajuste do modelo no aprendizado profundo, as redes neurais?
‫Então, vamos transformar isso em um knockdown.
‫Essa é uma questão que eu quero que você analise antes de passarmos para o próximo vídeo, quais são algumas maneiras de prevenir
‫um overfitting do modelo e redes profundas conhecidas?
‫Portanto, verifique isso mesmo se você não tiver certeza deles.
‫Eu só quero que você comece a ficar curioso sobre o que está acontecendo, e eu quero que você
‫pare de pegar nas pistas sobre quando seu modelo está superdimensionado, como um desempenho muito melhor no conjunto de dados de treinamento do
‫que no conjunto de dados de validação.
‫E uma pequena observação aqui, observe que o sobreajuste para começar é uma coisa boa.
‫Isso significa que nosso modelo está aprendendo.
‫Estou incrivelmente animado por termos acabado de treinar nossa primeira rede neural de aprendizado profundo juntos, usando
‫a visão do cão com aprendizado por transferência, está ganhando vida.
‫Portanto, concluímos o treinamento de um modelo, pelo menos um primeiro subconjunto de um modelo.
‫Isso não está nos dados completos.
‫Isso é apenas em mil imagens.
‫Portanto, nosso próximo passo é, se chegarmos à nossa palestra, o que estamos fazendo?
‫Portanto, ajustamos o modelo aos dados.
‫Ainda não fizemos uma previsão.
‫Então, o que podemos fazer é avaliar o modelo usando nossos callbacks da placa tensora para que você possa ver isso.
‫E então descobriremos como fazer uma previsão com nosso modelo treinado.
‫Parece um plano.
‫Então dê uma olhada nessa pergunta e vejo vocês no próximo vídeo.