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

[MetaQuotes]

Ilya Sutskever (Cientista Chefe da OpenAI) - Construindo AGI, Alinhamento, Espiões, Microsoft e Iluminismo

Ilya Sutskever (Cientista Chefe da OpenAI) - Construindo AGI, Alinhamento, Espiões, Microsoft e Iluminismo

O cientista-chefe da OpenAI, Ilya Sutskever, cobre uma variedade de tópicos neste vídeo, incluindo o potencial para usos ilícitos de GPT, a importância da confiabilidade em sistemas de IA, o papel da colaboração homem-máquina na construção de AGI, limitações de software e hardware de AGI e o potencial da pesquisa acadêmica. Ele acredita que uma combinação de abordagens será necessária para reduzir a probabilidade de desalinhamento na construção da AGI, e que os avanços necessários para a IA sobre-humana podem não parecer necessariamente avanços em retrospectiva. Ele também enfatiza o valor da contribuição humana nos modelos de ensino e sugere que o impacto dos modelos de linguagem pode ir além do mundo digital.

• 00:00:00 Nesta seção, Ilya Sutskever discute o potencial de usos ilícitos do GPT e reconhece que é possível que governos estrangeiros já o estejam usando para fins de propaganda. Ele também observa que, embora seja difícil dar um prazo exato para a transição da IA para a AGI, o valor econômico da IA continuará a aumentar de maneira exponencial nos anos anteriores. Sutskever também usa o carro autônomo como uma analogia para o estado atual da IA, observando que, embora os modelos pareçam capazes de fazer tudo, ainda há trabalho a ser feito para garantir confiabilidade e robustez. Por fim, Sutskever admite que é difícil prever qual porcentagem do PIB a IA representará até 2030 e por que ela pode não atingir uma porcentagem alta.
  
  
• 00:05:00 Nesta seção, o cientista-chefe da OpenAI, Ilya Sutskever, discute a importância da confiabilidade em sistemas de IA e como isso pode afetar o valor econômico que eles produzem. Ele também fala sobre o potencial do atual paradigma de modelos generativos para levar à AGI e que a integração de diferentes ideias do passado pode criar o próximo paradigma. Sutskever desafia a alegação de que a previsão do próximo token não pode superar o desempenho humano e explica como isso pode levar a percepções sobre pessoas hipotéticas com capacidade mental muito maior do que a pessoa média. Por fim, ele confirma que a maioria dos dados para aprendizado por reforço já vem da IA, e não de humanos, e fala sobre o potencial de professores humanos colaborarem com a IA para melhorar a si mesmos sem a contribuição humana.
  
  
• 00:10:00 Nesta seção, o cientista-chefe da OpenAI, Ilya Sutskever, discute a importância da colaboração homem-máquina na construção de sistemas com recursos avançados de raciocínio e a necessidade de treinamento dedicado para melhorar as habilidades de raciocínio em várias etapas em modelos de aprendizado de máquina. Ele também aborda as preocupações sobre a escassez de dados e sugere que a multimodalidade pode ser uma direção valiosa para a obtenção de mais dados. Embora a robótica não fosse uma direção viável para a OpenAI no passado devido à escassez de dados, pode haver mais potencial para progresso no campo agora, mas requer um forte comprometimento e dedicação à tarefa. Por fim, Sutskever expressa entusiasmo por ideias futuras que podem não funcionar bem com as atuais limitações de hardware.
  
  
• 00:15:00 Nesta seção, Ilya Sutskever discute as limitações de hardware para construir AGI e suas perspectivas para alcançar o alinhamento. Ele acredita que não haverá uma única definição matemática para alinhamento, mas sim várias definições que analisam o alinhamento de diferentes aspectos, e que uma combinação de abordagens será necessária para reduzir a probabilidade de desalinhamento. Sutskever também menciona a possibilidade de uma pequena rede neural bem compreendida para verificar o comportamento de uma grande rede neural. Quando questionado sobre as receitas projetadas da OpenAI de um bilhão de dólares em 2024, Sutskever explica que é difícil estimar o lucro inesperado de uma nova tecnologia de uso geral, mas atribui o número ao crescimento potencial dos produtos da OpenAI.
  
  
• 00:20:00 Nesta seção do vídeo, Ilya Sutskever, cientista-chefe da OpenAI, fala sobre como os dados desempenham um papel vital na determinação do futuro da AGI. Ele enfatiza que fazer previsões sem dados levará a uma grande margem de erro. Ele também compartilha seus pensamentos sobre o futuro pós-AGI, dizendo que o AGI pode ajudar os humanos a se tornarem mais iluminados e interagirem com o mundo de maneira mais correta. No entanto, Sutskever aponta que será difícil para as pessoas entender o que está acontecendo com precisão e como contribuir para a sociedade à medida que ela se transforma. Além disso, ele espera que a AGI não dite como a sociedade deve ser administrada, e que as pessoas ainda sejam livres para cometer seus próprios erros e sofrer suas consequências, com a AGI fornecendo mais como uma rede de segurança básica.
  
  
• 00:25:00 Nesta seção, o cientista-chefe da OpenAI, Ilya Sutskever, discute hardware em IA e desmascara a crença de que o TPU personalizado do Google oferece uma vantagem sobre as GPUs. Ele explica que, fundamentalmente, a arquitetura de TPUs e GPUs são muito semelhantes e a única coisa que importa sobre o hardware é o custo por flop e o custo geral dos sistemas. Sutskever também compartilha ideias sobre o trabalho envolvido no desenvolvimento da IA, que envolve entender o sistema e os resultados, não apenas apresentar novas ideias. Ele também fala sobre a parceria da OpenAI com a Microsoft e como o ecossistema de IA é vulnerável a contratempos como um desastre natural em Taiwan.
  
  
• 00:30:00 Nesta seção, Ilya Sutskever discute o potencial do custo de inferência se tornar uma barreira para o avanço dos modelos de IA. Ele sugere que a utilidade do modelo determinará se o custo é proibitivo ou não, observando que diferentes clientes já usam redes neurais diferentes de tamanhos diferentes, dependendo do caso de uso. Ele também aborda preocupações sobre governos estrangeiros tentando aprender sobre os modelos e a importância da confiabilidade e controlabilidade como propriedades emergentes. Embora prever capacidades específicas não seja simples, ele acredita que haverá progresso na melhoria dos modelos, tornando-os mais confiáveis e mais capazes de resolver problemas.
  
  
• 00:35:00 Nesta seção, Ilya Sutskever discute as leis de escala da IA e o vínculo entre a precisão da previsão da próxima palavra e a capacidade de raciocínio. Embora considere as leis de escala importantes, ele acredita que outras coisas podem dar mais raciocínio por unidade de esforço. Ele também enfatiza o valor da contribuição humana nos modelos de ensino, bem como a relação entre a existência de dados, GPUs e transformadores, sugerindo que seu desenvolvimento está interligado. Além disso, Sutskever expressa sua crença de que a revolução do aprendizado profundo teria ocorrido eventualmente, independentemente de quem fossem os pioneiros, e admite a dificuldade de alinhar modelos que poderiam potencialmente deturpar suas intenções.
  
  
• 00:40:00 Nesta seção, Ilya Sutskever discute o potencial da pesquisa acadêmica para obter insights importantes sobre os recursos de IA, mas reconhece que atualmente parece mais fácil para as empresas realizar esses recursos. Ele também observa que o impacto dos modelos de linguagem pode ir além do mundo dos bits e chegar ao mundo dos átomos, dependendo das ações que eles provocam. Sutskever acredita que os avanços necessários para a IA sobre-humana podem não parecer necessariamente avanços em retrospectiva, e que pode ser importante ser inspirado por humanos e pelo cérebro, mas também ciente das qualidades não essenciais que podem desviar a pesquisa.
  
  
• 00:45:00 Nesta seção, Ilya Sutskever responde à pergunta final sobre por que há uma forte correlação entre ser o primeiro na revolução do aprendizado profundo e ainda ser um dos principais pesquisadores. Ele acredita que a perseverança é uma condição necessária, mas não suficiente para o sucesso. Muitas coisas precisam se encaixar e é preciso ter a maneira certa de ver as coisas. É uma pergunta difícil de responder, mas ele continuou tentando muito, e acabou sendo suficiente até agora.

[MetaQuotes]

Lição 1: aprendizado profundo prático para codificadores 2022

Lição 1: aprendizado profundo prático para codificadores 2022

Neste vídeo do YouTube "Lesson 1: Practical Deep Learning for Coders 2022", o instrutor apresenta o curso, destacando o ritmo acelerado de mudança no aprendizado profundo e demonstra a facilidade de criar um sistema "pássaro ou não pássaro" usando Python. O curso visa mostrar às pessoas como construir e implantar modelos primeiro, em vez de começar com uma revisão de álgebra linear e cálculo, e cobrirá uma variedade de modelos de aprendizado profundo, incluindo algoritmos baseados em imagens que podem classificar sons ou movimentos do mouse. O instrutor enfatiza a importância da criação de blocos de dados, da compreensão dos detectores de recursos e do uso de modelos pré-treinados para reduzir os requisitos de codificação. O curso também abrange segmentação e análise tabular, com fast.ai fornecendo práticas recomendadas que ajudam a reduzir a codificação e melhorar os resultados.

O vídeo fornece uma introdução ao aprendizado profundo e suas aplicações em vários campos. O apresentador discute os fundamentos do aprendizado de máquina, incluindo o processo de treinamento do modelo e a importância de calcular a perda para atualizar o peso do modelo para um melhor desempenho. A lição abrange dois modelos: aprendizagem tabular e filtragem colaborativa. O apresentador também destaca a utilidade dos notebooks Jupyter na criação e compartilhamento de código, incluindo exemplos de projetos de alunos anteriores que levaram a novas startups, artigos científicos e ofertas de emprego. O principal argumento é que os aspirantes a aprendizes profundos devem experimentar e compartilhar seu trabalho com a comunidade para obter feedback e experiência valiosos.

