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

[MetaQuotes]

Aprendizagem por Reforço em 3 Horas | Curso Completo Usando Python

Código: https://github.com/nicknochnack/ReinforcementLearningCourse

Aprendizagem por Reforço em 3 Horas | Curso Completo Usando Python

00:00:00 - 01:00:00 O curso em vídeo "Aprendizado por Reforço em 3 Horas" abrange uma variedade de tópicos em aprendizado por reforço, incluindo implementação prática e ponte entre a teoria e a prática. O curso abrange tudo, desde a configuração do ambiente RL até a construção de ambientes personalizados, com foco no treinamento de agentes de aprendizado por reforço e na avaliação deles usando diferentes algoritmos e arquiteturas. Aplicações populares de RL, como robótica e jogos, são discutidas, bem como as limitações de RL, como a suposição de que os ambientes são markovianos e o potencial para treinamento instável. O curso usa Stable Baselines, uma biblioteca RL de código aberto e OpenAI Gym para criar ambientes simulados. O instrutor explica os diferentes tipos de espaços usados para representar ações e valores que os agentes podem assumir em um ambiente, bem como diferentes algoritmos de RL, como A2C e PPO. A importância de entender o ambiente antes de implementar algoritmos é enfatizada, e os usuários são orientados na configuração da plataforma de computação para aprendizado por reforço, escolha de algoritmos RL apropriados e treinamento e teste do modelo.

01:00:00 - 02:00:00 Este vídeo do YouTube oferece um curso de três horas sobre aprendizado por reforço usando Python. O instrutor explica os principais componentes do aprendizado por reforço, incluindo o agente, o ambiente, a ação e a recompensa. A seção discute como definir um ambiente, treinar um modelo usando aprendizado por reforço e visualizar logs de treinamento usando o TensorBoard para monitorar o processo de treinamento. O palestrante também aborda outros tópicos, como salvar e recarregar um modelo treinado, testar e melhorar o desempenho do modelo, definir uma arquitetura de rede para um ator personalizado e função de valor em uma rede neural e usar o aprendizado por reforço para jogar o jogo Breakout do Atari. Além disso, o curso inclui três projetos que os alunos construirão usando técnicas de aprendizado por reforço, incluindo o jogo Breakout no Atari, a construção de um carro de corrida para direção autônoma e a criação de ambientes personalizados usando os espaços do OpenAI Gym.

02:00:00 - 03:00:00 Este vídeo do YouTube intitulado "Aprendizado por reforço em 3 horas | Curso completo usando Python" abrange vários tópicos relacionados ao aprendizado por reforço. O instrutor demonstra como treinar um agente de aprendizado por reforço para jogos Atari e direção autônoma usando o ambiente de carro de corrida. Eles também apresentam várias dependências de ginásio OpenAI, auxiliares e linhas de base estáveis, bem como diferentes tipos de espaços para aprendizado de reforço. Além disso, o vídeo aborda como criar um ambiente personalizado para aprendizado por reforço, definindo o estado do ambiente, seus espaços de observação e ação, testando e treinando o modelo e salvando o modelo treinado após o aprendizado. O instrutor também discute a importância de treinar modelos por períodos mais longos para um melhor desempenho e incentiva os espectadores a entrar em contato caso encontrem alguma dificuldade.

• 00:00:00 Nesta seção do vídeo, o apresentador apresenta o curso de aprendizado por reforço e descreve os diferentes tópicos que serão abordados ao longo do curso. Ele explica que o curso foi desenvolvido para preencher a lacuna entre a teoria e a implementação prática e abrange tudo, desde a configuração do ambiente RL até a criação de ambientes personalizados. O apresentador oferece uma visão geral de alto nível do aprendizado por reforço, suas aplicações e algumas de suas limitações. O curso fornecerá experiência prática no treinamento de agentes de aprendizado por reforço e no teste e avaliação deles usando diferentes algoritmos e arquiteturas, além de abranger três projetos diferentes focados no ambiente de fuga, ambiente autônomo e ambientes personalizados.
  
  
• 00:05:00 Nesta seção do vídeo "Aprendizado por Reforço em 3 Horas", o instrutor explica os conceitos fundamentais do aprendizado por reforço. Um agente de aprendizado por reforço aprende com base nas recompensas que obtém do ambiente ao realizar diferentes ações. O agente observa o ambiente para maximizar suas recompensas ao longo do tempo tomando certas decisões. O instrutor também discute algumas aplicações práticas de aprendizado por reforço, como direção autônoma, negociação de valores mobiliários e pesquisa de arquitetura de rede neural.
  
  
• 00:10:00 Nesta seção, o vídeo discute algumas das aplicações populares de aprendizado por reforço, incluindo robótica, onde ambientes simulados podem ser usados para treinar robôs para realizar tarefas específicas. O vídeo também menciona o jogo como outro aplicativo popular em que a função de recompensa pode diferir a cada vez, tornando-o um ambiente adequado para aprendizado por reforço. As limitações do aprendizado por reforço também são discutidas, incluindo a suposição de que o ambiente é markoviano e o fato de que o treinamento pode ser demorado e instável. A configuração do modelo de aprendizado por reforço é discutida, o que inclui a instalação da biblioteca de linhas de base estáveis do OpenAI e a utilização de seus guias e documentação úteis.
  
  
• 00:15:00 Nesta seção, o instrutor apresenta o curso e descreve as 10 etapas diferentes que serão abordadas. A primeira etapa é importar e carregar as dependências necessárias, incluindo linhas de base estáveis, uma biblioteca de código aberto para aprendizado por reforço. O instrutor explica os diferentes algoritmos disponíveis na biblioteca e os benefícios do uso de PPO (Proximal Policy Optimization). As dependências também incluem SO, para funcionalidade do sistema operacional, e ginásio, para construir e trabalhar com ambientes. No geral, o processo é direto e requer apenas algumas linhas de código para começar com linhas de base estáveis.
  
  
• 00:20:00 Nesta seção, o instrutor discute as dependências e os ambientes necessários para o aprendizado por reforço. Eles introduzem Stable Baselines, que permite um aprendizado de máquina mais rápido por meio da vetorização de ambientes, e o wrapper Dummy Vec Env. Eles também explicam como o OpenAI Gym pode ser usado para construir ambientes simulados, o que pode reduzir custos e permitir uma produção mais rápida de modelos. Eles fornecem exemplos de ambientes reais, como um robô, bem como ambientes simulados, como o OpenAI Gym, que possui muita documentação e suporte.
  
  
• 00:25:00 Nesta seção do vídeo, o instrutor discute o padrão para criar ambientes de aprendizado por reforço, que é o OpenAI Gym. Ele explica que o OpenAI Gym fornece ambientes pré-construídos, incluindo aqueles baseados em robôs reais, como Fetch Robot e Shadow Hand Robot. Ele explica ainda os diferentes tipos de espaços suportados pelo OpenAI Gym, incluindo box, discreto, tupla, dict, multibinário e multidiscreto. Ele observa que esses espaços são usados para representar os diferentes tipos de valores ou ações que os agentes podem realizar no ambiente. O instrutor então apresenta o ambiente Classic Control, especificamente o problema CartPole, como um exemplo que ele usará para treinar um agente de aprendizado por reforço. O objetivo é equilibrar uma viga movendo-a para a esquerda ou para a direita usando duas ações.
  
  
• 00:30:00 Nesta seção, o instrutor explica como carregar e testar um ambiente usando o OpenAI Gym. Eles começam instanciando o ambiente CartPole-v0 usando duas linhas de código. Em seguida, eles demonstram como testar o ambiente percorrendo vários episódios e usando env.reset() para obter o conjunto inicial de observações. Essas observações serão posteriormente passadas para um agente de aprendizado por reforço para determinar a melhor ação para maximizar a recompensa. O instrutor observa a importância de entender o ambiente antes de implementar qualquer algoritmo.
  
  
• 00:35:00 Nesta seção, o instrutor explica o código usado para amostrar um ambiente no aprendizado por reforço. O código define um número máximo de etapas para o ambiente, configura um contador de pontuação e gera uma ação aleatória com base no espaço de ação definido pelo ambiente. As observações retornadas pelo ambiente após cada ação são acompanhadas por uma recompensa e um valor que indica se o episódio terminou. Os resultados são impressos e o ambiente é fechado após o teste. O instrutor também explica o conceito de espaço de observação e demonstra como ele pode ser amostrado.
  
  
• 00:40:00 Nesta seção, o instrutor explica as duas partes do ambiente, o espaço de ação e o espaço de observação, e como eles são representados na documentação do OpenAI Gym. O espaço de observação consiste em quatro valores que representam a posição do carrinho, velocidade, ângulo do polo e velocidades angulares do polo. Por outro lado, o espaço de ação tem duas ações possíveis, zero ou uma, onde zero empurra o carrinho para a esquerda e um empurra o carrinho para a direita. A seção também destaca os diferentes tipos de algoritmos no aprendizado por reforço, baseados em modelo e sem modelo, e como eles diferem. O instrutor se concentra no aprendizado por reforço sem modelo e se aprofunda nos algoritmos A2C e PPO, que serão usados no estágio de treinamento.
  
  
• 00:45:00 Nesta seção do vídeo, o instrutor explica como escolher o algoritmo de aprendizado por reforço apropriado com base no espaço de ação do ambiente que está sendo usado. Ele passa a explicar os diferentes tipos de algoritmos disponíveis em Stable Baselines, como A2C, DDPG, DQN, HER, PPO, SAC e TD3, e com quais espaços de ação eles funcionam melhor. O instrutor também discute as métricas de treinamento que devem ser consideradas durante o treinamento, como métricas de avaliação, métricas de tempo, métricas de perda e outras métricas. Ele lembra aos usuários que o Stable Baselines pode ser instalado com ou sem aceleração de GPU e fornece instruções para instalar o PyTorch se a aceleração de GPU for desejada.
  
  
• 00:50:00 Nesta seção, o instrutor discute como configurar a plataforma de computação para aprendizado por reforço, que é crucial para quem deseja aproveitar a aceleração de GPU. CUDA e cuDNN são suportados apenas em GPUs NVIDIA, portanto, os usuários devem garantir que possuem uma GPU NVIDIA para usar o CUDA para aproveitar a aceleração da GPU. Por outro lado, as GPUs AMD são suportadas pelo RockM, um pacote beta disponível apenas no Linux. O instrutor também enfatiza que o aprendizado profundo tradicional pode ter mais melhoria de desempenho com o uso de uma GPU do que o aprendizado por reforço. Por fim, o instrutor define o caminho do log e instancia o algoritmo e o agente.
  
  
• 00:55:00 Nesta seção, o instrutor demonstra como agrupar um ambiente não vetorizado dentro de um ambiente vetorizado fictício usando uma função lambda. Em seguida, eles definem o modelo, que é o agente que será treinado, como PPO e passam a política, o ambiente, o verboso e o caminho de log do tensorboard como argumentos. O instrutor passa a explicar os vários hiperparâmetros que podem ser passados para o algoritmo PPO. Por fim, eles demonstram como treinar o modelo usando a função model.learn e passando pelo número de etapas de tempo para treiná-lo, que neste exemplo é definido em 20.000. Depois que o modelo é treinado, o instrutor o testa e verifica as métricas de treinamento.

Parte 2

• 01:00:00 Nesta seção do vídeo, o instrutor mostra como salvar e recarregar um modelo treinado. O modelo é salvo usando a função `model.save()` e um caminho é definido para localizar o modelo salvo. O instrutor então demonstra como excluir o modelo salvo e recarregá-lo usando a função `ppo.load()`. A próxima etapa é testar o modelo treinado para ver como ele funciona. O instrutor explica que as métricas de rollout dependem do algoritmo usado para treinamento e mostra que o algoritmo `A2C` fornece essas métricas durante o treinamento, enquanto o algoritmo `PPO` requer um comando explícito para gerar essas métricas.
  
  
• 01:05:00 Nesta seção, o vídeo explica como usar o método activate_policy para testar o desempenho do modelo e determinar se o modelo PPO é considerado 'resolvido' neste caso específico. O método avalia_política é uma forma de testar o desempenho de um modelo, e o modelo é considerado resolvido se obtiver uma média de 200 ou mais. O método é passado pelo modelo, o ambiente, quantos episódios testar e se a renderização é necessária ou não. A recompensa média e o desvio padrão nessa recompensa são os valores que você obtém de avalia_política, e o fechamento do ambiente é feito usando emv.close. Por fim, o vídeo destaca como implantar o modelo em uma função encapsulada.
  
  
• 01:10:00 Nesta seção, o instrutor demonstra como usar as observações do ambiente para prever a melhor ação usando o agente, a fim de maximizar as recompensas. O bloco de código mostra como fazer alterações importantes para usar model.predict em vez de env.actionspace.sample para executar ações usando o modelo. O instrutor mostra que o agente executa melhor do que passos aleatórios e equilibra o mastro. O código também mostra as observações passadas para a função model.predict, com dois valores retornados, a ação do modelo e o próximo estado. O primeiro valor é usado aqui para determinar a melhor ação para o agente.
  
  
• 01:15:00 Nesta seção, o instrutor explica os principais componentes do aprendizado por reforço: o agente, o ambiente, a ação e a recompensa. Ele demonstra como definir um ambiente e treinar um modelo usando o aprendizado por reforço para acumular um valor de um a cada vez, mantendo o bastão na posição vertical e não caindo. O instrutor também mostra como visualizar os logs de treinamento usando o TensorBoard para monitorar o processo de treinamento.
  
  
• 01:20:00 Nesta seção do vídeo, o instrutor explica como usar o TensorBoard em um notebook Jupiter para visualizar as métricas de treinamento de um modelo de aprendizado por reforço. Ele demonstra como executar o comando TensorBoard usando um comando mágico e mostra como especificar o caminho do log de treinamento. O instrutor também mostra como visualizar as métricas de treinamento, como quadros por segundo, perda de entropia, taxa de aprendizado e perda de gradiente de política, no TensorBoard. Ele enfatiza que a recompensa média é a métrica mais importante a ser monitorada ao ajustar o desempenho do modelo. Ele conclui pedindo feedback e comentários dos telespectadores.
  
  
• 01:25:00 Nesta seção, o vídeo discute duas métricas principais para determinar o desempenho de um modelo de aprendizado por reforço - as métricas de recompensa e a duração média do episódio. O vídeo também fornece três estratégias para melhorar o desempenho do modelo se ele não estiver funcionando bem, incluindo treinamento por um período mais longo, ajuste de hiperparâmetros e exploração de diferentes algoritmos. A seção então se aprofunda em retornos de chamada, algoritmos alternativos e arquiteturas, discutindo especificamente como configurar um retorno de chamada para interromper o treinamento assim que um limite de recompensa for atingido e explorar diferentes arquiteturas e algoritmos de redes neurais. O vídeo também destaca a importância do uso de callbacks para modelos grandes que exigem um tempo maior de treinamento.
  
  
• 01:30:00 Nesta seção, o instrutor explica como usar callbacks no aprendizado por reforço para um treinamento mais flexível e eficiente. Dois callbacks são usados no exemplo: stop callback e eval callback. O callback stop especifica a recompensa média após a qual o treinamento deve parar, enquanto o callback eval avalia o melhor novo modelo e verifica se ele ultrapassou o limite de recompensa. O instrutor também demonstra como alterar a política especificando uma nova arquitetura de rede neural. No geral, os callbacks fornecem maior controle sobre os modelos de aprendizado por reforço, permitindo um treinamento mais personalizado e eficaz.
  
  
• 01:35:00 Nesta seção, o palestrante discute o processo de especificação de uma arquitetura de rede para um ator personalizado e função de valor em uma rede neural. Isso pode ser feito simplesmente alterando o número de unidades e camadas e passando-o para o modelo. O palestrante também enfatiza que os extratores de recursos personalizados podem ser definidos e mostra como usar um algoritmo alternativo, como DQN em vez de PPO, e destaca outros algoritmos disponíveis em Stable Baselines. O palestrante conclui apresentando o modelo DQN treinado.
  
  
• 01:40:00 Nesta seção, o instrutor discute os projetos que os alunos construirão usando técnicas de aprendizado por reforço. Eles começarão com o Project One, que é o jogo Breakout no Atari. Em seguida, eles também abordarão o Projeto Dois, onde usarão o aprendizado por reforço para construir um carro de corrida para simular a direção autônoma. Por fim, eles trabalharão no Projeto Três, que envolve a criação de ambientes personalizados usando os espaços do OpenAI Gym. O instrutor também explica como a importação de bibliotecas e dependências necessárias para os projetos são semelhantes às do curso principal, e só precisarão usar algoritmos diferentes dependendo do projeto.
  
  
• 01:45:00 Nesta seção, o instrutor em vídeo explica como configurar o ambiente Atari para aprendizado por reforço em Python. Devido a mudanças recentes, os usuários devem baixar os arquivos raw do atarimania.com e extraí-los em uma pasta para poder usar o ambiente. Depois de instalar os pacotes e dependências necessários, os usuários podem testar o ambiente usando as funções "emv.reset" e "emv.action_space". O espaço de observação é uma caixa que representa uma imagem com as dimensões 210x160x3. O instrutor também demonstra como testar um modelo dentro do ambiente.
  
  
• 01:50:00 Nesta seção, o instrutor mostra o código para jogar o Breakout usando ações aleatórias e aponta que o treinamento do modelo pode levar muito tempo. Para agilizar o treinamento, o instrutor vetoriza o ambiente e treina quatro ambientes diferentes ao mesmo tempo. O ambiente utilizado é o ambiente baseado em imagem, ao contrário da versão RAM do Breakout, pois será utilizada a política CNN. O código para configurar o modelo é mostrado, incluindo a especificação do caminho de log e o algoritmo A2C com a política CNN.
  
  
• 01:55:00 Nesta seção, o instrutor de vídeo usa aprendizado por reforço para treinar um modelo para jogar o jogo Atari "Breakout". O modelo usa uma política de rede neural convolucional (CNN), que é mais rápida de treinar do que uma política perceptron multicamadas. O ambiente é definido usando a função make_atari do OpenAI Gym e a vetorização é usada para acelerar o processo de treinamento. O modelo é treinado para 100.000 etapas e, após salvar e recarregar o modelo, ele é avaliado usando o método de política de avaliação. O modelo final atinge uma recompensa média de episódio de 6,1 com um desvio padrão de 1,9, uma melhoria significativa em relação a um agente aleatório. O instrutor também fornece informações sobre um modelo pré-treinado que foi treinado para 300.000 etapas e como carregá-lo e testá-lo.

Parte 3

