O documento aborda arquiteturas de redes neurais, incluindo deep, convolutional e recurrent neural networks, detalhando seus mecanismos de treinamento e aplicações. Foca principalmente em redes neurais recorrentes (RNNS) e seu funcionamento, discutindo problemas como o vanishing gradient e soluções como LSTM e GRU, além de apresentar aplicações práticas como previsão de séries temporais e geração de dados através de GANs. Exemplos práticos e links para colab são fornecidos para ilustrar conceitos aplicados em tarefas variadas.

1. Redes Neurais - Parte 2
Bruno Catão

2. Relembrando - Arquiteturas de Redes Neurais
- DNN: Deep Neural Network
- CNN: Convolutional Neural Network
- RNN: Recurrent Neural Network

3. Redes Feedforward
- Treinamento: entrada x labels
- Backpropagation
- Usos:
- Aproximação de funções
- Classificação
- Generalização
- Dados instantâneos
- Sem memória

4. Redes Neurais Recorrentes
- Aplicações
- Previsão de séries temporais
- Trabalho com textos (interpretação e geração)
- Tradução
- Reconhecimento de voz
- Composição musical
- ...

5. Tipos de Redes Neurais Recorrentes

6. Representação Matemática de uma RNN
- Uma RNN pode ser representada pela função:
- ht é o estado oculto no tempo t
- xt é o valor das entradas no tempo t multiplicado pela matriz de pesos W
- ht-1 é o estado oculto no tempo t-1 multiplicado pela matriz de pesos U
- Dependências de Longo Prazo:
- um evento depende de um ou mais eventos que vieram antes no tempo
- Pense no estado oculto como a memória da rede:
- ele sofre influência de todos os estados e entradas anteriores

7. Funções de Ativação em RNNs
- Por que usar funções de ativação diferentes?
- RNNs trabalham com muitos dados (entrada + estado oculto)
- Esses valores devem ser agrupados e comprimidos em uma representação não linear
- A ideia é tornar os gradientes viáveis para a retropropagação
- Sigmoide
- retorna valores entre 0 e 1
- Tangente hiperbólica (tanh)
- retorna valores entre -1 e 1

8. Backpropagation Through Time (BPTT)
- Suponha que nós vamos gerar uma sequência de 3 letras:
- Podemos “desenrolar” (unfold) a RNN para visualizar melhor o processo
- st é o estado oculto no instante t
- st = f(Uxt + Wst-1)
- f normalmente é uma função não linear (sigmoide ou tanh)
- O primeiro estado oculto, normalmente, é iniciado com 0
- ot é a saída no instante t
- ot = g(Vst)
- g pode ser ReLU ou logsoftmax

9. Backpropagation Through Time (BPTT)
- Cálculo do erro total:
- Soma dos erros em cada etapa
- Objetivo:
- Calcular os gradientes em função de U, V e W
- A rede é “desenrolada”:
- Uma camada para etapa da entrada
- O backpropagation é aplicado da etapa final
para a inicial
- Assim, os gradientes e U, V e W são
calculados com base no tamanho da
entrada (acumulando os erros)

10. Aplicações de RNNs !!!!
- Previsão de sequências numéricas
- Previsão de sequências de caracteres

11. Primeiro Exemplo
No Collab:
https://colab.research.google.com/drive/1Y-5lzBNueyLonj0Xfu4EP_akw7K1tpvG?usp=sharing

12. RNNs Empilhadas
- São modelos com múltiplas RNNs em
sequência
- Maior capacidade de aprendizagem
- Cada camada nova:
- Cria representações de mais alto nível dos
dados da camada anterior
- Pode trabalhar com unidades de tempo
diferentes

13. RNNs Bidirecionais
- São duas RNNs treinadas simultaneamente
- Cada uma trabalhando em um sentido das sequências de entrada
- Desse modo, é possível gerar dados futuros ou passados

