Aprendizado de máquina e redes neurais - página 17

[MetaQuotes]

PyTorch para Deep Learning e Machine Learning - curso completo (descrição das partes 4-8)

PyTorch para Deep Learning e Machine Learning - Curso Completo

Parte 4

• 03:00:00 Nesta seção, o instrutor explica os diferentes métodos de manipulação de tensores no PyTorch, como remodelar, visualizar, empilhar, apertar, descomprimir e permutar. Reshape altera a forma de um tensor de entrada, view retorna uma exibição de um tensor com uma forma diferente, stacking combina vários tensores juntos vertical ou horizontalmente, squeeze remove todas as dimensões iguais a 1 e unsqueeze adiciona uma nova dimensão com um tamanho de 1. Por fim, permutar troca as dimensões de um tensor. O instrutor fornece exemplos de código para demonstrar cada um desses métodos e enfatiza a importância da manipulação da forma do tensor no aprendizado de máquina e no aprendizado profundo.
  
  
• 03:05:00 Nesta seção, o tutorial em vídeo explora como remodelar e visualizar tensores PyTorch. Remodelar requer compatibilidade com o tamanho original e pode ser feito usando as funções 'reformar' ou 'visualizar'. É importante observar que 'view' compartilha a mesma memória com o tensor original. Além disso, a função 'stack' concatena tensores ao longo de uma nova dimensão e a dimensão padrão é zero. Os usuários são aconselhados a salvar seus trabalhos com frequência, pois podem ocorrer erros ao usar o Google CoLab ou qualquer outra forma de Jupyter Notebooks.
  
  
• 03:10:00 Nesta seção, o instrutor apresenta os conceitos de apertar e desapertar no PyTorch. Para praticar o uso desses métodos, o visualizador é incentivado a consultar a documentação e experimentá-los. O instrutor demonstra o método squeeze em que dimensões únicas são removidas de um tensor de destino. Para visualizar as alterações feitas nos tensores durante essas operações, o instrutor sugere imprimir cada alteração e verificar o tamanho do tensor. Além disso, o instrutor enfatiza a importância de praticar esses conceitos várias vezes para se familiarizar com eles.
  
  
• 03:15:00 Nesta seção, o instrutor explica o conceito de adicionar e remover dimensões em tensores PyTorch usando os métodos "squeeze" e "unsqueeze". Ele demonstra os efeitos desses métodos adicionando e removendo dimensões de tensores e imprimindo suas formas. O instrutor também apresenta o método "permute", que reorganiza as dimensões de um tensor de destino em uma ordem especificada. Ele fornece um exemplo de como permutar pode ser usado com imagens e discute a importância de transformar dados em representações numéricas em aprendizado profundo.
  
  
• 03:20:00 Nesta seção, o instrutor ensina como permutar um tensor reorganizando suas dimensões usando o método permute() no PyTorch. O exemplo dado é um tensor de imagem onde a dimensão do canal de cores é movida para o primeiro índice. O instrutor explica que um tensor permutado é apenas uma exibição e compartilha a mesma memória que o tensor original, demonstrado pela atualização de um valor no tensor original e vendo o mesmo valor copiado para o tensor permutado. A seção também aborda a indexação no PyTorch e como ela é semelhante à indexação com NumPy, outra biblioteca popular de computação numérica.
  
  
• 03:25:00 Nesta seção, o instrutor apresenta como importar a tocha e mostra como criar um pequeno intervalo e remodelá-lo de forma compatível. O tutorial então se aprofunda na indexação com tensores e mostra como indexar na primeira e segunda dimensões. O tutorial também revela a funcionalidade de usar um ponto e vírgula para selecionar tudo de uma dimensão de destino. A seção termina com um desafio para reorganizar o código para obter o número nove.
  
  
• 03:30:00 Nesta seção, o instrutor demonstra como selecionar valores específicos de um tensor usando o PyTorch. Os exemplos envolvem a seleção de elementos de diferentes dimensões do tensor, especificando os valores de índice apropriados. O instrutor então desafia os visualizadores a tentar indexar o tensor para retornar valores específicos. Na próxima seção, o instrutor explica como os tensores PyTorch interagem com a popular biblioteca de computação numérica científica, NumPy. Como o PyTorch exige isso, há uma funcionalidade integrada para permitir uma transição fácil entre as matrizes NumPy e os tensores PyTorch.
  
  
• 03:35:00 Nesta seção, o vídeo discute como converter dados de tensores NumPy para PyTorch e vice-versa. Para ir de NumPy para PyTorch, o método arch.fromNumPy é usado no array NumPy, mas deve-se observar que o tipo de dados padrão do PyTorch é float32, enquanto o padrão do NumPy é float64. Portanto, pode haver a necessidade de especificar o tipo de dados durante a conversão. Também é importante observar que ao alterar o valor do array NumPy original, não altera o valor do tensor PyTorch se ele foi criado usando o método fromNumPy. Para ir de PyTorch para NumPy, pode-se usar o método maçarico.tensor.numpy().
  
  
• 03:40:00 Nesta seção, o vídeo discute como ir entre PyTorch e NumPy e os tipos de dados padrão de cada um. O tipo de dados padrão do PyTorch é float32, enquanto o tipo de dados padrão do NumPy é float64 e, se você alterar o tipo de dados no PyTorch, o tensor NumPy refletirá o tipo de dados original. O vídeo também aborda o conceito de reprodutibilidade em redes neurais e o uso de sementes aleatórias para reduzir a aleatoriedade nos experimentos. Ao definir uma semente aleatória, a aleatoriedade é aromatizada e o computador se torna mais determinístico, permitindo resultados mais reprodutíveis.
  
  
• 03:45:00 Nesta seção, o instrutor apresenta o conceito de aleatoriedade e reprodutibilidade no PyTorch. Dois tensores aleatórios são criados usando a função arch.rand e seus valores são impressos e comparados. O instrutor explica o conceito de semente aleatória, que é usado para criar aleatoriedade reproduzível no PyTorch. O valor de semente aleatória pode ser definido como um valor numérico de escolha, como 42, e depois usado em várias funções aleatórias para obter aleatoriedade com sabor. É importante observar que, se a função arch.manual_seed for usada, ela geralmente funcionará apenas para um bloco de código em um notebook.
  
  
• 03:50:00 Nesta seção do vídeo, a importância da reprodutibilidade no aprendizado de máquina e no aprendizado profundo é enfatizada e o conceito de semente aleatória é explicado. A semente manual é uma maneira de dar sabor à aleatoriedade dos tensores aleatórios do PyTorch e torná-los reproduzíveis. O documento de reprodutibilidade do PyTorch é recomendado como um ótimo recurso para aprender sobre reprodutibilidade. A seção também discute a execução de objetos PyTorch em GPUs para cálculos mais rápidos e como obter acesso a GPUs, incluindo o uso do Google Colab para uma GPU gratuita, Google Colab Pro para GPUs mais rápidas e tempo de execução mais longo e Google Colab Pro Plus para vantagens mais avançadas.
  
  
• 03:55:00 Nesta seção, o instrutor explica diferentes maneiras de acessar GPUs para tarefas de aprendizado profundo e aprendizado de máquina. As opções são usar o Google Colab, atualizar para o Colab Pro, usar sua própria GPU ou usar serviços de computação em nuvem como GCP, AWS ou Azure. O instrutor recomenda começar com o Google Colab, que é fácil e gratuito de usar. No entanto, se você precisar de mais recursos ou quiser realizar experimentos maiores, convém atualizar ou usar sua própria GPU ou computação em nuvem. O instrutor também mostra como obter uma GPU no Google Colab alterando o tipo de tempo de execução e verificando o acesso à GPU com o PyTorch.

Parte 5

• 04:00:00 Nesta seção, o instrutor explica como verificar o acesso à GPU com o PyTorch e configurar o código agnóstico do dispositivo. Usando o comando "torch.cuda.is_available()", o usuário pode verificar se o PyTorch pode acessar a GPU. Além disso, para executar o PyTorch, a variável do dispositivo deve ser definida para usar a GPU, se disponível, ou padrão para a CPU. Também é importante configurar o código agnóstico do dispositivo, que permite que o PyTorch seja executado na CPU ou na GPU, dependendo do que estiver disponível, configurando "args.device=torch.device('cuda' if arch.cuda.is_available() else 'cpu')" em scripts Python. O instrutor enfatiza que a configuração do código agnóstico do dispositivo é uma prática recomendada ao trabalhar com o PyTorch, pois permite que o código seja executado em diferentes dispositivos.
  
  
• 04:05:00 Nesta seção, o instrutor discute como o uso de GPUs pode resultar em cálculos mais rápidos e ser benéfico para modelos de aprendizado de máquina que trabalham com cálculos numéricos como operações de tensor. Para usar a GPU, tensores e modelos precisam ser transferidos para ela, e o PyTorch facilita isso com o método `to`. O código pode ser feito independente de dispositivo para que seja executado independentemente de uma GPU estar disponível ou não. Da mesma forma, os tensores também podem ser movidos de volta para a CPU, se necessário, e o método `cpu()` pode ser usado para isso. O instrutor enfatiza que os problemas do dispositivo são o terceiro erro mais comum no PyTorch e que é uma boa prática ter em mente o tipo de dispositivo no qual os tensores e modelos são armazenados.
  
  
• 04:10:00 Nesta seção, o instrutor discute os fundamentos do trabalho com PyTorch na GPU. Ele explica como alternar entre CPU e GPU e como evitar erros ao usar cálculos NumPy com tensores na GPU. Ele também incentiva os alunos a praticar o que aprenderam por meio de um conjunto de exercícios e um currículo extra disponível em learn.pytorch.io. Os exercícios são baseados no que foi abordado nas seções anteriores e os alunos são incentivados a usar a documentação do PyTorch para completá-los. Por fim, o instrutor dá dicas de como abordar esses exercícios no Colab configurando duas telas e importando a tocha.
  
  
• 04:15:00 Nesta seção, o instrutor discute os exercícios e o currículo extra do curso PyTorch. Os exercícios são baseados em código e incluem modelos para cada um dos exercícios. O currículo extra é baseado em leitura, e o instrutor recomenda passar uma hora passando pelo tutorial básico do PyTorch, início rápido e seções de tensor, bem como assistir ao "O que é um tensor?" vídeo. O instrutor também descreve o fluxo de trabalho do PyTorch, que inclui preparar os dados e transformá-los em tensores, escolher ou construir um modelo pré-treinado, selecionar uma função de perda e otimizá-la, construir um loop de treinamento, ajustar o modelo, avaliar o modelo, experimentar e melhorando, salvando e recarregando o modelo treinado. O instrutor incentiva os alunos a acompanhar o código e a documentação, pesquisar recursos, tentar novamente e fazer perguntas nos fóruns do PyTorch.
  
  
• 04:20:00 Nesta seção do vídeo, o instrutor começa abrindo um novo notebook no Colab e o intitula "01 PyTorch Workflow". Ele explica que eles se concentrarão em codificar juntos e criar um fluxo de trabalho completo do PyTorch, que envolve preparação e carregamento de dados, construção de um modelo de aprendizado de máquina no PyTorch, treinamento do modelo, avaliação do modelo e salvamento/carregamento do modelo . O instrutor também menciona que eles usarão o módulo nn no PyTorch, que contém todos os blocos de construção do PyTorch para redes neurais.
  
  
• 04:25:00 Nesta seção, o instrutor discute o uso do arch.nn no PyTorch, explorando os blocos de construção básicos para gráficos computacionais, que são usados em redes neurais. A combinação desses blocos de construção permite que cientistas de dados e engenheiros de aprendizado de máquina construam vários tipos de redes neurais. O instrutor enfatiza a importância da primeira etapa do fluxo de trabalho do PyTorch, que é preparar e carregar dados em uma representação numérica para o modelo aprender padrões. O tipo de representação numérica usada para codificar dados depende do tipo de dados. A segunda etapa envolve a construção de uma rede neural para aprender os padrões na representação numérica e, em seguida, usar os padrões aprendidos para tarefas específicas, como reconhecimento de imagem ou classificação de spam.
  
  
• 04:30:00 Nesta seção, o instrutor apresenta o jogo de duas partes no aprendizado de máquina, que envolve a conversão de dados em representação numérica e a construção de um modelo para encontrar padrões nessa representação. O instrutor então cria dados conhecidos usando a fórmula de regressão linear para demonstrar esse processo. O peso e o viés da fórmula são usados como parâmetros que um modelo aprenderá observando diferentes exemplos. O código em Python é usado para criar um intervalo de números, atribuir um valor à variável X e criar uma fórmula Y que é igual a peso vezes X mais viés. O comprimento e o valor de X e Y são exibidos e os dez primeiros valores de X e Y são exibidos.
  
  
• 04:35:00 Nesta seção, o instrutor discute a importância de dividir os dados em conjuntos de treinamento e teste no aprendizado de máquina. Ele usa a analogia de cursos universitários e exames para explicar o conceito. O conjunto de treinamento é semelhante a todos os materiais do curso, o conjunto de validação é como um exame prático e o conjunto de teste é o exame final. O objetivo é alcançar a generalização, para que o modelo possa se adaptar a dados não vistos. O instrutor enfatiza que dividir os dados corretamente é vital para criar um modelo preciso.
  
  
• 04:40:00 Nesta seção do curso completo do PyTorch, o instrutor discute a importância da generalização em modelos de aprendizado de máquina e os três conjuntos de dados comumente usados em treinamento e teste: conjuntos de treinamento, validação e teste. Ele também explica as divisões percentuais comuns usadas para cada um desses conjuntos, com o conjunto de treinamento geralmente tendo 60-80% dos dados e o conjunto de teste tendo 10-20%. O instrutor então demonstra como criar um conjunto de treinamento e teste usando um conjunto de dados de amostra com valores X e Y usando a indexação para selecionar o número apropriado de amostras para cada divisão. Por fim, ele explica que, embora muitas vezes haja um caso de uso para um conjunto de validação em conjuntos de dados mais complexos, os conjuntos de treinamento e teste são os mais usados.
  
  
• 04:45:00 Nesta seção, o instrutor enfatiza a importância de visualizar os dados escrevendo uma função chamada "previsões de plotagem" que será usada para comparar os dados de treinamento e teste. A função usa trem X, trem Y, teste X, teste Y e previsões como parâmetros e, em seguida, plota os dados de treinamento em azul usando um gráfico de dispersão com a biblioteca matplotlib. Os dados de teste são plotados em verde usando a mesma função de dispersão. A função também verifica se há previsões e, em caso afirmativo, plota-as usando a função de dispersão também. Ao visualizar os dados, fica mais fácil entender e interpretar.
  
  
• 04:50:00 Nesta seção do vídeo, o instrutor discute o processo de treinamento e avaliação de modelos de aprendizado de máquina. Eles explicam que o objetivo é treinar o modelo nos dados de treinamento para prever com precisão os valores dos dados de teste. Eles demonstram isso usando um conjunto de dados lineares simples, com os dados de treinamento plotados em azul e os dados de teste em verde. O instrutor então apresenta o conceito de regressão linear e prepara o terreno para a próxima seção, onde eles construirão um modelo PyTorch para regressão linear. Eles também fornecem algumas dicas de solução de problemas para o Google Colab.
  
  
• 04:55:00 Nesta seção do vídeo, aprendemos como criar um modelo de regressão linear usando PyTorch puro. O instrutor explica que o PyTorch é construído sobre o nn.module, que é como os tijolos de construção de Lego dos modelos PyTorch. Quase tudo no PyTorch herda de nn.module, e os módulos podem conter outros módulos, o que facilita a construção de redes neurais complexas. Em seguida, o instrutor nos conduz pelo processo de criação de um construtor com a função init, criando um parâmetro de pesos usando nn.parameter e definindo-o como parâmetros aleatórios usando a tocha.rand. O instrutor também explica como definir require_grad e dtype.

Parte 6

• 05:00:00 Nesta seção, o instrutor explica como criar um modelo de regressão linear usando o PyTorch. Eles começam criando uma classe para o modelo e inicializando-o com parâmetros para pesos e viés, que são adicionados automaticamente à lista de parâmetros quando atribuídos a um atributo de módulo. Eles então criam um método direto para definir a computação no modelo, que é baseado na fórmula de regressão linear. O objetivo do modelo é atualizar os parâmetros aleatórios para representar o padrão dos dados de treinamento por meio do gradiente descendente, que é a premissa do aprendizado de máquina.
  
  
• 05:05:00 Nesta seção, o instrutor discute o processo de ajuste de valores aleatórios para melhor representar os valores desejados de peso e viés nos dados, que é realizado usando dois algoritmos principais: gradiente descendente e retropropagação. O uso de 'requires grad equals true' é explicado como o acompanhamento de gradientes por meio de cálculos feitos usando o modelo, empurrando o algoritmo na direção certa. A importância da programação orientada a objetos e o papel do PyTorch na implementação desses algoritmos são enfatizados, com recursos adicionais sugeridos para ajudar a obter intuição para o código. O instrutor também destaca o fato de que, embora o modelo atual lide com conjuntos de dados simples com parâmetros conhecidos, conjuntos de dados mais complexos geralmente têm parâmetros definidos por módulos de nn para nós.
  
  
• 05:10:00 Nesta seção, o instrutor explica as principais conclusões da criação do primeiro modelo PyTorch. Todo modelo em PyTorch herda de nn.modgable e deve substituir o método forward para definir a computação que está acontecendo dentro do modelo. Além disso, quando o modelo aprende, ele atualiza seus pesos e valores de viés por meio da descida do gradiente e da propagação reversa usando o módulo arch.auto grad. O instrutor recomenda a verificação de dois vídeos vinculados na transcrição para uma compreensão completa desse conceito. Além disso, o instrutor apresenta alguns fundamentos de construção de modelo PyTorch, como o módulo arch.nn que contém todos os blocos de construção necessários para redes neurais.
  
  
• 05:15:00 Nesta seção, o instrutor explica os módulos fundamentais do PyTorch, incluindo o arch.nn, o arch.nn.module, o arch.optim e o arch.utils.dataset. O arch.nn.module é a classe base para todos os módulos de rede neural e requer que o método de encaminhamento seja sobrescrito, o que define o que acontece na computação de encaminhamento. Torch.optim contém algoritmos para otimizar os valores do modelo, que começa com valores aleatórios e ajusta para melhor representar os valores ideais. O instrutor também menciona a folha de dicas do PyTorch como um recurso útil para uma exploração mais aprofundada da biblioteca.
  
  
• 05:20:00 Nesta seção, o instrutor adiciona um pouco de cor e código ao fluxo de trabalho do PyTorch e aborda importantes módulos do PyTorch usados para criar conjuntos de dados, construir e treinar modelos, otimizar parâmetros do modelo, avaliar o modelo e melhorar por meio da experimentação. O instrutor mostra como verificar o conteúdo de um modelo PyTorch criando uma instância do modelo de regressão linear e usando parâmetros de ponto para ver o tensor de valores. O instrutor também define uma semente aleatória para criar os parâmetros com valores consistentes.
  
  
• Na seção 05:25:00 , aprendemos como os modelos de aprendizado profundo são inicializados com valores aleatórios para pesos e parâmetros de viés. Também aprendemos sobre a importância de usar valores de sementes aleatórios para reprodutibilidade. A premissa fundamental do aprendizado profundo é ajustar esses valores aleatórios para ficarem o mais próximo possível dos valores ideais por meio de descida de gradiente e propagação reversa, usando dados de treinamento. Na próxima seção, o vídeo abordará como fazer previsões com os valores de parâmetros aleatórios do modelo.
  
  
• 05:30:00 Nesta seção, o vídeo explica o processo de teste do poder preditivo de um modelo PyTorch. O método de encaminhamento do modelo pega os dados de entrada X e os passa pelo modelo para fazer previsões. O vídeo demonstra como testar o poder preditivo do modelo inserindo o teste X, que consiste em 10 variáveis, e observando a saída Y pred do modelo. O vídeo também aborda um erro comum que pode ocorrer durante a criação de um modelo PyTorch e fornece uma correção para ele.
  
  
• 05:35:00 Nesta seção, vemos as previsões do modelo executando os dados de teste usando o método Ford definido anteriormente. As previsões parecem chocantemente longe das previsões ideais. O código também apresenta o modo de inferência de tocha, que é um gerenciador de contexto usado para desabilitar o rastreamento de gradiente ao fazer previsões, permitindo que o PyTorch acompanhe menos dados e faça previsões mais rapidamente. Embora o arch no grad possa fazer algo semelhante, o modo de inferência tem algumas vantagens sobre o no grad, conforme explicado na documentação do PyTorch e em um tópico do Twitter fornecido no vídeo. Portanto, o modo de inferência é atualmente a forma preferida de fazer inferência.
  
  
• 05:40:00 Nesta seção, o vídeo explica a importância de usar o gerenciador de contexto do arch.inference_mode ao fazer previsões no PyTorch, pois garante que o modelo esteja no modo de inferência em vez do modo de treinamento. O vídeo também destaca que inicializar um modelo com parâmetros aleatórios pode resultar em baixo desempenho e oferece algumas opções de inicialização, como usar valores zero ou transferir parâmetros de outro modelo. O foco principal do vídeo, no entanto, é treinar um modelo passando de parâmetros desconhecidos para parâmetros conhecidos usando uma função de perda, que mede o desempenho ruim das previsões do modelo. O vídeo observa que os termos "função de perda", "função de custo" e "critério" costumam ser usados de forma intercambiável no aprendizado de máquina.
  
  
• 05:45:00 Nesta seção, o instrutor apresenta o conceito de uma função de perda, que é usada para medir o quanto as previsões de um modelo estão erradas em comparação com os resultados ideais. O instrutor usa o exemplo de medição da distância entre pontos vermelhos e verdes para explicar como uma função de perda pode ser calculada. O vídeo também aborda a importância de um otimizador, que leva em consideração a perda de um modelo e ajusta seus parâmetros, como valores de peso e viés, para melhorar a função de perda. A seção conclui explicando que os princípios de uma função de perda e otimizador permanecem os mesmos, seja para modelos com dois parâmetros ou modelos com milhões de parâmetros, sejam modelos de visão computacional ou modelos simples como aqueles que prevêem pontos em uma linha reta.
  
  
• 05:50:00 Nesta seção do curso PyTorch para Deep Learning e Machine Learning, o instrutor explica a importância de usar um otimizador para ajustar os parâmetros de um modelo para valores que diminuem a função de perda para melhorar a precisão do previsões. O PyTorch possui funcionalidade integrada para implementar funções de perda e otimizadores, e o instrutor se concentra na perda L1, também conhecida como erro absoluto médio, que mede a diferença absoluta entre os valores previstos e reais. O instrutor fornece um gráfico colorido para ilustrar o erro médio absoluto e mostra como implementar a função de perda usando o módulo NN do PyTorch. O objetivo do treinamento de um modelo será minimizar as distâncias entre os valores preditos e reais e, por sua vez, minimizar o valor geral do erro médio absoluto.
  
  
• 05:55:00 Nesta seção, o instrutor discute o papel do otimizador no aprendizado de máquina, que funciona em conjunto com a função de perda para ajustar os parâmetros do modelo, como peso e viés, para minimizar a perda. O PyTorch tem o arch.optim, onde vários algoritmos de otimização estão disponíveis, como Stochastic Gradient Descent (SGD) e Adam. Ambos ajustam aleatoriamente os parâmetros do modelo para minimizar a perda, mas é uma questão de escolher o mais adequado para um problema específico. A maioria opta pelo SGD, que começa com ajustes aleatórios e depois continua ajustando na direção que minimiza a perda até que nenhum ajuste adicional possa ser feito. O otimizador requer dois argumentos, parâmetros ou quais parâmetros o otimizador deve otimizar e a taxa de aprendizado (LR), o hiperparâmetro mais importante a ser definido ao otimizar.

Parte 7

• 06:00:00 Nesta seção, o instrutor explica o que são parâmetros de modelo e hiperparâmetros e seu papel no processo de aprendizado profundo. Os parâmetros do modelo são valores que o modelo define, enquanto os hiperparâmetros são valores definidos pelo cientista de dados ou engenheiro de aprendizado de máquina. A taxa de aprendizado é um hiperparâmetro e seu valor determina o tamanho da mudança nos parâmetros durante a otimização. Uma pequena taxa de aprendizado resulta em pequenas mudanças, enquanto uma grande taxa de aprendizado resulta em grandes mudanças. O instrutor também fala sobre a importância de escolher a função de perda e o otimizador apropriados para o problema específico. Por fim, o instrutor passa a explicar o processo de criação de um loop de treinamento no PyTorch.
  
  
• 06:05:00 Nesta seção, o instrutor discute as etapas necessárias para criar um loop de treinamento e um loop de teste no PyTorch. A primeira etapa envolve percorrer os dados várias vezes para melhorar as previsões e minimizar a perda, fazendo passagens para a frente pelo modelo. O instrutor explica que o avanço é quando os dados se movem pelas funções de encaminhamento do modelo e a perda é calculada comparando as previsões do modelo com os rótulos de verdade do terreno. O instrutor então apresenta o otimizador e explica que a passagem reversa calcula os gradientes de cada parâmetro em relação à perda, permitindo que o otimizador ajuste os parâmetros do modelo para melhorar a perda por meio da descida do gradiente. O instrutor destaca que o PyTorch implementa a propagação reversa e a matemática da descida do gradiente, tornando mais fácil para aqueles com formação matemática limitada aprender sobre aprendizado de máquina.
  
  
• 06:10:00 Nesta seção, o instrutor apresenta o conceito de gradiente descendente, que é usado para otimizar os parâmetros do modelo no aprendizado de máquina. Usando o exemplo de uma colina, o instrutor explica como o modelo precisa se mover na direção em que a inclinação é menos íngreme para chegar ao sopé da colina, o que representa uma perda zero. O instrutor então passa a escrever algum código para executar a descida do gradiente, o que envolve definir o número de épocas e definir o modelo para o modo de treinamento usando o parâmetro "requer graduação igual a verdadeiro". O instrutor também menciona que diferentes modos estão disponíveis para modelos pytorch e incentiva os espectadores a experimentar diferentes configurações.
  
  
• 06:15:00 Nesta seção do vídeo, o instrutor discute a implementação do passe direto para treinar um modelo PyTorch. A passagem direta envolve a passagem de dados pela função direta do modelo para fazer previsões, que são então comparadas com os valores reais de treinamento usando a função de perda MAE. A função optimizer.zero_grad() também é introduzida, o que define todos os gradientes como zero antes de calcular a perda retroativa e atualizar os parâmetros do modelo usando a descida do gradiente. Essas etapas são cruciais para entender como um modelo aprende e será ainda mais otimizado e funcionalizado em seções posteriores do curso.
  
  
• 06:20:00 Nesta seção, o instrutor repassa as cinco principais etapas de um loop de treinamento no PyTorch, que inclui o avanço, cálculo da perda, zerar os gradientes do otimizador, realizar a propagação reversa e passar o otimizador pela descida do gradiente . O instrutor observa que a ordem dessas etapas às vezes pode ser ambígua, mas é importante manter a etapa do otimizador após a retropropagação. O instrutor também explica por que os gradientes do otimizador precisam ser zerados em cada iteração para evitar o acúmulo nos loops. O instrutor sugere praticar a escrita de um loop de treinamento para entender melhor essas etapas e fornece uma música e recursos extras para aprendizado adicional.
  
  
• 06:25:00 Nesta seção do vídeo, o apresentador recapitula as etapas em um loop de treinamento no PyTorch, que envolve passagem direta, cálculo do valor de perda, zeramento dos gradientes do otimizador e realização de retropropagação na função de perda. O loop de treinamento ajuda o modelo a aprender padrões nos dados de treinamento, enquanto o loop de teste avalia os padrões em dados não vistos. O apresentador também explica por que zeramos os gradientes do otimizador e apresenta o conceito de retropropagação, que calcula o gradiente da função de perda.
  
  
• 06:30:00 Nesta seção, o instrutor explica o conceito de gradientes e curvas de função de perda no aprendizado profundo do PyTorch. Ao definir 'requires grad' como true para os parâmetros, o PyTorch é capaz de rastrear os gradientes de cada parâmetro e criar uma curva de função de perda para todos eles. O objetivo da retropropagação e da subsequente descida do gradiente é calcular o ponto mais baixo da curva, que representa a perda mínima. O instrutor explica o conceito de gradientes no aprendizado de máquina e como a descida do gradiente funciona com pontos de passo. Ao otimizar a perda de grau zero para trás, otimizando a etapa e requer graduação, o PyTorch faz muito desse trabalho nos bastidores, rastreando gradientes automaticamente e encontrando a parte inferior da curva.
  
  
• 06:35:00 Nesta seção, o instrutor discute o otimizador e a taxa de aprendizado. O otimizador pega os parâmetros do modelo e cria curvas para cada parâmetro usando um mecanismo chamado tocha autograd para cálculo de gradiente automático para se aproximar da parte inferior da curva. A taxa de aprendizado decide quão grande ou pequeno o otimizador altera os parâmetros a cada passo, com passos menores dados à medida que nos aproximamos da convergência. Além disso, o instrutor aborda as cinco etapas envolvidas no treinamento de um modelo, que inclui a inicialização do modelo, a definição do otimizador, a taxa de aprendizado, o cálculo do avanço, a propagação regressiva e a etapa do otimizador. Por fim, o instrutor menciona que esse loop pode ser transformado em uma função, o que ajuda a evitar repetições de códigos.
  
  
• 06:40:00 Nesta seção do "PyTorch for Deep Learning & Machine Learning - Full Course", o instrutor enfatiza a importância de escrever o loop de treinamento no PyTorch, pois é assim que o modelo aprende padrões e dados. O vídeo também fornece recursos adicionais sobre retropropagação e descida de gradiente para os interessados no conhecimento matemático. O instrutor explica que a escolha da função de perda e otimizador será específica para cada problema e recomenda perda MAE e perda L1 para problemas de regressão e perda de entropia cruzada binária para problemas de classificação. A seção termina com uma demonstração do loop de treinamento usando um modelo com apenas dois parâmetros e uma única época.
  
  
• 06:45:00 Nesta seção, o instrutor continua treinando o modelo de aprendizado de máquina usando o PyTorch e mostra como a função de perda está diminuindo à medida que os parâmetros do modelo são atualizados por meio da descida do gradiente. O instrutor enfatiza que um valor de perda menor indica melhor progresso do modelo e que as pequenas diferenças nos valores devido à aleatoriedade no aprendizado de máquina não devem ser preocupantes. O instrutor então desafia o visualizador a executar o código por 100 épocas e fazer previsões para ver o quão baixo eles podem obter o valor de perda. Por fim, o instrutor discute a importância do teste e provoca o próximo vídeo sobre como escrever código de teste.
  
  
• 06:50:00 Nesta seção, o instrutor discute a importância de pesquisar e aprender novos tópicos usando recursos externos como Google e documentação. Eles incentivam os alunos a tentar executar o código de treinamento por 100 épocas e examinar os valores e previsões de peso e viés. Em seguida, o instrutor explica o código de teste e a finalidade da função model.eval(), que desativa as configurações do modelo que não são necessárias para o teste, como dropout e camadas de normas de lote. Eles também discutem o propósito de arch.no_grad() e como ele desativa o rastreamento de gradiente durante o teste, já que nenhum aprendizado está acontecendo nesse estágio. Por fim, a seção termina com a gravação do passo adiante para o modelo no modo de teste.
  
  
• 06:55:00 Nesta seção, o vídeo ensina como criar previsões de teste e calcular a perda de teste usando o modelo zero no PyTorch. As previsões de teste são feitas no conjunto de dados de teste, que o modelo nunca viu antes, assim como avaliar o conhecimento de alguém sobre materiais que nunca viu antes. O vídeo explica a importância de não permitir que o modelo veja o conjunto de dados de teste antes de avaliá-lo para evitar resultados ruins. O código imprime a perda e o que está acontecendo a cada 10ª época enquanto o modelo está treinando por 100 épocas, e a perda diminui a cada época. O vídeo também discute o conceito de precisão do modelo, que pode ser impresso posteriormente.

Parte 8