• 02:00:00 Nesta seção, o instrutor discute como lidar com problemas de congelamento ao trabalhar com o ambiente, especificamente o Atari. Se o ambiente congelar, o notebook deve ser reiniciado e o kernel deve ser reiniciado após salvar o modelo. O instrutor então demonstra como treinar um agente de aprendizado por reforço para breakout, percorrendo o processo de importação de dependências, instalação de ROMs Atari, vetorização do ambiente para treinar em quatro ambientes Atari simultaneamente, treinamento do agente e, finalmente, avaliação e salvamento do modelo. O instrutor também mostra o impacto de treinar o modelo por mais tempo e disponibiliza os modelos treinados no repositório do Github para que os alunos experimentem por conta própria.
  
  
• 02:05:00 Nesta seção do vídeo sobre aprendizado por reforço em três horas, o instrutor começa mostrando os resultados do Projeto 1, que envolveu o treinamento de um modelo para jogar um jogo usando aprendizado por reforço. O modelo teve um desempenho significativamente melhor do que os modelos anteriores, com uma recompensa média em 50 episódios de 22,22 e um desvio padrão de 9,1. O instrutor então apresenta o Projeto 2, que envolve o uso de aprendizado por reforço para direção autônoma usando o ambiente de carro de corrida. Para montar o ambiente, o instrutor explica que é necessário instalar o swig e duas novas dependências, box 2d e piglet. O instrutor então passa pelo processo de testar o ambiente e importar as dependências necessárias.
  
  
• 02:10:00 Nesta seção, o vídeo discute o espaço de observação e ação do ambiente de corrida de carros para aprendizado por reforço. O espaço de observação é uma imagem de 96 por 96 por 3 com valores entre 0 e 255, enquanto o espaço de ação está entre menos um e um para três valores diferentes. A função de recompensa é 0,1 negativo para cada quadro e mais 1000 dividido por n para cada ladrilho de trilha visitado. O jogo é considerado resolvido quando o agente consegue consistentemente obter 900 ou mais pontos, o que pode levar algum tempo para ser alcançado com treinamento. O vídeo passa a treinar um modelo usando o algoritmo PPO e mostra como testar o ambiente de corrida usando o modelo treinado.
  
  
• 02:15:00 Nesta seção, o instrutor configura o ambiente para o carro autônomo usando o OpenAI Gym e o envolve dentro de um Vectorize Environment Wrapper fictício. Em seguida, o agente e o modelo são especificados usando o algoritmo PPO e o modelo é treinado para 100.000 etapas. O modelo salvo é carregado e avaliado no ambiente e, apesar da falta de tração do carro de alta potência, ele não avança, mas gira e faz rosquinhas. Por fim, o ambiente é fechado e o instrutor carrega um modelo treinado para 438.000 passos para testar.
  
  
• 02:20:00 Nesta seção, o instrutor carrega um modelo de carro autônomo que foi treinado para 438.000 passos e o testa na pista. Embora seja mais lento, ele segue a pista e obtém uma pontuação muito maior do que o modelo anterior treinado para 100.000 passos. O instrutor explica que o treinamento de agentes de aprendizado por reforço por um período mais longo pode produzir modelos muito melhores e, idealmente, esse modelo deveria ter sido treinado por 1 a 2 milhões de etapas para ter um desempenho ideal. Ele demonstra como testar o modelo usando um trecho de código do tutorial principal, que mostra que, mesmo quando treinado apenas em imagens, o modelo pode navegar com sucesso pela pista. Por fim, o instrutor treinou esse modelo por dois milhões de passos adicionais, melhorando seu desempenho e atingindo uma estimativa de recompensa em torno de 700.
  
  
• 02:25:00 Nesta seção, o instrutor carrega e executa um modelo que tem um desempenho significativamente melhor do que os modelos anteriores que ele treinou, apesar de ocasionalmente girar nas curvas. Ele mostra a nota de avaliação do modelo, que chegou a 800 pontos, uma melhora significativa em relação aos modelos anteriores. Ele observa que esse modelo foi treinado por uma duração mais longa e teve um alto desvio padrão. O instrutor então apresenta o último projeto, que envolve o uso de linhas de base estáveis para aprendizado por reforço em ambientes personalizados. Ele importa as dependências necessárias e incentiva os espectadores a entrar em contato caso encontrem alguma dificuldade.
  
  
• 02:30:00 Nesta seção do vídeo, o instrutor passa pelas várias dependências da academia ou dependências da academia OpenAI, ajudantes e material de linha de base estável que será usado no curso de aprendizado por reforço. Eles importam ginásio, que é a importação padrão, classe de ambiente de ginásio de env e os diferentes tipos de espaços, como discreto, caixa, dict, tupla, multibinário, multidiscreto. O instrutor explica como usar cada um desses espaços e como eles podem ser usados para diferentes propósitos. O instrutor também analisa os diferentes auxiliares que foram importados, como numpy, random e os, e o material de linha de base estável, incluindo ppo, common.vec_env, dummy_vec_nv e função avalia_policy.
  
  
• 02:35:00 Nesta seção do vídeo, o apresentador discute os diferentes tipos de espaços disponíveis no OpenAI Gym para aprendizado por reforço. Esses espaços incluem discreto, caixa, tupla, dict, multibinário e multidiscreto. O apresentador fornece exemplos e explicações para cada um desses espaços. O vídeo então discute a construção de um ambiente simulado para treinar um agente para regular a temperatura de um chuveiro. O objetivo final é atingir uma temperatura entre 37 e 39 graus, mas o agente não sabe disso a priori e deve aprender por tentativa e erro.
  
  
• 02:40:00 Nesta seção, o instrutor constrói uma concha para um ambiente de chuveiro implementando as quatro funções principais. Essas funções são init, step, render e reset. A função init inicializa o ambiente definindo o espaço de ação, o espaço de observação e o estado inicial. A função step executa uma ação e a aplica ao ambiente. A função render exibe o ambiente. A função reset redefine o ambiente para seu estado inicial. O instrutor também define uma duração de episódio de 60 segundos para o ambiente.
  
  
• 02:45:00 Nesta seção, o instrutor define a função degrau para o ambiente do chuveiro, que contém seis blocos de código. O primeiro bloco aplica o impacto da ação no estado, com zero, um e dois como as três ações possíveis. Zero diminui a temperatura em um grau, um deixa a temperatura igual e dois aumenta a temperatura em um grau. O segundo bloco diminui o tempo de banho em um segundo. O terceiro bloco define a recompensa, com recompensa de um se a temperatura estiver entre 37 e 39 graus e -1 se estiver fora desse intervalo. O quarto bloco verifica se o banho foi feito e define feito como verdadeiro se o tempo de banho for menor ou igual a zero. O quinto bloco cria um dicionário de informações em branco e o bloco final retorna o estado, a recompensa, se o banho terminou e o dicionário. A função reset redefine a temperatura inicial para seu valor padrão e redefine o tempo de banho para 60 segundos.
  
  
• 02:50:00 Nesta seção, o instrutor explica como criar um ambiente personalizado para aprendizado por reforço usando Python. Ele demonstra como definir o estado do ambiente e seus espaços de observação e ação. O instrutor também mostra como testar e treinar o modelo usando o ambiente definido e como salvar o modelo treinado após o aprendizado. Ele menciona que os ambientes de jogos levarão mais tempo para treinar em comparação com ambientes simples e incentiva a ter isso em mente ao planejar projetos e se comprometer com os clientes.
  
  
• 02:55:00 Nesta seção, o instrutor demonstra como testar e salvar o modelo treinado. Eles usam o método 'avaliar política' para testar o desempenho do modelo e, em seguida, salvam o modelo usando o método 'model.save'. Além disso, eles fornecem um breve resumo do curso, que abrange uma variedade de tópicos, desde a configuração do ambiente usando linhas de base estáveis até modelos de treinamento com diferentes algoritmos, incluindo PPO, A2C e DQN. Eles também discutem a criação de ambientes personalizados e projetos de construção, como treinar um modelo para jogar Breakout ou pilotar um carro em uma pista.
  
  
• 03:00:00 Nesta seção, o instrutor recomenda recursos adicionais para aprendizado adicional, incluindo o curso Reinforcement Learning de David Silva, um livro chamado Reinforcement Learning: An Introduction de Richard Sutton e Andrew Bartos, além de explorar o ajuste de hiperparâmetros, criar ambientes personalizados e implementando soluções de ponta a ponta, como construir um robô de carrinho e treiná-lo em um ambiente simulado antes de implementá-lo em um ambiente real usando um Raspberry Pi. O instrutor incentiva o feedback e as perguntas dos espectadores e os agradece por sintonizar.

[MetaQuotes]

Detecção de linguagem de sinais usando RECONHECIMENTO DE AÇÃO com Python | Modelo de aprendizado profundo LSTM

Código: https://github.com/nicknochnack/ActionDetectionforSignLanguage

Detecção de linguagem de sinais usando RECONHECIMENTO DE AÇÃO com Python | Modelo de aprendizado profundo LSTM

Neste vídeo do YouTube intitulado "Detecção de linguagem de sinais usando RECONHECIMENTO DE AÇÃO com Python | Modelo de aprendizado profundo LSTM", o apresentador explica como criar um fluxo de detecção de linguagem de sinais em tempo real usando detecção de ação e modelos-chave. O apresentador usa OpenCV e MediaPipe Holistic para extrair pontos-chave de mãos, rosto e corpo e, em seguida, TensorFlow e Keras para construir um modelo LSTM que prevê a ação que está sendo demonstrada em uma sequência de quadros. O apresentador passa pelo processo de acesso e extração de pontos-chave da webcam, configura um loop para acessar a webcam e facilita a detecção da língua de sinais aplicando os pontos de referência ao último quadro capturado da webcam. Eles também demonstram como modificar o código para lidar com pontos-chave ausentes e adicionar tratamento de erros ao modelo de pose e à detecção de marcos faciais. Por fim, o apresentador explica a função de extração de pontos-chave para detecção de linguagem de sinais usando reconhecimento de ação com Python.

O vídeo fornece uma explicação detalhada de como criar um modelo de detecção de linguagem de sinais usando reconhecimento de ação com Python. Para coletar os dados, o apresentador cria pastas para cada ação e sequência e modifica o loop do MediaPipe para coletar 30 valores de pontos-chave por vídeo para cada ação. Os dados são pré-processados criando rótulos e recursos para o modelo de aprendizado profundo LSTM, e o modelo é treinado usando TensorFlow e Keras. O modelo treinado é avaliado usando uma matriz de confusão de vários rótulos e uma função de pontuação de precisão. Por fim, a detecção em tempo real é estabelecida criando novas variáveis para detecção, concatenando quadros e aplicando lógica de previsão, com uma variável de limite implementada para renderizar resultados acima de uma determinada métrica de confiança.

O tutorial em vídeo mostra como usar Python e um modelo LSTM Deep Learning para detecção de linguagem de sinais usando reconhecimento de ação. O palestrante percorreu a lógica de previsão e explicou o código, tornando-o fácil de entender. Eles também mostraram aos visualizadores como ajustar o código usando o método append, aumentando o limite de detecção e adicionando visualização de probabilidade para tornar a detecção visualmente atraente. O palestrante também abordou como verificar se o resultado está acima do limite, como manipular probabilidades e como estender e modificar o projeto adicionando ações ou visualizações adicionais. Por fim, o palestrante apresentou a lógica adicional do modelo, que minimiza as falsas detecções e melhora a precisão do modelo, juntamente com um convite para apoiar o vídeo e o canal.

• 00:00:00 Nesta seção do vídeo, o criador explica seu objetivo de produzir um fluxo de detecção de língua de sinais em tempo real usando detecção de ação e modelos-chave. Eles usarão o MediaPipe Holistic para extrair pontos-chave de mãos, rosto e corpo e, em seguida, usarão TensorFlow e Keras para criar um modelo LSTM que prevê a ação que está sendo demonstrada em uma sequência de quadros. O processo inclui coletar dados sobre pontos-chave, treinar uma rede neural, avaliar a precisão e testar o modelo em tempo real usando o OpenCV e uma webcam. O criador descreve 11 etapas para realizar esse processo e começa instalando e importando dependências.
  
  
• 00:05:00 Nesta seção, o apresentador discute as diferentes dependências que serão usadas no projeto, incluindo OpenCV, MediaPipe, scikit-learn, NumPy, Matplotlib e TensorFlow. Depois de importar essas dependências, o apresentador passa pelo processo de acesso e extração de pontos-chave da webcam usando OpenCV e MediaPipe Holistic. O apresentador então configura um loop para acessar a webcam e renderizar vários quadros na tela, permitindo o teste do projeto em tempo real. Esse loop será usado várias vezes ao longo do projeto, inclusive ao extrair quadros e testar o projeto. Todo o código utilizado no projeto será disponibilizado no Github, incluindo os pesos treinados finais.
  
  
• 00:10:00 Nesta seção do vídeo, o apresentador explica como acessar a webcam usando o OpenCV e começar a percorrer todos os quadros. O apresentador usa a função "captura de vídeo" para ler o feed da webcam e inicia um loop que lerá, exibirá e aguardará o pressionamento de uma tecla para interromper o loop. O apresentador também explica como quebrar o loop normalmente e como solucionar problemas de número de dispositivo se a webcam não aparecer. Por fim, o apresentador apresenta o MediaPipe Holistic e o MediaPipe Drawing Utilities, dois módulos Python usados para baixar e aproveitar o modelo holístico para detecção de pose e desenhar os pontos de referência de pose em uma imagem.
  
  
• 00:15:00 Nesta seção da transcrição, o locutor configura uma função para facilitar a detecção da língua de sinais. A função recebe uma imagem e um modelo holístico de tubo de mídia e passa por uma série de etapas, incluindo a conversão de cores de BGR para RGB, fazendo a detecção e convertendo a imagem de volta para BGR, antes de retornar a imagem e os resultados ao loop para Renderização. As etapas são executadas simetricamente para garantir que a imagem seja definida como não gravável antes da detecção e de volta para gravável depois. O palestrante também explica a função cvtColor usada para converter a cor da imagem e mostra como chamar a função de detecção de canal de mídia no loop.
  
  
• 00:20:00 Nesta seção, o apresentador explica como acessar o modelo MediaPipe usando uma "instrução with" e define a confiança inicial e de rastreamento. Eles também mostram como acessar e visualizar os diferentes tipos de pontos de referência: face, mão esquerda e direita e pontos de referência de pose. O apresentador então demonstra como usar o MediaPipe Holistic para detectar pontos de referência e exibe os resultados no quadro. Por fim, eles mostram como renderizar os pontos de referência na tela escrevendo uma função.
  
  
• 00:25:00 Nesta seção, o YouTuber configura uma nova função chamada "draw_landmarks" que renderizará dados de marcos em uma imagem para permitir a visualização dos diferentes marcos detectados pelos modelos de dutos de mídia usados no projeto. A função usa a função auxiliar "mp.drawing" fornecida pelo canal de mídia para desenhar os pontos de referência e também requer os dados de imagem e ponto de referência como entradas. A função também permite a especificação de mapas de conexão e opções de formatação. O YouTuber então demonstra como usar a função "plot.imshow" do matplotlib para exibir o último quadro capturado da webcam.
  
  
• 00:30:00 Nesta seção, o palestrante corrige a cor da imagem e aplica os pontos de referência à imagem, passando-os pela função "desenhar pontos de referência". Os resultados do modelo de detecção de canal de mídia são acessados como o último quadro e os resultados da execução do loop. Os métodos "mp_drawing.draw_landmarks" se aplicam ao quadro atual para renderizar todas as conexões de mãos, poses e faces. O locutor então aplica a função "desenhar marcos" ao loop em tempo real e, antes da renderização, aplica a formatação usando as "especificações de desenho de marco" e "especificações de desenho de conexão" para desenhar os pontos e as conexões, respectivamente. Por fim, o locutor cria uma nova função chamada "desenhar marcos de estilo" para personalizar a função "desenhar marcos", se desejar.
  
  
• 00:35:00 Nesta seção, o palestrante atualiza a formatação da função de desenhar marcos, adicionando dois parâmetros adicionais para a função mp_drawing.drawing_spec - cor e raio do círculo. Eles demonstram as mudanças para o marco facial e explicam que o primeiro parâmetro colore o marco e o segundo parâmetro colore a conexão. O palestrante então copia as mudanças na função para cada um dos modelos de pose e mão, dando a cada modelo cores únicas. As mudanças são puramente cosméticas e não afetarão o desempenho, mas demonstram os diferentes modelos em ação.
  
  
• 00:40:00 Nesta seção, o tutorial em vídeo explica como extrair valores de pontos-chave da variável de resultados do modelo MediaPipe Holistic de maneira resiliente, concatenando-os em uma matriz numpy e lidando com erros. O tutorial mostra como extrair valores para um ponto de referência e atualizá-lo para todos os pontos de referência usando um loop e uma compreensão de lista. A matriz final com todos os pontos de referência é nivelada para ter todos os valores em uma matriz, em vez de vários conjuntos de pontos de referência.
  
  
• 00:45:00 Nesta seção, o apresentador explica como modificar o código para lidar quando não há pontos-chave devido à mão estar fora do quadro. Eles começam mostrando que os pontos de referência do lado esquerdo têm três valores cada e há 21 pontos de referência para um total de 63 valores necessários. Eles então aplicam uma instrução if que substitui os valores ausentes por uma matriz numpy em branco. Essa mesma modificação é então aplicada aos pontos de referência do lado direito, que também possuem 63 valores. O código extrai os diferentes pontos-chave concatenando os valores x, y e z juntos em uma grande matriz e, em seguida, compactando-a no formato adequado para uso no modelo LSTM.
  
  
• 00:50:00 Nesta seção, o palestrante discute como adicionar tratamento de erros ao modelo de pose e detecção de pontos de referência faciais e cria uma função chamada "extract_key_points" para extrair os pontos-chave necessários para detecção de pontos de referência e detecção de ação. A função usa matrizes numpy e percorre os resultados para extrair os valores x, y e z para cada ponto de referência e, em seguida, os nivela em uma matriz. O palestrante também menciona que o código estará disponível na descrição do vídeo e convida os espectadores a fazerem perguntas nos comentários.
  
  
• 00:55:00 Nesta seção do vídeo, o palestrante explica a função de extração de pontos-chave para detecção de linguagem de sinais usando reconhecimento de ação com Python. A função extrai os pontos-chave para pose, rosto, mão esquerda e mão direita e os concatena em uma matriz numpy achatada. Esses pontos-chave formam os valores de quadro usados para a detecção de linguagem de sinais usando a detecção de ação humana. O alto-falante também configura variáveis para o caminho de dados exportados e as ações a serem detectadas - olá, obrigado e eu te amo - usando 30 quadros de dados para cada ação.

