chore(i18n): sync translations with latest source changes (chunk 1/1, 18 changes)
This commit is contained in:
localizeflow[bot]
parent
2ec6624436
commit
90101b2eb8
|
|
@ -5,6 +5,12 @@
|
|||
"source_file": "AGENTS.md",
|
||||
"language_code": "de"
|
||||
},
|
||||
"CONTRIBUTING.md": {
|
||||
"original_hash": "c6fd7e781b67111a90abd166d0ce4aa0",
|
||||
"translation_date": "2026-07-08T20:19:31+00:00",
|
||||
"source_file": "CONTRIBUTING.md",
|
||||
"language_code": "de"
|
||||
},
|
||||
"README.md": {
|
||||
"original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b",
|
||||
"translation_date": "2026-04-06T15:35:07+00:00",
|
||||
|
|
@ -17,6 +23,19 @@
|
|||
"source_file": "SECURITY.md",
|
||||
"language_code": "de"
|
||||
},
|
||||
"__translation_failures__": {
|
||||
"lessons/sketchnotes/LICENSE.md": {
|
||||
"original_hash": "45ab63a2cd8f5faef6c9b150618837a4",
|
||||
"source_file": "lessons/sketchnotes/LICENSE.md",
|
||||
"language_code": "de",
|
||||
"failure_date": "2026-07-08T20:19: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-24T09:44:37+00:00",
|
||||
|
|
@ -54,8 +73,8 @@
|
|||
"language_code": "de"
|
||||
},
|
||||
"examples/README.md": {
|
||||
"original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7",
|
||||
"translation_date": "2025-10-03T11:26:30+00:00",
|
||||
"original_hash": "7883d52c2e2a221e0b07a7b112a149b9",
|
||||
"translation_date": "2026-07-08T20:14:17+00:00",
|
||||
"source_file": "examples/README.md",
|
||||
"language_code": "de"
|
||||
},
|
||||
|
|
@ -66,8 +85,8 @@
|
|||
"language_code": "de"
|
||||
},
|
||||
"lessons/0-course-setup/how-to-run.md": {
|
||||
"original_hash": "a4717bd9103b9f6cd84d534b83534689",
|
||||
"translation_date": "2026-01-15T10:52:10+00:00",
|
||||
"original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1",
|
||||
"translation_date": "2026-07-08T20:14:36+00:00",
|
||||
"source_file": "lessons/0-course-setup/how-to-run.md",
|
||||
"language_code": "de"
|
||||
},
|
||||
|
|
@ -191,6 +210,12 @@
|
|||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
|
||||
"language_code": "de"
|
||||
},
|
||||
"lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": {
|
||||
"original_hash": "99b816b6a4957ef4100cee4c4221dff9",
|
||||
"translation_date": "2026-07-08T20:03:15+00:00",
|
||||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
|
||||
"language_code": "de"
|
||||
},
|
||||
"lessons/4-ComputerVision/08-TransferLearning/lab/README.md": {
|
||||
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
|
||||
"translation_date": "2025-08-24T09:37:45+00:00",
|
||||
|
|
@ -330,8 +355,8 @@
|
|||
"language_code": "de"
|
||||
},
|
||||
"lessons/5-NLP/README.md": {
|
||||
"original_hash": "8ef02a9318257ea140ed3ed74442096d",
|
||||
"translation_date": "2025-08-24T09:29:31+00:00",
|
||||
"original_hash": "038df6f1a73e49f6430740da083bfd6d",
|
||||
"translation_date": "2026-07-08T20:15:05+00:00",
|
||||
"source_file": "lessons/5-NLP/README.md",
|
||||
"language_code": "de"
|
||||
},
|
||||
|
|
|
|||
|
|
@ -0,0 +1,29 @@
|
|||
# Beitrag zu AI-For-Beginners
|
||||
|
||||
Vielen Dank für Ihr Interesse, zu AI-For-Beginners beizutragen! Wir begrüßen Übersetzungen, Korrekturen von Lektionen und Formatierungsverbesserungen.
|
||||
|
||||
## Microsoft Contributor License Agreement (CLA)
|
||||
|
||||
Dieses Projekt freut sich über Beiträge und Vorschläge. Die meisten Beiträge erfordern, dass Sie einer Contributor License Agreement (CLA) zustimmen, in der Sie erklären, dass Sie das Recht haben und tatsächlich die Rechte gewähren, Ihren Beitrag zu nutzen. Details finden Sie unter [https://cla.microsoft.com](https://cla.microsoft.com).
|
||||
|
||||
Wenn Sie eine Pull-Anfrage einreichen, wird ein CLA-Bot automatisch feststellen, ob Sie eine CLA bereitstellen müssen, und die PR entsprechend kennzeichnen (z. B. Label, Kommentar). Folgen Sie einfach den Anweisungen des Bots. Dies müssen Sie nur einmal für alle Repositories tun, die unsere CLA verwenden.
|
||||
|
||||
## Wie man beiträgt
|
||||
|
||||
### 1. Rechtschreibfehler / Programmierfehler korrigieren
|
||||
Wenn Sie einen Tippfehler oder Fehler in einem Jupyter-Notebook oder einer Lektion-Markdown-Datei finden:
|
||||
1. Forken Sie das Repository.
|
||||
2. Korrigieren Sie den Tippfehler oder den defekten Link.
|
||||
3. Reichen Sie eine Pull-Anfrage mit einer klaren Beschreibung der Korrektur ein.
|
||||
|
||||
### 2. Übersetzungen einreichen
|
||||
Wir begrüßen Übersetzungen der Lektionen in andere Sprachen! Bitte legen Sie Übersetzungen im Verzeichnis `translations/` unter Verwendung der dort vorhandenen Ordnernamen ab (z. B. `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`).
|
||||
|
||||
Für weitere Details siehe [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md).
|
||||
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Haftungsausschluss**:
|
||||
Dieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache gilt als maßgebliche Quelle. Bei kritischen Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -1,31 +1,31 @@
|
|||
# Anfängerfreundliche KI-Beispiele
|
||||
# Einstiegsfreundliche KI-Beispiele
|
||||
|
||||
Willkommen! Dieses Verzeichnis enthält einfache, eigenständige Beispiele, die Ihnen den Einstieg in KI und maschinelles Lernen erleichtern sollen. Jedes Beispiel ist anfängerfreundlich gestaltet und enthält ausführliche Kommentare sowie Schritt-für-Schritt-Erklärungen.
|
||||
Willkommen! Dieses Verzeichnis enthält einfache, eigenständige Beispiele, die Ihnen den Einstieg in KI und maschinelles Lernen erleichtern. Jedes Beispiel ist anfängerfreundlich gestaltet mit ausführlichen Kommentaren und Schritt-für-Schritt-Erklärungen.
|
||||
|
||||
## 📚 Überblick über die Beispiele
|
||||
## 📚 Beispielübersicht
|
||||
|
||||
| Beispiel | Beschreibung | Schwierigkeitsgrad | Voraussetzungen |
|
||||
|----------|--------------|--------------------|-----------------|
|
||||
| [Hello AI World](../../../examples/01-hello-ai-world.py) | Ihr erstes KI-Programm – einfache Mustererkennung | ⭐ Anfänger | Grundkenntnisse in Python |
|
||||
| [Einfaches Neuronales Netzwerk](../../../examples/02-simple-neural-network.py) | Erstellen Sie ein neuronales Netzwerk von Grund auf | ⭐⭐ Anfänger+ | Python, grundlegende Mathematik |
|
||||
| [Bildklassifikator](./03-image-classifier.ipynb) | Klassifizieren Sie Bilder mit einem vortrainierten Modell | ⭐⭐ Anfänger+ | Python, numpy |
|
||||
| [Textstimmung](../../../examples/04-text-sentiment.py) | Analysieren Sie die Stimmung von Texten (positiv/negativ) | ⭐⭐ Anfänger+ | Python |
|
||||
|---------|-------------|------------|---------------|
|
||||
| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Ihr erstes KI-Programm – einfache Mustererkennung | ⭐ Anfänger | Python-Grundlagen |
|
||||
| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Ein neuronales Netzwerk von Grund auf bauen | ⭐⭐ Anfänger+ | Python, Grundmathematik |
|
||||
| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Bilder mit einem vortrainierten Modell klassifizieren | ⭐⭐ Anfänger+ | Python, numpy |
|
||||
| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Text-Stimmung analysieren (positiv/negativ) | ⭐⭐ Anfänger+ | Python |
|
||||
|
||||
## 🚀 Erste Schritte
|
||||
|
||||
### Voraussetzungen
|
||||
|
||||
Stellen Sie sicher, dass Python installiert ist (empfohlen wird Version 3.8 oder höher). Installieren Sie die benötigten Pakete:
|
||||
Stellen Sie sicher, dass Python installiert ist (3.8 oder höher wird empfohlen). Installieren Sie die erforderlichen Pakete:
|
||||
|
||||
```bash
|
||||
# For Python scripts
|
||||
# Für Python-Skripte
|
||||
pip install numpy
|
||||
|
||||
# For Jupyter notebooks (image classifier)
|
||||
# Für Jupyter-Notebooks (Bildklassifizierer)
|
||||
pip install jupyter numpy pillow tensorflow
|
||||
```
|
||||
|
||||
Oder verwenden Sie die Conda-Umgebung aus dem Hauptcurriculum:
|
||||
Oder verwenden Sie die conda-Umgebung aus dem Hauptlehrplan:
|
||||
|
||||
```bash
|
||||
conda env create --name ai4beg --file ../environment.yml
|
||||
|
|
@ -39,47 +39,49 @@ conda activate ai4beg
|
|||
python 01-hello-ai-world.py
|
||||
```
|
||||
|
||||
**Für Jupyter-Notebooks (.ipynb-Dateien):**
|
||||
**Für Jupyter Notebooks (.ipynb-Dateien):**
|
||||
```bash
|
||||
jupyter notebook 03-image-classifier.ipynb
|
||||
```
|
||||
|
||||
## 📖 Lernpfad
|
||||
|
||||
Wir empfehlen, die Beispiele in der folgenden Reihenfolge zu bearbeiten:
|
||||
Wir empfehlen, die Beispiele in der Reihenfolge durchzuarbeiten:
|
||||
|
||||
1. **Beginnen Sie mit "Hello AI World"** – Lernen Sie die Grundlagen der Mustererkennung
|
||||
2. **Erstellen Sie ein einfaches neuronales Netzwerk** – Verstehen Sie, wie neuronale Netzwerke funktionieren
|
||||
3. **Probieren Sie den Bildklassifikator aus** – Erleben Sie KI in Aktion mit echten Bildern
|
||||
4. **Analysieren Sie die Textstimmung** – Erkunden Sie die Verarbeitung natürlicher Sprache
|
||||
1. **Beginnen Sie mit „Hello AI World“** – Lernen Sie die Grundlagen der Mustererkennung
|
||||
2. **Bauen Sie ein einfaches neuronales Netzwerk** – Verstehen Sie, wie neuronale Netzwerke funktionieren
|
||||
3. **Probieren Sie den Bildklassifikator aus** – Sehen Sie KI anhand echter Bilder in Aktion
|
||||
4. **Analysieren Sie Text-Stimmungen** – Entdecken Sie die natürliche Sprachverarbeitung
|
||||
|
||||
## 💡 Tipps für Anfänger
|
||||
|
||||
- **Lesen Sie die Kommentare im Code sorgfältig** – Sie erklären, was jede Zeile macht
|
||||
- **Experimentieren Sie!** – Ändern Sie Werte und sehen Sie, was passiert
|
||||
- **Lesen Sie die Code-Kommentare sorgfältig** – Sie erklären, was jede Zeile macht
|
||||
- **Experimentieren Sie!** – Ändern Sie Werte und beobachten Sie, was passiert
|
||||
- **Machen Sie sich keine Sorgen, alles sofort zu verstehen** – Lernen braucht Zeit
|
||||
- **Stellen Sie Fragen** – Nutzen Sie das [Diskussionsforum](https://github.com/microsoft/AI-For-Beginners/discussions)
|
||||
|
||||
## 🔗 Nächste Schritte
|
||||
|
||||
Nachdem Sie diese Beispiele abgeschlossen haben, erkunden Sie das vollständige Curriculum:
|
||||
Nach Abschluss dieser Beispiele erkunden Sie den vollständigen Lehrplan:
|
||||
- [Einführung in KI](../lessons/1-Intro/README.md)
|
||||
- [Neuronale Netzwerke](../lessons/3-NeuralNetworks/README.md)
|
||||
- [Computer Vision](../lessons/4-ComputerVision/README.md)
|
||||
- [Verarbeitung natürlicher Sprache](../lessons/5-NLP/README.md)
|
||||
- [Computervision](../lessons/4-ComputerVision/README.md)
|
||||
- [Natürliche Sprachverarbeitung](../lessons/5-NLP/README.md)
|
||||
|
||||
## 🤝 Mitwirken
|
||||
|
||||
Fanden Sie diese Beispiele hilfreich? Helfen Sie uns, sie zu verbessern:
|
||||
- Melden Sie Probleme oder schlagen Sie Verbesserungen vor
|
||||
- Fügen Sie weitere Beispiele für Anfänger hinzu
|
||||
- Verbessern Sie die Dokumentation und Kommentare
|
||||
- Verbessern Sie Dokumentation und Kommentare
|
||||
|
||||
---
|
||||
|
||||
*Denken Sie daran: Jeder Experte war einmal ein Anfänger. Viel Spaß beim Lernen! 🎓*
|
||||
*Denken Sie daran: Jeder Experte war einst ein Anfänger. Viel Erfolg beim Lernen! 🎓*
|
||||
|
||||
---
|
||||
|
||||
**Haftungsausschluss**:
|
||||
Dieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die sich aus der Nutzung dieser Übersetzung ergeben.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Haftungsausschluss**:
|
||||
Dieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache gilt als maßgebliche Quelle. Bei kritischen Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -1,10 +1,10 @@
|
|||
# Wie man den Code ausführt
|
||||
# So führen Sie den Code aus
|
||||
|
||||
Dieses Curriculum enthält viele ausführbare Beispiele und Labs, die Sie ausführen möchten. Um dies zu tun, benötigen Sie die Möglichkeit, Python-Code in Jupyter Notebooks auszuführen, die als Teil dieses Curriculums bereitgestellt werden. Sie haben mehrere Optionen, um den Code auszuführen:
|
||||
Dieser Lehrplan enthält viele ausführbare Beispiele und Labs, die Sie ausführen möchten. Um dies zu tun, benötigen Sie die Möglichkeit, Python-Code in Jupyter Notebooks auszuführen, die als Teil dieses Lehrplans bereitgestellt werden. Sie haben mehrere Möglichkeiten, den Code auszuführen:
|
||||
|
||||
## Lokal auf Ihrem Computer ausführen
|
||||
|
||||
Um den Code lokal auf Ihrem Computer auszuführen, ist eine Python-Installation erforderlich. Eine Empfehlung ist die Installation von **[miniconda](https://conda.io/en/latest/miniconda.html)** – es ist eine eher leichtgewichtige Installation, die den `conda` Paketmanager für verschiedene Python-**virtuelle Umgebungen** unterstützt.
|
||||
Um den Code lokal auf Ihrem Computer auszuführen, ist eine Python-Installation erforderlich. Eine Empfehlung ist die Installation von **[miniconda](https://conda.io/en/latest/miniconda.html)** – es handelt sich um eine eher leichte Installation, die den Paketmanager `conda` für verschiedene Python-**virtuelle Umgebungen** unterstützt.
|
||||
|
||||
Nachdem Sie miniconda installiert haben, klonen Sie das Repository und erstellen eine virtuelle Umgebung, die für diesen Kurs verwendet wird:
|
||||
|
||||
|
|
@ -15,17 +15,17 @@ conda env create --name ai4beg --file .devcontainer/environment.yml
|
|||
conda activate ai4beg
|
||||
```
|
||||
|
||||
### Verwendung von Visual Studio Code mit Python-Erweiterung
|
||||
### Visual Studio Code mit Python-Erweiterung verwenden
|
||||
|
||||
Dieses Curriculum wird am besten verwendet, wenn es in [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) mit der [Python-Erweiterung](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste) geöffnet wird.
|
||||
Dieser Lehrplan wird am besten verwendet, wenn Sie ihn in [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) mit der [Python-Erweiterung](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste) öffnen.
|
||||
|
||||
> **Hinweis**: Sobald Sie das Verzeichnis klonen und in VS Code öffnen, wird automatisch vorgeschlagen, Python-Erweiterungen zu installieren. Sie müssen auch miniconda wie oben beschrieben installieren.
|
||||
|
||||
> **Hinweis**: Wenn VS Code vorschlägt, das Repository in einem Container erneut zu öffnen, sollten Sie dies ablehnen, um die lokale Python-Installation zu verwenden.
|
||||
> **Hinweis**: Wenn VS Code Ihnen vorschlägt, das Repository in einem Container neu zu öffnen, sollten Sie dies ablehnen, um die lokale Python-Installation zu verwenden.
|
||||
|
||||
### Verwendung von Jupyter im Browser
|
||||
### Jupyter im Browser verwenden
|
||||
|
||||
Sie können auch eine Jupyter-Umgebung aus dem Browser auf Ihrem eigenen Computer verwenden. Sowohl klassisches Jupyter als auch JupyterHub bieten eine bequeme Entwicklungsumgebung mit Autovervollständigung, Code-Hervorhebung usw.
|
||||
Sie können auch eine Jupyter-Umgebung über den Browser auf Ihrem eigenen Computer nutzen. Sowohl klassisches Jupyter als auch JupyterHub bieten eine bequeme Entwicklungsumgebung mit Autovervollständigung, Codehervorhebung usw.
|
||||
|
||||
Um Jupyter lokal zu starten, wechseln Sie in das Verzeichnis des Kurses und führen aus:
|
||||
|
||||
|
|
@ -36,36 +36,36 @@ oder
|
|||
```bash
|
||||
jupyterhub
|
||||
```
|
||||
Sie können dann zu einer beliebigen `.ipynb`-Datei navigieren, sie öffnen und mit der Arbeit beginnen.
|
||||
Sie können dann zu einer der `.ipynb`-Dateien navigieren, sie öffnen und mit der Arbeit beginnen.
|
||||
|
||||
### Ausführen in einem Container
|
||||
|
||||
Eine Alternative zur Python-Installation wäre das Ausführen des Codes in einem Container. Da unser Repository einen speziellen `.devcontainer`-Ordner bereitstellt, der beschreibt, wie ein Container für dieses Repo gebaut wird, bietet VS Code die Möglichkeit, den Code in einem Container erneut zu öffnen. Dies erfordert die Installation von Docker und wäre auch komplexer, daher empfehlen wir dies eher erfahrenen Nutzern.
|
||||
Eine Alternative zur Python-Installation wäre, den Code in einem Container auszuführen. Da unser Repository einen speziellen `.devcontainer`-Ordner bereitstellt, der beschreibt, wie ein Container für dieses Repo gebaut wird, bietet VS Code die Möglichkeit, den Code neu in einem Container zu öffnen. Dies erfordert eine Docker-Installation und ist auch komplexer, daher empfehlen wir dies eher erfahrenen Nutzern.
|
||||
|
||||
## Ausführung in der Cloud
|
||||
## Ausführen in der Cloud
|
||||
|
||||
Wenn Sie Python nicht lokal installieren möchten und Zugriff auf Cloud-Ressourcen haben – eine gute Alternative ist es, den Code in der Cloud auszuführen. Es gibt mehrere Möglichkeiten, dies zu tun:
|
||||
Wenn Sie Python nicht lokal installieren möchten und Zugriff auf einige Cloud-Ressourcen haben – wäre eine gute Alternative, den Code in der Cloud auszuführen. Es gibt mehrere Möglichkeiten, dies zu tun:
|
||||
|
||||
* Verwendung von **[GitHub Codespaces](https://github.com/features/codespaces)**, einer virtuellen Umgebung, die für Sie auf GitHub erstellt wird und über eine VS Code-Browseroberfläche zugänglich ist. Wenn Sie Zugriff auf Codespaces haben, können Sie einfach auf die **Code**-Schaltfläche im Repo klicken, einen Codespace starten und sofort loslegen.
|
||||
* Verwendung von **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) bietet kostenfreie Cloud-Computing-Ressourcen für Personen wie Sie, um Code auf GitHub auszuprobieren. Es gibt eine Schaltfläche auf der Startseite, um das Repository in Binder zu öffnen – dies sollte Sie schnell auf die Binder-Seite bringen, die einen zugrundeliegenden Container baut und nahtlos eine Jupyter-Weboberfläche für Sie startet.
|
||||
* Verwendung von **[GitHub Codespaces](https://github.com/features/codespaces)**, einer virtuellen Umgebung, die für Sie auf GitHub erstellt wird, zugänglich über eine VS Code-Browseroberfläche. Wenn Sie Zugriff auf Codespaces haben, können Sie einfach auf die **Code**-Schaltfläche im Repo klicken, einen Codespace starten und sofort loslegen.
|
||||
* Verwendung von **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) bietet kostenlose Rechenressourcen in der Cloud für Personen wie Sie, um Code auf GitHub auszuprobieren. Auf der Startseite gibt es eine Schaltfläche, um das Repository in Binder zu öffnen – dies führt Sie schnell zur Binder-Seite, die einen zugrundeliegenden Container erstellt und nahtlos eine Jupyter-Weboberfläche startet.
|
||||
|
||||
> **Hinweis**: Zur Vermeidung von Missbrauch hat Binder den Zugriff auf einige Webressourcen blockiert. Dies kann verhindern, dass ein Teil des Codes funktioniert, der Modelle und/oder Datensätze aus dem öffentlichen Internet lädt. Sie müssen möglicherweise einige Umgehungen finden. Außerdem sind die von Binder bereitgestellten Rechenressourcen eher grundlegend, sodass das Training langsam sein wird, besonders in späteren, komplexeren Lektionen.
|
||||
> **Hinweis**: Um Missbrauch zu verhindern, hat Binder den Zugriff auf einige Web-Ressourcen blockiert. Dies kann verhindern, dass einige Codeabschnitte funktionieren, die Modelle und/oder Datensätze aus dem öffentlichen Internet laden. Sie müssen möglicherweise einige Umgehungsmöglichkeiten finden. Außerdem sind die von Binder bereitgestellten Rechenressourcen recht einfach, daher ist das Training besonders in späteren, komplexeren Lektionen langsam.
|
||||
|
||||
## Ausführung in der Cloud mit GPU
|
||||
## Ausführen in der Cloud mit GPU
|
||||
|
||||
Einige der späteren Lektionen in diesem Curriculum würden erheblich von GPU-Unterstützung profitieren. Das Modelltraining kann sonst sehr langsam sein. Es gibt einige Möglichkeiten, die Sie nutzen können, besonders wenn Sie über [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) oder über Ihre Institution Zugang zur Cloud haben:
|
||||
Einige der späteren Lektionen in diesem Lehrplan würden sehr von GPU-Unterstützung profitieren. Model-Training kann zum Beispiel ohne diese schmerzhaft langsam sein. Es gibt einige Optionen, denen Sie folgen können, besonders wenn Sie über [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) oder Ihre Institution Zugang zur Cloud haben:
|
||||
|
||||
* Erstellen Sie eine [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) und verbinden Sie sich über Jupyter mit ihr. Sie können dann das Repo direkt auf die Maschine klonen und mit dem Lernen beginnen. NC-Serien VMs unterstützen GPU.
|
||||
* Erstellen Sie eine [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) und verbinden Sie sich über Jupyter damit. Sie können dann das Repo direkt auf die Maschine klonen und mit dem Lernen beginnen. NC-Serie VMs verfügen über GPU-Unterstützung.
|
||||
|
||||
> **Hinweis**: Einige Abonnements, einschließlich Azure for Students, bieten nicht standardmäßig GPU-Unterstützung. Möglicherweise müssen Sie zusätzliche GPU-Kerne per technischem Supportantrag anfordern.
|
||||
> **Hinweis**: Einige Abonnements, einschließlich Azure for Students, bieten nicht standardmäßig GPU-Unterstützung. Sie müssen möglicherweise zusätzliche GPU-Kerne über eine technische Supportanfrage anfordern.
|
||||
|
||||
* Erstellen Sie einen [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) und verwenden Sie dort die Notizbuchfunktion. [Dieses Video](https://azure-for-academics.github.io/quickstart/azureml-papers/) zeigt, wie man ein Repository in ein Azure ML-Notizbuch klont und es verwendet.
|
||||
* Erstellen Sie einen [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) und nutzen Sie dann dort die Notebook-Funktion. [Dieses Video](https://azure-for-academics.github.io/quickstart/azureml-papers/) zeigt, wie Sie ein Repository in ein Azure ML Notebook klonen und verwenden.
|
||||
|
||||
Sie können auch Google Colab verwenden, das über eine kostenlose GPU-Unterstützung verfügt, und Jupyter Notebooks dort hochladen, um sie einzeln auszuführen.
|
||||
Sie können auch Google Colab verwenden, das einige kostenlose GPU-Unterstützung bietet, und Jupyter Notebooks dort hochladen, um sie nacheinander auszuführen.
|
||||
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Haftungsausschluss**:
|
||||
Dieses Dokument wurde mithilfe des KI-Übersetzungsdienstes [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir bemüht sind, eine genaue Übersetzung zu gewährleisten, sollten Sie beachten, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache gilt als verbindliche Quelle. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Nutzung dieser Übersetzung entstehen.
|
||||
**Haftungsausschluss**:
|
||||
Dieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache gilt als maßgebliche Quelle. Bei kritischen Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -6,9 +6,9 @@
|
|||
"source": [
|
||||
"# Vorgefertigte Modelle und Transferlernen\n",
|
||||
"\n",
|
||||
"Das Training von CNNs kann viel Zeit in Anspruch nehmen, und es wird eine große Menge an Daten dafür benötigt. Ein Großteil der Zeit wird jedoch darauf verwendet, die besten Low-Level-Filter zu erlernen, die ein Netzwerk nutzt, um Muster aus Bildern zu extrahieren. Eine naheliegende Frage ist: Können wir ein neuronales Netzwerk, das auf einem Datensatz trainiert wurde, verwenden und es anpassen, um andere Bilder zu klassifizieren, ohne den gesamten Trainingsprozess erneut durchlaufen zu müssen?\n",
|
||||
"Die Schulung von CNNs kann viel Zeit in Anspruch nehmen, und es werden viele Daten für diese Aufgabe benötigt. Allerdings wird viel Zeit darauf verwendet, die besten Low-Level-Filter zu erlernen, die ein Netzwerk verwendet, um Muster aus Bildern zu extrahieren. Eine natürliche Frage entsteht – können wir ein auf einem Datensatz trainiertes neuronales Netzwerk verwenden und es an die Klassifizierung anderer Bilder anpassen, ohne den vollständigen Trainingsprozess durchlaufen zu müssen?\n",
|
||||
"\n",
|
||||
"Dieser Ansatz wird als **Transferlernen** bezeichnet, da wir Wissen von einem neuronalen Netzwerkmodell auf ein anderes übertragen. Beim Transferlernen beginnen wir typischerweise mit einem vortrainierten Modell, das auf einem großen Bilddatensatz wie **ImageNet** trainiert wurde. Diese Modelle können bereits verschiedene Merkmale aus generischen Bildern gut extrahieren, und in vielen Fällen kann allein das Erstellen eines Klassifikators auf Basis dieser extrahierten Merkmale zu guten Ergebnissen führen.\n"
|
||||
"Dieser Ansatz wird **Transferlernen** genannt, weil wir Wissen von einem neuronalen Netzwerkmodell auf ein anderes übertragen. Beim Transferlernen starten wir typischerweise mit einem vortrainierten Modell, das auf einem großen Bilddatensatz wie **ImageNet** trainiert wurde. Diese Modelle können bereits gut verschiedene Merkmale aus generischen Bildern extrahieren, und in vielen Fällen kann es zu guten Ergebnissen führen, einfach einen Klassifikator auf den extrahierten Merkmalen aufzubauen.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -29,11 +29,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Katzen- vs. Hunde-Datensatz\n",
|
||||
"## Katzen vs. Hunde Datensatz\n",
|
||||
"\n",
|
||||
"In dieser Einheit werden wir ein reales Problem lösen: die Klassifizierung von Bildern von Katzen und Hunden. Dafür verwenden wir den [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), der auch [von Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste) heruntergeladen werden kann.\n",
|
||||
"In dieser Einheit werden wir ein reales Problem lösen, nämlich die Klassifizierung von Bildern von Katzen und Hunden. Aus diesem Grund verwenden wir den [Kaggle Katzen vs. Hunde Datensatz](https://www.kaggle.com/c/dogs-vs-cats), der auch [von Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste) heruntergeladen werden kann.\n",
|
||||
"\n",
|
||||
"Lassen Sie uns diesen Datensatz herunterladen und in das Verzeichnis `data` extrahieren (dieser Vorgang kann einige Zeit in Anspruch nehmen!):\n"
|
||||
"Lassen Sie uns diesen Datensatz herunterladen und in das Verzeichnis `data` entpacken (dieser Vorgang kann einige Zeit in Anspruch nehmen!):\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -64,7 +64,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Leider gibt es einige beschädigte Bilddateien im Datensatz. Wir müssen eine schnelle Bereinigung durchführen, um beschädigte Dateien zu überprüfen. Um dieses Tutorial nicht zu überladen, haben wir den Code zur Überprüfung des Datensatzes in ein Modul verschoben.\n"
|
||||
"Leider gibt es einige beschädigte Bilddateien im Datensatz. Wir müssen eine schnelle Reinigung durchführen, um nach beschädigten Dateien zu suchen. Um dieses Tutorial nicht zu überladen, haben wir den Code zur Überprüfung des Datensatzes in ein Modul ausgelagert.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -335,11 +335,11 @@
|
|||
"source": [
|
||||
"## Laden des Datensatzes\n",
|
||||
"\n",
|
||||
"In früheren Beispielen haben wir Datensätze geladen, die in Keras integriert sind. Jetzt werden wir mit unserem eigenen Datensatz arbeiten, den wir aus einem Verzeichnis mit Bildern laden müssen.\n",
|
||||
"In den vorherigen Beispielen haben wir Datensätze geladen, die in Keras eingebaut sind. Nun werden wir uns mit unserem eigenen Datensatz beschäftigen, den wir aus einem Verzeichnis mit Bildern laden müssen.\n",
|
||||
"\n",
|
||||
"In der Praxis können Bilddatensätze ziemlich groß sein, und man kann nicht davon ausgehen, dass alle Daten in den Speicher passen. Daher werden Datensätze oft als **Generatoren** dargestellt, die Daten in Minibatches zurückgeben können, die für das Training geeignet sind.\n",
|
||||
"Im echten Leben kann die Größe von Bilddatensätzen ziemlich groß sein, und es ist nicht immer möglich, alle Daten im Speicher zu halten. Daher werden Datensätze oft als **Generatoren** dargestellt, die Daten in kleinen Chargen (Minibatches) zurückgeben können, die sich zum Trainieren eignen.\n",
|
||||
"\n",
|
||||
"Um mit der Bildklassifikation umzugehen, enthält Keras die spezielle Funktion `image_dataset_from_directory`, die Bilder aus Unterverzeichnissen laden kann, die verschiedenen Klassen entsprechen. Diese Funktion skaliert die Bilder automatisch und kann den Datensatz auch in Trainings- und Testuntergruppen aufteilen:\n"
|
||||
"Um mit der Bildklassifikation umzugehen, enthält Keras die spezielle Funktion `image_dataset_from_directory`, die Bilder aus Unterverzeichnissen lädt, die verschiedenen Klassen entsprechen. Diese Funktion kümmert sich auch um die Skalierung der Bilder und kann den Datensatz zudem in Trainings- und Testuntermengen aufteilen:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -383,9 +383,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Es ist wichtig, denselben `seed`-Wert für beide Aufrufe festzulegen, da dieser die Aufteilung der Bilder zwischen Trainings- und Testdatensatz beeinflusst.\n",
|
||||
"Es ist wichtig, für beide Aufrufe denselben `seed`-Wert festzulegen, da er die Aufteilung der Bilder zwischen Trainings- und Testdatensatz beeinflusst.\n",
|
||||
"\n",
|
||||
"Das Dataset erkennt automatisch die Klassennamen aus den Verzeichnissen, und Sie können darauf zugreifen, falls erforderlich, indem Sie Folgendes aufrufen:\n"
|
||||
"Dataset übernimmt automatisch die Klassennamen aus den Verzeichnissen, und Sie können bei Bedarf darauf zugreifen, indem Sie aufrufen:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -412,7 +412,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Datensätze, die wir erhalten haben, können direkt an die `fit`-Funktion übergeben werden, um das Modell zu trainieren. Sie enthalten sowohl entsprechende Bilder als auch Labels, die mit der folgenden Konstruktion durchlaufen werden können:\n"
|
||||
"Datensätze, die wir erhalten haben, können direkt an die `fit`-Funktion übergeben werden, um das Modell zu trainieren. Sie enthalten sowohl die zugehörigen Bilder als auch Labels, über die mit folgender Konstruktion iteriert werden kann:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -453,7 +453,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **Hinweis**: Alle Bilder im Datensatz sind als Gleitkomma-Tensoren mit einem Bereich von 0-255 dargestellt. Bevor wir sie an das neuronale Netzwerk übergeben, müssen wir diese Werte in den Bereich 0-1 skalieren. Beim Plotten von Bildern müssen wir entweder dasselbe tun oder die Werte in den `int`-Typ konvertieren (was wir im obigen Code tun), um `matplotlib` zu zeigen, dass wir das ursprüngliche unskalierte Bild plotten möchten.\n"
|
||||
"> **Hinweis**: Alle Bilder im Datensatz werden als Gleitkommatensoren mit Wertebereich 0-255 dargestellt. Bevor wir sie an das neuronale Netzwerk übergeben, müssen wir diese Werte in den Bereich 0-1 skalieren. Beim Darstellen von Bildern müssen wir entweder dasselbe tun oder die Werte in den `int`-Typ konvertieren (was wir im obigen Code machen), um `matplotlib` zu zeigen, dass wir das ursprüngliche, nicht skalierte Bild darstellen möchten.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -462,7 +462,7 @@
|
|||
"source": [
|
||||
"## Vorgefertigte Modelle\n",
|
||||
"\n",
|
||||
"Für viele Aufgaben der Bildklassifikation gibt es vorgefertigte neuronale Netzwerkmodelle. Viele dieser Modelle sind im `keras.applications`-Namespace verfügbar, und noch mehr Modelle können im Internet gefunden werden. Schauen wir uns an, wie das einfachste VGG-16-Modell geladen und verwendet werden kann:\n"
|
||||
"Für viele Bildklassifizierungsaufgaben findet man vortrainierte neuronale Netzwerkmodelle. Viele dieser Modelle sind im `keras.applications` Namensraum verfügbar, und noch mehr Modelle kann man im Internet finden. Schauen wir uns an, wie das einfachste VGG-16 Modell geladen und verwendet werden kann:\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,18 +520,17 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Es gibt hier ein paar wichtige Punkte:\n",
|
||||
"\n",
|
||||
"* Bevor ein Eingabebild an ein vortrainiertes Netzwerk übergeben wird, muss es auf eine bestimmte Weise vorverarbeitet werden. Dies geschieht durch Aufruf der entsprechenden `preprocess_input`-Funktion, die einen Stapel von Bildern erhält und deren verarbeitete Form zurückgibt. Im Fall von VGG-16 werden die Bilder normalisiert, und ein vordefinierter Durchschnittswert für jeden Kanal wird abgezogen. Das liegt daran, dass VGG-16 ursprünglich mit dieser Vorverarbeitung trainiert wurde.\n",
|
||||
"* Das neuronale Netzwerk wird auf den Eingabestapel angewendet, und als Ergebnis erhalten wir einen Stapel von 1000-elementigen Tensoren, die die Wahrscheinlichkeit jeder Klasse anzeigen. Die wahrscheinlichste Klassennummer können wir durch Aufruf von `argmax` auf diesem Tensor ermitteln.\n",
|
||||
"* Das erhaltene Ergebnis ist eine [Nummer einer `ImageNet`-Klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Um dieses Ergebnis zu interpretieren, können wir auch die Funktion `decode_predictions` verwenden, die die Top-n-Klassen zusammen mit ihren Namen zurückgibt.\n"
|
||||
"Es gibt hier ein paar wichtige Dinge:\n",
|
||||
"* Bevor eine Eingabe an ein vortrainiertes Netzwerk weitergegeben wird, muss sie auf eine bestimmte Weise vorverarbeitet werden. Dies geschieht durch Aufrufen der entsprechenden `preprocess_input`-Funktion, die einen Stapel von Bildern erhält und deren verarbeitete Form zurückgibt. Im Fall von VGG-16 werden Bilder normalisiert und ein vordefinierter Durchschnittswert für jeden Kanal subtrahiert. Das liegt daran, dass VGG-16 ursprünglich mit dieser Vorverarbeitung trainiert wurde.\n",
|
||||
"* Das neuronale Netzwerk wird auf den Eingabestapel angewendet, und wir erhalten als Ergebnis einen Stapel von 1000-Element-Tensoren, die die Wahrscheinlichkeit jeder Klasse anzeigen. Die wahrscheinlichste Klassennummer können wir durch Aufrufen von `argmax` auf diesem Tensor finden.\n",
|
||||
"* Das erhaltene Ergebnis ist eine [Nummer einer `ImageNet`-Klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Um dieses Ergebnis besser zu verstehen, können wir auch die Funktion `decode_predictions` verwenden, die die top n Klassen zusammen mit ihren Namen zurückgibt.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Lass uns auch die Architektur des VGG-16 Netzwerks betrachten:\n"
|
||||
"Schauen wir uns auch die Architektur des VGG-16-Netzwerks an:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -600,7 +609,7 @@
|
|||
"source": [
|
||||
"## GPU-Berechnungen\n",
|
||||
"\n",
|
||||
"Tiefe neuronale Netzwerke, wie VGG-16 und andere modernere Architekturen, benötigen eine beträchtliche Rechenleistung, um ausgeführt zu werden. Es ist sinnvoll, GPU-Beschleunigung zu nutzen, wenn sie verfügbar ist. Glücklicherweise beschleunigt Keras automatisch die Berechnungen auf der GPU, wenn diese verfügbar ist. Wir können überprüfen, ob Tensorflow die GPU verwenden kann, indem wir den folgenden Code ausführen:\n"
|
||||
"Tiefe neuronale Netze, wie VGG-16 und andere modernere Architekturen, benötigen viel Rechenleistung, um ausgeführt zu werden. Es macht Sinn, GPU-Beschleunigung zu verwenden, wenn diese verfügbar ist. Glücklicherweise beschleunigt Keras die Berechnungen auf der GPU automatisch, wenn diese verfügbar ist. Wir können prüfen, ob Tensorflow die GPU nutzen kann, indem wir den folgenden Code verwenden:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -627,9 +636,10 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Extrahieren von VGG-Features\n",
|
||||
"\n",
|
||||
"Wenn wir VGG-16 verwenden möchten, um Features aus unseren Bildern zu extrahieren, benötigen wir das Modell ohne die finalen Klassifikationsschichten. Wir können das VGG-16-Modell ohne die oberen Schichten mit diesem Code instanziieren:\n"
|
||||
"## VGG-Merkmale extrahieren\n",
|
||||
"\n",
|
||||
"Wenn wir VGG-16 verwenden möchten, um Merkmale aus unseren Bildern zu extrahieren, benötigen wir das Modell ohne die finalen Klassifikationsschichten. Wir können das VGG-16-Modell ohne die oberen Schichten mit diesem Code instanziieren:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -681,9 +691,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Die Dimension des Feature-Tensors beträgt 7x7x512, aber um ihn zu visualisieren, mussten wir ihn in eine 2D-Form umformen.\n",
|
||||
"Die Dimension des Feature-Tensors ist 7x7x512, aber um ihn zu visualisieren, mussten wir ihn in eine 2D-Form umformen.\n",
|
||||
"\n",
|
||||
"Versuchen wir nun herauszufinden, ob diese Features zur Klassifizierung von Bildern verwendet werden können. Nehmen wir manuell einen Teil der Bilder (in unserem Fall 50 Minibatches) und berechnen ihre Feature-Vektoren vorab. Dafür können wir die **dataset**-API von Tensorflow verwenden. Die `map`-Funktion nimmt ein Dataset und wendet eine gegebene Lambda-Funktion an, um es zu transformieren. Mit diesem Mechanismus erstellen wir neue Datasets, `ds_features_train` und `ds_features_test`, die die von VGG extrahierten Features anstelle der Originalbilder enthalten.\n"
|
||||
"Versuchen wir nun zu sehen, ob diese Features zur Klassifizierung von Bildern verwendet werden können. Nehmen wir manuell einen Teil der Bilder (50 Mini-Batches, in unserem Fall) und berechnen ihre Feature-Vektoren vor. Wir können die Tensorflow **dataset** API dafür verwenden. Die `map`-Funktion nimmt einen Datensatz und wendet eine gegebene Lambda-Funktion zur Transformation darauf an. Wir nutzen diesen Mechanismus, um neue Datensätze zu erstellen, `ds_features_train` und `ds_features_test`, die VGG-extrahierte Features anstelle der Originalbilder enthalten.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -713,9 +723,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Wir haben die Konstruktion `.take(50)` verwendet, um die Datensatzgröße zu begrenzen und unsere Demonstration zu beschleunigen. Natürlich können Sie dieses Experiment auch mit dem vollständigen Datensatz durchführen.\n",
|
||||
"Wir haben die Konstruktion `.take(50)` verwendet, um die Datensatzgröße zu begrenzen und unsere Demonstration zu beschleunigen. Natürlich können Sie dieses Experiment mit dem vollständigen Datensatz durchführen.\n",
|
||||
"\n",
|
||||
"Jetzt, da wir einen Datensatz mit extrahierten Merkmalen haben, können wir einen einfachen dichten Klassifikator trainieren, um zwischen Katzen und Hunden zu unterscheiden. Dieses Netzwerk nimmt einen Merkmalsvektor der Form (7,7,512) und erzeugt eine Ausgabe, die entweder einem Hund oder einer Katze entspricht. Da es sich um eine binäre Klassifikation handelt, verwenden wir die `sigmoid`-Aktivierungsfunktion und den `binary_crossentropy`-Loss.\n"
|
||||
"Da wir jetzt einen Datensatz mit extrahierten Merkmalen haben, können wir einen einfachen dichten Klassifikator trainieren, um zwischen Katzen und Hunden zu unterscheiden. Dieses Netzwerk nimmt einen Merkmalsvektor der Form (7,7,512) auf und erzeugt eine Ausgabe, die entweder einem Hund oder einer Katze entspricht. Da es sich um eine binäre Klassifikation handelt, verwenden wir die Aktivierungsfunktion `sigmoid` und den Verlust `binary_crossentropy`.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -744,13 +754,13 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Das Ergebnis ist großartig, wir können mit fast 95% Wahrscheinlichkeit zwischen einer Katze und einem Hund unterscheiden! Allerdings haben wir diesen Ansatz nur an einem Teil aller Bilder getestet, da die manuelle Merkmalsextraktion scheinbar viel Zeit in Anspruch nimmt.\n",
|
||||
"Das Ergebnis ist großartig, wir können mit fast 95 % Wahrscheinlichkeit zwischen einer Katze und einem Hund unterscheiden! Allerdings haben wir diesen Ansatz nur an einer Teilmenge aller Bilder getestet, da die manuelle Merkmalsextraktion anscheinend viel Zeit in Anspruch nimmt.\n",
|
||||
"\n",
|
||||
"## Transfer Learning mit einem VGG-Netzwerk\n",
|
||||
"## Transferlernen mit einem VGG-Netzwerk\n",
|
||||
"\n",
|
||||
"Wir können das manuelle Vorberechnen der Merkmale auch vermeiden, indem wir das ursprüngliche VGG-16-Netzwerk während des Trainings vollständig nutzen und einen Merkmalsextraktor als erste Schicht zu unserem Netzwerk hinzufügen.\n",
|
||||
"Wir können auch vermeiden, die Merkmale manuell vorab zu berechnen, indem wir das ursprüngliche VGG-16-Netzwerk während des Trainings als Ganzes verwenden, indem wir den Merkmalsextraktor als erste Schicht zu unserem Netzwerk hinzufügen.\n",
|
||||
"\n",
|
||||
"Das Schöne an der Keras-Architektur ist, dass das oben definierte VGG-16-Modell auch als Schicht in einem anderen neuronalen Netzwerk verwendet werden kann! Wir müssen lediglich ein Netzwerk mit einem dichten Klassifikator darauf aufbauen und dann das gesamte Netzwerk mithilfe von Backpropagation trainieren.\n"
|
||||
"Das Schöne an der Keras-Architektur ist, dass das oben definierte VGG-16-Modell auch als Schicht in einem anderen neuronalen Netzwerk verwendet werden kann! Wir müssen nur ein Netzwerk mit einem dichten Klassifikator darauf aufbauen und dann das gesamte Netzwerk mit Backpropagation trainieren.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -794,13 +804,13 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Dieses Modell sieht aus wie ein End-to-End-Klassifikationsnetzwerk, das ein Bild nimmt und die Klasse zurückgibt. Der knifflige Punkt ist jedoch, dass wir möchten, dass VGG16 als Merkmalsextraktor fungiert und nicht neu trainiert wird. Daher müssen wir die **Gewichte des konvolutionalen Merkmalsextraktors einfrieren**. Wir können auf die erste Schicht des Netzwerks zugreifen, indem wir `model.layers[0]` aufrufen, und wir müssen lediglich die Eigenschaft `trainable` auf `False` setzen.\n",
|
||||
"Dieses Modell sieht aus wie ein End-to-End-Klassifizierungsnetzwerk, das ein Bild aufnimmt und die Klasse zurückgibt. Der knifflige Punkt ist jedoch, dass wir möchten, dass VGG16 als Merkmalsextraktor fungiert und nicht neu trainiert wird. Daher müssen wir die **Gewichte des konvolutionalen Merkmalsextraktors einfrieren**. Wir können auf die erste Schicht des Netzwerks zugreifen, indem wir `model.layers[0]` aufrufen, und wir müssen nur die Eigenschaft `trainable` auf `False` setzen.\n",
|
||||
"\n",
|
||||
"> **Hinweis**: Das Einfrieren der Gewichte des Merkmalsextraktors ist notwendig, da ansonsten die untrainierte Klassifikationsschicht die ursprünglichen vortrainierten Gewichte des konvolutionalen Extraktors zerstören könnte.\n",
|
||||
"> **Hinweis**: Das Einfrieren der Gewichte des Merkmalsextraktors ist notwendig, da sonst die untrainierte Klassifikationsschicht die ursprünglich vortrainierten Gewichte des konvolutionalen Extraktors zerstören kann.\n",
|
||||
"\n",
|
||||
"Man kann feststellen, dass, obwohl die Gesamtanzahl der Parameter in unserem Netzwerk etwa 15 Millionen beträgt, wir nur 25.000 Parameter trainieren. Alle anderen Parameter der oberen konvolutionalen Filter sind vortrainiert. Das ist gut, da wir eine kleinere Anzahl von Parametern mit einer kleineren Anzahl von Beispielen feinabstimmen können.\n",
|
||||
"Sie werden bemerken, dass während die Gesamtzahl der Parameter in unserem Netzwerk etwa 15 Millionen beträgt, wir nur 25k Parameter trainieren. Alle anderen Parameter der obersten Konvolutionsfilter sind vortrainiert. Das ist gut, da wir dadurch in der Lage sind, eine kleinere Anzahl von Parametern mit einer kleineren Anzahl von Beispielen feinzujustieren.\n",
|
||||
"\n",
|
||||
"Wir werden nun unser Netzwerk trainieren und sehen, wie gut wir werden können. Rechnen Sie mit einer ziemlich langen Laufzeit und machen Sie sich keine Sorgen, wenn die Ausführung für einige Zeit eingefroren zu sein scheint.\n"
|
||||
"Wir werden jetzt unser Netzwerk trainieren und sehen, wie gut wir werden können. Erwarten Sie eine eher lange Laufzeit und machen Sie sich keine Sorgen, wenn die Ausführung für einige Zeit eingefroren zu sein scheint.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -825,11 +835,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Es sieht so aus, als hätten wir einen ziemlich genauen Katzen-gegen-Hunde-Klassifikator erhalten!\n",
|
||||
"Es sieht so aus, als hätten wir einen vernünftig genauen Katzen-gegen-Hunde-Klassifikator erhalten! \n",
|
||||
"\n",
|
||||
"## Speichern und Laden des Modells\n",
|
||||
"\n",
|
||||
"Sobald wir das Modell trainiert haben, können wir die Modellarchitektur und die trainierten Gewichte in einer Datei speichern, um sie später zu verwenden:\n"
|
||||
"Sobald wir das Modell trainiert haben, können wir die Modellarchitektur und die trainierten Gewichte zur späteren Verwendung in einer Datei speichern:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -853,7 +863,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Wir können das Modell jederzeit aus der Datei laden. Dies könnte nützlich sein, falls das nächste Experiment das Modell zerstört - Sie müssten nicht von vorne beginnen.\n"
|
||||
"Wir können das Modell dann jederzeit aus einer Datei laden. Das kann nützlich sein, falls das nächste Experiment das Modell zerstört – dann müssten Sie nicht von Grund auf neu beginnen.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -869,15 +879,15 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Feinabstimmung des Transfer-Lernens\n",
|
||||
"## Feinabstimmung des Transferlernens\n",
|
||||
"\n",
|
||||
"Im vorherigen Abschnitt haben wir die finale Klassifikationsschicht trainiert, um Bilder in unserem eigenen Datensatz zu klassifizieren. Allerdings haben wir den Feature-Extraktor nicht neu trainiert, und unser Modell hat sich auf die Merkmale verlassen, die es aus den ImageNet-Daten gelernt hat. Wenn sich Ihre Objekte optisch stark von gewöhnlichen ImageNet-Bildern unterscheiden, könnte diese Kombination von Merkmalen nicht optimal funktionieren. Daher macht es Sinn, auch die Faltungsschichten zu trainieren.\n",
|
||||
"Im vorherigen Abschnitt haben wir die letzte Klassifikatorschicht trainiert, um Bilder in unserem eigenen Datensatz zu klassifizieren. Allerdings haben wir den Merkmalsextraktor nicht erneut trainiert, und unser Modell basierte auf den Merkmalen, die das Modell auf ImageNet-Daten gelernt hat. Wenn sich Ihre Objekte visuell von den gewöhnlichen ImageNet-Bildern unterscheiden, könnte diese Kombination von Merkmalen nicht optimal funktionieren. Daher ist es sinnvoll, auch die Faltungsschichten zu trainieren.\n",
|
||||
"\n",
|
||||
"Um dies zu tun, können wir die Parameter der Faltungsfilter, die wir zuvor eingefroren haben, wieder freigeben.\n",
|
||||
"Dazu können wir die zuvor eingefrorenen Parameter der Faltungsfilter wieder freigeben.\n",
|
||||
"\n",
|
||||
"> **Hinweis:** Es ist wichtig, dass Sie die Parameter zuerst einfrieren und mehrere Trainings-Epochen durchführen, um die Gewichte in der Klassifikationsschicht zu stabilisieren. Wenn Sie direkt mit einem End-to-End-Netzwerk mit freigegebenen Parametern beginnen, können große Fehler die vortrainierten Gewichte in den Faltungsschichten zerstören.\n",
|
||||
"> **Hinweis:** Es ist wichtig, dass Sie zuerst die Parameter einfrieren und mehrere Trainings-Epochen durchführen, um die Gewichte in der Klassifikationsschicht zu stabilisieren. Wenn Sie sofort das gesamte Netzwerk mit freigegebenen Parametern trainieren, können große Fehler die vortrainierten Gewichte in den Faltungsschichten zerstören.\n",
|
||||
"\n",
|
||||
"Unser konvolutionales VGG-16-Modell befindet sich in der ersten Schicht und besteht selbst aus vielen Schichten. Wir können uns seine Struktur ansehen:\n"
|
||||
"Unser konvolutionales VGG-16-Modell befindet sich innerhalb der ersten Schicht und besteht selbst aus vielen Schichten. Wir können seine Struktur ansehen:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -946,7 +956,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Wir können alle Schichten der konvolutionalen Basis auftauen:\n"
|
||||
"Wir können alle Schichten der Faltungsbasis auftauen:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -962,7 +972,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Allerdings ist es keine gute Idee, alle auf einmal aufzutauen. Wir können zunächst nur einige der letzten Schichten von Convolutionen auftauen, da sie höherwertige Muster enthalten, die für unsere Bilder relevant sind. Zum Beispiel können wir zu Beginn alle Schichten außer den letzten 4 einfrieren:\n"
|
||||
"Es ist jedoch keine gute Idee, sie alle auf einmal aufzutauen. Wir können zunächst nur einige wenige der letzten Faltungsschichten auftauen, da sie höherstufige Muster enthalten, die für unsere Bilder relevant sind. Zum Beispiel können wir zu Beginn alle Schichten einfrieren, außer den letzten 4: \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1001,11 +1011,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Beobachten Sie, dass die Anzahl der trainierbaren Parameter deutlich gestiegen ist, aber sie liegt immer noch bei etwa 50 % aller Parameter.\n",
|
||||
"Beachten Sie, dass die Anzahl der trainierbaren Parameter deutlich zugenommen hat, aber immer noch etwa 50 % aller Parameter beträgt.\n",
|
||||
"\n",
|
||||
"Nach dem Entsperren können wir ein paar weitere Trainings-Epochen durchführen (in unserem Beispiel machen wir nur eine). Sie können auch eine niedrigere Lernrate wählen, um den Einfluss auf die vortrainierten Gewichte zu minimieren. Allerdings können Sie selbst bei einer niedrigen Lernrate damit rechnen, dass die Genauigkeit zu Beginn des Trainings sinkt, bevor sie schließlich ein etwas höheres Niveau erreicht als im Fall von fixierten Gewichten.\n",
|
||||
"Nach dem Entfrieren können wir noch ein paar weitere Trainings-Epochen durchführen (in unserem Beispiel werden wir nur eine machen). Sie können auch eine niedrigere Lernrate wählen, um die Auswirkungen auf die vortrainierten Gewichte zu minimieren. Allerdings können Sie selbst bei niedriger Lernrate am Anfang des Trainings einen Genauigkeitsabfall erwarten, bis schließlich ein etwas höheres Niveau erreicht wird als im Fall fester Gewichte.\n",
|
||||
"\n",
|
||||
"> **Hinweis:** Dieses Training verläuft deutlich langsamer, da die Gradienten durch viele Schichten des Netzwerks zurückpropagiert werden müssen!\n"
|
||||
"> **Hinweis:** Dieses Training verläuft viel langsamer, weil wir die Gradienten durch viele Schichten des Netzwerks zurückpropagieren müssen!\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1029,18 +1039,18 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Wir werden wahrscheinlich eine höhere Trainingsgenauigkeit erreichen, da wir ein leistungsstärkeres Netzwerk mit mehr Parametern verwenden. Die Validierungsgenauigkeit wird jedoch nicht im gleichen Maße steigen.\n",
|
||||
"Wir werden wahrscheinlich eine höhere Trainingsgenauigkeit erreichen, weil wir ein leistungsfähigeres Netzwerk mit mehr Parametern verwenden, aber die Validierungsgenauigkeit würde nicht so stark steigen.\n",
|
||||
"\n",
|
||||
"Du kannst gerne ein paar weitere Schichten des Netzwerks freigeben und weiter trainieren, um zu sehen, ob du eine höhere Genauigkeit erzielen kannst!\n"
|
||||
"Fühlen Sie sich frei, ein paar weitere Schichten des Netzwerks freizugeben und mehr zu trainieren, um zu sehen, ob Sie eine höhere Genauigkeit erreichen können!\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Andere Modelle der Computer Vision\n",
|
||||
"## Andere Computer-Vision-Modelle\n",
|
||||
"\n",
|
||||
"VGG-16 ist eine der einfachsten Architekturen für Computer Vision. Keras bietet viele weitere vortrainierte Netzwerke an. Die am häufigsten verwendeten darunter sind die **ResNet**-Architekturen, entwickelt von Microsoft, und **Inception** von Google. Zum Beispiel werfen wir einen Blick auf die Architektur des einfachsten ResNet-50-Modells (ResNet ist eine Familie von Modellen mit unterschiedlicher Tiefe. Sie können mit ResNet-152 experimentieren, wenn Sie sehen möchten, wie ein wirklich tiefes Modell aussieht):\n"
|
||||
"VGG-16 ist eine der einfachsten Computer-Vision-Architekturen. Keras stellt viele weitere vortrainierte Netzwerke bereit. Die am häufigsten verwendeten darunter sind die **ResNet**-Architekturen, entwickelt von Microsoft, und **Inception** von Google. Zum Beispiel untersuchen wir die Architektur des einfachsten ResNet-50-Modells (ResNet ist eine Familie von Modellen mit unterschiedlicher Tiefe, du kannst auch ResNet-152 ausprobieren, wenn du sehen möchtest, wie ein wirklich tiefes Modell aussieht):\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1442,11 +1452,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Wie Sie sehen können, enthält das Modell die gleichen vertrauten Bausteine: Convolutional Layers, Pooling Layers und einen abschließenden dichten Klassifikator. Wir können dieses Modell genau so verwenden, wie wir VGG-16 für Transfer Learning genutzt haben. Sie können mit dem obigen Code experimentieren, indem Sie verschiedene ResNet-Modelle als Basismodell verwenden und beobachten, wie sich die Genauigkeit verändert.\n",
|
||||
"Wie Sie sehen können, enthält das Modell dieselben vertrauten Bausteine: Faltungsschichten, Pooling-Schichten und den abschließenden dichten Klassifikator. Wir können dieses Modell auf genau die gleiche Weise verwenden wie das VGG-16 für Transferlernen. Sie können gerne mit dem obigen Code experimentieren, verschiedene ResNet-Modelle als Basis verwenden und beobachten, wie sich die Genauigkeit verändert.\n",
|
||||
"\n",
|
||||
"## Batch-Normalisierung\n",
|
||||
"\n",
|
||||
"Dieses Netzwerk enthält noch eine weitere Art von Schicht: **Batch-Normalisierung**. Die Idee der Batch-Normalisierung besteht darin, die Werte, die durch das neuronale Netzwerk fließen, in den richtigen Bereich zu bringen. Normalerweise funktionieren neuronale Netzwerke am besten, wenn alle Werte im Bereich von [-1,1] oder [0,1] liegen. Aus diesem Grund skalieren/normalisieren wir unsere Eingabedaten entsprechend. Während des Trainings eines tiefen Netzwerks kann es jedoch passieren, dass Werte signifikant außerhalb dieses Bereichs liegen, was das Training erschwert. Die Batch-Normalisierungsschicht berechnet den Durchschnitt und die Standardabweichung für alle Werte des aktuellen Minibatches und verwendet diese, um das Signal zu normalisieren, bevor es durch eine Schicht des neuronalen Netzwerks geleitet wird. Dies verbessert die Stabilität tiefer Netzwerke erheblich.\n"
|
||||
"Dieses Netzwerk enthält noch einen weiteren Schichttyp: **Batch-Normalisierung**. Die Idee der Batch-Normalisierung ist es, Werte, die durch das neuronale Netzwerk fließen, in den richtigen Bereich zu bringen. Normalerweise arbeiten neuronale Netzwerke am besten, wenn alle Werte im Bereich von [-1,1] oder [0,1] liegen, weshalb wir unsere Eingabedaten entsprechend skalieren/normalisieren. Während des Trainings eines tiefen Netzwerks kann es jedoch vorkommen, dass Werte deutlich außerhalb dieses Bereichs liegen, was das Training problematisch macht. Die Batch-Normalisierungsschicht berechnet den Mittelwert und die Standardabweichung aller Werte des aktuellen Minibatches und verwendet diese, um das Signal zu normalisieren, bevor es durch eine Schicht des neuronalen Netzwerks geleitet wird. Dies verbessert die Stabilität tiefer Netzwerke erheblich.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1455,16 +1465,16 @@
|
|||
"source": [
|
||||
"## Fazit\n",
|
||||
"\n",
|
||||
"Mit Transfer Learning konnten wir schnell einen Klassifikator für unsere benutzerdefinierte Objektklassifizierungsaufgabe erstellen und eine hohe Genauigkeit erreichen. Allerdings war dieses Beispiel nicht ganz fair, da das ursprüngliche VGG-16-Netzwerk bereits darauf trainiert war, Katzen und Hunde zu erkennen. Wir haben also lediglich die meisten Muster wiederverwendet, die bereits im Netzwerk vorhanden waren. Bei exotischeren, domänenspezifischen Objekten, wie Details einer Produktionslinie in einer Fabrik oder verschiedenen Baumblättern, können Sie mit einer geringeren Genauigkeit rechnen.\n",
|
||||
"Mithilfe von Transferlernen konnten wir schnell einen Klassifikator für unsere benutzerdefinierte Objekterkennungsaufgabe erstellen und eine hohe Genauigkeit erzielen. Dieses Beispiel war jedoch nicht ganz fair, da das ursprüngliche VGG-16-Netzwerk bereits vortrainiert war, Katzen und Hunde zu erkennen, und wir daher nur die meisten Muster wiederverwendet haben, die bereits im Netzwerk vorhanden waren. Bei exotischeren, domänenspezifischen Objekten wie Details an Produktionslinien in einer Fabrik oder verschiedenen Baumblättern können Sie mit einer geringeren Genauigkeit rechnen.\n",
|
||||
"\n",
|
||||
"Sie können sehen, dass komplexere Aufgaben, die wir jetzt lösen, eine höhere Rechenleistung erfordern und nicht einfach auf der CPU gelöst werden können. In der nächsten Einheit werden wir versuchen, eine leichtere Implementierung zu verwenden, um dasselbe Modell mit geringeren Rechenressourcen zu trainieren, was nur zu einer leicht niedrigeren Genauigkeit führt.\n"
|
||||
"Sie können sehen, dass komplexere Aufgaben, die wir jetzt lösen, höhere Rechenleistung erfordern und nicht so einfach auf der CPU gelöst werden können. In der nächsten Einheit werden wir versuchen, eine leichtere Implementierung zu verwenden, um dasselbe Modell mit geringeren Rechenressourcen zu trainieren, was nur zu einer geringfügig niedrigeren Genauigkeit führt. \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**Haftungsausschluss**: \nDieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die sich aus der Nutzung dieser Übersetzung ergeben.\n"
|
||||
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Haftungsausschluss**:\nDieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache gilt als maßgebliche Quelle. Bei kritischen Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
@ -1485,12 +1495,6 @@
|
|||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.10"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "c189abc107848f96051085cc30945129",
|
||||
"translation_date": "2025-08-31T15:58:21+00:00",
|
||||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
|
||||
"language_code": "de"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
|
|
|
|||
|
|
@ -1,69 +1,73 @@
|
|||
# Verarbeitung natürlicher Sprache
|
||||
|
||||
|
||||
|
||||
|
||||
In diesem Abschnitt konzentrieren wir uns darauf, neuronale Netzwerke für Aufgaben im Bereich der **Verarbeitung natürlicher Sprache (Natural Language Processing, NLP)** einzusetzen. Es gibt viele NLP-Probleme, die wir möchten, dass Computer lösen können:
|
||||
In diesem Abschnitt konzentrieren wir uns darauf, neuronale Netze für Aufgaben im Zusammenhang mit **Natural Language Processing (NLP)** einzusetzen. Es gibt viele NLP-Probleme, die Computer lösen sollen:
|
||||
|
||||
* **Textklassifikation** ist ein typisches Klassifikationsproblem, das sich auf Textsequenzen bezieht. Beispiele sind das Klassifizieren von E-Mails als Spam oder Nicht-Spam oder das Kategorisieren von Artikeln in Sport, Wirtschaft, Politik usw. Auch bei der Entwicklung von Chatbots müssen wir oft verstehen, was ein Benutzer sagen wollte – in diesem Fall handelt es sich um **Intent-Klassifikation**. Häufig müssen wir bei der Intent-Klassifikation mit vielen Kategorien umgehen.
|
||||
* **Sentiment-Analyse** ist ein typisches Regressionsproblem, bei dem wir einer Zahl (einem Sentiment) zuordnen müssen, wie positiv/negativ die Bedeutung eines Satzes ist. Eine fortgeschrittenere Version der Sentiment-Analyse ist die **aspektbasierte Sentiment-Analyse** (ABSA), bei der wir das Sentiment nicht dem gesamten Satz, sondern verschiedenen Teilen davon (Aspekten) zuordnen, z. B. *In diesem Restaurant mochte ich die Küche, aber die Atmosphäre war schrecklich*.
|
||||
* **Erkennung benannter Entitäten** (Named Entity Recognition, NER) bezieht sich auf das Problem, bestimmte Entitäten aus Text zu extrahieren. Zum Beispiel müssen wir verstehen, dass in der Phrase *Ich muss morgen nach Paris fliegen* das Wort *morgen* ein DATUM und *Paris* ein ORT ist.
|
||||
* **Schlüsselwortextraktion** ist ähnlich wie NER, aber hier müssen wir automatisch Wörter extrahieren, die für die Bedeutung des Satzes wichtig sind, ohne vorheriges Training für spezifische Entitätstypen.
|
||||
* **Text-Clustering** kann nützlich sein, wenn wir ähnliche Sätze gruppieren möchten, z. B. ähnliche Anfragen in technischen Supportgesprächen.
|
||||
* **Fragebeantwortung** bezieht sich auf die Fähigkeit eines Modells, eine spezifische Frage zu beantworten. Das Modell erhält einen Textabschnitt und eine Frage als Eingaben und muss eine Stelle im Text angeben, an der die Antwort auf die Frage enthalten ist (oder manchmal die Antwort generieren).
|
||||
* **Textgenerierung** ist die Fähigkeit eines Modells, neuen Text zu generieren. Dies kann als Klassifikationsaufgabe betrachtet werden, bei der der nächste Buchstabe/das nächste Wort basierend auf einem *Textprompt* vorhergesagt wird. Fortgeschrittene Textgenerierungsmodelle wie GPT-3 können andere NLP-Aufgaben wie Klassifikation mithilfe einer Technik namens [Prompt Programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) oder [Prompt Engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) lösen.
|
||||
* **Textzusammenfassung** ist eine Technik, bei der wir möchten, dass ein Computer einen langen Text "liest" und ihn in wenigen Sätzen zusammenfasst.
|
||||
* **Maschinelle Übersetzung** kann als Kombination aus Textverständnis in einer Sprache und Textgenerierung in einer anderen betrachtet werden.
|
||||
* **Textklassifikation** ist ein typisches Klassifikationsproblem im Bereich von Textsequenzen. Beispiele sind das Klassifizieren von E-Mails als Spam oder kein Spam oder das Kategorisieren von Artikeln in Sport, Wirtschaft, Politik usw. Beim Entwickeln von Chatbots müssen wir oft verstehen, was ein Benutzer sagen wollte – in diesem Fall handelt es sich um **Intent-Klassifikation**. Hierbei müssen wir oft mit vielen Kategorien umgehen.
|
||||
* **Sentiment-Analyse** ist ein typisches Regressionsproblem, bei dem wir eine Zahl (ein Sentiment) zuordnen müssen, die angibt, wie positiv oder negativ die Bedeutung eines Satzes ist. Eine fortgeschrittenere Version der Sentiment-Analyse ist die **aspektbasierte Sentiment-Analyse** (ABSA), bei der wir das Sentiment nicht auf den ganzen Satz, sondern auf verschiedene Teile davon (Aspekte) beziehen, z. B. *In diesem Restaurant mochte ich die Küche, aber die Atmosphäre war schrecklich*.
|
||||
* **Named Entity Recognition** (NER) bezeichnet das Problem, bestimmte Entitäten aus Texten zu extrahieren. Beispielsweise müssen wir verstehen, dass im Satz *Ich muss morgen nach Paris fliegen* das Wort *morgen* ein DATUM bezeichnet und *Paris* ein ORT ist.
|
||||
* **Keyword-Extraktion** ähnelt NER, jedoch müssen automatisch die für die Bedeutung wichtigen Wörter extrahiert werden, ohne vorheriges Training für spezifische Entitätstypen.
|
||||
* **Text-Clustering** kann nützlich sein, wenn wir ähnliche Sätze gruppieren möchten, z. B. ähnliche Anfragen in Support-Gesprächen.
|
||||
* **Fragebeantwortung** bezeichnet die Fähigkeit eines Modells, auf eine gegebene Frage zu antworten. Das Modell erhält einen Textabschnitt und eine Frage als Eingabe und muss den Textabschnitt angeben, in dem die Antwort auf die Frage enthalten ist (oder manchmal die Antwort selbst generieren).
|
||||
* **Textgenerierung** ist die Fähigkeit eines Modells, neuen Text zu erzeugen. Dies kann als Klassifikationsaufgabe betrachtet werden, bei der das nächste Zeichen/Wort basierend auf einem *Textprompt* vorhergesagt wird. Fortgeschrittene Textgenerierungsmodelle wie GPT-3 können andere NLP-Aufgaben wie Klassifikation mithilfe von Techniken wie [Prompt-Programmierung](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) oder [Prompt-Engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) lösen.
|
||||
* **Textzusammenfassung** ist eine Technik, bei der ein Computer lange Texte „liest“ und sie in wenigen Sätzen zusammenfasst.
|
||||
* **Maschinelle Übersetzung** kann als Kombination aus Textverständnis in einer Sprache und Textgenerierung in einer anderen Sprache betrachtet werden.
|
||||
|
||||
Anfangs wurden die meisten NLP-Aufgaben mit traditionellen Methoden wie Grammatiken gelöst. Zum Beispiel wurden in der maschinellen Übersetzung Parser verwendet, um einen Ausgangssatz in einen Syntaxbaum zu transformieren, dann wurden semantische Strukturen höherer Ebene extrahiert, um die Bedeutung des Satzes darzustellen, und basierend auf dieser Bedeutung und der Grammatik der Zielsprache wurde das Ergebnis generiert. Heutzutage werden viele NLP-Aufgaben effektiver mit neuronalen Netzwerken gelöst.
|
||||
Anfangs wurden die meisten NLP-Aufgaben mit traditionellen Methoden wie Grammatiken gelöst. Beispielsweise wurden bei der maschinellen Übersetzung Parser verwendet, um einen Satz in einen Syntaxbaum zu transformieren, daraus höhere semantische Strukturen extrahiert, um die Bedeutung des Satzes darzustellen, und basierend auf dieser Bedeutung und der Grammatik der Zielsprache das Ergebnis generiert. Heutzutage werden viele NLP-Aufgaben effektiver mit neuronalen Netzen gelöst.
|
||||
|
||||
> Viele klassische NLP-Methoden sind in der Python-Bibliothek [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) implementiert. Es gibt ein großartiges [NLTK-Buch](https://www.nltk.org/book/), das online verfügbar ist und zeigt, wie verschiedene NLP-Aufgaben mit NLTK gelöst werden können.
|
||||
> Viele klassische NLP-Methoden sind in der Python-Bibliothek [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) implementiert. Es gibt ein großartiges [NLTK-Buch](https://www.nltk.org/book/), das online verfügbar ist und behandelt, wie verschiedene NLP-Aufgaben mit NLTK gelöst werden können.
|
||||
|
||||
In unserem Kurs konzentrieren wir uns hauptsächlich auf die Verwendung neuronaler Netzwerke für NLP und verwenden NLTK, wo es erforderlich ist.
|
||||
In unserem Kurs konzentrieren wir uns hauptsächlich darauf, neuronale Netze für NLP zu verwenden, und wir nutzen NLTK bei Bedarf.
|
||||
|
||||
Wir haben bereits gelernt, wie neuronale Netzwerke für tabellarische Daten und Bilder verwendet werden können. Der Hauptunterschied zwischen diesen Datentypen und Text besteht darin, dass Text eine Sequenz variabler Länge ist, während die Eingabegröße bei Bildern im Voraus bekannt ist. Während konvolutionale Netzwerke Muster aus Eingabedaten extrahieren können, sind Muster in Texten komplexer. Zum Beispiel kann eine Verneinung vom Subjekt durch viele Wörter getrennt sein (z. B. *Ich mag keine Orangen* vs. *Ich mag diese großen bunten leckeren Orangen nicht*), und das sollte dennoch als ein Muster interpretiert werden. Daher müssen wir zur Verarbeitung von Sprache neue Arten von neuronalen Netzwerken einführen, wie z. B. *rekurrente Netzwerke* und *Transformers*.
|
||||
Wir haben bereits gelernt, neuronale Netze für tabellarische Daten und Bilder zu verwenden. Der Hauptunterschied zwischen diesen Datenarten und Text ist, dass Text eine Sequenz variabler Länge ist, während die Eingangsgröße bei Bildern im Voraus bekannt ist. Während konvolutionale Netzwerke Muster aus Eingabedaten extrahieren können, sind Muster im Text komplexer. Zum Beispiel kann die Verneinung vom Subjekt durch viele Wörter beliebig getrennt sein (z. B. *Ich mag keine Orangen* vs. *Ich mag diese großen bunten leckeren Orangen nicht*), und das sollte immer noch als ein Muster interpretiert werden. Um Sprache zu verarbeiten, benötigen wir daher neue Typen von neuronalen Netzen, wie *rekurrente Netze* und *Transformers*.
|
||||
|
||||
## Bibliotheken installieren
|
||||
|
||||
Wenn Sie eine lokale Python-Installation verwenden, um diesen Kurs auszuführen, müssen Sie möglicherweise alle erforderlichen Bibliotheken für NLP mit den folgenden Befehlen installieren:
|
||||
Wenn Sie eine lokale Python-Installation verwenden, um diesen Kurs durchzuführen, müssen Sie möglicherweise alle erforderlichen Bibliotheken für NLP mit den folgenden Befehlen installieren:
|
||||
|
||||
**Für PyTorch**
|
||||
**Für PyTorch**
|
||||
```bash
|
||||
pip install -r requirements-torch.txt
|
||||
```
|
||||
**Für TensorFlow**
|
||||
pip install -r requirements-pytorch.txt
|
||||
```
|
||||
**Für TensorFlow**
|
||||
```bash
|
||||
pip install -r requirements-tf.txt
|
||||
```
|
||||
```
|
||||
|
||||
> Sie können NLP mit TensorFlow auf [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) ausprobieren.
|
||||
|
||||
## GPU-Warnung
|
||||
|
||||
In diesem Abschnitt werden wir in einigen Beispielen recht große Modelle trainieren.
|
||||
* **Verwenden Sie einen Computer mit GPU-Unterstützung**: Es wird empfohlen, Ihre Notebooks auf einem Computer mit GPU-Unterstützung auszuführen, um die Wartezeiten beim Arbeiten mit großen Modellen zu reduzieren.
|
||||
* **GPU-Speicherbeschränkungen**: Das Ausführen auf einer GPU kann dazu führen, dass der GPU-Speicher ausgeht, insbesondere beim Training großer Modelle.
|
||||
* **GPU-Speicherverbrauch**: Die Menge des während des Trainings verbrauchten GPU-Speichers hängt von verschiedenen Faktoren ab, einschließlich der Minibatch-Größe.
|
||||
* **Minimieren Sie die Minibatch-Größe**: Wenn Sie auf GPU-Speicherprobleme stoßen, sollten Sie die Minibatch-Größe in Ihrem Code reduzieren.
|
||||
* **TensorFlow GPU-Speicherfreigabe**: Ältere Versionen von TensorFlow geben den GPU-Speicher möglicherweise nicht korrekt frei, wenn mehrere Modelle innerhalb eines Python-Kernels trainiert werden. Um den GPU-Speicher effektiv zu verwalten, können Sie TensorFlow so konfigurieren, dass GPU-Speicher nur bei Bedarf zugewiesen wird.
|
||||
* **Code-Einbindung**: Um TensorFlow so einzustellen, dass GPU-Speicher nur bei Bedarf wächst, fügen Sie den folgenden Code in Ihre Notebooks ein:
|
||||
In diesem Abschnitt werden wir einige ziemlich große Modelle trainieren.
|
||||
* **Verwenden Sie einen GPU-fähigen Computer**: Es ist ratsam, Ihre Notebooks auf einem GPU-fähigen Computer auszuführen, um Wartezeiten beim Arbeiten mit großen Modellen zu reduzieren.
|
||||
* **GPU-Speicherbegrenzungen**: Das Ausführen auf einer GPU kann dazu führen, dass der GPU-Speicher ausgeht, insbesondere beim Training großer Modelle.
|
||||
* **GPU-Speicherverbrauch**: Die Menge des während des Trainings verbrauchten GPU-Speichers hängt von verschiedenen Faktoren ab, einschließlich der Minibatch-Größe.
|
||||
* **Minibatch-Größe minimieren**: Wenn Sie auf Probleme mit dem GPU-Speicher stoßen, ziehen Sie in Erwägung, die Minibatch-Größe in Ihrem Code zu reduzieren.
|
||||
* **GPU-Speicherfreigabe in TensorFlow**: Ältere TensorFlow-Versionen geben den GPU-Speicher beim Training mehrerer Modelle in einem Python-Kernel möglicherweise nicht korrekt frei. Um den GPU-Speicher effizient zu verwalten, können Sie TensorFlow so konfigurieren, dass der GPU-Speicher nur nach Bedarf allokiert wird.
|
||||
* **Codeeinbindung**: Um TensorFlow so einzustellen, dass der GPU-Speicher nur bei Bedarf wächst, fügen Sie den folgenden Code in Ihre Notebooks ein:
|
||||
|
||||
```python
|
||||
physical_devices = tf.config.list_physical_devices('GPU')
|
||||
if len(physical_devices)>0:
|
||||
tf.config.experimental.set_memory_growth(physical_devices[0], True)
|
||||
```
|
||||
```
|
||||
|
||||
Wenn Sie daran interessiert sind, NLP aus der Perspektive des klassischen maschinellen Lernens zu lernen, besuchen Sie [diese Lektionenreihe](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP).
|
||||
Wenn Sie NLP aus einer klassischen ML-Perspektive kennenlernen möchten, besuchen Sie [diese Lektionensammlung](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
|
||||
|
||||
## In diesem Abschnitt
|
||||
In diesem Abschnitt werden wir lernen:
|
||||
In diesem Abschnitt lernen wir:
|
||||
|
||||
* [Text als Tensoren darstellen](13-TextRep/README.md)
|
||||
* [Wort-Embeddings](14-Emdeddings/README.md)
|
||||
* [Sprachmodellierung](15-LanguageModeling/README.md)
|
||||
* [Rekurrente neuronale Netzwerke](16-RNN/README.md)
|
||||
* [Generative Netzwerke](17-GenerativeNetworks/README.md)
|
||||
* [Transformers](18-Transformers/README.md)
|
||||
* [Text als Tensoren darstellen](13-TextRep/README.md)
|
||||
* [Wort-Einbettungen](14-Emdeddings/README.md)
|
||||
* [Sprachmodellierung](15-LanguageModeling/README.md)
|
||||
* [Rekurrente neuronale Netze](16-RNN/README.md)
|
||||
* [Generative Netzwerke](17-GenerativeNetworks/README.md)
|
||||
* [Transformers](18-Transformers/README.md)
|
||||
|
||||
**Haftungsausschluss**:
|
||||
Dieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, weisen wir darauf hin, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Nutzung dieser Übersetzung entstehen.
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Haftungsausschluss**:
|
||||
Dieses Dokument wurde mit dem KI-Übersetzungsdienst [Co-op Translator](https://github.com/Azure/co-op-translator) übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache gilt als maßgebliche Quelle. Bei kritischen Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -5,6 +5,12 @@
|
|||
"source_file": "AGENTS.md",
|
||||
"language_code": "es"
|
||||
},
|
||||
"CONTRIBUTING.md": {
|
||||
"original_hash": "c6fd7e781b67111a90abd166d0ce4aa0",
|
||||
"translation_date": "2026-07-08T20:19:23+00:00",
|
||||
"source_file": "CONTRIBUTING.md",
|
||||
"language_code": "es"
|
||||
},
|
||||
"README.md": {
|
||||
"original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b",
|
||||
"translation_date": "2026-04-06T15:32:56+00:00",
|
||||
|
|
@ -17,6 +23,19 @@
|
|||
"source_file": "SECURITY.md",
|
||||
"language_code": "es"
|
||||
},
|
||||
"__translation_failures__": {
|
||||
"lessons/sketchnotes/LICENSE.md": {
|
||||
"original_hash": "45ab63a2cd8f5faef6c9b150618837a4",
|
||||
"source_file": "lessons/sketchnotes/LICENSE.md",
|
||||
"language_code": "es",
|
||||
"failure_date": "2026-07-08T20:13:58+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:26:49+00:00",
|
||||
|
|
@ -54,8 +73,8 @@
|
|||
"language_code": "es"
|
||||
},
|
||||
"examples/README.md": {
|
||||
"original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7",
|
||||
"translation_date": "2025-10-03T11:26:17+00:00",
|
||||
"original_hash": "7883d52c2e2a221e0b07a7b112a149b9",
|
||||
"translation_date": "2026-07-08T20:08:45+00:00",
|
||||
"source_file": "examples/README.md",
|
||||
"language_code": "es"
|
||||
},
|
||||
|
|
@ -66,8 +85,8 @@
|
|||
"language_code": "es"
|
||||
},
|
||||
"lessons/0-course-setup/how-to-run.md": {
|
||||
"original_hash": "a4717bd9103b9f6cd84d534b83534689",
|
||||
"translation_date": "2026-01-15T10:47:10+00:00",
|
||||
"original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1",
|
||||
"translation_date": "2026-07-08T20:09:11+00:00",
|
||||
"source_file": "lessons/0-course-setup/how-to-run.md",
|
||||
"language_code": "es"
|
||||
},
|
||||
|
|
@ -191,6 +210,12 @@
|
|||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
|
||||
"language_code": "es"
|
||||
},
|
||||
"lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": {
|
||||
"original_hash": "99b816b6a4957ef4100cee4c4221dff9",
|
||||
"translation_date": "2026-07-08T20:01:29+00:00",
|
||||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
|
||||
"language_code": "es"
|
||||
},
|
||||
"lessons/4-ComputerVision/08-TransferLearning/lab/README.md": {
|
||||
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
|
||||
"translation_date": "2025-08-24T09:19:55+00:00",
|
||||
|
|
@ -330,8 +355,8 @@
|
|||
"language_code": "es"
|
||||
},
|
||||
"lessons/5-NLP/README.md": {
|
||||
"original_hash": "8ef02a9318257ea140ed3ed74442096d",
|
||||
"translation_date": "2025-08-24T09:11:33+00:00",
|
||||
"original_hash": "038df6f1a73e49f6430740da083bfd6d",
|
||||
"translation_date": "2026-07-08T20:09:47+00:00",
|
||||
"source_file": "lessons/5-NLP/README.md",
|
||||
"language_code": "es"
|
||||
},
|
||||
|
|
|
|||
|
|
@ -0,0 +1,29 @@
|
|||
# Contribuyendo a AI-For-Beginners
|
||||
|
||||
¡Gracias por su interés en contribuir a AI-For-Beginners! Aceptamos traducciones, correcciones de lecciones y correcciones de formato.
|
||||
|
||||
## Acuerdo de Licencia para Colaboradores (CLA) de Microsoft
|
||||
|
||||
Este proyecto acepta contribuciones y sugerencias. La mayoría de las contribuciones requieren que acepte un Acuerdo de Licencia para Colaboradores (CLA) declarando que tiene el derecho y efectivamente nos concede los derechos para usar su contribución. Para más detalles, visite [https://cla.microsoft.com](https://cla.microsoft.com).
|
||||
|
||||
Cuando envíe una solicitud de extracción, un bot CLA determinará automáticamente si necesita proporcionar un CLA y decorará la solicitud de extracción adecuadamente (por ejemplo, etiqueta, comentario). Simplemente siga las instrucciones proporcionadas por el bot. Sólo tendrá que hacer esto una vez en todos los repositorios que utilizan nuestro CLA.
|
||||
|
||||
## Cómo Contribuir
|
||||
|
||||
### 1. Corregir errores tipográficos / errores de código
|
||||
Si encuentra un error tipográfico o un bug en cualquier cuaderno Jupyter o archivo markdown de una lección:
|
||||
1. Haga un fork del repositorio.
|
||||
2. Corrija el error tipográfico o el enlace roto.
|
||||
3. Envíe una solicitud de extracción con una descripción clara de la corrección.
|
||||
|
||||
### 2. Enviar Traducciones
|
||||
¡Aceptamos traducciones de las lecciones a otros idiomas! Por favor, coloque las traducciones en el directorio `translations/` usando los nombres de carpetas existentes allí (por ejemplo `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`).
|
||||
|
||||
Para más detalles, consulte [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md).
|
||||
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Descargo de responsabilidad**:
|
||||
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -1,79 +1,79 @@
|
|||
# Ejemplos de IA para Principiantes
|
||||
|
||||
¡Bienvenido! Este directorio contiene ejemplos simples e independientes para ayudarte a comenzar con la inteligencia artificial y el aprendizaje automático. Cada ejemplo está diseñado para ser accesible para principiantes, con comentarios detallados y explicaciones paso a paso.
|
||||
¡Bienvenido! Este directorio contiene ejemplos simples e independientes para ayudarte a comenzar con IA y aprendizaje automático. Cada ejemplo está diseñado para ser amigable para principiantes, con comentarios detallados y explicaciones paso a paso.
|
||||
|
||||
## 📚 Resumen de Ejemplos
|
||||
|
||||
| Ejemplo | Descripción | Dificultad | Requisitos Previos |
|
||||
|---------|-------------|------------|--------------------|
|
||||
| [Hola Mundo de IA](../../../examples/01-hello-ai-world.py) | Tu primer programa de IA: reconocimiento de patrones simple | ⭐ Principiante | Conceptos básicos de Python |
|
||||
| [Red Neuronal Simple](../../../examples/02-simple-neural-network.py) | Construye una red neuronal desde cero | ⭐⭐ Principiante+ | Python, matemáticas básicas |
|
||||
| [Clasificador de Imágenes](./03-image-classifier.ipynb) | Clasifica imágenes con un modelo preentrenado | ⭐⭐ Principiante+ | Python, numpy |
|
||||
| [Análisis de Sentimientos de Texto](../../../examples/04-text-sentiment.py) | Analiza el sentimiento de un texto (positivo/negativo) | ⭐⭐ Principiante+ | Python |
|
||||
| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Tu primer programa de IA - reconocimiento simple de patrones | ⭐ Principiante | Conceptos básicos de Python |
|
||||
| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Construye una red neuronal desde cero | ⭐⭐ Principiante+ | Python, matemáticas básicas |
|
||||
| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Clasifica imágenes con un modelo preentrenado | ⭐⭐ Principiante+ | Python, numpy |
|
||||
| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analiza el sentimiento del texto (positivo/negativo) | ⭐⭐ Principiante+ | Python |
|
||||
|
||||
## 🚀 Comenzando
|
||||
|
||||
### Requisitos Previos
|
||||
|
||||
Asegúrate de tener Python instalado (se recomienda la versión 3.8 o superior). Instala los paquetes necesarios:
|
||||
Asegúrate de tener Python instalado (se recomienda 3.8 o superior). Instala los paquetes necesarios:
|
||||
|
||||
```bash
|
||||
# For Python scripts
|
||||
# Para scripts de Python
|
||||
pip install numpy
|
||||
|
||||
# For Jupyter notebooks (image classifier)
|
||||
# Para notebooks de Jupyter (clasificador de imágenes)
|
||||
pip install jupyter numpy pillow tensorflow
|
||||
```
|
||||
|
||||
O utiliza el entorno conda del currículo principal:
|
||||
O usa el entorno conda del plan principal:
|
||||
|
||||
```bash
|
||||
conda env create --name ai4beg --file ../environment.yml
|
||||
conda activate ai4beg
|
||||
```
|
||||
|
||||
### Ejecutando los Ejemplos
|
||||
### Ejecutar los Ejemplos
|
||||
|
||||
**Para scripts de Python (.py):**
|
||||
**Para scripts Python (.py):**
|
||||
```bash
|
||||
python 01-hello-ai-world.py
|
||||
```
|
||||
|
||||
**Para notebooks de Jupyter (.ipynb):**
|
||||
**Para notebooks Jupyter (.ipynb):**
|
||||
```bash
|
||||
jupyter notebook 03-image-classifier.ipynb
|
||||
```
|
||||
|
||||
## 📖 Ruta de Aprendizaje
|
||||
|
||||
Recomendamos seguir los ejemplos en el siguiente orden:
|
||||
Recomendamos seguir los ejemplos en orden:
|
||||
|
||||
1. **Comienza con "Hola Mundo de IA"** - Aprende los conceptos básicos del reconocimiento de patrones
|
||||
1. **Comienza con "Hello AI World"** - Aprende los fundamentos del reconocimiento de patrones
|
||||
2. **Construye una Red Neuronal Simple** - Entiende cómo funcionan las redes neuronales
|
||||
3. **Prueba el Clasificador de Imágenes** - Observa la IA en acción con imágenes reales
|
||||
4. **Analiza el Sentimiento de Texto** - Explora el procesamiento del lenguaje natural
|
||||
3. **Prueba el Clasificador de Imágenes** - Observa IA en acción con imágenes reales
|
||||
4. **Analiza el Sentimiento del Texto** - Explora el procesamiento del lenguaje natural
|
||||
|
||||
## 💡 Consejos para Principiantes
|
||||
|
||||
- **Lee cuidadosamente los comentarios del código** - Explican qué hace cada línea
|
||||
- **¡Experimenta!** - Prueba cambiar valores y observa qué sucede
|
||||
- **No te preocupes por entender todo** - Aprender lleva tiempo
|
||||
- **¡Experimenta!** - Prueba cambiando valores y observa qué pasa
|
||||
- **No te preocupes por entender todo** - Aprender requiere tiempo
|
||||
- **Haz preguntas** - Usa el [foro de discusión](https://github.com/microsoft/AI-For-Beginners/discussions)
|
||||
|
||||
## 🔗 Próximos Pasos
|
||||
|
||||
Después de completar estos ejemplos, explora el currículo completo:
|
||||
- [Introducción a la IA](../lessons/1-Intro/README.md)
|
||||
Después de completar estos ejemplos, explora el plan completo:
|
||||
- [Introducción a IA](../lessons/1-Intro/README.md)
|
||||
- [Redes Neuronales](../lessons/3-NeuralNetworks/README.md)
|
||||
- [Visión por Computadora](../lessons/4-ComputerVision/README.md)
|
||||
- [Procesamiento del Lenguaje Natural](../lessons/5-NLP/README.md)
|
||||
- [Procesamiento de Lenguaje Natural](../lessons/5-NLP/README.md)
|
||||
|
||||
## 🤝 Contribuir
|
||||
## 🤝 Contribuyendo
|
||||
|
||||
¿Encontraste útiles estos ejemplos? Ayúdanos a mejorarlos:
|
||||
¿Te parecieron útiles estos ejemplos? Ayúdanos a mejorarlos:
|
||||
- Reporta problemas o sugiere mejoras
|
||||
- Agrega más ejemplos para principiantes
|
||||
- Mejora la documentación y los comentarios
|
||||
- Mejora la documentación y comentarios
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -81,5 +81,7 @@ Después de completar estos ejemplos, explora el currículo completo:
|
|||
|
||||
---
|
||||
|
||||
**Descargo de responsabilidad**:
|
||||
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Descargo de responsabilidad**:
|
||||
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -1,12 +1,12 @@
|
|||
# Cómo Ejecutar el Código
|
||||
|
||||
Este plan de estudios contiene muchos ejemplos ejecutables y laboratorios que querrás ejecutar. Para hacerlo, necesitas la capacidad de ejecutar código Python en los Jupyter Notebooks proporcionados como parte de este plan de estudios. Tienes varias opciones para ejecutar el código:
|
||||
Este currículo contiene muchos ejemplos ejecutables y laboratorios que querrás ejecutar. Para hacer esto, necesitas la capacidad de ejecutar código Python en Jupyter Notebooks que se proporcionan como parte de este currículo. Tienes varias opciones para ejecutar el código:
|
||||
|
||||
## Ejecutar localmente en tu computadora
|
||||
|
||||
Para ejecutar el código localmente en tu computadora, se necesita una instalación de Python. Una recomendación es instalar **[miniconda](https://conda.io/en/latest/miniconda.html)**: es una instalación bastante ligera que soporta el gestor de paquetes `conda` para diferentes **entornos virtuales** de Python.
|
||||
Para ejecutar el código localmente en tu computadora, se necesita una instalación de Python. Una recomendación es instalar **[miniconda](https://conda.io/en/latest/miniconda.html)** - es una instalación bastante ligera que soporta el gestor de paquetes `conda` para diferentes **entornos virtuales** de Python.
|
||||
|
||||
Después de instalar miniconda, clona el repositorio y crea un entorno virtual que será usado para este curso:
|
||||
Después de instalar miniconda, clona el repositorio y crea un entorno virtual que se usará para este curso:
|
||||
|
||||
```bash
|
||||
git clone http://github.com/microsoft/ai-for-beginners
|
||||
|
|
@ -17,17 +17,17 @@ conda activate ai4beg
|
|||
|
||||
### Usando Visual Studio Code con la Extensión de Python
|
||||
|
||||
Este plan de estudios se usa mejor cuando se abre en [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) con la [Extensión de Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste).
|
||||
Este currículo es mejor utilizarlo abriéndolo en [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) con la [Extensión de Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste).
|
||||
|
||||
> **Nota**: Una vez que clones y abras el directorio en VS Code, automáticamente te sugerirá instalar las extensiones de Python. También tendrás que instalar miniconda como se describió arriba.
|
||||
> **Nota**: Una vez que clonas y abres el directorio en VS Code, te sugerirá automáticamente instalar extensiones de Python. También tendrás que instalar miniconda como se describió arriba.
|
||||
|
||||
> **Nota**: Si VS Code te sugiere volver a abrir el repositorio en un contenedor, deberías rechazar esto para usar la instalación local de Python.
|
||||
> **Nota**: Si VS Code te sugiere reabrir el repositorio en un contenedor, deberías rechazar esto para usar la instalación local de Python.
|
||||
|
||||
### Usando Jupyter en el Navegador
|
||||
### Usar Jupyter en el Navegador
|
||||
|
||||
También puedes usar un entorno Jupyter desde el navegador en tu propia computadora. Tanto Jupyter clásico como JupyterHub proveen un entorno de desarrollo conveniente con autocompletado, resaltado de código, etc.
|
||||
También puedes usar un entorno Jupyter desde el navegador en tu propia computadora. Tanto Jupyter clásico como JupyterHub proporcionan un entorno de desarrollo conveniente con autocompletado, resaltado de código, etc.
|
||||
|
||||
Para iniciar Jupyter localmente, ve al directorio del curso, y ejecuta:
|
||||
Para iniciar Jupyter localmente, ve al directorio del curso y ejecuta:
|
||||
|
||||
```bash
|
||||
jupyter notebook
|
||||
|
|
@ -38,34 +38,34 @@ jupyterhub
|
|||
```
|
||||
Luego puedes navegar a cualquiera de los archivos `.ipynb`, abrirlos y comenzar a trabajar.
|
||||
|
||||
### Ejecutando en un contenedor
|
||||
### Ejecutar en contenedor
|
||||
|
||||
Una alternativa a la instalación de Python sería ejecutar el código en un contenedor. Debido a que nuestro repositorio proporciona una carpeta especial `.devcontainer` que indica cómo construir un contenedor para este repositorio, VS Code ofrece la opción de volver a abrir el código en un contenedor. Esto requerirá la instalación de Docker y además sería más complejo, por lo que recomendamos esto a usuarios con más experiencia.
|
||||
Una alternativa a la instalación de Python sería ejecutar el código en un contenedor. Dado que nuestro repositorio suministra una carpeta especial `.devcontainer` que indica cómo construir un contenedor para este repositorio, VS Code ofrece la posibilidad de reabrir el código en un contenedor. Esto requerirá la instalación de Docker, y también sería más complejo, por lo que recomendamos esto a usuarios más experimentados.
|
||||
|
||||
## Ejecutar en la Nube
|
||||
|
||||
Si no quieres instalar Python localmente y tienes acceso a algunos recursos en la nube, una buena alternativa sería ejecutar el código en la nube. Hay varias maneras de hacerlo:
|
||||
Si no quieres instalar Python localmente y tienes acceso a algunos recursos en la nube, una buena alternativa sería ejecutar el código en la nube. Hay varias maneras en que puedes hacer esto:
|
||||
|
||||
* Usando **[GitHub Codespaces](https://github.com/features/codespaces)**, que es un entorno virtual creado para ti en GitHub, accesible a través de una interfaz de navegador de VS Code. Si tienes acceso a Codespaces, solo tienes que hacer clic en el botón **Code** en el repositorio, iniciar un codespace y comenzar a trabajar en muy poco tiempo.
|
||||
* Usando **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) ofrece recursos de cómputo gratuitos proporcionados en la nube para personas como tú que quieren probar código en GitHub. Hay un botón en la página principal para abrir el repositorio en Binder; esto debería llevarte rápidamente al sitio de Binder, que construirá un contenedor subyacente e iniciará una interfaz web de Jupyter para ti sin inconvenientes.
|
||||
* Usar **[GitHub Codespaces](https://github.com/features/codespaces)**, que es un entorno virtual creado para ti en GitHub, accesible a través de una interfaz de navegador de VS Code. Si tienes acceso a Codespaces, solo tienes que hacer clic en el botón **Code** en el repositorio, iniciar un codespace y empezar a trabajar en poco tiempo.
|
||||
* Usar **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) ofrece recursos computacionales gratuitos proporcionados en la nube para personas como tú para probar código en GitHub. Hay un botón en la página principal para abrir el repositorio en Binder - esto debería llevarte rápidamente al sitio de Binder, que construirá un contenedor subyacente y comenzará una interfaz web de Jupyter para ti sin problemas.
|
||||
|
||||
> **Nota**: Para prevenir uso indebido, Binder tiene acceso bloqueado a algunos recursos web. Esto puede prevenir que parte del código funcione si descarga modelos y/o conjuntos de datos de Internet público. Puede que necesites encontrar algunas soluciones alternativas. Además, los recursos de cómputo proporcionados por Binder son bastante básicos, por lo que el entrenamiento será lento, especialmente en lecciones posteriores y más complejas.
|
||||
> **Nota**: Para prevenir usos indebidos, Binder tiene acceso a algunos recursos web bloqueados. Esto puede impedir que parte del código funcione, especialmente el que descarga modelos y/o conjuntos de datos desde Internet público. Puede que necesites encontrar algunas soluciones alternativas. Además, los recursos computacionales proporcionados por Binder son bastante básicos, por lo que el entrenamiento será lento, especialmente en lecciones posteriores y más complejas.
|
||||
|
||||
## Ejecutar en la Nube con GPU
|
||||
|
||||
Algunas de las lecciones posteriores en este plan de estudios se beneficiarían mucho del soporte de GPU. El entrenamiento de modelos, por ejemplo, puede ser dolorosamente lento de otra forma. Hay algunas opciones que puedes seguir, especialmente si tienes acceso a la nube ya sea mediante [Azure para Estudiantes](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) o a través de tu institución:
|
||||
Algunas de las lecciones posteriores de este currículo se beneficiarían mucho del soporte GPU. El entrenamiento de modelos, por ejemplo, puede ser dolorosamente lento de otra manera. Hay algunas opciones que puedes seguir, especialmente si tienes acceso a la nube ya sea a través de [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), o mediante tu institución:
|
||||
|
||||
* Crear una [Máquina Virtual para Ciencia de Datos](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) y conectarte a ella mediante Jupyter. Luego puedes clonar el repositorio directamente en la máquina y comenzar a aprender. Las máquinas virtuales de la serie NC tienen soporte para GPU.
|
||||
* Crear una [Máquina Virtual de Ciencia de Datos](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) y conectarte a ella a través de Jupyter. Luego puedes clonar el repositorio directamente en la máquina y comenzar a aprender. Las máquinas virtuales de la serie NC tienen soporte GPU.
|
||||
|
||||
> **Nota**: Algunas suscripciones, incluidas Azure para Estudiantes, no proporcionan soporte para GPU por defecto. Puede que necesites solicitar núcleos GPU adicionales mediante una solicitud de soporte técnico.
|
||||
> **Nota**: Algunas suscripciones, incluyendo Azure for Students, no proporcionan soporte GPU por defecto. Puede que tengas que solicitar núcleos GPU adicionales con una solicitud de soporte técnico.
|
||||
|
||||
* Crear un [Espacio de Trabajo Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) y luego usar la función de Notebook allí. [Este video](https://azure-for-academics.github.io/quickstart/azureml-papers/) muestra cómo clonar un repositorio en un notebook de Azure ML y comenzar a usarlo.
|
||||
* Crear un [Espacio de Trabajo Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) y luego usar la función de Notebooks allí. [Este video](https://azure-for-academics.github.io/quickstart/azureml-papers/) muestra cómo clonar un repositorio en un notebook de Azure ML y empezar a usarlo.
|
||||
|
||||
También puedes usar Google Colab, que viene con soporte gratuito de GPU y subir allí Jupyter Notebooks para ejecutarlos uno por uno.
|
||||
También puedes usar Google Colab, que viene con algo de soporte GPU gratuito, y subir Jupyter Notebooks allí para ejecutarlos uno por uno.
|
||||
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Aviso legal**:
|
||||
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No nos hacemos responsables por malentendidos o interpretaciones erróneas derivadas del uso de esta traducción.
|
||||
**Descargo de responsabilidad**:
|
||||
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -6,9 +6,9 @@
|
|||
"source": [
|
||||
"# Modelos preentrenados y aprendizaje por transferencia\n",
|
||||
"\n",
|
||||
"Entrenar redes neuronales convolucionales (CNNs) puede llevar mucho tiempo y requiere una gran cantidad de datos. Sin embargo, gran parte del tiempo se dedica a aprender los mejores filtros de bajo nivel que una red utiliza para extraer patrones de las imágenes. Surge una pregunta natural: ¿podemos usar una red neuronal entrenada en un conjunto de datos y adaptarla para clasificar imágenes diferentes sin realizar todo el proceso de entrenamiento?\n",
|
||||
"Entrenar CNNs puede tomar mucho tiempo, y se requiere una gran cantidad de datos para esa tarea. Sin embargo, gran parte del tiempo se emplea en aprender los mejores filtros de bajo nivel que una red utiliza para extraer patrones de las imágenes. Surge una pregunta natural: ¿podemos usar una red neuronal entrenada en un conjunto de datos y adaptarla para clasificar diferentes imágenes sin un proceso de entrenamiento completo?\n",
|
||||
"\n",
|
||||
"Este enfoque se llama **aprendizaje por transferencia**, porque transferimos cierto conocimiento de un modelo de red neuronal a otro. En el aprendizaje por transferencia, normalmente comenzamos con un modelo preentrenado, que ha sido entrenado en un conjunto de datos de imágenes grande, como **ImageNet**. Estos modelos ya pueden realizar un buen trabajo extrayendo diferentes características de imágenes genéricas, y en muchos casos, simplemente construir un clasificador sobre esas características extraídas puede dar buenos resultados.\n"
|
||||
"Este enfoque se llama **aprendizaje por transferencia**, porque transferimos algún conocimiento de un modelo de red neuronal a otro. En el aprendizaje por transferencia, típicamente comenzamos con un modelo preentrenado, que ha sido entrenado en algún conjunto de datos de imágenes grande, como **ImageNet**. Esos modelos ya pueden hacer un buen trabajo extrayendo diferentes características de imágenes genéricas, y en muchos casos solo construir un clasificador sobre esas características extraídas puede producir un buen resultado.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -29,11 +29,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Conjunto de Datos de Gatos vs. Perros\n",
|
||||
"## Conjunto de datos de Gatos vs. Perros\n",
|
||||
"\n",
|
||||
"En esta unidad, resolveremos un problema de la vida real clasificando imágenes de gatos y perros. Para ello, utilizaremos el [Conjunto de Datos de Gatos vs. Perros de Kaggle](https://www.kaggle.com/c/dogs-vs-cats), que también se puede descargar [desde Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
|
||||
"En esta unidad, resolveremos un problema real de clasificación de imágenes de gatos y perros. Por esta razón, utilizaremos el [Conjunto de datos Gatos vs. Perros de Kaggle](https://www.kaggle.com/c/dogs-vs-cats), que también se puede descargar [desde Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
|
||||
"\n",
|
||||
"Descarguemos este conjunto de datos y extráigamoslo en el directorio `data` (¡este proceso puede tomar algo de tiempo!):\n"
|
||||
"Descarguemos este conjunto de datos y extráigalo en el directorio `data` (¡este proceso puede tomar algo de tiempo!):\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -64,7 +64,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Desafortunadamente, hay algunos archivos de imagen corruptos en el conjunto de datos. Necesitamos hacer una limpieza rápida para verificar los archivos corruptos. Para no saturar este tutorial, movimos el código para verificar el conjunto de datos a un módulo.\n"
|
||||
"Desafortunadamente, hay algunos archivos de imagen corruptos en el conjunto de datos. Necesitamos hacer una limpieza rápida para verificar archivos corruptos. Para no estropear este tutorial, movimos el código para verificar el conjunto de datos a un módulo.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -335,11 +335,11 @@
|
|||
"source": [
|
||||
"## Cargando el conjunto de datos\n",
|
||||
"\n",
|
||||
"En ejemplos anteriores, estuvimos cargando conjuntos de datos integrados en Keras. Ahora vamos a trabajar con nuestro propio conjunto de datos, que necesitamos cargar desde un directorio de imágenes.\n",
|
||||
"En ejemplos anteriores, cargábamos conjuntos de datos que vienen incorporados en Keras. Ahora vamos a trabajar con nuestro propio conjunto de datos, que necesitamos cargar desde un directorio de imágenes.\n",
|
||||
"\n",
|
||||
"En la vida real, el tamaño de los conjuntos de datos de imágenes puede ser bastante grande, y no se puede depender de que todos los datos puedan caber en la memoria. Por lo tanto, los conjuntos de datos a menudo se representan como **generadores** que pueden devolver datos en minibatches adecuados para el entrenamiento.\n",
|
||||
"En la vida real, el tamaño de los conjuntos de datos de imágenes puede ser bastante grande, y no se puede confiar en que todos los datos quepan en la memoria. Por lo tanto, los conjuntos de datos a menudo se representan como **generadores** que pueden devolver datos en minibatches adecuados para el entrenamiento.\n",
|
||||
"\n",
|
||||
"Para trabajar con la clasificación de imágenes, Keras incluye una función especial llamada `image_dataset_from_directory`, que puede cargar imágenes desde subdirectorios correspondientes a diferentes clases. Esta función también se encarga de escalar las imágenes y puede dividir el conjunto de datos en subconjuntos de entrenamiento y prueba:\n"
|
||||
"Para trabajar con clasificación de imágenes, Keras incluye una función especial `image_dataset_from_directory`, que puede cargar imágenes desde subdirectorios correspondientes a diferentes clases. Esta función también se encarga de escalar las imágenes y puede dividir el conjunto de datos en subconjuntos de entrenamiento y prueba:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -383,9 +383,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Es importante establecer el mismo valor de `seed` para ambas llamadas, ya que esto afecta la división de imágenes entre el conjunto de entrenamiento y el conjunto de prueba.\n",
|
||||
"Es importante establecer el mismo valor de `seed` para ambas llamadas, porque afecta la división de imágenes entre el conjunto de datos de entrenamiento y prueba.\n",
|
||||
"\n",
|
||||
"El conjunto de datos detecta automáticamente los nombres de las clases desde los directorios, y puedes acceder a ellos si es necesario llamando:\n"
|
||||
"Dataset selecciona automáticamente los nombres de las clases de los directorios, y puedes acceder a ellos si es necesario llamando a:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -412,7 +412,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Los conjuntos de datos que hemos obtenido pueden pasarse directamente a la función `fit` para entrenar el modelo. Contienen tanto las imágenes correspondientes como las etiquetas, que se pueden recorrer utilizando la siguiente construcción:\n"
|
||||
"Los conjuntos de datos que hemos obtenido se pueden pasar directamente a la función `fit` para entrenar el modelo. Contienen tanto las imágenes correspondientes como las etiquetas, que se pueden recorrer usando la siguiente construcción:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -453,7 +453,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **Nota**: Todas las imágenes en el conjunto de datos están representadas como tensores de punto flotante con un rango de 0-255. Antes de pasarlas a la red neuronal, necesitamos escalar esos valores al rango de 0-1. Al graficar imágenes, necesitamos hacer lo mismo o convertir los valores al tipo `int` (lo cual hacemos en el código anterior) para mostrarle a `matplotlib` que queremos graficar la imagen original sin escalar.\n"
|
||||
"> **Nota**: Todas las imágenes en el conjunto de datos están representadas como tensores de punto flotante con rango 0-255. Antes de pasarlas a la red neuronal, necesitamos escalar esos valores al rango 0-1. Al graficar imágenes, debemos hacer lo mismo o convertir los valores al tipo `int` (lo cual hacemos en el código anterior), para mostrar a `matplotlib` que queremos graficar la imagen original sin escalar.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -462,7 +462,7 @@
|
|||
"source": [
|
||||
"## Modelos preentrenados\n",
|
||||
"\n",
|
||||
"Para muchas tareas de clasificación de imágenes, se pueden encontrar modelos de redes neuronales preentrenados. Muchos de estos modelos están disponibles dentro del espacio de nombres `keras.applications`, y aún más modelos se pueden encontrar en Internet. Veamos cómo se puede cargar y utilizar el modelo más simple, VGG-16:\n"
|
||||
"Para muchas tareas de clasificación de imágenes se pueden encontrar modelos de redes neuronales preentrenados. Muchos de esos modelos están disponibles dentro del espacio de nombres `keras.applications`, y aún más modelos se pueden encontrar en Internet. Veamos cómo se puede cargar y usar el modelo más sencillo VGG-16:\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": [
|
||||
"Hay un par de cosas importantes aquí:\n",
|
||||
"* Antes de pasar una entrada a cualquier red preentrenada, debe ser preprocesada de cierta manera. Esto se realiza llamando a la función correspondiente `preprocess_input`, que recibe un lote de imágenes y devuelve su forma procesada. En el caso de VGG-16, las imágenes se normalizan y se resta un valor promedio predefinido para cada canal. Esto se debe a que VGG-16 fue originalmente entrenada con este preprocesamiento.\n",
|
||||
"* La red neuronal se aplica al lote de entrada, y como resultado recibimos un lote de tensores de 1000 elementos que muestran la probabilidad de cada clase. Podemos encontrar el número de la clase más probable llamando a `argmax` en este tensor.\n",
|
||||
"* El resultado obtenido es un [número de una clase de `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Para interpretar este resultado, también podemos usar la función `decode_predictions`, que devuelve las n clases principales junto con sus nombres.\n"
|
||||
"* Antes de pasar una entrada a cualquier red pre-entrenada, debe ser preprocesada de cierta manera. Esto se hace llamando a la función `preprocess_input` correspondiente, que recibe un lote de imágenes y devuelve su forma procesada. En el caso de VGG-16, las imágenes se normalizan y se resta un valor promedio predefinido para cada canal. Eso es porque VGG-16 se entrenó originalmente con este preprocesamiento.\n",
|
||||
"* La red neuronal se aplica al lote de entrada, y recibimos como resultado un lote de tensores de 1000 elementos que muestran la probabilidad de cada clase. Podemos encontrar el número de clase más probable llamando a `argmax` en este tensor.\n",
|
||||
"* El resultado obtenido es un [número de una clase `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Para darle sentido a este resultado, también podemos usar la función `decode_predictions`, que devuelve las n mejores clases junto con sus nombres.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -597,9 +607,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Cálculos en GPU\n",
|
||||
"## Cómputos en GPU\n",
|
||||
"\n",
|
||||
"Las redes neuronales profundas, como VGG-16 y otras arquitecturas más modernas, requieren bastante potencia de cálculo para ejecutarse. Tiene sentido utilizar la aceleración de GPU, si está disponible. Afortunadamente, Keras acelera automáticamente los cálculos en la GPU si está disponible. Podemos verificar si Tensorflow es capaz de usar la GPU utilizando el siguiente código:\n"
|
||||
"Las redes neuronales profundas, como VGG-16 y otras arquitecturas más modernas, requieren bastante potencia computacional para ejecutarse. Tiene sentido usar aceleración por GPU, si está disponible. Afortunadamente, Keras acelera automáticamente los cálculos en la GPU si esta está disponible. Podemos verificar si Tensorflow puede usar la GPU con el siguiente código:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -626,9 +636,10 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n",
|
||||
"## Extrayendo características de VGG\n",
|
||||
"\n",
|
||||
"Si queremos usar VGG-16 para extraer características de nuestras imágenes, necesitamos el modelo sin las capas finales de clasificación. Podemos instanciar el modelo VGG-16 sin las capas superiores utilizando este código:\n"
|
||||
"Si queremos usar VGG-16 para extraer características de nuestras imágenes, necesitamos el modelo sin las capas finales de clasificación. Podemos instanciar el modelo VGG-16 sin las capas superiores usando este código:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -680,9 +691,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"La dimensión del tensor de características es 7x7x512, pero para poder visualizarlo tuvimos que remodelarlo a una forma 2D.\n",
|
||||
"La dimensión del tensor de características es 7x7x512, pero para poder visualizarlo tuvimos que remodelarlo a forma 2D.\n",
|
||||
"\n",
|
||||
"Ahora intentemos ver si esas características pueden usarse para clasificar imágenes. Tomemos manualmente una porción de imágenes (50 minibatches, en nuestro caso) y precomputemos sus vectores de características. Podemos usar la API de **dataset** de Tensorflow para hacerlo. La función `map` toma un conjunto de datos y aplica una lambda-función dada para transformarlo. Usamos este mecanismo para construir nuevos conjuntos de datos, `ds_features_train` y `ds_features_test`, que contienen las características extraídas por VGG en lugar de las imágenes originales.\n"
|
||||
"Ahora intentemos ver si esas características pueden usarse para clasificar imágenes. Tomemos manualmente una porción de imágenes (50 minibatches, en nuestro caso), y pre-calculamos sus vectores de características. Podemos usar la API **dataset** de Tensorflow para eso. La función `map` toma un dataset y aplica una función lambda dada para transformarlo. Usamos este mecanismo para construir nuevos datasets, `ds_features_train` y `ds_features_test`, que contienen características extraídas con VGG en lugar de las imágenes originales.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -712,9 +723,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Usamos la construcción `.take(50)` para limitar el tamaño del conjunto de datos y acelerar nuestra demostración. Por supuesto, puedes realizar este experimento con el conjunto de datos completo.\n",
|
||||
"Usamos la construcción `.take(50)` para limitar el tamaño del conjunto de datos, para acelerar nuestra demostración. Por supuesto, puedes realizar este experimento con el conjunto de datos completo.\n",
|
||||
"\n",
|
||||
"Ahora que tenemos un conjunto de datos con características extraídas, podemos entrenar un clasificador denso simple para distinguir entre gatos y perros. Esta red tomará un vector de características con forma (7,7,512) y producirá una salida que corresponderá a un perro o a un gato. Dado que se trata de una clasificación binaria, utilizamos la función de activación `sigmoid` y la pérdida `binary_crossentropy`.\n"
|
||||
"Ahora que tenemos un conjunto de datos con características extraídas, podemos entrenar un clasificador denso simple para distinguir entre gatos y perros. Esta red tomará un vector de características de forma (7,7,512), y producirá una salida que corresponde ya sea a un perro o a un gato. Debido a que es una clasificación binaria, usamos la función de activación `sigmoid` y la pérdida `binary_crossentropy`.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -743,13 +754,13 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"¡El resultado es excelente! ¡Podemos distinguir entre un gato y un perro con casi un 95% de probabilidad! Sin embargo, solo hemos probado este enfoque en un subconjunto de todas las imágenes, ya que la extracción manual de características parece tomar mucho tiempo.\n",
|
||||
"¡El resultado es excelente, podemos distinguir entre un gato y un perro con casi un 95% de probabilidad! Sin embargo, solo hemos probado este enfoque en un subconjunto de todas las imágenes, porque la extracción manual de características parece tomar mucho tiempo.\n",
|
||||
"\n",
|
||||
"## Aprendizaje por transferencia utilizando una red VGG\n",
|
||||
"## Aprendizaje por transferencia usando una red VGG\n",
|
||||
"\n",
|
||||
"También podemos evitar precomputar manualmente las características utilizando la red VGG-16 original en su totalidad durante el entrenamiento, añadiendo un extractor de características a nuestra red como primera capa.\n",
|
||||
"También podemos evitar el pre-cálculo manual de las características usando la red original VGG-16 como un todo durante el entrenamiento, añadiendo el extractor de características a nuestra red como una primera capa.\n",
|
||||
"\n",
|
||||
"¡La belleza de la arquitectura de Keras es que el modelo VGG-16 que hemos definido anteriormente también puede usarse como una capa en otra red neuronal! Solo necesitamos construir una red con un clasificador denso encima de ella y luego entrenar toda la red utilizando retropropagación.\n"
|
||||
"¡La belleza de la arquitectura Keras es que el modelo VGG-16 que definimos arriba también puede usarse como una capa en otra red neuronal! Solo necesitamos construir una red con un clasificador denso encima, y luego entrenar toda la red usando retropropagación.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -793,13 +804,13 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Este modelo parece una red de clasificación de extremo a extremo, que toma una imagen y devuelve la clase. Sin embargo, lo complicado es que queremos que VGG16 actúe como un extractor de características y no sea reentrenado. Por lo tanto, necesitamos **congelar los pesos del extractor de características convolucionales**. Podemos acceder a la primera capa de la red llamando a `model.layers[0]`, y solo necesitamos establecer la propiedad `trainable` en `False`.\n",
|
||||
"Este modelo parece una red de clasificación de extremo a extremo, que toma una imagen y devuelve la clase. Sin embargo, lo complicado es que queremos que VGG16 actúe como un extractor de características, y no que se reentrene. Por lo tanto, necesitamos **congelar los pesos del extractor de características convolucional**. Podemos acceder a la primera capa de la red llamando a `model.layers[0]`, y solo necesitamos establecer la propiedad `trainable` en `False`.\n",
|
||||
"\n",
|
||||
"> **Nota**: La congelación de los pesos del extractor de características es necesaria, porque de lo contrario la capa clasificadora no entrenada podría destruir los pesos preentrenados originales del extractor convolucional.\n",
|
||||
"> **Nota**: Es necesario congelar los pesos del extractor de características, porque de lo contrario, la capa clasificador no entrenada puede destruir los pesos originales preentrenados del extractor convolucional.\n",
|
||||
"\n",
|
||||
"Puedes notar que, aunque el número total de parámetros en nuestra red es de alrededor de 15 millones, solo estamos entrenando 25,000 parámetros. Todos los demás parámetros de los filtros convolucionales de nivel superior están preentrenados. Esto es bueno, porque podemos ajustar un menor número de parámetros con un menor número de ejemplos.\n",
|
||||
"Puede notar que, mientras el número total de parámetros en nuestra red es de alrededor de 15 millones, solo estamos entrenando 25k parámetros. Todos los demás parámetros de los filtros convolucionales de nivel superior están preentrenados. Eso es bueno, porque podemos afinar un menor número de parámetros con una menor cantidad de ejemplos.\n",
|
||||
"\n",
|
||||
"Ahora entrenaremos nuestra red y veremos qué tan buenos resultados podemos obtener. Espera un tiempo de ejecución bastante largo y no te preocupes si la ejecución parece estar congelada por un tiempo.\n"
|
||||
"Ahora entrenaremos nuestra red y veremos qué tan bien podemos hacerlo. Espere un tiempo de ejecución bastante largo, y no se preocupe si la ejecución parece congelada por un tiempo.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -824,7 +835,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"¡Parece que hemos obtenido un clasificador de gatos contra perros bastante preciso!\n",
|
||||
"¡Parece que hemos obtenido un clasificador de gatos vs. perros razonablemente preciso!\n",
|
||||
"\n",
|
||||
"## Guardar y cargar el modelo\n",
|
||||
"\n",
|
||||
|
|
@ -852,7 +863,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Podemos cargar el modelo desde el archivo en cualquier momento. Puede resultar útil en caso de que el próximo experimento destruya el modelo; no tendrías que empezar desde cero.\n"
|
||||
"Entonces podemos cargar el modelo desde el archivo en cualquier momento. Puede resultarte útil en caso de que el siguiente experimento destruya el modelo; no tendrías que empezar desde cero.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -870,13 +881,13 @@
|
|||
"source": [
|
||||
"## Ajuste fino del aprendizaje por transferencia\n",
|
||||
"\n",
|
||||
"En la sección anterior, entrenamos la capa final del clasificador para clasificar imágenes en nuestro propio conjunto de datos. Sin embargo, no volvimos a entrenar el extractor de características, y nuestro modelo se basó en las características que había aprendido con los datos de ImageNet. Si tus objetos difieren visualmente de las imágenes comunes de ImageNet, esta combinación de características podría no ser la más adecuada. Por lo tanto, tiene sentido comenzar a entrenar también las capas convolucionales.\n",
|
||||
"En la sección anterior, hemos entrenado la capa final del clasificador para clasificar imágenes en nuestro propio conjunto de datos. Sin embargo, no volvimos a entrenar el extractor de características, y nuestro modelo dependió de las características que el modelo aprendió con los datos de ImageNet. Si tus objetos difieren visualmente de las imágenes comunes de ImageNet, esta combinación de características podría no ser la mejor. Por lo tanto, tiene sentido comenzar a entrenar también las capas convolucionales.\n",
|
||||
"\n",
|
||||
"Para hacerlo, podemos desbloquear los parámetros de los filtros convolucionales que previamente habíamos bloqueado.\n",
|
||||
"Para hacerlo, podemos descongelar los parámetros de los filtros convolucionales que previamente hemos congelado.\n",
|
||||
"\n",
|
||||
"> **Nota:** Es importante que primero bloquees los parámetros y realices varias épocas de entrenamiento para estabilizar los pesos en la capa de clasificación. Si comienzas inmediatamente a entrenar la red de extremo a extremo con los parámetros desbloqueados, es probable que los grandes errores destruyan los pesos preentrenados en las capas convolucionales.\n",
|
||||
"> **Nota:** Es importante que primero congeles los parámetros y realices varias épocas de entrenamiento para estabilizar los pesos en la capa de clasificación. Si comienzas inmediatamente a entrenar la red completa con parámetros descongelados, es probable que los grandes errores destruyan los pesos preentrenados en las capas convolucionales.\n",
|
||||
"\n",
|
||||
"Nuestro modelo convolucional VGG-16 se encuentra dentro de la primera capa y, a su vez, está compuesto por muchas capas. Podemos echar un vistazo a su estructura:\n"
|
||||
"Nuestro modelo convolucional VGG-16 está ubicado dentro de la primera capa, y consiste en muchas capas en sí mismo. Podemos echar un vistazo a su estructura:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -944,7 +955,9 @@
|
|||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
"source": [
|
||||
"Podemos descongelar todas las capas de la base convolucional:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
|
|
@ -959,7 +972,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Sin embargo, descongelar todos a la vez no es la mejor idea. Primero podemos descongelar solo unas pocas capas finales de convoluciones, porque contienen patrones de nivel superior que son relevantes para nuestras imágenes. Por ejemplo, para empezar, podemos congelar todas las capas excepto las últimas 4:\n"
|
||||
"Sin embargo, descongelar todas ellas a la vez no es la mejor idea. Podemos primero descongelar solo algunas de las últimas capas de convoluciones, porque contienen patrones de nivel superior que son relevantes para nuestras imágenes. Por ejemplo, para comenzar, podemos congelar todas las capas excepto las últimas 4: \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -998,11 +1011,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Observa que el número de parámetros entrenables aumentó significativamente, pero aún representa alrededor del 50% de todos los parámetros.\n",
|
||||
"Observe que el número de parámetros entrenables aumentó significativamente, pero todavía es alrededor del 50% de todos los parámetros.\n",
|
||||
"\n",
|
||||
"Después de descongelar, podemos realizar unas pocas épocas más de entrenamiento (en nuestro ejemplo, haremos solo una). También puedes seleccionar una tasa de aprendizaje más baja para minimizar el impacto en los pesos preentrenados. Sin embargo, incluso con una tasa de aprendizaje baja, es normal que la precisión disminuya al inicio del entrenamiento, hasta finalmente alcanzar un nivel ligeramente superior al caso de pesos fijos.\n",
|
||||
"Después de descongelar, podemos hacer unas pocas épocas más de entrenamiento (en nuestro ejemplo, haremos solo una). También puede seleccionar una tasa de aprendizaje menor, para minimizar el impacto en los pesos preentrenados. Sin embargo, incluso con una tasa de aprendizaje baja, puede esperar que la precisión caiga al principio del entrenamiento, hasta finalmente alcanzar un nivel ligeramente más alto que en el caso de pesos fijos.\n",
|
||||
"\n",
|
||||
"> **Nota:** ¡Este entrenamiento es mucho más lento porque necesitamos propagar los gradientes a través de muchas capas de la red!\n"
|
||||
"> **Nota:** Este entrenamiento ocurre mucho más lento, ¡porque necesitamos propagar los gradientes hacia atrás a través de muchas capas de la red!\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1026,9 +1039,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Es probable que logremos una mayor precisión en el entrenamiento, ya que estamos utilizando una red más potente con más parámetros, pero la precisión en la validación no aumentará tanto.\n",
|
||||
"Es probable que logremos una mayor precisión en el entrenamiento, porque estamos utilizando una red más potente con más parámetros, pero la precisión en la validación no aumentaría tanto.\n",
|
||||
"\n",
|
||||
"¡Siéntete libre de desbloquear algunas capas más de la red y entrenar un poco más para ver si puedes alcanzar una mayor precisión!\n"
|
||||
"Siéntete libre de descongelar algunas capas más de la red y entrenar más, para ver si puedes lograr una mayor precisión.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1037,7 +1050,7 @@
|
|||
"source": [
|
||||
"## Otros modelos de visión por computadora\n",
|
||||
"\n",
|
||||
"VGG-16 es una de las arquitecturas más simples de visión por computadora. Keras ofrece muchas más redes preentrenadas. Las más utilizadas entre ellas son las arquitecturas **ResNet**, desarrolladas por Microsoft, y **Inception** de Google. Por ejemplo, exploremos la arquitectura del modelo más simple, ResNet-50 (ResNet es una familia de modelos con diferentes profundidades; puedes intentar experimentar con ResNet-152 si quieres ver cómo se ve un modelo realmente profundo):\n"
|
||||
"VGG-16 es una de las arquitecturas de visión por computadora más simples. Keras ofrece muchas más redes preentrenadas. Las más usadas entre ellas son las arquitecturas **ResNet**, desarrolladas por Microsoft, y **Inception** de Google. Por ejemplo, exploremos la arquitectura del modelo ResNet-50 más simple (ResNet es una familia de modelos con diferente profundidad, puedes experimentar con ResNet-152 si quieres ver cómo es un modelo realmente profundo):\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1439,11 +1452,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Como puedes ver, el modelo contiene los mismos bloques básicos familiares: capas convolucionales, capas de agrupamiento (pooling) y un clasificador denso final. Podemos usar este modelo de la misma manera en que hemos estado utilizando VGG-16 para aprendizaje por transferencia. Puedes intentar experimentar con el código anterior, utilizando diferentes modelos ResNet como modelo base, y observar cómo cambia la precisión.\n",
|
||||
"Como puedes ver, el modelo contiene los mismos bloques constructivos familiares: capas convolucionales, capas de agrupación y el clasificador denso final. Podemos usar este modelo de la misma manera exacta en que hemos estado usando VGG-16 para aprendizaje por transferencia. Puedes experimentar con el código anterior, usando diferentes modelos ResNet como modelo base, y ver cómo cambia la precisión.\n",
|
||||
"\n",
|
||||
"## Normalización por Lotes\n",
|
||||
"\n",
|
||||
"Esta red contiene otro tipo de capa: **Normalización por Lotes**. La idea de la normalización por lotes es ajustar los valores que fluyen a través de la red neuronal al intervalo correcto. Generalmente, las redes neuronales funcionan mejor cuando todos los valores están en el rango de [-1,1] o [0,1], y por eso escalamos/normalizamos nuestros datos de entrada en consecuencia. Sin embargo, durante el entrenamiento de una red profunda, puede suceder que los valores se desvíen significativamente de este rango, lo que dificulta el entrenamiento. La capa de normalización por lotes calcula el promedio y la desviación estándar de todos los valores del minibatch actual, y los utiliza para normalizar la señal antes de pasarla a través de una capa de la red neuronal. Esto mejora significativamente la estabilidad de las redes profundas.\n"
|
||||
"Esta red contiene otro tipo de capa más: **Normalización por Lotes (Batch Normalization)**. La idea de la normalización por lotes es llevar los valores que fluyen a través de la red neuronal al intervalo correcto. Usualmente las redes neuronales funcionan mejor cuando todos los valores están en el rango de [-1,1] o [0,1], y esa es la razón por la que escalamos/normalizamos nuestros datos de entrada en consecuencia. Sin embargo, durante el entrenamiento de una red profunda, puede suceder que los valores se desvíen significativamente de este rango, lo cual hace que el entrenamiento sea problemático. La capa de normalización por lotes calcula el promedio y la desviación estándar para todos los valores del minibatch actual, y los usa para normalizar la señal antes de pasarla a través de una capa de la red neuronal. Esto mejora significativamente la estabilidad de las redes profundas.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1452,16 +1465,16 @@
|
|||
"source": [
|
||||
"## Conclusión\n",
|
||||
"\n",
|
||||
"Utilizando aprendizaje por transferencia, pudimos armar rápidamente un clasificador para nuestra tarea de clasificación de objetos personalizados y lograr una alta precisión. Sin embargo, este ejemplo no fue completamente justo, ya que la red original VGG-16 fue preentrenada para reconocer gatos y perros, por lo que simplemente reutilizamos la mayoría de los patrones que ya estaban presentes en la red. Puedes esperar una menor precisión en objetos más exóticos y específicos de un dominio, como detalles en una línea de producción en una planta o diferentes tipos de hojas de árboles.\n",
|
||||
"Usando transferencia de aprendizaje, pudimos armar rápidamente un clasificador para nuestra tarea personalizada de clasificación de objetos y lograr una alta precisión. Sin embargo, este ejemplo no fue completamente justo, porque la red VGG-16 original fue preentrenada para reconocer gatos y perros, y por lo tanto solo estábamos reutilizando la mayoría de los patrones que ya estaban presentes en la red. Puedes esperar una precisión menor en objetos más exóticos y específicos del dominio, como detalles en la línea de producción en una planta, o diferentes hojas de árboles.\n",
|
||||
"\n",
|
||||
"Puedes observar que las tareas más complejas que estamos resolviendo ahora requieren mayor poder computacional y no pueden resolverse fácilmente en la CPU. En la próxima unidad, intentaremos usar una implementación más ligera para entrenar el mismo modelo utilizando menos recursos computacionales, lo que resulta en una precisión solo ligeramente menor.\n"
|
||||
"Puedes ver que las tareas más complejas que estamos resolviendo ahora requieren mayor potencia computacional, y no pueden ser resueltas fácilmente en la CPU. En la siguiente unidad, intentaremos usar una implementación más ligera para entrenar el mismo modelo usando recursos computacionales menores, lo que resulta en una precisión solo ligeramente inferior.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**Descargo de responsabilidad**: \nEste documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por garantizar la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.\n"
|
||||
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Descargo de responsabilidad**:\nEste documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
@ -1482,12 +1495,6 @@
|
|||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.10"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "c189abc107848f96051085cc30945129",
|
||||
"translation_date": "2025-08-31T15:59:27+00:00",
|
||||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
|
||||
"language_code": "es"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
|
|
|
|||
|
|
@ -1,34 +1,34 @@
|
|||
# Procesamiento de Lenguaje Natural
|
||||
|
||||
|
||||
|
||||
|
||||
En esta sección, nos enfocaremos en usar Redes Neuronales para manejar tareas relacionadas con el **Procesamiento de Lenguaje Natural (PLN)**. Hay muchos problemas de PLN que queremos que las computadoras puedan resolver:
|
||||
En esta sección, nos centraremos en usar Redes Neuronales para manejar tareas relacionadas con el **Procesamiento de Lenguaje Natural (PLN)**. Hay muchos problemas de PLN que queremos que las computadoras puedan resolver:
|
||||
|
||||
* **Clasificación de texto** es un problema típico de clasificación relacionado con secuencias de texto. Ejemplos incluyen clasificar mensajes de correo electrónico como spam o no spam, o categorizar artículos como deporte, negocios, política, etc. Además, al desarrollar chatbots, a menudo necesitamos entender lo que un usuario quiso decir; en este caso estamos tratando con **clasificación de intención**. Frecuentemente, en la clasificación de intención necesitamos manejar muchas categorías.
|
||||
* **Análisis de sentimientos** es un problema típico de regresión, donde necesitamos atribuir un número (un sentimiento) que corresponda a cuán positivo/negativo es el significado de una oración. Una versión más avanzada del análisis de sentimientos es el **análisis de sentimientos basado en aspectos** (ABSA), donde atribuimos el sentimiento no a toda la oración, sino a diferentes partes de ella (aspectos), por ejemplo: *En este restaurante, me gustó la cocina, pero la atmósfera era horrible*.
|
||||
* **Reconocimiento de entidades nombradas** (NER) se refiere al problema de extraer ciertas entidades del texto. Por ejemplo, podríamos necesitar entender que en la frase *Necesito volar a París mañana*, la palabra *mañana* se refiere a una FECHA, y *París* es una UBICACIÓN.
|
||||
* **Extracción de palabras clave** es similar a NER, pero necesitamos extraer palabras importantes para el significado de la oración automáticamente, sin preentrenamiento para tipos específicos de entidades.
|
||||
* **Agrupación de texto** puede ser útil cuando queremos agrupar oraciones similares, por ejemplo, solicitudes similares en conversaciones de soporte técnico.
|
||||
* **Respuesta a preguntas** se refiere a la capacidad de un modelo para responder una pregunta específica. El modelo recibe un pasaje de texto y una pregunta como entradas, y necesita proporcionar un lugar en el texto donde se encuentre la respuesta a la pregunta (o, a veces, generar el texto de la respuesta).
|
||||
* **Generación de texto** es la capacidad de un modelo para generar texto nuevo. Puede considerarse como una tarea de clasificación que predice la siguiente letra/palabra basada en algún *texto inicial*. Modelos avanzados de generación de texto, como GPT-3, son capaces de resolver otras tareas de PLN utilizando una técnica llamada [programación con prompts](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) o [ingeniería de prompts](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29).
|
||||
* **Resumen de texto** es una técnica en la que queremos que una computadora "lea" un texto largo y lo resuma en unas pocas oraciones.
|
||||
* **Traducción automática** puede verse como una combinación de comprensión de texto en un idioma y generación de texto en otro.
|
||||
* **Clasificación de texto** es un problema típico de clasificación relacionado con secuencias de texto. Ejemplos incluyen clasificar mensajes de correo electrónico como spam vs. no spam, o categorizar artículos como deportes, negocios, política, etc. Además, al desarrollar bots de conversación, a menudo necesitamos entender lo que un usuario quiso decir — en este caso estamos tratando con **clasificación de intención**. A menudo, en la clasificación de intención necesitamos manejar muchas categorías.
|
||||
* **Análisis de sentimiento** es un problema típico de regresión, donde necesitamos atribuir un número (un sentimiento) que corresponde a qué tan positivo/negativo es el significado de una frase. Una versión más avanzada del análisis de sentimiento es el **análisis de sentimiento basado en aspectos** (ABSA), donde atribuimos sentimiento no a toda la frase, sino a diferentes partes de ella (aspectos), por ejemplo, *En este restaurante, me gustó la cocina, pero la atmósfera fue terrible*.
|
||||
* **Reconocimiento de Entidades Nombradas** (REN) se refiere al problema de extraer ciertas entidades del texto. Por ejemplo, podríamos necesitar entender que en la frase *Necesito volar a París mañana* la palabra *mañana* se refiere a FECHA, y *París* es una UBICACIÓN.
|
||||
* **Extracción de palabras clave** es similar al REN, pero necesitamos extraer automáticamente palabras importantes para el significado de la frase, sin preentrenamiento para tipos específicos de entidades.
|
||||
* **Agrupamiento de texto** puede ser útil cuando queremos agrupar frases similares, por ejemplo, solicitudes semejantes en conversaciones de soporte técnico.
|
||||
* **Respuesta a preguntas** se refiere a la capacidad de un modelo para responder a una pregunta específica. El modelo recibe un pasaje de texto y una pregunta como entradas, y debe proporcionar un lugar en el texto donde se contiene la respuesta a la pregunta (o, a veces, generar el texto de la respuesta).
|
||||
* **Generación de texto** es la capacidad de un modelo para generar texto nuevo. Puede considerarse como una tarea de clasificación que predice la siguiente letra/palabra basada en un *mensaje de texto*. Modelos avanzados de generación de texto, como GPT-3, son capaces de resolver otras tareas de PLN como clasificación usando una técnica llamada [programación de mensajes](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) o [ingeniería de mensajes](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29)
|
||||
* **Resumen de texto** es una técnica cuando queremos que una computadora "lea" un texto largo y lo resuma en pocas oraciones.
|
||||
* **Traducción automática** puede verse como una combinación de comprensión de texto en un idioma, y generación de texto en otro.
|
||||
|
||||
Inicialmente, la mayoría de las tareas de PLN se resolvían utilizando métodos tradicionales como gramáticas. Por ejemplo, en la traducción automática se utilizaban analizadores para transformar la oración inicial en un árbol sintáctico, luego se extraían estructuras semánticas de nivel superior para representar el significado de la oración, y con base en este significado y la gramática del idioma de destino se generaba el resultado. Hoy en día, muchas tareas de PLN se resuelven de manera más efectiva utilizando redes neuronales.
|
||||
Inicialmente, la mayoría de tareas de PLN se resolvieron usando métodos tradicionales como gramáticas. Por ejemplo, en la traducción automática se usaban analizadores sintácticos para transformar la frase inicial en un árbol sintáctico, luego se extraían estructuras semánticas de nivel superior para representar el significado de la frase, y basándose en este significado y la gramática del idioma objetivo se generaba el resultado. Hoy en día, muchas tareas de PLN se resuelven de manera más efectiva usando redes neuronales.
|
||||
|
||||
> Muchos métodos clásicos de PLN están implementados en la biblioteca de Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Hay un excelente [Libro de NLTK](https://www.nltk.org/book/) disponible en línea que cubre cómo resolver diferentes tareas de PLN utilizando NLTK.
|
||||
> Muchos métodos clásicos de PLN están implementados en la biblioteca Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Hay un excelente [libro NLTK](https://www.nltk.org/book/) disponible en línea que cubre cómo diferentes tareas de PLN pueden ser resueltas usando NLTK.
|
||||
|
||||
En nuestro curso, nos enfocaremos principalmente en usar Redes Neuronales para PLN, y utilizaremos NLTK cuando sea necesario.
|
||||
En nuestro curso, nos centraremos principalmente en el uso de Redes Neuronales para PLN, y usaremos NLTK cuando sea necesario.
|
||||
|
||||
Ya hemos aprendido sobre el uso de redes neuronales para manejar datos tabulares y con imágenes. La principal diferencia entre esos tipos de datos y el texto es que el texto es una secuencia de longitud variable, mientras que el tamaño de entrada en el caso de las imágenes se conoce de antemano. Aunque las redes convolucionales pueden extraer patrones de los datos de entrada, los patrones en el texto son más complejos. Por ejemplo, podemos tener una negación separada del sujeto por muchas palabras arbitrarias (por ejemplo: *No me gustan las naranjas*, vs. *No me gustan esas naranjas grandes, coloridas y sabrosas*), y eso aún debe interpretarse como un solo patrón. Por lo tanto, para manejar el lenguaje necesitamos introducir nuevos tipos de redes neuronales, como *redes recurrentes* y *transformadores*.
|
||||
Ya hemos aprendido sobre el uso de redes neuronales para manejar datos tabulares y con imágenes. La principal diferencia entre esos tipos de datos y el texto es que el texto es una secuencia de longitud variable, mientras que el tamaño de entrada en el caso de imágenes se conoce de antemano. Mientras que las redes convolucionales pueden extraer patrones de los datos de entrada, los patrones en texto son más complejos. Por ejemplo, podemos tener una negación separada del sujeto por muchas palabras arbitrarias (por ejemplo, *No me gustan las naranjas*, vs. *No me gustan esas grandes, coloridas y sabrosas naranjas*), y eso aún debería interpretarse como un patrón. Por lo tanto, para manejar el lenguaje necesitamos introducir nuevos tipos de redes neuronales, tales como *redes recurrentes* y *transformers*.
|
||||
|
||||
## Instalar Bibliotecas
|
||||
## Instalar Librerías
|
||||
|
||||
Si estás utilizando una instalación local de Python para ejecutar este curso, es posible que necesites instalar todas las bibliotecas requeridas para PLN utilizando los siguientes comandos:
|
||||
Si usas una instalación local de Python para ejecutar este curso, es posible que necesites instalar todas las librerías necesarias para PLN usando los siguientes comandos:
|
||||
|
||||
**Para PyTorch**
|
||||
```bash
|
||||
pip install -r requirements-torch.txt
|
||||
pip install -r requirements-pytorch.txt
|
||||
```
|
||||
**Para TensorFlow**
|
||||
```bash
|
||||
|
|
@ -41,11 +41,11 @@ pip install -r requirements-tf.txt
|
|||
|
||||
En esta sección, en algunos de los ejemplos entrenaremos modelos bastante grandes.
|
||||
* **Usa una computadora con GPU**: Es recomendable ejecutar tus notebooks en una computadora con GPU para reducir los tiempos de espera al trabajar con modelos grandes.
|
||||
* **Restricciones de memoria de GPU**: Ejecutar en una GPU puede llevar a situaciones en las que te quedes sin memoria de GPU, especialmente al entrenar modelos grandes.
|
||||
* **Consumo de memoria de GPU**: La cantidad de memoria de GPU consumida durante el entrenamiento depende de varios factores, incluido el tamaño del minibatch.
|
||||
* **Minimiza el tamaño del minibatch**: Si encuentras problemas de memoria de GPU, considera reducir el tamaño del minibatch en tu código como una posible solución.
|
||||
* **Liberación de memoria de GPU en TensorFlow**: Las versiones antiguas de TensorFlow pueden no liberar correctamente la memoria de GPU al entrenar múltiples modelos dentro de un mismo kernel de Python. Para gestionar el uso de memoria de GPU de manera efectiva, puedes configurar TensorFlow para que asigne memoria de GPU solo según sea necesario.
|
||||
* **Inclusión de código**: Para configurar TensorFlow para que crezca la asignación de memoria de GPU solo cuando sea necesario, incluye el siguiente código en tus notebooks:
|
||||
* **Restricciones de memoria GPU**: Ejecutar con GPU puede llevar a situaciones donde se agote la memoria de la GPU, especialmente al entrenar modelos grandes.
|
||||
* **Consumo de memoria GPU**: La cantidad de memoria GPU consumida durante el entrenamiento depende de varios factores, incluyendo el tamaño del minibatch.
|
||||
* **Minimiza el tamaño del minibatch**: Si tienes problemas de memoria GPU, considera reducir el tamaño del minibatch en tu código como posible solución.
|
||||
* **Liberación de memoria GPU en TensorFlow**: Las versiones antiguas de TensorFlow pueden no liberar correctamente la memoria de GPU al entrenar múltiples modelos dentro de un mismo kernel de Python. Para manejar bien el uso de memoria de GPU, puedes configurar TensorFlow para que asigne memoria GPU solo cuando sea necesario.
|
||||
* **Inclusión de código**: Para configurar TensorFlow para que aumente la asignación de memoria GPU solo cuando se requiera, incluye el siguiente código en tus 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)
|
||||
```
|
||||
|
||||
Si estás interesado en aprender sobre PLN desde una perspectiva de ML clásico, visita [esta serie de lecciones](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
|
||||
Si te interesa aprender sobre PLN desde una perspectiva clásica de ML, visita [este conjunto de lecciones](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
|
||||
|
||||
## En esta sección
|
||||
## En esta Sección
|
||||
En esta sección aprenderemos sobre:
|
||||
|
||||
* [Representar texto como tensores](13-TextRep/README.md)
|
||||
* [Embeddings de palabras](14-Emdeddings/README.md)
|
||||
* [Representaciones de palabras (Word Embeddings)](14-Emdeddings/README.md)
|
||||
* [Modelado de lenguaje](15-LanguageModeling/README.md)
|
||||
* [Redes Neuronales Recurrentes](16-RNN/README.md)
|
||||
* [Redes Generativas](17-GenerativeNetworks/README.md)
|
||||
* [Transformadores](18-Transformers/README.md)
|
||||
* [Redes neuronales recurrentes](16-RNN/README.md)
|
||||
* [Redes generativas](17-GenerativeNetworks/README.md)
|
||||
* [Transformers](18-Transformers/README.md)
|
||||
|
||||
**Descargo de responsabilidad**:
|
||||
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Descargo de responsabilidad**:
|
||||
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -5,6 +5,12 @@
|
|||
"source_file": "AGENTS.md",
|
||||
"language_code": "fr"
|
||||
},
|
||||
"CONTRIBUTING.md": {
|
||||
"original_hash": "c6fd7e781b67111a90abd166d0ce4aa0",
|
||||
"translation_date": "2026-07-08T20:19:13+00:00",
|
||||
"source_file": "CONTRIBUTING.md",
|
||||
"language_code": "fr"
|
||||
},
|
||||
"README.md": {
|
||||
"original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b",
|
||||
"translation_date": "2026-04-06T15:30:45+00:00",
|
||||
|
|
@ -17,6 +23,19 @@
|
|||
"source_file": "SECURITY.md",
|
||||
"language_code": "fr"
|
||||
},
|
||||
"__translation_failures__": {
|
||||
"lessons/sketchnotes/LICENSE.md": {
|
||||
"original_hash": "45ab63a2cd8f5faef6c9b150618837a4",
|
||||
"source_file": "lessons/sketchnotes/LICENSE.md",
|
||||
"language_code": "fr",
|
||||
"failure_date": "2026-07-08T20:08:23+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-24T21:00:13+00:00",
|
||||
|
|
@ -54,8 +73,8 @@
|
|||
"language_code": "fr"
|
||||
},
|
||||
"examples/README.md": {
|
||||
"original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7",
|
||||
"translation_date": "2025-10-03T11:26:04+00:00",
|
||||
"original_hash": "7883d52c2e2a221e0b07a7b112a149b9",
|
||||
"translation_date": "2026-07-08T20:03:32+00:00",
|
||||
"source_file": "examples/README.md",
|
||||
"language_code": "fr"
|
||||
},
|
||||
|
|
@ -66,8 +85,8 @@
|
|||
"language_code": "fr"
|
||||
},
|
||||
"lessons/0-course-setup/how-to-run.md": {
|
||||
"original_hash": "a4717bd9103b9f6cd84d534b83534689",
|
||||
"translation_date": "2026-01-15T10:42:15+00:00",
|
||||
"original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1",
|
||||
"translation_date": "2026-07-08T20:03:53+00:00",
|
||||
"source_file": "lessons/0-course-setup/how-to-run.md",
|
||||
"language_code": "fr"
|
||||
},
|
||||
|
|
@ -191,6 +210,12 @@
|
|||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
|
||||
"language_code": "fr"
|
||||
},
|
||||
"lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": {
|
||||
"original_hash": "99b816b6a4957ef4100cee4c4221dff9",
|
||||
"translation_date": "2026-07-08T19:59:46+00:00",
|
||||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
|
||||
"language_code": "fr"
|
||||
},
|
||||
"lessons/4-ComputerVision/08-TransferLearning/lab/README.md": {
|
||||
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
|
||||
"translation_date": "2025-08-24T20:53:21+00:00",
|
||||
|
|
@ -330,8 +355,8 @@
|
|||
"language_code": "fr"
|
||||
},
|
||||
"lessons/5-NLP/README.md": {
|
||||
"original_hash": "8ef02a9318257ea140ed3ed74442096d",
|
||||
"translation_date": "2025-08-24T20:45:19+00:00",
|
||||
"original_hash": "038df6f1a73e49f6430740da083bfd6d",
|
||||
"translation_date": "2026-07-08T20:04:45+00:00",
|
||||
"source_file": "lessons/5-NLP/README.md",
|
||||
"language_code": "fr"
|
||||
},
|
||||
|
|
|
|||
|
|
@ -0,0 +1,29 @@
|
|||
# Contribution à AI-For-Beginners
|
||||
|
||||
Merci de votre intérêt pour contribuer à AI-For-Beginners ! Nous accueillons les traductions, les corrections de leçons et les corrections de mise en forme.
|
||||
|
||||
## Accord de Licence Contributeur (CLA) Microsoft
|
||||
|
||||
Ce projet accueille les contributions et suggestions. La plupart des contributions nécessitent que vous acceptiez un Accord de Licence Contributeur (CLA) déclarant que vous avez le droit, et que vous accordez effectivement, les droits de nous permettre d’utiliser votre contribution. Pour plus de détails, consultez [https://cla.microsoft.com](https://cla.microsoft.com).
|
||||
|
||||
Lorsque vous soumettez une pull request, un bot CLA déterminera automatiquement si vous devez fournir un CLA et annotera la PR en conséquence (par exemple, étiquette, commentaire). Il vous suffit de suivre les instructions fournies par le bot. Vous n’aurez à le faire qu’une seule fois pour tous les dépôts utilisant notre CLA.
|
||||
|
||||
## Comment Contribuer
|
||||
|
||||
### 1. Correction de fautes de frappe / erreurs de code
|
||||
Si vous trouvez une faute de frappe ou un bug dans un notebook Jupyter ou un fichier markdown de leçon :
|
||||
1. Forkez le dépôt.
|
||||
2. Corrigez la faute ou le lien cassé.
|
||||
3. Soumettez une Pull Request avec une description claire de la correction.
|
||||
|
||||
### 2. Soumission de traductions
|
||||
Nous accueillons les traductions des leçons dans d’autres langues ! Veuillez placer les traductions sous le répertoire `translations/` en utilisant les noms des dossiers existants (par exemple `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`).
|
||||
|
||||
Pour plus de détails, consultez [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md).
|
||||
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Avertissement** :
|
||||
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -1,38 +1,38 @@
|
|||
# Exemples d'IA pour Débutants
|
||||
# Exemples d'IA adaptés aux débutants
|
||||
|
||||
Bienvenue ! Ce répertoire contient des exemples simples et autonomes pour vous aider à démarrer avec l'IA et l'apprentissage automatique. Chaque exemple est conçu pour être accessible aux débutants, avec des commentaires détaillés et des explications étape par étape.
|
||||
Bienvenue ! Ce répertoire contient des exemples simples et autonomes pour vous aider à démarrer avec l'IA et l'apprentissage automatique. Chaque exemple est conçu pour être accessible aux débutants avec des commentaires détaillés et des explications étape par étape.
|
||||
|
||||
## 📚 Aperçu des Exemples
|
||||
## 📚 Aperçu des exemples
|
||||
|
||||
| Exemple | Description | Niveau de difficulté | Prérequis |
|
||||
|---------|-------------|----------------------|-----------|
|
||||
| [Hello AI World](../../../examples/01-hello-ai-world.py) | Votre premier programme d'IA - reconnaissance de motifs simple | ⭐ Débutant | Bases de Python |
|
||||
| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Construisez un réseau de neurones à partir de zéro | ⭐⭐ Débutant+ | Python, mathématiques de base |
|
||||
| [Image Classifier](./03-image-classifier.ipynb) | Classifiez des images avec un modèle pré-entraîné | ⭐⭐ Débutant+ | Python, numpy |
|
||||
| [Text Sentiment](../../../examples/04-text-sentiment.py) | Analysez le sentiment d'un texte (positif/négatif) | ⭐⭐ Débutant+ | Python |
|
||||
| Exemple | Description | Difficulté | Prérequis |
|
||||
|---------|-------------|------------|---------------|
|
||||
| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Votre premier programme d'IA - reconnaissance de motifs simple | ⭐ Débutant | Bases de Python |
|
||||
| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Construisez un réseau de neurones à partir de zéro | ⭐⭐ Débutant+ | Python, mathématiques de base |
|
||||
| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Classifiez des images avec un modèle pré-entraîné | ⭐⭐ Débutant+ | Python, numpy |
|
||||
| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analysez le sentiment d'un texte (positif/négatif) | ⭐⭐ Débutant+ | Python |
|
||||
|
||||
## 🚀 Premiers Pas
|
||||
## 🚀 Pour commencer
|
||||
|
||||
### Prérequis
|
||||
|
||||
Assurez-vous d'avoir Python installé (version 3.8 ou supérieure recommandée). Installez les packages nécessaires :
|
||||
Assurez-vous d'avoir Python installé (3.8 ou plus recommandé). Installez les packages nécessaires :
|
||||
|
||||
```bash
|
||||
# For Python scripts
|
||||
# Pour les scripts Python
|
||||
pip install numpy
|
||||
|
||||
# For Jupyter notebooks (image classifier)
|
||||
# Pour les notebooks Jupyter (classificateur d’images)
|
||||
pip install jupyter numpy pillow tensorflow
|
||||
```
|
||||
|
||||
Ou utilisez l'environnement conda du programme principal :
|
||||
Ou utilisez l'environnement conda du cursus principal :
|
||||
|
||||
```bash
|
||||
conda env create --name ai4beg --file ../environment.yml
|
||||
conda activate ai4beg
|
||||
```
|
||||
|
||||
### Exécution des Exemples
|
||||
### Exécution des exemples
|
||||
|
||||
**Pour les scripts Python (.py) :**
|
||||
```bash
|
||||
|
|
@ -44,42 +44,44 @@ python 01-hello-ai-world.py
|
|||
jupyter notebook 03-image-classifier.ipynb
|
||||
```
|
||||
|
||||
## 📖 Parcours d'Apprentissage
|
||||
## 📖 Parcours d'apprentissage
|
||||
|
||||
Nous recommandons de suivre les exemples dans cet ordre :
|
||||
Nous recommandons de suivre les exemples dans l'ordre :
|
||||
|
||||
1. **Commencez par "Hello AI World"** - Apprenez les bases de la reconnaissance de motifs
|
||||
2. **Construisez un Réseau de Neurones Simple** - Comprenez le fonctionnement des réseaux de neurones
|
||||
3. **Essayez le Classificateur d'Images** - Découvrez l'IA en action avec des images réelles
|
||||
4. **Analysez le Sentiment d'un Texte** - Explorez le traitement du langage naturel
|
||||
2. **Construisez un réseau de neurones simple** - Comprenez le fonctionnement des réseaux de neurones
|
||||
3. **Essayez le classificateur d'images** - Découvrez l'IA en action avec des images réelles
|
||||
4. **Analysez le sentiment du texte** - Explorez le traitement du langage naturel
|
||||
|
||||
## 💡 Conseils pour Débutants
|
||||
## 💡 Conseils pour les débutants
|
||||
|
||||
- **Lisez attentivement les commentaires dans le code** - Ils expliquent chaque ligne
|
||||
- **Expérimentez !** - Essayez de modifier les valeurs et observez les résultats
|
||||
- **Ne vous inquiétez pas si vous ne comprenez pas tout** - L'apprentissage prend du temps
|
||||
- **Lisez attentivement les commentaires dans le code** - Ils expliquent ce que fait chaque ligne
|
||||
- **Expérimentez !** - Essayez de modifier les valeurs et voyez ce qui se passe
|
||||
- **Ne vous inquiétez pas de tout comprendre** - L'apprentissage prend du temps
|
||||
- **Posez des questions** - Utilisez le [forum de discussion](https://github.com/microsoft/AI-For-Beginners/discussions)
|
||||
|
||||
## 🔗 Prochaines Étapes
|
||||
## 🔗 Prochaines étapes
|
||||
|
||||
Après avoir terminé ces exemples, explorez le programme complet :
|
||||
Après avoir terminé ces exemples, explorez le cursus complet :
|
||||
- [Introduction à l'IA](../lessons/1-Intro/README.md)
|
||||
- [Réseaux de Neurones](../lessons/3-NeuralNetworks/README.md)
|
||||
- [Vision par Ordinateur](../lessons/4-ComputerVision/README.md)
|
||||
- [Traitement du Langage Naturel](../lessons/5-NLP/README.md)
|
||||
- [Réseaux de neurones](../lessons/3-NeuralNetworks/README.md)
|
||||
- [Vision par ordinateur](../lessons/4-ComputerVision/README.md)
|
||||
- [Traitement du langage naturel](../lessons/5-NLP/README.md)
|
||||
|
||||
## 🤝 Contribuer
|
||||
## 🤝 Contribution
|
||||
|
||||
Vous avez trouvé ces exemples utiles ? Aidez-nous à les améliorer :
|
||||
- Signalez des problèmes ou proposez des améliorations
|
||||
- Ajoutez d'autres exemples pour débutants
|
||||
Ces exemples vous ont été utiles ? Aidez-nous à les améliorer :
|
||||
- Signalez les problèmes ou suggérez des améliorations
|
||||
- Ajoutez plus d'exemples pour débutants
|
||||
- Améliorez la documentation et les commentaires
|
||||
|
||||
---
|
||||
|
||||
*Rappelez-vous : Chaque expert a été un débutant un jour. Bon apprentissage ! 🎓*
|
||||
*N'oubliez pas : Tout expert a un jour été débutant. Bon apprentissage ! 🎓*
|
||||
|
||||
---
|
||||
|
||||
**Avertissement** :
|
||||
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Avertissement** :
|
||||
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -1,10 +1,10 @@
|
|||
# Comment exécuter le code
|
||||
|
||||
Ce programme contient beaucoup d’exemples exécutables et de travaux pratiques que vous voudrez exécuter. Pour ce faire, vous avez besoin de pouvoir exécuter du code Python dans les notebooks Jupyter fournis dans le cadre de ce programme. Vous disposez de plusieurs options pour exécuter le code :
|
||||
Ce programme contient de nombreux exemples exécutables et laboratoires que vous voudrez exécuter. Pour ce faire, vous devez pouvoir exécuter du code Python dans les notebooks Jupyter fournis dans le cadre de ce programme. Plusieurs options s'offrent à vous pour exécuter le code :
|
||||
|
||||
## Exécuter localement sur votre ordinateur
|
||||
|
||||
Pour exécuter le code localement sur votre ordinateur, une installation de Python est nécessaire. Une recommandation est d’installer **[miniconda](https://conda.io/en/latest/miniconda.html)** – c’est une installation plutôt légère qui supporte le gestionnaire de paquets `conda` pour différents **environnements virtuels** Python.
|
||||
Pour exécuter le code localement sur votre ordinateur, une installation de Python est nécessaire. Une recommandation est d’installer **[miniconda](https://conda.io/en/latest/miniconda.html)** - il s'agit d'une installation assez légère qui supporte le gestionnaire de paquets `conda` pour différents **environnements virtuels** Python.
|
||||
|
||||
Après avoir installé miniconda, clonez le dépôt et créez un environnement virtuel à utiliser pour ce cours :
|
||||
|
||||
|
|
@ -15,19 +15,19 @@ conda env create --name ai4beg --file .devcontainer/environment.yml
|
|||
conda activate ai4beg
|
||||
```
|
||||
|
||||
### Utilisation de Visual Studio Code avec l'extension Python
|
||||
### Utilisation de Visual Studio Code avec l’extension Python
|
||||
|
||||
Ce programme est mieux utilisé en l’ouvrant dans [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) avec l’[extension Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste).
|
||||
Ce programme s’utilise le mieux en l’ouvrant dans [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) avec l’[extension Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste).
|
||||
|
||||
> **Note** : Une fois que vous avez cloné et ouvert le répertoire dans VS Code, il vous suggérera automatiquement d’installer les extensions Python. Vous devrez également installer miniconda comme décrit ci-dessus.
|
||||
> **Note** : Une fois que vous avez cloné et ouvert le dossier dans VS Code, il vous proposera automatiquement d’installer les extensions Python. Vous devrez aussi installer miniconda comme décrit ci-dessus.
|
||||
|
||||
> **Note** : Si VS Code vous suggère de rouvrir le dépôt dans un conteneur, vous devriez refuser cela pour utiliser l’installation Python locale.
|
||||
> **Note** : Si VS Code vous suggère de rouvrir le dépôt dans un conteneur, vous devriez refuser ceci pour utiliser l’installation Python locale.
|
||||
|
||||
### Utilisation de Jupyter dans le navigateur
|
||||
|
||||
Vous pouvez aussi utiliser un environnement Jupyter depuis le navigateur sur votre propre ordinateur. À la fois Jupyter classique et JupyterHub fournissent un environnement de développement pratique avec autocomplétion, coloration syntaxique, etc.
|
||||
Vous pouvez aussi utiliser un environnement Jupyter depuis le navigateur sur votre propre ordinateur. Tant Jupyter classique que JupyterHub offrent un environnement de développement pratique avec auto-complétion, coloration syntaxique, etc.
|
||||
|
||||
Pour démarrer Jupyter localement, allez dans le répertoire du cours et exécutez :
|
||||
Pour démarrer Jupyter localement, allez dans le dossier du cours, et exécutez :
|
||||
|
||||
```bash
|
||||
jupyter notebook
|
||||
|
|
@ -36,36 +36,36 @@ ou
|
|||
```bash
|
||||
jupyterhub
|
||||
```
|
||||
Vous pouvez alors naviguer vers n’importe lequel des fichiers `.ipynb`, les ouvrir et commencer à travailler.
|
||||
Vous pouvez alors naviguer vers n’importe quel fichier `.ipynb`, l’ouvrir et commencer à travailler.
|
||||
|
||||
### Exécution dans un conteneur
|
||||
### Exécuter dans un conteneur
|
||||
|
||||
Une alternative à l’installation de Python serait d’exécuter le code dans un conteneur. Puisque notre dépôt fournit un dossier spécial `.devcontainer` qui indique comment construire un conteneur pour ce dépôt, VS Code offre la possibilité de rouvrir le code dans un conteneur. Cela nécessitera l’installation de Docker, et serait aussi plus complexe, c’est pourquoi nous recommandons cela aux utilisateurs plus expérimentés.
|
||||
Une alternative à l’installation de Python serait d’exécuter le code dans un conteneur. Étant donné que notre dépôt fournit un dossier spécial `.devcontainer` qui explique comment construire un conteneur pour ce repo, VS Code offre la possibilité de rouvrir le code dans un conteneur. Cela nécessite l’installation de Docker, et est aussi plus complexe, donc nous recommandons cette option aux utilisateurs plus expérimentés.
|
||||
|
||||
## Exécution dans le cloud
|
||||
## Exécuter dans le cloud
|
||||
|
||||
Si vous ne souhaitez pas installer Python localement et avez accès à des ressources cloud, une bonne alternative serait d’exécuter le code dans le cloud. Plusieurs options s’offrent à vous :
|
||||
Si vous ne souhaitez pas installer Python localement, et disposez d’accès à des ressources cloud, une bonne alternative serait d’exécuter le code dans le cloud. Plusieurs méthodes sont possibles :
|
||||
|
||||
* Utilisation de **[GitHub Codespaces](https://github.com/features/codespaces)**, qui est un environnement virtuel créé pour vous sur GitHub, accessible via une interface VS Code dans le navigateur. Si vous avez accès à Codespaces, vous pouvez simplement cliquer sur le bouton **Code** dans le dépôt, démarrer un codespace et vous lancer en un rien de temps.
|
||||
* Utilisation de **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) offre des ressources informatiques gratuites fournies dans le cloud pour permettre à des personnes comme vous de tester du code sur GitHub. Il y a un bouton sur la page d’accueil pour ouvrir le dépôt dans Binder – cela devrait rapidement vous amener sur le site de Binder, qui construira un conteneur sous-jacent et lancera une interface web Jupyter pour vous de manière transparente.
|
||||
* Utiliser **[GitHub Codespaces](https://github.com/features/codespaces)**, qui est un environnement virtuel créé pour vous sur GitHub, accessible via une interface navigateur de VS Code. Si vous avez accès à Codespaces, vous pouvez simplement cliquer sur le bouton **Code** dans le dépôt, démarrer un codespace, et commencer très rapidement.
|
||||
* Utiliser **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) offre des ressources informatiques gratuites fournies dans le cloud pour permettre à des personnes comme vous d’essayer du code sur GitHub. Il y a un bouton sur la page d’accueil pour ouvrir le dépôt dans Binder - cela vous amènera rapidement au site Binder, qui construira un conteneur sous-jacent et lancera une interface web Jupyter pour vous de façon transparente.
|
||||
|
||||
> **Note** : Pour éviter les abus, Binder a bloqué l’accès à certaines ressources web. Cela peut empêcher certains codes de fonctionner, notamment ceux qui téléchargent des modèles et/ou jeux de données depuis Internet public. Vous devrez peut-être trouver des solutions de contournement. En outre, les ressources de calcul fournies par Binder sont assez basiques, donc l’entraînement sera lent, surtout dans les leçons plus avancées et complexes.
|
||||
> **Note** : Pour prévenir les abus, Binder bloque l’accès à certaines ressources web. Ceci peut empêcher une partie du code de fonctionner, notamment lorsque le code va chercher des modèles et/ou des jeux de données sur Internet. Vous pourriez devoir trouver des solutions alternatives. De plus, les ressources de calcul fournies par Binder sont assez basiques, donc l’entraînement sera lent, surtout dans les leçons plus avancées et complexes.
|
||||
|
||||
## Exécution dans le cloud avec GPU
|
||||
## Exécuter dans le cloud avec GPU
|
||||
|
||||
Certaines leçons avancées de ce programme bénéficieraient grandement du support GPU. L’entraînement de modèles, par exemple, peut être très lent autrement. Vous pouvez suivre quelques options, surtout si vous avez accès au cloud via [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) ou via votre institution :
|
||||
Certaines des leçons avancées de ce programme bénéficieraient grandement du support GPU. Par exemple, l’entraînement des modèles peut être très lent autrement. Vous avez plusieurs options, en particulier si vous avez accès au cloud via [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), ou via votre institution :
|
||||
|
||||
* Créez une [Machine virtuelle Data Science](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) et connectez-vous à celle-ci via Jupyter. Vous pourrez alors cloner le dépôt directement sur la machine et commencer à apprendre. Les machines virtuelles série NC offrent un support GPU.
|
||||
* Créer une [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) et s’y connecter via Jupyter. Vous pouvez alors cloner le dépôt directement sur la machine, et commencer à apprendre. Les machines virtuelles de la série NC ont un support GPU.
|
||||
|
||||
> **Note** : Certains abonnements, y compris Azure for Students, ne fournissent pas nativement de support GPU. Vous devrez peut-être demander des cœurs GPU supplémentaires via une demande de support technique.
|
||||
> **Note** : Certaines souscriptions, y compris Azure for Students, ne fournissent pas de support GPU nativement. Vous pourriez devoir demander des cœurs GPU supplémentaires via une demande de support technique.
|
||||
|
||||
* Créez un [Espace de travail Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) puis utilisez la fonctionnalité Notebook. [Cette vidéo](https://azure-for-academics.github.io/quickstart/azureml-papers/) montre comment cloner un dépôt dans un notebook Azure ML et commencer à l’utiliser.
|
||||
* Créer un [Espace de travail Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) puis utiliser la fonctionnalité Notebook là-bas. [Cette vidéo](https://azure-for-academics.github.io/quickstart/azureml-papers/) montre comment cloner un dépôt dans un notebook Azure ML et commencer à l’utiliser.
|
||||
|
||||
Vous pouvez aussi utiliser Google Colab, qui offre un support GPU gratuit, et y téléverser vos notebooks Jupyter pour les exécuter un par un.
|
||||
Vous pouvez aussi utiliser Google Colab, qui offre un support GPU gratuit limité, et y uploader les notebooks Jupyter pour les exécuter un à un.
|
||||
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Clause de non-responsabilité** :
|
||||
Ce document a été traduit à l’aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source officielle. Pour les informations critiques, une traduction professionnelle réalisée par un humain est recommandée. Nous ne pouvons être tenus responsables des malentendus ou des erreurs d’interprétation résultant de l’utilisation de cette traduction.
|
||||
**Avertissement** :
|
||||
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
|
|
@ -6,9 +6,9 @@
|
|||
"source": [
|
||||
"# Modèles pré-entraînés et apprentissage par transfert\n",
|
||||
"\n",
|
||||
"L'entraînement des CNNs peut prendre beaucoup de temps, et une grande quantité de données est nécessaire pour cette tâche. Cependant, une grande partie du temps est consacrée à apprendre les meilleurs filtres de bas niveau qu'un réseau utilise pour extraire des motifs à partir d'images. Une question naturelle se pose : peut-on utiliser un réseau neuronal entraîné sur un ensemble de données et l'adapter à la classification d'images différentes sans passer par un processus d'entraînement complet ?\n",
|
||||
"L'entraînement des CNN peut prendre beaucoup de temps, et une grande quantité de données est nécessaire pour cette tâche. Cependant, la majeure partie du temps est consacrée à l'apprentissage des meilleurs filtres de bas niveau qu'un réseau utilise pour extraire des motifs à partir d'images. Une question naturelle se pose : peut-on utiliser un réseau de neurones entraîné sur un jeu de données et l'adapter pour classer différentes images sans passer par un entraînement complet ?\n",
|
||||
"\n",
|
||||
"Cette approche est appelée **apprentissage par transfert**, car nous transférons une partie des connaissances d'un modèle de réseau neuronal à un autre. Dans l'apprentissage par transfert, nous commençons généralement par un modèle pré-entraîné, qui a été entraîné sur un grand ensemble de données d'images, tel que **ImageNet**. Ces modèles sont déjà capables d'extraire efficacement différentes caractéristiques à partir d'images génériques, et dans de nombreux cas, construire simplement un classificateur au-dessus de ces caractéristiques extraites peut donner de bons résultats.\n"
|
||||
"Cette approche s'appelle **l'apprentissage par transfert**, car nous transférons une partie des connaissances d'un modèle de réseau de neurones à un autre. Dans l'apprentissage par transfert, nous commençons généralement avec un modèle pré-entraîné, qui a été entraîné sur un grand jeu de données d'images, comme **ImageNet**. Ces modèles savent déjà bien extraire différentes caractéristiques d'images génériques, et dans de nombreux cas, il suffit de construire un classificateur par-dessus ces caractéristiques extraites pour obtenir un bon résultat.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -29,9 +29,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Jeu de données Chats vs Chiens\n",
|
||||
"## Jeu de données Chats vs. Chiens\n",
|
||||
"\n",
|
||||
"Dans cette unité, nous allons résoudre un problème réel de classification d'images de chats et de chiens. Pour cela, nous utiliserons le [jeu de données Chats vs Chiens de Kaggle](https://www.kaggle.com/c/dogs-vs-cats), qui peut également être téléchargé [depuis Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
|
||||
"Dans cette unité, nous allons résoudre un problème réel de classification d'images de chats et de chiens. Pour cette raison, nous utiliserons le [jeu de données Chats vs. Chiens de Kaggle](https://www.kaggle.com/c/dogs-vs-cats), qui peut également être téléchargé [depuis Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
|
||||
"\n",
|
||||
"Téléchargeons ce jeu de données et extrayons-le dans le répertoire `data` (ce processus peut prendre un certain temps !) :\n"
|
||||
]
|
||||
|
|
@ -64,7 +64,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Malheureusement, il y a des fichiers image corrompus dans le jeu de données. Nous devons effectuer un nettoyage rapide pour vérifier les fichiers corrompus. Afin de ne pas encombrer ce tutoriel, nous avons déplacé le code de vérification du jeu de données dans un module.\n"
|
||||
"Malheureusement, il y a des fichiers image corrompus dans le jeu de données. Nous devons faire un nettoyage rapide pour vérifier les fichiers corrompus. Afin de ne pas encombrer ce tutoriel, nous avons déplacé le code de vérification du jeu de données dans un module.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -335,11 +335,11 @@
|
|||
"source": [
|
||||
"## Chargement du jeu de données\n",
|
||||
"\n",
|
||||
"Dans les exemples précédents, nous chargions des jeux de données intégrés à Keras. Maintenant, nous allons travailler avec notre propre jeu de données, que nous devons charger à partir d'un répertoire d'images.\n",
|
||||
"Dans les exemples précédents, nous chargions des jeux de données intégrés à Keras. Maintenant, nous allons traiter notre propre jeu de données, que nous devons charger à partir d'un répertoire d'images.\n",
|
||||
"\n",
|
||||
"Dans la réalité, la taille des jeux de données d'images peut être assez importante, et il est impossible de compter sur le fait que toutes les données puissent tenir en mémoire. Ainsi, les jeux de données sont souvent représentés sous forme de **générateurs** capables de fournir des données en mini-lots adaptés à l'entraînement.\n",
|
||||
"Dans la vie réelle, la taille des jeux de données d’images peut être assez grande, et on ne peut pas compter sur le fait que toutes les données tiennent en mémoire. Ainsi, les jeux de données sont souvent représentés sous forme de **générateurs** qui peuvent retourner les données en petits lots adaptés à l'entraînement.\n",
|
||||
"\n",
|
||||
"Pour gérer la classification d'images, Keras inclut une fonction spéciale `image_dataset_from_directory`, qui peut charger des images à partir de sous-répertoires correspondant à différentes classes. Cette fonction prend également en charge le redimensionnement des images et peut diviser le jeu de données en ensembles d'entraînement et de test :\n"
|
||||
"Pour gérer la classification d’images, Keras inclut une fonction spéciale `image_dataset_from_directory`, qui peut charger les images à partir de sous-répertoires correspondant à différentes classes. Cette fonction s’occupe également de la mise à l’échelle des images, et peut aussi diviser le jeu de données en sous-ensembles d’entraînement et de test :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -383,9 +383,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Il est important de définir la même valeur de `seed` pour les deux appels, car cela influence la répartition des images entre les ensembles d'entraînement et de test.\n",
|
||||
"Il est important de définir la même valeur de `seed` pour les deux appels, car elle affecte la répartition des images entre les ensembles d'entraînement et de test.\n",
|
||||
"\n",
|
||||
"Le dataset récupère automatiquement les noms des classes à partir des répertoires, et vous pouvez y accéder si nécessaire en appelant :\n"
|
||||
"Dataset récupère automatiquement les noms des classes à partir des répertoires, et vous pouvez y accéder si nécessaire en appelant :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -412,7 +412,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Les ensembles de données que nous avons obtenus peuvent être directement passés à la fonction `fit` pour entraîner le modèle. Ils contiennent à la fois des images correspondantes et des étiquettes, qui peuvent être parcourues à l'aide de la construction suivante :\n"
|
||||
"Les ensembles de données que nous avons obtenus peuvent être directement passés à la fonction `fit` pour entraîner le modèle. Ils contiennent à la fois les images correspondantes et les étiquettes, qui peuvent être parcourues à l'aide de la construction suivante :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -453,7 +453,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **Remarque** : Toutes les images du jeu de données sont représentées sous forme de tenseurs à virgule flottante avec une plage de 0 à 255. Avant de les passer au réseau de neurones, nous devons ramener ces valeurs dans une plage de 0 à 1. Lors de l'affichage des images, nous devons soit faire de même, soit convertir les valeurs en type `int` (ce que nous faisons dans le code ci-dessus), afin de montrer à `matplotlib` que nous souhaitons afficher l'image originale non mise à l'échelle.\n"
|
||||
"> **Note** : Toutes les images dans le jeu de données sont représentées sous forme de tenseurs à virgule flottante avec une plage de 0 à 255. Avant de les transmettre au réseau neuronal, nous devons mettre ces valeurs à l’échelle dans la plage 0-1. Lors du tracé des images, nous devons soit faire de même, soit convertir les valeurs en type `int` (ce que nous faisons dans le code ci-dessus), afin de montrer à `matplotlib` que nous voulons tracer l’image originale non mise à l’échelle.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -462,7 +462,7 @@
|
|||
"source": [
|
||||
"## Modèles pré-entraînés\n",
|
||||
"\n",
|
||||
"Pour de nombreuses tâches de classification d'images, il est possible de trouver des modèles de réseaux neuronaux pré-entraînés. Beaucoup de ces modèles sont disponibles dans l'espace de noms `keras.applications`, et encore plus de modèles peuvent être trouvés sur Internet. Voyons comment le modèle VGG-16 le plus simple peut être chargé et utilisé :\n"
|
||||
"Pour de nombreuses tâches de classification d'images, on peut trouver des modèles de réseaux neuronaux pré-entraînés. Beaucoup de ces modèles sont disponibles dans l'espace de noms `keras.applications`, et encore plus de modèles peuvent être trouvés sur Internet. Voyons comment charger et utiliser le modèle VGG-16 le plus simple :\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,16 +521,16 @@
|
|||
"metadata": {},
|
||||
"source": [
|
||||
"Il y a quelques points importants ici :\n",
|
||||
"* Avant de passer une entrée à un réseau pré-entraîné, elle doit être prétraitée d'une certaine manière. Cela se fait en appelant la fonction correspondante `preprocess_input`, qui reçoit un lot d'images et renvoie leur forme traitée. Dans le cas de VGG-16, les images sont normalisées, et une valeur moyenne prédéfinie pour chaque canal est soustraite. Cela est dû au fait que VGG-16 a été initialement entraîné avec ce prétraitement.\n",
|
||||
"* Le réseau de neurones est appliqué au lot d'entrée, et nous recevons en résultat un lot de tenseurs à 1000 éléments qui indiquent la probabilité de chaque classe. Nous pouvons trouver le numéro de la classe la plus probable en appelant `argmax` sur ce tenseur.\n",
|
||||
"* Le résultat obtenu est un [numéro d'une classe `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Pour donner du sens à ce résultat, nous pouvons également utiliser la fonction `decode_predictions`, qui renvoie les n classes principales avec leurs noms.\n"
|
||||
"* Avant de passer une entrée à un réseau pré-entraîné, elle doit être pré-traitée d'une certaine manière. Cela se fait en appelant la fonction `preprocess_input` correspondante, qui reçoit un lot d'images et renvoie leur forme traitée. Dans le cas de VGG-16, les images sont normalisées, et une certaine valeur moyenne prédéfinie pour chaque canal est soustraite. Cela s'explique par le fait que VGG-16 a été initialement entraîné avec ce pré-traitement.\n",
|
||||
"* Le réseau de neurones est appliqué au lot d'entrée, et nous recevons en résultat un lot de tenseurs à 1000 éléments qui montrent la probabilité de chaque classe. Nous pouvons trouver le numéro de la classe la plus probable en appelant `argmax` sur ce tenseur.\n",
|
||||
"* Le résultat obtenu est un [numéro d'une classe `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Pour donner un sens à ce résultat, nous pouvons également utiliser la fonction `decode_predictions`, qui retourne les n meilleures classes accompagnées de leurs noms.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Voyons également l'architecture du réseau VGG-16 :\n"
|
||||
"Voyons également l'architecture du réseau VGG-16 :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -597,9 +607,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Calculs sur GPU\n",
|
||||
"## Calculs GPU\n",
|
||||
"\n",
|
||||
"Les réseaux neuronaux profonds, comme le VGG-16 et d'autres architectures plus modernes, nécessitent une puissance de calcul considérable pour fonctionner. Il est donc logique d'utiliser l'accélération GPU, si elle est disponible. Heureusement, Keras accélère automatiquement les calculs sur le GPU lorsqu'il est disponible. Nous pouvons vérifier si Tensorflow est capable d'utiliser le GPU avec le code suivant :\n"
|
||||
"Les réseaux neuronaux profonds, tels que VGG-16 et d'autres architectures plus modernes, nécessitent beaucoup de puissance de calcul pour fonctionner. Il est donc judicieux d'utiliser l'accélération GPU, si elle est disponible. Heureusement, Keras accélère automatiquement les calculs sur le GPU si celui-ci est disponible. Nous pouvons vérifier si Tensorflow est capable d'utiliser le GPU avec le code suivant :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -626,9 +636,10 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Extraction des caractéristiques de VGG\n",
|
||||
"\n",
|
||||
"Si nous souhaitons utiliser VGG-16 pour extraire des caractéristiques de nos images, nous avons besoin du modèle sans les couches finales de classification. Nous pouvons instancier le modèle VGG-16 sans les couches supérieures en utilisant ce code :\n"
|
||||
"## Extraction des caractéristiques VGG\n",
|
||||
"\n",
|
||||
"Si nous voulons utiliser VGG-16 pour extraire des caractéristiques de nos images, nous avons besoin du modèle sans les couches finales de classification. Nous pouvons instancier le modèle VGG-16 sans les couches supérieures en utilisant ce code : \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -680,9 +691,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"La dimension du tenseur de caractéristiques est de 7x7x512, mais pour le visualiser, nous avons dû le remodeler en une forme 2D.\n",
|
||||
"La dimension du tenseur de caractéristiques est de 7x7x512, mais pour pouvoir le visualiser, nous avons dû le remodeler en forme 2D.\n",
|
||||
"\n",
|
||||
"Voyons maintenant si ces caractéristiques peuvent être utilisées pour classer des images. Prenons manuellement une portion d'images (50 mini-lots, dans notre cas) et pré-calculons leurs vecteurs de caractéristiques. Nous pouvons utiliser l'API **dataset** de Tensorflow pour cela. La fonction `map` prend un dataset et applique une lambda-fonction donnée pour le transformer. Nous utilisons ce mécanisme pour construire de nouveaux datasets, `ds_features_train` et `ds_features_test`, qui contiennent les caractéristiques extraites par VGG au lieu des images originales.\n"
|
||||
"Maintenant, essayons de voir si ces caractéristiques peuvent être utilisées pour classer des images. Prenons manuellement une partie des images (50 mini-lots, dans notre cas) et pré-calculons leurs vecteurs de caractéristiques. Nous pouvons utiliser l'API **dataset** de Tensorflow pour cela. La fonction `map` prend un dataset et applique une fonction lambda donnée pour le transformer. Nous utilisons ce mécanisme pour construire de nouveaux datasets, `ds_features_train` et `ds_features_test`, qui contiennent des caractéristiques extraites par VGG au lieu des images originales.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -712,9 +723,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Nous avons utilisé la construction `.take(50)` pour limiter la taille du jeu de données, afin d'accélérer notre démonstration. Vous pouvez bien sûr effectuer cette expérience sur l'ensemble du jeu de données.\n",
|
||||
"Nous avons utilisé la construction `.take(50)` pour limiter la taille du jeu de données, afin d'accélérer notre démonstration. Vous pouvez bien sûr réaliser cette expérience sur l'ensemble du jeu de données.\n",
|
||||
"\n",
|
||||
"Maintenant que nous avons un jeu de données avec des caractéristiques extraites, nous pouvons entraîner un simple classificateur dense pour distinguer entre les chats et les chiens. Ce réseau prendra un vecteur de caractéristiques de forme (7,7,512) et produira une sortie correspondant soit à un chien, soit à un chat. Étant donné qu'il s'agit d'une classification binaire, nous utilisons la fonction d'activation `sigmoid` et la perte `binary_crossentropy`.\n"
|
||||
"Maintenant que nous avons un jeu de données avec des caractéristiques extraites, nous pouvons entraîner un classificateur dense simple pour distinguer les chats des chiens. Ce réseau prendra un vecteur de caractéristiques de forme (7,7,512), et produira une sortie correspondant soit à un chien, soit à un chat. Puisqu'il s'agit d'une classification binaire, nous utilisons la fonction d'activation `sigmoid` et la perte `binary_crossentropy`.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -743,13 +754,13 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Le résultat est excellent, nous pouvons distinguer un chat d'un chien avec une probabilité de presque 95 % ! Cependant, nous n'avons testé cette approche que sur un sous-ensemble de toutes les images, car l'extraction manuelle des caractéristiques semble prendre beaucoup de temps.\n",
|
||||
"Le résultat est excellent, nous pouvons distinguer entre un chat et un chien avec presque 95 % de probabilité ! Cependant, nous n'avons testé cette approche que sur un sous-ensemble de toutes les images, car l'extraction manuelle des caractéristiques semble prendre beaucoup de temps.\n",
|
||||
"\n",
|
||||
"## Apprentissage par transfert avec un réseau VGG\n",
|
||||
"## Apprentissage par transfert en utilisant un réseau VGG\n",
|
||||
"\n",
|
||||
"Nous pouvons également éviter de pré-calculer manuellement les caractéristiques en utilisant le réseau VGG-16 original dans son intégralité pendant l'entraînement, en ajoutant un extracteur de caractéristiques à notre réseau comme première couche.\n",
|
||||
"Nous pouvons également éviter de pré-calculer manuellement les caractéristiques en utilisant le réseau VGG-16 original dans son ensemble pendant l'entraînement, en ajoutant l'extracteur de caractéristiques à notre réseau comme première couche.\n",
|
||||
"\n",
|
||||
"La beauté de l'architecture Keras réside dans le fait que le modèle VGG-16 que nous avons défini ci-dessus peut également être utilisé comme une couche dans un autre réseau neuronal ! Il suffit de construire un réseau avec un classificateur dense au-dessus, puis d'entraîner l'ensemble du réseau en utilisant la rétropropagation.\n"
|
||||
"La beauté de l'architecture Keras est que le modèle VGG-16 que nous avons défini ci-dessus peut aussi être utilisé comme une couche dans un autre réseau neuronal ! Il nous suffit de construire un réseau avec un classificateur dense au-dessus, puis d'entraîner l'ensemble du réseau en utilisant la rétropropagation.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -793,13 +804,13 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Ce modèle ressemble à un réseau de classification de bout en bout, qui prend une image et retourne la classe correspondante. Cependant, la difficulté réside dans le fait que nous voulons que VGG16 agisse comme un extracteur de caractéristiques, et non qu'il soit réentraîné. Ainsi, nous devons **geler les poids de l'extracteur de caractéristiques convolutionnel**. Nous pouvons accéder à la première couche du réseau en appelant `model.layers[0]`, et il suffit de définir la propriété `trainable` sur `False`.\n",
|
||||
"Ce modèle ressemble à un réseau de classification de bout en bout, qui prend une image et renvoie la classe. Cependant, la difficulté est que nous voulons que VGG16 agisse comme un extracteur de caractéristiques, et ne soit pas réentraîné. Ainsi, nous devons **geler les poids de l'extracteur de caractéristiques convolutionnel**. Nous pouvons accéder à la première couche du réseau en appelant `model.layers[0]`, et nous devons simplement définir la propriété `trainable` sur `False`.\n",
|
||||
"\n",
|
||||
"> **Note** : Le gel des poids de l'extracteur de caractéristiques est nécessaire, car sinon la couche de classification non entraînée pourrait altérer les poids pré-entraînés de l'extracteur convolutionnel.\n",
|
||||
"> **Note** : Le gel des poids de l'extracteur de caractéristiques est nécessaire, car sinon la couche classifiante non entraînée peut détruire les poids pré-entraînés originaux de l'extracteur convolutionnel.\n",
|
||||
"\n",
|
||||
"Vous pouvez remarquer que, bien que le nombre total de paramètres dans notre réseau soit d'environ 15 millions, nous n'entraînons que 25 000 paramètres. Tous les autres paramètres des filtres convolutionnels de haut niveau sont pré-entraînés. C'est une bonne chose, car cela nous permet d'affiner un plus petit nombre de paramètres avec un plus petit nombre d'exemples.\n",
|
||||
"Vous pouvez remarquer que tandis que le nombre total de paramètres dans notre réseau est d'environ 15 millions, nous n'entraînons que 25k paramètres. Tous les autres paramètres des filtres convolutionnels de haut niveau sont pré-entraînés. C'est bien, car nous pouvons affiner un plus petit nombre de paramètres avec un nombre plus réduit d'exemples.\n",
|
||||
"\n",
|
||||
"Nous allons maintenant entraîner notre réseau et voir jusqu'où nous pouvons aller. Attendez-vous à un temps d'exécution assez long, et ne vous inquiétez pas si l'exécution semble figée pendant un certain temps.\n"
|
||||
"Nous allons maintenant entraîner notre réseau et voir à quel point nous pouvons l'améliorer. Attendez-vous à un temps d'exécution assez long, et ne vous inquiétez pas si l'exécution semble figée pendant un certain temps.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -824,11 +835,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Il semble que nous ayons obtenu un classificateur chats contre chiens assez précis !\n",
|
||||
"Il semble que nous ayons obtenu un classificateur chats vs. chiens raisonnablement précis ! \n",
|
||||
"\n",
|
||||
"## Sauvegarder et Charger le Modèle\n",
|
||||
"## Sauvegarde et chargement du modèle\n",
|
||||
"\n",
|
||||
"Une fois que nous avons entraîné le modèle, nous pouvons sauvegarder l'architecture du modèle et les poids entraînés dans un fichier pour une utilisation future :\n"
|
||||
"Une fois que nous avons entraîné le modèle, nous pouvons enregistrer l’architecture du modèle et les poids entraînés dans un fichier pour une utilisation future :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -852,7 +863,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Nous pouvons alors charger le modèle à partir du fichier à tout moment. Vous pourriez le trouver utile au cas où la prochaine expérience détruirait le modèle - vous n'auriez pas à recommencer depuis le début.\n"
|
||||
"Nous pouvons alors charger le modèle à partir du fichier à tout moment. Cela peut vous être utile au cas où la prochaine expérience détruirait le modèle - vous n’auriez pas à repartir de zéro.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -868,15 +879,15 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Ajustement fin de l'apprentissage par transfert\n",
|
||||
"## Affinage par apprentissage par transfert\n",
|
||||
"\n",
|
||||
"Dans la section précédente, nous avons entraîné la couche finale du classificateur pour classer les images de notre propre jeu de données. Cependant, nous n'avons pas réentraîné l'extracteur de caractéristiques, et notre modèle s'est appuyé sur les caractéristiques que le modèle a apprises à partir des données d'ImageNet. Si vos objets diffèrent visuellement des images ordinaires d'ImageNet, cette combinaison de caractéristiques pourrait ne pas être optimale. Il est donc logique de commencer à entraîner également les couches convolutionnelles.\n",
|
||||
"Dans la section précédente, nous avons entraîné la dernière couche de classification pour classer les images de notre propre jeu de données. Cependant, nous n'avons pas réentraîné l'extracteur de caractéristiques, et notre modèle s'est appuyé sur les caractéristiques que le modèle a apprises sur les données ImageNet. Si vos objets diffèrent visuellement des images ordinaires d’ImageNet, cette combinaison de caractéristiques pourrait ne pas être optimale. Il est donc logique de commencer à entraîner également les couches convolutionnelles.\n",
|
||||
"\n",
|
||||
"Pour ce faire, nous pouvons déverrouiller les paramètres des filtres convolutionnels que nous avions précédemment gelés.\n",
|
||||
"Pour cela, nous pouvons déverrouiller les paramètres des filtres convolutionnels que nous avions précédemment gelés.\n",
|
||||
"\n",
|
||||
"> **Note :** Il est important de geler les paramètres dans un premier temps et d'effectuer plusieurs époques d'entraînement afin de stabiliser les poids dans la couche de classification. Si vous commencez immédiatement à entraîner un réseau de bout en bout avec des paramètres dégelés, de grandes erreurs risquent de détruire les poids pré-entraînés dans les couches convolutionnelles.\n",
|
||||
"> **Note :** Il est important de geler les paramètres d'abord et d'effectuer plusieurs époques d'entraînement afin de stabiliser les poids dans la couche de classification. Si vous commencez immédiatement à entraîner le réseau de bout en bout avec des paramètres dégelés, de grandes erreurs risquent de détruire les poids pré-entraînés dans les couches convolutionnelles.\n",
|
||||
"\n",
|
||||
"Notre modèle convolutionnel VGG-16 se trouve dans la première couche, et il est lui-même composé de nombreuses couches. Nous pouvons examiner sa structure :\n"
|
||||
"Notre modèle convolutionnel VGG-16 est situé dans la première couche, et il est lui-même composé de nombreuses couches. Nous pouvons jeter un œil à sa structure : \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -945,7 +956,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Nous pouvons dégeler toutes les couches de la base convolutionnelle :\n"
|
||||
"Nous pouvons débloquer toutes les couches de la base convolutionnelle :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -961,7 +972,7 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Cependant, décongeler tous en même temps n'est pas la meilleure idée. Nous pouvons d'abord décongeler seulement quelques dernières couches de convolutions, car elles contiennent des motifs de niveau supérieur qui sont pertinents pour nos images. Par exemple, pour commencer, nous pouvons congeler toutes les couches sauf les 4 dernières :\n"
|
||||
"Cependant, décongeler tous ces calques d'un coup n'est pas la meilleure idée. Nous pouvons d'abord décongeler seulement quelques couches finales de convolutions, car elles contiennent des motifs de niveau supérieur qui sont pertinents pour nos images. Par exemple, pour commencer, nous pouvons congeler toutes les couches sauf les 4 dernières : \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1000,11 +1011,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"On observe que le nombre de paramètres entraînables a considérablement augmenté, mais il reste encore autour de 50 % de tous les paramètres.\n",
|
||||
"Observez que le nombre de paramètres entraînables a augmenté de manière significative, mais il reste encore autour de 50 % de tous les paramètres.\n",
|
||||
"\n",
|
||||
"Après avoir dégelé les couches, nous pouvons effectuer quelques époques supplémentaires d'entraînement (dans notre exemple, nous n'en ferons qu'une seule). Vous pouvez également choisir un taux d'apprentissage plus faible afin de minimiser l'impact sur les poids pré-entraînés. Cependant, même avec un taux d'apprentissage faible, il est normal de constater une baisse de précision au début de l'entraînement, avant d'atteindre finalement un niveau légèrement supérieur à celui obtenu avec des poids fixes.\n",
|
||||
"Après avoir débloqué, nous pouvons faire quelques epochs supplémentaires d'entraînement (dans notre exemple, nous en ferons juste un). Vous pouvez également sélectionner un taux d'apprentissage plus faible, afin de minimiser l'impact sur les poids pré-entraînés. Cependant, même avec un taux d'apprentissage faible, vous pouvez vous attendre à ce que la précision baisse au début de l'entraînement, jusqu'à atteindre enfin un niveau légèrement supérieur à celui du cas des poids fixes.\n",
|
||||
"\n",
|
||||
"> **Note :** Cet entraînement est beaucoup plus lent, car il faut propager les gradients à travers de nombreuses couches du réseau !\n"
|
||||
"> **Note :** Cet entraînement se déroule beaucoup plus lentement, car nous devons propager les gradients vers l'arrière à travers de nombreuses couches du réseau !\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1028,9 +1039,9 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Nous sommes susceptibles d'obtenir une meilleure précision d'entraînement, car nous utilisons un réseau plus puissant avec davantage de paramètres, mais la précision de validation n'augmentera pas autant.\n",
|
||||
"Nous avons de fortes chances d’atteindre une précision d’entraînement plus élevée, car nous utilisons un réseau plus puissant avec plus de paramètres, mais la précision de validation n'augmenterait pas autant.\n",
|
||||
"\n",
|
||||
"N'hésitez pas à débloquer quelques couches supplémentaires du réseau et à entraîner davantage, pour voir si vous pouvez atteindre une meilleure précision !\n"
|
||||
"N’hésitez pas à dégeler quelques couches supplémentaires du réseau et à entraîner davantage, pour voir si vous pouvez obtenir une précision plus élevée !\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1039,7 +1050,7 @@
|
|||
"source": [
|
||||
"## Autres modèles de vision par ordinateur\n",
|
||||
"\n",
|
||||
"VGG-16 est l'une des architectures de vision par ordinateur les plus simples. Keras propose de nombreux autres réseaux pré-entraînés. Parmi les plus utilisés, on trouve les architectures **ResNet**, développées par Microsoft, et **Inception** par Google. Par exemple, explorons l'architecture du modèle ResNet-50 le plus simple (ResNet est une famille de modèles avec différentes profondeurs, vous pouvez essayer de travailler avec ResNet-152 si vous voulez voir à quoi ressemble un modèle vraiment profond) :\n"
|
||||
"VGG-16 est l’une des architectures de vision par ordinateur les plus simples. Keras fournit de nombreux autres réseaux pré-entraînés. Parmi les plus fréquemment utilisés, on trouve les architectures **ResNet**, développées par Microsoft, et **Inception** par Google. Par exemple, explorons l’architecture du modèle ResNet-50 le plus simple (ResNet est une famille de modèles avec différentes profondeurs, vous pouvez essayer d’expérimenter avec ResNet-152 si vous voulez voir à quoi ressemble un modèle vraiment profond) :\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1441,11 +1452,11 @@
|
|||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Comme vous pouvez le voir, le modèle contient les mêmes blocs de construction familiers : des couches de convolution, des couches de pooling et un classificateur dense final. Nous pouvons utiliser ce modèle exactement de la même manière que nous avons utilisé VGG-16 pour l'apprentissage par transfert. Vous pouvez essayer d'expérimenter avec le code ci-dessus, en utilisant différents modèles ResNet comme modèle de base, et observer comment la précision évolue.\n",
|
||||
"Comme vous pouvez le voir, le modèle contient les mêmes blocs de construction familiers : les couches convolutionnelles, les couches de mise en commun et le classificateur dense final. Nous pouvons utiliser ce modèle exactement de la même manière que nous avons utilisé VGG-16 pour l'apprentissage par transfert. Vous pouvez essayer d'expérimenter avec le code ci-dessus, en utilisant différents modèles ResNet comme modèle de base, et voir comment la précision évolue.\n",
|
||||
"\n",
|
||||
"## Normalisation par lot\n",
|
||||
"\n",
|
||||
"Ce réseau contient un autre type de couche : **la normalisation par lot**. L'idée de la normalisation par lot est de ramener les valeurs qui traversent le réseau neuronal dans le bon intervalle. En général, les réseaux neuronaux fonctionnent mieux lorsque toutes les valeurs se situent dans la plage [-1,1] ou [0,1], et c'est pour cette raison que nous mettons à l'échelle/normalisons nos données d'entrée en conséquence. Cependant, pendant l'entraînement d'un réseau profond, il peut arriver que les valeurs sortent significativement de cette plage, ce qui rend l'entraînement problématique. La couche de normalisation par lot calcule la moyenne et l'écart type pour toutes les valeurs du minibatch actuel, et les utilise pour normaliser le signal avant de le faire passer à travers une couche du réseau neuronal. Cela améliore considérablement la stabilité des réseaux profonds.\n"
|
||||
"Ce réseau contient un autre type de couche : la **Normalisation par lot (Batch Normalization)**. L'idée de la normalisation par lot est de ramener les valeurs qui circulent dans le réseau neuronal dans le bon intervalle. Habituellement, les réseaux neuronaux fonctionnent mieux lorsque toutes les valeurs sont dans l'intervalle [-1,1] ou [0,1], et c'est la raison pour laquelle nous mettons à l'échelle/normalisons nos données d'entrée en conséquence. Cependant, pendant l'entraînement d'un réseau profond, il peut arriver que les valeurs sortent significativement de cet intervalle, ce qui rend l'entraînement problématique. La couche de normalisation par lot calcule la moyenne et l'écart type de toutes les valeurs du mini-lot courant, et les utilise pour normaliser le signal avant de le transmettre à travers une couche du réseau neuronal. Cela améliore considérablement la stabilité des réseaux profonds.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1454,16 +1465,16 @@
|
|||
"source": [
|
||||
"## À retenir\n",
|
||||
"\n",
|
||||
"En utilisant l'apprentissage par transfert, nous avons pu rapidement créer un classificateur pour notre tâche de classification d'objets personnalisés et obtenir une grande précision. Cependant, cet exemple n'était pas totalement équitable, car le réseau VGG-16 original avait été pré-entraîné pour reconnaître les chats et les chiens, et nous avons donc simplement réutilisé la plupart des motifs déjà présents dans le réseau. Vous pouvez vous attendre à une précision moindre pour des objets plus spécifiques à des domaines exotiques, comme des détails sur une ligne de production dans une usine ou différentes feuilles d'arbres.\n",
|
||||
"En utilisant l'apprentissage par transfert, nous avons pu rapidement assembler un classifieur pour notre tâche personnalisée de classification d'objets, et atteindre une grande précision. Cependant, cet exemple n'était pas complètement juste, car le réseau VGG-16 original avait été pré-entraîné pour reconnaître des chats et des chiens, et ainsi, nous réutilisions principalement des motifs déjà présents dans le réseau. Vous pouvez vous attendre à une précision moindre pour des objets plus exotiques spécifiques à un domaine, comme des détails sur une ligne de production dans une usine, ou différentes feuilles d'arbres.\n",
|
||||
"\n",
|
||||
"Vous pouvez constater que les tâches plus complexes que nous résolvons maintenant nécessitent une puissance de calcul plus élevée et ne peuvent pas être facilement exécutées sur le CPU. Dans la prochaine unité, nous essayerons d'utiliser une implémentation plus légère pour entraîner le même modèle en utilisant des ressources de calcul réduites, ce qui entraîne une baisse de précision seulement marginale.\n"
|
||||
"Vous pouvez constater que les tâches plus complexes que nous résolvons maintenant nécessitent une puissance de calcul plus élevée, et ne peuvent pas être facilement résolues sur le CPU. Dans l'unité suivante, nous essayerons d'utiliser une mise en œuvre plus légère pour entraîner le même modèle avec des ressources de calcul moindres, ce qui entraîne une précision légèrement inférieure.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**Avertissement** : \nCe document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle effectuée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.\n"
|
||||
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Avertissement** :\nCe document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
@ -1484,12 +1495,6 @@
|
|||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.10"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "c189abc107848f96051085cc30945129",
|
||||
"translation_date": "2025-08-31T14:35:45+00:00",
|
||||
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
|
||||
"language_code": "fr"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
|
|
|
|||
|
|
@ -1,69 +1,73 @@
|
|||
# Traitement du Langage Naturel
|
||||
|
||||
|
||||
|
||||
|
||||
Dans cette section, nous allons nous concentrer sur l'utilisation des réseaux neuronaux pour traiter des tâches liées au **Traitement du Langage Naturel (NLP)**. Il existe de nombreux problèmes NLP que nous souhaitons que les ordinateurs soient capables de résoudre :
|
||||
Dans cette section, nous allons nous concentrer sur l’utilisation des réseaux de neurones pour traiter les tâches liées au **Traitement du Langage Naturel (TLN)**. Il existe de nombreux problèmes du TLN que nous souhaitons que les ordinateurs puissent résoudre :
|
||||
|
||||
* **Classification de texte** : un problème classique de classification appliqué aux séquences de texte. Par exemple, classer des e-mails comme spam ou non-spam, ou catégoriser des articles en sport, économie, politique, etc. De plus, lors du développement de chatbots, il est souvent nécessaire de comprendre ce que l'utilisateur veut dire — dans ce cas, il s'agit de **classification d'intention**. Souvent, dans la classification d'intention, nous devons gérer de nombreuses catégories.
|
||||
* **Analyse de sentiment** : un problème typique de régression, où il faut attribuer un score (un sentiment) correspondant à la positivité/négativité d'une phrase. Une version plus avancée de l'analyse de sentiment est l'**analyse de sentiment basée sur les aspects** (ABSA), où le sentiment est attribué non pas à l'ensemble de la phrase, mais à différentes parties (aspects), par exemple : *Dans ce restaurant, j'ai aimé la cuisine, mais l'ambiance était horrible*.
|
||||
* **Reconnaissance d'entités nommées** (NER) : extraire certaines entités d'un texte. Par exemple, dans la phrase *Je dois prendre un vol pour Paris demain*, le mot *demain* fait référence à une DATE, et *Paris* est une LOCALISATION.
|
||||
* **Extraction de mots-clés** : similaire à la NER, mais ici, il s'agit d'extraire automatiquement les mots importants pour le sens de la phrase, sans pré-entraînement pour des types d'entités spécifiques.
|
||||
* **Regroupement de texte** : utile pour regrouper des phrases similaires, par exemple, des demandes similaires dans des conversations de support technique.
|
||||
* **Questions-réponses** : capacité d'un modèle à répondre à une question spécifique. Le modèle reçoit un passage de texte et une question en entrée, et doit fournir un endroit dans le texte où se trouve la réponse (ou, parfois, générer la réponse textuelle).
|
||||
* **Génération de texte** : capacité d'un modèle à générer du nouveau texte. Cela peut être considéré comme une tâche de classification qui prédit la lettre/mot suivant en fonction d'un *texte d'amorce*. Les modèles avancés de génération de texte, comme GPT-3, peuvent résoudre d'autres tâches NLP telles que la classification en utilisant une technique appelée [programmation par prompt](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) ou [ingénierie de prompt](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29).
|
||||
* **Résumé de texte** : technique permettant à un ordinateur de "lire" un texte long et de le résumer en quelques phrases.
|
||||
* **Traduction automatique** : peut être vue comme une combinaison de compréhension de texte dans une langue et de génération de texte dans une autre.
|
||||
* **Classification de texte** est un problème typique de classification concernant les séquences de texte. Par exemple, classer les messages électroniques comme spam ou non-spam, ou catégoriser les articles en sport, affaires, politique, etc. De plus, lors du développement de chatbots, nous devons souvent comprendre ce que l’utilisateur voulait dire – dans ce cas, nous traitons de la **classification d’intention**. Souvent, pour la classification d’intention, nous devons gérer de nombreuses catégories.
|
||||
* **Analyse de sentiment** est un problème typique de régression, où nous devons attribuer un nombre (un sentiment) correspondant à quel point le sens d’une phrase est positif/négatif. Une version plus avancée de l’analyse de sentiment est l’**analyse de sentiment basée sur les aspects** (ABSA), où nous attribuons le sentiment non pas à toute la phrase, mais à différentes parties de celle-ci (les aspects), par ex. *Dans ce restaurant, j’ai aimé la cuisine, mais l’atmosphère était horrible*.
|
||||
* **Reconnaissance d’entités nommées** (NER) fait référence au problème d’extraire certaines entités du texte. Par exemple, nous devons comprendre que dans la phrase *Je dois prendre l’avion pour Paris demain*, le mot *demain* fait référence à une DATE, et *Paris* est un LIEU.
|
||||
* **Extraction de mots-clés** est similaire à la NER, mais nous devons extraire automatiquement des mots importants pour le sens de la phrase, sans pré-entraînement pour des types d’entités spécifiques.
|
||||
* **Regroupement de textes** peut être utile lorsque nous voulons regrouper des phrases similaires, par exemple, des demandes similaires dans des conversations de support technique.
|
||||
* **Réponse à des questions** fait référence à la capacité d’un modèle à répondre à une question spécifique. Le modèle reçoit en entrée un passage de texte et une question, et doit fournir un endroit dans le texte où la réponse à la question se trouve (ou, parfois, générer le texte de la réponse).
|
||||
* **Génération de texte** est la capacité d’un modèle à générer un nouveau texte. Cela peut être considéré comme une tâche de classification qui prédit la lettre/mot suivant basé sur une *invite de texte*. Les modèles avancés de génération de texte, tels que GPT-3, sont capables de résoudre d’autres tâches du TLN, comme la classification, en utilisant une technique appelée [programmation par invite](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) ou [ingénierie des invites](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29)
|
||||
* **Résumé de texte** est une technique lorsque nous voulons qu’un ordinateur "lise" un long texte et le résume en quelques phrases.
|
||||
* **Traduction automatique** peut être vue comme une combinaison de compréhension de texte dans une langue et de génération de texte dans une autre.
|
||||
|
||||
À l'origine, la plupart des tâches NLP étaient résolues à l'aide de méthodes traditionnelles comme les grammaires. Par exemple, en traduction automatique, des analyseurs syntaxiques étaient utilisés pour transformer une phrase initiale en un arbre syntaxique, puis des structures sémantiques de haut niveau étaient extraites pour représenter le sens de la phrase. À partir de ce sens et de la grammaire de la langue cible, le résultat était généré. Aujourd'hui, de nombreuses tâches NLP sont plus efficacement résolues à l'aide de réseaux neuronaux.
|
||||
Initialement, la plupart des tâches du TLN étaient résolues à l’aide de méthodes traditionnelles telles que les grammaires. Par exemple, en traduction automatique, des analyseurs syntaxiques étaient utilisés pour transformer la phrase initiale en un arbre syntaxique, puis des structures sémantiques de niveau supérieur étaient extraites pour représenter le sens de la phrase, et sur la base de ce sens et de la grammaire de la langue cible, le résultat était généré. Aujourd’hui, de nombreuses tâches de TLN sont plus efficacement résolues à l’aide de réseaux de neurones.
|
||||
|
||||
> De nombreuses méthodes NLP classiques sont implémentées dans la bibliothèque Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Un excellent [livre NLTK](https://www.nltk.org/book/) est disponible en ligne et explique comment résoudre différentes tâches NLP avec NLTK.
|
||||
> De nombreuses méthodes classiques du TLN sont implémentées dans la bibliothèque Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Il existe un excellent [livre NLTK](https://www.nltk.org/book/) disponible en ligne qui couvre comment différentes tâches du TLN peuvent être résolues avec NLTK.
|
||||
|
||||
Dans notre cours, nous nous concentrerons principalement sur l'utilisation des réseaux neuronaux pour le NLP, et nous utiliserons NLTK si nécessaire.
|
||||
Dans notre cours, nous nous concentrerons principalement sur l’utilisation des réseaux de neurones pour le TLN, et nous utiliserons NLTK si nécessaire.
|
||||
|
||||
Nous avons déjà appris à utiliser les réseaux neuronaux pour traiter des données tabulaires et des images. La principale différence entre ces types de données et le texte est que le texte est une séquence de longueur variable, tandis que la taille d'entrée pour les images est connue à l'avance. Bien que les réseaux convolutionnels puissent extraire des motifs des données d'entrée, les motifs dans le texte sont plus complexes. Par exemple, une négation peut être séparée du sujet par de nombreux mots (par exemple : *Je n'aime pas les oranges* vs. *Je n'aime pas ces grandes oranges colorées et savoureuses*), et cela doit toujours être interprété comme un seul motif. Ainsi, pour traiter le langage, nous devons introduire de nouveaux types de réseaux neuronaux, tels que les *réseaux récurrents* et les *transformers*.
|
||||
Nous avons déjà appris à utiliser les réseaux de neurones pour traiter des données tabulaires et des images. La principale différence entre ces types de données et le texte est que le texte est une séquence de longueur variable, tandis que la taille d’entrée dans le cas des images est connue à l’avance. Alors que les réseaux convolutifs peuvent extraire des motifs des données d’entrée, les motifs dans le texte sont plus complexes. Par exemple, une négation peut être séparée du sujet par un nombre arbitraire de mots (par ex. *Je n’aime pas les oranges*, vs. *Je n’aime pas ces grosses oranges colorées et savoureuses*), et cela devrait toujours être interprété comme un seul motif. Ainsi, pour gérer le langage, nous devons introduire de nouveaux types de réseaux de neurones, tels que les *réseaux récurrents* et les *transformers*.
|
||||
|
||||
## Installer les bibliothèques
|
||||
|
||||
Si vous utilisez une installation Python locale pour suivre ce cours, vous devrez peut-être installer toutes les bibliothèques nécessaires pour le NLP en utilisant les commandes suivantes :
|
||||
Si vous utilisez une installation locale de Python pour suivre ce cours, vous devrez peut-être installer toutes les bibliothèques nécessaires pour le TLN en utilisant les commandes suivantes :
|
||||
|
||||
**Pour PyTorch**
|
||||
**Pour PyTorch**
|
||||
```bash
|
||||
pip install -r requirements-torch.txt
|
||||
```
|
||||
**Pour TensorFlow**
|
||||
pip install -r requirements-pytorch.txt
|
||||
```
|
||||
**Pour TensorFlow**
|
||||
```bash
|
||||
pip install -r requirements-tf.txt
|
||||
```
|
||||
```
|
||||
|
||||
> Vous pouvez essayer le NLP avec TensorFlow sur [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste)
|
||||
> Vous pouvez essayer le TLN avec TensorFlow sur [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste)
|
||||
|
||||
## Avertissement sur le GPU
|
||||
## Avertissement GPU
|
||||
|
||||
Dans cette section, certains exemples nécessiteront l'entraînement de modèles assez volumineux.
|
||||
* **Utilisez un ordinateur avec GPU** : Il est conseillé d'exécuter vos notebooks sur un ordinateur équipé d'un GPU pour réduire les temps d'attente lors de l'entraînement de grands modèles.
|
||||
* **Contraintes de mémoire GPU** : L'utilisation d'un GPU peut entraîner des situations où la mémoire GPU est insuffisante, en particulier lors de l'entraînement de grands modèles.
|
||||
* **Consommation de mémoire GPU** : La quantité de mémoire GPU consommée pendant l'entraînement dépend de plusieurs facteurs, notamment la taille des mini-lots.
|
||||
* **Réduisez la taille des mini-lots** : Si vous rencontrez des problèmes de mémoire GPU, envisagez de réduire la taille des mini-lots dans votre code comme solution potentielle.
|
||||
* **Libération de mémoire GPU avec TensorFlow** : Les anciennes versions de TensorFlow peuvent ne pas libérer correctement la mémoire GPU lors de l'entraînement de plusieurs modèles dans un même noyau Python. Pour gérer efficacement l'utilisation de la mémoire GPU, vous pouvez configurer TensorFlow pour allouer la mémoire GPU uniquement en cas de besoin.
|
||||
* **Inclusion de code** : Pour configurer TensorFlow afin qu'il alloue la mémoire GPU uniquement lorsque nécessaire, incluez le code suivant dans vos notebooks :
|
||||
Dans cette section, dans certains exemples, nous entraînerons des modèles assez volumineux.
|
||||
* **Utilisez un ordinateur équipé d’un GPU** : Il est conseillé d’exécuter vos notebooks sur un ordinateur doté d’un GPU pour réduire les temps d’attente lors du travail avec de grands modèles.
|
||||
* **Contraintes de mémoire GPU** : L’exécution sur GPU peut entraîner des situations où la mémoire GPU est insuffisante, notamment lors de l’entraînement de grands modèles.
|
||||
* **Consommation de mémoire GPU** : La quantité de mémoire GPU consommée pendant l’entraînement dépend de plusieurs facteurs, dont la taille du minibatch.
|
||||
* **Réduire la taille du minibatch** : Si vous rencontrez des problèmes de mémoire GPU, envisagez de réduire la taille du minibatch dans votre code comme solution possible.
|
||||
* **Libération de la mémoire GPU dans TensorFlow** : Les versions plus anciennes de TensorFlow ne libèrent pas correctement la mémoire GPU lors de l’entraînement de plusieurs modèles dans un même noyau Python. Pour gérer efficacement l’utilisation de la mémoire GPU, vous pouvez configurer TensorFlow pour qu’il alloue la mémoire GPU uniquement au besoin.
|
||||
* **Inclusion du code** : Pour configurer TensorFlow de façon à ce qu’il augmente l’allocation de mémoire GPU uniquement quand cela est nécessaire, incluez le code suivant dans vos 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)
|
||||
```
|
||||
```
|
||||
|
||||
Si vous souhaitez apprendre le NLP sous l'angle des méthodes classiques de ML, visitez [cette série de leçons](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP).
|
||||
Si vous souhaitez apprendre le TLN d’un point de vue classique du ML, visitez [cette série de leçons](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
|
||||
|
||||
## Dans cette section
|
||||
Dans cette section, nous apprendrons :
|
||||
Dans cette section, nous apprendrons à propos de :
|
||||
|
||||
* [Représenter le texte sous forme de tenseurs](13-TextRep/README.md)
|
||||
* [Word Embeddings](14-Emdeddings/README.md)
|
||||
* [Modélisation de langage](15-LanguageModeling/README.md)
|
||||
* [Réseaux neuronaux récurrents](16-RNN/README.md)
|
||||
* [Réseaux génératifs](17-GenerativeNetworks/README.md)
|
||||
* [Transformers](18-Transformers/README.md)
|
||||
* [Représentation du texte sous forme de tenseurs](13-TextRep/README.md)
|
||||
* [Word Embeddings](14-Emdeddings/README.md)
|
||||
* [Modélisation du langage](15-LanguageModeling/README.md)
|
||||
* [Réseaux de neurones récurrents](16-RNN/README.md)
|
||||
* [Réseaux génératifs](17-GenerativeNetworks/README.md)
|
||||
* [Transformers](18-Transformers/README.md)
|
||||
|
||||
**Avertissement** :
|
||||
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
|
||||
---
|
||||
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
||||
**Avertissement** :
|
||||
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
|
||||
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
|
||||
Loading…
Reference in New Issue