From 10b6d23c563228c41bedd7d6025bf6b76ec08d97 Mon Sep 17 00:00:00 2001 From: "localizeflow[bot]" Date: Wed, 8 Jul 2026 21:15:40 +0000 Subject: [PATCH] chore(i18n): sync translations with latest source changes (chunk 1/1, 18 changes) --- translations/it/.co-op-translator.json | 37 ++++- translations/it/CONTRIBUTING.md | 29 ++++ translations/it/examples/README.md | 42 +++--- .../it/lessons/0-course-setup/how-to-run.md | 50 +++---- .../TransferLearningTF.ipynb | 128 +++++++++-------- translations/it/lessons/5-NLP/README.md | 62 ++++---- translations/pt-BR/.co-op-translator.json | 37 ++++- translations/pt-BR/CONTRIBUTING.md | 29 ++++ translations/pt-BR/examples/README.md | 44 +++--- .../lessons/0-course-setup/how-to-run.md | 46 +++--- .../TransferLearningTF.ipynb | 127 ++++++++-------- translations/pt-BR/lessons/5-NLP/README.md | 66 +++++---- translations/pt-PT/.co-op-translator.json | 37 ++++- translations/pt-PT/CONTRIBUTING.md | 29 ++++ translations/pt-PT/examples/README.md | 50 +++---- .../lessons/0-course-setup/how-to-run.md | 46 +++--- .../TransferLearningTF.ipynb | 135 +++++++++--------- translations/pt-PT/lessons/5-NLP/README.md | 82 ++++++----- 18 files changed, 638 insertions(+), 438 deletions(-) create mode 100644 translations/it/CONTRIBUTING.md create mode 100644 translations/pt-BR/CONTRIBUTING.md create mode 100644 translations/pt-PT/CONTRIBUTING.md diff --git a/translations/it/.co-op-translator.json b/translations/it/.co-op-translator.json index fecc9522..4d5e7293 100644 --- a/translations/it/.co-op-translator.json +++ b/translations/it/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "it" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T21:15:35+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "it" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T21:07:23+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "it" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "it", + "failure_date": "2026-07-08T21:15:03+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.", + "translator_version": "0.20.0", + "failure_policy_version": 1 + } + }, "etc/CODE_OF_CONDUCT.md": { "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56", "translation_date": "2025-08-26T07:15:49+00:00", @@ -54,8 +73,8 @@ "language_code": "it" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:30:10+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T21:09:55+00:00", "source_file": "examples/README.md", "language_code": "it" }, @@ -66,8 +85,8 @@ "language_code": "it" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-15T14:20:38+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T21:10:18+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "it" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "it" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T20:58:18+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "it" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-26T07:05:08+00:00", @@ -330,8 +355,8 @@ "language_code": "it" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-26T06:55:02+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T21:10:44+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "it" }, diff --git a/translations/it/CONTRIBUTING.md b/translations/it/CONTRIBUTING.md new file mode 100644 index 00000000..040bb645 --- /dev/null +++ b/translations/it/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# Contribuire a AI-For-Beginners + +Grazie per il tuo interesse a contribuire a AI-For-Beginners! Accogliamo traduzioni, correzioni delle lezioni e modifiche al formato. + +## Contratto di Licenza per i Collaboratori Microsoft (CLA) + +Questo progetto accoglie contributi e suggerimenti. La maggior parte dei contributi richiede che tu accetti un Contratto di Licenza per i Collaboratori (CLA) dichiarando di avere il diritto e di concederci effettivamente i diritti di utilizzare il tuo contributo. Per dettagli, visita [https://cla.microsoft.com](https://cla.microsoft.com). + +Quando invii una pull request, un bot CLA determinerà automaticamente se devi fornire un CLA e decorerà opportunamente la PR (ad esempio, etichetta, commento). Segui semplicemente le istruzioni fornite dal bot. Dovrai farlo solo una volta per tutti i repository che utilizzano il nostro CLA. + +## Come Contribuire + +### 1. Correzione di Errori di Battitura / Codice +Se trovi un errore di battitura o un bug in qualsiasi notebook Jupyter o file markdown della lezione: +1. Fai il fork del repository. +2. Correggi l'errore di battitura o il collegamento interrotto. +3. Invia una Pull Request con una descrizione chiara della correzione. + +### 2. Invio di Traduzioni +Accogliamo con piacere traduzioni delle lezioni in altre lingue! Si prega di posizionare le traduzioni nella directory `translations/` usando i nomi di cartella esistenti (ad esempio `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +Per maggiori dettagli, vedi [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**Disclaimer**: +Questo documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire la precisione, si prega di notare che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un essere umano. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall’uso di questa traduzione. + \ No newline at end of file diff --git a/translations/it/examples/README.md b/translations/it/examples/README.md index 6117e293..afe43557 100644 --- a/translations/it/examples/README.md +++ b/translations/it/examples/README.md @@ -1,27 +1,27 @@ -# Esempi di AI per Principianti +# Esempi di Intelligenza Artificiale per Principianti -Benvenuto! Questa directory contiene esempi semplici e autonomi per aiutarti a iniziare con l'intelligenza artificiale e il machine learning. Ogni esempio è progettato per essere adatto ai principianti, con commenti dettagliati e spiegazioni passo dopo passo. +Benvenuto! Questa directory contiene esempi semplici e autonomi per aiutarti a iniziare con l'intelligenza artificiale e il machine learning. Ogni esempio è progettato per essere adatto ai principianti con commenti dettagliati e spiegazioni passo passo. ## 📚 Panoramica degli Esempi | Esempio | Descrizione | Difficoltà | Prerequisiti | |---------|-------------|------------|---------------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | Il tuo primo programma AI - riconoscimento di pattern semplice | ⭐ Principiante | Nozioni di base su Python | -| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Costruisci una rete neurale da zero | ⭐⭐ Principiante+ | Python, matematica di base | -| [Image Classifier](./03-image-classifier.ipynb) | Classifica immagini con un modello pre-addestrato | ⭐⭐ Principiante+ | Python, numpy | -| [Text Sentiment](../../../examples/04-text-sentiment.py) | Analizza il sentimento di un testo (positivo/negativo) | ⭐⭐ Principiante+ | Python | +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Il tuo primo programma AI - semplice riconoscimento di pattern | ⭐ Principiante | Nozioni base di Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Costruisci una rete neurale da zero | ⭐⭐ Principiante+ | Python, matematica di base | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Classifica immagini con un modello pre-addestrato | ⭐⭐ Principiante+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analizza il sentimento del testo (positivo/negativo) | ⭐⭐ Principiante+ | Python | ## 🚀 Per Iniziare ### Prerequisiti -Assicurati di avere Python installato (consigliato 3.8 o superiore). Installa i pacchetti richiesti: +Assicurati di avere Python installato (consigliata la versione 3.8 o superiore). Installa i pacchetti richiesti: ```bash -# For Python scripts +# Per script Python pip install numpy -# For Jupyter notebooks (image classifier) +# Per notebook Jupyter (classificatore di immagini) pip install jupyter numpy pillow tensorflow ``` @@ -46,21 +46,21 @@ jupyter notebook 03-image-classifier.ipynb ## 📖 Percorso di Apprendimento -Consigliamo di seguire gli esempi in ordine: +Si consiglia di seguire gli esempi in questo ordine: 1. **Inizia con "Hello AI World"** - Impara le basi del riconoscimento di pattern -2. **Costruisci una Semplice Rete Neurale** - Comprendi come funzionano le reti neurali -3. **Prova il Classificatore di Immagini** - Guarda l'AI in azione con immagini reali -4. **Analizza il Sentimento di un Testo** - Esplora l'elaborazione del linguaggio naturale +2. **Costruisci una rete neurale semplice** - Comprendi come funzionano le reti neurali +3. **Prova il classificatore di immagini** - Vedi l'AI in azione con immagini reali +4. **Analizza il sentimento del testo** - Esplora il trattamento del linguaggio naturale ## 💡 Consigli per Principianti - **Leggi attentamente i commenti nel codice** - Spiegano cosa fa ogni riga -- **Sperimenta!** - Prova a cambiare i valori e osserva cosa succede -- **Non preoccuparti di capire tutto subito** - L'apprendimento richiede tempo -- **Fai domande** - Usa il [Forum di discussione](https://github.com/microsoft/AI-For-Beginners/discussions) +- **Sperimenta!** - Prova a cambiare i valori e guarda cosa succede +- **Non preoccuparti di capire tutto subito** - Imparare richiede tempo +- **Fai domande** - Usa il [Forum di Discussione](https://github.com/microsoft/AI-For-Beginners/discussions) -## 🔗 Prossimi Passi +## 🔗 Passi Successivi Dopo aver completato questi esempi, esplora il curriculum completo: - [Introduzione all'AI](../lessons/1-Intro/README.md) @@ -77,9 +77,11 @@ Hai trovato utili questi esempi? Aiutaci a migliorarli: --- -*Ricorda: Ogni esperto è stato un principiante. Buon apprendimento! 🎓* +*Ricorda: ogni esperto è stato una volta un principiante. Buono studio! 🎓* --- -**Disclaimer**: -Questo documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un esperto umano. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file + +**Disclaimer**: +Questo documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire la precisione, si prega di notare che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un essere umano. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall’uso di questa traduzione. + \ No newline at end of file diff --git a/translations/it/lessons/0-course-setup/how-to-run.md b/translations/it/lessons/0-course-setup/how-to-run.md index 4adc510d..a72ecfba 100644 --- a/translations/it/lessons/0-course-setup/how-to-run.md +++ b/translations/it/lessons/0-course-setup/how-to-run.md @@ -1,12 +1,12 @@ -# Come eseguire il codice +# Come Eseguire il Codice -Questo curriculum contiene molti esempi eseguibili e laboratori che vorresti eseguire. Per farlo, hai bisogno della capacità di eseguire codice Python nei Jupyter Notebook forniti come parte di questo curriculum. Hai diverse opzioni per eseguire il codice: +Questo curriculum contiene molti esempi eseguibili e laboratori che vorrai eseguire. Per farlo, hai bisogno della possibilità di eseguire codice Python nei Jupyter Notebook forniti come parte di questo curriculum. Hai diverse opzioni per eseguire il codice: ## Esegui localmente sul tuo computer -Per eseguire il codice localmente sul tuo computer, è necessaria un'installazione di Python. Una raccomandazione è installare **[miniconda](https://conda.io/en/latest/miniconda.html)** - si tratta di un'installazione piuttosto leggera che supporta il gestore di pacchetti `conda` per diversi **ambienti virtuali** Python. +Per eseguire il codice localmente sul tuo computer, è necessaria un'installazione di Python. Una raccomandazione è quella di installare **[miniconda](https://conda.io/en/latest/miniconda.html)** - è un'installazione piuttosto leggera che supporta il gestore di pacchetti `conda` per diversi **ambienti virtuali** Python. -Dopo aver installato miniconda, clona il repository e crea un ambiente virtuale da utilizzare per questo corso: +Dopo aver installato miniconda, clona il repository e crea un ambiente virtuale da usare per questo corso: ```bash git clone http://github.com/microsoft/ai-for-beginners @@ -15,19 +15,19 @@ conda env create --name ai4beg --file .devcontainer/environment.yml conda activate ai4beg ``` -### Usare Visual Studio Code con l'estensione Python +### Usare Visual Studio Code con l'Estensione Python -Questo curriculum è meglio utilizzato aprendolo in [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) con l'[estensione Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). +Questo curriculum è meglio utilizzato aprendolo in [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) con l'[Estensione Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). -> **Nota**: Una volta che cloni e apri la directory in VS Code, ti suggerirà automaticamente di installare le estensioni Python. Dovrai anche installare miniconda come descritto sopra. +> **Nota**: Una volta che cloni e apri la cartella in VS Code, ti suggerirà automaticamente di installare le estensioni Python. Dovrai anche installare miniconda come descritto sopra. -> **Nota**: Se VS Code ti suggerisce di riaprire il repository in un container, dovresti rifiutare per usare l'installazione Python locale. +> **Nota**: Se VS Code ti suggerisce di riaprire il repository in un contenitore, dovresti rifiutare per usare l'installazione Python locale. -### Usare Jupyter nel browser +### Usare Jupyter nel Browser -Puoi anche usare un ambiente Jupyter dal browser sul tuo computer. Sia il classico Jupyter che JupyterHub offrono un ambiente di sviluppo comodo con completamento automatico, evidenziazione del codice, ecc. +Puoi anche usare un ambiente Jupyter dal browser sul tuo computer. Sia Jupyter classico che JupyterHub forniscono un ambiente di sviluppo comodo con completamento automatico, evidenziazione del codice, ecc. -Per iniziare Jupyter localmente, vai nella directory del corso ed esegui: +Per avviare Jupyter localmente, vai nella cartella del corso ed esegui: ```bash jupyter notebook @@ -36,36 +36,36 @@ o ```bash jupyterhub ``` -Puoi quindi navigare in uno qualsiasi dei file `.ipynb`, aprirli e iniziare a lavorare. +Poi puoi navigare su qualsiasi file `.ipynb`, aprirlo e iniziare a lavorare. ### Esecuzione in contenitore -Un'alternativa all'installazione di Python sarebbe eseguire il codice in un contenitore. Poiché il nostro repository fornisce una cartella speciale `.devcontainer` che spiega come costruire un contenitore per questo repo, VS Code offre l'opportunità di riaprire il codice in un contenitore. Questo richiederà l'installazione di Docker e sarà anche più complesso, quindi lo consigliamo a utenti più esperti. +Un'alternativa all'installazione di Python sarebbe eseguire il codice in un contenitore. Poiché il nostro repository fornisce una cartella speciale `.devcontainer` che indica come costruire un contenitore per questo repo, VS Code offre la possibilità di riaprire il codice in un contenitore. Questo richiederà l'installazione di Docker e sarebbe più complesso, quindi raccomandiamo questo a utenti più esperti. -## Esecuzione nel cloud +## Esecuzione nel Cloud -Se non vuoi installare Python localmente e hai accesso ad alcune risorse cloud, una buona alternativa è eseguire il codice nel cloud. Ci sono diversi modi per farlo: +Se non vuoi installare Python localmente e hai accesso a risorse cloud, un'ottima alternativa è eseguire il codice nel cloud. Ci sono diversi modi per farlo: -* Usare **[GitHub Codespaces](https://github.com/features/codespaces)**, che è un ambiente virtuale creato per te su GitHub, accessibile tramite un'interfaccia browser di VS Code. Se hai accesso a Codespaces, puoi semplicemente cliccare sul pulsante **Code** nel repo, avviare un codespace e iniziare rapidamente. -* Usare **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) offre risorse di calcolo gratuite fornite nel cloud per persone come te per testare del codice su GitHub. C'è un pulsante nella pagina principale per aprire il repository in Binder - questo ti porterà rapidamente al sito di binder, che costruirà un contenitore sottostante e avvierà un'interfaccia web Jupyter per te senza interruzioni. +* Usare **[GitHub Codespaces](https://github.com/features/codespaces)**, che è un ambiente virtuale creato per te su GitHub, accessibile tramite un'interfaccia browser di VS Code. Se hai accesso a Codespaces, puoi semplicemente cliccare il pulsante **Code** nel repo, avviare un codespace e iniziare subito. +* Usare **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) offre risorse di calcolo gratuite nel cloud per persone come te per testare codice su GitHub. C'è un pulsante nella pagina principale per aprire il repository in Binder - questo ti porterà rapidamente al sito di Binder, che costruirà un contenitore sottostante e avvierà un'interfaccia web Jupyter per te senza soluzione di continuità. -> **Nota**: Per prevenire abusi, Binder ha accesso bloccato ad alcune risorse web. Questo potrebbe impedire che parte del codice funzioni, specialmente quello che cerca di scaricare modelli e/o dataset da Internet pubblico. Potresti dover trovare alcune soluzioni alternative. Inoltre, le risorse di calcolo fornite da Binder sono piuttosto basilari, quindi l'addestramento sarà lento, specialmente nelle lezioni successive, più complesse. +> **Nota**: Per prevenire abusi, Binder ha accesso bloccato ad alcune risorse web. Questo può impedire ad alcune parti del codice di funzionare, che recuperano modelli e/o dataset da Internet pubblico. Potresti dover trovare qualche soluzione alternativa. Inoltre, le risorse di calcolo fornite da Binder sono piuttosto basiche, quindi l'addestramento sarà lento, specialmente nelle lezioni più avanzate e complesse. -## Esecuzione nel cloud con GPU +## Esecuzione nel Cloud con GPU -Alcune lezioni successive di questo curriculum trarrebbero grande beneficio dal supporto GPU. L'addestramento dei modelli, per esempio, può essere dolorosamente lento altrimenti. Ci sono alcune opzioni che puoi seguire, specialmente se hai accesso al cloud tramite [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), o tramite la tua istituzione: +Alcune delle lezioni avanzate in questo curriculum trarrebbero gran beneficio dal supporto GPU. L'addestramento di modelli, per esempio, può essere dolorosamente lento senza. Ci sono alcune opzioni che puoi seguire, specialmente se hai accesso al cloud tramite [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), o tramite la tua istituzione: -* Crea una [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) e connettiti tramite Jupyter. Puoi quindi clonare il repo direttamente sulla macchina e iniziare a imparare. Le VM della serie NC hanno supporto GPU. +* Creare una [Virtual Machine per Data Science](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) e connettersi ad essa tramite Jupyter. Puoi poi clonare il repo direttamente sulla macchina e iniziare a studiare. Le VM serie NC hanno supporto GPU. -> **Nota**: Alcuni abbonamenti, inclusi Azure for Students, non forniscono supporto GPU di default. Potresti dover richiedere core GPU aggiuntivi tramite richiesta di supporto tecnico. +> **Nota**: Alcuni abbonamenti, incluso Azure for Students, non forniscono supporto GPU predefinito. Potresti dover richiedere core GPU aggiuntivi tramite una richiesta di supporto tecnico. -* Crea un [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) e quindi usa la funzione Notebook lì. [Questo video](https://azure-for-academics.github.io/quickstart/azureml-papers/) mostra come clonare un repository in un notebook Azure ML e iniziare a usarlo. +* Creare uno [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) e poi usare la funzione Notebook lì. [Questo video](https://azure-for-academics.github.io/quickstart/azureml-papers/) mostra come clonare un repository in un notebook Azure ML e iniziare a usarlo. -Puoi anche usare Google Colab, che viene fornito con un certo supporto GPU gratuito, e caricare lì i Jupyter Notebook per eseguirli uno alla volta. +Puoi anche usare Google Colab, che include un certo supporto GPU gratuito, e caricare i Jupyter Notebook lì per eseguirli uno per uno. --- **Disclaimer**: -Questo documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Pur impegnandoci per garantire accuratezza, si prega di considerare che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua madre deve essere considerato la fonte autorevole. Per informazioni importanti, si consiglia una traduzione professionale effettuata da un esperto umano. Non ci assumiamo responsabilità per eventuali malintesi o interpretazioni errate derivanti dall’uso di questa traduzione. +Questo documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire la precisione, si prega di notare che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un essere umano. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall’uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/it/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index e7bade14..48322cc1 100644 --- a/translations/it/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/it/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Modelli pre-addestrati e apprendimento per trasferimento\n", + "# Modelli pre-addestrati e apprendimento trasferito\n", "\n", - "Addestrare le CNN può richiedere molto tempo e una grande quantità di dati. Tuttavia, gran parte del tempo viene impiegato per apprendere i migliori filtri di basso livello che una rete utilizza per estrarre schemi dalle immagini. Sorge una domanda naturale: possiamo utilizzare una rete neurale addestrata su un dataset e adattarla per classificare immagini diverse senza dover eseguire l'intero processo di addestramento?\n", + "L'addestramento delle CNN può richiedere molto tempo e per questo compito è necessario un grande quantitativo di dati. Tuttavia, gran parte del tempo viene speso per imparare i migliori filtri di basso livello che una rete utilizza per estrarre pattern dalle immagini. Sorge dunque una domanda naturale: possiamo usare una rete neurale addestrata su un dataset e adattarla a classificare immagini diverse senza dover completare un processo di addestramento completo?\n", "\n", - "Questo approccio è chiamato **apprendimento per trasferimento**, perché trasferiamo alcune conoscenze da un modello di rete neurale a un altro. Nell'apprendimento per trasferimento, di solito si parte da un modello pre-addestrato, che è stato addestrato su un grande dataset di immagini, come **ImageNet**. Questi modelli sono già in grado di estrarre efficacemente diverse caratteristiche da immagini generiche e, in molti casi, costruire semplicemente un classificatore sopra queste caratteristiche estratte può portare a buoni risultati.\n" + "Questo approccio è chiamato **apprendimento trasferito**, perché trasferiamo una certa conoscenza da un modello di rete neurale a un altro. Nell'apprendimento trasferito, tipicamente iniziamo con un modello pre-addestrato, il quale è stato addestrato su un grande dataset di immagini, come **ImageNet**. Questi modelli sono già in grado di svolgere un buon lavoro nell'estrarre diverse caratteristiche da immagini generiche, e in molti casi costruire un classificatore sopra queste caratteristiche estratte può dare un buon risultato.\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Dataset Cats vs. Dogs\n", + "## Dataset Gatti vs. Cani\n", "\n", - "In questa unità, affronteremo un problema reale di classificazione di immagini di gatti e cani. Per questo motivo, utilizzeremo il [Dataset Cats vs. Dogs di Kaggle](https://www.kaggle.com/c/dogs-vs-cats), che può essere scaricato anche [da Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "In questa unità, risolveremo un problema reale di classificazione delle immagini di gatti e cani. Per questo motivo, utilizzeremo il [Dataset Gatti vs. Cani di Kaggle](https://www.kaggle.com/c/dogs-vs-cats), che può anche essere scaricato [da Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", - "Scarichiamo questo dataset ed estraiamolo nella directory `data` (questo processo potrebbe richiedere un po' di tempo!):\n" + "Scarichiamo questo dataset e estraiamolo nella directory `data` (questo processo potrebbe richiedere un po' di tempo!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Sfortunatamente, ci sono alcuni file immagine corrotti nel dataset. Dobbiamo fare una rapida pulizia per controllare i file corrotti. Per non appesantire questo tutorial, abbiamo spostato il codice per verificare il dataset in un modulo.\n" + "Purtroppo, ci sono alcuni file immagine corrotti nel set di dati. Dobbiamo fare una rapida pulizia per controllare i file corrotti. Per non rovinare questo tutorial, abbiamo spostato il codice per verificare il set di dati in un modulo.\n" ] }, { @@ -335,11 +335,11 @@ "source": [ "## Caricamento del Dataset\n", "\n", - "Nei precedenti esempi, abbiamo caricato dataset già integrati in Keras. Ora stiamo per lavorare con un nostro dataset, che dobbiamo caricare da una directory di immagini.\n", + "Negli esempi precedenti, abbiamo caricato dataset incorporati in Keras. Ora ci apprestiamo a gestire il nostro dataset, che dobbiamo caricare da una directory di immagini.\n", "\n", - "Nella vita reale, la dimensione dei dataset di immagini può essere piuttosto grande, e non si può fare affidamento sul fatto che tutti i dati possano essere caricati in memoria. Per questo motivo, i dataset sono spesso rappresentati come **generatori** che possono restituire i dati in minibatch adatti per l'addestramento.\n", + "Nella vita reale, la dimensione dei dataset di immagini può essere abbastanza grande, e non si può contare che tutti i dati possano stare in memoria. Pertanto, i dataset sono spesso rappresentati come **generatori** che possono restituire dati in minibatch adatti per l’addestramento.\n", "\n", - "Per gestire la classificazione delle immagini, Keras include una funzione speciale chiamata `image_dataset_from_directory`, che può caricare immagini da sottodirectory corrispondenti a diverse classi. Questa funzione si occupa anche di scalare le immagini e può suddividere il dataset in sottoinsiemi di training e test:\n" + "Per gestire la classificazione delle immagini, Keras include una funzione speciale `image_dataset_from_directory`, che può caricare immagini da sottodirectory corrispondenti a classi diverse. Questa funzione si occupa anche di ridimensionare le immagini e può anche dividere il dataset in sottogruppi di addestramento e test:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "È importante impostare lo stesso valore di `seed` per entrambe le chiamate, poiché influisce sulla suddivisione delle immagini tra il dataset di addestramento e quello di test.\n", + "È importante impostare lo stesso valore `seed` per entrambe le chiamate, perché influisce sulla divisione delle immagini tra il set di addestramento e quello di test.\n", "\n", - "Il dataset rileva automaticamente i nomi delle classi dalle directory e puoi accedervi, se necessario, chiamando:\n" + "Dataset recupera automaticamente i nomi delle classi dalle directory, e puoi accedervi se necessario chiamando:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "I dataset che abbiamo ottenuto possono essere direttamente passati alla funzione `fit` per addestrare il modello. Contengono sia immagini corrispondenti che etichette, che possono essere iterate utilizzando la seguente costruzione:\n" + "I set di dati che abbiamo ottenuto possono essere direttamente passati alla funzione `fit` per addestrare il modello. Contengono sia le immagini corrispondenti che le etichette, che possono essere iterate utilizzando la seguente costruzione:\n" ] }, { @@ -453,7 +453,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **Nota**: Tutte le immagini nel dataset sono rappresentate come tensori a virgola mobile con intervallo 0-255. Prima di passarle alla rete neurale, dobbiamo scalare questi valori nell'intervallo 0-1. Quando tracciamo le immagini, dobbiamo fare lo stesso oppure convertire i valori nel tipo `int` (come facciamo nel codice sopra), per mostrare a `matplotlib` che vogliamo tracciare l'immagine originale non scalata.\n" + "> **Nota**: Tutte le immagini nel dataset sono rappresentate come tensori a virgola mobile con intervallo 0-255. Prima di passarle alla rete neurale, dobbiamo scalare questi valori nell'intervallo 0-1. Quando tracciamo le immagini, dobbiamo fare lo stesso o convertire i valori in tipo `int` (come facciamo nel codice sopra), per mostrare a `matplotlib` che vogliamo tracciare l'immagine originale non scalata.\n" ] }, { @@ -462,7 +462,7 @@ "source": [ "## Modelli pre-addestrati\n", "\n", - "Per molti compiti di classificazione delle immagini è possibile trovare modelli di reti neurali pre-addestrati. Molti di questi modelli sono disponibili all'interno del namespace `keras.applications`, e ancora più modelli possono essere trovati su Internet. Vediamo come caricare e utilizzare il modello più semplice, VGG-16:\n" + "Per molti compiti di classificazione delle immagini si possono trovare modelli di reti neurali pre-addestrati. Molti di questi modelli sono disponibili all'interno dello spazio dei nomi `keras.applications`, e molti altri modelli si possono trovare su Internet. Vediamo come il modello più semplice, VGG-16, può essere caricato e utilizzato:\n" ] }, { @@ -497,7 +497,17 @@ } ], "source": [ - "vgg = keras.applications.VGG16()\n", + "# SHA-256 of VGG16 weights (with top)\n", + "VGG16_WEIGHTS_SHA256 = '64373286793e3c8b2b4e3219cbf3544bce2f55ab4682710a29f5e7af8f5e4f61'\n", + "\n", + "_weights_path = keras.utils.get_file(\n", + " 'vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " 'https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " file_hash=VGG16_WEIGHTS_SHA256,\n", + " hash_algorithm='sha256',\n", + ")\n", + "\n", + "vgg = keras.applications.VGG16(weights=_weights_path)\n", "inp = keras.applications.vgg16.preprocess_input(x_sample[:1])\n", "\n", "res = vgg(inp)\n", @@ -510,11 +520,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Ci sono un paio di cose importanti da tenere a mente:\n", - "\n", - "* Prima di passare un input a qualsiasi rete pre-addestrata, è necessario pre-processarlo in un certo modo. Questo viene fatto chiamando la funzione corrispondente `preprocess_input`, che riceve un batch di immagini e restituisce la loro forma processata. Nel caso di VGG-16, le immagini vengono normalizzate e viene sottratto un valore medio predefinito per ciascun canale. Questo perché VGG-16 è stata originariamente addestrata con questo tipo di pre-elaborazione.\n", - "* La rete neurale viene applicata al batch di input e, come risultato, otteniamo un batch di tensori a 1000 elementi che mostrano la probabilità di ciascuna classe. Possiamo trovare il numero della classe più probabile chiamando `argmax` su questo tensore.\n", - "* Il risultato ottenuto è un [numero di una classe di `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Per dare un senso a questo risultato, possiamo anche utilizzare la funzione `decode_predictions`, che restituisce le prime n classi insieme ai loro nomi.\n" + "Ci sono un paio di cose importanti qui:\n", + "* Prima di passare un input a una rete pre-addestrata, deve essere pre-elaborato in un certo modo. Questo viene fatto chiamando la corrispondente funzione `preprocess_input`, che riceve un batch di immagini e restituisce la loro forma elaborata. Nel caso di VGG-16, le immagini vengono normalizzate e viene sottratto un valore medio predefinito per ciascun canale. Questo perché VGG-16 è stato originariamente addestrato con questa pre-elaborazione.\n", + "* La rete neurale viene applicata al batch di input, e riceviamo come risultato un batch di tensori da 1000 elementi che mostrano la probabilità di ciascuna classe. Possiamo trovare il numero della classe più probabile chiamando `argmax` su questo tensore.\n", + "* Il risultato ottenuto è un [numero di una classe `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Per dare un senso a questo risultato, possiamo anche usare la funzione `decode_predictions`, che restituisce le prime n classi insieme ai loro nomi.\n" ] }, { @@ -600,7 +609,7 @@ "source": [ "## Calcoli GPU\n", "\n", - "Le reti neurali profonde, come VGG-16 e altre architetture più moderne, richiedono una notevole potenza di calcolo per funzionare. Ha senso utilizzare l'accelerazione GPU, se disponibile. Fortunatamente, Keras accelera automaticamente i calcoli sulla GPU se è disponibile. Possiamo verificare se Tensorflow è in grado di utilizzare la GPU con il seguente codice:\n" + "Le reti neurali profonde, come VGG-16 e altre architetture più moderne richiedono una notevole potenza di calcolo per funzionare. Ha senso usare l'accelerazione GPU, se disponibile. Fortunatamente, Keras velocizza automaticamente i calcoli sulla GPU se è disponibile. Possiamo verificare se Tensorflow è in grado di utilizzare la GPU con il seguente codice:\n" ] }, { @@ -627,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "\n", "## Estrazione delle caratteristiche VGG\n", "\n", - "Se vogliamo utilizzare VGG-16 per estrarre caratteristiche dalle nostre immagini, abbiamo bisogno del modello senza gli strati finali di classificazione. Possiamo istanziare il modello VGG-16 senza gli strati superiori utilizzando questo codice:\n" + "Se vogliamo utilizzare VGG-16 per estrarre le caratteristiche dalle nostre immagini, abbiamo bisogno del modello senza i livelli finali di classificazione. Possiamo istanziare il modello VGG-16 senza i livelli superiori usando questo codice:\n" ] }, { @@ -681,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "La dimensione del tensore delle caratteristiche è 7x7x512, ma per visualizzarlo abbiamo dovuto riformattarlo in una forma 2D.\n", + "La dimensione del tensore delle caratteristiche è 7x7x512, ma per visualizzarlo abbiamo dovuto rimodellarlo in forma 2D.\n", "\n", - "Ora proviamo a vedere se queste caratteristiche possono essere utilizzate per classificare immagini. Prendiamo manualmente una parte delle immagini (50 minibatch, nel nostro caso) e pre-calcoliamo i loro vettori di caratteristiche. Possiamo utilizzare l'API **dataset** di Tensorflow per farlo. La funzione `map` prende un dataset e applica una lambda-function fornita per trasformarlo. Utilizziamo questo meccanismo per costruire nuovi dataset, `ds_features_train` e `ds_features_test`, che contengono le caratteristiche estratte da VGG invece delle immagini originali.\n" + "Ora proviamo a vedere se queste caratteristiche possono essere utilizzate per classificare le immagini. Prendiamo manualmente una parte delle immagini (50 minibatch, nel nostro caso) e pre-calcoliamo i loro vettori di caratteristiche. Possiamo usare l'API **dataset** di Tensorflow per farlo. La funzione `map` prende un dataset e applica una data lambda-funzione per trasformarlo. Usimo questo meccanismo per costruire nuovi dataset, `ds_features_train` e `ds_features_test`, che contengono caratteristiche estratte da VGG invece delle immagini originali.\n" ] }, { @@ -713,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Abbiamo utilizzato la costruzione `.take(50)` per limitare la dimensione del dataset, al fine di velocizzare la nostra dimostrazione. Naturalmente, puoi eseguire questo esperimento sull'intero dataset.\n", + "Abbiamo usato la costruzione `.take(50)` per limitare la dimensione del dataset, per velocizzare la nostra dimostrazione. Naturalmente, puoi eseguire questo esperimento sull'intero dataset.\n", "\n", - "Ora che abbiamo un dataset con caratteristiche estratte, possiamo addestrare un semplice classificatore denso per distinguere tra gatti e cani. Questa rete prenderà un vettore di caratteristiche con forma (7,7,512) e produrrà un output che corrisponde a un cane o a un gatto. Poiché si tratta di una classificazione binaria, utilizziamo la funzione di attivazione `sigmoid` e la perdita `binary_crossentropy`.\n" + "Ora che abbiamo un dataset con caratteristiche estratte, possiamo addestrare un semplice classificatore denso per distinguere tra gatti e cani. Questa rete prenderà un vettore di caratteristiche di forma (7,7,512), e produrrà un output che corrisponde a un cane o a un gatto. Poiché si tratta di una classificazione binaria, usiamo la funzione di attivazione `sigmoid` e la perdita `binary_crossentropy`.\n" ] }, { @@ -744,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Il risultato è ottimo, possiamo distinguere tra un gatto e un cane con una probabilità quasi del 95%! Tuttavia, abbiamo testato questo approccio solo su un sottoinsieme di tutte le immagini, perché l'estrazione manuale delle caratteristiche sembra richiedere molto tempo.\n", + "Il risultato è ottimo, possiamo distinguere tra un gatto e un cane con quasi il 95% di probabilità! Tuttavia, abbiamo testato questo approccio solo su un sottoinsieme di tutte le immagini, perché l'estrazione manuale delle caratteristiche sembra richiedere molto tempo.\n", "\n", "## Apprendimento per trasferimento utilizzando una rete VGG\n", "\n", - "Possiamo anche evitare di pre-calcolare manualmente le caratteristiche utilizzando l'intera rete VGG-16 originale durante l'addestramento, aggiungendo un estrattore di caratteristiche alla nostra rete come primo strato.\n", + "Possiamo anche evitare di pre-calcolare manualmente le caratteristiche utilizzando l'originale rete VGG-16 nel suo insieme durante l'addestramento, aggiungendo l'estrattore di caratteristiche alla nostra rete come primo strato.\n", "\n", - "La bellezza dell'architettura di Keras è che il modello VGG-16 che abbiamo definito sopra può essere utilizzato anche come strato in un'altra rete neurale! Basta costruire una rete con un classificatore denso sopra di essa e poi addestrare l'intera rete utilizzando la retropropagazione.\n" + "La bellezza dell'architettura Keras è che il modello VGG-16 che abbiamo definito sopra può anche essere utilizzato come uno strato in un'altra rete neurale! Dobbiamo solo costruire una rete con un classificatore denso sopra di essa, e poi addestrare l'intera rete usando la retropropagazione.\n" ] }, { @@ -794,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Questo modello sembra una rete di classificazione end-to-end, che prende un'immagine e restituisce la classe. Tuttavia, la parte complicata è che vogliamo che VGG16 funzioni come un estrattore di caratteristiche e non venga riaddestrato. Pertanto, dobbiamo **bloccare i pesi dell'estrattore di caratteristiche convoluzionali**. Possiamo accedere al primo strato della rete chiamando `model.layers[0]`, e dobbiamo semplicemente impostare la proprietà `trainable` su `False`.\n", + "Questo modello sembra una rete di classificazione end-to-end, che prende un'immagine e restituisce la classe. Tuttavia, la cosa complicata è che vogliamo che VGG16 agisca come estrattore di caratteristiche, e non venga riaddestrato. Pertanto, dobbiamo **congelare i pesi dell'estrattore di caratteristiche convoluzionali**. Possiamo accedere al primo strato della rete chiamando `model.layers[0]`, e dobbiamo solo impostare la proprietà `trainable` su `False`.\n", "\n", - "> **Nota**: Bloccare i pesi dell'estrattore di caratteristiche è necessario, perché altrimenti lo strato classificatore non addestrato potrebbe compromettere i pesi pre-addestrati originali dell'estrattore convoluzionale.\n", + "> **Nota**: Il congelamento dei pesi dell'estrattore di caratteristiche è necessario, perché altrimenti lo strato classificatore non addestrato potrebbe distruggere i pesi pre-addestrati originali dell'estrattore convoluzionale.\n", "\n", - "Puoi notare che, mentre il numero totale di parametri nella nostra rete è di circa 15 milioni, stiamo addestrando solo 25k parametri. Tutti gli altri parametri dei filtri convoluzionali di alto livello sono pre-addestrati. Questo è positivo, perché possiamo ottimizzare un numero più piccolo di parametri con un numero più ridotto di esempi.\n", + "Puoi notare che mentre il numero totale di parametri nella nostra rete è circa 15 milioni, stiamo allenando solo 25k parametri. Tutti gli altri parametri dei filtri convoluzionali di alto livello sono pre-addestrati. Questo è positivo, perché possiamo fare il fine-tuning di un numero minore di parametri con un numero minore di esempi.\n", "\n", - "Ora procederemo con l'addestramento della nostra rete e vedremo quanto possiamo migliorare. Aspettati tempi di esecuzione piuttosto lunghi e non preoccuparti se l'esecuzione sembra bloccata per un po'.\n" + "Ora alleneremo la nostra rete e vedremo quanto possiamo migliorare. Aspettati un tempo di esecuzione piuttosto lungo, e non ti preoccupare se l'esecuzione sembra bloccata per un po'.\n" ] }, { @@ -825,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Sembra che abbiamo ottenuto un classificatore abbastanza accurato per gatti contro cani!\n", + "Sembra che abbiamo ottenuto un classificatore di gatti e cani ragionevolmente accurato! \n", "\n", "## Salvare e Caricare il Modello\n", "\n", - "Una volta che abbiamo addestrato il modello, possiamo salvare l'architettura del modello e i pesi addestrati in un file per utilizzi futuri:\n" + "Una volta addestrato il modello, possiamo salvare l’architettura del modello e i pesi addestrati in un file per usi futuri:\n" ] }, { @@ -853,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Possiamo quindi caricare il modello dal file in qualsiasi momento. Potresti trovarlo utile nel caso in cui il prossimo esperimento distrugga il modello - non dovresti ricominciare da zero.\n" + "Possiamo quindi caricare il modello dal file in qualsiasi momento. Potresti trovarlo utile nel caso in cui il prossimo esperimento distrugga il modello - non dovresti ricominciare da capo.\n" ] }, { @@ -869,15 +879,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Ottimizzazione del transfer learning\n", + "## Apprendimento per trasferimento con messa a punto fine\n", "\n", - "Nella sezione precedente, abbiamo addestrato il livello finale del classificatore per classificare le immagini nel nostro dataset. Tuttavia, non abbiamo riaddestrato l'estrattore di caratteristiche, e il nostro modello si è basato sulle caratteristiche apprese dai dati di ImageNet. Se i tuoi oggetti differiscono visivamente dalle immagini comuni di ImageNet, questa combinazione di caratteristiche potrebbe non funzionare al meglio. Per questo motivo, ha senso iniziare ad addestrare anche i livelli convoluzionali.\n", + "Nella sezione precedente, abbiamo addestrato lo strato finale del classificatore per classificare le immagini nel nostro set di dati. Tuttavia, non abbiamo riaddestrato l'estrattore di caratteristiche, e il nostro modello si è basato sulle caratteristiche che il modello ha appreso dai dati di ImageNet. Se i tuoi oggetti differiscono visivamente dalle immagini ordinarie di ImageNet, questa combinazione di caratteristiche potrebbe non funzionare al meglio. Pertanto ha senso iniziare ad addestrare anche i livelli convoluzionali.\n", "\n", - "Per farlo, possiamo sbloccare i parametri dei filtri convoluzionali che avevamo precedentemente bloccato.\n", + "Per fare ciò, possiamo sbloccare i parametri dei filtri convoluzionali che abbiamo precedentemente congelato. \n", "\n", - "> **Nota:** È importante bloccare prima i parametri e svolgere diversi epoch di addestramento per stabilizzare i pesi nel livello di classificazione. Se inizi immediatamente ad addestrare la rete end-to-end con i parametri sbloccati, è probabile che grandi errori distruggano i pesi pre-addestrati nei livelli convoluzionali.\n", + "> **Nota:** È importante congelare prima i parametri ed eseguire qualche epoca di addestramento per stabilizzare i pesi nello strato di classificazione. Se inizi immediatamente ad addestrare la rete end-to-end con i parametri sbloccati, grandi errori potrebbero distruggere i pesi pre-addestrati negli strati convoluzionali.\n", "\n", - "Il nostro modello convoluzionale VGG-16 si trova all'interno del primo livello ed è composto a sua volta da molti livelli. Possiamo dare un'occhiata alla sua struttura:\n" + "Il nostro modello convoluzionale VGG-16 si trova all'interno del primo strato, e a sua volta è composto da molti strati. Possiamo dare un'occhiata alla sua struttura: \n" ] }, { @@ -945,7 +955,9 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "Possiamo sbloccare tutti i layer della base convoluzionale:\n" + ] }, { "cell_type": "code", @@ -960,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Tuttavia, sbloccare tutti quanti contemporaneamente non è la soluzione migliore. Possiamo iniziare sbloccando solo alcuni degli ultimi strati di convoluzioni, perché contengono schemi di livello superiore rilevanti per le nostre immagini. Ad esempio, per cominciare, possiamo congelare tutti gli strati tranne gli ultimi 4:\n" + "Tuttavia, sbloccare tutti loro contemporaneamente non è la scelta migliore. Possiamo prima sbloccare solo alcuni degli ultimi strati di convoluzione, perché contengono pattern di livello più alto rilevanti per le nostre immagini. Ad esempio, per cominciare, possiamo bloccare tutti gli strati eccetto gli ultimi 4: \n" ] }, { @@ -999,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Osserva che il numero di parametri allenabili è aumentato significativamente, ma è ancora circa il 50% di tutti i parametri.\n", + "Osserva che il numero di parametri addestrabili è aumentato significativamente, ma è ancora circa il 50% di tutti i parametri.\n", "\n", - "Dopo aver sbloccato i livelli, possiamo fare qualche altra epoca di addestramento (nel nostro esempio, ne faremo solo una). Puoi anche scegliere un tasso di apprendimento più basso, per minimizzare l'impatto sui pesi pre-addestrati. Tuttavia, anche con un tasso di apprendimento basso, puoi aspettarti che la precisione diminuisca all'inizio dell'addestramento, per poi raggiungere un livello leggermente più alto rispetto al caso dei pesi fissi.\n", + "Dopo lo sblocco, possiamo fare ancora qualche epoca di addestramento (nel nostro esempio, ne faremo solo una). Puoi anche selezionare un tasso di apprendimento più basso, per minimizzare l'impatto sui pesi pre-addestrati. Tuttavia, anche con un tasso di apprendimento basso, puoi aspettarti che la precisione cali all'inizio dell'addestramento, fino a raggiungere infine un livello leggermente superiore rispetto al caso con pesi fissi.\n", "\n", - "> **Nota:** Questo addestramento avviene molto più lentamente, perché dobbiamo propagare i gradienti attraverso molti livelli della rete!\n" + "> **Nota:** Questo addestramento avviene molto più lentamente, perché dobbiamo propagare i gradienti indietro attraverso molti strati della rete!\n" ] }, { @@ -1027,9 +1039,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "È probabile che otterremo una maggiore accuratezza di addestramento, poiché stiamo utilizzando una rete più potente con più parametri, ma l'accuratezza di validazione non aumenterà altrettanto.\n", + "Probabilmente otterremo un'accuratezza di addestramento più elevata, perché stiamo utilizzando una rete più potente con più parametri, ma l'accuratezza di validazione non aumenterà altrettanto.\n", "\n", - "Sentiti libero di sbloccare qualche altro livello della rete e continuare l'addestramento per vedere se riesci a raggiungere una maggiore accuratezza!\n" + "Sentiti libero di sbloccare qualche altro strato della rete e allenarti di più, per vedere se riesci a ottenere un'accuratezza maggiore!\n" ] }, { @@ -1038,7 +1050,7 @@ "source": [ "## Altri modelli di visione artificiale\n", "\n", - "VGG-16 è una delle architetture di visione artificiale più semplici. Keras offre molte altre reti pre-addestrate. Tra le più utilizzate ci sono le architetture **ResNet**, sviluppate da Microsoft, e **Inception** di Google. Ad esempio, esploriamo l'architettura del modello ResNet-50 più semplice (ResNet è una famiglia di modelli con profondità diverse; puoi provare a sperimentare con ResNet-152 se vuoi vedere come appare un modello davvero profondo):\n" + "VGG-16 è una delle architetture di visione artificiale più semplici. Keras offre molte altre reti pre-addestrate. Le più utilizzate tra queste sono le architetture **ResNet**, sviluppate da Microsoft, e **Inception** di Google. Ad esempio, esploriamo l'architettura del modello ResNet-50 più semplice (ResNet è una famiglia di modelli con diverse profondità, puoi provare a sperimentare con ResNet-152 se vuoi vedere com'è un modello veramente profondo):\n" ] }, { @@ -1440,11 +1452,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Come puoi vedere, il modello contiene gli stessi blocchi costitutivi familiari: livelli convoluzionali, livelli di pooling e un classificatore denso finale. Possiamo utilizzare questo modello esattamente nello stesso modo in cui abbiamo utilizzato VGG-16 per il transfer learning. Puoi provare a sperimentare con il codice sopra, utilizzando diversi modelli ResNet come modello di base, e osservare come cambia l'accuratezza.\n", + "Come puoi vedere, il modello contiene gli stessi blocchi costitutivi familiari: strati convoluzionali, strati di pooling e classificatore denso finale. Possiamo utilizzare questo modello esattamente nello stesso modo in cui abbiamo usato VGG-16 per il transfer learning. Puoi provare a sperimentare con il codice sopra, usando diversi modelli ResNet come modello base, e vedere come cambia la precisione.\n", "\n", "## Batch Normalization\n", "\n", - "Questa rete contiene un altro tipo di livello: **Batch Normalization**. L'idea della batch normalization è di portare i valori che attraversano la rete neurale nell'intervallo corretto. Di solito, le reti neurali funzionano meglio quando tutti i valori sono nell'intervallo [-1,1] o [0,1], ed è per questo che ridimensioniamo/normalizziamo i nostri dati di input di conseguenza. Tuttavia, durante l'addestramento di una rete profonda, può succedere che i valori escano significativamente da questo intervallo, rendendo l'addestramento problematico. Il livello di batch normalization calcola la media e la deviazione standard per tutti i valori del minibatch corrente e li utilizza per normalizzare il segnale prima di farlo passare attraverso un livello della rete neurale. Questo migliora significativamente la stabilità delle reti profonde.\n" + "Questa rete contiene un altro tipo di strato: **Batch Normalization**. L'idea della batch normalization è portare i valori che fluiscono attraverso la rete neurale nell'intervallo corretto. Di solito le reti neurali funzionano al meglio quando tutti i valori sono nell'intervallo [-1,1] o [0,1], ed è per questo che scaldiamo/normalizziamo i nostri dati di input di conseguenza. Tuttavia, durante l'addestramento di una rete profonda, può succedere che i valori escano significativamente da questo intervallo, il che rende problematico l'addestramento. Lo strato di batch normalization calcola la media e la deviazione standard per tutti i valori del minibatch corrente e li usa per normalizzare il segnale prima di passarlo attraverso uno strato della rete neurale. Questo migliora significativamente la stabilità delle reti profonde.\n" ] }, { @@ -1453,16 +1465,16 @@ "source": [ "## Conclusione\n", "\n", - "Utilizzando il transfer learning, siamo riusciti rapidamente a creare un classificatore per il nostro compito di classificazione di oggetti personalizzati, ottenendo un'elevata accuratezza. Tuttavia, questo esempio non è stato completamente imparziale, poiché la rete originale VGG-16 era pre-addestrata per riconoscere gatti e cani, e quindi abbiamo semplicemente riutilizzato la maggior parte dei pattern già presenti nella rete. È possibile aspettarsi una precisione inferiore su oggetti più esotici e specifici di un dominio, come dettagli su una linea di produzione in una fabbrica o diverse foglie di alberi.\n", + "Utilizzando il transfer learning, siamo stati in grado di mettere rapidamente insieme un classificatore per il nostro compito di classificazione di oggetti personalizzato, raggiungendo un'elevata accuratezza. Tuttavia, questo esempio non è stato completamente equo, perché la rete VGG-16 originale era pre-addestrata per riconoscere gatti e cani, e quindi stavamo solo riutilizzando la maggior parte dei pattern già presenti nella rete. Si può prevedere un'accuratezza inferiore su oggetti più esotici e specifici di dominio, come dettagli su una linea di produzione in uno stabilimento, o diverse foglie di alberi.\n", "\n", - "Si può notare che i compiti più complessi che stiamo affrontando ora richiedono una maggiore potenza di calcolo e non possono essere facilmente risolti con la CPU. Nella prossima unità, cercheremo di utilizzare un'implementazione più leggera per addestrare lo stesso modello utilizzando risorse di calcolo inferiori, ottenendo solo una leggera diminuzione dell'accuratezza.\n" + "Puoi vedere che compiti più complessi che stiamo risolvendo ora richiedono un maggiore potere computazionale e non possono essere facilmente risolti sulla CPU. Nell'unità successiva, proveremo a utilizzare un'implementazione più leggera per addestrare lo stesso modello usando risorse computazionali inferiori, con conseguente solo una leggermente inferiore accuratezza.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n---\n\n**Disclaimer**: \nQuesto documento è stato tradotto utilizzando il servizio di traduzione automatica [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un traduttore umano. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione.\n" + "---\n\n\n**Disclaimer**:\nQuesto documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire la precisione, si prega di notare che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un essere umano. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall’uso di questa traduzione.\n\n" ] } ], @@ -1483,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-28T13:04:48+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "it" } }, "nbformat": 4, diff --git a/translations/it/lessons/5-NLP/README.md b/translations/it/lessons/5-NLP/README.md index 77bcc6c6..87f6903b 100644 --- a/translations/it/lessons/5-NLP/README.md +++ b/translations/it/lessons/5-NLP/README.md @@ -1,51 +1,51 @@ # Elaborazione del Linguaggio Naturale -![Riepilogo dei compiti NLP in uno schizzo](../../../../translated_images/it/ai-nlp.b22dcb8ca4707cea.webp) +![Riepilogo dei compiti di NLP in uno schizzo](../../../../translated_images/it/ai-nlp.b22dcb8ca4707cea.webp) -In questa sezione ci concentreremo sull'utilizzo delle reti neurali per gestire compiti legati all'**Elaborazione del Linguaggio Naturale (NLP)**. Ci sono molti problemi di NLP che vogliamo che i computer siano in grado di risolvere: +In questa sezione, ci concentreremo sull'uso delle Reti Neurali per affrontare compiti correlati all'**Elaborazione del Linguaggio Naturale (NLP)**. Ci sono molti problemi di NLP che vogliamo che i computer siano in grado di risolvere: -* **Classificazione del testo** è un tipico problema di classificazione relativo alle sequenze di testo. Gli esempi includono la classificazione di e-mail come spam o non-spam, o la categorizzazione di articoli come sport, economia, politica, ecc. Inoltre, nello sviluppo di chatbot, spesso dobbiamo capire cosa l'utente vuole dire -- in questo caso ci occupiamo della **classificazione dell'intento**. Spesso, nella classificazione dell'intento, dobbiamo gestire molte categorie. -* **Analisi del sentiment** è un tipico problema di regressione, dove dobbiamo attribuire un numero (un sentiment) che corrisponde a quanto positivo/negativo è il significato di una frase. Una versione più avanzata dell'analisi del sentiment è l'**analisi del sentiment basata sugli aspetti** (ABSA), dove attribuiamo il sentiment non all'intera frase, ma a diverse parti di essa (aspetti), ad esempio: *In questo ristorante, mi è piaciuta la cucina, ma l'atmosfera era terribile*. -* **Riconoscimento delle entità nominate** (NER) si riferisce al problema di estrarre determinate entità dal testo. Ad esempio, potremmo dover capire che nella frase *Devo volare a Parigi domani* la parola *domani* si riferisce a una DATA, e *Parigi* è una LOCALITÀ. -* **Estrazione di parole chiave** è simile al NER, ma dobbiamo estrarre automaticamente le parole importanti per il significato della frase, senza pre-addestramento per tipi specifici di entità. +* **Classificazione del testo** è un tipico problema di classificazione che riguarda sequenze di testo. Esempi includono la classificazione di messaggi e-mail come spam o non spam, o la categorizzazione di articoli in sport, economia, politica, ecc. Inoltre, nello sviluppo di chatbot, spesso è necessario comprendere cosa l'utente voleva dire -- in questo caso si tratta di **classificazione dell'intento**. Spesso, nella classificazione dell'intento, dobbiamo gestire molte categorie. +* **Analisi del sentiment** è un tipico problema di regressione, dove dobbiamo attribuire un numero (un sentiment) corrispondente a quanto positivo/negativo sia il significato di una frase. Una versione più avanzata dell'analisi del sentiment è l'**analisi del sentiment basata sugli aspetti** (ABSA), dove attribuiamo sentiment non all'intera frase, ma a parti diverse di essa (aspetti), ad esempio *In questo ristorante, mi è piaciuta la cucina, ma l'atmosfera era orribile*. +* **Named Entity Recognition** (NER) si riferisce al problema di estrarre certe entità dal testo. Per esempio, potremmo dover capire che nella frase *Devo volare a Parigi domani* la parola *domani* si riferisce a una DATA, e *Parigi* è una LOCALITÀ. +* **Estrazione di parole chiave** è simile alla NER, ma dobbiamo estrarre automaticamente parole importanti per il significato della frase, senza un pre-addestramento per tipi specifici di entità. * **Clustering del testo** può essere utile quando vogliamo raggruppare insieme frasi simili, ad esempio, richieste simili nelle conversazioni di supporto tecnico. -* **Risposta alle domande** si riferisce alla capacità di un modello di rispondere a una domanda specifica. Il modello riceve un passaggio di testo e una domanda come input, e deve fornire un punto nel testo dove si trova la risposta alla domanda (o, a volte, generare il testo della risposta). -* **Generazione di testo** è la capacità di un modello di generare nuovo testo. Può essere considerato un compito di classificazione che prevede la prossima lettera/parola basandosi su un *prompt di testo*. Modelli avanzati di generazione di testo, come GPT-3, sono in grado di risolvere altri compiti NLP utilizzando una tecnica chiamata [programmazione tramite prompt](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) o [ingegneria dei prompt](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). -* **Riassunto del testo** è una tecnica in cui vogliamo che un computer "legga" un testo lungo e lo riassuma in poche frasi. -* **Traduzione automatica** può essere vista come una combinazione di comprensione del testo in una lingua e generazione di testo in un'altra. +* **Risposta a domande** si riferisce alla capacità di un modello di rispondere a una domanda specifica. Il modello riceve in input un passaggio di testo e una domanda, e deve fornire un luogo nel testo dove la risposta alla domanda è contenuta (o, talvolta, generare il testo della risposta). +* **Generazione di testo** è la capacità di un modello di generare nuovo testo. Può essere considerata come un compito di classificazione che predice la lettera/parola successiva basandosi su un *prompt di testo*. Modelli avanzati di generazione testuale, come GPT-3, sono in grado di risolvere altri compiti di NLP come la classificazione usando una tecnica chiamata [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) o [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **Sintesi del testo** è una tecnica in cui vogliamo che un computer "legga" un testo lungo e lo riassuma in poche frasi. +* **Traduzione automatica** può essere vista come una combinazione della comprensione del testo in una lingua e della generazione del testo in un'altra. -Inizialmente, la maggior parte dei compiti NLP veniva risolta utilizzando metodi tradizionali come le grammatiche. Ad esempio, nella traduzione automatica venivano utilizzati parser per trasformare la frase iniziale in un albero sintattico, poi venivano estratte strutture semantiche di livello superiore per rappresentare il significato della frase, e basandosi su questo significato e sulla grammatica della lingua di destinazione veniva generato il risultato. Oggi, molti compiti NLP vengono risolti in modo più efficace utilizzando reti neurali. +Inizialmente, la maggior parte dei compiti di NLP venivano risolti usando metodi tradizionali come le grammatiche. Ad esempio, nella traduzione automatica venivano usati parser per trasformare la frase iniziale in un albero sintattico, poi venivano estratte strutture semantiche di livello superiore per rappresentare il significato della frase, e basandosi su questo significato e sulla grammatica della lingua di destinazione veniva generato il risultato. Oggi molti compiti di NLP sono risolti in modo più efficace usando reti neurali. -> Molti metodi classici di NLP sono implementati nella libreria Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). È disponibile online un ottimo [Libro NLTK](https://www.nltk.org/book/) che copre come diversi compiti NLP possono essere risolti utilizzando NLTK. +> Molti metodi classici di NLP sono implementati nella libreria Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). È disponibile online un ottimo [Libro NLTK](https://www.nltk.org/book/) che spiega come diversi compiti di NLP possano essere risolti usando NLTK. -Nel nostro corso, ci concentreremo principalmente sull'utilizzo delle reti neurali per il NLP, e utilizzeremo NLTK dove necessario. +Nel nostro corso, ci concentreremo principalmente sull’uso delle Reti Neurali per NLP, e utilizzeremo NLTK quando necessario. -Abbiamo già imparato a utilizzare le reti neurali per gestire dati tabulari e immagini. La principale differenza tra questi tipi di dati e il testo è che il testo è una sequenza di lunghezza variabile, mentre la dimensione dell'input nel caso delle immagini è nota in anticipo. Mentre le reti convoluzionali possono estrarre schemi dai dati di input, gli schemi nel testo sono più complessi. Ad esempio, possiamo avere una negazione separata dal soggetto da molte parole (ad esempio: *Non mi piacciono le arance*, vs. *Non mi piacciono quelle grandi arance colorate e gustose*), e ciò dovrebbe comunque essere interpretato come un unico schema. Pertanto, per gestire il linguaggio dobbiamo introdurre nuovi tipi di reti neurali, come le *reti ricorrenti* e i *transformer*. +Abbiamo già imparato a usare reti neurali per lavorare con dati tabellari e immagini. La principale differenza tra quei tipi di dati e il testo è che il testo è una sequenza di lunghezza variabile, mentre la dimensione dell’input nel caso delle immagini è nota in anticipo. Mentre le reti convoluzionali possono estrarre pattern dai dati di input, i pattern nel testo sono più complessi. Ad esempio, possiamo avere una negazione separata dal soggetto da un numero arbitrario di parole (es. *Non mi piacciono le arance*, vs. *Non mi piacciono quelle grosse arance colorate e gustose*), e ciò dovrebbe ancora essere interpretato come un unico pattern. Quindi, per gestire il linguaggio, dobbiamo introdurre nuovi tipi di reti neurali, come le *reti ricorrenti* e i *transformers*. -## Installare le librerie +## Installazione delle librerie -Se stai utilizzando un'installazione locale di Python per eseguire questo corso, potresti dover installare tutte le librerie necessarie per il NLP utilizzando i seguenti comandi: +Se stai usando un’installazione locale di Python per seguire questo corso, potresti dover installare tutte le librerie necessarie per NLP utilizzando i seguenti comandi: **Per PyTorch** ```bash -pip install -r requirements-torch.txt +pip install -r requirements-pytorch.txt ``` **Per TensorFlow** ```bash pip install -r requirements-tf.txt ``` -> Puoi provare il NLP con TensorFlow su [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) +> Puoi provare NLP con TensorFlow su [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) ## Avviso GPU -In questa sezione, in alcuni esempi alleneremo modelli piuttosto grandi. -* **Usa un computer con GPU**: È consigliabile eseguire i tuoi notebook su un computer con GPU per ridurre i tempi di attesa quando lavori con modelli grandi. -* **Vincoli di memoria GPU**: L'esecuzione su GPU può portare a situazioni in cui esaurisci la memoria GPU, specialmente durante l'addestramento di modelli grandi. -* **Consumo di memoria GPU**: La quantità di memoria GPU consumata durante l'addestramento dipende da vari fattori, inclusa la dimensione del minibatch. -* **Riduci la dimensione del minibatch**: Se riscontri problemi di memoria GPU, considera di ridurre la dimensione del minibatch nel tuo codice come possibile soluzione. -* **Rilascio della memoria GPU in TensorFlow**: Le versioni più vecchie di TensorFlow potrebbero non rilasciare correttamente la memoria GPU durante l'addestramento di più modelli all'interno di un kernel Python. Per gestire efficacemente l'uso della memoria GPU, puoi configurare TensorFlow per allocare memoria GPU solo quando necessario. -* **Inclusione del codice**: Per impostare TensorFlow affinché cresca l'allocazione della memoria GPU solo quando richiesto, includi il seguente codice nei tuoi notebook: +In questa sezione, in alcuni degli esempi alleneremo modelli piuttosto grandi. +* **Usa un computer con GPU abilitata**: È consigliabile eseguire i tuoi notebook su un computer con GPU abilitata per ridurre i tempi di attesa quando si lavora con modelli grandi. +* **Vincoli di memoria GPU**: L'esecuzione su GPU può portare a situazioni in cui la memoria GPU si esaurisce, specialmente durante l’addestramento di modelli grandi. +* **Consumo di memoria GPU**: La quantità di memoria GPU consumata durante l’addestramento dipende da vari fattori, inclusa la dimensione del minibatch. +* **Minimizza la dimensione del minibatch**: Se riscontri problemi di memoria GPU, considera di ridurre la dimensione del minibatch nel tuo codice come possibile soluzione. +* **Rilascio di memoria GPU in TensorFlow**: Versioni più vecchie di TensorFlow possono non rilasciare correttamente la memoria GPU quando si addestrano più modelli all'interno dello stesso kernel Python. Per gestire efficacemente l’uso della memoria GPU, puoi configurare TensorFlow per allocare la memoria GPU solo quando necessario. +* **Inclusione del codice**: Per impostare TensorFlow in modo che cresca nell’allocazione della memoria GPU solo quando richiesto, includi il seguente codice nei tuoi notebook: ```python physical_devices = tf.config.list_physical_devices('GPU') @@ -53,7 +53,7 @@ if len(physical_devices)>0: tf.config.experimental.set_memory_growth(physical_devices[0], True) ``` -Se sei interessato a imparare il NLP da una prospettiva di ML classico, visita [questa suite di lezioni](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) +Se sei interessato a imparare NLP da una prospettiva classica di ML, visita [questa serie di lezioni](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) ## In questa sezione In questa sezione impareremo: @@ -61,9 +61,13 @@ In questa sezione impareremo: * [Rappresentare il testo come tensori](13-TextRep/README.md) * [Word Embeddings](14-Emdeddings/README.md) * [Modellazione del linguaggio](15-LanguageModeling/README.md) -* [Reti neurali ricorrenti](16-RNN/README.md) +* [Reti Neurali Ricorrenti](16-RNN/README.md) * [Reti generative](17-GenerativeNetworks/README.md) * [Transformers](18-Transformers/README.md) -**Disclaimer**: -Questo documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un esperto umano. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file +--- + + +**Disclaimer**: +Questo documento è stato tradotto utilizzando il servizio di traduzione AI [Co-op Translator](https://github.com/Azure/co-op-translator). Sebbene ci impegniamo per garantire la precisione, si prega di notare che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un essere umano. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall’uso di questa traduzione. + \ No newline at end of file diff --git a/translations/pt-BR/.co-op-translator.json b/translations/pt-BR/.co-op-translator.json index c40e6199..e618494f 100644 --- a/translations/pt-BR/.co-op-translator.json +++ b/translations/pt-BR/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "pt-BR" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T21:15:24+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "pt-BR" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T21:05:36+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "pt-BR" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "pt-BR", + "failure_date": "2026-07-08T21:09:34+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.", + "translator_version": "0.20.0", + "failure_policy_version": 1 + } + }, "etc/CODE_OF_CONDUCT.md": { "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56", "translation_date": "2025-08-26T11:17:41+00:00", @@ -54,8 +73,8 @@ "language_code": "pt-BR" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:29:59+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T21:04:26+00:00", "source_file": "examples/README.md", "language_code": "pt-BR" }, @@ -66,8 +85,8 @@ "language_code": "pt-BR" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-15T14:16:59+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T21:04:52+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "pt-BR" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "pt-BR" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T20:56:31+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "pt-BR" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-26T09:53:39+00:00", @@ -330,8 +355,8 @@ "language_code": "pt-BR" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-26T08:06:50+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T21:05:22+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "pt-BR" }, diff --git a/translations/pt-BR/CONTRIBUTING.md b/translations/pt-BR/CONTRIBUTING.md new file mode 100644 index 00000000..0ece534d --- /dev/null +++ b/translations/pt-BR/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# Contribuindo para AI-For-Beginners + +Obrigado pelo seu interesse em contribuir para o AI-For-Beginners! Agradecemos traduções, correções de lições e ajustes de formatação. + +## Acordo de Licença de Contribuidor (CLA) da Microsoft + +Este projeto aceita contribuições e sugestões. A maioria das contribuições requer que você concorde com um Acordo de Licença de Contribuidor (CLA) declarando que você tem o direito e de fato concede a nós os direitos de usar sua contribuição. Para mais detalhes, visite [https://cla.microsoft.com](https://cla.microsoft.com). + +Quando você enviar um pull request, um bot CLA determinará automaticamente se você precisa fornecer um CLA e marcará o PR apropriadamente (por exemplo, etiqueta, comentário). Basta seguir as instruções fornecidas pelo bot. Você precisará fazer isso apenas uma vez em todos os repositórios que usam nosso CLA. + +## Como Contribuir + +### 1. Corrigindo Erros de Digitação / Código +Se você encontrar um erro de digitação ou bug em qualquer notebook Jupyter ou arquivo markdown de lição: +1. Faça um fork do repositório. +2. Corrija o erro de digitação ou link quebrado. +3. Envie um Pull Request com uma descrição clara da correção. + +### 2. Enviando Traduções +Agradecemos traduções das lições para outros idiomas! Por favor, coloque as traduções sob o diretório `translations/` usando os nomes de pasta existentes lá (por exemplo `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +Para mais detalhes, veja [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**Aviso Legal**: +Este documento foi traduzido usando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução. + \ No newline at end of file diff --git a/translations/pt-BR/examples/README.md b/translations/pt-BR/examples/README.md index dffaa735..947b42c1 100644 --- a/translations/pt-BR/examples/README.md +++ b/translations/pt-BR/examples/README.md @@ -1,27 +1,27 @@ # Exemplos de IA para Iniciantes -Bem-vindo! Este diretório contém exemplos simples e independentes para ajudá-lo a começar com IA e aprendizado de máquina. Cada exemplo foi projetado para ser acessível a iniciantes, com comentários detalhados e explicações passo a passo. +Bem-vindo! Este diretório contém exemplos simples e independentes para ajudá-lo a começar com IA e aprendizado de máquina. Cada exemplo é projetado para ser amigável para iniciantes, com comentários detalhados e explicações passo a passo. ## 📚 Visão Geral dos Exemplos | Exemplo | Descrição | Dificuldade | Pré-requisitos | |---------|-------------|------------|---------------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | Seu primeiro programa de IA - reconhecimento de padrões simples | ⭐ Iniciante | Noções básicas de Python | -| [Rede Neural Simples](../../../examples/02-simple-neural-network.py) | Construa uma rede neural do zero | ⭐⭐ Iniciante+ | Python, matemática básica | -| [Classificador de Imagens](./03-image-classifier.ipynb) | Classifique imagens com um modelo pré-treinado | ⭐⭐ Iniciante+ | Python, numpy | -| [Sentimento de Texto](../../../examples/04-text-sentiment.py) | Analise o sentimento de textos (positivo/negativo) | ⭐⭐ Iniciante+ | Python | +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Seu primeiro programa de IA - reconhecimento simples de padrões | ⭐ Iniciante | Noções básicas de Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Construa uma rede neural do zero | ⭐⭐ Iniciante+ | Python, matemática básica | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Classifique imagens com um modelo pré-treinado | ⭐⭐ Iniciante+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analise o sentimento do texto (positivo/negativo) | ⭐⭐ Iniciante+ | Python | ## 🚀 Começando ### Pré-requisitos -Certifique-se de ter o Python instalado (recomenda-se a versão 3.8 ou superior). Instale os pacotes necessários: +Certifique-se de ter o Python instalado (recomendado 3.8 ou superior). Instale os pacotes necessários: ```bash -# For Python scripts +# Para scripts Python pip install numpy -# For Jupyter notebooks (image classifier) +# Para notebooks Jupyter (classificador de imagens) pip install jupyter numpy pillow tensorflow ``` @@ -44,25 +44,25 @@ python 01-hello-ai-world.py jupyter notebook 03-image-classifier.ipynb ``` -## 📖 Caminho de Aprendizado +## 📖 Caminho de Aprendizagem Recomendamos seguir os exemplos na ordem: -1. **Comece com "Hello AI World"** - Aprenda o básico sobre reconhecimento de padrões -2. **Construa uma Rede Neural Simples** - Entenda como funcionam as redes neurais -3. **Experimente o Classificador de Imagens** - Veja a IA em ação com imagens reais -4. **Analise o Sentimento de Texto** - Explore o processamento de linguagem natural +1. **Comece com "Hello AI World"** - Aprenda o básico de reconhecimento de padrões +2. **Construa uma Rede Neural Simples** - Entenda como redes neurais funcionam +3. **Experimente o Classificador de Imagens** - Veja IA em ação com imagens reais +4. **Analise o Sentimento do Texto** - Explore o processamento de linguagem natural ## 💡 Dicas para Iniciantes -- **Leia os comentários do código com atenção** - Eles explicam o que cada linha faz +- **Leia atentamente os comentários no código** - Eles explicam o que cada linha faz - **Experimente!** - Tente alterar valores e veja o que acontece - **Não se preocupe em entender tudo de imediato** - Aprender leva tempo -- **Faça perguntas** - Use o [Fórum de Discussão](https://github.com/microsoft/AI-For-Beginners/discussions) +- **Faça perguntas** - Use o [quadro de discussões](https://github.com/microsoft/AI-For-Beginners/discussions) ## 🔗 Próximos Passos -Depois de concluir esses exemplos, explore o currículo completo: +Após completar estes exemplos, explore o currículo completo: - [Introdução à IA](../lessons/1-Intro/README.md) - [Redes Neurais](../lessons/3-NeuralNetworks/README.md) - [Visão Computacional](../lessons/4-ComputerVision/README.md) @@ -70,16 +70,18 @@ Depois de concluir esses exemplos, explore o currículo completo: ## 🤝 Contribuindo -Achou esses exemplos úteis? Ajude-nos a melhorá-los: -- Relate problemas ou sugira melhorias +Encontrou esses exemplos úteis? Ajude-nos a melhorá-los: +- Reporte problemas ou sugira melhorias - Adicione mais exemplos para iniciantes - Melhore a documentação e os comentários --- -*Lembre-se: Todo especialista já foi um iniciante. Boa aprendizagem! 🎓* +*Lembre-se: Todo especialista já foi um iniciante. Bom aprendizado! 🎓* --- -**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 automatizadas 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. \ No newline at end of file + +**Aviso Legal**: +Este documento foi traduzido usando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução. + \ No newline at end of file diff --git a/translations/pt-BR/lessons/0-course-setup/how-to-run.md b/translations/pt-BR/lessons/0-course-setup/how-to-run.md index 50824b6c..3ce55dd8 100644 --- a/translations/pt-BR/lessons/0-course-setup/how-to-run.md +++ b/translations/pt-BR/lessons/0-course-setup/how-to-run.md @@ -1,12 +1,12 @@ # Como Executar o Código -Este currículo contém muitos exemplos executáveis e laboratórios que você vai querer executar. Para isso, você precisa da capacidade de executar código Python nos Jupyter Notebooks fornecidos como parte deste currículo. Você tem várias opções para executar o código: +Este currículo contém muitos exemplos executáveis e laboratórios que você vai querer executar. Para isso, é necessário ter a capacidade de executar código Python em Jupyter Notebooks fornecidos como parte deste currículo. Você tem várias opções para executar o código: ## Executar localmente no seu computador -Para executar o código localmente no seu computador, é necessária uma instalação do Python. Uma recomendação é instalar o **[miniconda](https://conda.io/en/latest/miniconda.html)** - é uma instalação bastante leve que suporta o gerenciador de pacotes `conda` para diferentes **ambientes virtuais** Python. +Para executar o código localmente no seu computador, é necessária a instalação do Python. Uma recomendação é instalar o **[miniconda](https://conda.io/en/latest/miniconda.html)** - é uma instalação bastante leve que suporta o gerenciador de pacotes `conda` para diferentes **ambientes virtuais** de Python. -Depois de instalar o miniconda, clone o repositório e crie um ambiente virtual para ser usado neste curso: +Após instalar o miniconda, clone o repositório e crie um ambiente virtual para ser usado neste curso: ```bash git clone http://github.com/microsoft/ai-for-beginners @@ -17,55 +17,55 @@ conda activate ai4beg ### Usando Visual Studio Code com Extensão Python -Este currículo é melhor utilizado ao abri-lo no [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) com a [Extensão Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). +Este currículo é melhor utilizado quando aberto no [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) com a [Extensão Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). -> **Nota**: Após clonar e abrir o diretório no VS Code, ele automaticamente sugerirá a instalação das extensões Python. Você também precisará instalar o miniconda conforme descrito acima. +> **Nota**: Uma vez que você clona e abre o diretório no VS Code, ele automaticamente sugerirá a instalação das extensões Python. Você também deverá instalar o miniconda conforme descrito acima. -> **Nota**: Se o VS Code sugerir reabrir o repositório em um contêiner, você deve recusar para usar a instalação local do Python. +> **Nota**: Se o VS Code sugerir que você reabra o repositório em um container, você deve recusar para usar a instalação local do Python. ### Usando Jupyter no Navegador -Você também pode usar um ambiente Jupyter pelo navegador em seu próprio computador. Tanto o Jupyter clássico quanto o JupyterHub fornecem um ambiente de desenvolvimento conveniente com auto-completar, realce de código, etc. +Você também pode usar um ambiente Jupyter a partir do navegador no seu próprio computador. Tanto o Jupyter clássico quanto o JupyterHub oferecem um ambiente de desenvolvimento conveniente com autocompletar, realce de código, etc. -Para iniciar o Jupyter localmente, vá para o diretório do curso e execute: +Para iniciar o Jupyter localmente, vá ao diretório do curso e execute: ```bash jupyter notebook ``` -ou + ou ```bash jupyterhub ``` -Depois você pode navegar para qualquer arquivo `.ipynb`, abri-lo e começar a trabalhar. + Você então pode navegar até qualquer um dos arquivos `.ipynb`, abri-los e começar a trabalhar. -### Executando em contêiner +### Executando em container -Uma alternativa à instalação do Python seria executar o código em um contêiner. Como nosso repositório fornece uma pasta especial `.devcontainer` que instrui como construir um contêiner para este repositório, o VS Code oferece a oportunidade de reabrir o código em um contêiner. Isso requer a instalação do Docker, e também seria mais complexo, então recomendamos isso para usuários mais experientes. +Uma alternativa à instalação do Python é executar o código em um container. Como nosso repositório fornece uma pasta especial `.devcontainer` que indica como construir um container para este repositório, o VS Code oferece a oportunidade de reabrir o código em um container. Isso exigirá a instalação do Docker e será mais complexo, por isso recomendamos para usuários mais experientes. ## Executando na Nuvem -Se você não quiser instalar o Python localmente e tiver acesso a alguns recursos na nuvem - uma boa alternativa seria executar o código na nuvem. Existem várias formas de fazer isso: +Se você não quiser instalar o Python localmente e tiver acesso a alguns recursos na nuvem, uma boa alternativa é executar o código na nuvem. Há várias maneiras de fazer isso: -* Usando **[GitHub Codespaces](https://github.com/features/codespaces)**, que é um ambiente virtual criado para você no GitHub, acessível através da interface do navegador do VS Code. Se você tem acesso ao Codespaces, basta clicar no botão **Code** no repositório, iniciar um codespace e começar a trabalhar rapidamente. -* Usando **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) oferece recursos computacionais gratuitos na nuvem para pessoas como você testarem algum código no GitHub. Há um botão na página principal para abrir o repositório no Binder - isso deve levá-lo rapidamente ao site do binder, que construirá um contêiner subjacente e iniciará uma interface web Jupyter para você de forma transparente. +* Usando **[GitHub Codespaces](https://github.com/features/codespaces)**, que é um ambiente virtual criado para você no GitHub, acessível através da interface do VS Code no navegador. Se você tiver acesso ao Codespaces, basta clicar no botão **Code** no repositório, iniciar um codespace e começar rapidamente. +* Usando **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. O [Binder](https://mybinder.org) oferece recursos computacionais gratuitos fornecidos na nuvem para pessoas como você testarem algum código no GitHub. Há um botão na página inicial para abrir o repositório no Binder - isso deve levá-lo rapidamente ao site do binder, que construirá um container subjacente e iniciará uma interface web Jupyter para você sem dificuldades. -> **Nota**: Para evitar uso indevido, o Binder tem acesso a alguns recursos web bloqueado. Isso pode impedir o funcionamento de algum código que busca modelos e/ou conjuntos de dados na internet pública. Você pode precisar encontrar algumas soluções alternativas. Além disso, os recursos computacionais oferecidos pelo Binder são bastante básicos, então o treinamento será lento, especialmente em aulas mais complexas. +> **Nota**: Para evitar uso indevido, o Binder bloqueia o acesso a alguns recursos da web. Isso pode impedir que parte do código funcione, especialmente aqueles que buscam modelos e/ou conjuntos de dados da Internet pública. Você pode precisar encontrar algumas soluções alternativas. Além disso, os recursos de computação fornecidos pelo Binder são bastante básicos, então o treinamento será lento, especialmente em aulas mais avançadas e complexas. ## Executando na Nuvem com GPU -Algumas das aulas posteriores deste currículo se beneficiariam muito do suporte a GPU. O treinamento de modelos, por exemplo, pode ser dolorosamente lento sem isso. Existem algumas opções que você pode seguir, especialmente se tiver acesso à nuvem pela [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) ou pela sua instituição: +Algumas das aulas mais avançadas deste currículo se beneficiariam muito do suporte a GPU. O treinamento de modelos, por exemplo, pode ser extremamente lento sem isso. Há algumas opções que você pode seguir, especialmente se você tiver acesso à nuvem por meio do [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) ou através da sua instituição: -* Crie uma [Máquina Virtual de Ciência de Dados](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) e conecte-se a ela via Jupyter. Você pode então clonar o repositório diretamente na máquina e começar a aprender. VMs da série NC têm suporte a GPU. +* Criar uma [Máquina Virtual de Ciência de Dados](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) e conectar a ela através do Jupyter. Você pode então clonar o repositório diretamente na máquina e começar a aprender. Máquinas virtuais da série NC têm suporte a GPU. -> **Nota**: Algumas assinaturas, incluindo Azure for Students, não oferecem suporte a GPU por padrão. Você pode precisar solicitar núcleos GPU adicionais por meio de um pedido de suporte técnico. +> **Nota**: Algumas assinaturas, incluindo o Azure for Students, não fornecem suporte a GPU por padrão. Você pode precisar solicitar núcleos adicionais de GPU através de um pedido de suporte técnico. -* Crie um [Workspace do Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) e use o recurso Notebook nele. [Este vídeo](https://azure-for-academics.github.io/quickstart/azureml-papers/) mostra como clonar um repositório dentro do notebook Azure ML e começar a usar. +* Criar um [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) e depois usar o recurso de Notebooks lá. [Este vídeo](https://azure-for-academics.github.io/quickstart/azureml-papers/) mostra como clonar um repositório em um notebook do Azure ML e começar a usá-lo. -Você também pode usar o Google Colab, que oferece algum suporte gratuito a GPU, e fazer upload dos Jupyter Notebooks para executá-los um por um. +Você também pode usar o Google Colab, que oferece algum suporte gratuito a GPU, e fazer upload dos Jupyter Notebooks para executar um por um. --- -**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 autoritativa. Para informações críticas, recomendamos 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. +**Aviso Legal**: +Este documento foi traduzido usando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução. \ No newline at end of file diff --git a/translations/pt-BR/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/pt-BR/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index 35eb1927..65a06e60 100644 --- a/translations/pt-BR/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/pt-BR/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -6,9 +6,9 @@ "source": [ "# Modelos pré-treinados e aprendizado por transferência\n", "\n", - "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 utiliza 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 passar por todo o processo de treinamento?\n", + "Treinar CNNs pode levar muito tempo, e uma grande quantidade de dados é necessária para essa tarefa. No entanto, grande parte do tempo é gasto aprendendo os melhores filtros de baixo nível que uma rede usa para extrair padrões das imagens. Surge uma pergunta natural - podemos usar uma rede neural treinada em um conjunto de dados e adaptá-la para classificar imagens diferentes sem o processo completo de treinamento?\n", "\n", - "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 de forma eficaz, e em muitos casos, apenas construir um classificador em cima dessas características extraídas pode gerar bons resultados.\n" + "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 algum grande conjunto de dados de imagens, como o **ImageNet**. Esses modelos já conseguem extrair diferentes características de imagens genéricas de forma eficaz, e em muitos casos, construir apenas um classificador sobre essas características extraídas pode gerar um bom resultado.\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Conjunto de Dados Cats vs. Dogs\n", + "## Conjunto de Dados Gatos vs. Cachorros\n", "\n", - "Nesta unidade, vamos resolver um problema real de classificação de imagens de gatos e cachorros. Para isso, utilizaremos o [Conjunto de Dados Cats vs. Dogs do Kaggle](https://www.kaggle.com/c/dogs-vs-cats), que também pode ser baixado [da Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "Nesta unidade, resolveremos um problema da vida real de classificar imagens de gatos e cachorros. Por essa razão, usaremos o [Conjunto de Dados Gatos vs. Cachorros do Kaggle](https://www.kaggle.com/c/dogs-vs-cats), que também pode ser baixado [pela Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", - "Vamos baixar este conjunto de dados e extraí-lo no diretório `data` (este processo pode levar algum tempo!):\n" + "Vamos baixar esse conjunto de dados e extraí-lo no diretório `data` (esse processo pode levar algum tempo!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Infelizmente, há alguns arquivos de imagem corrompidos no conjunto de dados. Precisamos fazer uma limpeza rápida para verificar os arquivos corrompidos. Para não sobrecarregar este tutorial, movemos o código para verificar o conjunto de dados para um módulo.\n" + "Infelizmente, há alguns arquivos de imagem corrompidos no conjunto de dados. Precisamos fazer uma limpeza rápida para verificar arquivos corrompidos. Para não sobrecarregar este tutorial, movemos o código para verificar o conjunto de dados para um módulo.\n" ] }, { @@ -335,11 +335,11 @@ "source": [ "## Carregando o Conjunto de Dados\n", "\n", - "Nos exemplos anteriores, estávamos carregando conjuntos de dados que já vêm integrados ao Keras. Agora, vamos trabalhar com nosso próprio conjunto de dados, que precisamos carregar a partir de um diretório de imagens.\n", + "Nos exemplos anteriores, estávamos carregando conjuntos de dados que já vêm embutidos no Keras. Agora, vamos lidar com nosso próprio conjunto de dados, que precisamos carregar a partir de um diretório de imagens.\n", "\n", - "Na prática, o tamanho dos conjuntos de dados de imagens pode ser bastante grande, e não é possível contar com a capacidade de toda a informação caber na memória. Por isso, os conjuntos de dados geralmente são representados como **geradores**, que podem retornar dados em minibatches adequados para o treinamento.\n", + "Na vida real, o tamanho dos conjuntos de dados de imagens pode ser bastante grande, e não se pode contar que todos os dados caibam na memória. Assim, os conjuntos de dados geralmente são representados como **geradores** que podem retornar dados em minibatches adequados para treinamento.\n", "\n", - "Para lidar com classificação de imagens, o Keras inclui a função especial `image_dataset_from_directory`, que pode carregar imagens de subdiretórios correspondentes a diferentes classes. Essa função também cuida do escalonamento das imagens e pode dividir o conjunto de dados em subconjuntos de treino e teste:\n" + "Para lidar com a classificação de imagens, o Keras inclui a função especial `image_dataset_from_directory`, que pode carregar imagens de subdiretórios correspondentes a diferentes classes. Essa função também cuida da escala das imagens, e pode também dividir o conjunto de dados em subconjuntos de treino e teste:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "É importante definir o mesmo valor de `seed` para ambas as chamadas, pois isso afeta a divisão das imagens entre os conjuntos de treino e teste.\n", + "É importante definir o mesmo valor de `seed` para ambas as chamadas, pois isso afeta a divisão das imagens entre o conjunto de dados de treinamento e de teste.\n", "\n", - "O dataset identifica automaticamente os nomes das classes a partir dos diretórios, e você pode acessá-los, se necessário, chamando:\n" + "O Dataset pega automaticamente os nomes das classes a partir dos diretórios, e você pode acessá-los se necessário chamando:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Os conjuntos de dados que obtivemos podem ser passados diretamente para a função `fit` para treinar o modelo. Eles contêm tanto as imagens correspondentes quanto os rótulos, que podem ser iterados usando a seguinte construção:\n" + "Conjuntos de dados que obtivemos podem ser passados diretamente para a função `fit` para treinar o modelo. Eles contêm tanto as imagens correspondentes quanto os rótulos, que podem ser percorridos usando a seguinte construção:\n" ] }, { @@ -453,7 +453,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **Nota**: Todas as imagens no conjunto de dados são representadas como tensores de ponto flutuante com intervalo de 0-255. Antes de passá-las para a rede neural, precisamos escalar esses valores para o intervalo de 0-1. Ao plotar imagens, precisamos fazer o mesmo ou converter os valores para o tipo `int` (o que fazemos no código acima), para mostrar ao `matplotlib` que queremos plotar a imagem original não escalada.\n" + "> **Nota**: Todas as imagens no conjunto de dados são representadas como tensores de ponto flutuante com faixa de 0-255. Antes de passá-las para a rede neural, precisamos escalar esses valores para a faixa de 0-1. Ao plotar imagens, precisamos fazer o mesmo, ou converter os valores para o tipo `int` (como fazemos no código acima), para mostrar ao `matplotlib` que queremos plotar a imagem original não escalada.\n" ] }, { @@ -462,7 +462,7 @@ "source": [ "## Modelos pré-treinados\n", "\n", - "Para muitas tarefas de classificação de imagens, é possível encontrar modelos de redes neurais pré-treinados. Muitos desses modelos estão disponíveis no namespace `keras.applications`, e ainda mais modelos podem ser encontrados na Internet. Vamos ver como o modelo mais simples, o VGG-16, pode ser carregado e utilizado:\n" + "Para muitas tarefas de classificação de imagens, é possível encontrar modelos de redes neurais pré-treinados. Muitos desses modelos estão disponíveis dentro do namespace `keras.applications`, e ainda mais modelos podem ser encontrados na Internet. Vamos ver como o modelo mais simples, VGG-16, pode ser carregado e utilizado:\n" ] }, { @@ -497,7 +497,17 @@ } ], "source": [ - "vgg = keras.applications.VGG16()\n", + "# SHA-256 of VGG16 weights (with top)\n", + "VGG16_WEIGHTS_SHA256 = '64373286793e3c8b2b4e3219cbf3544bce2f55ab4682710a29f5e7af8f5e4f61'\n", + "\n", + "_weights_path = keras.utils.get_file(\n", + " 'vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " 'https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " file_hash=VGG16_WEIGHTS_SHA256,\n", + " hash_algorithm='sha256',\n", + ")\n", + "\n", + "vgg = keras.applications.VGG16(weights=_weights_path)\n", "inp = keras.applications.vgg16.preprocess_input(x_sample[:1])\n", "\n", "res = vgg(inp)\n", @@ -511,9 +521,9 @@ "metadata": {}, "source": [ "Há algumas coisas importantes aqui:\n", - "* Antes de passar uma entrada para qualquer rede pré-treinada, ela precisa ser pré-processada de uma maneira específica. Isso é feito chamando a função correspondente `preprocess_input`, que recebe um lote de imagens e retorna sua forma processada. No caso do VGG-16, as imagens são normalizadas, e um valor médio pré-definido para cada canal é subtraído. Isso ocorre porque o VGG-16 foi originalmente treinado com esse pré-processamento.\n", - "* A rede neural é aplicada ao lote de entrada, e recebemos como resultado um lote de tensores de 1000 elementos que mostram a probabilidade de cada classe. Podemos encontrar o número da classe mais provável chamando `argmax` nesse tensor.\n", - "* O resultado obtido é um [número de uma classe do `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Para interpretar esse resultado, também podemos usar a função `decode_predictions`, que retorna as n classes principais junto com seus nomes.\n" + "* Antes de passar uma entrada para qualquer rede pré-treinada, ela precisa ser pré-processada de uma certa forma. Isso é feito chamando a função correspondente `preprocess_input`, que recebe um lote de imagens e retorna sua forma processada. No caso do VGG-16, as imagens são normalizadas, e um valor médio pré-definido para cada canal é subtraído. Isso porque o VGG-16 foi originalmente treinado com esse pré-processamento.\n", + "* A rede neural é aplicada ao lote de entrada, e recebemos como resultado um lote de tensores de 1000 elementos que mostram a probabilidade de cada classe. Podemos encontrar o número da classe mais provável chamando `argmax` neste tensor.\n", + "* O resultado obtido é um [número de uma classe do `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Para fazer sentido desse resultado, também podemos usar a função `decode_predictions`, que retorna as n principais classes juntamente com seus nomes.\n" ] }, { @@ -599,7 +609,7 @@ "source": [ "## Computações em GPU\n", "\n", - "Redes neurais profundas, como a VGG-16 e outras arquiteturas mais modernas, exigem bastante poder computacional para serem executadas. Faz sentido utilizar aceleração por GPU, se estiver disponível. Felizmente, o Keras acelera automaticamente as computações na GPU, caso ela esteja disponível. Podemos verificar se o Tensorflow consegue usar a GPU com o seguinte código:\n" + "Redes neurais profundas, como a VGG-16 e outras arquiteturas mais modernas, exigem bastante poder computacional para executar. Faz sentido usar aceleração por GPU, se estiver disponível. Felizmente, o Keras acelera automaticamente os cálculos na GPU se ela estiver disponível. Podemos verificar se o Tensorflow é capaz de usar a GPU usando o seguinte código:\n" ] }, { @@ -626,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Extraindo características do VGG\n", "\n", - "Se quisermos usar o VGG-16 para extrair características de nossas imagens, precisamos do modelo sem as camadas finais de classificação. Podemos instanciar o modelo VGG-16 sem as camadas superiores usando este código:\n" + "## Extraindo características VGG\n", + "\n", + "Se quisermos usar o VGG-16 para extrair características das nossas imagens, precisamos do modelo sem as camadas finais de classificação. Podemos instanciar o modelo VGG-16 sem as camadas superiores usando este código:\n" ] }, { @@ -680,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A dimensão do tensor de características é 7x7x512, mas, para visualizá-lo, tivemos que remodelá-lo para uma forma 2D.\n", + "A dimensão do tensor de características é 7x7x512, mas para visualizá-la tivemos que remodelá-la para a forma 2D.\n", "\n", - "Agora, vamos tentar verificar se essas características podem ser usadas para classificar imagens. Vamos selecionar manualmente uma parte das imagens (50 minibatches, no nosso caso) e pré-computar seus vetores de características. Podemos usar a API **dataset** do Tensorflow para isso. A função `map` pega um conjunto de dados e aplica uma lambda-function fornecida para transformá-lo. Usamos esse mecanismo para construir novos conjuntos de dados, `ds_features_train` e `ds_features_test`, que contêm as características extraídas pelo VGG em vez das imagens originais.\n" + "Agora vamos tentar ver se essas características podem ser usadas para classificar imagens. Vamos manualmente pegar uma parte das imagens (50 minibatches, no nosso caso), e pré-calcular seus vetores de características. Podemos usar a API **dataset** do Tensorflow para isso. A função `map` pega um conjunto de dados e aplica uma função lambda dada para transformá-lo. Usamos esse mecanismo para construir novos conjuntos de dados, `ds_features_train` e `ds_features_test`, que contêm características extraídas do VGG em vez das imagens originais.\n" ] }, { @@ -712,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Usamos a construção `.take(50)` para limitar o tamanho do conjunto de dados, a fim de acelerar nossa demonstração. Você pode, é claro, realizar este experimento no conjunto de dados completo.\n", + "Usamos a construção `.take(50)` para limitar o tamanho do conjunto de dados, para acelerar nossa demonstração. Você pode, claro, realizar este experimento no conjunto de dados completo.\n", "\n", - "Agora que temos um conjunto de dados com características extraídas, podemos treinar um classificador denso simples para distinguir entre gatos e cachorros. Esta rede receberá um vetor de características com formato (7,7,512) e produzirá uma saída que corresponde a um cachorro ou a um gato. Como se trata de uma classificação binária, usamos a função de ativação `sigmoid` e a perda `binary_crossentropy`.\n" + "Agora que temos um conjunto de dados com recursos extraídos, podemos treinar um classificador denso simples para distinguir entre gatos e cachorros. Esta rede receberá um vetor de recursos com formato (7,7,512) e produzirá uma saída que corresponde a um cachorro ou a um gato. Por se tratar de uma classificação binária, usamos a função de ativação `sigmoid` e a perda `binary_crossentropy`.\n" ] }, { @@ -743,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "O resultado é ótimo, conseguimos distinguir entre um gato e um cachorro com quase 95% de probabilidade! No entanto, testamos essa abordagem apenas em um subconjunto de todas as imagens, porque a extração manual de características parece levar muito tempo.\n", + "O resultado é ótimo, podemos distinguir entre um gato e um cachorro com quase 95% de probabilidade! No entanto, testamos essa abordagem apenas em um subconjunto de todas as imagens, porque a extração manual de características parece levar muito tempo.\n", "\n", - "## Transferência de aprendizado usando uma rede VGG\n", + "## Aprendizado por transferência usando uma rede VGG\n", "\n", - "Também podemos evitar o pré-cálculo manual das características utilizando a rede original VGG-16 como um todo durante o treinamento, adicionando o extrator de características à nossa rede como a primeira camada.\n", + "Também podemos evitar pré-calcular manualmente as características usando a rede VGG-16 original como um todo durante o treinamento, adicionando o extrator de características à nossa rede como a primeira camada.\n", "\n", - "A beleza da arquitetura do Keras é que o modelo VGG-16 que definimos acima também pode ser usado como uma camada em outra rede neural! Só precisamos construir uma rede com um classificador denso no topo dela e, em seguida, treinar toda a rede usando retropropagação.\n" + "A beleza da arquitetura Keras é que o modelo VGG-16 que definimos acima também pode ser usado como uma camada em outra rede neural! Só precisamos construir uma rede com um classificador denso em cima dela, e então treinar toda a rede usando retropropagação.\n" ] }, { @@ -793,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Este modelo parece uma rede de classificação de ponta a ponta, que recebe uma imagem e retorna a classe. No entanto, o desafio aqui é que queremos que o VGG16 atue como um extrator de características, e não seja re-treinado. Portanto, precisamos **congelar os pesos do extrator de características convolucional**. Podemos acessar a primeira camada da rede chamando `model.layers[0]`, e só precisamos definir a propriedade `trainable` como `False`.\n", + "Este modelo se parece com uma rede de classificação de ponta a ponta, que recebe uma imagem e retorna a classe. No entanto, o complicado é que queremos que o VGG16 atue como um extrator de características, e não seja re-treinado. Assim, precisamos **congelar os pesos do extrator de características convolucionais**. Podemos acessar a primeira camada da rede chamando `model.layers[0]`, e só precisamos definir a propriedade `trainable` como `False`.\n", "\n", - "> **Nota**: O congelamento dos pesos do extrator de características é necessário, porque, caso contrário, a camada de classificação não treinada pode destruir os pesos originais pré-treinados do extrator convolucional.\n", + "> **Nota**: O congelamento dos pesos do extrator de características é necessário, porque caso contrário a camada de classificador não treinada pode destruir os pesos pré-treinados originais do extrator convolucional.\n", "\n", - "Você pode notar que, embora o número total de parâmetros na nossa rede seja em torno de 15 milhões, estamos treinando apenas 25 mil parâmetros. Todos os outros parâmetros dos filtros convolucionais de alto nível já estão pré-treinados. Isso é bom, porque conseguimos ajustar um número menor de parâmetros com um número menor de exemplos.\n", + "Você pode notar que, enquanto o número total de parâmetros em nossa rede é de cerca de 15 milhões, estamos treinando apenas 25 mil parâmetros. Todos os outros parâmetros dos filtros convolucionais de nível superior são pré-treinados. Isso é bom, pois podemos ajustar um número menor de parâmetros com uma quantidade menor de exemplos.\n", "\n", - "Agora vamos treinar nossa rede e ver quão boa ela pode ficar. Espere um tempo de execução relativamente longo e não se preocupe se a execução parecer travada por algum tempo.\n" + "Agora vamos treinar nossa rede e ver o quão bom podemos chegar. Espere um tempo de execução relativamente longo, e não se preocupe se a execução parecer congelada por algum tempo.\n" ] }, { @@ -824,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Parece que conseguimos um classificador de gatos vs. cachorros razoavelmente preciso!\n", + "Parece que conseguimos um classificador razoavelmente preciso para gatos vs. cães! \n", "\n", "## Salvando e Carregando o Modelo\n", "\n", - "Depois de treinar o modelo, podemos salvar a arquitetura do modelo e os pesos treinados em um arquivo para uso futuro:\n" + "Uma vez que treinamos o modelo, podemos salvar a arquitetura do modelo e os pesos treinados em um arquivo para uso futuro:\n" ] }, { @@ -852,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Podemos então carregar o modelo a partir do arquivo a qualquer momento. Você pode achar isso útil caso o próximo experimento destrua o modelo - assim, você não precisaria começar do zero.\n" + "Podemos então carregar o modelo do arquivo a qualquer momento. Você pode achar isso útil caso o próximo experimento destrua o modelo - você não precisaria recomeçar do zero.\n" ] }, { @@ -868,15 +879,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Ajustando o aprendizado por transferência\n", + "## Transfer learning com fine-tuning\n", "\n", - "Na seção anterior, treinamos a camada final do classificador para classificar imagens em nosso próprio conjunto de dados. No entanto, não re-treinamos o extrator de características, e nosso modelo se baseou nas características que ele aprendeu com os dados do ImageNet. Se os seus objetos diferem visualmente das imagens comuns do ImageNet, essa combinação de características pode não funcionar da melhor forma. Por isso, faz sentido começar a treinar também as camadas convolucionais.\n", + "Na seção anterior, treinamos a camada final do classificador para classificar imagens em nosso próprio conjunto de dados. No entanto, não re-treinamos o extrator de características, e nosso modelo contou com as características que o modelo aprendeu nos dados do ImageNet. Se seus objetos forem visualmente diferentes das imagens comuns do ImageNet, essa combinação de características pode não funcionar melhor. Portanto, faz sentido começar a treinar as camadas convolucionais também.\n", "\n", - "Para fazer isso, podemos \"descongelar\" os parâmetros dos filtros convolucionais que havíamos \"congelado\" anteriormente.\n", + "Para isso, podemos descongelar os parâmetros dos filtros convolucionais que havíamos congelado anteriormente.\n", "\n", - "> **Nota:** É importante que você congele os parâmetros primeiro e realize várias épocas de treinamento para estabilizar os pesos na camada de classificação. Se você começar imediatamente a treinar a rede de ponta a ponta com os parâmetros descongelados, erros grandes podem destruir os pesos pré-treinados nas camadas convolucionais.\n", + "> **Nota:** É importante que você congele os parâmetros primeiro e realize várias épocas de treinamento para estabilizar os pesos na camada de classificação. Se você começar a treinar a rede end-to-end com os parâmetros descongelados imediatamente, grandes erros provavelmente destruirão os pesos pré-treinados nas camadas convolucionais.\n", "\n", - "Nosso modelo convolucional VGG-16 está localizado dentro da primeira camada e, por si só, consiste em muitas camadas. Podemos dar uma olhada na sua estrutura:\n" + "Nosso modelo convolucional VGG-16 está localizado dentro da primeira camada, e ele próprio consiste em muitas camadas. Podemos dar uma olhada na sua estrutura:\n" ] }, { @@ -944,7 +955,9 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "Podemos descongelar todas as camadas da base convolucional:\n" + ] }, { "cell_type": "code", @@ -959,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "No entanto, descongelar todos de uma vez não é a melhor ideia. Podemos primeiro descongelar apenas algumas camadas finais de convoluções, porque elas contêm padrões de nível mais alto que são relevantes para nossas imagens. Por exemplo, para começar, podemos congelar todas as camadas, exceto as últimas 4:\n" + "No entanto, descongelar todos eles de uma vez não é a melhor ideia. Podemos primeiro descongelar apenas algumas das últimas camadas de convolução, porque elas contêm padrões de nível mais alto que são relevantes para nossas imagens. Por exemplo, para começar, podemos congelar todas as camadas, exceto as últimas 4:\n" ] }, { @@ -1000,9 +1013,9 @@ "source": [ "Observe que o número de parâmetros treináveis aumentou significativamente, mas ainda está em torno de 50% de todos os parâmetros.\n", "\n", - "Após descongelar, podemos realizar mais algumas épocas de treinamento (em nosso exemplo, faremos apenas uma). Você também pode selecionar uma taxa de aprendizado menor para minimizar o impacto nos pesos pré-treinados. No entanto, mesmo com uma taxa de aprendizado baixa, é esperado que a precisão caia no início do treinamento, até finalmente alcançar um nível ligeiramente superior em comparação ao caso de pesos fixos.\n", + "Após descongelar, podemos fazer mais algumas épocas de treinamento (no nosso exemplo, faremos apenas uma). Você também pode selecionar uma taxa de aprendizado menor, para minimizar o impacto nos pesos pré-treinados. No entanto, mesmo com taxa de aprendizado baixa, você pode esperar que a precisão caia no início do treinamento, até finalmente atingir um nível ligeiramente mais alto do que no caso de pesos fixos.\n", "\n", - "> **Note:** Este treinamento ocorre muito mais lentamente, porque precisamos propagar os gradientes de volta através de muitas camadas da rede!\n" + "> **Nota:** Este treinamento acontece muito mais devagar, porque precisamos propagar os gradientes de volta por muitas camadas da rede!\n" ] }, { @@ -1026,9 +1039,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "É provável que alcancemos uma maior precisão no treinamento, porque estamos usando uma rede mais poderosa com mais parâmetros, mas a precisão na validação não aumentará tanto.\n", + "Provavelmente alcançaremos uma precisão de treinamento mais alta, porque estamos usando uma rede mais potente com mais parâmetros, mas a precisão de validação não aumentaria tanto.\n", "\n", - "Sinta-se à vontade para desbloquear mais algumas camadas da rede e treinar mais, para ver se consegue alcançar uma precisão maior!\n" + "Sinta-se à vontade para descongelar mais algumas camadas da rede e treinar mais, para ver se você consegue alcançar uma precisão maior!\n" ] }, { @@ -1037,7 +1050,7 @@ "source": [ "## Outros modelos de visão computacional\n", "\n", - "O VGG-16 é uma das arquiteturas mais simples de visão computacional. O Keras oferece muitas outras redes pré-treinadas. As mais frequentemente utilizadas entre elas são as arquiteturas **ResNet**, desenvolvidas pela Microsoft, e **Inception**, do Google. Por exemplo, vamos explorar a arquitetura do modelo ResNet-50 mais simples (ResNet é uma família de modelos com diferentes profundidades; você pode experimentar com o ResNet-152 se quiser ver como é um modelo realmente profundo):\n" + "VGG-16 é uma das arquiteturas de visão computacional mais simples. O Keras fornece muitas outras redes pré-treinadas. As mais usadas entre elas são as arquiteturas **ResNet**, desenvolvidas pela Microsoft, e **Inception**, do Google. Por exemplo, vamos explorar a arquitetura do modelo ResNet-50 mais simples (ResNet é uma família de modelos com diferentes profundidades, você pode experimentar o ResNet-152 se quiser ver como é um modelo realmente profundo):\n" ] }, { @@ -1439,11 +1452,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Como você pode ver, o modelo contém os mesmos blocos familiares: camadas convolucionais, camadas de pooling e um classificador denso final. Podemos usar este modelo exatamente da mesma maneira que temos usado o VGG-16 para aprendizado por transferência. Você pode experimentar com o código acima, utilizando diferentes modelos ResNet como modelo base, e observar como a precisão muda.\n", + "Como você pode ver, o modelo contém os mesmos blocos familiares: camadas convolucionais, camadas de pooling e o classificador denso final. Podemos usar este modelo exatamente da mesma forma que temos usado o VGG-16 para aprendizado por transferência. Você pode tentar experimentar com o código acima, usando diferentes modelos ResNet como o modelo base, e ver como a precisão muda.\n", "\n", - "## Normalização de Lote\n", + "## Normalização em Lote\n", "\n", - "Esta rede contém mais um tipo de camada: **Normalização de Lote**. A ideia da normalização de lote é trazer os valores que fluem pela rede neural para o intervalo correto. Geralmente, redes neurais funcionam melhor quando todos os valores estão na faixa de [-1,1] ou [0,1], e é por isso que escalamos/normalizamos nossos dados de entrada de forma correspondente. No entanto, durante o treinamento de uma rede profunda, pode acontecer de os valores ficarem significativamente fora dessa faixa, o que torna o treinamento problemático. A camada de normalização de lote calcula a média e o desvio padrão para todos os valores do minibatch atual e os utiliza para normalizar o sinal antes de passá-lo por uma camada da rede neural. Isso melhora significativamente a estabilidade de redes profundas.\n" + "Esta rede contém ainda outro tipo de camada: **Normalização em Lote**. A ideia da normalização em lote é trazer os valores que fluem pela rede neural para o intervalo correto. Normalmente, redes neurais funcionam melhor quando todos os valores estão no intervalo de [-1,1] ou [0,1], e essa é a razão pela qual escalamos/normalizamos nossos dados de entrada de acordo. No entanto, durante o treinamento de uma rede profunda, pode acontecer de os valores saírem significativamente desse intervalo, o que torna o treinamento problemático. A camada de normalização em lote calcula a média e o desvio padrão para todos os valores do minibatch atual, e os usa para normalizar o sinal antes de passá-lo pela camada da rede neural. Isso melhora significativamente a estabilidade das redes profundas.\n" ] }, { @@ -1452,16 +1465,16 @@ "source": [ "## Conclusão\n", "\n", - "Utilizando aprendizado por transferência, conseguimos montar rapidamente um classificador para nossa tarefa personalizada de classificação de objetos e alcançar alta precisão. No entanto, este exemplo não foi completamente justo, pois a rede original VGG-16 foi pré-treinada para reconhecer gatos e cachorros, e, assim, estávamos apenas reutilizando a maioria dos padrões que já estavam presentes na rede. Você pode esperar uma precisão menor em objetos mais exóticos e específicos de domínio, como detalhes em uma linha de produção em uma fábrica ou diferentes tipos de folhas de árvores.\n", + "Usando aprendizado por transferência, conseguimos montar rapidamente um classificador para nossa tarefa personalizada de classificação de objetos e alcançar alta precisão. No entanto, este exemplo não foi completamente justo, pois a rede VGG-16 original foi pré-treinada para reconhecer gatos e cachorros, e assim estávamos apenas reutilizando a maioria dos padrões que já estavam presentes na rede. Você pode esperar uma precisão menor para objetos mais exóticos e específicos de domínio, como detalhes na linha de produção de uma fábrica ou diferentes folhas de árvores.\n", "\n", - "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 utilizando menos recursos computacionais, o que resulta em uma precisão apenas ligeiramente menor.\n" + "Pode-se notar que tarefas mais complexas que estamos resolvendo agora exigem maior poder computacional e não podem ser facilmente resolvidas na CPU. Na próxima unidade, vamos tentar usar uma implementação mais leve para treinar o mesmo modelo usando recursos computacionais menores, o que resultará em uma precisão apenas ligeiramente inferior.\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, esteja ciente de que traduções automatizadas 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.\n" + "---\n\n\n**Aviso Legal**:\nEste documento foi traduzido usando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.\n\n" ] } ], @@ -1482,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-28T13:03:25+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "br" } }, "nbformat": 4, diff --git a/translations/pt-BR/lessons/5-NLP/README.md b/translations/pt-BR/lessons/5-NLP/README.md index 079d6144..35f5d692 100644 --- a/translations/pt-BR/lessons/5-NLP/README.md +++ b/translations/pt-BR/lessons/5-NLP/README.md @@ -1,34 +1,34 @@ # Processamento de Linguagem Natural -![Resumo das tarefas de PLN em um desenho](../../../../translated_images/pt-BR/ai-nlp.b22dcb8ca4707cea.webp) +![Resumo das tarefas de PLN em um rabisco](../../../../translated_images/pt-BR/ai-nlp.b22dcb8ca4707cea.webp) -Nesta seção, vamos focar no uso de Redes Neurais para lidar com tarefas relacionadas ao **Processamento de Linguagem Natural (PLN)**. Existem muitos problemas de PLN que queremos que os computadores sejam capazes de resolver: +Nesta seção, iremos focar no uso de Redes Neurais para lidar com tarefas relacionadas a **Processamento de Linguagem Natural (PLN)**. Existem muitos problemas de PLN que queremos que os computadores consigam resolver: -* **Classificação de texto** é um problema típico de classificação relacionado a sequências de texto. Exemplos incluem classificar mensagens de e-mail como spam ou não-spam, ou categorizar artigos como esportes, negócios, política, etc. Além disso, ao desenvolver chatbots, frequentemente precisamos entender o que o usuário quis dizer — nesse caso, estamos lidando com **classificação de intenção**. Muitas vezes, na classificação de intenção, precisamos lidar com muitas categorias. -* **Análise de sentimento** é um problema típico de regressão, onde precisamos atribuir um número (um sentimento) correspondente ao quão positivo/negativo é o significado de uma frase. Uma versão mais avançada da análise de sentimento é a **análise de sentimento baseada em aspectos** (ABSA), onde atribuímos o sentimento não à frase inteira, mas a diferentes partes dela (aspectos), por exemplo: *Neste restaurante, gostei da culinária, mas a atmosfera era horrível*. -* **Reconhecimento de Entidades Nomeadas** (NER) refere-se ao problema de extrair certas entidades de um texto. Por exemplo, podemos precisar entender que na frase *Preciso voar para Paris amanhã* a palavra *amanhã* refere-se a uma DATA, e *Paris* é um LOCAL. -* **Extração de palavras-chave** é semelhante ao NER, mas precisamos extrair palavras importantes para o significado da frase automaticamente, sem pré-treinamento para tipos específicos de entidades. -* **Agrupamento de texto** pode ser útil quando queremos agrupar frases semelhantes, por exemplo, solicitações similares em conversas de suporte técnico. -* **Resposta a perguntas** refere-se à capacidade de um modelo de responder a uma pergunta específica. O modelo recebe um trecho de texto e uma pergunta como entradas, e precisa fornecer um local no texto onde a resposta à pergunta está contida (ou, às vezes, gerar o texto da resposta). -* **Geração de texto** é a capacidade de um modelo de gerar novo texto. Pode ser considerado como uma tarefa de classificação que prevê a próxima letra/palavra com base em algum *texto inicial*. Modelos avançados de geração de texto, como o GPT-3, são capazes de resolver outras tarefas de PLN usando uma técnica chamada [programação de prompts](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) ou [engenharia de prompts](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). -* **Resumo de texto** é uma técnica em que queremos que um computador "leia" um texto longo e o resuma em algumas frases. -* **Tradução automática** pode ser vista como uma combinação de compreensão de texto em um idioma e geração de texto em outro. +* **Classificação de texto** é um problema típico de classificação relacionado a sequências de texto. Exemplos incluem classificar mensagens de e-mail como spam vs. não-spam, ou categorizar artigos como esporte, negócios, política, etc. Além disso, ao desenvolver chatbots, frequentemente precisamos entender o que o usuário quis dizer – nesse caso, estamos lidando com **classificação de intenção**. Muitas vezes, na classificação de intenção, precisamos lidar com muitas categorias. +* **Análise de sentimento** é um problema típico de regressão, onde precisamos atribuir um número (um sentimento) correspondente a quão positivo/negativo é o significado de uma frase. Uma versão mais avançada da análise de sentimento é a **análise de sentimento baseada em aspectos** (ABSA), onde atribuímos sentimento não à frase inteira, mas a diferentes partes dela (aspectos), por exemplo, *Neste restaurante, gostei da culinária, mas a atmosfera estava horrível*. +* **Reconhecimento de Entidades Nomeadas** (NER) refere-se ao problema de extrair certas entidades de um texto. Por exemplo, pode ser necessário entender que na frase *Preciso voar para Paris amanhã* a palavra *amanhã* refere-se a DATA, e *Paris* é um LOCAL. +* **Extração de palavras-chave** é semelhante ao NER, mas precisamos extrair automaticamente palavras importantes para o significado da frase, sem treinamento prévio para tipos específicos de entidades. +* **Agrupamento de texto** pode ser útil quando queremos agrupar frases similares, por exemplo, pedidos semelhantes em conversas de suporte técnico. +* **Resposta a perguntas** refere-se à capacidade de um modelo responder a uma pergunta específica. O modelo recebe um trecho de texto e uma pergunta como entradas, e precisa indicar onde no texto a resposta está contida (ou, às vezes, gerar o texto da resposta). +* **Geração de texto** é a capacidade de um modelo criar novo texto. Pode ser considerado uma tarefa de classificação que prevê a próxima letra/palavra com base em algum *prompt de texto*. Modelos avançados de geração de texto, como o GPT-3, são capazes de resolver outras tarefas de PLN, como classificação, usando uma técnica chamada [programação de prompt](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) ou [engenharia de prompt](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **Resumir texto** é uma técnica para fazer um computador "ler" textos longos e resumi-los em poucas frases. +* **Tradução automática** pode ser vista como uma combinação de compreensão de texto em um idioma e geração de texto em outro idioma. -Inicialmente, a maioria das tarefas de PLN era resolvida usando métodos tradicionais, como gramáticas. Por exemplo, na tradução automática, analisadores eram usados para transformar a frase inicial em uma árvore sintática, depois estruturas semânticas de nível superior eram extraídas para representar o significado da frase, e com base nesse significado e na gramática do idioma de destino, o resultado era gerado. Hoje em dia, muitas tarefas de PLN são resolvidas de forma mais eficaz usando redes neurais. +Inicialmente, a maioria das tarefas de PLN era resolvida usando métodos tradicionais, como gramáticas. Por exemplo, na tradução automática, analisadores sintáticos eram usados para transformar a frase inicial em uma árvore sintática, depois estruturas semânticas de nível mais alto eram extraídas para representar o significado da frase, e com base nesse significado e na gramática do idioma alvo, o resultado era gerado. Atualmente, muitas tarefas de PLN são resolvidas de forma mais eficaz usando redes neurais. -> Muitos métodos clássicos de PLN estão implementados na biblioteca Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Há um excelente [Livro do NLTK](https://www.nltk.org/book/) disponível online que cobre como diferentes tarefas de PLN podem ser resolvidas usando o NLTK. +> Muitos métodos clássicos de PLN são implementados na biblioteca Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Existe um ótimo [Livro NLTK](https://www.nltk.org/book/) disponível online que cobre como diferentes tarefas de PLN podem ser resolvidas usando o NLTK. -Em nosso curso, vamos focar principalmente no uso de Redes Neurais para PLN, e usaremos o NLTK quando necessário. +Em nosso curso, focaremos principalmente no uso de Redes Neurais para PLN, e usaremos o NLTK quando necessário. -Já aprendemos sobre o uso de redes neurais para lidar com dados tabulares e imagens. A principal diferença entre esses tipos de dados e texto é que o texto é uma sequência de comprimento variável, enquanto o tamanho da entrada no caso de imagens é conhecido antecipadamente. Embora redes convolucionais possam extrair padrões de dados de entrada, os padrões em texto são mais complexos. Por exemplo, podemos ter uma negação separada do sujeito por muitas palavras arbitrárias (ex.: *Eu não gosto de laranjas*, vs. *Eu não gosto dessas grandes laranjas coloridas e saborosas*), e isso ainda deve ser interpretado como um único padrão. Assim, para lidar com a linguagem, precisamos introduzir novos tipos de redes neurais, como *redes recorrentes* e *transformers*. +Já aprendemos sobre uso de redes neurais para lidar com dados tabulares e imagens. A principal diferença entre esses tipos de dados e texto é que o texto é uma sequência de comprimento variável, enquanto o tamanho da entrada no caso de imagens é conhecido antecipadamente. Enquanto redes convolucionais podem extrair padrões dos dados de entrada, padrões em texto são mais complexos. Exemplo: podemos ter uma negação separada do sujeito por um número arbitrário de palavras (ex.: *Eu não gosto de laranjas*, vs. *Eu não gosto daquelas laranjas grandes, coloridas e saborosas*), e isso ainda deve ser interpretado como um padrão único. Assim, para lidar com linguagem precisamos introduzir novos tipos de redes neurais, como *redes recorrentes* e *transformers*. ## Instalar Bibliotecas -Se você estiver usando uma instalação local do Python para executar este curso, pode ser necessário instalar todas as bibliotecas necessárias para PLN usando os seguintes comandos: +Se você estiver usando uma instalação local de Python para executar este curso, talvez precise instalar todas as bibliotecas necessárias para PLN usando os seguintes comandos: **Para PyTorch** ```bash -pip install -r requirements-torch.txt +pip install -r requirements-pytorch.txt ``` **Para TensorFlow** ```bash @@ -39,13 +39,13 @@ pip install -r requirements-tf.txt ## Aviso sobre GPU -Nesta seção, em alguns dos exemplos, treinaremos modelos bastante grandes. -* **Use um computador com GPU**: É recomendável executar seus notebooks em um computador com GPU para reduzir o tempo de espera ao trabalhar com modelos grandes. -* **Restrições de memória da GPU**: Executar em uma GPU pode levar a situações em que você fique sem memória da GPU, especialmente ao treinar modelos grandes. -* **Consumo de memória da GPU**: A quantidade de memória da GPU consumida durante o treinamento depende de vários fatores, incluindo o tamanho do minibatch. -* **Minimize o tamanho do minibatch**: Se você encontrar problemas de memória da GPU, considere reduzir o tamanho do minibatch em seu código como uma solução potencial. -* **Liberação de memória da GPU no TensorFlow**: Versões mais antigas do TensorFlow podem não liberar corretamente a memória da GPU ao treinar vários modelos dentro de um único kernel Python. Para gerenciar o uso de memória da GPU de forma eficaz, você pode configurar o TensorFlow para alocar memória da GPU apenas conforme necessário. -* **Inclusão de código**: Para configurar o TensorFlow para aumentar a alocação de memória da GPU apenas quando necessário, inclua o seguinte código em seus notebooks: +Nesta seção, em alguns exemplos, estaremos treinando modelos bastante grandes. +* **Use um Computador com GPU**: É recomendável executar seus notebooks em um computador com GPU para reduzir os tempos de espera ao trabalhar com modelos grandes. +* **Limitações de Memória da GPU**: Executar em GPU pode levar a situações em que a memória da GPU esgote, especialmente ao treinar modelos grandes. +* **Consumo de Memória da GPU**: A quantidade de memória da GPU consumida durante o treinamento depende de vários fatores, incluindo o tamanho do minibatch. +* **Minimize o Tamanho do Minibatch**: Se encontrar problemas de memória na GPU, considere reduzir o tamanho do minibatch no seu código como uma solução possível. +* **Liberação de Memória da GPU no TensorFlow**: Versões antigas do TensorFlow podem não liberar a memória da GPU corretamente ao treinar múltiplos modelos em um mesmo kernel Python. Para gerenciar o uso da memória da GPU de forma eficaz, você pode configurar o TensorFlow para alocar memória na GPU apenas conforme necessário. +* **Inclusão de Código**: Para configurar o TensorFlow para aumentar a alocação de memória da GPU somente quando necessário, inclua o código abaixo em seus notebooks: ```python physical_devices = tf.config.list_physical_devices('GPU') @@ -53,17 +53,21 @@ if len(physical_devices)>0: tf.config.experimental.set_memory_growth(physical_devices[0], True) ``` -Se você estiver interessado em aprender sobre PLN a partir de uma perspectiva de aprendizado de máquina clássico, visite [esta coleção de lições](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP). +Se você tem interesse em aprender sobre PLN a partir de uma perspectiva clássica de ML, visite [este conjunto de lições](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) ## Nesta Seção -Nesta seção, aprenderemos sobre: +Nesta seção vamos aprender sobre: -* [Representação de texto como tensores](13-TextRep/README.md) -* [Embeddings de palavras](14-Emdeddings/README.md) -* [Modelagem de linguagem](15-LanguageModeling/README.md) +* [Representando texto como tensores](13-TextRep/README.md) +* [Word Embeddings](14-Emdeddings/README.md) +* [Modelagem de Linguagem](15-LanguageModeling/README.md) * [Redes Neurais Recorrentes](16-RNN/README.md) * [Redes Generativas](17-GenerativeNetworks/README.md) * [Transformers](18-Transformers/README.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 automatizadas 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. \ No newline at end of file +--- + + +**Aviso Legal**: +Este documento foi traduzido usando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução. + \ No newline at end of file diff --git a/translations/pt-PT/.co-op-translator.json b/translations/pt-PT/.co-op-translator.json index fec9d150..ace29aae 100644 --- a/translations/pt-PT/.co-op-translator.json +++ b/translations/pt-PT/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "pt-PT" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T21:15:15+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "pt-PT" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T21:03:33+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "pt-PT" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "pt-PT", + "failure_date": "2026-07-08T21:04:06+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.", + "translator_version": "0.20.0", + "failure_policy_version": 1 + } + }, "etc/CODE_OF_CONDUCT.md": { "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56", "translation_date": "2025-08-24T09:08:52+00:00", @@ -54,8 +73,8 @@ "language_code": "pt-PT" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:29:51+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T20:58:38+00:00", "source_file": "examples/README.md", "language_code": "pt-PT" }, @@ -66,8 +85,8 @@ "language_code": "pt-PT" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-15T14:10:34+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T20:58:59+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "pt-PT" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "pt-PT" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T20:54:53+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "pt-PT" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-24T09:01:39+00:00", @@ -330,8 +355,8 @@ "language_code": "pt-PT" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-24T08:52:49+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T20:59:26+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "pt-PT" }, diff --git a/translations/pt-PT/CONTRIBUTING.md b/translations/pt-PT/CONTRIBUTING.md new file mode 100644 index 00000000..30c4bf42 --- /dev/null +++ b/translations/pt-PT/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# Contribuir para AI-For-Beginners + +Obrigado pelo seu interesse em contribuir para o AI-For-Beginners! Agradecemos traduções, correções de lições e correções de formatação. + +## Acordo de Licença de Contribuidor (CLA) da Microsoft + +Este projeto aceita contribuições e sugestões. A maioria das contribuições exige que concorde com um Acordo de Licença de Contribuidor (CLA) declarando que tem o direito, e de facto concede, os direitos para usarmos a sua contribuição. Para mais detalhes, visite [https://cla.microsoft.com](https://cla.microsoft.com). + +Quando submeter um pull request, um bot CLA determinará automaticamente se precisa fornecer uma CLA e decorará o PR de forma adequada (por exemplo, etiqueta, comentário). Simplesmente siga as instruções fornecidas pelo bot. Só precisará fazer isto uma vez em todos os repositórios que utilizam a nossa CLA. + +## Como Contribuir + +### 1. Corrigir Erros Tipográficos / Erros de Código +Se encontrar um erro tipográfico ou bug em qualquer notebook Jupyter ou ficheiro markdown da lição: +1. Faça um fork do repositório. +2. Corrija o erro tipográfico ou link roto. +3. Submeta um Pull Request com uma descrição clara da correção. + +### 2. Submeter Traduções +Aceitamos traduções das lições para outras línguas! Por favor, coloque as traduções na diretoria `translations/` usando as pastas existentes (por exemplo `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +Para mais detalhes, veja [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**Aviso Legal**: +Este documento foi traduzido utilizando o serviço de tradução automática [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 autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes da utilização desta tradução. + \ No newline at end of file diff --git a/translations/pt-PT/examples/README.md b/translations/pt-PT/examples/README.md index 9c6517e7..4ea5cad9 100644 --- a/translations/pt-PT/examples/README.md +++ b/translations/pt-PT/examples/README.md @@ -1,27 +1,27 @@ # Exemplos de IA para Iniciantes -Bem-vindo! Este diretório contém exemplos simples e independentes para ajudá-lo a começar com IA e aprendizagem automática. Cada exemplo foi projetado para ser acessível a iniciantes, com comentários detalhados e explicações passo a passo. +Bem-vindo! Este diretório contém exemplos simples e autónomos para ajudar a iniciar-se em IA e aprendizagem automática. Cada exemplo foi desenhado para ser acessível a iniciantes, com comentários detalhados e explicações passo a passo. ## 📚 Visão Geral dos Exemplos | Exemplo | Descrição | Dificuldade | Pré-requisitos | |---------|-------------|------------|---------------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | O seu primeiro programa de IA - reconhecimento de padrões simples | ⭐ Iniciante | Noções básicas de Python | -| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Construa uma rede neural do zero | ⭐⭐ Iniciante+ | Python, matemática básica | -| [Image Classifier](./03-image-classifier.ipynb) | Classifique imagens com um modelo pré-treinado | ⭐⭐ Iniciante+ | Python, numpy | -| [Text Sentiment](../../../examples/04-text-sentiment.py) | Analise o sentimento de texto (positivo/negativo) | ⭐⭐ Iniciante+ | Python | +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | O seu primeiro programa de IA - reconhecimento simples de padrões | ⭐ Iniciante | Noções básicas de Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Construir uma rede neural do zero | ⭐⭐ Iniciante+ | Python, matemática básica | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Classificar imagens com um modelo pré-treinado | ⭐⭐ Iniciante+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analisar o sentimento de texto (positivo/negativo) | ⭐⭐ Iniciante+ | Python | -## 🚀 Começando +## 🚀 Começar ### Pré-requisitos -Certifique-se de ter o Python instalado (recomenda-se a versão 3.8 ou superior). Instale os pacotes necessários: +Certifique-se de que tem Python instalado (recomendado 3.8 ou superior). Instale os pacotes necessários: ```bash -# For Python scripts +# Para scripts Python pip install numpy -# For Jupyter notebooks (image classifier) +# Para notebooks Jupyter (classificador de imagens) pip install jupyter numpy pillow tensorflow ``` @@ -32,7 +32,7 @@ conda env create --name ai4beg --file ../environment.yml conda activate ai4beg ``` -### Executando os Exemplos +### Executar os Exemplos **Para scripts Python (.py):** ```bash @@ -44,42 +44,44 @@ python 01-hello-ai-world.py jupyter notebook 03-image-classifier.ipynb ``` -## 📖 Caminho de Aprendizagem +## 📖 Rota de Aprendizagem -Recomendamos seguir os exemplos na ordem: +Recomendamos seguir os exemplos pela ordem: 1. **Comece com "Hello AI World"** - Aprenda o básico sobre reconhecimento de padrões -2. **Construa uma Rede Neural Simples** - Entenda como funcionam as redes neurais +2. **Construa uma Rede Neural Simples** - Compreenda como funcionam as redes neurais 3. **Experimente o Classificador de Imagens** - Veja a IA em ação com imagens reais 4. **Analise o Sentimento de Texto** - Explore o processamento de linguagem natural ## 💡 Dicas para Iniciantes -- **Leia os comentários no código com atenção** - Eles explicam o que cada linha faz -- **Experimente!** - Tente alterar valores e veja o que acontece -- **Não se preocupe em entender tudo de imediato** - Aprender leva tempo +- **Leia os comentários do código com atenção** - Eles explicam o que cada linha faz +- **Experimente!** - Tente mudar valores e veja o que acontece +- **Não se preocupe por entender tudo** - Aprender leva tempo - **Faça perguntas** - Use o [Fórum de Discussão](https://github.com/microsoft/AI-For-Beginners/discussions) ## 🔗 Próximos Passos -Depois de concluir esses exemplos, explore o currículo completo: -- [Introdução à IA](../lessons/1-Intro/README.md) +Depois de completar estes exemplos, explore o currículo completo: +- [Introdução a IA](../lessons/1-Intro/README.md) - [Redes Neurais](../lessons/3-NeuralNetworks/README.md) - [Visão Computacional](../lessons/4-ComputerVision/README.md) - [Processamento de Linguagem Natural](../lessons/5-NLP/README.md) -## 🤝 Contribuindo +## 🤝 Contribuir -Achou esses exemplos úteis? Ajude-nos a melhorá-los: -- Relate problemas ou sugira melhorias +Gostou destes exemplos? Ajude-nos a melhorá-los: +- Reporte problemas ou sugira melhorias - Adicione mais exemplos para iniciantes - Melhore a documentação e os comentários --- -*Lembre-se: Todo especialista já foi um iniciante. Boa aprendizagem! 🎓* +*Lembre-se: Todo especialista foi uma vez um iniciante. Boa aprendizagem! 🎓* --- -**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, é 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 uma 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. \ No newline at end of file + +**Aviso Legal**: +Este documento foi traduzido utilizando o serviço de tradução automática [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 autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes da utilização desta tradução. + \ No newline at end of file diff --git a/translations/pt-PT/lessons/0-course-setup/how-to-run.md b/translations/pt-PT/lessons/0-course-setup/how-to-run.md index 57f30036..6a5a05a0 100644 --- a/translations/pt-PT/lessons/0-course-setup/how-to-run.md +++ b/translations/pt-PT/lessons/0-course-setup/how-to-run.md @@ -1,12 +1,12 @@ # Como Executar o Código -Este currículo contém muitos exemplos executáveis e laboratórios que você vai querer executar. Para isso, precisa da capacidade de executar código Python nos Jupyter Notebooks fornecidos como parte deste currículo. Tem várias opções para executar o código: +Este currículo contém muitos exemplos e laboratórios executáveis que desejará correr. Para tal, precisa da capacidade de executar código Python em Jupyter Notebooks fornecidos como parte deste currículo. Tem várias opções para executar o código: ## Executar localmente no seu computador -Para executar o código localmente no seu computador, é necessário uma instalação de Python. Uma recomendação é instalar o **[miniconda](https://conda.io/en/latest/miniconda.html)** - é uma instalação relativamente leve que suporta o gestor de pacotes `conda` para diferentes **ambientes virtuais** Python. +Para executar o código localmente no seu computador, é necessário uma instalação de Python. Uma recomendação é instalar o **[miniconda](https://conda.io/en/latest/miniconda.html)** - é uma instalação bastante leve que suporta o gestor de pacotes `conda` para diferentes **ambientes virtuais** Python. -Depois de instalar o miniconda, clone o repositório e crie um ambiente virtual a ser usado para este curso: +Depois de instalar o miniconda, clone o repositório e crie um ambiente virtual a usar neste curso: ```bash git clone http://github.com/microsoft/ai-for-beginners @@ -15,17 +15,17 @@ conda env create --name ai4beg --file .devcontainer/environment.yml conda activate ai4beg ``` -### Usar Visual Studio Code com a Extensão Python +### Utilizar o Visual Studio Code com a Extensão Python -Este currículo é melhor aproveitado quando aberto no [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) com a [Extensão Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). +Este currículo é melhor utilizado ao abri-lo no [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) com a [Extensão Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). -> **Nota**: Depois de clonar e abrir o diretório no VS Code, será sugerido automaticamente que instale extensões Python. Também terá de instalar o miniconda conforme descrito acima. +> **Nota**: Uma vez que clone e abra o diretório no VS Code, irá automaticamente sugerir-lhe a instalação das extensões Python. Também terá que instalar o miniconda conforme descrito acima. > **Nota**: Se o VS Code lhe sugerir reabrir o repositório num contentor, deve recusar para usar a instalação local do Python. -### Usar Jupyter no Navegador +### Utilizar o Jupyter no Navegador -Também pode usar um ambiente Jupyter a partir do navegador no seu próprio computador. Tanto o Jupyter clássico como o JupyterHub oferecem um ambiente de desenvolvimento conveniente com auto-completação, realce de código, etc. +Também pode usar um ambiente Jupyter a partir do navegador no seu próprio computador. Tanto o Jupyter clássico como o JupyterHub fornecem um ambiente de desenvolvimento conveniente com auto-completação, realce de código, etc. Para iniciar o Jupyter localmente, vá para o diretório do curso e execute: @@ -36,36 +36,36 @@ ou ```bash jupyterhub ``` -Pode então navegar para qualquer um dos ficheiros `.ipynb`, abrir e começar a trabalhar. +Pode então navegar a qualquer um dos ficheiros `.ipynb`, abri-los e começar a trabalhar. -### Executar em contentor +### Executar num contentor -Uma alternativa à instalação do Python seria executar o código num contentor. Como o nosso repositório fornece uma pasta especial `.devcontainer` que indica como construir um contentor para este repositório, o VS Code oferece a oportunidade de reabrir o código num contentor. Isto irá requerer a instalação do Docker, e também será mais complexo, pelo que recomendamos isto para utilizadores mais experientes. +Uma alternativa à instalação do Python seria executar o código num contentor. Como o nosso repositório fornece uma pasta especial `.devcontainer` que indica como construir um contentor para este repositório, o VS Code oferece a oportunidade de reabrir o código num contentor. Isto requer a instalação do Docker e seria também mais complexo, por isso recomendamos isto para utilizadores mais experientes. -## Executar na Cloud +## Execução na Nuvem -Se não pretende instalar Python localmente, e tem acesso a alguns recursos na cloud - uma boa alternativa seria executar o código na cloud. Existem várias formas de o fazer: +Se não quiser instalar Python localmente e tiver acesso a alguns recursos na nuvem - uma boa alternativa seria executar o código na nuvem. Existem várias formas de o fazer: -* Usar **[GitHub Codespaces](https://github.com/features/codespaces)**, que é um ambiente virtual criado para si no GitHub, acessível através de uma interface de navegador VS Code. Se tem acesso ao Codespaces, pode simplesmente clicar no botão **Code** no repositório, iniciar um codespace, e começar a correr em pouco tempo. -* Usar **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) oferece recursos computacionais gratuitos providenciados na cloud para pessoas como você testarem algum código no GitHub. Existe um botão na página inicial para abrir o repositório no Binder – isto deve levá-lo rapidamente ao site binder, que vai construir um contentor subjacente e iniciar uma interface web Jupyter para si de forma integrada. +* Utilizando **[GitHub Codespaces](https://github.com/features/codespaces)**, que é um ambiente virtual criado para si no GitHub, acessível através de uma interface do VS Code no navegador. Se tiver acesso ao Codespaces, pode simplesmente clicar no botão **Code** no repositório, iniciar um codespace e ficar a correr em pouco tempo. +* Utilizando **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. O [Binder](https://mybinder.org) oferece recursos computacionais gratuitos disponibilizados na nuvem para pessoas como você testarem algum código no GitHub. Existe um botão na página principal para abrir o repositório no Binder - isto deverá levá-lo rapidamente ao site do binder, que irá construir um contentor base e iniciar uma interface web do Jupyter para si sem interrupções. -> **Nota**: Para prevenir uso indevido, o Binder tem acesso a alguns recursos web bloqueados. Isto pode impedir que algum código funcione, especialmente o que descarrega modelos e/ou conjuntos de dados da Internet pública. Pode precisar de encontrar algumas soluções alternativas. Além disso, os recursos computacionais providenciados pelo Binder são bastante básicos, pelo que o treino será lento, especialmente nas lições mais avançadas e complexas. +> **Nota**: Para prevenir uso indevido, o Binder tem acesso bloqueado a alguns recursos web. Isto pode impedir que algum código funcione, especialmente aquele que obtém modelos e/ou conjuntos de dados da Internet pública. Pode ser necessário encontrar algumas soluções alternativas. Além disso, os recursos computacionais fornecidos pelo Binder são bastante básicos, por isso o treino será lento, especialmente nas lições posteriores mais complexas. -## Executar na Cloud com GPU +## Execução na Nuvem com GPU -Algumas das lições mais avançadas deste currículo beneficiariam muito do suporte a GPU. O treino de modelos, por exemplo, pode ser extremamente lento de outra forma. Existem algumas opções que pode seguir, especialmente se tiver acesso à cloud através do [Azure para Estudantes](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) ou da sua instituição: +Algumas das lições posteriores neste currículo beneficiariam muito do suporte a GPU. O treino de modelos, por exemplo, pode ser dolorosamente lento de outra forma. Existem algumas opções que pode seguir, especialmente se tiver acesso à nuvem seja através do [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), ou através da sua instituição: -* Criar [Máquina Virtual para Ciência de Dados](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) e ligar-se a ela através do Jupyter. Pode então clonar o repositório diretamente na máquina e começar a aprender. As máquinas virtuais NC-series têm suporte a GPU. +* Crie uma [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) e ligue-se a ela através do Jupyter. Pode então clonar o repositório diretamente na máquina e começar a aprender. As VMs da série NC têm suporte GPU. -> **Nota**: Algumas subscrições, incluindo o Azure para Estudantes, não fornecem suporte a GPU por defeito. Pode precisar de pedir núcleos de GPU adicionais através de um pedido de suporte técnico. +> **Nota**: Algumas subscrições, incluindo o Azure for Students, não fornecem suporte a GPU imediatamente. Pode ser necessário solicitar núcleos GPU adicionais através de um pedido de suporte técnico. -* Criar um [Workspace Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) e depois usar a funcionalidade Notebook aí. [Este vídeo](https://azure-for-academics.github.io/quickstart/azureml-papers/) mostra como clonar um repositório num notebook Azure ML e começar a usar. +* Crie um [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) e utilize depois a funcionalidade de Notebook lá. [Este vídeo](https://azure-for-academics.github.io/quickstart/azureml-papers/) mostra como clonar um repositório num notebook Azure ML e começar a utilizá-lo. -Também pode usar o Google Colab, que vem com algum suporte GPU gratuito, e carregar Jupyter Notebooks lá para executá-los um a um. +Também pode usar o Google Colab, que vem com algum suporte GPU gratuito, e carregar aí os Jupyter Notebooks para os executar um por um. --- **Aviso Legal**: -Este documento foi traduzido utilizando o serviço de tradução automática [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos por garantir a precisão, tenha em atenção que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução profissional por um tradutor humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução. +Este documento foi traduzido utilizando o serviço de tradução automática [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 autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes da utilização desta tradução. \ No newline at end of file diff --git a/translations/pt-PT/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/pt-PT/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index 4fb92265..97d5fefb 100644 --- a/translations/pt-PT/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/pt-PT/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -6,9 +6,9 @@ "source": [ "# Modelos pré-treinados e aprendizagem por transferência\n", "\n", - "Treinar CNNs pode levar muito tempo, e é necessário uma grande quantidade de dados para essa tarefa. No entanto, grande parte do tempo é gasto a aprender os melhores filtros de baixo nível que uma rede utiliza para extrair padrões de imagens. Surge então uma questão natural - será que podemos usar uma rede neural treinada num conjunto de dados e adaptá-la para classificar imagens diferentes sem passar por todo o processo de treino?\n", + "Treinar CNNs pode levar muito tempo, e é necessário uma grande quantidade de dados para essa tarefa. No entanto, muito tempo é dedicado a aprender os melhores filtros de baixo nível que a rede usa para extrair padrões das imagens. Surge uma questão natural - podemos usar uma rede neural treinada num conjunto de dados e adaptá-la para classificar imagens diferentes sem realizar o processo completo de treino?\n", "\n", - "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 fazer um bom trabalho ao extrair diferentes características de imagens genéricas, e em muitos casos, simplesmente construir um classificador em cima dessas características extraídas pode produzir bons resultados.\n" + "Esta abordagem é chamada **aprendizagem por transferência**, porque transferimos algum conhecimento de um modelo de rede neural para outro. Na aprendizagem por transferência, tipicamente começamos com um modelo pré-treinado, que foi treinado num grande conjunto de imagens, como o **ImageNet**. Esses modelos já conseguem extrair bem diferentes características de imagens genéricas e, em muitos casos, simplesmente construir um classificador por cima dessas características extraídas pode produzir um bom resultado.\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Conjunto de Dados Cats vs. Dogs\n", + "## Conjunto de Dados Gatos vs. Cães\n", "\n", - "Nesta unidade, vamos resolver um problema real de classificação de imagens de gatos e cães. Para isso, utilizaremos o [Conjunto de Dados Cats vs. Dogs do Kaggle](https://www.kaggle.com/c/dogs-vs-cats), que também pode ser descarregado [da Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "Nesta unidade, iremos resolver um problema da vida real de classificar imagens de gatos e cães. Por esta razão, vamos usar o [Conjunto de Dados Gatos vs. Cães do Kaggle](https://www.kaggle.com/c/dogs-vs-cats), que também pode ser descarregado [da Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", - "Vamos descarregar este conjunto de dados e extraí-lo para o diretório `data` (este processo pode demorar algum tempo!):\n" + "Vamos descarregar este conjunto de dados e extrair para o diretório `data` (este processo pode demorar algum tempo!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Infelizmente, existem alguns ficheiros de imagem corrompidos no conjunto de dados. Precisamos de fazer uma limpeza rápida para verificar os ficheiros corrompidos. Para não sobrecarregar este tutorial, movemos o código para verificar o conjunto de dados para um módulo.\n" + "Infelizmente, há alguns ficheiros de imagem corrompidos no conjunto de dados. Precisamos de fazer uma limpeza rápida para verificar ficheiros corrompidos. Para não comprometer este tutorial, movemos o código para verificar o conjunto de dados para um módulo.\n" ] }, { @@ -335,11 +335,11 @@ "source": [ "## Carregar o Conjunto de Dados\n", "\n", - "Nos exemplos anteriores, estávamos a carregar conjuntos de dados que já vêm integrados no Keras. Agora vamos trabalhar com o nosso próprio conjunto de dados, que precisamos de carregar a partir de um diretório de imagens.\n", + "Nos exemplos anteriores, estávamos a carregar conjuntos de dados incorporados no Keras. Agora, estamos prestes a lidar com o nosso próprio conjunto de dados, que precisamos de carregar a partir de um diretório de imagens.\n", "\n", - "Na vida real, o tamanho dos conjuntos de dados de imagens pode ser bastante grande, e não se pode contar com a possibilidade de todos os dados caberem na memória. Por isso, os conjuntos de dados são frequentemente representados como **geradores** que podem devolver dados em minibatches adequados para o treino.\n", + "Na vida real, o tamanho dos conjuntos de dados de imagens pode ser bastante grande, e não se pode contar que todos os dados caibam na memória. Assim, os conjuntos de dados são frequentemente representados como **geradores** que podem devolver dados em minibatches adequados para treino.\n", "\n", - "Para lidar com a classificação de imagens, o Keras inclui uma função especial chamada `image_dataset_from_directory`, que pode carregar imagens a partir de subdiretórios correspondentes a diferentes classes. Esta função também trata da escala das imagens e pode dividir o conjunto de dados em subconjuntos de treino e teste:\n" + "Para lidar com a classificação de imagens, o Keras inclui a função especial `image_dataset_from_directory`, que pode carregar imagens a partir de subdiretórios correspondentes a diferentes classes. Esta função também trata da escala das imagens, e também pode dividir o conjunto de dados em subconjuntos de treino e teste:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "É importante definir o mesmo valor de `seed` para ambas as chamadas, pois isso afeta a divisão das imagens entre os conjuntos de treino e teste.\n", + "É importante definir o mesmo valor `seed` para ambas as chamadas, porque isso afeta a divisão das imagens entre o conjunto de treino e o conjunto de teste.\n", "\n", - "O dataset identifica automaticamente os nomes das classes a partir dos diretórios, e pode aceder a eles, se necessário, chamando:\n" + "O Dataset recolhe automaticamente os nomes das classes a partir dos diretórios, e você pode aceder a eles, se necessário, chamando:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Os conjuntos de dados que obtivemos podem ser diretamente passados para a função `fit` para treinar o modelo. Eles contêm tanto as imagens correspondentes como os rótulos, que podem ser iterados utilizando a seguinte construção:\n" + "Conjuntos de dados que obtivemos podem ser diretamente passados para a função `fit` para treinar o modelo. Eles contêm tanto as imagens correspondentes como os rótulos, que podem ser percorridos utilizando a seguinte construção:\n" ] }, { @@ -453,7 +453,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **Nota**: Todas as imagens no conjunto de dados são representadas como tensores de ponto flutuante com intervalo de 0-255. Antes de passá-las para a rede neural, precisamos escalar esses valores para o intervalo de 0-1. Ao plotar imagens, precisamos fazer o mesmo ou converter os valores para o tipo `int` (como fazemos no código acima), para mostrar ao `matplotlib` que queremos plotar a imagem original não escalada.\n" + "> **Nota**: Todas as imagens no conjunto de dados são representadas como tensores de ponto flutuante com intervalo 0-255. Antes de as passar para a rede neural, precisamos de escalar esses valores para o intervalo 0-1. Ao plotar imagens, precisamos de fazer o mesmo, ou converter os valores para o tipo `int` (como fazemos no código acima), para mostrar ao `matplotlib` que queremos plotar a imagem original sem escala.\n" ] }, { @@ -462,7 +462,7 @@ "source": [ "## Modelos pré-treinados\n", "\n", - "Para muitas tarefas de classificação de imagens, é possível encontrar modelos de redes neurais pré-treinados. Muitos desses modelos estão disponíveis no espaço de nomes `keras.applications`, e ainda mais modelos podem ser encontrados na Internet. Vamos ver como o modelo mais simples, o VGG-16, pode ser carregado e utilizado:\n" + "Para muitas tarefas de classificação de imagens, pode encontrar modelos de redes neurais pré-treinados. Muitos desses modelos estão disponíveis dentro do namespace `keras.applications`, e ainda mais modelos podem ser encontrados na Internet. Vamos ver como o modelo VGG-16 mais simples pode ser carregado e utilizado:\n" ] }, { @@ -497,7 +497,17 @@ } ], "source": [ - "vgg = keras.applications.VGG16()\n", + "# SHA-256 of VGG16 weights (with top)\n", + "VGG16_WEIGHTS_SHA256 = '64373286793e3c8b2b4e3219cbf3544bce2f55ab4682710a29f5e7af8f5e4f61'\n", + "\n", + "_weights_path = keras.utils.get_file(\n", + " 'vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " 'https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " file_hash=VGG16_WEIGHTS_SHA256,\n", + " hash_algorithm='sha256',\n", + ")\n", + "\n", + "vgg = keras.applications.VGG16(weights=_weights_path)\n", "inp = keras.applications.vgg16.preprocess_input(x_sample[:1])\n", "\n", "res = vgg(inp)\n", @@ -510,10 +520,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Há algumas coisas importantes aqui:\n", - "* Antes de passar uma entrada para qualquer rede pré-treinada, é necessário pré-processá-la de uma determinada forma. Isto é feito chamando a função correspondente `preprocess_input`, que recebe um lote de imagens e devolve a sua forma processada. No caso do VGG-16, as imagens são normalizadas, e um valor médio pré-definido para cada canal é subtraído. Isto acontece porque o VGG-16 foi originalmente treinado com este pré-processamento.\n", - "* A rede neural é aplicada ao lote de entrada, e recebemos como resultado um lote de tensores com 1000 elementos que mostram a probabilidade de cada classe. Podemos encontrar o número da classe mais provável chamando `argmax` neste tensor.\n", - "* O resultado obtido é um [número de uma classe do `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Para interpretar este resultado, podemos também usar a função `decode_predictions`, que devolve as n classes principais juntamente com os seus nomes.\n" + "Existem algumas coisas importantes aqui:\n", + "* Antes de passar uma entrada para qualquer rede pré-treinada, esta tem de ser pré-processada de uma certa forma. Isto é feito chamando a função `preprocess_input` correspondente, que recebe um lote de imagens e retorna a sua forma processada. No caso do VGG-16, as imagens são normalizadas e é subtraído um valor médio pré-definido para cada canal. Isso acontece porque o VGG-16 foi originalmente treinado com este pré-processamento.\n", + "* A rede neural é aplicada ao lote de entrada, e recebemos como resultado um lote de tensores com 1000 elementos que mostram a probabilidade de cada classe. Podemos encontrar o número da classe mais provável ao chamar `argmax` neste tensor.\n", + "* O resultado obtido é um [número de uma classe do `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Para fazer sentido deste resultado, podemos também usar a função `decode_predictions`, que retorna as n classes principais juntamente com os seus nomes.\n" ] }, { @@ -597,9 +607,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Computações com GPU\n", + "## Cálculos na GPU\n", "\n", - "Redes neurais profundas, como a VGG-16 e outras arquiteturas mais modernas, requerem bastante poder computacional para serem executadas. Faz sentido utilizar a aceleração por GPU, se estiver disponível. Felizmente, o Keras acelera automaticamente as computações na GPU, caso esta esteja disponível. Podemos verificar se o Tensorflow consegue utilizar a GPU com o seguinte código:\n" + "Redes neurais profundas, como a VGG-16 e outras arquiteturas mais modernas, requerem bastante potência computacional para funcionar. Faz sentido usar aceleração por GPU, se estiver disponível. Felizmente, o Keras acelera automaticamente os cálculos na GPU se esta estiver disponível. Podemos verificar se o Tensorflow é capaz de usar GPU com o seguinte código:\n" ] }, { @@ -626,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Extração de características do VGG\n", "\n", - "Se quisermos usar o VGG-16 para extrair características das nossas imagens, precisamos do modelo sem as camadas finais de classificação. Podemos instanciar o modelo VGG-16 sem as camadas superiores utilizando este código:\n" + "## Extrair características da VGG\n", + "\n", + "Se quisermos usar o VGG-16 para extrair características das nossas imagens, precisamos do modelo sem as camadas finais de classificação. Podemos instanciar o modelo VGG-16 sem as camadas superiores usando este código:\n" ] }, { @@ -680,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A dimensão do tensor de características é 7x7x512, mas para o visualizar tivemos de o remodelar para uma forma 2D.\n", + "A dimensão do tensor de características é 7x7x512, mas para o visualizar tivemos que o reestruturar para uma forma 2D.\n", "\n", - "Agora vamos tentar ver se essas características podem ser usadas para classificar imagens. Vamos selecionar manualmente uma parte das imagens (50 minibatches, no nosso caso) e pré-computar os seus vetores de características. Podemos usar a API **dataset** do Tensorflow para fazer isso. A função `map` recebe um dataset e aplica uma função lambda para o transformar. Usamos este mecanismo para construir novos datasets, `ds_features_train` e `ds_features_test`, que contêm as características extraídas pelo VGG em vez das imagens originais.\n" + "Agora vamos tentar ver se essas características podem ser usadas para classificar imagens. Vamos manualmente apanhar uma porção de imagens (50 minibatches, no nosso caso) e pré-calcular os seus vetores de características. Podemos usar a API **dataset** do Tensorflow para fazer isso. A função `map` recebe um conjunto de dados e aplica uma função lambda dada para o transformar. Usamos este mecanismo para construir novos conjuntos de dados, `ds_features_train` e `ds_features_test`, que contêm características extraídas da VGG em vez das imagens originais.\n" ] }, { @@ -712,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Utilizámos a construção `.take(50)` para limitar o tamanho do conjunto de dados, de forma a acelerar a nossa demonstração. Claro que pode realizar este experimento com o conjunto de dados completo.\n", + "Usámos a construção `.take(50)` para limitar o tamanho do conjunto de dados, de forma a acelerar a nossa demonstração. Pode claro realizar este experimento no conjunto de dados completo.\n", "\n", - "Agora que temos um conjunto de dados com as características extraídas, podemos treinar um classificador denso simples para distinguir entre gatos e cães. Esta rede irá receber um vetor de características com a forma (7,7,512) e produzirá uma saída que corresponde a um cão ou a um gato. Como se trata de uma classificação binária, utilizamos a função de ativação `sigmoid` e a perda `binary_crossentropy`.\n" + "Agora que temos um conjunto de dados com características extraídas, podemos treinar um classificador denso simples para distinguir entre gatos e cães. Esta rede irá receber um vetor de características com forma (7,7,512) e produzir uma saída que corresponde a um cão ou a um gato. Como é uma classificação binária, usamos a função de ativação `sigmoid` e a perda `binary_crossentropy`.\n" ] }, { @@ -743,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "O resultado é excelente, conseguimos distinguir entre um gato e um cão com quase 95% de probabilidade! No entanto, apenas testámos esta abordagem num subconjunto de todas as imagens, porque a extração manual de características parece demorar bastante tempo.\n", + "O resultado é ótimo, conseguimos distinguir entre um gato e um cão com quase 95% de probabilidade! No entanto, testámos esta abordagem apenas num subconjunto de todas as imagens, porque a extração manual de características parece levar muito tempo.\n", "\n", - "## Transferência de aprendizagem usando uma rede VGG\n", + "## Aprendizagem por transferência usando uma rede VGG\n", "\n", - "Também podemos evitar a pré-computação manual das características utilizando a rede VGG-16 original como um todo durante o treino, adicionando um extrator de características à nossa rede como primeira camada.\n", + "Também podemos evitar o pré-cálculo manual das características usando a rede original VGG-16 como um todo durante o treino, adicionando o extractor de características à nossa rede como uma primeira camada.\n", "\n", - "A grande vantagem da arquitetura do Keras é que o modelo VGG-16 que definimos acima pode também ser usado como uma camada noutra rede neural! Só precisamos de construir uma rede com um classificador denso por cima dela e, em seguida, treinar toda a rede utilizando retropropagação.\n" + "A beleza da arquitectura Keras é que o modelo VGG-16 que definimos acima pode também ser usado como uma camada numa outra rede neural! Só precisamos de construir uma rede com um classificador denso em cima, e depois treinar toda a rede usando retropropagação.\n" ] }, { @@ -793,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Este modelo parece uma rede de classificação de ponta a ponta, que recebe uma imagem e retorna a classe. No entanto, o desafio aqui é que queremos que o VGG16 funcione como um extrator de características, e não seja re-treinado. Assim, precisamos **congelar os pesos do extrator de características convolucional**. Podemos aceder à primeira camada da rede chamando `model.layers[0]`, e só precisamos definir a propriedade `trainable` como `False`.\n", + "Este modelo parece uma rede de classificação de ponta a ponta, que recebe uma imagem e devolve a classe. No entanto, o complicado é que queremos que o VGG16 atue como extrator de características, e não seja re-treinado. Assim, precisamos de **congelar os pesos do extrator de características convolucionais**. Podemos aceder à primeira camada da rede chamando `model.layers[0]`, e apenas precisamos definir a propriedade `trainable` para `False`.\n", "\n", - "> **Note**: Congelar os pesos do extrator de características é necessário, porque, caso contrário, a camada de classificação não treinada pode destruir os pesos originais pré-treinados do extrator convolucional.\n", + "> **Nota**: O congelamento dos pesos do extrator de características é necessário, porque caso contrário a camada classificador não treinada pode destruir os pesos pré-treinados originais do extrator convolucional.\n", "\n", - "Pode reparar que, embora o número total de parâmetros na nossa rede seja cerca de 15 milhões, estamos apenas a treinar 25 mil parâmetros. Todos os outros parâmetros dos filtros convolucionais de nível superior estão pré-treinados. Isso é bom, porque conseguimos ajustar um número menor de parâmetros com um número menor de exemplos.\n", + "Poderá notar que enquanto o número total de parâmetros da nossa rede é cerca de 15 milhões, estamos apenas a treinar 25k parâmetros. Todos os outros parâmetros dos filtros convolucionais de topo são pré-treinados. Isso é bom, porque somos capazes de ajustar um número menor de parâmetros com um número menor de exemplos.\n", "\n", - "Agora vamos treinar a nossa rede e ver quão boa ela pode ser. Espere um tempo de execução relativamente longo e não se preocupe se a execução parecer congelada por algum tempo.\n" + "Agora vamos treinar a nossa rede e ver quão boa ela pode ficar. Espere um tempo de execução bastante longo, e não se preocupe se a execução parecer congelada por algum tempo.\n" ] }, { @@ -824,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Parece que conseguimos um classificador de gatos vs. cães bastante preciso!\n", + "Parece que obtivemos um classificador razoavelmente preciso para gatos vs. cães! \n", "\n", "## Guardar e Carregar o Modelo\n", "\n", - "Depois de treinarmos o modelo, podemos guardar a arquitetura do modelo e os pesos treinados num ficheiro para uso futuro:\n" + "Uma vez que treinámos o modelo, podemos guardar a arquitetura do modelo e os pesos treinados num ficheiro para uso futuro:\n" ] }, { @@ -852,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Podemos então carregar o modelo a partir do ficheiro a qualquer momento. Pode achá-lo útil caso a próxima experiência destrua o modelo - não teria de recomeçar do zero.\n" + "Podemos então carregar o modelo a partir do ficheiro a qualquer momento. Pode achar útil no caso do próximo experimento destruir o modelo - não teria que recomeçar do zero.\n" ] }, { @@ -868,15 +879,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Ajuste fino no aprendizado por transferência\n", + "## Aprimoramento do fine-tuning transfer learning\n", "\n", - "Na secção anterior, treinámos a camada final do classificador para classificar imagens no nosso próprio conjunto de dados. No entanto, não re-treinámos o extrator de características, e o nosso modelo baseou-se nas características que aprendeu com os dados do ImageNet. Se os seus objetos diferirem visualmente das imagens comuns do ImageNet, esta combinação de características pode não ser a mais eficaz. Assim, faz sentido começar a treinar também as camadas convolucionais.\n", + "Na secção anterior, treinámos a última camada classificador para classificar imagens no nosso próprio conjunto de dados. Contudo, não re-treinámos o extrator de características, e o nosso modelo baseou-se nas características que o modelo aprendeu com dados da ImageNet. Se os seus objetos diferirem visualmente das imagens comuns da ImageNet, esta combinação de características pode não funcionar da melhor forma. Assim, faz sentido começar a treinar as camadas convolucionais também.\n", "\n", - "Para isso, podemos desbloquear os parâmetros dos filtros convolucionais que anteriormente tínhamos bloqueado.\n", + "Para isso, podemos descongelar os parâmetros dos filtros convolucionais que anteriormente tínhamos congelado. \n", "\n", - "> **Nota:** É importante que bloqueie os parâmetros primeiro e realize várias épocas de treino para estabilizar os pesos na camada de classificação. Se começar imediatamente a treinar a rede de ponta a ponta com os parâmetros desbloqueados, é provável que grandes erros destruam os pesos pré-treinados nas camadas convolucionais.\n", + "> **Nota:** É importante que congele os parâmetros primeiro e realize várias épocas de treino para estabilizar os pesos na camada de classificação. Se começar imediatamente a treinar a rede end-to-end com os parâmetros descongelados, é provável que grandes erros destruam os pesos pré-treinados nas camadas convolucionais.\n", "\n", - "O nosso modelo convolucional VGG-16 está localizado dentro da primeira camada e, por si só, é composto por muitas camadas. Podemos observar a sua estrutura:\n" + "O nosso modelo convolucional VGG-16 está localizado dentro da primeira camada, e ele próprio consiste em muitas camadas. Podemos observar a sua estrutura:\n" ] }, { @@ -944,7 +955,9 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "Podemos descongelar todas as camadas da base convolucional:\n" + ] }, { "cell_type": "code", @@ -959,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "No entanto, descongelar todos de uma vez não é a melhor ideia. Podemos primeiro descongelar apenas algumas camadas finais de convoluções, porque elas contêm padrões de nível superior que são relevantes para as nossas imagens. Por exemplo, para começar, podemos congelar todas as camadas, exceto as últimas 4:\n" + "No entanto, descongelar todos ao mesmo tempo não é a melhor ideia. Podemos primeiro descongelar apenas algumas camadas finais de convoluções, porque elas contêm padrões de nível mais elevado que são relevantes para as nossas imagens. Por exemplo, para começar, podemos congelar todas as camadas exceto as últimas 4: \n" ] }, { @@ -998,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Observe que o número de parâmetros treináveis aumentou significativamente, mas ainda corresponde a cerca de 50% de todos os parâmetros.\n", + "Note que o número de parâmetros treináveis aumentou significativamente, mas ainda é cerca de 50% de todos os parâmetros.\n", "\n", - "Após desbloquear os pesos, podemos realizar mais algumas épocas de treino (no nosso exemplo, faremos apenas uma). Também pode optar por uma taxa de aprendizagem mais baixa, para minimizar o impacto nos pesos pré-treinados. No entanto, mesmo com uma taxa de aprendizagem baixa, é esperado que a precisão diminua no início do treino, até finalmente atingir um nível ligeiramente superior ao caso dos pesos fixos.\n", + "Após desbloquear, podemos fazer mais algumas épocas de treino (no nosso exemplo, faremos apenas uma). Também pode selecionar uma taxa de aprendizagem mais baixa, para minimizar o impacto nos pesos pré-treinados. No entanto, mesmo com uma taxa de aprendizagem baixa, pode esperar que a precisão diminua no início do treino, até finalmente atingir um nível ligeiramente superior ao caso dos pesos fixos.\n", "\n", - "> **Note:** Este treino é muito mais lento, porque precisamos propagar os gradientes através de muitas camadas da rede!\n" + "> **Nota:** Este treino acontece muito mais devagar, porque precisamos propagar os gradientes de volta por muitas camadas da rede!\n" ] }, { @@ -1026,9 +1039,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "É provável que alcancemos uma maior precisão no treino, porque estamos a utilizar uma rede mais poderosa com mais parâmetros, mas a precisão na validação não aumentará tanto.\n", + "É provável que consigamos uma maior precisão no treino, porque estamos a usar uma rede mais poderosa com mais parâmetros, mas a precisão na validação não aumentará tanto.\n", "\n", - "Sinta-se à vontade para desbloquear mais algumas camadas da rede e treinar mais, para ver se consegue alcançar uma maior precisão!\n" + "Sinta-se à vontade para descongelar mais algumas camadas da rede e treinar mais, para ver se consegue obter uma precisão maior!\n" ] }, { @@ -1037,7 +1050,7 @@ "source": [ "## Outros modelos de visão computacional\n", "\n", - "O VGG-16 é uma das arquiteturas de visão computacional mais simples. O Keras oferece muitas outras redes pré-treinadas. As mais frequentemente utilizadas entre elas são as arquiteturas **ResNet**, desenvolvidas pela Microsoft, e o **Inception**, do Google. Por exemplo, vamos explorar a arquitetura do modelo ResNet-50 mais simples (ResNet é uma família de modelos com diferentes profundidades; pode experimentar com o ResNet-152 se quiser ver como é um modelo realmente profundo):\n" + "O VGG-16 é uma das arquiteturas de visão computacional mais simples. O Keras fornece muitas outras redes pré-treinadas. As mais frequentemente usadas entre estas são as arquiteturas **ResNet**, desenvolvidas pela Microsoft, e o **Inception** da Google. Por exemplo, vamos explorar a arquitetura do modelo ResNet-50 mais simples (ResNet é uma família de modelos com diferentes profundidades, podes experimentar o ResNet-152 se quiseres ver como é um modelo realmente profundo):\n" ] }, { @@ -1439,29 +1452,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Como pode ver, o modelo contém os mesmos blocos familiares: camadas de convolução, camadas de pooling e um classificador denso final. Podemos usar este modelo exatamente da mesma forma que temos usado o VGG-16 para aprendizagem por transferência. Pode experimentar com o código acima, utilizando diferentes modelos ResNet como modelo base, e observar como a precisão muda.\n", + "Como pode ver, o modelo contém os mesmos blocos de construção familiares: camadas convolucionais, camadas de pooling e um classificador denso final. Podemos usar este modelo exatamente da mesma forma que temos usado o VGG-16 para aprendizagem por transferência. Pode tentar experimentar com o código acima, usando diferentes modelos ResNet como modelo base, e ver como a precisão muda.\n", "\n", - "## Normalização por Lote\n", + "## Normalização por Batch\n", "\n", - "Esta rede contém mais um tipo de camada: **Normalização por Lote**. A ideia da normalização por lote é ajustar os valores que passam pela rede neural para o intervalo correto. Normalmente, redes neurais funcionam melhor quando todos os valores estão no intervalo de [-1,1] ou [0,1], e é por isso que escalamos/normalizamos os nossos dados de entrada de forma adequada. No entanto, durante o treino de uma rede profunda, pode acontecer que os valores fiquem significativamente fora deste intervalo, o que torna o treino problemático. A camada de normalização por lote calcula a média e o desvio padrão para todos os valores do minibatch atual e utiliza-os para normalizar o sinal antes de o passar por uma camada da rede neural. Isto melhora significativamente a estabilidade de redes profundas.\n" + "Esta rede contém ainda outro tipo de camada: **Normalização por Batch**. A ideia da normalização por batch é trazer os valores que fluem pela rede neural para o intervalo correto. Normalmente, as redes neurais funcionam melhor quando todos os valores estão no intervalo [-1,1] ou [0,1], e essa é a razão pela qual escalamos/normalizamos os nossos dados de entrada em conformidade. No entanto, durante o treino de uma rede profunda, pode acontecer de os valores saírem significativamente deste intervalo, o que torna o treino problemático. A camada de normalização por batch calcula a média e o desvio padrão para todos os valores do minibatch atual, e usa-os para normalizar o sinal antes de o passar por uma camada da rede neural. Isto melhora significativamente a estabilidade das redes profundas.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Conclusão\n", + "## Retirada\n", "\n", - "Utilizando aprendizagem por transferência, conseguimos rapidamente montar um classificador para a nossa tarefa personalizada de classificação de objetos e alcançar uma alta precisão. No entanto, este exemplo não foi completamente justo, pois a rede original VGG-16 foi pré-treinada para reconhecer gatos e cães, e, assim, estávamos apenas reutilizando a maioria dos padrões que já estavam presentes na rede. Pode-se esperar uma precisão menor em objetos mais exóticos e específicos de domínio, como detalhes em uma linha de produção numa fábrica ou diferentes tipos de folhas de árvores.\n", + "Usando transferência de aprendizagem, conseguimos montar rapidamente um classificador para a nossa tarefa personalizada de classificação de objetos, e alcançar uma alta precisão. No entanto, este exemplo não foi completamente justo, porque a rede original VGG-16 foi pré-treinada para reconhecer gatos e cães, e portanto estávamos apenas a reutilizar a maioria dos padrões que já estavam presentes na rede. Pode esperar uma precisão mais baixa em objetos exóticos e específicos de domínio, como detalhes na linha de produção numa fábrica, ou diferentes folhas de árvores.\n", "\n", - "É possível perceber que tarefas mais complexas, como as que estamos resolvendo agora, exigem maior poder computacional e não podem ser facilmente resolvidas apenas com o CPU. Na próxima unidade, tentaremos usar uma implementação mais leve para treinar o mesmo modelo utilizando menos recursos computacionais, o que resulta em uma precisão apenas ligeiramente inferior.\n" + "Pode ver que tarefas mais complexas que estamos a resolver agora requerem maior poder computacional, e não podem ser facilmente resolvidas na CPU. Na próxima unidade, iremos tentar usar uma implementação mais leve para treinar o mesmo modelo usando menos recursos computacionais, o que resulta numa precisão ligeiramente inferior. \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 ter em conta 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" + "---\n\n\n**Aviso Legal**:\nEste documento foi traduzido utilizando o serviço de tradução automática [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 autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes da utilização desta tradução.\n\n" ] } ], @@ -1482,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-31T11:40:14+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "pt" } }, "nbformat": 4, diff --git a/translations/pt-PT/lessons/5-NLP/README.md b/translations/pt-PT/lessons/5-NLP/README.md index 7cdd1c0c..85ee2241 100644 --- a/translations/pt-PT/lessons/5-NLP/README.md +++ b/translations/pt-PT/lessons/5-NLP/README.md @@ -1,69 +1,73 @@ # Processamento de Linguagem Natural -![Resumo das tarefas de PLN em um desenho](../../../../lessons/sketchnotes/ai-nlp.png) +![Resumo das tarefas de PLN num desenho](../../../../translated_images/pt-PT/ai-nlp.b22dcb8ca4707cea.webp) -Nesta secção, vamos focar no uso de Redes Neuronais para lidar com tarefas relacionadas ao **Processamento de Linguagem Natural (PLN)**. Existem muitos problemas de PLN que queremos que os computadores sejam capazes de resolver: +Nesta secção, vamos focar-nos na utilização de Redes Neurais para tratar tarefas relacionadas com o **Processamento de Linguagem Natural (PLN)**. Existem muitos problemas de PLN que queremos que os computadores consigam resolver: -* **Classificação de texto** é um problema típico de classificação relacionado a sequências de texto. Exemplos incluem classificar mensagens de e-mail como spam ou não-spam, ou categorizar artigos como desporto, negócios, política, etc. Além disso, ao desenvolver chatbots, muitas vezes precisamos entender o que o utilizador quis dizer — neste caso, estamos a lidar com **classificação de intenções**. Frequentemente, na classificação de intenções, precisamos lidar com muitas categorias. -* **Análise de sentimento** é um problema típico de regressão, onde precisamos atribuir um número (um sentimento) que corresponda ao quão positiva/negativa é a mensagem de uma frase. Uma versão mais avançada da análise de sentimento é a **análise de sentimento baseada em aspetos** (ABSA), onde atribuímos o sentimento não à frase inteira, mas a diferentes partes dela (aspeto), por exemplo: *Neste restaurante, gostei da cozinha, mas a atmosfera era horrível*. -* **Reconhecimento de Entidades Nomeadas** (NER) refere-se ao problema de extrair certas entidades de um texto. Por exemplo, podemos precisar entender que na frase *Preciso de voar para Paris amanhã*, a palavra *amanhã* refere-se a uma DATA, e *Paris* é uma LOCALIZAÇÃO. -* **Extração de palavras-chave** é semelhante ao NER, mas precisamos extrair automaticamente palavras importantes para o significado da frase, sem pré-treino para tipos específicos de entidades. -* **Agrupamento de texto** pode ser útil quando queremos agrupar frases semelhantes, por exemplo, pedidos semelhantes em conversas de suporte técnico. -* **Resposta a perguntas** refere-se à capacidade de um modelo responder a uma pergunta específica. O modelo recebe um trecho de texto e uma pergunta como entradas, e precisa fornecer um local no texto onde a resposta à pergunta está contida (ou, por vezes, gerar o texto da resposta). -* **Geração de texto** é a capacidade de um modelo gerar novo texto. Pode ser considerado como uma tarefa de classificação que prevê a próxima letra/palavra com base num *texto inicial*. Modelos avançados de geração de texto, como o GPT-3, conseguem resolver outras tarefas de PLN, como classificação, usando uma técnica chamada [programação por prompts](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) ou [engenharia de prompts](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). -* **Sumarização de texto** é uma técnica em que queremos que um computador "leia" um texto longo e o resuma em algumas frases. +* **Classificação de texto** é um problema típico de classificação relativo a sequências de texto. Exemplos incluem classificar mensagens de e-mail como spam vs. não spam, ou categorizar artigos como desporto, negócios, política, etc. Também, ao desenvolver chat bots, muitas vezes precisamos de entender o que um utilizador quis dizer – neste caso estamos a lidar com **classificação de intenção**. Frequentemente, na classificação de intenção precisamos de lidar com muitas categorias. +* **Análise de sentimento** é um problema típico de regressão, onde precisamos de atribuir um número (um sentimento) correspondente a quão positivo/negativo é o significado de uma frase. Uma versão mais avançada da análise de sentimento é a **análise de sentimento baseada em aspetos** (ABSA), onde atribuimos sentimento não à frase toda, mas a diferentes partes dela (aspeto), por exemplo, *Neste restaurante, gostei da cozinha, mas a atmosfera era horrível*. +* **Reconhecimento de Entidades Nomeadas** (NER) refere-se ao problema de extrair certas entidades do texto. Por exemplo, podemos precisar de entender que na frase *Preciso de voar para Paris amanhã* a palavra *amanhã* refere-se a DATA, e *Paris* é uma LOCALIZAÇÃO. +* **Extração de palavras-chave** é similar ao NER, mas precisamos de extrair automaticamente palavras importantes para o significado da frase, sem pré-treinamento para tipos de entidade específicos. +* **Agrupamento de texto** pode ser útil quando queremos agrupar frases similares, por exemplo, pedidos semelhantes em conversas de apoio técnico. +* **Resolução de perguntas** refere-se à capacidade de um modelo responder a uma pergunta específica. O modelo recebe como entrada um excerto de texto e uma pergunta, e precisa de indicar um local no texto onde a resposta à pergunta está contida (ou, por vezes, gerar o texto da resposta). +* **Geração de texto** é a capacidade de um modelo gerar novo texto. Pode ser considerado como uma tarefa de classificação que prevê a próxima letra/palavra com base num *texto inicial*. Modelos avançados de geração de texto, como o GPT-3, são capazes de resolver outras tarefas de PLN tais como classificação usando uma técnica chamada [programação de indicativos](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) ou [engenharia de indicativos](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **Sumarização de texto** é uma técnica quando queremos que um computador "leia" um texto longo e o resuma em poucas frases. * **Tradução automática** pode ser vista como uma combinação de compreensão de texto numa língua e geração de texto noutra. -Inicialmente, a maioria das tarefas de PLN era resolvida usando métodos tradicionais, como gramáticas. Por exemplo, na tradução automática, analisadores sintáticos eram usados para transformar a frase inicial numa árvore sintática, depois estruturas semânticas de nível superior eram extraídas para representar o significado da frase, e com base nesse significado e na gramática da língua de destino, o resultado era gerado. Atualmente, muitas tarefas de PLN são resolvidas de forma mais eficaz usando redes neuronais. +Inicialmente, a maioria das tarefas de PLN era resolvida usando métodos tradicionais como gramáticas. Por exemplo, na tradução automática eram usados analisadores para transformar a frase inicial numa árvore sintática, depois estruturas semânticas de nível superior eram extraídas para representar o significado da frase, e com base neste significado e na gramática da língua-alvo o resultado era gerado. Atualmente, muitas tarefas de PLN são resolvidas de forma mais eficaz usando redes neurais. -> Muitos métodos clássicos de PLN estão implementados na biblioteca Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Existe um excelente [Livro NLTK](https://www.nltk.org/book/) disponível online que cobre como diferentes tarefas de PLN podem ser resolvidas usando o NLTK. +> Muitos métodos clássicos de PLN estão implementados na biblioteca Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Existe um ótimo [Livro NLTK](https://www.nltk.org/book/) disponível online que aborda como diferentes tarefas de PLN podem ser resolvidas usando o NLTK. -No nosso curso, vamos focar-nos principalmente no uso de Redes Neuronais para PLN, e usaremos o NLTK quando necessário. +No nosso curso, vamos focar-nos maioritariamente no uso de Redes Neurais para PLN, e usaremos o NLTK onde necessário. -Já aprendemos a usar redes neuronais para lidar com dados tabulares e com imagens. A principal diferença entre esses tipos de dados e texto é que o texto é uma sequência de comprimento variável, enquanto o tamanho da entrada no caso de imagens é conhecido antecipadamente. Embora redes convolucionais possam extrair padrões de dados de entrada, os padrões no texto são mais complexos. Por exemplo, podemos ter uma negação separada do sujeito por muitas palavras (ex.: *Eu não gosto de laranjas* vs. *Eu não gosto daquelas laranjas grandes, coloridas e saborosas*), e isso ainda deve ser interpretado como um único padrão. Assim, para lidar com a linguagem, precisamos introduzir novos tipos de redes neuronais, como *redes recorrentes* e *transformers*. +Já aprendemos sobre o uso de redes neurais para lidar com dados tabulares e com imagens. A principal diferença entre esses tipos de dados e o texto é que o texto é uma sequência de comprimento variável, enquanto o tamanho da entrada no caso de imagens é conhecido de antemão. Enquanto redes convolucionais podem extrair padrões dos dados de entrada, os padrões no texto são mais complexos. Por exemplo, podemos ter uma negação separada do sujeito por muitas palavras arbitrárias (exemplo: *Eu não gosto de laranjas*, vs. *Eu não gosto daquelas laranjas grandes, coloridas e saborosas*), e isso ainda deve ser interpretado como um padrão único. Assim, para lidar com a linguagem precisamos de introduzir novos tipos de redes neurais, tais como *redes recorrentes* e *transformers*. ## Instalar Bibliotecas -Se estiver a usar uma instalação local de Python para executar este curso, pode ser necessário instalar todas as bibliotecas necessárias para PLN usando os seguintes comandos: +Se estiver a usar uma instalação local de Python para executar este curso, poderá precisar de instalar todas as bibliotecas necessárias para PLN usando os seguintes comandos: -**Para PyTorch** +**Para PyTorch** ```bash -pip install -r requirements-torch.txt -``` -**Para TensorFlow** +pip install -r requirements-pytorch.txt +``` +**Para TensorFlow** ```bash pip install -r requirements-tf.txt -``` +``` -> Pode experimentar PLN com TensorFlow no [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) +> Pode experimentar PLN com TensorFlow em [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) ## Aviso sobre GPU -Nesta secção, em alguns dos exemplos, treinaremos modelos bastante grandes. -* **Use um Computador com GPU**: É recomendável executar os seus notebooks num computador com GPU para reduzir os tempos de espera ao trabalhar com modelos grandes. -* **Limitações de Memória da GPU**: Executar numa GPU pode levar a situações em que a memória da GPU se esgote, especialmente ao treinar modelos grandes. -* **Consumo de Memória da GPU**: A quantidade de memória da GPU consumida durante o treino depende de vários fatores, incluindo o tamanho do minibatch. -* **Minimize o Tamanho do Minibatch**: Se encontrar problemas de memória na GPU, considere reduzir o tamanho do minibatch no seu código como uma solução potencial. -* **Libertação de Memória da GPU no TensorFlow**: Versões mais antigas do TensorFlow podem não libertar corretamente a memória da GPU ao treinar vários modelos num único kernel Python. Para gerir o uso da memória da GPU de forma eficaz, pode configurar o TensorFlow para alocar memória da GPU apenas conforme necessário. -* **Inclusão de Código**: Para configurar o TensorFlow para aumentar a alocação de memória da GPU apenas quando necessário, inclua o seguinte código nos seus notebooks: +Nesta secção, em alguns exemplos, vamos treinar modelos bastante grandes. +* **Use um Computador com GPU Ativada**: É aconselhável executar os seus notebooks num computador com GPU ativada para reduzir os tempos de espera quando se trabalha com modelos grandes. +* **Limites de Memória da GPU**: Executar numa GPU pode levar a situações em que fica sem memória na GPU, especialmente ao treinar modelos grandes. +* **Consumo de Memória da GPU**: A quantidade de memória da GPU consumida durante o treino depende de vários fatores, incluindo o tamanho do minibatch. +* **Minimize o Tamanho do Minibatch**: Se encontrar problemas de memória na GPU, considere reduzir o tamanho do minibatch no seu código como solução potencial. +* **Libertação de Memória da GPU pelo TensorFlow**: Versões mais antigas do TensorFlow podem não libertar corretamente a memória da GPU ao treinar múltiplos modelos dentro de um kernel Python. Para gerir eficazmente o uso de memória da GPU, pode configurar o TensorFlow para alocar memória da GPU apenas conforme necessário. +* **Inclusão de Código**: Para configurar o TensorFlow para aumentar a alocação de memória da GPU apenas quando necessário, inclua o seguinte código nos seus notebooks: ```python physical_devices = tf.config.list_physical_devices('GPU') if len(physical_devices)>0: tf.config.experimental.set_memory_growth(physical_devices[0], True) -``` +``` -Se estiver interessado em aprender sobre PLN numa perspetiva de ML clássico, visite [esta coleção de lições](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) +Se estiver interessado em aprender sobre PLN a partir de uma perspetiva clássica de ML, visite [esta coleção de lições](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) ## Nesta Secção -Nesta secção, vamos aprender sobre: +Nesta secção vamos aprender sobre: -* [Representar texto como tensores](13-TextRep/README.md) -* [Embeddings de palavras](14-Emdeddings/README.md) -* [Modelagem de linguagem](15-LanguageModeling/README.md) -* [Redes Neuronais Recorrentes](16-RNN/README.md) -* [Redes Generativas](17-GenerativeNetworks/README.md) -* [Transformers](18-Transformers/README.md) +* [Representar texto como tensores](13-TextRep/README.md) +* [Word Embeddings (Incorporação de Palavras)](14-Emdeddings/README.md) +* [Modelação de Linguagem](15-LanguageModeling/README.md) +* [Redes Neurais Recorrentes](16-RNN/README.md) +* [Redes Generativas](17-GenerativeNetworks/README.md) +* [Transformers](18-Transformers/README.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, é 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 do uso desta tradução. \ No newline at end of file +--- + + +**Aviso Legal**: +Este documento foi traduzido utilizando o serviço de tradução automática [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 autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes da utilização desta tradução. + \ No newline at end of file