14. Vanishing Gratients em RNNs
- RNNs têm dificuldade em aprender dependências de longo alcance
- Problema para aplicações reais:
- Exemplo - Tradução: às vezes o significado de uma palavra depende de outras palavras
distantes na frase
- Problema descrito em 2013:
- PASCANU, R.; MIKOLOV, T.; BENGIO, Y. On the difficulty of training recurrent neural
networks.
- As derivadas das funções sigmoide e tanh tendem a zero em seus
extremos
- Gradientes zerados além de não contribuir com a aprendizagem,
influenciam gradientes adjacentes a zerar também
- Desse modo, sobretreinar a rede não a fará aprender mais

15. Vanishing Gratients em RNNs

16. LSTM

17. LSTM - Long Short Term Memory
- Modelo proposto em 1997, para resolver problemas das RNNs
- HOCHREITER, Sepp; SCHMIDHUBER, Jürgen. Long short-term memory.
- Mudanças propostas em 1999, 2000 e 2014
- 2015: Google usa LSTM para reconhecimento de voz
- 2017: Facebook usa LSTM em seu algoritmo de tradução
- Trabalha com intervalos variáveis
- O modelo LSTM define uma estrutura chamada de célula

18. LSTM x RNN

19. LSTM x RNN

20. LSTM - Long Short Term Memory - Estrutura
- Uma célula LSTM é formada por:
- 4 redes neurais e blocos de memória (células)
- Os portões (gates) manipulam a memória
- Forget gate: determina que informações não são mais úteis
- Input gate: determina que informações devem ser adicionadas à memória
- Output gate: saída de informações úteis
- A entrada da célula LSTM é:
- ht-1: saída do último estado oculto (tempo t - 1)
- xt: observação no tempo t
- O portão de modulação de entrada decide:
- Que parte da entrada deve ser esquecida,
- Que parte da entrada deve ser lembrada
- Como compor a saída

21. LSTM - Input Gate
- Estrutura:
- Formada por 2 camadas
- 1ª camada: filtro, selecionando que informações devem ser lembradas ou não (i1)
- 2ª camada: agrupa a entrada com o estado oculto por uma função tanh (i2)
- Como funciona esse filtro ?
- Os valores de entrada (estado oculto + entrada) são passados por uma função sigmoide
- Uma função sigmoide retorna um valor entre 0 e 1
- 0 ⇒ descartar a informação
- 1 ⇒ armazena a informação
- Treinamento:
- Ajusta os pesos dessa função sigmoide de modo que a rede aprenda apenas informações
relevantes
- A informação guardada é: i1 x i2

22. LSTM - Forget Gate
- Função:
- Decide que informação deve ficar ou ser descartada na memória de longo prazo
- Estrutura:
- É calculado um forget vector
- O forget vector é a multiplicação da entrada pelo estado oculto passando por uma função
sigmoide
- Como funciona esse filtro ?
- 0 ⇒ descartar a informação
- 1 ⇒ armazena a informação
- As saídas do input gate e do forget gate são somadas
- Esse resultado vai compor a memória de longo prazo
- E vai ser passado para o próximo portão: output gate

23. LSTM - Output Gate
- Estado final do processamento de uma célula LSTM
- Combina:
- Entrada
- Estado oculto anterior
- Memória de longo prazo calculada pelos portões anteriores
- Processo:
- O1 = sigmoide(entrada, estado oculto anterior)
- O2 = tanh(memória de longo prazo)
- Novo estado oculto = O1 x O2
- Saídas:
- O valor de saída da rede
- Memória de longo prazo
- Novo estado oculto

24. LSTM - Exemplo 1
- Primeiros passos
- Colab:
- https://colab.research.google.com/drive/10qXIcLDcBEKAusafdLRtjPPKsm3Texxe?usp=sharing

25. LTSM - Exemplo 2
- Previsão de séries temporais
- Rede Stateless
- Previsão mensal de vendas de passagens aéreas
- Colab:
- https://colab.research.google.com/drive/1ncHgHJF0oGGzVe18oObu2SuCFNUWxtJK?usp=sharing