• 07:00:00 Nesta seção, o instrutor analisa o vídeo anterior, no qual treinou um modelo e fez previsões em um conjunto de dados simples. Eles então desafiam o visualizador a encontrar maneiras de melhorar a capacidade do modelo de alinhar os pontos vermelhos previstos com os pontos verdes reais, possivelmente treinando o modelo por mais tempo. O instrutor então reexecuta o código por mais 100 épocas e mostra uma melhoria significativa na perda de teste e nas previsões do modelo. O instrutor enfatiza que esse processo de treinamento e avaliação de modelos é fundamental para o aprendizado profundo com o PyTorch e será usado no restante do curso. Eles também discutem a importância de acompanhar o progresso do modelo usando uma lista vazia para armazenar valores úteis.
  
  
• 07:05:00 Nesta seção, o instrutor explica por que é importante acompanhar os valores de perda e como podemos usá-los para monitorar o progresso de nosso modelo e aprimorá-lo em experimentos futuros. O trecho de código apresentado anexa a contagem de época, o valor de perda atual e o valor de perda de teste atual a diferentes listas para que possam ser plotados posteriormente. O instrutor demonstra um gráfico das curvas de perda geradas a partir das listas e explica seu significado. Uma curva de perda ideal deve começar alta e diminuir ao longo do tempo, representando um valor de perda decrescente.
  
  
• 07:10:00 Nesta seção, o instrutor explica como converter valores de perda de PyTorch para NumPy para plotá-los no Matplotlib. Ele mostra que é necessário convertê-los para NumPy, pois o Matplotlib só funciona com NumPy. Ele também explica como acompanhar as curvas de perda de treinamento e perda de teste e menciona que, se elas se igualarem em algum ponto, isso significa que o modelo está convergindo e a perda está chegando o mais próximo possível de zero. O instrutor então percorre o loop de teste e explica que é necessário passar os dados do teste pelo modelo, calcular o valor da perda do teste e imprimir o que está acontecendo durante o treinamento para acompanhar os valores do que está acontecendo. Por fim, ele sugere colocar todas essas etapas em uma função e fornece uma música de loop de otimização não oficial do PyTorch para lembrar as etapas.
  
  
• 07:15:00 aprenda nesta seção - os três métodos principais para salvar e carregar modelos no PyTorch. O primeiro método, arch.save, permite salvar um objeto PyTorch no formato pickle do Python. O segundo método, arch.load, permite que você carregue um objeto PyTorch salvo. E o terceiro método, arch.nn.module.loadStateDict, permite que você carregue o dicionário salvo de um modelo ou salve o dicionário de estado, que exploraremos no vídeo a seguir. Esses métodos são cruciais para salvar e reutilizar modelos, especialmente ao trabalhar com modelos maiores ou ao compartilhar modelos com outras pessoas.
  
  
• 07:20:00 Nesta seção, o instrutor explica o conceito de dicionários de estado e sua importância no PyTorch. O PyTorch armazena os parâmetros importantes de um modelo em um dicionário, chamado dicionário de estado, que contém o estado do modelo, incluindo os parâmetros que podem ser aprendidos, como pesos e vieses. O instrutor demonstra como salvar e carregar o modelo PyTorch pode ser feito salvando seu dicionário de estado usando os métodos maçarico.save e maçarico.carregar. Além disso, o instrutor oferece um desafio adicional ao usuário para ler e entender os prós e contras de salvar todo o modelo, em vez de apenas o dicionário de estado. Finalmente, o instrutor compartilha o código PyTorch para salvar o modelo e criar uma pasta chamada models.
  
  
• 07:25:00 Nesta seção do vídeo, o instrutor demonstra como salvar um modelo PyTorch usando o método recomendado de salvar o dict de estado. O modelo recebe um nome e o caminho é criado usando a biblioteca pathlib. Uma vez que o caminho esteja pronto, o dict de estado do modelo é salvo usando a função arch.save(), onde o primeiro parâmetro é o objeto e o segundo é o caminho onde o modelo deve ser salvo. O instrutor mostra como o comando LS é usado para verificar se o modelo está salvo no diretório models. O vídeo também fornece um guia para baixar o modelo salvo em uma máquina local ou no Google Drive. Além disso, o instrutor incentiva o visualizador a se desafiar lendo a documentação adiante e usando a função arch.load() para aprender como carregar um modelo salvo.
  
  
• 07:30:00 Nesta seção, o instrutor fala sobre o carregamento de um modelo PyTorch e como usar o método de carregamento de pontos da tocha. O dicionário de parâmetros salvo anteriormente da classe de um modelo será carregado como um deck de estado, e esta seção mostra como criar uma nova instância da classe de modelo de regressão linear e carregar o deck de estado salvo nela. O método de deck de estado de carga do módulo nn da tocha permite carregar o dicionário de estado diretamente na instância do modelo, enquanto o método de carregamento de ponto de tocha leva em F e passa para o caminho de salvamento do modelo onde o deck de estado anterior é salvo.
  
  
• 07:35:00 Nesta seção, o instrutor explica como salvar e carregar um modelo no PyTorch. Eles testam o modelo carregado fazendo novas previsões com os dados de teste e comparando-os com as previsões do modelo original usando a função equivalente igual a igual. O instrutor soluciona os problemas dos modelos que não são equivalentes fazendo um novo conjunto de previsões de modelo e testando a equivalência novamente. Eles cobrem os principais aspectos de salvar e carregar um modelo, mas sugerem a verificação de tutoriais para obter mais detalhes. O instrutor planeja reunir todas as etapas abordadas até agora nos próximos vídeos.
  
  
• 07:40:00 Nesta seção do vídeo, o instrutor passa por todo o fluxo de trabalho de aprendizado profundo usando PyTorch, incluindo importar PyTorch, salvar e recarregar modelos e criar código independente de dispositivo, que permite que o código use a GPU se disponível, ou a CPU por padrão se não. O instrutor incentiva os espectadores a fazer uma pausa e tentar recriar o código por conta própria, além de oferecer orientação e dicas úteis. O vídeo também aborda como criar conjuntos de dados fictícios e plotar pontos de dados, que serão usados para construir um modelo que aprenderá a prever os pontos verdes a partir dos pontos azuis.
  
  
• 07:45:00 Nesta seção, o instrutor demonstra como criar dados usando a fórmula de regressão linear de y igual a peso vezes recursos mais viés. Eles explicam que os princípios de construção de um modelo para estimar esses valores permanecem os mesmos e passam a criar os recursos x e y, que serão usados para prever os valores de treinamento e teste. Eles também dividem os dados em conjuntos de treinamento e teste e plotam os dados para visualizar os padrões nos dados.
  
  
• 07:50:00 Nesta seção, o instrutor apresenta o conceito de construção de um modelo linear PyTorch para os dados fictícios lineares fornecidos. Eles subclassificam nn.module para criar um modelo de regressão linear e inicializar os parâmetros usando camadas. A camada nn.Linear recebe recursos como entrada e saída e aplica uma transformação linear aos dados de entrada usando a mesma fórmula do modelo de regressão linear. As formas de entrada e saída do modelo dependem dos dados, e o instrutor destaca que diferentes exemplos de recursos de entrada e saída serão vistos ao longo do curso.
  
  
• 07:55:00 Nesta seção, o instrutor explica como usar a camada linear no PyTorch como uma camada pré-existente para criar um modelo. A camada linear é uma forma de regressão linear y igual a x, uma transposição mais b, in features, out features. Subclassificando nn.module, podemos criar uma camada linear e substituir o método forward para passar os dados pela camada linear, que realiza a computação direta predefinida. O poder do arch.nn do PyTorch é que ele cria os parâmetros para nós nos bastidores e não precisamos inicializá-los manualmente. Além disso, o instrutor discute os diferentes nomes para a camada linear, como transformação linear, camada de sondagem, camada totalmente conectada, camada densa e fluxo intensivo.

[MetaQuotes]

PyTorch para Deep Learning e Machine Learning - curso completo (descrição das partes 5-9)

PyTorch para Deep Learning e Machine Learning - Curso Completo

Parte 5

• 04:00:00 Nesta seção, o instrutor explica como verificar o acesso à GPU com o PyTorch e configurar o código agnóstico do dispositivo. Usando o comando "torch.cuda.is_available()", o usuário pode verificar se o PyTorch pode acessar a GPU. Além disso, para executar o PyTorch, a variável do dispositivo deve ser definida para usar a GPU, se disponível, ou padrão para a CPU. Também é importante configurar o código agnóstico do dispositivo, que permite que o PyTorch seja executado na CPU ou na GPU, dependendo do que estiver disponível, configurando "args.device=torch.device('cuda' if arch.cuda.is_available() else 'cpu')" em scripts Python. O instrutor enfatiza que a configuração do código agnóstico do dispositivo é uma prática recomendada ao trabalhar com o PyTorch, pois permite que o código seja executado em diferentes dispositivos.
  
  
• 04:05:00 Nesta seção, o instrutor discute como o uso de GPUs pode resultar em cálculos mais rápidos e ser benéfico para modelos de aprendizado de máquina que trabalham com cálculos numéricos como operações de tensor. Para usar a GPU, tensores e modelos precisam ser transferidos para ela, e o PyTorch facilita isso com o método `to`. O código pode ser feito independente de dispositivo para que seja executado independentemente de uma GPU estar disponível ou não. Da mesma forma, os tensores também podem ser movidos de volta para a CPU, se necessário, e o método `cpu()` pode ser usado para isso. O instrutor enfatiza que os problemas do dispositivo são o terceiro erro mais comum no PyTorch e que é uma boa prática ter em mente o tipo de dispositivo no qual os tensores e modelos são armazenados.
  
  
• 04:10:00 Nesta seção, o instrutor discute os fundamentos do trabalho com PyTorch na GPU. Ele explica como alternar entre CPU e GPU e como evitar erros ao usar cálculos NumPy com tensores na GPU. Ele também incentiva os alunos a praticar o que aprenderam por meio de um conjunto de exercícios e um currículo extra disponível em learn.pytorch.io. Os exercícios são baseados no que foi abordado nas seções anteriores e os alunos são incentivados a usar a documentação do PyTorch para completá-los. Por fim, o instrutor dá dicas de como abordar esses exercícios no Colab configurando duas telas e importando a tocha.
  
  
• 04:15:00 Nesta seção, o instrutor discute os exercícios e o currículo extra do curso PyTorch. Os exercícios são baseados em código e incluem modelos para cada um dos exercícios. O currículo extra é baseado em leitura, e o instrutor recomenda passar uma hora passando pelo tutorial básico do PyTorch, início rápido e seções de tensor, bem como assistir ao "O que é um tensor?" vídeo. O instrutor também descreve o fluxo de trabalho do PyTorch, que inclui preparar os dados e transformá-los em tensores, escolher ou construir um modelo pré-treinado, selecionar uma função de perda e otimizá-la, construir um loop de treinamento, ajustar o modelo, avaliar o modelo, experimentar e melhorando, salvando e recarregando o modelo treinado. O instrutor incentiva os alunos a acompanhar o código e a documentação, pesquisar recursos, tentar novamente e fazer perguntas nos fóruns do PyTorch.
  
  
• 04:20:00 Nesta seção do vídeo, o instrutor começa abrindo um novo notebook no Colab e o intitula "01 PyTorch Workflow". Ele explica que eles se concentrarão em codificar juntos e criar um fluxo de trabalho completo do PyTorch, que envolve preparação e carregamento de dados, construção de um modelo de aprendizado de máquina no PyTorch, treinamento do modelo, avaliação do modelo e salvamento/carregamento do modelo . O instrutor também menciona que eles usarão o módulo nn no PyTorch, que contém todos os blocos de construção do PyTorch para redes neurais.
  
  
• 04:25:00 Nesta seção, o instrutor discute o uso do arch.nn no PyTorch, explorando os blocos de construção básicos para gráficos computacionais, que são usados em redes neurais. A combinação desses blocos de construção permite que cientistas de dados e engenheiros de aprendizado de máquina construam vários tipos de redes neurais. O instrutor enfatiza a importância da primeira etapa do fluxo de trabalho do PyTorch, que é preparar e carregar dados em uma representação numérica para o modelo aprender padrões. O tipo de representação numérica usada para codificar dados depende do tipo de dados. A segunda etapa envolve a construção de uma rede neural para aprender os padrões na representação numérica e, em seguida, usar os padrões aprendidos para tarefas específicas, como reconhecimento de imagem ou classificação de spam.
  
  
• 04:30:00 Nesta seção, o instrutor apresenta o jogo de duas partes no aprendizado de máquina, que envolve a conversão de dados em representação numérica e a construção de um modelo para encontrar padrões nessa representação. O instrutor então cria dados conhecidos usando a fórmula de regressão linear para demonstrar esse processo. O peso e o viés da fórmula são usados como parâmetros que um modelo aprenderá observando diferentes exemplos. O código em Python é usado para criar um intervalo de números, atribuir um valor à variável X e criar uma fórmula Y que é igual a peso vezes X mais viés. O comprimento e o valor de X e Y são exibidos e os dez primeiros valores de X e Y são exibidos.
  
  
• 04:35:00 Nesta seção, o instrutor discute a importância de dividir os dados em conjuntos de treinamento e teste no aprendizado de máquina. Ele usa a analogia de cursos universitários e exames para explicar o conceito. O conjunto de treinamento é semelhante a todos os materiais do curso, o conjunto de validação é como um exame prático e o conjunto de teste é o exame final. O objetivo é alcançar a generalização, para que o modelo possa se adaptar a dados não vistos. O instrutor enfatiza que dividir os dados corretamente é vital para criar um modelo preciso.
  
  
• 04:40:00 Nesta seção do curso completo do PyTorch, o instrutor discute a importância da generalização em modelos de aprendizado de máquina e os três conjuntos de dados comumente usados em treinamento e teste: conjuntos de treinamento, validação e teste. Ele também explica as divisões percentuais comuns usadas para cada um desses conjuntos, com o conjunto de treinamento geralmente tendo 60-80% dos dados e o conjunto de teste tendo 10-20%. O instrutor então demonstra como criar um conjunto de treinamento e teste usando um conjunto de dados de amostra com valores X e Y usando a indexação para selecionar o número apropriado de amostras para cada divisão. Por fim, ele explica que, embora muitas vezes haja um caso de uso para um conjunto de validação em conjuntos de dados mais complexos, os conjuntos de treinamento e teste são os mais usados.
  
  
• 04:45:00 Nesta seção, o instrutor enfatiza a importância de visualizar os dados escrevendo uma função chamada "previsões de plotagem" que será usada para comparar os dados de treinamento e teste. A função usa trem X, trem Y, teste X, teste Y e previsões como parâmetros e, em seguida, plota os dados de treinamento em azul usando um gráfico de dispersão com a biblioteca matplotlib. Os dados de teste são plotados em verde usando a mesma função de dispersão. A função também verifica se há previsões e, em caso afirmativo, plota-as usando a função de dispersão também. Ao visualizar os dados, fica mais fácil entender e interpretar.
  
  
• 04:50:00 Nesta seção do vídeo, o instrutor discute o processo de treinamento e avaliação de modelos de aprendizado de máquina. Eles explicam que o objetivo é treinar o modelo nos dados de treinamento para prever com precisão os valores dos dados de teste. Eles demonstram isso usando um conjunto de dados lineares simples, com os dados de treinamento plotados em azul e os dados de teste em verde. O instrutor então apresenta o conceito de regressão linear e prepara o terreno para a próxima seção, onde eles construirão um modelo PyTorch para regressão linear. Eles também fornecem algumas dicas de solução de problemas para o Google Colab.
  
  
• 04:55:00 Nesta seção do vídeo, aprendemos como criar um modelo de regressão linear usando PyTorch puro. O instrutor explica que o PyTorch é construído sobre o nn.module, que é como os tijolos de construção de Lego dos modelos PyTorch. Quase tudo no PyTorch herda de nn.module, e os módulos podem conter outros módulos, o que facilita a construção de redes neurais complexas. Em seguida, o instrutor nos conduz pelo processo de criação de um construtor com a função init, criando um parâmetro de pesos usando nn.parameter e definindo-o como parâmetros aleatórios usando a tocha.rand. O instrutor também explica como definir require_grad e dtype.

Parte 6

• 05:00:00 Nesta seção, o instrutor explica como criar um modelo de regressão linear usando o PyTorch. Eles começam criando uma classe para o modelo e inicializando-o com parâmetros para pesos e viés, que são adicionados automaticamente à lista de parâmetros quando atribuídos a um atributo de módulo. Eles então criam um método direto para definir a computação no modelo, que é baseado na fórmula de regressão linear. O objetivo do modelo é atualizar os parâmetros aleatórios para representar o padrão dos dados de treinamento por meio do gradiente descendente, que é a premissa do aprendizado de máquina.
  
  
• 05:05:00 Nesta seção, o instrutor discute o processo de ajuste de valores aleatórios para melhor representar os valores desejados de peso e viés nos dados, que é realizado usando dois algoritmos principais: gradiente descendente e retropropagação. O uso de 'requires grad equals true' é explicado como o acompanhamento de gradientes por meio de cálculos feitos usando o modelo, empurrando o algoritmo na direção certa. A importância da programação orientada a objetos e o papel do PyTorch na implementação desses algoritmos são enfatizados, com recursos adicionais sugeridos para ajudar a obter intuição para o código. O instrutor também destaca o fato de que, embora o modelo atual lide com conjuntos de dados simples com parâmetros conhecidos, conjuntos de dados mais complexos geralmente têm parâmetros definidos por módulos de nn para nós.
  
  
• 05:10:00 Nesta seção, o instrutor explica as principais conclusões da criação do primeiro modelo PyTorch. Todo modelo em PyTorch herda de nn.modgable e deve substituir o método forward para definir a computação que está acontecendo dentro do modelo. Além disso, quando o modelo aprende, ele atualiza seus pesos e valores de viés por meio da descida do gradiente e da propagação reversa usando o módulo arch.auto grad. O instrutor recomenda a verificação de dois vídeos vinculados na transcrição para uma compreensão completa desse conceito. Além disso, o instrutor apresenta alguns fundamentos de construção de modelo PyTorch, como o módulo arch.nn que contém todos os blocos de construção necessários para redes neurais.
  
  
• 05:15:00 Nesta seção, o instrutor explica os módulos fundamentais do PyTorch, incluindo o arch.nn, o arch.nn.module, o arch.optim e o arch.utils.dataset. O arch.nn.module é a classe base para todos os módulos de rede neural e requer que o método de encaminhamento seja sobrescrito, o que define o que acontece na computação de encaminhamento. Torch.optim contém algoritmos para otimizar os valores do modelo, que começa com valores aleatórios e ajusta para melhor representar os valores ideais. O instrutor também menciona a folha de dicas do PyTorch como um recurso útil para uma exploração mais aprofundada da biblioteca.
  
  
• 05:20:00 Nesta seção, o instrutor adiciona um pouco de cor e código ao fluxo de trabalho do PyTorch e aborda importantes módulos do PyTorch usados para criar conjuntos de dados, construir e treinar modelos, otimizar parâmetros do modelo, avaliar o modelo e melhorar por meio da experimentação. O instrutor mostra como verificar o conteúdo de um modelo PyTorch criando uma instância do modelo de regressão linear e usando parâmetros de ponto para ver o tensor de valores. O instrutor também define uma semente aleatória para criar os parâmetros com valores consistentes.
  
  
• Na seção 05:25:00 , aprendemos como os modelos de aprendizado profundo são inicializados com valores aleatórios para pesos e parâmetros de viés. Também aprendemos sobre a importância de usar valores de sementes aleatórios para reprodutibilidade. A premissa fundamental do aprendizado profundo é ajustar esses valores aleatórios para ficarem o mais próximo possível dos valores ideais por meio de descida de gradiente e propagação reversa, usando dados de treinamento. Na próxima seção, o vídeo abordará como fazer previsões com os valores de parâmetros aleatórios do modelo.
  
  
• 05:30:00 Nesta seção, o vídeo explica o processo de teste do poder preditivo de um modelo PyTorch. O método de encaminhamento do modelo pega os dados de entrada X e os passa pelo modelo para fazer previsões. O vídeo demonstra como testar o poder preditivo do modelo inserindo o teste X, que consiste em 10 variáveis, e observando a saída Y pred do modelo. O vídeo também aborda um erro comum que pode ocorrer durante a criação de um modelo PyTorch e fornece uma correção para ele.
  
  
• 05:35:00 Nesta seção, vemos as previsões do modelo executando os dados de teste usando o método Ford definido anteriormente. As previsões parecem chocantemente longe das previsões ideais. O código também apresenta o modo de inferência de tocha, que é um gerenciador de contexto usado para desabilitar o rastreamento de gradiente ao fazer previsões, permitindo que o PyTorch acompanhe menos dados e faça previsões mais rapidamente. Embora o arch no grad possa fazer algo semelhante, o modo de inferência tem algumas vantagens sobre o no grad, conforme explicado na documentação do PyTorch e em um tópico do Twitter fornecido no vídeo. Portanto, o modo de inferência é atualmente a forma preferida de fazer inferência.
  
  
• 05:40:00 Nesta seção, o vídeo explica a importância de usar o gerenciador de contexto do arch.inference_mode ao fazer previsões no PyTorch, pois garante que o modelo esteja no modo de inferência em vez do modo de treinamento. O vídeo também destaca que inicializar um modelo com parâmetros aleatórios pode resultar em baixo desempenho e oferece algumas opções de inicialização, como usar valores zero ou transferir parâmetros de outro modelo. O foco principal do vídeo, no entanto, é treinar um modelo passando de parâmetros desconhecidos para parâmetros conhecidos usando uma função de perda, que mede o desempenho ruim das previsões do modelo. O vídeo observa que os termos "função de perda", "função de custo" e "critério" costumam ser usados de forma intercambiável no aprendizado de máquina.
  
  
• 05:45:00 Nesta seção, o instrutor apresenta o conceito de uma função de perda, que é usada para medir o quanto as previsões de um modelo estão erradas em comparação com os resultados ideais. O instrutor usa o exemplo de medição da distância entre pontos vermelhos e verdes para explicar como uma função de perda pode ser calculada. O vídeo também aborda a importância de um otimizador, que leva em consideração a perda de um modelo e ajusta seus parâmetros, como valores de peso e viés, para melhorar a função de perda. A seção conclui explicando que os princípios de uma função de perda e otimizador permanecem os mesmos, seja para modelos com dois parâmetros ou modelos com milhões de parâmetros, sejam modelos de visão computacional ou modelos simples como aqueles que prevêem pontos em uma linha reta.
  
  
• 05:50:00 Nesta seção do curso PyTorch para Deep Learning e Machine Learning, o instrutor explica a importância de usar um otimizador para ajustar os parâmetros de um modelo para valores que diminuem a função de perda para melhorar a precisão do previsões. O PyTorch possui funcionalidade integrada para implementar funções de perda e otimizadores, e o instrutor se concentra na perda L1, também conhecida como erro absoluto médio, que mede a diferença absoluta entre os valores previstos e reais. O instrutor fornece um gráfico colorido para ilustrar o erro médio absoluto e mostra como implementar a função de perda usando o módulo NN do PyTorch. O objetivo do treinamento de um modelo será minimizar as distâncias entre os valores preditos e reais e, por sua vez, minimizar o valor geral do erro médio absoluto.
  
  
• 05:55:00 Nesta seção, o instrutor discute o papel do otimizador no aprendizado de máquina, que funciona em conjunto com a função de perda para ajustar os parâmetros do modelo, como peso e viés, para minimizar a perda. O PyTorch tem o arch.optim, onde vários algoritmos de otimização estão disponíveis, como Stochastic Gradient Descent (SGD) e Adam. Ambos ajustam aleatoriamente os parâmetros do modelo para minimizar a perda, mas é uma questão de escolher o mais adequado para um problema específico. A maioria opta pelo SGD, que começa com ajustes aleatórios e depois continua ajustando na direção que minimiza a perda até que nenhum ajuste adicional possa ser feito. O otimizador requer dois argumentos, parâmetros ou quais parâmetros o otimizador deve otimizar e a taxa de aprendizado (LR), o hiperparâmetro mais importante a ser definido ao otimizar.

Parte 7

• 06:00:00 Nesta seção, o instrutor explica o que são parâmetros de modelo e hiperparâmetros e seu papel no processo de aprendizado profundo. Os parâmetros do modelo são valores que o modelo define, enquanto os hiperparâmetros são valores definidos pelo cientista de dados ou engenheiro de aprendizado de máquina. A taxa de aprendizado é um hiperparâmetro e seu valor determina o tamanho da mudança nos parâmetros durante a otimização. Uma pequena taxa de aprendizado resulta em pequenas mudanças, enquanto uma grande taxa de aprendizado resulta em grandes mudanças. O instrutor também fala sobre a importância de escolher a função de perda e o otimizador apropriados para o problema específico. Por fim, o instrutor passa a explicar o processo de criação de um loop de treinamento no PyTorch.
  
  
• 06:05:00 Nesta seção, o instrutor discute as etapas necessárias para criar um loop de treinamento e um loop de teste no PyTorch. A primeira etapa envolve percorrer os dados várias vezes para melhorar as previsões e minimizar a perda, fazendo passagens para a frente pelo modelo. O instrutor explica que o avanço é quando os dados se movem pelas funções de encaminhamento do modelo e a perda é calculada comparando as previsões do modelo com os rótulos de verdade do terreno. O instrutor então apresenta o otimizador e explica que a passagem reversa calcula os gradientes de cada parâmetro em relação à perda, permitindo que o otimizador ajuste os parâmetros do modelo para melhorar a perda por meio da descida do gradiente. O instrutor destaca que o PyTorch implementa a propagação reversa e a matemática da descida do gradiente, tornando mais fácil para aqueles com formação matemática limitada aprender sobre aprendizado de máquina.
  
  
• 06:10:00 Nesta seção, o instrutor apresenta o conceito de gradiente descendente, que é usado para otimizar os parâmetros do modelo no aprendizado de máquina. Usando o exemplo de uma colina, o instrutor explica como o modelo precisa se mover na direção em que a inclinação é menos íngreme para chegar ao sopé da colina, o que representa uma perda zero. O instrutor então passa a escrever algum código para executar a descida do gradiente, o que envolve definir o número de épocas e definir o modelo para o modo de treinamento usando o parâmetro "requer graduação igual a verdadeiro". O instrutor também menciona que diferentes modos estão disponíveis para modelos pytorch e incentiva os espectadores a experimentar diferentes configurações.
  
  
• 06:15:00 Nesta seção do vídeo, o instrutor discute a implementação do passe direto para treinar um modelo PyTorch. A passagem direta envolve a passagem de dados pela função direta do modelo para fazer previsões, que são então comparadas com os valores reais de treinamento usando a função de perda MAE. A função optimizer.zero_grad() também é introduzida, o que define todos os gradientes como zero antes de calcular a perda retroativa e atualizar os parâmetros do modelo usando a descida do gradiente. Essas etapas são cruciais para entender como um modelo aprende e será ainda mais otimizado e funcionalizado em seções posteriores do curso.
  
  
• 06:20:00 Nesta seção, o instrutor repassa as cinco principais etapas de um loop de treinamento no PyTorch, que inclui o avanço, cálculo da perda, zerar os gradientes do otimizador, realizar a propagação reversa e passar o otimizador pela descida do gradiente . O instrutor observa que a ordem dessas etapas às vezes pode ser ambígua, mas é importante manter a etapa do otimizador após a retropropagação. O instrutor também explica por que os gradientes do otimizador precisam ser zerados em cada iteração para evitar o acúmulo nos loops. O instrutor sugere praticar a escrita de um loop de treinamento para entender melhor essas etapas e fornece uma música e recursos extras para aprendizado adicional.
  
  
• 06:25:00 Nesta seção do vídeo, o apresentador recapitula as etapas em um loop de treinamento no PyTorch, que envolve passagem direta, cálculo do valor de perda, zeramento dos gradientes do otimizador e realização de retropropagação na função de perda. O loop de treinamento ajuda o modelo a aprender padrões nos dados de treinamento, enquanto o loop de teste avalia os padrões em dados não vistos. O apresentador também explica por que zeramos os gradientes do otimizador e apresenta o conceito de retropropagação, que calcula o gradiente da função de perda.
  
  
• 06:30:00 Nesta seção, o instrutor explica o conceito de gradientes e curvas de função de perda no aprendizado profundo do PyTorch. Ao definir 'requires grad' como true para os parâmetros, o PyTorch é capaz de rastrear os gradientes de cada parâmetro e criar uma curva de função de perda para todos eles. O objetivo da retropropagação e da subsequente descida do gradiente é calcular o ponto mais baixo da curva, que representa a perda mínima. O instrutor explica o conceito de gradientes no aprendizado de máquina e como a descida do gradiente funciona com pontos de passo. Ao otimizar a perda de grau zero para trás, otimizando a etapa e requer graduação, o PyTorch faz muito desse trabalho nos bastidores, rastreando gradientes automaticamente e encontrando a parte inferior da curva.
  
  
• 06:35:00 Nesta seção, o instrutor discute o otimizador e a taxa de aprendizado. O otimizador pega os parâmetros do modelo e cria curvas para cada parâmetro usando um mecanismo chamado tocha autograd para cálculo de gradiente automático para se aproximar da parte inferior da curva. A taxa de aprendizado decide quão grande ou pequeno o otimizador altera os parâmetros a cada passo, com passos menores dados à medida que nos aproximamos da convergência. Além disso, o instrutor aborda as cinco etapas envolvidas no treinamento de um modelo, que inclui a inicialização do modelo, a definição do otimizador, a taxa de aprendizado, o cálculo do avanço, a propagação regressiva e a etapa do otimizador. Por fim, o instrutor menciona que esse loop pode ser transformado em uma função, o que ajuda a evitar repetições de códigos.
  
  
• 06:40:00 Nesta seção do "PyTorch for Deep Learning & Machine Learning - Full Course", o instrutor enfatiza a importância de escrever o loop de treinamento no PyTorch, pois é assim que o modelo aprende padrões e dados. O vídeo também fornece recursos adicionais sobre retropropagação e descida de gradiente para os interessados no conhecimento matemático. O instrutor explica que a escolha da função de perda e otimizador será específica para cada problema e recomenda perda MAE e perda L1 para problemas de regressão e perda de entropia cruzada binária para problemas de classificação. A seção termina com uma demonstração do loop de treinamento usando um modelo com apenas dois parâmetros e uma única época.
  
  
• 06:45:00 Nesta seção, o instrutor continua treinando o modelo de aprendizado de máquina usando o PyTorch e mostra como a função de perda está diminuindo à medida que os parâmetros do modelo são atualizados por meio da descida do gradiente. O instrutor enfatiza que um valor de perda menor indica melhor progresso do modelo e que as pequenas diferenças nos valores devido à aleatoriedade no aprendizado de máquina não devem ser preocupantes. O instrutor então desafia o visualizador a executar o código por 100 épocas e fazer previsões para ver o quão baixo eles podem obter o valor de perda. Por fim, o instrutor discute a importância do teste e provoca o próximo vídeo sobre como escrever código de teste.
  
  
• 06:50:00 Nesta seção, o instrutor discute a importância de pesquisar e aprender novos tópicos usando recursos externos como Google e documentação. Eles incentivam os alunos a tentar executar o código de treinamento por 100 épocas e examinar os valores e previsões de peso e viés. Em seguida, o instrutor explica o código de teste e a finalidade da função model.eval(), que desativa as configurações do modelo que não são necessárias para o teste, como dropout e camadas de normas de lote. Eles também discutem o propósito de arch.no_grad() e como ele desativa o rastreamento de gradiente durante o teste, já que nenhum aprendizado está acontecendo nesse estágio. Por fim, a seção termina com a gravação do passo adiante para o modelo no modo de teste.
  
  
• 06:55:00 Nesta seção, o vídeo ensina como criar previsões de teste e calcular a perda de teste usando o modelo zero no PyTorch. As previsões de teste são feitas no conjunto de dados de teste, que o modelo nunca viu antes, assim como avaliar o conhecimento de alguém sobre materiais que nunca viu antes. O vídeo explica a importância de não permitir que o modelo veja o conjunto de dados de teste antes de avaliá-lo para evitar resultados ruins. O código imprime a perda e o que está acontecendo a cada 10ª época enquanto o modelo está treinando por 100 épocas, e a perda diminui a cada época. O vídeo também discute o conceito de precisão do modelo, que pode ser impresso posteriormente.