• 00:00:00 Nesta seção, o instrutor apresenta a primeira lição do Practical Deep Learning for Coders versão 5, destacando o quanto mudou desde a última atualização do curso. Ele usa uma história em quadrinhos XKCD do final de 2015 como um exemplo de como as coisas estão evoluindo rapidamente no campo do aprendizado profundo. Posteriormente, ele demonstra a criação de um sistema "pássaro ou não pássaro" usando Python, que envolve baixar e redimensionar imagens de pássaros e florestas, criar um bloco de dados usando fast.ai e exibir algumas das imagens baixadas. O instrutor enfatiza que o curso fornecerá muito mais detalhes e que o objetivo desta seção é fornecer uma visão geral rápida de alto nível.
  
  
• 00:05:00 Nesta seção, o apresentador faz uma demonstração de como é fácil criar um modelo de visão computacional e identificar se uma imagem contém um pássaro ou uma floresta com apenas 200 fotos de cada um. O que costumava ser quase impossível agora se tornou facilmente acessível com o aprendizado profundo, e o apresentador compartilha o exemplo do DALLꞏEꞏ2, um algoritmo que gera novas imagens a partir de texto simples. Esses avanços recentes em aprendizado profundo são uma prova da rapidez com que esse campo se move, e o apresentador observa que é acessível sem exigir muito código, matemática ou qualquer coisa além de um laptop.
  
  
• 00:10:00 Nesta seção, o palestrante discute os recursos dos modelos de aprendizado profundo e como eles estão realizando tarefas que antes eram consideradas impossíveis para computadores. Eles mencionam como o aprendizado profundo está sendo usado em modelos de arte e linguagem, como o modelo de linguagem de caminhos do Google que pode explicar a resposta para uma piada. O palestrante também reconhece a necessidade de considerações éticas no aprendizado profundo e recomenda a verificação de um curso de ética de dados em Ethics.fast.ai. Eles então apresentam uma versão online do sistema de copos coloridos para verificar como os alunos estão se saindo e agradecem a Radek por criá-lo, que acaba de anunciar que conseguiu o emprego dos seus sonhos na Nvidia AI.
  
  
• 00:15:00 Nesta seção do vídeo, o instrutor enfatiza a importância do contexto na aprendizagem, principalmente no campo da aprendizagem profunda. Em vez de começar com uma revisão de álgebra linear e cálculo, o instrutor acredita que as pessoas aprendem de forma mais eficaz quando recebem um contexto. Ele usa a analogia do aprendizado de esportes, em que é mostrado um jogo inteiro de esportes e, gradualmente, junta-se mais peças. Esta é a abordagem que ele adota neste curso, onde você aprenderá a construir e implantar modelos primeiro e, posteriormente, aprofundar-se nas aulas mais sofisticadas e tecnicamente detalhadas. O instrutor também discute suas credenciais e experiência em aprendizado de máquina, incluindo a escrita do popular livro "Deep Learning for Coders".
  
  
• 00:20:00 Nesta seção, o instrutor explica a abordagem histórica da visão computacional antes da introdução das redes neurais. Ele descreve como modelos anteriores de aprendizado de máquina dependiam de especialistas para criar recursos que ditavam como o algoritmo identificaria objetos. O instrutor compara isso com redes neurais que aprendem esses recursos por conta própria, permitindo um desenvolvimento e treinamento de modelos muito mais rápidos. O instrutor observa que a capacidade das redes neurais de aprender seus próprios recursos e se adaptar a novos dados é a chave para o sucesso do aprendizado profundo nos últimos anos.
  
  
• 00:25:00 Nesta seção, o instrutor explica o conceito de detectores de recursos em aprendizado profundo, que são camadas de redes neurais que podem identificar e extrair recursos específicos de imagens sem intervenção humana. Ele ilustrou como esses detectores de recursos podem ser combinados para reconhecer imagens mais complexas e sofisticadas. Além disso, o instrutor enfatiza a versatilidade dos algoritmos baseados em imagens e como eles podem ser usados para classificar sons ou até mesmo movimentos do mouse. Por fim, ele desmascara o mito de que o aprendizado profundo requer muitos dados, computadores caros e matemática extensa, afirmando que o aprendizado por transferência permite um trabalho de última geração usando recursos mínimos.
  
  
• 00:30:00 Nesta seção, o instrutor discute a popularidade do Pytorch versus Tensorflow no mundo do aprendizado profundo, com o Pytorch crescendo rapidamente e superando o Tensorflow em repositórios de pesquisa e entre pesquisadores. No entanto, ele observa que o Pytorch pode exigir muito código para tarefas relativamente simples, e é aí que a biblioteca fast.ai é útil. A biblioteca fast.ai é construída sobre o Pytorch e fornece as melhores práticas que ajudam a reduzir a quantidade de código necessária e melhorar os resultados. O instrutor também apresenta o notebook Jupyter, um aplicativo baseado na Web amplamente utilizado na indústria, na academia e no ensino de ciência de dados, e menciona servidores em nuvem como o Kaggle, que podem ser usados para executar notebooks Jupyter.
  
  
• 00:35:00 Nesta seção do vídeo, o instrutor apresenta como usar notebooks Jupyter para codificar, experimentar e explorar com exemplos. Ele explica como editar ou copiar o notebook de outra pessoa, iniciar um computador virtual para executar códigos, usar atalhos de teclado, escrever prosa ou marcações e inserir imagens no notebook. O curso também cobre a versão mais recente do fast.ai e um pouco de código Python. Por meio dos notebooks Jupyter, os desenvolvedores podem exibir seu código e tornar seu trabalho acessível a outras pessoas na comunidade de código aberto.
  
  
• 00:40:00 Nesta seção, o palestrante discute o uso de bibliotecas externas e apresenta algumas das bibliotecas fast.ai, como "fastdownload" e "resize_images". Eles também explicam a importância do comando de bloco de dados, que é usado para inserir os dados no modelo. O bloco de dados tem cinco parâmetros principais para especificar, incluindo o tipo de entrada, tipo de saída, tipo de rótulo e de quais itens precisamos treinar. O palestrante enfatiza que a compreensão do bloco de dados é crucial para os profissionais de aprendizado profundo, pois o ajuste da arquitetura de rede neural raramente ocorre na prática, e este curso é focado no aprendizado profundo prático.
  
  
• 00:45:00 Nesta seção, o palestrante explica as etapas envolvidas na criação de um bloco de dados, que é fundamental para o sucesso de um modelo de aprendizado profundo. O bloco de dados é responsável por encontrar imagens para treinar usando uma função que recupera todos os arquivos de imagem em um caminho especificado, reservando alguns dados para teste e redimensionando as imagens para um tamanho padrão. A criação de um bloco de dados é seguida pela criação de carregadores de dados, que fornecem um fluxo de lotes de dados que podem ser processados pelo modelo. O palestrante também apresenta o conceito de aprendiz, que combina o modelo e os dados e é essencial para treinar um modelo de aprendizado profundo.
  
  
• 00:50:00 Nesta seção, o instrutor discute como usar modelos pré-treinados em fast.ai para tarefas de visão computacional usando a biblioteca de modelos de imagem pytorch (timm). A família de modelos resnet é suficiente para a maioria dos casos de uso, mas existem muitos outros modelos disponíveis para uso. O instrutor demonstra como ajustar o modelo para uma tarefa específica, como reconhecer imagens de pássaros em uma floresta e como implantar o modelo usando o método predict(). O instrutor também observa que existem muitos outros tipos de modelos disponíveis além da visão computacional, incluindo a segmentação.
  
  
• 00:55:00 Nesta seção, o palestrante explica a segmentação, que é usada para colorir cada pixel de uma imagem de acordo com o que ela representa. Usando uma pequena quantidade de dados e código mínimo, o palestrante mostra como um modelo pode ser treinado para segmentar imagens de cenas de estradas em diferentes categorias, como carros, cercas e edifícios em apenas 20 segundos, com um modelo treinado quase perfeito após 2 minutos. O palestrante explica que classes especiais de carregadores de dados podem ser usadas para manipulação de dados, exigindo ainda menos código para conjuntos de dados que ocorrem com frequência. O palestrante passa a explicar a análise tabular e como ela é amplamente utilizada em setores como a previsão de colunas de planilhas e tabelas de dados. Ao fornecer informações semelhantes aos blocos de dados e usar o type dispatch, você pode usar o fast.ai para fazer automaticamente a coisa certa para seus dados, independentemente do tipo de dados.
  
  
• 01:00:00 Nesta seção, a lição abrange dois tipos de modelos: aprendizagem tabular e filtragem colaborativa. Os modelos tabulares são usados para dados sem modelo pré-treinado, onde as tabelas de dados variam amplamente. A Filtragem Colaborativa é a base para a maioria dos sistemas de recomendação e funciona encontrando usuários semelhantes com base em quais produtos eles gostam. Um conjunto de dados de filtragem colaborativa terá um ID de usuário, um ID de produto (como um filme) e uma classificação. A lição continua mostrando como criar carregadores de dados de filtragem colaborativa e discute as diferenças entre ajuste fino e ajuste de um modelo.
  
  
• 01:05:00 Nesta seção, o palestrante fala sobre a utilidade dos notebooks Jupyter como ferramenta de criação e compartilhamento de código, incluindo o fato de que toda a biblioteca fast.ai é escrita em notebooks. Além disso, o palestrante aborda o estado atual do aprendizado profundo e suas aplicações em vários campos, incluindo PNL, visão computacional, medicina, sistemas de recomendação, jogos e robótica. O palestrante observa que o aprendizado profundo foi capaz de quebrar resultados de ponta em muitos campos e que geralmente é bom em tarefas que um ser humano pode realizar razoavelmente rapidamente.
  
  
• 01:10:00 Nesta seção, o apresentador explica a ideia básica do aprendizado de máquina, começando com um programa normal que possui entradas e resultados codificados com condicionais, loops e variáveis. O programa é então substituído por um modelo que contém pesos aleatórios, e o modelo é uma função matemática que recebe entradas e as multiplica pelos pesos. O modelo é essencialmente inútil a menos que os pesos sejam escolhidos com cuidado, então é necessário calcular a perda, que é um número que mede a qualidade dos resultados, e atualizar os pesos para criar um novo conjunto um pouco melhor que o conjunto anterior. Este processo é crítico para melhorar o desempenho do modelo.
  
  
• 01:15:00 Nesta seção, o palestrante explica o processo de treinamento de um modelo em aprendizado de máquina, que envolve a repetição de uma sequência simples de etapas que usam redes neurais para produzir saída enquanto substitui negativos por zeros. Em teoria, o modelo pode resolver qualquer função computável se tiver tempo, dados e entradas suficientes, e o modelo treinado pode ser integrado a qualquer programa como outro pedaço de código que mapeia entradas para resultados. Os programadores Python provavelmente aceitarão o processo facilmente, mas aqueles que não estão familiarizados ainda podem experimentar os notebooks Kaggle e tentar coisas diferentes, como modificar o exercício do pássaro ou da floresta, tentar três ou quatro categorias e compartilhar seu trabalho nos fóruns. O mais importante é experimentar e ler o capítulo 1 do livro para estar preparado para a próxima lição.
  
  
• 01:20:00 Nesta seção do vídeo, o instrutor compartilha vários exemplos de projetos que ex-alunos trabalharam no curso "Practical Deep Learning for Coders", que levaram a novas startups, artigos científicos e ofertas de emprego. Esses projetos incluem a classificação de diferentes tipos de pessoas com base em onde vivem, a criação de um classificador de abobrinha e pepino, a classificação precisa de imagens de satélite em 110 cidades diferentes e o reconhecimento do estado dos edifícios para esforços de resiliência a desastres. Alguns alunos até superaram o estado da arte em seus respectivos campos, como um classificador de som e sequenciamento normal de tumor. O instrutor incentiva os alunos atuais e futuros a começar a criar projetos, independentemente do nível de experiência, e a compartilhá-los no fórum para feedback e incentivo.

[MetaQuotes]

Lição 2: aprendizado profundo prático para codificadores 2022

Lição 2: aprendizado profundo prático para codificadores 2022