26. LSTM - Stateless x Statefull
- Redes Stateless:
- o estado oculto é resetado a cada passo de treinamento
- o conhecimento fica armazenado apenas nos pesos da rede
- a rede é mais estável a grandes variações nos dados de entrada
- Redes Statefull:
- o estado oculto é atualizado em cada passo de treinamento
- o conhecimento fica armazenado nos pesos da rede e no estado oculto
- a rede possui mais capacidade de aprendizado

27. LTSM - Exemplo 3
- Previsão de séries temporais
- Rede Statefull
- Previsão mensal de vendas de passagens aéreas
- Colab:
- https://colab.research.google.com/drive/12SQWC0CCC8BTEmgrNYwQLV8wKRo-qrXM?usp=sharing

28. Hora de Vocês Praticarem
- A partir do Colab, crie um sistema de previsão do valor de ações na bolsa
de valores

29. Algumas técnicas avançadas

30. Word Embedding
- Hot Encoding: técnica para converter dados de um domínio qualquer
para tensores numéricos
- Se os dados não forem correlatos, a técnica mais utilizada é:
- contar quantos dados distintos existem ⇒ N
- criar tensores com N dimensões
- cada dado será representado por um tensor no formato [0, 0 … 1 … 0, 0]
- Mas e se os dados tiverem alguma correlação?
- Exemplo: palavras em uma frase
- Podemos utilizar uma técnica chamada Embedding
- Representar os dados distintos em tensores
- Todos os tensores devem ser o mesmo módulo
- A distância entre tensores de dados correlatos deve ser menor

31. Word Embedding
- E como faz isso ?
- Devemos contar quantas palavras distintas existem
- Em seguida, calcular a quantidade de ocorrência de cada palavra
- Depois, ordenamos as palavras pela frequência de ocorrência
- Enfim, usamos a classe:
- nn.Embedding(qtd_palavras_únicas, dimensao_tensor_saída)

32. Dropout
- Reduz a probabilidade de overfitting
- Como funciona?
- Dropout é um filtro na entrada da rede neural
- Ele zera alguns valores aleatoriamente
- Qual a ideia?
- Introduzir pequenas variações nas entradas, durante o treinamento
- Reduz a tendência da rede neural de “decorar” os dados de entrada
“a inserção aleatória de zeros no vetor de entrada de
uma rede linear (feedforward) reduz a coadaptação
dos detectores de características”

33. Exploding Gradients
- Uma célula LSTM é formada por 4 redes neurais e 2 estados ocultos
- Todas essas matrizes são combinadas a cada passo de treinamento
- Portanto, com grandes conjuntos de treinamento, há uma tendência de
se chegar a números muito grandes (ou muito pequenos) nos gradientes
- Por exemplo: durante o treinamento, observa-se NaN ou Infinity nas saídas
- Solução: Gradient Clipping
- Estabelece-se valores máximos e mínimos para o gradiente
- Em cada passo, o gradiente é ajustado para ficar dentro desses limites
nn.utils.clip_grad_norm_(model.parameters(), clip)

34. LSTM - Análise de Sentimentos em Comentários
https://colab.research.google.com/drive/1Z5ziNqZNcWTzgQcsm_5g5INXjhP1Y8wH?usp=sharing

35. Ideia para a atividade prática
- A partir desse último Colab, você pode classificar textos como narrativo,
dissertativo, descritivo, expositivo e injuntivo
- A mesma ideia pode ser utilizada para classificar emails como spams,
livros pelo estilo (drama, comédia, ficção…), mensagens como conteúdo
ofensivo, fake news...

36. GRU

37. GRU - Gated Recurrent Unit
- Introduzidas em 2014 por Cho, et al.
- É uma modificação das LSTMs
- Características:
- Retiraram o estado da célula
- Usa apenas o estado oculto
- Possui dois portôes: reset gate e
update gate
- Por ser mais simples, costumam treinar
mais rapidamente que as LSTM,
apresentando resultados similares

38. GRU - Arquitetura