Parte 8

• 07:00:00 Nesta seção, o instrutor analisa o vídeo anterior, no qual treinou um modelo e fez previsões em um conjunto de dados simples. Eles então desafiam o visualizador a encontrar maneiras de melhorar a capacidade do modelo de alinhar os pontos vermelhos previstos com os pontos verdes reais, possivelmente treinando o modelo por mais tempo. O instrutor então reexecuta o código por mais 100 épocas e mostra uma melhoria significativa na perda de teste e nas previsões do modelo. O instrutor enfatiza que esse processo de treinamento e avaliação de modelos é fundamental para o aprendizado profundo com o PyTorch e será usado no restante do curso. Eles também discutem a importância de acompanhar o progresso do modelo usando uma lista vazia para armazenar valores úteis.
  
  
• 07:05:00 Nesta seção, o instrutor explica por que é importante acompanhar os valores de perda e como podemos usá-los para monitorar o progresso de nosso modelo e aprimorá-lo em experimentos futuros. O trecho de código apresentado anexa a contagem de época, o valor de perda atual e o valor de perda de teste atual a diferentes listas para que possam ser plotados posteriormente. O instrutor demonstra um gráfico das curvas de perda geradas a partir das listas e explica seu significado. Uma curva de perda ideal deve começar alta e diminuir ao longo do tempo, representando um valor de perda decrescente.
  
  
• 07:10:00 Nesta seção, o instrutor explica como converter valores de perda de PyTorch para NumPy para plotá-los no Matplotlib. Ele mostra que é necessário convertê-los para NumPy, pois o Matplotlib só funciona com NumPy. Ele também explica como acompanhar as curvas de perda de treinamento e perda de teste e menciona que, se elas se igualarem em algum ponto, isso significa que o modelo está convergindo e a perda está chegando o mais próximo possível de zero. O instrutor então percorre o loop de teste e explica que é necessário passar os dados do teste pelo modelo, calcular o valor da perda do teste e imprimir o que está acontecendo durante o treinamento para acompanhar os valores do que está acontecendo. Por fim, ele sugere colocar todas essas etapas em uma função e fornece uma música de loop de otimização não oficial do PyTorch para lembrar as etapas.
  
  
• 07:15:00 aprenda nesta seção - os três métodos principais para salvar e carregar modelos no PyTorch. O primeiro método, arch.save, permite salvar um objeto PyTorch no formato pickle do Python. O segundo método, arch.load, permite que você carregue um objeto PyTorch salvo. E o terceiro método, arch.nn.module.loadStateDict, permite que você carregue o dicionário salvo de um modelo ou salve o dicionário de estado, que exploraremos no vídeo a seguir. Esses métodos são cruciais para salvar e reutilizar modelos, especialmente ao trabalhar com modelos maiores ou ao compartilhar modelos com outras pessoas.
  
  
• 07:20:00 Nesta seção, o instrutor explica o conceito de dicionários de estado e sua importância no PyTorch. O PyTorch armazena os parâmetros importantes de um modelo em um dicionário, chamado dicionário de estado, que contém o estado do modelo, incluindo os parâmetros que podem ser aprendidos, como pesos e vieses. O instrutor demonstra como salvar e carregar o modelo PyTorch pode ser feito salvando seu dicionário de estado usando os métodos maçarico.save e maçarico.carregar. Além disso, o instrutor oferece um desafio adicional ao usuário para ler e entender os prós e contras de salvar todo o modelo, em vez de apenas o dicionário de estado. Finalmente, o instrutor compartilha o código PyTorch para salvar o modelo e criar uma pasta chamada models.
  
  
• 07:25:00 Nesta seção do vídeo, o instrutor demonstra como salvar um modelo PyTorch usando o método recomendado de salvar o dict de estado. O modelo recebe um nome e o caminho é criado usando a biblioteca pathlib. Uma vez que o caminho esteja pronto, o dict de estado do modelo é salvo usando a função arch.save(), onde o primeiro parâmetro é o objeto e o segundo é o caminho onde o modelo deve ser salvo. O instrutor mostra como o comando LS é usado para verificar se o modelo está salvo no diretório models. O vídeo também fornece um guia para baixar o modelo salvo em uma máquina local ou no Google Drive. Além disso, o instrutor incentiva o visualizador a se desafiar lendo a documentação adiante e usando a função arch.load() para aprender como carregar um modelo salvo.
  
  
• 07:30:00 Nesta seção, o instrutor fala sobre o carregamento de um modelo PyTorch e como usar o método de carregamento de pontos da tocha. O dicionário de parâmetros salvo anteriormente da classe de um modelo será carregado como um deck de estado, e esta seção mostra como criar uma nova instância da classe de modelo de regressão linear e carregar o deck de estado salvo nela. O método de deck de estado de carga do módulo nn da tocha permite carregar o dicionário de estado diretamente na instância do modelo, enquanto o método de carregamento de ponto de tocha leva em F e passa para o caminho de salvamento do modelo onde o deck de estado anterior é salvo.
  
  
• 07:35:00 Nesta seção, o instrutor explica como salvar e carregar um modelo no PyTorch. Eles testam o modelo carregado fazendo novas previsões com os dados de teste e comparando-os com as previsões do modelo original usando a função equivalente igual a igual. O instrutor soluciona os problemas dos modelos que não são equivalentes fazendo um novo conjunto de previsões de modelo e testando a equivalência novamente. Eles cobrem os principais aspectos de salvar e carregar um modelo, mas sugerem a verificação de tutoriais para obter mais detalhes. O instrutor planeja reunir todas as etapas abordadas até agora nos próximos vídeos.
  
  
• 07:40:00 Nesta seção do vídeo, o instrutor passa por todo o fluxo de trabalho de aprendizado profundo usando PyTorch, incluindo importar PyTorch, salvar e recarregar modelos e criar código independente de dispositivo, que permite que o código use a GPU se disponível, ou a CPU por padrão se não. O instrutor incentiva os espectadores a fazer uma pausa e tentar recriar o código por conta própria, além de oferecer orientação e dicas úteis. O vídeo também aborda como criar conjuntos de dados fictícios e plotar pontos de dados, que serão usados para construir um modelo que aprenderá a prever os pontos verdes a partir dos pontos azuis.
  
  
• 07:45:00 Nesta seção, o instrutor demonstra como criar dados usando a fórmula de regressão linear de y igual a peso vezes recursos mais viés. Eles explicam que os princípios de construção de um modelo para estimar esses valores permanecem os mesmos e passam a criar os recursos x e y, que serão usados para prever os valores de treinamento e teste. Eles também dividem os dados em conjuntos de treinamento e teste e plotam os dados para visualizar os padrões nos dados.
  
  
• 07:50:00 Nesta seção, o instrutor apresenta o conceito de construção de um modelo linear PyTorch para os dados fictícios lineares fornecidos. Eles subclassificam nn.module para criar um modelo de regressão linear e inicializar os parâmetros usando camadas. A camada nn.Linear recebe recursos como entrada e saída e aplica uma transformação linear aos dados de entrada usando a mesma fórmula do modelo de regressão linear. As formas de entrada e saída do modelo dependem dos dados, e o instrutor destaca que diferentes exemplos de recursos de entrada e saída serão vistos ao longo do curso.
  
  
• 07:55:00 Nesta seção, o instrutor explica como usar a camada linear no PyTorch como uma camada pré-existente para criar um modelo. A camada linear é uma forma de regressão linear y igual a x, uma transposição mais b, in features, out features. Subclassificando nn.module, podemos criar uma camada linear e substituir o método forward para passar os dados pela camada linear, que realiza a computação direta predefinida. O poder do arch.nn do PyTorch é que ele cria os parâmetros para nós nos bastidores e não precisamos inicializá-los manualmente. Além disso, o instrutor discute os diferentes nomes para a camada linear, como transformação linear, camada de sondagem, camada totalmente conectada, camada densa e fluxo intensivo.

Parte 9

• 08:00:00 Nesta seção, o instrutor discute as diferentes camadas disponíveis no arch.nn, incluindo convolucional, pooling, padding, normalização, recorrente, transformador, linear e dropout. As implementações pré-construídas dessas camadas são fornecidas pelo PyTorch para tarefas comuns de aprendizado profundo. A seção segue para o treinamento do modelo linear PyTorch criado anteriormente usando funções de perda e otimizador. O otimizador otimizará o peso do modelo e os parâmetros de viés para minimizar a função de perda, que mede o quanto o modelo está errado. O instrutor configura a função de perda L1 e o otimizador SGD para esta tarefa.
  
  
• 08:05:00 Nesta seção do vídeo, o instrutor discute a importância de escolher uma taxa de aprendizado adequada para o otimizador, pois uma etapa muito pequena ou muito grande pode afetar negativamente o desempenho do modelo. As etapas envolvidas na criação de um loop de treinamento também são explicadas, o que inclui fazer uma passagem direta, calcular o valor da perda, zerar o otimizador, realizar a propagação reversa e ajustar os pesos e vieses. Além disso, o instrutor sugere usar o arch.manual_seed() para garantir resultados reprodutíveis e fornece código para imprimir a perda de treinamento e a perda de teste a cada 10 épocas.
  
  
• 08:10:00 Nesta seção do curso PyTorch, o instrutor explica como escrever código agnóstico de dispositivo para dados, enfatizando que ter toda a computação no mesmo dispositivo é crucial para evitar erros. O modelo e os dados devem estar no mesmo dispositivo, que pode ser CPU ou CUDA. Ao colocar os dados de treinamento e teste no dispositivo de destino usando o trem X e o trem Y, isso cria um código agnóstico do dispositivo, que fornece resultados mais precisos ao treinar o modelo. O instrutor também explica como avaliar o modelo usando state deck, demonstrando que os parâmetros estimados estão próximos do valor ideal. A seção termina com um desafio para os usuários fazerem e avaliarem previsões e plotá-las nos dados originais.
  
  
• 08:15:00 Nesta seção, o instrutor discute a importância de transformar o modelo PyTorch no modo de avaliação e fazer previsões sobre os dados de teste que o modelo nunca viu antes. Eles trazem a função de previsões de plotagem para visualizar as previsões do modelo, mas encontram um erro de tipo ao tentar converter o tensor do tipo de dispositivo CUDA em NumPy porque o Matplotlib funciona com NumPy, não com PyTorch. Eles resolvem esse erro usando o tensor dot CPU para copiar o tensor para a memória do host primeiro. O instrutor também incentiva os visualizadores a salvar e carregar seu modelo treinado usando o módulo de caminho, que eles demonstram criando um diretório de modelos e definindo o caminho do modelo para ele.
  
  
• 08:20:00 Nesta seção, o instrutor explica como salvar e carregar modelos PyTorch usando o módulo path lib do Python. Primeiro, um caminho de salvamento de modelo é criado com a extensão .PTH para PyTorch. O dicionário de estado do modelo é então salvo usando o método de salvamento da tocha. O instrutor observa que visualizar o deck de estado explicitamente pode não ser viável para modelos com muitos parâmetros. Para carregar o modelo salvo, o dicionário de estado salvo é carregado em uma nova instância do modelo de regressão linear V2 usando o método load state deck e passando o caminho do arquivo do objeto PyTorch salvo. O uso da camada linear pré-construída do PyTorch e sua chamada no método forward também são discutidos.
  
  
• 08:25:00 Nesta seção, o instrutor finaliza verificando se o modelo carregado possui os mesmos parâmetros do modelo salvo, avaliando-o usando o modo de inferência da tocha. Eles então parabenizam o usuário por concluir o fluxo de trabalho do PyTorch desde a construção de um modelo, treinamento e salvamento até sua reutilização. O instrutor então aponta que os usuários podem encontrar os exercícios e o currículo extra na versão em livro dos materiais do curso em learnpytorch.io. Eles também fornecem modelos de caderno de exercícios que são numerados por seção e podem ser encontrados no repositório GitHub de aprendizado profundo do PyTorch em extras e exercícios.
  
  
• 08:30:00 Nesta seção, o instrutor fornece informações sobre como concluir os exercícios de fluxo de trabalho e encontrar recursos extras para o curso PyTorch. Ele enfatiza a importância de experimentar os exercícios por si mesmo antes de olhar para qualquer solução de exemplo. A seção termina com um resumo do fluxo de trabalho do PyTorch abordado, que inclui preparar os dados, transformá-los em tensores, criar ou selecionar um modelo, escolher uma função de perda e um otimizador, treinar o modelo, fazer previsões e avaliar o modelo. A próxima seção se concentra na classificação de rede neural com PyTorch, que é um dos maiores problemas no aprendizado de máquina. O instrutor fornece recursos para obter ajuda ao longo do curso, incluindo a página de discussões do GitHub do curso e a documentação do PyTorch. Ele também explica o que são problemas de classificação e dá exemplos como prever se um e-mail é spam ou não.
  
  
• 08:35:00 Nesta seção do curso PyTorch, o instrutor discute diferentes tipos de problemas de classificação em aprendizado profundo. A classificação binária é quando há apenas duas opções, como spam ou não spam. A classificação multiclasse ocorre quando há mais de duas opções, como classificar uma imagem como sushi, bife ou pizza. A classificação multi-rótulo é quando um exemplo pode ter mais de um rótulo, como atribuir tags a um artigo da Wikipédia. O instrutor fornece exemplos do mundo real e explica os conceitos minuciosamente. Ele também distingue entre classificação binária e multiclasse com exemplos de classificação de imagens de cães e gatos em um problema de classificação binária e classificação de imagens de diferentes animais em um problema de classificação multiclasse.
  
  
• 08:40:00 Nesta seção, o instrutor explica a arquitetura de um modelo de classificação de rede neural e as formas de entrada e saída de um modelo de classificação. Ele enfatiza a importância das entradas numéricas para modelos de aprendizado de máquina e explica como as entradas numéricas costumam ter formas diferentes, dependendo dos dados. Ele também discute o processo de criação de dados personalizados para ajuste e previsão e abrange as etapas envolvidas na modelagem para classificação de redes neurais. Além disso, o instrutor explica como configurar uma função de perda e um otimizador para um modelo de classificação, criar loops de treinamento e avaliação, salvar e carregar modelos, aproveitar a não linearidade e avaliar modelos de classificação. Ele conclui fornecendo um exemplo de como representar numericamente fotos de alimentos e sua previsão usando um algoritmo de aprendizado de máquina.
  
  
• 08:45:00 Nesta seção, o instrutor do curso PyTorch for Deep Learning & Machine Learning fornece detalhes sobre o processo de codificação numérica e o formato de saída. As entradas para o algoritmo de aprendizado de máquina são imagens codificadas numericamente, que possuem algumas saídas associadas em probabilidades de previsão. O instrutor observa que quanto mais próxima a probabilidade de previsão estiver de um, mais confiante o modelo estará em sua saída. Essa saída vem da observação de várias amostras e é possível ajustar o algoritmo e os dados para melhorar essas previsões. As saídas codificadas devem ser alteradas para rótulos compreensíveis para humanos. Além disso, o instrutor discute a forma dos tensores, incluindo tamanho do lote, canais de cores e altura/largura. Um tamanho de lote de 32 é uma prática comum e a forma pode variar dependendo do problema a ser resolvido.
  
  
• 08:50:00 Nesta seção, o instrutor explica a arquitetura de um modelo de classificação, que é o esquema do que é uma rede neural. A forma da camada de entrada é determinada pelo número de recursos, que devem ser codificados como uma representação numérica, e a camada de saída geralmente é uma probabilidade de previsão para uma determinada classe. Existem hiperparâmetros como o número de camadas ocultas, neurônios por camada oculta e formato da camada de saída que devem ser decididos pelo usuário. O instrutor também fornece exemplos de código para criar camadas e neurônios usando o PyTorch e observa que as formas variam dependendo do problema que está sendo resolvido.
  
  
• 08:55:00 Nesta seção, o instrutor discute os componentes de um problema de classificação, incluindo ativação de camada oculta, ativação de saída, função de perda e otimizador, e fornece exemplos de cada um. O instrutor então apresenta um problema de classificação multiclasse e discute como a arquitetura pode ser construída para ter vários recursos de saída. Por fim, o instrutor passa a escrever código usando o PyTorch no Google CoLab, lembrando ao público que todo o código será salvo em um repositório do GitHub. O instrutor também enfatiza a importância de iniciar qualquer problema de aprendizado de máquina com dados.

[MetaQuotes]

PyTorch para Deep Learning e Machine Learning - curso completo (partes 10-14)

PyTorch para Deep Learning e Machine Learning - Curso Completo

Parte 10

• 09:00:00 Nesta seção, o vídeo se concentra na criação de um conjunto de dados personalizado usando a biblioteca scikit-learn. O conjunto de dados fazer círculos é importado e 1000 amostras são criadas com algum ruído adicionado para aleatoriedade. O comprimento de X e Y são impressos, o que indica que existem 1000 amostras de recursos e rótulos. As primeiras cinco amostras de X e Y são então impressas, mostrando que os dados já são numéricos e possuem apenas duas classes: zero e uma para classificação binária. Um quadro de dados pandas é então criado, com os recursos rotulados como X1 e X2, e a amostragem aleatória é discutida como uma abordagem potencialmente útil para explorar grandes conjuntos de dados.
  
  
• 09:05:00 Nesta seção do curso, o instrutor explica o conjunto de dados do brinquedo que será usado para praticar a construção de uma rede neural no PyTorch para classificação binária. O conjunto de dados foi gerado usando o scikit-learn e consiste em dois círculos com cores diferentes representando as duas classes do problema de classificação binária. O instrutor mostra como a visualização de dados pode ajudar a entender o conjunto de dados e se preparar para a construção de uma rede neural. As formas de entrada e saída do problema também são discutidas, bem como dividir o conjunto de dados em conjuntos de treinamento e teste, que serão abordados na próxima seção do curso.
  
  
• 09:10:00 Nesta seção, o instrutor discute a importância de verificar as formas de entrada e saída no aprendizado de máquina, pois são fontes comuns de erros. Eles demonstram como visualizar as formas de entrada e saída de um conjunto de dados usando matrizes NumPy e converter os dados em tensores PyTorch. O processo de converter dados em tensores e dividi-los em conjuntos de treinamento e teste é uma etapa crucial no aprendizado de máquina, mesmo para conjuntos de dados de brinquedo como o usado neste exemplo. O instrutor mostra como importar o PyTorch e garantir que a versão usada seja 1.10, como converter matrizes NumPy em tensores PyTorch e como criar conjuntos de treinamento e teste para os dados.
  
  
• 09:15:00 Nesta seção, o instrutor demonstra como converter dados de arrays NumPy no tipo padrão de float 32 do PyTorch usando o comando "torch.float". Não fazer isso pode resultar em erros mais tarde. O instrutor então mostra como dividir os dados em conjuntos de treinamento e teste usando a divisão aleatória, que é feita usando a função "train_test_split" do scikit-learn. O exemplo de código mostra a ordem na qual os recursos e rótulos devem aparecer ao passá-los para a função. O instrutor também explica o uso do parâmetro "test_size", onde o valor dado é a porcentagem de dados a serem usados como dados de teste, e o parâmetro "random_state" que funciona como uma semente aleatória.
  
  
• 09:20:00 Nesta seção, o vídeo aborda a divisão dos dados em conjuntos de treinamento e teste usando a biblioteca Scikit-learn no PyTorch. A semente manual do ponto da tocha é definida para garantir que as mesmas divisões aleatórias sejam usadas, garantindo que sejam iguais às que você deseja comparar. Usando o comprimento dos conjuntos de treinamento e teste, o vídeo explica que eles têm 800 e 200 amostras, respectivamente, compondo o conjunto de dados com o qual trabalharão. O próximo passo é criar e escolher um modelo para classificar os pontos vermelhos e azuis. Para conseguir isso, eles configuram um código agnóstico incluindo o dispositivo de modo que ele seja executado em um acelerador, construam o modelo, definam a perda e usem o PyTorch para criar um loop de treinamento e teste que será explorado mais adiante na próxima seção.
  
  
• 09:25:00 Nesta seção, aprendemos como configurar uma GPU para PyTorch e criar um código independente de dispositivo para garantir que o código seja executado em uma CPU sem problemas. Em seguida, passamos a construir um modelo criando uma subclasse de um nn.Module e seguimos quatro etapas principais. Primeiramente, criamos um modelo que subclasse um nn.Module. Em segundo lugar, criamos duas Camadas Lineares capazes de lidar com as formas de nossos dados. Em terceiro lugar, definimos um método direto que descreve a passagem direta do modelo. Em quarto lugar, instanciamos a instância de nossa classe de modelo e a enviamos para o dispositivo de destino. Aprendemos que nosso modelo será usado para separar círculos vermelhos e azuis usando uma rede neural.
  
  
• 09:30:00 Nesta seção do curso, o instrutor discute como definir uma camada de rede neural capaz de lidar com recursos de entrada. Ele continua explicando que o número de recursos necessários para cada camada depende do conjunto de dados que está sendo usado. Neste exemplo, onde X tem dois recursos, a primeira camada é definida como "n-linear" com n recursos iguais a dois, enquanto a segunda camada é definida com cinco recursos para ajudar o modelo a aprender mais padrões. O instrutor também explica que os recursos internos da segunda camada devem corresponder aos recursos externos da camada anterior para evitar erros de incompatibilidade de formato. Finalmente, ele define um método de Ford que descreve a passagem de Ford e retorna a autocamada dois (que usa a autocamada um e X como entradas).
  
  
• 09:35:00 Nesta seção, o instrutor explica como instanciar uma instância da classe modelo e enviá-la ao dispositivo de destino. Ele mostra como criar uma rede neural multicamadas simples, que ele então demonstra no playground do TensorFlow usando dois recursos de entrada e passando-os para uma camada oculta com cinco neurônios, que alimenta outra camada que possui um recurso de saída. Ele ajusta a rede a alguns dados, e a perda de teste é de aproximadamente 50%, o que significa que se o modelo fosse apenas adivinhar aleatoriamente, obteria uma perda de cerca de 0,5, porque existem apenas duas classes.
  
  
• 09:40:00 Nesta seção do vídeo, o instrutor usa uma ferramenta de quadro branco chamada Fig Jam para representar visualmente uma rede neural para um problema de classificação binária. O instrutor explica que, em um problema de classificação binária, adivinhar aleatoriamente resultará em cerca de 50% de precisão. A rede neural é construída usando entradas, unidades ocultas e uma camada de saída, e o instrutor enfatiza que a forma das camadas deve corresponder. O playground do TensorFlow é sugerido como uma maneira divertida de explorar e desafiar a si mesmo na construção de uma rede neural sobre esse tipo de dados. Mais tarde, o instrutor discute a replicação da rede neural criada anteriormente com ainda menos código usando duas camadas lineares capazes de lidar com os recursos de entrada e aumentá-los para melhorar o aprendizado da rede.
  
  
• 09:45:00 Nesta seção, o instrutor demonstra como replicar um modelo de rede neural usando nn.Sequential no PyTorch. Ao usar nn.Sequential, o código do modelo pode ser simplificado, pois a maior parte do código é implementada nos bastidores. O instrutor explica que usar nn.Sequential para operações simples e diretas pode ser mais eficiente do que subclasses, conforme demonstrado em uma seção anterior do vídeo. No entanto, a subclasse permite operações mais complexas, como a construção de passes avançados mais complexos. Esta seção destaca a flexibilidade do PyTorch e as diferentes maneiras de criar um modelo. O instrutor também demonstra a passagem de dados pelo modelo e a análise do dicionário de estado.
  
  
• 09:50:00 Nesta seção, o instrutor demonstra como o PyTorch cria automaticamente parâmetros de peso e viés nos bastidores enquanto implementa uma rede neural de duas camadas. O instrutor destaca o fato de que o modelo é instanciado com números aleatórios e que o PyTorch alterará ligeiramente esses valores durante o processo de retropropagação e descida de gradiente para melhor ajustar ou representar os dados. O instrutor também mostra a complexidade potencial de ter muitas camadas com vários recursos e como acompanhar esses valores manualmente pode se tornar detalhado. Por fim, o instrutor faz previsões usando o modelo não treinado e destaca a importância de solucionar problemas e visualizar os dados.
  
  
• 09:55:00 Nesta seção, o vídeo explica como escolher uma função de perda e um otimizador após criar um modelo para aprendizado profundo. O tipo de função de perda e otimizador necessários geralmente depende da natureza do conjunto de dados que está sendo trabalhado. Para problemas de regressão, o erro médio absoluto ou o erro quadrático médio podem ser apropriados. Enquanto isso, para questões de classificação, a entropia cruzada binária ou a entropia cruzada categórica podem ser escolhidas. O vídeo conclui observando que a função de perda ajuda a medir a precisão das previsões de um modelo.

Parte 11

• 10:00:00 Nesta seção do curso em vídeo, o instrutor fornece uma visão geral de várias funções de perda e otimizadores comumente usados no PyTorch para classificação de redes neurais. O instrutor explica a perda de entropia cruzada binária, a perda de entropia cruzada, o erro médio absoluto e o erro quadrático médio e quais são normalmente usados para tarefas de regressão versus classificação. Para tarefas de classificação binária, os exemplos de código fornecidos incluem perda de BCE da tocha.nn com logits e perda de BCE. O vídeo também aborda o conceito de logit em aprendizado profundo e explora dois otimizadores comumente usados, SGD e Adam. O instrutor observa que, embora possa haver outros otimizadores disponíveis, manter esses dois ainda pode alcançar bons resultados em muitos problemas.
  
  
• 10:05:00 Nesta seção do vídeo, o palestrante configura a função de perda e o otimizador no PyTorch para aprendizado profundo e aprendizado de máquina. A função de perda é chamada de BCE com perda de logits, que possui a função de ativação sigmóide incorporada. O palestrante explica que, se alguém quiser aprender mais sobre funções de ativação em redes neurais, existem recursos online disponíveis. O otimizador escolhido é o gradiente descendente estocástico (SGD), com uma taxa de aprendizado de 0,1, e os parâmetros são definidos para atualizar os parâmetros do modelo com relação à perda. Por fim, o palestrante cria uma métrica de avaliação.
  
  
• 10:10:00 Nesta seção, o instrutor discute a importância da precisão como uma métrica de avaliação e demonstra como criar uma função de precisão usando pytorch. A função de precisão compara as previsões com os rótulos de verdade básica e retorna a porcentagem de previsões corretas do número total de amostras. O instrutor também fornece uma visão geral das etapas envolvidas em um loop de treinamento pytorch, incluindo passagem direta, cálculo de perda, grau zero do otimizador, propagação de retorno e descida de gradiente. As etapas são listadas e a importância de cada etapa é discutida.
  
  
• 10:15:00 Nesta seção, o instrutor explica como passar de logits brutos para probabilidades de previsão e rótulos de previsão. As saídas brutas do modelo são chamadas de logits, que podem ser convertidas em probabilidades de predição, passando-as para uma função de ativação, como sigmoid para classificação binária e softmax para classificação multiclasse. As probabilidades de previsão podem então ser convertidas em rótulos de previsão arredondando-as para classificação binária ou tomando o argmax para classificação multiclasse. O instrutor também explica o conceito de uma função de ativação como algo separado de uma camada e mostra como os dados passados por uma camada linear aplicam uma transformação linear aos dados recebidos por meio de um produto escalar e um termo de viés.
  
  
• 10:20:00 Nesta seção do vídeo, o instrutor explica como usar a função de ativação sigmoide para transformar a saída bruta de um modelo, chamado logits, em probabilidades de predição que podem ser usadas para classificação binária. O instrutor demonstra como usar a função sigmoide nos logits do modelo para criar predprobs, que podem então ser passados para uma função de arredondamento de ponto de tocha para obter rótulos de previsão. Esses rótulos de previsão são usados para determinar a qual classe uma entrada pertence, usando um limite de decisão geralmente definido em 0,5. O instrutor também enfatiza a importância de executar esta etapa nos logits brutos para garantir que as probabilidades de previsão estejam no mesmo formato dos dados de teste.
  
  
• 10:25:00 Nesta seção, o vídeo discute o processo de transformar logits brutos do modelo em probabilidades de previsão usando uma função de ativação e, em seguida, convertendo-os em rótulos de previsão. As etapas são demonstradas por meio de um pouco de código, onde y-pred é criado a partir de testes y-pred usando a etapa completa, incluindo previsões, logits para testes pred para rótulos pred. As previsões do modelo são comparadas aos rótulos de teste e o mesmo formato é criado usando a função squeeze. O próximo passo é construir um loop de treinamento e teste, que envolve fazer um passe para frente, calcular a perda e otimizar os gradientes. O vídeo incentiva o espectador a tentar fazer isso por conta própria antes de prosseguir para o próximo vídeo para obter mais instruções.
  
  
• 10:30:00 Nesta seção, o instrutor define uma semente manual para reprodutibilidade, especificamente uma semente aleatória CUDA para operações em um dispositivo CUDA. Em seguida, eles colocam os dados no dispositivo de destino e criam o loop de treinamento e avaliação. O instrutor destaca um pequeno detalhe na passagem direta, onde os logits brutos são gerados e devem ser passados através do arch.round e do arch.sigmoid para convertê-los em probabilidades e rótulos de previsão. Por fim, eles calculam a perda e a precisão, observando que, embora o cálculo da precisão não seja necessário, pode ser útil visualizar diferentes métricas enquanto o modelo está treinando.
  
  
• 10:35:00 Nesta seção, o vídeo discute a diferença entre perda de BCE e perda de BCE com logits em PyTorch. O BCE com perda de logits espera logits como entrada e combina uma camada sigmóide e perda de BCE, tornando-o mais estável numericamente. Por outro lado, a perda de BCE espera probabilidades de previsão como entrada, portanto, o sigmóide da tocha precisa ser chamado nos logits para convertê-los em probabilidades. O vídeo também descreve as etapas do loop de otimização do PyTorch, incluindo zerar os gradientes, realizar retropropagação e atualizar os parâmetros para reduzir os gradientes. Da mesma forma, ao testar ou fazer previsões, o modelo deve ser colocado no modo de inferência e os logits de teste devem ser processados chamando a função sigmoide para adquirir probabilidades de previsão.
  
  
• 10:40:00 Nesta seção, o instrutor discute como calcular a perda e a precisão do teste para o modelo de classificação. Para calcular a perda de teste, o instrutor usa o BCE com a função de perda de logits e a compara com os rótulos de teste Y. Para calcular a precisão do teste, o instrutor usa a função de precisão nas variáveis Y verdadeiras e Y pred. A ordem das variáveis é invertida para a função de precisão, pois o instrutor a baseou no pacote de métricas do scikit-learn. Por fim, o instrutor imprime o número da época, perda e precisão do treinamento e perda e precisão do teste a cada 10ª época. O instrutor incentiva os usuários a executar esse código gigantesco e corrigir quaisquer erros que surjam.
  
  
• 10:45:00 Nesta seção, o instrutor discute os resultados do treinamento do modelo da seção anterior, que não apresentou nenhuma melhoria significativa na precisão. O instrutor sugere que uma precisão ideal para o modelo deve ser 100 e um valor de perda deve ser zero. No entanto, a precisão do modelo atual está abaixo de 50%, o que equivale a adivinhar aleatoriamente. Para determinar o motivo do mau desempenho, o instrutor sugere visualizar as previsões feitas pelo modelo. O instrutor importa uma função chamada "limite de decisão de plotagem" de um arquivo de função auxiliar para ser usada neste processo de visualização. O instrutor também recomenda um recurso, madewithml.com, para os interessados em aprender mais sobre fundamentos de aprendizado de máquina e operações de ml.
  
  
• 10:50:00 Nesta seção, o instrutor explica como baixar funções auxiliares do repositório PyTorch de aprendizado de maneira programática usando os módulos "pathlib" e "request" do Python. O instrutor mostra o processo de verificação se o caminho das funções auxiliares já existe e, caso não exista, é feita uma solicitação para baixar a função auxiliar como um arquivo chamado "helper_functions.py". O instrutor demonstra a importação bem-sucedida dos métodos "plot_predictions" e "plot_decision_boundary" da função auxiliar baixada, que será usada posteriormente no curso. Por fim, o instrutor realiza um teste para visualizar a função auxiliar usando a função "plot_decision_boundary", que plota com sucesso um limite de decisão para o conjunto de treinamento.
  
  
• 10:55:00 Nesta seção do vídeo, o apresentador discute as limitações de um modelo linear na separação de dados circulares com linhas retas, conforme mostrado em uma visualização do limite de decisão do modelo. A solução para melhorar a precisão do modelo é adicionar mais camadas, ou seja, aumentar a profundidade da rede neural, o que permite mais chances de aprender sobre padrões nos dados. Outras maneiras de melhorar o desempenho de um modelo incluem aumentar a quantidade de dados de treinamento e ajustar hiperparâmetros, como taxa de aprendizado e tamanho do lote. Importar e usar funções auxiliares de scripts Python externos também é mencionado como uma prática comum.