• 01:00:00 Nesta seção do vídeo, o apresentador explica o processo de coleta de dados para detectar a língua de sinais usando o reconhecimento de ação com Python. Eles explicam que, para cada uma das três ações que desejam detectar, coletarão 30 vídeos de dados, com cada vídeo tendo 30 quadros de duração. Isso equivale a um pouco de dados, mas o apresentador garante aos espectadores que eles seguirão passo a passo. Eles criam pastas para cada ação e sequência de ação, nas quais os 30 pontos-chave de cada quadro de cada sequência serão armazenados como um array numpy. O apresentador também menciona que na etapa 11, eles mostrarão aos espectadores como concatenar palavras para formar frases.
  
  
• 01:05:00 Nesta seção, o instrutor mostra como coletar dados para o modelo de reconhecimento de língua de sinais. Ele começa criando pastas para as três classes diferentes de sinais - olá, obrigado e eu te amo - e suas pastas de sequência individuais correspondentes. Em seguida, ele modifica o loop de pipe de mídia para percorrer cada ação, vídeo e quadro para coletar os dados. Para garantir que os quadros não sejam coletados muito rapidamente, ele adiciona uma pausa entre cada vídeo usando uma declaração lógica. Ao fazer isso, o modelo coletará 30 valores de pontos-chave por vídeo, construindo efetivamente um conjunto empilhado de três ações, cada uma com 30 vídeos por ação e 30 quadros por vídeo.
  
  
• 01:10:00 Nesta seção, o criador do vídeo fornece uma explicação da lógica de coleta em um script Python que usa OpenCV e modelos de aprendizado profundo para detectar gestos de linguagem de sinais do vídeo. A lógica envolve enviar texto para a tela e fazer uma pausa a cada segundo quadro. O criador do vídeo também demonstra o uso de np.save para salvar os quadros como arrays numpy, que são armazenados em uma pasta mp_data. Eles então fornecem o bloco de código final para a extração do ponto-chave e salvamento dos quadros nas pastas corretas.
  
  
• 01:15:00 Nesta seção da transcrição, o palestrante explica a lógica aplicada para percorrer suas ações e sequências (vídeos), aplicar detecção de canal de mídia, desenhar pontos de referência estilizados e extrair diferentes pontos-chave para serem salvos em pastas específicas. Eles usarão três ações (olá, obrigado e eu te amo) e coletarão 30 quadros por ação para 30 sequências. Antes de executar esse código, eles verificam se há erros e ajustam a largura da linha para garantir que a fonte não seja obscurecida. Depois que o código é executado, o pop-up diz "Iniciando a coleta", eles têm dois segundos para se posicionar para executar a ação e 30 quadros para isso. O código deve ser capaz de fazer um loop e coletar dados indefinidamente.
  
  
• 01:20:00 Nesta seção do vídeo, o apresentador demonstra como coletar dados da língua de sinais usando as bibliotecas MediaPipe e OpenCV em Python. O apresentador sugere capturar vários ângulos de sinais de mão para melhor desempenho do modelo e também menciona que ter 30 sequências de 30 quadros cada tende a funcionar bem. Os pontos-chave coletados pelo MediaPipe são usados no lugar da imagem para tornar o modelo mais resiliente em vários cenários. O apresentador também explica que os dados coletados são armazenados como arrays numpy para uso futuro.
  
  
• 01:25:00 Nesta seção, o vídeo se concentra no pré-processamento dos dados e na criação de rótulos e recursos para o modelo de aprendizagem profunda LSTM. O vídeo começa importando as dependências e depois criando um mapa de rótulos, que é basicamente um dicionário que representa cada uma das diferentes ações. Em seguida, os dados são lidos e reunidos para estruturá-los em uma grande matriz com 90 matrizes, cada uma contendo 30 quadros com 1662 valores representando os pontos-chave. Duas matrizes em branco são criadas, sequências e rótulos, onde as sequências representam os dados do recurso e os rótulos representam os dados do rótulo. O código então percorre cada uma das ações e sequências, criando uma matriz em branco para janelas para representar todos os quadros diferentes para essa sequência específica. Finalmente, numpy.load é usado para carregar cada quadro.
  
  
• 01:30:00 Nesta seção, o palestrante passa pelo processo de pré-processamento dos dados, armazenando-os em uma matriz numpy e convertendo os rótulos em uma representação codificada a quente usando a função "to_categorical". Eles então usam a função "train_test_split" para particionar os dados em conjuntos de treinamento e teste. O conjunto de treinamento consiste em 85 sequências e o conjunto de teste possui cinco sequências. O palestrante também importa as dependências necessárias, incluindo o modelo sequencial, a camada LSTM e a camada densa, enquanto se prepara para treinar uma rede neural LSTM usando TensorFlow e Keras.
  
  
• 01:35:00 Nesta seção, o palestrante discute as dependências necessárias para construir uma rede neural, incluindo sequencial, lstm, densa e tensorboard. Eles explicam que o sequencial facilita a adição de camadas ao modelo e o lstm é usado para análise temporal e detecção de ação. O palestrante também demonstra como configurar retornos de chamada do tensorboard para monitorar o progresso do treinamento. Em seguida, eles constroem a arquitetura da rede neural, que inclui a adição de três conjuntos de camadas lstm e a especificação das funções de ativação e do formato de entrada. Por fim, eles mencionam a importância de não retornar as sequências à camada densa e recomendam recursos adicionais de aprendizado.
  
  
• 01:40:00 Nesta seção do vídeo, o apresentador analisa os diferentes tipos de camadas adicionadas ao modelo LSTM, especificando que as próximas três camadas são todas densas. Cada camada densa usa 64 e 32 unidades densas ou neurônios totalmente conectados com valores de ativação de ReLU. A camada final é a camada de ações, que extrai os valores retornados como três unidades de rede neural usando o valor de ativação de softmax. O modelo prevê uma ação como "Olá", e essa saída é passada por 30 quadros mais 1.662 pontos-chave e pré-processada para extrair as ações. O apresentador explica como eles chegaram ao uso do MediaPipe e da camada LSTM, discutindo a pesquisa e o desenvolvimento que realizaram. Finalmente, o modelo é compilado usando entropia cruzada categórica como a função de perda, e é ajustado e treinado com x train e y train para o número especificado de épocas.
  
  
• 01:45:00 Nesta seção, o vídeo demonstra o processo de treinamento de um modelo de aprendizado profundo LSTM para detecção de linguagem de sinais usando reconhecimento de ação com Python. O modelo usa o modelo MediaPipe Holistic, que não requer um gerador de dados, pois os dados podem caber na memória. O vídeo mostra como configurar o processo de treinamento com o TensorBoard e como monitorar a precisão e a perda do modelo durante o treinamento no TensorBoard. O vídeo também inclui como interromper o processo de treinamento assim que um nível razoável de precisão for alcançado e como inspecionar a estrutura do modelo usando a função model.summary.
  
  
• 01:50:00 Nesta seção, o palestrante treina um modelo e faz previsões usando o modelo salvo. O modelo usa a técnica de aprendizado profundo LSTM para identificar as ações da linguagem de sinais. O modelo prevê a maior probabilidade de ação detectada com uma função softmax. O valor previsto é comparado com o valor real para avaliar o desempenho do modelo. O alto-falante salva o modelo treinado como action.h5 e o recarrega com uma função de compilação e carregamento. Importando métricas do sklearn, o palestrante avalia o desempenho da matriz de confusão multi-rótulo do modelo.
  
  
• 01:55:00 Nesta seção do vídeo, o apresentador explica como avaliar o desempenho do modelo treinado usando uma matriz de confusão de vários rótulos e uma função de pontuação de precisão. A matriz de confusão representa os verdadeiros positivos e verdadeiros negativos, e quanto maior o número desses valores no canto superior esquerdo e no canto inferior direito, melhor será o desempenho do modelo. A função de pontuação de precisão fornece a porcentagem de previsões corretas do modelo. O modelo treinado é então avaliado usando os dados de teste e o loop é restabelecido para detecção em tempo real, o que envolve a criação de novas variáveis para detecção, concatenação de quadros e aplicação de lógica de previsão. Uma variável de limite também é implementada para renderizar resultados acima de uma determinada métrica de confiança.
  
  
• 02:00:00 Nesta seção, o palestrante explica sua lógica de previsão para detecção de linguagem de sinais usando reconhecimento de ação com Python e modelo de aprendizado profundo LSTM. Eles começam extraindo pontos-chave e anexando-os a uma sequência de 30 quadros. Se o comprimento da sequência for igual a 30, eles executarão a previsão chamando model.predict com as dimensões expandidas da sequência. Eles então imprimem a classe prevista usando np.argmax e as ações definidas anteriormente. O palestrante também insere pontos-chave no início da sequência para resolver a lógica e passa a adicionar lógica de visualização ao código.
  
  
• 02:05:00 Nesta seção, o palestrante detalha o código explicando como o programa verifica se o resultado está acima do limite extraindo o resultado da pontuação mais alta usando "mp.argmax" e passando por "res". A lógica do programa é verificar se a última palavra corresponde à previsão atual. Em caso afirmativo, o programa não será acrescentado ao comprimento da frase. Se não corresponder, o programa anexará a ação detectada atual em nossa matriz de sentenças. O comprimento da frase deve incluir até cinco palavras para que o programa não tente renderizar um array gigante. Por fim, o programa colocará um texto e um retângulo na imagem para exibir a frase.
  
  
• 02:10:00 Nesta seção, o vídeo demonstra como usar o Python e um modelo LSTM Deep Learning para detectar a linguagem de sinais usando o reconhecimento de ação. O tutorial orienta o ajuste do código para usar o método append e o aumento do limite de detecção para melhor precisão. O vídeo também mostra como renderizar as probabilidades com uma função rápida para criar uma visualização de probabilidade, tornando a saída da detecção visualmente atraente. No geral, o tutorial fornece um excelente exemplo de uso de modelos de aprendizado profundo para detectar linguagem de sinais com Python, tornando-o um excelente recurso para quem deseja criar projetos semelhantes.
  
  
• 02:15:00 Nesta seção do vídeo, o apresentador demonstra uma função de visualização de probabilidade que permite visualizar as diferentes ações e como suas probabilidades são calculadas em tempo real. A função usa cv2.rectangle para colocar um retângulo dinâmico no quadro de saída e, em seguida, o posiciona e preenche com base na ação com a qual estamos trabalhando no momento, que usa o método de texto cv2.put para exibir os valores de texto. O apresentador mostra como essa função pode ser inserida no loop para visualizá-la em tempo real, e podemos ver que ela está detectando e reconhecendo diferentes ações, como olá, obrigado e eu te amo com base nos valores de probabilidade. O apresentador destaca que existem muitos aplicativos para essa função e demonstra como o código pode ser usado para detectar e reconhecer diferentes ações em diversos cenários.
  
  
• 02:20:00 Nesta seção do vídeo, o apresentador recapitula o processo de seu projeto de detecção de língua de sinais. Eles configuraram pastas para coleta, coletaram pontos-chave, pré-processaram os dados, construíram uma rede neural LSTM, fizeram previsões e testaram em tempo real. Eles foram capazes de obter detecções em tempo real, incluindo a visualização de probabilidade. Eles fornecem uma demonstração de como corrigiram o código para capturar os quadros corretos e anexá-los à sequência movendo dois pontos e adicionando um negativo. Eles também adicionaram uma linha para anexar suas previsões a uma nova matriz de previsão para garantir mais estabilidade ao prever ações. Por fim, eles oferecem aos usuários a possibilidade de estender e modificar o projeto adicionando ações, cores e/ou visualizações adicionais conforme desejarem.
  
  
• 02:25:00 Nesta seção, o palestrante demonstra como o modelo de detecção de ação se tornou mais estável e resiliente ao implementar uma lógica adicional. O modelo agora é capaz de minimizar as falsas detecções e manter a detecção por períodos mais longos, melhorando sua precisão. O palestrante também menciona que os pesos treinados para o modelo estarão disponíveis no repositório GitHub para os usuários aproveitarem. O vídeo termina com um convite para dar um joinha e se inscrever no canal.

[MetaQuotes]

Numerics of Machine Learning na Universidade de Tübingen no período de inverno de 2022/23. Aula 1 - Introdução -- Philipp Hennig

Numéricos de ML 1 -- Introdução -- Philipp Hennig

Neste vídeo, Philipp Hennig discute a importância de entender os algoritmos numéricos no aprendizado de máquina e apresenta o conteúdo do curso para o semestre. O primeiro algoritmo numérico abordado é a Álgebra Linear, com aplicação em Regressão de Processos Gaussianos. Hennig também discute o papel da simulação, equações diferenciais, integração e otimização no aprendizado de máquina. Ele apresenta novos desenvolvimentos em algoritmos numéricos, como espinhos algorítmicos, observáveis e algoritmos numéricos probabilísticos. Ao longo do vídeo, Hennig enfatiza a importância de atualizar algoritmos clássicos usados em aprendizado de máquina para resolver problemas complexos e destaca o papel de escrever código nesta aula de ciência da computação.

Philipp Hennig está apresentando seu curso Numerics of Machine Learning, que visa explorar como os algoritmos de aprendizado de máquina funcionam dentro da caixa e como eles podem ser adaptados ou alterados para melhorar as máquinas de aprendizado. O conhecimento altamente técnico em algoritmos numéricos e algoritmos de aprendizado de máquina é muito procurado por pesquisadores e profissionais da indústria. O curso consistirá em teoria e trabalho de codificação, com atribuições classificadas em um sistema binário. Hennig enfatiza a importância dos algoritmos numéricos no aprendizado de máquina e convida os alunos a participar desse experimento de ensino exclusivo com nove instrutores diferentes.

• 00:00:00 Nesta seção, Philipp Hennig apresenta a importância de entender os algoritmos numéricos no aprendizado de máquina. Enquanto os algoritmos de aprendizado de máquina recebem dados como entrada e produzem modelos que preveem ou agem no mundo, o processo de aprendizado real envolve computação numérica. Ao contrário dos algoritmos clássicos de IA, os algoritmos contemporâneos de aprendizado de máquina usam algoritmos numéricos, como métodos de álgebra linear, simulação, integração e otimização como primitivos para esses cálculos. Philipp define algoritmos numéricos como métodos que estimam uma quantidade matemática que não tem uma solução de forma fechada e pode dar errado ao contrário das operações atômicas que sempre funcionam. Como os algoritmos numéricos são fundamentais para o aprendizado de máquina, é importante entendê-los para garantir que funcionem corretamente.
  
  
• 00:05:00 Nesta seção, o palestrante discute a diferença entre funções regulares e algoritmos numéricos, observando que os últimos tendem a ter suas próprias bibliotecas e várias sub-rotinas para escolher. Ele então fornece um exemplo de um algoritmo numérico prototípico escrito em 1993 na linguagem Forth, implementando um algoritmo inventado por dois matemáticos em 1975. Isso destaca o fato de que os algoritmos numéricos são antigos e têm interfaces precisas, tornando-os difíceis de modificar. Os engenheiros de aprendizado de máquina frequentemente encontram tarefas numéricas e foram capazes de utilizar esses algoritmos antigos desenvolvidos por outros campos, mas isso pode ser problemático se a tarefa em questão não corresponder com precisão aos recursos do método. O palestrante sugere que isso pode se tornar um problema no aprendizado de máquina ao tentar resolver problemas para os quais os métodos numéricos existentes não são suficientes.
  
  
• 00:10:00 Nesta seção, Philipp Hennig apresenta o tópico de algoritmos numéricos e o conteúdo do curso para o período. A álgebra linear, a camada base do aprendizado de máquina, é o primeiro algoritmo numérico que eles cobrem. Um exemplo de sua aplicação é na Regressão de Processo Gaussiano, onde duas funções são utilizadas para inferência: Média posterior e Função de covariância posterior. Essas funções são definidas usando métodos de kernel e sua implementação envolve o método de decomposição de Cholesky, em vez de calcular o inverso de uma matriz. Hennig também apresenta um trecho de código Python e explica por que se deve usar a decomposição de Cholesky em vez de calcular o inverso de uma matriz.
  
  
• 00:15:00 Nesta seção do vídeo, o palestrante Philipp Hennig discute o problema com as máquinas de kernel, principalmente no que diz respeito à sua incapacidade de escalar bem para grandes quantidades de dados. Ele explica que os cálculos caros necessários para máquinas de kernel os tornam difíceis de usar no aprendizado de máquina contemporâneo. No entanto, Hennig também sugere que existem outros algoritmos de álgebra linear que podem ser usados para acelerar os cálculos, aproveitando a estrutura e as aproximações do conjunto de dados, levando a soluções com regressão de processo gaussiano que escalam para grandes conjuntos de dados.
  
  
• 00:20:00 Nesta seção, Philipp Hennig apresenta algoritmos de simulação e seu papel no aprendizado de máquina. Os métodos de simulação simulam a trajetória de um sistema dinâmico ao longo do tempo e podem estimar X. Eles aparecem no aprendizado de máquina ao construir agentes como um carro autônomo ou ao criar um algoritmo de aprendizado de máquina que faz uso de insights físicos, como científicos aprendizado de máquina. As equações diferenciais, como a equação de Schrödinger, são tipicamente usadas para codificar o conhecimento da natureza. Além disso, Hennig fornece um exemplo de um problema simples de previsão dos casos de COVID-19 na Alemanha ao longo de um ano e meio para explicar por que as redes neurais profundas e os processos gaussianos não funcionam na solução desse problema.
  
  
• 00:25:00 Nesta seção, Philipp Hennig discute o uso de equações diferenciais em sistemas de modelagem, especificamente os modelos SIR que são comumente usados em simulações, e o desafio de incorporar dinâmicas do mundo real, como bloqueios, nesses modelos. Ele sugere o uso de uma rede neural para tornar o coeficiente beta dependente do tempo, mas observa a dificuldade em fazê-lo devido à falta de derivadas no código. No entanto, ele destaca o desenvolvimento recente de um algoritmo em Jax que resolve esse problema.
  
  
• 00:30:00 Nesta seção, Philipp Hennig discute um algoritmo chamado inferência baseada em simulação, que é uma forma atual de resolver problemas complexos. Esse algoritmo envolve um loop for aninhado que avalia a função f várias vezes e retorna o gradiente e faz uma etapa de descida do gradiente. Hennig explica que para criar um algoritmo mais flexível e rápido que esse código primitivo, podemos construir nosso próprio método que constrói uma lista de números dentro do código do fóton de forma procedural e os adapta. Esse método envolve uma espinha de uma cadeia de Markov que pode pendurar operadores nela, como distribuição de probabilidade e operadores de informação, para informar o algoritmo sobre fatores desconhecidos. Ao fazer isso, podemos resolver esses problemas sem chamar um loop for repetidas vezes em um loop externo, o que consumiria muito tempo.
  
  
• 00:35:00 Nesta seção, Philipp Hennig discute a importância de atualizar algoritmos clássicos usados em aprendizado de máquina, que têm mais de 100 anos. Ele apresenta a ideia de espinhos algorítmicos que podem operar em diferentes operadores de informação e podem criar novas funcionalidades. Hennig então discute o papel da integração no aprendizado de máquina, que é uma operação elementar de inferência paciente. A operação elementar para o aprendizado de máquina probabilístico é calcular uma distribuição posterior, tomando uma distribuição conjunta e dividindo-a por um marginal, o que envolve integração. Por fim, Hennig discute a importância da otimização, que é a operação fundamental no aprendizado de máquina, envolvendo a computação de valores que minimizam as funções de perda. Esses algoritmos formam a base para programas diferenciáveis, para os quais o gradiente da função pode ser calculado automaticamente.
  
  
• 00:40:00 Nesta seção, Philipp Hennig discute algoritmos de otimização e sua importância no aprendizado de máquina. Embora métodos clássicos como BFGS e minimize sejam armazenados em scipy.optimize, novos métodos como SGD e Adam são agora a norma em aprendizado de máquina. No entanto, esses métodos geralmente exigem uma taxa de aprendizado e muita supervisão, ao contrário dos métodos mais antigos, que podem convergir para um mínimo e funcionar em qualquer problema diferenciável. Para lidar com as limitações desses novos métodos em grandes conjuntos de dados com milhões de pontos de dados, uma descida de gradiente em lote é usada para calcular uma soma muito menor, que é um estimador imparcial daquilo em que estamos interessados. mais eficientes e eficazes, eles ainda se baseiam nos mesmos princípios dos algoritmos antigos, o que pode causar problemas para determinadas aplicações.
  
  
• 00:45:00 Nesta seção do vídeo, o palestrante discute a possibilidade de calcular a variância além do gradiente em algoritmos de aprendizado profundo. Ele argumenta que a omissão da computação de variância do processo de otimização ocorre porque a otimização ainda é vista como um problema de computação de gradiente, em vez de um problema de uso de variáveis aleatórias para encontrar pontos que generalizam bem. No entanto, ele destaca a importância de incluir a incerteza decorrente da aleatoriedade nos cálculos, observando que é essencial construir melhores configurações de treinamento para redes neurais profundas. Ele conclui mencionando as próximas palestras que irão aprofundar este tema.
  
  
• 00:50:00 Nesta seção, Philipp Hennig discute o uso de observáveis para adicionar novas funcionalidades a redes neurais profundas, como incerteza ou transformá-las em uma rede neural profunda bayesiana sem usar os caros algoritmos Monte Carlo da cadeia de Markov. Ele também explica como os algoritmos numéricos usados para treinar algoritmos de aprendizado de máquina são, na verdade, os próprios algoritmos de aprendizado de máquina, pois estimam uma quantidade desconhecida ou variável latente enquanto observam dados tratáveis e observáveis. Isso é semelhante ao processo de inferência, em que uma quantidade latente é estimada com base nos resultados observados de um cálculo.
  
  
• 00:55:00 Nesta seção, Philipp Hennig apresenta o conceito de algoritmos numéricos como máquinas de aprendizado e discute a ideia por trás da construção de algoritmos numéricos desde o início como algoritmos numéricos probabilísticos. Estes são algoritmos que usam uma distribuição de probabilidade descrevendo sua tarefa e usam a CPU ou a GPU como fonte de dados para refinar sua estimativa de qual é a solução para a tarefa numérica. Hennig enfatiza que a aula não é uma aula típica de análise numérica, pois o foco é entender as máquinas por dentro como máquinas de aprendizado e construir novos algoritmos na linguagem de aprendizado de máquina. Os alunos podem esperar escrever muito código nesta aula de ciência da computação.
  
  
• 01:00:00 Nesta seção, Philipp Hennig apresenta seu curso sobre Numerics of Machine Learning, que ele afirma ser o primeiro curso dedicado desse tipo no mundo. O curso visa aprofundar o funcionamento dos algoritmos de aprendizado de máquina, especificamente como eles funcionam dentro da caixa e como podem ser alterados ou adaptados para melhorar as máquinas de aprendizado. A natureza altamente técnica dos algoritmos numéricos e dos algoritmos de aprendizado de máquina significa que o conhecimento nessa área é muito procurado por pesquisadores e profissionais da indústria. As palestras serão ministradas por sua equipe de alunos de doutorado altamente experientes, que passaram anos pesquisando e pensando sobre o funcionamento interno desses algoritmos e, portanto, estão mais preparados para discutir os detalhes técnicos mais sutis do que um professor.
  
  
• 01:05:00 Nesta seção, Philipp Hennig discute a estrutura do curso e os requisitos do curso. O curso incluirá trabalho teórico e de codificação, pois espera-se que os alunos resolvam problemas numéricos usando código Python ou Julia. Os exercícios serão enviados em PDF, com soluções graduadas de forma binária – uma marca de seleção será dada para uma boa solução e uma cruz para uma insatisfatória. Os alunos receberão um ponto de bônus por cada nota, que contará para o resultado do exame final. O exame acontecerá em 13 de fevereiro ou 31 de março do próximo ano, e a aprovação no primeiro exame é incentivada, pois uma redefinição pode não estar disponível. Finalmente, os alunos interessados em obter um grau superior em algoritmos numéricos em aprendizado de máquina ou computação centrada em dados são incentivados a fazer este curso, pois oferece amplas oportunidades de pesquisa aplicada em vários campos.
  
  
• 01:10:00 Nesta seção, Philipp Hennig enfatiza a importância dos algoritmos numéricos no aprendizado de máquina, afirmando que eles são os motores que impulsionam a máquina de aprendizado. Ele descreve como entender esses algoritmos e sua linguagem de inferência bayesiana pode levar a soluções de aprendizado de máquina mais rápidas, confiáveis e fáceis de usar. Hennig enfatiza que, embora os algoritmos numéricos clássicos sejam importantes, eles devem ser vistos pelas lentes do aprendizado de máquina, adotando a perspectiva de máquinas de aprendizado como um meio de integrar a simulação e o aprendizado profundo de uma maneira mais holística. Ele convida os alunos a participarem desse emocionante experimento de ensino de aprendizado de máquina com uma configuração exclusiva de nove instrutores diferentes.