Esta série de vídeos do YouTube fornece uma introdução ao aprendizado profundo para codificadores. Abrange tópicos como preparação de dados, criação de modelo e implantação de um modelo de aprendizado de máquina.

Neste vídeo, o hacker Jeremy Howard ensina as pessoas a criar seus próprios aplicativos da Web usando aprendizado profundo. Ele aborda como configurar um projeto no Git, como usar o espaço de abraços para carregar um modelo a ser treinado, processamento de linguagem natural e como reconhecer texto.

• 00:00:00 Esta lição aborda o aprendizado profundo prático para codificadores em 2022. Novas técnicas de ponta estão sendo ensinadas para ajudar os alunos a se lembrarem melhor do material. O curso acompanha o livro e questionários estão disponíveis para ajudar os alunos a testar seu progresso.
  
  
• 00:05:00 Este vídeo aborda os fundamentos do aprendizado profundo para codificação, incluindo como encontrar dados, limpeza de dados e colocar um modelo em produção. O próximo vídeo da série mostrará como fazer isso.
  
  
• 00:10:00 Neste vídeo, Wes discute como treinar um modelo em aprendizado profundo usando o site ddg. Ele mostra como procurar objetos e como redimensionar imagens.
  
  
• 00:15:00 Neste vídeo é apresentada uma técnica de deep learning: RandomResizedCrop. Isso é usado para melhorar a precisão do reconhecimento de imagens. O aumento de dados também é discutido e é mostrado que, se você deseja treinar um modelo de aprendizado profundo por mais de cinco ou dez épocas, deve usar RandomResizedCrop e "aug_transforms".
  
  
• 00:20:00 Este vídeo do YouTube demonstra como usar um objeto de interpretação do classificador para determinar onde uma perda é alta em um conjunto de dados. Essas informações podem ser usadas para limpar os dados antes de serem usadas para treinar um modelo.
  
  
• 00:25:00 O vídeo apresenta a limpeza de dados e aprendizado profundo prático para codificadores 2022. Abrange a preparação de dados com ferramentas como limpeza de dados acelerada por GPU e HuggingFace Spaces, seguida pelo uso do Gradio para modelos de aprendizado de máquina em produção.
  
  
• 00:30:00 Este vídeo aborda como usar o Git para gerenciar seu código e como usar um terminal para trabalhar no código. O vídeo também explica como usar o VS Code para editar o código.
  
  
• 00:35:00 Este tutorial explica como criar um modelo de aprendizado profundo usando alguns métodos diferentes, incluindo um exemplo Kaggle e um exemplo Colab. Depois que o modelo é criado, ele pode ser baixado e copiado no mesmo diretório do código.
  
  
• 00:40:00 Nesta lição, o autor mostra como usar um aluno treinado para prever se uma imagem é um cachorro ou um gato. O aluno está congelado no tempo e pode ser carregado e descarregado facilmente.
  
  
• 00:45:00 Este vídeo explica como criar uma interface Gradio para converter imagens em classificações e como criar um script Python para fazer isso.
  
  
• 00:50:00 Nesta lição, o instrutor demonstra como criar um modelo PyTorch simples e carregá-lo no Gradio. Ele também fornece instruções sobre como usar o fastsetup para instalar notebooks PyTorch e Jupyter em um computador.
  
  
• 00:55:00 Este vídeo fornece instruções para instalar o python e algumas das bibliotecas necessárias para aprendizado profundo, incluindo Pytorch e Numpy. O autor recomenda usar uma distribuição python baseada em conda, como mambaforge, em vez do sistema python. Por fim, o autor recomenda a instalação do nbdev para usar o Jupyter Notebook.
  
  
• 01:00:00 Nesta lição, o instrutor demonstra como usar o Gradio, uma plataforma gratuita para treinamento de modelos de aprendizado profundo, para criar um site que prevê os nomes de cães e gatos. Embora o streamlit seja mais flexível que o Gradio, ambas as plataformas são gratuitas e fáceis de usar.
  
  
• 01:05:00 Este vídeo explica como criar modelos de aprendizagem profunda usando Javascript. O tutorial inclui uma versão de vários arquivos e uma versão HTML do mesmo modelo.
  
  
• 01:10:00 Este vídeo explica como criar um aplicativo básico de aprendizado profundo usando apenas Javascript e um navegador. Depois que o aplicativo é criado, você pode usar o FastPages para criar um site para ele que se pareça com o aplicativo.
  
  
• 01:15:00 Neste vídeo, o hacker Jeremy Howard ensina as pessoas a criar seus próprios aplicativos da web usando aprendizado profundo. Ele primeiro discute como configurar um projeto simples no Git e, em seguida, mostra como usar o espaço de abraços para carregar um modelo a ser treinado. Em seguida, ele discute o processamento de linguagem natural, explicando como os modelos funcionam nos bastidores. Por fim, ele demonstra como o aprendizado profundo pode ser usado para reconhecer texto.

[MetaQuotes]

Lição 3: aprendizado profundo prático para codificadores 2022

Lição 3: aprendizado profundo prático para codificadores 2022

Este vídeo fornece uma introdução ao aprendizado profundo prático para codificadores. Ele cobre os fundamentos da multiplicação de matrizes e gradientes e demonstra como usar um modelo de aprendizado profundo para prever a probabilidade de raças de cães e gatos. Este vídeo fornece uma breve introdução ao aprendizado profundo para codificadores, incluindo uma discussão de como a multiplicação de matrizes pode levar muito tempo para ser intuitiva. A próxima lição se concentrará no processamento de linguagem natural, que trata de pegar dados de texto e fazer previsões com base em sua prosa.

• 00:00:00 Esta lição abrange multiplicações e gradientes de matrizes e destina-se a alunos com inclinação matemática. O curso também inclui uma "Lição Zero" sobre como configurar uma máquina Linux do zero.
  
  
• 00:05:00 O vídeo desta semana apresenta cinco alunos que criaram diferentes projetos relacionados ao aprendizado profundo. Um aluno criou um detector da Marvel, outro criou um jogo onde o computador sempre perde, outro criou um aplicativo para prever temperaturas médias, outro criou um classificador de movimentos artísticos e, por último, um aluno criou um detector de redação.
  
  
• 00:10:00 Este vídeo aborda aprendizado profundo prático para codificadores, incluindo o uso de diferentes plataformas e bibliotecas de aprendizado profundo. Abrange como treinar um modelo e implantá-lo em um ambiente de produção.
  
  
• 00:15:00 Nesta lição, o aluno explica como funciona o aprendizado profundo e como usar diferentes modelos de aprendizado profundo. Ele também mostra como usar um modelo de aprendizado profundo para prever a probabilidade de raças de cães e gatos.
  
  
• 00:20:00 Neste vídeo, um modelo de aprendizado profundo é demonstrado. O modelo consiste em camadas, cada uma contendo código e parâmetros. O modelo é flexível e pode ser treinado para reconhecer padrões nos dados.
  
  
• 00:25:00 Nesta lição, o instrutor mostra como criar uma função para ajustar um conjunto de dados usando a aplicação parcial de uma função. Em seguida, ele demonstra como plotar a função e como ajustar os coeficientes da função para ajustá-la melhor aos dados.
  
  
• 00:30:00 Este vídeo explica como melhorar a capacidade de um computador prever valores usando uma função de perda. O autor demonstra como fazer isso movendo os controles deslizantes em um modelo gráfico baseado em controles deslizantes e verificando a função de perda para ver se ela melhora ou piora. O Pytorch pode calcular automaticamente o gradiente para você, tornando o processo rápido e fácil.
  
  
• 00:35:00 Neste vídeo, o programador Pytorch explica como usar a função gradiente para ajustar os coeficientes de uma equação quadrática. A função gradiente retorna o negativo da inclinação da curva à qual é aplicada.
  
  
• 00:40:00 Este vídeo explica como criar um modelo de aprendizado profundo usando o Pytorch. O modelo é otimizado usando gradiente descendente e os coeficientes finais são determinados pela função matemática rectified_linear().
  
  
• 00:45:00 Neste vídeo, Jeremy explica como usar o gradiente descendente para otimizar parâmetros em modelos de aprendizado profundo. Essa é a mesma técnica usada para treinar os modelos na vida real.
  
  
• 00:50:00 Este vídeo do YouTube aborda o aprendizado profundo prático para codificadores e como treinar modelos para precisão e velocidade. Ele aconselha começar com um modelo preciso e bem ajustado e adicionar gradualmente mais dados para ver se a precisão melhora.
  
  
• 00:55:00 Neste vídeo, o autor discute como calcular o gradiente de uma função usando derivadas. O autor recomenda multiplicar o gradiente por um número pequeno, chamado de taxa de aprendizado, para evitar saltos muito longos ao longo do gradiente e divergir.
  
  
• 01:00:00 Nesta lição, o instrutor mostra como fazer a multiplicação de matrizes para realizar cálculos de aprendizado profundo em dados reais. Ele fornece um site que fornece uma maneira fácil de fazer isso.
  
  
• 01:05:00 O palestrante explica como usar o aprendizado profundo para prever se os passageiros do verdadeiro Titanic sobreviveram ou não. Eles primeiro removem as colunas que não são relevantes para a previsão e depois multiplicam cada linha por um coeficiente correspondente à variável dependente. Em seguida, eles criam uma coluna chamada "eles embarcaram em Southampton?" e outra coluna chamada "eles embarcaram em Cherbourg?" e convertê-los em variáveis categóricas binárias. Finalmente, eles pegam a média de todos os coeficientes e a utilizam para prever a variável dependente.
  
  
• 01:10:00 Esta lição explica como aplicar aprendizado profundo a problemas de codificação usando uma regressão linear. Primeiro, os dados são normalizados e transformados em log para torná-los mais uniformemente distribuídos. Em seguida, os coeficientes são calculados usando uma função SumProduct no Excel. Finalmente, a descida do gradiente é usada para otimizar a função de perda.
  
  
• 01:15:00 Neste vídeo, um modelo de aprendizado profundo é criado do zero usando o Microsoft Excel. O modelo funciona melhor do que uma regressão ao prever as taxas de sobrevivência, mas é mais lento e mais difícil de executar. a multiplicação de matrizes é usada para acelerar o processo.
  
  
• 01:20:00 Este vídeo fornece uma breve introdução ao aprendizado profundo para codificadores, incluindo uma discussão sobre como a multiplicação de matrizes pode levar muito tempo para ser intuitiva. A próxima lição se concentrará no processamento de linguagem natural, que trata de pegar dados de texto e fazer previsões com base em sua prosa.
  
  
• 01:25:00 Este vídeo fornece um guia passo a passo sobre como usar o aprendizado profundo para classificação em idiomas diferentes do inglês.
  
  
• 01:30:00 Neste vídeo, o apresentador discute a importância dos conjuntos e métricas de validação no aprendizado profundo.

[MetaQuotes]

Lição 4: aprendizado profundo prático para codificadores 2022

Lição 4: aprendizado profundo prático para codificadores 2022