Parte 12

• 11:00:00 Nesta seção, o instrutor discute maneiras de melhorar um modelo: adicionar mais unidades ocultas, ajustar por mais tempo, alterar as funções de ativação, ajustar a taxa de aprendizado e alterar a função de perda. O instrutor aponta que aumentar o número de parâmetros em um modelo pode ajudar a representar melhor os dados, mas muitos parâmetros podem tornar o modelo muito complexo para um conjunto de dados simples. O instrutor também ilustra como a experimentação pode ajudar a melhorar o modelo alterando sua estrutura e hiperparâmetros. Por fim, o instrutor mostra exemplos gráficos de como adicionar camadas, aumentar o número de unidades ocultas, adicionar funções de ativação e alterar a função de otimização pode melhorar o modelo.
  
  
• 11:05:00 Nesta seção, o instrutor discute como melhorar um modelo de uma perspectiva de modelo. Ele explica o conceito de hiperparâmetros, que são valores que engenheiros de aprendizado de máquina e cientistas de dados podem alterar para melhorar os resultados do modelo. O instrutor demonstra como alterar os hiperparâmetros de um modelo, como o número de unidades ocultas, o número de camadas e o número de épocas. Ele também destaca a importância de testar essas mudanças uma de cada vez para identificar qual delas oferece a melhoria ou a degradação. Por fim, ele explica a diferença entre parâmetros e hiperparâmetros e por que é importante fazer essa distinção.
  
  
• 11:10:00 Nesta seção, o instrutor cria um modelo de três camadas com mais unidades ocultas para ver se treinar esse modelo por mais tempo produz melhores resultados. O método forward é substituído para passar dados por cada camada, com uma unidade oculta extra e uma camada extra geral. O método que aproveita os aumentos de velocidade também é demonstrado para executar todas as operações de uma só vez. Uma instância do modelo de três camadas é criada e enviada para o dispositivo de destino, seguida pela criação de uma função de perda e um otimizador e um loop de treinamento e avaliação para o modelo um.
  
  
• 11:15:00 Nesta seção, o vídeo continua do anterior em que o nn.module foi subclassificado para criar um novo modelo, Circle Model V1, com mais unidades ocultas e uma camada extra. Agora, a próxima etapa no fluxo de trabalho é selecionar uma função de perda, e o vídeo usa nn.BCEWithLogitsLoss() como antes, com o mesmo otimizador, archote.optin.SGD(). O vídeo define a taxa de aprendizado para 0,1, o número de épocas para 1.000 e coloca os dados no dispositivo de destino (CPU ou GPU). O vídeo também demonstra um loop pelas épocas e passa os dados de treinamento pelo modelo com a nova arquitetura, calcula a perda e atualiza os parâmetros usando o autograd da tocha.
  
  
• 11:20:00 Nesta seção do vídeo, o instrutor repassa as etapas para avaliar a precisão e a perda do modelo. A função de perda considera os valores de rótulo previstos e os compara com os valores de rótulo reais. A função de precisão é usada para determinar a precisão das previsões do modelo. O otimizador é usado para ajustar os parâmetros do modelo para criar uma melhor representação dos dados. O teste é feito chamando o método eval() do modelo e ativando o modo de inferência. Os logits são criados passando dados de entrada para o modelo e, em seguida, as funções maçarico.round() e maçarico.sigmoid() são usadas para convertê-los em previsões. A perda e a precisão são calculadas para os dados de teste e impressas a cada 100 épocas durante o treinamento do modelo.
  
  
• 11:25:00 Nesta seção do curso PyTorch para Deep Learning e Machine Learning, o instrutor discute técnicas de solução de problemas para quando um modelo não está funcionando, como testar um problema menor para ver se o modelo pode aprender alguma coisa. Ele sugere replicar o conjunto de dados de uma seção anterior em que um modelo linear foi capaz de ajustar uma linha reta e usá-lo para ver se o modelo atual pode aprender alguma coisa, já que atualmente está apenas adivinhando e incapaz de desenhar uma linha reta para separar o dados circulares. O instrutor também menciona que alguns métodos para melhorar um modelo incluem alterar os hiperparâmetros, como o número de camadas e unidades ocultas, e alterar as funções de ativação e perda.
  
  
• 11:30:00 Nesta seção, o instrutor cria um conjunto de dados usando a fórmula de regressão linear para verificar se o modelo funciona em qualquer tipo de problema. O conjunto de dados é chamado de regressão x e contém 100 amostras de um valor x por valor y. O instrutor então cria divisões de treinamento e teste para os dados e verifica seus comprimentos. Por fim, a função de previsões de plotagem do arquivo de funções auxiliares é usada para inspecionar visualmente os dados.
  
  
• 11:35:00 Nesta seção, o apresentador discute um projeto paralelo para ver se seu modelo pode ajustar um conjunto de dados de linha reta antes de tentar ajustar um conjunto de dados de linha não reta. Eles ajustam o Modelo 1 para ajustar o novo conjunto de dados, alterando o número de recursos de entrada de dois para um para corresponder aos dados, mantendo os recursos de saída em 10 para fornecer ao modelo tantos parâmetros quanto possível. Eles também criam o Modelo 2 usando sequencial de ponto NN, que passa dados por camadas e configura uma função de perda e otimizador.
  
  
• 11:40:00 Nesta seção, o instrutor apresenta a função de perda L1 para otimizar um problema de regressão e usa o otimizador SGD com uma taxa de aprendizado de 0,1 para otimizar os parâmetros do modelo. Depois de carregar o conjunto de dados e colocá-lo no dispositivo de destino, o modelo é treinado por mil épocas com um loop. Em cada época, o passo para frente é executado, a perda é calculada e os parâmetros são atualizados usando funções de retrocesso e passo. O progresso do treinamento é impresso com a época, perda e perda de teste a cada 100 épocas. A perda diminui à medida que o modelo é otimizado.
  
  
• 11:45:00 Nesta seção do vídeo, o instrutor recapitula a seção anterior, onde criou um conjunto de dados de linha reta e treinou um modelo para ajustá-lo. Eles confirmam que o modelo está aprendendo algo e sugerem que os alunos brinquem com diferentes valores da taxa de aprendizado para experimentar modelos de aprendizado de máquina. O instrutor passa a explicar como ativar o modo de avaliação e fazer previsões, também conhecidas como inferência. Eles também ensinam como usar a função de previsões de plotagem e encontram um erro devido aos dados não estarem no mesmo dispositivo que o modelo, que eles resolvem chamando dot CPU em suas entradas de tensor.
  
  
• 11:50:00 Nesta seção, o instrutor apresenta a importância da não linearidade no aprendizado de máquina e nos modelos de aprendizado profundo. As funções lineares sozinhas não podem capturar os padrões complexos em dados que requerem funções não lineares como curvas para representá-los com precisão. As redes neurais são construídas combinando funções lineares com funções não lineares, ou ativações, para modelar padrões de dados complexos. O instrutor sugere os próximos vídeos que abordarão as ativações não lineares e seu papel nos modelos de aprendizado profundo.
  
  
• 11:55:00 Nesta seção, o instrutor discute o poder da não linearidade no aprendizado de máquina e nas redes neurais. A não linearidade é essencial no aprendizado de máquina porque os dados nem sempre são compostos de linhas retas. O instrutor então demonstra como criar e plotar dados não lineares usando a função fazer círculos e converter dados em tempos e treinar e testar divisões usando PyTorch e a função de teste de divisão de treinamento do sklearn.

Parte 13

• 12:00:00 Nesta seção, o instrutor de um curso PyTorch para Deep Learning e Machine Learning apresenta a não linearidade, que é um componente crucial da construção de um modelo. O instrutor desafia o visualizador a encontrar uma função não linear específica no módulo TorchNN, que pode incluir camadas de agrupamento, camadas de preenchimento e funções de ativação para executar alguma operação matemática em uma entrada. São fornecidos exemplos de ativações não lineares, como n ponto sigmóide e n ponto relu. O instrutor então demonstra como construir um modelo de classificação usando não linearidade com o PyTorch. Não linearidade significa que o gráfico não é uma linha reta, enquanto linear significa o oposto.
  
  
• 12:05:00 Nesta seção do curso PyTorch para Deep Learning e Machine Learning, o instrutor apresenta o conceito de dados não lineares e como as redes neurais e os modelos de aprendizado de máquina podem trabalhar com números em centenas de dimensões, tornando mais fácil para eles lidar com dados não lineares. Uma nova rede neural, modelo circular V2, é criada usando classes com um construtor e várias camadas que executam operações lineares com a adição de uma função de ativação não linear chamada "relu". Essa função transforma as entradas negativas do modelo em zero, deixando as positivas como estão. O novo modelo é então passado pela função sigmoide para determinar a saída.
  
  
• 12:10:00 Nesta seção, o instrutor desafia os espectadores a recriar um modelo de rede neural no TensorFlow Playground com duas camadas ocultas e cinco neurônios, usando a função de ativação Rectified Linear Unit (ReLU) em vez da função de ativação linear, que eles tenho usado. O instrutor explica que a função de ativação ReLU é uma função de ativação não linear popular e eficaz necessária para modelar dados não lineares, para os quais as redes neurais foram projetadas. O instrutor demonstra o efeito de alterar a taxa de aprendizado na perda de treinamento e incentiva os espectadores a experimentar diferentes taxas de aprendizado para observar o efeito na curva de perda.
  
  
• 12:15:00 Nesta seção, o instrutor discute a criação de um otimizador e uma função de perda para um problema de classificação binária usando o PyTorch. Eles definem a função de ativação não linear do modelo como ReLU e criam sementes aleatórias para CUDA. Eles então percorrem 1000 épocas para treinar o modelo e calculam a perda e a precisão usando o BCE com a função de perda de logits e uma função de precisão, respectivamente. O instrutor incentiva a pensar em como funcionalizar o código de treinamento e sugere que esta seção é para criar experiência e impulso para trabalhar em projetos PyTorch do mundo real.
  
  
• 12:20:00 Nesta seção, o instrutor explica o processo de otimização do modelo com o método de retropropagação no PyTorch. Antes de realizar a retropropagação, os gradientes do otimizador são zerados para que ele possa começar do zero. Depois de executar loss.backward(), o método de etapa do otimizador é chamado para realizar a descida do gradiente nos parâmetros do modelo. O instrutor também demonstra como depurar os parâmetros do modelo e explica que a função de ativação ReLU não possui nenhum parâmetro, o que a torna eficaz. Por fim, o instrutor imprime a perda de treinamento e teste, a precisão e a época para acompanhar o progresso do aprendizado do modelo.
  
  
• 12:25:00 Nesta seção, o instrutor soluciona um problema de forma no código PyTorch e o corrige usando a função squeeze para remover uma dimensão extra na forma de ponto de logits de teste. Eles então discutem o poder da não linearidade e como a adição de camadas relu melhorou o desempenho do modelo, permitindo que ele potencialmente desenhe uma linha para separar os círculos no conjunto de dados. O instrutor também enfatiza a importância da visualização na avaliação do modelo e na realização de previsões, e desafia os espectadores a traçar os limites de decisão.
  
  
• 12:30:00 Nesta seção, o instrutor demonstra o uso da função de limite de decisão de plotagem para visualizar o desempenho de um modelo não linear comparado a um modelo linear. O modelo não linear mostrou ter melhor precisão do que o linear, mas o instrutor desafia o espectador a melhorar ainda mais a precisão. O instrutor passa a discutir como as redes neurais usam funções lineares e não lineares como ferramentas para descobrir padrões em dados, levando a uma demonstração de como criar tensores e usar funções de ativação não lineares no PyTorch.
  
  
• 12:35:00 Nesta seção, o instrutor explica como criar funções de ativação personalizadas no PyTorch replicando as populares funções ReLU e Sigmoid. O instrutor primeiro define um tipo de dados do flutuador da tocha 32 e visualiza uma linha reta plotada usando os valores negativos de 10 a 10 no eixo x. A função ReLU é então criada usando as funções maçarico.relu e nn.relu tomando um tensor de entrada e retornando o máximo de zero e x. Da mesma forma, a função Sigmoid é criada pegando um tensor de entrada e retornando um dividido por um mais o exponencial de x negativo. O instrutor demonstra a eficácia das funções ReLU e Sigmoid personalizadas, plotando-as e comparando-as com as funções integradas do PyTorch.
  
  
• 12:40:00 Nesta seção do curso PyTorch, o instrutor explica a importância de combinar funções lineares e não lineares para encontrar padrões em dados para ajustar um conjunto de dados. A ideia por trás das redes neurais é empilhar camadas dessas funções para criar um modelo. Embora seja possível construir essas camadas do zero, o Pytorch oferece camadas pré-construídas que foram testadas quanto a erros e calculadas o mais rápido possível nos bastidores, além de permitir o uso de GPUs. O instrutor também discute a diferença entre a classificação binária, que envolve dois resultados possíveis, e a classificação multiclasse, que envolve mais de dois resultados possíveis. Finalmente, a seção conclui reiterando a importância da não linearidade em redes neurais e o instrutor lança um desafio para melhorar seu modelo de classificação binária anterior.
  
  
• 12:45:00 Nesta seção, o instrutor do curso apresenta a classificação multiclasse e as diferenças entre ela e a classificação binária. A função de ativação softmax é usada em vez de sigmóide e entropia cruzada em vez de entropia cruzada binária. O instrutor então cria um conjunto de dados de 20 classes múltiplas usando a função make blobs de scikit-learn.datasets para gerar quatro classes com dois recursos cada. O desvio padrão central é ajustado para dar aos clusters alguma aleatoriedade e agitá-los um pouco, tornando assim um pouco mais difícil para o modelo.
  
  
• 12:50:00 Nesta seção, o trecho da transcrição discute como preparar dados para um modelo de classificação multiclasse usando o PyTorch. Eles transformam os dados em tensores e usam a função de divisão de teste de treinamento do scikit-learn para dividir os dados em conjuntos de treinamento e teste. Eles também visualizam os dados usando plot.figure e definem a semente aleatória para garantir a reprodutibilidade. Depois de criar o conjunto de dados de classificação multiclasse, eles consideram se a não linearidade é necessária para separar os dados e, em seguida, prosseguem para construir um modelo para os dados.
  
  
• 12:55:00 Nesta seção, o instrutor discute como configurar um modelo de classificação multiclasse usando o PyTorch. Ele explica o processo passo a passo, começando com a definição da forma da camada de entrada e determinando o número de neurônios por camada oculta. O instrutor então explica como definir a forma da camada de saída, que requer um recurso de saída por aula. Para criar o modelo, o instrutor cria uma classe chamada "modelo blob" que herda de nn.module e define alguns parâmetros para o modelo. Por fim, o instrutor demonstra como inicializar o modelo de classificação multiclasse com recursos de entrada e recursos de saída.

Parte 14

• 13:00:00 Nesta seção, o instrutor discute a criação de um modelo de pilha de camada linear usando o método nn.Sequential do PyTorch. Para instanciar o modelo, o número de recursos de entrada e o número de classes de saída são acessados para determinar a configuração das camadas ocultas. O instrutor configura uma pilha sequencial de camadas para passar os dados por cada camada, uma a uma. Eles também fornecem instruções sobre como adicionar não linearidade ao conjunto de dados e, em seguida, criam um método de encaminhamento para permitir que a entrada passe pelas camadas especificadas sequencialmente. Por fim, uma instância do modelo blob é criada com o número apropriado de recursos de entrada e saída.
  
  
• 13:05:00 Nesta seção do vídeo, o instrutor cria um modelo de classificação multiclasse subclassificando um nn.Module e configura parâmetros para o construtor de classe para personalizar os recursos de entrada e saída. Eles também explicam que o parâmetro de recursos de saída se alinha com o número de classes nos dados. Para criar uma função de perda para um modelo de classificação multiclasse, o instrutor procura e encontra a perda de entropia cruzada no módulo arch.nn, que calcula a perda entre a entrada e o destino e é útil ao treinar um problema de classificação com classes C. O instrutor também explica que o parâmetro de peso é útil ao lidar com um conjunto de treinamento desbalanceado.
  
  
• 13:10:00 Nesta seção, o instrutor discute a criação de uma função de perda e um otimizador para classificação multiclasse. Ele recomenda dois otimizadores comuns, SGD e Adam, mas opta por usar SGD para este exemplo. Em seguida, ele desafia os espectadores a avançar com o modelo criado no vídeo anterior e a considerar quais são as saídas brutas de um modelo. O instrutor também lembra aos espectadores que devem prestar atenção aos parâmetros do dispositivo, pois pode ocorrer um erro de tempo de execução se os tensores não estiverem no mesmo dispositivo. Por fim, ele transforma o modelo em modo de avaliação e faz algumas previsões.
  
  
• 13:15:00 Nesta seção, o instrutor explica como converter os logits de saída de um modelo em probabilidades de previsão e rótulos de previsão para problemas de classificação multiclasse. Para fazer isso, a função softmax é usada para converter os logits em probabilidades de previsão e, em seguida, a previsão com maior probabilidade é considerada o rótulo previsto. O instrutor demonstra esse processo usando o código PyTorch e também observa que a soma das probabilidades para cada amostra sempre será um devido à natureza da função softmax.
  
  
• 13:20:00 Nesta seção, o instrutor explica como ir da saída bruta de um modelo PyTorch para um problema de classificação multiclasse para probabilidades de previsão usando a função de ativação softmax e, em seguida, para rótulos de previsão tomando o argmax do probabilidades de previsão. Esse processo envolve converter a saída bruta do modelo em logits, usar a função softmax para obter as probabilidades de previsão e obter o argmax dessas probabilidades para obter os rótulos de previsão. O instrutor observa que, embora as previsões atuais sejam aleatórias, pois o modelo ainda não foi treinado, essas etapas serão usadas em um loop de treinamento para treinar e avaliar o modelo.
  
  
• 13:25:00 Nesta seção, o instrutor começa a construir um loop de treinamento e teste para um modelo multiclasse. Primeiro, eles configuram sementes manuais para tentar obter a mesma saída todas as vezes, mas observe que isso não é garantido. Eles então definem o número de épocas para 100 e colocam os dados no dispositivo de destino. O loop pelos dados começa e, para cada época, o modelo é treinado com uma passagem direta e logits criados a partir de x blob train. A saída da função Torch softmax é usada para calcular a perda com perda de entropia cruzada e precisão. O otimizador é então zerado e a retropropagação é executada antes que o otimizador seja escalonado. Também é apresentado o código para teste ou inferência, que envolve a configuração do modelo para o modo de avaliação.
  
  
• 13:30:00 Nesta seção, o instrutor discute as camadas de eliminação, desativando a norma de correspondência e o modo de inferência da tocha para tornar as previsões mais rápidas. Eles explicam que, durante o treinamento, as camadas de abandono eliminam aleatoriamente alguns dos neurônios para evitar o overfitting. O instrutor também demonstra como calcular logits de teste e precisão de teste passando em perda de teste e rótulos de teste nos bastidores. Eles então discutem um problema incômodo de tipo de dados que causou um erro de tempo de execução e como o resolveram. O instrutor enfatiza que o código de solução de problemas é uma parte essencial do aprendizado de máquina e leva tempo para identificar e resolver erros.
  
  
• 13:35:00 Nesta seção, o narrador encontra vários desafios de solução de problemas ao criar um modelo de classificação multiclasse. Em primeiro lugar, ele descobre que o erro em seu código se deve a um dos tensores com o tipo de dados errado. Por meio de algumas pesquisas e experimentos, ele muda o tensor para um "tensor torch.long", que otimiza a computação para perda de entropia cruzada. Mais tarde, ele encontra outro erro devido a tamanhos diferentes de seus dados de treinamento e teste. Ao depurar o código na hora, ele identifica o problema e reatribui os dados. Apesar desses desafios, a precisão e a perda do modelo funcionam conforme o esperado, indicando que o modelo está funcionando para um conjunto de dados de classificação multiclasse.
  
  
• 13:40:00 Nesta seção, o instrutor discute como avaliar o modelo de classificação multiclasse treinado fazendo previsões e avaliando-as. O instrutor explica que as previsões são feitas depois de definir o modelo para o modo de avaliação, passar os dados de teste e obter logits brutos como resultado. A próxima etapa é converter logits em probabilidades de predição chamando o arch.softmax em logits. Em seguida, os rótulos de previsões são obtidos chamando o arquivo arch.argmax nas probabilidades de previsão. O instrutor enfatiza a importância de visualizar as previsões plotando-as e comparando-as com os dados reais.
  
  
• 13:45:00 Nesta seção, o instrutor avalia visualmente o modelo de classificação multiclasse e explora as funções lineares e não lineares usadas para separar os dados. O instrutor também menciona que a maioria dos dados requer funções lineares e não lineares para classificação, e o PyTorch facilita a adição dessas funções aos modelos. Além disso, a seção aborda a importância de avaliar modelos e apresenta a precisão e a rechamada como métricas importantes ao lidar com classes com diferentes quantidades de valores.
  
  
• 13:50:00 Nesta seção, o instrutor discute vários métodos de avaliação de classificação, incluindo exatidão, precisão, recuperação, pontuação F1, matriz de confusão e relatório de classificação. O instrutor explica que, embora a precisão seja a métrica padrão para problemas de classificação, ela pode não ser a melhor para conjuntos de dados desequilibrados. Para conjuntos de dados desbalanceados, precisão e rechamada devem ser usados. A precisão é determinada pelo verdadeiro positivo sobre o verdadeiro positivo mais o falso positivo, enquanto a rechamada é determinada pelo verdadeiro positivo sobre o verdadeiro positivo mais o falso negativo. O instrutor também observa a compensação entre precisão e recall, onde o aumento de uma métrica diminuiria a outra. O uso de archmetrics e bibliotecas scikit-learn para métricas de classificação também é discutido.
  
  
• 13:55:00 Nesta seção, o instrutor mostra como importar e usar funções de métricas pré-construídas no PyTorch usando o pacote archmetrics. Eles demonstram como instalar a métrica da tocha, importar a métrica de precisão e usá-la para calcular a precisão de um modelo multiclasse. No entanto, eles também alertam que, ao usar a métrica da tocha, a métrica deve estar no mesmo dispositivo que os dados, usando código independente do dispositivo. O instrutor fornece um link para o módulo de métricas da tocha e artigos extracurriculares para exploração adicional. Eles também apresentam exercícios e soluções para praticar o código abordado nas seções anteriores.

[MetaQuotes]

PyTorch para Deep Learning e Machine Learning - curso completo (partes 15-17)

PyTorch para Deep Learning e Machine Learning - Curso Completo

Parte 15

• 14:00:00 Nesta seção, o instrutor aconselha os visualizadores sobre onde obter ajuda para o código de visão computacional PyTorch, incluindo acompanhar o código, usar o recurso de string doc do Google Colab, pesquisar código no Stack Overflow ou na documentação do PyTorch e fazendo perguntas na guia Discussões do repositório de aprendizado profundo do PyTorch. A seção também aborda exemplos de problemas de visão computacional, como problemas de classificação binária ou multiclasse, em que um modelo de aprendizado de máquina aprende padrões de diferentes exemplos de imagens para determinar se uma imagem é um bife ou pizza ou para classificar imagens em várias categorias .
  
  
• 14:05:00 Nesta seção, o palestrante discute diferentes aplicações de visão computacional usando aprendizado de máquina, como classificação multiclasse para problemas de imagem, detecção de objetos e segmentação de imagens. O palestrante fornece um exemplo de Nutrify, que usa aprendizado de máquina para classificar até 100 alimentos diferentes de uma imagem carregada. O palestrante também discute como a Tesla usa visão computacional para planejar os movimentos de seus carros autônomos usando espaço vetorial tridimensional e aprendizado de máquina. O palestrante observa que a Tesla usa o PyTorch, que é o mesmo código ensinado no curso.
  
  
• 14:10:00 Nesta seção do vídeo, o instrutor discute o uso do PyTorch para criar um modelo de visão computacional para classificação de imagens multiclasse. Usando o exemplo do Nutrify, uma tecnologia de reconhecimento de fotos para alimentos, o instrutor explica as entradas e saídas típicas de um problema de visão computacional. As entradas incluem um tensor que representa os canais de altura, largura e cor de uma imagem. O instrutor também menciona que algoritmos existentes podem já existir para problemas populares de visão computacional, mas um pode ser construído, se necessário. A saída desejada para o exemplo Nutrify é de três saídas, uma para cada classe de alimento.
  
  
• 14:15:00 Nesta seção, o vídeo explica como modelos de aprendizado de máquina podem ser usados para classificação de imagens, utilizando PyTorch e redes neurais convolucionais (CNNs) para representar informações numericamente e treinar o modelo para reconhecer padrões nos dados. O exemplo dado é prever os tipos de comida em uma imagem, como sushi, bife e pizza, com o uso do PyTorch para codificar as informações e CNNs para reconhecer padrões nas imagens. O vídeo enfatiza que as formas de entrada e saída variam de acordo com o problema que está sendo resolvido e que as CNNs são normalmente a melhor escolha para dados de imagem, embora outros modelos possam ser usados. Por fim, o vídeo apresenta um problema envolvendo imagens em tons de cinza de itens de moda que serão usadas para demonstrar melhor os mesmos princípios aprendidos nesta seção.
  
  
• 14:20:00 Nesta seção, o instrutor discute a representação de dados de imagem no PyTorch e outras bibliotecas de aprendizado profundo. Essas bibliotecas geralmente esperam que os canais de cores sejam os últimos, mas o padrão do PyTorch é representar dados de imagem com canais de cores primeiro. O vídeo explica a importância de alinhar as formas de entrada e saída de um modelo para um determinado problema. O instrutor fornece uma visão geral do fluxo de trabalho do PyTorch para criar modelos, incluindo preparar dados usando transformações e carregadores de dados, criar ou escolher um modelo pré-treinado, selecionar um otimizador e uma função de perda, avaliar o modelo usando métricas e experimentar para melhorar o modelo. A próxima seção discute a arquitetura de uma rede neural convolucional (CNN).
  
  
• 14:25:00 Nesta seção, o instrutor discute a arquitetura de uma rede neural convolutiva (CNN) típica. Os dados de entrada passam por várias camadas, incluindo camadas convolucionais, de ativação e de agrupamento, até serem convertidos em uma forma de saída que pode ser convertida em nomes de classe. O instrutor enfatiza que existem maneiras quase ilimitadas de empilhar uma CNN e demonstra uma maneira de fazer isso por meio de slides. No entanto, a melhor maneira de aprender é codificá-lo, e o instrutor direciona os usuários para um notebook do Google Colab, onde eles podem praticar a construção de uma CNN usando o PyTorch e a biblioteca TorchVision. O instrutor também fornece recursos adicionais, incluindo um caderno de referência e uma seção de visão computacional PyTorch em LearnPyTorch.io.
  
  
• 14:30:00 Nesta seção do vídeo, o instrutor apresenta as diferentes bibliotecas PyTorch para diferentes domínios, destacando a força do PyTorch em visão computacional. A principal biblioteca para visão computacional é a visão de tocha, que contém conjuntos de dados, modelos pré-treinados para visão computacional e transformações para manipular dados de visão em números utilizáveis por modelos de aprendizado de máquina. O instrutor demonstra a importação de PyTorch, NN e visão de tocha e percorre o módulo de transformações, que contém transformações de imagem comuns e podem ser treinadas juntas usando a composição. A função to_tensor é apresentada como uma transformação principal para transformar dados de imagem em formato de tensor.
  
  
• 14:35:00 Nesta seção do curso PyTorch para Deep Learning e Machine Learning, o instrutor aborda as bibliotecas fundamentais de visão computacional no PyTorch, incluindo TorchVision, módulos derivados do TorchVision e TorchUtils.data.dataset, que é o conjunto de dados base classe para PyTorch. O instrutor também discute a importância de usar o Matplotlib para visualização e a necessidade de converter imagens em tensores para usar com modelos. O instrutor então apresenta o conjunto de dados FashionMNIST, que é uma versão do banco de dados MNIST original, apresentando imagens em tons de cinza de peças de roupa. Este conjunto de dados será usado para demonstrar técnicas de visão computacional. O instrutor explica que, embora pesquisadores sérios de aprendizado de máquina considerem o MNIST usado em excesso e não representativo das tarefas modernas de visão computacional, o FashionMNIST é um conjunto de dados útil para começar.
  
  
• 14:40:00 Nesta seção, o instrutor discute como baixar e usar conjuntos de dados da biblioteca TorchVision. Eles mencionam vários conjuntos de dados de classificação de imagem, como Caltech101, CIFAR-100 e CIFAR-10, e como baixá-los usando o módulo archvision.datasets. Em seguida, o instrutor demonstra como baixar e usar o conjunto de dados Fashion-MNIST, explicando os vários parâmetros e transformações que podem ser aplicados ao conjunto de dados. Eles também fornecem código de amostra para baixar os conjuntos de dados de treinamento e teste.
  
  
• 14:45:00 Nesta seção, o instrutor explica como usar o archvision.datasets do PyTorch para baixar exemplos de conjuntos de dados de visão computacional, especificamente o conjunto de dados FashionMNIST. Podemos armazenar os dados em uma variável chamada "data" e usar o archvision.transforms para converter os dados da imagem em tensores. O instrutor também demonstra como verificar o comprimento dos conjuntos de dados de treinamento e teste, visualizar a imagem e o rótulo de um exemplo de treinamento e obter mais informações sobre os nomes das classes por meio do uso de atributos como ".classes" e ".class_to_idx". Por fim, eles explicam que um rótulo não tem forma porque é apenas um número inteiro.
  
  
• 14:50:00 Nesta seção, o instrutor discute as formas de entrada e saída do conjunto de dados Fashion MNIST, que é composto por imagens em tons de cinza de diferentes tipos de roupas. A forma de entrada das imagens está no formato NCHW, onde o tamanho do lote é definido como "nenhum" e a forma de saída é 10. Para entender melhor os dados, o instrutor usa Matplotlib para visualizar uma imagem e sua forma, mas encontra um erro porque o formato de dados não corresponde ao formato esperado. A seção enfatiza a importância de entender as formas de entrada e saída e a formatação ao trabalhar com modelos de aprendizado de máquina.
  
  
• 14:55:00 Nesta seção, o vídeo explora como plotar e visualizar dados de imagem usando PyTorch e Matplotlib. O instrutor demonstra como plotar uma única imagem e remover dimensões extras usando image.squeeze(). Em seguida, eles traçam um conjunto de 16 imagens aleatórias do conjunto de dados usando uma semente aleatória fixa e a função subplot do Matplotlib. O instrutor também mostra como usar a propriedade ou parâmetro cmap para alterar o mapa de cores do gráfico para escala de cinza. Eles então discutem a importância de explorar visualmente um conjunto de dados para obter uma melhor compreensão dos dados e identificar possíveis problemas, como semelhanças entre pulôveres e camisas no conjunto de dados.

Parte 16