[MetaQuotes]

Aula 2 -- Álgebra Linear Numérica -- Marvin Pförtner

Numéricos de ML 2 -- Álgebra Linear Numérica -- Marvin Pförtner

A álgebra linear numérica é fundamental para aprendizado de máquina, processos gaussianos e outros métodos de regressão não paramétricos. A palestra cobre vários aspectos da álgebra linear numérica, incluindo a importância de entender a estrutura de uma matriz para uma multiplicação mais eficiente, a otimização de algoritmos de aprendizado de máquina por meio da solução de problemas de seleção de hiperparâmetros e matrizes de computação de kernel, e a solução de um sistema linear usando o decomposição LU, entre outros. A palestra também enfatiza a importância de implementar algoritmos adequadamente, pois o algoritmo usado para operações matemáticas tem um impacto significativo no desempenho, estabilidade e consumo de memória.

Na segunda parte do vídeo, Marvin Pförtner discute a importância da álgebra linear numérica em algoritmos de aprendizado de máquina. Ele cobre vários tópicos, incluindo decomposição LU, decomposição de Cholesky, lema de inversão de matriz e regressão de processo gaussiano. Pförtner enfatiza a importância de utilizar a estrutura para tornar os algoritmos mais eficientes e destaca a importância da estabilidade numérica na resolução de grandes sistemas de equações na regressão do processo gaussiano. Ele também discute técnicas como aprendizado ativo e aproximações de classificação baixa para lidar com grandes conjuntos de dados e as possíveis limitações de memória de matrizes de kernel. No geral, o vídeo mostra o papel crucial que a álgebra linear numérica desempenha em muitos aspectos do aprendizado de máquina.

• 00:00:00 Nesta seção, um aluno de doutorado discute a importância da álgebra linear numérica no aprendizado de máquina e nos processos Gaussianos. A álgebra linear numérica é fundamental para o aprendizado de máquina e é um conjunto de ferramentas necessárias para implementar algoritmos. A palestra abrange tarefas fundamentais em álgebra linear numérica importantes para o aprendizado de máquina, explorando a estrutura para tornar os algoritmos de álgebra linear numérica rápidos e confiáveis e implementando a regressão do processo Gaussiano adequadamente. A palestra também cita exemplos de aplicações de álgebra linear numérica, como teoria básica de probabilidade, modelos lineares gerais, análise de componentes principais e produtos de matriz-vetor que fazem redução de dimensionalidade.
  
  
• 00:05:00 Nesta seção, o palestrante discute a álgebra linear numérica no contexto do aprendizado de máquina. Ele explica como os processos Gaussianos, um método de regressão não paramétrico em aprendizado de máquina, dependem de uma medida de probabilidade anterior, que é um processo Gaussiano que gera uma matriz Gram de kernel definida simétrica e positiva. A informação generativa nesta matriz permite algoritmos eficientes e confiáveis. O palestrante também menciona como equações semelhantes se aplicam a uma classe maior de modelos, incluindo métodos de kernel e regressão de Ridge. Ele também discute brevemente como a álgebra linear numérica é usada para resolver equações diferenciais parciais lineares e em métodos de otimização para otimização local de funções de perda.
  
  
• 00:10:00 Nesta seção, o palestrante discute a importância da álgebra linear no aprendizado de máquina e fornece exemplos para ilustrar essa importância. As operações de álgebra linear, como a multiplicação de vetores de matrizes, soluções de sistemas lineares e decomposições de matrizes, são fundamentais para muitos modelos de aprendizado de máquina. Além disso, ele observa que muitos modelos de aprendizado de máquina são realmente ruidosos, pois usam uma estimativa ruidosa da matriz com a qual pretendem resolver sistemas lineares. Finalmente, ele enfatiza que os determinantes logarítmicos são essenciais no caso da densidade gaussiana e da regressão GP para obter estimativas posteriores máximas.
  
  
• 00:15:00 Nesta seção, o palestrante enfatiza a importância da multiplicação eficiente de Matrix Vector em álgebra linear numérica e aprendizado de máquina. Eles dão um exemplo de como até mesmo tarefas simples podem se tornar computacionalmente inviáveis se a expressão matemática não for transformada em um algoritmo adequadamente. O palestrante também destaca a importância de identificar a estrutura na Matriz para uma multiplicação mais eficiente. Eles concluem afirmando que o algoritmo que implementa uma operação matemática tem um impacto significativo no desempenho, estabilidade e consumo de memória.
  
  
• 00:20:00 Nesta seção, o palestrante enfatiza a importância de entender a estrutura de uma matriz para otimizar os algoritmos de aprendizado de máquina. Ele explica que, se você sabe que há uma estrutura de classificação inferior dentro de uma matriz, deve usar métodos especializados em matrizes inferiores para fatorá-la, em vez de multiplicar a matriz completa. Ele explica que o abaixamento é apenas um tipo de estrutura, e existem várias estruturas matriciais, como matrizes esparsas e matrizes kernel, que também dependem de entradas diferentes de zero e dimensões de entrada do regressor. O palestrante também aborda como armazenar matrizes de kernel para obter economia de memória.
  
  
• 00:25:00 Nesta seção, o palestrante discute como armazenar e avaliar matrizes kernel para processos gaussianos de forma eficiente. Se os pontos de dados excederem um determinado limite, a abordagem ingênua de armazená-los não será mais viável devido a problemas de memória. Existem bibliotecas disponíveis que escrevem kernels CUDA muito eficientes e usam GPUs para computar processos gaussianos em um laptop usando centenas de milhares de pontos de dados. O palestrante também fala sobre matrizes com uma forma funcional geral, como gráficos de autodiferença, que requerem os mesmos requisitos de tempo e espaço. Por fim, o palestrante mergulha em um algoritmo concreto de aplicação de regressão bayesiana a processos gaussianos, onde o núcleo da medida gaussiana é a covariância da função desconhecida. O palestrante apresenta um gráfico da medida posterior sobre a função em conjunto com os dados observados e como a quantificação da incerteza funciona bem. No entanto, o problema surge ao calcular o inverso, que escala de forma bastante proibitiva, tornando a abordagem ingênua de calcular uma matriz de grama do kernel a partir de n pontos de dados inviável para n grande.
  
  
• 00:30:00 Nesta seção, o palestrante discute a complexidade numérica da computação de matrizes de kernel em processos gaussianos, que podem se tornar proibitivamente caros. Além disso, existem hiperparâmetros que precisam ser ajustados para o kernel, como escala de saída e escala de comprimento, a fim de otimizar o anterior para explicar o conjunto de dados observados. O palestrante descreve uma abordagem bayesiana para resolver esse problema de seleção de modelo calculando a verossimilhança marginal logarítmica e minimizando uma função de perda que consiste em uma compensação entre o ajuste do modelo e a complexidade representada pelo fator de normalização da distribuição gaussiana. O palestrante mostra exemplos de underfitting e overfitting severos e explica como o trade-off entre esses dois termos pode ser encontrado para alcançar o melhor desempenho do modelo.
  
  
• 00:35:00 Nesta seção, Marvin Pförtner discute a solução de um sistema linear. A solução requer M mais um resolve onde M é o número de pontos de dados nos quais queremos avaliar nosso regressor. O sistema é simétrico e positivo definido no caso mais geral, mas pode haver estruturas adicionais para alavancar, pois o sistema geralmente é enorme e geralmente não podemos resolver isso para conjuntos de dados muito grandes. Uma decomposição de matriz muito importante é a decomposição de Lu. O algoritmo usado para resolver um sistema triangular inferior é a substituição direta, que decompõe a matriz em quatro partes: escalar no canto inferior direito, a coluna acima que é zero, um vetor linha à esquerda e outra parte triangular chamada L menos li menos um acima dele, que também é triangular inferior.
  
  
• 00:40:00 Nesta seção, Marvin Pförtner discute como resolver sistemas onde a matriz do sistema é triangular inferior, com dimensão n menos um. Ao dividir a última linha, o sistema pode ser resolvido usando um algoritmo simples. Métodos recursivos são então usados para resolver um sistema para qualquer dimensão dada. Pförtner também explica como dividir a matriz em partes triangulares inferior e superior usando o que ele chama de decomposição Lu, que é uma definição recursiva usando técnicas de divisão e conquista. Esta técnica é útil para inverter matrizes e tornar a resolução de sistemas lineares mais barata, sendo o processo O(N^2) em vez de O(N^3).
  
  
• 00:45:00 Nesta seção, o método de decomposição Lu para resolver sistemas lineares de equações é explicado. Este método decompõe uma matriz em uma matriz triangular inferior e uma matriz triangular superior, permitindo o cálculo mais rápido de soluções para sistemas lineares. O processo envolve definir as entradas diagonais da parte esquerda da matriz triangular inferior em uma e usar a articulação parcial para garantir estabilidade e robustez. Apesar da eficiência do método, o custo de cálculo, que é O(n^3), deve ser considerado.
  
  
• 00:50:00 Nesta seção, Marvin Pförtner discute o tempo computacional da decomposição UD e demonstra como implementá-lo no local. Ele explica que a maior parte de cada etapa da recursão é o cálculo do produto externo e a subtração, que resulta em uma soma de duas vezes (n-1) ao quadrado. Usando uma estratégia conhecida como eliminação gaussiana, o algoritmo calcula eficientemente a matriz triangular superior. Pförtner mostra como realizar um exemplo de computação com uma matriz pequena, demonstrando que a parte não trivial de L está contida nas três entradas abaixo da diagonal, e a parte triangular superior conterá as partes diferentes de zero de U. Mantendo tudo na memória, Pförtner apresenta uma implementação que armazena inteligentemente L e U na mesma matriz.
  
  
• 00:55:00 Nesta seção, o palestrante explica o processo de decomposição LU em álgebra linear numérica. Ele mostra como calcular o algoritmo passo a passo e como usá-lo para resolver sistemas lineares. Assim que tivermos a decomposição LU de uma matriz, podemos aplicá-la para resolver com eficiência vários sistemas lineares com vários lados à direita, custando apenas 2N ao quadrado para substituição direta e reversa. O inverso de uma matriz de permutação é apenas sua transposição, que é barata de calcular, tornando possível realizar K resolve com a mesma matriz de sistema na regressão do processo gaussiano.
  
  
• 01:00:00 Nesta seção, o palestrante discute como resolver eficientemente vários sistemas lineares com a mesma matriz usando uma decomposição LU, que é computacionalmente eficiente. Além disso, é apresentado um método para calcular o logaritmo determinante com uma decomposição LU, que permite a representação eficiente de um sistema linear e a realização de várias tarefas de álgebra linear com ele. O palestrante enfatiza a importância de utilizar a estrutura para tornar os algoritmos mais eficientes e observa que a decomposição de Cholesky é uma versão especializada da decomposição LU que tira proveito da natureza simétrica e definida positiva da matriz de grama do kernel.
  
  
• 01:05:00 Nesta seção, o palestrante discute o cálculo da média posterior e covariância em processos Gaussianos. Para obter a média a posteriori, é preciso resolver um sistema por substituição direta e outro por substituição retrógrada. O palestrante observa que, com a estrutura dos fatores cholesky da matriz de covariância, pode-se obter uma boa aproximação redutora da matriz. Além disso, ele fala sobre o problema de potencialmente não conseguir encaixar a grande matriz do kernel na memória e apresenta duas abordagens para resolver esse problema; usando estrutura nos kernels empregados ou usando aproximações esparsas.
  
  
• 01:10:00 Nesta seção, o palestrante discute como inverter matrizes com eficiência em algoritmos de aprendizado de máquina. Ele usa um conjunto de dados gerado a partir de uma função senoidal como exemplo e mostra que, conhecendo a estrutura generativa do conjunto de dados, pode-se escolher kernels que reflitam esse conhecimento e sejam computacionalmente eficientes. O Matrix Inversion Lemma é uma ferramenta que pode ser usada para inverter matrizes eficientemente, perturbando-as com um pequeno número de subespaços. Usando este lema, pode-se calcular expressões de forma muito eficiente e nem mesmo precisar formar a matriz inteira na memória. O palestrante enfatiza que existem muitas abordagens diferentes para usar a estrutura em algoritmos de aprendizado de máquina.
  
  
• 01:15:00 Nesta seção, o palestrante discute métodos de álgebra linear numérica usados em inferências gaussianas e otimização de hiperparâmetros em aprendizado de máquina. Um método para dimensionar a regressão GP (processo gaussiano) para grandes conjuntos de dados é a inversão aproximada, que envolve a construção iterativa de aproximações de classificação baixa para a matriz do sistema representada na matriz do kernel. O palestrante demonstra esse método usando o algoritmo de Cholesky como exemplo e mostra como o aproximador de classificação baixa para a matriz pode ser obtido dinamicamente sem calcular toda a fatoração de Cholesky. A qualidade da aproximação depende da matriz do kernel e da ordem na qual os pontos de dados são processados. No geral, esta seção destaca a importância da álgebra linear numérica em vários aspectos do aprendizado de máquina.
  
  
• 01:20:00 Nesta seção, Marvin Pförtner discute como escolher a ordem dos pontos de dados em que Cholesky lida com eles para aproximar a matriz do kernel. Ele explica que pré-multiplicar a matriz de grama com a matriz de permutação, também conhecida como pivotização completa ou decomposição de Cholesky pivotada, pode levar a uma aproximação menor com menos iterações. A ideia é observar o preditor para os pontos de dados após uma iteração do Todeschini e então usar as informações coletadas para selecionar o ponto de dados a ser observado na próxima iteração. Essa técnica é considerada um problema de aprendizado ativo e pode gerar uma maneira inteligente de processar linhas e colunas simultaneamente e, assim, explorar a estrutura generativa da Matrix de maneira online.
  
  
• 01:25:00 Nesta seção, o palestrante discute a decomposição de valor singular (SVD) e como ela resolve um problema de otimização para obter os melhores fatores para uma aproximação de matriz. No entanto, truncar um SVD pode ser arbitrariamente ruim, então uma abordagem heurística é usada para aproximar o SVD e calcular uma decomposição própria. Há também a necessidade de uma raiz quadrada da matriz, que pode ser obtida por meio da decomposição de Cholesky. É importante levar em consideração a estrutura ao implementar algoritmos de álgebra linear numérica na prática, pois isso pode acelerar significativamente o processo.
  
  
• 01:30:00 Nesta seção, Marvin Pförtner discute como a estrutura da álgebra linear numérica afeta a regressão do processo gaussiano. A regressão do processo gaussiano é computacionalmente intensiva e requer a resolução de grandes sistemas de equações, o que pode ser feito usando técnicas de álgebra linear numérica. O palestrante enfatiza a importância da estabilidade numérica na resolução desses sistemas de equações para evitar perda de precisão nos resultados finais.

[MetaQuotes]

Aula 3 -- Escalando Processos Gaussianos -- Jonathan Wenger

Numéricos de ML 3 -- Escalando Processos Gaussianos -- Jonathan Wenger

Jonathan Wenger discute técnicas para dimensionar processos gaussianos para grandes conjuntos de dados no vídeo "Numerics of ML 3". Ele explora métodos iterativos para resolver sistemas lineares e aprender a matriz inversa, com o objetivo principal de alcançar generalização, simplicidade/interpretabilidade, estimativas de incerteza e velocidade. Wenger introduz aproximações de baixo escalão para a matriz kernel, como a decomposição iterativa de Cholesky, Cholesky parcial e métodos de gradiente conjugado. Ele também discute o pré-condicionamento para acelerar a convergência e melhorar a estabilidade ao lidar com grandes conjuntos de dados. Finalmente, ele propõe o uso de uma matriz ortogonal Z para reescrever o traço de uma matriz, o que poderia potencialmente levar a um tempo quadrático para escalar processos Gaussianos.

Na segunda parte da palestra, Jonathan Wenger discute o escalonamento de Processos Gaussianos (GP) para grandes conjuntos de dados neste vídeo. Ele apresenta várias estratégias para melhorar a taxa de convergência das estimativas de Monte Carlo para a regressão GP, incluindo o uso de pré-condicionadores existentes para a solução do sistema linear para estimar a matriz kernel e sua inversa. Ele também introduz a ideia de PG de tempo linear por meio de aproximação variacional e abordagem da quantificação de incerteza usando o método de ponto indutor. Ao usar essas estratégias, é possível aumentar a escala para conjuntos de dados com até um milhão de pontos de dados com a GPU, facilitando a otimização rápida de hiperparâmetros.