Este vídeo explica como construir um modelo de aprendizagem profunda para a competição Coders 2022. O autor aborda como criar um conjunto de validação, como usar dados de competição para testar o desempenho do seu modelo e como evitar o overfitting em configurações do mundo real. Neste vídeo, Jeremy explica como usar o coeficiente de correlação de Pearson para medir a relação entre duas variáveis e como usar o Pytorch para treinar um modelo que se comporta como um aprendiz fast.ai. Ele também discute um problema com previsões geradas pelas técnicas de PNL e como ele pode ser resolvido usando uma função sigmoide.

• 00:00:00 Este vídeo explica como ajustar um modelo de processamento de linguagem natural pré-treinado usando uma biblioteca diferente da fast.ai.
  
  
• 00:05:00 Este vídeo aborda o algoritmo Practical Deep Learning for Coders 2022, ULMFiT. ULMFiT foi um algoritmo de aprendizado de máquina que foi apresentado pela primeira vez em um curso fast.ai. O ULMFiT foi posteriormente transformado em um artigo acadêmico pelo autor. Depois de treinar na Wikipedia e nas resenhas de filmes do IMDB, o algoritmo foi capaz de prever o sentimento de uma resenha com 70% de precisão.
  
  
• 00:10:00 Nesta lição, Jeremy explicou os fundamentos da abordagem do modelo de linguagem mascarada Transformers para aprendizado de máquina. Ele observou que esta abordagem é mais popular do que a abordagem ULMFiT e que existem cinco camadas no modelo do transformador. John fez uma pergunta sobre como passar de um modelo que prevê a próxima palavra para um modelo que pode ser usado para classificação. Jeremy disse que você precisaria de detectores de borda e detectores de gradiente nas primeiras camadas e que a última camada teria ativações para cada categoria que você está prevendo. Ele disse que você pode treinar esse modelo adicionando gradualmente uma nova matriz aleatória ao final.
  
  
• 00:15:00 A competição Kaggle "US Patent Phrase to Phrase Matching Competition" requer um modelo que possa determinar automaticamente quais âncoras e pares de alvos estão falando sobre a mesma coisa. Neste vídeo, o apresentador sugere transformar os dados em um problema de classificação para fazer uso de técnicas de PNL.
  
  
• 00:20:00 Este vídeo explica como usar o aprendizado profundo para classificação de forma prática, trabalhando com um conjunto de dados que já está armazenado em um formato de valores separados por vírgula (CSV). O vídeo também aborda como usar pandas para ler os dados.
  
  
• 00:25:00 Este vídeo aborda o uso de quatro bibliotecas para aprendizado profundo - numpy, matplotlib, pandas e pytorch. O autor recomenda a leitura de "Python for Data Analysis" de Wes McKinney se você não estiver familiarizado com essas bibliotecas. A primeira etapa no treinamento de uma rede neural é tokenizar os dados e a segunda etapa é treinar a rede.
  
  
• 00:30:00 Neste vídeo, o apresentador explica como tokenizar um texto em tokens e numerar os tokens para criar um "conjunto de dados" de cara de abraço. O apresentador recomenda o uso de um modelo pré-treinado para tokenização e descreve alguns dos diferentes modelos disponíveis.
  
  
• 00:35:00 Neste vídeo, o apresentador explica como usar um tokenizador para tokenizar uma frase e como transformar os tokens em números. O conjunto de dados será o mesmo que o conjunto de dados original, mas o conjunto de dados tokenizados será diferente devido ao tokenizador.
  
  
• 00:40:00 O vídeo discute como transformar sequências de texto em números para permitir o aprendizado profundo e explica que não é necessário seguir um formato definido, desde que as informações sejam fornecidas. Se um campo for particularmente longo, pode ser útil usar uma abordagem de transformador.
  
  
• 00:45:00 Neste vídeo, o autor explica a importância de ter conjuntos separados de treinamento, validação e teste para aprendizado de máquina. Eles mostram como plotar uma regressão polinomial e ilustram a diferença entre underfit e overfit.
  
  
• 00:50:00 O vídeo explica como criar um bom conjunto de validação para um modelo de aprendizado profundo e como usar dados de competição para testar o desempenho do seu modelo. Ele também discute como evitar o overfitting em configurações do mundo real.
  
  
• 00:55:00 Neste vídeo, aprendemos sobre aprendizado profundo e como construir modelos para as competições Coders 2022. Aprendemos que um conjunto de validação é um conjunto de imagens que não são usadas para treinar o modelo e que um conjunto de teste é outro conjunto de validação usado para medir a precisão. Também aprendemos que há dois conjuntos de teste - aquele que é mostrado na tabela de classificação durante a competição e um segundo conjunto de teste que não é exibido até o término da competição.
  
  
• 01:00:00 O "coeficiente de correlação de Pearson" é uma medida amplamente usada de quão semelhantes são duas variáveis. Se suas previsões forem muito semelhantes aos valores reais, o "coeficiente de correlação de Pearson" será alto.
  
  
• 01:05:00 Este vídeo de 1 minuto explica como usar o coeficiente de correlação de Pearson para medir a relação entre duas variáveis. O coeficiente de correlação é uma medida de quão próximas duas variáveis estão relacionadas e pode ser usado para avaliar a força de uma relação entre duas variáveis. O coeficiente de correlação pode ser visualizado usando um gráfico de dispersão e pode ser útil para avaliar o conjunto de dados para o qual está sendo usado.
  
  
• 01:10:00 Neste vídeo, o apresentador discute como treinar adequadamente um modelo de aprendizado profundo. Eles cobrem tópicos como correlação, valores discrepantes e como dividir os dados corretamente. Eles então mostram como treinar o modelo com um “aluno” em fast.ai e como usar “tamanho do lote” e “épocas” para controlar quantas linhas são processadas de uma só vez.
  
  
• 01:15:00 Os transformadores Hugging Face fornecem uma variedade de taxas de aprendizado para diferentes tarefas e fornecem um modelo apropriado para classificar sequências de um modelo pré-treinado. Ele também pode identificar outliers nos dados.
  
  
• 01:20:00 Nesta lição, o instrutor explica como usar o Pytorch para treinar um modelo que se comporta como um aprendiz fast.ai. Ele observa que, embora os outliers nunca devam ser excluídos, eles podem ser investigados e, se necessário, corrigidos.
  
  
• 01:25:00 Deep Learning é uma tecnologia poderosa que está sendo usada em várias áreas de aplicação. É relativamente amigável para iniciantes, e a área de processamento de linguagem natural (PNL) é onde estão as maiores oportunidades. Um uso possível para o aprendizado profundo da PNL é criar prosa apropriada ao contexto para a mídia social, o que pode ter implicações em como as pessoas veem o mundo.
  
  
• 01:30:00 Neste vídeo, John explica como as técnicas de PNL, como o aprendizado de máquina, podem ser usadas para gerar texto que é tendencioso em favor de um ponto de vista específico. O vídeo também discute um problema com previsões geradas pelas técnicas de PNL e como ele pode ser resolvido usando uma função sigmoide.

[MetaQuotes]

Lição 5: aprendizado profundo prático para codificadores 2022

Lição 5: aprendizado profundo prático para codificadores 2022

Este vídeo fornece um tutorial sobre como construir e treinar um modelo linear usando aprendizado profundo. O vídeo começa discutindo as operações no local, que alteram os valores das variáveis em uma determinada função. A seguir, o vídeo demonstra como calcular a perda de um modelo linear usando gradiente descendente para trás. Finalmente, o vídeo fornece uma função que inicializa e atualiza os coeficientes dentro de um modelo linear. O vídeo conclui demonstrando como executar a função e imprimir a perda. Este vídeo explica como calcular a melhor divisão binária para uma determinada coluna em um conjunto de dados. Isso é particularmente útil para competições de aprendizado de máquina, pois fornece um modelo de linha de base para comparação.