• 15:00:00 Nesta seção, o instrutor explica a importância de preparar dados para um modelo de visão computacional e como fazer isso usando conjuntos de dados e carregadores de dados PyTorch. Ele também discute a necessidade potencial de não linearidade na modelagem das 60.000 imagens de roupas a serem classificadas em 10 classes diferentes e como dividir o conjunto de dados em lotes menores pode melhorar a eficiência computacional. O objetivo desta preparação é criar um Python iterável que possa ser usado pelo modelo para identificar padrões nos dados.
  
  
• 15:05:00 Nesta seção, o instrutor explica o conceito de minilotes e por que ele é comumente usado em aprendizado profundo, começando com a divisão de um conjunto de dados de 60.000 imagens em lotes de 32. Os dois principais motivos para usar minilotes são tornar a rede neural mais eficiente computacionalmente, evitando limitações de memória da GPU e dando à rede mais chances de atualizar seus gradientes por época. Os dados são agrupados usando o carregador de dados de arch.utils.data passando um conjunto de dados, definindo o tamanho do lote e configurando shuffle como verdadeiro para evitar que a rede memorize a ordem dos dados. O instrutor fornece código para criar carregadores de dados de treinamento e teste, que serão usados no loop de treinamento.
  
  
• 15:10:00 Nesta seção, a importância de mini-lotes em problemas de aprendizado profundo é enfatizada, e o processo de criação de carregadores de dados de treinamento e teste é explicado usando o PyTorch. O hiperparâmetro do tamanho do lote é definido como 32 e os conjuntos de dados são transformados em iteráveis. Os conjuntos de dados de treinamento e teste são carregados usando o DataLoader, com o tamanho do lote definido como 32 para os dados de treinamento e os dados de teste e shuffle definido como True para dados de treinamento e False para dados de teste. Os atributos do carregador de dados do trem, como tamanho do lote e conjunto de dados, são explorados. O comprimento dos carregadores de dados de treinamento e teste é impresso para determinar o número de lotes em cada um.
  
  
• 15:15:00 Nesta seção, o instrutor discute como visualizar lotes de imagens usando o PyTorch. O trecho da transcrição mostra como o comprimento do carregador de dados de treinamento é determinado, com base no tamanho do lote e no número de amostras de treinamento. Em seguida, o instrutor mostra como visualizar uma única imagem de um lote usando aleatoriedade e verifica o tamanho da imagem e o rótulo associado a essa amostra. O instrutor enfatiza que essas formas de entrada e saída variam dependendo do problema específico, mas a premissa básica permanece a mesma – os dados são transformados em lotes para serem passados para um modelo.
  
  
• 15:20:00 Nesta seção, o instrutor em vídeo explica como visualizar imagens em lote e transformar os dados em carregadores de dados. Eles também introduziram o conceito de um modelo de linha de base, que é usado como ponto de partida e é um modelo simples que pode ser aprimorado posteriormente por meio de experimentação. Em seguida, o instrutor apresenta uma nova camada, "flatten", que nivela uma faixa contínua de dims em um tensor para uso com sequencial e mostra como usá-lo como um modelo autônomo.
  
  
• 15:25:00 Nesta seção, aprendemos sobre nivelamento e como ele é usado para transformar dados multidimensionais em um único vetor. Depois de imprimir as formas antes e depois do achatamento, vemos que a saída agora é um vetor unidimensional com comprimento de 1784. Também vemos que esse processo é semelhante à codificação de informações nas câmeras de Tesla para uso em modelos de aprendizado profundo. Em seguida, vemos como os dados achatados serão usados na camada linear de nosso modelo PyTorch. O modelo é definido usando nn.Sequential e inclui uma camada plana e duas camadas lineares. As formas de entrada e saída são definidas e vemos que os recursos de saída da primeira camada linear correspondem aos recursos de entrada da segunda camada linear.
  
  
• 15:30:00 Nesta seção, o instrutor explica como criar um modelo de rede neural simples usando o PyTorch. O modelo consiste em uma camada achatada seguida por duas camadas lineares, sem não linearidades. O método forward do modelo é definido, que pega uma entrada, passa pela camada plana, depois pelas duas camadas lineares e retorna a saída. O instrutor, então, configura uma instância do modelo e executa um passe de simulação para garantir que o modelo esteja funcionando conforme o esperado. Além disso, eles também explicam a forma de entrada e saída de cada camada e como elas são organizadas para obter a forma de saída desejada. Finalmente, eles demonstram a importância de usar a camada plana e porque é necessário combinar a saída da camada anterior em um único vetor.
  
  
• 15:35:00 Nesta seção, o instrutor revisa o vídeo anterior em que criou o modelo zero para um problema de visão computacional e reiterou a importância de garantir que as formas de entrada e saída estejam alinhadas onde precisam estar. Eles também explicam que os pesos e as matrizes de viés representam diferentes recursos nas imagens, que o modelo aprenderá por meio de aprendizado profundo e aprendizado de máquina. Avançando, eles discutem a seleção de uma função de perda, otimizador e métrica de avaliação para o modelo, escolhendo perda de entropia cruzada, otimizador de descida de gradiente estocástico e métrica de avaliação de precisão, respectivamente. Eles também fornecem uma referência a um recurso on-line do PyTorch para métricas de avaliação de classificação.
  
  
• 15:40:00 Nesta seção, o instrutor de vídeo discute o conceito de usar funções auxiliares em projetos de aprendizado de máquina Python. Ele fornece um código de amostra para importar um script Python contendo funções comuns, incluindo uma função auxiliar chamada precisão. A função de precisão calcula a métrica de precisão e o instrutor demonstra que ela pode ser importada com sucesso verificando uma string de documento. Ele também explica que o uso de funções auxiliares em projetos Python pode economizar muito tempo e esforço, especialmente ao lidar com funcionalidades comuns que não precisam ser reescritas todas as vezes. Por fim, ele configura uma função de perda igual a nn pontos de perda de entropia cruzada e um otimizador para treinar o modelo.
  
  
• 15:45:00 Nesta seção, o instrutor configura o otimizador para descida de gradiente estocástico e define uma taxa de aprendizado relativamente alta de 0,1 para o conjunto de dados simples de imagens de 28x28. Em seguida, eles discutem a importância de acompanhar o desempenho de um modelo, bem como seu tempo de execução, já que muitas vezes há uma compensação entre os dois. Eles demonstram como criar uma função para cronometrar o treinamento do modelo usando o módulo de tempo em Python e passando o arquivo arch.device para comparar a velocidade com que o modelo é executado em diferentes dispositivos.
  
  
• 15:50:00 Nesta seção, o instrutor discute a importância das funções de temporização para medir quanto tempo um modelo leva para treinar. Ele demonstra como criar um timer usando o módulo "timer" do Python e mostra como incorporá-lo ao processo de treinamento. O instrutor também explica como usar o recurso de reconexão do Google Colab e fornece um lembrete sobre o uso de carregadores de dados para dividir dados em lotes para treinamento. Em seguida, ele descreve as etapas envolvidas na criação de um loop de treinamento e no treinamento de um modelo em lotes de dados, enfatizando a necessidade de percorrer épocas e lotes, executar etapas de treinamento e calcular a perda de trem por lote. Por fim, ele menciona que o modelo será avaliado na mesma etapa do treinamento.
  
  
• 15:55:00 Nesta seção, o instrutor inicia a fase de teste importando TQDM para uma barra de progresso que indicará por quantas épocas o loop de treinamento passou. TQDM é uma barra de progresso do Python com baixo overhead e é um software de código aberto. Como o TQDM é tão popular, ele está integrado ao Google CoLab. O instrutor define a semente e inicia o cronômetro antes de definir o número de épocas para três para um tempo de treinamento mais rápido para executar mais experimentos. Eles criam um loop de treinamento e teste, instanciam a perda de trem e calculam a perda de treinamento por época. Os dados são agrupados em lote e um loop é adicionado para percorrer os dados do lote de treinamento.

Parte 17

• 16:00:00 Nesta seção, o instrutor configura o loop de treinamento para a rede neural. O modelo é colocado em modo de treinamento e o passe para frente é executado para calcular a perda. Os valores de perda de treinamento são acumulados a cada lote e o otimizador é atualizado uma vez por lote em vez de uma vez por época. O instrutor também imprime as amostras examinadas e a perda média de treinamento por lote por época para fins de monitoramento. Esse loop continuará até que todos os lotes tenham sido processados no carregador de dados do trem.
  
  
• 16:05:00 Nesta seção, o instrutor percorre o código do loop de teste no PyTorch, que envolve a configuração de uma variável de perda de teste e o uso de uma passagem direta para avaliar os padrões aprendidos nos dados de treinamento. A precisão do teste também é calculada usando a função de precisão baixada, e os valores de perda e precisão do teste são acumulados por lote e depois divididos pelo número de lotes para encontrar a média por época. Esses valores são então impressos para acompanhar o progresso do modelo.
  
  
• 16:10:00 Nesta seção, o instrutor discute as etapas finais da configuração do loop de treinamento, que inclui a impressão da perda de trem, perda de teste e precisão do teste, bem como o cálculo do tempo de treinamento. Eles também fornecem dicas de solução de problemas para possíveis erros que podem surgir durante a codificação no PyTorch. Eles concluem demonstrando como executar o código e mostram a barra de progresso do loop de treinamento.
  
  
• 16:15:00 Nesta seção, o instrutor discute os resultados do loop de treinamento e apresenta a ideia de precisão da linha de base e tempo de treinamento. Ele destaca que os números podem variar um pouco devido à aleatoriedade inerente ao aprendizado de máquina e ao hardware utilizado. O instrutor passa a avaliar o modelo criando uma função para construir vários modelos e comparar os resultados posteriormente. A função recebe um modelo, um carregador de dados, uma função de perda e uma função de precisão e retorna um dicionário contendo os resultados da previsão do modelo no carregador de dados. Ele explica que a função é semelhante ao loop de teste, mas é funcionalizada para ser usada com vários modelos e carregadores de dados. O instrutor também menciona que as seções a seguir abordarão como fazer previsões e avaliar o modelo na GPU e na rede neural convolucional.
  
  
• 16:20:00 Nesta seção, o criador do vídeo mostra como tornar a função de perda e precisão generalizável para que possa ser usada com qualquer modelo e carregador de dados. Eles demonstram como acumular os valores de perda e precisão por lote, dimensioná-los para encontrar a perda/precisão média por lote e retornar os resultados em um formato de dicionário. Eles também mostram como criar uma nova função para calcular os resultados do modelo no conjunto de dados de teste, usando as funções definidas anteriormente. Por fim, eles usam uma barra de progresso para acompanhar o desempenho do modelo no conjunto de dados de teste.
  
  
• 16:25:00 Nesta seção do curso PyTorch para Deep Learning e Machine Learning, o instrutor discute como configurar o código independente de dispositivo para treinar modelos em CPUs e GPUs. Eles demonstram a verificação da disponibilidade de CUDA e a mudança para a GPU para aproveitar seu poder de processamento. O instrutor também recomenda começar com conjuntos de dados e modelos menores antes de aumentar a complexidade e o tamanho. Por fim, eles propõem construir um novo modelo para o conjunto de dados e testar seu desempenho com e sem não linearidades durante a execução na GPU.
  
  
• 16:30:00 Nesta seção, o instrutor apresenta o conceito de não linearidade em redes neurais e incentiva os espectadores a experimentar a criação de um modelo com funções não lineares. Os benefícios da não linearidade para modelar dados não lineares são discutidos e o instrutor explica como implementar uma rede neural com camadas lineares e não lineares usando o PyTorch. Eles percorrem o código passo a passo e enfatizam a importância da experimentação para encontrar o melhor modelo para um determinado conjunto de dados.
  
  
• 16:35:00 Nesta seção, o instrutor discute a personalização de redes neurais com funções lineares e não lineares e demonstra a adição de duas funções de ativação ReLU a uma rede definida anteriormente. O método forward é substituído para permitir que a entrada passe pela pilha de camadas e o modelo é instanciado no dispositivo. O vídeo passa a criar uma função de perda, otimizador e métricas de avaliação para o novo modelo, que adicionou camadas não lineares, enfatizando a importância de realizar experimentos para entender como diferentes funções podem influenciar as redes neurais.
  
  
• 16:40:00 Nesta seção, o palestrante discute a criação de funções auxiliares e a funcionalidade de loops de treinamento e avaliação no PyTorch. Eles mencionam a importação da função de precisão e a configuração de uma função de perda, bem como o otimizador. O próximo passo é construir loops de treinamento e avaliação como funções para que possam ser chamados repetidamente sem o risco de erros. O palestrante percorre o processo de criação de uma função de etapa de trem, que requer um modelo, carregador de dados, função de perda, otimizador e, opcionalmente, uma função de precisão e dispositivo de destino como entradas. A função train step percorre um carregador de dados, executa uma passagem direta, calcula a perda, retropropaga e atualiza os parâmetros do modelo com o otimizador.
  
  
• 16:45:00 Nesta seção, o apresentador explica como realizar uma etapa de treinamento no PyTorch. Eles começam definindo as entradas da função, incluindo um modelo, um carregador de dados, uma função de perda, um otimizador e um dispositivo. Em seguida, eles passam por cada linha da função, começando com um loop pelo carregador de dados e colocando os dados no dispositivo de destino. Eles também adicionam uma função de precisão para acumular a pontuação de precisão por lote. Por fim, ao final da etapa de treinamento, eles calculam a perda média e a precisão por lote e imprimem os resultados. No geral, esta seção fornece uma explicação clara e concisa de como usar o PyTorch para aprendizado profundo e aprendizado de máquina.
  
  
• 16:50:00 Nesta seção, o treinador funcionaliza o loop de teste criando uma função de etapa de teste que recebe um modelo, carregador de dados, função de perda, função de precisão e dispositivo como entradas. O treinador demonstra como configurar uma perda e precisão de teste e colocar o modelo no modo de avaliação antes de percorrer o carregador de dados e executar uma passagem direta. O instrutor também explica a importância de usar o gerenciador de contexto do modo de inferência e criar código independente de dispositivo. O pred do teste é calculado passando em X, e a perda e a precisão do teste são acumuladas por lote usando as respectivas funções. Por fim, o treinador converte os logits de saída em rótulos de previsão usando o argmax.
  
  
• 16:55:00 Nesta seção do curso completo do PyTorch, o instrutor demonstra como criar uma função de etapa de teste e um loop de otimização e avaliação usando as funções de etapa de treinamento e etapa de teste. As novas funções são usadas para treinar um modelo e avaliar sua precisão por três épocas. O instrutor também mostra como medir o tempo que leva para o modelo ser executado na GPU em comparação com a CPU.

[MetaQuotes]

PyTorch para Deep Learning e Machine Learning - Curso Completo (descrição das partes 18-22)

PyTorch para Deep Learning e Machine Learning - Curso Completo

Parte 18

• 17:00:00 Nesta seção, o instrutor nos orienta na configuração da etapa de teste para nosso modelo de aprendizado profundo e na criação de um cronômetro para medir o tempo de treinamento. O código é simples e eficiente, pois foi projetado para ser reutilizável em projetos futuros. Além disso, executamos o segundo experimento de modelagem e comparamos os resultados com o primeiro modelo, que utilizou camadas não lineares. Embora o segundo modelo tenha sido um pouco mais rápido em termos de tempo de treinamento, ele não produziu melhores resultados do que o anterior, o que significa que seus números podem não ser iguais aos do instrutor, mas devem ser bastante semelhantes na direção. Finalmente, o instrutor explica que nosso modelo não é muito complexo e nosso conjunto de dados não é muito grande, então isso pode explicar por que os tempos de treinamento de CPU e GPU não são tão diferentes.
  
  
• 17:05:00 Nesta seção, o instrutor explica que às vezes um modelo treina mais rápido em uma CPU do que em uma GPU. As duas principais razões para isso são que a sobrecarga para copiar dados/modelo de e para a GPU supera os benefícios de computação oferecidos pela GPU e que o hardware usado tem uma CPU melhor em termos de capacidade de computação do que a GPU. No entanto, o instrutor observa que isso é menos comum e, geralmente, uma GPU moderna é mais rápida na computação de algoritmos de aprendizado profundo do que uma CPU geral. Em seguida, o instrutor compartilha um recurso que fala sobre como tornar o aprendizado profundo mais rápido, otimizando a largura de banda e os custos indiretos, entre outras coisas. Por fim, o instrutor cria um dicionário de resultados para o modelo um para comparar os resultados da modelagem posteriormente.
  
  
• 17:10:00 Nesta seção, o instrutor discute um erro comum que pode ocorrer em modelos de aprendizado profundo em relação a incompatibilidades de dispositivo entre dados e modelo. Ele explica que o erro ocorreu porque os dados e o modelo estavam em dispositivos diferentes e sugere uma correção tornando o código independente do dispositivo. Ele também adverte que é sempre melhor criar um código agnóstico de dispositivo. Por fim, o instrutor apresenta o próximo experimento de modelagem, que envolve a construção de uma rede neural convolucional (CNN) e explica a arquitetura de uma CNN típica.
  
  
• 17:15:00 Nesta seção, o instrutor explica os diferentes tipos de camadas em uma rede neural convolucional simples (CNN). A CNN começa com uma entrada, pré-processada em um tensor em vermelho, verde e azul para uma imagem. A entrada então passa por uma combinação de camadas convolucionais, camadas relu e camadas de pooling. O modelo de aprendizado profundo pode ter mais camadas adicionadas a ele para encontrar mais padrões nos dados, com cada camada executando uma combinação diferente de operações matemáticas nos dados. O instrutor demonstra a CNN usando o site de explicação da CNN, onde a entrada de diferentes imagens passa por diferentes camadas, sendo a saída final a classe com o maior valor.
  
  
• 17:20:00 Nesta seção, o instrutor explica como as redes neurais convolucionais funcionam e a beleza do aprendizado profundo. Cada camada da rede é projetada para aprender diferentes recursos dos dados, com a própria rede descobrindo a melhor maneira de aprender esses recursos. O instrutor então apresenta o site explicativo da CNN como um recurso para aprender mais sobre redes neurais convolucionais, mas também incentiva
  os alunos participem da replicação da rede neural no código PyTorch. O instrutor então passa a construir uma pequena rede neural convolucional VGG no PyTorch e explica que os autores de trabalhos de pesquisa podem nomear novas arquiteturas de modelo para facilitar a referência futura. O código é inicializado com formato de entrada, unidades ocultas e formato de saída, que são parâmetros típicos na construção de um modelo PyTorch.
  
  
• 17:25:00 Nesta seção, o instrutor explica como criar uma rede neural usando blocos no PyTorch, geralmente chamados de blocos convolucionais. Esses blocos são compostos por várias camadas e uma arquitetura geral é composta por vários blocos. O instrutor mostra como criar blocos convolucionais escrevendo dois exemplos de camadas com hiperparâmetros, como canais de entrada e saída, tamanho do kernel, passo e preenchimento. O instrutor também fornece recursos interativos para que os alunos entendam os fundamentos dos hiperparâmetros e os incentiva a passar por isso.
  
  
• 17:30:00 Nesta seção, o instrutor percorre o código para construir um modelo de aprendizado profundo usando o PyTorch, focando especificamente nas camadas de blocos convolucionais. O modelo recebe dados de imagem 2D e as camadas são usadas para aprender uma representação compactada dos dados de entrada, com pooling máximo usado para obter o valor máximo dos dados de entrada. O código é dividido em dois blocos e, em seguida, uma camada de saída é adicionada. As entradas da camada final são niveladas antes de serem colocadas na última camada linear para criar a saída final.
  
  
• 17:35:00 Nesta seção, o instrutor constrói a camada classificadora para uma rede neural convolucional (CNN) chamada tiny VGG, que tem duas camadas que atuam como extratores de recursos e uma camada final que classifica esses recursos em classes de destino. O instrutor codifica a camada classificadora usando sequencial e passa em uma camada nivelada para nivelar a saída das duas camadas anteriores em um único vetor de recursos. O vetor de recursos é então passado para uma camada nn.linear, que calcula os recursos internos com base no número de unidades ocultas e os recursos externos com base no comprimento das classes. Por fim, o instrutor configura o método de encaminhamento e imprime a forma de ponto X para rastrear as alterações de forma de cada camada. O instrutor estabelece a forma de entrada para o modelo CNN, que possui apenas um canal de cores para imagens em preto e branco, define o valor das unidades ocultas para cada camada e finaliza instanciando o modelo.
  
  
• 17:40:00 Nesta seção do vídeo, o instrutor percorre o código que escreveu na seção anterior para criar uma rede neural convolucional usando o PyTorch. Eles identificam e corrigem alguns erros de digitação no código e explicam que a camada maxpool2d não possui nenhum parâmetro que possa ser aprendido. Eles então apresentam a camada conv2d e explicam que seu tensor de peso e valor de viés manipulam a entrada para produzir a saída. Eles mostram como reproduzir a primeira camada do site do explicador da CNN usando uma entrada fictícia no PyTorch e fornecem um link para a documentação do PyTorch para leitura posterior. Eles também demonstram como criar imagens em lote usando o estilo PyTorch com canais de cores primeiro.
  
  
• 17:45:00 Nesta seção, o tutorial em vídeo explora a composição de um modelo PyTorch e como as convoluções funcionam na prática. O instrutor explica como o modelo, composto de números aleatórios, ajusta essas camadas para melhor representar os dados usando camadas comp2d. Depois de passar alguns dados aleatórios por uma dessas camadas, o tutorial mergulha no tamanho do kernel e como ele determina a operação realizada pela convolução. O instrutor detalha o propósito de uma camada convolucional, que é garantir que esse kernel seja capaz de executar corretamente a operação para fornecer a saída correta.
  
  
• 17:50:00 Nesta seção, o instrutor explica os efeitos da alteração dos valores de passada e preenchimento em uma camada convolucional no PyTorch. Um valor de passo de 1 significa que a convolução salta sobre um pixel por vez, enquanto um valor de passo de 2 saltos sobre dois pixels por vez, levando a uma diminuição no tamanho da saída. Enquanto isso, adicionar preenchimento às bordas da imagem permite que o kernel opere nas informações da imagem nas bordas. O instrutor também observa que, quando não tem certeza sobre quais valores definir para os diferentes parâmetros, é comum copiar os valores existentes e ajustá-los conforme necessário. A seção termina com uma demonstração de como adicionar uma dimensão de lote a uma imagem de teste e passá-la por uma camada convolucional no PyTorch.
  
  
• 17:55:00 Nesta seção, o vídeo cobre as camadas convolucionais e de pool máximo no PyTorch para aprendizado profundo e aprendizado de máquina. O vídeo demonstra como usar o PyTorch para criar camadas convolucionais passando uma imagem de teste por uma camada convolucional para produzir uma saída. Ao brincar com os valores de tamanho do kernel, passo e preenchimento, os usuários podem observar como o tamanho da saída muda. O vídeo também aborda a camada de pooling máximo e mostra como criar uma camada de pooling máximo de amostra com um tamanho de kernel de dois.

Parte 19

• 18:00:00 Nesta seção, o instrutor demonstra como passar dados por uma camada convolucional e uma camada de pool máximo no PyTorch. Eles começam passando a imagem de teste pela camada conv primeiro e depois imprimindo a forma. Eles então passam a saída da camada conv através da camada max pool e novamente imprimem a forma resultante. O instrutor explica que a camada de pool máximo leva o máximo de um determinado intervalo de tensor interno e reduz o tamanho de saída da camada convolucional. Eles também demonstram como as formas mudarão se os valores das camadas e parâmetros forem alterados.
  
  
• 18:05:00 Nesta seção, o instrutor explica o conceito de Max Pooling em Redes Neurais Convolucionais (CNNs). O objetivo é compactar os dados de entrada em um vetor de recursos menor que pode ser usado para previsões futuras. O pooling máximo envolve obter o valor máximo de uma determinada seção de dados de entrada para determinar o recurso mais importante nessa região. O instrutor demonstra os efeitos da variação do tamanho do kernel para pooling máximo e como isso afeta o espaço de recursos. Eles também fornecem um exemplo visual usando um tensor aleatório menor para mostrar o processo de max pooling. No geral, o pooling máximo é uma técnica útil para reduzir a dimensionalidade dos dados, mantendo recursos importantes para previsões.
  
  
• 18:10:00 Nesta seção do curso, o instrutor discute o propósito da camada de pool máximo em uma rede neural convolucional, que é comprimir os recursos aprendidos da camada convolucional em um espaço menor, levando a uma representação comprimida dos dados de entrada que podem ser usados para fazer previsões. O instrutor também desafia os espectadores a criar um tensor fictício e passá-lo pela pequena rede VGG que eles construíram nos vídeos anteriores para ver o que acontece com a forma do tensor fictício conforme ele se move pelos blocos convolucionais. Por fim, o instrutor explica que o objetivo de replicar um modelo de outro lugar e passar dados por ele é uma prática comum no aprendizado profundo.
  
  
• 18:15:00 Nesta seção, o instrutor fornece um exemplo de passe para frente no PyTorch e demonstra como lidar com erros de incompatibilidade de formato. Eles usam uma imagem criada anteriormente do conjunto de dados Fashion MNIST e criam um tensor com a mesma forma da imagem. No entanto, eles recebem um erro devido ao tensor ter uma dimensão extra para o tamanho do lote. Para corrigir isso, eles descomprimem o tensor na dimensão zero para adicionar a dimensão do lote. Eles também garantem que o tensor esteja no mesmo dispositivo que o modelo e demonstram como solucionar problemas e encontrar as formas necessárias para diferentes camadas do modelo. A seção termina com o instrutor recriando o modelo usando as informações coletadas sobre as formas.
  
  
• 18:20:00 Nesta seção do vídeo, o instrutor demonstra um truque para depurar as formas das camadas em um modelo de rede neural. Ao passar dados fictícios pelo modelo e imprimir as formas da saída em cada camada, o instrutor é capaz de determinar onde estão ocorrendo incompatibilidades de formas e identificar problemas com a camada do classificador. O instrutor então mostra como calcular as formas de entrada e saída de camadas convolucionais manualmente, mas também afirma os benefícios de usar o código para realizar esses cálculos. Por fim, o instrutor usa o truque para garantir que o modelo seja compatível com as regras de multiplicação de matrizes e para confirmar que o modelo pode processar dados com a forma desejada.
  
  
• 18:25:00 Nesta seção, o instrutor discute as formas de entrada e saída de cada camada no modelo que construiu. Eles passam um tensor aleatório pelo modelo e obtêm uma forma de saída de um e dez, pois possuem dez classes em seu conjunto de dados. Em seguida, eles passam a configurar uma função de perda e um otimizador para seu segundo modelo e explicam como vão treinar sua primeira rede neural convolucional (CNN). Eles importam uma função de precisão, configuram uma função de perda de entropia cruzada e mantêm o otimizador como antes, arch.opt em SGD. Eles então demonstram como usar suas funções de etapa de treinamento e etapa de teste para treinar o modelo dois, que abordarão em detalhes no próximo vídeo. Por fim, eles configuram a funcionalidade de treinamento e teste executando a etapa de treinamento com o modelo e tentando aprender em um carregador de dados.
  
  
• 18:30:00 Nesta seção, o vídeo se concentra no treinamento de uma rede neural convolucional e mede o tempo necessário para treiná-la usando o TQDM para medir o progresso. Eles configuram a função de precisão, função de perda, otimizador, carregador de dados de trem e carregador de dados de teste. Eles também medem o tempo final para saber quanto tempo o código levou para ser executado. Eles tiveram um problema de código com uma impressão, mas o corrigiram e treinaram com sucesso sua primeira CNN, alcançando uma precisão de teste de 88,5% em cerca de 42 segundos. O vídeo aconselha estar ciente de que um modelo de melhor desempenho geralmente leva mais tempo para treinar.
  
  
• 18:35:00 Nesta seção, o instrutor discute a importância de comparar resultados e tempo de treinamento em diferentes modelos em experimentos de aprendizado de máquina. Eles apresentam três dicionários de resultados de modelos e criam um quadro de dados usando pandas para comparar a precisão, perda e tempo de treinamento de cada modelo. Eles descobriram que a rede neural convolucional (Modelo 2) superou os outros modelos com uma precisão de 88% e incentiva os visualizadores a experimentar diferentes arquiteturas de modelo, hiperparâmetros e tempos de treinamento para obter melhores resultados. O instrutor enfatiza a importância de considerar o trade-off entre desempenho do modelo e velocidade em aplicações práticas.
  
  
• 18:40:00 Nesta seção, o instrutor discute a comparação dos resultados dos três experimentos realizados na seção anterior usando um quadro de dados e um gráfico. O tempo de treinamento e a precisão são comparados para cada modelo, e o instrutor observa que o tempo de treinamento varia de acordo com o hardware usado. O modelo de melhor desempenho foi a rede neural convolucional, mas teve o maior tempo de treinamento. O instrutor sugere tentar fazer previsões em amostras aleatórias do conjunto de dados de teste usando o modelo de melhor desempenho.
  
  
• 18:45:00 Nesta seção, o instrutor discute como criar uma função chamada "fazer previsões" para avaliar um modelo de aprendizado de máquina treinado. A função leva em um modelo de tipo de tocha e módulo final, alguns dados e um tipo de dispositivo. O objetivo é obter amostras aleatórias do conjunto de dados de teste, fazer previsões sobre elas usando o modelo e visualizar as previsões. A função prepara a amostra descomprimindo-a e passando-a para o dispositivo de destino. Em seguida, ele faz um avanço no modelo para obter os logits brutos e aplica a função de ativação softmax para obter a probabilidade de previsão. Por fim, as probabilidades de previsão são transformadas em rótulos de previsão e a lista de probabilidades de previsão relacionadas a amostras específicas é empilhada para transformar a lista em um tensor. A seção termina com uma demonstração da função em ação usando amostras de teste.
  
  
• 18:50:00 Nesta seção, o instrutor explica como amostrar dados de teste aleatoriamente e criar rótulos de teste para avaliar as previsões do modelo. Os dados de teste ainda não foram convertidos em um carregador de dados e o código amostra nove amostras de dados de teste aleatórios. O instrutor enfatiza a importância de fazer previsões em amostras de dados de teste aleatórios mesmo depois de treinar o modelo para entender o desempenho do modelo. O instrutor também discute como converter probabilidades de previsão em rótulos de previsão usando argmax para obter o índice do valor mais alto nas probabilidades.
  
  
• 18:55:00 Nesta seção, o instrutor escreve o código para plotar as previsões e imagens para amostras aleatórias. O código cria uma figura Matplotlib com três linhas e três colunas e enumera cada amostra nas amostras de teste. Para cada amostra, uma subtrama é criada e a imagem alvo é plotada. O rótulo de previsão e o rótulo de verdade também são encontrados e convertidos em formato de texto usando nomes de classe e classes pred e índices de rótulos de teste. Por fim, um título é criado para o gráfico e a cor do texto do título é alterada para verde se o rótulo de previsão for igual ao rótulo de verdade e para vermelho se não forem iguais.

Parte 20

