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

translations/pt-PT/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 precisa desenvolver uma aplicação para um berçário de animais de estimação para catalogar todos os animais. Uma das grandes funcionalidades de tal aplicação seria identificar automaticamente a raça a partir de uma fotografia. Neste trabalho, vamos usar 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 descarregar o conjunto de dados, utilize 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
+```
+
+## Notebook Inicial
+
+Comece o trabalho prático abrindo [OxfordPets.ipynb](../../../../../../lessons/4-ComputerVision/08-TransferLearning/lab/OxfordPets.ipynb)
+
+## Conclusão
+
+Transfer learning e redes pré-treinadas permitem-nos 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 significativamente 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 na sua língua nativa deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.

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

@@ -0,0 +1,100 @@
+# Autoencoders
+
+Ao treinar redes neuronais convolucionais (CNNs), um dos problemas é que precisamos de muitos dados etiquetados. No caso da classificação de imagens, é necessário separar as imagens em diferentes classes, o que exige esforço manual.
+
+## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/17)
+
+No entanto, podemos querer usar dados brutos (não etiquetados) para treinar extratores de características de CNN, o que é chamado de **aprendizagem auto-supervisionada**. Em vez de etiquetas, utilizamos as imagens de treino como entrada e saída da rede. A ideia principal de um **autoencoder** é que teremos uma **rede codificadora** que converte a imagem de entrada num **espaço latente** (normalmente é apenas um vetor de tamanho reduzido), e uma **rede descodificadora**, cujo objetivo será reconstruir a imagem original.
+
+> ✅ Um [autoencoder](https://wikipedia.org/wiki/Autoencoder) é "um tipo de rede neuronal artificial usada para aprender codificações eficientes de dados não etiquetados."
+
+Como estamos a treinar um autoencoder para capturar o máximo de informação possível da imagem original para uma reconstrução precisa, a rede tenta encontrar a melhor **representação** das imagens de entrada para captar o seu significado.
+
+![Diagrama de Autoencoder](../../../../../translated_images/pt-PT/autoencoder_schema.5e6fc9ad98a5eb61.webp)
+
+> Imagem retirada do [blog da Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
+
+## Cenários para usar Autoencoders
+
+Embora a reconstrução de imagens originais possa não parecer útil por si só, existem alguns cenários em que os autoencoders são especialmente úteis:
+
+* **Redução da dimensão de imagens para visualização** ou **treino de representações de imagens**. Normalmente, os autoencoders produzem melhores resultados do que a PCA, porque consideram a natureza espacial das imagens e as características hierárquicas.
+* **Remoção de ruído**, ou seja, eliminar o ruído da imagem. Como o ruído contém muita informação inútil, o autoencoder não consegue encaixar tudo no espaço latente relativamente pequeno, capturando 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**, ou seja, aumentar a resolução da imagem. Começamos com imagens de alta resolução e usamos imagens de resolução mais baixa como entrada para o autoencoder.
+* **Modelos generativos**. Depois de treinar o autoencoder, a parte descodificadora pode ser usada para criar novos objetos a partir de vetores latentes aleatórios.
+
+## Autoencoders Variacionais (VAE)
+
+Os 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 muitas vezes não fazem muito sentido. Por 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 correspondem necessariamente aos mesmos dígitos.
+
+Por outro lado, para treinar modelos *generativos*, é melhor ter algum entendimento do espaço latente. Esta ideia leva-nos 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 uma média z<sub>mean</sub> e um 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 o descodificador utiliza 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 o seu logaritmo)
+ * Amostramos um vetor `sample` da distribuição N(z<sub>mean</sub>,exp(z<sub>log\_sigma</sub>))
+ * O descodificador tenta reconstruir a imagem original usando `sample` como vetor de entrada
+
+ <img src="../../../../../translated_images/pt-PT/vae.464c465a5b6a9e25.webp" width="50%">
+
+> Imagem retirada deste [artigo](https://ijdykeman.github.io/ml/2016/12/21/cvae.html) por Isaak Dykeman
+
+Os autoencoders variacionais utilizam uma função de perda complexa composta por duas partes:
+
+* **Perda de reconstrução**, que é a função de perda que indica 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 no conceito de [divergência de Kullback-Leibler](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained) - uma métrica para estimar a semelhança entre duas distribuições estatísticas.
+
+Uma vantagem importante dos VAEs é que permitem gerar novas imagens de forma relativamente fácil, porque sabemos de qual distribuição amostrar os vetores latentes. Por exemplo, se treinarmos um VAE com um vetor latente 2D no MNIST, podemos variar os componentes do vetor latente para obter diferentes dígitos:
+
+<img alt="vaemnist" src="../../../../../translated_images/pt-PT/vaemnist.cab9e602dc08dc50.webp" width="50%"/>
+
+> Imagem por [Dmitry Soshnikov](http://soshnikov.com)
+
+Observe como as imagens se fundem umas nas outras, à medida que começamos a obter vetores latentes de diferentes partes do espaço de parâmetros latentes. Também podemos visualizar este espaço em 2D:
+
+<img alt="vaemnist cluster" src="../../../../../translated_images/pt-PT/vaemnist-diag.694315f775d5d666.webp" width="50%"/> 
+
+> Imagem por [Dmitry Soshnikov](http://soshnikov.com)
+
+## ✍️ Exercícios: Autoencoders
+
+Saiba mais sobre autoencoders nestes notebooks correspondentes:
+
+* [Autoencoders em TensorFlow](AutoencodersTF.ipynb)
+* [Autoencoders em PyTorch](AutoEncodersPyTorch.ipynb)
+
+## Propriedades dos Autoencoders
+
+* **Específicos aos Dados** - 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. Isto acontece porque a rede pode produzir imagens de maior resolução ao extrair detalhes finos das características aprendidas no conjunto de dados de treino.
+* **Com perdas** - a imagem reconstruída não é exatamente igual à imagem original. A natureza da perda é definida pela *função de perda* usada durante o treino.
+* Funciona com **dados não etiquetados**
+
+## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/18)
+
+## Conclusão
+
+Nesta lição, aprendeste sobre os vários tipos de autoencoders disponíveis para o cientista de IA. Aprendeste como construí-los e como usá-los para reconstruir imagens. Também aprendeste sobre o VAE e como usá-lo para gerar novas imagens.
+
+## 🚀 Desafio
+
+Nesta lição, aprendeste sobre o uso de autoencoders para imagens. Mas eles também podem ser usados para música! Explora o projeto [MusicVAE](https://magenta.tensorflow.org/music-vae) do Magenta, que utiliza autoencoders para aprender a reconstruir música. Faz algumas [experiências](https://colab.research.google.com/github/magenta/magenta-demos/blob/master/colab-notebooks/Multitrack_MusicVAE.ipynb) com esta biblioteca para ver o que consegues criar.
+
+## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/16)
+
+## Revisão e Autoestudo
+
+Para referência, lê mais sobre autoencoders nestes recursos:
+
+* [Construindo Autoencoders em Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
+* [Artigo no 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), encontrarás uma 'tarefa' - usa-a como tua tarefa.
+
+---
+

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

@@ -0,0 +1,101 @@
+# Redes Adversárias Generativas
+
+Na secção anterior, aprendemos sobre **modelos generativos**: modelos que podem gerar novas imagens semelhantes às do conjunto de dados de treino. O VAE foi um bom exemplo de modelo generativo.
+
+## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/19)
+
+No entanto, se tentarmos gerar algo realmente significativo, como uma pintura com resolução razoável, usando o VAE, veremos que o treino não converge bem. Para este caso, devemos aprender sobre outra arquitetura especificamente direcionada para modelos generativos - **Redes Adversárias Generativas**, ou GANs.
+
+A ideia principal de uma GAN é ter duas redes neuronais que serão treinadas uma contra a outra:
+
+<img src="../../../../../translated_images/pt-PT/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 treino) 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", 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 ao combinar os resultados de clusters de neurónios numa 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. Pode ser considerado como um discriminador invertido. Começando por um vetor latente (em vez de um vetor de características), tem uma camada totalmente conectada para convertê-lo no tamanho/forma necessária, seguida por deconvoluções+ampliação. Isto é 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-PT/gan_arch_detail.46b95fd366f8e543.webp" width="70%"/>
+
+> Imagem por [Dmitry Soshnikov](http://soshnikov.com)
+
+### Treino da GAN
+
+As GANs são chamadas de **adversárias** porque há uma competição constante entre o gerador e o discriminador. Durante esta competição, tanto o gerador quanto o discriminador melhoram, e assim a rede aprende a produzir imagens cada vez melhores.
+
+O treino ocorre em duas etapas:
+
+* **Treino do discriminador**. Esta tarefa é bastante direta: geramos um lote de imagens com o gerador, rotulando-as como 0, que representa 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 backprop.
+* **Treino do gerador**. Isto é um pouco mais complicado, porque não sabemos diretamente o resultado esperado para o gerador. Pegamos toda a rede GAN, consistindo de um gerador seguido por um discriminador, alimentamo-la 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 backprop.
+
+Durante este processo, as perdas do gerador e do discriminador não diminuem significativamente. Na situação ideal, elas devem oscilar, correspondendo a ambos os modelos a melhorar o desempenho.
+
+## ✍️ Exercícios: GANs
+
+* [Notebook GAN em TensorFlow/Keras](GANTF.ipynb)
+* [Notebook GAN em PyTorch](GANPyTorch.ipynb)
+
+### Problemas no treino de GANs
+
+As GANs são conhecidas por serem especialmente difíceis de treinar. Aqui estão alguns problemas:
+
+* **Colapso de modo**. Este termo refere-se ao fato de o gerador aprender 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, pode-se observar que uma GAN não converge de forma alguma, e então, de repente, uma diminuição na taxa de aprendizagem 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 incapaz de continuar o treino. Para superar isso, podemos tentar definir taxas de aprendizagem diferentes para o gerador e o discriminador ou ignorar o treino do discriminador se a perda já for muito baixa.
+* Treino para **alta resolução**. Refletindo o mesmo problema dos autoencoders, este problema é desencadeado porque reconstruir muitas camadas de uma rede convolucional leva a artefactos. Este 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 camadas e treinar várias resoluções ao mesmo tempo - veja este artigo [Multi-Scale Gradient GANs](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 redesenha-a num 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 compreensão é mais fácil começar com ruído aleatório).
+* O nosso objetivo será criar uma imagem que seja próxima tanto da imagem de conteúdo quanto da imagem de estilo. Isto 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 forma 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 ciclo 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)
+
+## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/20)
+
+## Conclusão
+
+Nesta lição, aprendeste sobre GANs e como treiná-las. Também aprendeste sobre os desafios especiais que este tipo de rede neuronal pode enfrentar e algumas estratégias para superá-los.
+
+## 🚀 Desafio
+
+Experimenta o [notebook de Transferência de Estilo](StyleTransfer.ipynb) usando as tuas próprias imagens.
+
+## Revisão e Autoestudo
+
+Para referência, lê mais sobre GANs nestes recursos:
+
+* Marco Pasini, [10 Lições que Aprendi ao Treinar 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 considerar
+* [Criando Arte Generativa usando GANs no Azure ML](https://soshnikov.com/scienceart/creating-generative-art-using-gan-on-azureml/)
+
+## Tarefa
+
+Revisita um dos dois notebooks associados a esta lição e treina novamente a GAN com as tuas próprias imagens. O que consegues criar?
+
+---
+