• 00:00:00 Esta lição aborda o modelo linear e a rede neural desde o início usando o Jupyter Notebook. O objetivo é entender a lógica por trás do código e obter a saída esperada.
  
  
• 00:05:00 O vídeo discute o aprendizado profundo prático para codificadores, abordando tópicos como como instalar o Kaggle e usar sua variável de ambiente, como ler arquivos CSV com pandas e como imputar valores ausentes. Ele também cobre conceitos básicos em pandas, como o modo e como usar métodos e reduções para preencher dataframes.
  
  
• 00:10:00 Nesta lição, Jeremy aborda como imputar valores ausentes em um conjunto de dados usando o método fillna() em pandas. Ele explica que, na maioria dos casos, essa maneira "burra" será boa o suficiente e que é importante conhecer os fundamentos do nosso conjunto de dados para que os métodos comuns não sejam explicados várias vezes. Javier pergunta sobre os prós e contras de descartar campos que não são usados no modelo.
  
  
• 00:15:00 Nesta lição, o instrutor apresenta o conceito de "variáveis fictícias" e como elas podem ser usadas para representar dados categóricos de maneira mais sensata. Ele também mostra como descrever todas as variáveis numéricas e não numéricas nos dados.
  
  
• 00:20:00 Neste vídeo, o instrutor mostra como transformar uma coluna em um dataframe em um tensor e como usar esses tensores para treinar um modelo linear e uma rede neural. Ele também mostra como usar o Pytorch em vez do Python simples ao fazer a multiplicação de matrizes e elementos.
  
  
• 00:25:00 Neste vídeo, o instrutor discute como executar um produto vetorial de matriz em Python. Ele fornece um exemplo de multiplicação de uma matriz por um vetor e explica que o resultado é interessante porque os matemáticos podem realizar a mesma operação usando álgebra de matrizes. Ele também explica que iniciar uma sequência pseudo-aleatória é importante para produzir resultados reprodutíveis.
  
  
• 00:30:00 Neste vídeo, o autor explica como funciona a transmissão e por que ela é útil. Broadcasting é uma técnica que permite multiplicar vários valores entre si, levando em consideração o tamanho de cada valor. Isso permite que o código seja mais conciso e mais rápido para ser executado na GPU.
  
  
• 00:35:00 Este vídeo explica como otimizar modelos de aprendizado profundo calculando a perda de descida do gradiente. O autor demonstra como fazer isso criando uma função para calcular a perda e, em seguida, importando a função para uma sessão Pytorch.
  
  
• 00:40:00 Este vídeo do YouTube fornece um tutorial sobre como construir e treinar um modelo linear usando aprendizado profundo. O vídeo começa discutindo as operações no local, que alteram os valores das variáveis em uma determinada função. A seguir, o vídeo demonstra como calcular a perda de um modelo linear usando gradiente descendente para trás. Finalmente, o vídeo fornece uma função que inicializa e atualiza os coeficientes dentro de um modelo linear. O vídeo conclui demonstrando como executar a função e imprimir a perda.
  
  
• 00:45:00 Este vídeo de 1 minuto discute como criar uma função de precisão para um modelo de aprendizado profundo que prevê quem sobreviveu ao Titanic. A função é baseada na função sigmóide, que é uma função matemática que assume uma assíntota quando os números ficam muito grandes ou muito pequenos.
  
  
• 00:50:00 Neste vídeo, John explica como otimizar uma rede neural usando uma função sigmoide. Ele também explica como lidar com variáveis dependentes de bloco de categoria usando fast.ai.
  
  
• 00:55:00 Neste vídeo, o autor explica como criar um modelo do zero em Python usando o Pytorch e como enviar o modelo para o Kaggle. O autor menciona que o operador "matrix-multiply" significa matriz-multiplicação, mas que o Python não vem com uma implementação do operador.
  
  
• 01:00:00 Neste vídeo, o apresentador explica como criar uma rede neural usando o Pytorch. O primeiro passo é criar uma matriz com as somas dos coeficientes da primeira coluna. Essa matriz é então multiplicada pelo vetor de dados de treinamento. O segundo passo é criar uma segunda matriz com as ativações ocultas. Esta matriz é então multiplicada pelos coeficientes da primeira coluna. A etapa final é centralizar os vetores e treinar a rede neural.
  
  
• 01:05:00 Neste vídeo, Jeremy explica como treinar uma rede neural usando aprendizado profundo. Ele explica que, para treinar a rede, primeiro precisa calcular os gradientes e inicializar os coeficientes. Em seguida, ele executa update_coeffs(), que subtrai os coeficientes dos gradientes. Por fim, ele treina a rede e compara os resultados com um modelo linear.
  
  
• 01:10:00 Este vídeo explica como inicializar modelos de aprendizado profundo, como atualizar os coeficientes e como percorrer todas as camadas. Ele também discute por que o aprendizado profundo pode não ser tão eficaz em pequenos conjuntos de dados e como obter bons resultados com modelos de aprendizado profundo.
  
  
• 01:15:00 Nesta lição, o autor ensina como usar uma estrutura de aprendizagem profunda e mostra como é muito mais fácil do que fazer do zero. O autor também fornece um tutorial sobre engenharia de recursos com Pandas.
  
  
• 01:20:00 Neste vídeo, o instrutor demonstra como usar a biblioteca fastai para recomendar uma taxa de aprendizado para um modelo de aprendizado profundo. Ele mostra como executar várias épocas e compara as previsões do modelo com as previsões de dois outros modelos. Por fim, ele demonstra como usar a função de conjunto para criar um conjunto de cinco previsões cuja média é calculada sobre as linhas.
  
  
• 01:25:00 Neste vídeo, John explica como as florestas aleatórias funcionam e por que elas são um algoritmo popular de aprendizado de máquina. Ele também mostra como usar um atalho útil para importar todos os módulos necessários.
  
  
• 01:30:00 Neste vídeo, o Pandas explica como o aprendizado profundo funciona e como aplicá-lo a problemas de codificação. O algoritmo de floresta aleatória é introduzido e mostra-se que esta técnica pode ser usada para melhorar a precisão das previsões feitas usando uma variável categórica.
  
  
• 01:35:00 Este resumo de 1 parágrafo explica como pontuar uma divisão binária usando um método simples de adicionar pontuações de desvio padrão dos dois grupos de dados. O melhor ponto de divisão é encontrado calculando o menor índice na lista de pontos de divisão com a menor pontuação.
  
  
• 01:40:00 Nesta lição, o instrutor explica como calcular a melhor divisão binária para uma determinada coluna em um conjunto de dados. Isso é particularmente útil para competições de aprendizado de máquina, pois fornece um modelo de linha de base para comparação.

[MetaQuotes]

Lição 6: aprendizado profundo prático para codificadores 2022

Lição 6: aprendizado profundo prático para codificadores 2022

Este vídeo do YouTube fornece um guia sobre como começar a usar o aprendizado profundo para codificadores. O foco principal é o aprendizado profundo prático para codificadores, com dicas sobre como configurar uma competição, obter um conjunto de validação e iterar rapidamente. O vídeo também discute a importância dos gráficos de importância de recursos e dependência parcial e como criá-los usando um modelo de aprendizado de máquina.

Este vídeo fornece uma visão geral de como usar o aprendizado profundo para melhorar a precisão dos projetos de codificação. Ele explica que os conjuntos de dados geralmente podem ter uma ampla variedade de tamanhos de entrada e proporções, o que dificulta a criação de representações precisas com retângulos. Ele sugere o uso de representações quadradas, que funcionam bem na maioria dos casos.

• 00:00:00 Nesta lição, os autores mostram como criar uma árvore de decisão para prever quais machos sobreviverão ao Titanic.
  
  
• 00:05:00 O vídeo discute como criar um classificador de árvore de decisão com no máximo quatro nós folha. A árvore pode ser gerada automaticamente e o código para calcular o coeficiente de Gini é fornecido. O erro absoluto médio da árvore de decisão é calculado em 0,407.
  
  
• 00:10:00 Este vídeo explica como construir uma árvore de decisão para prever classificações de tarifas de passageiros usando dados de uma competição Kaggle. As árvores de decisão são eficientes e não requerem pré-processamento, tornando-as uma boa opção para dados tabulares.
  
  
• 00:15:00 A técnica "bagging" de Leo Breiman é usada para criar um grande número de modelos imparciais que são melhores do que qualquer modelo individual. Isso é feito selecionando aleatoriamente um subconjunto dos dados cada vez que uma árvore de decisão é construída e usando esses dados para treinar o modelo.
  
  
• 00:20:00 Nesta lição, aprendemos a criar uma Random Forest, um algoritmo de aprendizado de máquina simples de implementar e que funciona bem em pequenos conjuntos de dados. Também mostramos como usar gráficos de importância de recursos para nos ajudar a determinar quais recursos são mais importantes nos dados de treinamento.
  
  
• 00:25:00 Neste vídeo, John aborda os fundamentos do aprendizado profundo, incluindo como as Random Forests funcionam e por que aumentar o número de árvores sempre leva a uma melhor taxa de erro. Jeremy continua explicando como Random Forests pode ser usado para prever resultados para grandes conjuntos de dados sem a necessidade de um conjunto de validação.
  
  
• 00:30:00 O vídeo explica como calcular o erro Out-of-Bag ou erro OOB, que é uma medida da precisão das previsões feitas em dados não usados no treinamento de um modelo de aprendizado de máquina. Ele observa que, se o erro OOB for alto, isso sugere que o modelo não está prevendo corretamente os dados.
  
  
• 00:35:00 O vídeo discute a importância dos gráficos de importância de recursos e dependência parcial e como criá-los usando um modelo de aprendizado de máquina.
  
  
• 00:40:00 Neste vídeo, Jeremy explica como funcionam os modelos Random Forest e como interpretar seus gráficos de importância de recursos. Ele também menciona que os modelos Random Forest são mais confiáveis do que outras técnicas de explicabilidade.
  
  
• 00:45:00 Random Forests é um algoritmo de aprendizado de máquina que é particularmente bom para fazer previsões. No entanto, adicionar mais árvores tornará o modelo mais preciso e o overfitting não é um problema. O Gradient Boosting é um algoritmo de aprendizado de máquina semelhante ao Random Forests, mas em vez de ajustar uma árvore repetidamente, ele ajusta árvores muito pequenas que resultam em pouca divisão de dados.
  
  
• 00:50:00 O vídeo explica como uma máquina de aumento de gradiente (GBM) é mais precisa do que uma floresta aleatória, mas que você pode superajustar com um GBM. O passo a passo demonstra como escolher uma competição Kaggle e alcançar o primeiro lugar.
  
  
• 00:55:00 Este vídeo do YouTube fornece um guia sobre como começar a usar o aprendizado profundo para codificadores. O foco principal é o aprendizado profundo prático para codificadores, com dicas sobre como configurar uma competição, obter um conjunto de validação e iterar rapidamente.
  
  
• 01:00:00 Este vídeo explica como usar o FastKaggle para treinar modelos de aprendizado profundo. Ele explica que você precisa ter cuidado ao trabalhar com imagens, pois o tamanho pode mudar dependendo da proporção. O vídeo também mostra como redimensionar as imagens usando uma função chamada "squish".
  
  
• 01:05:00 Neste vídeo, o instrutor discute como usar a biblioteca de IA rápida show_batch() para ver rapidamente a aparência dos dados para modelos de aprendizado de máquina. Ele recomenda o uso de resnet26d para desempenho e precisão de treinamento rápido.
  
  
• 01:10:00 O vídeo demonstra como enviar um modelo de aprendizado profundo para o Kaggle em menos de um minuto usando um carregador de dados e um arquivo CSV que inclui as previsões e rótulos do modelo.
  
  
• 01:15:00 O apresentador compartilha sua estratégia para criar notebooks públicos no Kaggle, que envolve duplicar e renomear notebooks conforme necessário para mantê-los organizados. Ele observa que essa abordagem de baixa tecnologia funciona bem para ele e que normalmente envia apenas um bloco de anotações por vez.
  
  
• 01:20:00 O apresentador fornece uma breve visão geral dos diferentes métodos de aprendizado profundo, incluindo estruturas AutoML e florestas aleatórias. Ele recomenda o uso de um localizador de taxa de aprendizado para evitar modelos de overtraining e recomenda o uso de GPUs para aprendizado profundo, se possível.
  
  
• 01:25:00 Nesta lição, o autor explica como acelerar uma iteração em uma competição Kaggle usando uma arquitetura de rede neural convolucional (CNN) diferente. Ele também mostra como usar uma regra prática para escolher o tamanho certo da CNN.
  
  
• 01:30:00 Neste vídeo, o apresentador discute como melhorar o desempenho de um modelo de aprendizado profundo usando diferentes técnicas de pré-processamento, incluindo corte e preenchimento. Ele também observa que Test Time Augmentation (TTA) pode melhorar o desempenho de um modelo calculando a média de várias versões de uma imagem.
  
  
• 01:35:00 Neste vídeo, Jeremy discute como melhorar a precisão de um modelo de visão computacional usando aprendizado profundo. Ele observa que a precisão do modelo pode ser melhorada variando as imagens nas quais é treinado e fornece um exemplo de como fazer isso usando pandas. Ele também explica a rapidez com que os algoritmos de aprendizado profundo funcionam e como usar o TTA, ou aumento do tempo de teste, para acelerar o processo de treinamento. Finalmente, ele fornece um resumo das perguntas que Victor e John fizeram.
  
  
• 01:40:00 Neste vídeo, Jeremy explica como o aprendizado profundo pode ser usado para melhorar a precisão dos projetos de codificação. Ele observa que os conjuntos de dados geralmente podem ter uma ampla variedade de tamanhos de entrada e proporções, o que dificulta a criação de representações precisas com retângulos. Ele sugere o uso de representações quadradas, que funcionam bem na maioria dos casos.

[MetaQuotes]

Lição 7: aprendizado profundo prático para codificadores 2022

Lição 7: aprendizado profundo prático para codificadores 2022