• 19:00:00 Nesta seção, o apresentador discute a importância de visualizar as previsões do modelo de aprendizado de máquina e mostra como plotar as previsões de uma rede neural convolucional treinada (CNN) em amostras selecionadas aleatoriamente de um conjunto de dados de teste. O apresentador demonstra como plotar imagens com seus rótulos previstos e verdadeiros e alterar a cor do texto do título dependendo se a previsão está correta ou não. Ao analisar as previsões, o apresentador mostra as possíveis confusões entre as classes de rótulos e sugere que a visualização das previsões pode fornecer insights para melhorar os rótulos ou o próprio modelo. O apresentador então apresenta o conceito de matriz de confusão como outra forma de avaliar o desempenho do modelo comparando os rótulos previstos e verdadeiros de um grande conjunto de amostras de teste.
  
  
• 19:05:00 Nesta seção, o instrutor discute como avaliar um modelo de classificação multiclasse usando a matriz de confusão no PyTorch. A matriz de confusão é uma representação visual que mostra o desempenho do modelo em diferentes classes. O instrutor explica como usar métricas de tocha para métricas de avaliação e mostra como acessar as métricas de avaliação da matriz de confusão. Além disso, ML extend é usado para plotar a matriz de confusão. É importante ressaltar que o instrutor explica que o Google Colab não possui a versão exigida do ML extend, sendo necessária a versão 0.19.0 para garantir a instalação adequada do pacote. Por fim, o vídeo mostra como fazer previsões no conjunto de dados de teste e como definir o modelo no modo de avaliação com o modo de inferência da tocha como gerenciador de contexto.
  
  
• 19:10:00 Nesta seção, o instrutor demonstra como iterar por meio do carregador de dados de teste para fazer previsões usando o PyTorch. As previsões são anexadas a uma lista e depois concatenadas em um tensor usando o arch.cat. O tensor resultante tem uma previsão por amostra de teste. O instrutor também instala métricas de tocha e mostra como usar um loop try and accept para importá-lo. Por fim, a versão necessária do ML extend é verificada usando uma instrução assert para uso na função de matriz de confusão de plotagem.
  
  
• 19:15:00 Nesta seção, o instrutor explica como instalar e atualizar pacotes no Google Colab usando o exemplo de instalação de métricas de tocha e atualização de extensão de ML para a versão 0.19.0 ou superior. O instrutor percorre o código e explica como verificar se a instalação correu bem e o que fazer se houver algum erro durante o processo, incluindo como reiniciar o tempo de execução, se necessário. Após a conclusão da instalação, o instrutor explica como criar uma matriz de confusão com as previsões feitas em todo o conjunto de dados de teste no vídeo anterior.
  
  
• 19:20:00 Nesta seção, o instrutor explica como criar e plotar uma matriz de confusão para avaliar o desempenho de um modelo de aprendizado profundo. Primeiro, a classe da matriz de confusão das métricas da tocha e a função da matriz de confusão do gráfico da extensão ML são importadas. Em seguida, uma instância de matriz de confusão é configurada passando o número de classes como o comprimento da lista de nomes de classes. O tensor da matriz de confusão é criado passando previsões e alvos no conjunto de dados de teste. Por fim, a matriz de confusão é plotada usando a função de matriz de confusão de plotagem, passando o tensor da matriz de confusão e a lista de nomes de classe, criando uma diagonal visualmente agradável mostrando as previsões corretas e áreas potenciais onde o modelo está cometendo erros.
  
  
• 19:25:00 Nesta seção, o instrutor explica a importância de usar uma matriz de confusão para avaliar visualmente as previsões de um modelo de classificação, especialmente quando os erros cometidos pelo modelo são significativos, como confundir duas classes de dados de aparência semelhante, como camisas e casacos. O uso de uma matriz de confusão é uma maneira poderosa de avaliar o desempenho de um modelo e pode ajudar a identificar quaisquer problemas com os rótulos existentes. Ele também fala sobre a importância de salvar e carregar um modelo treinado, principalmente quando o desempenho do modelo é satisfatório. Ao salvar o modelo em um arquivo, ele pode ser usado em outro lugar ou recarregado para garantir que foi salvo corretamente. O instrutor descreve como criar um caminho de diretório de modelo e um caminho de salvamento de modelo e, em seguida, mostra como salvar o ditado de estado do modelo usando o método arch.save.
  
  
• 19:30:00 Nesta seção, o instrutor demonstra como salvar e carregar um modelo PyTorch. O dicionário de estados é salvo, o que representa todos os parâmetros aprendidos do modelo depois de treinado. Para carregar o modelo salvo, uma nova instância é criada com os mesmos parâmetros da original. É importante configurar o modelo carregado com os mesmos parâmetros do original para evitar um erro de incompatibilidade de forma. O modelo carregado é então avaliado para garantir que produza resultados semelhantes aos do modelo original. O instrutor enfatiza a importância de avaliar um modelo após salvá-lo e carregá-lo para garantir que ele foi salvo corretamente.
  
  
• 19:35:00 Nesta seção, vemos que o modelo carregado produz os mesmos resultados que o modelo treinado anteriormente antes de ser salvo e podemos usar o arch.is_close para verificar programaticamente se os resultados do modelo estão próximos uns dos outros. O nível de tolerância absoluta pode ser ajustado para garantir que os resultados sejam semelhantes o suficiente e, se houver discrepâncias, é recomendável verificar se o modelo está salvando corretamente e se as sementes aleatórias estão configuradas. O fluxo de trabalho para um problema de visão computacional também é discutido, desde o uso de materiais de referência e bibliotecas como o archvision até a avaliação do modelo e a experimentação de modelos de rede neural não linear e convolucional para encontrar o melhor.
  
  
• 19:40:00 Nesta seção de "PyTorch for Deep Learning & Machine Learning", o instrutor incentiva os espectadores a praticar o que aprenderam até agora acessando o site de aprendizado pytorch.io e concluindo os exercícios fornecidos. Os exercícios focam na prática do código e dos conceitos abordados nas seções anteriores, e também há um currículo extra disponível para quem deseja se aprofundar na visão computacional. Além disso, a seção aborda o tópico de conjuntos de dados personalizados do pytorch e oferece recursos para obter ajuda, se necessário, como a documentação do pytorch e estouro de pilha.
  
  
• 19:45:00 Nesta seção do curso PyTorch, é discutido como trabalhar com conjuntos de dados personalizados, bem como as diferentes bibliotecas de domínio, como visão da tocha, texto da tocha, áudio da tocha e gravação da tocha. As bibliotecas de domínio contêm funções de carregamento de dados para diferentes fontes de dados e vêm com conjuntos de dados integrados, como conjuntos de dados de visão de tocha para conjuntos de dados de visão pré-construídos, como Fashion MNIST, e personalizados. Cada biblioteca de domínio também possui um módulo 'conjuntos de dados' que ajuda os usuários a trabalhar com diferentes conjuntos de dados em diferentes domínios e, dependendo do domínio em que você está trabalhando, como visão, texto, áudio, recomendação, é recomendável consultar sua biblioteca personalizada em PyTorch.
  
  
• 19:50:00 Nesta seção, o instrutor discute como carregar conjuntos de dados personalizados no PyTorch para uso na construção de um modelo de visão computacional. O modelo que eles vão construir chama-se food vision mini, que vai classificar imagens de pizza, sushi e bife. O instrutor cobre várias etapas envolvidas no treinamento de um modelo, como escolher uma função de perda e um otimizador, criar um loop de treinamento e avaliar o modelo. Eles também explicam como transformar dados para uso com um modelo e comparar modelos com e sem aumento de dados. Por fim, eles mostram como fazer previsões sobre dados personalizados e fornecem um recurso para acessar o notebook de vídeo no repositório de aprendizagem profunda PyTorch.
  
  
• 19:55:00 Nesta seção, o instrutor discute o processo de colocar seus próprios dados no PyTorch por meio de conjuntos de dados personalizados. Eles enfatizam a importância do uso de bibliotecas de domínio para funções de carregamento de dados e funções de carregamento de dados personalizáveis e fornecem exemplos dessas bibliotecas para várias categorias, como visão, texto, áudio e recomendação. O instrutor também demonstra como importar as bibliotecas necessárias e configurar o código agnóstico do dispositivo para as práticas recomendadas com o PyTorch. Eles mostram como verificar se há dispositivos CUDA disponíveis e como alterar o tipo de tempo de execução para usar GPUs para um processamento mais rápido. Finalmente, o instrutor sugere obter dados para trabalhar no próximo vídeo.

Parte 21

• 20:00:00 Nesta seção do curso, o instrutor apresenta o conjunto de dados Food 101, que inclui 101 categorias diferentes de alimentos com 101.000 imagens. No entanto, para praticar o uso do PyTorch, o instrutor criou um subconjunto menor desse conjunto de dados que inclui três categorias de alimentos e apenas 10% das imagens. Esse conjunto de dados menor tem 750 imagens de treinamento, 250 imagens de teste e cerca de 75 imagens de treinamento e 25 imagens de teste por classe. Ao começar com esse conjunto de dados menor, o objetivo é acelerar a experimentação e reduzir o tempo necessário para treinar modelos. O instrutor fornece um bloco de anotações sobre como criar esse conjunto de dados personalizado e incentiva os alunos a começar pequeno e atualizar conforme necessário.
  
  
• 20:05:00 Nesta seção, o instrutor explica o processo de download e preparação de um conjunto de dados de imagem para o PyTorch. O conjunto de dados inclui imagens de pizza, bife e sushi, que são armazenados em uma pasta chamada data. O instrutor usa a biblioteca de solicitações do Python para baixar os dados e, em seguida, descompacta-os na pasta de dados. O objetivo desta seção é demonstrar como carregar dados de imagem no PyTorch, que podem ser aplicados a qualquer projeto semelhante. O instrutor enfatiza a importância de ter um diretório separado para os dados, que podem estar localizados em um computador local ou na nuvem.
  
  
• 20:10:00 Nesta seção, o instrutor mostra como usar a biblioteca Python, zipfile, para extrair dados de um arquivo zip. Eles usam o exemplo de extração de um arquivo zip contendo imagens de pizza, bife e sushi para um problema de visão computacional de aprendizado de máquina. O instrutor demonstra como extrair o conteúdo do arquivo zip para um caminho de arquivo específico usando o método zipfile.extractall(). Eles também abordam um erro no código resultante da cópia do endereço de link errado do GitHub, enfatizando a importância de garantir que o link correto seja usado para baixar conjuntos de dados. No geral, o processo mostrado pode ser usado para baixar e extrair qualquer conjunto de dados personalizado para uso no PyTorch. O próximo vídeo explorará mais os dados.
  
  
• 20:15:00 Nesta seção, o instrutor discute a importância de se tornar um com os dados por meio da preparação e exploração de dados. Ele compartilha uma citação inventada da função de perda de Abraham, enfatizando a necessidade de gastar muito tempo preparando o conjunto de dados. O instrutor percorre cada diretório dos dados de amostra baixados, que estão em um formato de classificação de imagem padrão. Ele usa a função dot walk do SO para gerar uma árvore de diretórios para cada diretório, exibindo informações sobre os diretórios e imagens presentes em cada um. Por fim, o instrutor configura as partes de treinamento e teste e demonstra a configuração de classificação de imagem padrão para elas.
  
  
• 20:20:00 Nesta seção, o instrutor explica a estrutura de dados de classificação de imagem padrão em que uma pasta de conjunto de dados geral contém pastas de treinamento e teste com subdiretórios com nomes de classe que contêm as respectivas imagens. O instrutor observa que existem formas padronizadas de armazenar tipos específicos de dados como referência para formatos de dados. Para preparar dados de imagem para uso com PyTorch, o código é escrito para converter os dados em tensores. O instrutor destaca o formato de dados necessário para classificar imagens de cães e gatos, onde os diretórios de imagens de treinamento e teste contêm as respectivas pastas de classe. O instrutor também menciona planos para visualizar uma imagem e codificar para fazer isso que envolve obter todos os caminhos de imagem, escolher um caminho de imagem aleatório, obter o nome da classe de imagem usando o módulo Pathlib.
  
  
• 20:25:00 Nesta seção, o instrutor explica como abrir e manipular imagens usando a biblioteca de imagens Python chamada Pillow. Primeiro, eles geram uma lista de todos os caminhos de imagem dentro de uma pasta específica e usam a biblioteca aleatória do Python para selecionar aleatoriamente uma imagem dessa lista. Eles então abrem e exibem a imagem enquanto também extraem metadados sobre ela. Além disso, o instrutor fornece uma visão geral dos recursos da biblioteca Torch Vision, incluindo métodos para carregar e processar imagens.
  
  
• 20:30:00 Nesta seção, o instrutor demonstra como trabalhar com imagens usando a biblioteca PIL e como abrir e analisar metadados de imagens. A classe da imagem é o nome do diretório onde os dados da imagem são armazenados e os metadados são obtidos usando a função Imprimir. O instrutor então mostra algumas imagens aleatórias de alimentos do conjunto de dados, incluindo pizza, sushi e bife, e explica a importância de visualizar imagens aleatoriamente para se familiarizar com o conjunto de dados. O instrutor oferece um pequeno desafio para os visualizadores, que é visualizar uma imagem usando o Matplotlib para a próxima seção.
  
  
• 20:35:00 Nesta seção, o instrutor mostra como plotar imagens e dados com matplotlib e transformar imagens em arrays usando o método NumPy NP. A importância de entender a forma dos dados é enfatizada para evitar problemas de incompatibilidade de forma. O formato padrão para a biblioteca de pílulas e matplotlib é o último formato dos canais de cores, mas o padrão do PyTorch é o primeiro formato dos canais de cores. O instrutor também mostra como visualizar diferentes imagens e se familiarizar com os dados, e como transformar os dados convertendo-os em tensores PyTorch para usar com o PyTorch.
  
  
• 20:40:00 Nesta seção, o instrutor discute o processo de transformação de dados de destino em tensores PyTorch e criação de conjuntos de dados e carregadores de dados PyTorch. Usando a documentação do PyTorch, o instrutor mostra como criar conjuntos de dados com o módulo de pasta de imagem e apresenta o parâmetro transform que permite a aplicação de transformações específicas nos dados. O instrutor então demonstra como criar uma transformação para dados de imagem que redimensiona as imagens para 64x64 e as inverte aleatoriamente no plano horizontal para aumentar artificialmente a diversidade do conjunto de dados. Isso é feito usando o método transforms.compose, que usa uma lista de transformações como argumento.
  
  
• 20:45:00 Nesta seção, o instrutor explica como transformar uma imagem em um tensor de tocha usando o módulo transforms no PyTorch. Isso é feito com a função "transforms.ToTensor()", que converte uma imagem PIL ou um array NumPy de altura com canais de cores no intervalo de 0 a 255 para um tensor flutuante de tocha de largura de altura de canais de cores de forma no intervalo de 0 a 1. O instrutor sugere tentar passar dados por esta transformação e mostra como alterar a forma da imagem usando a função "transforms.Resize()". A seção termina com uma discussão sobre as várias transformações disponíveis na biblioteca do archvision, incluindo transformações de aumento de dados e uma prévia do próximo código de visualização para explorar as imagens transformadas.
  
  
• 20:50:00 Nesta seção, o instrutor demonstra como amostrar aleatoriamente imagens de um caminho, carregá-las e transformá-las e, em seguida, comparar as versões originais e transformadas usando o PyTorch. O código usa a função de semente aleatória para definir a semente para a função aleatória e amostras aleatoriamente k imagens da lista de caminhos de imagem. O instrutor então usa a biblioteca matplotlib para criar uma subtrama com uma linha e n colunas para plotar as imagens originais e transformadas lado a lado. A imagem transformada precisa ter sua forma alterada para se ajustar ao formato preferido de canais de cores da biblioteca matplotlib. Por fim, o código define o título das imagens originais e transformadas e define o supertítulo como o nome da classe da imagem.
  
  
• 20:55:00 Nesta seção do vídeo, o instrutor demonstra como usar transformações para manipular dados de imagem para modelos de aprendizado profundo usando PyTorch. O instrutor define a transformação para ser igual à transformação de dados, o que significa que a imagem será redimensionada, invertida horizontalmente aleatoriamente e convertida em um tensor. Eles também mostram como usar a função de permuta para reorganizar a forma dos dados trocando a ordem dos eixos. As imagens são plotadas para mostrar as versões originais e transformadas lado a lado, com as imagens transformadas em formato tensor, ideal para uso com modelos de aprendizado profundo. O instrutor informa que o tamanho da imagem é um hiperparâmetro que pode ser ajustado e incentiva os espectadores a explorar a ampla gama de transformações disponíveis no PyTorch.

Parte 22

• 21:00:00 Nesta seção, o instrutor explica como carregar dados de imagem usando a opção de pasta de imagem. Eles usam o módulo de conjuntos de dados de visão de tocha para mostrar como carregar dados no formato genérico de classificação de imagem. A função de conjuntos de dados pré-construídos, pasta de imagens, é demonstrada e pode ser usada para carregar todas as imagens personalizadas em tensores com a ajuda de transformações. O instrutor então mostra como transformar o conjunto de dados de treinamento e criar um conjunto de dados de teste, que também será transformado da mesma forma que o conjunto de dados de treinamento. Finalmente, eles imprimem os conjuntos de dados criados.
  
  
• 21:05:00 Nesta seção, o instrutor explica como usar a função de pasta de imagens no PyTorch para carregar imagens em tensores e transformá-las usando um pipeline, que pode ser usado com um modelo PyTorch. Eles demonstram como acessar e utilizar vários atributos que acompanham o carregador de dados pré-construído, como obter nomes de classe como uma lista ou dicionário e verificar o comprimento do conjunto de dados. Além disso, eles mostram como visualizar amostras e rótulos do conjunto de dados de treinamento usando a indexação.
  
  
• 21:10:00 Nesta seção do curso, o instrutor demonstra como converter um conjunto de dados de imagem em formato tensor, que é o formato de dados padrão do PyTorch. Eles usam um exemplo de imagem de pizza e mostram como obter seu rótulo associado e convertê-lo em formato numérico. Em seguida, eles imprimem algumas informações importantes sobre os dados do tensor, como seu tipo e forma de dados, que serão úteis para solucionar problemas posteriormente. Por fim, eles plotam a imagem usando matplotlib e definem o título como o nome da classe, que neste caso é pizza. Eles incentivam os alunos a experimentar isso com diferentes imagens e explorar diferentes transformações.
  
  
• 21:15:00 Nesta seção do vídeo, o instrutor discute o processo de conversão de imagens carregadas em carregadores de dados no PyTorch. Um carregador de dados pode ajudar a transformar conjuntos de dados em iteráveis, permitindo que os usuários personalizem o tamanho do lote e visualizem um número específico de imagens por vez. Isso é importante porque se todas as imagens forem carregadas de uma vez, existe o risco de ficar sem memória. Portanto, imagens em lote ajudam a aproveitar toda a memória disponível. O instrutor fornece um guia passo a passo para criar um carregador de dados de trem e também apresenta o conceito de número de parâmetros de trabalho, que decide quantos núcleos de CPU são usados para carregar dados.
  
  
• 21:20:00 Nesta seção, o instrutor discute como criar e personalizar carregadores de dados para treinamento e teste de dados no PyTorch. Ele mostra como inicializar conjuntos de dados e personalizar hiperparâmetros para carregadores de dados, como tamanho do lote e número de funcionários. O instrutor também demonstra como iterar pelos carregadores e obter informações sobre a forma das imagens e rótulos. A seção termina com um resumo do processo de carregamento e uma recomendação para construir uma rede neural convolucional para identificar padrões em tensores de imagem.
  
  
• 21:25:00 Nesta seção, o instrutor discute o processo de criação de uma classe de carregamento de dados personalizada para carregar dados de imagem no formato Tensor. O objetivo é replicar a funcionalidade da pasta de imagens por meio dessa classe personalizada, pois é uma boa prática e pode ser necessária nos casos em que não existe uma função pré-construída. O instrutor lista as etapas necessárias para que a classe personalizada carregue imagens, obtenha nomes de classe como uma lista e obtenha classes como um dicionário do conjunto de dados. Os prós e contras da criação de um conjunto de dados personalizado também são discutidos, incluindo a flexibilidade de criar um conjunto de dados de quase tudo, mas também o potencial de erros e problemas de desempenho. O instrutor então importa os módulos necessários para criar a classe personalizada, incluindo SO e path lib para trabalhar com o sistema de arquivos.
  
  
• 21:30:00 Nesta seção, estamos aprendendo como criar um conjunto de dados personalizado no PyTorch e estamos focados em escrever uma função para obter nomes de classe do diretório de destino. O conjunto de dados personalizado será usado para carregar imagens de um arquivo, obter nomes de classe do conjunto de dados e obter classes como um dicionário do conjunto de dados. A função usará o scanner do SO para percorrer o diretório de destino e obter os nomes das classes e gerará um erro se os nomes das classes não forem encontrados, indicando um problema com a estrutura do diretório. Posteriormente, criaremos uma subclasse do arch.utils.data.Dataset para criar um conjunto de dados personalizado.
  
  
• 21:35:00 Nesta seção do vídeo, o instrutor demonstra como criar uma função chamada "find_classes" que pega um diretório como uma string e retorna uma lista de nomes de classe e um dicionário que mapeia os nomes de classe para números inteiros. A função utiliza o scanner do sistema operacional para verificar o diretório de destino e obter os nomes das classes. O instrutor também demonstra como gerar um erro se os nomes das classes não puderem ser encontrados. A função pode ser usada para qualquer diretório específico e replica a funcionalidade feita anteriormente para o diretório de treinamento.
  
  
• 21:40:00 Nesta seção do vídeo, o instrutor explica como criar um conjunto de dados personalizado subclassificando arch.utils.data.dataset. O conjunto de dados deve representar um mapa de chaves para amostras de dados, onde as chaves se referem a alvos ou rótulos e as amostras de dados, neste caso, são imagens de alimentos. A subclasse deve substituir o método get item, que busca uma amostra de dados para uma determinada chave e, opcionalmente, sobrescreve o método len para retornar o tamanho do conjunto de dados. O instrutor percorre as etapas para criar o conjunto de dados personalizado e explica como usar a função auxiliar que criamos na seção anterior para mapear nomes de classe para números inteiros.
  
  
• 21:45:00 Nesta seção, o instrutor explica como criar um conjunto de dados personalizado no PyTorch. Para fazer isso, precisamos criar uma subclasse da classe arch.utils.data.Dataset e inicializar nosso conjunto de dados personalizado passando o diretório de destino (onde os dados residem) e transform (para executar quaisquer transformações de dados). Além disso, precisamos criar vários atributos, como paths, transform, classes e class para ID X. Além disso, precisamos criar uma função para carregar imagens, substituir o método LAN para retornar o tamanho do nosso conjunto de dados e obter item método para retornar uma determinada amostra quando passado um índice. Por fim, escrevemos um conjunto de dados personalizado implementando pathlib e passando diretórios de destino como os diretórios test ou train.
  
  
• 21:50:00 Nesta seção, o instrutor explica as diferentes etapas envolvidas na criação de uma classe de conjunto de dados PyTorch personalizada. A primeira etapa envolve a obtenção de todos os caminhos de imagem que seguem a convenção de nome de arquivo correta. A próxima etapa é criar um conjunto de transformações de imagem, que podem ser opcionais. Também é criada uma função para carregar imagens, que recebe um índice e retorna uma imagem. O instrutor então mostra como substituir o método "len" para retornar o número total de amostras no conjunto de dados, que é opcional. Por fim, o método "obter item" é substituído para que retorne uma amostra específica se for passado um índice.
  
  
• 21:55:00 Nesta seção, aprenderemos sobre a subclassificação de arch.utils.data.Dataset para personalizar a maneira como os dados são carregados no PyTorch. A classe é inicializada com um diretório raiz e um dicionário que mapeia os nomes das classes para os índices. O método __len__ retorna o comprimento do conjunto de dados, enquanto o __getitem__ permite a indexação no conjunto de dados para retornar uma tupla de uma imagem do tensor da tocha e o rótulo inteiro correspondente. A classe também possui um parâmetro transform opcional para aplicar transformações na imagem antes de retornar a tupla. As vantagens de subclassificar arch.utils.data.Dataset são os recursos de customização que ele oferece, mas requer escrever quantidades significativas de código que podem estar sujeitas a erros.

[MetaQuotes]

PyTorch para Deep Learning e Machine Learning - Curso Completo (descrição das partes 23-26)

PyTorch para Deep Learning e Machine Learning - Curso Completo

Parte 23

• 22:00:00 Nesta seção, o instrutor mostra como criar um conjunto de dados personalizado no PyTorch usando o módulo Torchvision. Eles criam uma transformação para converter imagens JPEG brutas em tensores e configuram a composição de transformações de treinamento e teste. Em seguida, eles testam a classe de pasta de imagem personalizada e verificam se ela funciona em seu próprio conjunto de dados personalizado. Eles verificam o comprimento e os atributos de classe para garantir que está funcionando corretamente. Por fim, eles inspecionam o custom de dados de trem e o custom de dados de teste para verificar se tudo está funcionando conforme o esperado.
  
  
• 22:05:00 Nesta seção do curso completo PyTorch para Deep Learning e Machine Learning, o instrutor demonstra como verificar a igualdade entre o conjunto de dados da pasta de imagem original e o conjunto de dados personalizado que ele criou na seção anterior, comparando a classe ao ID X de ambos os conjuntos de dados. Ele afirma que podemos replicar a funcionalidade principal da classe de conjunto de dados da pasta de imagem criando nossa própria função de carregamento de conjunto de dados personalizado, e as conclusões disso são que o PyTorch fornece uma classe de conjunto de dados base para herdar e, desde que substituamos a terra e obter métodos de item e retornar algum tipo de valor, podemos criar nossa própria função de carregamento de conjunto de dados. O instrutor passa a explicar como criar uma função para exibir imagens aleatórias da classe personalizada de dados treinados para visualizar nossos dados.
  
  
• 22:10:00 Nesta seção, o instrutor percorre as etapas para criar uma função chamada "exibir imagens aleatórias" que recebe um "conjunto de dados", "classes" e "n" como parâmetros. A função exibe um número n de imagens selecionadas aleatoriamente do conjunto de dados e imprime sua forma se "display shape" for definido como verdadeiro. O instrutor também analisa os detalhes da implementação, como ajustar a exibição se n for maior que 10 e definir a semente aleatória para reprodutibilidade. Além disso, a função percorre as imagens ou índices de amostra aleatória e os plota com o Matplotlib.
  
  
• 22:15:00 Nesta seção, o instrutor continua a construir seu modelo de aprendizado profundo no PyTorch configurando o gráfico e certificando-se de que as dimensões de suas imagens estejam alinhadas com matplotlib. Eles ajustam suas dimensões de tensor para plotagem, adicionam uma subtrama ao gráfico matplotlib e ajustam o título da plotagem com base na variável classes, uma lista de classes. Em seguida, eles criam uma função para exibir imagens aleatórias da pasta de imagens, tanto para a pasta de imagens pytorch incorporada quanto para o conjunto de dados personalizado criado pelo instrutor. Finalmente, eles ajustam a semente e traçam as imagens para ver como seu código para ajustar o gráfico faz sentido.
  
  
• 22:20:00 Nesta seção da transcrição, o instrutor demonstra como transformar um conjunto de dados de imagem carregada personalizada em carregadores de dados, que é uma etapa necessária para agrupar as imagens e usá-las com um modelo. Usando o archvision.datasets.ImageFolder e o archvision.transforms, o conjunto de dados personalizado é transformado em um formato de tensor. A próxima etapa é transformar o conjunto de dados em um carregador de dados usando o arch.utils.data.DataLoader. O instrutor define o tamanho do lote como 32 e o número de funcionários como 0 para o carregador de dados de treinamento personalizado e o carregador de dados de teste personalizado. A diferença entre eles é que os dados do trem serão embaralhados enquanto os dados de teste não serão embaralhados.
  
  
• 22:25:00 Nesta seção, o vídeo aborda carregadores de dados personalizados e transformação de dados no PyTorch. O instrutor primeiro redefine a contagem de CPU OOS e define os trabalhadores dormentes como zero para garantir que o treinamento seja executado sem problemas. Depois de configurar o carregador de dados personalizado, ele usa a função de impressão para verificar o formato da imagem e o tamanho do lote, que foram definidos como 32 pela transformação configurada anteriormente. O instrutor também explica como o aumento de dados pode aumentar artificialmente a diversidade do conjunto de dados de treinamento e demonstra as várias maneiras pelas quais os dados podem ser transformados usando o módulo de transformações de visão da tocha, incluindo redimensionamento, corte central, escala de cinza, transformações aleatórias e aumento aleatório .
  
  
• 22:30:00 aprendi sobre aumento de dados, que é o processo de adicionar diversidade artificialmente aos seus dados de treinamento aplicando várias transformações de imagem. Isso ajuda a tornar o modelo mais generalizável para dados não vistos. Existem muitos tipos diferentes de aumento de dados, como corte, substituição, corte e muito mais. O PyTorch tem um pacote de visão de tocha que inclui primitivas ou funções que podem ajudar a treinar modelos para um bom desempenho. Usando o aumento de dados e outras melhorias, o PyTorch conseguiu treinar modelos de última geração com alta precisão, como o modelo ResNet 50.
  
  
• 22:35:00 Nesta seção, o instrutor discute maneiras de melhorar a precisão do modelo, como otimização da taxa de aprendizado, treinamento por mais tempo e uso de diferentes técnicas de aumento. O instrutor se concentra na técnica de aumento trivial, que aproveita o poder da aleatoriedade para alterar as imagens de várias maneiras usando vários compartimentos de magnitude. O instrutor demonstra como implementar um aumento trivial usando a biblioteca de transformações de visão da tocha PyTorch e fornece um link para o documento para os interessados em ler mais sobre ele. Além disso, o instrutor aconselha experimentar diferentes técnicas e experimentos de aumento para ver o que funciona melhor para problemas individuais. Por fim, o instrutor mostra como testar o pipeline de aumento obtendo todos os caminhos de imagem e agrupando todos os arquivos e pastas que correspondem a um padrão específico.
  
  
• 22:40:00 Nesta seção, o vídeo demonstra o uso de aumento trivial, uma técnica de aumento de dados, na transformação de imagens para adicionar artificialmente diversidade a um conjunto de dados de treinamento. O poder da aleatoriedade é aproveitado selecionando diferentes tipos de aumento e aplicando-os com níveis variados de intensidade. Esta seção mostra como o aumento trivial é aplicado a imagens transformadas aleatoriamente e os resultados são exibidos. O objetivo é permitir que o modelo de aprendizado de máquina aprenda os padrões das imagens manipuladas e seja capaz de identificá-los adequadamente. A próxima seção se concentra na construção do primeiro modelo de visão computacional sem aumento de dados usando a minúscula arquitetura VGG.
  
  
• 22:45:00 Nesta seção, o apresentador passa pelo processo de criação de transformações e carregamento de dados para um modelo PyTorch. O objetivo é carregar imagens da pasta de dados, no caso, pizza, bife e sushi, e transformá-las em tensores. As transformações incluem redimensionar as imagens para 64x64 e convertê-las em tensores para que os valores fiquem entre 0 e 1. O apresentador também explica como criar carregadores de dados e ajustar o tamanho do lote e o número de núcleos da CPU dedicados ao carregamento dos dados. O tamanho do lote usado neste exemplo é 32.
  
  
• 22:50:00 Nesta seção, o instrutor explica como carregar e transformar dados usando o DataLoader do PyTorch. O processo envolve criar uma transformação e, em seguida, carregar e transformar os dados ao mesmo tempo usando a função DataLoader. O instrutor também fornece um código simples para construir a arquitetura Tiny VGG do zero, que inclui a criação do primeiro bloco COM que consiste em camadas como COM, ReLU, MaxPool e ComToD. O modelo é inicializado com a forma de entrada, unidades ocultas e parâmetros de forma de saída. O instrutor incentiva os alunos a experimentar diferentes valores para hiperparâmetros, como tamanho do kernel e passo.
  
  
• 22:55:00 Nesta seção, vemos a criação de uma rede neural convolucional usando PyTorch. Começamos definindo os blocos convolucionais e as camadas de agrupamento máximo para a rede. Em seguida, replicamos o mesmo bloco para criar outro e alteramos a forma de entrada para corresponder à forma de saída. Em seguida, criamos uma camada classificadora para transformar a saída de blocos convolucionais em um vetor de recursos e passamos por uma camada linear para gerar dez classes. Por fim, substituímos o método forward para passar os dados pelos blocos convolucionais e imprimir sua forma a cada etapa. O método forward também pode ser reescrito para incluir a fusão do operador, que acelera a computação da GPU.

Parte 24