39. GRU - Reset Gate
- Calculado a partir do estado oculto anterior e da entrada
- A entrada é multiplicada pela matriz de pesos correspondentes Winput
- O estado oculto anterior é multiplicado por sua matriz de pesos Whidden
- Esses dois valores são somados e passados por uma função sigmoide
- A saída do reset gate determina a importância da informação
- O valor do Reset Gate é então somado com os valores de entrada e estado
oculto (multiplicados pelos respectivos pesos)
- Finalmente, esse valor é comprimido por uma função tanh → vetor r

40. GRU - Update Gate
- Calculado, também, a partir do estado oculto anterior e da entrada
- O vetor u é calculado multiplicando o update gate pelo estado oculto

41. GRU - Combinando as Saídas
- Multiplicamos o inverso do update gate pelo vetor r:
- A ideia é determinar que porção da entrada deve ser armazenada no estado oculto
- Esse valor será somado com o vetor u, compondo o novo estado oculto
- Esse estado oculto também é usado como a saída da rede

42. GRU - Exemplo 1
- Conhecendo os tamanhos das entradas e saídas
- Colab:
https://colab.research.google.com/drive/1xYEniO4dX4e8iy9ISzo4mCcfckt0klX5?usp=sharing

43. GRU - Exemplo 2
- Prevendo vendas de passagens aéreas nos próximos 12 meses
- Colab:
https://colab.research.google.com/drive/15GL8rgAcjamhaXKo6vQmRknn35Jj6sst?usp=sharing
- GitHub: https://github.com/brunogamacatao/gru_acoes

44. Hora de Vocês Praticarem
- Modifique o Colab que você fez para as LSTM para utilizar GRU e compare
a velocidade de treinamento e acurácia, entre os dois modelos

45. GAN

46. Redes Neurais Adversárias Generativas - GAN
- Modelo introduzido por Ian Goodfellow, et al. em 2014
- Duas redes neurais, uma contra a outra (adversárias)
- GANs podem aprender a imitar qualquer distribuição de dados:
- imagens, músicas, sons, texto …
- Exemplos:
- Google Dream
- Pinturas de Robbie Barrat
- Deep Fake

47. Algoritmos Generativos x Discriminativos
- Algoritmos discriminativos:
- Classificam dados
- Trabalha com probabilidades de elementos serem de classes
- Mapeiam recursos para rótulos
- Algoritmos generativos:
- Geram novos dados
- Produzem recursos que podem ser mapeados para rótulos

48. Funcionamento das GANs
- O gerador produz recursos a partir de valores aleatórios
- O discriminador recebe recursos verdadeiros e falsos e retorna uma
probabilidade (entre 0 e 1) do recurso ser verdadeiro

49. Aplicações das GANs
- Deep Fake:
- Fake Obama: https://www.youtube.com/watch?v=AmUC4m6w1wo
- Arte:
- Produção de obras de arte (pinturas, música, etc)
- Geração de fotografias / personagens: https://www.thispersondoesnotexist.com/
- Upscaling:
- Filmes e Jogos antigos (ERSGAN)
- Fotografias de baixa resolução

50. Aplicações das GANs (arte)

51. Aplicações das GANs
- StyleGAN - geração de rostos
- Aplicação - site: https://www.thispersondoesnotexist.com/

52. Aplicação das GANs - Upscaling de Filmes Antigos
Louis Lumière, 1896

53. Aplicação das GANs - Upscaling de Filmes Antigos
Chaves em 120fps e 4K !

54. GAN - Treinamento
- Temos que ter em mente que as duas redes são adversárias
- Como assim?
- A rede generativa tenta enganar a discriminativa
- A rede discriminativa tenta não ser enganada
- Em cada passo de treinamento há o ajuste das duas redes
- Didaticamente, vamos dividir cada passo de treinamento em 2 etapas:
- Treinamento da rede generativa (na direção de enganar a discriminativa)
- Treinamento da rede discriminativa (na direção de diferenciar dados reais de
dados gerados)