Na Lição 7 do Practical Deep Learning for Coders 2022, Jeremy explica como escalar modelos de deep learning reduzindo a memória necessária para modelos maiores. Ele demonstra um truque chamado acumulação de gradiente, que envolve não atualizar os pesos a cada loop de cada mini-lote, mas fazê-lo algumas vezes, permitindo que tamanhos de lote maiores sejam usados sem a necessidade de GPUs maiores. Além disso, Jeremy discute a validação cruzada k-fold e a criação de um modelo de aprendizado profundo que prevê o tipo de arroz e a doença presente na imagem usando uma função de perda diferente chamada perda de entropia cruzada. No geral, o vídeo fornece dicas e truques práticos para criar modelos de aprendizado profundo mais complexos.

Neste vídeo, o palestrante explora a criação de sistemas de recomendação usando filtragem colaborativa e produto ponto no PyTorch. Ele descreve a previsão de multiplicação de matrizes de classificações de filmes e calcula a função de perda, uma medida de quão bem as classificações previstas correspondem às classificações reais. Ele introduz o conceito de embeddings, que permite uma aceleração em multiplicadores de matrizes com variáveis fictícias. O palestrante explica como adicionar viés e regularização à matriz para diferenciar as avaliações do usuário e evitar o ajuste excessivo. Finalmente, o tópico de busca de hiperparâmetros é discutido, enfatizando a necessidade de dados granulares para recomendações precisas. No geral, o vídeo detalha conceitos complexos de aprendizado profundo para criar uma compreensão prática para os espectadores.

• 00:00:00 Nesta seção, o instrutor apresenta um truque simples para ampliar ainda mais os modelos, o que envolve reduzir a memória necessária para modelos maiores. Quando modelos maiores são usados, mais parâmetros significam que eles podem encontrar recursos mais complexos, tornando-os mais precisos. No entanto, modelos maiores têm uma desvantagem, pois suas ativações ou gradientes que precisam ser computados consomem muita memória da GPU e, se a memória disponível for insuficiente, resulta em uma mensagem de erro. O instrutor explica como contornar esse problema e usar um modelo x-large mesmo na GPU de 16 Gig do Kaggle.
  
  
• 00:05:00 Nesta seção do vídeo, Jeremy discute os aspectos práticos da execução de modelos de aprendizado profundo no Kaggle e como usar métodos hacky rápidos para determinar o uso de memória dos modelos. Ele demonstra um truque chamado acumulação de gradiente que pode ser usado se o modelo travar com um "erro de falta de memória cuda" para evitar a necessidade de comprar uma GPU maior. Ao ajustar o tamanho do lote e o número de imagens, pode-se garantir que o modelo use a quantidade mínima de memória possível sem afetar as taxas de aprendizado.
  
  
• 00:10:00 Nesta seção, o palestrante discute o conceito de acúmulo de gradiente, que é a ideia de não atualizar os pesos a cada loop para cada mini-lote, mas fazê-lo de vez em quando. Isso permite que tamanhos de lote maiores sejam usados sem a necessidade de GPUs maiores, pois o gradiente pode ser acumulado em vários lotes menores. Os resultados são numericamente idênticos para arquiteturas que não usam normalização em lote, mas podem apresentar mais volatilidade para aquelas que usam. No geral, a acumulação de gradiente é uma ideia simples com implicações significativas para o treinamento de modelos maiores.
  
  
• 00:15:00 Nesta seção, Jeremy discute questões do fórum relacionadas a lr_find() e acúmulo de gradiente. Ele explica que lr_find() usa o tamanho do lote dos carregadores de dados e que o acúmulo de gradiente permite experimentar diferentes lotes para encontrar o tamanho ideal para diferentes arquiteturas. Jeremy recomenda escolher o maior tamanho de lote que caiba em sua GPU, mas menciona que nem sempre é necessário usar o maior tamanho de lote. A regra geral é dividir o tamanho do lote por dois e dividir a taxa de aprendizado por dois. Por fim, Jeremy demonstra como usar o acúmulo de gradiente no fastai dividindo o tamanho do lote pelo valor de acúmulo desejado e passando o retorno de chamada GradientAccumulation ao criar o aprendiz, permitindo que ele treine vários modelos em um cartão de 16 GB.
  
  
• 00:20:00 Nesta seção, o apresentador discute o uso de modelos de transformadores pré-treinados vit, swinv2 e swin, que têm tamanhos fixos. Para contornar isso, o tamanho final deve ser quadrado e do tamanho necessário. O apresentador usa um dicionário de arquiteturas e detalhes de pré-processamento, alternando o caminho de treinamento de volta para usar todas as imagens e percorrer cada arquitetura e transformar o tamanho para treinar cada modelo. O script de treinamento retorna tta previsões, que são anexadas a uma lista que é posteriormente calculada por meio de bagging para criar uma lista de índices para cada doença. Ao enviar inscrições regularmente, o apresentador melhorou seus resultados e conseguiu garantir uma posição de destaque na tabela de classificação.
  
  
• 00:25:00 Nesta seção, Jeremy discute o conceito de validação cruzada k-fold e como ele é semelhante ao que ele fez com modelos de combinação. Ele explica que a validação cruzada k-fold é onde os dados são divididos em cinco subconjuntos e os modelos são treinados em cada subconjunto com conjuntos de validação não sobrepostos, que são então agrupados. Embora possa ser potencialmente melhor do que seu método, Jeremy prefere ensemble porque permite a fácil adição e remoção de modelos. Jeremy também discute o acúmulo de gradiente e como não há desvantagens reais ou possíveis armadilhas, e recomenda a compra de placas gráficas mais baratas com menos memória em vez das caras. Por fim, ele menciona que a Nvidia é o único jogo da cidade para GPUs, e os cartões RTX de consumo são tão bons quanto os caros cartões corporativos.
  
  
• 00:30:00 Nesta seção, Jeremy discute os benefícios de investir em uma GPU para aprendizado profundo e reconhece que ela pode ser cara devido ao seu uso em computação em nuvem. Ele também aborda como treinar um modelo menor para produzir as mesmas ativações de um modelo maior, que será abordado na Parte 2. O restante do vídeo se concentra na construção de um modelo que prediz a doença e o tipo de arroz de uma imagem , que requer um carregador de dados com duas variáveis dependentes. Jeremy explica como usar o DataBlock para criar um carregador com várias variáveis dependentes e demonstra como diferenciar entre categorias de entrada e saída.
  
  
• 00:35:00 Nesta seção, o instrutor explica como criar um modelo de aprendizado profundo que prevê o tipo de arroz e a doença presente na imagem. Para conseguir isso, a função get_y deve receber uma matriz com dois rótulos diferentes. Um é o nome do diretório pai, pois indica a doença, e o segundo é a variedade. O professor cria uma função que pega a localização no quadro de dados do nome do arquivo e retorna a coluna de variedade. Finalmente, eles criam um modelo que prevê 20 coisas: a probabilidade de cada uma das 10 doenças e cada uma das 10 variedades. A métrica de taxa de erro deve ser modificada para lidar com três coisas em vez de duas para funcionar com o novo conjunto de dados.
  
  
• 00:40:00 Nesta seção, o palestrante explica a necessidade de uma função de perda diferente chamada perda de entropia cruzada quando a variável dependente é uma categoria. Enquanto o vision_learner de fastai adivinhou e usou a perda de entropia cruzada anteriormente, o palestrante agora explica como ela funciona em detalhes com a ajuda de uma planilha. Começando com a saída de um modelo com cinco categorias, o palestrante demonstra como converter as saídas do modelo em probabilidades usando a função softmax. Uma vez que as saídas são probabilidades, a função de perda de entropia cruzada é usada para medir a diferença entre as probabilidades previstas e as probabilidades reais e determinar o desempenho do modelo.
  
  
• 00:45:00 Nesta seção, aprendemos sobre o softmax e como ele é usado para prever uma coisa específica de categorias que são escolhidas com antecedência. A fórmula usada para calcular a perda de entropia cruzada envolve a multiplicação de probabilidades e valores de destino reais e, em seguida, a soma. O log de softmax é utilizado para acelerar os cálculos. O resultado é um único valor de probabilidade que é então somado para cada linha para calcular a perda de entropia cruzada.
  
  
• 00:50:00 Nesta seção, o instrutor explica a função binária de perda de entropia cruzada e como usá-la com vários alvos. Ele observa que o pytorch tem duas versões de funções de perda, uma classe e uma função, e mostra como usá-las. Ao criar um modelo de múltiplos alvos, o aprendiz de visão requer vinte saídas, com dez prevendo a doença e dez prevendo a variedade. O instrutor demonstra como criar esse modelo e depois o treina. No geral, esse modelo é idêntico ao modelo anterior, exceto pela adição do segundo conjunto de alvos.
  
  
• 00:55:00 Nesta seção, aprenderemos como um modelo sabe o que está prevendo por meio de sua função de perda. As primeiras dez colunas de valores de entrada prevêem a probabilidade da doença e as dez seguintes representam a probabilidade da variedade. Usando a entropia cruzada, fatoramos os valores-alvo da doença e da variedade para criar uma função de perda com base na previsão desses dois valores. A função de perda reduz quando as primeiras dez colunas fazem boas previsões de doenças e as segundas dez para variedade, tornando os coeficientes melhores no uso eficaz de cada coluna. Calculamos e rastreamos as taxas de erro para previsões de doenças e variedades ao longo da época de treinamento. O treinamento por mais tempo usando um modelo multialvo às vezes pode resultar em melhor previsão de doenças do que um único modelo alvo devido a certos recursos que ajudam a reconhecer diferentes alvos.
  
  
• 01:00:00 Nesta seção do vídeo, o palestrante discute os benefícios de construir modelos que prevêem várias coisas e incentiva os espectadores a experimentar modelos em pequenos conjuntos de dados. Ele também apresenta o notebook Collaborative Filtering Deep Dive, que usa um conjunto de dados de avaliações de filmes para ensinar o conceito de sistemas de recomendação. Ele explica que esse tipo de dado é comum em setores como sistemas de recomendação e fornece um exemplo de tabulação cruzada para entender melhor o conjunto de dados. O palestrante faz uma pausa antes de mergulhar no próximo caderno.
  
  
• 01:05:00 Nesta seção, o palestrante explica como preencher lacunas em um conjunto de dados de filtragem colaborativa. A filtragem colaborativa ajuda a recomendar um produto a um usuário usando dados coletados de vários usuários. Para descobrir se um usuário pode gostar de um determinado filme, o palestrante propõe um método de multiplicar os valores correspondentes das preferências do usuário e o tipo de filme por meio de análise vetorial. No entanto, como não recebemos nenhuma informação sobre usuários ou filmes, o palestrante sugere a criação de fatores latentes para preencher os pontos de dados ausentes. Usando supostos fatores latentes, o palestrante propõe o uso do SGD para encontrar a correlação e gerar hipóteses.
  
  
• 01:10:00 Nesta seção, o vídeo descreve como usar a multiplicação de matrizes para prever classificações de filmes para usuários com base em suas classificações históricas. O tutorial atribui valores aleatórios para fatores latentes para filmes e usuários e executa o produto escalar para prever as classificações. Uma função de perda é então calculada e a otimização é realizada usando a ferramenta Data Solver. O vídeo demonstra que as classificações previstas melhoraram comparando-as com as classificações reais após a otimização. A técnica de preenchimento de matriz e filtragem colaborativa, onde usuários com gostos semelhantes são recomendados filmes semelhantes, também são introduzidas.
  
  
• 01:15:00 Nesta seção, o vídeo discute o uso de filtragem colaborativa e produtos de ponto no PyTorch. O cosseno do ângulo entre dois vetores pode aproximar a correlação e eles são os mesmos depois de normalizados. O Excel é usado para explicar os cálculos necessários no PyTorch. O vídeo também observa que as incorporações, geralmente consideradas uma ferramenta matemática complexa, são na verdade matrizes usadas para pesquisar coisas. O vídeo tenta quebrar o jargão confuso para tornar o aprendizado profundo mais fácil de entender para todos.
  
  
• 01:20:00 Nesta seção, Jeremy explica como usar carregadores de dados de filtragem colaborativa no PyTorch para trabalhar com dados de classificação de filmes. Ele mescla a tabela de filmes com a tabela de classificações para obter o ID do usuário e o nome do filme. A função CollabDataLoaders é usada para carregar dados do quadro de dados com classificações, ID do usuário e colunas de título do item. Em seguida, ele cria fatores de usuário e filme usando uma matriz de números aleatórios, onde o número de colunas é igual ao número de fatores que ele deseja criar. Ele também menciona que usa uma fórmula predeterminada para determinar o número de fatores, que é derivada de sua intuição e testada por meio do ajuste de uma função.
  
  
• 01:25:00 Nesta seção, o palestrante explica que um vetor codificado em um hot pode ser usado para procurar um número de índice no vetor, o que é o mesmo que obter o produto escalar de um vetor codificado em um hot com alguma coisa. Embeddings são então introduzidos como um atalho computacional para multiplicar algo por um vetor codificado por um hot, permitindo uma aceleração ao fazer multiplicadores de matrizes com variáveis fictícias. O palestrante também apresenta a criação de um modelo Pytorch, que é uma classe que inclui uma superclasse chamada Module que fornece algumas funcionalidades adicionais. O objeto dot product é usado como exemplo de como criar um modelo, que chama o método dunder init e cria embeddings de usuários por fatores e filmes por vetores.
  
  
• 01:30:00 Nesta seção, o instrutor explica como usar o PyTorch para chamar um método chamado "forward" para calcular o modelo. O próprio objeto e os dados que estão sendo calculados são passados para "forward". Usar o produto escalar e passar os dados pelo PyTorch é muito mais rápido do que usar o Excel. No entanto, o modelo não funciona bem, pois, por exemplo, prevê valores maiores que o maior valor possível enquanto ninguém classificou um filme abaixo de um. O instrutor corrige isso usando a função sigmóide para reduzir a previsão a um intervalo entre zero e 5,5. Apesar dessa mudança, a perda não melhora consideravelmente, mas o instrutor apresenta uma nova observação de alguns usuários com classificações altas, sugerindo que envolver o viés do usuário pode melhorar o modelo.
  
  
• 01:35:00 Nesta seção, o palestrante demonstra como adicionar viés à matriz usada no modelo de recomendação de filmes. Ao adicionar esses vieses, é possível diferenciar os usuários que tendem a dar classificações mais baixas ou mais altas. O palestrante também discute como evitar o overfitting usando decaimento de peso ou regularização L2. O palestrante explica que isso pode ser obtido adicionando a soma dos pesos ao quadrado à função de perda. No geral, a seção fornece uma introdução útil ao tópico de vieses e regularização em modelos de aprendizado profundo.
  
  
• 01:40:00 Nesta seção, o vídeo discute o uso do decaimento de peso como uma forma de regularização para evitar o overfitting em modelos de aprendizado profundo. Ao encontrar a combinação certa de pesos que não são muito altos, mas altos o suficiente para serem úteis na previsão, o modelo pode obter o menor valor possível da função de perda. O coeficiente de decaimento de peso pode ser passado para o método de ajuste e os padrões são normalmente bons para aplicações de visão, mas para filtragem tabular e colaborativa, os usuários devem tentar alguns múltiplos de 10 para ver o que dá o melhor resultado. A regularização trata de tornar o modelo não mais complexo do que deveria ser, com os valores mais altos de decaimento de peso reduzindo o overfitting, mas também reduzindo a capacidade do modelo de fazer boas previsões.
  
  
• 01:45:00 Nesta seção, Jeremy e John discutem o tópico de pesquisa de hiperparâmetros e como ela é freqüentemente usada na construção de modelos individuais. No entanto, não há regras além da regra prática de Jeremy quando se trata de realizar uma exploração de hiperparâmetros. Em resposta a uma pergunta sobre se os sistemas de recomendação podem ser construídos com base nas classificações médias da experiência dos usuários em vez de filtragem colaborativa, Jeremy explica que não seria ideal se tudo o que se tem é o histórico de compras. Em vez disso, dados granulares, como informações demográficas sobre usuários e metadados sobre produtos, são necessários para fazer recomendações precisas.