• 23:00:00 Nesta seção, o instrutor discute o conceito de fusão de operador, que é a otimização mais importante em compiladores de aprendizado profundo. Eles também criam um modelo usando a minúscula arquitetura VGG para imagens em cores RGB e verificam suas formas de entrada e saída. O instrutor destaca a importância de usar a fusão de operadores para acelerar a computação de grandes redes neurais, evitando o transporte entre a memória e a computação. Eles também sugerem passar dados fictícios pelo modelo para solucionar problemas e garantir que o método de encaminhamento esteja funcionando corretamente. Por fim, uma mensagem de erro é exibida ao tentar passar o lote de imagens para o modelo devido a uma incompatibilidade nos tipos de entrada.
  
  
• 23:05:00 Nesta seção, o instrutor está solucionando um erro de forma para o modelo. Eles explicam que as regras de multiplicação de matrizes precisam ser satisfeitas ao passar tensores por camadas lineares. O instrutor investiga as formas da matriz e determina que 10, que representa o número de unidades ocultas, está causando um problema quando multiplicado por 2560. Eles usam a forma de saída da camada anterior para determinar que 10 deve ser multiplicado por 16x16 para obter 2560. Após a correção Isso e a verificação de que as formas do modelo se alinham com a saída do explicador da CNN, eles passam para a solução de problemas e, finalmente, descobrem que remover o preenchimento das camadas convolucionais alinhará as formas com a saída do explicador da CNN.
  
  
• 23:10:00 Nesta seção, o instrutor apresenta o Torch Info, um pacote que permite aos usuários imprimir um resumo de seus modelos PyTorch. Primeiro, o instrutor comenta as instruções de impressão do método forward e instala o Torch Info no Google CoLab usando o comando pip install. O instrutor então importa o resumo do Torch Info e o usa para passar o modelo e um tamanho de entrada para obter as formas dos dados que fluem pelo modelo. O instrutor mostra como o Torch Info imprime um resumo do modelo, incluindo as camadas e suas formas correspondentes.
  
  
• 23:15:00 Nesta seção, o palestrante discute o pacote de informações da tocha, que é usado para dar uma ideia das formas de entrada e saída de cada camada em um modelo PyTorch. Eles explicam que o pacote também fornece informações sobre o número de parâmetros em cada camada, o que pode ser útil para determinar o tamanho do modelo e as restrições de armazenamento para aplicações futuras. O palestrante observa que, à medida que um modelo fica maior e tem mais camadas, ele terá mais parâmetros, resultando em um tamanho de entrada maior e tamanho total estimado. Na próxima seção, o palestrante avança para o treinamento de um conjunto de dados personalizado e cria duas funções - etapa de treinamento e etapa de teste - que são genéricas e podem ser usadas com praticamente qualquer modelo e carregador de dados. A função de etapa de treinamento inclui um modelo, um carregador de dados, uma função de perda e um otimizador e coloca o modelo no modo de treinamento enquanto configura as métricas de avaliação.
  
  
• 23:20:00 Nesta seção, o palestrante discute a configuração de valores de perda de trem e precisão de trem para uma função de loop de trem no PyTorch. Os dados são repetidos usando o carregador de dados e, para cada lote, o avanço é feito para fazer previsões e calcular a perda. O otimizador é então usado para realizar a retropropagação e dar um passo. Depois que o loop do trem é concluído, a precisão é calculada obtendo a classe prevista e comparando-a com os rótulos corretos. Isso é feito fora do loop do lote, onde a perda de trem e a precisão do trem são ajustadas para obter a média por época em todos os lotes. O orador então desafia os espectadores a escrever uma função de loop de teste.
  
  
• 23:25:00 Nesta seção, o instrutor passa pelo processo de criação de uma etapa de teste para avaliar o desempenho de um modelo de aprendizagem profunda PyTorch em um conjunto de dados. A etapa envolve configurar o modelo no modo de avaliação, percorrer os lotes do conjunto de dados, enviar os dados para o dispositivo de destino, fazer um avanço, calcular a perda e a precisão por lote, acumular a perda e a precisão e ajustar as métricas para obter os valores médios. O instrutor então sugere a criação de uma função train para funcionalizar o processo de treinamento do modelo, que será abordado na próxima seção.
  
  
• 23:30:00 Nesta seção, o instrutor percorre o processo de criação de uma função de trem que combina as funções de etapa de treinamento e etapa de teste. A ideia é criar uma função para chamar essas duas funções para treinar e avaliar um modelo com apenas uma chamada de função. A função train aceita uma variedade de parâmetros do modelo, incluindo otimizador, carregadores de dados, função de perda e outros. O instrutor então cria um dicionário vazio para ajudar a rastrear o desempenho do modelo durante o treinamento, incluindo perda e precisão de treinamento e teste. Eles então percorrem as épocas, chamando TQDM para obter uma barra de progresso enquanto o modelo está treinando. A função train é uma ferramenta útil para não ter que reescrever o código ao treinar mais modelos e alavancar o código existente.
  
  
• 23:35:00 Nesta seção, o instrutor explica a função de treinamento que acompanha o treinamento e o teste usando as funções de etapa de treinamento e teste, respectivamente. A função será executada por um número especificado de épocas e, para cada época, imprimirá o trem e testará a perda e a precisão usando uma instrução de impressão sofisticada. Os resultados serão armazenados no dicionário de resultados para posterior análise. A função de trem aproveitará a função de etapa de trem e a função de etapa de teste para atualizar o modelo e testá-lo, respectivamente. A função retornará os resultados da época.
  
  
• 23:40:00 Nesta seção, o instrutor analisa o progresso feito no fluxo de trabalho do PyTorch, que inclui preparação de dados, construção e seleção de um modelo, construção de um loop de treinamento e agora o desafio de criar uma função de perda e um otimizador. Passando para a seção 7.7, o instrutor descreve como treinar e avaliar o modelo zero, o modelo de linha de base, em seu conjunto de dados personalizado. Eles definem as sementes aleatórias para reprodutibilidade, instanciam o minúsculo modelo VGG com uma forma de entrada de três para imagens coloridas, definem o número de unidades ocultas e a forma de saída para corresponder ao número de classes em seu conjunto de dados de treinamento. Eles também selecionam a função de perda de entropia cruzada para classificação multiclasse e experimentam o otimizador Adam com uma taxa de aprendizado de 0,001.
  
  
• 23:45:00 Nesta seção, o instrutor mostra como cronometrar o processo de treinamento de um modelo de aprendizado profundo. Eles primeiro importam a classe de timer padrão de time e, em seguida, iniciam o timer antes de treinar o modelo zero usando a função train de um vídeo anterior. Em seguida, eles definem os dados de treinamento para o carregador de dados de treinamento simples e os dados de teste para o carregador de dados de teste simples, bem como o otimizador para o FriendlyAtomOptimizer e a função de perda para a n perda de entropia cruzada. O modelo é treinado por cinco épocas e o cronômetro é encerrado para exibir o tempo total de treinamento. O instrutor então mostra os resultados de precisão do modelo nos conjuntos de treinamento e teste, que estão em torno de 40% e 50%, respectivamente. Eles sugerem tentar diferentes métodos para melhorar o modelo, como adicionar mais camadas ou unidades ocultas, ajustar por mais tempo, alterar as funções de ativação e ajustar a taxa de aprendizado.
  
  
• 23:50:00 Nesta seção, o instrutor explica como traçar curvas de perda para acompanhar o progresso do modelo ao longo do tempo. Uma curva de perda é uma forma de rastrear o progresso de um modelo ao longo do tempo, visualizando o valor da perda à esquerda e as etapas no eixo inferior. Ao plotar os valores de precisão e perda de treinamento e teste de nosso dicionário de resultados usando matplotlib, podemos ver como nosso modelo está funcionando e avaliá-lo. O instrutor escreve uma função chamada "def plot loss curves" que usa um dicionário de resultados contendo os valores de perda e precisão como uma string e uma lista de flutuações.
  
  
• 23:55:00 Nesta seção, o instrutor mostra como criar curvas de perda para dados de treinamento e teste usando épocas como métrica de tempo. A trama consiste em duas subtramas, uma para perda e outra para precisão, com rótulos e títulos para cada uma delas. A tendência ideal para uma curva de perda é que a perda diminua com o tempo e a precisão aumente. O instrutor encoraja o espectador a experimentar épocas adicionais para ver se a perda atinge o valor ideal. O próximo vídeo abordará diferentes formas de curvas de perda, e o instrutor recomenda um guia para interpretar as curvas de perda.

Parte 25

• 24:00:00 Nesta seção do curso PyTorch para Deep Learning e Machine Learning, o instrutor discute as curvas de perda e sua importância na avaliação do desempenho de um modelo ao longo do tempo. Uma curva de perda deve mostrar uma tendência de perda decrescente ao longo do tempo e precisão crescente. Existem diferentes formas de curvas de perda, e uma curva de perda ideal mostra que as perdas de treinamento e teste diminuem a uma taxa semelhante. O underfitting ocorre quando a perda do modelo pode ser menor, enquanto o overfitting ocorre quando o modelo aprende muito bem os dados de treinamento, levando a uma perda de treinamento menor do que a perda de teste. O instrutor fornece um currículo extra do guia de curva de perda do Google e discute métodos para lidar com o overfitting, como técnicas de regularização e redução da complexidade do modelo.
  
  
• 24:05:00 algumas maneiras de reduzir o overfitting em seu modelo de aprendizagem profunda que foram discutidas nesta seção. Obter mais dados por meio de aumento de dados ou melhor qualidade de dados pode ajudar seu modelo a aprender padrões mais generalizáveis. Usar o aprendizado de transferência, tomando padrões aprendidos de modelos pré-treinados e aplicando-os ao seu próprio conjunto de dados, também pode ser eficaz. Simplificar seu modelo reduzindo o número de camadas ou unidades ocultas também pode ajudar. O declínio da taxa de aprendizado pode ajudar diminuindo a taxa de aprendizado ao longo do tempo, e a parada antecipada pode interromper o processo de treinamento antes que ocorra o overfitting.
  
  
• 24:10:00 Nesta seção, o conceito de parada antecipada é discutido como um método para lidar com o overfitting no aprendizado de máquina. Antes que o erro de teste comece a aumentar, o erro de teste do modelo é rastreado e o treinamento é interrompido ou os pesos/padrões são salvos onde a perda do modelo foi a menor. Diferentes métodos para lidar com o underfitting também são explorados, como adicionar mais camadas/unidades ao modelo, ajustar a taxa de aprendizado, treinar por mais tempo e usar o aprendizado de transferência. O equilíbrio entre overfitting e underfitting é enfatizado, e destaca-se a importância de avaliar o desempenho de um modelo ao longo do tempo usando curvas de perda. Por fim, são discutidas maneiras de evitar a regularização excessiva do modelo e acabar com o underfitting, e o objetivo de alcançar um equilíbrio perfeito entre o underfitting e o overfitting é enfatizado.
  
  
• 24:15:00 Nesta seção do vídeo sobre PyTorch para aprendizado profundo e aprendizado de máquina, o instrutor discute o conceito de overfitting e underfitting em modelos, juntamente com as formas de lidar com eles. O aumento de dados é um dos métodos introduzidos para lidar com o overfitting, onde as imagens são manipuladas para aumentar a diversidade do conjunto de dados de treinamento. Em seguida, o instrutor demonstra como criar uma transformação com aumento de dados e carregar dados usando essas transformações para criar conjuntos de dados de treinamento e teste e carregadores de dados. O vídeo enfatiza a importância de experimentar diferentes modelos com vários ajustes e transformações para encontrar o melhor ajuste para um determinado problema.
  
  
• 24:20:00 Nesta seção do vídeo, o instrutor percorre o processo de criação de um conjunto de dados e um carregador de dados usando as transformações PyTorch e a classe ImageFolder. Eles fornecem exemplos de código e incentivam os espectadores a testá-lo por conta própria, se desejarem. O conjunto de dados é criado a partir de imagens de pizza, bife e sushi para as pastas de treinamento e teste. O instrutor também discute a importância de ser claro com nomes de variáveis ao trabalhar com nomes semelhantes em todo o notebook. Eles configuram os carregadores de dados para os conjuntos de dados de treinamento e teste, com o conjunto de dados de treinamento sendo aumentado com a função trivial de aumento amplo. O instrutor então sugere que os espectadores construam e treinem o modelo um usando a pequena classe VGG e a função train.
  
  
• 24:25:00 Nesta seção do curso completo PyTorch, o instrutor orienta o visualizador através do processo de criação e treinamento de um novo modelo usando a mesma arquitetura de antes, mas com dados de treinamento aumentados. O objetivo é comparar o desempenho desse modelo com o modelo de linha de base sem aumento de dados. O instrutor usa a classe criada anteriormente para o minúsculo modelo VGG e define uma semente manual para reprodutibilidade. Eles então definem a função de perda e o otimizador, definem os hiperparâmetros e iniciam o cronômetro. Por fim, o instrutor treina o modelo chamando a função train criada anteriormente, passando o modelo e os carregadores de dados e avaliando os resultados.
  
  
• 24:30:00 Nesta seção, o instrutor continua o treinamento do segundo modelo com aumento de dados e mostra que não funcionou tão bem quanto o primeiro modelo sem aumento de dados devido ao fato de que a perda já estava diminuindo e havia não era muito overfitting. O instrutor então apresenta uma função para traçar curvas de perda e a utiliza para avaliar o desempenho do segundo modelo. A curva de perda mostra que o modelo está subajustado e possivelmente superajustado, indicado pela maior perda de teste em comparação com a perda de treinamento. O instrutor então questiona o que pode ser feito para lidar com o underfitting e o overfitting no modelo, sugerindo opções como obter mais dados, simplificar o modelo, usar o aprendizado por transferência ou adicionar mais camadas.
  
  
• 24:35:00 Nesta seção, o instrutor discute a importância de comparar os resultados do modelo e fornece algumas ferramentas, como PyTorch mais TensorBoard e pesos e vieses, para rastrear diferentes experimentos. No entanto, ele enfatiza que este curso se concentrará apenas no PyTorch puro por enquanto. O instrutor então configura um gráfico para comparar os resultados do modelo lado a lado, usando quadros de dados para cada um dos resultados do modelo. Ele também sugere tentar um experimento para treinar o modelo zero por um período mais longo para ver se ele melhora. Por fim, comparar visualmente diferentes experimentos e suas métricas é crucial para melhorar os modelos.
  
  
• 24:40:00 Nesta seção, o instrutor usa subtramas para comparar diferentes métricas em dois modelos que experimentou. Eles começam criando um intervalo para o número de épocas e, em seguida, criam um gráfico para perda de trem usando PLT.subplot() e PLT.plot(). Eles fazem o mesmo para perda de teste e precisão para dados de treinamento e teste. O instrutor aponta que o modelo um, que implementou o aumento de dados, parece estar superajustado neste estágio, enquanto o modelo zero está tendo um desempenho melhor em termos de perda. O instrutor sugere que, se eles tivessem mais modelos para comparar, poderiam transformar isso em uma função, mas também observa que ferramentas como TensorBoard, pesos e vieses e MLflow podem ajudar a entender esses gráficos quando vários experimentos são conduzidos.
  
  
• 24:45:00 Nesta seção, o palestrante discute a importância de avaliar modelos com base em seu desempenho no conjunto de dados de teste, em vez de apenas no conjunto de dados de treinamento. Eles sugerem que, embora as métricas no conjunto de dados de treinamento sejam boas, o objetivo final é fazer com que o modelo tenha um bom desempenho em dados não vistos. O palestrante recomenda treinar os modelos por mais tempo e possivelmente adicionar mais unidades ocultas a cada camada para obter melhores resultados. Em seguida, eles demonstram como fazer previsões em imagens personalizadas que não estão no conjunto de dados de treinamento ou teste, usando um aplicativo de reconhecimento de alimentos como exemplo. Eles explicam o fluxo de trabalho para baixar uma imagem personalizada e fazer uma previsão usando um modelo PyTorch treinado, mas alertam que o modelo atual pode não ter um ótimo desempenho.
  
  
• 24:50:00 Nesta seção, o instrutor mostra como baixar uma imagem personalizada de uma pizza e prepará-la para previsão usando o modelo que treinou. A imagem é baixada usando um URL bruto do GitHub e salva na pasta de dados. O instrutor observa que a imagem personalizada deve estar no mesmo formato que os dados que foram usados para treinar o modelo, especificamente a forma do Tensor com tipo de dados Torch float 32 e uma forma de 64 por 64 por três. Eles demonstram como carregar a imagem no PyTorch usando o pacote de visão da tocha e a função read_image, que lê um JPEG ou PNG em um RGB tridimensional ou tensor em tons de cinza.
  
  
• 24:55:00 Nesta seção, o instrutor demonstra como ler uma imagem personalizada no PyTorch usando o maçarico vision.io e convertê-la em um tensor. Ele também mostra como obter metadados sobre a imagem, como sua forma e tipo de dados. O instrutor observa que, antes de passar a imagem por um modelo, pode ser necessário redimensioná-la, convertê-la em float32 e colocá-la no dispositivo correto. Na próxima seção, ele planeja demonstrar como fazer uma previsão na imagem personalizada usando um modelo PyTorch.

Parte 26

• 25:00:00 Nesta seção, o instrutor discute a importância dos tipos e formas de dados no aprendizado profundo e como corrigir erros relacionados a eles. O instrutor tenta fazer uma previsão em uma imagem, mas se depara com erros porque os dados personalizados não são do mesmo tipo de dados com os quais o modelo foi originalmente treinado. Eles mostram como corrigir o erro recriando o tensor de imagem personalizado e convertendo-o em flutuador de tocha 32. O instrutor então enfrenta outro problema com a forma da imagem personalizada e mostra como corrigi-lo criando um pipeline de transformação para redimensionar a imagem para o mesmo tamanho em que o modelo foi treinado.
  
  
• 25:05:00 Nesta seção, o instrutor mostra como usar o pacote de transformações do PyTorch para transformar uma imagem de entrada e prepará-la para uso por um modelo de aprendizado profundo. Eles demonstram como aplicar um pipeline de transformação a uma imagem personalizada, o que resulta na compactação e pixelização da imagem. O instrutor observa que isso pode afetar a precisão do modelo e recomenda experimentar tamanhos de imagem maiores para melhorar o desempenho. Eles também discutem a importância de garantir que as dimensões do tensor se alinhem com os requisitos do modelo, incluindo adicionar uma dimensão de lote a uma imagem personalizada antes de passá-la pelo modelo para inferência.
  
  
• 25:10:00 Nesta seção do vídeo, o apresentador demonstra como fazer previsões em dados de imagem personalizados usando um modelo PyTorch. Eles destacam a importância de formatar os dados corretamente e garantir que eles tenham o mesmo tipo de dados, forma e dispositivo em que o modelo foi treinado para evitar erros. O apresentador também mostra como converter as saídas brutas do modelo, ou logits, em probabilidades de previsão usando a função softmax. Embora o modelo usado no exemplo não tenha um bom desempenho, o processo de previsão de dados personalizados é ilustrado.
  
  
• 25:15:00 Nesta seção do vídeo, o instrutor mostra como funcionar o processo de previsão de imagem personalizada. Essa função usa um modelo PyTorch, um caminho de imagem, uma lista de nomes de classes, uma transformação e um dispositivo como entradas. Ele carrega a imagem usando o TorchVision, formata, obtém os rótulos de previsão e plota a imagem com sua previsão como título. O instrutor desafia os espectadores a tentar construir essa função por conta própria e, em seguida, passa por uma possível implementação no vídeo. A função não está totalmente implementada nesta seção e continuará no próximo vídeo.
  
  
• 25:20:00 Nesta seção, veremos como fazer uma previsão sobre dados personalizados usando o PyTorch. Primeiro, precisamos dimensionar os dados da imagem entre 0 e 1 para que nosso modelo possa processá-los adequadamente. Em seguida, verificamos se alguma transformação é necessária e passamos a imagem por ela, se necessário. Em seguida, garantimos que o modelo esteja no dispositivo correto e o colocamos no modo de inferência. Também adicionamos uma dimensão extra à imagem para refletir o tamanho do lote de 1 que nosso modelo irá prever. Em seguida, fazemos uma previsão, convertemos os logits brutos em probabilidades de previsão usando softmax e os convertemos em rótulos de previsão usando argmax. Por fim, criamos um gráfico da imagem junto com sua previsão e probabilidade de previsão. Se uma lista de nomes de classe for fornecida, a função replicará os nomes de classe para cada previsão no gráfico.
  
  
• 25:25:00 Nesta seção, o instrutor explica como criar uma função que pode capturar imagens e exibir sua classe prevista usando um modelo PyTorch pré-treinado. A função pode obter uma lista de nomes de classe para rotulação e também exibe a probabilidade de previsão. O instrutor então demonstra o uso dessa função em imagens personalizadas e um modelo pré-treinado, explicando a importância de colocar o resultado na CPU para compatibilidade com matplotlib. Apesar do baixo desempenho do modelo, o instrutor enfatiza o poder de visualização dos resultados.
  
  
• 25:30:00 Nesta seção, o instrutor resume as principais conclusões da seção anterior, que abordou como prever dados personalizados com o PyTorch. Os principais pontos a serem lembrados são que os dados devem ser pré-processados para corresponder ao formato esperado do modelo, incluindo tipo de dados correto, dispositivo correto e formato correto. O PyTorch tem muitas funções integradas para lidar com diferentes tipos de dados, e os usuários podem escrever suas próprias classes de conjuntos de dados personalizados, se necessário. Além disso, o instrutor destaca a importância de equilibrar overfitting e underfitting ao treinar modelos e menciona vários recursos para aprendizado e prática adicionais, incluindo exercícios e materiais extracurriculares.
  
  
• 25:35:00 Nesta seção, o instrutor incentiva os alunos a passar primeiro pelo modelo de exercícios de conjuntos de dados personalizados do PyTorch e tentar preencher todo o código por conta própria. Caso fiquem presos, eles podem consultar as soluções de exemplo fornecidas pelo instrutor. As soluções oferecidas são apenas uma maneira de fazer as coisas, e os usuários são livres para consultá-las e comparar com sua implementação. As soluções e erros encontrados durante o processo também podem ser vistos nas orientações ao vivo disponíveis no YouTube. O instrutor lembra aos usuários que eles cobriram muitos exercícios e podem verificar os exercícios e soluções extras no repositório de aprendizado profundo do PyTorch. O instrutor conclui mencionando que há mais cinco capítulos disponíveis em learnpytorch.io, que os alunos podem explorar para saber mais sobre aprendizado por transferência, rastreamento de experimentos de modelo pytorch, replicação de papel pytorch e implantação de modelo pytorch.

[MetaQuotes]

Nenhum curso de aprendizado de máquina Black Box - Aprenda sem bibliotecas

Nenhum curso de aprendizado de máquina Black Box - Aprenda sem bibliotecas

00:00:00 - 01:00:00 Neste vídeo do YouTube, o instrutor apresenta um curso de aprendizado de máquina sem caixa preta que ensina como codificar em aprendizado de máquina sem depender de bibliotecas. O curso aborda tópicos relacionados à construção de um aplicativo da Web que reconhece desenhos, incluindo coleta de dados, extração e visualização de recursos e implementação de classificadores, como o vizinho mais próximo e K vizinho mais próximo. O instrutor enfatiza a importância de entender os dados no aprendizado de máquina e sugere recursos para quem precisa aprimorar a matemática do ensino médio e a experiência em programação. O vídeo demonstra o processo de criação de uma página da Web que atua como um criador de dados usando JavaScript sem nenhuma biblioteca externa. O apresentador também inclui instruções sobre como criar um botão de desfazer e um campo de entrada de nome, armazenar desenhos em um objeto de dados e salvar os caminhos no computador do usuário. Por fim, o vídeo mostra como criar um gerador de conjunto de dados em node.js e gerar dados associados a cada amostra usando JavaScript.

01:00:00 - 02:00:00 Neste vídeo do YouTube, o instrutor ensina aos espectadores como criar um conjunto de dados de aprendizado de máquina e extrair recursos sem usar bibliotecas. Eles demonstram como armazenar o conjunto de dados em uma pasta que pode se comunicar entre scripts de nó e aplicativos da web e criar um aplicativo visualizador de dados. O instrutor também mostra como visualizar os dados coletados usando gráficos do Google e como identificar e enfatizar itens selecionados no gráfico e na lista. No geral, o vídeo fornece um guia abrangente para os alunos criarem conjuntos de dados de aprendizado de máquina e extrair recursos usando apenas JavaScript. 02:00:00 - 03:00:00 O vídeo "No Black Box Machine Learning Course - Aprenda sem bibliotecas" demonstra como classificar desenhos com base em seus recursos sem usar bibliotecas de aprendizado de máquina. O criador do vídeo enfatiza a importância de ter um sistema rápido e responsivo para inspecionar os dados para evitar erros manuais. Eles demonstram como adicionar recursos ao gráfico, como ocultar o plano de fundo e como exibir rótulos previstos na tela usando contêineres dinâmicos com HTML e CSS. O vídeo também aborda técnicas de dimensionamento de dados, como normalização e padronização. Finalmente, o vídeo mostra como implementar o classificador de K vizinhos mais próximos e contar o número de cada rótulo dentro dos K vizinhos mais próximos.

03:00:00 - 03:50:00 O vídeo do YouTube "No Black Box Machine Learning Course - Learn Without Libraries" aborda vários tópicos relacionados à classificação K-vizinho mais próximo sem usar bibliotecas de aprendizado de máquina, como JavaScript e Python. O vídeo explica como dividir conjuntos de dados em conjuntos de treinamento e teste, lidar com amostras de treinamento e teste separadamente e normalizar os dados. O instrutor também discute a importância dos limites de decisão para entender como um classificador opera, demonstra como implementar um classificador K-vizinho mais próximo (KNN) em JavaScript e gera um gráfico baseado em pixel sem usar bibliotecas de aprendizado de máquina. Por fim, o vídeo termina com uma chamada para que os espectadores explorem recursos adicionais do Python e reflitam sobre o que aprenderam até agora.

Parte 1

• 00:00:00 Nesta seção, o palestrante apresenta o curso de aprendizado de máquina sem caixa preta, que se concentra na codificação sem depender de bibliotecas. O curso aborda vários tópicos para a construção de um aplicativo da web que reconhece desenhos, incluindo coleta de dados, extração e visualização de recursos e implementação de classificadores, como o vizinho mais próximo e K vizinho mais próximo. O palestrante enfatiza a importância de entender os dados no aprendizado de máquina e oferece uma pequena pausa para os alunos se concentrarem no dever de casa, além de sugerir recursos para aprimorar a matemática do ensino médio e a experiência de programação. O curso então passa para a fase dois, onde serão abordados métodos mais avançados, como redes neurais. Um exemplo de criação de um aplicativo de desenho para coleta de dados também é demonstrado com as funcionalidades de desfazer e salvar.
  
  
• 00:05:00 Nesta seção do vídeo, o instrutor percorre o processo de criação de uma página da Web que será usada como criadora de dados para um conjunto de dados. Eles começam criando uma nova pasta chamada web e, dentro dessa pasta, criam o primeiro arquivo, uma página da web chamada Creator.html. A página inclui HTML básico, uma seção de título e uma folha de estilo externa chamada Styles.css. Eles também adicionam estilos básicos para a página, incluindo a família de fontes e a cor de fundo. O instrutor então implementa o sketchpad usando um arquivo JavaScript externo chamado sketchpad.js e define o construtor da classe sketchpad para conter o elemento canvas.
  
  
• 00:10:00 Nesta seção, o instrutor configura uma tela usando JavaScript e adiciona um ouvinte de evento "onmousedown" para detectar ações do mouse. Eles obtêm as coordenadas do mouse obtendo o retângulo da área delimitadora da tela e subtraindo os lados esquerdo e superior, respectivamente. Depois de arredondar as coordenadas para números inteiros, o instrutor cria uma matriz de caminho que contém as coordenadas do mouse quando a tela é clicada. Eles também definem "desenho" como falso e "caminho" como vazio. Outro ouvinte de evento é adicionado para "onmousemove" para continuar adicionando mais pontos à matriz de caminho conforme o mouse é movido.
  
  
• 00:15:00 Nesta seção, o palestrante explica como implementar eventos de mouse para desenhar em uma tela usando JavaScript, sem o uso de bibliotecas. Ao usar ouvintes de evento para "onMouseMove" e "onMouseUp", o código rastreia os movimentos do mouse e adiciona o local a um caminho se o usuário estiver desenhando. Além disso, uma nova função "obter mouse" é criada para adicionar o local à tela. Por fim, o palestrante demonstra como criar um objeto utilitário "desenhar" para limpar e desenhar o caminho na tela.
  
  
• 00:20:00 Nesta seção, o instrutor de vídeo continua criando um programa de desenho sem nenhuma biblioteca externa, abordando alguns problemas com as linhas desenhadas, como aparência de canto e extremidades de linha reta. Eles então criam uma função para desenhar vários caminhos e a incorporam ao programa. O instrutor encontra alguns problemas ao executar o programa em um dispositivo móvel devido à janela de visualização e os corrige usando uma metatag na seção principal do arquivo HTML.
  
  
• 00:25:00 Nesta seção, o tutorial se concentra em fazer a tela caber em telas menores, como as de dispositivos móveis, adicionando comandos específicos à meta tag viewport no código HTML. No entanto, os ouvintes de evento para toque são diferentes daqueles para mouse, necessitando de uma modificação do bloco de desenho com ouvintes de evento para toque. Para aprimorar ainda mais a tela, um botão de desfazer é criado, mas somente quando houver caminhos para desfazer. O botão é desabilitado quando a tela está vazia.
  
  
• 00:30:00 Nesta seção, o vídeo explica como melhorar a aparência do botão alterando o estilo no arquivo CSS. O narrador adiciona um efeito de foco e define os estilos para o estado desabilitado. A seguir, aprendemos a criar um campo de entrada para o usuário inserir seu nome e um botão para avançar para o próximo desenho. O vídeo também explica como coletar dados desses campos e armazená-los em um objeto com três campos: aluno, sessão e desenhos. Por fim, o narrador começa a implementar a função start que será utilizada para iniciar o processo de desenho.
  
  
• 00:35:00 Nesta seção do vídeo, o apresentador mostra como implementar um aplicativo de desenho usando JavaScript sem usar nenhuma biblioteca. Eles começam definindo um índice para os rótulos das coisas que desejam desenhar, como carro, peixe, casa etc. Eles também adicionam um campo para instruções e modificam o botão Iniciar para mudar para "próximo" após o primeiro desenho . Eles então implementam uma função para o botão "próximo", que aumenta o índice, obtém o próximo rótulo e atualiza as instruções. Eles também armazenam os desenhos em um objeto de dados para o rótulo específico e adicionam um método público para redefinir o bloco de desenho. O apresentador testa o aplicativo e mostra que o objeto de dados está coletando os desenhos.
  
  
• 00:40:00 Nesta seção, o instrutor explica como salvar os caminhos traçados pelos usuários localmente em seu computador. Eles criam um elemento "a" com o atributo href definido como "texto simples de dados" e codificam o componente URI usando a versão stringificada dos dados. Os dados coletados são salvos como uma string JSON em um arquivo com um nome exclusivo gerado a partir de um carimbo de data/hora. Por fim, a ação de download é acionada para baixar o arquivo. O instrutor também adiciona instruções sobre o que fazer com o arquivo baixado e afirma que isso fará mais sentido após a próxima aula.
  
  
• 00:45:00 Nesta seção, o instrutor mostra como corrigir um possível problema com o bloco de desenho adicionando um ouvinte de evento no documento em vez da tela. Ele também pede aos espectadores que ajudem a testar o sistema em diferentes dispositivos e relatem quaisquer problemas ou proponham soluções. O instrutor então explica como processar os dados coletados em uma forma mais gerenciável usando node.js e mostra como navegar até o diretório do projeto e criar uma nova pasta para armazenar os dados. Por fim, ele cria uma pasta "bruta" onde cola todos os dados coletados de quase 500 envios de alunos, cada um contendo oito desenhos diferentes, e explica como processará esses arquivos para criar um conjunto de dados em que cada amostra é um desenho.
  
  
• 00:50:00 +Alt+M e o arquivo Json será formatado corretamente. Nesta seção, o instrutor explica como eles criarão um gerador de conjunto de dados no nodejs para processar as amostras e visualizá-las usando duas pastas separadas: uma para representações Json e outra para imagens. O script lerá nomes de arquivo do diretório de dados brutos, extrairá conteúdo deles e armazenará informações sobre cada amostra, como ID, rótulo, nome e ID do aluno, sessão e desenho. Por fim, a seção mostra brevemente como executar e testar o código, resultando na criação de um arquivo Json de amostra no diretório designado.
  
  
• 00:55:00 Nesta seção, o palestrante explica como gerar dados associados a cada amostra usando JavaScript. Isso envolve gravar arquivos em um diretório Json e restringir o desenho de cada rótulo específico. O palestrante então demonstra como gerar uma representação de imagem de cada desenho usando uma tela e a função 'desenhar caminhos' de um diretório comum. Para fazer isso, o palestrante exporta o objeto 'draw' do arquivo 'draw.js' para ser usado no gerador de conjunto de dados e instala a biblioteca de telas usando o gerenciador de pacotes do nó.