• 00:00:00 Nesta seção do vídeo, Jonathan Wenger discute como dimensionar processos gaussianos para grandes conjuntos de dados usando métodos iterativos para resolver sistemas lineares. Ele explica que esses métodos podem ser vistos como algoritmos de aprendizado para o inverso da matriz, que é o principal objeto necessário para calcular o GP posterior. Wenger também descreve os principais objetivos da regressão, incluindo generalização, simplicidade/interpretabilidade, estimativas de incerteza e velocidade. Ele observa que os GPs são exemplos excelentes de modelos que podem atingir todos esses objetivos, mas são caros para treinar e fazer inferências. No entanto, desenvolvendo métodos modernos para resolver sistemas lineares com matrizes kernel, a inferência de tempo quadrático para GPS pode ser feita mais rapidamente do que o tempo cúbico. Wenger também sugere que existe uma maneira de fazer isso ainda mais rápido em tempo linear, mas reconhece que pode haver algumas desvantagens que ele discutirá mais adiante na próxima palestra.
  
  
• 00:05:00 Nesta seção, o palestrante discute as limitações da decomposição de Scholesky para processos gaussianos ao lidar com grandes conjuntos de dados, pois ela se torna proibitiva em termos de complexidade de tempo e espaço. Ele propõe métodos iterativos para reduzir a complexidade ao quadrado no número de pontos de dados, mostrando como o Cholesky iterativo é usado para a aproximação de baixo escalão da matriz do kernel. No entanto, o problema não é aproximar a Matriz do kernel em si, pois a regressão GP requer uma aproximação do inverso da Matriz do kernel ou da Matriz de Precisão, então a questão é se a formulação iterativa do Cholesky pode ser interpretada como uma aproximação da Precisão Matriz para soluções lineares.
  
  
• 00:10:00 Nesta seção, o palestrante explora uma forma iterativa da decomposição de Cholesky, que pode ser usada para aproximações de baixo escalão para matrizes de kernel. Ao rastrear quantidades adicionais, é possível obter uma aproximação inversa da matriz, que também é de baixo escalão, semelhante ao Cholesky. O palestrante demonstra como calcular essa aproximação inversa recursivamente, em termos dos fatores de Cholesky e do resíduo. Esse método iterativo pode ser usado como um algoritmo aproximado de inversão de matrizes para matrizes positivas definidas, como matrizes kernel, e é uma ferramenta útil para dimensionar processos gaussianos.
  
  
• 00:15:00 Nesta seção, o palestrante discute o uso do método parcial de Cholesky para dimensionar processos Gaussianos. O método envolve modificar a decomposição de Cholesky com um fator e multiplicá-lo com um vetor. Isso resulta em um processo iterativo que produz uma aproximação inversa adicionando produtos externos de vetores. A análise de complexidade mostra que é tão caro quanto aproximar a própria matriz. O palestrante também compara o método Cholesky parcial com a regressão GP e destaca a importância de selecionar os pontos de dados corretos ou vetores unitários para melhorar o processo de aprendizagem.
  
  
• 00:20:00 Nesta seção, Jonathan Wenger discute a importância de selecionar os pontos de dados corretos ao aproximar a matriz do kernel para Processos Gaussianos (GP). Ele ilustra como uma seleção aleatória de pontos de dados para condicionar pode resultar em um processo de aprendizado mais lento. Ele apresenta o "método de gradientes conjugados", originalmente projetado para resolver sistemas lineares em regressão GP. Este método reformula o problema de ax=B, onde a é uma matriz kernel e B é um vetor de tamanho n, como um problema de otimização quadrática, que é equivalente a resolver o sistema linear ax=B. Tomando o gradiente da função quadrática e definindo-o como zero, a coluna para ax é igual a B, e um resíduo pode ser definido como B menos ax, que pode ser usado para encontrar uma maneira melhor e mais eficiente de selecionar pontos de dados para acelerar o processo de aprendizagem.
  
  
• 00:25:00 Nesta seção, Jonathan Wenger discute o uso de direções conjugadas para otimização em processos gaussianos. Ele explica que, modificando a direção em que caminhamos, podemos convergir no máximo em n etapas ao usar direções conjugadas. Para começar, ele usa o gradiente negativo como o primeiro passo na direção da descida mais íngreme e modifica os passos para satisfazer a condição de conjugação. Ele apresenta o algoritmo e explica suas partes de alto nível, incluindo o critério de parada baseado na norma de gradiente.
  
  
• 00:30:00 Nesta seção, Jonathan Wenger discute o método de gradientes conjugados, que é um método para aproximar o inverso ao resolver sistemas lineares múltiplos para covariância posterior. O método de gradientes conjugados constrói uma aproximação para o inverso, que é de baixo escalão da mesma forma que o Swarovski parcial. A atualização para a estimativa da solução envolve uma direção conjugada di, e a matriz CI aproxima o inverso com a forma de todas as direções de busca anteriores empilhadas em colunas. Este método permite resolver rapidamente o sistema de cenários, e sua estrutura de baixo escalão o torna um método eficiente para escalar processos gaussianos.
  
  
• 00:35:00 Nesta seção, o palestrante compara o método Scholastic parcial com o método de gradiente conjugado para inferência de processos gaussianos. O método do gradiente conjugado converge muito mais rápido, e o palestrante explica que as "ações" usadas no método do gradiente conjugado sondam a matriz de uma maneira diferente, o que permite uma melhor convergência. No entanto, o palestrante observa que é importante analisar a velocidade de convergência do método, o que requer uma compreensão de números, especificamente a precisão da máquina e o número de condição. O número de condição é o autovalor máximo dividido pelo autovalor mínimo em termos absolutos e mede a inevitável amplificação do erro ao implementar algoritmos de inversão.
  
  
• 00:40:00 Nesta seção, Jonathan Wenger discute a estabilidade e o comportamento de convergência de métodos para resolver sistemas lineares com matrizes kernel, como o método de gradiente conjugado ou a decomposição de Cholesky. A estabilidade é determinada pelo número de condição da matriz, que depende de seus autovalores, e quanto maior o número de condição, mais instável é o método. O comportamento de convergência é determinado pelo número de condição da matriz e o maior dividido pelo menor autovalor. Quanto mais próximo o número de condição estiver de um, mais lenta será a convergência. Apesar do número de condição moderadamente grande da matriz kernel com mil pontos de dados, Wenger mostra que o método de gradiente conjugado ainda converge rapidamente em algumas centenas de iterações em relação ao tamanho do problema.
  
  
• 00:45:00 Nesta seção, Jonathan Wenger discute o escalonamento dos processos gaussianos e o impacto do ruído de observação na convergência. À medida que o ruído de observação diminui, a convergência do CG diminui devido à explosão do número de condição da matriz do kernel. O número da condição é o maior autovalor dividido pelo menor autovalor e, à medida que os pontos de dados se aproximam, o número da condição aumenta. Para resolver este problema, o pré-condicionamento pode ser usado para aproximar a matriz kernel, assumindo que o armazenamento da matriz é bastante barato em relação ao armazenamento da matriz real. Ao avaliar eficientemente o inverso da aproximação, o pré-condicionador pode substituir o problema original por um mais fácil de resolver, resultando em uma convergência mais rápida do CG.
  
  
• 00:50:00 Nesta seção, Jonathan Wenger discute o conceito de pré-condicionamento no escalonamento de processos gaussianos para uma solução de sistema linear mais eficiente. Ele usa o exemplo de métodos de aprendizado probabilísticos para explicar como o conhecimento prévio de um problema pode torná-lo mais fácil de resolver e, da mesma forma, o pré-condicionamento transforma um problema para ficar mais próximo da matriz de identidade e, portanto, mais fácil de resolver. Ao usar um pré-condicionador, o número de condição do sistema é reduzido, o que acelera o CG e o torna mais estável. Wenger demonstra a eficiência do pré-condicionamento usando um pré-condicionador diagonal de classificação baixa e SVD parcial para resolver um sistema linear de grande escala com 100.000 pontos de dados em sete minutos.
  
  
• 00:55:00 Nesta seção, o palestrante discute o uso de gradiente conjugado pré-condicionado (CG) para resolver sistemas lineares durante a otimização de hiperparâmetros para Cholesky. Para avaliar a perda e calcular seu gradiente, precisamos resolver sistemas lineares e calcular traços. No entanto, computar o traço envolve n multiplicações vetor-matriz, o que é muito caro para grandes conjuntos de dados. Para resolver isso, o palestrante propõe o uso de uma matriz ortogonal Z tal que cx Z(transpor) = matriz identidade, permitindo reescrever o traço de a como o traço de Z(transpor) xax Z. Esse método de aproximação pode potencialmente levar a equações quadráticas tempo para escalar os processos Gaussianos.
  
  
• 01:00:00 Nesta seção, o apresentador discute o desafio de escalar o cálculo do traço da matriz kernel, que envolve a realização de várias multiplicações matriz-vetor. Uma possível solução é randomizar o cálculo desenhando vetores aleatórios, dimensionados com a raiz quadrada da dimensão e, em seguida, calculando a covariância de identidade. Com a covariância do vetor aleatório aproximada, o traço pode ser calculado, o que é o mesmo que resolver o problema original sem vetores aleatórios. No entanto, usar estimadores de Monte Carlo neste método é insuficiente para grandes conjuntos de dados, pois requer dezenas de milhares de vetores aleatórios, tornando a otimização de hiperparâmetros lenta.
  
  
• 01:05:00 Nesta seção, Jonathan Wenger discute o dimensionamento de Processos Gaussianos (GP) para grandes conjuntos de dados. Ele explica que os pré-condicionadores existentes para a solução do sistema linear podem ser usados para estimar a matriz do kernel e seu inverso para lidar com o problema de escalonamento de dados. O uso do pré-condicionador com Cholesky parcial ou a estimativa de traço estocástico ajuda a estimar o traço de volta. Usando a mesma informação, pode-se estimar o gradiente do determinante de log também. Ao usar essas estratégias, é possível aumentar a escala para conjuntos de dados com até um milhão de pontos de dados com a GPU. Wenger observa que o pré-treinamento envolve o uso de um pequeno conjunto de dados como trampolim para otimizar os parâmetros híbridos.
  
  
• 01:10:00 Nesta seção, o palestrante discute diferentes estratégias para melhorar a taxa de convergência das estimativas de Monte Carlo para a regressão do processo gaussiano. Ao herdar a taxa de convergências de pré-condicionamento, é possível convergir mais rapidamente para o valor verdadeiro de forma exponencial ou polinomial. A escolha de ações para observar a matriz do kernel por meio da multiplicação do vetor da matriz também pode afetar a rapidez com que a convergência pode ser alcançada. Portanto, para desenvolver algoritmos numéricos rápidos para o processo gaussiano, é necessário conhecimento de domínio, que pode ser fornecido por meio de pré-condições ou da escolha de ações para convergir rapidamente. Além disso, é introduzida a ideia de GP de tempo linear por meio de aproximação variacional, que envolve a compactação de dados de alta dimensão em um conjunto de dados de treinamento menor para resumi-los de maneira mais eficaz.
  
  
• 01:15:00 Nesta seção, Wenger discute o uso de processos gaussianos e como eles podem ser dimensionados de forma eficaz. A ideia é resumir os dados de treinamento para fornecer uma aproximação direta ao posterior, que leva apenas I ao quadrado n, onde I é o número de entradas indutoras en é o tamanho dos dados de treinamento. No entanto, métodos iterativos requerem otimização de hiperparâmetros, o que também precisa ser considerado. Métodos estocásticos como otimização em lote ou sdd podem ser usados neste caso, que podem ser otimizados rapidamente usando um otimizador preferido. Todas as operações essenciais são I ao cubo ou I ao quadrado vezes n, exceto para avaliar a matriz kernel, que é a operação mais cara.
  
  
• 01:20:00 Nesta seção, o palestrante discute a questão da quantificação da incerteza com o escalonamento de processos gaussianos usando o método do ponto indutor, que requer a definição do número de pontos indutores a priori para o conjunto de dados. À medida que o otimizador procura por melhores pontos de dados resumidos, a quantificação da incerteza resultante torna-se significativamente diferente do verdadeiro processo gaussiano. Enquanto os métodos iterativos podem controlar a precisão da aproximação até que o tempo acabe, o método do ponto indutor requer o controle da fidelidade da aproximação antes da otimização. O palestrante questiona se um método pode ser projetado onde a quantificação da incerteza pode ser confiável em qualquer ponto da aproximação, independentemente do tempo de computação.

[MetaQuotes]

Aula 4 -- Processos gaussianos com reconhecimento de computação -- Jonathan Wenger

Numéricos de ML 4 -- Processos gaussianos com reconhecimento de computação -- Jonathan Wenger

Neste vídeo sobre Numerics of ML, Jonathan Wenger discute os processos gaussianos com reconhecimento de computação e sua capacidade de quantificar o erro de aproximação e a incerteza nas previsões. Ele explora a importância de escolher as ações certas e como os gradientes conjugados podem reduzir significativamente a incerteza e acelerar o aprendizado. Wenger também fala sobre o uso de aproximações GP de tempo linear baseadas em pontos indutores, mas destaca os problemas que surgem de tais aproximações. Finalmente, ele discute a atualização de crenças sobre pesos representativos e o uso de algoritmos de aprendizado probabilístico para resolver o erro nos pesos representativos. No geral, o vídeo demonstra a eficácia dos processos gaussianos com reconhecimento de computação para melhorar a precisão das previsões, levando em conta as incertezas computacionais.

Jonathan Wenger também discute o processo gaussiano com reconhecimento de computação e sua complexidade neste vídeo. Ele explica que é necessário apenas calcular e armazenar o quadrante superior da matriz do kernel, e o custo computacional do algoritmo é proporcional ao tamanho desse quadrante. O processo gaussiano pode ser usado em conjuntos de dados de tamanho arbitrário, desde que os cálculos tenham como alvo apenas determinados pontos de dados, confundindo a linha entre dados e computação. Wenger argumenta que o GP pode ser modelado para dar conta dessa situação, condicionando os dados projetados. Ele apresenta um novo teorema que permite a quantificação exata da incerteza com um modelo aproximado. Por fim, ele prevê a palestra da próxima semana sobre a extensão do modelo GP para casos em que uma lei física governa parcialmente a função que está sendo aprendida.

• 00:00:00 Nesta seção, Jonathan Wenger fala sobre a culminação final de suas palestras sobre processos gaussianos, onde ele demonstra como conduzir a quantificação exata da incerteza em tempo arbitrário. Ele explica que essa abordagem permite que os usuários sempre quantifiquem a que distância estão da função que estão tentando aprender, não importa quanto cálculo eles façam ou qual seja o seu orçamento. Ao reinterpretar os algoritmos das aulas anteriores como agentes de aprendizado, eles são capazes de quantificar o erro de aproximação, que é introduzido na previsão a posteriori. Além disso, eles discutem o que significa observar dados por meio de um computador e o debate filosófico que o envolve.
  
  
• 00:05:00 Nesta seção, Jonathan Wenger discute a importância de escolher as ações corretas ao lidar com processos gaussianos com reconhecimento de computação. Ele mostra que a escolha de ações pode reduzir significativamente a incerteza e acelerar o processo de aprendizado sobre os fenômenos que estão sendo previstos. Além disso, ele explora o método de gradientes conjugados como forma de encontrar melhores ações ao resolver sistemas lineares ou minimizar funções quadráticas. Ao levar em consideração a geometria do problema, gradientes conjugados podem convergir para uma solução em um pequeno número de etapas.
  
  
• 00:10:00 Nesta seção do vídeo, Jonathan Wenger discute os processos gaussianos com reconhecimento de computação e como eles diferem de outros métodos de aproximação. Ele fala sobre a operação mais cara em ambos os métodos de aproximação gradiente parcialmente conjugado e inverso parcial do céu, sendo a multiplicação matriz-vetor. Em seguida, ele provoca a ideia de aproximações GP de tempo linear baseadas em pontos de indução como pontos de dados resumidos e discute as questões que surgem de uma aproximação de tempo linear. Wenger então apresenta a inferência GP com reconhecimento de computação, que aborda as questões da quantificação exata da incerteza e diz que é uma pesquisa de ponta que será apresentada no NURBS ainda este ano.
  
  
• 00:15:00 Nesta seção, Jonathan Wenger discute o processo gaussiano com reconhecimento de computação e como quantificar o erro de aproximação que surge do uso de métodos iterativos para resolver um sistema linear de pesos representativos. Ele explica que as funções de kernel no modelo GP codificam suposições sobre como é a verdadeira função, e os solucionadores iterativos aproximam esses pesos para construir uma previsão média posterior. Ao quantificar este erro de aproximação probabilisticamente, é possível adicionar incerteza adicional à previsão, o que pode melhorar a precisão do modelo. Wenger também faz uma breve recapitulação da álgebra linear das distribuições gaussianas e como elas facilitam os cálculos na teoria da probabilidade, principalmente quando se trata de condicionamento e observações.
  
  
• 00:20:00 Nesta seção, Jonathan Wenger discute as propriedades das distribuições gaussianas e como elas podem ser usadas para determinar a distribuição posterior sobre uma variável X dadas as observações Y. Ao combinar as propriedades de escala e marginalização, os processos gaussianos podem ser usados quantificar o erro de aproximação em estimativas de pesos representativos. Wenger explica como uma distribuição gaussiana anterior pode ser atualizada e usada para aprender os verdadeiros pesos representativos, que não podem ser observados diretamente. A propagação e a orientação de uma curva de sino gaussiana podem ser usadas para determinar a direção na qual procurar os verdadeiros pesos representativos.
  
  
• 00:25:00 Nesta seção, Jonathan Wenger explica como observar indiretamente um ponto preto em um processo gaussiano com reconhecimento de computação usando um resíduo e uma transformação vetorial. Ele mostra como aplicar o teorema de inferência gaussiana afim para calcular a distância entre as representações e os pesos estimados. O processo envolve o colapso da crença em uma linha ortogonal e o desenvolvimento de uma crença de probabilidade unidimensional, que é usada para encontrar os pesos representados. Wenger também discute como selecionar uma linha vermelha mais informativa que se alinhe com a crença anterior para alcançar uma solução mais precisa.
  
  
• 00:30:00 Nesta seção, Jonathan Wenger discute um algoritmo para atualizar uma crença sobre pesos representativos em processos gaussianos com reconhecimento de computação por meio de uma observação feita por uma ação vezes um resíduo. Ele explica que a atualização envolve uma inferência gaussiana afim e aponta os elementos-chave no processo de atualização. Embora o algoritmo seja semelhante ao CG e Cholesky parcial, ele observa que a escolha do prior ainda é uma questão que precisa ser abordada, pois deve estar relacionada a onde estão os verdadeiros pesos representativos para obter uma boa estimativa de erro. Wenger propõe que a priori da PG e as suposições feitas estão relacionadas aos pesos representativos, pois estão envolvidos no inverso da matriz kernel, tornando-os significativos na priori da PG.
  
  
• 00:35:00 Nesta seção, Jonathan Wenger discute como entender de quais dados de distribuição foram gerados antes de fazer qualquer observação com um Processo Gaussiano (GP). Assumindo uma distribuição sobre f, Wenger explica que os rótulos são distribuídos de acordo com a média zero ao usar um gaussiano de média zero a priori e variam de acordo com a matriz kernel mais ruído independente, que faz parte do modelo de observação. Wenger então discute encontrar os representantes usando um algoritmo de aprendizado probabilístico que atualiza o anterior projetando em ações. Por fim, Wenger explica como resolver o problema de precisar calibrar o K hat inverse calculando uma distribuição de mu star avaliada em um ponto de dados, que é uma função linear de V star.
  
  
• 00:40:00 Nesta seção, Jonathan Wenger explica processos gaussianos com reconhecimento de computação e como contabilizar incertezas computacionais. Ele discute a ideia de marginalização, onde múltiplas opções para uma variável aleatória são consideradas e uma previsão média posterior que leva em conta todas as estimativas de pesos representativos possíveis é calculada. Ele explica como a marginalização linear funciona e como ela acrescenta incerteza adicional à covariância. Wenger então discute a interpretação da incerteza de um GP como uma estimativa de erro médio e como a incerteza computacional também pode ser considerada uma estimativa de erro. Em geral, a seção explica o cálculo da incerteza combinada que inclui o erro para a função verdadeira e o erro nos pesos representativos em uma única estimativa.
  
  
• 00:45:00 Nesta seção, o palestrante discute processos gaussianos com reconhecimento de computação, que combinam o erro resultante de não ter dados observados suficientes com o erro de não ter realizado cálculos suficientes para aprender a previsão. O palestrante demonstra dois exemplos desse processo em ação com as ações Ed Cholesky e CG. O método proposto chamado GP calcula a posteriori e combina uma crença representativa com inicialização para obter previsões mais precisas por meio da incerteza de rastreamento. O método é simples e eficaz, como visto na incerteza computacional reduzida e maior aproximação da verdadeira média posterior nos gráficos plotados.
  
  
• 00:50:00 Nesta seção, o palestrante discute os processos gaussianos com reconhecimento de computação e o uso da crença sem a necessidade de inverter a matriz do kernel. Eles escolhem uma ação em uma direção específica e observam quão próximos estão dos dois pesos representados no subespaço escolhido, o que afeta a rapidez com que convergem para os pesos representados. Para atualizar a estimativa dos pesos representativos, eles observam o resíduo projetado e calculam a direção a seguir. Eles também calculam uma aproximação de baixo escalão e atualizam sua estimativa dos representantes e da Matriz de Precisão. Eles aplicam as mesmas quantidades usando Alaska parcial e CG, escolhem ações de vetores unitários para recuperar certas ações e projetam um método como o método de tempo linear que pesa pontos de dados de acordo com a função de kernel centralizada em um ponto indutor.
  
  
• 00:55:00 Nesta seção, Jonathan Wenger discute Processos Gaussianos (GP) com reconhecimento de computação e os compara com GP condicional de treinamento totalmente independente (FITC-GP). Ele apresenta Kernel Vector Actions, que resolve alguns dos problemas com FITC-GP, mas são densos, resultando em complexidade de N ao quadrado e, portanto, não são econômicos. Wenger mostra que, ao tomar ações específicas que visam apenas parte dos pontos de dados, elas podem reduzir a complexidade necessária para o cálculo da matriz do kernel. No final, GP computacional tem melhor desempenho e tais ações provam ser uma abordagem útil para computação escalável com alta precisão.
  
  
• 01:00:00 Nesta seção, Jonathan Wenger discute o processo gaussiano com reconhecimento computacional e sua complexidade. Ele mostra que é necessário apenas calcular e armazenar o quadrante superior da matriz do kernel e, como resultado, o custo computacional do algoritmo é apenas proporcional ao tamanho desse quadrante. Além disso, ele destaca que o algoritmo pode ser usado em conjuntos de dados de tamanho arbitrário, desde que as ações que tenham zeros no quadrante inferior sejam escolhidas para atingir apenas determinados pontos de dados com computação. Wenger argumenta que isso obscurece a distinção entre dados e computação porque apenas as observações direcionadas para a computação são consideradas dados. Finalmente, ele observa que o processo gaussiano pode ser modelado para dar conta dessa situação, condicionando-o aos dados projetados.
  
  
• 01:05:00 Nesta seção, Jonathan Wenger explica que os Processos Gaussianos (GPs) podem ser pensados de duas maneiras: como um modelo mais preciso do que está acontecendo ou como uma ferramenta numérica probabilística que quantifica o erro introduzido por aproximação e leva em conta nas previsões. Ele então passa a discutir a interpretação dos erros quadrados como medidas probabilísticas e como o posterior combinado pode ser usado como uma ferramenta de previsão. Wenger também apresenta um novo teorema que permite a quantificação exata da incerteza com um modelo aproximado, permitindo que os usuários confiem em sua quantificação de incerteza da mesma forma que confiam nos processos gaussianos.
  
  
• 01:10:00 Nesta seção, Jonathan Wenger explica que os Processos Gaussianos (GPs) podem ser aproximados criando um algoritmo de aprendizado, que pode quantificar probabilisticamente o erro do algoritmo e empurrar o erro para o GP posterior usado para fazer previsões, permitindo para a quantificação exata da incerteza, independentemente do poder computacional usado. Wenger também observa que, embora existam diferentes variantes do método, elas fornecem quantificação exata da incerteza, desde que as ações sejam linearmente independentes. Por fim, Wenger antevê a palestra da próxima semana, na qual Jonathan discutirá a extensão do modelo GP para casos em que uma lei física governa parcialmente a função que está sendo aprendida.