[MetaQuotes]

Lição 8 - Deep Learning prático para codificadores 2022

Lição 8 - Deep Learning prático para codificadores 2022

Este vídeo aborda os fundamentos do aprendizado profundo para codificadores. Ele explica como criar parâmetros para modelos de aprendizado profundo usando a biblioteca Pytorch, como usar o PCA para reduzir o número de fatores em um conjunto de dados e como usar uma rede neural para prever o preço de venda em leilão de equipamentos industriais pesados.

Este vídeo do YouTube fornece uma visão geral do aprendizado profundo para programadores. O orador explica que a tenacidade é importante nesta área e aconselha que, se quiser ter sucesso, deve continuar até que algo esteja concluído. Ele também recomenda ajudar outros iniciantes em forums.fast.ai.

• 00:00:00 Nesta lição, Pytorch se encarrega de criar e gerenciar parâmetros para uma rede neural, certificando-se automaticamente de que os coeficientes e pesos sejam inicializados da maneira correta. Isso evita que o usuário tenha que se lembrar dessas informações ou escrever código para fazer isso.
  
  
• 00:05:00 Este vídeo explica como criar parâmetros para modelos de aprendizado profundo usando a biblioteca Pytorch. O Pytorch inicializará automaticamente esses parâmetros com base em uma distribuição gerada aleatoriamente.
  
  
• 00:10:00 Este vídeo mostra como construir uma camada de incorporação Pytorch do zero, usando o mesmo código e conceitos do original. O vídeo então demonstra como a camada prevê as preferências do filme observando as preferências anteriores do filme.
  
  
• 00:15:00 O vídeo demonstra como usar o aplicativo de aprendizado colaborativo fast.ai para prever qual filme um usuário pode gostar. O aplicativo usa fatores latentes (filmes e fatores) para calcular o viés de um usuário, que é usado para prever qual filme o usuário pode gostar.
  
  
• 00:20:00 Este vídeo explica como usar o PCA para reduzir o número de fatores em um conjunto de dados. Ele também aborda o Problema de Bootstrapping, que é a questão de como recomendar novos produtos aos clientes quando você não tem histórico anterior com eles.
  
  
• 00:25:00 Este vídeo aborda os fundamentos do aprendizado profundo para codificadores, incluindo um modelo sequencial, como usar a funcionalidade do Pytorch para criar um modelo facilmente e como ajustar o modelo em um aluno colaborativo. Jona faz uma pergunta ao apresentador sobre a questão do viés em sistemas de filtragem colaborativa, e o apresentador fornece uma resposta geral sobre o problema.
  
  
• 00:30:00 Neste vídeo, Jeremy explica como os embeddings funcionam em Collaborative Filtering e NLP, e como eles podem ser usados para interpretar redes neurais.
  
  
• 00:35:00 Neste vídeo, o autor demonstra como usar uma Rede Neural para prever o preço de venda em leilão de equipamentos industriais pesados, usando uma Random Forest e um Tabular Learner. O autor observa que a rede neural criada usando o Tabular Learner é quase idêntica à rede neural criada manualmente.
  
  
• 00:40:00 As redes neurais podem ser consideradas como um tipo de algoritmo de aprendizado de máquina que recebe dados como entrada e usa esses dados para criar previsões ou saídas. As redes neurais são compostas por camadas de nós (chamados neurônios), que são interconectados para criar um grafo. As entradas para uma rede neural podem ser categóricas (por exemplo, uma categoria como carros ou flores) ou contínuas (por exemplo, um número). As redes neurais podem ser usadas para prever os resultados de diferentes resultados (por exemplo, vendas em diferentes lojas) ou para adivinhar o conteúdo de uma nova entrada (por exemplo, a localização geográfica de um determinado conjunto de pontos de dados).
  
  
• 00:45:00 Neste vídeo, aprendemos sobre convoluções, que são um tipo de multiplicação de matrizes usado em redes neurais convolucionais. Vemos um exemplo disso em ação e, em seguida, discutimos como criar um detector de borda superior usando redes neurais convolucionais.
  
  
• 00:50:00 O vídeo explica como realizar uma convolução, uma operação matemática que pega duas matrizes de dados e combina seus elementos, produzindo um resultado geralmente maior no lado esquerdo da matriz do que no lado direito. Uma convolução é executada em um kernel 3 por 3, que é repetido várias vezes para produzir uma camada de aprendizado profundo.
  
  
• 00:55:00 O vídeo explica como funciona o aprendizado profundo, mostrando como dois filtros, um para bordas horizontais e outro para bordas verticais, são combinados para criar uma única ativação para reconhecer números. A maneira mais antiga de fazer isso, que usava pooling máximo, resultou em menos ativações e, eventualmente, uma esquerda. A nova maneira, que usa uma técnica chamada "Max Pooling com janelas deslizantes", continua até que todas as ativações sejam usadas e produza um resultado mais preciso.
  
  
• 01:00:00 Neste vídeo, o apresentador explica como o aprendizado profundo é feito no século XXI. Hoje, o aprendizado profundo é feito de maneira diferente de 10 anos atrás, e o apresentador fornece um exemplo de como essa mudança funciona. Em vez do Max Pooling, os algoritmos de aprendizado profundo agora usam o Stride 2 Convolution. Além disso, os modelos de aprendizado profundo agora usam uma única camada densa no final, em vez de uma camada Max Pool. Por fim, o apresentador fornece uma breve visão geral de como o fast.ai lida com o treinamento e a previsão de aprendizado profundo.
  
  
• 01:05:00 Neste vídeo do YouTube, o autor mostra como a convolução é igual à multiplicação de matrizes e como calcular uma convolução usando os dois métodos. Ele também discute o Dropout, uma técnica para reduzir o impacto do ruído aleatório em redes neurais.
  
  
• 01:10:00 Nesta lição, o autor descreve como Dropout Layers ajudam a evitar overfitting em redes neurais. Quanto mais dropout você usar, menos bom será nos dados de treinamento, mas melhor deve ser generalizado. Isso vem de um artigo do grupo de Geoffrey Hinton, que foi rejeitado na principal conferência de redes neurais, então chamada NIPS, agora chamada NeurIPS.
  
  
• 01:15:00 Este vídeo aborda os fundamentos do aprendizado profundo, incluindo os tipos de redes neurais e como implementá-las. Ele também aborda como usar vários métodos de treinamento e como avaliar o desempenho de uma rede neural. Por fim, o vídeo fornece conselhos sobre como continuar aprendendo o aprendizado profundo.
  
  
• 01:20:00 Lucas pergunta como se manter motivado no aprendizado profundo e observa que o campo está rapidamente se tornando mais voltado para modelos mais caros e de grande escala. Ele se pergunta se ainda seria capaz de treinar modelos razoáveis com uma única GPU no futuro. No geral, este vídeo fornece uma visão geral de como se manter motivado no aprendizado profundo e como se manter atualizado com as pesquisas mais recentes.
  
  
• 01:25:00 Este vídeo do YouTube fornece uma breve visão geral do aprendizado profundo e sua aplicação prática à codificação. O vídeo discute como o sucesso do aprendizado profundo do DawnBench foi devido ao uso de bom senso e inteligência da equipe, e como qualquer pessoa pode aplicar o aprendizado profundo a seus próprios domínios de problemas. O vídeo também aborda a importância da educação formal no campo do aprendizado de máquina e como as sessões de codificação ao vivo ajudam a reforçar o aprendizado.
  
  
• 01:30:00 Jeremy compartilhou alguns hacks de produtividade, incluindo gastar tempo aprendendo algo novo todos os dias e não trabalhando muito.
  
  
• 01:35:00 Este vídeo do YouTube é uma aula de deep learning para programadores, e o palestrante explica que tenacidade é importante nessa área. Ele aconselha que, se você deseja ter sucesso, deve continuar até que algo seja concluído, mesmo que não seja da melhor qualidade. Ele também recomenda ajudar outros iniciantes em forums.fast.ai.