55. GAN - Treinamento da Rede Generativa
- Gera um valor aleatório de entrada (random noise):
- Esse valor é passado à rede generativa, produzindo uma saída:
- dado gerado
- O dado gerado será apresentado à rede discriminativa:
- calcula o erro: compara o dado gerado com um label real (verdadeiro)
- Calcula-se os gradientes a partir desse erro:
- se a rede discriminativa achou que o dado gerado era real → gradiente pequeno
- se a rede discriminativa achou que o dado gerado era falso → gradiente grande
- Lembre-se: gradientes grandes → ajustes maiores nos pesos
- Os pesos da rede generativa são ajustados:
- utiliza-se apenas o otimizador associado à rede generativa

56. GAN - Treinamento da Rede Discriminativa
- O treinamento da rede discriminativa é feito em duas direções:
- A rede tem que identificar como verdadeiros os dados reais
- A rede tem que identificar como falsos os dados gerados
- Capacidade de identificar valores reais como verdadeiros:
- É passado um valor real
- A saída é confrontada com um label um (valor verdadeiro) e o erro é calculado
- Capacidade de identificar valores gerados como falsos:
- É passado a saída da rede generativa
- A saída é confrontada com um label zero (valor falso) o erro é calculado
- O erro da rede discriminativa é a média dos erros anteriores:
- (erro em identificar valores reais + erro em identificar valores gerados) / 2
- O gradiente é calculado e os pesos são ajustados

57. GAN - Exemplo 1
- Geração de números pares
- Eu sei, eu sei, parece um exemplo besta ...
- Mas, o mais importante é entender o processo de treinamento
- Colab:
https://colab.research.google.com/drive/13dkWF_DP18X_qdFVGH6-HXTdekiClpK2?usp=sharing

58. GAN - Exemplo 2
- Geração de emojis
- Entradas:

59. GAN - Exemplo 2
- Pré-Processamento:
- Redimensiona as imagens para 32 x 32
- Transforma em tons de cinza, com apenas 1 canal
- Converte para tensores
- Rede discriminativa:
- A mesma rede convolutiva utilizada para identificar os caracteres manuscritos
- Saída 0 ou 1 (falso ou verdadeiro)
- Rede generativa:
- Entrada de tamanho 1 x 32 x 32
- Saída de tamanho 1 x 32 x 32
- Foram feitos vários experimentos com camadas ocultas

60. GAN - Exemplo 2
- Resultados:
Epoch 1
Epoch 128
Epoch 128
Ativação: sigmoide
1 camada
normalização
Ativação: sigmoide
3 camadas
sem normalização

61. GAN - Exemplo 2
Repositório:
https://github.com/brunogamacatao/gera_emojis

62. GAN - Exemplo 3
- Vamos fazer uma rede que gera números manuscritos
- Para treinar a rede, vamos utilizar o MNIST Dataset:
- Produzido pelo National Institute of Standards and Technology
- 60.000 imagens de treinamento - 10.000 imagens de teste
- Imagens de 28x28 pixels

63. GAN - Exemplo 3 - Resultados
Epoch 1
Epoch 45

64. GAN - Exemplo 3
Repositório:
https://github.com/brunogamacatao/gera_digitos

65. Hora de Vocês Praticarem
- Modifiquem um dos exemplos anteriores para realizar a geração de uma
série numérica, imagens, textos ...
- Sugestão para atividade prática: geração de logomarcas, nomes de
personagens/empresas...

66. Autoencoders

67. Autoencoders
- Conceito introduzido por Rumelhart et al., 1986
- Para resolver o backpropagation não assistido
- Técnica de aprendizado não supervisionado
- A ideia é aprender alguma representação da entrada
- A rede é formada por um Encoder e um Decoder
- Como é feito isso:
- Os dados de entrada são passados por um “gargalo”
- Encoder: Compressão → Decoder: Descompressão

68. Autoencoders