[MetaQuotes]

Aula 5 -- Modelos de Espaço de Estados -- Jonathan Schmidt

Numéricos de ML 5 -- Modelos de espaço de estado -- Jonathan Schmidt

Nesta seção, Jonathan Schmidt apresenta modelos de espaço de estado e sua aplicação ao aprendizado de máquina. Ele explica que os modelos de espaço de estado são usados para modelar sistemas dinâmicos complexos, que são apenas parcialmente observáveis e envolvem interações altamente não lineares. A palestra cobre a representação gráfica de modelos de espaço de estados e as propriedades importantes da propriedade de Markov e medições condicionalmente independentes. Schmidt apresenta diferentes algoritmos para calcular várias distribuições, como predição, filtragem e distribuições de suavização, que são usadas para estimar o estado de um sistema, usando medições obtidas em diferentes pontos no tempo. A palestra também aborda a implementação de algoritmos de filtro de Kalman em Julia e o cálculo de estimativas de suavização em modelos de espaço de estado gaussianos lineares. Finalmente, Schmidt discute o filtro de Kalman estendido, que permite a estimativa de dinâmica não linear e medições em modelos de espaço de estado.

Jonathan Schmidt também discute modelos de espaço de estados e sua implementação usando código, focando especificamente na dinâmica não linear e no filtro de Kalman estendido. Ele também demonstra algoritmos de suavização e métodos alternativos de filtragem bayesiana, destacando seus prós e contras. A palestra termina com uma recomendação de aprendizado adicional e antecipação para a próxima palestra, onde Nathaniel apresentará números probabilísticos para simulação de sistemas dinâmicos.

• 00:00:00 Nesta seção, Jonathan Schmidt apresenta modelos de espaço de estado e sistemas dinâmicos como um novo foco para os números do curso de aprendizado de máquina. Ele explica que os sistemas dinâmicos evoluem com o tempo e só podem ser parcialmente observados, tornando-os difíceis de modelar. Schmidt fornece exemplos como contagens de casos COVID-19 e estimativa de orientação de smartphone para ilustrar a estrutura temporal e os componentes ocultos dos sistemas dinâmicos. O objetivo final é usar métodos probabilísticos para simular esses sistemas, mas primeiro, uma linguagem e uma estrutura algorítmica devem ser estabelecidas para descobrir componentes latentes a partir de dados observáveis.
  
  
• 00:05:00 Nesta seção, o palestrante discute modelos de espaço de estado, que envolvem uma tarefa de estimativa online onde o objetivo é atualizar rapidamente a estimativa de um sistema dinâmico complexo à medida que novos dados chegam. Esses modelos geralmente são apenas parcialmente observáveis e envolvem funções e interações altamente não lineares. Para conseguir isso, uma estrutura algorítmica é necessária para atualizar a crença de acordo. O palestrante discute a representação gráfica da linguagem de modelagem utilizada em modelos de espaço de estado, onde a sequência de nós brancos representa variáveis aleatórias modelando o estado do sistema, e a caixa vermelha representa os dados observados. O estado de um sistema dinâmico é um conjunto de grandezas físicas que determinam a evolução do sistema, que são rastreadas e interagem entre si. Os dados observados, y, dependem do estado atual e geralmente estão disponíveis apenas para alguns estados na trajetória, mas não para outros.
  
  
• 00:10:00 Nesta seção, Jonathan Schmidt apresenta modelos de espaço de estado como uma estrutura probabilística para modelagem de sistemas dinâmicos. Ele enfatiza duas propriedades importantes dos modelos de espaço de estados: a propriedade de Markov e as medidas condicionalmente independentes. Usando essas propriedades, ele define um modelo de espaço de estado como um modelo bayesiano que inclui uma distribuição inicial para o primeiro estado, um modelo dinâmico para os estados subsequentes e um modelo de medição para observações. Schmidt observa que esses componentes destilados formarão a base para o restante da série de palestras.
  
  
• 00:15:00 Nesta seção, o palestrante explica como analisar sistemas usando modelos de espaço de estado e calcula quatro diferentes distribuições de probabilidade condicional. Isso inclui a distribuição de previsão, distribuição de filtragem, probabilidade de dados e distribuição de suavização, que são computadas para cada etapa em uma sequência contínua. A derivação envolve a introdução da quantidade que está sendo calculada e a construção de uma distribuição conjunta com base no que já é conhecido. A equação de Chapman Kolmogorov é usada para prever o futuro com base em medições passadas, e a etapa de correção usando o teorema de Bayes é usada para integrar novos dados na estimativa.
  
  
• 00:20:00 Nesta seção, o palestrante explica o conceito de um modelo de espaço de estados e o esquema de previsão e atualização usado nele. Calculando a distribuição prevista pela equação de Chapman-Homógrafo, o modelo atualiza a previsão pelo teorema de Bayes. O palestrante então apresenta o pseudocódigo para o algoritmo, que opera em um loop de tempo linear sem retroceder. O palestrante enfatiza a importância de produzir uma sequência de distribuições para os estados atuais dadas todas as medições anteriores. Por fim, o palestrante apresenta um modelo de espaço de estado gaussiano linear e como ele produz distribuições.
  
  
• 00:25:00 Nesta seção, o palestrante apresenta modelos de espaço de estado para um sistema gaussiano linear com uma matriz de covariância de ruído de processo Q e um modelo de medição com uma matriz de medição H e uma matriz de covariância de medição R. A palestra explica como a previsão e os momentos de filtragem do modelo podem ser calculados usando inferência gaussiana, com a distribuição posterior sendo uma coleção complicada de termos. O palestrante então apresenta o filtro de Kalman, em homenagem ao cientista húngaro Rudolph Kalman, que permite o cálculo de previsão e filtragem de momentos de forma fechada. São apresentadas as equações de predição e correção do filtro de Kalman, sendo o ganho de Kalman uma grandeza importante que traduz as informações obtidas no espaço de medição para o espaço de estado para atualização da média de filtragem.
  
  
• 00:30:00 Nesta seção do vídeo, Jonathan Schmidt apresenta modelos de espaço de estados e explica como usá-los para filtrar trajetórias com base em medições de ruído. Ele fornece um exemplo de rastreamento de um carro em um plano 2D usando medições de GPS e escreve o código em Julia. Schmidt explica que o modelo dinâmico é um modelo gaussiano linear, e a covariância do ruído do processo envolve termos polinomiais do intervalo de tempo. Ele também enfatiza que a trajetória de filtragem usa apenas pontos de dados anteriores e atuais e não é informada pelo futuro.
  
  
• 00:35:00 Nesta seção, o palestrante explica a implementação do filtro de Kalman para modelos de espaço de estados usando o código Julia. Ele explica como configurar os modelos de medição e transição, prever a média e a covariância e corrigir a estimativa usando o modelo de medição. O palestrante então demonstra como executar o filtro de Kalman e fornece uma visualização da estimativa resultante e a incerteza correspondente.
  
  
• 00:40:00 Nesta seção, Jonathan Schmidt explica como os modelos de espaço de estado são usados para descrever sistemas dinâmicos e como eles podem ser construídos usando modelos gaussianos lineares que permitem o cálculo de quantidades interessantes usando álgebra linear. Ele também introduz o conceito de posteriores de suavização, que fornecem a melhor estimativa de uma trajetória dados todos os pontos de dados disponíveis, e se baseia em distribuições de filtragem para calculá-los em um algoritmo recursivo reverso. Embora a derivação de equações de suavização envolva a teoria da probabilidade e a propriedade de Markov, a coleção resultante de variáveis aleatórias gaussianas facilita o cálculo da distribuição de suavização em cada intervalo de tempo.
  
  
• 00:45:00 Nesta seção, o palestrante explica o processo de cálculo de estimativas de suavização em modelos lineares de espaço de estado gaussiano. Isso envolve a utilização de operações de produto vetorial de matriz e marginalização no próximo passo de tempo enquanto marginaliza para calcular a posterior da filtragem posterior. O algoritmo para estimativas de suavização é calculado por meio de loops for, uma vez que só funciona se houver um conjunto de dados ou uma porção fixa de etapas de tempo a serem consideradas. O processo envolve começar do final da série temporal e retroceder até o início, calculando o ganho de suavização e usando-o para calcular os momentos de suavização. O palestrante também menciona que a estimativa de filtragem coincide com a estimativa de suavização no final da série temporal. O algoritmo de suavização finalmente fornece um processo gaussiano posterior como a suavização posterior.
  
  
• 00:50:00 Nesta seção, o palestrante explica como calcular posteriores de processo gaussiano em tempo linear fazendo suposições que incluem transição linear, medições lineares, ruído gaussiano aditivo para dinâmica e medições e a propriedade de Markov. No entanto, nem todos os posteriores do processo gaussiano podem ser calculados usando filtragem e suavização gaussianas. O palestrante também discute a possibilidade de descartar a suposição gaussiana, mas isso exigiria uma classe inteiramente nova de algoritmos. A próxima etapa envolve a observação de modelos não lineares usando uma aproximação de Taylor em primeira ordem para linearizar as funções e, em seguida, usar a filtragem comum.
  
  
• 00:55:00 Nesta seção, Jonathan Schmidt discute modelos de espaço de estados e o filtro de Kalman estendido, que é uma extensão do filtro de Kalman para dinâmicas e medições não lineares. A linearização da dinâmica não linear e dos modelos de medição é realizada através do uso de matrizes jacobianas, permitindo o uso das equações padrão do filtro de Kalman com algumas modificações. A média prevista é avaliada na média de filtragem anterior, permitindo o cálculo fácil da matriz de covariância prevista. O modelo de medição é similarmente linearizado e as equações estendidas do filtro de Kalman são derivadas. Schmidt observa que o filtro estendido de Kalman é útil quando não é possível ou desejável diferenciar funções não lineares.
  
  
• 01:00:00 Nesta seção, Jonathan Schmidt discute o que acontece se não pudermos diferenciar nossa função e como contorná-la. Uma solução possível é usar uma diferença finita no esquema, onde construímos uma diferença como diferenças finitas padrão e depois fazemos a mesma coisa. Schmidt também constrói o suavizador de raiz estendida observando as equações suavizadas e inserindo, como a matriz de transição transposta, a matriz jacobiana da função não linear avaliada na média de filtragem. Schmidt fornece um exemplo de código usando um modelo de espaço de estado não linear de um pêndulo, onde a dimensão do estado é 2 e as medições são escalares. Ele configura o modelo dinâmico usando uma transformação não linear e discute a covariância do ruído do processo.
  
  
• 01:05:00 Nesta seção, Jonathan Schmidt discute modelos de espaço de estado e como implementá-los usando código. Ele explica a dinâmica não linear do sistema e o modelo de medição linear simples usado para medições. Ele também demonstra como implementar um filtro de Kalman estendido para estimar a trajetória de um pêndulo. O filtro usa diferenciação automática para calcular a matriz jacobiana para a função de dinâmica não linear e o gradiente para a função de medição. A animação resultante mostra a trajetória prevista e as medições ruidosas.
  
  
• 01:10:00 Nesta seção, Jonathan Schmidt discute a estimativa de filtragem e suavização estendida em modelos de espaço de estado. A estimativa de filtragem mostra a estimativa de incerteza na área sombreada, enquanto o algoritmo de suavização organiza a estimativa de filtragem usando diferenciação automática, calculando o ganho de suavização, média suave e covariância suave. O mais suave retorna um processo Gaussiano marginal posterior, que cobre bem a trajetória de campo-verdade em sua incerteza. Schmidt também menciona métodos alternativos para filtragem bayesiana, como o filtro de Kalman sem cheiro para aproximar distribuições e o filtro de partículas, que aproxima o posterior verdadeiro real. Embora esses métodos tenham seus prós e contras e possam ser mais difíceis de implementar, eles podem ser eficazes para modelos não lineares ou não gaussianos. Schmidt recomenda o livro "Bayesian Filtering and Smoothing" de Simo Särkkä para os interessados em aprender sobre esses métodos.
  
  
• 01:15:00 Nesta seção, o palestrante resume o que foi aprendido sobre modelos de espaço de estado, seu modelo gaussiano linear e os filtros Kalman e Kalman estendido usados para lidar com medições e dinâmicas não lineares. A próxima palestra é recomendada, onde Nathaniel apresentará uma linguagem poderosa para capturar as leis da natureza e combiná-la com a palestra de uma semana para aprender a simular esses sistemas dinâmicos usando números probabilísticos por meio de filtragem e suavização Bayesiana. O palestrante conclui pedindo feedback e agradecendo aos ouvintes por seu tempo.

[MetaQuotes]

Aula 6 -- Resolução de Equações Diferenciais Ordinárias -- Nathanael Bosch

Numéricos de ML 6 -- Resolução de Equações Diferenciais Ordinárias -- Nathanael Bosch

Nathanael Bosch cobre o conceito de ODEs em aprendizado de máquina, que descreve a derivada de uma função dada sua entrada e sistemas de modelo que evoluem ao longo do tempo. Ele discute os desafios de resolver EDOs e apresenta métodos numéricos, como Euler progressivo e Euler inverso, e suas propriedades de estabilidade. A Bosch explora diferentes métodos numéricos e suas compensações em precisão e complexidade, como ponto médio explícito e métodos clássicos de quarta ordem. Ele enfatiza a importância do erro local, ordem e compreensão da estabilidade para evitar problemas no uso de bibliotecas para resolver EDOs.

Esta segunda parte do vídeo discute o problema de estimar o campo vetorial e o valor inicial de uma equação diferencial ordinária (ODE) usando técnicas de aprendizado de máquina. O palestrante explica a importância de anotar o modelo generativo e o modelo de observação para os estados da EDO para resolver o problema de inferência. A função de verossimilhança é maximizada minimizando a verossimilhança logarítmica negativa, que produz uma estimativa de parâmetro. O palestrante demonstra essa abordagem usando um modelo SIR-D e discute o uso de redes neurais para melhorar a estimativa da taxa de contato. A importância das ODEs na pesquisa de aprendizado de máquina e seu papel na solução de problemas do mundo real também é destacada.