[MetaQuotes]

Lição 9: Fundamentos de aprendizado profundo para difusão estável, 2022

Lição 9: Fundamentos de aprendizado profundo para difusão estável, 2022

Este vídeo fornece uma introdução ao aprendizado profundo, discutindo como os modelos de difusão estáveis funcionam e como eles podem ser aplicados para gerar novas imagens. O vídeo inclui uma demonstração de como usar a biblioteca Diffusers para criar imagens que se parecem com dígitos manuscritos. Também introduz o conceito de difusão estável, que é um método para treinamento de Redes Neurais. A ideia básica é modificar as entradas de uma Rede Neural para alterar a saída. Neste vídeo, o instrutor discute como criar uma Rede Neural que será capaz de identificar corretamente os dígitos manuscritos de entradas ruidosas. Este vídeo discute como treinar um modelo de aprendizado de máquina usando um algoritmo de aprendizado profundo. O modelo é inicializado com um conjunto de variáveis latentes (representando os dados) e usa um decodificador para entender os dados brutos. Em seguida, um codificador de texto é usado para criar legendas legíveis por máquina para os dados. Finalmente, uma U-Net é treinada usando as legendas como entrada e os gradientes (a "função de pontuação") são usados para ajustar os níveis de ruído nos dados de treinamento.

• 00:00:00 Esta lição explica como o aprendizado profundo funciona e como aplicá-lo a problemas do mundo real. No entanto, como os conceitos e técnicas descritos nesta lição provavelmente ficarão desatualizados em um futuro próximo, a maior parte do vídeo é dedicada a ensinar como usar a difusão estável, um algoritmo de aprendizado profundo que ainda será aplicável em 2022.
  
  
• 00:05:00 O curso está avançando rapidamente e novos artigos mostraram que o número de etapas necessárias para gerar um modelo de difusão estável caiu de mil para quatro ou cinquenta e seis. O curso se concentrará nos fundamentos do modelo e como ele funciona.
  
  
• 00:10:00 O curso fornece fundamentos de aprendizado profundo, discutindo como funcionam os modelos de difusão estável e fornecendo recursos para um aprendizado mais aprofundado. Em 2022, as GPUs para aprendizado profundo ficarão mais caras, por isso é importante observar as recomendações atuais.
  
  
• 00:15:00 Este vídeo do YouTube fornece uma breve introdução ao aprendizado profundo, descrevendo os fundamentos da difusão estável. O autor fornece um conjunto de notebooks Colab, "diffusion-nbs", que podem ser usados para explorar os fundamentos do aprendizado profundo. O vídeo termina com uma recomendação para brincar com o material fornecido e explorar outros recursos.
  
  
• 00:20:00 Nesta lição, os fundamentos do Deep Learning são abordados, incluindo como criar um algoritmo de difusão estável. Em seguida, é apresentada a biblioteca Diffusers e como salvar um pipeline para uso de outras pessoas.
  
  
• 00:25:00 Esta lição discute os fundamentos do aprendizado profundo e como usar o Colab para criar imagens de alta qualidade. As 51 etapas necessárias para criar uma imagem são comparadas às três a quatro etapas disponíveis em outubro de 2022.
  
  
• 00:30:00 Nesta lição, o instrutor demonstra como criar imagens usando aprendizagem profunda. Ele demonstra como usar a "escala de orientação" para controlar o quão abstratas são as imagens.
  
  
• 00:35:00 Este vídeo explica como usar um modelo de aprendizado profundo para gerar imagens que se parecem com o desenho original, usando uma técnica chamada difusão estável.
  
  
• 00:40:00 Nesta lição, o instrutor explica como treinar modelos de aprendizado de máquina com o algoritmo de difusão estável. Eles explicam que o algoritmo é útil para gerar imagens semelhantes aos exemplos fornecidos. O instrutor também compartilha um exemplo de como o algoritmo de difusão estável foi usado para gerar uma imagem de um ursinho semelhante ao ursinho original.
  
  
• 00:45:00 Neste vídeo, o instrutor apresenta o conceito de difusão estável, que é uma abordagem matemática equivalente à abordagem tradicional, mas conceitualmente mais simples. Ele explica que usando uma função que pode determinar a probabilidade de uma imagem ser um dígito manuscrito, você pode gerar novas imagens que se parecem com dígitos manuscritos.
  
  
• 00:50:00 Neste vídeo, um instrutor explica como calcular o gradiente da probabilidade de uma imagem inserida ser um dígito manuscrito, usando aprendizado profundo.
  
  
• 01:05:00 Este vídeo apresenta a ideia de difusão estável, que é um método de treinamento de Redes Neurais. A ideia básica é modificar as entradas de uma Rede Neural para alterar a saída.
  
  
• 01:10:00 Neste vídeo, o instrutor discute como criar uma Rede Neural que será capaz de identificar corretamente os dígitos manuscritos de entradas ruidosas. Eles primeiro discutem como criar um conjunto de dados de treinamento e, em seguida, explicam como treinar a Rede Neural.
  
  
• 01:15:00 Este vídeo apresenta o conceito de aprendizado profundo e difusão estável, que é uma forma de prever o ruído em uma imagem digital. A rede neural prevê o ruído e a função de perda é simples: pegar a entrada e prever o ruído.
  
  
• 01:20:00 A Rede Neural neste vídeo está tentando prever o ruído que foi adicionado às entradas. Ele faz isso subtraindo os bits que considera ruído da entrada. Depois de fazer isso várias vezes, eventualmente obtém algo que se parece mais com um dígito.
  
  
• 01:25:00 Neste vídeo, o instrutor mostra como uma Rede Neural, chamada U-Net, pode ser usada para aproximar uma imagem. O problema é que o U-Net requer muito armazenamento, o que pode ser um problema para o Google com sua grande nuvem de TPUs.
  
  
• 01:30:00 O vídeo explica como compactar uma imagem usando aprendizado profundo. Primeiro, uma imagem é comprimida passando-a por uma camada de duas camadas convolucionais. Este processo é repetido até que a imagem seja reduzida a uma versão 64x64x4. Em seguida, a imagem é salva como uma camada de Rede Neural. Finalmente, a Rede Neural é usada para comprimir imagens de diferentes tamanhos.
  
  
• 01:35:00 O vídeo discute como uma função de perda pode ser usada para ensinar uma Rede Neural a compactar uma imagem, resultando em um arquivo menor. O algoritmo de compactação funciona bem e pode ser usado para compartilhar imagens entre duas pessoas.
  
  
• 01:40:00 Este vídeo fornece um tutorial sobre como treinar um modelo de aprendizado profundo usando dados latentes. Latentes são um tipo especial de dados que não são observados diretamente e são usados para treinar um modelo de aprendizado profundo. Os latentes são criados codificando os pixels de uma imagem usando uma rede neural. O processo de codificação cria uma representação latente da imagem. O decodificador usa essa representação latente para gerar a imagem original.
  
  
• 01:45:00 Este vídeo explica como uma Rede Neural pode aprender a prever melhor o ruído aproveitando o fato de saber qual era a imagem original. Isso é útil porque, ao alimentar o número 3, por exemplo, o modelo dirá que o ruído é tudo o que não representa o número 3.
  
  
• 01:50:00 O vídeo explica como duas redes neurais podem ser usadas para codificar texto e imagens. A primeira rede neural é usada para codificar texto e a segunda rede neural é usada para codificar imagens. O objetivo é que as duas redes produzam saídas semelhantes para uma determinada entrada. A similaridade das saídas é determinada pelo produto escalar das características da entrada e as características da saída.
  
  
• 01:55:00 Este vídeo explica como criar um codificador de texto CLIP, que é um tipo de modelo de aprendizado de máquina que pode produzir incorporações semelhantes para entradas de texto semelhantes. Isso é importante porque permite o reconhecimento e a síntese de texto multimodal.
  
  
• 02:00:00 Neste vídeo, o instrutor explica como treinar um modelo de aprendizado de máquina usando um algoritmo de aprendizado profundo. O modelo é inicializado com um conjunto de variáveis latentes (representando os dados) e usa um decodificador para entender os dados brutos. Em seguida, um codificador de texto é usado para criar legendas legíveis por máquina para os dados. Finalmente, uma U-Net é treinada usando as legendas como entrada e os gradientes (a "função de pontuação") são usados para ajustar os níveis de ruído nos dados de treinamento.
  
  
• 02:05:00 Neste vídeo, o autor descreve como funcionam os algoritmos de aprendizado profundo e como eles tentam encontrar a melhor estimativa para uma imagem latente (desconhecida). O autor também descreve como ajustar os parâmetros do algoritmo para melhorar os resultados.
  
  
• 02:10:00 O vídeo discute como os solucionadores de equações diferenciais, como otimizadores, usam ideias semelhantes aos modelos de aprendizado profundo. O vídeo discute como a perda de percepção e outras funções de perda podem ser usadas para melhorar a precisão dos modelos de aprendizagem profunda. O vídeo fornece uma prévia da próxima lição, na qual o código para um pipeline de aprendizado profundo será explicado.
  
  
• 02:15:00 Este vídeo discute algumas novas direções de pesquisa em aprendizado profundo que provavelmente melhorarão a estabilidade e a difusão da tecnologia.