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

translations/pt-BR/lessons/4-ComputerVision/07-ConvNets/lab/README.md

@@ -0,0 +1,38 @@
+# Classificação de Rostos de Animais de Estimação
+
+Atividade de laboratório do [Currículo de IA para Iniciantes](https://github.com/microsoft/ai-for-beginners).
+
+## Tarefa
+
+Imagine que você precisa desenvolver um aplicativo para um berçário de animais de estimação para catalogar todos os animais. Uma das grandes funcionalidades de tal aplicativo seria identificar automaticamente a raça a partir de uma fotografia. Isso pode ser feito com sucesso usando redes neurais.
+
+Você precisa treinar uma rede neural convolucional para classificar diferentes raças de gatos e cães usando o conjunto de dados **Pet Faces**.
+
+## O Conjunto de Dados
+
+Usaremos o [Oxford-IIIT Pet Dataset](https://www.robots.ox.ac.uk/~vgg/data/pets/), que contém imagens de 37 diferentes raças de cães e gatos.
+
+![Conjunto de dados com o qual trabalharemos](../../../../../../translated_images/pt-BR/data.50b2a9d5484bdbf0.webp)
+
+Para baixar o conjunto de dados, use este trecho de código:
+
+```python
+!wget https://thor.robots.ox.ac.uk/~vgg/data/pets/images.tar.gz
+!tar xfz images.tar.gz
+!rm images.tar.gz
+```
+
+**Nota:** As imagens do Oxford-IIIT Pet Dataset estão organizadas por nome de arquivo (por exemplo, `Abyssinian_1.jpg`, `Bengal_2.jpg`). O notebook inclui código para organizar essas imagens em subdiretórios específicos de raças para facilitar a classificação.
+
+## Notebook Inicial
+
+Comece o laboratório abrindo [PetFaces.ipynb](PetFaces.ipynb)
+
+## Conclusão
+
+Você resolveu um problema relativamente complexo de classificação de imagens do zero! Havia muitas classes, e você ainda conseguiu obter uma precisão razoável! Também faz sentido medir a precisão top-k, porque é fácil confundir algumas classes que não são claramente diferentes, mesmo para seres humanos.
+
+---
+
+**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, é importante estar 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 autoritativa. 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 equivocadas decorrentes do uso desta tradução.

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

@@ -0,0 +1,81 @@
+# Redes Pré-treinadas e Aprendizado por Transferência
+
+Treinar CNNs pode levar muito tempo e exigir uma grande quantidade de dados. No entanto, grande parte do tempo é gasto aprendendo os melhores filtros de baixo nível que uma rede pode usar para extrair padrões de imagens. Surge uma pergunta natural: podemos usar uma rede neural treinada em um conjunto de dados e adaptá-la para classificar imagens diferentes sem precisar de um processo completo de treinamento?
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/15)
+
+Essa abordagem é chamada de **aprendizado por transferência**, porque transferimos algum conhecimento de um modelo de rede neural para outro. No aprendizado por transferência, normalmente começamos com um modelo pré-treinado, que foi treinado em um grande conjunto de dados de imagens, como o **ImageNet**. Esses modelos já conseguem extrair diferentes características de imagens genéricas, e, em muitos casos, apenas construir um classificador em cima dessas características extraídas pode gerar bons resultados.
+
+> ✅ Aprendizado por Transferência é um termo que você encontra em outros campos acadêmicos, como Educação. Ele se refere ao processo de levar conhecimento de um domínio e aplicá-lo em outro.
+
+## Modelos Pré-treinados como Extratores de Características
+
+As redes convolucionais que discutimos na seção anterior contêm várias camadas, cada uma delas destinada a extrair características da imagem, começando por combinações de pixels de baixo nível (como linhas horizontais/verticais ou traços), até combinações de características de nível mais alto, correspondendo a coisas como o olho de uma chama. Se treinarmos uma CNN em um conjunto de dados suficientemente grande de imagens genéricas e diversas, a rede deve aprender a extrair essas características comuns.
+
+Tanto o Keras quanto o PyTorch possuem funções para carregar facilmente pesos de redes neurais pré-treinadas para algumas arquiteturas comuns, a maioria das quais foi treinada em imagens do ImageNet. As mais utilizadas estão descritas na página [Arquiteturas de CNN](../07-ConvNets/CNN_Architectures.md) da lição anterior. Em particular, você pode considerar usar uma das seguintes:
+
+* **VGG-16/VGG-19**, que são modelos relativamente simples, mas ainda oferecem boa precisão. Usar o VGG como uma primeira tentativa é uma boa escolha para ver como o aprendizado por transferência está funcionando.
+* **ResNet** é uma família de modelos proposta pela Microsoft Research em 2015. Eles possuem mais camadas e, portanto, exigem mais recursos.
+* **MobileNet** é uma família de modelos com tamanho reduzido, adequada para dispositivos móveis. Use-os se você tiver poucos recursos e puder sacrificar um pouco de precisão.
+
+Aqui estão características extraídas de uma imagem de um gato pela rede VGG-16:
+
+![Características extraídas pelo VGG-16](../../../../../translated_images/pt-BR/features.6291f9c7ba3a0b95.webp)
+
+## Conjunto de Dados de Gatos vs. Cachorros
+
+Neste exemplo, usaremos um conjunto de dados de [Gatos e Cachorros](https://www.microsoft.com/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste), que é muito próximo de um cenário real de classificação de imagens.
+
+## ✍️ Exercício: Aprendizado por Transferência
+
+Vamos ver o aprendizado por transferência em ação nos notebooks correspondentes:
+
+* [Transfer Learning - PyTorch](TransferLearningPyTorch.ipynb)
+* [Transfer Learning - TensorFlow](TransferLearningTF.ipynb)
+
+## Visualizando o Gato Adversarial
+
+Uma rede neural pré-treinada contém diferentes padrões em seu *cérebro*, incluindo noções de **gato ideal** (assim como cachorro ideal, zebra ideal, etc.). Seria interessante de alguma forma **visualizar essa imagem**. No entanto, isso não é simples, porque os padrões estão espalhados por todos os pesos da rede e organizados em uma estrutura hierárquica.
+
+Uma abordagem que podemos adotar é começar com uma imagem aleatória e, em seguida, tentar usar a técnica de **otimização por descida de gradiente** para ajustar essa imagem de forma que a rede comece a pensar que é um gato.
+
+![Loop de Otimização de Imagem](../../../../../translated_images/pt-BR/ideal-cat-loop.999fbb8ff306e044.webp)
+
+No entanto, se fizermos isso, receberemos algo muito semelhante a um ruído aleatório. Isso ocorre porque *existem muitas maneiras de fazer a rede pensar que a imagem de entrada é um gato*, incluindo algumas que não fazem sentido visualmente. Embora essas imagens contenham muitos padrões típicos de um gato, não há nada que as restrinja a serem visualmente distintas.
+
+Para melhorar o resultado, podemos adicionar outro termo à função de perda, chamado de **perda de variação**. É uma métrica que mostra quão semelhantes são os pixels vizinhos da imagem. Minimizar a perda de variação torna a imagem mais suave e elimina o ruído, revelando padrões mais visualmente atraentes. Aqui está um exemplo de tais imagens "ideais", classificadas como gato e zebra com alta probabilidade:
+
+![Gato Ideal](../../../../../translated_images/pt-BR/ideal-cat.203dd4597643d6b0.webp) | ![Zebra Ideal](../../../../../translated_images/pt-BR/ideal-zebra.7f70e8b54ee15a7a.webp)
+-----|-----
+ *Gato Ideal* | *Zebra Ideal*
+
+Uma abordagem semelhante pode ser usada para realizar os chamados **ataques adversariais** em uma rede neural. Suponha que queremos enganar uma rede neural e fazer um cachorro parecer um gato. Se pegarmos a imagem de um cachorro, que é reconhecida pela rede como um cachorro, podemos ajustá-la um pouco usando otimização por descida de gradiente até que a rede comece a classificá-la como um gato:
+
+![Imagem de um Cachorro](../../../../../translated_images/pt-BR/original-dog.8f68a67d2fe0911f.webp) | ![Imagem de um cachorro classificada como gato](../../../../../translated_images/pt-BR/adversarial-dog.d9fc7773b0142b89.webp)
+-----|-----
+*Imagem original de um cachorro* | *Imagem de um cachorro classificada como gato*
+
+Veja o código para reproduzir os resultados acima no seguinte notebook:
+
+* [Ideal e Adversarial Cat - TensorFlow](AdversarialCat_TF.ipynb)
+
+## Conclusão
+
+Usando aprendizado por transferência, você pode montar rapidamente um classificador para uma tarefa de classificação de objetos personalizada e alcançar alta precisão. Você pode perceber que tarefas mais complexas que estamos resolvendo agora exigem maior poder computacional e não podem ser facilmente resolvidas no CPU. Na próxima unidade, tentaremos usar uma implementação mais leve para treinar o mesmo modelo usando menos recursos computacionais, o que resulta em uma precisão apenas ligeiramente menor.
+
+## 🚀 Desafio
+
+Nos notebooks que acompanham, há notas no final sobre como o aprendizado por transferência funciona melhor com dados de treinamento um pouco semelhantes (um novo tipo de animal, talvez). Faça algumas experimentações com tipos completamente novos de imagens para ver como seus modelos de aprendizado por transferência se saem.
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/16)
+
+## Revisão e Autoestudo
+
+Leia o arquivo [TrainingTricks.md](TrainingTricks.md) para aprofundar seu conhecimento sobre outras formas de treinar seus modelos.
+
+## [Tarefa](lab/README.md)
+
+Neste laboratório, usaremos o conjunto de dados real [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) de animais de estimação, com 35 raças de gatos e cachorros, e construiremos um classificador de aprendizado por transferência.
+
+---
+

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

@@ -0,0 +1,108 @@
+# Truques para Treinamento de Deep Learning
+
+À medida que as redes neurais se tornam mais profundas, o processo de treinamento delas se torna cada vez mais desafiador. Um dos principais problemas é o chamado [vanishing gradients](https://en.wikipedia.org/wiki/Vanishing_gradient_problem) (gradientes que desaparecem) ou [exploding gradients](https://deepai.org/machine-learning-glossary-and-terms/exploding-gradient-problem#:~:text=Exploding%20gradients%20are%20a%20problem,updates%20are%20small%20and%20controlled.) (gradientes que explodem). [Este artigo](https://towardsdatascience.com/the-vanishing-exploding-gradient-problem-in-deep-neural-networks-191358470c11) oferece uma boa introdução a esses problemas.
+
+Para tornar o treinamento de redes profundas mais eficiente, existem algumas técnicas que podem ser utilizadas.
+
+## Mantendo os valores em um intervalo razoável
+
+Para tornar os cálculos numéricos mais estáveis, queremos garantir que todos os valores dentro da nossa rede neural estejam em uma escala razoável, tipicamente [-1..1] ou [0..1]. Não é um requisito muito rigoroso, mas a natureza dos cálculos em ponto flutuante é tal que valores de magnitudes diferentes não podem ser manipulados com precisão juntos. Por exemplo, se somarmos 10<sup>-10</sup> e 10<sup>10</sup>, provavelmente obteremos 10<sup>10</sup>, porque o valor menor seria "convertido" para a mesma ordem do maior, e assim a mantissa seria perdida.
+
+A maioria das funções de ativação possui não-linearidades em torno de [-1..1], e, portanto, faz sentido escalar todos os dados de entrada para o intervalo [-1..1] ou [0..1].
+
+## Inicialização de Pesos
+
+Idealmente, queremos que os valores estejam na mesma faixa após passarem pelas camadas da rede. Assim, é importante inicializar os pesos de forma a preservar a distribuição dos valores.
+
+A distribuição normal **N(0,1)** não é uma boa ideia, porque se tivermos *n* entradas, o desvio padrão da saída será *n*, e os valores provavelmente sairão do intervalo [0..1].
+
+As seguintes inicializações são frequentemente usadas:
+
+- Distribuição uniforme -- `uniform`
+- **N(0,1/n)** -- `gaussian`
+- **N(0,1/√n_in)** garante que, para entradas com média zero e desvio padrão de 1, a mesma média/desvio padrão será mantida
+- **N(0,√2/(n_in+n_out))** -- a chamada **inicialização de Xavier** (`glorot`), que ajuda a manter os sinais na faixa durante a propagação direta e reversa
+
+## Normalização em Lote (Batch Normalization)
+
+Mesmo com uma inicialização adequada dos pesos, eles podem ficar arbitrariamente grandes ou pequenos durante o treinamento, o que levará os sinais para fora da faixa adequada. Podemos trazer os sinais de volta usando uma das técnicas de **normalização**. Embora existam várias delas (normalização de pesos, normalização de camadas), a mais utilizada é a Normalização em Lote.
+
+A ideia da **normalização em lote** é levar em conta todos os valores dentro do minibatch e realizar a normalização (ou seja, subtrair a média e dividir pelo desvio padrão) com base nesses valores. Ela é implementada como uma camada da rede que realiza essa normalização após aplicar os pesos, mas antes da função de ativação. Como resultado, é provável que vejamos maior precisão final e treinamento mais rápido.
+
+Aqui está o [artigo original](https://arxiv.org/pdf/1502.03167.pdf) sobre normalização em lote, a [explicação na Wikipedia](https://en.wikipedia.org/wiki/Batch_normalization) e [um bom post introdutório](https://towardsdatascience.com/batch-normalization-in-3-levels-of-understanding-14c2da90a338) (e outro [em russo](https://habrahabr.ru/post/309302/)).
+
+## Dropout
+
+**Dropout** é uma técnica interessante que remove uma certa porcentagem de neurônios aleatórios durante o treinamento. Ele também é implementado como uma camada com um parâmetro (percentual de neurônios a serem removidos, tipicamente 10%-50%), e durante o treinamento ele zera elementos aleatórios do vetor de entrada antes de passá-lo para a próxima camada.
+
+Embora isso possa parecer uma ideia estranha, você pode ver o efeito do dropout no treinamento de um classificador de dígitos MNIST no notebook [`Dropout.ipynb`](../../../../../lessons/4-ComputerVision/08-TransferLearning/Dropout.ipynb). Ele acelera o treinamento e permite alcançar maior precisão em menos épocas de treinamento.
+
+Esse efeito pode ser explicado de várias maneiras:
+
+- Pode ser considerado como um fator de choque aleatório para o modelo, que tira a otimização de mínimos locais
+- Pode ser considerado como uma *média implícita de modelos*, porque podemos dizer que durante o dropout estamos treinando modelos ligeiramente diferentes
+
+> *Algumas pessoas dizem que, quando uma pessoa bêbada tenta aprender algo, ela se lembrará melhor disso na manhã seguinte, em comparação com uma pessoa sóbria, porque um cérebro com alguns neurônios "defeituosos" tenta se adaptar melhor para captar o significado. Nunca testamos se isso é verdade ou não.*
+
+## Prevenindo Overfitting
+
+Um dos aspectos muito importantes do deep learning é ser capaz de prevenir o [overfitting](../../3-NeuralNetworks/05-Frameworks/Overfitting.md). Embora possa ser tentador usar um modelo de rede neural muito poderoso, devemos sempre equilibrar o número de parâmetros do modelo com o número de amostras de treinamento.
+
+> Certifique-se de entender o conceito de [overfitting](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) que introduzimos anteriormente!
+
+Existem várias maneiras de prevenir o overfitting:
+
+- Parada antecipada (Early stopping) -- monitorar continuamente o erro no conjunto de validação e interromper o treinamento quando o erro de validação começar a aumentar.
+- Decaimento de pesos explícito / Regularização -- adicionar uma penalidade extra à função de perda para valores absolutos altos dos pesos, o que evita que o modelo produza resultados muito instáveis
+- Média de Modelos -- treinar vários modelos e depois fazer a média dos resultados. Isso ajuda a minimizar a variância.
+- Dropout (Média Implícita de Modelos)
+
+## Otimizadores / Algoritmos de Treinamento
+
+Outro aspecto importante do treinamento é escolher um bom algoritmo de treinamento. Embora o **gradiente descendente** clássico seja uma escolha razoável, ele pode, às vezes, ser muito lento ou resultar em outros problemas.
+
+No deep learning, usamos o **Stochastic Gradient Descent** (SGD), que é um gradiente descendente aplicado a minibatches, selecionados aleatoriamente do conjunto de treinamento. Os pesos são ajustados usando esta fórmula:
+
+w<sup>t+1</sup> = w<sup>t</sup> - η∇ℒ
+
+### Momentum
+
+No **momentum SGD**, mantemos uma parte do gradiente dos passos anteriores. É semelhante a quando estamos nos movendo com inércia e recebemos um empurrão em uma direção diferente; nossa trajetória não muda imediatamente, mas mantém parte do movimento original. Aqui introduzimos outro vetor v para representar a *velocidade*:
+
+- v<sup>t+1</sup> = γ v<sup>t</sup> - η∇ℒ
+- w<sup>t+1</sup> = w<sup>t</sup> + v<sup>t+1</sup>
+
+Aqui, o parâmetro γ indica a extensão em que levamos a inércia em conta: γ=0 corresponde ao SGD clássico; γ=1 é uma equação de movimento puro.
+
+### Adam, Adagrad, etc.
+
+Como em cada camada multiplicamos os sinais por alguma matriz W<sub>i</sub>, dependendo de ||W<sub>i</sub>||, o gradiente pode diminuir e ficar próximo de 0 ou crescer indefinidamente. Esse é o cerne do problema de Exploding/Vanishing Gradients.
+
+Uma das soluções para esse problema é usar apenas a direção do gradiente na equação e ignorar o valor absoluto, ou seja:
+
+w<sup>t+1</sup> = w<sup>t</sup> - η(∇ℒ/||∇ℒ||), onde ||∇ℒ|| = √∑(∇ℒ)<sup>2</sup>
+
+Esse algoritmo é chamado de **Adagrad**. Outros algoritmos que usam a mesma ideia: **RMSProp**, **Adam**
+
+> **Adam** é considerado um algoritmo muito eficiente para muitas aplicações, então, se você não tiver certeza de qual usar, use Adam.
+
+### Gradient clipping
+
+Gradient clipping é uma extensão da ideia acima. Quando ||∇ℒ|| ≤ θ, consideramos o gradiente original na otimização dos pesos, e quando ||∇ℒ|| > θ, dividimos o gradiente pela sua norma. Aqui, θ é um parâmetro; na maioria dos casos, podemos usar θ=1 ou θ=10.
+
+### Decaimento da taxa de aprendizado
+
+O sucesso do treinamento frequentemente depende do parâmetro de taxa de aprendizado η. É lógico supor que valores maiores de η resultam em treinamento mais rápido, algo que geralmente queremos no início do treinamento, e então valores menores de η permitem ajustar melhor a rede. Assim, na maioria dos casos, queremos diminuir η ao longo do treinamento.
+
+Isso pode ser feito multiplicando η por algum número (por exemplo, 0,98) após cada época de treinamento ou usando um **cronograma de taxa de aprendizado** mais complexo.
+
+## Diferentes Arquiteturas de Redes
+
+Selecionar a arquitetura de rede certa para o seu problema pode ser complicado. Normalmente, escolheríamos uma arquitetura que tenha se mostrado eficaz para nossa tarefa específica (ou uma similar). Aqui está uma [boa visão geral](https://www.topbots.com/a-brief-history-of-neural-network-architectures/) de arquiteturas de redes neurais para visão computacional.
+
+> É importante selecionar uma arquitetura que seja poderosa o suficiente para o número de amostras de treinamento que temos. Selecionar um modelo muito poderoso pode resultar em [overfitting](../../3-NeuralNetworks/05-Frameworks/Overfitting.md).
+
+Outra boa abordagem seria usar uma arquitetura que se ajuste automaticamente à complexidade necessária. Até certo ponto, as arquiteturas **ResNet** e **Inception** são autoajustáveis. [Mais sobre arquiteturas para visão computacional](../07-ConvNets/CNN_Architectures.md)
+
+**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.