• 00:00:00 Nesta seção da palestra, Nathanael Bosch apresenta o conceito de equações diferenciais ordinárias (ODEs) e como elas são usadas no aprendizado de máquina. Ele define uma ODE como uma forma de descrever a derivada de uma função dada sua entrada e explica que muitas vezes no aprendizado de máquina, as ODEs são usadas para modelar sistemas que evoluem com o tempo. Ele fornece exemplos de onde as ODEs aparecem no aprendizado de máquina, inclusive em modelos de difusão e em problemas de otimização. Bosch também discute os desafios de resolver EDOs, que exigem solucionadores numéricos complexos devido à inviabilidade de resolvê-los perfeitamente.
  
  
• 00:05:00 Nesta seção, o palestrante discute como as EDOs são usadas para transformar ruído em dados para modelar distribuições complexas, o que é feito por meio da normalização de fluxos. Ele também explica o conceito de EDOs neurais, que gerou muita pesquisa e reinterpreta as redes neurais residuais como discretizações de algo mais contínuo. Além disso, o palestrante relaciona EDOs à otimização, especificamente, fluxo de gradiente, sobre o qual é mais fácil escrever um teorema do que descida de gradiente discreta. Por fim, o palestrante discute como a inferência de parâmetros é um exemplo de uso de EDOs para aprender algo desconhecido e, na próxima palestra, interpretará soluções numéricas de EDOs como algoritmos de aprendizado de máquina. O palestrante conclui que, embora possamos escrever uma solução para uma EDO, isso não é útil devido ao problema de integração e às variáveis desconhecidas.
  
  
• 00:10:00 Nesta seção, o narrador apresenta equações diferenciais ordinárias (ODEs) e problemas de valor inicial, que são cruciais para a compreensão de muitos algoritmos em aprendizado de máquina. As EDOs representam a taxa de mudança de um sistema ao longo do tempo, e o valor inicial é necessário para resolver o problema. A solução para uma EDO é dada por uma função que depende do valor inicial, e soluções numéricas para EDOs requerem extrapolação passo a passo. O narrador apresenta um problema logístico de EDO para crescimento populacional, e a solução é dada. O narrador enfatiza que o objetivo de resolver um problema de valor inicial é encontrar a solução para um ponto de partida específico dado o campo vetorial das EDOs. A dificuldade em resolver EDOs é resolver a integral e lidar com o termo diferencial. O narrador sugere pequenos tamanhos de etapas para soluções numéricas de EDOs para aproximar a solução verdadeira com precisão.
  
  
• 00:15:00 Nesta seção, Nathanael Bosch explica diferentes métodos numéricos para resolver equações diferenciais ordinárias. O primeiro método que ele apresenta é a aproximação da série de Taylor de ordem zero, onde apenas o valor da função no intervalo de tempo atual é considerado para a aproximação. Isso leva ao método Forward Euler, que é uma fórmula simples e explícita para calcular o próximo ponto no tempo. A Bosch observa que, embora esse método seja uma aproximação ruim, ainda é amplamente usado em software e simulações dinâmicas.
  
  
• 00:20:00 Nesta seção, o vídeo discute dois métodos para resolver equações diferenciais ordinárias (EDOs): o método de Euler direto e o método de Euler inverso. O método de Euler direto usa a inclinação no ponto atual para aproximar o valor no próximo ponto, enquanto o método de Euler reverso usa uma aproximação da série de Taylor em torno de Tau igual a t mais h. O vídeo fornece exemplos de código para ambos os métodos usando o ODE logístico, que produz soluções razoáveis. No entanto, o vídeo adverte que equações diferenciais mais complexas podem exigir consideração adicional ao escolher um solucionador numérico. Além disso, o vídeo aborda a complexidade dos métodos numéricos e a importância de estar ciente dos algoritmos subjacentes ao usar pacotes numéricos.
  
  
• 00:25:00 Nesta seção, o palestrante discute a diferença entre métodos explícitos e implícitos na resolução de equações diferenciais ordinárias (EDOs) e a importância da estabilidade na escolha do algoritmo apropriado. O palestrante compara os métodos de Euler direto e reverso para uma EDO escalar simples, x' = λx, onde λ é menor que zero. O método de Euler direto é estável apenas para tamanhos de passo em que 1 + hλ é menor que um, enquanto o método de Euler reverso é estável para todos os tamanhos de passo. O palestrante demonstra que a escolha de um tamanho de passo inadequado pode levar a um comportamento divergente, enfatizando a importância da estabilidade na seleção de um método apropriado para resolver EDOs.
  
  
• 00:30:00 Nesta seção, Nathanael Bosch discute as diferenças entre os métodos de Euler progressivo e reverso para resolver equações diferenciais ordinárias (EDOs). Embora ambos os métodos usem matemática semelhante, o Euler reverso requer pequenos requisitos para convergência e pode lidar com áreas rígidas nas EDOs que o Euler avançado não pode. A quadratura numérica é necessária e há muitas maneiras de fazê-lo. Além disso, a construção de X hat, a aproximação da função em um determinado momento, é outro problema para o qual métodos diferentes fornecem respostas diferentes. No geral, a escolha do método depende de fatores como o tempo de computação e a inclinação esperada da EDO.
  
  
• 00:35:00 Nesta seção, Nathanael Bosch explica a formulação geral de métodos numéricos para resolver equações diferenciais ordinárias (EDOs), que envolvem três variáveis: bi, Qi e X hats. Ele também apresenta tabelas de açougueiro como uma forma de tornar a conversa sobre os diferentes métodos mais compacta e legível, e aponta que as diferentes maneiras de calcular o bi e o Qi, bem como a forma de construir os chapéus X, são o que torna cada método único. . Bosch dá exemplos de diferentes métodos numéricos, incluindo o mais simples, Euler progressivo, que satisfaz a equação geral e tem um tableau de açougueiro que contém zeros, mas ainda é um método suficientemente útil. Ele também apresenta o Euler retrógrado como um método implícito que não possui um zero e é calculado de maneira ligeiramente diferente do Euler direto.
  
  
• 00:40:00 Nesta seção, o vídeo explora as diferentes estratégias que podem ser usadas para resolver Equações Diferenciais Ordinárias (EDOs). Uma sugestão de um ouvinte foi dividir a integral em termos diferentes e executar etapas entre cada termo, mas o apresentador explica que isso resultaria em um algoritmo diferente com propriedades diferentes. O vídeo continua demonstrando a regra explícita do ponto médio, que está perto de fazer duas etapas de Euler, mas não é exatamente a mesma coisa. O apresentador explica que a regra do ponto médio extrapola do ponto e reduz o que o atacante Euler fez para conseguir uma extrapolação melhor. Além disso, o vídeo explora o método clássico de quarta ordem, assim chamado por ser o método original desenvolvido por Byron e Kota. Por fim, o vídeo observa que, embora haja alguma liberdade na escolha dos coeficientes para resolver EDOs, já existem centenas de métodos conhecidos na Wikipédia.
  
  
• 00:45:00 leva a duas soluções. No método Dobre-Fermi, há duas linhas no final porque dá duas soluções em cada etapa. Esse método é complicado porque satisfaz várias propriedades e se torna mais intrincado quando o Tableau fica maior. O objetivo não deve ser entender como o gradiente funciona, mas sim focar nas propriedades que os coeficientes precisam satisfazer. O método foi motivado por regras de quadratura e, embora possa não haver um mapeamento direto para EDOs, eles ainda são muito motivados por regras de quadratura.
  
  
• 00:50:00 Nesta seção, o vídeo discute como resolver equações diferenciais pode ser complicado devido aos métodos que visam a eficiência ao fornecer dois métodos ao mesmo tempo com diferentes graus de precisão. Um é mais preciso que o outro, e usar o mais preciso pode ajudar a estimar o erro do menos preciso, o que pode ser útil para ajustar o tamanho do passo ao resolver a EDO enquanto satisfaz algum erro local. O vídeo também menciona que existem diferentes tipos de métodos com diferentes propriedades, e a estabilidade também é um fator a ser considerado na hora de escolher um método para resolver um problema. Por fim, o vídeo aborda brevemente a importância da ordem na resolução de equações diferenciais.
  
  
• 00:55:00 Nesta seção, Nathanael Bosch discute os diferentes métodos para resolver equações diferenciais ordinárias (ODEs) e a compensação entre precisão e complexidade. Ele destaca a importância do erro local, que mede o erro em uma única etapa da estimação, e como ele pode ser reduzido diminuindo o tamanho da etapa. Diferentes métodos, como Hard Euler e Explicit Midpoint, são então discutidos, cada um com sua própria ordem e taxa de convergência de erros. A Bosch também aborda os vários sinos e assobios que acompanham o uso de bibliotecas para resolver ODEs, como seleção de tamanho de etapa e seleção automática de servidor, mas adverte que ainda é importante entender a estabilidade e evitar possíveis problemas quando as coisas quebram.
  
  
• 01:00:00 Nesta seção do vídeo, o palestrante discute o problema de estimar o campo vetorial e o valor inicial de uma equação diferencial ordinária (ODE) a partir de dados usando técnicas de aprendizado de máquina. Ele dá um exemplo de modelo epidemiológico onde o objetivo é estimar os parâmetros beta, gama e lambda que ajustam a ODE aos dados observados. O palestrante explica que anotar o modelo generativo e o modelo de observação para os estados da EDO é essencial para resolver o problema de inferência. Ele observa que estimar os parâmetros permite uma melhor compreensão do processo que gerou os dados e comparar os parâmetros inferidos com a literatura pode fornecer informações adicionais.
  
  
• 01:05:00 Nesta seção, o palestrante discute o problema de inferência de parâmetros e como calcular a estimativa de máxima verossimilhança para resolver equações diferenciais ordinárias (EDOs). A função de verossimilhança é um produto de gaussianas que não pode ser avaliada devido à suposição de que o verdadeiro X não pode ser obtido, portanto, uma aproximação é necessária. Ao assumir que o solucionador é bom o suficiente, o palestrante demonstra que inserir uma solução estimada para a solução verdadeira produz um termo avaliável. A função de verossimilhança é então maximizada minimizando a verossimilhança logarítmica negativa e a função de perda resultante produz uma estimativa de parâmetro. O palestrante conclui com um exemplo usando um modelo SIR-D onde o número de indivíduos infectados no início é desconhecido e precisa ser estimado.
  
  
• 01:10:00 Nesta seção, o palestrante discute como realizar inferência de parâmetros em um modelo de equações diferenciais ordinárias (EDOs). A simulação do modelo ODE é feita tirando amostras ruidosas dele, e dois parâmetros são usados para formar uma função de perda que é calculada comparando as linhas no gráfico de dispersão com os dados reais. O otimizador é usado para iterar a suposição inicial e os parâmetros, e o otimizador L-BFGS é usado para gerar dados de saída. Os dados resultantes podem ser usados para interpretar o modelo e seus parâmetros, que podem ser comparados com a literatura. O modelo é então aprimorado tornando a taxa de contato variável no tempo, o que o torna um pouco mais complexo, e todo o processo de inferência de parâmetros é feito novamente.
  
  
• 01:15:00 Nesta seção, Nathanael Bosch discute os desafios de estimar beta de t, que descreve uma estimativa variável no tempo de uma taxa de contato em ODEs, e enfatiza a necessidade de melhores ferramentas para resolver o problema de estimativa. Para resolver isso, ele propõe o uso de uma rede neural para modelar beta de t e minimizar uma função de perda L2 na inferência de parâmetros. Embora a abordagem da rede neural seja menos interpretável e não forneça boas estimativas de incerteza, ela fornece uma estimativa pontual para a taxa de contato. Além disso, os resultados sugerem que a abordagem de rede neural ainda precisa de melhorias significativas para corresponder ao ajuste do modelo GP, e as incertezas nos resultados devem ser levadas em consideração.
  
  
• 01:20:00 Nesta seção, o palestrante discute a abordagem de usar redes neurais para resolver EDOs e menciona que, embora a quantificação da incerteza não esteja prontamente disponível usando este método, ainda é uma abordagem conceitual válida. As estimativas de máxima verossimilhança são discutidas e o potencial para adicionar prioris e amostragem para fornecer a quantificação da incerteza é mencionado. O palestrante também discute o próximo tópico de solucionadores de EDOs numéricos probabilísticos e destaca a importância dos EDOs na pesquisa de aprendizado de máquina e seu papel na solução de problemas do mundo real. As EDOs neurais também são brevemente mencionadas como uma abordagem mais geral e livre de estrutura, mas com semelhanças na função de perda e nos procedimentos de treinamento.

[MetaQuotes]

Aula 7 -- Solvers EDO Numéricos Probabilísticos -- Nathanael Bosch

Numéricos de ML 7 -- Solvers Numéricos Probabilísticos EDO -- Nathanael Bosch

Neste vídeo, Nathanael Bosch apresenta o conceito de solucionadores ODE numéricos probabilísticos, que combinam estimativa de estado e solucionadores numéricos ODE para fornecer distribuições sobre os estados ou soluções ODE. A Bosch explica como um processo Wiener integrado Q vezes pode ser usado para modelar a verdadeira solução e como esse processo permite quantificar e propagar incertezas no sistema. Em seguida, ele demonstra como usar filtros de Kalman estendidos para resolver EDOs e como os tamanhos dos passos afetam as estimativas de erro. O vídeo termina com uma discussão sobre calibração de incerteza e uso do filtro de Kalman estendido para estimar parâmetros em modelos de espaço de estados não lineares.

Na segunda parte da palestra, Nathanael Bosch fala sobre os benefícios de usar métodos probabilísticos para resolver EDOs, incluindo a obtenção de estimativas de incerteza significativas e a flexibilidade de incluir recursos adicionais do modelo, como valores iniciais. Ele demonstra essa abordagem com exemplos como o oscilador harmônico e equações algébricas diferenciais. Bosch também mostra como a inclusão de informações adicionais e o uso de técnicas probabilísticas podem levar a resultados mais significativos, usando um exemplo de modelo epidêmico que falhou em representar com precisão os dados usando métodos escalares tradicionais. Ele usa filtros de Kalman estendidos e suavizadores para resolver EDOs por meio de estimativa de estado, tratando a estimativa como um problema probabilístico e destaca a importância de ser bayesiano na tomada de decisão.

• 00:00:00 Nesta seção, Nathanael Bosch apresenta o conceito de solucionadores numéricos probabilísticos de EDO. Ele começa resumindo as aulas anteriores, incluindo modelos de espaço de estado e filtros/suavizadores comuns para estimativa de estado e solucionadores numéricos de ODE. Ele explica que o desafio é estimar o estado de uma solução de EDO dada uma equação diferencial, e que os solucionadores numéricos de EDO fornecem apenas uma aproximação. A Bosch então propõe uma maneira de combinar os dois conceitos interpretando EDOs como problemas de estimativa de estado e resolvendo-os como problemas de estimativa de dados. Os algoritmos resultantes fornecem distribuições sobre os estados ou soluções ODE, criando servidores numéricos probabilísticos que oferecem uma saída mais rica do que os servidores clássicos.
  
  
• 00:05:00 Nesta seção, o conceito de solucionadores numéricos probabilísticos de EDO é discutido. Esses solucionadores estimam a solução verdadeira fornecendo uma única estimativa X hat por meio da avaliação do campo vetorial para atualizar ou estender a estimativa para um ponto no tempo futuro com um erro que depende do tamanho do passo. A discussão então segue para o uso da estimativa de estado especial como uma ferramenta para resolver problemas de estimativa numérica de EDO. A distribuição de filtragem, o posterior de suavização e a etapa de previsão que estima estados futuros com informações atuais são explicadas, com algoritmos como o filtro de Kalman estendido e o suavizador de Kalman estendido mencionados como métodos simples para calcular essas quantidades. A seção conclui com a ideia de que as soluções numéricas de EDO podem ser formuladas como um problema de inferência, em vez de tentar calcular a solução verdadeira real, e que o objetivo é encontrar a posterior de x de t que satisfaça a condição inicial e a EDO em uma escala discreta. conjunto de pontos.
  
  
• 00:10:00 Nesta seção, mergulhamos na construção de um modelo de espaço de estado para solucionadores de ODE numéricos probabilísticos. O estado que consideramos é o processo Wiener integrado Q vezes. Este estado é um processo estocástico que descreve o sistema dinâmico e rastreia as derivadas até Q. Rastreando um número limitado de derivadas, podemos obter um modelo de estado probabilístico que nos permite quantificar e propagar a incerteza no sistema. O objetivo principal é definir um prior, uma probabilidade e um modelo de dados que, uma vez resolvido, nos dará uma estimativa da saída. Isso é necessário para fazer a filtragem e suavização Gaussiana, que é um algoritmo rápido para inferência.
  
  
• 00:15:00 Nesta seção, Nathanael Bosch explica o processo estocástico que modela a verdadeira solução de um processo Winner Q vezes integrado. O processo possui transições na forma de um modelo Gaussiano que utiliza uma Matriz a de H e uma Matriz de covariância Q de H que possuem fórmulas de forma fechada. O acesso a uma entrada no processo é uma operação linear, tornando conveniente o acesso à primeira e à segunda derivada. O processo é markoviano e satisfaz as propriedades de um processo gaussiano. A Bosch também mostra gráficos de diferentes amostras do processo, o que ilustra por que ele é chamado de processo linear integrado duas vezes.
  
  
• 00:20:00 Nesta seção, o palestrante discute o Q vezes Integrated Ornstein-Uhlenbeck anterior e como é conveniente porque eles podem anotar as densidades de transição necessárias para a filtragem gaussiana e suavização posteriormente. A parte de probabilidade e combinação de dados também é importante porque informa o anterior para fazer a coisa desejada no topo. O palestrante mostra como usar a linguagem da EDO e define uma função de medição ou operador de informação que deve ser zero em um mundo perfeito onde há computação infinita. Eles também introduzem um modelo de observação e explicam por que ele ajuda a satisfazer o desejado para a inferência. Finalmente, o modelo de verossimilhança sem ruído é uma verossimilhança direta, o que é conveniente porque tem em mente as atualizações do filtro de Kalman.
  
  
• 00:25:00 Nesta seção, Nathanael Bosch discute o modelo gerador de um Z, que é um exemplo concreto da EDO logística, e como ele se relaciona com o processo de inferência. O modelo generativo permite a simulação de soluções, cálculo de derivadas e geração de uma posterior, que colapsa em torno de Z. Esse modelo generativo, além do modelo de verossimilhança que codifica a equação diferencial, permite que o modelo de espaço de estados seja resolvido e fornece estimativas para o X, que se relacionam com a solução. A inferência permite estabelecer uma relação entre o resultado anterior e o resultado final desejado e permite a resolução do modelo de espaço de estados.
  
  
• 00:30:00 Nesta seção, Nathanael Bosch discute a importância de incluir o valor inicial ao resolver uma equação diferencial ordinária por meio de métodos numéricos probabilísticos. Ele explica que adicionar outra medida que depende apenas do valor inicial ao modelo de observação é uma forma mais geral de incluir o valor inicial. Em seguida, ele fornece pseudocódigo para o filtro de Kalman estendido e os blocos de construção do filtro ODE necessários para implementar o algoritmo e descreve o loop de filtragem padrão envolvido nas etapas de previsão e atualização. O algoritmo estendido satisfaz primeiro o valor inicial e usa o modelo de transição A e Q para calcular o tamanho do passo.
  
  
• 00:35:00 Nesta seção, Nathanael Bosch demonstra o código necessário para resolver uma equação diferencial ordinária (ODE) usando métodos numéricos probabilísticos em Julia. Ele observa que, embora as fórmulas possam parecer complicadas, as 10 linhas de código necessárias para configurar o modelo corretamente são simples. Bosch mostra como o filtro de Kalman estendido é implementado com apenas duas linhas de código e a notação padrão para multiplicar com o inverso é substituída por uma solução numericamente estável que resolve um sistema linear. Ele define o campo vetorial, o intervalo de tempo inicial e a verdadeira solução para a EDO logística e demonstra como definir o anterior usando o processo de Wiener integrado duas vezes. A implementação de Bosch do algoritmo de filtro de Kalman estendido corresponde de perto ao pseudocódigo dos slides, e a distribuição inicial que ele usa é definida arbitrariamente como média zero e covariância padrão.
  
  
• 00:40:00 Nesta seção, Nathanael Bosch demonstra como usar filtros de Kalman estendidos para resolver EDOs e traçar as estimativas do filtro. Ele então brinca com tamanhos de passo, mostrando como tamanhos de passo menores diminuem as incertezas e como os maiores as aumentam. Ele explica que a incerteza não cresce apenas com o tempo e as estimativas de erro são um modelo do erro que está acontecendo. Por fim, ele demonstra que a suavização geralmente melhora os resultados das trajetórias, o que condiz com a motivação de duas palestras atrás. No entanto, as estimativas de erro poderiam ser ainda melhores, mas ele pede ao público informações sobre como fazê-lo.
  
  
• 00:45:00 Nesta seção, aprendemos que a estimativa de erro para o solucionador EDO numérico probabilístico é muito grande e precisa ser corrigida por meio de calibração de incerteza. O hiperparâmetro sigma quadrado influencia diretamente as incertezas e precisa ser definido adequadamente para obter estimativas de incerteza reais que sejam significativas. A motivação para definir os hiperparâmetros é semelhante à dos processos gaussianos, onde os hiperparâmetros são estimados maximizando a verossimilhança dos dados dados o parâmetro. A probabilidade dos dados pode ser decomposta, tornando conveniente expressar e otimizar.
  
  
• 00:50:00 Nesta seção, Nathanael Bosch discute o uso do filtro de Kalman estendido para estimar os parâmetros em um modelo de espaço de estado não linear. O P de z K dado Z1 até K menos 1 é estimado usando estimativas gaussianas, e o chapéu Sigma é calculado como o argmax da estimativa de probabilidade quase máxima. Nos filtros ODE, é possível calcular a estimativa de máxima verossimilhança de forma fechada usando uma forma reescalonada de recalibrar as estimativas dos parâmetros. Este método produz melhores estimativas e corresponde à estimativa de máxima verossimilhança Sigma. A Bosch explica como isso pode ser implementado usando uma função de atualização com um sufixo de calibração.
  
  
• 00:55:00 Nesta seção, Nathanael Bosch discute o Filtro de Kalman Estendido (EKF) para solucionadores numéricos probabilísticos de Equação Diferencial Ordinária (ODE). Ele menciona que foi modificado para aumentar a escotilha sigma, o que resulta na soma sendo calculada de forma contínua e dividida por n, que é a quantidade que eles desejam calcular. O EKF estava tentando anteriormente aproximar algo tão Gaussiano que pode não ser, e o objetivo é obter estimativas de incerteza que sejam tão informativas quanto possível. Ao fazer isso, eles obtiveram um algoritmo que fornece estimativas de erro úteis que descrevem significativamente o erro numérico do solucionador de EDO. O algoritmo obtido é rápido e fornece estimativas de incerteza não perfeitas, mas ainda úteis.
  
  
• 01:00:00 Nesta seção, Nathanael Bosch explica a motivação para usar métodos probabilísticos para resolver EDOs. Além de simplesmente quantificar a incerteza e obter estimativas e gráficos de incerteza significativos, a Bosch acredita que formular solucionadores de EDO de maneira probabilística é flexível e conveniente, permitindo a inclusão de recursos de modelo adicionais, como valores iniciais. Ao definir um modelo de espaço de estado e executar um filtro de Kalman estendido, é possível resolver não apenas problemas numéricos com valor inicial, mas também EDOs de ordem superior com informações adicionais.
  
  
• 01:05:00 Nesta seção, Nathanael Bosch explica uma abordagem diferente para valores iniciais para solucionadores de EDO. Ele define uma nova quantidade para garantir que X1 seja igual à derivada inicial fornecida, e isso pode ser usado para executar um filtro de comando estendido com algumas etapas de previsão e atualização. Ele mostra o exemplo do oscilador harmônico e como apenas duas linhas precisavam ser alteradas antes para incluir uma atualização na primeira derivada. A calibração é aplicada novamente para obter resultados significativos, e o erro neste caso não tende a zero, pois não há atrator para o qual tender, mas se ajusta dependendo da configuração do problema. Bosch também discute equações algébricas diferenciais, que são equações diferenciais que não podem ser movidas da esquerda para a direita devido a uma matriz singular.
  
  
• 01:10:00 Nesta seção, o palestrante discute o conceito de equações algébricas diferenciais (DAE), que são equações que não descrevem uma derivada e têm um valor constante em algum ponto. O palestrante sugere uma modificação no algoritmo de verossimilhança ODE para criar um algoritmo de verossimilhança DAE que possa resolver DAE de forma probabilística. O palestrante então dá um exemplo de um problema em que uma EDO tem informações adicionais e sugere uma modificação no modelo de espaço de estado para introduzir um modelo de observação adicional para que o algoritmo possa aplicar ambos os modelos de observação para satisfazer g na grade discreta. O palestrante fornece um exemplo de vídeo que ilustra a importância das quantidades de conservação na resolução de problemas com EDOs e informações adicionais.
  
  
• 01:15:00 Nesta seção do vídeo, Nathanael Bosch discute o uso de solucionadores numéricos probabilísticos de ODE e os benefícios de incluir informações adicionais para melhorar os resultados dos modelos ODE. Ele apresenta um exemplo de modelo epidêmico, onde o modelo escalar tradicional falhou em representar os dados com precisão e mostra como um processo gaussiano pode ser usado para melhorar o modelo. Adicionar mais informações e usar técnicas probabilísticas pode levar a um resultado mais significativo.
  
  
• 01:20:00 Nesta seção, a Bosch discute solucionadores de ODE numéricos probabilísticos, que envolvem o uso de um operador de medição linear para medir certas dimensões de uma solução para um ODE, representado como um objeto quadridimensional (sirnd). Depois de criar um modelo de espaço de estados, a solução ODE é resolvida, com a adição de um estado beta, e são considerados os modelos de verossimilhança da solução ODE, valor inicial e dados. A tarefa de inferência envolve o uso de um filtro de Kalman estendido para determinar quais são os pontos brancos, dados os pontos pretos dos dados observados. Também é sugerido que X e beta sejam mesclados para uma reformulação mais simples.
  
  
• 01:25:00 Nesta seção, o palestrante explica como funcionam os Solucionadores de EDOs Numéricos Probabilísticos, que é essencialmente uma forma de resolver EDOs por meio de estimação de estado, tratando a estimativa como um problema probabilístico. Ele define um método para resolver ODEs usando filtros de Kalman estendidos e suavizadores que levam a uma variedade de solucionadores às vezes chamados de "filtros ODE". O palestrante destaca a importância de ser bayesiano na tomada de decisões e a utilidade das estimativas de incerteza, bem como a conveniência de usar algoritmos pacientes que podem ser aplicados a uma variedade de problemas, incluindo a resolução de EDOs.
  
  
• 01:30:00 Nesta seção, o palestrante fala sobre o uso de filtros de comando externos de maneira não padronizada para resolver problemas numéricos e realizar inferências a partir de dados de uma forma que combine física e observações externas gerais. Segundo o palestrante, a filtragem e suavização bayesiana são a melhor forma de modelar ou formular sistemas dinâmicos, pois permite a adição flexível de informações e a fatoração do algoritmo de inferência. O público é incentivado a escanear códigos QR para obter feedback e perguntas para o palestrante são bem-vindas.