Parte 2

• 01:00:00 Nesta seção, o instrutor mostra como criar uma tela e usá-la para desenhar caminhos na tela e, em seguida, armazená-la como uma imagem. Eles também limpam a tela antes de traçar novos caminhos. Depois de gerar os arquivos de imagem, o instrutor corrige um problema no aplicativo de desenho causado pelo módulo não estar definido no draw JS. Eles utilizam uma estrutura que será utilizada ao longo do curso, separando constantes em outro arquivo e solicitando isso. O instrutor adiciona um indicador de progresso em um novo arquivo chamado utils criando o objeto utils e adicionando a função chamada print progress. Eles usam o processo STD out para obter a saída padrão, calculam a porcentagem usando a função para formatar uma porcentagem e a gravam na saída padrão para mostrar o indicador de progresso.
  
  
• 01:05:00 Nesta seção, o criador do vídeo explica como armazenar o conjunto de dados gerado de forma que o navegador possa lê-lo. Ele cria uma pasta chamada "JS_objects" que conterá arquivos que podem se comunicar entre os scripts do nó e os aplicativos da web. Um arquivo JavaScript de "amostras" é criado e inicializará um objeto JavaScript dentro da pasta JS_objects. O criador do vídeo também menciona que criará um aplicativo visualizador para o conjunto de dados e criará um arquivo HTML chamado "viewer.html" com código HTML básico. A seção head do arquivo inclui uma meta tag para suportar caracteres UTF e um título para a página. A seção body inclui uma tag H1 com o título "Data Viewer" e um div com um ID de "container" para conter o conjunto de dados. O arquivo JavaScript "amostras" está incluído no arquivo HTML.
  
  
• 01:10:00 Nesta seção, o instrutor está trabalhando na criação de uma tabela com amostras agrupadas por carteira de aluno. Para fazer isso, eles implementam uma função "agrupar por" no arquivo utils.js, que agrupa um array por uma determinada chave. Em seguida, eles registram os grupos no console para verificar se está funcionando. Em seguida, eles criam uma função chamada "criar linha" em um arquivo display.js separado, que recebe um contêiner, um nome de aluno e amostras como parâmetros e cria uma linha com o nome à esquerda e amostras à direita. Eles criam um loop para percorrer cada ID do aluno, chamam a função "criar linha" e passam os parâmetros necessários para exibir os dados em um formato de tabela.
  
  
• 01:15:00 Nesta seção, o instrutor mostra como criar dinamicamente uma linha de imagens com rótulos e alinhá-las adequadamente com CSS. Eles começam percorrendo um conjunto de amostras de imagem, criando um elemento de imagem e atribuindo os atributos de origem e estilo. As imagens são anexadas a uma linha enquanto um rótulo div é criado e anexado a um contêiner de amostra. O contêiner de amostra é então agrupado com um div, que recebe um ID e uma classe. O instrutor então refina o CSS para centralizar os rótulos e imagens e adicionar reticências a nomes mais longos. Por fim, eles adicionam um plano de fundo branco aos desenhos de amostra criando um div e anexando-o após o rótulo.
  
  
• 01:20:00 Nesta seção, o criador do vídeo modifica a exibição das amostras de imagens coletadas no aplicativo da web. A modificação envolve a criação de um contêiner de amostra com fundo branco, texto alinhado ao centro, canto arredondado e margem de um pixel. A miniatura é definida como 100 e o rótulo da linha tem uma propriedade que ocupa 20 por cento do espaço, com as oito amostras restantes ocupando dez por cento do espaço cada. A estrutura de exibição resultante é organizada, mas algumas imagens não se encaixam perfeitamente, o que não é grande coisa porque é destinado a aplicativos de desktop. Além disso, o criador adiciona um filtro de desfoque a alguns desenhos feitos por usuários sinalizados usando seus IDs. Alguns dos desenhos coletados são impressionantes, enquanto outros contêm interpretações errôneas que tornam os dados mais desafiadores.
  
  
• 01:25:00 Nesta seção, o YouTuber está dando uma olhada em alguns desenhos do conjunto de dados e comentando sobre sua qualidade, observando que alguns são muito detalhados e devem ter demorado muito para serem criados. Eles também mencionam que seu conjunto de dados é diferente do conjunto de dados do Quick Draw, pois eles têm um botão de desfazer e não têm limite de tempo, o que significa que seus desenhos devem ter, em média, melhor qualidade. Por fim, eles fazem um comentário improvisado sobre a organização e o estilo da página.
  
  
• 01:30:00 Nesta seção, o instrutor explica como extrair recursos de amostras sem usar nenhuma biblioteca. As funções para extrair contagem de caminho e contagem de pontos são implementadas em um arquivo chamado features.js e adicionadas a um objeto chamado features. Em seguida, no arquivo feature extractor.js, as amostras são lidas e as características são extraídas fazendo um loop por todas as amostras e obtendo a contagem de caminhos e pontos para cada uma delas. Esses valores de recurso são combinados em uma matriz e gravados em um novo arquivo. Por fim, os nomes dos recursos e as amostras são combinados em outro arquivo chamado features.json. Ao executar o script do extrator de recursos, o log diz "extraindo recursos" e, no final, "concluído". Os recursos resultantes no diretório do conjunto de dados podem então ser examinados.
  
  
• 01:35:00 Nesta seção, o criador do vídeo explica como usar um objeto JavaScript para armazenar dados adicionais que ainda não estão contidos em um arquivo de recurso. O objeto pode ser salvo em um arquivo JavaScript separado e usado para extrair todos os dados necessários para um aplicativo da web. O criador também demonstra como visualizar os dados usando gráficos do Google, onde opções como largura, altura, títulos de eixo e o pacote principal do gráfico podem ser definidos em um objeto. Uma tabela de dados é criada com duas colunas para valores de recursos e seus nomes correspondentes.
  
  
• 01:40:00 Nesta seção, o vídeo demonstra como criar um gráfico de dispersão com o Google Visualization, permitindo que os usuários investiguem diferentes recursos dos dados mais de perto usando as ações do Explorer para aumentar e diminuir o zoom. O vídeo também mostra como usar cores diferentes para cada classe e implementar transparência para melhor visualização da densidade em diferentes partes usando uma versão diferente da biblioteca de gráficos do Google chamada gráficos de materiais.
  
  
• 01:45:00 Nesta seção, o criador do vídeo mostra como criar um gráfico de dispersão usando gráficos do Google e, em seguida, criar um novo gráfico com seu próprio código JavaScript. O criador simplifica as opções do gráfico e altera o esquema de cores para usar emojis, o que facilita o reconhecimento dos pontos de dados sem a necessidade de rótulos ou legendas. A transparência do gráfico também é ajustada para permitir uma melhor visibilidade dos dados densamente plotados.
  
  
• 01:50:00 Nesta seção, o instrutor adiciona uma função de callback ao gráfico para identificar qualquer item selecionado na tabela abaixo. A nova função é chamada de "clicar em lidar", que adiciona uma classe "enfatizar" ao item selecionado e usa "rolar para ver" e "centralizar bloco" para garantir que ele seja rolado automaticamente para o centro da página. O instrutor então modifica o layout da página para que o gráfico fique no lado direito da página, com o outro conteúdo no lado esquerdo. O gráfico também é fixo na posição para que não se mova quando o usuário rolar.
  
  
• 01:55:00 Nesta seção do vídeo, o apresentador mostra como selecionar e desmarcar itens do gráfico e da lista. Eles especificam um parâmetro para definir se a rolagem deve ocorrer e adicionam código para lidar com o erro que ocorre ao tentar não selecionar nada. Além disso, o apresentador adiciona a capacidade de enfatizar um elemento por meio de uma classe, removendo a classe se ela já estiver enfatizada. Finalmente, eles testam a funcionalidade do gráfico e ajustam o tamanho do gráfico.

Parte 3

• 02:00:00 Nesta seção, o palestrante demonstra o uso de um bloco de desenho como entrada para desenhar algo a ser classificado. Eles preparam um contêiner para ele, adicionam estilos a ele e fixam sua posição a uma certa distância da direita e do topo da tela. Eles também oferecem uma margem para visibilidade clara e um botão de desfazer no centro. Eles então adicionam um painel de controle e um botão para alternar a entrada visível ou não, que funciona com sucesso no teste. O palestrante enfatiza a importância de ter um sistema ágil e responsivo na hora de inspecionar os dados para evitar erros manuais que podem levar a erros.
  
  
• 02:05:00 Nesta seção, o instrutor de vídeo mostra como adicionar um painel de controle ao gráfico e como ocultar o plano de fundo quando a entrada estiver presente. Eles demonstram uma solução para ocultar o plano de fundo no HTML do visualizador, tornando transparente o contorno da tela do bloco de desenho. Eles também mostram como exibir recursos no gráfico imediatamente quando algo é desenhado no bloco de esboços, adicionando uma função de retorno de chamada de atualização que extrai recursos da mesma forma que o extrator de recursos. O instrutor encontra um problema com objetos conflitantes chamados recursos, mas o resolve renomeando-os para funções de recursos em todos os lugares.
  
  
• 02:10:00 Nesta seção, o palestrante demonstra um ponto dinâmico que pode ser adicionado ao gráfico, que se move conforme o desenho é feito. Isso é obtido definindo um atributo para um valor e redesenhando-o. O ponto dinâmico é adicionado à classe do gráfico e desenhado antes que os eixos sejam exibidos. Ao arrastar, o ponto se move para diferentes áreas e, quando desenhado com um ponto branco transparente sobre um fundo preto, fica muito mais visível. O valor precisa ser grande, pois o gráfico pode ser ampliado e o ponto permanece visível sem ultrapassar as bordas.
  
  
• 02:15:00 Nesta seção, o instrutor demonstra como acionar um método de atualização em sketchpad.js, que funciona ocultando a entrada dinâmica e mostrando os dados quando a entrada de alternância é pressionada. Com o método de atualização do acionador, o instrutor aplica as funções de recursos de obtenção de largura e altura em funções de recursos comuns para calcular a largura e a altura do desenho, que são usadas para extrair novos recursos no extrator de recursos de nó. O instrutor sugere que eles precisem reestruturar o HTML para que o mesmo recurso seja utilizado para extração e exibição de dados.
  
  
• 02:20:00 Nesta seção, o criador do vídeo demonstra como remover códigos desnecessários e substituí-los por novas funções de recursos, resultando em um processo de criação de pontos mais generalizado e multidimensional. Depois de regenerar os recursos e atualizar os nomes dos recursos, alguns pontos de amostra problemáticos são observados, o que é um problema comum ao trabalhar com dados. O criador observa que exceções e inconsistências são esperadas nos dados e convida os espectadores a ajudar a identificar a causa do problema.
  
  
• 02:25:00 Nesta seção, o instrutor explica como classificar um desenho com base em seus recursos sem usar bibliotecas de aprendizado de máquina. Eles extraem características da entrada e olham para os pontos próximos para classificar a entrada. Para encontrar o ponto mais próximo, o instrutor copia a função obter o mais próximo do gráfico math.js e a cola em seu código. Eles então chamam a função para identificar o rótulo do desenho e registram o resultado.
  
  
• 02:30:00 Nesta seção, o criador do vídeo adiciona a funcionalidade de exibir o rótulo previsto na tela usando contêineres dinâmicos com HTML e CSS. O rótulo previsto é exibido em um contêiner branco com um texto concatenado exibindo se o objeto é um carro ou não. O criador experimenta desenhar diferentes objetos, como relógios e lápis, para testar as capacidades preditivas do programa. O criador do vídeo atualiza o gráfico usando pontos dinâmicos com rótulos e imagens e desenha linhas conectando as amostras mais próximas.
  
  
• 02:35:00 Nesta seção, o palestrante discute a importância de não comprimir ou esticar dados em gráficos ao trabalhar em projetos de aprendizado de máquina. Eles demonstram como a proporção de um gráfico pode afetar a forma como os dados são interpretados, levando a confusão e erros. Para resolver esse problema, o palestrante calcula um delta para os valores máximos de x e y e ajusta o gráfico de acordo. Embora isso crie um espaço vazio, ele permite a visualização adequada dos dados e os resultados precisos do aprendizado de máquina.
  
  
• 02:40:00 Nesta seção da transcrição, o criador do vídeo enfatiza a importância do escalonamento de dados no aprendizado de máquina para garantir que todos os recursos tenham o mesmo significado na classificação. O criador demonstra como os dados podem ser compactados e esticados durante a extração de recursos, resultando em tratamento desigual de determinados recursos. Para nivelar o campo de jogo, o criador introduz a normalização, uma técnica comum para remapear valores de recursos para um intervalo entre 0 e 1. O vídeo mostra a implementação de uma nova função chamada "normalizar pontos" na seção "utils" para realizar isso remapeamento.
  
  
• 02:45:00 Nesta seção, o tutorial em vídeo mostra como normalizar os dados alterando os valores entre 0 e 1. A função é inicializada para ser geral o suficiente e os valores mínimo e máximo para cada recurso são calculados. Os pontos são modificados para ficarem entre 0 e 1 subtraindo o valor mínimo e dividindo pela diferença. A função inverse lerp é utilizada para converter o valor dado em uma porcentagem para normalizar as feições extraídas do desenho. Os valores min-max são retornados da função e gravados em um dos arquivos de objeto JavaScript para se comunicar com a interface. Por fim, os dados são gerados e os valores min-max são incluídos nos arquivos de objeto JavaScript.
  
  
• 02:50:00 Nesta seção, o apresentador explica como normalizar pontos antes de tentar classificá-los usando a função normalizar pontos do Utils. Para fazer isso, os dados brutos do recurso são carregados e passados como entrada para a função. Além disso, um valor min-max pode ser passado para suportar a normalização sem ter que calculá-los. Também é demonstrado como a normalização é sensível a pontos atípicos e como lidar com eles, como detectá-los e removê-los automaticamente ou usar a padronização como um escalonamento de dados diferente.
  
  
• 02:55:00 Nesta seção, o instrutor discute a técnica de padronização, que envolve calcular a média e o desvio padrão de cada recurso e remapeá-lo subtraindo a média e dividindo pelo desvio padrão. Essa técnica é menos sensível a outliers e pode funcionar melhor em certos casos. O instrutor também apresenta o classificador de K vizinhos mais próximos, onde a classe é determinada com base na maioria dos K vizinhos mais próximos. O código é atualizado para permitir a pesquisa de K vizinhos mais próximos, e o instrutor demonstra como contar o número de cada rótulo dentro dos K vizinhos mais próximos.

Parte 4

• 03:00:00 Nesta seção, o instrutor explica o processo de descobrir a maioria de um conjunto de amostras com base em seus rótulos. Isso envolve contar as ocorrências de cada rótulo nas amostras e definir o rótulo majoritário como aquele com a contagem mais alta. O instrutor faz atualizações no código para retornar todas as amostras mais próximas e traçar linhas até elas no gráfico, em vez de apenas a mais próxima. Eles então demonstram o funcionamento do classificador em vários conjuntos de dados e encorajam os visualizadores a compartilhar suas próprias implementações de outras variantes dos classificadores vizinhos mais próximos. Por fim, o instrutor enfatiza a necessidade de dividir os dados em conjuntos de treinamento e teste para avaliar objetivamente o desempenho do classificador.
  
  
• 03:05:00 Nesta seção, o vídeo demonstra como dividir um conjunto de dados em conjuntos de treinamento e teste, gravá-los em arquivos e definir constantes para essas divisões no código usando JavaScript. O conjunto de treinamento é definido como 50% do número de amostras e o vídeo alerta sobre o erro de testar os dados de treinamento. Para testar, o código percorre todas as amostras de teste e armazena o valor do rótulo em um atributo chamado Truth, fingindo não conhecer o rótulo para fins de teste.
  
  
• 03:10:00 Nesta seção, o vídeo aborda como lidar com as amostras de treinamento e teste separadamente e como normalizar os dados corretamente. O palestrante explica que é importante normalizar os dados apenas com o conjunto de treinamento, pois não temos ideia de qual será o conjunto de teste. Eles também descrevem como classificar adequadamente usando apenas informações dos dados de treinamento e demonstram como lidar com pontos de dados desconhecidos usando a função de classificação.
  
  
• 03:15:00 Nesta seção, o criador do vídeo adiciona um atributo correto a um rótulo de teste e compara esse rótulo com o valor verdadeiro anterior para determinar a precisão. Um subtítulo também é adicionado para esclarecer onde o conjunto de teste começa. O criador então adiciona um campo de estatísticas para calcular e exibir a precisão do classificador K vizinho mais próximo, que é definido como 10 vizinhos mais próximos, resultando em uma precisão de 39,62%. Ao alterar o parâmetro para um vizinho mais próximo, a precisão é realmente muito pior, mostrando que considerar vários vizinhos foi uma boa ideia.
  
  
• 03:20:00 Nesta seção, o instrutor refatora o código e discute a importância dos limites de decisão na compreensão de como um classificador opera. Eles criam um novo arquivo chamado "avaliação de execução" e carregam as constantes e utilitários necessários. O instrutor explica como criar um classificador e como obter amostras de treinamento e teste para calcular a precisão de um classificador. Eles também introduzem limites de decisão, que fornecem informações valiosas sobre como um classificador determina a classificação de um ponto de dados. O instrutor afirma que os limites de decisão são mais úteis do que simplesmente contar os diferentes recursos de um ponto de dados.
  
  
• 03:25:00 Nesta seção, o palestrante explica como implementar um classificador de K-vizinho mais próximo (KNN) em JavaScript. O código começa com rótulos de previsão para cada ponto de amostra de teste usando o método KNN e calculando a precisão verificando a contagem de previsões corretas. O arquivo KN.js é criado para definir a classe que recebe amostras de treinamento e K para armazenar e prever um determinado ponto. O código da classe para classificação é copiado do HTML do visualizador para KN.js e modificado para caber na nova classe. O script de avaliação de execução é atualizado para usar o classificador KNN em vez do antigo método de classificação. Ao refatorar dessa maneira, o código se torna mais gerenciável e erros bobos podem ser evitados.
  
  
• 03:30:00 Nesta seção, o instrutor demonstra como gerar um gráfico baseado em pixel sem usar bibliotecas de aprendizado de máquina, normalizando valores de pixel e codificando-os por cores com base em valores previstos. O gráfico é salvo como uma imagem PNG e definido como plano de fundo de um gráfico. O instrutor mostra como implementar esse novo recurso no arquivo chart.js tomando a coordenada superior esquerda de acordo com os dados, obtendo o valor de pixel dos limites de dados para os limites de pixel e dividindo-o de acordo com a forma como o dimensionamento foi feito usando a transformação.
  
  
• 03:35:00 Nesta seção do vídeo, o apresentador discute a imagem gerada na seção anterior e comenta sobre sua baixa resolução e efeito de suavização. Eles então introduzem uma imagem de maior resolução, que não requer mais a exibição de dados. Eles explicam que as regiões coloridas nos informam sobre os diferentes rótulos e como é interessante observar o aparecimento das diferentes regiões. Eles então desafiam os espectadores a calcular a precisão de todos os valores possíveis de K e criar um gráfico de linha para determinar o melhor valor e também gerar um gráfico de limite de decisão de alta resolução para o melhor valor.
  
  
• 03:40:00 Nesta seção, o YouTuber explica como preparar dados para Python escrevendo uma função para converter dados de amostra em formato CSV usando JavaScript. Eles criam uma função chamada toCSV que converte dados de amostra com cabeçalhos e nomes de recursos em formato CSV, que é comumente usado em Python. Eles geram o CSV com nomes e rótulos de recursos para dados de treinamento e teste e, em seguida, passam para a implementação Python do K vizinho mais próximo usando bibliotecas. Eles abrem o arquivo CSV de treinamento, leem as linhas e analisam os dados como uma matriz de linhas representadas como uma string, com o caractere de nova linha.
  
  
• 03:45:00 Nesta seção, o instrutor explica como preparar os dados para classificação dos K vizinhos mais próximos sem o uso de bibliotecas. Os dados são lidos de um arquivo CSV e armazenados em duas matrizes vazias em Python - X para valores de recursos e Y para rótulos. O instrutor percorre um loop para preencher as matrizes, converter os valores de recursos em flutuantes e remapear os rótulos em números. O remapeamento é obtido usando um dicionário Python. Os dados são então ajustados a um objeto classificador KNN com parâmetros definidos para emular o aplicativo da web, incluindo 250 vizinhos, algoritmo de força bruta e pesos uniformes. O instrutor termina destacando a importância da indentação em Python e extraindo os dados do recurso de leitura de um arquivo como uma função.
  
  
• 03:50:00 Nesta seção, o palestrante demonstra como passar dados para o modelo e verificar sua precisão usando a função de pontuação. Eles também incentivam os visualizadores a explorar recursos adicionais do Python, como instalar matplotlib para visualizar valores de recursos e limites de decisão. O vídeo termina com um apelo para que os espectadores reflitam sobre o que aprenderam até agora e se preparem para a próxima fase do curso.

[MetaQuotes]

MIT 6.034 "Inteligência Artificial". Outono de 2010. Aula 1. Introdução e Escopo

1. Introdução e Escopo

Este vídeo é uma introdução ao curso MIT 6.034 "Inteligência Artificial" Por fim, o vídeo fornece uma breve visão geral do curso, incluindo como a nota é calculada e o que o questionário e a final implicarão.

• 00:00:00 Neste vídeo, um professor discute a definição de inteligência artificial e sua importância. Ele continua dizendo que quem fizer o curso vai ficar mais esperto. O professor também discute modelos de pensamento e como eles são importantes para um bom entendimento do assunto. Por fim, ele fala sobre a importância das representações para fazer bons modelos.
  
  
• 00:05:00 Neste vídeo, o professor explica como funcionam os giroscópios e como representar um problema em termos de gráfico. Em seguida, ele explica como resolver o problema do ganso e dos grãos do fazendeiro Fox, que é um exemplo com o qual muitas pessoas podem estar familiarizadas desde a infância.
  
  
• 00:10:00 O vídeo apresenta o conceito de inteligência artificial e seus vários componentes, incluindo testes gerados por inteligência artificial. O vídeo continua discutindo o princípio de Rumpelstiltskin, que afirma que, uma vez que você pode nomear algo, pode obter poder sobre ele.
  
  
• 00:15:00 Este vídeo apresenta o conceito de ideias simples, que são poderosas e podem ser simples ou complexas. O vídeo passa a discutir a definição e exemplos de ideias simples. O ponto principal do vídeo é que ideias simples são importantes para construir programas mais inteligentes e que cientistas e engenheiros têm motivações diferentes para estudá-las.
  
  
• 00:20:00 Este vídeo discute a história da inteligência artificial, começando com o trabalho feito por Ada Lovelace há mais de um século. A era moderna da IA começou com o artigo escrito por Marvin Minsky em 1960. Em um dia, a discussão da inteligência artificial será abordada no curso.
  
  
• 00:25:00 A "era da escavadeira" refere-se à época em que as pessoas começaram a ver que tinham acesso a um poder de computação ilimitado e começaram a desenvolver sistemas especializados baseados em regras.
  
  
• 00:30:00 O vídeo discute a história da evolução humana e a ideia do ensino médio, que é a de que os humanos evoluíram por meio de uma melhoria gradual e contínua. Ele continua discutindo como as mudanças acidentais que levaram à evolução humana foram produtos evolutivos acidentais e especulando sobre o que essas mudanças podem ser.
  
  
• 00:35:00 Este vídeo fornece uma breve introdução às ideias de Noam Chomsky sobre o desenvolvimento da inteligência humana. Os principais pontos levantados são que a linguagem está no centro da inteligência humana e que o principal objetivo do curso é ajudar os alunos a desenvolver habilidades na área. O vídeo também menciona a importância de recitações e tutoriais, que são aspectos-chave do curso.
  
  
• 00:40:00 Este vídeo fornece uma breve visão geral do curso do MIT, incluindo sua correlação entre frequência às aulas e notas. O vídeo fornece um resumo de como o curso calcula a nota de um aluno, o que inclui levar em consideração o desempenho do aluno nos questionários e na final. Por fim, o vídeo adverte os alunos a não tentarem fazer todos os exames finais, pois haveria muita pressão e menos oportunidades de melhoria.
  
  
• 00:45:00 O vídeo apresenta o questionário e a final e explica como o questionário funcionará e o formato do exame final. O vídeo também explica como os alunos poderão entrar em contato com o instrutor e agendar tutoriais.

[MetaQuotes]

Aula 2. Raciocínio: Árvores de Metas e Resolução de Problemas

2. Raciocínio: Árvores de Objetivos e Resolução de Problemas

Este vídeo discute como raciocinar, árvores de objetivos e resolução de problemas. Ele apresenta uma técnica chamada "redução de problemas" e explica como ela pode ser usada para resolver problemas de cálculo. Também discute como usar transformações heurísticas para resolver problemas e como o conhecimento pode ser usado para resolver problemas em domínios complexos.

• 00:00:00 O vídeo apresenta a redução de problemas, que é uma técnica comum de resolução de problemas usada pelos alunos em cálculo. Ele discute a filosofia educacional por trás da redução de problemas e fornece uma lista de exemplos de reduções de problemas.
  
  
• 00:05:00 O palestrante está explicando como funciona a solução de problemas e como diferentes transformações podem ajudar a resolver um problema. Eles abordam quatro transformações seguras necessárias para resolver um problema. O primeiro passo é aplicar todas as transformações seguras e depois consultar a tabela para ver se o problema foi resolvido. Se o problema for resolvido, o palestrante relatará o sucesso.
  
  
• 00:10:00 O vídeo discute o conceito de árvores de objetivos e resolução de problemas e apresenta a ideia de transformações heurísticas. Essas transformações, embora nem sempre bem-sucedidas, podem ser úteis em determinadas situações.
  
  
• 00:15:00 O vídeo discute várias transformações heurísticas que podem ser usadas para resolver problemas. Uma dessas transformações é uma família de transformações das quais mostrarei apenas uma. Esta transformação é assim: se você tem a integral de uma função da tangente e X, você pode reescrever isso como a integral de uma função de Y sobre 1 mais y ao quadrado dy. Essa transformação de uma forma trigonométrica em uma forma polinomial elimina todo aquele lixo trigonométrico com o qual não queremos lidar. Há um C de que precisamos também, e essa será sua reação instintiva adequada. Você vê algo na forma de 1 menos x ao quadrado, e o que você faz quando vê isso? Bem, você poderia fazer isso. Não há nada que você possa fazer se Kristen tiver algo que ela possa sugerir. Ela diz que, por causa de onde está nosso húngaro, viro nosso jovem, sugere que façamos a transformação que envolve o sinal de X pessoas. Isso significa que Scylla não precisa mais se lembrar disso porque daqui para frente, ela nunca terá que integrar nada pessoalmente em sua vida. Ela pode apenas simular o programa. Eles vão da forma polinomial para a forma trigonométrica, então você tem três
  
  
• 00:20:00 O vídeo discute raciocínio, árvores de objetivos e resolução de problemas. O apresentador apresenta uma técnica de solução de problemas chamada "árvore de objetivos". Essa árvore mostra como as metas estão relacionadas entre si e pode ser útil na tomada de decisões sobre qual problema resolver. O apresentador explica que essa técnica também é conhecida como "árvore de indução de problemas" ou "árvore de objetivos em árvore".
  
  
• 00:25:00 Este vídeo apresenta o conceito de árvores de objetivos e resolução de problemas e mostra como se pode medir a profundidade da composição de funções usando símbolos. O vídeo demonstra como aplicar uma transformação segura para dividir uma integral em três partes e como ela funciona para uma função racional específica.
  
  
• 00:30:00 O vídeo aborda o programa de raciocínio, que resolve problemas compondo transformações seguras. Ele mostra como o programa parou antes de encontrar uma solução para um determinado problema e voltou a trabalhar em outro problema.
  
  
• 00:35:00 O vídeo discute o raciocínio por trás do modelo de problemas de cálculo de calouros de Schlegel, que é um modelo no qual o conhecimento sobre transformações, como funcionam as árvores antigas e tabelas são necessários para resolver os problemas. O vídeo também menciona como a profundidade da composição funcional, que é uma técnica sugerida por Brett, na verdade não importa porque a árvore não cresce profunda ou larga.
  
  
• 00:40:00 O vídeo discute como o conhecimento é representado na solução de problemas e como certas transformações tornam o problema mais simples. Também discute como o conhecimento pode ser usado para resolver problemas em domínios complexos.
  
  
• 00:45:00 O palestrante demonstra um programa que supostamente demonstra como os computadores podem ser "inteligentes". No entanto, o locutor rapidamente percebe que o programa faz a mesma coisa que ele e, portanto, o computador não é verdadeiramente inteligente.

[MetaQuotes]

Aula 3. Raciocínio: Árvores de Objetivos e Sistemas Especialistas Baseados em Regras

3. Raciocínio: Árvores de Objetivos e Sistemas Especialistas Baseados em Regras

Este vídeo explica como funciona um sistema especialista baseado em regras. O sistema é projetado para resolver problemas difíceis de resolver usando métodos mais tradicionais. O sistema é composto por diversas regras que são conectadas por portas e portas, permitindo que o sistema reconheça com certeza um determinado animal.

• 00:00:00 Este vídeo explica como um sistema especialista baseado em regras (RBS) é construído e fornece um exemplo de como o sistema funciona. O RBS é projetado para resolver problemas difíceis de resolver usando métodos mais tradicionais, como equações algébricas.
  
  
• 00:05:00 Neste vídeo, o professor Patrick Winston explica como funcionam os programas de raciocínio, ou sistemas especialistas baseados em regras. A estrutura do programa é muito simples, com quatro blocos que são executados em um loop iterativo para atingir o resultado desejado. O programa é capaz de resolver problemas que envolvem blocos simples porque pega dicas de perguntas respondidas no passado e usa recursão para obter um resultado complexo.
  
  
• 00:10:00 O vídeo explica como uma árvore de objetivo é usada para responder perguntas sobre como algo foi feito e como uma árvore e-ou pode ser usada para fazer isso. Ele também explica que o programa de integração pode usar árvores de metas para responder a perguntas sobre seu próprio comportamento.
  
  
• 00:15:00 Este vídeo discute como o comportamento complexo é resultado da complexidade do ambiente, não da complexidade do programa. Os sistemas especialistas baseados em regras foram desenvolvidos no final dos anos 60 como uma forma de encapsular o conhecimento em regras simples e ainda estão em uso hoje.
  
  
• 00:20:00 Este vídeo do YouTube discute como um sistema especialista baseado em regras de encadeamento avançado (RBSES) pode ser usado para identificar animais em um pequeno zoológico. A RBSES é composta por diversas regras que são interligadas por portas e portas, permitindo que o sistema reconheça com certeza um determinado animal.
  
  
• 00:25:00 Este vídeo explica como funciona um sistema especialista baseado em regras (RBE), retrocedendo a partir de uma hipótese para determinar se um objeto é um determinado tipo de animal.
  
  
• 00:30:00 Um sistema especialista baseado em regras foi criado para projetar casas semelhantes às projetadas pelo arquiteto português Siza. O sistema é capaz de traduzir o que um empacotador de supermercado diz em uma regra se-então, permitindo que um engenheiro de conhecimento entenda isso.
  
  
• 00:35:00 Neste vídeo, o professor Patrick Winston discute os princípios da engenharia do conhecimento, incluindo a necessidade de casos específicos e o uso de heurísticas. Ele também fornece um exemplo de como a heurística número dois, a questão de saber se dois objetos são iguais ou diferentes, pode ser usada para resolver problemas.
  
  
• 00:40:00 O apresentador discute três maneiras pelas quais a inteligência humana pode ser aprimorada: construindo sistemas baseados em regras, desenvolvendo programas orientados a objetivos e usando programas de integração. A heurística número três é que, quando uma regra ou meta não está sendo seguida, o sistema falha, indicando a necessidade de mais conhecimento. O apresentador demonstra isso discutindo um caso em que um programa prescreveu um barril de penicilina a um paciente.
  
  
• 00:45:00 Este vídeo explica como funciona o raciocínio por meio de árvores de objetivos e sistemas especialistas baseados em regras. Em ambos os exemplos, o sistema é capaz de ler histórias e determinar as consequências das ações.