69. Autoencoders
- Funcionamento:
- A rede comprime os dados de entrada
- A rede é treinada para reproduzir os mesmos dados da entrada
- Qual a ideia?
- Se os dados forem totalmente independentes não será possível reconstruí-los a partir de
uma representação compactada
- Porém, se houver alguma relação possível de ser aprendida, a reconstrução é possível
- Aplicações
- Tratamento de imagens (compressão, remoção de ruído, reconstrução)
- Simplificar dados antes de passar para uma outra rede
- Tradução de textos
- Simulação de populações

70. Tipos de Autoencoders
- Padrão: 3 camadas (entrada, oculta e saída)
- A camada oculta é a representação do recurso
- Multicamada: mais camadas ocultas
- Idealmente é simétrica e a camada mais interna guarda a representação
- Convolutiva:
- Usamos camadas convolutivas para comprimir e gerar a representação
- Regularizado (tipos diferentes de restrição)
- Denoising: a entrada é combinada com um ruído, o label é a entrada original
- Variational Autoencoders (VAE)
- é o nosso próximo tópico

71. Autoencoders - Exemplo 1
- Vamos implementar um autoencoder multicamadas
- Vamos utilizar (mais uma vez) o dataset MNIST
- A ideia aqui será aprender as representações para cada dígito manuscrito
- Colab: https://colab.research.google.com/drive/17aa_w3CalNvIaAdCz6qLnBNBD426NsO-?usp=sharing
Epoch 1 Epoch 100

72. Ideia para atividade prática
- Denoising: você pode treinar um autoencoder apresentando como
entrada uma imagem com ruído (soma o tensor da imagem com um
tensor com dados aleatórios); utiliza como label a imagem sem ruído
- A ideia é que a rede aprenda a remover o ruído das imagens

73. Aprendizagem por
Reforço

74. Aprendizagem por Reforço
- Tipos de aprendizagem:
- Supervisionada
- Não supervisionada
- Porém, existe um outro tipo:
- Aprendizagem por Reforço ou Reinforcement Learning
- Como funciona?
- Um problema é apresentado
- Para cada decisão tomada é oferecida uma recompensa ou penalidade

75. Aprendizagem por Reforço
Aplicações
- Gerenciamento em clusters de computadores
- Controle de semáforos
- Robótica
- Configuração dinâmica de containers
- Recomendações
- Jogos

76. Aprendizagem por Reforço
Principais Componentes
- Agente: executa ações
- Ação (A): como um agente pode interagir com o ambiente
- Fator de desconto (γ): multiplicado a recompensas e penalidades
- Ambiente: domínio de ação do agente
- Estado (S): os valores de todas as variáveis e sensores em um instante
- Recompensa (R): feedback que representa sucesso ou falha
- Política (π): a estratégia que o agente emprega para determinar a
próxima ação baseada no estado atual

77. Aprendizagem por Reforço - Q Learning
- Q: Qualidade
- Aprendizagem off-policy
- Não há uma política definida a priori
- A política é otimizada e modificada por um processo de treinamento
- Valor: função que associa um estado a uma ação f(estado, ação)
- valor(estado)t = valor(estado)t-1 + (lr x γ x R - valor(estado)t-1)
- Equação de Bellman:
- Escolha das próximas ações (combinação de duas estratégias):
- Exploit: escolher, dentre os estados salvos, a ação de maior valor
- Explore: ações escolhidas aleatoriamente

78. Exemplo: Jogo da Velha
- O estado do jogo (tabuleiro) é um array de 3 x 3, iniciado com zeros
- Jogador 1 → 1; Jogador 2 → -1
- Durante cada passo de treinamento:
- jogadas possíveis = casas vazias do tabuleiro (lugares com zero)
- calcula a próxima jogada
- se o jogo terminou atribui as recompensas
- Qual o impacto das recompensas?
- Cada jogador armazena uma lista com todos os estados daquela partida
- O valor desses estados é calculado de forma decrescente (do último para o
primeiro) a partir do valor da recompensa
- Como a próxima jogada é escolhida:
- simula as próximas possíveis jogadas e seleciona a de maior valor

