Aprendizado de máquina e redes neurais - página 65
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Fundamentos do Python - Parte 02
Fundamentos do Python - Parte 02
Eu sou o Dr. Soper e hoje tenho o prazer de apresentar a segunda parte de nossa série de três partes sobre os fundamentos da linguagem de programação Python.
Antes de mergulharmos na lição de hoje, quero enfatizar que as informações que compartilharei se baseiam no conhecimento e nas habilidades que desenvolvemos na lição anterior. Portanto, se você ainda não teve a oportunidade de assistir ao vídeo anterior, recomendo fortemente que o faça antes de iniciar esta lição sobre Python.
Agora, vamos analisar brevemente o que você pode esperar aprender nesta lição.
Ao final deste vídeo, você obterá conhecimento sobre os seguintes aspectos do Python:
Ao longo da lição, exploraremos cada um desses tópicos em detalhes, completos com exemplos ilustrativos e demonstrações mostrando seus recursos na linguagem de programação Python.
Vamos começar discutindo listas em Python.
Em Python, uma lista é simplesmente uma coleção nomeada de itens. Esses itens podem ser de qualquer tipo, incluindo números, texto, variáveis, objetos e até mesmo outras listas! Se uma lista contém outras listas como seus itens, ela é chamada de lista multidimensional.
Para ilustrar, vamos considerar alguns exemplos. No primeiro exemplo, criamos uma lista chamada "int list" e atribuímos os valores -3, 7, 4, 0, -2 e 342 aos seus elementos. Você pode visualizar uma lista simples e unidimensional como um vetor. Python identifica uma lista por seus colchetes. Para atribuir valores aos elementos da lista, os separamos com vírgulas dentro dos colchetes. Lembre-se de que as listas podem acomodar itens de qualquer tipo de dados.
No segundo exemplo, declaramos uma lista de planetas e atribuímos os nomes de todos os planetas conhecidos em nosso sistema solar como seus elementos. Vale a pena notar que Plutão foi rebaixado ao status de "planeta anão" pela União Astronômica Internacional em 2006, portanto não está incluído nesta lista. Passando para o terceiro exemplo, declaramos uma lista bidimensional. Em outras palavras, os elementos dessa lista também são listas. Você pode pensar nisso como uma matriz 2x3 com duas linhas e três colunas.
Agora, vamos observar algumas demonstrações onde as listas são declaradas e utilizadas em Python. Na primeira célula de código, simplesmente declaramos as três listas que discutimos anteriormente. Quando executamos esta célula, nenhuma saída será exibida porque estamos apenas instruindo o Python a criar essas três listas e armazená-las na memória do computador. Na célula de código subsequente, exploraremos como acessar valores específicos em uma lista. No entanto, antes de prosseguirmos, é importante entender a indexação em Python.
Python emprega um sistema de indexação baseado em zero. Isso significa que, ao lidar com coleções como listas ou arrays, o primeiro item tem índice zero, o segundo item tem índice um e assim por diante. Para ilustrar, vamos considerar nossa "lista int" como exemplo. Esta lista contém seis valores. Se quisermos acessar, digamos, o quinto item da lista, esse item teria um índice de 4.
Tendo entendido esse sistema de indexação baseado em zero, a próxima célula de código simplesmente imprime o nome do terceiro planeta na lista de "planetas", que, neste caso, é "Terra". Como é o terceiro elemento da lista, ele deve estar localizado na posição 2 do índice. Vamos clicar no botão executar para verificar se a saída é a esperada e confirmar que a Terra é de fato a terceira rocha depois do sol.
Seguindo em frente, vamos nos aprofundar no próximo tópico desta lição: arrays NumPy em Python. Agora, vamos passar para o próximo tópico desta lição: instruções if e operadores lógicos. O Python nos fornece a capacidade de usar instruções condicionais usando instruções if. Uma instrução if nos permite executar diferentes blocos de código com base no fato de uma determinada condição ser verdadeira ou falsa. Além disso, o Python também fornece operadores lógicos que nos permitem combinar várias condições.
No primeiro exemplo, temos uma estrutura if-else simples que verifica se uma variável chamada 'x' é menor que 10. Se a condição for verdadeira, imprime "x é menor que 10" na tela. Caso contrário, se a condição for falsa, imprime "x é maior ou igual a 10". A instrução else é usada para especificar o código que deve ser executado quando a condição na instrução if for falsa.
Podemos estender essa estrutura para lidar com várias possibilidades usando uma estrutura if-elif-else. No segundo exemplo, introduzimos uma condição adicional verificando se a idade da pessoa é menor que 13 anos. Com base na idade da pessoa, o código determina se a pessoa é criança, adolescente ou adulto. A instrução elif nos permite verificar condições adicionais antes de retornar à instrução else se nenhuma das condições for verdadeira.
Vamos ver algumas demonstrações dessas instruções if e operadores lógicos em ação em nosso Jupyter Notebook.
Na primeira célula de código, declaramos uma variável chamada 'x' e definimos seu valor. Em seguida, usamos uma estrutura if-else para imprimir uma mensagem específica dependendo se 'x' é menor que 10. Vamos executar a célula de código e observar a saída. Como o valor de 'x' é atualmente 10, o Python imprime "x é maior ou igual a 10" na tela. Se alterarmos o valor de 'x' para -7 e executarmos a célula de código novamente, obteremos um resultado diferente. Depois de alterar o valor de 'x' para -7, o Python agora imprime "x é menor que 10".
Na próxima célula de código, implementamos a estrutura if-elif-else para determinar se uma pessoa é criança, adolescente ou adulto com base em sua idade. Vamos executar a célula e ver o que acontece. Como esperado, o Python imprime "child" porque o valor da variável 'age' está atualmente definido como 5. Se alterarmos o valor de 'age' e executarmos novamente a célula de código, obteremos resultados diferentes com base na idade da pessoa. Passando para o próximo tópico, vamos discutir os operadores lógicos em Python. Python fornece três operadores lógicos: 'and', 'or' e 'not'. Esses operadores nos permitem testar várias condições simultaneamente.
No primeiro exemplo, demonstramos como usar os operadores 'and' e 'or' para determinar se duas variáveis, 'x' e 'y', são positivas. A instrução if verifica se 'x' e 'y' são positivos. Se pelo menos uma das condições for falsa, o código prossegue para a instrução elif, que verifica se 'x' ou 'y' é positivo. Se nem 'x' nem 'y' forem positivos, a instrução else será executada.
No segundo exemplo, introduzimos o operador 'not', que é utilizado para reverter ou inverter o resultado de uma comparação. Verificamos se a idade de uma pessoa não é inferior a 13 anos. Se a pessoa não é inferior a 13 anos, ela deve ter pelo menos 13 anos e, portanto, não ser uma criança. Caso contrário, eles são considerados uma criança.
Vamos ver algumas demonstrações desses operadores lógicos sendo usados em Python.
Na primeira célula de código, usamos os operadores lógicos 'and' e 'or' para determinar se 'x' e 'y' são positivos. Definimos 'x' como 5 e 'y' como -2. Vamos executar a célula e observar a saída. Como 'y' é negativo, a condição para o operador 'e' é falsa. No entanto, a condição para o operador 'ou' é verdadeira porque 'x' é positivo. Portanto, o código imprime "x é positivo" na tela. Agora, vamos alterar o valor de 'x' para -3 e executar a célula de código novamente. Desta vez, ambas as condições para os operadores 'e' e 'ou' são falsas, então o código segue para a instrução else e imprime "x e y não são positivos".
Na próxima célula de código, usamos o operador 'não' para verificar se uma pessoa não é criança com base em sua idade. Definimos a variável 'idade' como 10, o que significa que a pessoa é considerada uma criança. Vamos executar a célula de código e observar a saída. Como a idade da pessoa é menor que 13 anos, a condição para o operador 'não' é falsa e o código imprime "Criança" na tela.
Agora, altere o valor de 'idade' para 18 e execute novamente a célula de código. Desta vez, a idade da pessoa não é inferior a 13 anos, portanto, a condição para o operador 'não' é verdadeira e o código imprime "Não é uma criança". Isso conclui nossa lição sobre listas, arrays NumPy, instruções if e operadores lógicos em Python. Espero que você tenha achado essas informações úteis e que elas o ajudem em sua jornada de programação em Python.
Na próxima e última parte desta série, exploraremos tópicos mais avançados, incluindo loops, funções e manipulação de arquivos. Então, fique atento a isso!
Obrigado pela atenção, e até a próxima aula!
Fundamentos do Python - Parte 03
Fundamentos do Python - Parte 03
Espero que todos estejam tendo um bom dia. Aqui é o Dr. Soper, e estou muito feliz por estar de volta com vocês para nossa terceira lição sobre os fundamentos da linguagem de programação Python. Na sessão de hoje, vamos nos aprofundar no Python e explorar alguns conceitos-chave que irão aprimorar sua compreensão e proficiência.
Antes de começar, gostaria de enfatizar que as informações apresentadas nesta lição se baseiam no conhecimento e nas habilidades que desenvolvemos nas duas lições anteriores. Se você ainda não assistiu a esses vídeos, recomendo fortemente que o faça antes de mergulhar nesta lição sobre Python.
Agora, vamos dedicar um momento para discutir o que você pode esperar aprender nesta lição. Ao final desta sessão, você terá uma compreensão abrangente dos seguintes aspectos do Python:
Ao longo desta lição, exploraremos esses conceitos por meio de exemplos ilustrativos e demonstrações, permitindo que você compreenda suas aplicações práticas na linguagem de programação Python.
Vamos começar nos aprofundando no mundo dos loops "for" e "while" em Python.
Em geral, os loops nos permitem executar um conjunto de instruções repetidamente. Python fornece dois tipos de loops: loops "for" e loops "while". A principal distinção entre os dois é que os loops "for" são executados um número específico de vezes, enquanto os loops "while" continuam sendo executados até que uma determinada condição seja atendida.
Vamos começar com um exemplo de loop "for" que imprime os 10 primeiros números naturais, que são inteiros variando de 1 a 10. Para criar um loop "for", usamos a palavra-chave "for" seguida de um nome de variável. Neste caso, usaremos a variável "x". À medida que o loop "for" itera, a variável "x" receberá um valor diferente para cada iteração. Em seguida, especificamos o conjunto de itens que serão atribuídos iterativamente à variável, seguido de dois pontos. Neste exemplo específico, criamos o conjunto de itens usando a função "range" do Python. A função "intervalo" retorna um intervalo de números entre um limite inferior e um limite superior. Notavelmente, o limite inferior é inclusivo, enquanto o limite superior é exclusivo. Portanto, o intervalo de números neste exemplo será de 1 a 10.
Durante a primeira iteração do loop, o valor de "x" será 1. Subseqüentemente, "x" receberá 2 durante a segunda iteração e assim por diante até atingir 10. Quaisquer linhas de código recuadas após o "for" instrução será executada com cada iteração do loop. Neste exemplo, estamos simplesmente imprimindo o valor de "x", resultando na exibição dos números de 1 a 10.
Agora, vamos explorar outro loop "for" que imprime os nomes dos planetas. Nesse caso, usaremos o nome da variável "planeta" para controlar o loop e iteraremos sobre uma lista de planetas. À medida que o loop avança, a variável "planeta" receberá o nome de cada planeta, um por um, permitindo-nos imprimir o nome de cada planeta na lista.
Seguindo em frente, vamos discutir loops aninhados em Python. Com loops aninhados, um loop (conhecido como loop interno) é executado dentro de outro loop (conhecido como loop externo). O loop interno será executado uma vez para cada iteração do loop externo. Por exemplo, considere um cenário onde o loop externo preenche uma variável chamada "linha" com inteiros variando de 0 a 1, enquanto o loop interno preenche uma variável chamada "coluna" com inteiros variando de 0 a 2. Esses números correspondem à linha e índices de coluna de uma matriz NumPy bidimensional. À medida que o loop aninhado progride, ele primeiro imprime os valores de todos os elementos na primeira linha da matriz e, em seguida, passa para a segunda linha.
Finalmente, vamos explorar o loop "while". Nesse tipo de loop, contamos com uma variável de controle, como "x", que é inicialmente definida com um valor específico. O loop continuará executando enquanto o valor de "x" satisfizer uma determinada condição. Por exemplo, podemos inicializar "x" em 1, e o loop continuará rodando enquanto "x" permanecer abaixo de 10. A cada iteração, o valor de "x" será atualizado, permitindo realizar ações específicas dentro do loop até que a condição não seja mais atendida.
Isso encerra nossa visão geral dos loops "for" e "while" em Python. No próximo segmento, exploraremos as funções, um conceito fundamental na programação que nos permite organizar e reutilizar o código de forma eficaz.
Fundamentos do Aprendizado por Reforço
Fundamentos do Aprendizado por Reforço
Eu sou o Dr. Soper e hoje discutirei os fundamentos do aprendizado por reforço, que é uma área crucial dentro do domínio mais amplo da inteligência artificial. Antes de nos aprofundarmos nos fundamentos do aprendizado por reforço, vamos revisar o que você aprenderá nesta lição.
Ao final deste vídeo, você terá uma compreensão clara do seguinte:
Assim que entendermos esses conceitos, estaremos totalmente equipados para começar a construir modelos reais de IA. Então, não vamos perder tempo e começar!
Primeiro, vamos explorar o que significa "aprendizado por reforço". Juntamente com o aprendizado supervisionado e o aprendizado não supervisionado, o aprendizado por reforço é um dos três paradigmas principais do aprendizado de máquina.
No aprendizado supervisionado, uma máquina aprende uma função geral para prever saídas com base em pares de entrada-saída. No aprendizado não supervisionado, uma máquina descobre padrões em um conjunto de dados sem conhecimento prévio sobre os dados. Por outro lado, o aprendizado por reforço visa treinar uma máquina para entender seu ambiente de forma a permitir que ela tome ações para maximizar as recompensas cumulativas. Para conseguir isso, o aprendizado por reforço envolve encontrar o equilíbrio ideal entre explorar o ambiente e explorar o que foi aprendido até agora. Agora, vamos nos aprofundar nos cinco princípios subjacentes à IA baseada no aprendizado por reforço.
O primeiro princípio que discutiremos é o sistema de entrada e saída. Este sistema não é exclusivo do aprendizado por reforço, mas é fundamental para todos os sistemas de inteligência artificial e computação cognitiva. Envolve a conversão de entradas em saídas.
No contexto do aprendizado por reforço, as entradas são chamadas de "estados", representando o estado do ambiente. As saídas são chamadas de "ações", respondendo à pergunta "O que devo fazer a seguir?" O objetivo do aprendizado por reforço é identificar uma política ótima que guie as ações em cada estado.
Seguindo em frente, vamos falar sobre recompensas. As recompensas desempenham um papel crucial em todos os sistemas de IA e computação cognitiva. Eles agem como métricas que informam o sistema sobre seu desempenho. As funções de recompensa podem ser projetadas para maximizar ganhos ou minimizar perdas, dependendo do problema que está sendo resolvido. Recompensas imediatas e cumulativas são consideradas para maximizar o total de recompensas acumuladas ao longo do tempo.
O terceiro princípio é o ambiente, que se refere ao cenário ou ambiente em que o sistema de aprendizado por reforço opera. O ambiente fornece informações sobre estados e recompensas. Também define as regras do jogo, determinando quais ações são possíveis a qualquer momento. Inicialmente, o sistema não tem conhecimento das consequências de suas ações e deve experimentar para aprender.
Em seguida, temos os Processos de Decisão de Markov (MDP). Com o nome do matemático Andrey Andreyevich Markov, os MDPs fornecem uma estrutura matemática para modelar a tomada de decisões quando os resultados são parcialmente aleatórios e parcialmente sob o controle de um tomador de decisão. No aprendizado por reforço, o sistema de IA atua como o tomador de decisão operando no ambiente. Os MDPs envolvem unidades discretas de tempo e as transições do sistema de um estado para o próximo com base em observações, ações, recompensas e estados subsequentes.
Por fim, temos o modo de treinamento e o modo de inferência. Os sistemas de aprendizado por reforço passam por duas fases: treinamento e inferência. No modo de treinamento, o sistema aprende e busca identificar uma política ótima por meio de vários ciclos de treinamento. Atualiza sua política com base no conhecimento adquirido. No modo de inferência, o sistema foi totalmente treinado e é implantado para executar sua tarefa usando a política aprendida sem atualizações adicionais.
Agora que temos uma compreensão sólida dos princípios do aprendizado por reforço, podemos começar a construir modelos reais de aprendizado por reforço. Nos próximos dois vídeos, exploraremos modelos de aprendizado por reforço que utilizam a amostragem de Thompson para resolver problemas práticos. O primeiro modelo abordará o dilema exploração-exploração no problema do bandido multi-armado, e o segundo modelo otimizará resultados em uma campanha publicitária complexa usando simulações.
Esses vídeos fornecerão experiência prática na criação de modelos de IA usando Python. Espero que você se junte a mim nestas emocionantes aventuras em computação cognitiva e inteligência artificial!
Isso conclui nossa lição sobre os fundamentos do aprendizado por reforço. Espero que tenham achado esta informação interessante, e desejo a todos um ótimo dia.
Aprendizado por Reforço: Amostragem de Thompson e o Problema do Bandido Multi-Armado - Parte 01
Aprendizado por Reforço: Amostragem de Thompson e o Problema do Bandido Multi-Armado - Parte 01
Eu sou o Dr. Soper, e é um prazer apresentar a você a primeira parte de nossa lição abrangente sobre aprendizado por reforço, com foco específico na amostragem de Thompson e no renomado problema do bandido multi-armado.
Antes de nos aprofundarmos nas complexidades do aprendizado por reforço no contexto da Amostragem de Thompson e do Problema do Bandido Multi-Armed, gostaria de enfatizar a importância de assistir aos vídeos anteriores desta série. Essas lições anteriores servem como base para os conceitos que exploraremos hoje, e recomendo fortemente que você se familiarize com elas, caso ainda não o tenha feito.
Para fornecer uma breve visão geral do que você pode esperar aprender nesta lição, deixe-me descrever os pontos principais:
A jornada à frente promete ser esclarecedora, à medida que descobrimos várias aplicações e implicações de problemas de bandidos multi-armados. Então, sem mais delongas, vamos começar nossa exploração!
Para entender o conceito de aprendizado por reforço no contexto do Problema do Bandido Multi-Armed, é essencial primeiro definir o que esse problema envolve.
O problema do bandido armado refere-se a qualquer cenário em que devemos determinar como alocar uma quantidade fixa de um recurso limitado entre um conjunto de opções concorrentes. O objetivo principal é maximizar nossas recompensas esperadas enquanto enfrentamos a incerteza.
Esse recurso limitado pode assumir várias formas, como tempo, dinheiro, turnos e assim por diante. Além disso, as recompensas que podemos receber de cada opção disponível não são totalmente conhecidas. No entanto, à medida que alocamos recursos para diferentes opções, gradualmente entendemos melhor as recompensas potenciais associadas a cada uma.
O nome "Problema do bandido multi-armado" se origina de uma analogia com jogos de azar. Imagine um jogador diante de uma fileira de máquinas caça-níqueis, tentando identificar a máquina que maximiza suas chances de ganhar. As máquinas caça-níqueis são jogos de azar comumente encontrados em cassinos, onde os jogadores depositam dinheiro e se revezam. Se a sorte favorecer o jogador, a máquina distribui uma recompensa monetária, que o jogador espera que supere seu investimento inicial.
Tradicionalmente, as máquinas caça-níqueis eram chamadas de "bandidos de um braço só" devido à alavanca mecânica (braço) usada para iniciar o jogo. Portanto, quando um jogador encontra várias máquinas caça-níqueis e deve decidir em qual delas jogar, ele apresenta um clássico problema de bandido multi-armado. Esse problema incorpora inerentemente o dilema exploração-exploração que é fundamental para o aprendizado por reforço.
O dilema exploração-exploração gira em torno de determinar quantas vezes o jogador deve jogar cada máquina. Se um jogador descobre uma máquina que parece oferecer recompensas frequentes, ele deve continuar jogando nessa máquina em particular (exploração) ou arriscar perdas potenciais tentando outras máquinas na esperança de encontrar uma opção ainda mais gratificante (exploração)?
Agora, você pode se perguntar por que o problema do bandido multi-armado tem tanta importância. Bem, a verdade é que os problemas do bandido multi-armado são onipresentes no mundo real, permeando tanto nossas vidas diárias quanto ambientes de negócios.
Considere as escolhas que você encontra em sua vida pessoal. Por exemplo, decidir se vai visitar seu restaurante favorito mais uma vez em uma noite de sexta-feira ou explorar um novo restaurante que você nunca experimentou antes. Da mesma forma, imagine ter várias séries de TV intrigantes disponíveis para streaming, mas tempo livre limitado para assisti-las. Como você determina em qual programa investir seu tempo?
Thompson Sampling é um algoritmo popular usado para abordar o dilema exploração-exploração no Problema do Bandido Multi-Armed. Ele fornece uma abordagem baseada em princípios para equilibrar a exploração e a exploração, aproveitando a inferência bayesiana.
A ideia central por trás da Thompson Sampling é manter uma crença ou distribuição de probabilidade sobre as verdadeiras probabilidades de recompensa subjacentes de cada opção (braço) no problema do bandido. Essa crença é atualizada com base nas recompensas observadas nas interações anteriores com os braços.
Thompson Sampling adota uma abordagem probabilística para a tomada de decisões. Em vez de selecionar estritamente o braço com a maior recompensa esperada (exploração) ou explorar aleatoriamente os braços, ele amostra um braço da distribuição de crenças de uma forma que equilibra a exploração e a exploração.
Vamos percorrer as etapas do algoritmo Thompson Sampling:
Inicialização: Comece inicializando a distribuição de crenças para cada braço. Essa distribuição representa a incerteza sobre a verdadeira probabilidade de recompensa de cada braço. Normalmente, uma distribuição Beta é usada como distribuição a priori, pois é conjugada à distribuição binomial comumente usada para modelar as recompensas em problemas de bandidos.
Amostragem: para cada rodada de interação, experimente uma probabilidade de recompensa da distribuição de crenças para cada braço. Esta etapa incorpora exploração considerando armas com maior incerteza em suas probabilidades de recompensa.
Seleção: Selecione o braço com a maior probabilidade de recompensa amostrada. Esta etapa incorpora a exploração ao favorecer armas que provavelmente terão recompensas esperadas mais altas com base na distribuição de crenças.
Atualização: Observe a recompensa do braço selecionado e atualize a distribuição de crença para esse braço com base na inferência bayesiana. Esta etapa atualiza a distribuição posterior usando a distribuição anterior e a recompensa observada.
Ao amostrar, selecionar e atualizar repetidamente, o Thompson Sampling adapta sua distribuição de crenças com base nas recompensas observadas, melhorando gradualmente a seleção de armas ao longo do tempo.
Thompson Sampling provou ser um algoritmo eficaz para resolver o dilema exploração-exploração em várias aplicações. Tem sido amplamente utilizado em publicidade online, ensaios clínicos, sistemas de recomendação e muitos outros domínios onde a tomada de decisão sequencial sob incerteza está envolvida.
Uma das principais vantagens do Thompson Sampling é sua simplicidade e facilidade de implementação. O algoritmo não requer cálculos complexos ou ajuste de hiperparâmetros, tornando-o uma escolha prática em muitos cenários do mundo real.
Em conclusão, Thompson Sampling oferece uma solução elegante para o Problema do Bandido Multi-Armed, equilibrando exploração e exploração por meio de inferência bayesiana. Sua capacidade de se adaptar às mudanças nas probabilidades de recompensa e sua ampla aplicabilidade o tornam uma ferramenta valiosa no aprendizado por reforço e na tomada de decisões.
Na próxima parte de nossa lição, aprofundaremos os fundamentos matemáticos da Thompson Sampling e exploraremos suas garantias de desempenho. Fique ligado para uma emocionante jornada pelas complexidades deste poderoso algoritmo!
Aprendizado por Reforço: Amostragem de Thompson e o Problema do Bandido Multi-Armado - Parte 02
Aprendizado por Reforço: Amostragem de Thompson e o Problema do Bandido Multi-Armado - Parte 02
Eu sou o Dr. Soper, e estou aqui para apresentar a segunda parte de nossa lição sobre aprendizado por reforço no contexto da amostragem de Thompson e do famoso problema do bandido multi-armado.
No vídeo anterior desta série, entendemos o Problema do bandido multi-armado e como a amostragem de Thompson pode ser utilizada para resolvê-lo.
Antes de prosseguirmos, recomendo enfaticamente que você assista ao vídeo anterior, caso ainda não o tenha feito, pois ele fornece conhecimentos essenciais que irão beneficiar muito sua compreensão desta lição.
Hoje, nosso foco será a implementação de um sistema de IA baseado em aprendizado por reforço que utiliza Thompson Sampling para resolver um problema real de bandido multi-armado. Para fazer isso, vamos mudar para o Python e começar! Para começar, vamos revisar brevemente o cenário com o qual trabalharemos. Imagine que você está em um cassino com $ 1.000 para jogar nas máquinas caça-níqueis. Existem seis máquinas caça-níqueis disponíveis e cada turno custa $ 1 para jogar. A taxa de conversão, que representa a probabilidade de ganhar em qualquer jogada, varia entre as máquinas e é desconhecida para você.
Seu objetivo é maximizar suas chances de ganhar identificando a máquina caça-níqueis com a maior taxa de conversão o mais rápido possível.
Em nossa implementação do Python, começaremos importando as bibliotecas necessárias. Felizmente, para este projeto, precisamos apenas importar numpy. Em seguida, definiremos o ambiente. Definir o ambiente é uma etapa crucial em qualquer projeto de aprendizado por reforço. Aqui, começaremos especificando o número total de voltas que jogaremos nas máquinas caça-níqueis. Como temos $ 1.000 e cada turno custa $ 1, teremos um total de 1.000 turnos.
Também precisamos definir o número total de máquinas caça-níqueis, que neste caso é seis. Além disso, criaremos matrizes para acompanhar nossas vitórias e derrotas para cada caça-níqueis. Essas matrizes servirão como parâmetros de forma para a distribuição beta, conforme discutido na lição anterior. Além disso, definiremos uma semente para o gerador de números aleatórios para garantir a reprodutibilidade de nossos resultados.
Em seguida, geraremos taxas de conversão aleatórias entre 1% e 15% para cada slot machine. Essas taxas de conversão representam a frequência com que um jogador ganharia se jogasse naquela máquina específica. Observe que, em um cenário do mundo real, o jogador não teria acesso a essas informações. Após gerar as taxas de conversão, iremos imprimi-las na tela para observar os valores armazenados na memória do computador.
Na etapa subsequente, criaremos o conjunto de dados primário. Este conjunto de dados será uma matriz com uma linha para cada turno e uma coluna para cada caça-níqueis. Nesse caso, nosso conjunto de dados terá 1.000 linhas e 6 colunas, representando as 1.000 voltas e 6 possíveis caça-níqueis. Cada entrada na matriz indicará o resultado de jogar uma determinada máquina caça-níqueis em um turno específico, com "1" indicando uma vitória e "0" indicando uma perda.
Para gerar o conjunto de dados, usaremos loops "for" aninhados. Depois de gerar o conjunto de dados, imprimiremos as primeiras 15 linhas para ter uma noção de sua estrutura.
A execução da célula de código exibirá uma matriz preenchida com uns e zeros, representando vitórias e derrotas, respectivamente. Cada linha corresponde a um turno e cada coluna corresponde a uma máquina caça-níqueis. Por exemplo, no primeiro turno, jogar em qualquer caça-níqueis resultaria em perda. O conjunto de dados nos permite entender os resultados se jogarmos em uma máquina caça-níqueis específica em um determinado turno.
Em seguida, exibiremos as médias para cada coluna no conjunto de dados. Essas médias representam as verdadeiras taxas de conversão que podemos esperar para cada caça-níqueis em nossa simulação. A execução da célula de código mostrará esses valores, que devem estar próximos das taxas de conversão teóricas definidas anteriormente, embora não sejam exatas devido ao gerador de números aleatórios e ao número limitado de voltas em nosso conjunto de dados.
Agora, é hora de simular jogar nas máquinas caça-níqueis 1.000 vezes, respeitando a restrição de jogar apenas uma máquina por turno.
Usando loops "for" aninhados, com o loop externo iterando em cada turno e o loop interno iterando em cada caça-níqueis, conduziremos a simulação. No início de cada turno, definiremos a variável "max_beta" como -1. Essa variável nos ajudará a acompanhar o maior valor beta observado para o turno atual.
Para cada máquina caça-níqueis, vamos extrair um valor aleatório da distribuição beta da máquina, onde a forma da distribuição é determinada pelo número de vitórias e perdas acumuladas ao jogar aquela máquina em particular. Vamos comparar o valor beta da máquina caça-níqueis atual com o maior valor beta observado até agora na rodada atual. Se for maior, atualizaremos a variável "index_of_machine_to_play" com o índice da máquina caça-níqueis atual.
Depois de examinar os valores beta de todas as seis máquinas caça-níqueis, a variável "index_of_machine_to_play" armazenará o índice da máquina com o valor beta mais alto para o turno atual. Em seguida, jogaremos a máquina caça-níqueis selecionada procurando o resultado em nosso conjunto de dados e registrando se foi uma vitória ou derrota incrementando o elemento correspondente na matriz "number_of_positive_rewards" ou "number_of_negative_rewards".
Este processo continuará até que tenhamos completado todas as 1.000 rodadas. Nosso sistema de IA aprenderá continuamente com o ambiente em cada rodada, utilizando seu conhecimento acumulado para decidir entre exploração e exploração. Depois que todas as 1.000 rodadas terminarem, calcularemos o número total de vezes que nosso agente de IA jogou cada caça-níqueis e imprimiremos os resultados na tela.
A execução da célula de código exibirá o número de vezes que cada caça-níqueis foi jogado. Como você pode ver, nosso sistema de IA baseado em aprendizado de reforço identificou com sucesso o caça-níqueis 4 como tendo a maior probabilidade de ganhar. Ele escolheu jogar aquela máquina em 695 das 1.000 voltas em uma tentativa de maximizar suas recompensas cumulativas.
Finalmente, é crucial comparar esses resultados com uma linha de base relevante. Nesse caso, a abordagem ingênua seria selecionar aleatoriamente uma máquina caça-níqueis para jogar em cada rodada. A última célula de código demonstra essa abordagem de amostragem aleatória calculando o número de vitórias se escolhêssemos aleatoriamente uma máquina caça-níqueis para jogar em cada turno.
A execução da célula de código revelará a comparação entre a abordagem Thompson Sampling e a abordagem de amostragem aleatória. Como você pode ver, a abordagem Thompson Sampling resultou em significativamente mais vitórias em comparação com a abordagem de amostragem ingênua e aleatória. Assim, nosso jogador seria sábio para utilizar Thompson Sampling!
Nesta lição, aplicamos o conhecimento adquirido até agora em nossa série para resolver um problema de decisão do mundo real. Especificamente, construímos com sucesso um sistema completo de inteligência artificial baseado em aprendizado por reforço em Python que usa Thompson Sampling para resolver um problema real de bandidos multi-armados.
Nesta fase de nossa série, espero que você esteja começando a entender a utilidade das ferramentas de IA no suporte à tomada de decisões. Você também pode imaginar aplicações inteligentes e inovadoras dessas tecnologias para resolver outros problemas do mundo real.
No próximo vídeo desta série, exploraremos uma versão mais sofisticada do aprendizado por reforço baseado em Thompson Sampling aplicado a uma campanha publicitária complexa. Convido você a se juntar a mim para esse vídeo também.
Isso conclui a segunda parte de nossa lição sobre aprendizado por reforço no contexto da amostragem de Thompson e do famoso problema do bandido multi-armado. Espero que você tenha achado esta lição interessante e até a próxima, tenha um ótimo dia!
Um sistema de IA baseado em aprendizado de reforço para maximizar lucros em Python
Um sistema de IA baseado em aprendizado de reforço para maximizar lucros em Python
Bom dia a todos! Aqui é o Dr. Soper falando. Hoje, vamos nos aprofundar em um exemplo abrangente em Python que demonstra como um sistema de IA baseado em aprendizado por reforço pode efetivamente maximizar os lucros corporativos em um cenário complexo envolvendo várias opções e milhões de clientes.
As técnicas apresentadas neste vídeo foram apresentadas e amplamente discutidas nas lições anteriores desta série. Se você ainda não teve a oportunidade de assistir aos vídeos anteriores, recomendo fortemente que o faça antes de prosseguir com este.
Antes de mergulharmos na codificação em Python, vamos discutir o problema de negócios que pretendemos resolver neste vídeo usando um sistema de IA baseado no aprendizado por reforço de amostragem de Thompson.
Imagine que você trabalha para uma empresa sem fio que possui 10 milhões de clientes. A empresa decidiu aumentar seus lucros lançando um programa de atualização de smartphones. Para motivar os clientes a atualizar seus smartphones, a equipe de marketing da empresa criou oito campanhas publicitárias distintas. Cada campanha oferece aos clientes recursos, promoções ou descontos específicos. No entanto, o lucro médio de cada campanha variará, pois os recursos, promoções e descontos associados incorrerão em custos variáveis para a empresa. Embora a empresa possa calcular o custo e o lucro por venda de cada campanha publicitária, ainda não se sabe qual será a eficácia de cada campanha. Certas campanhas podem ser altamente eficazes, enquanto outras podem não produzir resultados significativos.
Nosso objetivo é construir um sistema de IA que possa maximizar os lucros da empresa para seu programa de atualização de smartphones. É importante ressaltar que nosso objetivo não é simplesmente maximizar o número de clientes participantes do programa. Em vez disso, pretendemos otimizar os lucros, que dependem não só do número de clientes expostos a cada campanha publicitária, mas também da eficácia de cada campanha na geração de vendas e do lucro médio por venda. Com uma compreensão clara do problema de negócios, vamos mudar para Python e começar a implementação.
Antes de descrever o código deste notebook, quero informar que um link para este notebook está disponível na descrição do vídeo. Sinta-se à vontade para baixar uma cópia do notebook para experimentar ou adaptar às suas necessidades específicas. Como sempre, começamos importando as bibliotecas Python necessárias. Necessitaremos de duas bibliotecas para este projeto: NumPy, que utilizaremos para gerar valores aleatórios de várias distribuições de probabilidade, e locale, que empregaremos para formatar os valores monetários adequadamente. Como nosso objetivo é maximizar os lucros, trabalharemos extensivamente com valores monetários neste projeto. Definir nossa localidade atual para os Estados Unidos garante que o Python formate valores monetários em dólares americanos e use vírgulas para separar números grandes. Se você preferir uma formatação de moeda diferente, sinta-se à vontade para modificar a localidade de acordo.
A próxima linha de código define uma semente para o gerador de números aleatórios. Isso garante que você possa reproduzir os resultados exatos observados neste vídeo se optar por baixar e executar o notebook.
Nossa próxima tarefa envolve definir uma classe para armazenar informações sobre as diferentes campanhas publicitárias. Utilizaremos esta classe para criar objetos que representam cada campanha publicitária, que reterão os atributos ou características das respectivas campanhas. O uso de objetos de campanha dessa maneira nos permite segregar todos os detalhes relacionados à campanha do restante da lógica do programa, aprimorando significativamente nossa compreensão de como a IA aprende e toma decisões.
Como você pode observar, cada objeto de campanha é inicializado fornecendo um ID de campanha exclusivo. A função __init__ subseqüentemente atribui uma taxa de conversão aleatória entre 1% e 20% à campanha usando NumPy para extrair um valor aleatório de uma distribuição de probabilidade uniforme. A taxa de conversão significa a porcentagem de clientes que optarão por atualizar seus smartphones se forem expostos a uma campanha publicitária específica. Vale a pena notar que a empresa sem fio não tem conhecimento dessas informações. Também empregamos o NumPy para atribuir um lucro aleatório por venda bem-sucedida, variando de $ 100 a $ 200 para cada campanha. Embora atribuamos aleatoriamente esses valores de lucro, é igualmente possível usar valores específicos fornecidos pela empresa sem fio para cada campanha publicitária. Por fim, a classe inclui um método get_profit() que retorna o lucro por venda bem-sucedida da campanha.
Aqui está o código para a classe Campaign:
Agora que definimos a classe Campaign, podemos implementar o algoritmo de aprendizado por reforço baseado na amostragem de Thompson. Criaremos uma classe chamada ThompsonSampling que encapsulará o algoritmo.
A classe ThompsonSampling terá os seguintes atributos e métodos: num_campaigns: O número de campanhas publicitárias.
Os métodos da classe ThompsonSampling são os seguintes:
Aqui está o código para a classe ThompsonSampling:
Agora que implementamos a classe ThompsonSampling, podemos criar uma instância da classe e executar o algoritmo. Definiremos o número de campanhas como 8 e o número de tentativas como 1.000 para este exemplo. Depois de executar os testes, exibiremos o total de vendas e lucros de cada campanha.
Você pode modificar o código de acordo com seus requisitos específicos, como o número de campanhas e testes. Além disso, você pode estender a classe Campaign com mais atributos e métodos para capturar informações adicionais sobre cada campanha.Aqui está o código para executar o algoritmo de amostragem de Thompson:
Fundamentos do Q-Learning
Fundamentos do Q-Learning
Bom dia a todos! Eu sou o Dr. Soper e hoje estou animado para mergulhar nos fundamentos do Q-learning, uma técnica poderosa dentro do domínio da inteligência artificial. Antes de embarcarmos nessa jornada de aprendizado, recomendo assistir ao vídeo anterior desta série intitulado "Fundamentos do Aprendizado por Reforço" se você for novo no conceito.
Nesta lição, exploraremos os conceitos fundamentais do Q-learning, incluindo suas características, valores Q, diferenças temporais, a equação de Bellman e o processo geral de Q-learning. Ao final desta lição, você terá uma compreensão sólida desses conceitos e estará bem equipado para construir modelos de IA que dependem do Q-learning. Então, sem mais delongas, vamos começar!
Para começar, vamos discutir brevemente o que o Q-learning implica. Como mencionado anteriormente, o Q-learning é uma forma de aprendizado por reforço, onde um agente de IA interage com um ambiente composto por estados e recompensas. O objetivo do agente é construir uma política ótima diretamente interagindo com o ambiente, sem a necessidade de aprender um modelo matemático subjacente ou distribuição de probabilidade. O Q-learning abrange tentativa e erro, pois o agente tenta continuamente resolver o problema usando diferentes abordagens em vários episódios enquanto atualiza sua política com base no conhecimento adquirido.
Agora, vamos nos aprofundar nas características dos modelos de Q-learning. Como o Q-learning é um tipo de aprendizado por reforço, ele compartilha as características fundamentais de todos os modelos de aprendizado por reforço. Essas características incluem um sistema de entrada e saída, recompensas, ambiente, processos de decisão de Markov e modos de treinamento e inferência. Além dessas características, os modelos de Q-learning possuem dois atributos específicos. Em primeiro lugar, o número de estados possíveis nos modelos de Q-learning é finito, o que significa que o agente de IA sempre se encontrará em uma de um número fixo de situações possíveis. Em segundo lugar, o número de ações possíveis em modelos de Q-learning também é finito, exigindo que o agente de IA escolha entre um conjunto fixo de ações possíveis em cada estado.
Agora que entendemos as características, vamos explorar alguns problemas clássicos de Q-learning. Um desses problemas é o labirinto, onde cada local representa um estado e as ações do agente envolvem mover-se para cima, para a direita, para baixo ou para a esquerda. O objetivo é navegar pelo labirinto e chegar à saída o mais rápido possível. Outro exemplo clássico é o problema do cliff walking, em que o agente deve navegar por um ambiente semelhante a uma grade para chegar a um local específico sem cair do penhasco. Em ambos os cenários, o agente de IA aprende sobre o ambiente confiando e atualizando os valores Q.
Então, o que são valores-Q? Os valores Q representam a qualidade de uma ação específica (a) em um determinado estado (s). Eles indicam a soma esperada de recompensas futuras se essa ação for realizada a partir do estado atual. Em outras palavras, os valores-Q estimam a recompensa adicional que o agente pode acumular ao realizar uma determinada ação e proceder de maneira otimizada a partir daí. O agente de IA visa maximizar suas recompensas totais ou minimizar suas punições totais em cenários com recompensas negativas. Ao atualizar e refinar os valores-Q, o agente aprende por reforço positivo e negativo.
Os valores-Q são armazenados em uma tabela-Q, que possui linhas que representam os estados possíveis e colunas que representam as ações possíveis. A Q-table serve como a política do agente, orientando suas ações no ambiente. Uma tabela Q ótima contém valores que permitem ao agente selecionar a melhor ação em qualquer estado, levando à maior recompensa potencial.
As diferenças temporais (TD) desempenham um papel crucial no Q-learning. TD fornece um método para calcular quanto o valor Q para a ação anterior deve ser ajustado com base no que o agente aprendeu sobre os valores Q para as ações do estado atual. Esse ajuste ajuda o agente a tomar melhores decisões nos episódios subsequentes. O valor TD é calculado considerando a recompensa imediata recebida pela ação anterior, um fator de desconto (gama) que desconta recompensas futuras e o valor Q máximo do próximo estado.
O erro TD, geralmente denotado como δ, é calculado como a diferença entre o valor TD e o valor Q atual para o par estado-ação anterior. Representa a discrepância entre a previsão do agente e a recompensa real observada no ambiente. O erro TD é usado para atualizar o valor Q do par estado-ação anterior, refinando gradualmente os valores Q ao longo do tempo.
Agora, vamos apresentar a equação de Bellman, que está no centro do Q-learning. A equação de Bellman expressa a relação entre o valor Q de um par estado-ação e os valores Q de seus pares estado-ação vizinhos. É definido da seguinte forma:
Q(s, a) = R(s, a) + γ * max[Q(s', a')]
Nesta equação, Q(s, a) representa o valor Q do estado s e a ação a, R(s, a) denota a recompensa imediata obtida ao realizar a ação a no estado s, γ (gama) é o fator de desconto que determina a importância das recompensas futuras comparadas às recompensas imediatas, s' é o próximo estado alcançado após a ação a no estado s, e a' representa a melhor ação a ser tomada nos estados s'.
A equação de Bellman afirma essencialmente que o valor Q de um par estado-ação deve ser igual à recompensa imediata obtida mais o valor Q máximo descontado dos próximos pares estado-ação. Ao aplicar iterativamente a equação de Bellman e atualizar os valores Q com base nas recompensas observadas e nas estimativas futuras, o agente converge gradualmente para uma política ótima.
Agora, vamos passar para o processo geral de Q-learning. O Q-learning segue uma abordagem iterativa que consiste nas seguintes etapas:
Por meio desse processo iterativo, os valores Q são atualizados e gradualmente convergem para seus valores ótimos, levando a uma política aprimorada. A estratégia de exploração-exploração permite que o agente equilibre entre explorar novas ações para descobrir melhores estratégias e explorar o conhecimento aprendido para tomar decisões com base nas melhores ações atuais.
Vale ressaltar que o Q-learning é um algoritmo de aprendizado fora da política, o que significa que o agente pode aprender com as experiências geradas por uma política diferente. Essa propriedade permite um aprendizado mais eficiente e maior flexibilidade na exploração de diferentes estratégias.
Em resumo, o Q-learning é uma técnica poderosa dentro do domínio do aprendizado por reforço. Envolve o aprendizado de políticas ótimas por meio de tentativa e erro, sem a necessidade de um modelo matemático do ambiente. Usando Q-valores para estimar a soma esperada de recompensas futuras, atualizando-os por meio de diferenças temporais e da equação de Bellman, e seguindo um processo de aprendizado iterativo, o agente gradualmente melhora sua política e alcança melhor desempenho na tarefa dada.
Espero que esta lição tenha fornecido a você uma compreensão sólida dos fundamentos do Q-learning. Na próxima lição, vamos nos aprofundar nos detalhes da implementação e explorar exemplos práticos de Q-learning em ação. Obrigado pela atenção e aguardo você no próximo vídeo!
Q-Learning: um exemplo completo em Python
Q-Learning: um exemplo completo em Python
Eu sou o Dr. Soper e hoje estou animado para apresentar um passo a passo detalhado de um sistema de IA baseado em Python usando Q-learning. Esta lição se baseia nos conceitos discutidos no vídeo anterior, portanto, se você não estiver familiarizado com o Q-learning, recomendo assistir ao vídeo anterior antes de prosseguir com este.
Nesta lição, abordaremos um problema de negócios enfrentado por uma empresa de comércio eletrônico em crescimento. A empresa está construindo um novo armazém e deseja automatizar as operações de picking usando robôs de armazém. Os robôs de armazém são veículos terrestres autônomos projetados para lidar com várias tarefas de armazém, incluindo separação.
Picking refere-se ao processo de coleta de itens individuais de diferentes locais dentro do depósito para atender aos pedidos dos clientes. Depois que os itens são retirados das prateleiras, a empresa de comércio eletrônico deseja que os robôs os transportem para uma área de embalagem específica dentro do depósito para envio.
Para garantir a máxima eficiência e produtividade, os robôs precisam aprender os caminhos mais curtos entre a área de embalagem e todos os outros locais dentro do armazém onde podem viajar. Neste vídeo, nosso objetivo é usar o Q-learning para realizar essa tarefa.
Primeiro, vamos apresentar o ambiente para nosso cenário de robô de armazém. O armazém pode ser representado como um diagrama, onde cada quadrado preto representa um local de armazenamento de itens (prateleira ou caixa de armazenamento) e cada quadrado branco representa um corredor que os robôs podem usar para navegação. O quadrado verde indica a localização da área de embalagem do item.
No total, existem 121 locais no armazém e cada local representa um estado ou situação em que um robô pode se encontrar em um determinado ponto no tempo. Cada estado pode ser identificado por um índice de linha e coluna. Por exemplo, a área de embalagem do item está localizada na posição (0, 5). Os quadrados preto e verde são estados terminais, o que significa que se o agente de IA conduzir um robô para uma dessas áreas durante o treinamento, o episódio de treinamento será concluído. O quadrado verde representa o estado do objetivo, enquanto os quadrados pretos representam os estados de falha, pois colidir com o robô em uma área de armazenamento de itens é considerado uma falha.
A seguir, vamos discutir as ações disponíveis para o agente AI. O agente AI pode escolher uma das quatro direções: Cima, Direita, Baixo ou Esquerda. O objetivo do agente é aprender ações que impeçam o robô de colidir com áreas de armazenamento de itens.
Agora, vamos explorar a estrutura de recompensa para nosso cenário. Cada estado (localização) no armazém recebe um valor de recompensa. Para ajudar o agente de IA a aprender, recompensas negativas (punições) são usadas para todos os estados, exceto o estado objetivo. A área de embalagem (estado de objetivo) recebe um valor de recompensa de 100, enquanto todos os outros estados têm um valor de recompensa de -100. O uso de recompensas negativas encoraja o agente de IA a encontrar o caminho mais curto para o objetivo minimizando suas punições. Recompensas positivas para quadrados brancos não são usadas porque o objetivo do agente é maximizar as recompensas cumulativas, e usar recompensas positivas para quadrados brancos pode levar o agente a acumular recompensas sem rumo sem atingir a meta.
Agora que definimos o ambiente com seus estados, ações e recompensas, vamos mudar para Python e dar uma olhada mais de perto na implementação do código.
Começamos importando as bibliotecas Python necessárias. Para este projeto, precisamos apenas da biblioteca numpy, que será usada para criar arrays multidimensionais, gerar valores aleatórios e realizar tarefas numéricas.
O próximo passo é definir o ambiente, começando pelos estados. O armazém é representado como uma grade 11x11, resultando em 121 estados possíveis. Usamos um array numpy tridimensional para armazenar os valores Q para cada combinação de estado e ação. As duas primeiras dimensões representam as linhas e colunas dos estados, enquanto a terceira dimensão contém um elemento para cada ação possível que o agente de IA pode realizar.
Em seguida, definimos as quatro ações disponíveis para o agente: Cima, Direita, Baixo, Esquerda.
Vamos continuar com a implementação do código.
Aqui está o código que implementa o algoritmo Q-learning para nosso cenário de robô de armazém:
Para testar a política aprendida, podemos usar a tabela Q para selecionar ações com base nos valores Q mais altos para cada estado:
Fundamentos de Redes Neurais Artificiais e Q-Learning Profundo
Fundamentos de Redes Neurais Artificiais e Q-Learning Profundo
Eu sou o Dr. Soper e hoje tenho o prazer de discutir os fundamentos das redes neurais artificiais e Q-learning profundo com todos vocês.
Antes de nos aprofundarmos nas complexidades desses tópicos, recomendo assistir ao vídeo anterior desta série intitulado "Fundamentos do Q-Learning" se você não estiver familiarizado com o Q-learning.
Vamos começar resumindo brevemente o que você aprenderá nesta lição.
Ao final deste vídeo, você terá uma compreensão abrangente de:
Assim que entendermos esses conceitos, estaremos totalmente equipados para construir modelos de IA que dependem de redes neurais artificiais e Q-learning profundo.
Sem mais delongas, vamos começar!
Para entender as redes neurais artificiais e seu funcionamento interno, devemos primeiro compreender os neurônios artificiais e as funções de ativação.
Então, o que exatamente é um neurônio artificial?
Os neurônios artificiais servem como os blocos de construção básicos sobre os quais todas as redes neurais artificiais são construídas. Eles foram inicialmente propostos por Warren McCulloch e Walter Pitts em 1943 como um modelo matemático de neurônios biológicos, que formam a base dos cérebros de animais, incluindo o cérebro humano.
Inspirado por esses neurônios biológicos, surgiu o modelo de neurônio artificial.
Conforme representado no diagrama, o objetivo de um neurônio artificial é transformar um ou mais valores de entrada em um valor de saída. Cada valor de entrada é multiplicado por um peso, que ajusta a intensidade da entrada. Por exemplo, se o valor de entrada for 0,8 e o peso for 0,5, a multiplicação resultante resultará em 0,4. Nesse cenário, o peso diminuiu a força da entrada. Por outro lado, se o peso fosse maior que 1, a intensidade da entrada seria amplificada.
Uma vez calculados os valores de entrada ponderados, eles passam por uma função de ativação, que produz o valor de saída do neurônio artificial. Vale a pena notar que os pesos podem ser ajustados durante o treinamento para minimizar os erros - uma ideia que revisitaremos em breve.
Agora, vamos nos aprofundar nas funções de ativação.
Uma função de ativação é uma função matemática utilizada por um neurônio artificial para transformar seus valores de entrada ponderados em um valor de saída. Conforme mostrado na equação, uma função de ativação pega um único valor de entrada, obtido pela multiplicação de cada valor de entrada por seu peso associado e, em seguida, soma todos esses resultados. O valor somado é então passado pela função de ativação para obter o valor de saída do neurônio artificial.
É importante observar que várias funções de ativação podem ser usadas em um neurônio artificial, cada uma se comportando de maneira diferente ao transformar valores de entrada em valores de saída.
Vamos explorar quatro funções de ativação comuns:
Função de ativação de limiar: Esta função retorna 0 ou 1 como saída. Se o valor de entrada for maior ou igual a zero, retorna 1; caso contrário, retorna 0. Conseqüentemente, os valores de saída para neurônios artificiais que empregam uma função de ativação de limite sempre serão 0 ou 1.
Função de ativação sigmóide: A saída da função de ativação sigmóide varia entre 0 e 1. Valores de entrada positivos resultam em valores de saída próximos de 1,0 à medida que os valores de entrada aumentam, enquanto valores de entrada negativos produzem valores de saída mais próximos de 0,0 à medida que os valores de entrada diminuem. Portanto, a função de ativação sigmóide sempre produz uma saída entre 0 e 1.
Função de Ativação de Tangente Hiperbólica: A função de tangente hiperbólica se assemelha muito à função de ativação sigmóide, exceto que seu valor de saída sempre cai entre -1,0 e +1,0. Valores de entrada positivos geram valores de saída próximos de +1,0 conforme os valores de entrada aumentam, e valores de entrada negativos geram valores de saída próximos de -1,0 conforme os valores de entrada diminuem.
Estes são apenas alguns exemplos de funções de ativação usadas em redes neurais artificiais. A escolha da função de ativação depende do problema específico e do comportamento desejado da rede neural. Agora que cobrimos os neurônios artificiais e as funções de ativação, vamos entender como as redes neurais operam.
As redes neurais consistem em múltiplas camadas de neurônios artificiais interconectados, formando uma complexa estrutura de rede. As três camadas primárias em uma rede neural são a camada de entrada, as camadas ocultas e a camada de saída. A camada de entrada é responsável por receber os dados de entrada, como imagens, texto ou valores numéricos, e passá-los para as camadas subsequentes para processamento. O número de neurônios na camada de entrada corresponde ao número de recursos de entrada ou dimensões nos dados. As camadas ocultas, como o nome sugere, são camadas intermediárias entre as camadas de entrada e saída. Essas camadas executam a maior parte da computação em uma rede neural. Cada neurônio em uma camada oculta recebe entrada da camada anterior e calcula uma saída usando a função de ativação.
A camada de saída produz a saída final da rede neural. O número de neurônios na camada de saída depende da natureza do problema. Por exemplo, em um problema de classificação binária, normalmente haveria um neurônio na camada de saída para representar a probabilidade de pertencer a uma classe. Para possibilitar o aprendizado e melhorar o desempenho da rede neural, os pesos das conexões entre os neurônios são ajustados durante uma fase de treinamento. Esse ajuste é realizado usando um processo chamado retropropagação, combinado com um algoritmo de otimização, como descida de gradiente estocástico. Durante o treinamento, a rede neural é apresentada com um conjunto de dados de entrada junto com suas saídas de destino correspondentes. A rede calcula sua saída para cada entrada e a diferença entre a saída calculada e a saída de destino é medida usando uma função de perda.
O objetivo do treinamento é minimizar essa perda ajustando os pesos das conexões. O algoritmo de retropropagação calcula o gradiente da função de perda em relação aos pesos, permitindo que os pesos sejam atualizados na direção que reduz a perda. Esse processo iterativo continua até que a rede neural aprenda a produzir saídas precisas para as entradas fornecidas. Agora que temos uma compreensão sólida das redes neurais artificiais, vamos explorar os fundamentos do Q-learning profundo.
Deep Q-learning é uma técnica de aprendizado por reforço que utiliza redes neurais profundas como aproximadores de função para aprender ações ótimas em um processo de decisão Markov (MDP) ou um ambiente de aprendizado por reforço. No contexto do Q-learning profundo, a rede neural, muitas vezes chamada de rede Q, toma o estado do ambiente como entrada e produz um valor Q para cada ação possível. O valor Q representa a recompensa futura esperada ao realizar uma ação específica de um determinado estado. Durante o treinamento, a Q-network é atualizada usando o algoritmo Q-learning, que combina elementos de aprendizado por reforço e redes neurais. O algoritmo Q-learning usa uma combinação de exploração e exploração para melhorar gradualmente as estimativas da rede Q dos valores Q ideais.
As etapas básicas do algoritmo Q-learning profundo são as seguintes:
Ao atualizar iterativamente a rede Q usando o algoritmo Q-learning, a rede aprende gradualmente a estimar os valores Q ideais para cada par estado-ação. Uma vez treinada, a rede Q pode ser usada para selecionar a ação com o maior valor Q para um determinado estado, permitindo que um agente tome decisões informadas em um ambiente de aprendizado por reforço. O Deep Q-learning foi aplicado com sucesso a vários domínios, incluindo jogos, robótica e controle de veículos autônomos, entre outros. Ele mostrou um desempenho notável no aprendizado de tarefas complexas a partir de entradas sensoriais de alta dimensão. No entanto, é importante observar que o Q-learning profundo tem certas limitações, como o potencial de superestimação dos valores Q e a dificuldade de lidar com espaços de ação contínuos. Os pesquisadores continuam a explorar técnicas e algoritmos avançados para enfrentar esses desafios e melhorar os recursos do aprendizado por reforço profundo.
Deep Q-learning é uma técnica poderosa que combina aprendizado por reforço com redes neurais profundas para aprender ações ideais em um determinado ambiente. Ao alavancar a capacidade de redes neurais profundas para aproximar funções complexas, o Q-learning profundo demonstrou avanços significativos em vários campos da inteligência artificial.
Redes neurais convolucionais e Q-Learning Convolucional Profundo
Redes neurais convolucionais e Q-Learning Convolucional Profundo
Bom dia a todos! Aqui é o Dr. Soper, e hoje estarei discutindo redes neurais convolucionais (CNNs) e Q-learning convolucional profundo. Se você não estiver familiarizado com redes neurais artificiais ou Q-learning, recomendo assistir ao vídeo anterior desta série intitulado "Fundamentos de redes neurais artificiais e Q-learning profundo" antes de prosseguir com este.
Antes de nos aprofundarmos no tópico de redes neurais convolucionais e Q-learning convolucional profundo, vamos revisar brevemente o que você pode esperar aprender nesta lição. Ao final deste vídeo, você terá uma compreensão sólida do que são as redes neurais convolucionais e como elas funcionam. Discutiremos conceitos importantes, como mapas de recursos, convolução, agrupamento máximo, nivelamento e conexão com camadas totalmente conectadas para gerar previsões. Além disso, exploraremos como o Q-learning convolucional profundo opera.
Depois de cobrir esses conceitos fundamentais, poderemos construir redes neurais convolucionais capazes de realizar tarefas notáveis. Essas tarefas incluem reconhecimento de objetos em imagens e vídeos e até mesmo jogar videogames em um nível que ultrapassa as capacidades humanas.
Então vamos começar. Primeiro, vamos desenvolver uma compreensão intuitiva do que são as redes neurais convolucionais e por que são úteis. Em termos simples, uma rede neural convolucional (CNN) é um tipo de rede neural artificial projetada para dados com uma estrutura espacial. Os dados com estruturas espaciais incluem imagens, vídeos e até mesmo texto (embora as CNNs sejam usadas principalmente para tarefas de visão computacional). Para a finalidade deste vídeo, vamos nos concentrar na entrada baseada em imagem.
Dados com uma estrutura espacial, como imagens, contêm pixels organizados de uma maneira específica. A localização de cada pixel contém um significado, e é esse arranjo que nos permite identificar os objetos em uma imagem. Por exemplo, se reordenássemos aleatoriamente os pixels em uma imagem, ela se tornaria uma coleção de ruído sem sentido, em vez de um objeto reconhecível. Esse arranjo espacial é o que queremos dizer com "dados que possuem uma estrutura espacial".
As redes neurais convolucionais são projetadas intencionalmente para capturar essas relações espaciais entre os valores de entrada, como a localização de um pixel em uma imagem ou a posição de uma palavra em uma frase. Ao considerar essas relações espaciais, as CNNs podem efetivamente processar e analisar dados com estruturas espaciais.
Agora, vamos discutir como as CNNs funcionam em alto nível. Em termos gerais, uma CNN gera um conjunto de mapas de recursos para cada caso de entrada. Em outras palavras, ele cria dados para a camada convolucional. Em seguida, uma técnica chamada pooling é aplicada para simplificar cada mapa de recursos. Em seguida, os mapas de recursos agrupados são nivelados e os vetores resultantes são conectados a camadas totalmente conectadas. Essa conexão permite que as informações se propaguem pela rede, levando à geração de previsões.
Para aprofundar os detalhes, vamos começar com a primeira etapa: aplicar filtros à imagem de entrada. Os filtros, também conhecidos como detectores de recursos ou kernels, são projetados para detectar recursos específicos em uma imagem, como linhas, curvas ou formas. Ao aplicar esses filtros a uma imagem de entrada, geramos mapas de recursos. A coleção de mapas de recursos forma a camada convolucional.
Para ilustrar esse processo, vamos considerar uma imagem simples em preto e branco composta por pixels representados por uma matriz. Podemos então aplicar um filtro, como um filtro 3x3 projetado para detectar linhas verticais, à imagem. Ao deslizar o filtro pela imagem, podemos criar um mapa de recursos que indica o grau de sobreposição entre o filtro e as diferentes seções da imagem.
Podemos aplicar vários filtros a uma imagem para detectar vários recursos. Cada filtro gera seu próprio mapa de recursos, permitindo detectar linhas, curvas, formas e muito mais. Esses mapas de recursos formam coletivamente a camada convolucional.
Parabéns! Agora você entende o processo de convolução em redes neurais convolucionais. Em seguida, vamos discutir o pooling máximo.
O pooling máximo é uma técnica usada em CNNs para reduzir a amostra dos mapas de recursos obtidos da camada convolucional. Seu objetivo é reduzir as dimensões espaciais dos mapas de recursos, mantendo as informações mais importantes.
A ideia por trás do pooling máximo é dividir o mapa de recursos em regiões não sobrepostas, geralmente chamadas de janelas de pooling ou regiões de pooling. Para cada região, apenas o valor máximo dentro dessa região é retido, enquanto os outros valores são descartados. Esse valor máximo é então incluído no mapa de recursos agrupado.
Ao selecionar o valor máximo, o pooling máximo ajuda a preservar os recursos mais salientes dos dados de entrada. Ele também fornece um grau de invariância de translação, o que significa que, mesmo que a posição de um recurso mude ligeiramente, o valor máximo associado a ele provavelmente ainda será capturado.
Para ilustrar esse processo, vamos considerar uma operação de agrupamento máximo de 2x2 aplicada a um mapa de recursos. Dividimos o mapa de recursos em regiões 2x2 não sobrepostas e pegamos o valor máximo de cada região para formar o mapa de recursos agrupado. Isso reduz as dimensões espaciais do mapa de recursos por um fator de 2.
O pooling máximo pode ser executado várias vezes em uma CNN, levando a uma redução adicional nas dimensões espaciais. Esse downsampling ajuda a reduzir a complexidade computacional da rede, tornando-a mais eficiente.
Depois que a operação de agrupamento máximo for concluída, a próxima etapa é nivelar os mapas de recursos agrupados. O nivelamento envolve a conversão dos mapas de recursos multidimensionais em um vetor unidimensional. Essa transformação permite que os dados sejam conectados a camadas totalmente conectadas, que são as camadas padrão nas redes neurais tradicionais.
O vetor achatado serve como entrada para as camadas totalmente conectadas, onde a rede aprende a extrair representações de alto nível e fazer previsões com base nessas representações. As camadas totalmente conectadas são responsáveis por incorporar o contexto global e tomar decisões complexas com base nas características extraídas pelas camadas convolucionais.
Para resumir o fluxo de informações em uma CNN:
Esse processo de extração de recursos, redução da resolução e tomada de decisão permite que as CNNs capturem efetivamente as relações espaciais nos dados de entrada e façam previsões precisas.
Agora que temos uma boa compreensão das redes neurais convolucionais, vamos nos aprofundar no Q-learning convolucional profundo.
O Q-learning convolucional profundo combina o poder das CNNs com técnicas de aprendizado por reforço, especificamente o Q-learning, para resolver tarefas complexas. Q-learning é um tipo de algoritmo de aprendizado por reforço que permite que um agente aprenda ações ótimas em um ambiente, interagindo com ele e recebendo recompensas.
No contexto do Q-learning convolucional profundo, o agente é tipicamente um agente artificial, como um programa de computador, e o ambiente é uma tarefa baseada em visual, como jogar um videogame. O agente observa o estado atual do jogo (representado como imagens) e realiza ações com base nos valores Q associados a cada ação. Os valores Q representam as recompensas futuras esperadas para uma ação específica em um determinado estado.
Para aproximar os valores Q, uma rede neural convolucional profunda é usada. A CNN toma o estado atual (imagem) como entrada e gera um valor Q para cada ação possível. Os valores-Q são então usados para selecionar a ação com a maior recompensa futura esperada, de acordo com uma política.
O agente interage com o ambiente realizando ações, recebendo recompensas e atualizando os valores Q com base nas recompensas observadas e nos valores Q previstos. Este processo de interação com o ambiente e atualização dos valores Q é repetido iterativamente para melhorar a capacidade de tomada de decisão do agente.
A combinação de redes neurais convolucionais profundas e Q-learning permite que o agente aprenda padrões visuais complexos e tome decisões com base neles. Essa abordagem tem sido bem-sucedida em vários domínios, incluindo jogos de vídeo, direção autônoma e robótica.