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

translations/pt-PT/lessons/3-NeuralNetworks/05-Frameworks/README.md

@@ -0,0 +1,123 @@
+# Frameworks de Redes Neuronais
+
+Como já aprendemos, para treinar redes neuronais de forma eficiente, precisamos fazer duas coisas:
+
+* Operar com tensores, por exemplo, multiplicar, somar e calcular algumas funções como sigmoid ou softmax.
+* Calcular os gradientes de todas as expressões, para realizar a otimização por descida de gradiente.
+
+## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/9)
+
+Embora a biblioteca `numpy` consiga realizar a primeira parte, precisamos de um mecanismo para calcular gradientes. No [nosso framework](../04-OwnFramework/OwnFramework.ipynb) que desenvolvemos na seção anterior, tivemos que programar manualmente todas as funções derivadas dentro do método `backward`, que realiza a retropropagação. Idealmente, um framework deveria permitir-nos calcular os gradientes de *qualquer expressão* que possamos definir.
+
+Outro ponto importante é a capacidade de realizar cálculos em GPU ou outras unidades de computação especializadas, como [TPU](https://en.wikipedia.org/wiki/Tensor_Processing_Unit). O treino de redes neuronais profundas exige *muitos* cálculos, e poder paralelizar esses cálculos em GPUs é fundamental.
+
+> ✅ O termo 'paralelizar' significa distribuir os cálculos por vários dispositivos.
+
+Atualmente, os dois frameworks de redes neuronais mais populares são: [TensorFlow](http://TensorFlow.org) e [PyTorch](https://pytorch.org/). Ambos oferecem uma API de baixo nível para operar com tensores tanto em CPU quanto em GPU. Além da API de baixo nível, também existe uma API de alto nível, chamada [Keras](https://keras.io/) e [PyTorch Lightning](https://pytorchlightning.ai/), respetivamente.
+
+API de Baixo Nível | [TensorFlow](http://TensorFlow.org) | [PyTorch](https://pytorch.org/)
+--------------------|-------------------------------------|--------------------------------
+API de Alto Nível   | [Keras](https://keras.io/)         | [PyTorch Lightning](https://pytorchlightning.ai/)
+
+**APIs de baixo nível** em ambos os frameworks permitem construir os chamados **grafos computacionais**. Este grafo define como calcular o resultado (geralmente a função de perda) com os parâmetros de entrada fornecidos e pode ser enviado para cálculo em GPU, se disponível. Existem funções para diferenciar este grafo computacional e calcular gradientes, que podem ser usados para otimizar os parâmetros do modelo.
+
+**APIs de alto nível** consideram redes neuronais como uma **sequência de camadas**, facilitando muito a construção da maioria das redes neuronais. Treinar o modelo geralmente requer preparar os dados e, em seguida, chamar uma função `fit` para realizar o trabalho.
+
+A API de alto nível permite construir redes neuronais típicas de forma muito rápida, sem se preocupar com muitos detalhes. Por outro lado, a API de baixo nível oferece muito mais controlo sobre o processo de treino e, por isso, é amplamente utilizada em pesquisa, quando se trabalha com novas arquiteturas de redes neuronais.
+
+É também importante entender que ambas as APIs podem ser usadas em conjunto. Por exemplo, pode-se desenvolver a arquitetura de uma camada de rede usando a API de baixo nível e, em seguida, utilizá-la dentro de uma rede maior construída e treinada com a API de alto nível. Ou pode-se definir uma rede usando a API de alto nível como uma sequência de camadas e, depois, usar o próprio loop de treino de baixo nível para realizar a otimização. Ambas as APIs utilizam os mesmos conceitos básicos subjacentes e foram projetadas para funcionar bem juntas.
+
+## Aprendizagem
+
+Neste curso, oferecemos a maior parte do conteúdo tanto para PyTorch quanto para TensorFlow. Pode escolher o framework preferido e seguir apenas os notebooks correspondentes. Se não tiver certeza de qual framework escolher, leia algumas discussões na internet sobre **PyTorch vs. TensorFlow**. Também pode explorar ambos os frameworks para obter uma melhor compreensão.
+
+Sempre que possível, utilizaremos APIs de alto nível para simplificar. No entanto, acreditamos que é importante entender como as redes neuronais funcionam desde o início, por isso começamos trabalhando com a API de baixo nível e tensores. Contudo, se quiser avançar rapidamente e não gastar muito tempo aprendendo esses detalhes, pode ignorar essa parte e ir diretamente para os notebooks de API de alto nível.
+
+## ✍️ Exercícios: Frameworks
+
+Continue a sua aprendizagem nos seguintes notebooks:
+
+API de Baixo Nível | [Notebook TensorFlow+Keras](IntroKerasTF.ipynb) | [PyTorch](IntroPyTorch.ipynb)
+--------------------|-------------------------------------|--------------------------------
+API de Alto Nível   | [Keras](IntroKeras.ipynb)         | *PyTorch Lightning*
+
+Depois de dominar os frameworks, vamos recapitular o conceito de overfitting.
+
+# Overfitting
+
+Overfitting é um conceito extremamente importante em aprendizagem automática, e é essencial compreendê-lo corretamente!
+
+Considere o seguinte problema de aproximar 5 pontos (representados por `x` nos gráficos abaixo):
+
+![linear](../../../../../translated_images/pt-PT/overfit1.f24b71c6f652e59e.webp) | ![overfit](../../../../../translated_images/pt-PT/overfit2.131f5800ae10ca5e.webp)
+-------------------------|--------------------------
+**Modelo linear, 2 parâmetros** | **Modelo não-linear, 7 parâmetros**
+Erro de treino = 5.3 | Erro de treino = 0
+Erro de validação = 5.1 | Erro de validação = 20
+
+* À esquerda, vemos uma boa aproximação com uma linha reta. Como o número de parâmetros é adequado, o modelo compreende corretamente a distribuição dos pontos.
+* À direita, o modelo é demasiado poderoso. Como temos apenas 5 pontos e o modelo possui 7 parâmetros, ele ajusta-se de forma a passar por todos os pontos, fazendo com que o erro de treino seja 0. No entanto, isso impede o modelo de entender o padrão correto dos dados, resultando num erro de validação muito alto.
+
+É muito importante encontrar o equilíbrio correto entre a complexidade do modelo (número de parâmetros) e o número de amostras de treino.
+
+## Por que ocorre o overfitting
+
+  * Poucos dados de treino
+  * Modelo demasiado poderoso
+  * Demasiado ruído nos dados de entrada
+
+## Como detetar o overfitting
+
+Como pode ver no gráfico acima, o overfitting pode ser detetado por um erro de treino muito baixo e um erro de validação elevado. Normalmente, durante o treino, vemos tanto os erros de treino quanto de validação começarem a diminuir, e então, em algum momento, o erro de validação pode parar de diminuir e começar a aumentar. Este será um sinal de overfitting e um indicador de que provavelmente devemos parar o treino nesse ponto (ou pelo menos fazer um snapshot do modelo).
+
+![overfitting](../../../../../translated_images/pt-PT/Overfitting.408ad91cd90b4371.webp)
+
+## Como prevenir o overfitting
+
+Se perceber que o overfitting está a ocorrer, pode fazer o seguinte:
+
+ * Aumentar a quantidade de dados de treino.
+ * Reduzir a complexidade do modelo.
+ * Utilizar alguma [técnica de regularização](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md), como [Dropout](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md#Dropout), que será abordada mais tarde.
+
+## Overfitting e o Tradeoff Viés-Variância
+
+O overfitting é, na verdade, um caso de um problema mais genérico em estatística chamado [Tradeoff Viés-Variância](https://en.wikipedia.org/wiki/Bias%E2%80%93variance_tradeoff). Se considerarmos as possíveis fontes de erro no nosso modelo, podemos identificar dois tipos de erros:
+
+* **Erros de viés** são causados pelo nosso algoritmo não conseguir capturar corretamente a relação entre os dados de treino. Isso pode resultar do facto de o modelo não ser suficientemente poderoso (**underfitting**).
+* **Erros de variância**, que são causados pelo modelo aproximar o ruído nos dados de entrada em vez de uma relação significativa (**overfitting**).
+
+Durante o treino, o erro de viés diminui (à medida que o modelo aprende a aproximar os dados) e o erro de variância aumenta. É importante parar o treino - seja manualmente (quando detetamos overfitting) ou automaticamente (introduzindo regularização) - para evitar o overfitting.
+
+## Conclusão
+
+Nesta lição, aprendeu sobre as diferenças entre as várias APIs dos dois frameworks de IA mais populares, TensorFlow e PyTorch. Além disso, aprendeu sobre um tópico muito importante: overfitting.
+
+## 🚀 Desafio
+
+Nos notebooks que acompanham esta lição, encontrará 'tarefas' no final; trabalhe nos notebooks e complete as tarefas.
+
+## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/10)
+
+## Revisão & Autoestudo
+
+Pesquise sobre os seguintes tópicos:
+
+- TensorFlow
+- PyTorch
+- Overfitting
+
+Pergunte a si mesmo as seguintes questões:
+
+- Qual é a diferença entre TensorFlow e PyTorch?
+- Qual é a diferença entre overfitting e underfitting?
+
+## [Trabalho prático](lab/README.md)
+
+Neste trabalho prático, será solicitado que resolva dois problemas de classificação usando redes totalmente conectadas de uma ou várias camadas, utilizando PyTorch ou TensorFlow.
+
+* [Instruções](lab/README.md)
+* [Notebook](lab/LabFrameworks.ipynb)
+
+---
+

translations/pt-PT/lessons/3-NeuralNetworks/05-Frameworks/lab/README.md

@@ -0,0 +1,19 @@
+# Classificação com PyTorch/TensorFlow
+
+Trabalho prático do [Currículo de IA para Iniciantes](https://github.com/microsoft/ai-for-beginners).
+
+## Tarefa
+
+Resolva dois problemas de classificação utilizando redes totalmente conectadas de uma e várias camadas com PyTorch ou TensorFlow:
+
+1. Problema de **[classificação de íris](https://en.wikipedia.org/wiki/Iris_flower_data_set)** - um exemplo de problema com dados tabulares de entrada, que pode ser resolvido com aprendizagem automática clássica. O teu objetivo será classificar íris em 3 classes, com base em 4 parâmetros numéricos.
+1. Problema de classificação de dígitos manuscritos **MNIST**, que já vimos anteriormente.
+
+Experimente diferentes arquiteturas de rede para alcançar a melhor precisão possível.
+
+## Notebook Inicial
+
+Comece o trabalho prático abrindo [LabFrameworks.ipynb](../../../../../../lessons/3-NeuralNetworks/05-Frameworks/lab/LabFrameworks.ipynb)
+
+**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 no seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se uma tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes do uso desta tradução.

translations/pt-PT/lessons/3-NeuralNetworks/README.md

@@ -0,0 +1,53 @@
+# Introdução às Redes Neuronais
+
+![Resumo do conteúdo de Introdução às Redes Neuronais em um desenho](../../../../translated_images/pt-PT/ai-neuralnetworks.1c687ae40bc86e83.webp)
+
+Como discutimos na introdução, uma das formas de alcançar inteligência é treinar um **modelo computacional** ou um **cérebro artificial**. Desde meados do século XX, os investigadores experimentaram diferentes modelos matemáticos, até que, nos últimos anos, esta abordagem provou ser extremamente bem-sucedida. Esses modelos matemáticos do cérebro são chamados de **redes neuronais**.
+
+> Às vezes, as redes neuronais são chamadas de *Redes Neuronais Artificiais* (Artificial Neural Networks, ANNs), para indicar que estamos a falar de modelos, e não de redes reais de neurónios.
+
+## Aprendizagem Automática
+
+As Redes Neuronais fazem parte de uma disciplina mais ampla chamada **Aprendizagem Automática** (Machine Learning), cujo objetivo é usar dados para treinar modelos computacionais capazes de resolver problemas. A Aprendizagem Automática constitui uma grande parte da Inteligência Artificial; no entanto, não abordamos a aprendizagem automática clássica neste currículo.
+
+> Visite o nosso currículo separado **[Aprendizagem Automática para Iniciantes](http://github.com/microsoft/ml-for-beginners)** para aprender mais sobre a Aprendizagem Automática clássica.
+
+Na Aprendizagem Automática, assumimos que temos um conjunto de dados de exemplos **X** e os valores de saída correspondentes **Y**. Os exemplos são frequentemente vetores N-dimensionais que consistem em **características**, e as saídas são chamadas de **rótulos**.
+
+Consideraremos os dois problemas mais comuns da aprendizagem automática:
+
+* **Classificação**, onde precisamos classificar um objeto de entrada em duas ou mais classes.
+* **Regressão**, onde precisamos prever um valor numérico para cada uma das amostras de entrada.
+
+> Ao representar entradas e saídas como tensores, o conjunto de dados de entrada é uma matriz de tamanho M×N, onde M é o número de amostras e N é o número de características. Os rótulos de saída **Y** são um vetor de tamanho M.
+
+Neste currículo, focar-nos-emos apenas em modelos de redes neuronais.
+
+## Um Modelo de Neurónio
+
+Na biologia, sabemos que o nosso cérebro é composto por células neuronais (neurónios), cada uma delas com múltiplas "entradas" (dendritos) e uma única "saída" (axónio). Tanto os dendritos como os axónios podem conduzir sinais elétricos, e as conexões entre eles — conhecidas como sinapses — podem apresentar diferentes graus de condutividade, que são regulados por neurotransmissores.
+
+![Modelo de um Neurónio](../../../../translated_images/pt-PT/synapse-wikipedia.ed20a9e4726ea1c6.webp) | ![Modelo de um Neurónio](../../../../translated_images/pt-PT/artneuron.1a5daa88d20ebe6f.webp)
+----|----
+Neurónio Real *([Imagem](https://en.wikipedia.org/wiki/Synapse#/media/File:SynapseSchematic_lines.svg) da Wikipédia)* | Neurónio Artificial *(Imagem do Autor)*
+
+Assim, o modelo matemático mais simples de um neurónio contém várias entradas X<sub>1</sub>, ..., X<sub>N</sub> e uma saída Y, e uma série de pesos W<sub>1</sub>, ..., W<sub>N</sub>. A saída é calculada como:
+
+<img src="../../../../translated_images/pt-PT/netout.1eb15eb76fd76731.webp" alt="Y = f\left(\sum_{i=1}^N X_iW_i\right)" width="131" height="53" align="center"/>
+
+onde **f** é uma **função de ativação** não linear.
+
+> Os primeiros modelos de neurónio foram descritos no artigo clássico [A logical calculus of the ideas immanent in nervous activity](https://www.cs.cmu.edu/~./epxing/Class/10715/reading/McCulloch.and.Pitts.pdf) por Warren McCullock e Walter Pitts em 1943. Donald Hebb, no seu livro "[The Organization of Behavior: A Neuropsychological Theory](https://books.google.com/books?id=VNetYrB8EBoC)", propôs uma forma de treinar essas redes.
+
+## Nesta Secção
+
+Nesta secção, aprenderemos sobre:
+* [Perceptron](03-Perceptron/README.md), um dos primeiros modelos de redes neuronais para classificação binária
+* [Redes com múltiplas camadas](04-OwnFramework/README.md) com um notebook associado [como construir o nosso próprio framework](04-OwnFramework/OwnFramework.ipynb)
+* [Frameworks de Redes Neuronais](05-Frameworks/README.md), com estes notebooks: [PyTorch](05-Frameworks/IntroPyTorch.ipynb) e [Keras/Tensorflow](05-Frameworks/IntroKerasTF.ipynb)
+* [Overfitting](../../../../lessons/3-NeuralNetworks/05-Frameworks)
+
+---
+
+**Aviso**:  
+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 pela precisão, é importante notar 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 da utilização desta tradução.

translations/pt-PT/lessons/4-ComputerVision/06-IntroCV/README.md

@@ -0,0 +1,112 @@
+# Introdução à Visão Computacional
+
+[Visão Computacional](https://wikipedia.org/wiki/Computer_vision) é uma disciplina cujo objetivo é permitir que os computadores obtenham uma compreensão de alto nível de imagens digitais. Esta é uma definição bastante ampla, pois *compreensão* pode significar muitas coisas diferentes, incluindo encontrar um objeto numa imagem (**detecção de objetos**), entender o que está a acontecer (**detecção de eventos**), descrever uma imagem em texto ou reconstruir uma cena em 3D. Existem também tarefas específicas relacionadas a imagens humanas: estimativa de idade e emoções, deteção e identificação de rostos, e estimativa de pose em 3D, entre outras.
+
+## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/11)
+
+Uma das tarefas mais simples da visão computacional é a **classificação de imagens**.
+
+A visão computacional é frequentemente considerada um ramo da IA. Atualmente, a maioria das tarefas de visão computacional é resolvida utilizando redes neuronais. Vamos aprender mais sobre o tipo especial de redes neuronais usadas para visão computacional, [redes neuronais convolucionais](../07-ConvNets/README.md), ao longo desta secção.
+
+No entanto, antes de passar a imagem para uma rede neuronal, em muitos casos faz sentido usar algumas técnicas algorítmicas para melhorar a imagem.
+
+Existem várias bibliotecas Python disponíveis para processamento de imagens:
+
+* **[imageio](https://imageio.readthedocs.io/en/stable/)** pode ser usada para ler/escrever diferentes formatos de imagem. Também suporta ffmpeg, uma ferramenta útil para converter frames de vídeo em imagens.
+* **[Pillow](https://pillow.readthedocs.io/en/stable/index.html)** (também conhecida como PIL) é um pouco mais poderosa e também suporta manipulação de imagens, como morphing, ajustes de paleta e mais.
+* **[OpenCV](https://opencv.org/)** é uma biblioteca de processamento de imagens poderosa escrita em C++, que se tornou o padrão *de facto* para processamento de imagens. Possui uma interface conveniente em Python.
+* **[dlib](http://dlib.net/)** é uma biblioteca C++ que implementa muitos algoritmos de aprendizagem automática, incluindo alguns algoritmos de Visão Computacional. Também possui uma interface em Python e pode ser usada para tarefas desafiadoras, como deteção de rostos e pontos de referência faciais.
+
+## OpenCV
+
+[OpenCV](https://opencv.org/) é considerado o padrão *de facto* para processamento de imagens. Contém muitos algoritmos úteis, implementados em C++. Pode-se usar o OpenCV a partir de Python também.
+
+Um bom lugar para aprender OpenCV é [este curso Learn OpenCV](https://learnopencv.com/getting-started-with-opencv/). No nosso currículo, o objetivo não é aprender OpenCV, mas mostrar alguns exemplos de quando ele pode ser usado e como.
+
+### Carregar Imagens
+
+Imagens em Python podem ser convenientemente representadas por arrays NumPy. Por exemplo, imagens em escala de cinza com tamanho de 320x200 pixels seriam armazenadas num array 200x320, e imagens coloridas da mesma dimensão teriam a forma 200x320x3 (para 3 canais de cor). Para carregar uma imagem, pode usar o seguinte código:
+
+```python
+import cv2
+import matplotlib.pyplot as plt
+
+im = cv2.imread('image.jpeg')
+plt.imshow(im)
+```
+
+Tradicionalmente, o OpenCV usa codificação BGR (Azul-Verde-Vermelho) para imagens coloridas, enquanto o restante das ferramentas Python usa a mais tradicional RGB (Vermelho-Verde-Azul). Para que a imagem seja exibida corretamente, é necessário convertê-la para o espaço de cores RGB, seja trocando as dimensões no array NumPy ou chamando uma função do OpenCV:
+
+```python
+im = cv2.cvtColor(im,cv2.COLOR_BGR2RGB)
+```
+
+A mesma função `cvtColor` pode ser usada para realizar outras transformações de espaço de cores, como converter uma imagem para escala de cinza ou para o espaço de cores HSV (Matiz-Saturação-Valor).
+
+Também pode usar o OpenCV para carregar frames de vídeo um a um - um exemplo é dado no exercício [OpenCV Notebook](OpenCV.ipynb).
+
+### Processamento de Imagens
+
+Antes de alimentar uma imagem numa rede neuronal, pode querer aplicar vários passos de pré-processamento. O OpenCV pode fazer muitas coisas, incluindo:
+
+* **Redimensionar** a imagem usando `im = cv2.resize(im, (320,200),interpolation=cv2.INTER_LANCZOS)`
+* **Desfocar** a imagem usando `im = cv2.medianBlur(im,3)` ou `im = cv2.GaussianBlur(im, (3,3), 0)`
+* Alterar o **brilho e contraste** da imagem pode ser feito através de manipulações de arrays NumPy, conforme descrito [nesta nota do Stackoverflow](https://stackoverflow.com/questions/39308030/how-do-i-increase-the-contrast-of-an-image-in-python-opencv).
+* Usar [thresholding](https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html) chamando as funções `cv2.threshold`/`cv2.adaptiveThreshold`, que muitas vezes é preferível a ajustar brilho ou contraste.
+* Aplicar diferentes [transformações](https://docs.opencv.org/4.5.5/da/d6e/tutorial_py_geometric_transformations.html) à imagem:
+    - **[Transformações Afins](https://docs.opencv.org/4.5.5/d4/d61/tutorial_warp_affine.html)** podem ser úteis se precisar combinar rotação, redimensionamento e inclinação na imagem e souber a localização de origem e destino de três pontos na imagem. Transformações afins mantêm linhas paralelas paralelas.
+    - **[Transformações de Perspetiva](https://medium.com/analytics-vidhya/opencv-perspective-transformation-9edffefb2143)** podem ser úteis quando se conhece as posições de origem e destino de 4 pontos na imagem. Por exemplo, se tirar uma foto de um documento retangular com uma câmara de smartphone de algum ângulo e quiser criar uma imagem retangular do próprio documento.
+* Compreender o movimento dentro da imagem usando **[fluxo ótico](https://docs.opencv.org/4.5.5/d4/dee/tutorial_optical_flow.html)**.
+
+## Exemplos de uso da Visão Computacional
+
+No nosso [OpenCV Notebook](OpenCV.ipynb), damos alguns exemplos de quando a visão computacional pode ser usada para realizar tarefas específicas:
+
+* **Pré-processamento de uma fotografia de um livro em Braille**. Focamos em como podemos usar thresholding, deteção de características, transformação de perspetiva e manipulações NumPy para separar símbolos individuais em Braille para posterior classificação por uma rede neuronal.
+
+![Imagem Braille](../../../../../translated_images/pt-PT/braille.341962ff76b1bd70.webp) | ![Imagem Braille Pré-processada](../../../../../translated_images/pt-PT/braille-result.46530fea020b03c7.webp) | ![Símbolos Braille](../../../../../translated_images/pt-PT/braille-symbols.0159185ab69d5339.webp)
+----|-----|-----
+
+> Imagem de [OpenCV.ipynb](OpenCV.ipynb)
+
+* **Deteção de movimento em vídeo usando diferença de frames**. Se a câmara estiver fixa, os frames do feed da câmara devem ser bastante semelhantes entre si. Como os frames são representados como arrays, apenas subtraindo esses arrays de dois frames subsequentes obteremos a diferença de pixels, que deve ser baixa para frames estáticos e tornar-se maior quando houver movimento substancial na imagem.
+
+![Imagem de frames de vídeo e diferenças de frames](../../../../../translated_images/pt-PT/frame-difference.706f805491a0883c.webp)
+
+> Imagem de [OpenCV.ipynb](OpenCV.ipynb)
+
+* **Deteção de movimento usando Fluxo Ótico**. [Fluxo ótico](https://docs.opencv.org/3.4/d4/dee/tutorial_optical_flow.html) permite entender como os pixels individuais nos frames de vídeo se movem. Existem dois tipos de fluxo ótico:
+
+   - **Fluxo Ótico Denso** calcula o campo vetorial que mostra para cada pixel onde ele está a mover-se.
+   - **Fluxo Ótico Esparso** baseia-se em tomar algumas características distintivas na imagem (por exemplo, bordas) e construir a sua trajetória de frame para frame.
+
+![Imagem de Fluxo Ótico](../../../../../translated_images/pt-PT/optical.1f4a94464579a83a.webp)
+
+> Imagem de [OpenCV.ipynb](OpenCV.ipynb)
+
+## ✍️ Notebooks de Exemplo: OpenCV [experimente OpenCV em ação](OpenCV.ipynb)
+
+Vamos fazer algumas experiências com OpenCV explorando [OpenCV Notebook](OpenCV.ipynb)
+
+## Conclusão
+
+Por vezes, tarefas relativamente complexas, como deteção de movimento ou deteção de ponta dos dedos, podem ser resolvidas puramente por visão computacional. Assim, é muito útil conhecer as técnicas básicas de visão computacional e o que bibliotecas como OpenCV podem fazer.
+
+## 🚀 Desafio
+
+Assista a [este vídeo](https://docs.microsoft.com/shows/ai-show/ai-show--2021-opencv-ai-competition--grand-prize-winners--cortic-tigers--episode-32?WT.mc_id=academic-77998-cacaste) do AI Show para aprender sobre o projeto Cortic Tigers e como eles construíram uma solução baseada em blocos para democratizar tarefas de visão computacional através de um robô. Faça uma pesquisa sobre outros projetos como este que ajudam novos aprendizes a entrar no campo.
+
+## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/12)
+
+## Revisão & Autoestudo
+
+Leia mais sobre fluxo ótico [neste excelente tutorial](https://learnopencv.com/optical-flow-in-opencv/).
+
+## [Tarefa](lab/README.md)
+
+Neste laboratório, irá gravar um vídeo com gestos simples, e o seu objetivo será extrair movimentos para cima/baixo/esquerda/direita usando fluxo ótico.
+
+<img src="../../../../../translated_images/pt-PT/palm-movement.341495f0e9c47da3.webp" width="30%" alt="Frame de Movimento da Palma"/>
+
+---
+

translations/pt-PT/lessons/4-ComputerVision/06-IntroCV/lab/MovementDetection.ipynb

@@ -0,0 +1,108 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Detecção de Movimento da Palma usando Fluxo Óptico\n",
+    "\n",
+    "Este laboratório faz parte do [Currículo de IA para Iniciantes](http://aka.ms/ai-beginners).\n",
+    "\n",
+    "Considere [este vídeo](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/palm-movement.mp4), no qual a palma de uma pessoa se move para a esquerda/direita/cima/baixo sobre um fundo estável.\n",
+    "\n",
+    "**O seu objetivo** será usar Fluxo Óptico para determinar quais partes do vídeo contêm movimentos para cima/baixo/esquerda/direita.\n",
+    "\n",
+    "Comece por obter os frames do vídeo conforme descrito na aula:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Code here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Agora, calcula os fotogramas de fluxo ótico denso conforme descrito na aula e converte o fluxo ótico denso para coordenadas polares:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Code here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Construa um histograma de direções para cada frame do fluxo óptico. Um histograma mostra quantos vetores se enquadram em determinados intervalos e deve separar as diferentes direções de movimento no frame.\n",
+    "\n",
+    "> Também pode ser útil eliminar todos os vetores cuja magnitude esteja abaixo de um determinado limite. Isso ajudará a remover pequenos movimentos extras no vídeo, como olhos e cabeça.\n",
+    "\n",
+    "Faça o gráfico dos histogramas para alguns dos frames.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Code here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ao observar os histogramas, deve ser bastante simples determinar a direção do movimento. É necessário selecionar os intervalos que correspondem às direções cima/baixo/esquerda/direita e que estão acima de um determinado limite.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Code here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Parabéns! Se concluíste todos os passos acima, terminaste o laboratório!\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n---\n\n**Aviso Legal**:  \nEste 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 notar 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 da utilização desta tradução.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  },
+  "orig_nbformat": 4,
+  "coopTranslator": {
+   "original_hash": "153d9e417e079bf62f8f693002d0deaf",
+   "translation_date": "2025-08-31T11:42:50+00:00",
+   "source_file": "lessons/4-ComputerVision/06-IntroCV/lab/MovementDetection.ipynb",
+   "language_code": "pt"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

translations/pt-PT/lessons/4-ComputerVision/06-IntroCV/lab/README.md

@@ -0,0 +1,22 @@
+# Deteção de Movimentos usando Optical Flow
+
+Trabalho prático do [Currículo de IA para Iniciantes](https://aka.ms/ai-beginners).
+
+## Tarefa
+
+Considere [este vídeo](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/palm-movement.mp4), no qual a palma da mão de uma pessoa se move para a esquerda/direita/cima/baixo num fundo estável.
+
+**O seu objetivo** será usar Optical Flow para determinar quais partes do vídeo contêm movimentos para cima/baixo/esquerda/direita.
+
+**Objetivo adicional** seria rastrear efetivamente o movimento da palma/dedo utilizando o tom de pele, como descrito [neste artigo](https://dev.to/amarlearning/finger-detection-and-tracking-using-opencv-and-python-586m) ou [aqui](http://www.benmeline.com/finger-tracking-with-opencv-and-python/).
+
+## Notebook Inicial
+
+Comece o trabalho prático abrindo [MovementDetection.ipynb](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/MovementDetection.ipynb)
+
+## Conclusão
+
+Por vezes, tarefas relativamente complexas, como deteção de movimento ou deteção da ponta do dedo, podem ser resolvidas apenas com visão por computador. Por isso, é muito útil saber o que bibliotecas como OpenCV podem fazer.
+
+**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 pela 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/07-ConvNets/CNN_Architectures.md

@@ -0,0 +1,64 @@
+# Arquiteturas Conhecidas de CNN
+
+### VGG-16
+
+VGG-16 é uma rede que alcançou 92,7% de precisão na classificação top-5 do ImageNet em 2014. Tem a seguinte estrutura de camadas:
+
+![Camadas do ImageNet](../../../../../translated_images/pt-PT/vgg-16-arch1.d901a5583b3a51ba.webp)
+
+Como pode ver, a VGG segue uma arquitetura tradicional em pirâmide, que consiste numa sequência de camadas de convolução e pooling.
+
+![Pirâmide do ImageNet](../../../../../translated_images/pt-PT/vgg-16-arch.64ff2137f50dd49f.webp)
+
+> Imagem de [Researchgate](https://www.researchgate.net/figure/Vgg16-model-structure-To-get-the-VGG-NIN-model-we-replace-the-2-nd-4-th-6-th-7-th_fig2_335194493)
+
+### ResNet
+
+ResNet é uma família de modelos proposta pela Microsoft Research em 2015. A ideia principal da ResNet é utilizar **blocos residuais**:
+
+<img src="../../../../../translated_images/pt-PT/resnet-block.aba4ccbcc0944434.webp" width="300"/>
+
+> Imagem retirada [deste artigo](https://arxiv.org/pdf/1512.03385.pdf)
+
+A razão para usar a passagem de identidade é fazer com que a camada preveja **a diferença** entre o resultado de uma camada anterior e a saída do bloco residual - daí o nome *residual*. Estes blocos são muito mais fáceis de treinar, e é possível construir redes com centenas destes blocos (as variantes mais comuns são ResNet-52, ResNet-101 e ResNet-152).
+
+Pode também pensar nesta rede como sendo capaz de ajustar a sua complexidade ao conjunto de dados. Inicialmente, quando começa a treinar a rede, os valores dos pesos são pequenos, e a maior parte do sinal passa pelas camadas de identidade. À medida que o treino avança e os pesos se tornam maiores, a importância dos parâmetros da rede cresce, e a rede ajusta-se para acomodar o poder expressivo necessário para classificar corretamente as imagens de treino.
+
+### Google Inception
+
+A arquitetura Google Inception leva esta ideia um passo mais além e constrói cada camada da rede como uma combinação de vários caminhos diferentes:
+
+<img src="../../../../../translated_images/pt-PT/inception.a6605b85bcbc6f52.webp" width="400"/>
+
+> Imagem de [Researchgate](https://www.researchgate.net/figure/Inception-module-with-dimension-reductions-left-and-schema-for-Inception-ResNet-v1_fig2_355547454)
+
+Aqui, é importante destacar o papel das convoluções 1x1, porque à primeira vista não fazem sentido. Por que razão precisaríamos de passar pela imagem com um filtro 1x1? No entanto, é necessário lembrar que os filtros de convolução também trabalham com vários canais de profundidade (originalmente - cores RGB, em camadas subsequentes - canais para diferentes filtros), e a convolução 1x1 é usada para misturar esses canais de entrada utilizando diferentes pesos treináveis. Pode também ser vista como uma redução dimensional (pooling) sobre a dimensão dos canais.
+
+Aqui está [um bom artigo](https://medium.com/analytics-vidhya/talented-mr-1x1-comprehensive-look-at-1x1-convolution-in-deep-learning-f6b355825578) sobre o assunto, e [o artigo original](https://arxiv.org/pdf/1312.4400.pdf).
+
+### MobileNet
+
+MobileNet é uma família de modelos com tamanho reduzido, adequada para dispositivos móveis. Utilize-os se tiver poucos recursos e puder sacrificar um pouco de precisão. A ideia principal por trás destes modelos é a chamada **convolução separável por profundidade**, que permite representar filtros de convolução através de uma composição de convoluções espaciais e convoluções 1x1 sobre os canais de profundidade. Isto reduz significativamente o número de parâmetros, tornando a rede menor em tamanho e também mais fácil de treinar com menos dados.
+
+Aqui está [um bom artigo sobre MobileNet](https://medium.com/analytics-vidhya/image-classification-with-mobilenet-cc6fbb2cd470).
+
+## Conclusão
+
+Nesta unidade, aprendeu o conceito principal por trás das redes neurais de visão computacional - redes convolucionais. Arquiteturas reais que alimentam classificação de imagens, deteção de objetos e até redes de geração de imagens são todas baseadas em CNNs, apenas com mais camadas e alguns truques adicionais de treino.
+
+## 🚀 Desafio
+
+Nos notebooks que acompanham esta unidade, há notas no final sobre como obter maior precisão. Faça alguns experimentos para ver se consegue alcançar uma precisão mais elevada.
+
+## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/14)
+
+## Revisão e Autoestudo
+
+Embora as CNNs sejam mais frequentemente usadas para tarefas de Visão Computacional, elas são geralmente boas para extrair padrões de tamanho fixo. Por exemplo, se estivermos a lidar com sons, também podemos querer usar CNNs para procurar padrões específicos no sinal de áudio - neste caso, os filtros seriam unidimensionais (e esta CNN seria chamada de 1D-CNN). Além disso, às vezes utiliza-se 3D-CNN para extrair características em espaço multidimensional, como certos eventos que ocorrem em vídeos - a CNN pode capturar certos padrões de mudança de características ao longo do tempo. Faça uma revisão e autoestudo sobre outras tarefas que podem ser realizadas com CNNs.
+
+## [Tarefa](lab/README.md)
+
+Neste laboratório, a sua tarefa é classificar diferentes raças de gatos e cães. Estas imagens são mais complexas do que o conjunto de dados MNIST, têm dimensões mais elevadas e há mais de 10 classes.
+
+---
+

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

@@ -0,0 +1,60 @@
+# Redes Neuronais Convolucionais
+
+Já vimos anteriormente que as redes neuronais são bastante eficazes a lidar com imagens, e até mesmo um perceptron de uma camada consegue reconhecer dígitos manuscritos do conjunto de dados MNIST com uma precisão razoável. No entanto, o conjunto de dados MNIST é muito especial, pois todos os dígitos estão centrados na imagem, o que torna a tarefa mais simples.
+
+## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/13)
+
+Na vida real, queremos ser capazes de reconhecer objetos numa imagem independentemente da sua localização exata. A visão computacional é diferente da classificação genérica, porque, ao tentar encontrar um determinado objeto na imagem, estamos a analisar a imagem em busca de **padrões** específicos e das suas combinações. Por exemplo, ao procurar um gato, podemos começar por procurar linhas horizontais, que podem formar os bigodes, e depois uma certa combinação de bigodes pode indicar que se trata de uma imagem de um gato. A posição relativa e a presença de certos padrões são importantes, e não a sua posição exata na imagem.
+
+Para extrair padrões, utilizaremos o conceito de **filtros convolucionais**. Como sabe, uma imagem é representada por uma matriz 2D ou um tensor 3D com profundidade de cor. Aplicar um filtro significa que utilizamos uma matriz relativamente pequena chamada **kernel do filtro**, e para cada pixel na imagem original calculamos a média ponderada com os pontos vizinhos. Podemos imaginar isto como uma pequena janela que desliza sobre toda a imagem, e que calcula a média de todos os pixels de acordo com os pesos na matriz kernel do filtro.
+
+![Filtro de Borda Vertical](../../../../../translated_images/pt-PT/filter-vert.b7148390ca0bc356.webp) | ![Filtro de Borda Horizontal](../../../../../translated_images/pt-PT/filter-horiz.59b80ed4feb946ef.webp)
+----|----
+
+> Imagem por Dmitry Soshnikov
+
+Por exemplo, se aplicarmos filtros de borda vertical e horizontal de 3x3 aos dígitos do MNIST, podemos obter realces (por exemplo, valores altos) onde existem bordas verticais e horizontais na imagem original. Assim, esses dois filtros podem ser usados para "procurar" bordas. Da mesma forma, podemos projetar diferentes filtros para procurar outros padrões de baixo nível:
+
+<img src="../../../../../translated_images/pt-PT/lmfilters.ea9e4868a82cf74c.webp" width="500" align="center"/>
+
+> Imagem do [Leung-Malik Filter Bank](https://www.robots.ox.ac.uk/~vgg/research/texclass/filters.html)
+
+No entanto, embora possamos projetar os filtros manualmente para extrair alguns padrões, também podemos projetar a rede de forma a que ela aprenda os padrões automaticamente. Esta é uma das principais ideias por trás das CNN.
+
+## Ideias principais das CNN
+
+O funcionamento das CNN baseia-se nas seguintes ideias importantes:
+
+* Os filtros convolucionais podem extrair padrões
+* Podemos projetar a rede de forma a que os filtros sejam treinados automaticamente
+* Podemos usar a mesma abordagem para encontrar padrões em características de alto nível, não apenas na imagem original. Assim, a extração de características pelas CNN funciona numa hierarquia de características, começando por combinações de pixels de baixo nível até combinações de partes da imagem de nível mais alto.
+
+![Extração Hierárquica de Características](../../../../../translated_images/pt-PT/FeatureExtractionCNN.d9b456cbdae7cb64.webp)
+
+> Imagem de [um artigo de Hislop-Lynch](https://www.semanticscholar.org/paper/Computer-vision-based-pedestrian-trajectory-Hislop-Lynch/26e6f74853fc9bbb7487b06dc2cf095d36c9021d), baseado na [sua pesquisa](https://dl.acm.org/doi/abs/10.1145/1553374.1553453)
+
+## ✍️ Exercícios: Redes Neuronais Convolucionais
+
+Vamos continuar a explorar como funcionam as redes neuronais convolucionais e como podemos obter filtros treináveis, trabalhando nos notebooks correspondentes:
+
+* [Redes Neuronais Convolucionais - PyTorch](ConvNetsPyTorch.ipynb)
+* [Redes Neuronais Convolucionais - TensorFlow](ConvNetsTF.ipynb)
+
+## Arquitetura em Pirâmide
+
+A maioria das CNN utilizadas para processamento de imagens segue uma arquitetura chamada de pirâmide. A primeira camada convolucional aplicada às imagens originais geralmente tem um número relativamente baixo de filtros (8-16), que correspondem a diferentes combinações de pixels, como linhas horizontais/verticais ou traços. No nível seguinte, reduzimos a dimensão espacial da rede e aumentamos o número de filtros, o que corresponde a mais combinações possíveis de características simples. Com cada camada, à medida que avançamos para o classificador final, as dimensões espaciais da imagem diminuem e o número de filtros aumenta.
+
+Como exemplo, vejamos a arquitetura da VGG-16, uma rede que alcançou 92,7% de precisão na classificação top-5 do ImageNet em 2014:
+
+![Camadas do ImageNet](../../../../../translated_images/pt-PT/vgg-16-arch1.d901a5583b3a51ba.webp)
+
+![Pirâmide do ImageNet](../../../../../translated_images/pt-PT/vgg-16-arch.64ff2137f50dd49f.webp)
+
+> Imagem de [Researchgate](https://www.researchgate.net/figure/Vgg16-model-structure-To-get-the-VGG-NIN-model-we-replace-the-2-nd-4-th-6-th-7-th_fig2_335194493)
+
+## Arquiteturas de CNN mais conhecidas
+
+[Continue o seu estudo sobre as arquiteturas de CNN mais conhecidas](CNN_Architectures.md)
+
+---
+

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

@@ -0,0 +1,38 @@
+# Classificação de Rostos de Animais de Estimação
+
+Trabalho de laboratório do [Currículo de IA para Iniciantes](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. Isto pode ser feito com sucesso utilizando redes neuronais.
+
+Precisa treinar uma rede neuronal convolucional para classificar diferentes raças de gatos e cães utilizando o dataset **Pet Faces**.
+
+## O Dataset
+
+Vamos utilizar o [Oxford-IIIT Pet Dataset](https://www.robots.ox.ac.uk/~vgg/data/pets/), que contém imagens de 37 raças diferentes de cães e gatos.
+
+![Dataset com que iremos trabalhar](../../../../../../translated_images/pt-PT/data.50b2a9d5484bdbf0.webp)
+
+Para descarregar o dataset, utilize 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 ficheiro (por exemplo, `Abyssinian_1.jpg`, `Bengal_2.jpg`). O notebook inclui código para organizar estas imagens em subdiretórios específicos de cada raça para facilitar a classificação.
+
+## Notebook Inicial
+
+Comece o laboratório abrindo [PetFaces.ipynb](PetFaces.ipynb)
+
+## Conclusão
+
+Conseguiu resolver um problema relativamente complexo de classificação de imagens do zero! Havia bastantes classes, e ainda assim 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**:  
+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 uma 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/08-TransferLearning/README.md

@@ -0,0 +1,81 @@
+# Redes Pré-treinadas e Aprendizagem por Transferência
+
+Treinar CNNs pode levar muito tempo e requer 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 então uma questão natural: podemos usar uma rede neural treinada num conjunto de dados e adaptá-la para classificar imagens diferentes sem precisar de um processo completo de treino?
+
+## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ai/quiz/15)
+
+Esta abordagem é chamada de **aprendizagem por transferência**, porque transferimos algum conhecimento de um modelo de rede neural para outro. Na aprendizagem por transferência, normalmente começamos com um modelo pré-treinado, que foi treinado num 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.
+
+> ✅ Aprendizagem por Transferência é um termo que também aparece em outros campos académicos, como a Educação. Refere-se ao processo de aplicar conhecimentos de um domínio a 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 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 superior, correspondendo a coisas como o olho de uma chama. Se treinarmos uma CNN num conjunto de dados suficientemente grande e diversificado, a rede deve aprender a extrair essas características comuns.
+
+Tanto o Keras como o PyTorch possuem funções para carregar facilmente pesos de redes neurais pré-treinadas para algumas arquiteturas comuns, a maioria das quais foi treinada com 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, pode considerar usar uma das seguintes:
+
+* **VGG-16/VGG-19**, que são modelos relativamente simples e ainda assim oferecem boa precisão. Usar o VGG como primeira tentativa é uma boa escolha para ver como a aprendizagem por transferência funciona.
+* **ResNet**, uma família de modelos proposta pela Microsoft Research em 2015. Estes têm mais camadas e, portanto, requerem mais recursos.
+* **MobileNet**, uma família de modelos com tamanho reduzido, adequada para dispositivos móveis. Use-os se 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 pela VGG-16](../../../../../translated_images/pt-PT/features.6291f9c7ba3a0b95.webp)
+
+## Conjunto de Dados de Gatos vs. Cães
+
+Neste exemplo, usaremos um conjunto de dados de [Gatos e Cães](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: Aprendizagem por Transferência
+
+Vamos ver a aprendizagem por transferência em ação nos notebooks correspondentes:
+
+* [Aprendizagem por Transferência - PyTorch](TransferLearningPyTorch.ipynb)
+* [Aprendizagem por Transferência - TensorFlow](TransferLearningTF.ipynb)
+
+## Visualizando o Gato Adversarial
+
+Uma rede neural pré-treinada contém diferentes padrões no seu *cérebro*, incluindo noções de **gato ideal** (bem como cão ideal, zebra ideal, etc.). Seria interessante **visualizar esta imagem**. No entanto, isso não é simples, porque os padrões estão espalhados pelos pesos da rede e organizados numa estrutura hierárquica.
+
+Uma abordagem que podemos adotar é começar com uma imagem aleatória e 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.
+
+![Ciclo de Otimização de Imagem](../../../../../translated_images/pt-PT/ideal-cat-loop.999fbb8ff306e044.webp)
+
+No entanto, se fizermos isso, obteremos algo muito semelhante a um ruído aleatório. Isso acontece 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 obrigue a serem visualmente distintas.
+
+Para melhorar o resultado, podemos adicionar outro termo à função de perda, chamado **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 apelativos. Aqui está um exemplo de imagens "ideais", classificadas como gato e zebra com alta probabilidade:
+
+![Gato Ideal](../../../../../translated_images/pt-PT/ideal-cat.203dd4597643d6b0.webp) | ![Zebra Ideal](../../../../../translated_images/pt-PT/ideal-zebra.7f70e8b54ee15a7a.webp)
+-----|-----
+ *Gato Ideal* | *Zebra Ideal*
+
+Uma abordagem semelhante pode ser usada para realizar os chamados **ataques adversariais** numa rede neural. Suponha que queremos enganar uma rede neural e fazer com que um cão pareça um gato. Se pegarmos na imagem de um cão, que é reconhecida pela rede como um cão, podemos ajustá-la ligeiramente usando otimização por descida de gradiente até que a rede comece a classificá-la como um gato:
+
+![Imagem de um Cão](../../../../../translated_images/pt-PT/original-dog.8f68a67d2fe0911f.webp) | ![Imagem de um cão classificada como gato](../../../../../translated_images/pt-PT/adversarial-dog.d9fc7773b0142b89.webp)
+-----|-----
+*Imagem original de um cão* | *Imagem de um cão classificada como gato*
+
+Veja o código para reproduzir os resultados acima no seguinte notebook:
+
+* [Gato Ideal e Adversarial - TensorFlow](AdversarialCat_TF.ipynb)
+
+## Conclusão
+
+Usando a aprendizagem por transferência, é possível montar rapidamente um classificador para uma tarefa de classificação de objetos personalizada e alcançar alta precisão. Pode perceber que tarefas mais complexas que estamos a resolver agora requerem 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 numa ligeira redução de precisão.
+
+## 🚀 Desafio
+
+Nos notebooks que acompanham, há notas no final sobre como o conhecimento transferido funciona melhor com dados de treino algo semelhantes (um novo tipo de animal, talvez). Experimente com tipos de imagens completamente novos para ver como os seus modelos de conhecimento transferido se comportam.
+
+## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ai/quiz/16)
+
+## Revisão e Autoestudo
+
+Leia o documento [TrainingTricks.md](TrainingTricks.md) para aprofundar o seu conhecimento sobre outras formas de treinar os 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 cães, e construiremos um classificador de aprendizagem por transferência.
+
+---
+

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

@@ -0,0 +1,108 @@
+# Truques para Treino em Deep Learning
+
+À medida que as redes neurais se tornam mais profundas, o processo de treino torna-se cada vez mais desafiador. Um dos principais problemas é o chamado [vanishing gradients](https://en.wikipedia.org/wiki/Vanishing_gradient_problem) 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.). [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 treino de redes profundas mais eficiente, existem algumas técnicas que podem ser utilizadas.
+
+## Manter valores num intervalo razoável
+
+Para tornar os cálculos numéricos mais estáveis, é importante garantir que todos os valores dentro da rede neural estejam numa escala razoável, tipicamente [-1..1] ou [0..1]. Não é um requisito muito rígido, 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>, é provável que obtenhamos 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 tem não-linearidades em torno de [-1..1], e por isso 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 permaneçam 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 seria *n*, e os valores provavelmente sairão do intervalo [0..1].
+
+As seguintes inicializações são frequentemente utilizadas:
+
+ * 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))** -- chamada **Xavier initialization** (`glorot`), ajuda a manter os sinais na faixa durante a propagação direta e reversa
+
+## Normalização por Lote
+
+Mesmo com uma inicialização adequada dos pesos, estes podem ficar arbitrariamente grandes ou pequenos durante o treino, levando os sinais para fora da faixa apropriada. Podemos trazer os sinais de volta utilizando 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 por Lote.
+
+A ideia da **normalização por lote** é considerar todos os valores do minibatch e realizar a normalização (ou seja, subtrair a média e dividir pelo desvio padrão) com base nesses valores. É implementada como uma camada na rede que realiza essa normalização após aplicar os pesos, mas antes da função de ativação. Como resultado, é provável que se obtenha maior precisão final e treino mais rápido.
+
+Aqui está o [artigo original](https://arxiv.org/pdf/1502.03167.pdf) sobre normalização por lote, a [explicação na Wikipedia](https://en.wikipedia.org/wiki/Batch_normalization), e [um bom artigo 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 percentagem de neurónios aleatórios durante o treino. É implementada como uma camada com um parâmetro (percentagem de neurónios a remover, tipicamente 10%-50%), e durante o treino zera elementos aleatórios do vetor de entrada antes de passá-lo para a próxima camada.
+
+Embora possa parecer uma ideia estranha, pode-se observar o efeito do dropout no treino de um classificador de dígitos MNIST no notebook [`Dropout.ipynb`](../../../../../lessons/4-ComputerVision/08-TransferLearning/Dropout.ipynb). Ele acelera o treino e permite alcançar maior precisão em menos épocas de treino.
+
+Este efeito pode ser explicado de várias formas:
+
+ * Pode ser considerado como um fator de choque aleatório para o modelo, que o tira de mínimos locais
+ * Pode ser considerado como *média implícita de modelos*, porque durante o dropout estamos a treinar modelos ligeiramente diferentes
+
+> *Algumas pessoas dizem que quando uma pessoa bêbada tenta aprender algo, ela lembra-se melhor no dia seguinte, comparando com uma pessoa sóbria, porque um cérebro com alguns neurónios a funcionar mal tenta adaptar-se melhor para captar o significado. Nunca testámos se isto é verdade ou não.*
+
+## Prevenir overfitting
+
+Um dos aspetos 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 treino.
+
+> Certifique-se de que compreende o conceito de [overfitting](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) que introduzimos anteriormente!
+
+Existem várias formas de prevenir o overfitting:
+
+ * Paragem antecipada -- monitorizar continuamente o erro no conjunto de validação e parar o treino quando o erro de validação começar a aumentar.
+ * Decaimento explícito de pesos / Regularização -- adicionar uma penalização extra à função de perda para valores absolutos altos de pesos, o que previne resultados muito instáveis no modelo
+ * Média de Modelos -- treinar vários modelos e depois fazer a média dos resultados. Isto ajuda a minimizar a variância.
+ * Dropout (Média Implícita de Modelos)
+
+## Otimizadores / Algoritmos de Treino
+
+Outro aspeto importante do treino é escolher um bom algoritmo de treino. Embora o **gradient descent** clássico seja uma escolha razoável, pode por vezes ser demasiado lento ou resultar em outros problemas.
+
+Em deep learning, utilizamos **Stochastic Gradient Descent** (SGD), que é um gradient descent aplicado a minibatches, selecionados aleatoriamente do conjunto de treino. Os pesos são ajustados utilizando 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 nos movemos com inércia e recebemos um empurrão numa direção diferente; a 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 até que ponto consideramos a inércia: γ=0 corresponde ao SGD clássico; γ=1 é uma equação de movimento puro.
+
+### Adam, Adagrad, etc.
+
+Como em cada camada multiplicamos os sinais por uma matriz W<sub>i</sub>, dependendo de ||W<sub>i</sub>||, o gradiente pode diminuir e ser próximo de 0, ou crescer indefinidamente. Este é o cerne do problema de Exploding/Vanishing Gradients.
+
+Uma das soluções para este 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>
+
+Este algoritmo é chamado **Adagrad**. Outros algoritmos que utilizam a mesma ideia: **RMSProp**, **Adam**
+
+> **Adam** é considerado um algoritmo muito eficiente para muitas aplicações, por isso, se 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 aprendizagem
+
+O sucesso do treino muitas vezes depende do parâmetro de taxa de aprendizagem η. É lógico assumir que valores maiores de η resultam em treino mais rápido, algo que normalmente queremos no início do treino, e depois valores menores de η permitem ajustar melhor a rede. Assim, na maioria dos casos queremos diminuir η durante o processo de treino.
+
+Isto pode ser feito multiplicando η por um número (ex. 0.98) após cada época de treino, ou utilizando um **cronograma de taxa de aprendizagem** mais complicado.
+
+## Diferentes Arquiteturas de Redes
+
+Selecionar a arquitetura certa para o seu problema pode ser complicado. Normalmente, escolhemos uma arquitetura que já tenha demonstrado funcionar para a nossa tarefa específica (ou uma semelhante). 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 suficientemente poderosa para o número de amostras de treino que temos. Escolher um modelo demasiado 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 de 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 no seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes do uso desta tradução.