79. Exemplo: Jogo da Velha
- Cálculo do valor do estados (Equação de Bellman)
- R = recompensa, lr = taxa de aprendizagem, γ = fator de desconto
- para cada estado (do último para o primeiro):
- R = valor(estado) + (lr x γ x R - valor(estado))
- valor(estado) = R
- Qual a ideia?
- Em uma sequência de estados que leva a uma vitória, o valor de cada estado
vai ficando cada vez maior (está se aproximando da vitória)
- O impacto da recompensa é determinado por γ (fator de desconto)
- Um mesmo estado que aparece em vitórias subsequentes vai sendo
reforçado (regulado pela taxa de aprendizagem)
- Sequências menores valem mais

80. Exemplo: Jogo da Velha
- Exemplo de uma sequência de estados x valores:
[ 1. 0. 0. -1. 1. -1. 1. -1. 1.] - val: 0.180
[ 0. 0. 0. 0. 1. -1. 1. -1. 1.] - val: 0.032
[ 0. 0. 0. 0. 0. 0. 1. -1. 1.] - val: 0.005
[ 0. 0. 0. 0. 0. 0. 0. 0. 1.] - val: 0.001
X O X X O X
O
X O X
X O
X O X
O X O
X O X
X
O X X
X O X

81. Exemplo - Jogo da Velha
Repositório:
https://github.com/brunogamacatao/jogo_da_velha

82. Ideia de Atividade Prática
- Implemente um algoritmo de aprendizagem por reforço que aprenda a
jogar blackjack (versão simplificada)
- Ações: pedir mais uma carta ou parar
- Resultados:
- você perde se o valor de suas cartas passarem de 21
- você ganha se o valor de suas cartas for superior ao valor das cartas da banca

83. Cadê as redes neurais ?!

84. Deep Q-Learning
- Qual o problema do Q-Learning?
- Explosão da matriz de estados
- Imagina se você tem um ambiente muito grande
- Qual a ideia?
- Um estado só possui relação com os estados próximos
- Podemos tentar aprender essas relações por meio de uma rede neural
- Vamos usar uma rede neural profunda para obter valores de ações para um
determinado estado

85. Deep Q-Learning - Exemplo
- Gym OpenAI: https://gym.openai.com/
- Ambiente para teste de algoritmos de aprendizagem por reforço
- Possui vários ambientes:

86. Deep Q-Learning - Exemplo
Como usar o Gym:

87. Deep Q-Learning - Exemplo
Equilibrar uma haste sobre uma plataforma
Ambiente: CartPole-v0
Repositório:
https://github.com/brunogamacatao/cartpole

88. Ideia de Atividade Prática
- Modifique o código do blackjack ou jogo da velha para utilizar Deep Q-
Learning
- Implemente a estratégia de aprendizagem para outro cenário do Gym

89. Considerações finais

90. Torchaudio
- Biblioteca apropriada para trabalhar com arquivos de áudio
- Permite representar arquivos de áudio como tensores
- Suporte a processamento por GPU
- Possui várias funções de representação gráfica
- Importando o torchaudio:
import torch
import torchaudio
import matplotlib.pyplot as plt

91. Torchaudio
- Abrindo um arquivo:
filename = "arquivo.wav"
waveform, sample_rate = torchaudio.load(filename)
print("Shape of waveform: {}".format(waveform.size()))
print("Sample rate of waveform: {}".format(sample_rate))
plt.figure()
plt.plot(waveform.t().numpy())

92. Torchaudio
Base de Dados: https://urbansounddataset.weebly.com
Classificador
Colab:
https://colab.research.google.com/drive/1icD-wPsVJDZaU3DoIpzIPJ8QycxHg6Sq?usp=sharing

93. Exemplo Avançado:
- Reconhecimento de voz
- Mistura CNN com GRU
- https://www.assemblyai.com/blog/end-to-end-speech-recognition-pytorch

94. Outros Tópicos Interessantes
- Neural Inpainting

95. Dúvidas?