chore(i18n): sync translations with latest source changes (chunk 4/8, 8 changes)

translations/pt-BR/lessons/4-ComputerVision/08-TransferLearning/lab/README.md

@@ -0,0 +1,30 @@
+# Classificação de Oxford Pets usando Transfer Learning
+
+Trabalho prático do [Currículo AI for Beginners](https://github.com/microsoft/ai-for-beginners).
+
+## Tarefa
+
+Imagine que você precisa desenvolver um aplicativo para uma creche de animais para catalogar todos os pets. Uma das grandes funcionalidades de tal aplicativo seria identificar automaticamente a raça a partir de uma fotografia. Neste exercício, usaremos transfer learning para classificar imagens reais de animais de estimação do conjunto de dados [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/).
+
+## O Conjunto de Dados
+
+Usaremos o conjunto de dados original [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/), que contém 35 raças diferentes de cães e gatos.
+
+Para baixar o conjunto de dados, use este trecho de código:
+
+```python
+!wget https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz
+!tar xfz images.tar.gz
+!rm images.tar.gz
+```
+
+## Iniciando o Notebook
+
+Comece o exercício abrindo [OxfordPets.ipynb](../../../../../../lessons/4-ComputerVision/08-TransferLearning/lab/OxfordPets.ipynb)
+
+## Conclusão
+
+Transfer learning e redes pré-treinadas nos permitem resolver problemas reais de classificação de imagens de forma relativamente simples. No entanto, redes pré-treinadas funcionam bem em imagens de tipos semelhantes, e se começarmos a classificar imagens muito diferentes (por exemplo, imagens médicas), é provável que obtenhamos resultados muito piores.
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/lessons/4-ComputerVision/09-Autoencoders/README.md

@@ -0,0 +1,100 @@
+# Autoencoders
+
+Ao treinar CNNs, um dos problemas é que precisamos de muitos dados rotulados. No caso de classificação de imagens, precisamos separar as imagens em diferentes classes, o que exige esforço manual.
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/17)
+
+No entanto, podemos querer usar dados brutos (não rotulados) para treinar extratores de características de CNN, o que é chamado de **aprendizado auto-supervisionado**. Em vez de rótulos, usaremos as imagens de treinamento como entrada e saída da rede. A ideia principal do **autoencoder** é que teremos uma **rede codificadora** que converte a imagem de entrada em algum **espaço latente** (normalmente é apenas um vetor de tamanho menor), e então uma **rede decodificadora**, cujo objetivo será reconstruir a imagem original.
+
+> ✅ Um [autoencoder](https://wikipedia.org/wiki/Autoencoder) é "um tipo de rede neural artificial usada para aprender codificações eficientes de dados não rotulados."
+
+Como estamos treinando um autoencoder para capturar o máximo de informações da imagem original possível para uma reconstrução precisa, a rede tenta encontrar a melhor **representação** das imagens de entrada para capturar seu significado.
+
+![Diagrama de AutoEncoder](../../../../../translated_images/pt-BR/autoencoder_schema.5e6fc9ad98a5eb61.webp)
+
+> Imagem do [blog do Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
+
+## Cenários para usar Autoencoders
+
+Embora reconstruir imagens originais não pareça útil por si só, há alguns cenários em que os autoencoders são especialmente úteis:
+
+* **Redução da dimensão de imagens para visualização** ou **treinamento de representações de imagens**. Normalmente, autoencoders oferecem melhores resultados do que PCA, porque levam em conta a natureza espacial das imagens e características hierárquicas.
+* **Remoção de ruído**, ou seja, eliminar ruídos da imagem. Como o ruído carrega muitas informações inúteis, o autoencoder não consegue encaixar tudo em um espaço latente relativamente pequeno e, assim, captura apenas a parte importante da imagem. Ao treinar removedores de ruído, começamos com imagens originais e usamos imagens com ruído artificialmente adicionado como entrada para o autoencoder.
+* **Super-resolução**, aumentando a resolução da imagem. Começamos com imagens de alta resolução e usamos a imagem com resolução mais baixa como entrada do autoencoder.
+* **Modelos generativos**. Depois de treinar o autoencoder, a parte decodificadora pode ser usada para criar novos objetos a partir de vetores latentes aleatórios.
+
+## Autoencoders Variacionais (VAE)
+
+Autoencoders tradicionais reduzem a dimensão dos dados de entrada de alguma forma, identificando as características importantes das imagens de entrada. No entanto, os vetores latentes frequentemente não fazem muito sentido. Em outras palavras, usando o conjunto de dados MNIST como exemplo, identificar quais dígitos correspondem a diferentes vetores latentes não é uma tarefa fácil, porque vetores latentes próximos não necessariamente correspondem aos mesmos dígitos.
+
+Por outro lado, para treinar modelos *generativos*, é melhor ter algum entendimento do espaço latente. Essa ideia nos leva ao **autoencoder variacional** (VAE).
+
+O VAE é um autoencoder que aprende a prever a *distribuição estatística* dos parâmetros latentes, chamada de **distribuição latente**. Por exemplo, podemos querer que os vetores latentes sejam distribuídos normalmente com alguma média z<sub>mean</sub> e desvio padrão z<sub>sigma</sub> (tanto a média quanto o desvio padrão são vetores de alguma dimensionalidade d). O codificador no VAE aprende a prever esses parâmetros, e então o decodificador usa um vetor aleatório dessa distribuição para reconstruir o objeto.
+
+Resumindo:
+
+ * A partir do vetor de entrada, prevemos `z_mean` e `z_log_sigma` (em vez de prever o desvio padrão diretamente, prevemos seu logaritmo)
+ * Amostramos um vetor `sample` da distribuição N(z<sub>mean</sub>,exp(z<sub>log\_sigma</sub>))
+ * O decodificador tenta decodificar a imagem original usando `sample` como vetor de entrada
+
+ <img src="../../../../../translated_images/pt-BR/vae.464c465a5b6a9e25.webp" width="50%">
+
+> Imagem deste [post no blog](https://ijdykeman.github.io/ml/2016/12/21/cvae.html) por Isaak Dykeman
+
+Autoencoders variacionais usam uma função de perda complexa que consiste em duas partes:
+
+* **Perda de reconstrução** é a função de perda que mostra quão próxima a imagem reconstruída está do alvo (pode ser o Erro Quadrático Médio, ou MSE). É a mesma função de perda usada em autoencoders normais.
+* **Perda KL**, que garante que as distribuições das variáveis latentes permaneçam próximas da distribuição normal. Baseia-se na noção de [divergência de Kullback-Leibler](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained) - uma métrica para estimar quão semelhantes duas distribuições estatísticas são.
+
+Uma vantagem importante dos VAEs é que eles permitem gerar novas imagens relativamente fácil, porque sabemos de qual distribuição amostrar os vetores latentes. Por exemplo, se treinarmos um VAE com vetor latente 2D no MNIST, podemos então variar os componentes do vetor latente para obter diferentes dígitos:
+
+<img alt="vaemnist" src="../../../../../translated_images/pt-BR/vaemnist.cab9e602dc08dc50.webp" width="50%"/>
+
+> Imagem por [Dmitry Soshnikov](http://soshnikov.com)
+
+Observe como as imagens se misturam umas às outras, à medida que começamos a obter vetores latentes de diferentes partes do espaço de parâmetros latentes. Também podemos visualizar esse espaço em 2D:
+
+<img alt="vaemnist cluster" src="../../../../../translated_images/pt-BR/vaemnist-diag.694315f775d5d666.webp" width="50%"/> 
+
+> Imagem por [Dmitry Soshnikov](http://soshnikov.com)
+
+## ✍️ Exercícios: Autoencoders
+
+Saiba mais sobre autoencoders nos notebooks correspondentes:
+
+* [Autoencoders em TensorFlow](AutoencodersTF.ipynb)
+* [Autoencoders em PyTorch](AutoEncodersPyTorch.ipynb)
+
+## Propriedades dos Autoencoders
+
+* **Específicos para os dados** - eles funcionam bem apenas com o tipo de imagens em que foram treinados. Por exemplo, se treinarmos uma rede de super-resolução em flores, ela não funcionará bem em retratos. Isso ocorre porque a rede pode produzir imagens de alta resolução ao usar detalhes finos das características aprendidas no conjunto de dados de treinamento.
+* **Com perdas** - a imagem reconstruída não é idêntica à imagem original. A natureza da perda é definida pela *função de perda* usada durante o treinamento.
+* Funciona com **dados não rotulados**
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/18)
+
+## Conclusão
+
+Nesta lição, você aprendeu sobre os vários tipos de autoencoders disponíveis para o cientista de IA. Aprendeu como construí-los e como usá-los para reconstruir imagens. Também aprendeu sobre o VAE e como usá-lo para gerar novas imagens.
+
+## 🚀 Desafio
+
+Nesta lição, você aprendeu sobre o uso de autoencoders para imagens. Mas eles também podem ser usados para música! Confira o projeto [MusicVAE](https://magenta.tensorflow.org/music-vae) do Magenta, que usa autoencoders para aprender a reconstruir música. Faça alguns [experimentos](https://colab.research.google.com/github/magenta/magenta-demos/blob/master/colab-notebooks/Multitrack_MusicVAE.ipynb) com esta biblioteca para ver o que você pode criar.
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/16)
+
+## Revisão e Autoestudo
+
+Para referência, leia mais sobre autoencoders nestes recursos:
+
+* [Construindo Autoencoders em Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
+* [Post no blog NeuroHive](https://neurohive.io/ru/osnovy-data-science/variacionnyj-avtojenkoder-vae/)
+* [Autoencoders Variacionais Explicados](https://kvfrans.com/variational-autoencoders-explained/)
+* [Autoencoders Variacionais Condicionais](https://ijdykeman.github.io/ml/2016/12/21/cvae.html)
+
+## Tarefa
+
+No final deste [notebook usando TensorFlow](AutoencodersTF.ipynb), você encontrará uma 'tarefa' - use-a como sua tarefa.
+
+---
+

translations/pt-BR/lessons/4-ComputerVision/10-GANs/README.md

@@ -0,0 +1,101 @@
+# Redes Adversárias Generativas
+
+Na seção anterior, aprendemos sobre **modelos generativos**: modelos que podem gerar novas imagens semelhantes às do conjunto de dados de treinamento. O VAE foi um bom exemplo de modelo generativo.
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/19)
+
+No entanto, se tentarmos gerar algo realmente significativo, como uma pintura em resolução razoável, com o VAE, veremos que o treinamento não converge bem. Para esse caso de uso, devemos aprender sobre outra arquitetura especificamente voltada para modelos generativos - as **Redes Adversárias Generativas**, ou GANs.
+
+A ideia principal de uma GAN é ter duas redes neurais que serão treinadas uma contra a outra:
+
+<img src="../../../../../translated_images/pt-BR/gan_architecture.8f3a5ab62b8d5d69.webp" width="70%"/>
+
+> Imagem por [Dmitry Soshnikov](http://soshnikov.com)
+
+> ✅ Um pouco de vocabulário:
+> * **Gerador** é uma rede que recebe um vetor aleatório e produz uma imagem como resultado.
+> * **Discriminador** é uma rede que recebe uma imagem e deve dizer se é uma imagem real (do conjunto de dados de treinamento) ou se foi gerada por um gerador. Essencialmente, é um classificador de imagens.
+
+### Discriminador
+
+A arquitetura do discriminador não difere de uma rede de classificação de imagens comum. No caso mais simples, pode ser um classificador totalmente conectado, mas provavelmente será uma [rede convolucional](../07-ConvNets/README.md).
+
+> ✅ Uma GAN baseada em redes convolucionais é chamada de [DCGAN](https://arxiv.org/pdf/1511.06434.pdf)
+
+Um discriminador CNN consiste nas seguintes camadas: várias convoluções+poolings (com tamanho espacial decrescente) e uma ou mais camadas totalmente conectadas para obter o "vetor de características", seguido de um classificador binário final.
+
+> ✅ Um 'pooling' neste contexto é uma técnica que reduz o tamanho da imagem. "As camadas de pooling reduzem as dimensões dos dados combinando as saídas de clusters de neurônios em uma camada em um único neurônio na próxima camada." - [fonte](https://wikipedia.org/wiki/Convolutional_neural_network#Pooling_layers)
+
+### Gerador
+
+Um Gerador é um pouco mais complicado. Você pode considerá-lo como um discriminador invertido. Começando de um vetor latente (no lugar de um vetor de características), ele possui uma camada totalmente conectada para convertê-lo no tamanho/forma necessários, seguida de deconvoluções+upscaling. Isso é semelhante à parte de *decodificador* de um [autoencoder](../09-Autoencoders/README.md).
+
+> ✅ Como a camada de convolução é implementada como um filtro linear que percorre a imagem, a deconvolução é essencialmente semelhante à convolução e pode ser implementada usando a mesma lógica de camada.
+
+<img src="../../../../../translated_images/pt-BR/gan_arch_detail.46b95fd366f8e543.webp" width="70%"/>
+
+> Imagem por [Dmitry Soshnikov](http://soshnikov.com)
+
+### Treinando a GAN
+
+As GANs são chamadas de **adversárias** porque há uma competição constante entre o gerador e o discriminador. Durante essa competição, tanto o gerador quanto o discriminador melhoram, fazendo com que a rede aprenda a produzir imagens cada vez melhores.
+
+O treinamento ocorre em duas etapas:
+
+* **Treinando o discriminador**. Esta tarefa é bastante direta: geramos um lote de imagens com o gerador, rotulando-as como 0, o que significa imagem falsa, e pegamos um lote de imagens do conjunto de dados de entrada (com rótulo 1, imagem real). Obtemos uma *perda do discriminador* e realizamos o backpropagation.
+* **Treinando o gerador**. Isso é um pouco mais complicado, porque não sabemos diretamente a saída esperada para o gerador. Pegamos toda a rede GAN, composta por um gerador seguido de um discriminador, alimentamos com alguns vetores aleatórios e esperamos que o resultado seja 1 (correspondente a imagens reais). Em seguida, congelamos os parâmetros do discriminador (não queremos que ele seja treinado nesta etapa) e realizamos o backpropagation.
+
+Durante esse processo, as perdas do gerador e do discriminador não diminuem significativamente. Na situação ideal, elas devem oscilar, correspondendo à melhoria de ambos os modelos.
+
+## ✍️ Exercícios: GANs
+
+* [Notebook de GAN em TensorFlow/Keras](GANTF.ipynb)
+* [Notebook de GAN em PyTorch](GANPyTorch.ipynb)
+
+### Problemas no treinamento de GANs
+
+As GANs são conhecidas por serem especialmente difíceis de treinar. Aqui estão alguns problemas:
+
+* **Colapso de modo**. Esse termo significa que o gerador aprende a produzir uma única imagem bem-sucedida que engana o discriminador, em vez de uma variedade de imagens diferentes.
+* **Sensibilidade aos hiperparâmetros**. Muitas vezes, você pode perceber que uma GAN não converge de forma alguma e, de repente, uma redução na taxa de aprendizado leva à convergência.
+* Manter um **equilíbrio** entre o gerador e o discriminador. Em muitos casos, a perda do discriminador pode cair para zero relativamente rápido, o que resulta no gerador sendo incapaz de continuar o treinamento. Para superar isso, podemos tentar definir taxas de aprendizado diferentes para o gerador e o discriminador ou pular o treinamento do discriminador se a perda já estiver muito baixa.
+* Treinamento para **alta resolução**. Refletindo o mesmo problema dos autoencoders, esse problema é desencadeado porque reconstruir muitas camadas de uma rede convolucional leva a artefatos. Esse problema é geralmente resolvido com o chamado **crescimento progressivo**, onde primeiro algumas camadas são treinadas em imagens de baixa resolução e, em seguida, as camadas são "desbloqueadas" ou adicionadas. Outra solução seria adicionar conexões extras entre as camadas e treinar várias resoluções ao mesmo tempo - veja este [artigo sobre GANs de Gradiente Multi-Escala](https://arxiv.org/abs/1903.06048) para mais detalhes.
+
+## Transferência de Estilo
+
+As GANs são uma ótima maneira de gerar imagens artísticas. Outra técnica interessante é a chamada **transferência de estilo**, que pega uma **imagem de conteúdo** e a redesenha em um estilo diferente, aplicando filtros de uma **imagem de estilo**.
+
+O funcionamento é o seguinte:
+* Começamos com uma imagem de ruído aleatório (ou com uma imagem de conteúdo, mas para fins de entendimento é mais fácil começar com ruído aleatório).
+* Nosso objetivo será criar uma imagem que seja próxima tanto da imagem de conteúdo quanto da imagem de estilo. Isso será determinado por duas funções de perda:
+   - **Perda de conteúdo** é calculada com base nas características extraídas pela CNN em algumas camadas da imagem atual e da imagem de conteúdo.
+   - **Perda de estilo** é calculada entre a imagem atual e a imagem de estilo de uma maneira inteligente usando matrizes de Gram (mais detalhes no [notebook de exemplo](StyleTransfer.ipynb)).
+* Para tornar a imagem mais suave e remover o ruído, também introduzimos a **Perda de variação**, que calcula a distância média entre pixels vizinhos.
+* O principal loop de otimização ajusta a imagem atual usando descida de gradiente (ou algum outro algoritmo de otimização) para minimizar a perda total, que é uma soma ponderada de todas as três perdas.
+
+## ✍️ Exemplo: [Transferência de Estilo](StyleTransfer.ipynb)
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/20)
+
+## Conclusão
+
+Nesta lição, você aprendeu sobre GANs e como treiná-las. Você também aprendeu sobre os desafios específicos que esse tipo de Rede Neural pode enfrentar e algumas estratégias para superá-los.
+
+## 🚀 Desafio
+
+Execute o [notebook de Transferência de Estilo](StyleTransfer.ipynb) usando suas próprias imagens.
+
+## Revisão e Autoestudo
+
+Para referência, leia mais sobre GANs nestes recursos:
+
+* Marco Pasini, [10 Lições que Aprendi Treinando GANs por um Ano](https://towardsdatascience.com/10-lessons-i-learned-training-generative-adversarial-networks-gans-for-a-year-c9071159628)
+* [StyleGAN](https://en.wikipedia.org/wiki/StyleGAN), uma arquitetura GAN *de facto* a ser considerada.
+* [Criando Arte Generativa usando GANs no Azure ML](https://soshnikov.com/scienceart/creating-generative-art-using-gan-on-azureml/)
+
+## Tarefa
+
+Revise um dos dois notebooks associados a esta lição e re-treine a GAN com suas próprias imagens. O que você consegue criar?
+
+---
+