[MetaQuotes]

Aula 8 -- Equações Diferenciais Parciais -- Marvin Pförtner

Numéricos de ML 8 -- Equações Diferenciais Parciais -- Marvin Pförtner

Marvin Pförtner discute equações diferenciais parciais (PDEs) e sua importância na modelagem de vários sistemas do mundo real. Ele explica como os PDEs representam o mecanismo de um sistema com uma função desconhecida e um operador diferencial linear, mas requerem a resolução de parâmetros que muitas vezes são desconhecidos. A inferência do processo gaussiano pode ser usada para analisar modelos PDE e injetar conhecimento mecanicista em modelos estatísticos. Pförtner examina a distribuição de calor em uma unidade de processamento central em um computador, restringindo o modelo a uma distribuição de calor bidimensional e apresentando as suposições feitas para o modelo. A palestra também cobre o uso de processos gaussianos para resolver PDEs e adicionar condições de contorno realistas para modelar a incerteza. No geral, a abordagem GP combinada com a noção de um operador de informação nos permite incorporar conhecimento prévio sobre o comportamento do sistema, injetar conhecimento mecanístico na forma de um PDE linear e lidar com condições de contorno e lados direitos.

Na segunda parte deste vídeo, Marvin Pförtner discute o uso de processos Gaussianos para resolver equações diferenciais parciais (PDEs) estimando uma medida de probabilidade sobre funções em vez de uma estimativa pontual. Ele explica os benefícios da quantificação da incerteza e observa que essa abordagem é mais honesta porque reconhece a incerteza na estimativa da função do lado direito da PDE. Pförtner também explica o kernel Matern, que é útil na prática e pode controlar a diferenciabilidade do GP, e fornece uma fórmula para calcular o parâmetro P para o kernel Matern. Ele ainda explica como construir um kernel d-dimensional para PDEs tomando produtos de kernels Matern unidimensionais sobre as dimensões e a importância de ser matematicamente cuidadoso na construção do modelo.

• 00:00:00 Nesta seção da palestra, Marvin Pförtner apresenta as equações diferenciais parciais (PDEs) e sua importância na descrição de modelos mecanísticos que geram dados no mundo real, incluindo mercados financeiros, fluidos como clima e tempo e mecânica das ondas . Apesar de serem difíceis de resolver, os PDEs lineares continuam a ser uma poderosa linguagem de modelagem, pois descrevem com precisão muitos processos físicos, como condução térmica, eletromagnetismo e velocidades de partículas no movimento browniano. A palestra se concentra especificamente na integração de modelos baseados em PDE em modelos probabilísticos de aprendizado de máquina por meio de um exemplo de modelagem prática.
  
  
• 00:05:00 Nesta seção, Marvin Pförtner discute o uso de equações diferenciais parciais (PDEs) para modelar vários sistemas, incluindo modelos físicos e financeiros. Ele enfatiza a importância de entender o comportamento do mecanismo de um sistema e inferir seu comportamento com o uso de modelos PDE. No entanto, os PDEs geralmente exigem parâmetros do sistema que são desconhecidos, e o objetivo é usar a estimativa estatística bayesiana para fundir o conhecimento mecanicista do sistema com dados de medição para encontrar esses parâmetros desconhecidos e ganhar confiança nas previsões. Marvin também explica PDEs lineares e como eles se relacionam com sistemas físicos com extensão espacial.
  
  
• 00:10:00 Nesta seção, Marvin Pförtner discute equações diferenciais parciais (PDEs), que são comumente usadas para descrever sistemas físicos, como distribuições de temperatura ou a força gerada por um conjunto de cargas elétricas. A função desconhecida em uma EDP representa o sistema que está sendo simulado, e o conhecimento mecanístico é dado por um operador diferencial linear. No entanto, um desafio com os PDEs é que eles geralmente não possuem uma solução analítica e requerem solucionadores numéricos que introduzem erros de discretização. Parâmetros materiais e a função do lado direito são dois dos parâmetros que não podem ser conhecidos exatamente, causando dificuldades na propagação de incertezas através de solucionadores clássicos. Além disso, os PDEs geralmente não identificam exclusivamente sua solução, exigindo a imposição de condições adicionais.
  
  
• 00:15:00 Nesta seção, o palestrante discute equações diferenciais parciais (PDEs) e sua relação com funções, que são objetos de dimensão infinita. O operador diferencial é linear, o que significa que as funções lineares estão no núcleo do operador diferencial, permitindo adicionar um termo linear a qualquer solução da equação de Poisson e ainda obter uma solução. As condições de contorno são necessárias para modelar as interações fora do domínio de simulação, que são então resumidas em como o exterior interage com a simulação no limite. As EDPs são declarações sobre funções pertencentes a espaços de funções, que são conjuntos de funções que possuem uma estrutura de espaço vetorial semelhante à do Rn, permitindo a representação de operadores lineares por matrizes. Operadores lineares são mapas entre espaços de função que possuem uma propriedade de linearidade porque um operador diferencial mapeia uma função para sua derivada.
  
  
• 00:20:00 Nesta seção, Pförtner explica que os PDEs lineares são essencialmente sistemas lineares em um espaço vetorial de dimensão infinita e retransmite a importância de definir normas em espaços vetoriais e entender a convergência. Ele então apresenta um modelo matemático da distribuição de calor em uma unidade central de processamento em um computador e restringe o modelo a uma distribuição de calor bidimensional em uma linha que corta o chip. A palestra discute as suposições feitas para este modelo e como ele é um bom modelo para este caso particular.
  
  
• 00:25:00 Nesta seção, o palestrante discute a modelagem das fontes e dissipadores de calor em um chip e como isso pode ser representado usando equações diferenciais parciais (PDEs). Eles explicam a equação do calor, que é uma PDE linear de segunda ordem e como ela pode ser aplicada para modelar a distribuição de temperatura no chip. O palestrante também explica como o conhecimento mecanístico da equação diferencial pode ser injetado em modelos estatísticos interpretando os PDEs como uma observação da função desconhecida e a imagem sob o operador diferencial. Os PDEs são comparados às leis fundamentais da física que descrevem a conservação de quantidades fundamentais como energia e massa.
  
  
• 00:30:00 Nesta seção, Marvin Pförtner discute a relação entre temperatura e energia térmica e como elas são proporcionais entre si por meio de parâmetros materiais. Ele explica que toda mudança na energia térmica pode ser explicada por um valor conhecido de calor que entra no sistema ou pelo calor que flui para um determinado ponto do ambiente por meio da condução de calor. Ele então apresenta o operador de informação como um conceito matemático que pode ser usado para expressar qualquer informação, incluindo a de uma equação diferencial. Ele explica ainda como um processo gaussiano anterior pode ser usado para modelar uma função desconhecida U e como o posterior pode ser calculado usando fechamentos de processos gaussianos sob observações lineares. No entanto, como resolver PDEs requer um conjunto infinito de observações, é computacionalmente impossível para a maioria dos casos, a menos que informações analíticas sejam conhecidas sobre o problema que está sendo resolvido.
  
  
• 00:35:00 Nesta seção, o palestrante discute o uso de processos gaussianos (GPs) para resolver equações diferenciais parciais (PDEs), que é semelhante à abordagem usada em equações diferenciais ordinárias (ODEs). O GP é visto como uma medida de probabilidade em espaços de função e um operador linear mapeia os caminhos amostrais desse GP em RN. A preditiva a priori desse processo é uma distribuição normal, com a média dada pela imagem da função média GP através do operador linear, e a matriz de covariância muito semelhante à matriz de covariância encontrada no caso de dimensão finita. O posterior deste evento acaba por ter uma estrutura semelhante a ele. O palestrante observa que muitos detalhes teóricos estão envolvidos e é necessário cautela devido aos infinitos envolvidos na resolução de PDEs usando GPs.
  
  
• 00:40:00 Nesta seção, Marvin Pförtner explica como calcular uma escolha específica de um operador linear e as dificuldades em expressá-lo na notação de operador linear padrão. Ele também discute como diferenciar um argumento, diferenciar o outro argumento e construir uma matriz de todas as derivadas pareadas entre dois pontos. Ele então fala sobre como usar o mesmo teorema para aplicá-lo ao problema e calcular o processo gaussiano posterior e como definir o conjunto de pontos de colocação.
  
  
• 00:45:00 Nesta seção, o palestrante explica como uma forma generalizada de inferência do Processo Gaussiano pode resolver um problema de valor de contorno. Eles descrevem como as observações podem ser representadas usando uma função preta que corresponde ao lado direito da Equação Diferencial Parcial (PDE) e como as informações aprendidas com isso podem ser propagadas de volta ao Processo Gaussiano original. O grau de liberdade no PDE que as condições de contorno não fixam pode causar incerteza, mas ao impor as condições de contorno de Dirichlet, o posterior torna-se um problema de regressão do Processo Gaussiano normal, que funciona se os dois valores de contorno forem observados. O palestrante enfatiza a importância de observar que os valores limite na implantação geralmente não são conhecidos e seria útil adicionar incerteza aos valores limite e à distribuição da fonte de calor.
  
  
• 00:50:00 Nesta seção, o palestrante discute condições de contorno mais realistas para equações diferenciais parciais. Ele afirma que o calor é extraído uniformemente sobre toda a superfície da CPU e essa informação pode ser modelada como condições de contorno de Neumann, onde a primeira derivada de um ponto de contorno é definida em vez do valor do ponto de contorno. Ao fazer isso, podemos adicionar incerteza ao modelo e usar uma distribuição gaussiana para modelar a derivada. Um operador de informação adicional é usado para descrever essa condição de contorno. O palestrante explica ainda como a escala absoluta do sistema é determinada usando termômetros dentro da CPU e também como estimativas incertas da função podem ser obtidas pela modelagem de uma crença anterior usando outro processo gaussiano.
  
  
• 00:55:00 Nesta seção, Marvin Pförtner discute como integrar conhecimento prévio sobre o comportamento de um sistema no modelo, com a ajuda de processos gaussianos e operadores de informação. Ele menciona que é essencial escolher a função do lado direito para o modelo integrável a zero para evitar que o sistema apenas aqueça continuamente. Pförtner então passa a discutir os desafios de garantir que o GP tenha área um em todas as suas amostras e como eles podem ser resolvidos adicionando restrições adicionais, incluindo os efeitos de contorno, que levam em conta o calor que sai pelo contorno. Finalmente, Pförtner conclui que esta abordagem GP combinada com a noção de um operador de informação nos permite incorporar conhecimento prévio sobre o comportamento do sistema, injetar conhecimento mecanístico na forma de um PDE linear e lidar com condições de contorno e lados direitos.
  
  
• 01:00:00 Nesta seção, Marvin Pförtner discute o uso de processos gaussianos para resolver equações diferenciais parciais (PDEs) estimando uma medida de probabilidade sobre funções em vez de uma estimativa pontual, que pode fornecer intervalos de confiança e amostras que atendem às condições da PDE . Ele explica que essa abordagem é mais honesta porque reconhece a incerteza na estimativa da função do lado direito do PDE e pode ser aplicada a simulações 2D, bem como a simulações com o tempo como outra dimensão espacial. Pförtner observa que a média posterior desse método assumindo nenhuma incerteza é equivalente a um método clássico chamado colocação simétrica. Finalmente, ele explica que outros métodos para resolver EDPs, como resíduo ponderado, volume finito e métodos espectrais, também podem ser realizados como meios posteriores de um processo gaussiano, apenas sem a quantificação da incerteza.
  
  
• 01:05:00 Nesta seção, o palestrante explica como os processos Gaussianos (GPs) podem ser usados para resolver equações diferenciais parciais lineares (PDEs) e também realizar regressão para estimativa de função. Eles enfatizam a importância de escolher as funções certas e antes de trabalhar, bem como os benefícios da quantificação da incerteza. O palestrante também aponta os casos de falha, como quando os caminhos amostrais dos GPs não são diferenciáveis, e a necessidade de verificar condições importantes para que tudo seja rigoroso. A seção termina com um teaser de uma publicação futura do grupo de palestrantes que se aprofundará nos detalhes formais desses teoremas.
  
  
• 01:10:00 Nesta seção, o palestrante discute como os processos Gaussianos (GPs) são definidos e usados para modelar funções desconhecidas. GPs são coleções de variáveis aleatórias de valor real, uma para cada ponto em seu domínio. Eles são usados para representar funções, mas só conhecemos a combinação finita de avaliações do GP. Para obter um caminho de amostra de um GP, precisamos amostrar continuamente uma função fixando um Omega e transformando-o em todas as funções. Garantimos que os caminhos de amostra sejam suficientemente diferenciáveis para garantir que sejam definidos. Além disso, para calcular LF, a imagem de um GP sob um operador linear L, fixamos um Omega e aplicamos L à função correspondente.
  
  
• 01:15:00 Nesta seção, o palestrante explica como um caminho de amostra pode ser mapeado por meio de um operador linear para criar um objeto de dimensão infinita chamado GP, que posteriormente é transformado em uma variável aleatória que precisa ser mensurável. Eles observam que os caminhos de amostragem do GPS são transformados em um Espaço de Hilbert do kernel de reprodução, escolhendo um kernel apropriado; no entanto, o espaço de Hibbert do kernel de reprodução do kernel real do GP não é o espaço de onde as amostras vêm, e um espaço maior precisa ser escolhido em que essas amostras estão contidas. O palestrante discute o kernel Matern, que é útil na prática e pode controlar a diferenciabilidade do GP, e fornece uma fórmula para calcular o parâmetro P para o kernel Matern, que pode ajudar a generalizar o processo.
  
  
• 01:20:00 Nesta seção, o palestrante explica como construir um kernel d-dimensional para equações diferenciais parciais (PDEs) tomando produtos de kernels Matern unidimensionais sobre as dimensões, especialmente se houver ordens mistas das derivadas. Isso ajuda a se adaptar à equação concreta que os usuários estão tentando resolver. Além disso, o GPS fornece uma estrutura para combinar várias fontes de informação em um único modelo de regressão usando operadores de informação afim. O palestrante destaca a importância do cuidado matemático na construção do modelo, principalmente na construção da priori para uma equação específica.