RomanNum3ral
/
AI-For-Beginners
mirror of https://github.com/microsoft/AI-For-Beginners.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #479 from microsoft/update-translations 

🌐 Update translations via Co-op Translator
This commit is contained in:
Lee Stott 2025-08-24 12:37:52 +01:00 committed by GitHub
parent 57df099835 464396d431
commit b3f402ba73
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
378 changed files with 18463 additions and 6023 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
translations/de/README.md
View File

@ -1,140 +1,155 @@
[![GitHub license](https://img.shields.io/github/license/microsoft/AI-For-Beginners.svg)](https://github.com/microsoft/AI-For-Beginners/blob/main/LICENSE)
[![GitHub contributors](https://img.shields.io/github/contributors/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/graphs/contributors/)
[![GitHub issues](https://img.shields.io/github/issues/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/issues/)
[![GitHub pull-requests](https://img.shields.io/github/issues-pr/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/pulls/)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f3a6b0ddf7e6e3f33b2a543baf086dc9",
"translation_date": "2025-08-24T09:27:46+00:00",
"source_file": "README.md",
"language_code": "de"
}
-->
[![GitHub license](https://img.shields.io/github/license/microsoft/AI-For-Beginners.svg)](https://github.com/microsoft/AI-For-Beginners/blob/main/LICENSE)
[![GitHub contributors](https://img.shields.io/github/contributors/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/graphs/contributors/)
[![GitHub issues](https://img.shields.io/github/issues/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/issues/)
[![GitHub pull-requests](https://img.shields.io/github/issues-pr/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/pulls/)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
[![GitHub watchers](https://img.shields.io/github/watchers/microsoft/AI-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/AI-For-Beginners/watchers/)
[![GitHub forks](https://img.shields.io/github/forks/microsoft/AI-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/AI-For-Beginners/network/)
[![GitHub stars](https://img.shields.io/github/stars/microsoft/AI-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/AI-For-Beginners/stargazers/)
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)
[![Gitter](https://badges.gitter.im/Microsoft/ai-for-beginners.svg)](https://gitter.im/Microsoft/ai-for-beginners?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
[![GitHub watchers](https://img.shields.io/github/watchers/microsoft/AI-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/AI-For-Beginners/watchers/)
[![GitHub forks](https://img.shields.io/github/forks/microsoft/AI-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/AI-For-Beginners/network/)
[![GitHub stars](https://img.shields.io/github/stars/microsoft/AI-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/AI-For-Beginners/stargazers/)
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)
[![Gitter](https://badges.gitter.im/Microsoft/ai-for-beginners.svg)](https://gitter.im/Microsoft/ai-for-beginners?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
[![](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://discord.gg/zxKYvhSnVp?WT.mc_id=academic-000002-leestott)
[![](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://discord.gg/zxKYvhSnVp?WT.mc_id=academic-000002-leestott)
# Künstliche Intelligenz für Anfänger - Ein Lehrplan
# Künstliche Intelligenz für Anfänger – Ein Curriculum
|![ Sketchnote von [(@girlie_mac)](https://twitter.com/girlie_mac) ](./lessons/sketchnotes/ai-overview.png)|
|:---:|
| KI für Anfänger - _Sketchnote von [@girlie_mac](https://twitter.com/girlie_mac)_ |
|![ Sketchnote von [(@girlie_mac)](https://twitter.com/girlie_mac) ](./lessons/sketchnotes/ai-overview.png)|
|:---:|
| KI für Anfänger – _Sketchnote von [@girlie_mac](https://twitter.com/girlie_mac)_ |
Entdecken Sie die Welt der **Künstlichen Intelligenz** (KI) mit unserem 12-wöchigen, 24-Lektion umfassenden Lehrplan! Er umfasst praktische Lektionen, Quizze und Labore. Der Lehrplan ist anfängerfreundlich und behandelt Werkzeuge wie TensorFlow und PyTorch sowie ethische Aspekte der KI.
Entdecken Sie die Welt der **Künstlichen Intelligenz** (KI) mit unserem 12-wöchigen Curriculum, das aus 24 Lektionen besteht! Es enthält praktische Lektionen, Quizze und Labore. Das Curriculum ist anfängerfreundlich und behandelt Tools wie TensorFlow und PyTorch sowie ethische Aspekte der KI.
## Was Sie lernen werden
## Was Sie lernen werden
**[Mindmap des Kurses](http://soshnikov.com/courses/ai-for-beginners/mindmap.html)**
**[Mindmap des Kurses](http://soshnikov.com/courses/ai-for-beginners/mindmap.html)**
In diesem Lehrplan werden Sie lernen:
In diesem Curriculum lernen Sie:
* Verschiedene Ansätze zur Künstlichen Intelligenz, einschließlich des "guten alten" symbolischen Ansatzes mit **Wissensrepräsentation** und Schlussfolgerungen ([GOFAI](https://en.wikipedia.org/wiki/Symbolic_artificial_intelligence)).
* **Neuronale Netzwerke** und **Deep Learning**, die im Zentrum der modernen KI stehen. Wir werden die Konzepte hinter diesen wichtigen Themen anhand von Code in zwei der beliebtesten Frameworks - [TensorFlow](http://Tensorflow.org) und [PyTorch](http://pytorch.org) - veranschaulichen.
* **Neuronale Architekturen** für die Arbeit mit Bildern und Texten. Wir werden aktuelle Modelle behandeln, aber möglicherweise nicht die neuesten Entwicklungen.
* Weniger populäre KI-Ansätze, wie **Genetische Algorithmen** und **Multi-Agenten-Systeme**.
* Verschiedene Ansätze der Künstlichen Intelligenz, einschließlich des "klassischen" symbolischen Ansatzes mit **Wissensrepräsentation** und Schlussfolgerung ([GOFAI](https://en.wikipedia.org/wiki/Symbolic_artificial_intelligence)).
* **Neuronale Netze** und **Deep Learning**, die im Zentrum moderner KI stehen. Wir veranschaulichen die Konzepte hinter diesen wichtigen Themen mit Code in zwei der beliebtesten Frameworks – [TensorFlow](http://Tensorflow.org) und [PyTorch](http://pytorch.org).
* **Neuronale Architekturen** für die Arbeit mit Bildern und Text. Wir behandeln aktuelle Modelle, könnten aber bei den neuesten Entwicklungen etwas hinterherhinken.
* Weniger populäre KI-Ansätze wie **Genetische Algorithmen** und **Multi-Agenten-Systeme**.
Was wir in diesem Lehrplan nicht behandeln werden:
Was wir in diesem Curriculum nicht behandeln:
> [Finden Sie alle zusätzlichen Ressourcen für diesen Kurs in unserer Microsoft Learn Sammlung](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)
> [Finden Sie alle zusätzlichen Ressourcen für diesen Kurs in unserer Microsoft Learn-Sammlung](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)
* Geschäftsanwendungen der **KI im Geschäft**. Erwägen Sie, den Lernpfad [Einführung in KI für Geschäftsanwender](https://docs.microsoft.com/learn/paths/introduction-ai-for-business-users/?WT.mc_id=academic-77998-bethanycheum) auf Microsoft Learn zu belegen oder die **AI Business School** ([AI Business School](https://www.microsoft.com/ai/ai-business-school/?WT.mc_id=academic-77998-bethanycheum)), die in Zusammenarbeit mit [INSEAD](https://www.insead.edu/) entwickelt wurde.
* **Klassisches maschinelles Lernen**, das in unserem [Lehrplan für maschinelles Lernen für Anfänger](http://github.com/Microsoft/ML-for-Beginners) gut beschrieben ist.
* Praktische KI-Anwendungen, die mit **[Kognitiven Diensten](https://azure.microsoft.com/services/cognitive-services/?WT.mc_id=academic-77998-bethanycheum)** erstellt wurden. Dafür empfehlen wir, mit den Modulen von Microsoft Learn für [Bildverarbeitung](https://docs.microsoft.com/learn/paths/create-computer-vision-solutions-azure-cognitive-services/?WT.mc_id=academic-77998-bethanycheum), [natürliche Sprachverarbeitung](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-bethanycheum), **[Generative KI mit Azure OpenAI Service](https://learn.microsoft.com/en-us/training/paths/develop-ai-solutions-azure-openai/?WT.mc_id=academic-77998-bethanycheum)** und anderen zu beginnen.
* Spezifische ML **Cloud-Frameworks**, wie [Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-bethanycheum), [Microsoft Fabric](https://learn.microsoft.com/en-us/training/paths/get-started-fabric/?WT.mc_id=academic-77998-bethanycheum) oder [Azure Databricks](https://docs.microsoft.com/learn/paths/data-engineer-azure-databricks?WT.mc_id=academic-77998-bethanycheum). Ziehen Sie in Betracht, die Lernpfade [Build and operate machine learning solutions with Azure Machine Learning](https://docs.microsoft.com/learn/paths/build-ai-solutions-with-azure-ml-service/?WT.mc_id=academic-77998-bethanycheum) und [Build and Operate Machine Learning Solutions with Azure Databricks](https://docs.microsoft.com/learn/paths/build-operate-machine-learning-solutions-azure-databricks/?WT.mc_id=academic-77998-bethanycheum) zu nutzen.
* **Konversationelle KI** und **Chatbots**. Es gibt einen separaten Lernpfad [Create conversational AI solutions](https://docs.microsoft.com/learn/paths/create-conversational-ai-solutions/?WT.mc_id=academic-77998-bethanycheum), und Sie können auch [diesen Blogbeitrag](https://soshnikov.com/azure/hello-bot-conversational-ai-on-microsoft-platform/) für weitere Details konsultieren.
* **Tiefe Mathematik** hinter Deep Learning. Dafür empfehlen wir das Buch [Deep Learning](https://www.amazon.com/Deep-Learning-Adaptive-Computation-Machine/dp/0262035618) von Ian Goodfellow, Yoshua Bengio und Aaron Courville, das auch online unter [https://www.deeplearningbook.org/](https://www.deeplearningbook.org/) verfügbar ist.
* Geschäftsanwendungen von **KI im Business**. Ziehen Sie in Betracht, den Lernpfad [Einführung in KI für Geschäftsanwender](https://docs.microsoft.com/learn/paths/introduction-ai-for-business-users/?WT.mc_id=academic-77998-bethanycheum) auf Microsoft Learn oder die [AI Business School](https://www.microsoft.com/ai/ai-business-school/?WT.mc_id=academic-77998-bethanycheum) zu absolvieren, die in Zusammenarbeit mit [INSEAD](https://www.insead.edu/) entwickelt wurde.
* **Klassisches maschinelles Lernen**, das in unserem [Maschinelles Lernen für Anfänger Curriculum](http://github.com/Microsoft/ML-for-Beginners) gut beschrieben ist.
* Praktische KI-Anwendungen, die mit **[Cognitive Services](https://azure.microsoft.com/services/cognitive-services/?WT.mc_id=academic-77998-bethanycheum)** erstellt wurden. Dafür empfehlen wir, mit den Microsoft Learn-Modulen für [Vision](https://docs.microsoft.com/learn/paths/create-computer-vision-solutions-azure-cognitive-services/?WT.mc_id=academic-77998-bethanycheum), [Natural Language Processing](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-bethanycheum), **[Generative KI mit Azure OpenAI Service](https://learn.microsoft.com/en-us/training/paths/develop-ai-solutions-azure-openai/?WT.mc_id=academic-77998-bethanycheum)** und anderen zu beginnen.
* Spezifische ML-**Cloud-Frameworks** wie [Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-bethanycheum), [Microsoft Fabric](https://learn.microsoft.com/en-us/training/paths/get-started-fabric/?WT.mc_id=academic-77998-bethanycheum) oder [Azure Databricks](https://docs.microsoft.com/learn/paths/data-engineer-azure-databricks?WT.mc_id=academic-77998-bethanycheum). Ziehen Sie die Lernpfade [Erstellen und Betreiben von maschinellen Lernlösungen mit Azure Machine Learning](https://docs.microsoft.com/learn/paths/build-ai-solutions-with-azure-ml-service/?WT.mc_id=academic-77998-bethanycheum) und [Erstellen und Betreiben von maschinellen Lernlösungen mit Azure Databricks](https://docs.microsoft.com/learn/paths/build-operate-machine-learning-solutions-azure-databricks/?WT.mc_id=academic-77998-bethanycheum) in Betracht.
* **Konversationelle KI** und **Chatbots**. Es gibt einen separaten Lernpfad [Erstellen von konversationellen KI-Lösungen](https://docs.microsoft.com/learn/paths/create-conversational-ai-solutions/?WT.mc_id=academic-77998-bethanycheum), und Sie können auch [diesen Blogbeitrag](https://soshnikov.com/azure/hello-bot-conversational-ai-on-microsoft-platform/) für weitere Details konsultieren.
* **Tiefgehende Mathematik** hinter Deep Learning. Dafür empfehlen wir [Deep Learning](https://www.amazon.com/Deep-Learning-Adaptive-Computation-Machine/dp/0262035618) von Ian Goodfellow, Yoshua Bengio und Aaron Courville, das auch online verfügbar ist unter [https://www.deeplearningbook.org/](https://www.deeplearningbook.org/).
Für eine sanfte Einführung in die Themen _KI in der Cloud_ könnten Sie den Lernpfad [Get started with artificial intelligence on Azure](https://docs.microsoft.com/learn/paths/get-started-with-artificial-intelligence-on-azure/?WT.mc_id=academic-77998-bethanycheum) in Betracht ziehen.
Für eine sanfte Einführung in _KI in der Cloud_ können Sie den Lernpfad [Erste Schritte mit künstlicher Intelligenz auf Azure](https://docs.microsoft.com/learn/paths/get-started-with-artificial-intelligence-on-azure/?WT.mc_id=academic-77998-bethanycheum) in Betracht ziehen.
# Inhalt
# Inhalt
| | Link zur Lektion | PyTorch/Keras/TensorFlow | Lab |
| :-: | :------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------ |
| 0 | [Kurssetup](./lessons/0-course-setup/setup.md) | [Entwicklungsumgebung einrichten](./lessons/0-course-setup/how-to-run.md) | |
| I | [**Einführung in KI**](./lessons/1-Intro/README.md) | | |
| 01 | [Einführung und Geschichte der KI](./lessons/1-Intro/README.md) | - | - |
| II | **Symbolische KI** |
| 02 | [Wissenrepräsentation und Expertensysteme](./lessons/2-Symbolic/README.md) | [Expertensysteme](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) / [Ontologie](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb) /[Konzeptgraph](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/MSConceptGraph.ipynb) | |
| III | [**Einführung in neuronale Netzwerke**](./lessons/3-NeuralNetworks/README.md) |||
| 03 | [Perzeptron](./lessons/3-NeuralNetworks/03-Perceptron/README.md) | [Notizbuch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb) | [Lab](./lessons/3-NeuralNetworks/03-Perceptron/lab/README.md) |
| 04 | [Mehrschichtiges Perzeptron und Erstellen unseres eigenen Frameworks](./lessons/3-NeuralNetworks/04-OwnFramework/README.md) | [Notizbuch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) | [Lab](./lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md) |
| 05 | [Einführung in Frameworks (PyTorch/TensorFlow) und Überanpassung](./lessons/3-NeuralNetworks/05-Frameworks/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) / [Keras](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Lab](./lessons/3-NeuralNetworks/05-Frameworks/lab/README.md) |
| IV | [**Computer Vision**](./lessons/4-ComputerVision/README.md) | [PyTorch](https://docs.microsoft.com/learn/modules/intro-computer-vision-pytorch/?WT.mc_id=academic-77998-cacaste) / [TensorFlow](https://docs.microsoft.com/learn/modules/intro-computer-vision-TensorFlow/?WT.mc_id=academic-77998-cacaste)| [Entdecken Sie Computer Vision auf Microsoft Azure](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum) |
| 06 | [Einführung in die Computer Vision. OpenCV](./lessons/4-ComputerVision/06-IntroCV/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) | [Labor](./lessons/4-ComputerVision/06-IntroCV/lab/README.md) |
| 07 | [Konvolutionale Neuronale Netzwerke](./lessons/4-ComputerVision/07-ConvNets/README.md) & [CNN-Architekturen](./lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/ConvNetsPyTorch.ipynb) /[TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/4-ComputerVision/07-ConvNets/ConvNetsTF.ipynb) | [Labor](./lessons/4-ComputerVision/07-ConvNets/lab/README.md) |
| 08 | [Vortrainierte Netzwerke und Transferlernen](./lessons/4-ComputerVision/08-TransferLearning/README.md) und [Trainingstricks](./lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/TransferLearningPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Labor](./lessons/4-ComputerVision/08-TransferLearning/lab/README.md) |
| | Lektion Link | PyTorch/Keras/TensorFlow | Labor |
| :-: | :------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------ |
| 0 | [Kurs-Setup](./lessons/0-course-setup/setup.md) | [Einrichtung Ihrer Entwicklungsumgebung](./lessons/0-course-setup/how-to-run.md) | |
| I | [**Einführung in KI**](./lessons/1-Intro/README.md) | | |
| 01 | [Einführung und Geschichte der KI](./lessons/1-Intro/README.md) | - | - |
| II | **Symbolische KI** |
| 02 | [Wissensrepräsentation und Expertensysteme](./lessons/2-Symbolic/README.md) | [Expertensysteme](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) / [Ontologie](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb) /[Konzeptgraph](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/MSConceptGraph.ipynb) | |
| III | [**Einführung in neuronale Netze**](./lessons/3-NeuralNetworks/README.md) |||
| 03 | [Perzeptron](./lessons/3-NeuralNetworks/03-Perceptron/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb) | [Labor](./lessons/3-NeuralNetworks/03-Perceptron/lab/README.md) |
| 04 | [Mehrschichtiges Perzeptron und Erstellung eines eigenen Frameworks](./lessons/3-NeuralNetworks/04-OwnFramework/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) | [Labor](./lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md) |
| 05 | [Einführung in Frameworks (PyTorch/TensorFlow) und Overfitting](./lessons/3-NeuralNetworks/05-Frameworks/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) / [Keras](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Labor](./lessons/3-NeuralNetworks/05-Frameworks/lab/README.md) |
| IV | [**Computer Vision**](./lessons/4-ComputerVision/README.md) | [PyTorch](https://docs.microsoft.com/learn/modules/intro-computer-vision-pytorch/?WT.mc_id=academic-77998-cacaste) / [TensorFlow](https://docs.microsoft.com/learn/modules/intro-computer-vision-TensorFlow/?WT.mc_id=academic-77998-cacaste)| [Erkunden Sie Computer Vision auf Microsoft Azure](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum) |
| 06 | [Einführung in Computer Vision. OpenCV](./lessons/4-ComputerVision/06-IntroCV/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) | [Labor](./lessons/4-ComputerVision/06-IntroCV/lab/README.md) |
| 07 | [Convolutional Neural Networks](./lessons/4-ComputerVision/07-ConvNets/README.md) & [CNN-Architekturen](./lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/ConvNetsPyTorch.ipynb) /[TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/4-ComputerVision/07-ConvNets/ConvNetsTF.ipynb) | [Labor](./lessons/4-ComputerVision/07-ConvNets/lab/README.md) |
| 08 | [Vortrainierte Netzwerke und Transferlernen](./lessons/4-ComputerVision/08-TransferLearning/README.md) und [Trainingstricks](./lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/TransferLearningPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Lab](./lessons/4-ComputerVision/08-TransferLearning/lab/README.md) |
| 09 | [Autoencoder und VAEs](./lessons/4-ComputerVision/09-Autoencoders/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/09-Autoencoders/AutoEncodersPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb) | |
| 10 | [Generative Adversarial Networks & Stilübertragung](./lessons/4-ComputerVision/10-GANs/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANTF.ipynb) | |
| 11 | [Objekterkennung](./lessons/4-ComputerVision/11-ObjectDetection/README.md) | [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/11-ObjectDetection/ObjectDetection.ipynb) | [Labor](./lessons/4-ComputerVision/11-ObjectDetection/lab/README.md) |
| 12 | [Semantische Segmentierung. U-Net](./lessons/4-ComputerVision/12-Segmentation/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationPytorch.ipynb) / [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationTF.ipynb) | |
| V | [**Verarbeitung natürlicher Sprache**](./lessons/5-NLP/README.md) | [PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste) /[TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-TensorFlow/?WT.mc_id=academic-77998-cacaste) | [Erforschen Sie die Verarbeitung natürlicher Sprache auf Microsoft Azure](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)|
| 13 | [Textdarstellung. Bow/TF-IDF](./lessons/5-NLP/13-TextRep/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/TextRepresentationPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/TextRepresentationTF.ipynb) | |
| 14 | [Semantische Wort-Einbettungen. Word2Vec und GloVe](./lessons/5-NLP/14-Embeddings/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/EmbeddingsPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/EmbeddingsTF.ipynb) | |
| 15 | [Sprachmodellierung. Trainieren Sie Ihre eigenen Einbettungen](./lessons/5-NLP/15-LanguageModeling/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb) | [Labor](./lessons/5-NLP/15-LanguageModeling/lab/README.md) |
| 10 | [Generative Adversarial Networks & Künstlerischer Stiltransfer](./lessons/4-ComputerVision/10-GANs/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANTF.ipynb) | |
| 11 | [Objekterkennung](./lessons/4-ComputerVision/11-ObjectDetection/README.md) | [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/11-ObjectDetection/ObjectDetection.ipynb) | [Lab](./lessons/4-ComputerVision/11-ObjectDetection/lab/README.md) |
| 12 | [Semantische Segmentierung. U-Net](./lessons/4-ComputerVision/12-Segmentation/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationPytorch.ipynb) / [TensorFlow](../../(https:/github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationTF.ipynb)) | |
| V | [**Verarbeitung natürlicher Sprache**](./lessons/5-NLP/README.md) | [PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste) /[TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-TensorFlow/?WT.mc_id=academic-77998-cacaste) | [Erkunde die Verarbeitung natürlicher Sprache auf Microsoft Azure](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)|
| 13 | [Textrepräsentation. BoW/TF-IDF](./lessons/5-NLP/13-TextRep/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/TextRepresentationPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/TextRepresentationTF.ipynb) | |
| 14 | [Semantische Wort-Embeddings. Word2Vec und GloVe](./lessons/5-NLP/14-Embeddings/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/EmbeddingsPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/EmbeddingsTF.ipynb) | |
| 15 | [Sprachmodellierung. Eigene Embeddings trainieren](./lessons/5-NLP/15-LanguageModeling/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb) | [Lab](./lessons/5-NLP/15-LanguageModeling/lab/README.md) |
| 16 | [Rekurrente Neuronale Netze](./lessons/5-NLP/16-RNN/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/16-RNN/RNNPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/16-RNN/RNNTF.ipynb) | |
| 17 | [Generative Rekurrente Netze](./lessons/5-NLP/17-GenerativeNetworks/README.md) | [PyTorch](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativePyTorch.md) / [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativeTF.md) | [Labor](./lessons/5-NLP/17-GenerativeNetworks/lab/README.md) |
| 18 | [Transformatoren. BERT.](./lessons/5-NLP/18-Transformers/READMEtransformers.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersPyTorch.ipynb) /[TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersTF.ipynb) | |
| 19 | [Erkennung benannter Entitäten](./lessons/5-NLP/19-NER/README.md) | [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/19-NER/NER-TF.ipynb) | [Labor](./lessons/5-NLP/19-NER/lab/README.md) |
| 17 | [Generative Rekurrente Netze](./lessons/5-NLP/17-GenerativeNetworks/README.md) | [PyTorch](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativePyTorch.md) / [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativeTF.md) | [Lab](./lessons/5-NLP/17-GenerativeNetworks/lab/README.md) |
| 18 | [Transformers. BERT.](./lessons/5-NLP/18-Transformers/READMEtransformers.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersPyTorch.ipynb) /[TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersTF.ipynb) | |
| 19 | [Named Entity Recognition](./lessons/5-NLP/19-NER/README.md) | [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/19-NER/NER-TF.ipynb) | [Lab](./lessons/5-NLP/19-NER/lab/README.md) |
| 20 | [Große Sprachmodelle, Prompt-Programmierung und Few-Shot-Aufgaben](./lessons/5-NLP/20-LangModels/READMELargeLang.md) | [PyTorch](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/20-LangModels/GPT-PyTorch.ipynb) | |
| VI | **Andere KI-Techniken** || |
| 21 | [Genetische Algorithmen](./lessons/6-Other/21-GeneticAlgorithms/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/21-GeneticAlgorithms/Genetic.ipynb) | |
| 22 | [Deep Reinforcement Learning](./lessons/6-Other/22-DeepRL/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb) /[TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb) | [Lab](./lessons/6-Other/22-DeepRL/lab/README.md) |
| 23 | [Multi-Agent-Systeme](./lessons/6-Other/23-MultiagentSystems/README.md) | | |
| VII | **KI-Ethische Aspekte** | | |
| 24 | [KI-Ethische Grundsätze und verantwortungsvolle KI](./lessons/7-Ethics/README.md) | [Microsoft Learn: Grundsätze für verantwortungsvolle KI](https://docs.microsoft.com/learn/paths/responsible-ai-business-principles/?WT.mc_id=academic-77998-cacaste) | |
| 22 | [Tiefes Verstärkungslernen](./lessons/6-Other/22-DeepRL/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb) /[TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb) | [Lab](./lessons/6-Other/22-DeepRL/lab/README.md) |
| 23 | [Multi-Agenten-Systeme](./lessons/6-Other/23-MultiagentSystems/README.md) | | |
| VII | **KI-Ethik** | | |
| 24 | [KI-Ethik und Verantwortungsvolle KI](./lessons/7-Ethics/README.md) | [Microsoft Learn: Prinzipien für verantwortungsvolle KI](https://docs.microsoft.com/learn/paths/responsible-ai-business-principles/?WT.mc_id=academic-77998-cacaste) | |
| IX | **Extras** | | |
| 25 | [Multi-Modal-Netzwerke, CLIP und VQGAN](./lessons/X-Extras/X1-MultiModal/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/Clip.ipynb) | |
| 25 | [Multi-Modale Netzwerke, CLIP und VQGAN](./lessons/X-Extras/X1-MultiModal/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/Clip.ipynb) | |
## Jede Lektion enthält
* Vorbereitende Materialien
* Ausführbare Jupyter-Notebooks, die oft spezifisch für das Framework (**PyTorch** oder **TensorFlow**) sind. Das ausführbare Notebook enthält auch viele theoretische Inhalte, daher sollten Sie mindestens eine Version des Notebooks (entweder PyTorch oder TensorFlow) durchgehen, um das Thema zu verstehen.
* Vorbereitendes Lesematerial
* Ausführbare Jupyter-Notebooks, die oft spezifisch für das Framework (**PyTorch** oder **TensorFlow**) sind. Die ausführbaren Notebooks enthalten auch viele theoretische Inhalte, daher ist es wichtig, mindestens eine Version des Notebooks (entweder PyTorch oder TensorFlow) durchzugehen, um das Thema zu verstehen.
* **Labs**, die für einige Themen verfügbar sind und Ihnen die Möglichkeit geben, das Gelernte auf ein spezifisches Problem anzuwenden.
* Einige Abschnitte enthalten Links zu [**MS Learn**](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum) Modulen, die verwandte Themen abdecken.
* Einige Abschnitte enthalten Links zu [**MS Learn**](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)-Modulen, die verwandte Themen behandeln.
## Erste Schritte
- Wir haben eine [Einrichtungslektion](./lessons/0-course-setup/setup.md) erstellt, um Ihnen bei der Einrichtung Ihrer Entwicklungsumgebung zu helfen. - Für Lehrende haben wir ebenfalls eine [Lehrpläne-Einrichtungslektion](./lessons/0-course-setup/for-teachers.md) erstellt!
- So [führen Sie den Code in VSCode oder Codepace aus](./lessons/0-course-setup/how-to-run.md)
- Wir haben eine [Setup-Lektion](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/0-course-setup/setup.md) erstellt, um Ihnen bei der Einrichtung Ihrer Entwicklungsumgebung zu helfen. - Für Lehrkräfte haben wir auch eine [Curricula-Setup-Lektion](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/0-course-setup/for-teachers.md) erstellt!
- Wie man [den Code in VSCode oder einem Codespace ausführt](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/0-course-setup/how-to-run.md)
Befolgen Sie diese Schritte:
Folgen Sie diesen Schritten:
Forken Sie das Repository: Klicken Sie auf die Schaltfläche "Fork" in der oberen rechten Ecke dieser Seite.
Forken Sie das Repository: Klicken Sie auf die Schaltfläche "Fork" oben rechts auf dieser Seite.
Klonen Sie das Repository: `git clone https://github.com/microsoft/AI-For-Beginners.git`
Vergessen Sie nicht, dieses Repo zu star (🌟), um es später leichter zu finden.
Vergessen Sie nicht, dieses Repository mit einem Stern (🌟) zu markieren, damit Sie es später leichter finden.
## Lernen Sie andere Lernende kennen
## Treffen Sie andere Lernende
Treten Sie unserem [offiziellen KI-Discord-Server](https://aka.ms/genai-discord?WT.mc_id=academic-105485-bethanycheum) bei, um andere Lernende, die diesen Kurs belegen, zu treffen und sich zu vernetzen sowie Unterstützung zu erhalten.
Treten Sie unserem [offiziellen AI-Discord-Server](https://aka.ms/genai-discord?WT.mc_id=academic-105485-bethanycheum) bei, um andere Lernende dieses Kurses zu treffen und sich zu vernetzen sowie Unterstützung zu erhalten.
## Quizze
Wenn Sie Feedback zu Produkten oder Fragen während des Aufbaus haben, besuchen Sie unser [Azure AI Foundry Developer Forum](https://aka.ms/foundry/forum)
> **Eine Anmerkung zu Quizzen**: Alle Quizze befinden sich im Ordner Quiz-app in etc\quiz-app. Sie sind von den Lektionen aus verlinkt. Die Quiz-App kann lokal ausgeführt oder auf Azure bereitgestellt werden; folgen Sie den Anweisungen im `quiz-app` Ordner. Sie werden schrittweise lokalisiert.
## Quizze
> **Eine Anmerkung zu den Quiz**: Alle Quiz befinden sich im Ordner Quiz-app unter etc\quiz-app. Sie sind mit den Lektionen verknüpft. Die Quiz-App kann lokal ausgeführt oder auf Azure bereitgestellt werden; folgen Sie den Anweisungen im Ordner `quiz-app`. Sie werden nach und nach lokalisiert.
## Hilfe gesucht
## Hilfe gewünscht
Haben Sie Vorschläge oder haben Sie Schreib- oder Codefehler gefunden? Erstellen Sie ein Issue oder einen Pull Request.
Hast du Vorschläge oder Fehler in der Rechtschreibung oder im Code gefunden? Erstelle ein Issue oder einen Pull Request.
## Besonderer Dank
* **✍️ Hauptautor:** [Dmitry Soshnikov](http://soshnikov.com), PhD
* **🔥 Redakteur:** [Jen Looper](https://twitter.com/jenlooper), PhD
* **🎨 Sketchnote-Illustrator:** [Tomomi Imura](https://twitter.com/girlie_mac)
* **✅ Quiz-Ersteller:** [Lateefah Bello](https://github.com/CinnamonXI), [MLSA](https://studentambassadors.microsoft.com/)
* **🙏 Hauptbeitragsleistende:** [Evgenii Pishchik](https://github.com/Pe4enIks)
* **✍️ Hauptautor:** [Dmitry Soshnikov](http://soshnikov.com), PhD
* **🔥 Redakteurin:** [Jen Looper](https://twitter.com/jenlooper), PhD
* **🎨 Sketchnote-Illustratorin:** [Tomomi Imura](https://twitter.com/girlie_mac)
* **✅ Quiz-Erstellerin:** [Lateefah Bello](https://github.com/CinnamonXI), [MLSA](https://studentambassadors.microsoft.com/)
* **🙏 Hauptbeitragende:** [Evgenii Pishchik](https://github.com/Pe4enIks)
## Weitere Lehrpläne
Unser Team produziert auch andere Lehrpläne! Schauen Sie sich an:
Unser Team erstellt auch andere Lehrpläne! Schau dir diese an:
* [Data Science für Anfänger](https://aka.ms/ds4beginners)
* [**Version 2.0** Generative KI für Anfänger](https://aka.ms/genai-beginners)
* [**NEU** Cybersicherheit für Anfänger](https://github.com/microsoft/Security-101??WT.mc_id=academic-96948-sayoung)
* [Webentwicklung für Anfänger](https://aka.ms/webdev-beginners)
* [IoT für Anfänger](https://aka.ms/iot-beginners)
* [Maschinelles Lernen für Anfänger](https://aka.ms/ml4beginners)
* [XR-Entwicklung für Anfänger](https://aka.ms/xr-dev-for-beginners)
* [GitHub Copilot für KI-gestütztes Programmieren meistern](https://aka.ms/GitHubCopilotAI)
- [Generative KI für Anfänger](https://aka.ms/genai-beginners)
- [Generative KI für Anfänger .NET](https://github.com/microsoft/Generative-AI-for-beginners-dotnet)
- [Generative KI mit JavaScript](https://github.com/microsoft/generative-ai-with-javascript)
- [Generative KI mit Java](https://github.com/microsoft/Generative-AI-for-beginners-java)
- [KI für Anfänger](https://aka.ms/ai-beginners)
- [Datenwissenschaft für Anfänger](https://aka.ms/datascience-beginners)
- [Maschinelles Lernen für Anfänger](https://aka.ms/ml-beginners)
- [Cybersicherheit für Anfänger](https://github.com/microsoft/Security-101)
- [Webentwicklung für Anfänger](https://aka.ms/webdev-beginners)
- [IoT für Anfänger](https://aka.ms/iot-beginners)
- [XR-Entwicklung für Anfänger](https://github.com/microsoft/xr-development-for-beginners)
- [GitHub Copilot meistern für agentische Nutzung](https://github.com/microsoft/Mastering-GitHub-Copilot-for-Paired-Programming)
- [GitHub Copilot meistern für C#/.NET-Entwickler](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers)
- [Wähle dein eigenes Copilot-Abenteuer](https://github.com/microsoft/CopilotAdventures)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

49
translations/de/SECURITY.md
View File

@ -1,40 +1,49 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a583f49d359c7ebba61433e4dfcd05a9",
"translation_date": "2025-08-24T09:28:59+00:00",
"source_file": "SECURITY.md",
"language_code": "de"
}
-->
## Sicherheit
Microsoft nimmt die Sicherheit unserer Softwareprodukte und -dienste ernst, einschließlich aller Quellcode-Repositorys, die über unsere GitHub-Organisationen verwaltet werden, darunter [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin) und [unsere GitHub-Organisationen](https://opensource.microsoft.com/).
Microsoft nimmt die Sicherheit seiner Softwareprodukte und -dienste sehr ernst, einschließlich aller Quellcode-Repositories, die über unsere GitHub-Organisationen verwaltet werden. Dazu gehören [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin) und [unsere GitHub-Organisationen](https://opensource.microsoft.com/).
Wenn Sie glauben, eine Sicherheitsanfälligkeit in einem Microsoft-eigenen Repository gefunden zu haben, die [Microsofts Definition einer Sicherheitsanfälligkeit](https://aka.ms/opensource/security/definition) erfüllt, melden Sie dies bitte wie unten beschrieben.
Wenn Sie der Meinung sind, eine Sicherheitslücke in einem von Microsoft verwalteten Repository gefunden zu haben, die [Microsofts Definition einer Sicherheitslücke](https://aka.ms/opensource/security/definition) entspricht, melden Sie diese bitte wie unten beschrieben.
## Meldung von Sicherheitsproblemen
## Melden von Sicherheitsproblemen
**Bitte melden Sie Sicherheitsanfälligkeiten nicht über öffentliche GitHub-Issues.**
**Bitte melden Sie Sicherheitslücken nicht über öffentliche GitHub-Issues.**
Stattdessen melden Sie diese bitte an das Microsoft Security Response Center (MSRC) unter [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
Stattdessen melden Sie diese bitte dem Microsoft Security Response Center (MSRC) unter [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
Wenn Sie lieber ohne Anmeldung einreichen möchten, senden Sie eine E-Mail an [secure@microsoft.com](mailto:secure@microsoft.com). Wenn möglich, verschlüsseln Sie Ihre Nachricht mit unserem PGP-Schlüssel; bitte laden Sie ihn von der [Microsoft Security Response Center PGP Key-Seite](https://aka.ms/opensource/security/pgpkey) herunter.
Falls Sie lieber ohne Anmeldung einreichen möchten, senden Sie eine E-Mail an [secure@microsoft.com](mailto:secure@microsoft.com). Wenn möglich, verschlüsseln Sie Ihre Nachricht mit unserem PGP-Schlüssel; laden Sie diesen von der [Microsoft Security Response Center PGP Key-Seite](https://aka.ms/opensource/security/pgpkey) herunter.
Sie sollten innerhalb von 24 Stunden eine Antwort erhalten. Wenn Sie aus irgendeinem Grund keine Antwort erhalten, folgen Sie bitte per E-Mail nach, um sicherzustellen, dass wir Ihre ursprüngliche Nachricht erhalten haben. Weitere Informationen finden Sie unter [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
Sie sollten innerhalb von 24 Stunden eine Antwort erhalten. Falls dies aus irgendeinem Grund nicht geschieht, folgen Sie bitte per E-Mail nach, um sicherzustellen, dass wir Ihre ursprüngliche Nachricht erhalten haben. Weitere Informationen finden Sie unter [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
Bitte fügen Sie die angeforderten Informationen aufgelistet unten (so viel wie Sie bereitstellen können) hinzu, um uns zu helfen, die Natur und den Umfang des möglichen Problems besser zu verstehen:
Bitte geben Sie die unten aufgeführten Informationen (so weit wie möglich) an, um uns zu helfen, die Art und den Umfang des möglichen Problems besser zu verstehen:
* Art des Problems (z.B. Bufferüberlauf, SQL-Injection, Cross-Site-Scripting usw.)
* Vollständige Pfade der Quellcodedatei(en), die mit dem Auftreten des Problems zusammenhängen
* Der Standort des betroffenen Quellcodes (Tag/Branch/Commit oder direkte URL)
* Alle speziellen Konfigurationen, die erforderlich sind, um das Problem zu reproduzieren
* Schritt-für-Schritt-Anleitungen zur Reproduktion des Problems
* Proof-of-Concept oder Exploit-Code (wenn möglich)
* Auswirkungen des Problems, einschließlich wie ein Angreifer das Problem ausnutzen könnte
* Art des Problems (z. B. Buffer Overflow, SQL-Injection, Cross-Site-Scripting usw.)
* Vollständige Pfade der Quellcodedatei(en), die mit dem Problem in Zusammenhang stehen
* Der Ort des betroffenen Quellcodes (Tag/Branch/Commit oder direkte URL)
* Besondere Konfigurationen, die erforderlich sind, um das Problem zu reproduzieren
* Schritt-für-Schritt-Anleitung zur Reproduktion des Problems
* Proof-of-Concept- oder Exploit-Code (falls möglich)
* Auswirkungen des Problems, einschließlich der möglichen Ausnutzung durch einen Angreifer
Diese Informationen helfen uns, Ihren Bericht schneller zu triagieren.
Diese Informationen helfen uns, Ihren Bericht schneller zu priorisieren.
Wenn Sie für ein Bug-Bounty berichten, können vollständigere Berichte zu einer höheren Belohnung führen. Bitte besuchen Sie unsere Seite [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) für weitere Details zu unseren aktiven Programmen.
Wenn Sie im Rahmen eines Bug-Bounty-Programms berichten, können vollständigere Berichte zu einer höheren Prämie führen. Besuchen Sie unsere Seite zum [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty), um weitere Details zu unseren aktiven Programmen zu erhalten.
## Bevorzugte Sprachen
Wir bevorzugen, dass alle Kommunikationen in Englisch erfolgen.
Wir bevorzugen alle Kommunikation in Englisch.
## Richtlinie
Microsoft folgt dem Prinzip der [Koordinierten Verwundbarkeitsoffenlegung](https://aka.ms/opensource/security/cvd).
Microsoft folgt dem Prinzip der [koordinierten Offenlegung von Sicherheitslücken](https://aka.ms/opensource/security/cvd).
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung resultieren.
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.

13
translations/de/etc/CODE_OF_CONDUCT.md
View File

@ -1,3 +1,12 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
"translation_date": "2025-08-24T09:44:37+00:00",
"source_file": "etc/CODE_OF_CONDUCT.md",
"language_code": "de"
}
-->
# Microsoft Open Source Verhaltenskodex
Dieses Projekt hat den [Microsoft Open Source Verhaltenskodex](https://opensource.microsoft.com/codeofconduct/) übernommen.
@ -6,7 +15,7 @@ Ressourcen:
- [Microsoft Open Source Verhaltenskodex](https://opensource.microsoft.com/codeofconduct/)
- [Microsoft Verhaltenskodex FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
- Kontaktieren Sie [opencode@microsoft.com](mailto:opencode@microsoft.com) bei Fragen oder Bedenken.
- Kontaktieren Sie [opencode@microsoft.com](mailto:opencode@microsoft.com) bei Fragen oder Bedenken
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

27
translations/de/etc/CONTRIBUTING.md
View File

@ -1,20 +1,29 @@
# Mitwirken
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "847a587aa1b83f4d00858183ff3ed18a",
"translation_date": "2025-08-24T09:44:51+00:00",
"source_file": "etc/CONTRIBUTING.md",
"language_code": "de"
}
-->
# Beiträge
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 erklärt wird, dass Sie das Recht haben, und tatsächlich auch, uns die Rechte zur Nutzung Ihres Beitrags zu gewähren. Für weitere Informationen besuchen Sie bitte https://cla.microsoft.com.
Dieses Projekt begrüßt Beiträge und Vorschläge. Die meisten Beiträge erfordern, dass Sie einer Contributor License Agreement (CLA) zustimmen, die erklärt, dass Sie das Recht haben und tatsächlich gewähren, uns die Rechte zur Nutzung Ihres Beitrags zu übertragen. Weitere Details finden Sie unter https://cla.microsoft.com.
Wenn Sie einen Pull Request einreichen, wird ein CLA-Bot automatisch bestimmen, ob Sie eine CLA bereitstellen müssen, und den PR entsprechend kennzeichnen (z. B. Label, Kommentar). Befolgen Sie einfach die Anweisungen des Bots. Sie müssen dies nur einmal für alle Repositories tun, die unsere CLA verwenden.
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.
Dieses Projekt hat den [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/) übernommen. Für weitere Informationen siehe die [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) oder kontaktieren Sie [opencode@microsoft.com](mailto:opencode@microsoft.com) bei weiteren Fragen oder Anmerkungen.
Dieses Projekt hat den [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/) übernommen. Weitere Informationen finden Sie in den [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) oder kontaktieren Sie [opencode@microsoft.com](mailto:opencode@microsoft.com) bei zusätzlichen Fragen oder Kommentaren.
# Suche nach Beiträgen
# Gesuchte Beiträge
Wir suchen derzeit aktiv nach Beiträgen zu folgenden Themen:
Wir suchen derzeit aktiv nach Beiträgen zu den folgenden Themen:
- [ ] Abschnitt über Deep Reinforcement Learning schreiben
- [ ] Abschnitt + Notebook zur Objekterkennung verbessern
- [ ] PyTorch Lightning (für [diesen Abschnitt](https://github.com/microsoft/AI-For-Beginners/blob/main/3-NeuralNetworks/05-Frameworks/README.md))
- [ ] Abschnitt + Beispiele zur Named Entity Recognition schreiben
- [ ] Beispiele für das Training unserer eigenen Embeddings für [diesen Abschnitt](https://github.com/microsoft/AI-For-Beginners/tree/main/5-NLP/15-LanguageModeling) erstellen
- [ ] Abschnitt + Beispiele zu Named Entity Recognition schreiben
- [ ] Beispiele erstellen, um eigene Embeddings für [diesen Abschnitt](https://github.com/microsoft/AI-For-Beginners/tree/main/5-NLP/15-LanguageModeling) zu trainieren
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

49
translations/de/etc/Mindmap.md
View File

@ -1,24 +1,33 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f2f88dbd2debd38e26149b27b1fd272d",
"translation_date": "2025-08-24T09:44:59+00:00",
"source_file": "etc/Mindmap.md",
"language_code": "de"
}
-->
# KI
## [Einführung in KI](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/1-Intro/README.md)
- Definition von KI
- Geschichte der KI
- Ansätze zur KI
- Ansätze der KI
- Top-down/Symbolisch
- Bottom-up/Neural
- Bottom-up/Neuronale
- Evolutionär
- Synergetische / Emergent KI
- Synergetisch / Entstehende KI
- [Microsoft AI Business School](https://www.microsoft.com/ai/ai-business-school/?WT.mc_id=academic-77998-cacaste)
## [Symbolische KI](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/README.md)
- Wissensdarstellung
- Wissensrepräsentation
- [Expertensysteme](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb)
- [Ontologien](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb)
- Semantisches Web
## [Neuronale Netze](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/README.md)
## [Neuronale Netzwerke](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/README.md)
- [Perzeptron](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/03-Perceptron/README.md)
- [Mehrschichtige Netze](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/04-OwnFramework/README.md)
- [Mehrschichtige Netzwerke](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/04-OwnFramework/README.md)
- [Einführung in Frameworks](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/README.md)
- [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb)
- [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.md)
@ -26,46 +35,48 @@
## [Computer Vision](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/README.md)
- Auf MS Learn
- [KI-Grundlagen: Erkunde Computer Vision](https://docs.microsoft.com/learn/paths/explore-computer-vision-microsoft-azure/?WT.mc_id=academic-77998-cacaste)
- [KI-Grundlagen: Einführung in Computer Vision](https://docs.microsoft.com/learn/paths/explore-computer-vision-microsoft-azure/?WT.mc_id=academic-77998-cacaste)
- [CV mit PyTorch](https://docs.microsoft.com/learn/modules/intro-computer-vision-pytorch/?WT.mc_id=academic-77998-cacaste)
- [CV mit TensorFlow](https://docs.microsoft.com/learn/modules/intro-computer-vision-TensorFlow/?WT.mc_id=academic-77998-cacaste)
- [Einführung in CV. OpenCV](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/06-IntroCV/README.md)
- [Faltungsnetzwerke](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/README.md)
- [Konvolutionale Netzwerke](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/README.md)
- [CNN-Architekturen](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md)
- [Transferlernen](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/README.md)
- [Trainingstricks](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md)
- [Transfer-Lernen](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/README.md)
- [Trainings-Tricks](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md)
- [Autoencoder und VAEs](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/09-Autoencoders/README.md)
- [Generative Adversarial Networks](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/README.md)
- [Stilübertragung](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)
- [Stiltransfer](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)
- [Objekterkennung](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/11-ObjectDetection/README.md)
- [Segmentierung](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/README.md)
## [Verarbeitung natürlicher Sprache](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/README.md)
## [Verarbeitung natürlicher Sprache (NLP)](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/README.md)
- Auf MS Learn
- [KI-Grundlagen: Erkunde NLP](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-cacaste)
- [KI-Grundlagen: Einführung in NLP](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-cacaste)
- [NLP mit PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste)
- [NLP mit TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-TensorFlow/?WT.mc_id=academic-77998-cacaste)
- [Textdarstellung](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/README.md)
- [Textrepräsentation](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/README.md)
- Bag of Words
- TF/IDF
- [Semantische Einbettungen](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/README.md)
- Word2Vec
- GloVE
- [Sprachmodellierung](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling)
- [Rekurrente Neuronale Netze](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/16-RNN/README.md)
- [Rekurrente Neuronale Netzwerke](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/16-RNN/README.md)
- LSTM
- GRU
- [Generative Rekurrente Netze](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/17-GenerativeNetworks/README.md)
- [Generative Rekurrente Netzwerke](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/17-GenerativeNetworks/README.md)
- [Transformatoren und BERT](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/README.md)
- [Erkennung benannter Entitäten](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/19-NER/README.md)
- [Textgenerierung und GPT](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/20-LanguageModels/README.md)
## Andere Techniken
- [Genetische Algorithmen](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/21-GeneticAlgorithms/README.md)
- [Tiefes Verstärkendes Lernen](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/README.md)
- [Deep Reinforcement Learning](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/README.md)
- [Multi-Agenten-Systeme](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md)
## [KI-Ethische Grundsätze](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/README.md)
## [KI-Ethik](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/README.md)
- [MS Learn über verantwortungsvolle KI](https://docs.microsoft.com/learn/paths/responsible-ai-business-principles/?WT.mc_id=academic-77998-cacaste)
## Extras
- [Multimodale Netzwerke](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/README.md)
- [CLIP](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/Clip.ipynb)
@ -73,4 +84,4 @@
- VQ-GAN
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

19
translations/de/etc/SUPPORT.md
View File

@ -1,16 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fdfc08baee91e402938a2b1f94fe0949",
"translation_date": "2025-08-24T09:44:32+00:00",
"source_file": "etc/SUPPORT.md",
"language_code": "de"
}
-->
# Unterstützung
## So melden Sie Probleme und erhalten Hilfe
Dieses Projekt verwendet GitHub Issues, um Fehler und Funktionsanfragen zu verfolgen. Bitte durchsuchen Sie die vorhandenen
Probleme, bevor Sie neue Probleme melden, um Duplikate zu vermeiden. Für neue Probleme melden Sie Ihren Fehler oder
Ihre Funktionsanfrage als neues Issue.
Dieses Projekt verwendet GitHub Issues, um Fehler und Funktionsanfragen zu verfolgen. Bitte durchsuchen Sie die vorhandenen Issues, bevor Sie neue erstellen, um Duplikate zu vermeiden. Für neue Issues melden Sie Ihren Fehler oder Ihre Funktionsanfrage als neues Issue.
Für Hilfe und Fragen zur Nutzung dieses Projekts nutzen Sie bitte die Diskussionsforen.
## Microsoft Support-Richtlinie
## Microsoft-Support-Richtlinie
Die Unterstützung für dieses Projekt ist auf die oben aufgeführten Ressourcen beschränkt.
Die Unterstützung für dieses Projekt beschränkt sich auf die oben aufgeführten Ressourcen.
**Haftungsausschluss**:
Dieses Dokument wurde mit Hilfe von maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie beachten, 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 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.
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 sich aus der Nutzung dieser Übersetzung ergeben.

35
translations/de/etc/TRANSLATIONS.md
View File

@ -1,36 +1,45 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "62b3e3ad5182edb905eec649a87eeeb4",
"translation_date": "2025-08-24T09:44:42+00:00",
"source_file": "etc/TRANSLATIONS.md",
"language_code": "de"
}
-->
# Beiträge durch Übersetzung von Lektionen
Wir freuen uns über Übersetzungen der Lektionen in diesem Curriculum!
Wir freuen uns über Übersetzungen der Lektionen in diesem Lehrplan!
## Richtlinien
In jedem Lektion-Ordner und im Ordner der Lektionseinführung gibt es Unterordner, die die übersetzten Markdown-Dateien enthalten.
In jedem Lektionen-Ordner und Einführungsordner der Lektionen gibt es Unterordner, die die übersetzten Markdown-Dateien enthalten.
> Hinweis: Bitte übersetze keinen Code in den Beispiel-Code-Dateien; die einzigen Dinge, die übersetzt werden sollen, sind README, Aufgaben und die Quizze. Danke!
> Hinweis: Bitte übersetzen Sie keinen Code in den Codebeispieldateien; die einzigen Dinge, die übersetzt werden sollen, sind README, Aufgaben und die Quizfragen. Danke!
Übersetzte Dateien sollten diesem Namensschema folgen:
Übersetzte Dateien sollten folgendem Namensschema folgen:
**README._[language]_.md**
wobei _[language]_ eine zweibuchstabige Sprachabkürzung gemäß dem ISO 639-1 Standard ist (z.B. `README.es.md` für Spanisch und `README.nl.md` für Niederländisch).
wobei _[language]_ eine zweibuchstabige Sprachabkürzung gemäß dem ISO 639-1-Standard ist (z. B. `README.es.md` für Spanisch und `README.nl.md` für Niederländisch).
**assignment._[language]_.md**
Ähnlich wie bei den Readme-Dateien, bitte auch die Aufgaben übersetzen.
Ähnlich wie bei den Readme-Dateien, übersetzen Sie bitte auch die Aufgaben.
**Quizze**
**Quizfragen**
1. Füge deine Übersetzung zur Quiz-App hinzu, indem du eine Datei hier hinzufügst: https://github.com/microsoft/AI-For-Beginners/tree/main/etc/quiz-app/src/assets/translations, mit der richtigen Namenskonvention (en.json, fr.json). **Bitte lokalisiere jedoch die Wörter 'true' oder 'false' nicht. Danke!**
1. Fügen Sie Ihre Übersetzung zur Quiz-App hinzu, indem Sie hier eine Datei hinzufügen: https://github.com/microsoft/AI-For-Beginners/tree/main/etc/quiz-app/src/assets/translations, mit dem richtigen Namensschema (en.json, fr.json). **Bitte lokalisieren Sie jedoch nicht die Wörter 'true' oder 'false'. Danke!**
2. Füge deinen Sprachcode zum Dropdown-Menü in der App.vue-Datei der Quiz-App hinzu.
2. Fügen Sie Ihren Sprachcode zum Dropdown-Menü in der App.vue-Datei der Quiz-App hinzu.
3. Bearbeite die [translations index.js Datei](https://github.com/microsoft/AI-For-Beginners/blob/main/etc/quiz-app/src/assets/translations/index.js) der Quiz-App, um deine Sprache hinzuzufügen.
3. Bearbeiten Sie die [translations index.js Datei](https://github.com/microsoft/AI-For-Beginners/blob/main/etc/quiz-app/src/assets/translations/index.js) der Quiz-App, um Ihre Sprache hinzuzufügen.
4. Schließlich bearbeite ALLE Quiz-Links in deinen übersetzten README.md-Dateien, damit sie direkt auf dein übersetztes Quiz verweisen: https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1 wird zu https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1?loc=id
4. Bearbeiten Sie schließlich ALLE Quiz-Links in Ihren übersetzten README.md-Dateien, damit sie direkt auf Ihr übersetztes Quiz verweisen: https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1 wird zu https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1?loc=id
**DANKE**
Wir schätzen deine Bemühungen sehr!
Wir schätzen Ihre Bemühungen wirklich sehr!
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 autoritative Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung resultieren.
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 sich aus der Nutzung dieser Übersetzung ergeben.

112
translations/de/etc/quiz-app/README.md
View File

@ -1,18 +1,27 @@
# Quizze
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d699cf8509f74baa5b0b838de5cf0662",
"translation_date": "2025-08-24T09:45:20+00:00",
"source_file": "etc/quiz-app/README.md",
"language_code": "de"
}
-->
# Quizfragen
Diese Quizze sind die Vor- und Nach-Lecture-Quizze für das KI-Curriculum unter https://aka.ms/ai-beginners
Diese Quizfragen sind die Vor- und Nachbereitungsquizfragen für den KI-Lehrplan unter https://aka.ms/ai-beginners
## Hinzufügen eines übersetzten Quizsets
## Hinzufügen eines übersetzten Quiz-Sets
Fügen Sie eine Quizübersetzung hinzu, indem Sie passende Quizstrukturen in den `assets/translations`-Ordnern erstellen. Die kanonischen Quizze befinden sich in `assets/translations/en`. Die Quizze sind in mehrere Gruppen nach Lektionen unterteilt. Stellen Sie sicher, dass die Nummerierung mit dem entsprechenden Quizabschnitt übereinstimmt. In diesem Curriculum gibt es insgesamt 40 Quizze, beginnend bei 0.
Füge eine Quiz-Übersetzung hinzu, indem du passende Quizstrukturen in den Ordnern `assets/translations` erstellst. Die ursprünglichen Quizfragen befinden sich in `assets/translations/en`. Die Quizfragen sind nach Lektionen in mehrere Gruppen unterteilt. Achte darauf, die Nummerierung mit dem entsprechenden Quizabschnitt abzugleichen. Insgesamt gibt es 40 Quizfragen in diesem Lehrplan, beginnend mit der Nummer 0.
Nach der Bearbeitung der Übersetzungen bearbeiten Sie die index.js-Datei im Übersetzungsordner, um alle Dateien gemäß den Konventionen in `en` zu importieren.
Nach dem Bearbeiten der Übersetzungen bearbeite die Datei `index.js` im Übersetzungsordner, um alle Dateien gemäß den Konventionen in `en` zu importieren.
Bearbeiten Sie die `index.js`-Datei in `assets/translations`, um die neuen übersetzten Dateien zu importieren.
Bearbeite die Datei `index.js` in `assets/translations`, um die neuen übersetzten Dateien zu importieren.
Dann bearbeiten Sie das Dropdown-Menü in `App.vue` in dieser App, um Ihre Sprache hinzuzufügen. Passen Sie die lokalisierte Abkürzung an den Ordnernamen Ihrer Sprache an.
Bearbeite anschließend das Dropdown-Menü in `App.vue` in dieser App, um deine Sprache hinzuzufügen. Passe die lokalisierte Abkürzung an den Ordnernamen deiner Sprache an.
Schließlich bearbeiten Sie alle Quizlinks in den übersetzten Lektionen, falls vorhanden, um diese Lokalisierung als Abfrageparameter einzuschließen: `?loc=fr` zum Beispiel.
Schließlich bearbeite alle Quiz-Links in den übersetzten Lektionen, falls vorhanden, um diese Lokalisierung als Abfrageparameter hinzuzufügen: z. B. `?loc=fr`.
## Projektsetup
@ -26,13 +35,13 @@ npm install
npm run serve
```
### Konstruiert und minimiert für die Produktion
### Kompiliert und minimiert für die Produktion
```
npm run build
```
### Linter und behebt Dateien
### Überprüft und behebt Dateien
```
npm run lint
@ -42,55 +51,56 @@ npm run lint
Siehe [Konfigurationsreferenz](https://cli.vuejs.org/config/).
Credits: Vielen Dank an die ursprüngliche Version dieser Quiz-App: https://github.com/arpan45/simple-quiz-vue
Credits: Dank an die ursprüngliche Version dieser Quiz-App: https://github.com/arpan45/simple-quiz-vue
## Bereitstellung in Azure
## Bereitstellung auf Azure
Hier ist eine Schritt-für-Schritt-Anleitung, um Ihnen den Einstieg zu erleichtern:
Hier ist eine Schritt-für-Schritt-Anleitung, um dir den Einstieg zu erleichtern:
1. Forken Sie ein GitHub-Repository
Stellen Sie sicher, dass Ihr Code für die statische Web-App in Ihrem GitHub-Repository vorhanden ist. Forken Sie dieses Repository.
1. Forke ein GitHub-Repository
Stelle sicher, dass sich der Code deiner statischen Web-App in deinem GitHub-Repository befindet. Forke dieses Repository.
2. Erstellen Sie eine Azure Static Web App
- Erstellen Sie ein [Azure-Konto](http://azure.microsoft.com)
- Gehen Sie zum [Azure-Portal](https://portal.azure.com)
- Klicken Sie auf „Ressource erstellen“ und suchen Sie nach „Static Web App“.
- Klicken Sie auf „Erstellen“.
2. Erstelle eine Azure Static Web App
- Erstelle ein [Azure-Konto](http://azure.microsoft.com)
- Gehe zum [Azure-Portal](https://portal.azure.com)
- Klicke auf „Ressource erstellen“ und suche nach „Static Web App“.
- Klicke auf „Erstellen“.
3. Konfigurieren Sie die Static Web App
- Grundlagen: Abonnement: Wählen Sie Ihr Azure-Abonnement aus.
- Ressourcengruppe: Erstellen Sie eine neue Ressourcengruppe oder verwenden Sie eine vorhandene.
- Name: Geben Sie einen Namen für Ihre statische Web-App an.
- Region: Wählen Sie die Region, die Ihren Nutzern am nächsten ist.
3. Konfiguriere die Static Web App
- Grundlagen:
- Abonnement: Wähle dein Azure-Abonnement aus.
- Ressourcengruppe: Erstelle eine neue Ressourcengruppe oder verwende eine bestehende.
- Name: Gib deiner statischen Web-App einen Namen.
- Region: Wähle die Region, die deinen Nutzern am nächsten liegt.
- #### Bereitstellungsdetails:
- Quelle: Wählen Sie „GitHub“.
- GitHub-Konto: Autorisieren Sie Azure, auf Ihr GitHub-Konto zuzugreifen.
- Organisation: Wählen Sie Ihre GitHub-Organisation aus.
- Repository: Wählen Sie das Repository, das Ihre statische Web-App enthält.
- Branch: Wählen Sie den Branch aus, den Sie bereitstellen möchten.
- #### Bereitstellungsdetails:
- Quelle: Wähle „GitHub“.
- GitHub-Konto: Autorisiere Azure, auf dein GitHub-Konto zuzugreifen.
- Organisation: Wähle deine GitHub-Organisation aus.
- Repository: Wähle das Repository, das deine statische Web-App enthält.
- Branch: Wähle den Branch, von dem aus du bereitstellen möchtest.
- #### Build-Details:
- Build-Voreinstellungen: Wählen Sie das Framework, mit dem Ihre App erstellt wurde (z. B. React, Angular, Vue usw.).
- App-Standort: Geben Sie den Ordner an, der Ihren App-Code enthält (z. B. /, wenn es sich im Stammverzeichnis befindet).
- API-Standort: Wenn Sie eine API haben, geben Sie deren Standort an (optional).
- Ausgabeort: Geben Sie den Ordner an, in dem die Build-Ausgabe generiert wird (z. B. build oder dist).
- #### Build-Details:
- Build-Voreinstellungen: Wähle das Framework, mit dem deine App erstellt wurde (z. B. React, Angular, Vue usw.).
- App-Standort: Gib den Ordner an, der deinen App-Code enthält (z. B. /, wenn er sich im Root-Verzeichnis befindet).
- API-Standort: Falls du eine API hast, gib deren Standort an (optional).
- Ausgabe-Standort: Gib den Ordner an, in dem die Build-Ausgabe generiert wird (z. B. build oder dist).
4. Überprüfen und Erstellen
Überprüfen Sie Ihre Einstellungen und klicken Sie auf „Erstellen“. Azure wird die erforderlichen Ressourcen einrichten und einen GitHub Actions-Workflow in Ihrem Repository erstellen.
4. Überprüfen und Erstellen
Überprüfe deine Einstellungen und klicke auf „Erstellen“. Azure wird die erforderlichen Ressourcen einrichten und einen GitHub Actions-Workflow in deinem Repository erstellen.
5. GitHub Actions Workflow
Azure wird automatisch eine GitHub Actions-Workflow-Datei in Ihrem Repository erstellen (.github/workflows/azure-static-web-apps-<name>.yml). Dieser Workflow wird den Build- und Bereitstellungsprozess verwalten.
5. GitHub Actions-Workflow
Azure erstellt automatisch eine GitHub Actions-Workflow-Datei in deinem Repository (.github/workflows/azure-static-web-apps-<name>.yml). Dieser Workflow übernimmt den Build- und Bereitstellungsprozess.
6. Überwachen der Bereitstellung
Gehen Sie zum Tab „Aktionen“ in Ihrem GitHub-Repository.
Sie sollten einen laufenden Workflow sehen. Dieser Workflow wird Ihre statische Web-App in Azure erstellen und bereitstellen.
Sobald der Workflow abgeschlossen ist, wird Ihre App unter der angegebenen Azure-URL live sein.
6. Überwache die Bereitstellung
Gehe zum Tab „Actions“ in deinem GitHub-Repository.
Du solltest sehen, dass ein Workflow ausgeführt wird. Dieser Workflow wird deine statische Web-App auf Azure erstellen und bereitstellen.
Sobald der Workflow abgeschlossen ist, ist deine App unter der bereitgestellten Azure-URL live.
### Beispiel-Workflow-Datei
### Beispiel für eine Workflow-Datei
Hier ist ein Beispiel dafür, wie die GitHub Actions-Workflow-Datei aussehen könnte:
name: Azure Static Web Apps CI/CD
Hier ist ein Beispiel, wie die GitHub Actions-Workflow-Datei aussehen könnte:
name: Azure Static Web Apps CI/CD
```
on:
push:
@ -119,9 +129,9 @@ jobs:
output_location: "dist" #Built app content directory - optional
```
### Zusätzliche Ressourcen
- [Dokumentation zu Azure Static Web Apps](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [Dokumentation zu GitHub Actions](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
### Zusätzliche Ressourcen
- [Azure Static Web Apps Dokumentation](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [GitHub Actions Dokumentation](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

31
translations/de/lessons/0-course-setup/for-teachers.md
View File

@ -1,26 +1,35 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a094ef9927883de1cfcee51dbd143381",
"translation_date": "2025-08-24T09:44:12+00:00",
"source_file": "lessons/0-course-setup/for-teachers.md",
"language_code": "de"
}
-->
# Für Lehrkräfte
Möchten Sie diesen Lehrplan in Ihrem Unterricht verwenden? Fühlen Sie sich frei dazu!
Möchten Sie dieses Curriculum in Ihrem Unterricht verwenden? Fühlen Sie sich frei, es zu nutzen!
Tatsächlich können Sie ihn direkt in GitHub verwenden, indem Sie GitHub Classroom nutzen.
Tatsächlich können Sie es direkt auf GitHub verwenden, indem Sie GitHub Classroom nutzen.
Dazu müssen Sie dieses Repo forken. Sie müssen für jede Lektion ein eigenes Repo erstellen, also müssen Sie jeden Ordner in ein separates Repo extrahieren. Auf diese Weise kann [GitHub Classroom](https://classroom.github.com/classrooms) jede Lektion separat erfassen.
Dazu müssen Sie dieses Repository forken. Sie müssen für jede Lektion ein eigenes Repository erstellen, indem Sie jeden Ordner in ein separates Repository extrahieren. Auf diese Weise kann [GitHub Classroom](https://classroom.github.com/classrooms) jede Lektion einzeln erfassen.
Diese [vollständigen Anweisungen](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) geben Ihnen eine Vorstellung davon, wie Sie Ihr Klassenzimmer einrichten können.
## Verwendung des Repos wie es ist
## Nutzung des Repos wie es ist
Wenn Sie dieses Repo so verwenden möchten, wie es derzeit ist, ohne GitHub Classroom zu nutzen, ist das ebenfalls möglich. Sie müssten mit Ihren Schülern kommunizieren, welche Lektion sie gemeinsam durcharbeiten sollen.
Wenn Sie dieses Repository in seiner aktuellen Form verwenden möchten, ohne GitHub Classroom zu nutzen, ist das ebenfalls möglich. Sie müssten Ihren Schülern mitteilen, welche Lektion Sie gemeinsam durcharbeiten möchten.
In einem Online-Format (Zoom, Teams oder ähnliches) könnten Sie Breakout-Räume für die Quizze bilden und die Schüler betreuen, um ihnen beim Lernen zu helfen. Dann laden Sie die Schüler ein, die Quizze zu machen und ihre Antworten zu einem bestimmten Zeitpunkt als 'Issues' einzureichen. Sie könnten dasselbe mit Aufgaben machen, wenn Sie möchten, dass die Schüler offen und kollaborativ arbeiten.
In einem Online-Format (Zoom, Teams oder andere) könnten Sie Breakout-Räume für die Quizfragen einrichten und die Schüler unterstützen, damit sie bereit sind zu lernen. Anschließend können Sie die Schüler einladen, die Quizfragen zu bearbeiten und ihre Antworten zu einem bestimmten Zeitpunkt als 'Issues' einzureichen. Dasselbe könnten Sie mit Aufgaben machen, wenn Sie möchten, dass die Schüler offen und kollaborativ arbeiten.
Wenn Sie ein privateres Format bevorzugen, bitten Sie Ihre Schüler, den Lehrplan lektion für lektion in ihre eigenen GitHub-Repos als private Repos zu forken und Ihnen Zugang zu gewähren. Dann können sie Quizze und Aufgaben privat abschließen und diese über Issues in Ihrem Klassenrepo einreichen.
Wenn Sie ein privateres Format bevorzugen, bitten Sie Ihre Schüler, das Curriculum Lektion für Lektion in ihre eigenen privaten GitHub-Repositories zu forken und Ihnen Zugriff zu gewähren. So können sie Quizfragen und Aufgaben privat bearbeiten und diese über Issues in Ihrem Klassen-Repository einreichen.
Es gibt viele Möglichkeiten, dies in einem Online-Klassenraumformat zu gestalten. Bitte lassen Sie uns wissen, was für Sie am besten funktioniert!
Es gibt viele Möglichkeiten, dies in einem Online-Klassenzimmer-Format umzusetzen. Lassen Sie uns wissen, was für Sie am besten funktioniert!
## Bitte teilen Sie uns Ihre Gedanken mit
## Bitte teilen Sie uns Ihre Meinung mit
Wir möchten, dass dieser Lehrplan für Sie und Ihre Schüler funktioniert. Bitte geben Sie uns Feedback in den Diskussionsforen!
Wir möchten, dass dieses Curriculum für Sie und Ihre Schüler funktioniert. Bitte geben Sie uns Feedback in den Diskussionsforen!
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung resultieren.
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.

59
translations/de/lessons/0-course-setup/how-to-run.md
View File

@ -1,12 +1,21 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7df19702b8d2d3f7c4238c51bec2c8fc",
"translation_date": "2025-08-24T09:43:53+00:00",
"source_file": "lessons/0-course-setup/how-to-run.md",
"language_code": "de"
}
-->
# So führen Sie den Code aus
Dieser Lehrplan enthält viele ausführbare Beispiele und Laborübungen, die Sie ausführen möchten. Um dies zu tun, benötigen Sie die Möglichkeit, Python-Code in Jupyter-Notebooks auszuführen, die Teil dieses Lehrplans sind. Sie haben mehrere Optionen, um den Code auszuführen:
Dieses Curriculum enthält viele ausführbare Beispiele und Übungen, die Sie ausprobieren möchten. Um dies zu tun, benötigen Sie die Möglichkeit, Python-Code in den Jupyter-Notebooks auszuführen, die Teil dieses Curriculums sind. Es gibt mehrere Möglichkeiten, den Code auszuführen:
## Lokal auf Ihrem Computer ausführen
Um den Code lokal auf Ihrem Computer auszuführen, müssen Sie eine Version von Python installiert haben. Ich empfehle persönlich die Installation von **[miniconda](https://conda.io/en/latest/miniconda.html)** - es handelt sich um eine recht leichte Installation, die den `conda` Paketmanager für verschiedene Python **virtuelle Umgebungen** unterstützt.
Um den Code lokal auf Ihrem Computer auszuführen, benötigen Sie eine installierte Python-Version. Ich empfehle persönlich die Installation von **[miniconda](https://conda.io/en/latest/miniconda.html)** – eine schlanke Installation, die den `conda`-Paketmanager für verschiedene Python-**virtuelle Umgebungen** unterstützt.
Nachdem Sie miniconda installiert haben, müssen Sie das Repository klonen und eine virtuelle Umgebung erstellen, die für diesen Kurs verwendet wird:
Nachdem Sie Miniconda installiert haben, müssen Sie das Repository klonen und eine virtuelle Umgebung für diesen Kurs erstellen:
```bash
git clone http://github.com/microsoft/ai-for-beginners
@ -17,51 +26,51 @@ conda activate ai4beg
### Verwendung von Visual Studio Code mit Python-Erweiterung
Wahrscheinlich ist der beste Weg, den Lehrplan zu nutzen, 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) zu öffnen.
Die wahrscheinlich beste Möglichkeit, das Curriculum zu nutzen, besteht darin, 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) zu öffnen.
> **Hinweis**: Sobald Sie das Verzeichnis in VS Code klonen und öffnen, wird Ihnen automatisch vorgeschlagen, Python-Erweiterungen zu installieren. Sie müssen auch miniconda installieren, wie oben beschrieben.
> **Hinweis**: Sobald Sie das Verzeichnis in VS Code klonen und öffnen, wird Ihnen automatisch vorgeschlagen, die Python-Erweiterungen zu installieren. Sie müssen auch Miniconda wie oben beschrieben installieren.
> **Hinweis**: Wenn VS Code Ihnen vorschlägt, das Repository im Container erneut zu öffnen, müssen Sie dies ablehnen, um die lokale Python-Installation zu verwenden.
> **Hinweis**: Wenn VS Code Ihnen vorschlägt, das Repository in einem Container zu öffnen, sollten Sie dies ablehnen, um die lokale Python-Installation zu verwenden.
### Verwendung von Jupyter im Browser
Sie können auch die Jupyter-Umgebung direkt über den Browser auf Ihrem eigenen Computer verwenden. Tatsächlich bieten sowohl klassisches Jupyter als auch Jupyter Hub eine recht bequeme Entwicklungsumgebung mit Autovervollständigung, Code-Hervorhebung usw.
Sie können die Jupyter-Umgebung auch direkt im Browser auf Ihrem eigenen Computer nutzen. Tatsächlich bieten sowohl das klassische Jupyter als auch Jupyter Hub eine recht komfortable Entwicklungsumgebung mit Autovervollständigung, Syntaxhervorhebung usw.
Um Jupyter lokal zu starten, gehen Sie in das Verzeichnis des Kurses und führen Sie aus:
```bash
jupyter notebook
```
oder
```
oder
```bash
jupyterhub
```
Sie können dann zu einem der `.ipynb` files, open them and start working.
```
Anschließend können Sie zu einer der `.ipynb`-Dateien navigieren, diese öffnen und mit der Arbeit beginnen.
### Running in container
### Ausführung in einem Container
One alternative to Python installation would be to run the code in container. Since our repository contains special `.devcontainer`-Ordner navigieren, der Anweisungen gibt, wie ein Container für dieses Repo erstellt wird. VS Code würde Ihnen anbieten, den Code im Container erneut zu öffnen. Dies erfordert die Installation von Docker und wäre auch komplexer, daher empfehlen wir dies erfahrenen Benutzern.
Eine Alternative zur Python-Installation besteht darin, den Code in einem Container auszuführen. Da unser Repository einen speziellen `.devcontainer`-Ordner enthält, der Anweisungen zum Erstellen eines Containers für dieses Repository bereitstellt, wird Ihnen VS Code anbieten, den Code in einem Container zu öffnen. Dies erfordert die Installation von Docker und ist auch etwas komplexer, daher empfehlen wir dies eher erfahrenen Nutzern.
## Ausführen in der Cloud
## Ausführung in der Cloud
Wenn Sie Python nicht lokal installieren möchten und Zugang zu einigen Cloud-Ressourcen haben, wäre eine gute Alternative, 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 Cloud-Ressourcen haben, ist eine gute Alternative, den Code in der Cloud auszuführen. Es gibt mehrere Möglichkeiten, dies zu tun:
* Verwenden von **[GitHub Codespaces](https://github.com/features/codespaces)**, einem virtuellen Umfeld, das für Sie auf GitHub erstellt wird und über die VS Code-Browseroberfläche zugänglich ist. Wenn Sie Zugriff auf Codespaces haben, können Sie einfach auf die Schaltfläche **Code** im Repo klicken, einen Codespace starten und im Handumdrehen loslegen.
* Verwenden von **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) ist eine kostenlose Rechenressource, die in der Cloud für Menschen wie Sie bereitgestellt wird, um etwas Code auf GitHub auszuprobieren. Es gibt eine Schaltfläche auf der Startseite, um das Repository in Binder zu öffnen - dies sollte Sie schnell zur Binder-Website bringen, die den zugrunde liegenden Container erstellt und die Jupyter-Weboberfläche nahtlos für Sie startet.
* Verwendung von **[GitHub Codespaces](https://github.com/features/codespaces)**, einer virtuellen Umgebung, die für Sie auf GitHub erstellt wird und über die Browseroberfläche von VS Code zugänglich ist. Wenn Sie Zugriff auf Codespaces haben, können Sie einfach auf die Schaltfläche **Code** im Repository 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, mit denen Sie Code auf GitHub testen können. Auf der Startseite gibt es eine Schaltfläche, um das Repository in Binder zu öffnen – dies sollte Sie schnell zur Binder-Seite führen, die den zugrunde liegenden Container erstellt und nahtlos die Jupyter-Weboberfläche startet.
> **Hinweis**: Um Missbrauch zu verhindern, 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 abruft. Möglicherweise müssen Sie einige Umgehungen finden. Außerdem sind die von Binder bereitgestellten Rechenressourcen ziemlich grundlegend, sodass das Training langsam sein wird, insbesondere in späteren, komplexeren Lektionen.
> **Hinweis**: Um Missbrauch zu verhindern, hat Binder den Zugriff auf einige Webressourcen blockiert. Dies kann dazu führen, dass bestimmter Code, der Modelle und/oder Datensätze aus dem öffentlichen Internet abruft, nicht funktioniert. Sie müssen möglicherweise Workarounds finden. Außerdem sind die von Binder bereitgestellten Rechenressourcen recht begrenzt, sodass das Training, insbesondere in späteren komplexeren Lektionen, langsam sein wird.
## Ausführen in der Cloud mit GPU
## Ausführung in der Cloud mit GPU
Einige der späteren Lektionen in diesem Lehrplan würden erheblich von GPU-Unterstützung profitieren, da das Training sonst schmerzhaft langsam sein wird. Es gibt einige Optionen, die Sie verfolgen können, insbesondere 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 Curriculum profitieren stark von GPU-Unterstützung, da das Training sonst extrem langsam wäre. Es gibt einige Optionen, die Sie nutzen können, insbesondere 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 damit. Sie können das Repo dann direkt auf der Maschine klonen und mit dem Lernen beginnen. NC-Serie VMs haben GPU-Unterstützung.
* 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 das Repository dann direkt auf die Maschine klonen und mit dem Lernen beginnen. NC-Serien-VMs unterstützen GPUs.
> **Hinweis**: Einige Abonnements, einschließlich Azure for Students, bieten nicht standardmäßig GPU-Unterstützung. Möglicherweise müssen Sie zusätzliche GPU-Kerne über eine technische Supportanfrage anfordern.
> **Hinweis**: Einige Abonnements, einschließlich Azure for Students, bieten standardmäßig keine 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 dann die Notebook-Funktion dort. [Dieses Video](https://azure-for-academics.github.io/quickstart/azureml-papers/) zeigt, wie man ein Repository in ein Azure ML-Notebook klont und es zu verwenden beginnt.
* Erstellen Sie einen [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) und nutzen Sie 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 es verwenden können.
Sie können auch Google Colab verwenden, das mit einer gewissen kostenlosen GPU-Unterstützung kommt, und dort Jupyter-Notebooks hochladen, um sie nacheinander auszuführen.
Sie können auch Google Colab verwenden, das einige kostenlose GPU-Ressourcen bietet, und Jupyter-Notebooks hochladen, um sie dort Schritt für Schritt auszuführen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

39
translations/de/lessons/0-course-setup/setup.md
View File

@ -1,45 +1,54 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c4c545eb30765a49469ced84cfb4379f",
"translation_date": "2025-08-24T09:44:20+00:00",
"source_file": "lessons/0-course-setup/setup.md",
"language_code": "de"
}
-->
# Einstieg in dieses Curriculum
## Bist du ein Student?
Beginne mit den folgenden Ressourcen:
* [Student Hub-Seite](https://docs.microsoft.com/learn/student-hub?WT.mc_id=academic-77998-cacaste) Auf dieser Seite findest du Ressourcen für Anfänger, Studentensets und sogar Möglichkeiten, einen kostenlosen Zertifikatsgutschein zu erhalten. Dies ist eine Seite, die du dir merken und von Zeit zu Zeit überprüfen solltest, da wir die Inhalte mindestens monatlich wechseln.
* [Microsoft Student Learn Botschafter](https://studentambassadors.microsoft.com?WT.mc_id=academic-77998-cacaste) Trete einer globalen Gemeinschaft von Studentbotschaftern bei, dies könnte dein Zugang zu Microsoft sein.
* [Student Hub-Seite](https://docs.microsoft.com/learn/student-hub?WT.mc_id=academic-77998-cacaste) Auf dieser Seite findest du Ressourcen für Anfänger, Student Packs und sogar Möglichkeiten, einen kostenlosen Zertifikatsgutschein zu erhalten. Diese Seite solltest du dir unbedingt als Lesezeichen speichern und regelmäßig besuchen, da wir den Inhalt mindestens monatlich aktualisieren.
* [Microsoft Student Learn Ambassadors](https://studentambassadors.microsoft.com?WT.mc_id=academic-77998-cacaste) Werde Teil einer globalen Gemeinschaft von Studentenbotschaftern – dies könnte dein Einstieg bei Microsoft sein.
**Studierende**, es gibt mehrere Möglichkeiten, das Curriculum zu nutzen. Zunächst kannst du den Text einfach lesen und den Code direkt auf GitHub durchsehen. Wenn du den Code in einem der Notebooks ausführen möchtest - [lies unsere Anweisungen](./etc/how-to-run.md), und finde weitere Ratschläge, wie du es [in diesem Blogbeitrag](https://soshnikov.com/education/how-to-execute-notebooks-from-github/) tun kannst.
**Studenten**, es gibt mehrere Möglichkeiten, das Curriculum zu nutzen. Zunächst kannst du einfach den Text lesen und den Code direkt auf GitHub durchsehen. Wenn du den Code in einem der Notebooks ausführen möchtest, [lies unsere Anweisungen](./etc/how-to-run.md) und finde weitere Tipps dazu [in diesem Blogbeitrag](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
> **Hinweis**: [Anweisungen zum Ausführen des Codes in diesem Curriculum](/how-to-run.md)
> **Hinweis**: [Anweisungen, wie man den Code in diesem Curriculum ausführt](./how-to-run.md)
## Selbststudium
Wenn du jedoch den Kurs als Selbststudienprojekt durchführen möchtest, empfehlen wir dir, das gesamte Repository in dein eigenes GitHub-Konto zu fork und die Übungen selbstständig oder in einer Gruppe abzuschließen:
Falls du den Kurs als Selbststudienprojekt absolvieren möchtest, empfehlen wir dir, das gesamte Repository in deinen eigenen GitHub-Account zu forken und die Übungen eigenständig oder in einer Gruppe zu bearbeiten:
* Beginne mit einem Quiz vor der Vorlesung.
* Lies den Einführungstext zur Vorlesung.
* Wenn die Vorlesung zusätzliche Notebooks enthält, gehe diese durch, indem du den Code liest und ausführst. Wenn sowohl TensorFlow- als auch PyTorch-Notebooks bereitgestellt werden, kannst du dich auf eines von ihnen konzentrieren - wähle dein bevorzugtes Framework.
* Notebooks enthalten oft einige Herausforderungen, die es erfordern, den Code ein wenig anzupassen, um zu experimentieren.
* Falls die Vorlesung zusätzliche Notebooks enthält, arbeite diese durch, indem du den Code liest und ausführst. Wenn sowohl TensorFlow- als auch PyTorch-Notebooks bereitgestellt werden, kannst du dich auf eines davon konzentrieren – wähle dein bevorzugtes Framework.
* Notebooks enthalten oft Herausforderungen, bei denen du den Code ein wenig anpassen musst, um zu experimentieren.
* Mache das Quiz nach der Vorlesung.
* Wenn ein Labor an das Modul angehängt ist - schließe die Aufgabe ab.
* Falls ein Labor mit dem Modul verbunden ist, bearbeite die Aufgabe.
* Besuche das [Diskussionsforum](https://github.com/microsoft/AI-For-Beginners/discussions), um "laut zu lernen".
> Für weiterführende Studien empfehlen wir, diese [Microsoft Learn](https://docs.microsoft.com/en-us/users/dmitrysoshnikov-9132/collections/31zgizg2p418yo/?WT.mc_id=academic-77998-cacaste) Module und Lernpfade zu verfolgen.
> Für weiterführendes Lernen empfehlen wir, diese [Microsoft Learn](https://docs.microsoft.com/en-us/users/dmitrysoshnikov-9132/collections/31zgizg2p418yo/?WT.mc_id=academic-77998-cacaste)-Module und Lernpfade zu verfolgen.
**Lehrkräfte**, wir haben [einige Vorschläge](/for-teachers.md) zur Nutzung dieses Curriculums aufgenommen.
**Lehrer**, wir haben [einige Vorschläge](/for-teachers.md) aufgenommen, wie dieses Curriculum genutzt werden kann.
---
## Pädagogik
Wir haben beim Aufbau dieses Curriculums zwei pädagogische Grundsätze gewählt: sicherzustellen, dass es praxisorientiert **projektbasiert** ist und dass es **häufige Quizze** enthält.
Wir haben zwei pädagogische Grundsätze gewählt, während wir dieses Curriculum erstellt haben: sicherzustellen, dass es **projektbasiert** und **hands-on** ist und dass es **häufige Quizfragen** enthält.
Durch die Ausrichtung der Inhalte auf Projekte wird der Prozess für die Studierenden ansprechender gestaltet und die Beibehaltung von Konzepten wird gefördert. Darüber hinaus setzt ein niedrigschwelliges Quiz vor einer Klasse die Absicht des Studierenden, ein Thema zu lernen, während ein zweites Quiz nach der Klasse die weitere Beibehaltung sichert. Dieses Curriculum wurde so gestaltet, dass es flexibel und unterhaltsam ist und ganz oder teilweise absolviert werden kann. Die Projekte beginnen klein und werden bis zum Ende des 12-wöchigen Zyklus zunehmend komplexer.
Indem wir sicherstellen, dass der Inhalt auf Projekte abgestimmt ist, wird der Lernprozess für Studenten ansprechender und das Verständnis der Konzepte wird verbessert. Außerdem setzt ein niedrigschwelliges Quiz vor einer Klasse die Absicht des Studenten, ein Thema zu lernen, während ein zweites Quiz nach der Klasse das Verständnis weiter festigt. Dieses Curriculum wurde so gestaltet, dass es flexibel und unterhaltsam ist und entweder vollständig oder teilweise absolviert werden kann. Die Projekte beginnen klein und werden im Laufe des 12-Wochen-Zyklus zunehmend komplexer.
> **Eine Anmerkung zu Quizzen**: Alle Quizze sind [in dieser App](https://red-field-0a6ddfd03.1.azurestaticapps.net/) enthalten, insgesamt 50 Quizze mit jeweils drei Fragen. Sie sind aus den Lektionen heraus verlinkt, aber die Quiz-App kann lokal ausgeführt werden; folge den Anweisungen im `etc/quiz-app`-Ordner.
> **Ein Hinweis zu den Quizfragen**: Alle Quizfragen sind [in dieser App](https://red-field-0a6ddfd03.1.azurestaticapps.net/) enthalten, insgesamt 50 Quizfragen mit jeweils drei Fragen. Sie sind in den Lektionen verlinkt, aber die Quiz-App kann lokal ausgeführt werden; folge den Anweisungen im `etc/quiz-app`-Ordner.
## Offline-Zugriff
Du kannst diese Dokumentation offline ausführen, indem du [Docsify](https://docsify.js.org/#/) verwendest. Forke dieses Repository, [installiere Docsify](https://docsify.js.org/#/quickstart) auf deinem lokalen Rechner und tippe dann im `etc/docsify`-Ordner dieses Repositories `docsify serve` ein. Die Website wird auf Port 3000 auf deinem localhost bereitgestellt: `localhost:3000`. Eine PDF des Curriculums ist [unter diesem Link](../../../../../../etc/pdf/readme.pdf) verfügbar.
Du kannst diese Dokumentation offline nutzen, indem du [Docsify](https://docsify.js.org/#/) verwendest. Forke dieses Repository, [installiere Docsify](https://docsify.js.org/#/quickstart) auf deinem lokalen Rechner und gib dann im Root-Ordner dieses Repositories `docsify serve` ein. Die Website wird auf Port 3000 auf deinem localhost bereitgestellt: `localhost:3000`. Eine PDF-Version des Curriculums ist [unter diesem Link](../../../../../../../../../etc/pdf/readme.pdf) verfügbar.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung resultieren.
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.

58
translations/de/lessons/1-Intro/README.md
View File

@ -1,38 +1,66 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5d1cbc67a9690adb5b33adf297794087",
"translation_date": "2025-08-24T09:33:15+00:00",
"source_file": "lessons/1-Intro/README.md",
"language_code": "de"
}
-->
> Bild von [Dmitry Soshnikov](http://soshnikov.com)
Mit der Zeit wurden Rechenressourcen günstiger, und es standen mehr Daten zur Verfügung, sodass Ansätze mit neuronalen Netzwerken in vielen Bereichen, wie z. B. der Computer-Vision oder der Spracherkennung, große Fortschritte zeigten und mit Menschen konkurrieren konnten. In den letzten zehn Jahren wurde der Begriff Künstliche Intelligenz (KI) größtenteils als Synonym für neuronale Netzwerke verwendet, da die meisten Erfolge der KI, von denen wir hören, auf diesen basieren.
Wir können beobachten, wie sich die Ansätze verändert haben, zum Beispiel bei der Entwicklung eines Schachprogramms:
* Frühe Schachprogramme basierten auf Suchalgorithmen – ein Programm versuchte explizit, mögliche Züge eines Gegners für eine bestimmte Anzahl von Zügen im Voraus abzuschätzen und wählte den optimalen Zug basierend auf der besten Position, die in wenigen Zügen erreicht werden konnte. Dies führte zur Entwicklung des sogenannten [Alpha-Beta-Suchalgorithmus](https://de.wikipedia.org/wiki/Alpha-Beta-Suche).
* Suchstrategien funktionieren gut gegen Ende des Spiels, wenn der Suchraum durch eine geringe Anzahl möglicher Züge begrenzt ist. Zu Beginn des Spiels ist der Suchraum jedoch riesig, und der Algorithmus kann durch das Lernen aus bestehenden Partien zwischen menschlichen Spielern verbessert werden. Spätere Experimente nutzten das sogenannte [fallbasierte Schließen](https://de.wikipedia.org/wiki/Fallbasiertes_Schlie%C3%9Fen), bei dem das Programm in der Wissensdatenbank nach Fällen suchte, die der aktuellen Spielsituation sehr ähnlich sind.
* Moderne Programme, die menschliche Spieler besiegen, basieren auf neuronalen Netzwerken und [Reinforcement Learning](https://de.wikipedia.org/wiki/Best%C3%A4rkendes_Lernen), bei dem die Programme allein durch das Spielen gegen sich selbst über einen langen Zeitraum lernen und aus ihren eigenen Fehlern lernen – ähnlich wie Menschen, wenn sie Schach spielen lernen. Ein Computerprogramm kann jedoch viel mehr Partien in viel kürzerer Zeit spielen und somit viel schneller lernen.
✅ Recherchieren Sie ein wenig über andere Spiele, die von KI gespielt wurden.
Ähnlich können wir sehen, wie sich der Ansatz zur Entwicklung von „sprechenden Programmen“ (die den Turing-Test bestehen könnten) verändert hat:
* Frühe Programme dieser Art, wie [Eliza](https://de.wikipedia.org/wiki/ELIZA), basierten auf sehr einfachen grammatikalischen Regeln und der Umformulierung des Eingabesatzes in eine Frage.
* Moderne Assistenten wie Cortana, Siri oder Google Assistant sind hybride Systeme, die neuronale Netzwerke nutzen, um Sprache in Text umzuwandeln und unsere Absicht zu erkennen, und dann einige logische Schlussfolgerungen oder explizite Algorithmen anwenden, um die erforderlichen Aktionen auszuführen.
* In der Zukunft können wir erwarten, dass ein vollständig neuronales Modell den Dialog eigenständig bewältigt. Die neueren neuronalen Netzwerke der GPT- und [Turing-NLG](https://turing.microsoft.com/)-Familie zeigen in diesem Bereich große Erfolge.
> Bild von Dmitry Soshnikov, [Foto](https://unsplash.com/photos/r8LmVbUKgns) von [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
## Aktuelle AI-Forschung
## Aktuelle KI-Forschung
Das enorme Wachstum der Forschung zu neuronalen Netzwerken begann etwa 2010, als große öffentliche Datensätze verfügbar wurden. Eine riesige Sammlung von Bildern namens [ImageNet](https://en.wikipedia.org/wiki/ImageNet), die etwa 14 Millionen annotierte Bilder enthält, gab den Anstoß zur [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
Das enorme Wachstum der Forschung zu neuronalen Netzwerken begann um 2010, als große öffentliche Datensätze verfügbar wurden. Eine riesige Sammlung von Bildern namens [ImageNet](https://en.wikipedia.org/wiki/ImageNet), die etwa 14 Millionen annotierte Bilder enthält, führte zur [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
![ILSVRC Genauigkeit](../../../../lessons/1-Intro/images/ilsvrc.gif)
> Bild von [Dmitry Soshnikov](http://soshnikov.com)
Im Jahr 2012 wurden [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) erstmals in der Bildklassifizierung eingesetzt, was zu einem signifikanten Rückgang der Klassifizierungsfehler führte (von fast 30% auf 16,4%). Im Jahr 2015 erreichte die ResNet-Architektur von Microsoft Research [eine menschenähnliche Genauigkeit](https://doi.org/10.1109/ICCV.2015.123).
Seitdem haben Neuronale Netzwerke in vielen Aufgaben ein sehr erfolgreiches Verhalten gezeigt:
Im Jahr 2012 wurden [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) erstmals für die Bildklassifikation eingesetzt, was zu einem signifikanten Rückgang der Klassifikationsfehler führte (von fast 30 % auf 16,4 %). Im Jahr 2015 erreichte die ResNet-Architektur von Microsoft Research [menschliche Genauigkeit](https://doi.org/10.1109/ICCV.2015.123).
Seitdem haben neuronale Netzwerke in vielen Aufgaben sehr erfolgreiche Ergebnisse gezeigt:
---
Jahr | Erreichte Menschenparität
Jahr | Menschliche Gleichwertigkeit erreicht
-----|--------
2015 | [Bildklassifizierung](https://doi.org/10.1109/ICCV.2015.123)
2016 | [Gesprächs-Spracherkennung](https://arxiv.org/abs/1610.05256)
2018 | [Automatische maschinelle Übersetzung](https://arxiv.org/abs/1803.05567) (Chinesisch-zu-Englisch)
2020 | [Bildunterschriftenerstellung](https://arxiv.org/abs/2009.13682)
2015 | [Bildklassifikation](https://doi.org/10.1109/ICCV.2015.123)
2016 | [Gesprächsbasierte Spracherkennung](https://arxiv.org/abs/1610.05256)
2018 | [Automatische maschinelle Übersetzung](https://arxiv.org/abs/1803.05567) (Chinesisch-Englisch)
2020 | [Bildbeschreibung](https://arxiv.org/abs/2009.13682)
In den letzten Jahren haben wir enorme Erfolge mit großen Sprachmodellen wie BERT und GPT-3 erlebt. Dies geschah hauptsächlich aufgrund der Tatsache, dass eine große Menge an allgemeinen Textdaten verfügbar ist, die es uns ermöglicht, Modelle zu trainieren, um die Struktur und Bedeutung von Texten zu erfassen, sie auf allgemeinen Textsammlungen vorzutrainen und diese Modelle dann für spezifischere Aufgaben zu spezialisieren. Wir werden später in diesem Kurs mehr über [Natural Language Processing](../5-NLP/README.md) lernen.
In den letzten Jahren haben wir große Erfolge mit großen Sprachmodellen wie BERT und GPT-3 erlebt. Dies geschah vor allem aufgrund der Tatsache, dass es eine große Menge an allgemeinen Textdaten gibt, die es uns ermöglichen, Modelle zu trainieren, um die Struktur und Bedeutung von Texten zu erfassen, sie auf allgemeinen Textsammlungen vorzutrainieren und diese Modelle dann für spezifischere Aufgaben zu spezialisieren. Wir werden später in diesem Kurs mehr über [Natural Language Processing](../5-NLP/README.md) lernen.
## 🚀 Herausforderung
Machen Sie eine Internettour, um zu bestimmen, wo Ihrer Meinung nach KI am effektivsten eingesetzt wird. Ist es in einer Karten-App, einem Spracherkennungsdienst oder einem Videospiel? Recherchieren Sie, wie das System aufgebaut wurde.
Machen Sie eine Internetrecherche, um herauszufinden, wo KI Ihrer Meinung nach am effektivsten eingesetzt wird. Ist es in einer Karten-App, einem Sprach-zu-Text-Dienst oder einem Videospiel? Recherchieren Sie, wie das System aufgebaut wurde.
## [Nach der Vorlesung Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
## Überprüfung & Selbststudium
## Rückblick & Selbststudium
Überprüfen Sie die Geschichte von KI und ML, indem Sie [diese Lektion](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML) durchlesen. Nehmen Sie ein Element aus dem Sketchnote am Anfang dieser Lektion oder dieser hier und recherchieren Sie es eingehender, um den kulturellen Kontext zu verstehen, der seine Entwicklung beeinflusst hat.
Überblicken Sie die Geschichte der KI und des maschinellen Lernens, indem Sie [diese Lektion](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML) durchlesen. Nehmen Sie ein Element aus der Sketchnote am Anfang dieser oder jener Lektion und recherchieren Sie es genauer, um den kulturellen Kontext zu verstehen, der seine Entwicklung beeinflusst hat.
**Aufgabe**: [Game Jam](assignment.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

13
translations/de/lessons/1-Intro/assignment.md
View File

@ -1,6 +1,15 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "702dc1df5d0285dbe4d04bee982d183e",
"translation_date": "2025-08-24T09:33:36+00:00",
"source_file": "lessons/1-Intro/assignment.md",
"language_code": "de"
}
-->
# Game Jam
Spiele sind ein Bereich, der stark von den Entwicklungen in KI und ML beeinflusst wurde. In dieser Aufgabe schreiben Sie ein kurzes Papier über ein Spiel, das Ihnen gefällt und das von der Entwicklung der KI beeinflusst wurde. Es sollte ein ausreichend altes Spiel sein, das von verschiedenen Arten von Computerverarbeitungssystemen beeinflusst wurde. Ein gutes Beispiel sind Schach oder Go, aber schauen Sie sich auch Videospiele wie Pong oder Pac-Man an. Schreiben Sie einen Aufsatz, der die Vergangenheit, die Gegenwart und die zukünftige Rolle der KI im Spiel behandelt.
Spiele sind ein Bereich, der stark von Entwicklungen in KI und ML beeinflusst wurde. In dieser Aufgabe sollst du ein kurzes Essay über ein Spiel schreiben, das dir gefällt und das von der Entwicklung der KI beeinflusst wurde. Es sollte ein Spiel sein, das alt genug ist, um von verschiedenen Arten von Computersystemen beeinflusst worden zu sein. Ein gutes Beispiel ist Schach oder Go, aber schaue dir auch Videospiele wie Pong oder Pac-Man an. Schreibe ein Essay, das die Vergangenheit, Gegenwart und die Zukunft des Spiels im Hinblick auf KI diskutiert.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

217
translations/de/lessons/2-Symbolic/README.md
View File

@ -1,107 +1,114 @@
# Wissensdarstellung und Expertensysteme
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "98c5222ff9556b55223fed2337145e18",
"translation_date": "2025-08-24T09:42:56+00:00",
"source_file": "lessons/2-Symbolic/README.md",
"language_code": "de"
}
-->
# Wissensrepräsentation und Expertensysteme
![Zusammenfassung des Inhalts der symbolischen KI](../../../../translated_images/ai-symbolic.715a30cb610411a6964d2e2f23f24364cb338a07cb4844c1f97084d366e586c3.de.png)
![Zusammenfassung des Symbolischen KI-Inhalts](../../../../lessons/sketchnotes/ai-symbolic.png)
> Sketchnote von [Tomomi Imura](https://twitter.com/girlie_mac)
Die Suche nach künstlicher Intelligenz basiert auf dem Streben nach Wissen, um die Welt ähnlich wie Menschen zu verstehen. Aber wie geht man dabei vor?
Die Suche nach künstlicher Intelligenz basiert auf dem Streben nach Wissen, um die Welt ähnlich wie Menschen zu verstehen. Aber wie kann man das erreichen?
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/102)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/102)
In den frühen Tagen der KI war der Top-Down-Ansatz zur Schaffung intelligenter Systeme (der im vorherigen Kapitel besprochen wurde) populär. Die Idee war, das Wissen von Menschen in eine maschinenlesbare Form zu extrahieren und es dann zur automatischen Problemlösung zu verwenden. Dieser Ansatz basierte auf zwei großen Ideen:
In den frühen Tagen der KI war der Top-Down-Ansatz zur Erstellung intelligenter Systeme (im vorherigen Kapitel besprochen) beliebt. Die Idee war, das Wissen von Menschen in eine maschinenlesbare Form zu extrahieren und es dann zu nutzen, um Probleme automatisch zu lösen. Dieser Ansatz basierte auf zwei großen Ideen:
* Wissensdarstellung
* Wissensrepräsentation
* Schlussfolgerung
## Wissensdarstellung
## Wissensrepräsentation
Eines der wichtigen Konzepte in der symbolischen KI ist **Wissen**. Es ist wichtig, Wissen von *Information* oder *Daten* zu unterscheiden. Zum Beispiel kann man sagen, dass Bücher Wissen enthalten, weil man Bücher studieren und ein Experte werden kann. Was Bücher jedoch enthalten, wird tatsächlich als *Daten* bezeichnet, und durch das Lesen von Büchern und die Integration dieser Daten in unser Weltmodell wandeln wir diese Daten in Wissen um.
Eines der wichtigen Konzepte in der symbolischen KI ist **Wissen**. Es ist wichtig, Wissen von *Information* oder *Daten* zu unterscheiden. Zum Beispiel könnte man sagen, dass Bücher Wissen enthalten, weil man durch das Studium von Büchern ein Experte werden kann. Tatsächlich enthalten Bücher jedoch *Daten*, und durch das Lesen und Integrieren dieser Daten in unser Weltmodell wandeln wir diese Daten in Wissen um.
> ✅ **Wissen** ist etwas, das in unserem Kopf enthalten ist und unser Verständnis der Welt repräsentiert. Es wird durch einen aktiven **Lernprozess** erlangt, der die Informationen, die wir erhalten, in unser aktives Weltmodell integriert.
> ✅ **Wissen** ist etwas, das in unserem Kopf enthalten ist und unsere Vorstellung von der Welt repräsentiert. Es wird durch einen aktiven **Lernprozess** gewonnen, der die erhaltenen Informationen in unser aktives Weltmodell integriert.
Meistens definieren wir Wissen nicht streng, sondern stellen es in Beziehung zu anderen verwandten Konzepten mithilfe der [DIKW-Pyramide](https://en.wikipedia.org/wiki/DIKW_pyramid). Sie enthält die folgenden Konzepte:
Meistens definieren wir Wissen nicht streng, sondern ordnen es anderen verwandten Konzepten mithilfe der [DIKW-Pyramide](https://de.wikipedia.org/wiki/DIKW-Pyramide) zu. Sie enthält die folgenden Konzepte:
* **Daten** sind etwas, das in physischen Medien dargestellt wird, wie geschriebenem Text oder gesprochenen Worten. Daten existieren unabhängig von Menschen und können zwischen Personen ausgetauscht werden.
* **Information** ist, wie wir Daten in unserem Kopf interpretieren. Zum Beispiel, wenn wir das Wort *Computer* hören, haben wir ein gewisses Verständnis davon, was es ist.
* **Wissen** ist Information, die in unser Weltmodell integriert wird. Zum Beispiel, sobald wir lernen, was ein Computer ist, beginnen wir, einige Ideen darüber zu haben, wie er funktioniert, wie viel er kostet und wofür er verwendet werden kann. Dieses Netzwerk von miteinander verbundenen Konzepten bildet unser Wissen.
* **Weisheit** ist eine weitere Ebene unseres Verständnisses der Welt und repräsentiert *Meta-Wissen*, z.B. eine Vorstellung davon, wie und wann das Wissen verwendet werden sollte.
* **Daten** sind etwas, das in physischem Medium dargestellt wird, wie geschriebener Text oder gesprochene Worte. Daten existieren unabhängig von Menschen und können zwischen ihnen weitergegeben werden.
* **Information** ist, wie wir Daten in unserem Kopf interpretieren. Zum Beispiel haben wir eine Vorstellung davon, was ein *Computer* ist, wenn wir das Wort hören.
* **Wissen** ist Information, die in unser Weltmodell integriert wird. Sobald wir lernen, was ein Computer ist, entwickeln wir Ideen darüber, wie er funktioniert, wie viel er kostet und wofür er verwendet werden kann. Dieses Netzwerk von miteinander verbundenen Konzepten bildet unser Wissen.
* **Weisheit** ist eine weitere Ebene unseres Weltverständnisses und repräsentiert *Meta-Wissen*, z. B. eine Vorstellung davon, wie und wann Wissen verwendet werden sollte.
<img src="images/DIKW_Pyramid.png" width="30%"/>
*Bild [von Wikipedia](https://commons.wikimedia.org/w/index.php?curid=37705247), von Longlivetheux - Eigenes Werk, CC BY-SA 4.0*
*Bild [von Wikipedia](https://commons.wikimedia.org/w/index.php?curid=37705247), Von Longlivetheux - Eigenes Werk, CC BY-SA 4.0*
Das Problem der **Wissensrepräsentation** besteht also darin, eine effektive Möglichkeit zu finden, Wissen in Form von Daten in einem Computer darzustellen, um es automatisch nutzbar zu machen. Dies kann als Spektrum betrachtet werden:
Das Problem der **Wissensdarstellung** besteht also darin, eine effektive Möglichkeit zu finden, Wissen in einem Computer in Form von Daten darzustellen, um es automatisch nutzbar zu machen. Dies kann als Spektrum betrachtet werden:
![Spektrum der Wissensdarstellung](../../../../translated_images/knowledge-spectrum.b60df631852c0217e941485b79c9eee40ebd574f15f18609cec5758fcb384bf3.de.png)
![Spektrum der Wissensrepräsentation](../../../../lessons/2-Symbolic/images/knowledge-spectrum.png)
> Bild von [Dmitry Soshnikov](http://soshnikov.com)
* Links befinden sich sehr einfache Arten von Wissensdarstellungen, die effektiv von Computern genutzt werden können. Die einfachste ist algorithmisch, wenn Wissen durch ein Computerprogramm dargestellt wird. Dies ist jedoch nicht der beste Weg, Wissen darzustellen, da es nicht flexibel ist. Wissen in unserem Kopf ist oft nicht-algorithmisch.
* Rechts gibt es Darstellungen wie natürlichen Text. Es ist die mächtigste Form, kann jedoch nicht für automatisches Schließen verwendet werden.
* Links befinden sich sehr einfache Arten der Wissensrepräsentation, die effektiv von Computern genutzt werden können. Die einfachste ist die algorithmische Darstellung, bei der Wissen durch ein Computerprogramm repräsentiert wird. Dies ist jedoch keine flexible Methode, da Wissen in unserem Kopf oft nicht algorithmisch ist.
* Rechts befinden sich Darstellungen wie natürlicher Text. Diese sind am mächtigsten, können jedoch nicht für automatisches Schließen verwendet werden.
> ✅ Denke einen Moment darüber nach, wie du Wissen in deinem Kopf darstellst und es in Notizen umwandelst. Gibt es ein bestimmtes Format, das dir hilft, es zu behalten?
> ✅ Überlege kurz, wie du Wissen in deinem Kopf darstellst und in Notizen umwandelst. Gibt es ein bestimmtes Format, das dir hilft, es besser zu behalten?
## Klassifizierung von Computer-Wissensdarstellungen
## Klassifizierung von Wissensrepräsentationen in Computern
Wir können verschiedene Methoden zur Wissensdarstellung im Computer in die folgenden Kategorien einteilen:
Wir können verschiedene Methoden der Wissensrepräsentation in Computern in folgende Kategorien einteilen:
* **Netzwerkdarstellungen** basieren auf der Tatsache, dass wir ein Netzwerk von miteinander verbundenen Konzepten in unserem Kopf haben. Wir können versuchen, die gleichen Netzwerke als Graphen in einem Computer zu reproduzieren - ein sogenanntes **semantisches Netzwerk**.
* **Netzwerkrepräsentationen** basieren auf der Tatsache, dass wir ein Netzwerk miteinander verbundener Konzepte in unserem Kopf haben. Wir können versuchen, dieselben Netzwerke als Graphen in einem Computer nachzubilden - ein sogenanntes **semantisches Netzwerk**.
1. **Objekt-Attribut-Wert-Triple** oder **Attribut-Wert-Paare**. Da ein Graph in einem Computer als Liste von Knoten und Kanten dargestellt werden kann, können wir ein semantisches Netzwerk durch eine Liste von Tripeln darstellen, die Objekte, Attribute und Werte enthalten. Zum Beispiel bauen wir die folgenden Tripel über Programmiersprachen:
1. **Objekt-Attribut-Wert-Tripel** oder **Attribut-Wert-Paare**. Da ein Graph in einem Computer als Liste von Knoten und Kanten dargestellt werden kann, können wir ein semantisches Netzwerk durch eine Liste von Tripeln darstellen, die Objekte, Attribute und Werte enthalten. Zum Beispiel erstellen wir die folgenden Tripel über Programmiersprachen:
Objekt | Attribut | Wert
-------|-----------|------
Python | ist | Ungetypte-Sprache
-------|----------|-----
Python | ist | Untyped-Language
Python | erfunden-von | Guido van Rossum
Python | Block-Syntax | Einrückung
Ungetypte-Sprache | hat-keine | Typdefinitionen
Untyped-Language | hat nicht | Typdefinitionen
> ✅ Überlege, wie Tripel verwendet werden können, um andere Arten von Wissen darzustellen.
2. **Hierarchische Darstellungen** betonen die Tatsache, dass wir oft eine Hierarchie von Objekten in unserem Kopf erstellen. Zum Beispiel wissen wir, dass ein Kanarienvogel ein Vogel ist und alle Vögel Flügel haben. Wir haben auch eine Vorstellung davon, welche Farbe ein Kanarienvogel normalerweise hat und wie schnell er fliegen kann.
2. **Hierarchische Repräsentationen** betonen die Tatsache, dass wir oft eine Hierarchie von Objekten in unserem Kopf erstellen. Zum Beispiel wissen wir, dass ein Kanarienvogel ein Vogel ist und alle Vögel Flügel haben. Wir haben auch eine Vorstellung davon, welche Farbe ein Kanarienvogel normalerweise hat und wie schnell er fliegen kann.
- **Frame-Darstellung** basiert darauf, jedes Objekt oder jede Klasse von Objekten als **Frame** darzustellen, der **Slots** enthält. Slots haben mögliche Standardwerte, Wertbeschränkungen oder gespeicherte Prozeduren, die aufgerufen werden können, um den Wert eines Slots zu erhalten. Alle Frames bilden eine Hierarchie, die einer Objekt-Hierarchie in objektorientierten Programmiersprachen ähnelt.
- **Szenarien** sind spezielle Arten von Frames, die komplexe Situationen darstellen, die sich im Laufe der Zeit entfalten können.
- **Frame-Repräsentation** basiert darauf, jedes Objekt oder jede Klasse von Objekten als **Frame** darzustellen, der **Slots** enthält. Slots haben mögliche Standardwerte, Wertbeschränkungen oder gespeicherte Prozeduren, die aufgerufen werden können, um den Wert eines Slots zu erhalten. Alle Frames bilden eine Hierarchie, ähnlich einer Objekt-Hierarchie in objektorientierten Programmiersprachen.
- **Szenarien** sind spezielle Arten von Frames, die komplexe Situationen darstellen, die sich im Laufe der Zeit entwickeln können.
**Python**
Slot | Wert | Standardwert | Intervall |
-----|-------|---------------|----------|
-----|------|--------------|----------|
Name | Python | | |
Ist-Ein | Ungetypte-Sprache | | |
Variablenfall | | CamelCase | |
Ist-Ein | Untyped-Language | | |
Variable-Schreibweise | | CamelCase | |
Programmlänge | | | 5-5000 Zeilen |
Blocksyntax | Einrückung | | |
Block-Syntax | Einrückung | | |
3. **Prozedurale Darstellungen** basieren auf der Darstellung von Wissen durch eine Liste von Aktionen, die ausgeführt werden können, wenn eine bestimmte Bedingung eintritt.
- Produktionsregeln sind Wenn-Dann-Aussagen, die es uns ermöglichen, Schlussfolgerungen zu ziehen. Zum Beispiel kann ein Arzt eine Regel haben, die besagt, dass **WENN** ein Patient Fieber hat **ODER** einen hohen Wert für C-reaktives Protein im Bluttest hat **DANN** hat er eine Entzündung. Sobald wir eine der Bedingungen treffen, können wir eine Schlussfolgerung über die Entzündung ziehen und diese dann in weiteren Überlegungen verwenden.
- Algorithmen können als eine andere Form der prozeduralen Darstellung betrachtet werden, obwohl sie fast nie direkt in wissensbasierten Systemen verwendet werden.
3. **Prozedurale Repräsentationen** basieren darauf, Wissen durch eine Liste von Aktionen darzustellen, die ausgeführt werden können, wenn eine bestimmte Bedingung eintritt.
- Produktionsregeln sind Wenn-Dann-Aussagen, die es uns ermöglichen, Schlussfolgerungen zu ziehen. Zum Beispiel könnte ein Arzt eine Regel haben, die besagt: **WENN** ein Patient hohes Fieber **ODER** einen hohen C-reaktiven Proteinspiegel im Bluttest hat, **DANN** hat er eine Entzündung. Sobald wir eine der Bedingungen feststellen, können wir eine Schlussfolgerung über die Entzündung ziehen und diese dann für weitere Überlegungen verwenden.
- Algorithmen können als eine andere Form der prozeduralen Repräsentation betrachtet werden, obwohl sie fast nie direkt in wissensbasierten Systemen verwendet werden.
4. **Logik** wurde ursprünglich von Aristoteles als eine Möglichkeit vorgeschlagen, universelles menschliches Wissen darzustellen.
- Prädikatenlogik als mathematische Theorie ist zu reich, um berechenbar zu sein, daher wird normalerweise eine Teilmenge davon verwendet, wie Horn-Klauseln, die in Prolog verwendet werden.
- Beschreibende Logik ist eine Familie von logischen Systemen, die verwendet werden, um Hierarchien von Objekten in verteilten Wissensdarstellungen wie dem *semantischen Web* darzustellen und darüber nachzudenken.
4. **Logik** wurde ursprünglich von Aristoteles als Methode vorgeschlagen, universelles menschliches Wissen darzustellen.
- Prädikatenlogik als mathematische Theorie ist zu komplex, um berechenbar zu sein, daher wird normalerweise ein Teil davon verwendet, wie Horn-Klauseln in Prolog.
- Beschreibungslogik ist eine Familie logischer Systeme, die verwendet wird, um Hierarchien von Objekten und verteilte Wissensrepräsentationen wie das *semantische Web* darzustellen und darüber zu schlussfolgern.
## Expertensysteme
Einer der frühen Erfolge der symbolischen KI waren die sogenannten **Expertensysteme** - Computersysteme, die dazu entworfen wurden, als Experte in einem bestimmten begrenzten Problembereich zu agieren. Sie basierten auf einer **Wissensbasis**, die aus einem oder mehreren menschlichen Experten extrahiert wurde, und sie enthielten eine **Schlussfolgerungsmaschine**, die darauf basierend einige Überlegungen anstellte.
Einer der frühen Erfolge der symbolischen KI waren sogenannte **Expertensysteme** - Computersysteme, die so konzipiert waren, dass sie in einem begrenzten Problembereich als Experte agieren. Sie basierten auf einer **Wissensbasis**, die von einem oder mehreren menschlichen Experten extrahiert wurde, und enthielten eine **Schlussfolgerungsmaschine**, die darauf basierende Überlegungen anstellte.
![Menschliche Architektur](../../../../translated_images/arch-human.5d4d35f1bba3ab1cdfda96af2f10b89574eb31e9796d0e3011cd9beda1c35112.de.png) | ![Wissensbasiertes System](../../../../translated_images/arch-kbs.3ec5c150b09fa8dadc2beb0931a4983c9e2b03913a89eebcc103b5bb841b0212.de.png)
---------------------------------------------|------------------------------------------------
Vereinfachte Struktur eines menschlichen neuronalen Systems | Architektur eines wissensbasierten Systems
![Menschliche Architektur](../../../../lessons/2-Symbolic/images/arch-human.png) | ![Wissensbasiertes System](../../../../lessons/2-Symbolic/images/arch-kbs.png)
--------------------------------------------------|-----------------------------------------------
Vereinfachte Struktur des menschlichen Nervensystems | Architektur eines wissensbasierten Systems
Expertensysteme sind aufgebaut wie das menschliche Denk-System, das **Kurzzeitgedächtnis** und **Langzeitgedächtnis** enthält. Ähnlich unterscheiden wir in wissensbasierten Systemen die folgenden Komponenten:
Expertensysteme sind ähnlich aufgebaut wie das menschliche Denksystem, das **Kurzzeitgedächtnis** und **Langzeitgedächtnis** enthält. Ebenso unterscheiden wir in wissensbasierten Systemen die folgenden Komponenten:
* **Problemerinnerung**: enthält das Wissen über das aktuell zu lösende Problem, z.B. die Temperatur oder den Blutdruck eines Patienten, ob er eine Entzündung hat oder nicht usw. Dieses Wissen wird auch als **statisches Wissen** bezeichnet, da es einen Schnappschuss dessen enthält, was wir derzeit über das Problem wissen - den sogenannten *Problemzustand*.
* **Wissensbasis**: repräsentiert langfristiges Wissen über ein Problembereich. Es wird manuell von menschlichen Experten extrahiert und ändert sich nicht von Konsultation zu Konsultation. Da es uns ermöglicht, von einem Problemzustand zu einem anderen zu navigieren, wird es auch als **dynamisches Wissen** bezeichnet.
* **Schlussfolgerungsmaschine**: orchestriert den gesamten Prozess der Suche im Problembereich und stellt dem Benutzer bei Bedarf Fragen. Sie ist auch dafür verantwortlich, die richtigen Regeln zu finden, die auf jeden Zustand angewendet werden sollen.
* **Problemgedächtnis**: enthält das Wissen über das aktuell zu lösende Problem, z. B. die Temperatur oder den Blutdruck eines Patienten, ob er eine Entzündung hat oder nicht usw. Dieses Wissen wird auch als **statisches Wissen** bezeichnet, da es eine Momentaufnahme dessen enthält, was wir derzeit über das Problem wissen - den sogenannten *Problemzustand*.
* **Wissensbasis**: repräsentiert langfristiges Wissen über einen Problembereich. Es wird manuell von menschlichen Experten extrahiert und ändert sich nicht von einer Konsultation zur nächsten. Da es uns ermöglicht, von einem Problemzustand zum anderen zu navigieren, wird es auch als **dynamisches Wissen** bezeichnet.
* **Schlussfolgerungsmaschine**: orchestriert den gesamten Prozess der Suche im Problemzustandsraum und stellt dem Benutzer bei Bedarf Fragen. Sie ist auch dafür verantwortlich, die richtigen Regeln für jeden Zustand zu finden.
Als Beispiel betrachten wir folgendes Expertensystem zur Bestimmung eines Tieres basierend auf seinen physischen Eigenschaften:
Als Beispiel betrachten wir das folgende Expertensystem zur Bestimmung eines Tieres basierend auf seinen physischen Merkmalen:
![AND-OR-Baum](../../../../translated_images/AND-OR-Tree.5592d2c70187f283703c8e9c0d69d6a786eb370f4ace67f9a7aae5ada3d260b0.de.png)
![AND-OR-Baum](../../../../lessons/2-Symbolic/images/AND-OR-Tree.png)
> Bild von [Dmitry Soshnikov](http://soshnikov.com)
Dieses Diagramm wird als **AND-OR-Baum** bezeichnet und ist eine grafische Darstellung einer Menge von Produktionsregeln. Das Zeichnen eines Baumes ist zu Beginn der Wissensgewinnung von Nutzen. Um das Wissen im Computer darzustellen, ist es bequemer, Regeln zu verwenden:
Dieses Diagramm wird als **AND-OR-Baum** bezeichnet und ist eine grafische Darstellung einer Reihe von Produktionsregeln. Das Zeichnen eines Baums ist nützlich zu Beginn der Wissensextraktion vom Experten. Um das Wissen im Computer darzustellen, ist es jedoch praktischer, Regeln zu verwenden:
```
IF the animal eats meat
@ -112,59 +119,57 @@ OR (animal has sharp teeth
THEN the animal is a carnivore
```
Du wirst feststellen, dass jede Bedingung auf der linken Seite der Regel und die Aktion im Wesentlichen Objekt-Attribut-Wert (OAV) Tripel sind. **Arbeitsgedächtnis** enthält die Menge der OAV-Triple, die dem aktuell zu lösenden Problem entsprechen. Eine **Regelmaschine** sucht nach Regeln, für die eine Bedingung erfüllt ist, und wendet sie an, indem sie ein weiteres Tripel zum Arbeitsgedächtnis hinzufügt.
Man kann erkennen, dass jede Bedingung auf der linken Seite der Regel und die Aktion im Wesentlichen Objekt-Attribut-Wert (OAV)-Tripel sind. **Arbeitsgedächtnis** enthält die Menge von OAV-Tripeln, die dem aktuell zu lösenden Problem entsprechen. Eine **Regelmaschine** sucht nach Regeln, deren Bedingungen erfüllt sind, und wendet sie an, indem sie ein weiteres Tripel zum Arbeitsgedächtnis hinzufügt.
> ✅ Schreibe deinen eigenen AND-OR-Baum zu einem Thema, das dir gefällt!
> ✅ Erstelle deinen eigenen AND-OR-Baum zu einem Thema, das dir gefällt!
### Vorwärts- vs. Rückwärtsinferenz
### Vorwärts- vs. Rückwärts-Schlussfolgerung
Der oben beschriebene Prozess wird als **Vorwärtsinferenz** bezeichnet. Er beginnt mit einigen Anfangsdaten über das Problem, die im Arbeitsgedächtnis verfügbar sind, und führt dann die folgende Schlussfolgerungsschleife aus:
Der oben beschriebene Prozess wird als **Vorwärts-Schlussfolgerung** bezeichnet. Er beginnt mit einigen Anfangsdaten über das Problem, die im Arbeitsgedächtnis verfügbar sind, und führt dann die folgende Schlussfolgerungsschleife aus:
1. Wenn das Zielattribut im Arbeitsgedächtnis vorhanden ist - stoppe und gib das Ergebnis an
2. Suche nach allen Regeln, deren Bedingung derzeit erfüllt ist - erhalte die **Konfliktmenge** von Regeln.
3. Führe die **Konfliktlösung** durch - wähle eine Regel aus, die in diesem Schritt ausgeführt wird. Es könnte verschiedene Strategien zur Konfliktlösung geben:
1. Wenn das Zielattribut im Arbeitsgedächtnis vorhanden ist - stoppen und das Ergebnis ausgeben
2. Suche nach allen Regeln, deren Bedingungen derzeit erfüllt sind - erhalte den **Konfliktset** von Regeln.
3. Führe **Konfliktlösung** durch - wähle eine Regel aus, die in diesem Schritt ausgeführt wird. Es können verschiedene Konfliktlösungsstrategien angewendet werden:
- Wähle die erste anwendbare Regel in der Wissensbasis
- Wähle eine zufällige Regel
- Wähle eine *spezifischere* Regel, d.h. diejenige, die die meisten Bedingungen auf der "linken Seite" (LHS) erfüllt
4. Wende die ausgewählte Regel an und füge neues Wissen in den Problemzustand ein
- Wähle eine *spezifischere* Regel, d. h. diejenige, die die meisten Bedingungen auf der "linken Seite" (LHS) erfüllt
4. Wende die ausgewählte Regel an und füge ein neues Wissenselement zum Problemzustand hinzu
5. Wiederhole ab Schritt 1.
In einigen Fällen möchten wir jedoch vielleicht mit einem leeren Wissen über das Problem beginnen und Fragen stellen, die uns helfen, zu einer Schlussfolgerung zu gelangen. Zum Beispiel führen wir bei einer medizinischen Diagnose normalerweise nicht alle medizinischen Analysen im Voraus durch, bevor wir mit der Diagnose des Patienten beginnen. Wir möchten vielmehr Analysen durchführen, wenn eine Entscheidung getroffen werden muss.
In einigen Fällen möchten wir jedoch mit leerem Wissen über das Problem beginnen und Fragen stellen, die uns helfen, zur Schlussfolgerung zu gelangen. Zum Beispiel führen wir bei medizinischen Diagnosen normalerweise nicht alle medizinischen Analysen im Voraus durch, bevor wir mit der Diagnose des Patienten beginnen. Stattdessen möchten wir Analysen durchführen, wenn eine Entscheidung getroffen werden muss.
Dieser Prozess kann mit **Rückwärtsinferenz** modelliert werden. Er wird durch das **Ziel** gesteuert - den Attributwert, den wir zu finden versuchen:
Dieser Prozess kann mithilfe der **Rückwärts-Schlussfolgerung** modelliert werden. Sie wird durch das **Ziel** angetrieben - den Attributwert, den wir finden möchten:
1. Wähle alle Regeln aus, die uns den Wert eines Ziels geben können (d.h. mit dem Ziel auf der RHS ("rechten Seite")) - eine Konfliktmenge
1. Wenn es keine Regeln für dieses Attribut gibt oder eine Regel besagt, dass wir den Wert vom Benutzer abfragen sollten - frage danach, andernfalls:
1. Verwende die Konfliktlösungsstrategie, um eine Regel auszuwählen, die wir als *Hypothese* verwenden werden - wir werden versuchen, sie zu beweisen
1. Wähle alle Regeln aus, die uns den Wert eines Ziels geben können (d. h. mit dem Ziel auf der RHS ("rechte Seite")) - ein Konfliktset
1. Wenn es keine Regeln für dieses Attribut gibt oder eine Regel besagt, dass wir den Wert vom Benutzer erfragen sollen - frage danach, andernfalls:
1. Verwende eine Konfliktlösungsstrategie, um eine Regel auszuwählen, die wir als *Hypothese* verwenden werden - wir versuchen, sie zu beweisen
1. Wiederhole den Prozess rekursiv für alle Attribute auf der LHS der Regel und versuche, sie als Ziele zu beweisen
1. Wenn der Prozess an irgendeinem Punkt fehlschlägt - verwende eine andere Regel in Schritt 3.
1. Wenn der Prozess zu irgendeinem Zeitpunkt fehlschlägt - verwende eine andere Regel in Schritt 3.
> ✅ In welchen Situationen ist Vorwärtsinferenz geeigneter? Und Rückwärtsinferenz?
> ✅ In welchen Situationen ist die Vorwärts-Schlussfolgerung besser geeignet? Und wie sieht es mit der Rückwärts-Schlussfolgerung aus?
### Implementierung von Expertensystemen
Expertensysteme können mit verschiedenen Werkzeugen implementiert werden:
* Direkt in einer Hochsprache programmieren. Das ist nicht die beste Idee, da der Hauptvorteil eines wissensbasierten Systems darin besteht, dass Wissen von der Schlussfolgerung getrennt ist, und potenziell sollte ein Experte im Problembereich in der Lage sein, Regeln zu schreiben, ohne die Details des Schlussfolgerungsprozesses zu verstehen.
* Verwendung einer **Expertensystem-Schale**, d.h. eines Systems, das speziell dafür entworfen wurde, mit Wissen unter Verwendung einer bestimmten Wissensdarstellungssprache befüllt zu werden.
* Direkte Programmierung in einer Hochsprache. Dies ist keine optimale Lösung, da der Hauptvorteil eines wissensbasierten Systems darin besteht, dass Wissen von der Schlussfolgerung getrennt ist und ein Fachexperte potenziell Regeln schreiben können sollte, ohne die Details des Schlussfolgerungsprozesses zu verstehen.
* Verwendung einer **Expertensystem-Shell**, d. h. eines Systems, das speziell dafür entwickelt wurde, mit Wissen in einer Wissensrepräsentationssprache gefüllt zu werden.
## ✍️ Übung: Tierinferenz
## ✍️ Übung: Tier-Schlussfolgerung
Siehe [Animals.ipynb](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) für ein Beispiel zur Implementierung eines Expertensystems für Vorwärts- und Rückwärtsinferenz.
Siehe [Animals.ipynb](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) für ein Beispiel zur Implementierung eines Expertensystems mit Vorwärts- und Rückwärts-Schlussfolgerung.
> **Hinweis**: Dieses Beispiel ist ziemlich einfach und vermittelt lediglich eine Vorstellung davon, wie ein Expertensystem aussieht. Sobald Sie beginnen, ein solches System zu erstellen, werden Sie erst ab einer bestimmten Anzahl von Regeln, etwa 200+, ein gewisses *intelligentes* Verhalten bemerken. Ab einem bestimmten Punkt werden die Regeln so komplex, dass es schwierig wird, alle im Kopf zu behalten, und an diesem Punkt könnten Sie sich fragen, warum das System bestimmte Entscheidungen trifft. Eine wichtige Eigenschaft von wissensbasierten Systemen ist jedoch, dass Sie immer genau *erklären* können, wie jede Entscheidung getroffen wurde.
## Ontologien und das Semantische Web
> **Hinweis**: Dieses Beispiel ist recht einfach und vermittelt nur eine Vorstellung davon, wie ein Expertensystem aussieht. Sobald du anfängst, ein solches System zu erstellen, wirst du erst dann einige *intelligente* Verhaltensweisen bemerken, wenn du eine bestimmte Anzahl von Regeln erreichst, etwa 200+. Irgendwann werden die Regeln zu komplex, um alle im Kopf zu behalten, und an diesem Punkt wirst du dich fragen, warum ein System bestimmte Entscheidungen trifft. Dennoch ist die wichtige Eigenschaft wissensbasierter Systeme, dass du immer genau *erklären* kannst, wie eine der Entscheidungen getroffen wurde.
Ende des 20. Jahrhunderts gab es eine Initiative, die Wissensrepräsentation nutzte, um Internetressourcen zu annotieren, sodass Ressourcen gefunden werden konnten, die sehr spezifischen Anfragen entsprechen. Diese Bewegung wurde **Semantisches Web** genannt und basierte auf mehreren Konzepten:
## Ontologien und das semantische Web
Am Ende des 20. Jahrhunderts gab es eine Initiative, Wissensdarstellung zu verwenden, um Internetressourcen zu annotieren, sodass es möglich wäre, Ressourcen zu finden, die sehr spezifischen Anfragen entsprechen. Diese Bewegung wurde als **semantisches Web** bezeichnet und basierte auf mehreren Konzepten:
- Eine spezielle Wissensdarstellung, die auf **[Beschreibungslogiken](https://en.wikipedia.org/wiki/Description_logic)** (DL) basiert. Sie ähnelt der Frame-Wissensdarstellung, da sie eine Hierarchie von Objekten mit Eigenschaften aufbaut, jedoch formale logische Semantik und Schlussfolgerung hat. Es gibt eine ganze Familie von DLs, die zwischen Ausdruckskraft und algorithmischer Komplexität der Schlussfolgerung balancieren.
- Verteilte Wissensdarstellung, bei der alle Konzepte durch einen globalen URI-Identifikator dargestellt werden, was es ermöglicht, Wissenshierarchien zu erstellen, die sich über das Internet erstrecken.
- Eine spezielle Wissensrepräsentation basierend auf **[Beschreibungssprachen](https://en.wikipedia.org/wiki/Description_logic)** (DL). Sie ähnelt der Rahmen-Wissensrepräsentation, da sie eine Hierarchie von Objekten mit Eigenschaften aufbaut, hat jedoch formale logische Semantik und Schlussfolgerungen. Es gibt eine ganze Familie von DLs, die zwischen Ausdruckskraft und algorithmischer Komplexität der Schlussfolgerungen balancieren.
- Verteilte Wissensrepräsentation, bei der alle Konzepte durch einen globalen URI-Identifikator repräsentiert werden, was es ermöglicht, Wissenshierarchien zu erstellen, die das Internet umfassen.
- Eine Familie von XML-basierten Sprachen zur Wissensbeschreibung: RDF (Resource Description Framework), RDFS (RDF Schema), OWL (Ontology Web Language).
Ein zentrales Konzept im semantischen Web ist das Konzept der **Ontologie**. Es bezieht sich auf eine explizite Spezifikation eines Problembereichs unter Verwendung einer formalen Wissensdarstellung. Die einfachste Ontologie kann einfach eine Hierarchie von Objekten in einem Problembereich sein, aber komplexere Ontologien werden Regeln enthalten, die für Schlussfolgerungen verwendet werden können.
Ein Kernkonzept im Semantischen Web ist das Konzept der **Ontologie**. Es bezieht sich auf eine explizite Spezifikation eines Problemfeldes unter Verwendung einer formalen Wissensrepräsentation. Die einfachste Ontologie kann einfach eine Hierarchie von Objekten in einem Problemfeld sein, aber komplexere Ontologien beinhalten Regeln, die für Schlussfolgerungen verwendet werden können.
Im semantischen Web basieren alle Darstellungen auf Tripeln. Jedes Objekt und jede Relation sind eindeutig durch die URI identifiziert. Zum Beispiel, wenn wir den Fakt angeben wollen, dass dieser KI-Lehrplan von Dmitry Soshnikov am 1. Januar 2022 entwickelt wurde - hier sind die Tripel, die wir verwenden können:
Im Semantischen Web basieren alle Darstellungen auf Tripeln. Jedes Objekt und jede Beziehung werden eindeutig durch den URI identifiziert. Zum Beispiel, wenn wir die Tatsache ausdrücken möchten, dass dieses KI-Curriculum von Dmitry Soshnikov am 1. Januar 2022 entwickelt wurde, könnten wir die folgenden Tripel verwenden:
<img src="images/triplet.png" width="30%"/>
@ -173,17 +178,17 @@ http://github.com/microsoft/ai-for-beginners http://www.example.com/terms/creati
http://github.com/microsoft/ai-for-beginners http://purl.org/dc/elements/1.1/creator http://soshnikov.com
```
> ✅ Hier `http://www.example.com/terms/creation-date` and `http://purl.org/dc/elements/1.1/creator` sind einige bekannte und allgemein akzeptierte URIs, um die Konzepte von *Schöpfer* und *Erstellungsdatum* auszudrücken.
> ✅ Hier sind `http://www.example.com/terms/creation-date` und `http://purl.org/dc/elements/1.1/creator` einige bekannte und allgemein akzeptierte URIs, um die Konzepte von *Ersteller* und *Erstellungsdatum* auszudrücken.
In einem komplexeren Fall, wenn wir eine Liste von Schöpfern definieren möchten, können wir einige in RDF definierte Datenstrukturen verwenden.
In einem komplexeren Fall, wenn wir eine Liste von Erstellern definieren möchten, können wir einige in RDF definierte Datenstrukturen verwenden.
<img src="images/triplet-complex.png" width="40%"/>
> Diagramme oben von [Dmitry Soshnikov](http://soshnikov.com)
Der Fortschritt beim Aufbau des semantischen Webs wurde durch den Erfolg von Suchmaschinen und Techniken der natürlichen Sprachverarbeitung, die es ermöglichen, strukturierte Daten aus Texten zu extrahieren, etwas verlangsamt. Dennoch gibt es in einigen Bereichen weiterhin erhebliche Bemühungen, Ontologien und Wissensbasen zu pflegen. Einige Projekte, die erwähnenswert sind:
Der Fortschritt beim Aufbau des Semantischen Webs wurde durch den Erfolg von Suchmaschinen und Techniken der natürlichen Sprachverarbeitung etwas verlangsamt, die es ermöglichen, strukturierte Daten aus Texten zu extrahieren. Dennoch gibt es in einigen Bereichen weiterhin bedeutende Bemühungen, Ontologien und Wissensbasen zu pflegen. Einige bemerkenswerte Projekte:
* [WikiData](https://wikidata.org/) ist eine Sammlung von maschinenlesbaren Wissensbasen, die mit Wikipedia verbunden sind. Die meisten Daten stammen aus den Wikipedia *InfoBoxen*, Stücken strukturierten Inhalts innerhalb von Wikipedia-Seiten. Du kannst [abfragen](https://query.wikidata.org/) wikidata in SPARQL, einer speziellen Abfragesprache für das semantische Web. Hier ist eine Beispielabfrage, die die beliebtesten Augenfarben unter Menschen anzeigt:
* [WikiData](https://wikidata.org/) ist eine Sammlung maschinenlesbarer Wissensbasen, die mit Wikipedia verbunden sind. Die meisten Daten werden aus den Wikipedia *InfoBoxes* extrahiert, strukturierten Inhalten innerhalb der Wikipedia-Seiten. Sie können [WikiData abfragen](https://query.wikidata.org/) mit SPARQL, einer speziellen Abfragesprache für das Semantische Web. Hier ist eine Beispielabfrage, die die beliebtesten Augenfarben unter Menschen anzeigt:
```sparql
#defaultView:BubbleChart
@ -197,13 +202,47 @@ WHERE
GROUP BY ?eyeColorLabel
```
* [DBpedia](https://www.dbpedia.org/) ist ein weiterer Versuch, ähnlich wie WikiData.
* [DBpedia](https://www.dbpedia.org/) ist ein weiteres Projekt, das WikiData ähnelt.
> ✅ Wenn du mit dem Erstellen deiner eigenen Ontologien oder dem Öffnen bestehender experimentieren möchtest, gibt es einen großartigen visuellen Ontologie-Editor namens [Protégé](https://protege.stanford.edu/). Lade ihn herunter oder benutze ihn online.
> ✅ Wenn Sie mit dem Aufbau eigener Ontologien oder dem Öffnen bestehender experimentieren möchten, gibt es einen großartigen visuellen Ontologie-Editor namens [Protégé](https://protege.stanford.edu/). Laden Sie ihn herunter oder nutzen Sie ihn online.
<img src="images/protege.png" width="70%"/>
*Web Protégé Editor geöffnet mit der Romanov-Familienontologie. Screenshot von Dmitry Soshnikov*
## ✍️ Übung: Eine Familienontologie
Sehen Sie sich [FamilyOntology.ipynb](https://github.com/Ezana135/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb) an, um ein Beispiel für die Verwendung von Techniken des Semantischen Webs zur Analyse von Familienbeziehungen zu sehen. Wir werden einen Familienstammbaum im üblichen GEDCOM-Format und eine Ontologie von Familienbeziehungen verwenden, um einen Graphen aller Familienbeziehungen für eine gegebene Gruppe von Individuen zu erstellen.
## Microsoft Concept Graph
In den meisten Fällen werden Ontologien sorgfältig von Hand erstellt. Es ist jedoch auch möglich, Ontologien aus unstrukturierten Daten zu **extrahieren**, beispielsweise aus Texten in natürlicher Sprache.
Ein solcher Versuch wurde von Microsoft Research unternommen und führte zum [Microsoft Concept Graph](https://blogs.microsoft.com/ai/microsoft-researchers-release-graph-that-helps-machines-conceptualize/?WT.mc_id=academic-77998-cacaste).
Es handelt sich um eine große Sammlung von Entitäten, die mithilfe der `is-a`-Vererbungsbeziehung gruppiert wurden. Damit können Fragen wie "Was ist Microsoft?" beantwortet werden – die Antwort könnte etwa lauten: "Ein Unternehmen mit einer Wahrscheinlichkeit von 0,87 und eine Marke mit einer Wahrscheinlichkeit von 0,75".
Der Graph ist entweder als REST-API oder als große herunterladbare Textdatei verfügbar, die alle Entitätspaare auflistet.
## ✍️ Übung: Ein Concept Graph
Probieren Sie das [MSConceptGraph.ipynb](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/MSConceptGraph.ipynb)-Notebook aus, um zu sehen, wie wir den Microsoft Concept Graph verwenden können, um Nachrichtenartikel in verschiedene Kategorien zu gruppieren.
## Fazit
Heutzutage wird KI oft als Synonym für *Maschinelles Lernen* oder *Neuronale Netze* betrachtet. Ein Mensch zeigt jedoch auch explizites Denken, etwas, das derzeit von neuronalen Netzen nicht behandelt wird. In realen Projekten wird explizites Denken weiterhin verwendet, um Aufgaben auszuführen, die Erklärungen erfordern oder die Fähigkeit, das Verhalten des Systems auf kontrollierte Weise zu ändern.
## 🚀 Herausforderung
Im Family Ontology Notebook, das mit dieser Lektion verbunden ist, gibt es die Möglichkeit, mit anderen Familienbeziehungen zu experimentieren. Versuchen Sie, neue Verbindungen zwischen Personen im Familienstammbaum zu entdecken.
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/202)
## Überprüfung & Selbststudium
Recherchieren Sie im Internet, um Bereiche zu entdecken, in denen Menschen versucht haben, Wissen zu quantifizieren und zu kodifizieren. Schauen Sie sich Bloom's Taxonomy an und gehen Sie in der Geschichte zurück, um zu erfahren, wie Menschen versucht haben, ihre Welt zu verstehen. Erkunden Sie die Arbeit von Linnaeus zur Erstellung einer Taxonomie von Organismen und beobachten Sie, wie Dmitri Mendelejew eine Methode zur Beschreibung und Gruppierung chemischer Elemente entwickelte. Welche anderen interessanten Beispiele können Sie finden?
**Aufgabe**: [Erstellen Sie eine Ontologie](assignment.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

15
translations/de/lessons/2-Symbolic/assignment.md
View File

@ -1,6 +1,15 @@
# Eine Ontologie erstellen
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a057a8604f3976c3e309884453f1fad0",
"translation_date": "2025-08-24T09:43:46+00:00",
"source_file": "lessons/2-Symbolic/assignment.md",
"language_code": "de"
}
-->
# Erstellen Sie eine Ontologie
Der Aufbau einer Wissensdatenbank dreht sich darum, ein Modell zu kategorisieren, das Fakten über ein Thema repräsentiert. Wählen Sie ein Thema - wie eine Person, einen Ort oder eine Sache - und erstellen Sie dann ein Modell dieses Themas. Verwenden Sie einige der Techniken und Modellierungsstrategien, die in dieser Lektion beschrieben werden. Ein Beispiel wäre die Erstellung einer Ontologie für ein Wohnzimmer mit Möbeln, Beleuchtung und so weiter. Wie unterscheidet sich das Wohnzimmer von der Küche? Vom Badezimmer? Wie wissen Sie, dass es sich um ein Wohnzimmer und nicht um ein Esszimmer handelt? Verwenden Sie [Protégé](https://protege.stanford.edu/), um Ihre Ontologie zu erstellen.
Eine Wissensbasis zu erstellen bedeutet, ein Modell zu kategorisieren, das Fakten zu einem bestimmten Thema darstellt. Wählen Sie ein Thema – wie eine Person, einen Ort oder ein Objekt – und erstellen Sie dann ein Modell zu diesem Thema. Verwenden Sie einige der in dieser Lektion beschriebenen Techniken und Strategien zur Modellerstellung. Ein Beispiel wäre das Erstellen einer Ontologie eines Wohnzimmers mit Möbeln, Lampen und so weiter. Worin unterscheidet sich das Wohnzimmer von der Küche? Dem Badezimmer? Woran erkennen Sie, dass es sich um ein Wohnzimmer und nicht um ein Esszimmer handelt? Verwenden Sie [Protégé](https://protege.stanford.edu/), um Ihre Ontologie zu erstellen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung resultieren.
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.

54
translations/de/lessons/3-NeuralNetworks/03-Perceptron/README.md
View File

@ -1,8 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "0c37770bba4fff3c71dc00eb261ee61b",
"translation_date": "2025-08-24T09:40:50+00:00",
"source_file": "lessons/3-NeuralNetworks/03-Perceptron/README.md",
"language_code": "de"
}
-->
# Einführung in Neuronale Netze: Perzeptron
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/103)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/103)
Einer der ersten Versuche, etwas Ähnliches wie ein modernes neuronales Netzwerk zu implementieren, wurde 1957 von Frank Rosenblatt vom Cornell Aeronautical Laboratory unternommen. Es handelte sich um eine Hardware-Implementierung namens "Mark-1", die darauf ausgelegt war, primitive geometrische Figuren wie Dreiecke, Quadrate und Kreise zu erkennen.
Einer der ersten Versuche, etwas Ähnliches wie ein modernes neuronales Netz zu implementieren, wurde 1957 von Frank Rosenblatt vom Cornell Aeronautical Laboratory unternommen. Es handelte sich um eine Hardware-Implementierung namens "Mark-1", die entwickelt wurde, um primitive geometrische Figuren wie Dreiecke, Quadrate und Kreise zu erkennen.
| | |
|--------------|-----------|
@ -10,39 +19,39 @@ Einer der ersten Versuche, etwas Ähnliches wie ein modernes neuronales Netzwerk
> Bilder [von Wikipedia](https://en.wikipedia.org/wiki/Perceptron)
Ein Eingabebild wurde durch ein 20x20-Photodetektor-Array dargestellt, sodass das neuronale Netzwerk 400 Eingaben und eine binäre Ausgabe hatte. Ein einfaches Netzwerk bestand aus einem Neuron, das auch als **Schwellwertlogikeinheit** bezeichnet wird. Die Gewichte des neuronalen Netzwerks wirkten wie Potentiometer, die während der Trainingsphase manuell angepasst werden mussten.
Ein Eingabebild wurde durch ein 20x20-Photodioden-Array dargestellt, sodass das neuronale Netz 400 Eingaben und eine binäre Ausgabe hatte. Ein einfaches Netzwerk bestand aus einem Neuron, das auch als **Schwellenwert-Logikeinheit** bezeichnet wird. Die Gewichte des neuronalen Netzes wirkten wie Potentiometer, die während der Trainingsphase manuell angepasst werden mussten.
> ✅ Ein Potentiometer ist ein Gerät, das es dem Benutzer ermöglicht, den Widerstand eines Schaltkreises anzupassen.
> ✅ Ein Potentiometer ist ein Gerät, das es dem Benutzer ermöglicht, den Widerstand eines Stromkreises einzustellen.
> Die New York Times schrieb zu dieser Zeit über das Perzeptron: *der Embryo eines elektronischen Computers, von dem [die Marine] erwartet, dass er gehen, sprechen, sehen, schreiben, sich selbst reproduzieren und sich seiner Existenz bewusst sein wird.*
> Die New York Times schrieb damals über das Perzeptron: *der Embryo eines elektronischen Computers, von dem [die Marine] erwartet, dass er laufen, sprechen, sehen, schreiben, sich selbst reproduzieren und sich seiner Existenz bewusst sein wird.*
## Perzeptron-Modell
Angenommen, wir haben N Merkmale in unserem Modell, in diesem Fall wäre der Eingangsvektor ein Vektor der Größe N. Ein Perzeptron ist ein **binäres Klassifikations**modell, d.h. es kann zwischen zwei Klassen von Eingabedaten unterscheiden. Wir nehmen an, dass für jeden Eingangsvektor x die Ausgabe unseres Perzeptrons entweder +1 oder -1 beträgt, je nach Klasse. Die Ausgabe wird mit der Formel berechnet:
Angenommen, wir haben N Merkmale in unserem Modell, dann wäre der Eingabevektor ein Vektor der Größe N. Ein Perzeptron ist ein Modell zur **binären Klassifikation**, d.h. es kann zwischen zwei Klassen von Eingabedaten unterscheiden. Wir nehmen an, dass für jeden Eingabevektor x die Ausgabe unseres Perzeptrons entweder +1 oder -1 ist, abhängig von der Klasse. Die Ausgabe wird mit der folgenden Formel berechnet:
y(x) = f(w<sup>T</sup>x)
wobei f eine Schritt-Aktivierungsfunktion ist.
wobei f eine Stufenaktivierungsfunktion ist.
<!-- img src="http://www.sciweavers.org/tex2img.php?eq=f%28x%29%20%3D%20%5Cbegin%7Bcases%7D%0A%20%20%20%20%20%20%20%20%20%2B1%20%26%20x%20%5Cgeq%200%20%5C%5C%0A%20%20%20%20%20%20%20%20%20-1%20%26%20x%20%3C%200%0A%20%20%20%20%20%20%20%5Cend%7Bcases%7D%20%5C%5C%0A&bc=White&fc=Black&im=jpg&fs=12&ff=arev&edit=0" align="center" border="0" alt="f(x) = \begin{cases} +1 & x \geq 0 \\ -1 & x < 0 \end{cases} \\" width="154" height="50" / -->
<img src="images/activation-func.png"/>
## Training des Perzeptrons
Um ein Perzeptron zu trainieren, müssen wir einen Gewichtungsvektor w finden, der die meisten Werte korrekt klassifiziert, d.h. der den kleinsten **Fehler** ergibt. Dieser Fehler E wird durch das **Perzeptron-Kriterium** wie folgt definiert:
Um ein Perzeptron zu trainieren, müssen wir einen Gewichtsvektor w finden, der die meisten Werte korrekt klassifiziert, d.h. den kleinsten **Fehler** ergibt. Dieser Fehler E wird durch das **Perzeptron-Kriterium** wie folgt definiert:
E(w) = -∑w<sup>T</sup>x<sub>i</sub>t<sub>i</sub>
wobei:
* die Summe über die Trainingsdatenpunkte i genommen wird, die zu einer falschen Klassifikation führen
* x<sub>i</sub> die Eingabedaten sind und t<sub>i</sub> für negative und positive Beispiele entsprechend -1 oder +1 ist.
* die Summe über jene Trainingsdatenpunkte i gebildet wird, die zu einer falschen Klassifikation führen
* x<sub>i</sub> die Eingabedaten sind und t<sub>i</sub> entweder -1 oder +1 für negative bzw. positive Beispiele ist.
Dieses Kriterium wird als Funktion der Gewichte w betrachtet, und wir müssen es minimieren. Oft wird eine Methode namens **Gradientenabstieg** verwendet, bei der wir mit einigen Anfangsgewichten w<sup>(0)</sup> beginnen und dann bei jedem Schritt die Gewichte gemäß der Formel aktualisieren:
Dieses Kriterium wird als Funktion der Gewichte w betrachtet, und wir müssen es minimieren. Oft wird eine Methode namens **Gradientenabstieg** verwendet, bei der wir mit einigen Anfangsgewichten w<sup>(0)</sup> beginnen und dann in jedem Schritt die Gewichte nach der Formel aktualisieren:
w<sup>(t+1)</sup> = w<sup>(t)</sup> - η∇E(w)
Hierbei ist η die sogenannte **Lernrate**, und ∇E(w) bezeichnet den **Gradienten** von E. Nachdem wir den Gradienten berechnet haben, erhalten wir
Hierbei ist η die sogenannte **Lernrate**, und ∇E(w) bezeichnet den **Gradienten** von E. Nachdem wir den Gradienten berechnet haben, erhalten wir:
w<sup>(t+1)</sup> = w<sup>(t)</sup> + ∑ηx<sub>i</sub>t<sub>i</sub>
@ -70,27 +79,26 @@ def train(positive_examples, negative_examples, num_iterations = 100, eta = 1):
## Fazit
In dieser Lektion haben Sie über ein Perzeptron gelernt, das ein binäres Klassifikationsmodell ist, und wie man es mit einem Gewichtungsvektor trainiert.
In dieser Lektion haben Sie ein Perzeptron kennengelernt, ein Modell zur binären Klassifikation, und wie man es mit einem Gewichtsvektor trainiert.
## 🚀 Herausforderung
Wenn Sie versuchen möchten, Ihr eigenes Perzeptron zu bauen, probieren Sie [dieses Labor auf Microsoft Learn](https://docs.microsoft.com/en-us/azure/machine-learning/component-reference/two-class-averaged-perceptron?WT.mc_id=academic-77998-cacaste), das den [Azure ML Designer](https://docs.microsoft.com/en-us/azure/machine-learning/concept-designer?WT.mc_id=academic-77998-cacaste) verwendet.
Wenn Sie versuchen möchten, Ihr eigenes Perzeptron zu erstellen, probieren Sie [dieses Lab auf Microsoft Learn](https://docs.microsoft.com/en-us/azure/machine-learning/component-reference/two-class-averaged-perceptron?WT.mc_id=academic-77998-cacaste) aus, das den [Azure ML Designer](https://docs.microsoft.com/en-us/azure/machine-learning/concept-designer?WT.mc_id=academic-77998-cacaste) verwendet.
## [Nachlese-Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/203)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/203)
## Überprüfung & Selbststudium
## Rückblick & Selbststudium
Um zu sehen, wie wir das Perzeptron zur Lösung eines Spielzeugsproblems sowie realer Probleme verwenden können und um weiter zu lernen - gehen Sie zum [Perzeptron](../../../../../lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb) Notizbuch.
Um zu sehen, wie wir ein Perzeptron verwenden können, um ein einfaches Problem sowie reale Probleme zu lösen, und um weiterzulernen, gehen Sie zum [Perceptron](../../../../../lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb)-Notebook.
Hier ist ein interessanter [Artikel über Perzeptrons](https://towardsdatascience.com/what-is-a-perceptron-basics-of-neural-networks-c4cfea20c590
) ebenfalls.
Hier ist ein interessanter [Artikel über Perzeptrons](https://towardsdatascience.com/what-is-a-perceptron-basics-of-neural-networks-c4cfea20c590).
## [Aufgabe](lab/README.md)
In dieser Lektion haben wir ein Perzeptron für die binäre Klassifizierungsaufgabe implementiert und es verwendet, um zwischen zwei handgeschriebenen Ziffern zu klassifizieren. In diesem Labor sind Sie aufgefordert, das Problem der Ziffernklassifizierung vollständig zu lösen, d.h. zu bestimmen, welche Ziffer am wahrscheinlichsten einem gegebenen Bild entspricht.
In dieser Lektion haben wir ein Perzeptron für eine binäre Klassifikationsaufgabe implementiert und es verwendet, um zwischen zwei handgeschriebenen Ziffern zu klassifizieren. In diesem Lab sollen Sie das Problem der Ziffernklassifikation vollständig lösen, d.h. bestimmen, welche Ziffer am wahrscheinlichsten zu einem gegebenen Bild gehört.
* [Anleitungen](lab/README.md)
* [Notizbuch](../../../../../lessons/3-NeuralNetworks/03-Perceptron/lab/PerceptronMultiClass.ipynb)
* [Anleitung](lab/README.md)
* [Notebook](../../../../../lessons/3-NeuralNetworks/03-Perceptron/lab/PerceptronMultiClass.ipynb)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

25
translations/de/lessons/3-NeuralNetworks/03-Perceptron/lab/README.md
View File

@ -1,22 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7336583e4630220c835335da640016db",
"translation_date": "2025-08-24T09:41:10+00:00",
"source_file": "lessons/3-NeuralNetworks/03-Perceptron/lab/README.md",
"language_code": "de"
}
-->
# Mehrklassenklassifikation mit Perzeptron
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
Verwenden Sie den Code, den wir in dieser Lektion für die binäre Klassifikation von handgeschriebenen MNIST-Ziffern entwickelt haben, um einen Mehrklassenklassifikator zu erstellen, der in der Lage ist, jede Ziffer zu erkennen. Berechnen Sie die Klassifikationsgenauigkeit auf dem Trainings- und Testdatensatz und drucken Sie die Verwirrungsmatrix aus.
Verwenden Sie den Code, den wir in dieser Lektion für die binäre Klassifikation von MNIST-Handschriftziffern entwickelt haben, um einen Mehrklassenklassifikator zu erstellen, der jede Ziffer erkennen kann. Berechnen Sie die Klassifikationsgenauigkeit für das Trainings- und Testdatenset und geben Sie die Verwirrungsmatrix aus.
## Hinweise
1. Erstellen Sie für jede Ziffer einen Datensatz für den binären Klassifikator "diese Ziffer vs. alle anderen Ziffern"
1. Trainieren Sie 10 verschiedene Perzeptrons für die binäre Klassifikation (eines für jede Ziffer)
1. Definieren Sie eine Funktion, die eine Eingabenziffer klassifiziert
1. Erstellen Sie für jede Ziffer ein Datenset für einen binären Klassifikator von „diese Ziffer vs. alle anderen Ziffern“.
1. Trainieren Sie 10 verschiedene Perzeptrons für die binäre Klassifikation (jeweils eines für jede Ziffer).
1. Definieren Sie eine Funktion, die eine Eingabeziffer klassifiziert.
> **Hinweis**: Wenn wir die Gewichte aller 10 Perzeptrons in eine Matrix kombinieren, sollten wir in der Lage sein, alle 10 Perzeptrons auf die Eingabenziffern durch eine Matrixmultiplikation anzuwenden. Die wahrscheinlichste Ziffer kann dann einfach durch die Anwendung der `argmax`-Operation auf die Ausgabe gefunden werden.
> **Hinweis**: Wenn wir die Gewichte aller 10 Perzeptrons in einer Matrix kombinieren, sollten wir in der Lage sein, alle 10 Perzeptrons durch eine einzige Matrixmultiplikation auf die Eingabeziffern anzuwenden. Die wahrscheinlichste Ziffer kann dann einfach durch die Anwendung der `argmax`-Operation auf die Ausgabe gefunden werden.
## Notizbuch starten
## Start-Notebook
Starten Sie das Labor, indem Sie [PerceptronMultiClass.ipynb](../../../../../../lessons/3-NeuralNetworks/03-Perceptron/lab/PerceptronMultiClass.ipynb) öffnen.
Beginnen Sie das Labor, indem Sie [PerceptronMultiClass.ipynb](../../../../../../lessons/3-NeuralNetworks/03-Perceptron/lab/PerceptronMultiClass.ipynb) öffnen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, bitten wir zu beachten, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache sollte als die 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 Verwendung dieser Übersetzung resultieren.
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 sich aus der Nutzung dieser Übersetzung ergeben.

81
translations/de/lessons/3-NeuralNetworks/04-OwnFramework/README.md
View File

@ -1,89 +1,98 @@
# Einführung in Neuronale Netzwerke. Mehrschichtiger Perzeptron
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "186bf7eeab776b36f557357ea56d4751",
"translation_date": "2025-08-24T09:39:49+00:00",
"source_file": "lessons/3-NeuralNetworks/04-OwnFramework/README.md",
"language_code": "de"
}
-->
# Einführung in Neuronale Netze. Mehrschichtiger Perzeptron
Im vorherigen Abschnitt haben Sie das einfachste Modell eines neuronalen Netzwerks kennengelernt - den einlagigen Perzeptron, ein lineares Klassifikationsmodell für zwei Klassen.
Im vorherigen Abschnitt hast du das einfachste Modell eines neuronalen Netzes kennengelernt – den einlagigen Perzeptron, ein lineares Klassifikationsmodell für zwei Klassen.
In diesem Abschnitt werden wir dieses Modell zu einem flexibleren Rahmen erweitern, der es uns ermöglicht:
In diesem Abschnitt erweitern wir dieses Modell zu einem flexibleren Framework, das uns ermöglicht:
* **Mehrklassenklassifikation** zusätzlich zur Zwei-Klassen-Klassifikation durchzuführen
* **Mehrklassenklassifikation** zusätzlich zur Zweiklassenklassifikation durchzuführen
* **Regressionsprobleme** zusätzlich zur Klassifikation zu lösen
* Klassen zu trennen, die nicht linear separierbar sind
Wir werden auch unser eigenes modulares Framework in Python entwickeln, das es uns ermöglicht, verschiedene Architekturen neuronaler Netzwerke zu konstruieren.
Wir werden außerdem unser eigenes modulares Framework in Python entwickeln, mit dem wir verschiedene Architekturen neuronaler Netze erstellen können.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/104)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/104)
## Formalisierung des Maschinellen Lernens
## Formalisierung des maschinellen Lernens
Lassen Sie uns mit der Formalisierung des Problems des Maschinellen Lernens beginnen. Angenommen, wir haben einen Trainingsdatensatz **X** mit Labels **Y**, und wir müssen ein Modell *f* erstellen, das die genauesten Vorhersagen trifft. Die Qualität der Vorhersagen wird durch die **Verlustfunktion** ℒ gemessen. Folgende Verlustfunktionen werden häufig verwendet:
Beginnen wir mit der Formalisierung des Problems des maschinellen Lernens. Angenommen, wir haben einen Trainingsdatensatz **X** mit Labels **Y**, und wir müssen ein Modell *f* erstellen, das möglichst genaue Vorhersagen trifft. Die Qualität der Vorhersagen wird durch die **Verlustfunktion** ℒ gemessen. Die folgenden Verlustfunktionen werden häufig verwendet:
* Für das Regressionsproblem, wenn wir eine Zahl vorhersagen müssen, können wir den **absoluten Fehler** ∑<sub>i</sub>|f(x<sup>(i)</sup>)-y<sup>(i)</sup>| oder den **quadratischen Fehler** ∑<sub>i</sub>(f(x<sup>(i)</sup>)-y<sup>(i)</sup>)<sup>2</sup> verwenden
* Für die Klassifikation verwenden wir den **0-1 Fehler** (der im Wesentlichen dasselbe wie die **Genauigkeit** des Modells ist) oder den **logistischen Fehler**.
* Für Regressionsprobleme, bei denen wir eine Zahl vorhersagen müssen, können wir den **absoluten Fehler** ∑<sub>i</sub>|f(x<sup>(i)</sup>)-y<sup>(i)</sup>| oder den **quadratischen Fehler** ∑<sub>i</sub>(f(x<sup>(i)</sup>)-y<sup>(i)</sup>)<sup>2</sup> verwenden.
* Für Klassifikationen verwenden wir den **0-1-Verlust** (der im Wesentlichen der **Genauigkeit** des Modells entspricht) oder den **logistischen Verlust**.
Für den einlagigen Perzeptron wurde die Funktion *f* als lineare Funktion *f(x)=wx+b* definiert (hier ist *w* die Gewichtsmatrix, *x* der Vektor der Eingangsmerkmale und *b* der Bias-Vektor). Für verschiedene Architekturen neuronaler Netzwerke kann diese Funktion komplexere Formen annehmen.
Für den einlagigen Perzeptron wurde die Funktion *f* als lineare Funktion definiert: *f(x)=wx+b* (hierbei ist *w* die Gewichtsmatrix, *x* der Vektor der Eingabefeatures und *b* der Bias-Vektor). Für verschiedene Architekturen neuronaler Netze kann diese Funktion eine komplexere Form annehmen.
> Im Falle der Klassifikation ist es oft wünschenswert, Wahrscheinlichkeiten der entsprechenden Klassen als Netzwerk-Ausgabe zu erhalten. Um willkürliche Zahlen in Wahrscheinlichkeiten umzuwandeln (z.B. um die Ausgabe zu normalisieren), verwenden wir oft die **Softmax**-Funktion σ, und die Funktion *f* wird zu *f(x)=σ(wx+b)*
> Im Fall der Klassifikation ist es oft wünschenswert, Wahrscheinlichkeiten der entsprechenden Klassen als Ausgabe des Netzes zu erhalten. Um beliebige Zahlen in Wahrscheinlichkeiten umzuwandeln (z. B. um die Ausgabe zu normalisieren), verwenden wir oft die **Softmax-Funktion** σ, und die Funktion *f* wird zu *f(x)=σ(wx+b)*.
In der obigen Definition von *f* werden *w* und *b* als **Parameter** θ=⟨*w,b*⟩ bezeichnet. Gegebenen den Datensatz ⟨**X**,**Y**⟩ können wir einen Gesamter Fehler über den gesamten Datensatz als Funktion der Parameter θ berechnen.
In der obigen Definition von *f* werden *w* und *b* als **Parameter** θ=⟨*w,b*⟩ bezeichnet. Gegeben den Datensatz ⟨**X**,**Y**⟩, können wir den Gesamterror für den gesamten Datensatz als Funktion der Parameter θ berechnen.
> ✅ **Das Ziel des Trainings eines neuronalen Netzwerks besteht darin, den Fehler durch Variieren der Parameter θ zu minimieren.**
> ✅ **Das Ziel des Trainings eines neuronalen Netzes ist es, den Fehler durch Variation der Parameter θ zu minimieren.**
## Gradientabstieg-Optimierung
## Gradient-Descent-Optimierung
Es gibt eine bekannte Methode zur Optimierung von Funktionen, die als **Gradientenabstieg** bezeichnet wird. Die Idee ist, dass wir die Ableitung (im mehrdimensionalen Fall als **Gradient** bezeichnet) der Verlustfunktion bezüglich der Parameter berechnen und die Parameter so variieren, dass der Fehler sinkt. Dies kann wie folgt formalisiert werden:
Es gibt eine bekannte Methode zur Optimierung von Funktionen, die als **Gradient Descent** bezeichnet wird. Die Idee ist, dass wir eine Ableitung (im mehrdimensionalen Fall als **Gradient** bezeichnet) der Verlustfunktion in Bezug auf die Parameter berechnen und die Parameter so variieren können, dass der Fehler abnimmt. Dies kann wie folgt formalisiert werden:
* Initialisieren Sie die Parameter mit zufälligen Werten w<sup>(0)</sup>, b<sup>(0)</sup>
* Wiederholen Sie den folgenden Schritt viele Male:
* Initialisiere die Parameter mit zufälligen Werten w<sup>(0)</sup>, b<sup>(0)</sup>
* Wiederhole die folgenden Schritte viele Male:
- w<sup>(i+1)</sup> = w<sup>(i)</sup>-η∂ℒ/∂w
- b<sup>(i+1)</sup> = b<sup>(i)</sup>-η∂ℒ/∂b
Während des Trainings sollen die Optimierungsschritte unter Berücksichtigung des gesamten Datensatzes berechnet werden (denken Sie daran, dass der Verlust als Summe über alle Trainingsproben berechnet wird). In der Praxis nehmen wir jedoch kleine Portionen des Datensatzes, die als **Minibatches** bezeichnet werden, und berechnen die Gradienten basierend auf einer Teilmenge von Daten. Da die Teilmenge jedes Mal zufällig ausgewählt wird, wird diese Methode als **stochastischer Gradientabstieg** (SGD) bezeichnet.
Während des Trainings sollten die Optimierungsschritte unter Berücksichtigung des gesamten Datensatzes berechnet werden (denk daran, dass der Verlust als Summe über alle Trainingsbeispiele berechnet wird). In der Praxis nehmen wir jedoch kleine Teile des Datensatzes, sogenannte **Minibatches**, und berechnen die Gradienten basierend auf einem Teil der Daten. Da der Teil jedes Mal zufällig ausgewählt wird, wird diese Methode als **stochastischer Gradient Descent** (SGD) bezeichnet.
## Mehrschichtige Perzeptrons und Rückpropagation
## Mehrschichtige Perzeptrons und Backpropagation
Das einlagige Netzwerk, wie wir oben gesehen haben, ist in der Lage, linear separierbare Klassen zu klassifizieren. Um ein reichhaltigeres Modell zu erstellen, können wir mehrere Schichten des Netzwerks kombinieren. Mathematisch würde das bedeuten, dass die Funktion *f* eine komplexere Form annehmen würde und in mehreren Schritten berechnet wird:
Ein einlagiges Netzwerk, wie wir oben gesehen haben, ist in der Lage, linear separierbare Klassen zu klassifizieren. Um ein komplexeres Modell zu erstellen, können wir mehrere Schichten des Netzwerks kombinieren. Mathematisch bedeutet dies, dass die Funktion *f* eine komplexere Form annimmt und in mehreren Schritten berechnet wird:
* z<sub>1</sub>=w<sub>1</sub>x+b<sub>1</sub>
* z<sub>2</sub>=w<sub>2</sub>α(z<sub>1</sub>)+b<sub>2</sub>
* f = σ(z<sub>2</sub>)
Hier ist α eine **nicht-lineare Aktivierungsfunktion**, σ ist eine Softmax-Funktion, und die Parameter sind θ=<*w<sub>1</sub>,b<sub>1</sub>,w<sub>2</sub>,b<sub>2</sub>*>.
Hierbei ist α eine **nichtlineare Aktivierungsfunktion**, σ eine Softmax-Funktion, und die Parameter θ=<*w<sub>1</sub>,b<sub>1</sub>,w<sub>2</sub>,b<sub>2</sub>*>.
Der Gradientabstiegsalgorithmus bleibt derselbe, aber es wird schwieriger, die Gradienten zu berechnen. Gegebenen der Kettenregel für Ableitungen können wir die Ableitungen wie folgt berechnen:
Der Gradient-Descent-Algorithmus bleibt derselbe, aber die Berechnung der Gradienten wird schwieriger. Mithilfe der Kettenregel der Differentiation können wir die Ableitungen wie folgt berechnen:
* ∂ℒ/∂w<sub>2</sub> = (∂ℒ/∂σ)(∂σ/∂z<sub>2</sub>)(∂z<sub>2</sub>/∂w<sub>2</sub>)
* ∂ℒ/∂w<sub>1</sub> = (∂ℒ/∂σ)(∂σ/∂z<sub>2</sub>)(∂z<sub>2</sub>/∂α)(∂α/∂z<sub>1</sub>)(∂z<sub>1</sub>/∂w<sub>1</sub>)
> ✅ Die Kettenregel wird verwendet, um die Ableitungen der Verlustfunktion bezüglich der Parameter zu berechnen.
> ✅ Die Kettenregel der Differentiation wird verwendet, um die Ableitungen der Verlustfunktion in Bezug auf die Parameter zu berechnen.
Beachten Sie, dass der linkeste Teil all dieser Ausdrücke gleich ist, und somit können wir die Ableitungen effektiv berechnen, indem wir von der Verlustfunktion ausgehen und "rückwärts" durch den Berechnungsgraphen gehen. Daher wird die Methode zum Trainieren eines mehrschichtigen Perzeptrons als **Rückpropagation** oder 'Backprop' bezeichnet.
Beachte, dass der linke Teil all dieser Ausdrücke identisch ist, und daher können wir die Ableitungen effizient berechnen, indem wir von der Verlustfunktion ausgehend "rückwärts" durch den Berechnungsgraphen gehen. Daher wird die Methode zum Trainieren eines mehrschichtigen Perzeptrons als **Backpropagation** oder 'Backprop' bezeichnet.
<img alt="Berechnungsgraph" src="images/ComputeGraphGrad.png"/>
> TODO: Bildnachweis
> ✅ Wir werden die Rückpropagation in unserem Notizbuchbeispiel viel detaillierter behandeln.
> ✅ Wir werden Backpropagation in unserem Notebook-Beispiel noch viel detaillierter behandeln.
## Fazit
In dieser Lektion haben wir unsere eigene Bibliothek für neuronale Netzwerke erstellt und sie für eine einfache zweidimensionale Klassifikationsaufgabe verwendet.
In dieser Lektion haben wir unsere eigene Bibliothek für neuronale Netze erstellt und sie für eine einfache zweidimensionale Klassifikationsaufgabe verwendet.
## 🚀 Herausforderung
Im begleitenden Notizbuch werden Sie Ihr eigenes Framework zur Erstellung und zum Training von mehrschichtigen Perzeptrons implementieren. Sie werden im Detail sehen, wie moderne neuronale Netzwerke funktionieren.
Im begleitenden Notebook wirst du dein eigenes Framework zur Erstellung und zum Training mehrschichtiger Perzeptrons implementieren. Du wirst im Detail sehen, wie moderne neuronale Netze funktionieren.
Gehen Sie zum Notizbuch [OwnFramework](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) und arbeiten Sie es durch.
Gehe zum [OwnFramework](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) Notebook und arbeite es durch.
## [Nachvorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/204)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/204)
## Überprüfung & Selbststudium
## Rückblick & Selbststudium
Rückpropagation ist ein gängiger Algorithmus, der in KI und ML verwendet wird und es wert ist, [im Detail](https://wikipedia.org/wiki/Backpropagation) studiert zu werden.
Backpropagation ist ein gängiger Algorithmus in KI und ML, der es wert ist, [im Detail](https://wikipedia.org/wiki/Backpropagation) studiert zu werden.
## [Aufgabe](lab/README.md)
In diesem Labor werden Sie gebeten, das Framework, das Sie in dieser Lektion erstellt haben, zu verwenden, um die Klassifikation handgeschriebener Ziffern im MNIST-Datensatz zu lösen.
In diesem Labor wirst du das Framework, das du in dieser Lektion erstellt hast, verwenden, um die Klassifikation handgeschriebener Ziffern aus dem MNIST-Datensatz zu lösen.
* [Anleitungen](lab/README.md)
* [Notizbuch](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/lab/MyFW_MNIST.ipynb)
* [Anweisungen](lab/README.md)
* [Notebook](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/lab/MyFW_MNIST.ipynb)
**Haftungsausschluss**:
Dieses Dokument wurde mit Hilfe von KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

25
translations/de/lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md
View File

@ -1,23 +1,32 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "48fdd704d483e19bc3d7464074c9fcbe",
"translation_date": "2025-08-24T09:40:10+00:00",
"source_file": "lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md",
"language_code": "de"
}
-->
# MNIST-Klassifikation mit unserem eigenen Framework
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
Löse das Problem der Klassifikation handgeschriebener Ziffern im MNIST-Datensatz mithilfe von 1-, 2- und 3-schichtigen Perzeptronen. Nutze das neuronale Netzwerk-Framework, das wir in der Lektion entwickelt haben.
Lösen Sie das MNIST-Problem der handschriftlichen Ziffernklassifikation mithilfe eines 1-, 2- und 3-schichtigen Perzeptrons. Verwenden Sie das neuronale Netzwerk-Framework, das wir in der Lektion entwickelt haben.
## Notebook starten
## Start-Notebook
Beginne das Labor, indem du [MyFW_MNIST.ipynb](../../../../../../lessons/3-NeuralNetworks/04-OwnFramework/lab/MyFW_MNIST.ipynb) öffnest.
Beginnen Sie das Labor, indem Sie [MyFW_MNIST.ipynb](../../../../../../lessons/3-NeuralNetworks/04-OwnFramework/lab/MyFW_MNIST.ipynb) öffnen.
## Fragen
Versuche als Ergebnis dieses Labors die folgenden Fragen zu beantworten:
Versuchen Sie, als Ergebnis dieses Labors die folgenden Fragen zu beantworten:
- Beeinflusst die Aktivierungsfunktion zwischen den Schichten die Leistung des Netzwerks?
- Beeinflusst die Aktivierungsfunktion zwischen den Schichten die Netzwerkleistung?
- Benötigen wir für diese Aufgabe ein 2- oder 3-schichtiges Netzwerk?
- Hattest du Probleme beim Trainieren des Netzwerks? Besonders als die Anzahl der Schichten zunahm.
- Wie verhalten sich die Gewichte des Netzwerks während des Trainings? Du kannst den maximalen Absolutwert der Gewichte im Vergleich zur Epoche auftragen, um die Beziehung zu verstehen.
- Sind während des Trainings des Netzwerks Probleme aufgetreten? Besonders, wenn die Anzahl der Schichten zunahm.
- Wie verhalten sich die Gewichte des Netzwerks während des Trainings? Sie können den maximalen absoluten Wert der Gewichte im Vergleich zur Epoche plotten, um die Beziehung zu verstehen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die maßgebliche Quelle angesehen werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung resultieren.
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 sich aus der Nutzung dieser Übersetzung ergeben.

91
translations/de/lessons/3-NeuralNetworks/05-Frameworks/README.md
View File

@ -1,37 +1,46 @@
# Frameworks für Neuronale Netzwerke
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "2b544f20b796402507fb05a0df893323",
"translation_date": "2025-08-24T09:40:17+00:00",
"source_file": "lessons/3-NeuralNetworks/05-Frameworks/README.md",
"language_code": "de"
}
-->
# Neuronale Netzwerk-Frameworks
Wie wir bereits gelernt haben, um neuronale Netzwerke effizient zu trainieren, müssen wir zwei Dinge tun:
Wie wir bereits gelernt haben, müssen wir zwei Dinge tun, um neuronale Netzwerke effizient trainieren zu können:
* Mit Tensors arbeiten, z. B. multiplizieren, addieren und Funktionen wie Sigmoid oder Softmax berechnen
* Die Gradienten aller Ausdrücke berechnen, um die Optimierung durch Gradientenabstieg durchzuführen
* Mit Tensoren arbeiten, z. B. multiplizieren, addieren und Funktionen wie Sigmoid oder Softmax berechnen
* Gradienten aller Ausdrücke berechnen, um die Gradientenabstiegsoptimierung durchzuführen
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/105)
## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/105)
Während die `numpy` Bibliothek den ersten Teil erledigen kann, benötigen wir einen Mechanismus zur Berechnung von Gradienten. In [unserem Framework](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb), das wir im vorherigen Abschnitt entwickelt haben, mussten wir alle Ableitungsfunktionen manuell innerhalb der `backward` Methode programmieren, die Backpropagation durchführt. Idealerweise sollte ein Framework uns die Möglichkeit geben, die Gradienten *jeden Ausdrucks* zu berechnen, den wir definieren können.
Während die Bibliothek `numpy` den ersten Teil übernehmen kann, benötigen wir einen Mechanismus, um Gradienten zu berechnen. In [unserem Framework](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb), das wir im vorherigen Abschnitt entwickelt haben, mussten wir alle Ableitungsfunktionen manuell im `backward`-Methodenprogrammieren, die die Rückwärtspropagation durchführt. Idealerweise sollte ein Framework uns die Möglichkeit geben, Gradienten für *jeden Ausdruck* zu berechnen, den wir definieren können.
Ein weiterer wichtiger Aspekt ist die Fähigkeit, Berechnungen auf der GPU oder anderen spezialisierten Recheneinheiten wie [TPU](https://en.wikipedia.org/wiki/Tensor_Processing_Unit) durchzuführen. Das Training tiefer neuronaler Netzwerke erfordert *eine Menge* Berechnungen, und die Möglichkeit, diese Berechnungen auf GPUs zu parallelisieren, ist von großer Bedeutung.
Ein weiterer wichtiger Punkt ist die Möglichkeit, Berechnungen auf der GPU oder anderen spezialisierten Recheneinheiten wie [TPU](https://en.wikipedia.org/wiki/Tensor_Processing_Unit) durchzuführen. Das Training tiefer neuronaler Netzwerke erfordert *sehr viele* Berechnungen, und die Möglichkeit, diese Berechnungen auf GPUs zu parallelisieren, ist von großer Bedeutung.
> ✅ Der Begriff 'parallelisieren' bedeutet, die Berechnungen auf mehrere Geräte zu verteilen.
Derzeit sind die beiden beliebtesten neuronalen Frameworks: [TensorFlow](http://TensorFlow.org) und [PyTorch](https://pytorch.org/). Beide bieten eine Low-Level-API, um mit Tensors sowohl auf CPU als auch auf GPU zu arbeiten. Darüber hinaus gibt es eine höherstufige API, die entsprechend [Keras](https://keras.io/) und [PyTorch Lightning](https://pytorchlightning.ai/) genannt wird.
Derzeit sind die beiden beliebtesten neuronalen Frameworks: [TensorFlow](http://TensorFlow.org) und [PyTorch](https://pytorch.org/). Beide bieten eine Low-Level-API, um mit Tensoren sowohl auf der CPU als auch auf der GPU zu arbeiten. Zusätzlich zur Low-Level-API gibt es auch eine High-Level-API, die entsprechend [Keras](https://keras.io/) und [PyTorch Lightning](https://pytorchlightning.ai/) genannt wird.
Low-Level API | [TensorFlow](http://TensorFlow.org) | [PyTorch](https://pytorch.org/)
--------------|-------------------------------------|--------------------------------
High-level API| [Keras](https://keras.io/) | [PyTorch Lightning](https://pytorchlightning.ai/)
High-Level API| [Keras](https://keras.io/) | [PyTorch Lightning](https://pytorchlightning.ai/)
**Low-Level APIs** in beiden Frameworks ermöglichen es Ihnen, sogenannte **Berechnungsgraphen** zu erstellen. Dieser Graph definiert, wie man die Ausgabe (normalerweise die Verlustfunktion) mit gegebenen Eingabeparametern berechnet und kann zur Berechnung auf der GPU verschoben werden, wenn diese verfügbar ist. Es gibt Funktionen, um diesen Berechnungsgraphen zu differenzieren und Gradienten zu berechnen, die dann zur Optimierung der Modellparameter verwendet werden können.
**Low-Level-APIs** in beiden Frameworks ermöglichen es, sogenannte **Rechengraphen** zu erstellen. Dieser Graph definiert, wie die Ausgabe (normalerweise die Verlustfunktion) mit gegebenen Eingabeparametern berechnet wird, und kann zur Berechnung auf die GPU übertragen werden, falls verfügbar. Es gibt Funktionen, um diesen Rechengraphen zu differenzieren und Gradienten zu berechnen, die dann zur Optimierung der Modellparameter verwendet werden können.
**High-Level APIs** betrachten neuronale Netzwerke im Wesentlichen als eine **Folge von Schichten** und erleichtern den Aufbau der meisten neuronalen Netzwerke erheblich. Das Training des Modells erfordert normalerweise die Vorbereitung der Daten und dann das Aufrufen einer `fit` Funktion, um die Arbeit zu erledigen.
**High-Level-APIs** betrachten neuronale Netzwerke im Wesentlichen als eine **Abfolge von Schichten** und erleichtern den Aufbau der meisten neuronalen Netzwerke erheblich. Das Training des Modells erfordert in der Regel die Vorbereitung der Daten und dann das Aufrufen einer `fit`-Funktion, um die Arbeit zu erledigen.
Die hochgradige API ermöglicht es Ihnen, typische neuronale Netzwerke sehr schnell zu konstruieren, ohne sich um viele Details kümmern zu müssen. Gleichzeitig bieten Low-Level-APIs viel mehr Kontrolle über den Trainingsprozess, und daher werden sie häufig in der Forschung verwendet, wenn es darum geht, neue Architekturen neuronaler Netzwerke zu entwickeln.
Die High-Level-API ermöglicht es, typische neuronale Netzwerke sehr schnell zu erstellen, ohne sich um viele Details kümmern zu müssen. Gleichzeitig bieten Low-Level-APIs viel mehr Kontrolle über den Trainingsprozess und werden daher häufig in der Forschung verwendet, wenn man mit neuen Architekturen neuronaler Netzwerke arbeitet.
Es ist auch wichtig zu verstehen, dass Sie beide APIs zusammen verwenden können, z. B. können Sie Ihre eigene Netzwerkarchitektur mit der Low-Level-API entwickeln und sie dann in das größere Netzwerk einfügen, das mit der High-Level-API konstruiert und trainiert wurde. Oder Sie können ein Netzwerk mit der High-Level-API als Folge von Schichten definieren und dann Ihre eigene Low-Level-Trainingsschleife verwenden, um die Optimierung durchzuführen. Beide APIs verwenden die gleichen grundlegenden zugrunde liegenden Konzepte und sind so gestaltet, dass sie gut zusammenarbeiten.
Es ist auch wichtig zu verstehen, dass beide APIs zusammen verwendet werden können, z. B. kann man eine eigene Netzwerkschichtarchitektur mit der Low-Level-API entwickeln und diese dann in einem größeren Netzwerk verwenden, das mit der High-Level-API erstellt und trainiert wurde. Oder man definiert ein Netzwerk mit der High-Level-API als Abfolge von Schichten und verwendet dann eine eigene Low-Level-Trainingsschleife zur Optimierung. Beide APIs basieren auf denselben grundlegenden Konzepten und sind so konzipiert, dass sie gut zusammenarbeiten.
## Lernen
In diesem Kurs bieten wir den Großteil des Inhalts sowohl für PyTorch als auch für TensorFlow an. Sie können Ihr bevorzugtes Framework auswählen und nur die entsprechenden Notebooks durchgehen. Wenn Sie sich nicht sicher sind, welches Framework Sie wählen sollen, lesen Sie einige Diskussionen im Internet über **PyTorch vs. TensorFlow**. Sie können auch beide Frameworks betrachten, um ein besseres Verständnis zu bekommen.
In diesem Kurs bieten wir die meisten Inhalte sowohl für PyTorch als auch für TensorFlow an. Sie können Ihr bevorzugtes Framework auswählen und nur die entsprechenden Notebooks durchgehen. Wenn Sie sich nicht sicher sind, welches Framework Sie wählen sollen, lesen Sie einige Diskussionen im Internet über **PyTorch vs. TensorFlow**. Sie können sich auch beide Frameworks ansehen, um ein besseres Verständnis zu bekommen.
Wo immer möglich, werden wir High-Level-APIs zur Vereinfachung verwenden. Wir glauben jedoch, dass es wichtig ist, zu verstehen, wie neuronale Netzwerke von Grund auf funktionieren, weshalb wir zu Beginn mit der Low-Level-API und Tensors arbeiten. Wenn Sie jedoch schnell vorankommen und nicht viel Zeit mit dem Lernen dieser Details verbringen möchten, können Sie diese überspringen und direkt zu den High-Level-API-Notebooks gehen.
Wo möglich, verwenden wir High-Level-APIs der Einfachheit halber. Wir glauben jedoch, dass es wichtig ist, zu verstehen, wie neuronale Netzwerke von Grund auf funktionieren. Daher beginnen wir zunächst mit der Arbeit mit Low-Level-APIs und Tensoren. Wenn Sie jedoch schnell loslegen möchten und nicht viel Zeit mit diesen Details verbringen möchten, können Sie diese überspringen und direkt zu den High-Level-API-Notebooks wechseln.
## ✍️ Übungen: Frameworks
@ -39,65 +48,65 @@ Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
Low-Level API | [TensorFlow+Keras Notebook](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [PyTorch](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb)
--------------|-------------------------------------|--------------------------------
High-level API| [Keras](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) | *PyTorch Lightning*
High-Level API| [Keras](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) | *PyTorch Lightning*
Nachdem Sie die Frameworks gemeistert haben, lassen Sie uns das Konzept des Overfittings zusammenfassen.
Nachdem Sie die Frameworks gemeistert haben, lassen Sie uns das Konzept des Overfittings rekapitulieren.
# Overfitting
Overfitting ist ein äußerst wichtiges Konzept im maschinellen Lernen, und es ist sehr wichtig, es richtig zu verstehen!
Betrachten Sie das folgende Problem, 5 Punkte (dargestellt durch `x` in den Grafiken unten) zu approximieren:
Betrachten Sie das folgende Problem der Annäherung an 5 Punkte (dargestellt durch `x` in den untenstehenden Diagrammen):
![linear](../../../../../translated_images/overfit1.f24b71c6f652e59e6bed7245ffbeaecc3ba320e16e2221f6832b432052c4da43.de.jpg) | ![overfit](../../../../../translated_images/overfit2.131f5800ae10ca5e41d12a411f5f705d9ee38b1b10916f284b787028dd55cc1c.de.jpg)
![linear](../../../../../lessons/3-NeuralNetworks/images/overfit1.jpg) | ![overfit](../../../../../lessons/3-NeuralNetworks/images/overfit2.jpg)
-------------------------|--------------------------
**Lineares Modell, 2 Parameter** | **Nicht-lineares Modell, 7 Parameter**
Training Fehler = 5.3 | Training Fehler = 0
Trainingsfehler = 5.3 | Trainingsfehler = 0
Validierungsfehler = 5.1 | Validierungsfehler = 20
* Links sehen wir eine gute gerade Linienapproximation. Da die Anzahl der Parameter angemessen ist, erfasst das Modell die Idee hinter der Punktverteilung gut.
* Rechts ist das Modell zu mächtig. Da wir nur 5 Punkte haben und das Modell 7 Parameter hat, kann es sich so anpassen, dass es durch alle Punkte verläuft, was den Trainingsfehler auf 0 reduziert. Dies hindert das Modell jedoch daran, das korrekte Muster hinter den Daten zu verstehen, sodass der Validierungsfehler sehr hoch ist.
* Links sehen wir eine gute lineare Annäherung. Da die Anzahl der Parameter angemessen ist, erfasst das Modell die Verteilung der Punkte korrekt.
* Rechts ist das Modell zu mächtig. Da wir nur 5 Punkte haben und das Modell 7 Parameter hat, kann es sich so anpassen, dass es durch alle Punkte verläuft, wodurch der Trainingsfehler 0 wird. Dies verhindert jedoch, dass das Modell das richtige Muster hinter den Daten versteht, was zu einem sehr hohen Validierungsfehler führt.
Es ist sehr wichtig, ein korrektes Gleichgewicht zwischen der Komplexität des Modells (Anzahl der Parameter) und der Anzahl der Trainingsproben zu finden.
Es ist sehr wichtig, ein korrektes Gleichgewicht zwischen der Komplexität des Modells (Anzahl der Parameter) und der Anzahl der Trainingsbeispiele zu finden.
## Warum Overfitting auftritt
* Nicht genügend Trainingsdaten
* Zu wenig Trainingsdaten
* Zu mächtiges Modell
* Zu viel Rauschen in den Eingabedaten
## Wie man Overfitting erkennt
Wie Sie aus dem obigen Diagramm sehen können, kann Overfitting durch einen sehr niedrigen Trainingsfehler und einen hohen Validierungsfehler erkannt werden. Normalerweise sehen wir während des Trainings, dass sowohl der Trainings- als auch der Validierungsfehler zu sinken beginnen, und dann kann der Validierungsfehler an einem bestimmten Punkt aufhören zu sinken und anfangen zu steigen. Dies wird ein Zeichen für Overfitting sein und der Hinweis, dass wir wahrscheinlich an dieser Stelle das Training stoppen sollten (oder zumindest einen Snapshot des Modells erstellen sollten).
Wie Sie aus dem obigen Diagramm sehen können, kann Overfitting durch einen sehr niedrigen Trainingsfehler und einen hohen Validierungsfehler erkannt werden. Normalerweise sehen wir während des Trainings, dass sowohl der Trainings- als auch der Validierungsfehler zunächst abnehmen. An einem bestimmten Punkt könnte der Validierungsfehler jedoch aufhören zu sinken und anfangen zu steigen. Dies ist ein Zeichen für Overfitting und ein Hinweis darauf, dass wir das Training an diesem Punkt wahrscheinlich stoppen sollten (oder zumindest einen Schnappschuss des Modells machen sollten).
![overfitting](../../../../../translated_images/Overfitting.408ad91cd90b4371d0a81f4287e1409c359751adeb1ae450332af50e84f08c3e.de.png)
![overfitting](../../../../../lessons/3-NeuralNetworks/images/Overfitting.png)
## Wie man Overfitting verhindert
Wenn Sie sehen, dass Overfitting auftritt, können Sie Folgendes tun:
Wenn Sie feststellen, dass Overfitting auftritt, können Sie Folgendes tun:
* Erhöhen Sie die Menge an Trainingsdaten
* Verringern Sie die Komplexität des Modells
* Verwenden Sie eine [Regularisierungstechnik](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md), wie z. B. [Dropout](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md#Dropout), die wir später betrachten werden.
* Die Menge der Trainingsdaten erhöhen
* Die Komplexität des Modells verringern
* Eine [Regularisierungstechnik](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md) verwenden, wie z. B. [Dropout](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md#Dropout), die wir später betrachten werden.
## Overfitting und Bias-Varianz-Handel
## Overfitting und Bias-Varianz-Abwägung
Overfitting ist tatsächlich ein Fall eines allgemeineren Problems in der Statistik, das als [Bias-Varianz-Handel](https://en.wikipedia.org/wiki/Bias%E2%80%93variance_tradeoff) bekannt ist. Wenn wir die möglichen Fehlerquellen in unserem Modell betrachten, können wir zwei Arten von Fehlern sehen:
Overfitting ist tatsächlich ein Fall eines allgemeineren Problems in der Statistik, das als [Bias-Varianz-Abwägung](https://en.wikipedia.org/wiki/Bias%E2%80%93variance_tradeoff) bezeichnet wird. Wenn wir die möglichen Fehlerquellen in unserem Modell betrachten, können wir zwei Arten von Fehlern erkennen:
* **Bias-Fehler** entstehen, weil unser Algorithmus nicht in der Lage ist, die Beziehung zwischen den Trainingsdaten korrekt zu erfassen. Dies kann darauf zurückzuführen sein, dass unser Modell nicht mächtig genug ist (**Underfitting**).
* **Varianz-Fehler**, die entstehen, weil das Modell Rauschen in den Eingabedaten anstelle von bedeutungsvollen Beziehungen approximiert (**Overfitting**).
* **Bias-Fehler** entstehen dadurch, dass unser Algorithmus die Beziehung zwischen den Trainingsdaten nicht korrekt erfassen kann. Dies kann darauf zurückzuführen sein, dass unser Modell nicht mächtig genug ist (**Underfitting**).
* **Varianz-Fehler**, die dadurch entstehen, dass das Modell Rauschen in den Eingabedaten anstelle einer sinnvollen Beziehung approximiert (**Overfitting**).
Während des Trainings nimmt der Bias-Fehler ab (da unser Modell lernt, die Daten zu approximieren), und der Varianz-Fehler nimmt zu. Es ist wichtig, das Training zu stoppen - entweder manuell (wenn wir Overfitting erkennen) oder automatisch (durch Einführung von Regularisierung) - um Overfitting zu verhindern.
Während des Trainings nimmt der Bias-Fehler ab (da unser Modell lernt, die Daten zu approximieren), und der Varianz-Fehler nimmt zu. Es ist wichtig, das Training zu stoppen - entweder manuell (wenn wir Overfitting erkennen) oder automatisch (durch Einführung von Regularisierung) -, um Overfitting zu verhindern.
## Fazit
In dieser Lektion haben Sie die Unterschiede zwischen den verschiedenen APIs der beiden beliebtesten KI-Frameworks, TensorFlow und PyTorch, kennengelernt. Darüber hinaus haben Sie ein sehr wichtiges Thema, Overfitting, behandelt.
In dieser Lektion haben Sie die Unterschiede zwischen den verschiedenen APIs der beiden beliebtesten KI-Frameworks, TensorFlow und PyTorch, kennengelernt. Außerdem haben Sie ein sehr wichtiges Thema, Overfitting, behandelt.
## 🚀 Herausforderung
In den begleitenden Notebooks finden Sie am Ende 'Aufgaben'; arbeiten Sie die Notebooks durch und erfüllen Sie die Aufgaben.
In den begleitenden Notebooks finden Sie 'Aufgaben' am Ende; arbeiten Sie die Notebooks durch und lösen Sie die Aufgaben.
## [Nachlesequiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/205)
## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/205)
## Überprüfung & Selbststudium
@ -114,10 +123,10 @@ Stellen Sie sich die folgenden Fragen:
## [Aufgabe](lab/README.md)
In diesem Labor werden Sie gebeten, zwei Klassifikationsprobleme mit ein- und mehrschichtigen voll verbundenen Netzwerken mit PyTorch oder TensorFlow zu lösen.
In diesem Labor sollen Sie zwei Klassifikationsprobleme mit ein- und mehrschichtigen vollständig verbundenen Netzwerken mithilfe von PyTorch oder TensorFlow lösen.
* [Anweisungen](lab/README.md)
* [Anleitung](lab/README.md)
* [Notebook](../../../../../lessons/3-NeuralNetworks/05-Frameworks/lab/LabFrameworks.ipynb)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

21
translations/de/lessons/3-NeuralNetworks/05-Frameworks/lab/README.md
View File

@ -1,19 +1,28 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "e452d897efb9a89700f41021834cf6e5",
"translation_date": "2025-08-24T09:40:45+00:00",
"source_file": "lessons/3-NeuralNetworks/05-Frameworks/lab/README.md",
"language_code": "de"
}
-->
# Klassifikation mit PyTorch/TensorFlow
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
Lösen Sie zwei Klassifikationsprobleme mithilfe von ein- und mehrschichtigen vollständig verbundenen Netzwerken mit PyTorch oder TensorFlow:
Lösen Sie zwei Klassifikationsprobleme mit ein- und mehrschichtigen vollständig verbundenen Netzwerken unter Verwendung von PyTorch oder TensorFlow:
1. **[Iris-Klassifikation](https://en.wikipedia.org/wiki/Iris_flower_data_set)** - ein Beispiel für ein Problem mit tabellarischen Eingabedaten, das mit klassischem maschinellem Lernen bearbeitet werden kann. Ihr Ziel ist es, Irisblumen in 3 Klassen basierend auf 4 numerischen Parametern zu klassifizieren.
2. **MNIST** Klassifikation handgeschriebener Ziffern, die wir bereits gesehen haben.
1. **[Iris-Klassifikation](https://en.wikipedia.org/wiki/Iris_flower_data_set)** - ein Beispiel für ein Problem mit tabellarischen Eingabedaten, das durch klassische maschinelle Lernmethoden gelöst werden kann. Ihr Ziel ist es, Iris-Blumen basierend auf 4 numerischen Parametern in 3 Klassen zu klassifizieren.
1. **MNIST**-Handschriftenerkennung, ein Problem, das wir bereits zuvor behandelt haben.
Probieren Sie verschiedene Netzwerkarchitekturen aus, um die bestmögliche Genauigkeit zu erreichen.
Probieren Sie verschiedene Netzwerkarchitekturen aus, um die bestmögliche Genauigkeit zu erzielen.
## Notizbuch starten
## Start-Notebook
Beginnen Sie das Labor, indem Sie [LabFrameworks.ipynb](../../../../../../lessons/3-NeuralNetworks/05-Frameworks/lab/LabFrameworks.ipynb) öffnen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle angesehen werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung resultieren.
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.

49
translations/de/lessons/3-NeuralNetworks/README.md
View File

@ -1,51 +1,60 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1c6b8c7c1778a35fc1139b7f2aecb7b3",
"translation_date": "2025-08-24T09:39:36+00:00",
"source_file": "lessons/3-NeuralNetworks/README.md",
"language_code": "de"
}
-->
# Einführung in Neuronale Netzwerke
![Zusammenfassung des Inhalts zu Einführung in Neuronale Netzwerke in einem Doodle](../../../../translated_images/ai-neuralnetworks.1c687ae40bc86e834f497844866a26d3e0886650a67a4bbe29442e2f157d3b18.de.png)
![Zusammenfassung des Inhalts zu neuronalen Netzwerken in einer Skizze](../../../../lessons/sketchnotes/ai-neuralnetworks.png)
Wie wir in der Einführung besprochen haben, ist eine der Möglichkeiten, Intelligenz zu erreichen, ein **Computermodell** oder ein **künstliches Gehirn** zu trainieren. Seit der Mitte des 20. Jahrhunderts haben Forscher verschiedene mathematische Modelle ausprobiert, bis sich in den letzten Jahren diese Richtung als äußerst erfolgreich erwies. Solche mathematischen Modelle des Gehirns werden als **neuronale Netzwerke** bezeichnet.
Wie wir in der Einführung besprochen haben, ist eine Möglichkeit, Intelligenz zu erreichen, das Training eines **Computermodells** oder eines **künstlichen Gehirns**. Seit Mitte des 20. Jahrhunderts haben Forscher verschiedene mathematische Modelle ausprobiert, bis sich in den letzten Jahren dieser Ansatz als äußerst erfolgreich erwiesen hat. Solche mathematischen Modelle des Gehirns werden als **neuronale Netzwerke** bezeichnet.
> Manchmal werden neuronale Netzwerke als *Künstliche Neuronale Netzwerke* (ANNs) bezeichnet, um zu verdeutlichen, dass wir von Modellen und nicht von echten Netzwerken von Neuronen sprechen.
> Manchmal werden neuronale Netzwerke als *Künstliche Neuronale Netzwerke* (Artificial Neural Networks, ANNs) bezeichnet, um klarzustellen, dass es sich um Modelle handelt und nicht um echte Netzwerke von Neuronen.
## Maschinelles Lernen
Neuronale Netzwerke sind ein Teil eines größeren Fachgebiets, das **Maschinelles Lernen** genannt wird, dessen Ziel es ist, Daten zu verwenden, um Computermodelle zu trainieren, die in der Lage sind, Probleme zu lösen. Maschinelles Lernen ist ein großer Teil der Künstlichen Intelligenz, jedoch behandeln wir klassisches ML in diesem Lehrplan nicht.
Neuronale Netzwerke sind Teil einer größeren Disziplin namens **Maschinelles Lernen**, deren Ziel es ist, Daten zu nutzen, um Computermodelle zu trainieren, die Probleme lösen können. Maschinelles Lernen macht einen großen Teil der Künstlichen Intelligenz aus, jedoch behandeln wir in diesem Lehrplan nicht das klassische ML.
> Besuchen Sie unseren separaten **[Maschinelles Lernen für Anfänger](http://github.com/microsoft/ml-for-beginners)** Lehrplan, um mehr über klassisches Maschinelles Lernen zu erfahren.
Im Maschinellen Lernen nehmen wir an, dass wir einen Datensatz von Beispielen **X** und die entsprechenden Ausgabewerte **Y** haben. Beispiele sind oft N-dimensionale Vektoren, die aus **Merkmalen** bestehen, und Ausgaben werden als **Labels** bezeichnet.
Im Maschinellen Lernen gehen wir davon aus, dass wir einen Datensatz mit Beispielen **X** und den entsprechenden Ausgabewerten **Y** haben. Beispiele sind oft N-dimensionale Vektoren, die aus **Merkmalen** bestehen, und Ausgaben werden als **Labels** bezeichnet.
Wir werden die zwei häufigsten Probleme des maschinellen Lernens betrachten:
Wir betrachten die zwei häufigsten Probleme des Maschinellen Lernens:
* **Klassifikation**, bei der wir ein Eingabeobjekt in zwei oder mehr Klassen einordnen müssen.
* **Regression**, bei der wir eine numerische Zahl für jede der Eingabemuster vorhersagen müssen.
* **Klassifikation**, bei der ein Eingabeobjekt in zwei oder mehr Klassen eingeteilt werden muss.
* **Regression**, bei der für jede Eingabeprobe eine numerische Zahl vorhergesagt werden muss.
> Wenn Eingaben und Ausgaben als Tensoren dargestellt werden, ist der Eingabedatensatz eine Matrix der Größe M×N, wobei M die Anzahl der Proben und N die Anzahl der Merkmale ist. Die Ausgabelabel Y ist der Vektor der Größe M.
> Wenn Eingaben und Ausgaben als Tensoren dargestellt werden, ist der Eingabedatensatz eine Matrix der Größe M×N, wobei M die Anzahl der Proben und N die Anzahl der Merkmale ist. Die Ausgabelabels **Y** sind ein Vektor der Größe M.
In diesem Lehrplan konzentrieren wir uns ausschließlich auf Modelle neuronaler Netzwerke.
## Ein Modell eines Neurons
Aus der Biologie wissen wir, dass unser Gehirn aus Nervenzellen besteht, von denen jede mehrere "Eingänge" (Axone) und einen Ausgang (Dendrit) hat. Axone und Dendriten können elektrische Signale leiten, und die Verbindungen zwischen Axonen und Dendriten können unterschiedliche Leitfähigkeiten aufweisen (gesteuert durch Neuromediatoren).
Aus der Biologie wissen wir, dass unser Gehirn aus Nervenzellen besteht, von denen jede mehrere "Eingänge" (Axone) und einen Ausgang (Dendrit) hat. Axone und Dendriten können elektrische Signale leiten, und die Verbindungen zwischen Axonen und Dendriten können unterschiedliche Leitfähigkeitsgrade aufweisen (gesteuert durch Neurotransmitter).
![Modell eines Neurons](../../../../translated_images/synapse-wikipedia.ed20a9e4726ea1c6a3ce8fec51c0b9bec6181946dca0fe4e829bc12fa3bacf01.de.jpg) | ![Modell eines Neurons](../../../../translated_images/artneuron.1a5daa88d20ebe6f5824ddb89fba0bdaaf49f67e8230c1afbec42909df1fc17e.de.png)
![Modell eines Neurons](../../../../lessons/3-NeuralNetworks/images/synapse-wikipedia.jpg) | ![Modell eines Neurons](../../../../lessons/3-NeuralNetworks/images/artneuron.png)
----|----
Reales Neuron *([Bild](https://en.wikipedia.org/wiki/Synapse#/media/File:SynapseSchematic_lines.svg) von Wikipedia)* | Künstliches Neuron *(Bild vom Autor)*
Echtes Neuron *([Bild](https://en.wikipedia.org/wiki/Synapse#/media/File:SynapseSchematic_lines.svg) von Wikipedia)* | Künstliches Neuron *(Bild vom Autor)*
Somit enthält das einfachste mathematische Modell eines Neurons mehrere Eingänge X<sub>1</sub>, ..., X<sub>N</sub> und einen Ausgang Y sowie eine Reihe von Gewichten W<sub>1</sub>, ..., W<sub>N</sub>. Ein Ausgang wird berechnet als:
Das einfachste mathematische Modell eines Neurons enthält also mehrere Eingänge X<sub>1</sub>, ..., X<sub>N</sub> und einen Ausgang Y sowie eine Reihe von Gewichten W<sub>1</sub>, ..., W<sub>N</sub>. Der Ausgang wird berechnet als:
<img src="images/netout.png" alt="Y = f\left(\sum_{i=1}^N X_iW_i\right)" width="131" height="53" align="center"/>
wobei f eine nichtlineare **Aktivierungsfunktion** ist.
wobei **f** eine nichtlineare **Aktivierungsfunktion** ist.
> Frühe Modelle von Neuronen wurden in dem klassischen Papier [A logical calculus of the ideas immanent in nervous activity](https://www.cs.cmu.edu/~./epxing/Class/10715/reading/McCulloch.and.Pitts.pdf) von Warren McCullock und Walter Pitts im Jahr 1943 beschrieben. Donald Hebb schlug in seinem Buch "[The Organization of Behavior: A Neuropsychological Theory](https://books.google.com/books?id=VNetYrB8EBoC)" vor, wie diese Netzwerke trainiert werden können.
> Frühe Modelle von Neuronen wurden in dem klassischen Artikel [A logical calculus of the ideas immanent in nervous activity](https://www.cs.cmu.edu/~./epxing/Class/10715/reading/McCulloch.and.Pitts.pdf) von Warren McCullock und Walter Pitts im Jahr 1943 beschrieben. Donald Hebb schlug in seinem Buch "[The Organization of Behavior: A Neuropsychological Theory](https://books.google.com/books?id=VNetYrB8EBoC)" vor, wie solche Netzwerke trainiert werden können.
## In diesem Abschnitt
In diesem Abschnitt werden wir lernen über:
* [Perzeptron](03-Perceptron/README.md), eines der frühesten Modelle neuronaler Netzwerke für die Klassifikation in zwei Klassen
* [Mehrschichtige Netzwerke](04-OwnFramework/README.md) mit einem begleitenden Notizbuch [wie man unser eigenes Framework erstellt](../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb)
* [Frameworks für Neuronale Netzwerke](05-Frameworks/README.md), mit diesen Notizbüchern: [PyTorch](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) und [Keras/Tensorflow](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb)
In diesem Abschnitt lernen wir:
* [Perceptron](03-Perceptron/README.md), eines der frühesten neuronalen Netzwerkmodelle für Zwei-Klassen-Klassifikation
* [Mehrschichtige Netzwerke](04-OwnFramework/README.md) mit einem zugehörigen Notebook [wie man unser eigenes Framework erstellt](../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb)
* [Frameworks für neuronale Netzwerke](05-Frameworks/README.md), mit diesen Notebooks: [PyTorch](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) und [Keras/Tensorflow](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb)
* [Overfitting](../../../../lessons/3-NeuralNetworks/05-Frameworks)
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, bitten wir zu beachten, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die 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 Verwendung dieser Übersetzung entstehen.
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.

93
translations/de/lessons/4-ComputerVision/06-IntroCV/README.md
View File

@ -1,31 +1,40 @@
# Einführung in die Computer Vision
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "4bedc8e702db17260cfe824d58b6cfd4",
"translation_date": "2025-08-24T09:36:26+00:00",
"source_file": "lessons/4-ComputerVision/06-IntroCV/README.md",
"language_code": "de"
}
-->
# Einführung in Computer Vision
[Computer Vision](https://wikipedia.org/wiki/Computer_vision) ist ein Fachgebiet, das darauf abzielt, Computern ein umfassendes Verständnis digitaler Bilder zu ermöglichen. Diese Definition ist recht breit gefasst, da *Verstehen* viele verschiedene Bedeutungen haben kann, einschließlich der Identifizierung eines Objekts auf einem Bild (**Objekterkennung**), dem Verständnis dessen, was passiert (**Ereigniserkennung**), der Beschreibung eines Bildes in Text oder der Rekonstruktion einer Szene in 3D. Es gibt auch spezielle Aufgaben im Zusammenhang mit menschlichen Bildern: Alters- und Emotionserkennung, Gesichtserkennung und -identifikation sowie 3D-Pose-Schätzung, um nur einige zu nennen.
[Computer Vision](https://wikipedia.org/wiki/Computer_vision) ist ein Fachgebiet, dessen Ziel es ist, Computern ein hochgradiges Verständnis digitaler Bilder zu ermöglichen. Dies ist eine recht breite Definition, da *Verständnis* viele verschiedene Dinge bedeuten kann, wie z. B. das Finden eines Objekts auf einem Bild (**Objekterkennung**), das Verstehen, was passiert (**Ereigniserkennung**), das Beschreiben eines Bildes in Text oder die Rekonstruktion einer Szene in 3D. Es gibt auch spezielle Aufgaben im Zusammenhang mit menschlichen Bildern: Alter- und Emotionserkennung, Gesichtserkennung und -identifikation sowie 3D-Pose-Schätzung, um nur einige zu nennen.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/106)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/106)
Eine der einfachsten Aufgaben der Computer Vision ist die **Bildklassifizierung**.
Eine der einfachsten Aufgaben von Computer Vision ist die **Bildklassifikation**.
Computer Vision wird oft als ein Zweig der KI betrachtet. Heutzutage werden die meisten Aufgaben der Computer Vision mit Hilfe von neuronalen Netzwerken gelöst. In diesem Abschnitt werden wir mehr über die speziellen Arten von neuronalen Netzwerken lernen, die für Computer Vision verwendet werden, [faltungsneuronale Netzwerke](../07-ConvNets/README.md).
Computer Vision wird oft als ein Teilbereich der KI betrachtet. Heutzutage werden die meisten Aufgaben in Computer Vision mithilfe von neuronalen Netzwerken gelöst. Wir werden mehr über die spezielle Art von neuronalen Netzwerken lernen, die für Computer Vision verwendet werden, [Convolutional Neural Networks](../07-ConvNets/README.md), im Verlauf dieses Abschnitts.
Bevor Sie jedoch das Bild an ein neuronales Netzwerk übergeben, macht es in vielen Fällen Sinn, einige algorithmische Techniken zur Verbesserung des Bildes zu verwenden.
Bevor Sie jedoch ein Bild an ein neuronales Netzwerk weitergeben, macht es in vielen Fällen Sinn, einige algorithmische Techniken anzuwenden, um das Bild zu verbessern.
Es gibt mehrere Python-Bibliotheken für die Bildverarbeitung:
* **[imageio](https://imageio.readthedocs.io/en/stable/)** kann zum Lesen/Schreiben verschiedener Bildformate verwendet werden. Es unterstützt auch ffmpeg, ein nützliches Tool zum Konvertieren von Videobildern in Bilder.
* **[imageio](https://imageio.readthedocs.io/en/stable/)** kann verwendet werden, um verschiedene Bildformate zu lesen/schreiben. Es unterstützt auch ffmpeg, ein nützliches Tool, um Videobilder in Einzelbilder umzuwandeln.
* **[Pillow](https://pillow.readthedocs.io/en/stable/index.html)** (auch bekannt als PIL) ist etwas leistungsfähiger und unterstützt auch einige Bildmanipulationen wie Morphing, Palettenanpassungen und mehr.
* **[OpenCV](https://opencv.org/)** ist eine leistungsstarke Bildverarbeitungsbibliothek, die in C++ geschrieben wurde und zum *de facto* Standard für die Bildverarbeitung geworden ist. Sie hat eine praktische Python-Schnittstelle.
* **[dlib](http://dlib.net/)** ist eine C++-Bibliothek, die viele Algorithmen des maschinellen Lernens implementiert, einschließlich einiger Algorithmen der Computer Vision. Sie hat ebenfalls eine Python-Schnittstelle und kann für herausfordernde Aufgaben wie Gesichtserkennung und Erkennung von Gesichtsmerkmalen verwendet werden.
* **[OpenCV](https://opencv.org/)** ist eine leistungsstarke Bildverarbeitungsbibliothek, die in C++ geschrieben wurde und zum *de facto* Standard für Bildverarbeitung geworden ist. Sie verfügt über eine praktische Python-Schnittstelle.
* **[dlib](http://dlib.net/)** ist eine C++-Bibliothek, die viele maschinelle Lernalgorithmen implementiert, einschließlich einiger Computer-Vision-Algorithmen. Sie verfügt ebenfalls über eine Python-Schnittstelle und kann für anspruchsvolle Aufgaben wie Gesichts- und Gesichtsmerkmalserkennung verwendet werden.
## OpenCV
[OpenCV](https://opencv.org/) wird als der *de facto* Standard für die Bildverarbeitung angesehen. Es enthält viele nützliche Algorithmen, die in C++ implementiert sind. Sie können OpenCV auch aus Python heraus aufrufen.
[OpenCV](https://opencv.org/) gilt als der *de facto* Standard für Bildverarbeitung. Es enthält viele nützliche Algorithmen, die in C++ implementiert sind. Sie können OpenCV auch aus Python heraus verwenden.
Ein guter Ort, um OpenCV zu lernen, ist [dieser Learn OpenCV-Kurs](https://learnopencv.com/getting-started-with-opencv/). In unserem Lehrplan ist es nicht unser Ziel, OpenCV zu lernen, sondern Ihnen einige Beispiele zu zeigen, wann es verwendet werden kann und wie.
Eine gute Quelle, um OpenCV zu lernen, ist [dieser Learn OpenCV Kurs](https://learnopencv.com/getting-started-with-opencv/). In unserem Lehrplan ist es nicht unser Ziel, OpenCV zu lernen, sondern Ihnen einige Beispiele zu zeigen, wann und wie es verwendet werden kann.
### Bilder laden
Bilder in Python können bequem durch NumPy-Arrays dargestellt werden. Beispielsweise würden Graustufenbilder mit einer Größe von 320x200 Pixeln in einem 200x320-Array gespeichert werden, während Farbbilder derselben Dimension die Form 200x320x3 (für 3 Farbkanäle) hätten. Um ein Bild zu laden, können Sie den folgenden Code verwenden:
Bilder in Python können bequem durch NumPy-Arrays dargestellt werden. Zum Beispiel würden Graustufenbilder mit einer Größe von 320x200 Pixeln in einem 200x320-Array gespeichert, und Farbbilder derselben Dimension hätten die Form 200x320x3 (für 3 Farbkanäle). Um ein Bild zu laden, können Sie den folgenden Code verwenden:
```python
import cv2
@ -35,68 +44,68 @@ im = cv2.imread('image.jpeg')
plt.imshow(im)
```
Traditionell verwendet OpenCV die BGR (Blau-Grün-Rot) Kodierung für Farbbilder, während die meisten anderen Python-Tools das traditionellere RGB (Rot-Grün-Blau) verwenden. Damit das Bild richtig aussieht, müssen Sie es in den RGB-Farbraum konvertieren, entweder indem Sie die Dimensionen im NumPy-Array vertauschen oder eine OpenCV-Funktion aufrufen:
Traditionell verwendet OpenCV BGR (Blau-Grün-Rot) Kodierung für Farbbilder, während die restlichen Python-Tools die traditionellere RGB (Rot-Grün-Blau) Kodierung verwenden. Damit das Bild korrekt aussieht, müssen Sie es in den RGB-Farbraum konvertieren, entweder durch das Tauschen der Dimensionen im NumPy-Array oder durch Aufrufen einer OpenCV-Funktion:
```python
im = cv2.cvtColor(im,cv2.COLOR_BGR2RGB)
```
Die gleiche `cvtColor` function can be used to perform other color space transformations such as converting an image to grayscale or to the HSV (Hue-Saturation-Value) color space.
Die gleiche `cvtColor`-Funktion kann verwendet werden, um andere Farbraumtransformationen durchzuführen, wie z. B. die Konvertierung eines Bildes in Graustufen oder in den HSV-Farbraum (Farbton-Sättigung-Helligkeit).
You can also use OpenCV to load video frame-by-frame - an example is given in the exercise [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb).
Sie können OpenCV auch verwenden, um Videos Bild für Bild zu laden – ein Beispiel finden Sie in der Übung [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb).
### Image Processing
### Bildverarbeitung
Before feeding an image to a neural network, you may want to apply several pre-processing steps. OpenCV can do many things, including:
Bevor Sie ein Bild an ein neuronales Netzwerk weitergeben, möchten Sie möglicherweise mehrere Vorverarbeitungsschritte anwenden. OpenCV kann viele Dinge tun, einschließlich:
* **Resizing** the image using `im = cv2.resize(im, (320,200),interpolation=cv2.INTER_LANCZOS)`
* **Blurring** the image using `im = cv2.medianBlur(im,3)` or `im = cv2.GaussianBlur(im, (3,3), 0)`
* Changing the **brightness and contrast** of the image can be done by NumPy array manipulations, as described [in this Stackoverflow note](https://stackoverflow.com/questions/39308030/how-do-i-increase-the-contrast-of-an-image-in-python-opencv).
* Using [thresholding](https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html) by calling `cv2.threshold`/`cv2.adaptiveThreshold` Funktionen, die oft vorzuziehen sind, um Helligkeit oder Kontrast anzupassen.
* Verschiedene [Transformationen](https://docs.opencv.org/4.5.5/da/d6e/tutorial_py_geometric_transformations.html) auf das Bild anwenden:
- **[Affintransformationen](https://docs.opencv.org/4.5.5/d4/d61/tutorial_warp_affine.html)** können nützlich sein, wenn Sie Rotation, Größenänderung und Verzerrung des Bildes kombinieren müssen und die Quelle und Zielpositionen von drei Punkten im Bild kennen. Affintransformationen halten parallele Linien parallel.
- **[Perspektivtransformationen](https://medium.com/analytics-vidhya/opencv-perspective-transformation-9edffefb2143)** können nützlich sein, wenn Sie die Quelle und Zielpositionen von 4 Punkten im Bild kennen. Zum Beispiel, wenn Sie ein Bild eines rechteckigen Dokuments mit einer Smartphone-Kamera aus einem bestimmten Winkel aufnehmen und ein rechteckiges Bild des Dokuments selbst erstellen möchten.
* Bewegung im Bild verstehen, indem Sie **[optischen Fluss](https://docs.opencv.org/4.5.5/d4/dee/tutorial_optical_flow.html)** verwenden.
* **Größenänderung** des Bildes mit `im = cv2.resize(im, (320,200),interpolation=cv2.INTER_LANCZOS)`
* **Weichzeichnen** des Bildes mit `im = cv2.medianBlur(im,3)` oder `im = cv2.GaussianBlur(im, (3,3), 0)`
* Ändern der **Helligkeit und des Kontrasts** des Bildes kann durch Manipulationen von NumPy-Arrays erfolgen, wie [in dieser Stackoverflow-Notiz](https://stackoverflow.com/questions/39308030/how-do-i-increase-the-contrast-of-an-image-in-python-opencv) beschrieben.
* Verwenden von [Thresholding](https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html) durch Aufrufen der Funktionen `cv2.threshold`/`cv2.adaptiveThreshold`, was oft vorzuziehen ist gegenüber der Anpassung von Helligkeit oder Kontrast.
* Anwenden verschiedener [Transformationen](https://docs.opencv.org/4.5.5/da/d6e/tutorial_py_geometric_transformations.html) auf das Bild:
- **[Affine Transformationen](https://docs.opencv.org/4.5.5/d4/d61/tutorial_warp_affine.html)** können nützlich sein, wenn Sie Rotation, Größenänderung und Verzerrung des Bildes kombinieren müssen und die Quell- und Zielposition von drei Punkten im Bild kennen. Affine Transformationen halten parallele Linien parallel.
- **[Perspektivische Transformationen](https://medium.com/analytics-vidhya/opencv-perspective-transformation-9edffefb2143)** können nützlich sein, wenn Sie die Quell- und Zielpositionen von 4 Punkten im Bild kennen. Zum Beispiel, wenn Sie ein Bild eines rechteckigen Dokuments mit einer Smartphone-Kamera aus einem Winkel aufnehmen und ein rechteckiges Bild des Dokuments selbst erstellen möchten.
* Bewegung im Bild verstehen durch **[Optischen Fluss](https://docs.opencv.org/4.5.5/d4/dee/tutorial_optical_flow.html)**.
## Beispiele für die Verwendung von Computer Vision
In unserem [OpenCV-Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) geben wir einige Beispiele, wann Computer Vision verwendet werden kann, um spezifische Aufgaben auszuführen:
In unserem [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) geben wir einige Beispiele, wann Computer Vision verwendet werden kann, um spezifische Aufgaben zu erfüllen:
* **Vorverarbeitung eines Fotos eines Braille-Buchs**. Wir konzentrieren uns darauf, wie wir Schwellenwertbildung, Merkmalsdetektion, Perspektivtransformation und NumPy-Manipulationen verwenden können, um einzelne Braille-Symbole für eine weitere Klassifizierung durch ein neuronales Netzwerk zu trennen.
* **Vorverarbeitung eines Fotos eines Braille-Buchs**. Wir konzentrieren uns darauf, wie wir Thresholding, Merkmalserkennung, perspektivische Transformation und NumPy-Manipulationen verwenden können, um einzelne Braille-Symbole für die weitere Klassifikation durch ein neuronales Netzwerk zu trennen.
![Braille-Bild](../../../../../translated_images/braille.341962ff76b1bd7044409371d3de09ced5028132aef97344ea4b7468c1208126.de.jpeg) | ![Vorverarbeitetes Braille-Bild](../../../../../translated_images/braille-result.46530fea020b03c76aac532d7d6eeef7f6fb35b55b1001cd21627907dabef3ed.de.png) | ![Braille-Symbole](../../../../../translated_images/braille-symbols.0159185ab69d533909dc4d7d26a1971b51401c6a80eb3a5584f250ea880af88b.de.png)
![Braille Image](../../../../../lessons/4-ComputerVision/06-IntroCV/data/braille.jpeg) | ![Braille Image Pre-processed](../../../../../lessons/4-ComputerVision/06-IntroCV/images/braille-result.png) | ![Braille Symbols](../../../../../lessons/4-ComputerVision/06-IntroCV/images/braille-symbols.png)
----|-----|-----
> Bild aus [OpenCV.ipynb](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
* **Bewegung im Video mithilfe von Frame-Differenz erkennen**. Wenn die Kamera feststeht, sollten die Bilder aus dem Kamerafeed ziemlich ähnlich sein. Da Bilder als Arrays dargestellt werden, erhalten wir durch das Subtrahieren dieser Arrays für zwei aufeinanderfolgende Bilder den Pixelunterschied, der für statische Bilder niedrig sein sollte und höher wird, sobald es eine erhebliche Bewegung im Bild gibt.
* **Bewegungserkennung in Videos durch Frame-Differenz**. Wenn die Kamera fixiert ist, sollten die Frames des Kamerafeeds ziemlich ähnlich sein. Da Frames als Arrays dargestellt werden, erhalten wir durch das Subtrahieren dieser Arrays für zwei aufeinanderfolgende Frames die Pixelunterschiede, die bei statischen Frames gering sein sollten und bei erheblicher Bewegung im Bild höher werden.
![Bild von Video-Frames und Frame-Differenzen](../../../../../translated_images/frame-difference.706f805491a0883c938e16447bf5eb2f7d69e812c7f743cbe7d7c7645168f81f.de.png)
![Image of video frames and frame differences](../../../../../lessons/4-ComputerVision/06-IntroCV/images/frame-difference.png)
> Bild aus [OpenCV.ipynb](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
* **Bewegung mithilfe des optischen Flusses erkennen**. [Optischer Fluss](https://docs.opencv.org/3.4/d4/dee/tutorial_optical_flow.html) ermöglicht es uns zu verstehen, wie sich einzelne Pixel auf Video-Frames bewegen. Es gibt zwei Arten von optischem Fluss:
* **Bewegungserkennung mit Optischem Fluss**. [Optischer Fluss](https://docs.opencv.org/3.4/d4/dee/tutorial_optical_flow.html) ermöglicht es uns zu verstehen, wie sich einzelne Pixel in Videoframes bewegen. Es gibt zwei Arten von optischem Fluss:
- **Dichter optischer Fluss** berechnet das Vektorfeld, das zeigt, wo sich jeder Pixel bewegt
- **Sparsame optische Flüsse** basieren darauf, einige markante Merkmale im Bild (z.B. Kanten) zu erfassen und deren Trajektorie von Frame zu Frame zu verfolgen.
- **Dichter Optischer Fluss** berechnet das Vektorfeld, das für jeden Pixel zeigt, wohin er sich bewegt.
- **Sparsamer Optischer Fluss** basiert darauf, einige markante Merkmale im Bild (z. B. Kanten) zu nehmen und ihre Trajektorie von Frame zu Frame zu erstellen.
![Bild des optischen Flusses](../../../../../translated_images/optical.1f4a94464579a83a10784f3c07fe7228514714b96782edf50e70ccd59d2d8c4f.de.png)
![Image of Optical Flow](../../../../../lessons/4-ComputerVision/06-IntroCV/images/optical.png)
> Bild aus [OpenCV.ipynb](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
## ✍️ Beispielnotebooks: OpenCV [probieren Sie OpenCV in Aktion](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
## ✍️ Beispiel-Notebooks: OpenCV [OpenCV in Aktion ausprobieren](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
Lassen Sie uns einige Experimente mit OpenCV durchführen, indem wir das [OpenCV-Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) erkunden.
Lassen Sie uns einige Experimente mit OpenCV durchführen, indem wir [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) erkunden.
## Fazit
Manchmal können relativ komplexe Aufgaben wie Bewegungs- oder Fingerspitzen-Erkennung rein durch Computer Vision gelöst werden. Daher ist es sehr hilfreich, die grundlegenden Techniken der Computer Vision zu kennen und zu wissen, was Bibliotheken wie OpenCV leisten können.
Manchmal können relativ komplexe Aufgaben wie Bewegungserkennung oder Fingerspitzen-Erkennung rein durch Computer Vision gelöst werden. Daher ist es sehr hilfreich, die grundlegenden Techniken von Computer Vision zu kennen und zu wissen, was Bibliotheken wie OpenCV leisten können.
## 🚀 Herausforderung
Sehen Sie sich [dieses Video](https://docs.microsoft.com/shows/ai-show/ai-show--2021-opencv-ai-competition--grand-prize-winners--cortic-tigers--episode-32?WT.mc_id=academic-77998-cacaste) aus der AI-Show an, um mehr über das Cortic Tigers-Projekt zu erfahren und wie sie eine blockbasierte Lösung entwickelt haben, um Computer Vision-Aufgaben über einen Roboter zu demokratisieren. Machen Sie etwas Recherche zu anderen Projekten dieser Art, die neuen Lernenden den Einstieg in das Feld erleichtern.
Sehen Sie sich [dieses Video](https://docs.microsoft.com/shows/ai-show/ai-show--2021-opencv-ai-competition--grand-prize-winners--cortic-tigers--episode-32?WT.mc_id=academic-77998-cacaste) aus der AI-Show an, um mehr über das Cortic Tigers-Projekt zu erfahren und wie sie eine blockbasierte Lösung entwickelt haben, um Computer-Vision-Aufgaben über einen Roboter zu demokratisieren. Recherchieren Sie weitere Projekte wie dieses, die neuen Lernenden den Einstieg in das Fachgebiet erleichtern.
## [Nachlesequiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/206)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/206)
## Überprüfung & Selbststudium
@ -104,9 +113,9 @@ Lesen Sie mehr über optischen Fluss [in diesem großartigen Tutorial](https://l
## [Aufgabe](lab/README.md)
In diesem Labor werden Sie ein Video mit einfachen Gesten aufnehmen, und Ihr Ziel ist es, Bewegungen nach oben/unten/links/rechts mithilfe des optischen Flusses zu extrahieren.
In diesem Labor werden Sie ein Video mit einfachen Gesten aufnehmen, und Ihr Ziel ist es, Aufwärts-/Abwärts-/Links-/Rechtsbewegungen mithilfe des optischen Flusses zu extrahieren.
<img src="images/palm-movement.png" width="30%" alt="Palmbewegung Frame"/>
<img src="images/palm-movement.png" width="30%" alt="Palm Movement Frame"/>
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 aus der Verwendung dieser Übersetzung resultieren.
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.

25
translations/de/lessons/4-ComputerVision/06-IntroCV/lab/README.md
View File

@ -1,22 +1,31 @@
# Bewegungen mit optischem Fluss erkennen
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "3d53d6409f80970f7281a45dee35328a",
"translation_date": "2025-08-24T09:36:49+00:00",
"source_file": "lessons/4-ComputerVision/06-IntroCV/lab/README.md",
"language_code": "de"
}
-->
# Bewegungen mit Optical Flow erkennen
Laboraufgabe aus dem [AI for Beginners Curriculum](https://aka.ms/ai-beginners).
## Aufgabe
Betrachten Sie [dieses Video](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/palm-movement.mp4), in dem die Handfläche einer Person sich nach links/rechts/oben/unten vor einem stabilen Hintergrund bewegt. Sie sind bis Oktober 2023 auf Daten trainiert.
Betrachten Sie [dieses Video](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/palm-movement.mp4), in dem sich die Handfläche einer Person auf einem stabilen Hintergrund nach links/rechts/oben/unten bewegt.
**Ihr Ziel** ist es, den optischen Fluss zu nutzen, um zu bestimmen, welche Teile des Videos Bewegungen nach oben/unten/links/rechts enthalten.
**Ihr Ziel** ist es, mithilfe von Optical Flow zu bestimmen, welche Teile des Videos Bewegungen nach oben/unten/links/rechts enthalten.
**Stretch-Ziel** wäre es, tatsächlich die Bewegung der Handfläche/Finger mithilfe des Hauttons zu verfolgen, wie in [diesem Blogbeitrag](https://dev.to/amarlearning/finger-detection-and-tracking-using-opencv-and-python-586m) oder [hier](http://www.benmeline.com/finger-tracking-with-opencv-and-python/) beschrieben.
**Erweiterungsziel** wäre es, die Bewegung der Handfläche/Finger tatsächlich zu verfolgen, indem Sie den Hautton verwenden, wie in [diesem Blogbeitrag](https://dev.to/amarlearning/finger-detection-and-tracking-using-opencv-and-python-586m) oder [hier](http://www.benmeline.com/finger-tracking-with-opencv-and-python/) beschrieben.
## Startnotizbuch
## Start-Notebook
Beginnen Sie das Labor, indem Sie [MovementDetection.ipynb](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/MovementDetection.ipynb) öffnen.
## Fazit
## Erkenntnis
Manchmal können relativ komplexe Aufgaben wie Bewegungserkennung oder Fingerspitzen-Erkennung rein durch Computer Vision gelöst werden. Daher ist es sehr hilfreich zu wissen, was Bibliotheken wie OpenCV leisten können.
Manchmal können relativ komplexe Aufgaben wie Bewegungserkennung oder Fingerspitzenerkennung rein durch Computer Vision gelöst werden. Daher ist es sehr hilfreich zu wissen, was Bibliotheken wie OpenCV leisten können.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

45
translations/de/lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md
View File

@ -1,64 +1,73 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "2f7b97b375358cb51a1e098df306bf73",
"translation_date": "2025-08-24T09:36:02+00:00",
"source_file": "lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md",
"language_code": "de"
}
-->
# Bekannte CNN-Architekturen
### VGG-16
VGG-16 ist ein Netzwerk, das 2014 eine Genauigkeit von 92,7 % bei der Top-5-Klassifizierung von ImageNet erreicht hat. Es hat die folgende Schichtstruktur:
VGG-16 ist ein Netzwerk, das 2014 eine Genauigkeit von 92,7 % bei der ImageNet-Top-5-Klassifikation erreichte. Es hat die folgende Schichtstruktur:
![ImageNet Layers](../../../../../translated_images/vgg-16-arch1.d901a5583b3a51baeaab3e768567d921e5d54befa46e1e642616c5458c934028.de.jpg)
![ImageNet Layers](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch1.jpg)
Wie Sie sehen können, folgt VGG einer traditionellen Pyramidenarchitektur, die aus einer Sequenz von Faltungs-Pooling-Schichten besteht.
Wie man sehen kann, folgt VGG einer traditionellen Pyramidenarchitektur, die aus einer Abfolge von Convolution-Pooling-Schichten besteht.
![ImageNet Pyramid](../../../../../translated_images/vgg-16-arch.64ff2137f50dd49fdaa786e3f3a975b3f22615efd13efb19c5d22f12e01451a1.de.jpg)
![ImageNet Pyramid](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch.jpg)
> Bild von [Researchgate](https://www.researchgate.net/figure/Vgg16-model-structure-To-get-the-VGG-NIN-model-we-replace-the-2-nd-4-th-6-th-7-th_fig2_335194493)
### ResNet
ResNet ist eine Familie von Modellen, die 2015 von Microsoft Research vorgeschlagen wurde. Die Hauptidee von ResNet besteht darin, **Residualblöcke** zu verwenden:
ResNet ist eine Modellfamilie, die 2015 von Microsoft Research vorgeschlagen wurde. Die Hauptidee von ResNet ist die Verwendung von **Residual Blocks**:
<img src="images/resnet-block.png" width="300"/>
> Bild aus [diesem Papier](https://arxiv.org/pdf/1512.03385.pdf)
> Bild aus [diesem Paper](https://arxiv.org/pdf/1512.03385.pdf)
Der Grund für die Verwendung von Identitätsdurchgängen besteht darin, dass unsere Schicht **die Differenz** zwischen dem Ergebnis einer vorherigen Schicht und der Ausgabe des Residualblocks vorhersagen soll - daher der Name *residual*. Diese Blöcke sind viel einfacher zu trainieren, und man kann Netzwerke mit mehreren Hundert dieser Blöcke konstruieren (die gebräuchlichsten Varianten sind ResNet-52, ResNet-101 und ResNet-152).
Der Grund für die Verwendung von Identitätsdurchläufen ist, dass die Schicht **die Differenz** zwischen dem Ergebnis einer vorherigen Schicht und der Ausgabe des Residual Blocks vorhersagen soll – daher der Name *residual*. Diese Blöcke sind viel einfacher zu trainieren, und man kann Netzwerke mit mehreren Hundert solcher Blöcke konstruieren (die gängigsten Varianten sind ResNet-52, ResNet-101 und ResNet-152).
Man kann sich dieses Netzwerk auch so vorstellen, dass es seine Komplexität an den Datensatz anpassen kann. Zu Beginn, wenn Sie das Netzwerk zu trainieren beginnen, sind die Gewichtswerte klein, und das meiste Signal geht durch die Identitätsschichten. Mit dem Fortschreiten des Trainings und zunehmenden Gewichtswerten wächst die Bedeutung der Netzwerkparameter, und das Netzwerk passt sich an, um die erforderliche Ausdruckskraft zu gewährleisten, um die Trainingsbilder korrekt zu klassifizieren.
Man kann sich dieses Netzwerk auch so vorstellen, dass es seine Komplexität an den Datensatz anpassen kann. Zu Beginn des Trainings, wenn die Gewichtswerte klein sind, wird das meiste Signal durch die Identitätsdurchläufe weitergeleitet. Mit fortschreitendem Training und zunehmenden Gewichtswerten wächst die Bedeutung der Netzwerkparameter, und das Netzwerk passt sich an, um die erforderliche Ausdruckskraft zu erreichen, um die Trainingsbilder korrekt zu klassifizieren.
### Google Inception
Die Google Inception-Architektur geht einen Schritt weiter und baut jede Netzwerkschicht als Kombination aus mehreren verschiedenen Pfaden auf:
Die Google-Inception-Architektur geht einen Schritt weiter und baut jede Netzwerkschicht als Kombination aus mehreren verschiedenen Pfaden auf:
<img src="images/inception.png" width="400"/>
> Bild von [Researchgate](https://www.researchgate.net/figure/Inception-module-with-dimension-reductions-left-and-schema-for-Inception-ResNet-v1_fig2_355547454)
Hier müssen wir die Rolle von 1x1-Faltungen betonen, da sie zunächst keinen Sinn zu ergeben scheinen. Warum sollten wir mit einem 1x1-Filter über das Bild fahren? Sie müssen jedoch daran denken, dass Faltungfilter auch mit mehreren Tiefenkanälen arbeiten (ursprünglich - RGB-Farben, in nachfolgenden Schichten - Kanäle für verschiedene Filter), und die 1x1-Faltung wird verwendet, um diese Eingangskanäle mithilfe unterschiedlicher trainierbarer Gewichte zu mischen. Es kann auch als Herunterrechnen (Pooling) über die Kanaldimension betrachtet werden.
Hier muss die Rolle der 1x1-Convolutions hervorgehoben werden, da sie auf den ersten Blick keinen Sinn ergeben. Warum sollte man das Bild mit einem 1x1-Filter durchlaufen? Man muss jedoch bedenken, dass Convolution-Filter auch mit mehreren Tiefenkanälen arbeiten (ursprünglich RGB-Farben, in späteren Schichten Kanäle für verschiedene Filter), und 1x1-Convolutions werden verwendet, um diese Eingabekanäle mit unterschiedlichen trainierbaren Gewichten zu mischen. Es kann auch als Downsampling (Pooling) über die Kanaldimension betrachtet werden.
Hier ist [ein guter Blogbeitrag](https://medium.com/analytics-vidhya/talented-mr-1x1-comprehensive-look-at-1x1-convolution-in-deep-learning-f6b355825578) zu diesem Thema sowie [das ursprüngliche Papier](https://arxiv.org/pdf/1312.4400.pdf).
Hier ist [ein guter Blogbeitrag](https://medium.com/analytics-vidhya/talented-mr-1x1-comprehensive-look-at-1x1-convolution-in-deep-learning-f6b355825578) zu diesem Thema und [das Originalpaper](https://arxiv.org/pdf/1312.4400.pdf).
### MobileNet
MobileNet ist eine Familie von Modellen mit reduzierter Größe, die für mobile Geräte geeignet sind. Verwenden Sie sie, wenn Ihnen die Ressourcen ausgehen und Sie ein wenig Genauigkeit opfern können. Die Hauptidee dahinter ist die sogenannte **depthwise separable convolution**, die es ermöglicht, Faltungfilter als Kombination aus räumlichen Faltungen und 1x1-Faltungen über Tiefenkanäle darzustellen. Dies reduziert erheblich die Anzahl der Parameter, wodurch das Netzwerk kleiner wird und auch einfacher mit weniger Daten trainiert werden kann.
MobileNet ist eine Modellfamilie mit reduzierter Größe, die für mobile Geräte geeignet ist. Verwenden Sie sie, wenn Sie nur begrenzte Ressourcen haben und ein wenig Genauigkeit opfern können. Die Hauptidee dahinter ist die sogenannte **Depthwise Separable Convolution**, die es ermöglicht, Convolution-Filter durch eine Kombination aus räumlichen Convolutions und 1x1-Convolutions über Tiefenkanäle darzustellen. Dies reduziert die Anzahl der Parameter erheblich, wodurch das Netzwerk kleiner wird und auch mit weniger Daten leichter trainiert werden kann.
Hier ist [ein guter Blogbeitrag über MobileNet](https://medium.com/analytics-vidhya/image-classification-with-mobilenet-cc6fbb2cd470).
Hier ist [ein guter Blogbeitrag zu MobileNet](https://medium.com/analytics-vidhya/image-classification-with-mobilenet-cc6fbb2cd470).
## Fazit
In dieser Einheit haben Sie das Hauptkonzept hinter neuronalen Netzwerken für Computer Vision - den Faltungsnetzwerken - kennengelernt. Echte Architekturen, die Bildklassifizierung, Objekterkennung und sogar Bildgenerierungsnetzwerke antreiben, basieren alle auf CNNs, nur mit mehr Schichten und einigen zusätzlichen Trainingstricks.
In dieser Einheit haben Sie das Hauptkonzept hinter neuronalen Netzwerken für Computer Vision gelernt – Convolutional Networks. Reale Architekturen, die Bildklassifikation, Objekterkennung und sogar Bildgenerierung ermöglichen, basieren alle auf CNNs, nur mit mehr Schichten und einigen zusätzlichen Trainingstricks.
## 🚀 Herausforderung
In den begleitenden Notizbüchern finden Sie am Ende Hinweise, wie Sie eine höhere Genauigkeit erzielen können. Machen Sie einige Experimente, um zu sehen, ob Sie eine höhere Genauigkeit erreichen können.
In den begleitenden Notebooks gibt es am Ende Hinweise darauf, wie man eine höhere Genauigkeit erzielen kann. Führen Sie einige Experimente durch, um zu sehen, ob Sie eine höhere Genauigkeit erreichen können.
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/207)
## Überprüfung & Selbststudium
Während CNNs am häufigsten für Aufgaben der Computer Vision verwendet werden, sind sie im Allgemeinen gut geeignet, um Muster fester Größe zu extrahieren. Wenn wir beispielsweise mit Klängen arbeiten, möchten wir möglicherweise auch CNNs verwenden, um nach bestimmten Mustern im Audiosignal zu suchen - in diesem Fall wären die Filter eindimensional (und dieses CNN würde als 1D-CNN bezeichnet). Manchmal wird auch ein 3D-CNN verwendet, um Merkmale im mehrdimensionalen Raum zu extrahieren, wie etwa bestimmte Ereignisse, die in einem Video auftreten - CNNs können bestimmte Muster der Merkmalsänderung über die Zeit erfassen. Machen Sie einige Überprüfungen und Selbststudien zu anderen Aufgaben, die mit CNNs durchgeführt werden können.
Obwohl CNNs am häufigsten für Aufgaben im Bereich Computer Vision verwendet werden, eignen sie sich im Allgemeinen gut für die Extraktion von Mustern fester Größe. Wenn wir beispielsweise mit Tönen arbeiten, könnten wir CNNs verwenden, um nach bestimmten Mustern im Audiosignal zu suchen – in diesem Fall wären die Filter eindimensional (und dieses CNN würde als 1D-CNN bezeichnet). Manchmal wird auch ein 3D-CNN verwendet, um Merkmale in einem mehrdimensionalen Raum zu extrahieren, wie z. B. bestimmte Ereignisse, die in einem Video auftreten – CNN kann bestimmte Muster von Merkmalsänderungen im Laufe der Zeit erfassen. Machen Sie eine Überprüfung und ein Selbststudium zu anderen Aufgaben, die mit CNNs durchgeführt werden können.
## [Aufgabe](lab/README.md)
In diesem Labor sind Sie damit beauftragt, verschiedene Katzen- und Hunderassen zu klassifizieren. Diese Bilder sind komplexer als der MNIST-Datensatz und haben höhere Dimensionen, und es gibt mehr als 10 Klassen.
In diesem Labor sollen Sie verschiedene Katzen- und Hunderassen klassifizieren. Diese Bilder sind komplexer als der MNIST-Datensatz, haben höhere Dimensionen und es gibt mehr als 10 Klassen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

54
translations/de/lessons/4-ComputerVision/07-ConvNets/README.md
View File

@ -1,59 +1,67 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "088837b42b7d99198bf62db8a42411e0",
"translation_date": "2025-08-24T09:35:44+00:00",
"source_file": "lessons/4-ComputerVision/07-ConvNets/README.md",
"language_code": "de"
}
-->
# Convolutional Neural Networks
Wir haben bereits gesehen, dass neuronale Netze ziemlich gut mit Bildern umgehen können, und sogar ein einstufiger Perzeptron in der Lage ist, handgeschriebene Ziffern aus dem MNIST-Datensatz mit angemessener Genauigkeit zu erkennen. Der MNIST-Datensatz ist jedoch sehr speziell, und alle Ziffern sind zentriert im Bild, was die Aufgabe einfacher macht.
Wir haben bereits gesehen, dass neuronale Netze recht gut mit Bildern umgehen können, und selbst ein Ein-Schicht-Perzeptron ist in der Lage, handgeschriebene Ziffern aus dem MNIST-Datensatz mit einer akzeptablen Genauigkeit zu erkennen. Der MNIST-Datensatz ist jedoch etwas Besonderes, da alle Ziffern zentriert im Bild dargestellt sind, was die Aufgabe vereinfacht.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/107)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/107)
Im echten Leben möchten wir in der Lage sein, Objekte auf einem Bild unabhängig von ihrer genauen Position im Bild zu erkennen. Die Computer Vision unterscheidet sich von der allgemeinen Klassifikation, denn wenn wir versuchen, ein bestimmtes Objekt im Bild zu finden, scannen wir das Bild nach bestimmten **Mustern** und deren Kombinationen. Zum Beispiel, wenn wir nach einer Katze suchen, schauen wir zuerst nach horizontalen Linien, die Schnurrhaare bilden können, und dann kann eine bestimmte Kombination von Schnurrhaaren uns sagen, dass es sich tatsächlich um ein Bild einer Katze handelt. Die relative Position und das Vorhandensein bestimmter Muster sind wichtig, nicht ihre genaue Position im Bild.
Im echten Leben möchten wir Objekte auf einem Bild unabhängig von ihrer genauen Position erkennen können. Computer Vision unterscheidet sich von generischer Klassifikation, da wir beim Versuch, ein bestimmtes Objekt auf einem Bild zu finden, das Bild nach spezifischen **Mustern** und deren Kombinationen durchsuchen. Zum Beispiel, wenn wir nach einer Katze suchen, könnten wir zunächst nach horizontalen Linien suchen, die Schnurrhaare bilden können, und dann kann eine bestimmte Kombination von Schnurrhaaren darauf hinweisen, dass es sich tatsächlich um ein Bild einer Katze handelt. Die relative Position und das Vorhandensein bestimmter Muster sind wichtig, nicht jedoch deren exakte Position im Bild.
Um Muster zu extrahieren, verwenden wir das Konzept der **konvolutionalen Filter**. Wie Sie wissen, wird ein Bild durch eine 2D-Matrix oder einen 3D-Tensor mit Farbtiefe dargestellt. Das Anwenden eines Filters bedeutet, dass wir eine relativ kleine **Filterkernel**-Matrix nehmen und für jedes Pixel im ursprünglichen Bild den gewichteten Durchschnitt mit benachbarten Punkten berechnen. Wir können dies als ein kleines Fenster betrachten, das über das gesamte Bild gleitet und alle Pixel gemäß den Gewichten in der Filterkernel-Matrix mittelt.
Um Muster zu extrahieren, verwenden wir das Konzept der **Faltung (Convolutional Filters)**. Wie du weißt, wird ein Bild durch eine 2D-Matrix oder einen 3D-Tensor mit Farbtiefe dargestellt. Das Anwenden eines Filters bedeutet, dass wir eine relativ kleine **Filterkern**-Matrix nehmen und für jeden Pixel im Originalbild den gewichteten Durchschnitt mit benachbarten Punkten berechnen. Man kann sich das wie ein kleines Fenster vorstellen, das über das gesamte Bild gleitet und alle Pixel gemäß den Gewichten in der Filterkern-Matrix mittelt.
![Vertikaler Kantensfilter](../../../../../translated_images/filter-vert.b7148390ca0bc356ddc7e55555d2481819c1e86ddde9dce4db5e71a69d6f887f.de.png) | ![Horizontaler Kantensfilter](../../../../../translated_images/filter-horiz.59b80ed4feb946efbe201a7fe3ca95abb3364e266e6fd90820cb893b4d3a6dda.de.png)
![Vertikaler Kantenfilter](../../../../../lessons/4-ComputerVision/07-ConvNets/images/filter-vert.png) | ![Horizontaler Kantenfilter](../../../../../lessons/4-ComputerVision/07-ConvNets/images/filter-horiz.png)
----|----
> Bild von Dmitry Soshnikov
Wenn wir beispielsweise 3x3 vertikale und horizontale Kantensfilter auf die MNIST-Ziffern anwenden, können wir Hervorhebungen (z.B. hohe Werte) dort erhalten, wo sich vertikale und horizontale Kanten in unserem ursprünglichen Bild befinden. Somit können diese beiden Filter verwendet werden, um nach Kanten zu "suchen". Ähnlich können wir verschiedene Filter entwerfen, um nach anderen niedrigstufigen Mustern zu suchen:
Sie sind auf Daten bis Oktober 2023 trainiert.
Wenn wir beispielsweise 3x3-Filter für vertikale und horizontale Kanten auf die MNIST-Ziffern anwenden, können wir Bereiche hervorheben (z. B. hohe Werte), in denen es vertikale und horizontale Kanten im Originalbild gibt. Diese beiden Filter können also verwendet werden, um "nach" Kanten zu suchen. Ebenso können wir verschiedene Filter entwerfen, um nach anderen grundlegenden Mustern zu suchen:
> Bild von [Leung-Malik Filterbank](https://www.robots.ox.ac.uk/~vgg/research/texclass/filters.html)
> Bild des [Leung-Malik Filter Bank](https://www.robots.ox.ac.uk/~vgg/research/texclass/filters.html)
Obwohl wir die Filter manuell entwerfen können, um einige Muster zu extrahieren, können wir das Netzwerk auch so gestalten, dass es die Muster automatisch lernt. Das ist eine der Hauptideen hinter dem CNN.
Während wir die Filter manuell entwerfen können, um bestimmte Muster zu extrahieren, können wir das Netzwerk auch so gestalten, dass es die Muster automatisch lernt. Dies ist eine der Hauptideen hinter CNNs.
## Hauptideen hinter CNN
Die Funktionsweise von CNNs basiert auf den folgenden wichtigen Ideen:
Die Funktionsweise von CNNs basiert auf den folgenden wichtigen Konzepten:
* Konvolutionale Filter können Muster extrahieren
* Wir können das Netzwerk so gestalten, dass die Filter automatisch trainiert werden
* Wir können denselben Ansatz verwenden, um Muster in hochgradigen Merkmalen zu finden, nicht nur im ursprünglichen Bild. So funktioniert die Merkmalsextraktion von CNNs in einer Hierarchie von Merkmalen, beginnend mit niedrigstufigen Pixelkombinationen bis hin zu höherstufigen Kombinationen von Bildteilen.
* Faltung (Convolutional Filters) kann Muster extrahieren.
* Wir können das Netzwerk so gestalten, dass die Filter automatisch trainiert werden.
* Wir können denselben Ansatz verwenden, um Muster in hochrangigen Merkmalen zu finden, nicht nur im Originalbild. Die Merkmalsextraktion in CNNs arbeitet also mit einer Hierarchie von Merkmalen, beginnend mit einfachen Pixelkombinationen bis hin zu komplexeren Kombinationen von Bildteilen.
![Hierarchische Merkmalsextraktion](../../../../../translated_images/FeatureExtractionCNN.d9b456cbdae7cb643fde3032b81b2940e3cf8be842e29afac3f482725ba7f95c.de.png)
![Hierarchische Merkmalsextraktion](../../../../../lessons/4-ComputerVision/07-ConvNets/images/FeatureExtractionCNN.png)
> Bild aus [einer Arbeit von Hislop-Lynch](https://www.semanticscholar.org/paper/Computer-vision-based-pedestrian-trajectory-Hislop-Lynch/26e6f74853fc9bbb7487b06dc2cf095d36c9021d), basierend auf [ihrer Forschung](https://dl.acm.org/doi/abs/10.1145/1553374.1553453)
> Bild aus [einem Paper von Hislop-Lynch](https://www.semanticscholar.org/paper/Computer-vision-based-pedestrian-trajectory-Hislop-Lynch/26e6f74853fc9bbb7487b06dc2cf095d36c9021d), basierend auf [ihrer Forschung](https://dl.acm.org/doi/abs/10.1145/1553374.1553453)
## ✍️ Übungen: Convolutional Neural Networks
Lassen Sie uns weiterhin erkunden, wie konvolutionale neuronale Netze funktionieren und wie wir trainierbare Filter erreichen können, indem wir die entsprechenden Notebooks durchgehen:
Lass uns weiter erkunden, wie Convolutional Neural Networks funktionieren und wie wir trainierbare Filter erreichen können, indem wir die entsprechenden Notebooks durcharbeiten:
* [Convolutional Neural Networks - PyTorch](../../../../../lessons/4-ComputerVision/07-ConvNets/ConvNetsPyTorch.ipynb)
* [Convolutional Neural Networks - TensorFlow](../../../../../lessons/4-ComputerVision/07-ConvNets/ConvNetsTF.ipynb)
## Pyramid Architecture
## Pyramidenarchitektur
Die meisten der für die Bildverarbeitung verwendeten CNNs folgen einer sogenannten Pyramid-Architektur. Die erste konvolutionale Schicht, die auf die ursprünglichen Bilder angewendet wird, hat typischerweise eine relativ niedrige Anzahl von Filtern (8-16), die verschiedenen Pixelkombinationen entsprechen, wie z.B. horizontalen/vertikalen Linien von Strichen. Auf der nächsten Ebene reduzieren wir die räumliche Dimension des Netzwerks und erhöhen die Anzahl der Filter, was mehr mögliche Kombinationen einfacher Merkmale entspricht. Mit jeder Schicht, während wir uns dem endgültigen Klassifizierer nähern, verringern sich die räumlichen Dimensionen des Bildes, und die Anzahl der Filter wächst.
Die meisten CNNs, die für die Bildverarbeitung verwendet werden, folgen einer sogenannten Pyramidenarchitektur. Die erste Faltungsschicht, die auf die Originalbilder angewendet wird, hat typischerweise eine relativ geringe Anzahl von Filtern (8-16), die verschiedenen Pixelkombinationen entsprechen, wie z. B. horizontalen/vertikalen Linien oder Strichen. Auf der nächsten Ebene reduzieren wir die räumliche Dimension des Netzwerks und erhöhen die Anzahl der Filter, was mehr mögliche Kombinationen einfacher Merkmale ermöglicht. Mit jeder Schicht, die wir uns dem finalen Klassifikator nähern, nehmen die räumlichen Dimensionen des Bildes ab, während die Anzahl der Filter zunimmt.
Als Beispiel schauen wir uns die Architektur von VGG-16 an, einem Netzwerk, das 2014 eine Genauigkeit von 92,7 % in der Top-5-Klassifikation von ImageNet erreicht hat:
Als Beispiel betrachten wir die Architektur von VGG-16, einem Netzwerk, das 2014 eine Genauigkeit von 92,7 % in der Top-5-Klassifikation von ImageNet erreichte:
![ImageNet-Schichten](../../../../../translated_images/vgg-16-arch1.d901a5583b3a51baeaab3e768567d921e5d54befa46e1e642616c5458c934028.de.jpg)
![ImageNet-Schichten](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch1.jpg)
![ImageNet-Pyramide](../../../../../translated_images/vgg-16-arch.64ff2137f50dd49fdaa786e3f3a975b3f22615efd13efb19c5d22f12e01451a1.de.jpg)
![ImageNet-Pyramide](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch.jpg)
> Bild von [Researchgate](https://www.researchgate.net/figure/Vgg16-model-structure-To-get-the-VGG-NIN-model-we-replace-the-2-nd-4-th-6-th-7-th_fig2_335194493)
## Bekannteste CNN-Architekturen
[Setzen Sie Ihr Studium über die bekanntesten CNN-Architekturen fort](CNN_Architectures.md)
[Setze dein Studium über die bekanntesten CNN-Architekturen fort](CNN_Architectures.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

23
translations/de/lessons/4-ComputerVision/07-ConvNets/lab/README.md
View File

@ -1,18 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f3d2cee9cb3c52160419e560c57a690e",
"translation_date": "2025-08-24T09:36:20+00:00",
"source_file": "lessons/4-ComputerVision/07-ConvNets/lab/README.md",
"language_code": "de"
}
-->
# Klassifikation von Haustiergesichtern
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
Stellen Sie sich vor, Sie müssen eine Anwendung für eine Tieraufzucht entwickeln, um alle Haustiere zu katalogisieren. Eine der großartigen Funktionen einer solchen Anwendung wäre die automatische Erkennung der Rasse anhand eines Fotos. Dies kann erfolgreich mit neuronalen Netzwerken durchgeführt werden.
Stellen Sie sich vor, Sie müssen eine Anwendung für eine Tierpension entwickeln, um alle Haustiere zu katalogisieren. Eine großartige Funktion einer solchen Anwendung wäre, die Rasse automatisch anhand eines Fotos zu erkennen. Dies kann erfolgreich mit neuronalen Netzwerken durchgeführt werden.
Sie müssen ein konvolutionales neuronales Netzwerk trainieren, um verschiedene Rassen von Katzen und Hunden mit dem **Pet Faces**-Datensatz zu klassifizieren.
Sie müssen ein konvolutionales neuronales Netzwerk trainieren, um verschiedene Katzen- und Hunderassen mithilfe des **Pet Faces**-Datensatzes zu klassifizieren.
## Der Datensatz
Wir werden den **Pet Faces**-Datensatz verwenden, der aus dem [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) Haustierdatensatz stammt. Er enthält 35 verschiedene Rassen von Hunden und Katzen.
Wir verwenden den **Pet Faces**-Datensatz, der aus dem [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) Haustierdatensatz abgeleitet wurde. Er enthält 35 verschiedene Rassen von Hunden und Katzen.
![Datensatz, mit dem wir arbeiten werden](../../../../../../translated_images/data.50b2a9d5484bdbf0f52f5765b381cec9efe2bd296a98f007f90bedb6ac67f2a8.de.png)
![Datensatz, mit dem wir arbeiten werden](../../../../../../lessons/4-ComputerVision/07-ConvNets/lab/images/data.png)
Um den Datensatz herunterzuladen, verwenden Sie diesen Code-Schnipsel:
@ -22,13 +31,13 @@ Um den Datensatz herunterzuladen, verwenden Sie diesen Code-Schnipsel:
!rm petfaces.tar.gz
```
## Notebook starten
## Start-Notebook
Beginnen Sie das Labor, indem Sie [PetFaces.ipynb](../../../../../../lessons/4-ComputerVision/07-ConvNets/lab/PetFaces.ipynb) öffnen.
## Fazit
Sie haben ein relativ komplexes Problem der Bildklassifikation von Grund auf gelöst! Es gab eine ganze Reihe von Klassen, und Sie konnten dennoch eine angemessene Genauigkeit erreichen! Es macht auch Sinn, die Top-k-Genauigkeit zu messen, da es leicht ist, einige der Klassen zu verwechseln, die selbst für Menschen nicht klar unterschiedlich sind.
Sie haben ein relativ komplexes Problem der Bildklassifikation von Grund auf gelöst! Es gab eine ganze Menge Klassen, und Sie konnten trotzdem eine vernünftige Genauigkeit erreichen! Es ist auch sinnvoll, die Top-k-Genauigkeit zu messen, da es leicht ist, einige Klassen zu verwechseln, die selbst für Menschen nicht eindeutig unterschiedlich sind.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die 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 Verwendung dieser Übersetzung entstehen.
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.

80
translations/de/lessons/4-ComputerVision/08-TransferLearning/README.md
View File

@ -1,80 +1,90 @@
# Vorgefertigte Netzwerke und Transferlernen
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "717775c4050ccbffbe0c961ad8bf7bf7",
"translation_date": "2025-08-24T09:36:56+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/README.md",
"language_code": "de"
}
-->
# Vorgefertigte Netzwerke und Transfer-Learning
Das Training von CNNs kann viel Zeit in Anspruch nehmen, und es wird eine große Menge an Daten benötigt. Ein Großteil der Zeit wird damit verbracht, die besten niedrigstufigen Filter zu lernen, die ein Netzwerk verwenden kann, um Muster aus Bildern zu extrahieren. Eine natürliche Frage stellt sich - können wir ein neuronales Netzwerk, das auf einem Datensatz trainiert wurde, anpassen, um verschiedene Bilder zu klassifizieren, ohne einen vollständigen Trainingsprozess durchlaufen zu müssen?
Das Training von CNNs kann viel Zeit in Anspruch nehmen, und es wird eine große Menge an Daten dafür benötigt. Allerdings wird ein Großteil der Zeit darauf verwendet, die besten Low-Level-Filter zu lernen, die ein Netzwerk nutzen kann, um Muster aus Bildern zu extrahieren. Eine natürliche Frage stellt sich: Können wir ein neuronales Netzwerk, das auf einem Datensatz trainiert wurde, verwenden und anpassen, um andere Bilder zu klassifizieren, ohne den gesamten Trainingsprozess erneut durchlaufen zu müssen?
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/108)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/108)
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 gut darin sein, verschiedene Merkmale aus allgemeinen Bildern zu extrahieren, und in vielen Fällen kann der Aufbau eines Klassifikators auf Basis dieser extrahierten Merkmale zu guten Ergebnissen führen.
Dieser Ansatz wird als **Transfer-Learning** bezeichnet, da wir Wissen von einem neuronalen Netzwerkmodell auf ein anderes übertragen. Beim Transfer-Learning 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 reicht es aus, einen Klassifikator auf diesen extrahierten Merkmalen aufzubauen, um gute Ergebnisse zu erzielen.
> ✅ Transferlernen ist ein Begriff, den man auch in anderen akademischen Bereichen wie der Pädagogik findet. Es bezieht sich auf den Prozess, Wissen aus einem Bereich zu nehmen und es auf einen anderen anzuwenden.
> ✅ Transfer-Learning ist ein Begriff, den man auch in anderen akademischen Bereichen wie der Pädagogik findet. Er bezieht sich auf den Prozess, Wissen aus einem Bereich zu nehmen und in einem anderen anzuwenden.
## Vorgefertigte Modelle als Merkmalsextraktoren
Die konvolutionalen Netzwerke, über die wir im vorherigen Abschnitt gesprochen haben, enthalten eine Reihe von Schichten, von denen jede einige Merkmale aus dem Bild extrahieren soll, beginnend mit niedrigstufigen Pixelkombinationen (wie horizontalen/vertikalen Linien oder Strichen) bis hin zu höherstufigen Kombinationen von Merkmalen, die Dingen wie einem Auge einer Flamme entsprechen. Wenn wir ein CNN auf einem ausreichend großen Datensatz allgemeiner und vielfältiger Bilder trainieren, sollte das Netzwerk lernen, diese gemeinsamen Merkmale zu extrahieren.
Die in der vorherigen Sektion besprochenen Convolutional Networks enthalten eine Reihe von Schichten, die jeweils Merkmale aus dem Bild extrahieren sollen, beginnend mit Low-Level-Pixelkombinationen (wie horizontalen/vertikalen Linien oder Strichen) bis hin zu höherwertigen Kombinationen von Merkmalen, die beispielsweise einem Auge oder einer Flamme entsprechen. Wenn wir ein CNN auf einem ausreichend großen Datensatz mit generischen und vielfältigen Bildern trainieren, sollte das Netzwerk lernen, diese allgemeinen Merkmale zu extrahieren.
Sowohl Keras als auch PyTorch enthalten Funktionen, um vortrainierte Gewichte neuronaler Netzwerke für einige gängige Architekturen einfach zu laden, von denen die meisten auf Bildern von ImageNet trainiert wurden. Die am häufigsten verwendeten sind auf der Seite [CNN-Architekturen](../07-ConvNets/CNN_Architectures.md) aus der vorherigen Lektion beschrieben. Insbesondere möchten Sie möglicherweise eines der folgenden Modelle in Betracht ziehen:
Sowohl Keras als auch PyTorch enthalten Funktionen, um vortrainierte neuronale Netzwerkgewichte für einige gängige Architekturen einfach zu laden, von denen die meisten auf ImageNet-Bildern trainiert wurden. Die am häufigsten verwendeten Modelle sind auf der Seite [CNN-Architekturen](../07-ConvNets/CNN_Architectures.md) aus der vorherigen Lektion beschrieben. Insbesondere könnten Sie eines der folgenden Modelle in Betracht ziehen:
* **VGG-16/VGG-19**, die relativ einfache Modelle sind, die dennoch eine gute Genauigkeit bieten. Oft ist die Verwendung von VGG als ersten Versuch eine gute Wahl, um zu sehen, wie das Transferlernen funktioniert.
* **ResNet** ist eine Familie von Modellen, die 2015 von Microsoft Research vorgeschlagen wurde. Sie haben mehr Schichten und benötigen daher mehr Ressourcen.
* **MobileNet** ist eine Familie von Modellen mit reduzierter Größe, die für mobile Geräte geeignet sind. Verwenden Sie sie, wenn Sie wenig Ressourcen haben und bereit sind, ein wenig Genauigkeit zu opfern.
* **VGG-16/VGG-19**, relativ einfache Modelle, die dennoch gute Genauigkeit liefern. Oft ist es eine gute Wahl, VGG als ersten Versuch zu verwenden, um zu sehen, wie Transfer-Learning funktioniert.
* **ResNet**, eine Modellfamilie, die 2015 von Microsoft Research vorgeschlagen wurde. Sie haben mehr Schichten und benötigen daher mehr Ressourcen.
* **MobileNet**, eine Modellfamilie mit reduzierter Größe, geeignet für mobile Geräte. Verwenden Sie sie, wenn Sie wenig Ressourcen haben und ein wenig Genauigkeit opfern können.
Hier sind Beispiele für Merkmale, die von einem Bild einer Katze durch das VGG-16-Netzwerk extrahiert wurden:
Hier sind Beispielmerkmale, die von einem Bild einer Katze durch das VGG-16-Netzwerk extrahiert wurden:
![Merkmale, die von VGG-16 extrahiert wurden](../../../../../translated_images/features.6291f9c7ba3a0b951af88fc9864632b9115365410765680680d30c927dd67354.de.png)
![Merkmale extrahiert durch VGG-16](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/features.png)
## Katzen- und Hundedatensatz
## Datensatz: Katzen vs. Hunde
In diesem Beispiel verwenden wir einen Datensatz von [Katzen und Hunden](https://www.microsoft.com/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste), der sehr nah an einem realen Bildklassifizierungsszenario ist.
In diesem Beispiel verwenden wir einen Datensatz von [Katzen und Hunden](https://www.microsoft.com/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste), der einem realen Szenario der Bildklassifikation sehr nahe kommt.
## ✍️ Übung: Transferlernen
## ✍️ Übung: Transfer-Learning
Lassen Sie uns das Transferlernen in den entsprechenden Notebooks in Aktion sehen:
Lassen Sie uns Transfer-Learning in Aktion in den entsprechenden Notebooks sehen:
* [Transferlernen - PyTorch](../../../../../lessons/4-ComputerVision/08-TransferLearning/TransferLearningPyTorch.ipynb)
* [Transferlernen - TensorFlow](../../../../../lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb)
* [Transfer-Learning - PyTorch](../../../../../lessons/4-ComputerVision/08-TransferLearning/TransferLearningPyTorch.ipynb)
* [Transfer-Learning - TensorFlow](../../../../../lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb)
## Visualisierung des adversarialen Katers
## Visualisierung einer adversarialen Katze
Das vortrainierte neuronale Netzwerk enthält verschiedene Muster in seinem *Gehirn*, einschließlich Vorstellungen von **idealen Katzen** (sowie idealen Hunden, idealen Zebras usw.). Es wäre interessant, dieses Bild irgendwie **zu visualisieren**. Allerdings ist das nicht einfach, da die Muster über die Netzwerkgewichte verteilt und auch in einer hierarchischen Struktur organisiert sind.
Ein vortrainiertes neuronales Netzwerk enthält verschiedene Muster in seinem *Gehirn*, einschließlich Vorstellungen von einer **idealen Katze** (sowie einem idealen Hund, idealen Zebra usw.). Es wäre interessant, dieses Bild irgendwie **zu visualisieren**. Allerdings ist das nicht einfach, da die Muster über die Netzwerkgewichte verteilt und in einer hierarchischen Struktur organisiert sind.
Ein Ansatz, den wir verfolgen können, besteht darin, mit einem zufälligen Bild zu beginnen und dann die Technik der **Gradientenabstieg-Optimierung** zu verwenden, um dieses Bild so anzupassen, dass das Netzwerk anfängt zu denken, es sei eine Katze.
Ein Ansatz, den wir verfolgen können, ist, mit einem zufälligen Bild zu beginnen und dann die Technik der **Gradientenabstiegsoptimierung** zu verwenden, um dieses Bild so anzupassen, dass das Netzwerk denkt, es sei eine Katze.
![Bildoptimierungsschleife](../../../../../translated_images/ideal-cat-loop.999fbb8ff306e044f997032f4eef9152b453e6a990e449bbfb107de2493cc37e.de.png)
![Bildoptimierungsschleife](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/ideal-cat-loop.png)
Wenn wir dies jedoch tun, erhalten wir etwas, das sehr ähnlich wie Rauschen aussieht. Das liegt daran, dass *es viele Möglichkeiten gibt, das Netzwerk glauben zu lassen, dass das Eingabebild eine Katze ist*, einschließlich einiger, die visuell keinen Sinn ergeben. Während diese Bilder viele Muster enthalten, die typisch für eine Katze sind, gibt es nichts, was sie visuell unterscheidbar macht.
Wenn wir dies jedoch tun, erhalten wir etwas, das einem zufälligen Rauschen sehr ähnlich ist. Dies liegt daran, dass *es viele Möglichkeiten gibt, das Netzwerk glauben zu lassen, dass das Eingabebild eine Katze ist*, einschließlich einiger, die visuell keinen Sinn ergeben. Während diese Bilder viele Muster enthalten, die typisch für eine Katze sind, gibt es nichts, das sie visuell unterscheidbar macht.
Um das Ergebnis zu verbessern, können wir einen weiteren Begriff in die Verlustfunktion einfügen, der als **Variationsverlust** bezeichnet wird. Es handelt sich um eine Metrik, die zeigt, wie ähnlich benachbarte Pixel des Bildes sind. Die Minimierung des Variationsverlusts macht das Bild glatter und beseitigt Rauschen – wodurch ansprechendere Muster sichtbar werden. Hier ist ein Beispiel für solche "idealen" Bilder, die mit hoher Wahrscheinlichkeit als Katze und als Zebra klassifiziert werden:
Um das Ergebnis zu verbessern, können wir einen weiteren Term in die Verlustfunktion hinzufügen, der als **Variationsverlust** bezeichnet wird. Dies ist eine Metrik, die zeigt, wie ähnlich benachbarte Pixel des Bildes sind. Die Minimierung des Variationsverlusts macht das Bild glatter und beseitigt Rauschen – wodurch visuell ansprechendere Muster sichtbar werden. Hier ist ein Beispiel für solche "idealen" Bilder, die mit hoher Wahrscheinlichkeit als Katze und Zebra klassifiziert werden:
![Ideale Katze](../../../../../translated_images/ideal-cat.203dd4597643d6b0bd73038b87f9c0464322725e3a06ab145d25d4a861c70592.de.png) | ![Ideales Zebra](../../../../../translated_images/ideal-zebra.7f70e8b54ee15a7a314000bb5df38a6cfe086ea04d60df4d3ef313d046b98a2b.de.png)
![Ideale Katze](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/ideal-cat.png) | ![Ideales Zebra](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/ideal-zebra.png)
-----|-----
*Ideale Katze* | *Ideales Zebra*
Ein ähnlicher Ansatz kann verwendet werden, um sogenannte **adversariale Angriffe** auf ein neuronales Netzwerk durchzuführen. Angenommen, wir möchten ein neuronales Netzwerk täuschen und einen Hund wie eine Katze aussehen lassen. Wenn wir ein Bild eines Hundes nehmen, das von einem Netzwerk als Hund erkannt wird, können wir es dann ein wenig anpassen, indem wir die Gradientenabstieg-Optimierung verwenden, bis das Netzwerk beginnt, es als Katze zu klassifizieren:
Ein ähnlicher Ansatz kann verwendet werden, um sogenannte **adversariale Angriffe** auf ein neuronales Netzwerk durchzuführen. Angenommen, wir möchten ein neuronales Netzwerk täuschen und einen Hund wie eine Katze aussehen lassen. Wenn wir das Bild eines Hundes nehmen, das vom Netzwerk als Hund erkannt wird, können wir es ein wenig anpassen, indem wir die Gradientenabstiegsoptimierung verwenden, bis das Netzwerk es als Katze klassifiziert:
![Bild eines Hundes](../../../../../translated_images/original-dog.8f68a67d2fe0911f33041c0f7fce8aa4ea919f9d3917ec4b468298522aeb6356.de.png) | ![Bild eines Hundes, der als Katze klassifiziert wird](../../../../../translated_images/adversarial-dog.d9fc7773b0142b89752539bfbf884118de845b3851c5162146ea0b8809fc820f.de.png)
![Bild eines Hundes](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/original-dog.png) | ![Bild eines Hundes, der als Katze klassifiziert wird](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/adversarial-dog.png)
-----|-----
*Ursprüngliches Bild eines Hundes* | *Bild eines Hundes, der als Katze klassifiziert wird*
*Originalbild eines Hundes* | *Bild eines Hundes, der als Katze klassifiziert wird*
Siehe den Code, um die oben genannten Ergebnisse im folgenden Notebook zu reproduzieren:
Sehen Sie sich den Code an, um die oben genannten Ergebnisse in folgendem Notebook zu reproduzieren:
* [Ideale und adversariale Katze - TensorFlow](../../../../../lessons/4-ComputerVision/08-TransferLearning/AdversarialCat_TF.ipynb)
## Fazit
Mit Transferlernen können Sie schnell einen Klassifikator für eine benutzerdefinierte Objektklassifizierungsaufgabe zusammenstellen und eine hohe Genauigkeit erreichen. Sie können sehen, dass komplexere Aufgaben, die wir jetzt lösen, mehr 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 zu einer nur geringfügig niedrigeren Genauigkeit führt.
Mit Transfer-Learning können Sie schnell einen Klassifikator für eine benutzerdefinierte Objektklassifikationsaufgabe zusammenstellen und eine hohe Genauigkeit erzielen. Sie 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. Im nächsten Abschnitt werden wir versuchen, eine leichtere Implementierung zu verwenden, um dasselbe Modell mit geringeren Rechenressourcen zu trainieren, was zu einer nur geringfügig niedrigeren Genauigkeit führt.
## 🚀 Herausforderung
In den begleitenden Notebooks gibt es Hinweise am Ende, wie der Wissenstransfer am besten mit einigermaßen ähnlichen Trainingsdaten funktioniert (vielleicht eine neue Tierart). Experimentieren Sie mit völlig neuen Bildtypen, um zu sehen, wie gut oder schlecht Ihre Modelle für den Wissenstransfer abschneiden.
In den begleitenden Notebooks gibt es am Ende Hinweise darauf, dass Transfer-Wissen am besten mit einigermaßen ähnlichen Trainingsdaten funktioniert (zum Beispiel eine neue Tierart). Experimentieren Sie mit völlig neuen Bildtypen, um zu sehen, wie gut oder schlecht Ihre Transfer-Wissen-Modelle abschneiden.
## [Nachlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## Überprüfung & Selbststudium
Lesen Sie [TrainingTricks.md](TrainingTricks.md) durch, um Ihr Wissen über einige andere Möglichkeiten zu vertiefen, wie Sie Ihre Modelle trainieren können.
Lesen Sie [TrainingTricks.md](TrainingTricks.md), um Ihr Wissen über andere Möglichkeiten zur Modellschulung zu vertiefen.
## [Aufgabe](lab/README.md)
In diesem Labor werden wir den realen [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) Haustierdatensatz mit 35 Rassen von Katzen und Hunden verwenden und einen Klassifikator für das Transferlernen erstellen.
In diesem Lab verwenden wir den realen [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) Haustierdatensatz mit 35 Katzen- und Hunderassen und erstellen einen Transfer-Learning-Klassifikator.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, bitten wir zu beachten, 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 wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

95
translations/de/lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md
View File

@ -1,108 +1,117 @@
# Tricks für das Training von Deep Learning
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "ae074cd940fc2f4dc24fc07b66ccbd99",
"translation_date": "2025-08-24T09:37:15+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
"language_code": "de"
}
-->
# Deep Learning Training Tricks
Mit zunehmender Tiefe von neuronalen Netzwerken wird der Trainingsprozess immer herausfordernder. Ein großes Problem sind die sogenannten [verschwindenen Gradienten](https://en.wikipedia.org/wiki/Vanishing_gradient_problem) oder [explodierenden Gradienten](https://deepai.org/machine-learning-glossary-and-terms/exploding-gradient-problem#:~:text=Exploding%20gradients%20are%20a%20problem,updates%20are%20small%20and%20controlled.). [Dieser Beitrag](https://towardsdatascience.com/the-vanishing-exploding-gradient-problem-in-deep-neural-networks-191358470c11) bietet eine gute Einführung in diese Probleme.
Je tiefer neuronale Netzwerke werden, desto herausfordernder wird ihr Training. Ein Hauptproblem sind die sogenannten [verschwindenden Gradienten](https://en.wikipedia.org/wiki/Vanishing_gradient_problem) oder [explodierenden Gradienten](https://deepai.org/machine-learning-glossary-and-terms/exploding-gradient-problem#:~:text=Exploding%20gradients%20are%20a%20problem,updates%20are%20small%20and%20controlled.). [Dieser Artikel](https://towardsdatascience.com/the-vanishing-exploding-gradient-problem-in-deep-neural-networks-191358470c11) bietet eine gute Einführung in diese Probleme.
Um das Training tiefer Netzwerke effizienter zu gestalten, können einige Techniken verwendet werden.
Um das Training tiefer Netzwerke effizienter zu gestalten, gibt es einige Techniken, die angewendet werden können.
## Werte in einem angemessenen Intervall halten
## Werte in einem vernünftigen Bereich halten
Um numerische Berechnungen stabiler zu machen, möchten wir sicherstellen, dass alle Werte in unserem neuronalen Netzwerk innerhalb eines angemessenen Bereichs liegen, typischerweise [-1..1] oder [0..1]. Dies ist keine sehr strenge Anforderung, aber die Natur der Gleitkomma-Berechnungen ist so, dass Werte unterschiedlicher Größenordnung nicht genau zusammen manipuliert werden können. Wenn wir beispielsweise 10<sup>-10</sup> und 10<sup>10</sup> addieren, erhalten wir wahrscheinlich 10<sup>10</sup>, weil der kleinere Wert "in die gleiche Größenordnung" wie der größere umgewandelt wird, und somit die Mantisse verloren geht.
Um numerische Berechnungen stabiler zu machen, sollten alle Werte innerhalb des neuronalen Netzwerks in einem vernünftigen Bereich liegen, typischerweise [-1..1] oder [0..1]. Dies ist keine strikte Anforderung, aber die Natur von Gleitkomma-Berechnungen ist so, dass Werte unterschiedlicher Größenordnungen nicht genau zusammen verarbeitet werden können. Zum Beispiel, wenn wir 10<sup>-10</sup> und 10<sup>10</sup> addieren, erhalten wir wahrscheinlich 10<sup>10</sup>, da der kleinere Wert auf die gleiche Größenordnung wie der größere "umgerechnet" wird und somit die Mantisse verloren geht.
Die meisten Aktivierungsfunktionen haben Nichtlinearitäten im Bereich von [-1..1], daher macht es Sinn, alle Eingabedaten auf den Intervall [-1..1] oder [0..1] zu skalieren.
Die meisten Aktivierungsfunktionen haben Nichtlinearitäten im Bereich von [-1..1], daher macht es Sinn, alle Eingabedaten auf den Bereich [-1..1] oder [0..1] zu skalieren.
## Initiale Gewichtsinitalisierung
## Initialisierung der Gewichte
Idealerweise möchten wir, dass die Werte nach dem Durchlaufen der Netzwerkebenen im gleichen Bereich liegen. Daher ist es wichtig, die Gewichte so zu initialisieren, dass die Verteilung der Werte erhalten bleibt.
Idealerweise sollten die Werte nach dem Durchlaufen der Netzwerkschichten im gleichen Bereich bleiben. Daher ist es wichtig, die Gewichte so zu initialisieren, dass die Verteilung der Werte erhalten bleibt.
Eine normale Verteilung **N(0,1)** ist keine gute Idee, denn wenn wir *n* Eingaben haben, wäre die Standardabweichung des Outputs *n*, und die Werte würden wahrscheinlich aus dem Intervall [0..1] herausspringen.
Eine Normalverteilung **N(0,1)** ist keine gute Idee, da bei *n* Eingaben die Standardabweichung der Ausgabe *n* wäre und die Werte wahrscheinlich aus dem Bereich [0..1] herausfallen.
Die folgenden Initialisierungen werden häufig verwendet:
* Gleichverteilung -- `uniform`
* **N(0,1/n)** -- `gaussian`
* **N(0,1/√n_in)** garantiert, dass für Eingaben mit einem Mittelwert von null und einer Standardabweichung von 1 der gleiche Mittelwert/die gleiche Standardabweichung erhalten bleibt.
* **N(0,√2/(n_in+n_out))** -- die sogenannte **Xavier-Initalisierung** (`glorot`), sie hilft, die Signale während der Vorwärts- und Rückwärtspropagation im Bereich zu halten.
* **N(0,1/√n_in)** garantiert, dass für Eingaben mit einem Mittelwert von 0 und einer Standardabweichung von 1 der gleiche Mittelwert/Standardabweichung erhalten bleibt
* **N(0,√2/(n_in+n_out))** -- die sogenannte **Xavier-Initialisierung** (`glorot`), die hilft, die Signale während der Vorwärts- und Rückwärtsausbreitung im Bereich zu halten
## Batch-Normalisierung
Selbst bei einer ordnungsgemäßen Gewichtsinitalisierung können die Gewichte während des Trainings willkürlich groß oder klein werden, was dazu führt, dass die Signale aus dem richtigen Bereich herauskommen. Wir können die Signale zurückbringen, indem wir eine der **Normalisierung**-Techniken verwenden. Während es mehrere davon gibt (Gewichtsnormierung, Schichtnormalisierung), wird die am häufigsten verwendete Batch-Normalisierung.
Selbst bei ordnungsgemäßer Initialisierung der Gewichte können diese während des Trainings beliebig groß oder klein werden und die Signale aus dem richtigen Bereich bringen. Wir können die Signale mit einer der **Normalisierungstechniken** wieder in den Bereich bringen. Während es mehrere davon gibt (Gewichtsnormierung, Schichtnormierung), wird am häufigsten die Batch-Normalisierung verwendet.
Die Idee der **Batch-Normalisierung** besteht darin, alle Werte über das Minibatch hinweg zu berücksichtigen und die Normalisierung (d.h. Mittelwert subtrahieren und durch die Standardabweichung teilen) auf der Grundlage dieser Werte durchzuführen. Sie wird als Netzwerkschicht implementiert, die diese Normalisierung nach der Anwendung der Gewichte, aber vor der Aktivierungsfunktion durchführt. Infolgedessen sehen wir wahrscheinlich eine höhere endgültige Genauigkeit und ein schnelleres Training.
Die Idee der **Batch-Normalisierung** besteht darin, alle Werte innerhalb des Minibatches zu berücksichtigen und eine Normalisierung (d. h. Mittelwert abziehen und durch Standardabweichung teilen) basierend auf diesen Werten durchzuführen. Sie wird als Netzwerkschicht implementiert, die diese Normalisierung nach der Anwendung der Gewichte, aber vor der Aktivierungsfunktion durchführt. Dadurch erreichen wir in der Regel eine höhere Endgenauigkeit und schnelleres Training.
Hier ist das [ursprüngliche Papier](https://arxiv.org/pdf/1502.03167.pdf) zur Batch-Normalisierung, die [Erklärung auf Wikipedia](https://en.wikipedia.org/wiki/Batch_normalization) und [ein guter einführender Blogbeitrag](https://towardsdatascience.com/batch-normalization-in-3-levels-of-understanding-14c2da90a338) (und der [auf Russisch](https://habrahabr.ru/post/309302/)).
Hier ist das [Originalpapier](https://arxiv.org/pdf/1502.03167.pdf) zur Batch-Normalisierung, die [Erklärung auf Wikipedia](https://en.wikipedia.org/wiki/Batch_normalization) und [ein guter einführender Blogbeitrag](https://towardsdatascience.com/batch-normalization-in-3-levels-of-understanding-14c2da90a338) (und einer [auf Russisch](https://habrahabr.ru/post/309302/)).
## Dropout
**Dropout** ist eine interessante Technik, die während des Trainings einen bestimmten Prozentsatz zufälliger Neuronen entfernt. Sie wird ebenfalls als Schicht mit einem Parameter (Prozentsatz der zu entfernenden Neuronen, typischerweise 10%-50%) implementiert, und während des Trainings werden zufällige Elemente des Eingangsvektors auf null gesetzt, bevor sie an die nächste Schicht weitergegeben werden.
**Dropout** ist eine interessante Technik, bei der ein bestimmter Prozentsatz zufälliger Neuronen während des Trainings entfernt wird. Es wird ebenfalls als Schicht mit einem Parameter (Prozentsatz der zu entfernenden Neuronen, typischerweise 10%-50%) implementiert, und während des Trainings werden zufällige Elemente des Eingabevektors auf null gesetzt, bevor sie an die nächste Schicht weitergegeben werden.
Obwohl dies seltsam erscheinen mag, können Sie den Effekt von Dropout auf das Training eines MNIST-Ziffernklassifikators im [`Dropout.ipynb`](../../../../../lessons/4-ComputerVision/08-TransferLearning/Dropout.ipynb) Notizbuch sehen. Es beschleunigt das Training und ermöglicht es uns, in weniger Trainings-Epochen eine höhere Genauigkeit zu erreichen.
Auch wenn dies seltsam klingen mag, können Sie die Wirkung von Dropout beim Training eines MNIST-Ziffernklassifikators im [`Dropout.ipynb`](../../../../../lessons/4-ComputerVision/08-TransferLearning/Dropout.ipynb)-Notebook sehen. Es beschleunigt das Training und ermöglicht es uns, in weniger Trainingsepochen eine höhere Genauigkeit zu erreichen.
Dieser Effekt kann auf verschiedene Weise erklärt werden:
* Es kann als ein zufälliger Schockfaktor für das Modell betrachtet werden, der die Optimierung aus dem lokalen Minimum herausnimmt.
* Es kann als *implizite Modellmittelung* betrachtet werden, weil wir sagen können, dass wir während des Dropouts ein leicht anderes Modell trainieren.
* Es kann als zufälliger Schockfaktor für das Modell betrachtet werden, der die Optimierung aus einem lokalen Minimum herausführt
* Es kann als *implizites Modellmittelwertbilden* betrachtet werden, da man sagen kann, dass während des Dropouts leicht unterschiedliche Modelle trainiert werden
> *Einige Leute sagen, dass wenn eine betrunkene Person versucht, etwas zu lernen, sie sich am nächsten Morgen besser daran erinnert als eine nüchterne Person, weil das Gehirn mit einigen defekten Neuronen versucht, sich besser anzupassen, um den Sinn zu erfassen. Wir haben nie getestet, ob das wahr ist oder nicht.*
> *Manche Leute sagen, dass eine betrunkene Person, die versucht, etwas zu lernen, sich dies am nächsten Morgen besser merken kann als eine nüchterne Person, weil ein Gehirn mit einigen fehlerhaften Neuronen besser versucht, den Sinn zu erfassen. Wir haben nie getestet, ob das stimmt oder nicht.*
## Überanpassung verhindern
Ein sehr wichtiger Aspekt des Deep Learning ist die Fähigkeit, [Überanpassung](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) zu verhindern. Obwohl es verlockend sein könnte, ein sehr leistungsstarkes neuronales Netzwerkmodell zu verwenden, sollten wir immer die Anzahl der Modellparameter mit der Anzahl der Trainingsproben in Einklang bringen.
Ein sehr wichtiger Aspekt des Deep Learnings ist es, [Überanpassung](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) zu verhindern. Auch wenn es verlockend sein mag, ein sehr leistungsstarkes neuronales Netzwerkmodell zu verwenden, sollten wir die Anzahl der Modellparameter immer mit der Anzahl der Trainingsbeispiele in Einklang bringen.
> Stellen Sie sicher, dass Sie das Konzept der [Überanpassung](../../3-NeuralNetworks/05-Frameworks/Overfitting.md), das wir zuvor eingeführt haben, verstehen!
> Stellen Sie sicher, dass Sie das Konzept der [Überanpassung](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) verstanden haben, das wir zuvor eingeführt haben!
Es gibt mehrere Möglichkeiten, Überanpassung zu verhindern:
* Frühes Stoppen -- kontinuierliche Überwachung des Fehlers im Validierungsdatensatz und das Stoppen des Trainings, wenn der Validierungsfehler zu steigen beginnt.
* Explizite Gewichtsnormierung / Regularisierung -- Hinzufügen einer zusätzlichen Strafe zur Verlustfunktion für hohe absolute Werte der Gewichte, was verhindert, dass das Modell sehr instabile Ergebnisse erzielt.
* Modellmittelung -- Training mehrerer Modelle und anschließendes Mittelung des Ergebnisses. Dies hilft, die Varianz zu minimieren.
* Dropout (implizite Modellmittelung).
* Frühes Stoppen -- kontinuierliches Überwachen des Fehlers auf dem Validierungsdatensatz und Beenden des Trainings, wenn der Validierungsfehler zu steigen beginnt.
* Expliziter Gewichtsrückgang / Regularisierung -- Hinzufügen einer zusätzlichen Strafe zur Verlustfunktion für hohe absolute Werte der Gewichte, was verhindert, dass das Modell sehr instabile Ergebnisse liefert
* Modellmittelwertbildung -- Training mehrerer Modelle und anschließendes Mitteln der Ergebnisse. Dies hilft, die Varianz zu minimieren.
* Dropout (implizite Modellmittelwertbildung)
## Optimierer / Trainingsalgorithmen
Ein weiterer wichtiger Aspekt des Trainings ist die Wahl eines guten Trainingsalgorithmus. Während der klassische **Gradientenabstieg** eine vernünftige Wahl ist, kann er manchmal zu langsam sein oder andere Probleme verursachen.
Im Deep Learning verwenden wir **Stochastic Gradient Descent** (SGD), was ein Gradientabstieg ist, der auf Minibatches angewendet wird, die zufällig aus dem Trainingssatz ausgewählt werden. Die Gewichte werden mit dieser Formel angepasst:
Im Deep Learning verwenden wir den **stochastischen Gradientenabstieg** (SGD), der ein Gradientenabstieg ist, der auf Minibatches angewendet wird, die zufällig aus dem Trainingssatz ausgewählt werden. Die Gewichte werden mit dieser Formel angepasst:
w<sup>t+1</sup> = w<sup>t</sup> - η∇ℒ
### Momentum
Im **Momentum SGD** behalten wir einen Teil des Gradienten aus vorherigen Schritten bei. Es ist ähnlich, als würden wir uns mit Trägheit bewegen und einen Stoß in eine andere Richtung erhalten; unsere Trajektorie ändert sich nicht sofort, sondern behält einen Teil der ursprünglichen Bewegung bei. Hier führen wir einen weiteren Vektor v ein, um die *Geschwindigkeit* darzustellen:
Beim **Momentum-SGD** behalten wir einen Teil des Gradienten aus vorherigen Schritten bei. Es ist ähnlich wie bei einer Bewegung mit Trägheit: Wenn wir in eine Richtung unterwegs sind und einen Stoß in eine andere Richtung erhalten, ändert sich unsere Flugbahn nicht sofort, sondern behält einen Teil der ursprünglichen Bewegung bei. Hier führen wir einen weiteren Vektor v ein, um die *Geschwindigkeit* darzustellen:
* v<sup>t+1</sup> = γ v<sup>t</sup> - η∇ℒ
* w<sup>t+1</sup> = w<sup>t</sup> + v<sup>t+1</sup>
* w<sup>t+1</sup> = w<sup>t</sup>+v<sup>t+1</sup>
Hier gibt der Parameter γ an, inwieweit wir die Trägheit berücksichtigen: γ=0 entspricht dem klassischen SGD; γ=1 ist eine reine Bewegungsgleichung.
Hier gibt der Parameter γ an, in welchem Maße wir die Trägheit berücksichtigen: γ=0 entspricht dem klassischen SGD; γ=1 ist eine reine Bewegungsgleichung.
### Adam, Adagrad usw.
### Adam, Adagrad, etc.
Da wir in jeder Schicht Signale mit einer Matrix W<sub>i</sub> multiplizieren, kann der Gradient je nach ||W<sub>i</sub>|| entweder abnehmen und nahe bei 0 sein oder unbegrenzt steigen. Dies ist das Wesen des Problems der explodierenden/verschwindenen Gradienten.
Da in jeder Schicht Signale mit einer Matrix W<sub>i</sub> multipliziert werden, kann der Gradient je nach ||W<sub>i</sub>|| entweder verschwinden und nahe 0 sein oder unbegrenzt ansteigen. Dies ist das Wesen des Exploding/Vanishing-Gradients-Problems.
Eine der Lösungen für dieses Problem besteht darin, nur die Richtung des Gradienten in der Gleichung zu verwenden und den absoluten Wert zu ignorieren, d.h.
Eine Lösung für dieses Problem besteht darin, in der Gleichung nur die Richtung des Gradienten zu verwenden und den absoluten Wert zu ignorieren, d. h.
w<sup>t+1</sup> = w<sup>t</sup> - η(∇ℒ/||∇ℒ||), wobei ||∇ℒ|| = √∑(∇ℒ)<sup>2</sup>
Dieser Algorithmus wird **Adagrad** genannt. Weitere Algorithmen, die dieselbe Idee verwenden: **RMSProp**, **Adam**.
Dieser Algorithmus wird **Adagrad** genannt. Andere Algorithmen, die dieselbe Idee verwenden: **RMSProp**, **Adam**
> **Adam** gilt als sehr effizienter Algorithmus für viele Anwendungen, also wenn Sie sich nicht sicher sind, welchen Sie verwenden sollen - verwenden Sie Adam.
> **Adam** gilt als ein sehr effizienter Algorithmus für viele Anwendungen. Wenn Sie sich nicht sicher sind, welchen Sie verwenden sollen, nehmen Sie Adam.
### Gradientenbeschneidung
### Gradient Clipping
Gradientenbeschneidung ist eine Erweiterung der obigen Idee. Wenn ||∇ℒ|| ≤ θ, berücksichtigen wir den ursprünglichen Gradienten bei der Gewichtoptimierung, und wenn ||∇ℒ|| > θ - teilen wir den Gradienten durch seine Norm. Hier ist θ ein Parameter, in den meisten Fällen können wir θ=1 oder θ=10 wählen.
Gradient Clipping ist eine Erweiterung der obigen Idee. Wenn ||∇ℒ|| ≤ θ, verwenden wir den ursprünglichen Gradienten in der Gewichtsoptimierung, und wenn ||∇ℒ|| > θ, teilen wir den Gradienten durch seine Norm. Hier ist θ ein Parameter, in den meisten Fällen können wir θ=1 oder θ=10 wählen.
### Lernratenverfall
### Lernratenabnahme
Der Erfolg des Trainings hängt oft vom Lernratenparameter η ab. Es ist logisch anzunehmen, dass größere Werte von η zu schnellerem Training führen, was wir typischerweise zu Beginn des Trainings wollen, und dann kleinere Werte von η uns ermöglichen, das Netzwerk fein abzustimmen. Daher möchten wir in den meisten Fällen η während des Trainings verringern.
Der Erfolg des Trainings hängt oft vom Lernratenparameter η ab. Es ist logisch anzunehmen, dass größere Werte von η zu schnellerem Training führen, was wir typischerweise zu Beginn des Trainings wollen, und dass kleinere Werte von η es uns ermöglichen, das Netzwerk fein abzustimmen. Daher möchten wir in den meisten Fällen η im Verlauf des Trainings verringern.
Dies kann erreicht werden, indem η nach jeder Trainings-Epoche mit einer bestimmten Zahl (z.B. 0,98) multipliziert wird oder durch die Verwendung eines komplizierteren **Lernratenplans**.
Dies kann erreicht werden, indem η nach jeder Epoche des Trainings mit einer Zahl (z. B. 0,98) multipliziert wird, oder durch die Verwendung eines komplizierteren **Lernratenplans**.
## Verschiedene Netzwerkarchitekturen
Die Auswahl der richtigen Netzwerkarchitektur für Ihr Problem kann knifflig sein. Normalerweise würden wir eine Architektur wählen, die sich für unsere spezifische Aufgabe (oder eine ähnliche) bewährt hat. Hier ist eine [gute Übersicht](https://www.topbots.com/a-brief-history-of-neural-network-architectures/) über neuronale Netzwerkarchitekturen für die Computer Vision.
Die Auswahl der richtigen Netzwerkarchitektur für Ihr Problem kann knifflig sein. Normalerweise würden wir eine Architektur wählen, die sich für unsere spezifische Aufgabe (oder eine ähnliche) bewährt hat. Hier ist ein [guter Überblick](https://www.topbots.com/a-brief-history-of-neural-network-architectures/) über neuronale Netzwerkarchitekturen für Computer Vision.
> Es ist wichtig, eine Architektur auszuwählen, die leistungsfähig genug für die Anzahl der Trainingsproben ist, die wir haben. Eine zu leistungsstarke Modellwahl kann zu [Überanpassung](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) führen.
> Es ist wichtig, eine Architektur zu wählen, die leistungsstark genug für die Anzahl der Trainingsbeispiele ist, die wir haben. Eine zu leistungsstarke Modellwahl kann zu [Überanpassung](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) führen.
Ein weiterer guter Weg wäre, eine Architektur zu verwenden, die sich automatisch an die erforderliche Komplexität anpasst. Bis zu einem gewissen Grad sind die Architekturen **ResNet** und **Inception** selbstanpassend. [Mehr zu Architekturen der Computer Vision](../07-ConvNets/CNN_Architectures.md)
Eine weitere gute Möglichkeit wäre die Verwendung einer Architektur, die sich automatisch an die erforderliche Komplexität anpasst. Bis zu einem gewissen Grad sind die **ResNet**-Architektur und **Inception** selbstanpassend. [Mehr zu Computer-Vision-Architekturen](../07-ConvNets/CNN_Architectures.md)
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ausgangssprache sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

21
translations/de/lessons/4-ComputerVision/08-TransferLearning/lab/README.md
View File

@ -1,10 +1,19 @@
# Klassifizierung von Oxford-Haustieren mit Transferlernen
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
"translation_date": "2025-08-24T09:37:45+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/lab/README.md",
"language_code": "de"
}
-->
# Klassifikation von Oxford-Haustieren mit Transfer-Learning
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
Stellen Sie sich vor, Sie müssen eine Anwendung für eine Tieraufzucht entwickeln, um alle Haustiere zu katalogisieren. Eine der großartigen Funktionen einer solchen Anwendung wäre die automatische Erkennung der Rasse anhand eines Fotos. In dieser Aufgabe werden wir Transferlernen nutzen, um echte Haustierbilder aus dem [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) Haustier-Datensatz zu klassifizieren.
Stellen Sie sich vor, Sie müssen eine Anwendung für eine Tierpension entwickeln, um alle Haustiere zu katalogisieren. Eine großartige Funktion einer solchen Anwendung wäre die automatische Erkennung der Rasse anhand eines Fotos. In dieser Aufgabe werden wir Transfer-Learning verwenden, um echte Bilder von Haustieren aus dem [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) Haustier-Datensatz zu klassifizieren.
## Der Datensatz
@ -18,13 +27,13 @@ Um den Datensatz herunterzuladen, verwenden Sie diesen Code-Schnipsel:
!rm images.tar.gz
```
## Notebook starten
## Start des Notebooks
Beginnen Sie das Labor, indem Sie [OxfordPets.ipynb](../../../../../../lessons/4-ComputerVision/08-TransferLearning/lab/OxfordPets.ipynb) öffnen.
## Fazit
## Erkenntnis
Transferlernen und vortrainierte Netzwerke ermöglichen es uns, reale Bildklassifizierungsprobleme relativ einfach zu lösen. Allerdings funktionieren vortrainierte Netzwerke gut bei Bildern ähnlicher Art, und wenn wir beginnen, sehr unterschiedliche Bilder (z. B. medizinische Bilder) zu klassifizieren, werden wir wahrscheinlich viel schlechtere Ergebnisse erzielen.
Transfer-Learning und vortrainierte Netzwerke ermöglichen es uns, reale Bildklassifikationsprobleme relativ einfach zu lösen. Allerdings funktionieren vortrainierte Netzwerke gut bei Bildern ähnlicher Art, und wenn wir anfangen, sehr unterschiedliche Bilder zu klassifizieren (z. B. medizinische Bilder), werden die Ergebnisse wahrscheinlich deutlich schlechter ausfallen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

85
translations/de/lessons/4-ComputerVision/09-Autoencoders/README.md
View File

@ -1,58 +1,67 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "0b306c04f5337b6e7430e5c0b16bb5c0",
"translation_date": "2025-08-24T09:33:46+00:00",
"source_file": "lessons/4-ComputerVision/09-Autoencoders/README.md",
"language_code": "de"
}
-->
# Autoencoder
Beim Training von CNNs besteht eines der Probleme darin, dass wir eine große Menge an beschrifteten Daten benötigen. Im Falle der Bildklassifikation müssen wir Bilder in verschiedene Klassen unterteilen, was einen manuellen Aufwand erfordert.
Beim Training von CNNs besteht eines der Probleme darin, dass wir viele gelabelte Daten benötigen. Im Fall der Bildklassifikation müssen wir Bilder in verschiedene Klassen unterteilen, was manuell erfolgen muss.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/109)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/109)
Wir möchten jedoch möglicherweise rohe (unbeschriftete) Daten für das Training von CNN-Feature-Extraktoren verwenden, was als **selbstüberwachtes Lernen** bezeichnet wird. Anstelle von Beschriftungen verwenden wir Trainingsbilder sowohl als Eingabe als auch als Ausgabe des Netzwerks. Die Hauptidee des **Autoencoders** ist, dass wir ein **Encoder-Netzwerk** haben, das das Eingangsbild in einen **latent space** (normalerweise ein Vektor einer kleineren Größe) umwandelt, und dann das **Decoder-Netzwerk**, dessen Ziel es ist, das ursprüngliche Bild wiederherzustellen.
Wir möchten jedoch möglicherweise rohe (nicht gelabelte) Daten verwenden, um CNN-Feature-Extraktoren zu trainieren, was als **selbstüberwachtes Lernen** bezeichnet wird. Anstelle von Labels verwenden wir Trainingsbilder sowohl als Netzwerkeingabe als auch als -ausgabe. Die Hauptidee des **Autoencoders** besteht darin, dass wir ein **Encoder-Netzwerk** haben, das das Eingabebild in einen **latenten Raum** umwandelt (normalerweise ist dies einfach ein Vektor mit kleinerer Größe), und dann ein **Decoder-Netzwerk**, dessen Ziel es ist, das ursprüngliche Bild zu rekonstruieren.
> ✅ Ein [Autoencoder](https://wikipedia.org/wiki/Autoencoder) ist "eine Art künstliches neuronales Netzwerk, das verwendet wird, um effiziente Kodierungen von unbeschrifteten Daten zu lernen."
> ✅ Ein [Autoencoder](https://wikipedia.org/wiki/Autoencoder) ist "eine Art künstliches neuronales Netzwerk, das verwendet wird, um effiziente Kodierungen von nicht gelabelten Daten zu lernen."
Da wir einen Autoencoder trainieren, um so viele Informationen wie möglich aus dem ursprünglichen Bild für eine genaue Rekonstruktion zu erfassen, versucht das Netzwerk, die beste **Einbettung** der Eingabebilder zu finden, um die Bedeutung zu erfassen.
![AutoEncoder Diagramm](../../../../../translated_images/autoencoder_schema.5e6fc9ad98a5eb6197f3513cf3baf4dfbe1389a6ae74daebda64de9f1c99f142.de.jpg)
![AutoEncoder Diagramm](../../../../../lessons/4-ComputerVision/09-Autoencoders/images/autoencoder_schema.jpg)
> Bild von [Keras Blog](https://blog.keras.io/building-autoencoders-in-keras.html)
## Szenarien für die Verwendung von Autoencodern
Obwohl die Rekonstruktion ursprünglicher Bilder an sich nicht nützlich erscheint, gibt es einige Szenarien, in denen Autoencoder besonders nützlich sind:
Obwohl die Rekonstruktion ursprünglicher Bilder an sich nicht nützlich erscheint, gibt es einige Szenarien, in denen Autoencoder besonders hilfreich sind:
* **Reduzierung der Dimension von Bildern zur Visualisierung** oder **Training von Bild-Einbettungen**. In der Regel liefern Autoencoder bessere Ergebnisse als PCA, da sie die räumliche Natur von Bildern und hierarchische Merkmale berücksichtigen.
* **Rauschunterdrückung**, d.h. das Entfernen von Rauschen aus dem Bild. Da Rauschen viele nutzlose Informationen enthält, kann der Autoencoder diese nicht alle in den relativ kleinen latenten Raum einfügen und erfasst daher nur den wichtigen Teil des Bildes. Beim Training von Rauschunterdrückern beginnen wir mit den Originalbildern und verwenden Bilder mit künstlich hinzugefügtem Rauschen als Eingabe für den Autoencoder.
* **Superauflösung**, d.h. Erhöhung der Bildauflösung. Wir beginnen mit hochauflösenden Bildern und verwenden das Bild mit niedrigerer Auflösung als Eingabe für den Autoencoder.
* **Reduzierung der Dimension von Bildern zur Visualisierung** oder **Training von Bild-Einbettungen**. Autoencoder liefern normalerweise bessere Ergebnisse als PCA, da sie die räumliche Natur von Bildern und hierarchische Merkmale berücksichtigen.
* **Rauschunterdrückung**, d.h. das Entfernen von Rauschen aus dem Bild. Da Rauschen viele unnütze Informationen enthält, kann der Autoencoder nicht alles in den relativ kleinen latenten Raum einpassen und erfasst daher nur den wichtigen Teil des Bildes. Beim Training von Rauschunterdrückern beginnen wir mit den ursprünglichen Bildern und verwenden Bilder mit künstlich hinzugefügtem Rauschen als Eingabe für den Autoencoder.
* **Superauflösung**, Erhöhung der Bildauflösung. Wir beginnen mit hochauflösenden Bildern und verwenden das Bild mit niedrigerer Auflösung als Eingabe für den Autoencoder.
* **Generative Modelle**. Sobald wir den Autoencoder trainiert haben, kann der Decoder-Teil verwendet werden, um neue Objekte aus zufälligen latenten Vektoren zu erstellen.
## Variationale Autoencoder (VAE)
Traditionelle Autoencoder reduzieren die Dimension der Eingabedaten auf irgendeine Weise, indem sie die wichtigen Merkmale der Eingabebilder herausfinden. Allerdings machen latente Vektoren oft nicht viel Sinn. Mit anderen Worten, wenn wir das MNIST-Dataset als Beispiel nehmen, ist es keine einfache Aufgabe herauszufinden, welche Ziffern verschiedenen latenten Vektoren entsprechen, da nahe latente Vektoren nicht unbedingt den gleichen Ziffern entsprechen.
Traditionelle Autoencoder reduzieren die Dimension der Eingabedaten auf irgendeine Weise und identifizieren die wichtigen Merkmale der Eingabebilder. Allerdings machen latente Vektoren oft wenig Sinn. Mit anderen Worten, wenn wir das MNIST-Dataset als Beispiel nehmen, ist es nicht einfach herauszufinden, welche Ziffern zu verschiedenen latenten Vektoren gehören, da nahe latente Vektoren nicht unbedingt denselben Ziffern entsprechen.
Andererseits ist es besser, um *generative* Modelle zu trainieren, ein gewisses Verständnis des latenten Raums zu haben. Diese Idee führt uns zu **variational auto-encoder** (VAE).
Um generative Modelle zu trainieren, ist es jedoch besser, ein Verständnis des latenten Raums zu haben. Diese Idee führt uns zu **variationalen Autoencodern** (VAE).
VAE ist der Autoencoder, der lernt, die *statistische Verteilung* der latenten Parameter, die sogenannte **latente Verteilung**, vorherzusagen. Zum Beispiel möchten wir, dass latente Vektoren normal verteilt sind mit einem Mittelwert z<sub>mean</sub> und einer Standardabweichung z<sub>sigma</sub> (sowohl Mittelwert als auch Standardabweichung sind Vektoren einer bestimmten Dimension d). Der Encoder in VAE lernt, diese Parameter vorherzusagen, und dann nimmt der Decoder einen zufälligen Vektor aus dieser Verteilung, um das Objekt zu rekonstruieren.
Ein VAE ist ein Autoencoder, der lernt, die *statistische Verteilung* der latenten Parameter vorherzusagen, die sogenannte **latente Verteilung**. Zum Beispiel möchten wir möglicherweise, dass latente Vektoren normal verteilt sind mit einem Mittelwert z<sub>mean</sub> und einer Standardabweichung z<sub>sigma</sub> (sowohl Mittelwert als auch Standardabweichung sind Vektoren einer bestimmten Dimensionalität d). Der Encoder im VAE lernt, diese Parameter vorherzusagen, und der Decoder nimmt dann einen zufälligen Vektor aus dieser Verteilung, um das Objekt zu rekonstruieren.
Zusammenfassend:
Zusammengefasst:
* Vom Eingangsvektor sagen wir `z_mean` und `z_log_sigma` voraus (anstatt die Standardabweichung selbst vorherzusagen, sagen wir ihren Logarithmus voraus)
* Wir ziehen einen Vektor `sample` aus der Verteilung N(z<sub>mean</sub>,exp(z<sub>log\_sigma</sub>))
* Der Decoder versucht, das ursprüngliche Bild unter Verwendung von `sample` als Eingangsvektor zu decodieren
* Aus dem Eingabevektor sagen wir `z_mean` und `z_log_sigma` voraus (anstatt die Standardabweichung selbst vorherzusagen, sagen wir deren Logarithmus voraus).
* Wir entnehmen einen Vektor `sample` aus der Verteilung N(z<sub>mean</sub>,exp(z<sub>log\_sigma</sub>)).
* Der Decoder versucht, das ursprüngliche Bild mithilfe von `sample` als Eingabevektor zu dekodieren.
<img src="images/vae.png" width="50%">
<img src="images/vae.png" width="50%">
> Bild von [diesem Blogbeitrag](https://ijdykeman.github.io/ml/2016/12/21/cvae.html) von Isaak Dykeman
> Bild aus [diesem Blogbeitrag](https://ijdykeman.github.io/ml/2016/12/21/cvae.html) von Isaak Dykeman
Variationale Autoencoder verwenden eine komplexe Verlustfunktion, die aus zwei Teilen besteht:
* **Rekonstruktionsverlust** ist die Verlustfunktion, die zeigt, wie nah ein rekonstruiertes Bild am Zielbild ist (es kann der Mittlere Quadratische Fehler, oder MSE, sein). Es ist dieselbe Verlustfunktion wie bei normalen Autoencodern.
* **KL-Verlust**, der sicherstellt, dass die Verteilungen der latenten Variablen nahe an der Normalverteilung bleiben. Er basiert auf dem Konzept der [Kullback-Leibler-Divergenz](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained) - eine Metrik zur Schätzung, wie ähnlich zwei statistische Verteilungen sind.
* **Rekonstruktionsverlust** ist die Verlustfunktion, die zeigt, wie nah ein rekonstruiertes Bild am Ziel ist (es kann Mean Squared Error oder MSE sein). Es ist dieselbe Verlustfunktion wie bei normalen Autoencodern.
* **KL-Verlust**, der sicherstellt, dass die Verteilung der latenten Variablen nahe an der Normalverteilung bleibt. Er basiert auf dem Konzept der [Kullback-Leibler-Divergenz](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained) - einem Maß zur Schätzung der Ähnlichkeit zweier statistischer Verteilungen.
Ein wichtiger Vorteil von VAEs ist, dass sie es uns ermöglichen, relativ einfach neue Bilder zu generieren, da wir wissen, aus welcher Verteilung wir latente Vektoren ziehen können. Wenn wir beispielsweise VAE mit einem 2D-latenten Vektor auf MNIST trainieren, können wir dann die Komponenten des latenten Vektors variieren, um verschiedene Ziffern zu erhalten:
Ein wichtiger Vorteil von VAEs ist, dass sie es uns ermöglichen, relativ einfach neue Bilder zu generieren, da wir wissen, aus welcher Verteilung wir latente Vektoren entnehmen müssen. Wenn wir beispielsweise einen VAE mit einem 2D-latenten Vektor auf MNIST trainieren, können wir dann die Komponenten des latenten Vektors variieren, um verschiedene Ziffern zu erhalten:
<img alt="vaemnist" src="images/vaemnist.png" width="50%"/>
> Bild von [Dmitry Soshnikov](http://soshnikov.com)
Beobachten Sie, wie die Bilder ineinander übergehen, während wir latente Vektoren aus verschiedenen Bereichen des latenten Parameterraums erhalten. Wir können diesen Raum auch in 2D visualisieren:
Beobachten Sie, wie Bilder ineinander übergehen, wenn wir beginnen, latente Vektoren aus verschiedenen Bereichen des latenten Parameterraums zu entnehmen. Wir können diesen Raum auch in 2D visualisieren:
<img alt="vaemnist cluster" src="images/vaemnist-diag.png" width="50%"/>
@ -60,41 +69,41 @@ Beobachten Sie, wie die Bilder ineinander übergehen, während wir latente Vekto
## ✍️ Übungen: Autoencoder
Erfahren Sie mehr über Autoencoder in diesen entsprechenden Notizbüchern:
Erfahren Sie mehr über Autoencoder in den entsprechenden Notebooks:
* [Autoencoders in TensorFlow](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb)
* [Autoencoders in PyTorch](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoEncodersPyTorch.ipynb)
* [Autoencoder in TensorFlow](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb)
* [Autoencoder in PyTorch](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoEncodersPyTorch.ipynb)
## Eigenschaften von Autoencodern
* **Daten-spezifisch** - sie funktionieren nur gut mit der Art von Bildern, auf denen sie trainiert wurden. Wenn wir beispielsweise ein Superauflösungsnetzwerk auf Blumen trainieren, wird es bei Porträts nicht gut abschneiden. Das liegt daran, dass das Netzwerk ein hochauflösendes Bild erzeugen kann, indem es feine Details aus den im Trainingsdatensatz gelernten Merkmalen entnimmt.
* **Verlustbehaftet** - das rekonstruierte Bild ist nicht dasselbe wie das ursprüngliche Bild. Die Art des Verlusts wird durch die *Verlustfunktion* definiert, die während des Trainings verwendet wird.
* Funktioniert mit **unbeschrifteten Daten**.
* **Daten-spezifisch** - sie funktionieren nur gut mit der Art von Bildern, auf denen sie trainiert wurden. Wenn wir beispielsweise ein Superauflösungsnetzwerk auf Blumen trainieren, wird es bei Porträts nicht gut funktionieren. Dies liegt daran, dass das Netzwerk ein hochauflösendes Bild erzeugen kann, indem es feine Details aus den Merkmalen des Trainingsdatensatzes entnimmt.
* **Verlustbehaftet** - das rekonstruierte Bild ist nicht identisch mit dem ursprünglichen Bild. Die Art des Verlusts wird durch die *Verlustfunktion* definiert, die während des Trainings verwendet wird.
* Funktioniert mit **nicht gelabelten Daten**
## [Nachlese-Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/209)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/209)
## Fazit
In dieser Lektion haben Sie die verschiedenen Arten von Autoencodern kennengelernt, die für den KI-Wissenschaftler verfügbar sind. Sie haben gelernt, wie man sie baut und wie man sie zur Rekonstruktion von Bildern verwendet. Sie haben auch über den VAE gelernt und wie man ihn verwendet, um neue Bilder zu generieren.
In dieser Lektion haben Sie die verschiedenen Arten von Autoencodern kennengelernt, die einem KI-Wissenschaftler zur Verfügung stehen. Sie haben gelernt, wie man sie erstellt und wie man sie verwendet, um Bilder zu rekonstruieren. Sie haben auch den VAE kennengelernt und erfahren, wie man ihn verwendet, um neue Bilder zu generieren.
## 🚀 Herausforderung
In dieser Lektion haben Sie gelernt, wie man Autoencoder für Bilder verwendet. Aber sie können auch für Musik verwendet werden! Schauen Sie sich das Projekt [MusicVAE](https://magenta.tensorflow.org/music-vae) des Magenta-Projekts an, das Autoencoder verwendet, um zu lernen, Musik zu rekonstruieren. Machen Sie einige [Experimente](https://colab.research.google.com/github/magenta/magenta-demos/blob/master/colab-notebooks/Multitrack_MusicVAE.ipynb) mit dieser Bibliothek, um zu sehen, was Sie erstellen können.
In dieser Lektion haben Sie gelernt, wie man Autoencoder für Bilder verwendet. Aber sie können auch für Musik verwendet werden! Schauen Sie sich das [MusicVAE](https://magenta.tensorflow.org/music-vae)-Projekt des Magenta-Projekts an, das Autoencoder verwendet, um Musik zu rekonstruieren. Machen Sie einige [Experimente](https://colab.research.google.com/github/magenta/magenta-demos/blob/master/colab-notebooks/Multitrack_MusicVAE.ipynb) mit dieser Bibliothek, um zu sehen, was Sie erstellen können.
## [Nachlese-Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## Überprüfung & Selbststudium
Zur Referenz lesen Sie mehr über Autoencoder in diesen Ressourcen:
Lesen Sie zur Referenz mehr über Autoencoder in diesen Ressourcen:
* [Autoencoder in Keras erstellen](https://blog.keras.io/building-autoencoders-in-keras.html)
* [Building Autoencoders in Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
* [Blogbeitrag auf NeuroHive](https://neurohive.io/ru/osnovy-data-science/variacionnyj-avtojenkoder-vae/)
* [Variationale Autoencoder erklärt](https://kvfrans.com/variational-autoencoders-explained/)
* [Bedingte Variationale Autoencoder](https://ijdykeman.github.io/ml/2016/12/21/cvae.html)
* [Variational Autoencoders Explained](https://kvfrans.com/variational-autoencoders-explained/)
* [Conditional Variational Autoencoders](https://ijdykeman.github.io/ml/2016/12/21/cvae.html)
## Aufgabe
Am Ende von [diesem Notizbuch mit TensorFlow](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb) finden Sie eine 'Aufgabe' - verwenden Sie dies als Ihre Aufgabe.
Am Ende [dieses Notebooks mit TensorFlow](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb) finden Sie eine 'Aufgabe' - verwenden Sie diese als Ihre Aufgabe.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 autoritative Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

93
translations/de/lessons/4-ComputerVision/10-GANs/README.md
View File

@ -1,10 +1,19 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f07c85bbf05a1f67505da98f4ecc124c",
"translation_date": "2025-08-24T09:34:36+00:00",
"source_file": "lessons/4-ComputerVision/10-GANs/README.md",
"language_code": "de"
}
-->
# Generative Adversarial Networks
Im vorherigen Abschnitt haben wir über **generative Modelle** gelernt: Modelle, die neue Bilder erzeugen können, die den Bildern im Trainingsdatensatz ähnlich sind. VAE war ein gutes Beispiel für ein generatives Modell.
Im vorherigen Abschnitt haben wir über **generative Modelle** gelernt: Modelle, die neue Bilder erzeugen können, die den Bildern im Trainingsdatensatz ähneln. VAE war ein gutes Beispiel für ein generatives Modell.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/110)
## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/110)
Wenn wir jedoch versuchen, etwas wirklich Sinnvolles zu generieren, wie ein Gemälde in angemessener Auflösung, mit VAE, werden wir feststellen, dass das Training nicht gut konvergiert. Für diesen Anwendungsfall sollten wir über eine andere Architektur lernen, die speziell auf generative Modelle abzielt - **Generative Adversarial Networks**, oder GANs.
Wenn wir jedoch versuchen, etwas wirklich Bedeutungsvolles zu generieren, wie ein Gemälde in vernünftiger Auflösung, werden wir feststellen, dass das Training mit VAE nicht gut konvergiert. Für diesen Anwendungsfall sollten wir eine andere Architektur kennenlernen, die speziell auf generative Modelle ausgerichtet ist - **Generative Adversarial Networks**, oder GANs.
Die Hauptidee eines GANs besteht darin, zwei neuronale Netzwerke zu haben, die gegeneinander trainiert werden:
@ -12,90 +21,90 @@ Die Hauptidee eines GANs besteht darin, zwei neuronale Netzwerke zu haben, die g
> Bild von [Dmitry Soshnikov](http://soshnikov.com)
> ✅ Ein kleines Vokabular:
> * **Generator** ist ein Netzwerk, das einen zufälligen Vektor nimmt und als Ergebnis das Bild erzeugt
> * **Discriminator** ist ein Netzwerk, das ein Bild nimmt und feststellen sollte, ob es sich um ein echtes Bild (aus dem Trainingsdatensatz) handelt oder ob es von einem Generator erzeugt wurde. Es ist im Wesentlichen ein Bildklassifizierer.
> ✅ Ein bisschen Vokabular:
> * **Generator** ist ein Netzwerk, das einen zufälligen Vektor nimmt und daraus ein Bild erzeugt.
> * **Discriminator** ist ein Netzwerk, das ein Bild nimmt und entscheiden soll, ob es sich um ein echtes Bild (aus dem Trainingsdatensatz) oder ein vom Generator erzeugtes Bild handelt. Es ist im Wesentlichen ein Bildklassifikator.
### Discriminator
Die Architektur des Discriminators unterscheidet sich nicht von einem gewöhnlichen Bildklassifizierungsnetzwerk. Im einfachsten Fall kann es ein vollständig verbundener Klassifizierer sein, aber höchstwahrscheinlich wird es ein [konvolutionales Netzwerk](../07-ConvNets/README.md) sein.
Die Architektur des Discriminators unterscheidet sich nicht von einem gewöhnlichen Bildklassifikationsnetzwerk. Im einfachsten Fall kann es ein vollständig verbundenes Klassifikationsnetzwerk sein, aber höchstwahrscheinlich wird es ein [Convolutional Network](../07-ConvNets/README.md) sein.
> ✅ Ein auf konvolutionalen Netzwerken basierendes GAN wird als [DCGAN](https://arxiv.org/pdf/1511.06434.pdf) bezeichnet.
> ✅ Ein GAN, das auf Convolutional Networks basiert, wird als [DCGAN](https://arxiv.org/pdf/1511.06434.pdf) bezeichnet.
Ein CNN-Discriminator besteht aus den folgenden Schichten: mehreren Faltungen+Pooling (mit abnehmender räumlicher Größe) und einer oder mehreren vollständig verbundenen Schichten, um den "Merkmalsvektor" zu erhalten, und einem endgültigen binären Klassifizierer.
Ein CNN-Discriminator besteht aus den folgenden Schichten: mehreren Convolutions+Poolings (mit abnehmender räumlicher Größe) und einer oder mehreren vollständig verbundenen Schichten, um einen "Feature-Vektor" zu erhalten, sowie einem abschließenden binären Klassifikator.
> ✅ Ein 'Pooling' in diesem Kontext ist eine Technik, die die Größe des Bildes reduziert. "Pooling-Schichten reduzieren die Dimensionen der Daten, indem sie die Ausgaben von Neuronengruppen in einer Schicht in ein einzelnes Neuron in der nächsten Schicht kombinieren." - [Quelle](https://wikipedia.org/wiki/Convolutional_neural_network#Pooling_layers)
> ✅ Ein 'Pooling' in diesem Kontext ist eine Technik, die die Größe des Bildes reduziert. "Pooling-Schichten reduzieren die Dimensionen der Daten, indem sie die Ausgaben von Neuronenclustern in einer Schicht zu einem einzelnen Neuron in der nächsten Schicht kombinieren." - [Quelle](https://wikipedia.org/wiki/Convolutional_neural_network#Pooling_layers)
### Generator
Ein Generator ist etwas kniffliger. Man kann ihn als umgekehrten Discriminator betrachten. Ausgehend von einem latenten Vektor (anstatt eines Merkmalsvektors) hat er eine vollständig verbundene Schicht, um ihn in die erforderliche Größe/Form zu konvertieren, gefolgt von Dekonvolutionen+Hochskalierung. Dies ähnelt dem *Decoder*-Teil eines [Autoencoders](../09-Autoencoders/README.md).
Ein Generator ist etwas komplizierter. Man kann ihn als umgekehrten Discriminator betrachten. Ausgehend von einem latenten Vektor (anstelle eines Feature-Vektors) hat er eine vollständig verbundene Schicht, um ihn in die erforderliche Größe/Form umzuwandeln, gefolgt von Deconvolutions+Upscaling. Dies ähnelt dem *Decoder*-Teil eines [Autoencoders](../09-Autoencoders/README.md).
> ✅ Da die Faltungsschicht als linearer Filter implementiert ist, der das Bild durchläuft, ist die Dekonvolution im Wesentlichen ähnlich wie die Faltung und kann mit derselben Schichtlogik implementiert werden.
> ✅ Da die Convolution-Schicht als linearer Filter implementiert ist, der das Bild durchläuft, ist Deconvolution im Wesentlichen ähnlich wie Convolution und kann mit derselben Schichtlogik implementiert werden.
<img src="images/gan_arch_detail.png" width="70%"/>
> Bild von [Dmitry Soshnikov](http://soshnikov.com)
### Training des GAN
### Training des GANs
GANs werden als **adversarial** bezeichnet, weil es einen ständigen Wettbewerb zwischen dem Generator und dem Discriminator gibt. Während dieses Wettbewerbs verbessern sich sowohl der Generator als auch der Discriminator, sodass das Netzwerk lernt, immer bessere Bilder zu erzeugen.
Das Training erfolgt in zwei Phasen:
* **Training des Discriminators**. Diese Aufgabe ist ziemlich einfach: Wir erzeugen eine Charge von Bildern mit dem Generator, kennzeichnen sie mit 0, was für ein gefälschtes Bild steht, und nehmen eine Charge von Bildern aus dem Eingabedatensatz (mit dem Label 1, echtes Bild). Wir erhalten einen *Discriminator-Verlust* und führen die Rückpropagation durch.
* **Training des Generators**. Dies ist etwas kniffliger, da wir den erwarteten Ausgang für den Generator nicht direkt kennen. Wir nehmen das gesamte GAN-Netzwerk, das aus einem Generator gefolgt von einem Discriminator besteht, füttern es mit einigen zufälligen Vektoren und erwarten, dass das Ergebnis 1 ist (entsprechend echten Bildern). Dann frieren wir die Parameter des Discriminators ein (wir möchten nicht, dass er in diesem Schritt trainiert wird) und führen die Rückpropagation durch.
* **Training des Discriminators**. Diese Aufgabe ist ziemlich einfach: Wir generieren eine Charge von Bildern mit dem Generator, kennzeichnen sie mit 0 (was für ein gefälschtes Bild steht), und nehmen eine Charge von Bildern aus dem Eingabedatensatz (mit dem Label 1, echtes Bild). Wir erhalten einen *Discriminator Loss* und führen Backpropagation durch.
* **Training des Generators**. Dies ist etwas komplizierter, da wir die erwartete Ausgabe für den Generator nicht direkt kennen. Wir nehmen das gesamte GAN-Netzwerk, das aus einem Generator und einem Discriminator besteht, füttern es mit zufälligen Vektoren und erwarten, dass das Ergebnis 1 ist (entsprechend echten Bildern). Dann frieren wir die Parameter des Discriminators ein (wir wollen ihn in diesem Schritt nicht trainieren) und führen Backpropagation durch.
Während dieses Prozesses sinken die Verluste von sowohl Generator als auch Discriminator nicht signifikant. In der idealen Situation sollten sie oszillieren, was bedeutet, dass beide Netzwerke ihre Leistung verbessern.
Während dieses Prozesses sinken die Verluste des Generators und des Discriminators nicht signifikant. Im Idealfall sollten sie oszillieren, was darauf hinweist, dass beide Netzwerke ihre Leistung verbessern.
## ✍️ Übungen: GANs
* [GAN-Notebook in TensorFlow/Keras](../../../../../lessons/4-ComputerVision/10-GANs/GANTF.ipynb)
* [GAN-Notebook in PyTorch](../../../../../lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb)
* [GAN Notebook in TensorFlow/Keras](../../../../../lessons/4-ComputerVision/10-GANs/GANTF.ipynb)
* [GAN Notebook in PyTorch](../../../../../lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb)
### Probleme beim Training von GANs
Es ist bekannt, dass GANs besonders schwierig zu trainieren sind. Hier sind einige Probleme:
GANs sind dafür bekannt, besonders schwierig zu trainieren zu sein. Hier sind einige Probleme:
* **Mode Collapse**. Mit diesem Begriff meinen wir, dass der Generator lernt, ein erfolgreiches Bild zu erzeugen, das den Discriminator täuscht, und nicht eine Vielzahl unterschiedlicher Bilder.
* **Empfindlichkeit gegenüber Hyperparametern**. Oft sieht man, dass ein GAN überhaupt nicht konvergiert, und dann plötzlich der Lernrate sinkt, was zur Konvergenz führt.
* Den **Ausgleich** zwischen Generator und Discriminator halten. In vielen Fällen kann der Discriminator-Verlust relativ schnell auf null sinken, was dazu führt, dass der Generator nicht weiter trainiert werden kann. Um dies zu überwinden, können wir versuchen, unterschiedliche Lernraten für den Generator und den Discriminator festzulegen oder das Training des Discriminators zu überspringen, wenn der Verlust bereits zu niedrig ist.
* Training für **hohe Auflösung**. Dies spiegelt dasselbe Problem wie bei Autoencodern wider; dieses Problem wird ausgelöst, weil das Rekonstruieren zu vieler Schichten eines konvolutionalen Netzwerks zu Artefakten führt. Dieses Problem wird typischerweise mit dem sogenannten **progressiven Wachsen** gelöst, bei dem zunächst einige Schichten mit niedrig aufgelösten Bildern trainiert werden und dann Schichten "freigeschaltet" oder hinzugefügt werden. Eine andere Lösung wäre, zusätzliche Verbindungen zwischen den Schichten hinzuzufügen und mehrere Auflösungen gleichzeitig zu trainieren - siehe dazu das [Multi-Scale Gradient GANs-Papier](https://arxiv.org/abs/1903.06048) für weitere Details.
* **Mode Collapse**. Damit ist gemeint, dass der Generator lernt, ein erfolgreiches Bild zu erzeugen, das den Discriminator täuscht, aber keine Vielfalt an verschiedenen Bildern produziert.
* **Empfindlichkeit gegenüber Hyperparametern**. Oft kann man beobachten, dass ein GAN überhaupt nicht konvergiert, und dann plötzlich durch eine Verringerung der Lernrate zur Konvergenz gelangt.
* Das **Gleichgewicht** zwischen Generator und Discriminator aufrechterhalten. In vielen Fällen kann der Verlust des Discriminators relativ schnell auf null sinken, was dazu führt, dass der Generator nicht weiter trainiert werden kann. Um dies zu überwinden, können wir versuchen, unterschiedliche Lernraten für Generator und Discriminator festzulegen oder das Training des Discriminators zu überspringen, wenn der Verlust bereits zu niedrig ist.
* Training für **hohe Auflösung**. Ähnlich wie bei Autoencodern tritt dieses Problem auf, weil das Rekonstruieren zu vieler Schichten eines Convolutional Networks zu Artefakten führt. Dieses Problem wird typischerweise durch sogenanntes **progressives Wachstum** gelöst, bei dem zunächst einige Schichten auf niedrig aufgelösten Bildern trainiert werden und dann Schichten "freigeschaltet" oder hinzugefügt werden. Eine andere Lösung wäre, zusätzliche Verbindungen zwischen den Schichten hinzuzufügen und mehrere Auflösungen gleichzeitig zu trainieren - siehe dieses [Multi-Scale Gradient GANs Paper](https://arxiv.org/abs/1903.06048) für Details.
## Stiltransfer
## Style Transfer
GANs sind eine großartige Möglichkeit, künstlerische Bilder zu generieren. Eine weitere interessante Technik ist der sogenannte **Stiltransfer**, bei dem ein **Inhaltsbild** genommen und in einem anderen Stil neu gezeichnet wird, indem Filter aus einem **Stilbild** angewendet werden.
GANs sind eine großartige Möglichkeit, künstlerische Bilder zu generieren. Eine weitere interessante Technik ist der sogenannte **Style Transfer**, bei dem ein **Inhaltsbild** genommen und in einem anderen Stil neu gezeichnet wird, indem Filter aus einem **Stilbild** angewendet werden.
So funktioniert es:
* Wir beginnen mit einem Bild aus zufälligem Rauschen (oder mit einem Inhaltsbild, aber um es besser zu verstehen, ist es einfacher, mit zufälligem Rauschen zu beginnen)
* Unser Ziel wäre es, ein solches Bild zu erstellen, das sowohl dem Inhaltsbild als auch dem Stilbild nahekommt. Dies würde durch zwei Verlustfunktionen bestimmt:
- **Inhaltsverlust** wird basierend auf den Merkmalen berechnet, die von der CNN in einigen Schichten aus dem aktuellen Bild und dem Inhaltsbild extrahiert werden
- **Stilverlust** wird auf clevere Weise zwischen dem aktuellen Bild und dem Stilbild unter Verwendung von Gram-Matrizen berechnet (weitere Details im [Beispiel-Notebook](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb))
* Um das Bild glatter zu machen und Rauschen zu entfernen, führen wir auch einen **Variationsverlust** ein, der die durchschnittliche Distanz zwischen benachbarten Pixeln berechnet
* Die Hauptoptimierungsschleife passt das aktuelle Bild unter Verwendung von Gradientenabstieg (oder einem anderen Optimierungsalgorithmus) an, um den Gesamtschaden zu minimieren, der eine gewichtete Summe aller drei Verluste ist.
* Wir beginnen mit einem zufälligen Rauschbild (oder mit einem Inhaltsbild, aber der Einfachheit halber ist es leichter, mit zufälligem Rauschen zu beginnen).
* Unser Ziel ist es, ein Bild zu erstellen, das sowohl dem Inhaltsbild als auch dem Stilbild nahekommt. Dies wird durch zwei Verlustfunktionen bestimmt:
- **Content Loss** wird basierend auf den Merkmalen berechnet, die von der CNN in einigen Schichten aus dem aktuellen Bild und dem Inhaltsbild extrahiert werden.
- **Style Loss** wird zwischen dem aktuellen Bild und dem Stilbild auf clevere Weise unter Verwendung von Gram-Matrizen berechnet (mehr Details im [Beispiel-Notebook](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)).
* Um das Bild glatter zu machen und Rauschen zu entfernen, führen wir auch einen **Variation Loss** ein, der den durchschnittlichen Abstand zwischen benachbarten Pixeln berechnet.
* Die Hauptoptimierungsschleife passt das aktuelle Bild mithilfe von Gradient Descent (oder einem anderen Optimierungsalgorithmus) an, um den Gesamtabstand zu minimieren, der eine gewichtete Summe aller drei Verluste ist.
## ✍️ Beispiel: [Stiltransfer](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)
## ✍️ Beispiel: [Style Transfer](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)
## [Nachlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/210)
## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/210)
## Fazit
In dieser Lektion haben Sie über GANs gelernt und wie man sie trainiert. Sie haben auch über die speziellen Herausforderungen gelernt, mit denen dieser Typ von neuronalen Netzwerken konfrontiert sein kann, sowie über einige Strategien, um darüber hinwegzukommen.
In dieser Lektion haben Sie über GANs und deren Training gelernt. Sie haben auch die besonderen Herausforderungen kennengelernt, denen diese Art von neuronalen Netzwerken begegnen kann, und einige Strategien, wie man diese überwinden kann.
## 🚀 Herausforderung
Durchlaufen Sie das [Stiltransfer-Notebook](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb) mit Ihren eigenen Bildern.
Arbeiten Sie das [Style Transfer Notebook](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb) mit Ihren eigenen Bildern durch.
## Überprüfung & Selbststudium
## Wiederholung & Selbststudium
Zur Referenz lesen Sie mehr über GANs in diesen Ressourcen:
Zur Vertiefung lesen Sie mehr über GANs in diesen Ressourcen:
* Marco Pasini, [10 Lektionen, die ich beim Training von GANs für ein Jahr gelernt habe](https://towardsdatascience.com/10-lessons-i-learned-training-generative-adversarial-networks-gans-for-a-year-c9071159628)
* [StyleGAN](https://en.wikipedia.org/wiki/StyleGAN), eine *de facto* GAN-Architektur, die in Betracht gezogen werden sollte
* [Erstellung generativer Kunst mit GANs auf Azure ML](https://soshnikov.com/scienceart/creating-generative-art-using-gan-on-azureml/)
* Marco Pasini, [10 Lessons I Learned Training GANs for one Year](https://towardsdatascience.com/10-lessons-i-learned-training-generative-adversarial-networks-gans-for-a-year-c9071159628)
* [StyleGAN](https://en.wikipedia.org/wiki/StyleGAN), eine *de facto* GAN-Architektur, die man in Betracht ziehen sollte.
* [Creating Generative Art using GANs on Azure ML](https://soshnikov.com/scienceart/creating-generative-art-using-gan-on-azureml/)
## Aufgabe
Überarbeiten Sie eines der beiden Notebooks, die mit dieser Lektion verbunden sind, und trainieren Sie das GAN mit Ihren eigenen Bildern neu. Was können Sie erschaffen?
Besuchen Sie eines der beiden Notebooks zu dieser Lektion erneut und trainieren Sie das GAN mit Ihren eigenen Bildern. Was können Sie erschaffen?
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Originalsprache sollte als die maßgebliche Quelle angesehen werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

162
translations/de/lessons/4-ComputerVision/11-ObjectDetection/README.md
View File

@ -1,63 +1,74 @@
## Objekt Erkennung
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d85c8b08f6d1b48fd7f35b99f93c1138",
"translation_date": "2025-08-24T09:35:05+00:00",
"source_file": "lessons/4-ComputerVision/11-ObjectDetection/README.md",
"language_code": "de"
}
-->
# Objekterkennung
Die Bildklassifizierungsmodelle, mit denen wir bisher gearbeitet haben, nahmen ein Bild und lieferten ein kategoriales Ergebnis, wie die Klasse 'Zahl' in einem MNIST-Problem. In vielen Fällen wollen wir jedoch nicht nur wissen, dass ein Bild Objekte darstellt - wir wollen in der Lage sein, ihren genauen Standort zu bestimmen. Genau das ist der Punkt der **Objekt Erkennung**.
Die Bildklassifikationsmodelle, die wir bisher behandelt haben, nahmen ein Bild und lieferten ein kategorisches Ergebnis, wie beispielsweise die Klasse "Zahl" in einem MNIST-Problem. In vielen Fällen möchten wir jedoch nicht nur wissen, dass ein Bild Objekte darstellt – wir möchten auch deren genaue Position bestimmen können. Genau darum geht es bei der **Objekterkennung**.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/111)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/111)
![Objekt Erkennung](../../../../../translated_images/Screen_Shot_2016-11-17_at_11.14.54_AM.b4bb3769353287be1b905373ed9c858102c054b16e4595c76ec3f7bba0feb549.de.png)
![Objekterkennung](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/Screen_Shot_2016-11-17_at_11.14.54_AM.png)
> Bild von [YOLO v2 Webseite](https://pjreddie.com/darknet/yolov2/)
## Ein Naiver Ansatz zur Objekt Erkennung
## Ein naiver Ansatz zur Objekterkennung
Angenommen, wir wollten eine Katze auf einem Bild finden, ein sehr naiver Ansatz zur Objekt Erkennung wäre folgender:
Angenommen, wir wollten eine Katze auf einem Bild finden, dann wäre ein sehr naiver Ansatz zur Objekterkennung folgender:
1. Zerlegen Sie das Bild in eine Anzahl von Kacheln.
2. Führen Sie die Bildklassifizierung auf jeder Kachel durch.
3. Die Kacheln, die eine ausreichend hohe Aktivierung ergeben, können als solche betrachtet werden, die das betreffende Objekt enthalten.
1. Zerlege das Bild in eine Anzahl von Kacheln.
2. Führe eine Bildklassifikation auf jeder Kachel durch.
3. Die Kacheln, die eine ausreichend hohe Aktivierung ergeben, können als die Kacheln betrachtet werden, die das gesuchte Objekt enthalten.
![Naive Objekt Erkennung](../../../../../translated_images/naive-detection.e7f1ba220ccd08c68a2ea8e06a7ed75c3fcc738c2372f9e00b7f4299a8659c01.de.png)
![Naive Objekterkennung](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/naive-detection.png)
> *Bild aus [Übungsnotizbuch](../../../../../lessons/4-ComputerVision/11-ObjectDetection/ObjectDetection-TF.ipynb)*
> *Bild aus [Übungsnotebook](../../../../../lessons/4-ComputerVision/11-ObjectDetection/ObjectDetection-TF.ipynb)*
Dieser Ansatz ist jedoch alles andere als ideal, da er es dem Algorithmus nur ermöglicht, die Begrenzungsbox des Objekts sehr ungenau zu lokalisieren. Für eine genauere Lokalisierung müssen wir eine Art **Regression** durchführen, um die Koordinaten der Begrenzungsrahmen vorherzusagen - und dafür benötigen wir spezifische Datensätze.
Dieser Ansatz ist jedoch alles andere als ideal, da er es dem Algorithmus nur erlaubt, die Begrenzungsbox des Objekts sehr ungenau zu lokalisieren. Für eine präzisere Lokalisierung müssen wir eine Art **Regression** durchführen, um die Koordinaten der Begrenzungsboxen vorherzusagen – und dafür benötigen wir spezifische Datensätze.
## Regression zur Objekt Erkennung
## Regression für Objekterkennung
[Dieser Blogbeitrag](https://towardsdatascience.com/object-detection-with-neural-networks-a4e2c46b4491) bietet eine großartige sanfte Einführung in die Erkennung von Formen.
[Dieser Blogbeitrag](https://towardsdatascience.com/object-detection-with-neural-networks-a4e2c46b4491) bietet eine großartige Einführung in die Erkennung von Formen.
## Datensätze zur Objekt Erkennung
## Datensätze für Objekterkennung
Sie könnten auf die folgenden Datensätze für diese Aufgabe stoßen:
Für diese Aufgabe könnten Sie auf die folgenden Datensätze stoßen:
* [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) - 20 Klassen
* [COCO](http://cocodataset.org/#home) - Gemeinsame Objekte im Kontext. 80 Klassen, Begrenzungsrahmen und Segmentierungs-Masken
* [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) – 20 Klassen
* [COCO](http://cocodataset.org/#home) – Common Objects in Context. 80 Klassen, Begrenzungsboxen und Segmentierungsmasken
![COCO](../../../../../translated_images/coco-examples.71bc60380fa6cceb7caad48bd09e35b6028caabd363aa04fee89c414e0870e86.de.jpg)
![COCO](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/coco-examples.jpg)
## Metriken zur Objekt Erkennung
## Metriken für Objekterkennung
### Schnittmenge über Vereinigung
### Intersection over Union
Während es bei der Bildklassifizierung einfach ist, zu messen, wie gut der Algorithmus funktioniert, müssen wir bei der Objekt Erkennung sowohl die Richtigkeit der Klasse als auch die Präzision des abgeleiteten Begrenzungsrahmenstandorts messen. Für letzteres verwenden wir die sogenannte **Schnittmenge über Vereinigung** (IoU), die misst, wie gut zwei Boxen (oder zwei beliebige Bereiche) überlappen.
Während es bei der Bildklassifikation einfach ist, die Leistung des Algorithmus zu messen, müssen wir bei der Objekterkennung sowohl die Korrektheit der Klasse als auch die Präzision der vorhergesagten Begrenzungsbox-Position messen. Für Letzteres verwenden wir die sogenannte **Intersection over Union** (IoU), die misst, wie gut sich zwei Boxen (oder zwei beliebige Bereiche) überlappen.
![IoU](../../../../../translated_images/iou_equation.9a4751d40fff4e119ecd0a7bcca4e71ab1dc83e0d4f2a0d66ff0859736f593cf.de.png)
![IoU](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/iou_equation.png)
> *Abbildung 2 aus [diesem ausgezeichneten Blogbeitrag über IoU](https://pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/)*
Die Idee ist einfach - wir teilen die Fläche der Schnittmenge zwischen zwei Figuren durch die Fläche ihrer Vereinigung. Für zwei identische Bereiche wäre IoU 1, während es für vollständig disjunkte Bereiche 0 sein würde. Ansonsten variiert es von 0 bis 1. Wir berücksichtigen typischerweise nur diejenigen Begrenzungsrahmen, für die IoU über einem bestimmten Wert liegt.
Die Idee ist einfach – wir teilen die Fläche der Überschneidung zwischen zwei Figuren durch die Fläche ihrer Vereinigung. Für zwei identische Flächen wäre IoU 1, während es für vollständig getrennte Flächen 0 wäre. Ansonsten variiert es zwischen 0 und 1. Wir betrachten typischerweise nur die Begrenzungsboxen, für die IoU über einem bestimmten Wert liegt.
### Durchschnittliche Präzision
Angenommen, wir wollen messen, wie gut eine gegebene Klasse von Objekten $C$ erkannt wird. Um dies zu messen, verwenden wir **Durchschnittliche Präzisions**-Metriken, die wie folgt berechnet werden:
Angenommen, wir möchten messen, wie gut eine bestimmte Objektklasse $C$ erkannt wird. Um dies zu messen, verwenden wir die **Durchschnittliche Präzision** (Average Precision, AP), die wie folgt berechnet wird:
1. Betrachten Sie die Precision-Recall-Kurve, die die Genauigkeit in Abhängigkeit von einem Erkennungsschwellenwert (von 0 bis 1) zeigt.
2. Je nach Schwellenwert erhalten wir mehr oder weniger Objekte, die im Bild erkannt werden, und unterschiedliche Werte für Präzision und Rückruf.
3. Die Kurve sieht folgendermaßen aus:
1. Betrachte die Precision-Recall-Kurve, die die Genauigkeit in Abhängigkeit von einem Erkennungsschwellenwert (von 0 bis 1) zeigt.
2. Abhängig vom Schwellenwert werden mehr oder weniger Objekte im Bild erkannt, und es ergeben sich unterschiedliche Werte für Präzision und Recall.
3. Die Kurve sieht wie folgt aus:
<img src="https://github.com/shwars/NeuroWorkshop/raw/master/images/ObjDetectionPrecisionRecall.png"/>
> *Bild aus [NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
Die durchschnittliche Präzision für eine gegebene Klasse $C$ ist die Fläche unter dieser Kurve. Genauer gesagt, wird die Recall-Achse typischerweise in 10 Teile unterteilt, und die Präzision wird über all diese Punkte gemittelt:
Die durchschnittliche Präzision für eine gegebene Klasse $C$ ist die Fläche unter dieser Kurve. Genauer gesagt wird die Recall-Achse typischerweise in 10 Teile unterteilt, und die Präzision wird über alle diese Punkte gemittelt:
$$
AP = {1\over11}\sum_{i=0}^{10}\mbox{Precision}(\mbox{Recall}={i\over10})
@ -65,108 +76,113 @@ $$
### AP und IoU
Wir werden nur diejenigen Erkennungen berücksichtigen, für die IoU über einem bestimmten Wert liegt. Zum Beispiel wird im PASCAL VOC-Datensatz typischerweise $\mbox{IoU-Schwellenwert} = 0.5$ angenommen, während im COCO AP für unterschiedliche Werte von $\mbox{IoU-Schwellenwert}$ gemessen wird.
Wir betrachten nur die Erkennungen, für die IoU über einem bestimmten Wert liegt. Beispielsweise wird im PASCAL VOC-Datensatz typischerweise $\mbox{IoU Threshold} = 0.5$ angenommen, während im COCO-Datensatz AP für verschiedene Werte von $\mbox{IoU Threshold}$ gemessen wird.
### Durchschnittliche Durchschnittliche Präzision - mAP
<img src="https://github.com/shwars/NeuroWorkshop/raw/master/images/ObjDetectionPrecisionRecallIoU.png"/>
Die Hauptmetrik für die Objekt Erkennung wird **Durchschnittliche Durchschnittliche Präzision** oder **mAP** genannt. Es ist der Wert der Durchschnittlichen Präzision, gemittelt über alle Objektklassen und manchmal auch über $\mbox{IoU-Schwellenwert}$. Im Detail wird der Prozess zur Berechnung von **mAP** in
[diesem Blogbeitrag](https://medium.com/@timothycarlen/understanding-the-map-evaluation-metric-for-object-detection-a07fe6962cf3) beschrieben, und auch [hier mit Codebeispielen](https://gist.github.com/tarlen5/008809c3decf19313de216b9208f3734).
> *Bild aus [NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
## Verschiedene Ansätze zur Objekt Erkennung
### Mittlere Durchschnittliche Präzision – mAP
Es gibt zwei breite Klassen von Algorithmen zur Objekt Erkennung:
Die Hauptmetrik für die Objekterkennung wird **Mittlere Durchschnittliche Präzision** (Mean Average Precision, mAP) genannt. Sie ist der Wert der Durchschnittlichen Präzision, gemittelt über alle Objektklassen und manchmal auch über $\mbox{IoU Threshold}$. Der Prozess zur Berechnung von **mAP** wird ausführlich beschrieben
[in diesem Blogbeitrag](https://medium.com/@timothycarlen/understanding-the-map-evaluation-metric-for-object-detection-a07fe6962cf3)) und auch [hier mit Codebeispielen](https://gist.github.com/tarlen5/008809c3decf19313de216b9208f3734).
* **Region Proposal Networks** (R-CNN, Fast R-CNN, Faster R-CNN). Die Hauptidee besteht darin, **Regionen von Interessen** (ROI) zu generieren und CNN darüber laufen zu lassen, um maximale Aktivierung zu suchen. Es ist ein wenig ähnlich wie der naive Ansatz, mit der Ausnahme, dass ROIs auf eine cleverere Weise generiert werden. Einer der größten Nachteile solcher Methoden ist, dass sie langsam sind, da wir viele Durchläufe des CNN-Klassifikators über das Bild benötigen.
* **Einmalige** (YOLO, SSD, RetinaNet) Methoden. In diesen Architekturen entwerfen wir das Netzwerk, um sowohl Klassen als auch ROIs in einem Durchgang vorherzusagen.
## Verschiedene Ansätze zur Objekterkennung
Es gibt zwei große Klassen von Objekterkennungsalgorithmen:
* **Region Proposal Networks** (R-CNN, Fast R-CNN, Faster R-CNN). Die Hauptidee ist, **Regions of Interest** (ROI) zu generieren und CNN darüber laufen zu lassen, um maximale Aktivierung zu suchen. Es ist ein bisschen ähnlich wie der naive Ansatz, mit dem Unterschied, dass ROIs auf eine intelligentere Weise generiert werden. Ein Hauptnachteil solcher Methoden ist, dass sie langsam sind, da viele Durchläufe des CNN-Klassifikators über das Bild erforderlich sind.
* **One-pass** (YOLO, SSD, RetinaNet) Methoden. In diesen Architekturen wird das Netzwerk so gestaltet, dass es sowohl Klassen als auch ROIs in einem Durchgang vorhersagt.
### R-CNN: Region-Based CNN
[R-CNN](http://islab.ulsan.ac.kr/files/announcement/513/rcnn_pami.pdf) verwendet [Selective Search](http://www.huppelen.nl/publications/selectiveSearchDraft.pdf), um eine hierarchische Struktur von ROI-Regionen zu generieren, die dann durch CNN-Feature-Extraktoren und SVM-Klassifizierer geleitet werden, um die Objektklasse zu bestimmen, und durch lineare Regression, um die *Begrenzungsrahmen*-Koordinaten zu bestimmen. [Offizielles Papier](https://arxiv.org/pdf/1506.01497v1.pdf)
[R-CNN](http://islab.ulsan.ac.kr/files/announcement/513/rcnn_pami.pdf) verwendet [Selective Search](http://www.huppelen.nl/publications/selectiveSearchDraft.pdf), um eine hierarchische Struktur von ROI-Regionen zu generieren, die dann durch CNN-Feature-Extraktoren und SVM-Klassifikatoren geleitet werden, um die Objektklasse zu bestimmen, und durch lineare Regression, um die *Koordinaten der Begrenzungsbox* zu bestimmen. [Offizielles Paper](https://arxiv.org/pdf/1506.01497v1.pdf)
![RCNN](../../../../../translated_images/rcnn1.cae407020dfb1d1fb572656e44f75cd6c512cc220591c116c506652c10e47f26.de.png)
![RCNN](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/rcnn1.png)
> *Bild von van de Sande et al. ICCV’11*
![RCNN-1](../../../../../translated_images/rcnn2.2d9530bb83516484ec65b250c22dbf37d3d23244f32864ebcb91d98fe7c3112c.de.png)
![RCNN-1](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/rcnn2.png)
> *Bilder aus [diesem Blog](https://towardsdatascience.com/r-cnn-fast-r-cnn-faster-r-cnn-yolo-object-detection-algorithms-36d53571365e)*
### F-RCNN - Fast R-CNN
### F-RCNN – Fast R-CNN
Dieser Ansatz ähnelt R-CNN, aber die Regionen werden definiert, nachdem die Faltungsschichten angewendet wurden.
Dieser Ansatz ähnelt R-CNN, aber die Regionen werden definiert, nachdem die Convolution-Schichten angewendet wurden.
![FRCNN](../../../../../translated_images/f-rcnn.3cda6d9bb41888754037d2d9763e2298a96de5d9bc2a21db3147357aa5da9b1a.de.png)
![FRCNN](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/f-rcnn.png)
> Bild aus [dem offiziellen Papier](https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/Girshick_Fast_R-CNN_ICCV_2015_paper.pdf), [arXiv](https://arxiv.org/pdf/1504.08083.pdf), 2015
> Bild aus [dem offiziellen Paper](https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/Girshick_Fast_R-CNN_ICCV_2015_paper.pdf), [arXiv](https://arxiv.org/pdf/1504.08083.pdf), 2015
### Faster R-CNN
Die Hauptidee dieses Ansatzes ist es, ein neuronales Netzwerk zu verwenden, um ROIs vorherzusagen - so genannte *Region Proposal Network*. [Papier](https://arxiv.org/pdf/1506.01497.pdf), 2016
Die Hauptidee dieses Ansatzes ist es, ein neuronales Netzwerk zu verwenden, um ROIs vorherzusagen – das sogenannte *Region Proposal Network*. [Paper](https://arxiv.org/pdf/1506.01497.pdf), 2016
![FasterRCNN](../../../../../translated_images/faster-rcnn.8d46c099b87ef30ab2ea26dbc4bdd85b974a57ba8eb526f65dc4cd0a4711de30.de.png)
![FasterRCNN](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/faster-rcnn.png)
> Bild aus [dem offiziellen Papier](https://arxiv.org/pdf/1506.01497.pdf)
> Bild aus [dem offiziellen Paper](https://arxiv.org/pdf/1506.01497.pdf)
### R-FCN: Region-Based Fully Convolutional Network
Dieser Algorithmus ist sogar schneller als Faster R-CNN. Die Hauptidee ist folgende:
1. Wir extrahieren Merkmale mit ResNet-101.
2. Merkmale werden durch **Positionssensitives Score Map** verarbeitet. Jedes Objekt aus $C$ Klassen wird in $k\times k$ Regionen unterteilt, und wir trainieren, um Teile von Objekten vorherzusagen.
3. Für jedes Teil aus $k\times k$ Regionen stimmen alle Netzwerke für Objektklassen ab, und die Objektklasse mit der maximalen Stimme wird ausgewählt.
1. Wir extrahieren Features mit ResNet-101.
2. Die Features werden durch **Position-Sensitive Score Map** verarbeitet. Jedes Objekt aus $C$ Klassen wird in $k\times k$ Regionen unterteilt, und wir trainieren, um Teile von Objekten vorherzusagen.
3. Für jeden Teil aus den $k\times k$ Regionen stimmen alle Netzwerke für Objektklassen ab, und die Objektklasse mit der maximalen Stimme wird ausgewählt.
![r-fcn image](../../../../../translated_images/r-fcn.13eb88158b99a3da50fa2787a6be5cb310d47f0e9655cc93a1090dc7aab338d1.de.png)
![r-fcn image](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/r-fcn.png)
> Bild aus [offiziellen Papier](https://arxiv.org/abs/1605.06409)
> Bild aus [offiziellem Paper](https://arxiv.org/abs/1605.06409)
### YOLO - You Only Look Once
### YOLO – You Only Look Once
YOLO ist ein Echtzeit-Einmal-Algorithmus. Die Hauptidee ist folgende:
YOLO ist ein Echtzeit-Ein-Pass-Algorithmus. Die Hauptidee ist folgende:
* Das Bild wird in $S\times S$ Regionen unterteilt.
* Für jede Region sagt **CNN** $n$ mögliche Objekte, *Begrenzungsrahmen*-Koordinaten und *Konfidenz*=*Wahrscheinlichkeit* * IoU voraus.
* Das Bild wird in $S\times S$ Regionen unterteilt.
* Für jede Region sagt **CNN** $n$ mögliche Objekte, *Koordinaten der Begrenzungsbox* und *Confidence*=*Wahrscheinlichkeit* * IoU voraus.
![YOLO](../../../../../translated_images/yolo.a2648ec82ee8bb4ea27537677adb482fd4b733ca1705c561b6a24a85102dced5.de.png)
> Bild aus [offiziellen Papier](https://arxiv.org/abs/1506.02640)
![YOLO](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/yolo.png)
> Bild aus [offiziellem Paper](https://arxiv.org/abs/1506.02640)
### Andere Algorithmen
* RetinaNet: [offizielles Papier](https://arxiv.org/abs/1708.02002)
* RetinaNet: [offizielles Paper](https://arxiv.org/abs/1708.02002)
- [PyTorch-Implementierung in Torchvision](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html)
- [Keras-Implementierung](https://github.com/fizyr/keras-retinanet)
- [Objekterkennung mit RetinaNet](https://keras.io/examples/vision/retinanet/) in Keras-Beispielen
* SSD (Single Shot Detector): [offizielles Papier](https://arxiv.org/abs/1512.02325)
* SSD (Single Shot Detector): [offizielles Paper](https://arxiv.org/abs/1512.02325)
## ✍️ Übungen: Objekterkennung
Setze dein Lernen im folgenden Notizbuch fort:
Setzen Sie Ihr Lernen im folgenden Notebook fort:
[ObjectDetection.ipynb](../../../../../lessons/4-ComputerVision/11-ObjectDetection/ObjectDetection.ipynb)
## Fazit
In dieser Lektion hast du eine rasante Tour durch die verschiedenen Möglichkeiten der Objekterkennung gemacht!
In dieser Lektion haben Sie einen Überblick über die verschiedenen Möglichkeiten zur Objekterkennung erhalten!
## 🚀 Herausforderung
Lies dir diese Artikel und Notizbücher über YOLO durch und probiere sie selbst aus.
Lesen Sie diese Artikel und Notebooks über YOLO und probieren Sie sie selbst aus:
* [Guter Blogbeitrag](https://www.analyticsvidhya.com/blog/2018/12/practical-guide-object-detection-yolo-framewor-python/) der YOLO beschreibt
* [Offizielle Seite](https://pjreddie.com/darknet/yolo/)
* Yolo: [Keras-Implementierung](https://github.com/experiencor/keras-yolo2), [Schritt-für-Schritt-Notizbuch](https://github.com/experiencor/basic-yolo-keras/blob/master/Yolo%20Step-by-Step.ipynb)
* Yolo v2: [Keras-Implementierung](https://github.com/experiencor/keras-yolo2), [Schritt-für-Schritt-Notizbuch](https://github.com/experiencor/keras-yolo2/blob/master/Yolo%20Step-by-Step.ipynb)
* [Guter Blogbeitrag](https://www.analyticsvidhya.com/blog/2018/12/practical-guide-object-detection-yolo-framewor-python/) über YOLO
* [Offizielle Webseite](https://pjreddie.com/darknet/yolo/)
* Yolo: [Keras-Implementierung](https://github.com/experiencor/keras-yolo2), [Schritt-für-Schritt-Notebook](https://github.com/experiencor/basic-yolo-keras/blob/master/Yolo%20Step-by-Step.ipynb)
* Yolo v2: [Keras-Implementierung](https://github.com/experiencor/keras-yolo2), [Schritt-für-Schritt-Notebook](https://github.com/experiencor/keras-yolo2/blob/master/Yolo%20Step-by-Step.ipynb)
## [Nach der Vorlesung Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/211)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/211)
## Überprüfung & Selbststudium
* [Objekterkennung](https://tjmachinelearning.com/lectures/1718/obj/) von Nikhil Sardana
* [Ein guter Vergleich von Algorithmen zur Objekterkennung](https://lilianweng.github.io/lil-log/2018/12/27/object-detection-part-4.html)
* [Überprüfung von Deep Learning-Algorithmen zur Objekterkennung](https://medium.com/comet-app/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852)
* [Eine Schritt-für-Schritt-Einführung in die grundlegenden Algorithmen zur Objekterkennung](https://www.analyticsvidhya.com/blog/2018/10/a-step-by-step-introduction-to-the-basic-object-detection-algorithms-part-1/)
* [Implementierung von Faster R-CNN in Python zur Objekterkennung](https://www.analyticsvidhya.com/blog/2018/11/implementation-faster-r-cnn-python-object-detection/)
* [Ein guter Vergleich von Objekterkennungsalgorithmen](https://lilianweng.github.io/lil-log/2018/12/27/object-detection-part-4.html)
* [Überblick über Deep-Learning-Algorithmen für Objekterkennung](https://medium.com/comet-app/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852)
* [Eine Schritt-für-Schritt-Einführung in die grundlegenden Objekterkennungsalgorithmen](https://www.analyticsvidhya.com/blog/2018/10/a-step-by-step-introduction-to-the-basic-object-detection-algorithms-part-1/)
* [Implementierung von Faster R-CNN in Python für Objekterkennung](https://www.analyticsvidhya.com/blog/2018/11/implementation-faster-r-cnn-python-object-detection/)
## [Aufgabe: Objekterkennung](lab/README.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

29
translations/de/lessons/4-ComputerVision/11-ObjectDetection/lab/README.md
View File

@ -1,14 +1,23 @@
# Kopfdetektion mit dem Hollywood Heads Dataset
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "ad568d55ae65c856fe929fc2b278510a",
"translation_date": "2025-08-24T09:35:32+00:00",
"source_file": "lessons/4-ComputerVision/11-ObjectDetection/lab/README.md",
"language_code": "de"
}
-->
# Kopferkennung mit dem Hollywood Heads Dataset
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
Die Zählung der Anzahl von Personen im Videoüberwachungs-Kamerastream ist eine wichtige Aufgabe, die es uns ermöglicht, die Anzahl der Besucher in Geschäften, Stoßzeiten in einem Restaurant usw. zu schätzen. Um diese Aufgabe zu lösen, müssen wir in der Lage sein, menschliche Köpfe aus verschiedenen Blickwinkeln zu erkennen. Um ein Objekt-Erkennungsmodell zur Erkennung menschlicher Köpfe zu trainieren, können wir das [Hollywood Heads Dataset](https://www.di.ens.fr/willow/research/headdetection/) verwenden.
Das Zählen der Anzahl von Personen in einem Videoüberwachungsstream ist eine wichtige Aufgabe, die es uns ermöglicht, die Anzahl der Besucher in Geschäften, Stoßzeiten in Restaurants usw. zu schätzen. Um diese Aufgabe zu lösen, müssen wir in der Lage sein, menschliche Köpfe aus verschiedenen Blickwinkeln zu erkennen. Um ein Objekterkennungsmodell zu trainieren, das menschliche Köpfe erkennt, können wir das [Hollywood Heads Dataset](https://www.di.ens.fr/willow/research/headdetection/) verwenden.
## Das Dataset
Das [Hollywood Heads Dataset](https://www.di.ens.fr/willow/research/headdetection/release/HollywoodHeads.zip) enthält 369.846 menschliche Köpfe, die in 224.740 Filmframes aus Hollywood-Filmen annotiert sind. Es wird im [https://host.robots.ox.ac.uk/pascal/VOC/](../../../../../../lessons/4-ComputerVision/11-ObjectDetection/lab/PASCAL VOC) Format bereitgestellt, wobei für jedes Bild auch eine XML-Beschreibungsdatei vorhanden ist, die so aussieht:
Das [Hollywood Heads Dataset](https://www.di.ens.fr/willow/research/headdetection/release/HollywoodHeads.zip) enthält 369.846 menschliche Köpfe, die in 224.740 Filmframes aus Hollywood-Filmen annotiert sind. Es wird im [https://host.robots.ox.ac.uk/pascal/VOC/](../../../../../../lessons/4-ComputerVision/11-ObjectDetection/lab/PASCAL VOC)-Format bereitgestellt, bei dem es zu jedem Bild auch eine XML-Beschreibungsdatei gibt, die so aussieht:
```xml
<annotation>
@ -48,19 +57,19 @@ Das [Hollywood Heads Dataset](https://www.di.ens.fr/willow/research/headdetectio
</annotation>
```
In diesem Dataset gibt es nur eine Klasse von Objekten `head`, und für jeden Kopf erhältst du die Koordinaten des Begrenzungsrahmens. Du kannst XML mit Python-Bibliotheken parsen oder [diese Bibliothek](https://pypi.org/project/pascal-voc/) verwenden, um direkt mit dem PASCAL VOC-Format zu arbeiten.
In diesem Datensatz gibt es nur eine Objektklasse `head`, und für jeden Kopf erhält man die Koordinaten des Begrenzungsrahmens. Sie können XML mit Python-Bibliotheken analysieren oder [diese Bibliothek](https://pypi.org/project/pascal-voc/) verwenden, um direkt mit dem PASCAL VOC-Format zu arbeiten.
## Training der Objekterkennung
Du kannst ein Objekt-Erkennungsmodell auf eine der folgenden Arten trainieren:
Sie können ein Objekterkennungsmodell auf eine der folgenden Arten trainieren:
* Verwende [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste) und dessen Python-API, um das Modell programmgesteuert in der Cloud zu trainieren. Die benutzerdefinierte Vision kann nicht mehr als einige hundert Bilder für das Training des Modells verwenden, daher musst du das Dataset möglicherweise einschränken.
* Verwende das Beispiel aus dem [Keras-Tutorial](https://keras.io/examples/vision/retinanet/), um das RetunaNet-Modell zu trainieren.
* Verwende das eingebaute Modul [torchvision.models.detection.RetinaNet](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html) in torchvision.
* Mit [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste) und dessen Python-API, um das Modell programmgesteuert in der Cloud zu trainieren. Custom Vision kann jedoch nicht mehr als ein paar hundert Bilder für das Training des Modells verwenden, sodass Sie den Datensatz möglicherweise begrenzen müssen.
* Mit dem Beispiel aus dem [Keras-Tutorial](https://keras.io/examples/vision/retinanet/), um ein RetunaNet-Modell zu trainieren.
* Mit dem [torchvision.models.detection.RetinaNet](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html)-Modul, das in torchvision integriert ist.
## Fazit
Die Objekterkennung ist eine Aufgabe, die in der Industrie häufig erforderlich ist. Während es einige Dienste gibt, die zur Durchführung der Objekterkennung verwendet werden können (wie [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste)), ist es wichtig zu verstehen, wie Objekterkennung funktioniert und in der Lage zu sein, eigene Modelle zu trainieren.
Die Objekterkennung ist eine Aufgabe, die in der Industrie häufig benötigt wird. Während es einige Dienste gibt, die zur Durchführung der Objekterkennung verwendet werden können (wie z. B. [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste)), ist es wichtig zu verstehen, wie Objekterkennung funktioniert, und in der Lage zu sein, eigene Modelle zu trainieren.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle angesehen werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

55
translations/de/lessons/4-ComputerVision/12-Segmentation/README.md
View File

@ -1,13 +1,22 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d7f8a25ff13cfe9f4cd671cc23351fad",
"translation_date": "2025-08-24T09:34:07+00:00",
"source_file": "lessons/4-ComputerVision/12-Segmentation/README.md",
"language_code": "de"
}
-->
# Segmentierung
Wir haben zuvor über Objekterkennung gelernt, die es uns ermöglicht, Objekte im Bild zu lokalisieren, indem wir ihre *Umrandungsrahmen* vorhersagen. Für einige Aufgaben benötigen wir jedoch nicht nur Umrandungsrahmen, sondern auch eine genauere Lokalisierung der Objekte. Diese Aufgabe wird als **Segmentierung** bezeichnet.
Wir haben zuvor über Objekterkennung gelernt, die es uns ermöglicht, Objekte in einem Bild durch Vorhersage ihrer *Bounding Boxes* zu lokalisieren. Für einige Aufgaben benötigen wir jedoch nicht nur Bounding Boxes, sondern auch eine präzisere Objektlokalisierung. Diese Aufgabe nennt man **Segmentierung**.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/112)
## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/112)
Segmentierung kann als **Pixelklassifikation** betrachtet werden, wobei für **jedes** Pixel des Bildes seine Klasse vorhergesagt werden muss (hintergrund ist eine der Klassen). Es gibt zwei Hauptalgorithmen für die Segmentierung:
Segmentierung kann als **Pixelklassifikation** betrachtet werden, bei der für **jeden** Pixel des Bildes seine Klasse vorhergesagt werden muss (*Hintergrund* ist dabei eine der Klassen). Es gibt zwei Hauptalgorithmen für die Segmentierung:
* **Semantische Segmentierung** gibt nur die Pixelklasse an und unterscheidet nicht zwischen verschiedenen Objekten derselben Klasse.
* **Instanzsegmentierung** unterteilt Klassen in verschiedene Instanzen.
* **Semantische Segmentierung** gibt nur die Klasse des Pixels an und unterscheidet nicht zwischen verschiedenen Objekten derselben Klasse.
* **Instanzsegmentierung** teilt Klassen in verschiedene Instanzen auf.
Bei der Instanzsegmentierung sind diese Schafe unterschiedliche Objekte, während bei der semantischen Segmentierung alle Schafe durch eine Klasse repräsentiert werden.
@ -15,55 +24,55 @@ Bei der Instanzsegmentierung sind diese Schafe unterschiedliche Objekte, währen
> Bild aus [diesem Blogbeitrag](https://nirmalamurali.medium.com/image-classification-vs-semantic-segmentation-vs-instance-segmentation-625c33a08d50)
Es gibt verschiedene neuronale Architekturen für die Segmentierung, aber sie haben alle die gleiche Struktur. In gewisser Weise ähnelt es dem Autoencoder, den Sie zuvor gelernt haben, aber anstatt das ursprüngliche Bild zu dekonstruierten, besteht unser Ziel darin, eine **Maske** zu dekodieren. Daher hat ein Segmentierungsnetzwerk die folgenden Teile:
Es gibt verschiedene neuronale Architekturen für die Segmentierung, aber sie haben alle dieselbe Struktur. In gewisser Weise ähnelt sie dem Autoencoder, den Sie zuvor kennengelernt haben, aber anstatt das ursprüngliche Bild zu rekonstruieren, ist unser Ziel, eine **Maske** zu rekonstruieren. Eine Segmentierungsnetzwerk hat daher folgende Bestandteile:
* **Encoder** extrahiert Merkmale aus dem Eingangsbild.
* **Decoder** transformiert diese Merkmale in das **Maskenbild**, mit der gleichen Größe und Anzahl von Kanälen, die der Anzahl der Klassen entsprechen.
* **Encoder** extrahiert Merkmale aus dem Eingabebild.
* **Decoder** transformiert diese Merkmale in das **Maskenbild**, mit derselben Größe und einer Anzahl von Kanälen, die der Anzahl der Klassen entspricht.
<img src="images/segm.png" width="80%">
> Bild aus [dieser Veröffentlichung](https://arxiv.org/pdf/2001.05566.pdf)
> Bild aus [dieser Publikation](https://arxiv.org/pdf/2001.05566.pdf)
Besonders erwähnenswert ist die Verlustfunktion, die für die Segmentierung verwendet wird. Bei klassischen Autoencodern müssen wir die Ähnlichkeit zwischen zwei Bildern messen, und wir können dazu den mittleren quadratischen Fehler (MSE) verwenden. In der Segmentierung repräsentiert jedes Pixel im Zielmaskenbild die Klassennummer (one-hot-encoded entlang der dritten Dimension), sodass wir Verlustfunktionen verwenden müssen, die spezifisch für die Klassifikation sind - Kreuzentropieverlust, gemittelt über alle Pixel. Wenn die Maske binär ist, wird **binärer Kreuzentropieverlust** (BCE) verwendet.
Besonders erwähnenswert ist die Verlustfunktion, die für die Segmentierung verwendet wird. Bei klassischen Autoencodern müssen wir die Ähnlichkeit zwischen zwei Bildern messen, wofür wir den mittleren quadratischen Fehler (MSE) verwenden können. Bei der Segmentierung repräsentiert jeder Pixel im Zielmaskenbild die Klassennummer (one-hot-encoded entlang der dritten Dimension), daher müssen wir Verlustfunktionen verwenden, die speziell für Klassifikationen geeignet sind - Kreuzentropieverlust, gemittelt über alle Pixel. Wenn die Maske binär ist, wird der **binäre Kreuzentropieverlust** (BCE) verwendet.
> ✅ One-Hot-Encoding ist eine Methode, um ein Klassenlabel in einen Vektor der Länge zu kodieren, die der Anzahl der Klassen entspricht. Schauen Sie sich [diesen Artikel](https://datagy.io/sklearn-one-hot-encode/) zu dieser Technik an.
> ✅ One-Hot-Encoding ist eine Methode, um eine Klassenbezeichnung in einen Vektor mit einer Länge zu kodieren, die der Anzahl der Klassen entspricht. Schauen Sie sich [diesen Artikel](https://datagy.io/sklearn-one-hot-encode/) zu dieser Technik an.
## Segmentierung in der medizinischen Bildgebung
In dieser Lektion werden wir die Segmentierung in Aktion sehen, indem wir das Netzwerk trainieren, um menschliche Nävi (auch als Muttermale bekannt) auf medizinischen Bildern zu erkennen. Wir werden die <a href="https://www.fc.up.pt/addi/ph2%20database.html">PH<sup>2</sup> Datenbank</a> von Dermatoskopiebildern als Bildquelle verwenden. Dieses Dataset enthält 200 Bilder von drei Klassen: typischer Nevus, atypischer Nevus und Melanom. Alle Bilder enthalten auch eine entsprechende **Maske**, die den Nevus umreißt.
In dieser Lektion werden wir die Segmentierung in Aktion sehen, indem wir ein Netzwerk trainieren, um menschliche Nävi (auch bekannt als Muttermale) auf medizinischen Bildern zu erkennen. Wir verwenden die <a href="https://www.fc.up.pt/addi/ph2%20database.html">PH<sup>2</sup>-Datenbank</a> mit Dermatoskopiebildern als Bildquelle. Dieses Datenset enthält 200 Bilder von drei Klassen: typischer Nävus, atypischer Nävus und Melanom. Alle Bilder enthalten auch eine entsprechende **Maske**, die den Nävus umreißt.
> ✅ Diese Technik ist besonders geeignet für diese Art der medizinischen Bildgebung, aber welche anderen realen Anwendungen könnten Sie sich vorstellen?
> ✅ Diese Technik ist besonders geeignet für diese Art der medizinischen Bildgebung, aber welche anderen Anwendungen in der realen Welt könnten Sie sich vorstellen?
<img alt="navi" src="images/navi.png"/>
> Bild aus der PH<sup>2</sup> Datenbank
> Bild aus der PH<sup>2</sup>-Datenbank
Wir werden ein Modell trainieren, um jeden Nevus von seinem Hintergrund zu segmentieren.
Wir werden ein Modell trainieren, um jeden Nävus vom Hintergrund zu segmentieren.
## ✍️ Übungen: Semantische Segmentierung
Öffnen Sie die folgenden Notebooks, um mehr über verschiedene Architekturen der semantischen Segmentierung zu erfahren, mit ihnen zu üben und sie in Aktion zu sehen.
Öffnen Sie die untenstehenden Notebooks, um mehr über verschiedene Architekturen der semantischen Segmentierung zu erfahren, mit ihnen zu arbeiten und sie in Aktion zu sehen.
* [Semantische Segmentierung Pytorch](../../../../../lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationPytorch.ipynb)
* [Semantische Segmentierung TensorFlow](../../../../../lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationTF.ipynb)
## [Nachlesequiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/212)
## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/212)
## Fazit
Segmentierung ist eine sehr leistungsfähige Technik für die Bildklassifikation, die über Umrandungsrahmen hinaus zur Klassifikation auf Pixel-Ebene übergeht. Sie ist eine Technik, die in der medizinischen Bildgebung und anderen Anwendungen verwendet wird.
Segmentierung ist eine sehr leistungsstarke Technik für die Bildklassifikation, die über Bounding Boxes hinausgeht und eine Klassifikation auf Pixelebene ermöglicht. Sie wird unter anderem in der medizinischen Bildgebung eingesetzt.
## 🚀 Herausforderung
Die Körpersegmentierung ist nur eine der häufigen Aufgaben, die wir mit Bildern von Menschen durchführen können. Weitere wichtige Aufgaben sind **Skelettdetektion** und **Posenerkennung**. Probieren Sie die [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) Bibliothek aus, um zu sehen, wie die Posenerkennung verwendet werden kann.
Die Segmentierung des Körpers ist nur eine der häufigen Aufgaben, die wir mit Bildern von Menschen durchführen können. Andere wichtige Aufgaben umfassen **Skelett-Erkennung** und **Posenerkennung**. Probieren Sie die [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose)-Bibliothek aus, um zu sehen, wie Posenerkennung verwendet werden kann.
## Überprüfung & Selbststudium
## Rückblick & Selbststudium
Dieser [Wikipedia-Artikel](https://wikipedia.org/wiki/Image_segmentation) bietet einen guten Überblick über die verschiedenen Anwendungen dieser Technik. Lernen Sie selbst mehr über die Teilbereiche der Instanzsegmentierung und der panoptischen Segmentierung in diesem Forschungsfeld.
Dieser [Wikipedia-Artikel](https://wikipedia.org/wiki/Image_segmentation) bietet einen guten Überblick über die verschiedenen Anwendungen dieser Technik. Informieren Sie sich selbst über die Teilbereiche der Instanzsegmentierung und der Panoptischen Segmentierung in diesem Forschungsfeld.
## [Aufgabe](lab/README.md)
In diesem Labor versuchen Sie die **Segmentierung des menschlichen Körpers** mithilfe des [Segmentation Full Body MADS Dataset](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) von Kaggle.
In diesem Labor versuchen Sie die **Segmentierung des menschlichen Körpers** mit dem [Segmentation Full Body MADS Dataset](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) von Kaggle.
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

23
translations/de/lessons/4-ComputerVision/12-Segmentation/lab/README.md
View File

@ -1,22 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "365f0decfe0f47b460bbde8227c5009d",
"translation_date": "2025-08-24T09:34:29+00:00",
"source_file": "lessons/4-ComputerVision/12-Segmentation/lab/README.md",
"language_code": "de"
}
-->
# Segmentierung des menschlichen Körpers
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
In der Videoproduktion, zum Beispiel in Wettervorhersagen, müssen wir oft ein menschliches Bild aus der Kamera ausschneiden und es über andere Aufnahmen legen. Dies geschieht typischerweise mit **Chroma-Key**-Techniken, bei denen ein Mensch vor einem einfarbigen Hintergrund gefilmt wird, der dann entfernt wird. In diesem Labor werden wir ein neuronales Netzwerkmodell trainieren, um die menschliche Silhouette auszuschneiden.
In der Videoproduktion, beispielsweise bei Wettervorhersagen, müssen wir oft ein menschliches Bild aus der Kamera ausschneiden und es über anderes Filmmaterial legen. Dies wird typischerweise mit **Chroma-Key**-Techniken durchgeführt, bei denen eine Person vor einem einfarbigen Hintergrund gefilmt wird, der anschließend entfernt wird. In diesem Labor werden wir ein neuronales Netzwerk trainieren, um die Silhouette eines Menschen auszuschneiden.
## Der Datensatz
Wir werden den [Segmentation Full Body MADS Dataset](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) von Kaggle verwenden. Laden Sie den Datensatz manuell von Kaggle herunter.
Wir verwenden den [Segmentation Full Body MADS Dataset](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) von Kaggle. Laden Sie den Datensatz manuell von Kaggle herunter.
## Notebook starten
## Start-Notebook
Starten Sie das Labor, indem Sie [BodySegmentation.ipynb](../../../../../../lessons/4-ComputerVision/12-Segmentation/lab/BodySegmentation.ipynb) öffnen.
Beginnen Sie das Labor, indem Sie [BodySegmentation.ipynb](../../../../../../lessons/4-ComputerVision/12-Segmentation/lab/BodySegmentation.ipynb) öffnen.
## Fazit
## Erkenntnis
Die Segmentierung des Körpers ist nur eine der häufigen Aufgaben, die wir mit Bildern von Menschen durchführen können. Weitere wichtige Aufgaben sind **Skelett-Erkennung** und **Pose-Erkennung**. Schauen Sie sich die [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) Bibliothek an, um zu sehen, wie diese Aufgaben umgesetzt werden können.
Die Segmentierung des Körpers ist nur eine der gängigen Aufgaben, die wir mit Bildern von Menschen durchführen können. Weitere wichtige Aufgaben umfassen **Skelett-Erkennung** und **Pose-Erkennung**. Schauen Sie sich die [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose)-Bibliothek an, um zu sehen, wie diese Aufgaben umgesetzt werden können.
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle angesehen werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

19
translations/de/lessons/4-ComputerVision/README.md
View File

@ -1,16 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "58a52f000089c1d8906a4daa4ab1169b",
"translation_date": "2025-08-24T09:33:41+00:00",
"source_file": "lessons/4-ComputerVision/README.md",
"language_code": "de"
}
-->
# Computer Vision
![Zusammenfassung der Inhalte zur Computer Vision in einem Doodle](../../../../translated_images/ai-computervision.6506ebebac3fbf76cdb78989d7d3dfea87e88285c0feaade53aa7804a22b248f.de.png)
![Zusammenfassung der Inhalte zu Computer Vision in einer Skizze](../../../../lessons/sketchnotes/ai-computervision.png)
In diesem Abschnitt werden wir lernen über:
In diesem Abschnitt lernen wir über:
* [Einführung in Computer Vision und OpenCV](06-IntroCV/README.md)
* [Faltung neuronaler Netzwerke](07-ConvNets/README.md)
* [Vortrainierte Netzwerke und Transferlernen](08-TransferLearning/README.md)
* [Convolutional Neural Networks](07-ConvNets/README.md)
* [Vortrainierte Netzwerke und Transfer Learning](08-TransferLearning/README.md)
* [Autoencoder](09-Autoencoders/README.md)
* [Generative Adversarial Networks](10-GANs/README.md)
* [Objekterkennung](11-ObjectDetection/README.md)
* [Semantische Segmentierung](12-Segmentation/README.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Originalsprache sollte als die 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.
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.

65
translations/de/lessons/5-NLP/13-TextRep/README.md
View File

@ -1,76 +1,85 @@
# Text als Tensoren darstellen
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "4522e22e150be0845e03aa41209a39d5",
"translation_date": "2025-08-24T09:31:28+00:00",
"source_file": "lessons/5-NLP/13-TextRep/README.md",
"language_code": "de"
}
-->
# Darstellung von Text als Tensoren
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/113)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/113)
## Textklassifikation
Im ersten Teil dieses Abschnitts konzentrieren wir uns auf die Aufgabe der **Textklassifikation**. Wir verwenden den [AG News](https://www.kaggle.com/amananandrai/ag-news-classification-dataset) Datensatz, der Nachrichtenartikel wie die folgenden enthält:
Im ersten Teil dieses Abschnitts konzentrieren wir uns auf die Aufgabe der **Textklassifikation**. Wir verwenden das [AG News](https://www.kaggle.com/amananandrai/ag-news-classification-dataset)-Datenset, das Nachrichtenartikel wie den folgenden enthält:
* Kategorie: Sci/Tech
* Titel: Ky. Unternehmen gewinnt Zuschuss zur Untersuchung von Peptiden (AP)
* Text: AP - Ein Unternehmen, das von einem Chemieforscher an der Universität von Louisville gegründet wurde, hat einen Zuschuss erhalten, um...
* Kategorie: Wissenschaft/Technik
* Titel: Ky. Unternehmen erhält Zuschuss zur Erforschung von Peptiden (AP)
* Inhalt: AP - Ein Unternehmen, das von einem Chemieforscher der Universität von Louisville gegründet wurde, erhielt einen Zuschuss zur Entwicklung...
Unser Ziel wird es sein, den Nachrichtenartikel basierend auf dem Text in eine der Kategorien einzuordnen.
Unser Ziel wird es sein, die Nachricht basierend auf dem Text einer der Kategorien zuzuordnen.
## Text darstellen
## Darstellung von Text
Wenn wir Aufgaben der Verarbeitung natürlicher Sprache (NLP) mit neuronalen Netzwerken lösen wollen, benötigen wir eine Möglichkeit, Text als Tensoren darzustellen. Computer stellen bereits textuelle Zeichen als Zahlen dar, die auf Schriftarten auf Ihrem Bildschirm mithilfe von Kodierungen wie ASCII oder UTF-8 abgebildet werden.
Wenn wir Aufgaben der natürlichen Sprachverarbeitung (NLP) mit neuronalen Netzwerken lösen wollen, benötigen wir eine Methode, um Text als Tensoren darzustellen. Computer stellen Zeichen bereits als Zahlen dar, die mithilfe von Codierungen wie ASCII oder UTF-8 auf die Schriftarten auf Ihrem Bildschirm abgebildet werden.
<img alt="Bild, das ein Diagramm zeigt, das ein Zeichen einer ASCII- und binären Darstellung zuordnet" src="images/ascii-character-map.png" width="50%"/>
<img alt="Bild zeigt ein Diagramm, das ein Zeichen einer ASCII- und binären Darstellung zuordnet" src="images/ascii-character-map.png" width="50%"/>
> [Bildquelle](https://www.seobility.net/en/wiki/ASCII)
Als Menschen verstehen wir, was jeder Buchstabe **darstellt**, und wie alle Zeichen zusammenkommen, um die Wörter eines Satzes zu bilden. Computer hingegen haben ein solches Verständnis nicht, und neuronale Netzwerke müssen die Bedeutung während des Trainings lernen.
Als Menschen verstehen wir, was jeder Buchstabe **repräsentiert** und wie alle Zeichen zusammenkommen, um die Wörter eines Satzes zu bilden. Computer hingegen haben von sich aus kein solches Verständnis, und ein neuronales Netzwerk muss die Bedeutung während des Trainings lernen.
Daher können wir verschiedene Ansätze zur Darstellung von Text verwenden:
Daher können wir verschiedene Ansätze verwenden, um Text darzustellen:
* **Zeichenebene Darstellung**, bei der wir Text darstellen, indem wir jedes Zeichen als eine Zahl behandeln. Angenommen, wir haben *C* verschiedene Zeichen in unserem Textkorpus, würde das Wort *Hallo* durch einen 5x*C* Tensor dargestellt. Jeder Buchstabe würde einer Tensor-Spalte in der One-Hot-Kodierung entsprechen.
* **Wortebene Darstellung**, bei der wir ein **Wörterbuch** aller Wörter in unserem Text erstellen und dann Wörter mithilfe von One-Hot-Kodierung darstellen. Dieser Ansatz ist in gewisser Weise besser, da jeder Buchstabe für sich genommen nicht viel Bedeutung hat, und indem wir somit höherwertige semantische Konzepte - Wörter - verwenden, vereinfachen wir die Aufgabe für das neuronale Netzwerk. Aufgrund der großen Wörterbuchgröße müssen wir jedoch mit hochdimensionalen spärlichen Tensoren umgehen.
* **Zeichenbasierte Darstellung**, bei der wir Text darstellen, indem wir jedes Zeichen als Zahl behandeln. Angenommen, wir haben *C* verschiedene Zeichen in unserem Textkorpus, dann würde das Wort *Hello* durch einen 5x*C*-Tensor dargestellt. Jedes Zeichen würde einer Spalte im Tensor in One-Hot-Codierung entsprechen.
* **Wortbasierte Darstellung**, bei der wir ein **Vokabular** aller Wörter in unserem Text erstellen und dann Wörter mithilfe von One-Hot-Codierung darstellen. Dieser Ansatz ist in gewisser Weise besser, da jedes Zeichen für sich genommen nicht viel Bedeutung hat. Durch die Verwendung höherer semantischer Konzepte – Wörter – vereinfachen wir die Aufgabe für das neuronale Netzwerk. Aufgrund der großen Wörterbuchgröße müssen wir jedoch mit hochdimensionalen, spärlichen Tensoren umgehen.
Unabhängig von der Darstellung müssen wir den Text zunächst in eine Sequenz von **Tokens** umwandeln, wobei ein Token entweder ein Zeichen, ein Wort oder manchmal sogar ein Teil eines Wortes ist. Dann wandeln wir das Token in eine Zahl um, typischerweise unter Verwendung eines **Wörterbuchs**, und diese Zahl kann über One-Hot-Kodierung in ein neuronales Netzwerk eingespeist werden.
Unabhängig von der Darstellung müssen wir den Text zunächst in eine Sequenz von **Tokens** umwandeln, wobei ein Token entweder ein Zeichen, ein Wort oder manchmal sogar ein Teil eines Wortes ist. Anschließend konvertieren wir das Token in eine Zahl, typischerweise mithilfe eines **Vokabulars**, und diese Zahl kann mithilfe von One-Hot-Codierung in ein neuronales Netzwerk eingespeist werden.
## N-Gramme
In der natürlichen Sprache kann die genaue Bedeutung von Wörtern nur im Kontext bestimmt werden. Zum Beispiel sind die Bedeutungen von *neuronales Netzwerk* und *Fischernetz* völlig unterschiedlich. Eine Möglichkeit, dies zu berücksichtigen, besteht darin, unser Modell auf Wortpaaren aufzubauen und Wortpaare als separate Wörterbuch-Token zu betrachten. Auf diese Weise wird der Satz *Ich gehe gerne angeln* durch die folgende Token-Sequenz dargestellt: *Ich gehe*, *gehe gerne*, *gerne angeln*. Das Problem mit diesem Ansatz ist, dass die Wörterbuchgröße erheblich wächst und Kombinationen wie *gehe angeln* und *gehe einkaufen* durch unterschiedliche Tokens dargestellt werden, die trotz des gleichen Verbs keine semantische Ähnlichkeit aufweisen.
In der natürlichen Sprache kann die genaue Bedeutung von Wörtern nur im Kontext bestimmt werden. Zum Beispiel haben *neuronales Netzwerk* und *Fischernetz* völlig unterschiedliche Bedeutungen. Eine Möglichkeit, dies zu berücksichtigen, besteht darin, unser Modell auf Wortpaaren aufzubauen und Wortpaare als separate Vokabular-Tokens zu betrachten. Auf diese Weise wird der Satz *Ich gehe gerne angeln* durch die folgende Sequenz von Tokens dargestellt: *Ich gehe*, *gehe gerne*, *gerne angeln*. Das Problem bei diesem Ansatz ist, dass die Wörterbuchgröße erheblich wächst und Kombinationen wie *gerne angeln* und *gerne einkaufen* durch unterschiedliche Tokens dargestellt werden, die trotz des gleichen Verbs keine semantische Ähnlichkeit teilen.
In einigen Fällen können wir auch Tri-Gramme - Kombinationen von drei Wörtern - in Betracht ziehen. Daher wird dieser Ansatz oft als **n-Gramme** bezeichnet. Es macht auch Sinn, n-Gramme mit der Zeichenebene Darstellung zu verwenden, wobei n-Gramme grob unterschiedlichen Silben entsprechen.
In einigen Fällen können wir auch Tri-Gramme – Kombinationen aus drei Wörtern – in Betracht ziehen. Daher wird dieser Ansatz oft als **n-Gramme** bezeichnet. Es macht auch Sinn, n-Gramme mit zeichenbasierter Darstellung zu verwenden, wobei n-Gramme in diesem Fall grob verschiedenen Silben entsprechen.
## Bag-of-Words und TF/IDF
Bei der Lösung von Aufgaben wie der Textklassifikation müssen wir in der Lage sein, Text durch einen festgelegten Vektor fester Größe darzustellen, den wir als Eingabe für den abschließenden dichten Klassifizierer verwenden. Eine der einfachsten Möglichkeiten, dies zu tun, besteht darin, alle individuellen Wortdarstellungen zu kombinieren, z.B. indem wir sie addieren. Wenn wir die One-Hot-Kodierungen jedes Wortes addieren, erhalten wir einen Vektor von Frequenzen, der zeigt, wie oft jedes Wort im Text erscheint. Eine solche Textdarstellung wird als **Bag of Words** (BoW) bezeichnet.
Bei Aufgaben wie der Textklassifikation müssen wir in der Lage sein, Text durch einen festen Vektor darzustellen, den wir als Eingabe für den abschließenden dichten Klassifikator verwenden. Eine der einfachsten Möglichkeiten, dies zu tun, besteht darin, alle einzelnen Wortdarstellungen zu kombinieren, z. B. indem wir sie addieren. Wenn wir die One-Hot-Codierungen jedes Wortes addieren, erhalten wir einen Frequenzvektor, der zeigt, wie oft jedes Wort im Text vorkommt. Eine solche Darstellung von Text wird als **Bag-of-Words** (BoW) bezeichnet.
<img src="images/bow.png" width="90%"/>
> Bild vom Autor
Ein BoW stellt im Wesentlichen dar, welche Wörter im Text erscheinen und in welchen Mengen, was tatsächlich ein guter Hinweis darauf sein kann, worum es im Text geht. Zum Beispiel enthält ein Nachrichtenartikel über Politik wahrscheinlich Wörter wie *Präsident* und *Land*, während eine wissenschaftliche Publikation etwas wie *Collider*, *entdeckt* usw. enthalten würde. Daher können Wortfrequenzen in vielen Fällen ein guter Indikator für den Textinhalt sein.
Ein BoW zeigt im Wesentlichen, welche Wörter im Text vorkommen und in welchen Mengen, was tatsächlich ein guter Hinweis darauf sein kann, worum es im Text geht. Ein Nachrichtenartikel über Politik enthält beispielsweise wahrscheinlich Wörter wie *Präsident* und *Land*, während eine wissenschaftliche Veröffentlichung Begriffe wie *Kollider*, *entdeckt* usw. enthalten könnte. Daher können Wortfrequenzen in vielen Fällen ein guter Indikator für den Textinhalt sein.
Das Problem mit BoW ist, dass bestimmte häufige Wörter, wie *und*, *ist* usw., in den meisten Texten erscheinen und die höchsten Frequenzen aufweisen, wodurch die Wörter, die wirklich wichtig sind, in den Hintergrund gedrängt werden. Wir können die Bedeutung dieser Wörter verringern, indem wir die Häufigkeit berücksichtigen, mit der Wörter in der gesamten Dokumentensammlung auftreten. Dies ist die Hauptidee hinter dem TF/IDF-Ansatz, der in den Notebooks, die zu dieser Lektion gehören, detaillierter behandelt wird.
Das Problem bei BoW ist, dass bestimmte häufige Wörter wie *und*, *ist* usw. in den meisten Texten vorkommen und die höchsten Frequenzen aufweisen, wodurch die wirklich wichtigen Wörter in den Hintergrund treten. Wir können die Bedeutung dieser Wörter verringern, indem wir die Häufigkeit berücksichtigen, mit der Wörter in der gesamten Dokumentensammlung vorkommen. Dies ist die Hauptidee hinter dem TF/IDF-Ansatz, der in den zu dieser Lektion gehörenden Notebooks ausführlicher behandelt wird.
Allerdings können keine dieser Ansätze die **Semantik** des Textes vollständig berücksichtigen. Wir benötigen leistungsfähigere Modelle neuronaler Netzwerke, um dies zu tun, was wir später in diesem Abschnitt besprechen werden.
Allerdings können keine dieser Ansätze die **Semantik** des Textes vollständig berücksichtigen. Dafür benötigen wir leistungsstärkere neuronale Netzwerkmodelle, die wir später in diesem Abschnitt besprechen werden.
## ✍️ Übungen: Textdarstellung
Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
* [Textdarstellung mit PyTorch](../../../../../lessons/5-NLP/13-TextRep/TextRepresentationPyTorch.ipynb)
* [Textdarstellung mit PyTorch](../../../../../lessons/5-NLP/13-TextRep/TextRepresentationPyTorch.ipynb)
* [Textdarstellung mit TensorFlow](../../../../../lessons/5-NLP/13-TextRep/TextRepresentationTF.ipynb)
## Fazit
Bis jetzt haben wir Techniken untersucht, die Frequenzgewichtungen für verschiedene Wörter hinzufügen können. Sie sind jedoch nicht in der Lage, Bedeutung oder Reihenfolge darzustellen. Wie der berühmte Linguist J. R. Firth 1935 sagte: "Die vollständige Bedeutung eines Wortes ist immer kontextabhängig, und kein Studium der Bedeutung, das vom Kontext getrennt ist, kann ernst genommen werden." Wir werden später im Kurs lernen, wie man kontextuelle Informationen aus Text mithilfe von Sprachmodellen erfasst.
Bisher haben wir Techniken untersucht, die Frequenzgewichte für verschiedene Wörter hinzufügen können. Sie sind jedoch nicht in der Lage, Bedeutung oder Reihenfolge darzustellen. Wie der berühmte Linguist J. R. Firth 1935 sagte: "Die vollständige Bedeutung eines Wortes ist immer kontextabhängig, und keine Untersuchung der Bedeutung ohne Kontext kann ernst genommen werden." Später im Kurs werden wir lernen, wie man kontextuelle Informationen aus Text mithilfe von Sprachmodellen erfasst.
## 🚀 Herausforderung
Versuchen Sie einige andere Übungen mit Bag-of-Words und verschiedenen Datenmodellen. Sie könnten inspiriert werden von diesem [Wettbewerb auf Kaggle](https://www.kaggle.com/competitions/word2vec-nlp-tutorial/overview/part-1-for-beginners-bag-of-words)
Probieren Sie einige andere Übungen mit Bag-of-Words und verschiedenen Datenmodellen aus. Vielleicht inspiriert Sie dieser [Wettbewerb auf Kaggle](https://www.kaggle.com/competitions/word2vec-nlp-tutorial/overview/part-1-for-beginners-bag-of-words).
## [Nach dem Vortrag Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/213)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/213)
## Überprüfung & Selbststudium
## Wiederholung & Selbststudium
Üben Sie Ihre Fähigkeiten mit Text-Embeddings und Bag-of-Words-Techniken auf [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste)
Üben Sie Ihre Fähigkeiten mit Text-Embeddings und Bag-of-Words-Techniken auf [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste).
## [Aufgabe: Notebooks](assignment.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

13
translations/de/lessons/5-NLP/13-TextRep/assignment.md
View File

@ -1,6 +1,15 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "cdc1f2e631f055f3473b36d18e4760b3",
"translation_date": "2025-08-24T09:31:50+00:00",
"source_file": "lessons/5-NLP/13-TextRep/assignment.md",
"language_code": "de"
}
-->
# Aufgabe: Notebooks
Verwenden Sie die mit dieser Lektion verbundenen Notebooks (entweder die PyTorch- oder die TensorFlow-Version), und führen Sie sie mit Ihrem eigenen Datensatz erneut aus, möglicherweise einem von Kaggle, unter Angabe der Quelle. Überarbeiten Sie das Notebook, um Ihre eigenen Erkenntnisse hervorzuheben. Probieren Sie einige innovative Datensätze aus, die überraschend sein könnten, wie [diesen über UFO-Sichtungen](https://www.kaggle.com/datasets/NUFORC/ufo-sightings) von NUFORC.
Verwenden Sie die Notebooks, die zu dieser Lektion gehören (entweder die PyTorch- oder die TensorFlow-Version), und führen Sie sie mit Ihrem eigenen Datensatz aus, möglicherweise einem von Kaggle, unter Angabe der Quelle. Überarbeiten Sie das Notebook, um Ihre eigenen Erkenntnisse hervorzuheben. Probieren Sie einige innovative Datensätze aus, die überraschend sein könnten, wie zum Beispiel [diesen über UFO-Sichtungen](https://www.kaggle.com/datasets/NUFORC/ufo-sightings) von NUFORC.
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Originalsprache sollte als autoritative 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 Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

55
translations/de/lessons/5-NLP/14-Embeddings/README.md
View File

@ -1,16 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "e40b47ac3fd48f71304ede1474e66293",
"translation_date": "2025-08-24T09:30:31+00:00",
"source_file": "lessons/5-NLP/14-Embeddings/README.md",
"language_code": "de"
}
-->
# Einbettungen
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/114)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/114)
Beim Training von Klassifikatoren, die auf BoW oder TF/IDF basieren, haben wir mit hochdimensionalen Bag-of-Words-Vektoren mit einer Länge von `vocab_size` gearbeitet und explizit von niedrigdimensionalen positionsbasierten Repräsentationsvektoren in spärliche One-Hot-Repräsentationen umgewandelt. Diese One-Hot-Repräsentation ist jedoch nicht speichereffizient. Darüber hinaus wird jedes Wort unabhängig voneinander behandelt, d.h. One-Hot-kodierte Vektoren drücken keine semantische Ähnlichkeit zwischen Wörtern aus.
Beim Training von Klassifikatoren basierend auf BoW oder TF/IDF arbeiteten wir mit hochdimensionalen Bag-of-Words-Vektoren der Länge `vocab_size` und konvertierten explizit von niedrigdimensionalen Positionsdarstellungsvektoren in spärliche One-Hot-Darstellungen. Diese One-Hot-Darstellung ist jedoch nicht speichereffizient. Außerdem wird jedes Wort unabhängig von den anderen behandelt, d. h. One-Hot-codierte Vektoren drücken keine semantische Ähnlichkeit zwischen Wörtern aus.
Die Idee der **Einbettung** besteht darin, Wörter durch niederdimensionale dichte Vektoren darzustellen, die in gewisser Weise die semantische Bedeutung eines Wortes widerspiegeln. Wir werden später besprechen, wie man sinnvolle Wort-Einbettungen erstellt, aber für den Moment denken wir einfach an Einbettungen als eine Möglichkeit, die Dimensionalität eines Wortvektors zu verringern.
Die Idee der **Einbettung** besteht darin, Wörter durch niedrigdimensionale dichte Vektoren darzustellen, die irgendwie die semantische Bedeutung eines Wortes widerspiegeln. Später werden wir besprechen, wie man sinnvolle Wort-Einbettungen erstellt, aber vorerst betrachten wir Einbettungen einfach als eine Möglichkeit, die Dimensionalität eines Wortvektors zu reduzieren.
Die Einbettungsschicht würde ein Wort als Eingabe nehmen und einen Ausgabvektor der angegebenen `embedding_size` erzeugen. In gewissem Sinne ähnelt es einer `Linear`-Schicht, aber anstatt einen One-Hot-kodierten Vektor zu verwenden, kann es eine Wortnummer als Eingabe akzeptieren, was es uns ermöglicht, große One-Hot-kodierte Vektoren zu vermeiden.
Die Einbettungsschicht würde also ein Wort als Eingabe nehmen und einen Ausgabesektor mit einer bestimmten `embedding_size` erzeugen. In gewisser Weise ist sie einer `Linear`-Schicht sehr ähnlich, aber anstatt einen One-Hot-codierten Vektor zu verwenden, kann sie eine Wortnummer als Eingabe akzeptieren, wodurch wir große One-Hot-codierte Vektoren vermeiden können.
Durch die Verwendung einer Einbettungsschicht als erste Schicht in unserem Klassifikator-Netzwerk können wir von einem Bag-of-Words- zu einem **Einbettungsbeutel**-Modell wechseln, bei dem wir zunächst jedes Wort in unserem Text in die entsprechende Einbettung umwandeln und dann eine aggregierte Funktion über all diese Einbettungen berechnen, wie z.B. `sum`, `average` oder `max`.
Durch die Verwendung einer Einbettungsschicht als erste Schicht in unserem Klassifikator-Netzwerk können wir von einem Bag-of-Words-Modell zu einem **Embedding-Bag-Modell** wechseln, bei dem wir zunächst jedes Wort in unserem Text in die entsprechende Einbettung umwandeln und dann eine Aggregatfunktion über alle diese Einbettungen berechnen, wie z. B. `sum`, `average` oder `max`.
![Bild, das einen Einbettungsklassifikator für fünf aufeinanderfolgende Wörter zeigt.](../../../../../translated_images/embedding-classifier-example.b77f021a7ee67eeec8e68bfe11636c5b97d6eaa067515a129bfb1d0034b1ac5b.de.png)
![Bild, das einen Einbettungsklassifikator für fünf Sequenzwörter zeigt.](../../../../../lessons/5-NLP/14-Embeddings/images/embedding-classifier-example.png)
> Bild vom Autor
@ -22,47 +31,47 @@ Setze dein Lernen in den folgenden Notebooks fort:
## Semantische Einbettungen: Word2Vec
Während die Einbettungsschicht gelernt hat, Wörter in Vektorrepräsentationen abzubilden, hatte diese Repräsentation nicht unbedingt viel semantische Bedeutung. Es wäre schön, eine Vektorrepräsentation zu lernen, sodass ähnliche Wörter oder Synonyme Vektoren entsprechen, die in Bezug auf eine bestimmte Vektordistanz (z.B. euklidische Distanz) nah beieinander liegen.
Während die Einbettungsschicht gelernt hat, Wörter in Vektordarstellungen zu überführen, hat diese Darstellung jedoch nicht unbedingt eine große semantische Bedeutung. Es wäre wünschenswert, eine Vektordarstellung zu lernen, bei der ähnliche Wörter oder Synonyme Vektoren entsprechen, die in Bezug auf eine Vektordistanz (z. B. euklidische Distanz) nahe beieinander liegen.
Um dies zu erreichen, müssen wir unser Einbettungsmodell auf eine bestimmte Weise auf einer großen Textsammlung vortrainieren. Eine Möglichkeit, semantische Einbettungen zu trainieren, nennt sich [Word2Vec](https://en.wikipedia.org/wiki/Word2vec). Es basiert auf zwei Hauptarchitekturen, die verwendet werden, um eine verteilte Repräsentation von Wörtern zu erzeugen:
Um dies zu erreichen, müssen wir unser Einbettungsmodell auf einer großen Textsammlung in einer bestimmten Weise vortrainieren. Eine Methode, um semantische Einbettungen zu trainieren, wird [Word2Vec](https://en.wikipedia.org/wiki/Word2vec) genannt. Sie basiert auf zwei Hauptarchitekturen, die verwendet werden, um eine verteilte Darstellung von Wörtern zu erzeugen:
- **Kontinuierlicher Bag-of-Words** (CBoW) — In dieser Architektur trainieren wir das Modell, um ein Wort aus dem umgebenden Kontext vorherzusagen. Gegeben das ngram $(W_{-2},W_{-1},W_0,W_1,W_2)$ besteht das Ziel des Modells darin, $W_0$ aus $(W_{-2},W_{-1},W_1,W_2)$ vorherzusagen.
- **Kontinuierliches Skip-Gram** ist das Gegenteil von CBoW. Das Modell verwendet das umgebende Fenster von Kontextwörtern, um das aktuelle Wort vorherzusagen.
- **Continuous Bag-of-Words** (CBoW) — In dieser Architektur trainieren wir das Modell, ein Wort aus dem umgebenden Kontext vorherzusagen. Gegeben das ngram $(W_{-2},W_{-1},W_0,W_1,W_2)$, ist das Ziel des Modells, $W_0$ aus $(W_{-2},W_{-1},W_1,W_2)$ vorherzusagen.
- **Continuous Skip-Gram** ist das Gegenteil von CBoW. Das Modell verwendet das umgebende Fenster von Kontextwörtern, um das aktuelle Wort vorherzusagen.
CBoW ist schneller, während Skip-Gram langsamer ist, aber eine bessere Darstellung seltener Wörter liefert.
CBoW ist schneller, während Skip-Gram langsamer ist, aber eine bessere Darstellung von seltenen Wörtern liefert.
![Bild, das sowohl CBoW- als auch Skip-Gram-Algorithmen zur Umwandlung von Wörtern in Vektoren zeigt.](../../../../../translated_images/example-algorithms-for-converting-words-to-vectors.fbe9207a726922f6f0f5de66427e8a6eda63809356114e28fb1fa5f4a83ebda7.de.png)
![Bild, das sowohl CBoW- als auch Skip-Gram-Algorithmen zur Umwandlung von Wörtern in Vektoren zeigt.](../../../../../lessons/5-NLP/14-Embeddings/images/example-algorithms-for-converting-words-to-vectors.png)
> Bild aus [diesem Papier](https://arxiv.org/pdf/1301.3781.pdf)
> Bild aus [diesem Paper](https://arxiv.org/pdf/1301.3781.pdf)
Vortrainierte Word2Vec-Einbettungen (sowie andere ähnliche Modelle wie GloVe) können auch anstelle der Einbettungsschicht in neuronalen Netzwerken verwendet werden. Allerdings müssen wir uns mit Vokabularen auseinandersetzen, da das Vokabular, das zum Vortrainieren von Word2Vec/GloVe verwendet wird, wahrscheinlich von dem Vokabular in unserem Textkorpus abweicht. Sieh dir die oben genannten Notebooks an, um zu sehen, wie dieses Problem gelöst werden kann.
Word2Vec vortrainierte Einbettungen (sowie andere ähnliche Modelle wie GloVe) können auch anstelle der Einbettungsschicht in neuronalen Netzwerken verwendet werden. Allerdings müssen wir mit Vokabularen umgehen, da das Vokabular, das zum Vortrainieren von Word2Vec/GloVe verwendet wurde, wahrscheinlich von dem Vokabular in unserem Textkorpus abweicht. Schau dir die oben genannten Notebooks an, um zu sehen, wie dieses Problem gelöst werden kann.
## Kontextuelle Einbettungen
Eine wesentliche Einschränkung traditioneller vortrainierter Einbettungsrepräsentationen wie Word2Vec ist das Problem der Mehrdeutigkeit von Wörtern. Während vortrainierte Einbettungen einige Bedeutungen von Wörtern im Kontext erfassen können, wird jede mögliche Bedeutung eines Wortes in der gleichen Einbettung kodiert. Dies kann Probleme in nachgelagerten Modellen verursachen, da viele Wörter, wie das Wort 'play', je nach verwendetem Kontext unterschiedliche Bedeutungen haben.
Eine zentrale Einschränkung traditioneller vortrainierter Einbettungsdarstellungen wie Word2Vec ist das Problem der Wortbedeutungsunterscheidung. Während vortrainierte Einbettungen einen Teil der Bedeutung von Wörtern im Kontext erfassen können, wird jede mögliche Bedeutung eines Wortes in derselben Einbettung kodiert. Dies kann in nachgelagerten Modellen Probleme verursachen, da viele Wörter, wie das Wort 'play', je nach Kontext unterschiedliche Bedeutungen haben.
Zum Beispiel haben die Wörter 'play' in diesen beiden verschiedenen Sätzen eine ganz andere Bedeutung:
Zum Beispiel hat das Wort 'play' in diesen beiden Sätzen eine ganz unterschiedliche Bedeutung:
- Ich ging zu einem **Theaterstück**.
- John möchte mit seinen Freunden **spielen**.
Die vortrainierten Einbettungen oben repräsentieren beide Bedeutungen des Wortes 'play' in der gleichen Einbettung. Um diese Einschränkung zu überwinden, müssen wir Einbettungen auf der Grundlage des **Sprachmodells** erstellen, das auf einem großen Textkorpus trainiert wurde und *weiß*, wie Wörter in unterschiedlichen Kontexten zusammengefügt werden können. Die Diskussion über kontextuelle Einbettungen fällt außerhalb des Rahmens dieses Tutorials, aber wir werden später im Kurs darauf zurückkommen, wenn wir über Sprachmodelle sprechen.
Die oben genannten vortrainierten Einbettungen repräsentieren beide Bedeutungen des Wortes 'play' in derselben Einbettung. Um diese Einschränkung zu überwinden, müssen wir Einbettungen basierend auf dem **Sprachmodell** erstellen, das auf einem großen Textkorpus trainiert wurde und *weiß*, wie Wörter in verschiedenen Kontexten zusammengefügt werden können. Die Diskussion über kontextuelle Einbettungen liegt außerhalb des Rahmens dieses Tutorials, aber wir werden darauf zurückkommen, wenn wir später im Kurs über Sprachmodelle sprechen.
## Fazit
In dieser Lektion hast du entdeckt, wie man Einbettungsschichten in TensorFlow und Pytorch erstellt und verwendet, um die semantischen Bedeutungen von Wörtern besser widerzuspiegeln.
In dieser Lektion hast du gelernt, wie man Einbettungsschichten in TensorFlow und PyTorch erstellt und verwendet, um die semantische Bedeutung von Wörtern besser widerzuspiegeln.
## 🚀 Herausforderung
Word2Vec wurde für einige interessante Anwendungen verwendet, einschließlich der Generierung von Songtexten und Poesie. Schau dir [diesen Artikel](https://www.politetype.com/blog/word2vec-color-poems) an, der erklärt, wie der Autor Word2Vec zur Erstellung von Poesie verwendet hat. Schau dir auch [dieses Video von Dan Shiffmann](https://www.youtube.com/watch?v=LSS_bos_TPI&ab_channel=TheCodingTrain) an, um eine andere Erklärung dieser Technik zu entdecken. Versuche dann, diese Techniken auf deinen eigenen Textkorpus anzuwenden, vielleicht aus Kaggle.
Word2Vec wurde für einige interessante Anwendungen verwendet, einschließlich der Generierung von Songtexten und Gedichten. Schau dir [diesen Artikel](https://www.politetype.com/blog/word2vec-color-poems) an, der erklärt, wie der Autor Word2Vec verwendet hat, um Gedichte zu generieren. Sieh dir auch [dieses Video von Dan Shiffmann](https://www.youtube.com/watch?v=LSS_bos_TPI&ab_channel=TheCodingTrain) an, um eine andere Erklärung dieser Technik zu entdecken. Versuche dann, diese Techniken auf deinen eigenen Textkorpus anzuwenden, vielleicht aus Kaggle.
## [Nachlese-Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/214)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/214)
## Überprüfung & Selbststudium
## Wiederholung & Selbststudium
Lies dir dieses Papier über Word2Vec durch: [Effiziente Schätzung von Wortdarstellungen im Vektorraum](https://arxiv.org/pdf/1301.3781.pdf)
Lies dieses Paper über Word2Vec: [Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/pdf/1301.3781.pdf)
## [Aufgabe: Notebooks](assignment.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

13
translations/de/lessons/5-NLP/14-Embeddings/assignment.md
View File

@ -1,6 +1,15 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "bc690ecf68b38d311cc9e12f3144a28c",
"translation_date": "2025-08-24T09:30:53+00:00",
"source_file": "lessons/5-NLP/14-Embeddings/assignment.md",
"language_code": "de"
}
-->
# Aufgabe: Notebooks
Verwenden Sie die Notebooks, die mit dieser Lektion verbunden sind (entweder die PyTorch- oder die TensorFlow-Version), und führen Sie sie mit Ihrem eigenen Datensatz erneut aus, möglicherweise einem von Kaggle, wobei Sie die Quelle angeben. Überarbeiten Sie das Notebook, um Ihre eigenen Erkenntnisse zu unterstreichen. Probieren Sie eine andere Art von Datensatz aus und dokumentieren Sie Ihre Ergebnisse, indem Sie Texte wie [diese Beatles-Lyrics](https://www.kaggle.com/datasets/jenlooper/beatles-lyrics) verwenden.
Verwenden Sie die Notebooks, die mit dieser Lektion verbunden sind (entweder die PyTorch- oder die TensorFlow-Version), und führen Sie sie mit Ihrem eigenen Datensatz erneut aus, vielleicht einem von Kaggle, der mit entsprechender Quellenangabe verwendet wird. Überarbeiten Sie das Notebook, um Ihre eigenen Erkenntnisse hervorzuheben. Probieren Sie eine andere Art von Datensatz aus und dokumentieren Sie Ihre Ergebnisse, indem Sie beispielsweise Texte wie [diese Beatles-Songtexte](https://www.kaggle.com/datasets/jenlooper/beatles-lyrics) verwenden.
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, bitten wir zu beachten, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die 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 Verwendung dieser Übersetzung resultieren.
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.

53
translations/de/lessons/5-NLP/15-LanguageModeling/README.md
View File

@ -1,45 +1,54 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "31b46ba1f3aa78578134d4829f88be53",
"translation_date": "2025-08-24T09:31:56+00:00",
"source_file": "lessons/5-NLP/15-LanguageModeling/README.md",
"language_code": "de"
}
-->
# Sprachmodellierung
Semantische Einbettungen, wie Word2Vec und GloVe, sind in der Tat ein erster Schritt in Richtung **Sprachmodellierung** - Modelle zu erstellen, die irgendwie die Natur der Sprache *verstehen* (oder *darstellen*).
Semantische Einbettungen wie Word2Vec und GloVe sind tatsächlich ein erster Schritt in Richtung **Sprachmodellierung** – Modelle zu erstellen, die die Natur der Sprache irgendwie *verstehen* (oder *repräsentieren*).
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/115)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/115)
Die Hauptidee hinter der Sprachmodellierung besteht darin, sie auf unlabeled Datensätzen auf unüberwachtem Weg zu trainieren. Dies ist wichtig, da wir große Mengen an unlabeled Text zur Verfügung haben, während die Menge an labeled Text immer durch den Aufwand, den wir für das Labeling aufwenden können, begrenzt ist. Oft können wir Sprachmodelle erstellen, die **fehlende Wörter** im Text vorhersagen, da es einfach ist, ein zufälliges Wort im Text zu maskieren und es als Trainingsbeispiel zu verwenden.
Die Hauptidee hinter der Sprachmodellierung besteht darin, Modelle auf unbeschrifteten Datensätzen in einer unüberwachten Weise zu trainieren. Das ist wichtig, da uns riesige Mengen an unbeschriftetem Text zur Verfügung stehen, während die Menge an beschriftetem Text immer durch den Aufwand begrenzt ist, den wir für die Beschriftung aufbringen können. Meistens können wir Sprachmodelle erstellen, die **fehlende Wörter** im Text vorhersagen, da es einfach ist, ein zufälliges Wort im Text auszublenden und es als Trainingsbeispiel zu verwenden.
## Einbettungen trainieren
## Training von Einbettungen
In unseren vorherigen Beispielen haben wir vortrainierte semantische Einbettungen verwendet, aber es ist interessant zu sehen, wie diese Einbettungen trainiert werden können. Es gibt mehrere mögliche Ansätze, die verwendet werden können:
In unseren bisherigen Beispielen haben wir vortrainierte semantische Einbettungen verwendet, aber es ist interessant zu sehen, wie diese Einbettungen trainiert werden können. Es gibt mehrere mögliche Ansätze, die verwendet werden können:
* **N-Gram** Sprachmodellierung, wenn wir ein Token vorhersagen, indem wir auf N vorherige Tokens (N-gram) schauen.
* **Continuous Bag-of-Words** (CBoW), wenn wir das mittlere Token $W_0$ in einer Token-Sequenz $W_{-N}$, ..., $W_N$ vorhersagen.
* **Skip-gram**, wo wir eine Menge benachbarter Tokens {$W_{-N},\dots, W_{-1}, W_1,\dots, W_N$} aus dem mittleren Token $W_0$ vorhersagen.
* **N-Gramm**-Sprachmodellierung, bei der wir ein Token vorhersagen, indem wir auf die N vorherigen Tokens (N-Gramm) schauen.
* **Continuous Bag-of-Words** (CBoW), bei dem wir das mittlere Token $W_0$ in einer Token-Sequenz $W_{-N}$, ..., $W_N$ vorhersagen.
* **Skip-Gram**, bei dem wir eine Menge benachbarter Tokens {$W_{-N},\dots, W_{-1}, W_1,\dots, W_N$} aus dem mittleren Token $W_0$ vorhersagen.
![Bild aus dem Papier zur Umwandlung von Wörtern in Vektoren](../../../../../translated_images/example-algorithms-for-converting-words-to-vectors.fbe9207a726922f6f0f5de66427e8a6eda63809356114e28fb1fa5f4a83ebda7.de.png)
![Bild aus einem Paper über die Umwandlung von Wörtern in Vektoren](../../../../../lessons/5-NLP/14-Embeddings/images/example-algorithms-for-converting-words-to-vectors.png)
> Bild aus [diesem Papier](https://arxiv.org/pdf/1301.3781.pdf)
> Bild aus [diesem Paper](https://arxiv.org/pdf/1301.3781.pdf)
## ✍️ Beispiel-Notebooks: CBoW-Modell trainieren
## ✍️ Beispiel-Notebooks: Training eines CBoW-Modells
Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
Setze dein Lernen in den folgenden Notebooks fort:
* [Training CBoW Word2Vec mit TensorFlow](../../../../../lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb)
* [Training CBoW Word2Vec mit PyTorch](../../../../../lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb)
* [Training von CBoW Word2Vec mit TensorFlow](../../../../../lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb)
* [Training von CBoW Word2Vec mit PyTorch](../../../../../lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb)
## Fazit
In der vorherigen Lektion haben wir gesehen, dass Wort-Einbettungen wie Magie funktionieren! Jetzt wissen wir, dass das Trainieren von Wort-Einbettungen keine sehr komplexe Aufgabe ist und wir in der Lage sein sollten, unsere eigenen Wort-Einbettungen für domänenspezifischen Text zu trainieren, falls erforderlich.
In der vorherigen Lektion haben wir gesehen, dass Wort-Einbettungen wie Magie funktionieren! Jetzt wissen wir, dass das Training von Wort-Einbettungen keine sehr komplexe Aufgabe ist, und wir sollten in der Lage sein, unsere eigenen Wort-Einbettungen für textspezifische Domänen zu trainieren, falls erforderlich.
## [Nachlese-Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/215)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/215)
## Überprüfung & Selbststudium
## Rückblick & Selbststudium
* [Offizielles PyTorch-Tutorial zur Sprachmodellierung](https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html).
* [Offizielles TensorFlow-Tutorial zum Training des Word2Vec-Modells](https://www.TensorFlow.org/tutorials/text/word2vec).
* Die Verwendung des **gensim**-Frameworks, um die am häufigsten verwendeten Einbettungen in wenigen Codezeilen zu trainieren, wird [in dieser Dokumentation](https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html) beschrieben.
* [Offizielles TensorFlow-Tutorial zum Training eines Word2Vec-Modells](https://www.TensorFlow.org/tutorials/text/word2vec).
* Die Verwendung des **gensim**-Frameworks, um die am häufigsten verwendeten Einbettungen mit nur wenigen Codezeilen zu trainieren, wird [in dieser Dokumentation](https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html) beschrieben.
## 🚀 [Aufgabe: Trainiere Skip-Gram-Modell](lab/README.md)
## 🚀 [Aufgabe: Trainiere ein Skip-Gram-Modell](lab/README.md)
Im Labor fordern wir Sie heraus, den Code aus dieser Lektion zu ändern, um ein Skip-Gram-Modell anstelle von CBoW zu trainieren. [Lesen Sie die Details](lab/README.md)
Im Labor fordern wir dich heraus, den Code aus dieser Lektion zu modifizieren, um ein Skip-Gram-Modell anstelle von CBoW zu trainieren. [Lies die Details](lab/README.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle angesehen werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

27
translations/de/lessons/5-NLP/15-LanguageModeling/lab/README.md
View File

@ -1,14 +1,23 @@
# Training Skip-Gram Modell
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5130f01fdc5ebb83032b23d489027aac",
"translation_date": "2025-08-24T09:32:08+00:00",
"source_file": "lessons/5-NLP/15-LanguageModeling/lab/README.md",
"language_code": "de"
}
-->
# Training eines Skip-Gram-Modells
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
In diesem Labor fordern wir dich heraus, ein Word2Vec-Modell mit der Skip-Gram-Technik zu trainieren. Trainiere ein Netzwerk mit Einbettungen, um benachbarte Wörter in einem $N$-Tokens-breiten Skip-Gram-Fenster vorherzusagen. Du kannst [den Code aus dieser Lektion](../../../../../../lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb) verwenden und ihn leicht anpassen.
In diesem Labor fordern wir Sie heraus, ein Word2Vec-Modell mit der Skip-Gram-Technik zu trainieren. Trainieren Sie ein Netzwerk mit Embedding, um benachbarte Wörter in einem $N$-Tokens-breiten Skip-Gram-Fenster vorherzusagen. Sie können den [Code aus dieser Lektion](../../../../../../lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb) verwenden und leicht anpassen.
## Der Datensatz
Du kannst jedes Buch verwenden. Viele kostenlose Texte findest du bei [Project Gutenberg](https://www.gutenberg.org/), zum Beispiel hier ist ein direkter Link zu [Alice's Adventures in Wonderland](https://www.gutenberg.org/files/11/11-0.txt) von Lewis Carroll. Oder du kannst die Stücke von Shakespeare verwenden, die du mit dem folgenden Code erhalten kannst:
Sie können jedes beliebige Buch verwenden. Viele kostenlose Texte finden Sie bei [Project Gutenberg](https://www.gutenberg.org/), zum Beispiel gibt es hier einen direkten Link zu [Alice's Adventures in Wonderland](https://www.gutenberg.org/files/11/11-0.txt)) von Lewis Carroll. Alternativ können Sie auch die Stücke von Shakespeare verwenden, die Sie mit folgendem Code abrufen können:
```python
path_to_file = tf.keras.utils.get_file(
@ -17,13 +26,13 @@ path_to_file = tf.keras.utils.get_file(
text = open(path_to_file, 'rb').read().decode(encoding='utf-8')
```
## Erforschen!
## Erkunden Sie!
Wenn du Zeit hast und tiefer in das Thema eintauchen möchtest, versuche mehrere Dinge zu erkunden:
Wenn Sie Zeit haben und tiefer in das Thema eintauchen möchten, versuchen Sie, mehrere Dinge zu erforschen:
* Wie beeinflusst die Größe der Einbettung die Ergebnisse?
* Wie beeinflussen verschiedene Textstile das Ergebnis?
* Nimm mehrere sehr unterschiedliche Wortarten und deren Synonyme, erhalte ihre Vektordarstellungen, wende PCA an, um die Dimensionen auf 2 zu reduzieren, und plotiere sie im 2D-Raum. Siehst du irgendwelche Muster?
* Wie beeinflusst die Größe des Embeddings die Ergebnisse?
* Wie beeinflussen unterschiedliche Textstile das Ergebnis?
* Nehmen Sie mehrere sehr unterschiedliche Worttypen und deren Synonyme, erhalten Sie deren Vektorrepräsentationen, wenden Sie PCA an, um die Dimensionen auf 2 zu reduzieren, und plotten Sie sie im 2D-Raum. Erkennen Sie irgendwelche Muster?
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als autoritative 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 Verwendung dieser Übersetzung entstehen.
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.

69
translations/de/lessons/5-NLP/16-RNN/README.md
View File

@ -1,87 +1,96 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "58bf4adb210aab53e8f78c8082040e7c",
"translation_date": "2025-08-24T09:29:56+00:00",
"source_file": "lessons/5-NLP/16-RNN/README.md",
"language_code": "de"
}
-->
# Rekurrente Neuronale Netze
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/116)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/116)
In den vorherigen Abschnitten haben wir reichhaltige semantische Darstellungen von Texten und einen einfachen linearen Klassifikator auf den Embeddings verwendet. Was diese Architektur tut, ist, die aggregierte Bedeutung von Wörtern in einem Satz zu erfassen, jedoch berücksichtigt sie nicht die **Reihenfolge** der Wörter, da die Aggregationsoperation über den Embeddings diese Information aus dem ursprünglichen Text entfernt hat. Da diese Modelle nicht in der Lage sind, die Wortreihenfolge zu modellieren, können sie komplexere oder mehrdeutige Aufgaben wie Textgenerierung oder Fragenbeantwortung nicht lösen.
In den vorherigen Abschnitten haben wir reichhaltige semantische Repräsentationen von Text und einen einfachen linearen Klassifikator auf den Einbettungen verwendet. Diese Architektur erfasst die aggregierte Bedeutung der Wörter in einem Satz, berücksichtigt jedoch nicht die **Reihenfolge** der Wörter, da die Aggregationsoperation auf den Einbettungen diese Information aus dem ursprünglichen Text entfernt hat. Da diese Modelle die Wortreihenfolge nicht modellieren können, sind sie nicht in der Lage, komplexere oder mehrdeutige Aufgaben wie Textgenerierung oder Beantwortung von Fragen zu lösen.
Um die Bedeutung einer Textsequenz zu erfassen, müssen wir eine andere Architektur neuronaler Netze verwenden, die als **rekurrentes neuronales Netz** oder RNN bezeichnet wird. Im RNN leiten wir unseren Satz symbolweise durch das Netzwerk, und das Netzwerk erzeugt einen **Zustand**, den wir dann erneut mit dem nächsten Symbol an das Netzwerk übergeben.
Um die Bedeutung einer Textsequenz zu erfassen, müssen wir eine andere Architektur neuronaler Netze verwenden, die als **rekurrentes neuronales Netz** oder RNN bezeichnet wird. Im RNN führen wir unseren Satz ein Symbol nach dem anderen durch das Netzwerk, und das Netzwerk erzeugt einen **Zustand**, den wir dann mit dem nächsten Symbol erneut in das Netzwerk einspeisen.
![RNN](../../../../../translated_images/rnn.27f5c29c53d727b546ad3961637a267f0fe9ec5ab01f2a26a853c92fcefbb574.de.png)
![RNN](../../../../../lessons/5-NLP/16-RNN/images/rnn.png)
> Bild vom Autor
Gegeben die Eingabesequenz von Token X<sub>0</sub>,...,X<sub>n</sub> erstellt das RNN eine Sequenz von neuronalen Netzwerkblöcken und trainiert diese Sequenz End-to-End mithilfe von Rückpropagation. Jeder Netzwerkblock nimmt ein Paar (X<sub>i</sub>,S<sub>i</sub>) als Eingabe und produziert S<sub>i+1</sub> als Ergebnis. Der endgültige Zustand S<sub>n</sub> oder (Ausgabe Y<sub>n</sub>) geht in einen linearen Klassifikator, um das Ergebnis zu produzieren. Alle Netzwerkblöcke teilen sich die gleichen Gewichte und werden End-to-End mit einem Rückpropagationsdurchlauf trainiert.
Angenommen, wir haben eine Eingabesequenz von Token X<sub>0</sub>,...,X<sub>n</sub>, erstellt RNN eine Sequenz von neuronalen Netzwerkblöcken und trainiert diese Sequenz end-to-end mittels Backpropagation. Jeder Netzwerkblock nimmt ein Paar (X<sub>i</sub>,S<sub>i</sub>) als Eingabe und erzeugt S<sub>i+1</sub> als Ergebnis. Der finale Zustand S<sub>n</sub> oder (Ausgabe Y<sub>n</sub>) wird in einen linearen Klassifikator eingespeist, um das Ergebnis zu erzeugen. Alle Netzwerkblöcke teilen sich die gleichen Gewichte und werden end-to-end mit einem Backpropagation-Durchlauf trainiert.
Da Zustandsvektoren S<sub>0</sub>,...,S<sub>n</sub> durch das Netzwerk geleitet werden, ist es in der Lage, die sequentiellen Abhängigkeiten zwischen Wörtern zu lernen. Zum Beispiel, wenn das Wort *not* irgendwo in der Sequenz erscheint, kann es lernen, bestimmte Elemente innerhalb des Zustandsvektors zu negieren, was zu einer Negation führt.
Da die Zustandsvektoren S<sub>0</sub>,...,S<sub>n</sub> durch das Netzwerk weitergegeben werden, kann es die sequentiellen Abhängigkeiten zwischen Wörtern lernen. Zum Beispiel, wenn das Wort *nicht* irgendwo in der Sequenz erscheint, kann es lernen, bestimmte Elemente im Zustandsvektor zu negieren, was zu einer Verneinung führt.
> ✅ Da die Gewichte aller RNN-Blöcke im obigen Bild geteilt werden, kann dasselbe Bild als ein Block (rechts) mit einer rekurrenten Rückkopplungsschleife dargestellt werden, die den Ausgangszustand des Netzwerks zurück an den Eingang übergibt.
> ✅ Da die Gewichte aller RNN-Blöcke im obigen Bild geteilt werden, kann dasselbe Bild als ein Block (rechts) mit einer rekurrenten Rückkopplungsschleife dargestellt werden, die den Ausgabestatus des Netzwerks zurück an die Eingabe weitergibt.
## Anatomie einer RNN-Zelle
Schauen wir uns an, wie eine einfache RNN-Zelle organisiert ist. Sie akzeptiert den vorherigen Zustand S<sub>i-1</sub> und das aktuelle Symbol X<sub>i</sub> als Eingaben und muss den Ausgangszustand S<sub>i</sub> produzieren (und manchmal interessieren wir uns auch für eine andere Ausgabe Y<sub>i</sub>, wie im Fall von generativen Netzwerken).
Schauen wir uns an, wie eine einfache RNN-Zelle organisiert ist. Sie akzeptiert den vorherigen Zustand S<sub>i-1</sub> und das aktuelle Symbol X<sub>i</sub> als Eingaben und muss den Ausgabestatus S<sub>i</sub> erzeugen (und manchmal sind wir auch an einer anderen Ausgabe Y<sub>i</sub> interessiert, wie im Fall von generativen Netzwerken).
Eine einfache RNN-Zelle hat zwei Gewichtsmatrizen: eine transformiert ein Eingabesymbol (nennen wir sie W) und eine andere transformiert einen Eingabestatus (H). In diesem Fall wird der Ausgang des Netzwerks als σ(W×X<sub>i</sub>+H×S<sub>i-1</sub>+b) berechnet, wobei σ die Aktivierungsfunktion ist und b der zusätzliche Bias.
Eine einfache RNN-Zelle hat zwei Gewichtsmatrizen: eine transformiert ein Eingabesymbol (wir nennen sie W), und eine andere transformiert einen Eingabezustand (H). In diesem Fall wird die Ausgabe des Netzwerks als σ(W×X<sub>i</sub>+H×S<sub>i-1</sub>+b) berechnet, wobei σ die Aktivierungsfunktion ist und b ein zusätzlicher Bias.
<img alt="Anatomie einer RNN-Zelle" src="images/rnn-anatomy.png" width="50%"/>
> Bild vom Autor
In vielen Fällen werden Eingabetoken vor dem Eintritt in das RNN durch die Embedding-Schicht geleitet, um die Dimensionalität zu reduzieren. In diesem Fall, wenn die Dimension der Eingangsvektoren *emb_size* beträgt und der Zustandsvektor *hid_size* - die Größe von W ist *emb_size*×*hid_size* und die Größe von H ist *hid_size*×*hid_size*.
In vielen Fällen werden Eingabetoken vor dem Eintritt in das RNN durch die Einbettungsschicht geleitet, um die Dimensionalität zu reduzieren. In diesem Fall, wenn die Dimension der Eingabevektoren *emb_size* ist und der Zustandsvektor *hid_size* ist - beträgt die Größe von W *emb_size*×*hid_size*, und die Größe von H ist *hid_size*×*hid_size*.
## Langzeit-Kurzzeitgedächtnis (LSTM)
## Long Short Term Memory (LSTM)
Eines der Hauptprobleme klassischer RNNs ist das sogenannte **verschwinden der Gradienten**-Problem. Da RNNs End-to-End in einem Rückpropagationsdurchlauf trainiert werden, hat es Schwierigkeiten, den Fehler auf die ersten Schichten des Netzwerks zu propagieren, und daher kann das Netzwerk keine Beziehungen zwischen weit entfernten Token lernen. Eine Möglichkeit, dieses Problem zu vermeiden, besteht darin, eine **explizite Zustandsverwaltung** durch die Verwendung sogenannter **Tore** einzuführen. Es gibt zwei bekannte Architekturen dieser Art: **Langzeit-Kurzzeitgedächtnis** (LSTM) und **Gated Relay Unit** (GRU).
Eines der Hauptprobleme klassischer RNNs ist das sogenannte **Vanishing-Gradients-Problem**. Da RNNs end-to-end in einem Backpropagation-Durchlauf trainiert werden, fällt es ihnen schwer, Fehler an die ersten Schichten des Netzwerks weiterzuleiten, und das Netzwerk kann daher keine Beziehungen zwischen weit entfernten Token lernen. Eine Möglichkeit, dieses Problem zu vermeiden, besteht darin, eine **explizite Zustandsverwaltung** durch sogenannte **Gates** einzuführen. Es gibt zwei bekannte Architekturen dieser Art: **Long Short Term Memory** (LSTM) und **Gated Relay Unit** (GRU).
![Bild, das ein Beispiel für eine Langzeit-Kurzzeitgedächtniszelle zeigt](../../../../../lessons/5-NLP/16-RNN/images/long-short-term-memory-cell.svg)
![Bild eines Beispiels einer Long Short Term Memory-Zelle](../../../../../lessons/5-NLP/16-RNN/images/long-short-term-memory-cell.svg)
> Bildquelle TBD
Das LSTM-Netzwerk ist ähnlich wie das RNN organisiert, aber es gibt zwei Zustände, die von Schicht zu Schicht übergeben werden: den aktuellen Zustand C und den versteckten Vektor H. An jeder Einheit wird der versteckte Vektor H<sub>i</sub> mit dem Eingabevektor X<sub>i</sub> verknüpft, und sie steuern, was mit dem Zustand C über die **Tore** geschieht. Jedes Tor ist ein neuronales Netzwerk mit sigmoidaler Aktivierung (Ausgabe im Bereich [0,1]), das als bitweiser Maske betrachtet werden kann, wenn es mit dem Zustandsvektor multipliziert wird. Es gibt die folgenden Tore (von links nach rechts im obigen Bild):
Das LSTM-Netzwerk ist ähnlich wie ein RNN organisiert, aber es gibt zwei Zustände, die von Schicht zu Schicht weitergegeben werden: den tatsächlichen Zustand C und den versteckten Vektor H. In jeder Einheit wird der versteckte Vektor H<sub>i</sub> mit der Eingabe X<sub>i</sub> verkettet, und sie steuern, was mit dem Zustand C über **Gates** geschieht. Jedes Gate ist ein neuronales Netzwerk mit Sigmoid-Aktivierung (Ausgabe im Bereich [0,1]), das als bitweises Maskieren betrachtet werden kann, wenn es mit dem Zustandsvektor multipliziert wird. Es gibt die folgenden Gates (von links nach rechts im obigen Bild):
* Das **Vergessenstor** nimmt einen versteckten Vektor und bestimmt, welche Komponenten des Vektors C wir vergessen müssen und welche durchgelassen werden sollen.
* Das **Eingangstor** nimmt einige Informationen aus den Eingabe- und versteckten Vektoren und fügt sie in den Zustand ein.
* Das **Ausgangstor** transformiert den Zustand über eine lineare Schicht mit *tanh*-Aktivierung und wählt dann einige seiner Komponenten unter Verwendung eines versteckten Vektors H<sub>i</sub> aus, um einen neuen Zustand C<sub>i+1</sub> zu erzeugen.
* Das **Vergessens-Gate** nimmt einen versteckten Vektor und bestimmt, welche Komponenten des Vektors C wir vergessen und welche wir durchlassen müssen.
* Das **Eingabe-Gate** nimmt einige Informationen aus den Eingabe- und versteckten Vektoren und fügt sie in den Zustand ein.
* Das **Ausgabe-Gate** transformiert den Zustand über eine lineare Schicht mit *tanh*-Aktivierung und wählt dann einige seiner Komponenten mithilfe eines versteckten Vektors H<sub>i</sub> aus, um einen neuen Zustand C<sub>i+1</sub> zu erzeugen.
Die Komponenten des Zustands C können als einige Flags betrachtet werden, die ein- und ausgeschaltet werden können. Wenn wir zum Beispiel im Verlauf der Sequenz auf einen Namen wie *Alice* stoßen, möchten wir vielleicht annehmen, dass es sich um eine weibliche Figur handelt, und das Flag im Zustand erhöhen, dass wir ein weibliches Substantiv im Satz haben. Wenn wir dann auf die Phrasen *und Tom* stoßen, heben wir das Flag, dass wir ein Pluralnoun haben. So können wir durch die Manipulation des Zustands angeblich die grammatikalischen Eigenschaften von Satzteilen im Auge behalten.
Komponenten des Zustands C können als Flags betrachtet werden, die ein- und ausgeschaltet werden können. Zum Beispiel, wenn wir in der Sequenz den Namen *Alice* finden, könnten wir annehmen, dass es sich um eine weibliche Figur handelt, und das Flag im Zustand setzen, dass wir ein weibliches Substantiv im Satz haben. Wenn wir später die Phrase *und Tom* finden, setzen wir das Flag, dass wir ein Plural-Substantiv haben. Durch die Manipulation des Zustands können wir also möglicherweise die grammatikalischen Eigenschaften von Satzteilen verfolgen.
> ✅ Eine hervorragende Ressource zum Verständnis der Interna von LSTM ist dieser großartige Artikel [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) von Christopher Olah.
> ✅ Eine ausgezeichnete Ressource, um die Interna von LSTM zu verstehen, ist dieser großartige Artikel [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) von Christopher Olah.
## Bidirektionale und mehrschichtige RNNs
Wir haben rekurrente Netze besprochen, die in eine Richtung arbeiten, vom Anfang einer Sequenz bis zum Ende. Das wirkt natürlich, da es der Art und Weise ähnelt, wie wir lesen und Sprache hören. Da wir jedoch in vielen praktischen Fällen zufälligen Zugriff auf die Eingabesequenz haben, kann es sinnvoll sein, die rekursive Berechnung in beide Richtungen auszuführen. Solche Netzwerke werden **bidirektionale** RNNs genannt. Bei der Arbeit mit einem bidirektionalen Netzwerk benötigen wir zwei versteckte Zustandsvektoren, einen für jede Richtung.
Wir haben rekurrente Netzwerke besprochen, die in eine Richtung arbeiten, vom Anfang einer Sequenz bis zum Ende. Das erscheint natürlich, da es der Art und Weise ähnelt, wie wir lesen und Sprache hören. Da wir jedoch in vielen praktischen Fällen zufälligen Zugriff auf die Eingabesequenz haben, könnte es sinnvoll sein, die rekurrente Berechnung in beide Richtungen auszuführen. Solche Netzwerke werden als **bidirektionale** RNNs bezeichnet. Bei der Arbeit mit einem bidirektionalen Netzwerk benötigen wir zwei versteckte Zustandsvektoren, einen für jede Richtung.
Ein rekurrentes Netzwerk, ob einseitig oder bidirektional, erfasst bestimmte Muster innerhalb einer Sequenz und kann sie in einem Zustandsvektor speichern oder in die Ausgabe übergeben. Wie bei konvolutionalen Netzwerken können wir eine weitere rekursive Schicht über der ersten aufbauen, um höhere Muster zu erfassen und von den von der ersten Schicht extrahierten niederwertigen Mustern aufzubauen. Dies führt uns zum Begriff eines **mehrschichtigen RNN**, das aus zwei oder mehr rekurrenten Netzwerken besteht, wobei die Ausgabe der vorherigen Schicht als Eingabe an die nächste Schicht übergeben wird.
Ein rekurrentes Netzwerk, sei es eindirektional oder bidirektional, erfasst bestimmte Muster innerhalb einer Sequenz und kann diese in einem Zustandsvektor speichern oder in die Ausgabe weitergeben. Wie bei konvolutionalen Netzwerken können wir eine weitere rekurrente Schicht auf die erste aufbauen, um höherstufige Muster zu erfassen und aus den von der ersten Schicht extrahierten niedrigstufigen Mustern aufzubauen. Dies führt uns zum Konzept eines **mehrschichtigen RNN**, das aus zwei oder mehr rekurrenten Netzwerken besteht, wobei die Ausgabe der vorherigen Schicht als Eingabe an die nächste Schicht weitergegeben wird.
![Bild, das ein mehrschichtiges Langzeit-Kurzzeitgedächtnis-RNN zeigt](../../../../../translated_images/multi-layer-lstm.dd975e29bb2a59fe58b429db833932d734c81f211cad2783797a9608984acb8c.de.jpg)
![Bild eines mehrschichtigen Long-Short-Term-Memory-RNNs](../../../../../lessons/5-NLP/16-RNN/images/multi-layer-lstm.jpg)
*Bild von [diesem wunderbaren Beitrag](https://towardsdatascience.com/from-a-lstm-cell-to-a-multilayer-lstm-network-with-pytorch-2899eb5696f3) von Fernando López*
*Bild aus [diesem wunderbaren Beitrag](https://towardsdatascience.com/from-a-lstm-cell-to-a-multilayer-lstm-network-with-pytorch-2899eb5696f3) von Fernando López*
## ✍️ Übungen: Embeddings
## ✍️ Übungen: Einbettungen
Setze dein Lernen in den folgenden Notebooks fort:
Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
* [RNNs mit PyTorch](../../../../../lessons/5-NLP/16-RNN/RNNPyTorch.ipynb)
* [RNNs mit TensorFlow](../../../../../lessons/5-NLP/16-RNN/RNNTF.ipynb)
## Fazit
In dieser Einheit haben wir gesehen, dass RNNs für die Sequenzklassifizierung verwendet werden können, aber tatsächlich können sie viele weitere Aufgaben bewältigen, wie Textgenerierung, maschinelle Übersetzung und mehr. Diese Aufgaben werden wir in der nächsten Einheit betrachten.
In dieser Einheit haben wir gesehen, dass RNNs für die Sequenzklassifikation verwendet werden können, aber tatsächlich können sie viele weitere Aufgaben bewältigen, wie Textgenerierung, maschinelle Übersetzung und mehr. Diese Aufgaben werden wir in der nächsten Einheit betrachten.
## 🚀 Herausforderung
Lies einige Literatur über LSTMs und ziehe deren Anwendungen in Betracht:
Lesen Sie einige Literatur über LSTMs und überlegen Sie sich deren Anwendungen:
- [Grid Long Short-Term Memory](https://arxiv.org/pdf/1507.01526v1.pdf)
- [Show, Attend and Tell: Neural Image Caption
Generation with Visual Attention](https://arxiv.org/pdf/1502.03044v2.pdf)
## [Nachlesequiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/216)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/216)
## Überprüfung & Selbststudium
## Wiederholung & Selbststudium
- [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) von Christopher Olah.
## [Aufgabe: Notebooks](assignment.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Originalsprache sollte als die 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 Verwendung dieser Übersetzung entstehen.
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.

13
translations/de/lessons/5-NLP/16-RNN/assignment.md
View File

@ -1,6 +1,15 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "47f7d3c6a5373543e051e4d1140ce898",
"translation_date": "2025-08-24T09:30:25+00:00",
"source_file": "lessons/5-NLP/16-RNN/assignment.md",
"language_code": "de"
}
-->
# Aufgabe: Notebooks
Verwenden Sie die mit dieser Lektion verbundenen Notebooks (entweder die PyTorch- oder die TensorFlow-Version), und führen Sie sie erneut mit Ihrem eigenen Datensatz aus, möglicherweise einem von Kaggle, wobei Sie die Quelle angeben. Überarbeiten Sie das Notebook, um Ihre eigenen Erkenntnisse zu betonen. Probieren Sie eine andere Art von Datensatz aus und dokumentieren Sie Ihre Ergebnisse mit Texten wie [diesem Kaggle-Wettbewerbsdatensatz über Wettertweets](https://www.kaggle.com/competitions/crowdflower-weather-twitter/data?select=train.csv).
Verwenden Sie die Notebooks, die mit dieser Lektion verbunden sind (entweder die PyTorch- oder die TensorFlow-Version), und führen Sie sie mit Ihrem eigenen Datensatz erneut aus, möglicherweise einem von Kaggle, unter Angabe der Quelle. Überarbeiten Sie das Notebook, um Ihre eigenen Erkenntnisse hervorzuheben. Probieren Sie eine andere Art von Datensatz aus und dokumentieren Sie Ihre Ergebnisse, beispielsweise mit Text wie [diesem Kaggle-Wettbewerbsdatensatz über Wetter-Tweets](https://www.kaggle.com/competitions/crowdflower-weather-twitter/data?select=train.csv).
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir um Genauigkeit bemüht sind, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

65
translations/de/lessons/5-NLP/17-GenerativeNetworks/README.md
View File

@ -1,31 +1,40 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d9de7847385eeeda67cfdcce1640ab72",
"translation_date": "2025-08-24T09:30:59+00:00",
"source_file": "lessons/5-NLP/17-GenerativeNetworks/README.md",
"language_code": "de"
}
-->
# Generative Netzwerke
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/117)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/117)
Recurrent Neural Networks (RNNs) und ihre gated Cell-Varianten wie Long Short Term Memory Cells (LSTMs) und Gated Recurrent Units (GRUs) bieten einen Mechanismus für das Sprachmodellieren, da sie die Wortreihenfolge lernen und Vorhersagen für das nächste Wort in einer Sequenz machen können. Dies ermöglicht es uns, RNNs für **generative Aufgaben** zu verwenden, wie zum Beispiel die gewöhnliche Textgenerierung, maschinelle Übersetzung und sogar Bildbeschriftung.
Rekurrente Neuronale Netzwerke (RNNs) und ihre Varianten mit Gated Cells wie Long Short Term Memory Cells (LSTMs) und Gated Recurrent Units (GRUs) bieten einen Mechanismus für Sprachmodellierung, da sie die Wortreihenfolge lernen und Vorhersagen für das nächste Wort in einer Sequenz treffen können. Dies ermöglicht es uns, RNNs für **generative Aufgaben** zu nutzen, wie z. B. die Generierung von gewöhnlichem Text, maschinelle Übersetzung und sogar Bildbeschreibungen.
> ✅ Denk darüber nach, wie oft du von generativen Aufgaben wie der Textvervollständigung beim Tippen profitiert hast. Recherchiere deine Lieblingsanwendungen, um zu sehen, ob sie RNNs genutzt haben.
> ✅ Denke an all die Male, in denen du von generativen Aufgaben wie der automatischen Textvervollständigung profitiert hast. Recherchiere zu deinen Lieblingsanwendungen, um herauszufinden, ob sie RNNs verwendet haben.
In der RNN-Architektur, die wir in der vorherigen Einheit besprochen haben, erzeugte jede RNN-Einheit den nächsten verborgenen Zustand als Ausgabe. Wir können jedoch auch eine weitere Ausgabe zu jeder rekurrenten Einheit hinzufügen, die es uns ermöglichen würde, eine **Sequenz** auszugeben (die in der Länge der ursprünglichen Sequenz entspricht). Darüber hinaus können wir RNN-Einheiten verwenden, die nicht bei jedem Schritt eine Eingabe akzeptieren, sondern einfach einen anfänglichen Zustandsvektor nehmen und dann eine Sequenz von Ausgaben erzeugen.
In der RNN-Architektur, die wir in der vorherigen Einheit besprochen haben, erzeugte jede RNN-Einheit den nächsten versteckten Zustand als Ausgabe. Wir können jedoch auch eine weitere Ausgabe zu jeder rekurrenten Einheit hinzufügen, die es uns ermöglicht, eine **Sequenz** auszugeben (die genauso lang ist wie die ursprüngliche Sequenz). Darüber hinaus können wir RNN-Einheiten verwenden, die bei jedem Schritt keine Eingabe akzeptieren, sondern nur einen anfänglichen Zustandsvektor aufnehmen und dann eine Sequenz von Ausgaben erzeugen.
Dies ermöglicht verschiedene neuronale Architekturen, die im Bild unten gezeigt sind:
Dies ermöglicht verschiedene neuronale Architekturen, die im folgenden Bild dargestellt sind:
![Bild, das gängige Muster rekurrenter neuronaler Netzwerke zeigt.](../../../../../translated_images/unreasonable-effectiveness-of-rnn.541ead816778f42dce6c42d8a56c184729aa2378d059b851be4ce12b993033df.de.jpg)
![Bild, das gängige Muster von rekurrenten neuronalen Netzwerken zeigt.](../../../../../lessons/5-NLP/17-GenerativeNetworks/images/unreasonable-effectiveness-of-rnn.jpg)
> Bild aus dem Blogbeitrag [Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) von [Andrej Karpaty](http://karpathy.github.io/)
> Bild aus dem Blogpost [Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) von [Andrej Karpaty](http://karpathy.github.io/)
* **Eins-zu-eins** ist ein traditionelles neuronales Netzwerk mit einer Eingabe und einer Ausgabe
* **Eins-zu-viele** ist eine generative Architektur, die einen Eingabewert akzeptiert und eine Sequenz von Ausgabewerten erzeugt. Wenn wir beispielsweise ein **Bildbeschriftungs**-Netzwerk trainieren möchten, das eine textuelle Beschreibung eines Bildes erzeugt, können wir ein Bild als Eingabe nehmen, es durch ein CNN leiten, um seinen verborgenen Zustand zu erhalten, und dann eine rekursive Kette verwenden, um die Beschriftung Wort für Wort zu generieren
* **Viele-zu-eins** entspricht den RNN-Architekturen, die wir in der vorherigen Einheit beschrieben haben, wie z.B. der Textklassifikation
* **Viele-zu-viele**, oder **Sequenz-zu-Sequenz**, entspricht Aufgaben wie **maschineller Übersetzung**, bei denen wir zuerst ein RNN haben, das alle Informationen aus der Eingabesequenz in den verborgenen Zustand aufnimmt, und eine andere RNN-Kette diesen Zustand in die Ausgabesequenz entrollt.
* **One-to-one** ist ein traditionelles neuronales Netzwerk mit einer Eingabe und einer Ausgabe.
* **One-to-many** ist eine generative Architektur, die einen Eingabewert akzeptiert und eine Sequenz von Ausgabewerten erzeugt. Zum Beispiel, wenn wir ein **Bildbeschreibungsnetzwerk** trainieren möchten, das eine textuelle Beschreibung eines Bildes erzeugt, können wir ein Bild als Eingabe verwenden, es durch ein CNN leiten, um seinen versteckten Zustand zu erhalten, und dann eine rekurrente Kette Wort für Wort die Beschreibung generieren lassen.
* **Many-to-one** entspricht den RNN-Architekturen, die wir in der vorherigen Einheit beschrieben haben, wie z. B. Textklassifikation.
* **Many-to-many**, oder **Sequenz-zu-Sequenz**, entspricht Aufgaben wie der **maschinellen Übersetzung**, bei der ein erstes RNN alle Informationen aus der Eingabesequenz in den versteckten Zustand sammelt und eine andere RNN-Kette diesen Zustand in die Ausgabesequenz entfaltet.
In dieser Einheit werden wir uns auf einfache generative Modelle konzentrieren, die uns helfen, Text zu generieren. Zur Vereinfachung verwenden wir die Zeichenebene Tokenisierung.
In dieser Einheit konzentrieren wir uns auf einfache generative Modelle, die uns helfen, Text zu generieren. Der Einfachheit halber verwenden wir eine Tokenisierung auf Zeichenebene.
Wir werden dieses RNN trainieren, um Text Schritt für Schritt zu generieren. Bei jedem Schritt nehmen wir eine Sequenz von Zeichen der Länge `nchars` und bitten das Netzwerk, das nächste Ausgabesymbol für jedes Eingabesymbol zu generieren:
Wir werden dieses RNN trainieren, um Text Schritt für Schritt zu generieren. Bei jedem Schritt nehmen wir eine Zeichenfolge der Länge `nchars` und lassen das Netzwerk das nächste Zeichen für jedes Eingabezeichen generieren:
![Bild, das ein Beispiel für die RNN-Generierung des Wortes 'HELLO' zeigt.](../../../../../translated_images/rnn-generate.56c54afb52f9781d63a7c16ea9c1b86cb70e6e1eae6a742b56b7b37468576b17.de.png)
![Bild, das ein Beispiel für die RNN-Generierung des Wortes 'HELLO' zeigt.](../../../../../lessons/5-NLP/17-GenerativeNetworks/images/rnn-generate.png)
Beim Generieren von Text (während der Inferenz) beginnen wir mit einem **Prompt**, der durch RNN-Zellen geleitet wird, um seinen Zwischenzustand zu erzeugen, und dann beginnt die Generierung von diesem Zustand. Wir generieren ein Zeichen nach dem anderen und übergeben den Zustand und das generierte Zeichen an eine andere RNN-Zelle, um das nächste zu generieren, bis wir genügend Zeichen generiert haben.
Beim Generieren von Text (während der Inferenz) beginnen wir mit einem **Prompt**, der durch die RNN-Zellen geleitet wird, um seinen Zwischenzustand zu erzeugen. Von diesem Zustand aus beginnt die Generierung. Wir generieren ein Zeichen nach dem anderen und übergeben den Zustand und das generierte Zeichen an eine weitere RNN-Zelle, um das nächste zu generieren, bis wir genügend Zeichen erzeugt haben.
<img src="images/rnn-generate-inf.png" width="60%"/>
@ -38,42 +47,42 @@ Setze dein Lernen in den folgenden Notebooks fort:
* [Generative Netzwerke mit PyTorch](../../../../../lessons/5-NLP/17-GenerativeNetworks/GenerativePyTorch.ipynb)
* [Generative Netzwerke mit TensorFlow](../../../../../lessons/5-NLP/17-GenerativeNetworks/GenerativeTF.ipynb)
## Sanfte Textgenerierung und Temperatur
## Weiche Textgenerierung und Temperatur
Die Ausgabe jeder RNN-Zelle ist eine Wahrscheinlichkeitsverteilung von Zeichen. Wenn wir immer das Zeichen mit der höchsten Wahrscheinlichkeit als nächstes Zeichen im generierten Text nehmen, kann der Text oft zwischen denselben Zeichenfolgen "zyklisch" werden, wie in diesem Beispiel:
Die Ausgabe jeder RNN-Zelle ist eine Wahrscheinlichkeitsverteilung von Zeichen. Wenn wir immer das Zeichen mit der höchsten Wahrscheinlichkeit als nächstes Zeichen im generierten Text auswählen, kann der Text oft in "Schleifen" geraten, in denen sich dieselben Zeichenfolgen immer wiederholen, wie in diesem Beispiel:
```
today of the second the company and a second the company ...
```
Wenn wir jedoch die Wahrscheinlichkeitsverteilung für das nächste Zeichen betrachten, könnte es sein, dass der Unterschied zwischen den höchsten Wahrscheinlichkeiten nicht groß ist, z.B. könnte ein Zeichen eine Wahrscheinlichkeit von 0.2 haben, ein anderes - 0.19, usw. Wenn wir nach dem nächsten Zeichen in der Sequenz '*play*' suchen, könnte das nächste Zeichen ebenso gut ein Leerzeichen oder **e** (wie im Wort *player*) sein.
Wenn wir jedoch die Wahrscheinlichkeitsverteilung für das nächste Zeichen betrachten, könnte es sein, dass der Unterschied zwischen den höchsten Wahrscheinlichkeiten nicht groß ist, z. B. könnte ein Zeichen eine Wahrscheinlichkeit von 0,2 haben, ein anderes 0,19 usw. Zum Beispiel könnte das nächste Zeichen in der Sequenz '*play*' genauso gut ein Leerzeichen oder ein **e** sein (wie im Wort *player*).
Dies führt uns zu dem Schluss, dass es nicht immer "fair" ist, das Zeichen mit der höheren Wahrscheinlichkeit auszuwählen, da die Wahl des zweithöchsten uns immer noch zu bedeutungsvollem Text führen könnte. Es ist klüger, Zeichen aus der Wahrscheinlichkeitsverteilung zu **sample**n, die durch die Netzwerkausgabe gegeben wird. Wir können auch einen Parameter, **Temperatur**, verwenden, der die Wahrscheinlichkeitsverteilung abflacht, falls wir mehr Zufälligkeit hinzufügen möchten, oder sie steiler machen, wenn wir uns mehr an den Zeichen mit der höchsten Wahrscheinlichkeit orientieren möchten.
Das führt uns zu der Erkenntnis, dass es nicht immer "fair" ist, das Zeichen mit der höchsten Wahrscheinlichkeit auszuwählen, da die Wahl des zweitwahrscheinlichsten Zeichens dennoch zu sinnvollem Text führen könnte. Es ist klüger, Zeichen aus der Wahrscheinlichkeitsverteilung zu **samplen**, die durch die Netzwerkausgabe gegeben ist. Wir können auch einen Parameter, die **Temperatur**, verwenden, um die Wahrscheinlichkeitsverteilung abzuflachen, falls wir mehr Zufälligkeit hinzufügen möchten, oder sie steiler machen, wenn wir uns stärker an die Zeichen mit der höchsten Wahrscheinlichkeit halten wollen.
Erforsche, wie diese sanfte Textgenerierung in den oben verlinkten Notebooks implementiert ist.
Erforsche, wie diese weiche Textgenerierung in den oben verlinkten Notebooks implementiert ist.
## Fazit
Obwohl die Textgenerierung an sich nützlich sein kann, kommen die größten Vorteile von der Fähigkeit, Text mithilfe von RNNs aus einem anfänglichen Merkmalsvektor zu generieren. Zum Beispiel wird die Textgenerierung als Teil der maschinellen Übersetzung verwendet (Sequenz-zu-Sequenz, in diesem Fall wird der Zustandsvektor aus dem *Encoder* verwendet, um die übersetzte Nachricht zu generieren oder *zu dekodieren*), oder um eine textuelle Beschreibung eines Bildes zu erzeugen (in diesem Fall würde der Merkmalsvektor aus dem CNN-Extractor stammen).
Während die Textgenerierung an sich nützlich sein kann, liegen die Hauptvorteile in der Fähigkeit, Text mit RNNs aus einem anfänglichen Merkmalsvektor zu generieren. Zum Beispiel wird die Textgenerierung als Teil der maschinellen Übersetzung verwendet (Sequenz-zu-Sequenz, in diesem Fall wird der Zustandsvektor des *Encoders* verwendet, um die übersetzte Nachricht zu generieren oder zu *decodieren*), oder um eine textuelle Beschreibung eines Bildes zu erzeugen (in diesem Fall würde der Merkmalsvektor aus einem CNN-Extraktor stammen).
## 🚀 Herausforderung
Nehmt an einigen Lektionen auf Microsoft Learn zu diesem Thema teil
Nimm an einigen Lektionen auf Microsoft Learn zu diesem Thema teil:
* Textgenerierung mit [PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/6-generative-networks/?WT.mc_id=academic-77998-cacaste)/[TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/5-generative-networks/?WT.mc_id=academic-77998-cacaste)
## [Nachlesequiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/217)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/217)
## Überprüfung & Selbststudium
## Rückblick & Selbststudium
Hier sind einige Artikel, um dein Wissen zu erweitern
Hier sind einige Artikel, um dein Wissen zu erweitern:
* Verschiedene Ansätze zur Textgenerierung mit Markov-Kette, LSTM und GPT-2: [Blogbeitrag](https://towardsdatascience.com/text-generation-gpt-2-lstm-markov-chain-9ea371820e1e)
* Textgenerierungsbeispiel in der [Keras-Dokumentation](https://keras.io/examples/generative/lstm_character_level_text_generation/)
* Verschiedene Ansätze zur Textgenerierung mit Markov-Ketten, LSTM und GPT-2: [Blogpost](https://towardsdatascience.com/text-generation-gpt-2-lstm-markov-chain-9ea371820e1e)
* Beispiel zur Textgenerierung in der [Keras-Dokumentation](https://keras.io/examples/generative/lstm_character_level_text_generation/)
## [Aufgabe](lab/README.md)
Wir haben gesehen, wie man Text Zeichen für Zeichen generiert. Im Labor wirst du die Textgenerierung auf Wortebene erkunden.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

15
translations/de/lessons/5-NLP/17-GenerativeNetworks/lab/README.md
View File

@ -1,14 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "439e12796197a90e7623d4c9c057b9c2",
"translation_date": "2025-08-24T09:31:22+00:00",
"source_file": "lessons/5-NLP/17-GenerativeNetworks/lab/README.md",
"language_code": "de"
}
-->
# Wortbasierte Textgenerierung mit RNNs
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
In diesem Labor müssen Sie ein beliebiges Buch auswählen und es als Datensatz verwenden, um einen wortbasierten Textgenerator zu trainieren.
In diesem Labor sollen Sie ein beliebiges Buch verwenden und es als Datensatz nutzen, um einen wortbasierten Textgenerator zu trainieren.
## Der Datensatz
Sie können jedes Buch verwenden. Sie finden viele kostenlose Texte auf [Project Gutenberg](https://www.gutenberg.org/). Zum Beispiel, hier ist ein direkter Link zu [Alice's Adventures in Wonderland](https://www.gutenberg.org/files/11/11-0.txt) von Lewis Carroll.
Sie können jedes beliebige Buch verwenden. Viele kostenlose Texte finden Sie bei [Project Gutenberg](https://www.gutenberg.org/), zum Beispiel gibt es hier einen direkten Link zu [Alice's Adventures in Wonderland](https://www.gutenberg.org/files/11/11-0.txt)) von Lewis Carroll.
**Haftungsausschluss**:
Dieses Dokument wurde mit Hilfe von maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung entstehen.
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.

121
translations/de/lessons/5-NLP/18-Transformers/README.md Normal file
View File

@ -0,0 +1,121 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7e617f0b8de85a43957a853aba09bfeb",
"translation_date": "2025-08-24T10:18:00+00:00",
"source_file": "lessons/5-NLP/18-Transformers/README.md",
"language_code": "de"
}
-->
# Aufmerksamkeitsmechanismen und Transformer
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/118)
Eines der wichtigsten Probleme im Bereich der NLP ist die **maschinelle Übersetzung**, eine wesentliche Aufgabe, die Tools wie Google Translate zugrunde liegt. In diesem Abschnitt konzentrieren wir uns auf die maschinelle Übersetzung oder allgemeiner auf jede *Sequence-to-Sequence*-Aufgabe (auch **Satztransduktion** genannt).
Mit RNNs wird Sequence-to-Sequence durch zwei rekurrente Netzwerke implementiert, wobei ein Netzwerk, der **Encoder**, eine Eingabesequenz in einen versteckten Zustand zusammenfasst, während ein anderes Netzwerk, der **Decoder**, diesen versteckten Zustand in ein übersetztes Ergebnis entfaltet. Es gibt jedoch einige Probleme bei diesem Ansatz:
* Der Endzustand des Encoder-Netzwerks hat Schwierigkeiten, sich an den Anfang eines Satzes zu erinnern, was zu einer schlechten Modellqualität bei langen Sätzen führt.
* Alle Wörter in einer Sequenz haben den gleichen Einfluss auf das Ergebnis. In der Realität haben jedoch bestimmte Wörter in der Eingabesequenz oft mehr Einfluss auf die sequentiellen Ausgaben als andere.
**Aufmerksamkeitsmechanismen** bieten eine Möglichkeit, den kontextuellen Einfluss jedes Eingabevektors auf jede Ausgabewahrscheinlichkeit des RNN zu gewichten. Dies wird durch die Erstellung von Abkürzungen zwischen den Zwischenzuständen des Eingabe-RNN und des Ausgabe-RNN umgesetzt. Auf diese Weise berücksichtigen wir bei der Generierung des Ausgabesymbols y<sub>t</sub> alle versteckten Eingabezustände h<sub>i</sub>, mit unterschiedlichen Gewichtungskoeffizienten α<sub>t,i</sub>.
![Bild eines Encoder/Decoder-Modells mit einer additiven Aufmerksamkeits-Schicht](../../../../../lessons/5-NLP/18-Transformers/images/encoder-decoder-attention.png)
> Das Encoder-Decoder-Modell mit additivem Aufmerksamkeitsmechanismus aus [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf), zitiert aus [diesem Blogbeitrag](https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html)
Die Aufmerksamkeitsmatrix {α<sub>i,j</sub>} würde den Grad darstellen, in dem bestimmte Eingabewörter bei der Generierung eines bestimmten Wortes in der Ausgabesequenz eine Rolle spielen. Unten ist ein Beispiel für eine solche Matrix:
![Bild eines Beispiel-Alignments, gefunden von RNNsearch-50, entnommen aus Bahdanau - arviz.org](../../../../../lessons/5-NLP/18-Transformers/images/bahdanau-fig3.png)
> Abbildung aus [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf) (Fig.3)
Aufmerksamkeitsmechanismen sind verantwortlich für viele der aktuellen oder nahezu aktuellen Spitzenleistungen in der NLP. Das Hinzufügen von Aufmerksamkeit erhöht jedoch die Anzahl der Modellparameter erheblich, was zu Skalierungsproblemen mit RNNs führte. Eine wichtige Einschränkung bei der Skalierung von RNNs ist, dass die rekurrente Natur der Modelle es schwierig macht, das Training zu batchen und zu parallelisieren. In einem RNN muss jedes Element einer Sequenz in der Reihenfolge verarbeitet werden, was bedeutet, dass es nicht leicht parallelisiert werden kann.
![Encoder Decoder mit Aufmerksamkeit](../../../../../lessons/5-NLP/18-Transformers/images/EncDecAttention.gif)
> Abbildung aus [Googles Blog](https://research.googleblog.com/2016/09/a-neural-network-for-machine.html)
Die Einführung von Aufmerksamkeitsmechanismen in Kombination mit dieser Einschränkung führte zur Entwicklung der heute bekannten und genutzten Transformer-Modelle wie BERT und Open-GPT3, die den aktuellen Stand der Technik darstellen.
## Transformer-Modelle
Eine der Hauptideen hinter Transformern ist es, die sequentielle Natur von RNNs zu vermeiden und ein Modell zu schaffen, das während des Trainings parallelisierbar ist. Dies wird durch die Implementierung von zwei Ideen erreicht:
* Positionskodierung
* Verwendung des Selbstaufmerksamkeitsmechanismus, um Muster zu erfassen, anstatt RNNs (oder CNNs) zu verwenden (deshalb heißt das Papier, das Transformer einführt, *[Attention is all you need](https://arxiv.org/abs/1706.03762)*).
### Positionskodierung/-einbettung
Die Idee der Positionskodierung ist folgende:
1. Bei der Verwendung von RNNs wird die relative Position der Tokens durch die Anzahl der Schritte dargestellt und muss daher nicht explizit dargestellt werden.
2. Sobald wir jedoch zu Aufmerksamkeit wechseln, müssen wir die relativen Positionen der Tokens innerhalb einer Sequenz kennen.
3. Um Positionskodierung zu erhalten, ergänzen wir unsere Sequenz von Tokens mit einer Sequenz von Token-Positionen in der Sequenz (d.h. einer Sequenz von Zahlen 0,1, ...).
4. Wir mischen dann die Token-Position mit einem Token-Einbettungsvektor. Um die Position (Ganzzahl) in einen Vektor zu transformieren, können wir verschiedene Ansätze verwenden:
* Trainierbare Einbettung, ähnlich wie Token-Einbettung. Dies ist der Ansatz, den wir hier betrachten. Wir wenden Einbettungsschichten sowohl auf Tokens als auch auf ihre Positionen an, was zu Einbettungsvektoren derselben Dimensionen führt, die wir dann zusammen addieren.
* Feste Positionskodierungsfunktion, wie im ursprünglichen Papier vorgeschlagen.
<img src="images/pos-embedding.png" width="50%"/>
> Bild vom Autor
Das Ergebnis, das wir mit Positionskodierung erhalten, bettet sowohl das ursprüngliche Token als auch seine Position innerhalb einer Sequenz ein.
### Multi-Head Selbstaufmerksamkeit
Als Nächstes müssen wir einige Muster innerhalb unserer Sequenz erfassen. Um dies zu tun, verwenden Transformer einen **Selbstaufmerksamkeitsmechanismus**, der im Wesentlichen Aufmerksamkeit ist, die auf dieselbe Sequenz als Eingabe und Ausgabe angewendet wird. Die Anwendung von Selbstaufmerksamkeit ermöglicht es uns, den **Kontext** innerhalb des Satzes zu berücksichtigen und zu sehen, welche Wörter miteinander in Beziehung stehen. Zum Beispiel ermöglicht es uns zu sehen, welche Wörter durch Koreferenzen wie *es* referenziert werden, und auch den Kontext zu berücksichtigen:
![](../../../../../lessons/5-NLP/18-Transformers/images/CoreferenceResolution.png)
> Bild aus dem [Google Blog](https://research.googleblog.com/2017/08/transformer-novel-neural-network.html)
In Transformern verwenden wir **Multi-Head Attention**, um dem Netzwerk die Fähigkeit zu geben, verschiedene Arten von Abhängigkeiten zu erfassen, z. B. langfristige vs. kurzfristige Wortbeziehungen, Koreferenz vs. etwas anderes usw.
[TensorFlow Notebook](../../../../../lessons/5-NLP/18-Transformers/TransformersTF.ipynb) enthält weitere Details zur Implementierung von Transformer-Schichten.
### Encoder-Decoder Aufmerksamkeit
In Transformern wird Aufmerksamkeit an zwei Stellen verwendet:
* Um Muster innerhalb des Eingabetextes mit Selbstaufmerksamkeit zu erfassen
* Um Sequenzübersetzung durchzuführen - dies ist die Aufmerksamkeits-Schicht zwischen Encoder und Decoder.
Encoder-Decoder Aufmerksamkeit ist der Aufmerksamkeitsmechanismus, der in RNNs verwendet wird, wie zu Beginn dieses Abschnitts beschrieben. Dieses animierte Diagramm erklärt die Rolle der Encoder-Decoder Aufmerksamkeit.
![Animiertes GIF, das zeigt, wie die Bewertungen in Transformer-Modellen durchgeführt werden.](../../../../../lessons/5-NLP/18-Transformers/images/transformer-animated-explanation.gif)
Da jede Eingabeposition unabhängig auf jede Ausgabeposition abgebildet wird, können Transformer besser parallelisieren als RNNs, was viel größere und ausdrucksstärkere Sprachmodelle ermöglicht. Jeder Aufmerksamkeitskopf kann verwendet werden, um verschiedene Beziehungen zwischen Wörtern zu lernen, was die nachgelagerten Aufgaben der natürlichen Sprachverarbeitung verbessert.
## BERT
**BERT** (Bidirectional Encoder Representations from Transformers) ist ein sehr großes mehrschichtiges Transformer-Netzwerk mit 12 Schichten für *BERT-base* und 24 für *BERT-large*. Das Modell wird zunächst auf einem großen Textkorpus (Wikipedia + Bücher) mit unüberwachtem Training (Vorhersage maskierter Wörter in einem Satz) vortrainiert. Während des Vortrainings absorbiert das Modell signifikante Sprachverständnisfähigkeiten, die dann mit anderen Datensätzen durch Feinabstimmung genutzt werden können. Dieser Prozess wird als **Transfer Learning** bezeichnet.
![Bild von http://jalammar.github.io/illustrated-bert/](../../../../../lessons/5-NLP/18-Transformers/images/jalammarBERT-language-modeling-masked-lm.png)
> Bild [Quelle](http://jalammar.github.io/illustrated-bert/)
## ✍️ Übungen: Transformer
Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
* [Transformer in PyTorch](../../../../../lessons/5-NLP/18-Transformers/TransformersPyTorch.ipynb)
* [Transformer in TensorFlow](../../../../../lessons/5-NLP/18-Transformers/TransformersTF.ipynb)
## Fazit
In dieser Lektion haben Sie Transformer und Aufmerksamkeitsmechanismen kennengelernt, die wesentliche Werkzeuge im NLP-Werkzeugkasten sind. Es gibt viele Variationen von Transformer-Architekturen, darunter BERT, DistilBERT, BigBird, OpenGPT3 und mehr, die fein abgestimmt werden können. Das [HuggingFace-Paket](https://github.com/huggingface/) bietet ein Repository für das Training vieler dieser Architekturen mit sowohl PyTorch als auch TensorFlow.
## 🚀 Herausforderung
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/218)
## Überprüfung & Selbststudium
* [Blogbeitrag](https://mchromiak.github.io/articles/2017/Sep/12/Transformer-Attention-is-all-you-need/), der das klassische [Attention is all you need](https://arxiv.org/abs/1706.03762)-Papier über Transformer erklärt.
* [Eine Serie von Blogbeiträgen](https://towardsdatascience.com/transformers-explained-visually-part-1-overview-of-functionality-95a6dd460452) über Transformer, die die Architektur im Detail erklären.
## [Aufgabe](assignment.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.

15
translations/de/lessons/5-NLP/18-Transformers/assignment.md
View File

@ -1,6 +1,15 @@
# Aufgabe: Transformer
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "177f3ea3995d725e6f9f5c66af16edcd",
"translation_date": "2025-08-24T09:32:15+00:00",
"source_file": "lessons/5-NLP/18-Transformers/assignment.md",
"language_code": "de"
}
-->
# Aufgabe: Transformers
Experimentiere mit Transformers auf HuggingFace! Probiere einige der Skripte aus, die sie bereitstellen, um mit den verschiedenen Modellen zu arbeiten, die auf ihrer Seite verfügbar sind: https://huggingface.co/docs/transformers/run_scripts. Teste einen ihrer Datensätze, importiere dann einen eigenen aus diesem Lehrplan oder von Kaggle und schaue, ob du interessante Texte generieren kannst. Erstelle ein Notizbuch mit deinen Ergebnissen.
Experimentiere mit Transformers auf HuggingFace! Probiere einige der Skripte aus, die sie bereitstellen, um mit den verschiedenen Modellen auf ihrer Website zu arbeiten: https://huggingface.co/docs/transformers/run_scripts. Teste eines ihrer Datensätze, importiere dann einen eigenen aus diesem Lehrplan oder von Kaggle und schau, ob du interessante Texte generieren kannst. Erstelle ein Notebook mit deinen Ergebnissen.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die 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 Verwendung dieser Übersetzung resultieren.
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.

62
translations/de/lessons/5-NLP/19-NER/README.md
View File

@ -1,28 +1,37 @@
# Benannte Entitätenerkennung
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "bd10f434e444bce61b7f97eeb1ff6a55",
"translation_date": "2025-08-24T09:32:21+00:00",
"source_file": "lessons/5-NLP/19-NER/README.md",
"language_code": "de"
}
-->
# Erkennung benannter Entitäten
Bis jetzt haben wir uns hauptsächlich auf eine NLP-Aufgabe - Klassifikation - konzentriert. Es gibt jedoch auch andere NLP-Aufgaben, die mit neuronalen Netzwerken durchgeführt werden können. Eine dieser Aufgaben ist die **[Benannte Entitätenerkennung](https://wikipedia.org/wiki/Named-entity_recognition)** (NER), die sich mit der Erkennung spezifischer Entitäten innerhalb von Texten befasst, wie z.B. Orte, Personennamen, Zeiträume, chemische Formeln und so weiter.
Bis jetzt haben wir uns hauptsächlich auf eine NLP-Aufgabe konzentriert – die Klassifikation. Es gibt jedoch auch andere NLP-Aufgaben, die mit neuronalen Netzwerken gelöst werden können. Eine dieser Aufgaben ist die **[Erkennung benannter Entitäten](https://wikipedia.org/wiki/Named-entity_recognition)** (NER), bei der spezifische Entitäten im Text erkannt werden, wie z. B. Orte, Personennamen, Datums- und Zeitangaben, chemische Formeln und vieles mehr.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/119)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/119)
## Beispiel für die Verwendung von NER
Angenommen, Sie möchten einen Chatbot für natürliche Sprache entwickeln, ähnlich wie Amazon Alexa oder Google Assistant. Die Funktionsweise intelligenter Chatbots besteht darin, zu *verstehen*, was der Benutzer möchte, indem sie eine Textklassifikation auf dem eingegebenen Satz durchführen. Das Ergebnis dieser Klassifikation ist die sogenannte **Intention**, die bestimmt, was ein Chatbot tun sollte.
Angenommen, Sie möchten einen Chatbot für natürliche Sprache entwickeln, ähnlich wie Amazon Alexa oder Google Assistant. Intelligente Chatbots funktionieren, indem sie *verstehen*, was der Benutzer möchte, indem sie eine Textklassifikation auf den Eingabesatz anwenden. Das Ergebnis dieser Klassifikation ist die sogenannte **Intention**, die bestimmt, was der Chatbot tun soll.
<img alt="Bot NER" src="images/bot-ner.png" width="50%"/>
> Bild vom Autor
Ein Benutzer kann jedoch einige Parameter als Teil des Satzes angeben. Wenn sie beispielsweise nach dem Wetter fragt, kann sie einen Ort oder ein Datum angeben. Ein Bot sollte in der Lage sein, diese Entitäten zu verstehen und die Parameter entsprechend auszufüllen, bevor er die Aktion ausführt. Genau hier kommt NER ins Spiel.
Ein Benutzer könnte jedoch einige Parameter als Teil der Phrase angeben. Wenn er beispielsweise nach dem Wetter fragt, könnte er einen Ort oder ein Datum angeben. Ein Bot sollte in der Lage sein, diese Entitäten zu verstehen und die Parameter entsprechend auszufüllen, bevor er die Aktion ausführt. Genau hier kommt NER ins Spiel.
> ✅ Ein weiteres Beispiel wäre [die Analyse wissenschaftlicher medizinischer Arbeiten](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Eine der Hauptsachen, auf die wir achten müssen, sind spezifische medizinische Begriffe, wie Krankheiten und medizinische Substanzen. Während eine kleine Anzahl von Krankheiten wahrscheinlich mit Substring-Suche extrahiert werden kann, erfordern komplexere Entitäten, wie chemische Verbindungen und Medikamentennamen, einen komplexeren Ansatz.
> ✅ Ein weiteres Beispiel wäre [die Analyse wissenschaftlicher medizinischer Artikel](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Eine der Hauptaufgaben besteht darin, spezifische medizinische Begriffe wie Krankheiten und medizinische Substanzen zu identifizieren. Während eine kleine Anzahl von Krankheiten wahrscheinlich durch Substring-Suche extrahiert werden kann, erfordern komplexere Entitäten wie chemische Verbindungen und Medikamentennamen einen komplexeren Ansatz.
## NER als Token-Klassifikation
NER-Modelle sind im Wesentlichen **Token-Klassifikationsmodelle**, da wir für jedes der Eingabetokens entscheiden müssen, ob es zu einer Entität gehört oder nicht, und wenn ja - zu welcher Entitätsklasse.
NER-Modelle sind im Wesentlichen **Token-Klassifikationsmodelle**, da wir für jedes Eingabetoken entscheiden müssen, ob es zu einer Entität gehört oder nicht, und falls ja, zu welcher Entitätsklasse.
Betrachten Sie den folgenden Titel einer Arbeit:
Betrachten wir den folgenden Titel eines Artikels:
**Trikuspidalklappeninsuffizienz** und **Lithiumcarbonat** **Toxizität** bei einem Neugeborenen.
**Trikuspidalklappeninsuffizienz** und **Lithiumcarbonat**-**Toxizität** bei einem Neugeborenen.
Die Entitäten hier sind:
@ -30,55 +39,54 @@ Die Entitäten hier sind:
* Lithiumcarbonat ist eine chemische Substanz (`CHEM`)
* Toxizität ist ebenfalls eine Krankheit (`DIS`)
Beachten Sie, dass eine Entität mehrere Tokens umfassen kann. Und, wie in diesem Fall, müssen wir zwischen zwei aufeinanderfolgenden Entitäten unterscheiden. Daher ist es üblich, zwei Klassen für jede Entität zu verwenden - eine, die das erste Token der Entität angibt (häufig wird das `B-`-Präfix verwendet, für **b**eginning), und eine andere - die Fortsetzung einer Entität (`I-`, für **i**nner token). Wir verwenden auch `O` als Klasse, um alle **o**ther Tokens darzustellen. Solches Token-Tagging wird als [BIO-Tagging](https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)) (oder IOB) bezeichnet. Wenn wir unseren Titel taggen, sieht er folgendermaßen aus:
Beachten Sie, dass eine Entität aus mehreren Tokens bestehen kann. Und wie in diesem Fall müssen wir zwischen zwei aufeinanderfolgenden Entitäten unterscheiden. Daher ist es üblich, zwei Klassen für jede Entität zu verwenden – eine, die das erste Token der Entität angibt (oft wird das Präfix `B-` für **b**eginning verwendet), und eine andere für die Fortsetzung einer Entität (`I-`, für **i**nner Token). Wir verwenden auch `O` als Klasse, um alle **o**ther Tokens darzustellen. Diese Token-Kennzeichnung wird als [BIO-Tagging](https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)) (oder IOB) bezeichnet. Nach der Kennzeichnung sieht unser Titel so aus:
Token | Tag
------|-----
Trikuspidal | B-DIS
klappe | I-DIS
Trikuspidalklappen | B-DIS
insuffizienz | I-DIS
und | O
lithium | B-CHEM
Lithium | B-CHEM
carbonat | I-CHEM
toxizität | B-DIS
Toxizität | B-DIS
bei | O
einem | O
neugeborenen | O
Neugeborenen | O
. | O
Da wir eine Eins-zu-eins-Zuordnung zwischen Tokens und Klassen herstellen müssen, können wir ein rechtsseitiges **viele-zu-viele** neuronales Netzwerkmodell aus diesem Bild trainieren:
Da wir eine Eins-zu-eins-Korrespondenz zwischen Tokens und Klassen herstellen müssen, können wir ein **many-to-many**-neuronales Netzwerkmodell wie in diesem Bild trainieren:
![Bild zeigt gängige Muster wiederkehrender neuronaler Netzwerke.](../../../../../translated_images/unreasonable-effectiveness-of-rnn.541ead816778f42dce6c42d8a56c184729aa2378d059b851be4ce12b993033df.de.jpg)
![Bild zeigt gängige Muster von rekurrenten neuronalen Netzwerken.](../../../../../lessons/5-NLP/17-GenerativeNetworks/images/unreasonable-effectiveness-of-rnn.jpg)
> *Bild aus [diesem Blogbeitrag](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) von [Andrej Karpathy](http://karpathy.github.io/). NER-Token-Klassifikationsmodelle entsprechen der ganz rechts stehenden Netzwerkarchitektur in diesem Bild.*
> *Bild aus [diesem Blogbeitrag](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) von [Andrej Karpathy](http://karpathy.github.io/). NER-Token-Klassifikationsmodelle entsprechen der Architektur des Netzwerks ganz rechts in diesem Bild.*
## Training von NER-Modellen
Da ein NER-Modell im Wesentlichen ein Token-Klassifikationsmodell ist, können wir RNNs verwenden, mit denen wir bereits vertraut sind. In diesem Fall gibt jeder Block des rekurrenten Netzwerks die Token-ID zurück. Das folgende Beispiel-Notebook zeigt, wie man LSTM für die Token-Klassifikation trainiert.
Da ein NER-Modell im Wesentlichen ein Token-Klassifikationsmodell ist, können wir RNNs, die wir bereits kennen, für diese Aufgabe verwenden. In diesem Fall gibt jeder Block des rekurrenten Netzwerks die Token-ID zurück. Das folgende Beispiel-Notebook zeigt, wie man ein LSTM für die Token-Klassifikation trainiert.
## ✍️ Beispiel-Notebooks: NER
Setzen Sie Ihr Lernen im folgenden Notebook fort:
Setzen Sie Ihr Lernen mit dem folgenden Notebook fort:
* [NER mit TensorFlow](../../../../../lessons/5-NLP/19-NER/NER-TF.ipynb)
## Fazit
Ein NER-Modell ist ein **Token-Klassifikationsmodell**, was bedeutet, dass es zur Durchführung der Token-Klassifikation verwendet werden kann. Dies ist eine sehr gängige Aufgabe im NLP, die hilft, spezifische Entitäten innerhalb von Texten zu erkennen, einschließlich Orte, Namen, Daten und mehr.
Ein NER-Modell ist ein **Token-Klassifikationsmodell**, was bedeutet, dass es zur Token-Klassifikation verwendet werden kann. Dies ist eine sehr häufige Aufgabe in der NLP, die hilft, spezifische Entitäten im Text zu erkennen, einschließlich Orte, Namen, Daten und mehr.
## 🚀 Herausforderung
Schließen Sie die unten verlinkte Aufgabe ab, um ein Modell zur Benannten Entitätenerkennung für medizinische Begriffe zu trainieren, und testen Sie es dann an einem anderen Datensatz.
Bearbeiten Sie die unten verlinkte Aufgabe, um ein Modell zur Erkennung benannter medizinischer Entitäten zu trainieren, und testen Sie es anschließend mit einem anderen Datensatz.
## [Nachvorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/219)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/219)
## Überprüfung & Selbststudium
## Wiederholung & Selbststudium
Lesen Sie den Blog [Die unangemessene Effektivität von rekurrenten neuronalen Netzwerken](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) und folgen Sie dem Abschnitt Weiterführende Literatur in diesem Artikel, um Ihr Wissen zu vertiefen.
Lesen Sie den Blog [The Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) und arbeiten Sie die Sektion "Weiterführende Literatur" in diesem Artikel durch, um Ihr Wissen zu vertiefen.
## [Aufgabe](lab/README.md)
In der Aufgabe für diese Lektion müssen Sie ein Modell zur Erkennung medizinischer Entitäten trainieren. Sie können mit dem Training eines LSTM-Modells beginnen, wie in dieser Lektion beschrieben, und dann das BERT-Transformator-Modell verwenden. Lesen Sie [die Anweisungen](lab/README.md), um alle Details zu erhalten.
In der Aufgabe zu dieser Lektion müssen Sie ein Modell zur Erkennung medizinischer Entitäten trainieren. Sie können mit dem Training eines LSTM-Modells beginnen, wie in dieser Lektion beschrieben, und anschließend das BERT-Transformermodell verwenden. Lesen Sie [die Anweisungen](lab/README.md), um alle Details zu erfahren.
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von KI-Übersetzungsdiensten ü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 aus der Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

31
translations/de/lessons/5-NLP/19-NER/lab/README.md
View File

@ -1,16 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "032bda5068f543d6c1fcb30c34231461",
"translation_date": "2025-08-24T09:32:40+00:00",
"source_file": "lessons/5-NLP/19-NER/lab/README.md",
"language_code": "de"
}
-->
# NER
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
In diesem Labor müssen Sie ein Modell zur Erkennung benannter Entitäten für medizinische Begriffe trainieren.
In diesem Labor müssen Sie ein Modell zur Erkennung benannter Entitäten (NER) für medizinische Begriffe trainieren.
## Der Datensatz
Um das NER-Modell zu trainieren, benötigen wir einen richtig beschrifteten Datensatz mit medizinischen Entitäten. Der [BC5CDR-Datensatz](https://biocreative.bioinformatics.udel.edu/tasks/biocreative-v/track-3-cdr/) enthält beschriftete Krankheiten und chemische Entitäten aus mehr als 1500 Arbeiten. Sie können den Datensatz herunterladen, nachdem Sie sich auf ihrer Website registriert haben.
Um ein NER-Modell zu trainieren, benötigen wir einen korrekt gekennzeichneten Datensatz mit medizinischen Entitäten. Der [BC5CDR-Datensatz](https://biocreative.bioinformatics.udel.edu/tasks/biocreative-v/track-3-cdr/) enthält gekennzeichnete Krankheits- und Chemikalienentitäten aus mehr als 1500 wissenschaftlichen Artikeln. Sie können den Datensatz nach der Registrierung auf deren Website herunterladen.
Der BC5CDR-Datensatz sieht folgendermaßen aus:
Der BC5CDR-Datensatz sieht wie folgt aus:
```
6794356|t|Tricuspid valve regurgitation and lithium carbonate toxicity in a newborn infant.
@ -21,17 +30,17 @@ Der BC5CDR-Datensatz sieht folgendermaßen aus:
...
```
In diesem Datensatz befinden sich der Titel und die Zusammenfassung der Arbeit in den ersten beiden Zeilen, gefolgt von einzelnen Entitäten mit Anfangs- und Endpositionen im Titel+Zusammenfassungsblock. Zusätzlich zum Entitätstyp erhalten Sie die Ontologie-ID dieser Entität innerhalb einer medizinischen Ontologie.
In diesem Datensatz befinden sich der Titel und die Zusammenfassung des Artikels in den ersten beiden Zeilen, gefolgt von den einzelnen Entitäten mit Anfangs- und Endpositionen innerhalb des Titel+Zusammenfassungsblocks. Zusätzlich zur Entitätstyp erhalten Sie die Ontologie-ID dieser Entität innerhalb einer medizinischen Ontologie.
Sie müssen einige Python-Codes schreiben, um dies in BIO-Codierung umzuwandeln.
Sie müssen etwas Python-Code schreiben, um dies in BIO-Codierung umzuwandeln.
## Das Netzwerk
Der erste Versuch zur NER kann unter Verwendung eines LSTM-Netzwerks erfolgen, wie in unserem Beispiel, das Sie während der Lektion gesehen haben. In NLP-Aufgaben zeigen jedoch [Transformator-Architekturen](https://en.wikipedia.org/wiki/Transformer_(machine_learning_model)) und insbesondere [BERT-Sprachmodelle](https://en.wikipedia.org/wiki/BERT_(language_model)) deutlich bessere Ergebnisse. Vorgefertigte BERT-Modelle verstehen die allgemeine Struktur einer Sprache und können mit relativ kleinen Datensätzen und geringen Rechenkosten für spezifische Aufgaben feinabgestimmt werden.
Ein erster Versuch mit NER kann mit einem LSTM-Netzwerk durchgeführt werden, wie Sie es in unserem Beispiel während der Lektion gesehen haben. Allerdings zeigen bei NLP-Aufgaben die [Transformer-Architektur](https://de.wikipedia.org/wiki/Transformer_(machine_learning_model)) und speziell [BERT-Sprachmodelle](https://de.wikipedia.org/wiki/BERT_(language_model)) deutlich bessere Ergebnisse. Vorgefertigte BERT-Modelle verstehen die allgemeine Struktur einer Sprache und können mit relativ kleinen Datensätzen und geringem Rechenaufwand für spezifische Aufgaben feinabgestimmt werden.
Da wir planen, NER im medizinischen Szenario anzuwenden, ist es sinnvoll, ein BERT-Modell zu verwenden, das auf medizinischen Texten trainiert wurde. Microsoft Research hat ein vortrainiertes Modell namens [PubMedBERT][PubMedBERT] ([Veröffentlichung][PubMedBERT-Pub]) veröffentlicht, das mithilfe von Texten aus dem [PubMed](https://pubmed.ncbi.nlm.nih.gov/) Repository feinabgestimmt wurde.
Da wir planen, NER in einem medizinischen Szenario anzuwenden, macht es Sinn, ein BERT-Modell zu verwenden, das auf medizinischen Texten trainiert wurde. Microsoft Research hat ein vortrainiertes Modell namens [PubMedBERT][PubMedBERT] ([Publikation][PubMedBERT-Pub]) veröffentlicht, das mit Texten aus dem [PubMed](https://pubmed.ncbi.nlm.nih.gov/) Repository feinabgestimmt wurde.
Der *de facto* Standard für das Training von Transformator-Modellen ist die [Hugging Face Transformers](https://huggingface.co/) Bibliothek. Sie enthält auch ein Repository von von der Community gewarteten vortrainierten Modellen, einschließlich PubMedBERT. Um dieses Modell zu laden und zu verwenden, benötigen wir nur ein paar Zeilen Code:
Der *de facto* Standard für das Training von Transformer-Modellen ist die [Hugging Face Transformers](https://huggingface.co/) Bibliothek. Sie enthält auch ein Repository mit von der Community gepflegten vortrainierten Modellen, einschließlich PubMedBERT. Um dieses Modell zu laden und zu verwenden, benötigen wir nur ein paar Zeilen Code:
```python
model_name = "microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract"
@ -40,11 +49,11 @@ tokenizer = AutoTokenizer.from_pretrained(model_name)
model = BertForTokenClassification.from_pretrained(model_name, classes)
```
Dies gibt uns das `model` itself, built for token classification task using `classes` number of classes, as well as `tokenizer`-Objekt, das den Eingabetext in Tokens aufteilen kann. Sie müssen den Datensatz in das BIO-Format umwandeln und dabei die Tokenisierung von PubMedBERT berücksichtigen. Sie können [diesen Python-Code](https://gist.github.com/shwars/580b55684be3328eb39ecf01b9cbbd88) als Inspiration verwenden.
Dies liefert uns das `model` selbst, das für die Token-Klassifikationsaufgabe mit `classes` Anzahl von Klassen gebaut wurde, sowie das `tokenizer`-Objekt, das den Eingabetext in Tokens aufteilen kann. Sie müssen den Datensatz in BIO-Format umwandeln und dabei die Tokenisierung von PubMedBERT berücksichtigen. Sie können [dieses Stück Python-Code](https://gist.github.com/shwars/580b55684be3328eb39ecf01b9cbbd88) als Inspiration verwenden.
## Fazit
Diese Aufgabe ist sehr nah an der tatsächlichen Aufgabe, die Sie wahrscheinlich haben werden, wenn Sie mehr Einblicke in große Mengen an Texten in natürlicher Sprache gewinnen möchten. In unserem Fall können wir unser trainiertes Modell auf den [Datensatz von COVID-bezogenen Arbeiten](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) anwenden und sehen, welche Erkenntnisse wir gewinnen können. [Dieser Blogbeitrag](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/) und [dieses Papier](https://www.mdpi.com/2504-2289/6/1/4) beschreiben die Forschung, die an diesem Korpus von Arbeiten unter Verwendung von NER durchgeführt werden kann.
Diese Aufgabe ist der tatsächlichen Arbeit sehr nahe, die Sie wahrscheinlich durchführen werden, wenn Sie tiefere Einblicke in große Mengen an natürlichen Sprachtexten gewinnen möchten. In unserem Fall können wir unser trainiertes Modell auf den [Datensatz von COVID-bezogenen Artikeln](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) anwenden und sehen, welche Erkenntnisse wir daraus gewinnen können. [Dieser Blogbeitrag](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/) und [dieses Paper](https://www.mdpi.com/2504-2289/6/1/4) beschreiben die Forschung, die mit diesem Korpus von Artikeln unter Verwendung von NER durchgeführt werden kann.
**Haftungsausschluss**:
Dieses Dokument wurde mit Hilfe von KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Originalsprache sollte als maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

64
translations/de/lessons/5-NLP/20-LangModels/README.md Normal file
View File

@ -0,0 +1,64 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "2efbb183384a50f0fc0cde02534d912f",
"translation_date": "2025-08-24T10:20:36+00:00",
"source_file": "lessons/5-NLP/20-LangModels/README.md",
"language_code": "de"
}
-->
# Vorgefertigte große Sprachmodelle
In all unseren bisherigen Aufgaben haben wir ein neuronales Netzwerk trainiert, um eine bestimmte Aufgabe mithilfe eines beschrifteten Datensatzes auszuführen. Mit großen Transformermodellen wie BERT verwenden wir Sprachmodellierung in selbstüberwachter Weise, um ein Sprachmodell zu erstellen, das anschließend durch weitere domänenspezifische Trainings für spezifische nachgelagerte Aufgaben spezialisiert wird. Es wurde jedoch gezeigt, dass große Sprachmodelle viele Aufgaben auch ohne jegliches domänenspezifisches Training lösen können. Eine Familie von Modellen, die dazu in der Lage ist, wird **GPT** genannt: Generative Pre-Trained Transformer.
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/120)
## Textgenerierung und Perplexität
Die Idee, dass ein neuronales Netzwerk allgemeine Aufgaben ohne nachgelagertes Training ausführen kann, wird im Papier [Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) vorgestellt. Der Hauptgedanke ist, dass viele andere Aufgaben mithilfe der **Textgenerierung** modelliert werden können, da das Verstehen von Text im Wesentlichen bedeutet, ihn produzieren zu können. Da das Modell auf einer riesigen Menge an Text trainiert wird, die menschliches Wissen umfasst, wird es auch über eine Vielzahl von Themen informiert.
> Text zu verstehen und produzieren zu können, bedeutet auch, etwas über die Welt um uns herum zu wissen. Menschen lernen ebenfalls in großem Maße durch Lesen, und das GPT-Netzwerk ist in dieser Hinsicht ähnlich.
Textgenerierungsnetzwerke arbeiten, indem sie die Wahrscheinlichkeit des nächsten Wortes $$P(w_N)$$ vorhersagen. Die bedingungslose Wahrscheinlichkeit des nächsten Wortes entspricht jedoch der Häufigkeit dieses Wortes im Textkorpus. GPT ist in der Lage, uns die **bedingte Wahrscheinlichkeit** des nächsten Wortes zu geben, basierend auf den vorherigen: $$P(w_N | w_{n-1}, ..., w_0)$$
> Mehr über Wahrscheinlichkeiten können Sie in unserem [Data Science für Anfänger Curriculum](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/1-Introduction/04-stats-and-probability) lesen.
Die Qualität eines sprachgenerierenden Modells kann mithilfe der **Perplexität** definiert werden. Es handelt sich um eine intrinsische Metrik, die es uns ermöglicht, die Modellqualität ohne einen aufgabenspezifischen Datensatz zu messen. Sie basiert auf dem Konzept der *Wahrscheinlichkeit eines Satzes* – das Modell weist einem Satz, der wahrscheinlich real ist (d.h. das Modell ist nicht **verwirrt** davon), eine hohe Wahrscheinlichkeit zu und Sätzen, die weniger Sinn ergeben (z.B. *Kann es was tun?*), eine niedrige Wahrscheinlichkeit. Wenn wir unserem Modell Sätze aus einem echten Textkorpus geben, erwarten wir, dass sie eine hohe Wahrscheinlichkeit und eine niedrige **Perplexität** haben. Mathematisch wird sie als normalisierte inverse Wahrscheinlichkeit des Testsets definiert:
$$
\mathrm{Perplexity}(W) = \sqrt[N]{1\over P(W_1,...,W_N)}
$$
**Sie können mit der Textgenerierung experimentieren, indem Sie den [GPT-gestützten Texteditor von Hugging Face](https://transformer.huggingface.co/doc/gpt2-large) verwenden.** In diesem Editor beginnen Sie, Ihren Text zu schreiben, und durch Drücken von **[TAB]** werden Ihnen mehrere Abschlussoptionen angeboten. Wenn diese zu kurz sind oder Sie nicht zufrieden sind, drücken Sie erneut [TAB], und Sie erhalten weitere Optionen, einschließlich längerer Textstücke.
## GPT ist eine Familie
GPT ist kein einzelnes Modell, sondern vielmehr eine Sammlung von Modellen, die von [OpenAI](https://openai.com) entwickelt und trainiert wurden.
Innerhalb der GPT-Modelle haben wir:
| [GPT-2](https://huggingface.co/docs/transformers/model_doc/gpt2#openai-gpt2) | [GPT 3](https://openai.com/research/language-models-are-few-shot-learners) | [GPT-4](https://openai.com/gpt-4) |
| -- | -- | -- |
|Sprachmodell mit bis zu 1,5 Milliarden Parametern. | Sprachmodell mit bis zu 175 Milliarden Parametern | 100T Parameter und akzeptiert sowohl Bild- als auch Texteingaben und gibt Text aus. |
Die GPT-3- und GPT-4-Modelle sind verfügbar [als kognitiver Dienst von Microsoft Azure](https://azure.microsoft.com/en-us/services/cognitive-services/openai-service/#overview?WT.mc_id=academic-77998-cacaste) und als [OpenAI API](https://openai.com/api/).
## Prompt Engineering
Da GPT auf großen Datenmengen trainiert wurde, um Sprache und Code zu verstehen, liefert es Ausgaben als Reaktion auf Eingaben (Prompts). Prompts sind GPT-Eingaben oder Abfragen, bei denen man den Modellen Anweisungen zu den Aufgaben gibt, die sie als Nächstes ausführen sollen. Um ein gewünschtes Ergebnis zu erzielen, benötigt man den effektivsten Prompt, der die Auswahl der richtigen Wörter, Formate, Phrasen oder sogar Symbole umfasst. Dieser Ansatz wird [Prompt Engineering](https://learn.microsoft.com/en-us/shows/ai-show/the-basics-of-prompt-engineering-with-azure-openai-service?WT.mc_id=academic-77998-bethanycheum) genannt.
[Diese Dokumentation](https://learn.microsoft.com/en-us/semantic-kernel/prompt-engineering/?WT.mc_id=academic-77998-bethanycheum) bietet Ihnen weitere Informationen zum Prompt Engineering.
## ✍️ Beispiel-Notebook: [Spielen mit OpenAI-GPT](../../../../../lessons/5-NLP/20-LangModels/GPT-PyTorch.ipynb)
Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
* [Textgenerierung mit OpenAI-GPT und Hugging Face Transformers](../../../../../lessons/5-NLP/20-LangModels/GPT-PyTorch.ipynb)
## Fazit
Neue allgemeine vortrainierte Sprachmodelle modellieren nicht nur die Sprachstruktur, sondern enthalten auch eine große Menge an natürlicher Sprache. Daher können sie effektiv verwendet werden, um einige NLP-Aufgaben in Zero-Shot- oder Few-Shot-Szenarien zu lösen.
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/220)
**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.

83
translations/de/lessons/5-NLP/README.md
View File

@ -1,69 +1,78 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "8ef02a9318257ea140ed3ed74442096d",
"translation_date": "2025-08-24T09:29:31+00:00",
"source_file": "lessons/5-NLP/README.md",
"language_code": "de"
}
-->
# Verarbeitung natürlicher Sprache
![Zusammenfassung der NLP-Aufgaben in einem Doodle](../../../../translated_images/ai-nlp.b22dcb8ca4707ceaee8576db1c5f4089c8cac2f454e9e03ea554f07fda4556b8.de.png)
![Zusammenfassung der NLP-Aufgaben in einer Skizze](../../../../lessons/sketchnotes/ai-nlp.png)
In diesem Abschnitt konzentrieren wir uns darauf, neuronale Netzwerke für Aufgaben im Bereich der **Verarbeitung natürlicher Sprache (NLP)** zu nutzen. Es gibt viele NLP-Probleme, die wir möchten, dass Computer lösen können:
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:
* **Textklassifikation** ist ein typisches Klassifikationsproblem, das sich auf Textsequenzen bezieht. Beispiele sind die Klassifizierung von E-Mail-Nachrichten als Spam oder Nicht-Spam oder die Kategorisierung 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 beschäftigen wir uns mit **Intent-Klassifikation**. Oft müssen wir bei der Intent-Klassifikation mit vielen Kategorien umgehen.
* **Sentimentanalyse** ist ein typisches Regressionsproblem, bei dem wir einer Zahl (einem Sentiment) zuordnen müssen, wie positiv oder negativ die Bedeutung eines Satzes ist. Eine fortgeschrittenere Version der Sentimentanalyse ist die **aspektbasierte Sentimentanalyse** (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*.
* **Named Entity Recognition** (NER) bezieht sich auf das Problem, bestimmte Entitäten aus Text zu extrahieren. Zum Beispiel müssen wir möglicherweise verstehen, dass im Satz *Ich muss morgen nach Paris fliegen* das Wort *morgen* auf DATUM verweist und *Paris* ein ORT ist.
* **Schlüsselwortextraktion** ähnelt NER, aber wir müssen automatisch Wörter extrahieren, die für die Bedeutung des Satzes wichtig sind, ohne eine Vorab-Trainierung für spezifische Entitätstypen.
* **Textclustering** kann nützlich sein, wenn wir ähnliche Sätze gruppieren möchten, beispielsweise ähnliche Anfragen in technischen Supportgesprächen.
* **Fragenbeantwortung** 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 einen Ort im Text angeben, an dem die Antwort auf die Frage enthalten ist (oder manchmal den Antworttext generieren).
* **Textgenerierung** ist die Fähigkeit eines Modells, neuen Text zu generieren. Sie kann als Klassifikationsaufgabe betrachtet werden, die den nächsten Buchstaben/Wort basierend auf einem *Text-Prompt* vorhersagt. Fortgeschrittene Textgenerierungsmodelle, wie GPT-3, sind in der Lage, andere NLP-Aufgaben wie Klassifikation mit einer Technik namens [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) zu lösen.
* **Textzusammenfassung** ist eine Technik, bei der wir möchten, dass ein Computer 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 angesehen werden.
* **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.
Ursprünglich wurden die meisten NLP-Aufgaben mit traditionellen Methoden wie Grammatiken gelöst. Zum Beispiel wurden in der maschinellen Übersetzung Parser verwendet, um den ursprünglichen Satz in einen Syntaxbaum zu transformieren, dann wurden höhere semantische Strukturen 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. 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.
> 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.
> 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.
In unserem Kurs werden wir uns hauptsächlich auf die Verwendung neuronaler Netzwerke für NLP konzentrieren und NLTK dort einsetzen, wo es notwendig ist.
In unserem Kurs konzentrieren wir uns hauptsächlich auf die Verwendung neuronaler Netzwerke für NLP und verwenden NLTK, wo es erforderlich ist.
Wir haben bereits gelernt, wie man neuronale Netzwerke für die Verarbeitung von tabellarischen Daten und Bildern einsetzt. Der Hauptunterschied zwischen diesen Datentypen und Text ist, dass Text eine Sequenz variabler Länge ist, während die Eingangsgröße im Fall von Bildern im Voraus bekannt ist. Während konvolutionale Netzwerke Muster aus Eingabedaten extrahieren können, sind Muster in Text komplexer. Zum Beispiel kann die Negation für viele Wörter vom Subjekt 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. Daher müssen wir zur Handhabung von Sprache neue Arten von neuronalen Netzwerken einführen, wie *rekurrente Netzwerke* und *Transformatoren*.
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*.
## Bibliotheken 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:
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:
**Für PyTorch**
**Für PyTorch**
```bash
pip install -r requirements-torch.txt
```
**Für TensorFlow**
```
**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 GPU-fähigen Computer**: Es wird empfohlen, Ihre Notebooks auf einem GPU-fähigen Computer auszuführen, um die Wartezeiten beim Arbeiten mit großen Modellen zu reduzieren.
* **GPU-Speicherbeschränkungen**: Das Ausführen auf einer GPU kann zu Situationen führen, in denen der GPU-Speicher erschöpft ist, insbesondere beim Trainieren großer Modelle.
* **GPU-Speicherverbrauch**: Die Menge an GPU-Speicher, die während des Trainings verbraucht wird, hängt von verschiedenen Faktoren ab, einschließlich der Mini-Batch-Größe.
* **Mini-Batch-Größe minimieren**: Wenn Sie auf GPU-Speicherprobleme stoßen, ziehen Sie in Betracht, die Mini-Batch-Größe in Ihrem Code als potenzielle Lösung zu 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 die GPU-Speichernutzung effektiv zu verwalten, können Sie TensorFlow so konfigurieren, dass GPU-Speicher nur nach Bedarf zugewiesen wird.
* **Code-Einbeziehung**: Um TensorFlow so einzustellen, dass die GPU-Speicherzuweisung nur bei Bedarf wächst, fügen Sie den folgenden Code in Ihre Notebooks ein:
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:
```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 einer klassischen ML-Perspektive zu lernen, besuchen Sie [diese Reihe von Lektionen](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP).
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).
## In diesem Abschnitt
In diesem Abschnitt werden wir lernen über:
In diesem Abschnitt werden wir lernen:
* [Text als Tensoren darstellen](13-TextRep/README.md)
* [Wort-Einbettungen](14-Emdeddings/README.md)
* [Sprachmodellierung](15-LanguageModeling/README.md)
* [Rekurrente neuronale Netzwerke](16-RNN/README.md)
* [Generative Netzwerke](17-GenerativeNetworks/README.md)
* [Transformatoren](18-Transformers/README.md)
* [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)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Verantwortung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

75
translations/de/lessons/6-Other/21-GeneticAlgorithms/README.md
View File

@ -1,44 +1,53 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "893aa368cb485da704b466a0f3775587",
"translation_date": "2025-08-24T09:37:52+00:00",
"source_file": "lessons/6-Other/21-GeneticAlgorithms/README.md",
"language_code": "de"
}
-->
# Genetische Algorithmen
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/121)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/121)
**Genetische Algorithmen** (GA) basieren auf einem **evolutionären Ansatz** für KI, bei dem Methoden der Evolution einer Population verwendet werden, um eine optimale Lösung für ein gegebenes Problem zu finden. Sie wurden 1975 von [John Henry Holland](https://wikipedia.org/wiki/John_Henry_Holland) vorgeschlagen.
**Genetische Algorithmen** (GA) basieren auf einem **evolutionären Ansatz** der KI, bei dem Methoden der Evolution einer Population genutzt werden, um eine optimale Lösung für ein gegebenes Problem zu finden. Sie wurden 1975 von [John Henry Holland](https://wikipedia.org/wiki/John_Henry_Holland) vorgeschlagen.
Genetische Algorithmen beruhen auf den folgenden Ideen:
Genetische Algorithmen basieren auf den folgenden Ideen:
* Gültige Lösungen für das Problem können als **Gene** dargestellt werden.
* **Crossover** ermöglicht es uns, zwei Lösungen zu kombinieren, um eine neue gültige Lösung zu erhalten.
* **Selektion** wird verwendet, um optimalere Lösungen mithilfe einer **Fitnessfunktion** auszuwählen.
* **Mutationen** werden eingeführt, um die Optimierung zu destabilisieren und uns aus dem lokalen Minimum herauszuholen.
* Gültige Lösungen des Problems können als **Gene** dargestellt werden.
* Durch **Crossover** können zwei Lösungen kombiniert werden, um eine neue gültige Lösung zu erhalten.
* **Selektion** wird verwendet, um mithilfe einer **Fitnessfunktion** optimalere Lösungen auszuwählen.
* **Mutationen** werden eingeführt, um die Optimierung zu destabilisieren und aus lokalen Minima herauszukommen.
Wenn Sie einen genetischen Algorithmus implementieren möchten, benötigen Sie Folgendes:
* Eine Methode zu finden, um unsere Problemlösungen mit **Genen** g∈Γ zu codieren.
* Auf der Menge der Gene Γ müssen wir eine **Fitnessfunktion** fit: Γ→**R** definieren. Kleinere Funktionswerte entsprechen besseren Lösungen.
* Einen **Crossover**-Mechanismus zu definieren, um zwei Gene zu kombinieren, um eine neue gültige Lösung zu erhalten: crossover: Γ<sup>2</sub>→Γ.
* Einen **Mutations**-Mechanismus zu definieren: mutate: Γ→Γ.
* Eine Methode, um Problemlösungen mithilfe von **Genen** g∈Γ zu kodieren.
* Auf der Menge der Gene Γ muss eine **Fitnessfunktion** fit: Γ→**R** definiert werden. Kleinere Funktionswerte entsprechen besseren Lösungen.
* Einen **Crossover-Mechanismus**, um zwei Gene zu kombinieren und eine neue gültige Lösung zu erhalten: crossover: Γ<sup>2</sub>→Γ.
* Einen **Mutationsmechanismus**: mutate: Γ→Γ.
In vielen Fällen sind Crossover und Mutation recht einfache Algorithmen, um Gene als numerische Sequenzen oder Bitvektoren zu manipulieren.
In vielen Fällen sind Crossover und Mutation recht einfache Algorithmen, die Gene als numerische Sequenzen oder Bitvektoren manipulieren.
Die spezifische Implementierung eines genetischen Algorithmus kann von Fall zu Fall variieren, aber die allgemeine Struktur ist wie folgt:
1. Wählen Sie eine Anfangspopulation G⊂Γ aus.
2. Wählen Sie zufällig eine der Operationen aus, die in diesem Schritt durchgeführt werden: Crossover oder Mutation.
1. Wählen Sie eine Anfangspopulation G⊂Γ.
2. Wählen Sie zufällig eine der Operationen aus, die in diesem Schritt ausgeführt werden sollen: Crossover oder Mutation.
3. **Crossover**:
* Wählen Sie zufällig zwei Gene g<sub>1</sub>, g<sub>2</sub> ∈ G aus.
* Berechnen Sie das Crossover g=crossover(g<sub>1</sub>,g<sub>2</sub>).
* Wenn fit(g)<fit(g<sub>1</sub>) oder fit(g)<fit(g<sub>2</sub>) - ersetzen Sie das entsprechende Gen in der Population durch g.
4. **Mutation** - wählen Sie ein zufälliges Gen g∈G aus und ersetzen Sie es durch mutate(g).
5. Wiederholen Sie Schritt 2, bis wir einen ausreichend kleinen Wert für fit erhalten oder bis die Grenze für die Anzahl der Schritte erreicht ist.
* Wählen Sie zufällig zwei Gene g<sub>1</sub>, g<sub>2</sub> ∈ G aus.
* Berechnen Sie den Crossover g=crossover(g<sub>1</sub>,g<sub>2</sub>).
* Wenn fit(g)<fit(g<sub>1</sub>) oder fit(g)<fit(g<sub>2</sub>), ersetzen Sie das entsprechende Gen in der Population durch g.
4. **Mutation** - Wählen Sie ein zufälliges Gen g∈G aus und ersetzen Sie es durch mutate(g).
5. Wiederholen Sie ab Schritt 2, bis ein ausreichend kleiner Wert von fit erreicht ist oder das Limit der Schrittanzahl erreicht wurde.
## Typische Aufgaben
Typische Aufgaben, die durch genetische Algorithmen gelöst werden, umfassen:
Typische Aufgaben, die mit genetischen Algorithmen gelöst werden, umfassen:
1. Terminoptimierung
1. Optimale Verpackung
1. Optimierung von Zeitplänen
1. Optimales Packen
1. Optimales Schneiden
1. Beschleunigung der exhaustiven Suche
1. Beschleunigung von erschöpfenden Suchverfahren
## ✍️ Übungen: Genetische Algorithmen
@ -46,35 +55,35 @@ Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
Gehen Sie zu [diesem Notebook](../../../../../lessons/6-Other/21-GeneticAlgorithms/Genetic.ipynb), um zwei Beispiele für die Verwendung genetischer Algorithmen zu sehen:
1. Gerechte Aufteilung von Schätzen
1. Gerechte Aufteilung eines Schatzes
1. 8-Damen-Problem
## Fazit
Genetische Algorithmen werden verwendet, um viele Probleme zu lösen, einschließlich Logistik- und Suchprobleme. Das Feld ist inspiriert von Forschungen, die Themen aus Psychologie und Informatik zusammengeführt haben.
Genetische Algorithmen werden verwendet, um viele Probleme zu lösen, einschließlich Logistik- und Suchprobleme. Das Feld ist inspiriert von Forschung, die Themen aus Psychologie und Informatik miteinander verbindet.
## 🚀 Herausforderung
"Genetische Algorithmen sind einfach zu implementieren, aber ihr Verhalten ist schwer zu verstehen." [Quelle](https://wikipedia.org/wiki/Genetic_algorithm) Machen Sie einige Recherchen, um eine Implementierung eines genetischen Algorithmus zu finden, wie z.B. das Lösen eines Sudoku-Rätsels, und erklären Sie, wie es funktioniert, als Skizze oder Flussdiagramm.
"Genetische Algorithmen sind einfach zu implementieren, aber ihr Verhalten ist schwer zu verstehen." [Quelle](https://wikipedia.org/wiki/Genetic_algorithm) Recherchieren Sie eine Implementierung eines genetischen Algorithmus, z. B. zur Lösung eines Sudoku-Puzzles, und erklären Sie, wie er funktioniert, in Form einer Skizze oder eines Flussdiagramms.
## [Nachvorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/221)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/221)
## Überprüfung & Selbststudium
## Wiederholung & Selbststudium
Sehen Sie sich [dieses großartige Video](https://www.youtube.com/watch?v=qv6UVOQ0F44) an, das darüber spricht, wie Computer lernen können, Super Mario mit Hilfe von neuronalen Netzwerken zu spielen, die durch genetische Algorithmen trainiert wurden. Wir werden mehr darüber lernen, wie Computer Spiele wie dieses spielen [im nächsten Abschnitt](../22-DeepRL/README.md).
Sehen Sie sich [dieses großartige Video](https://www.youtube.com/watch?v=qv6UVOQ0F44) an, das zeigt, wie ein Computer lernen kann, Super Mario zu spielen, indem neuronale Netzwerke mit genetischen Algorithmen trainiert werden. Wir werden mehr darüber lernen, wie Computer solche Spiele spielen können [im nächsten Abschnitt](../22-DeepRL/README.md).
## [Aufgabe: Diophantische Gleichung](../../../../../lessons/6-Other/21-GeneticAlgorithms/Diophantine.ipynb)
Ihr Ziel ist es, die sogenannte **diophantische Gleichung** zu lösen - eine Gleichung mit ganzzahligen Wurzeln. Betrachten Sie zum Beispiel die Gleichung a+2b+3c+4d=30. Sie müssen die ganzzahligen Wurzeln finden, die diese Gleichung erfüllen.
Ihr Ziel ist es, die sogenannte **diophantische Gleichung** zu lösen – eine Gleichung mit ganzzahligen Wurzeln. Betrachten Sie zum Beispiel die Gleichung a+2b+3c+4d=30. Sie müssen die ganzzahligen Wurzeln finden, die diese Gleichung erfüllen.
*Diese Aufgabe ist inspiriert von [diesem Beitrag](https://habr.com/post/128704/).*
Hinweise:
1. Sie können die Wurzeln im Intervall [0;30] betrachten.
1. Verwenden Sie als Gen die Liste der Wurzelwerte.
1. Sie können Wurzeln im Intervall [0;30] betrachten.
1. Als Gen können Sie die Liste der Wurzelwerte verwenden.
Verwenden Sie [Diophantine.ipynb](../../../../../lessons/6-Other/21-GeneticAlgorithms/Diophantine.ipynb) als Ausgangspunkt.
**Haftungsausschluss**:
Dieses Dokument wurde mit Hilfe von maschinellen KI-Übersetzungsdiensten ü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 wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Nutzung dieser Übersetzung resultieren.
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 sich aus der Nutzung dieser Übersetzung ergeben.

91
translations/de/lessons/6-Other/22-DeepRL/README.md
View File

@ -1,31 +1,40 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "dbacf9b1915612981d76059678e563e5",
"translation_date": "2025-08-24T09:38:46+00:00",
"source_file": "lessons/6-Other/22-DeepRL/README.md",
"language_code": "de"
}
-->
# Deep Reinforcement Learning
Reinforcement Learning (RL) wird als eines der grundlegenden Paradigmen des maschinellen Lernens angesehen, neben dem überwachten und unüberwachten Lernen. Während wir im überwachten Lernen auf Datensätze mit bekannten Ergebnissen angewiesen sind, basiert RL auf **Lernen durch Handeln**. Zum Beispiel, wenn wir ein Computer-Spiel zum ersten Mal sehen, fangen wir an zu spielen, selbst ohne die Regeln zu kennen, und bald sind wir in der Lage, unsere Fähigkeiten allein durch das Spielen und Anpassen unseres Verhaltens zu verbessern.
Reinforcement Learning (RL) wird als eines der grundlegenden Paradigmen des maschinellen Lernens angesehen, neben überwachten und unüberwachten Lernen. Während wir beim überwachten Lernen auf Datensätze mit bekannten Ergebnissen angewiesen sind, basiert RL auf dem Prinzip des **Lernens durch Handeln**. Zum Beispiel: Wenn wir ein Computerspiel zum ersten Mal sehen, beginnen wir zu spielen, auch ohne die Regeln zu kennen, und verbessern unsere Fähigkeiten allein durch das Spielen und Anpassen unseres Verhaltens.
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/122)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/122)
Um RL durchzuführen, benötigen wir:
* Eine **Umgebung** oder **Simulation**, die die Regeln des Spiels festlegt. Wir sollten in der Lage sein, die Experimente in der Simulation durchzuführen und die Ergebnisse zu beobachten.
* Eine **Belohnungsfunktion**, die angibt, wie erfolgreich unser Experiment war. Im Fall des Lernens, ein Computerspiel zu spielen, wäre die Belohnung unser Endpunktestand.
* Eine **Umgebung** oder einen **Simulator**, der die Regeln des Spiels festlegt. Wir sollten in der Lage sein, Experimente im Simulator durchzuführen und die Ergebnisse zu beobachten.
* Eine **Belohnungsfunktion**, die angibt, wie erfolgreich unser Experiment war. Im Fall des Lernens, ein Computerspiel zu spielen, wäre die Belohnung unsere Endpunktzahl.
Basierend auf der Belohnungsfunktion sollten wir in der Lage sein, unser Verhalten anzupassen und unsere Fähigkeiten zu verbessern, damit wir beim nächsten Mal besser spielen. Der Hauptunterschied zwischen anderen Arten des maschinellen Lernens und RL besteht darin, dass wir im RL typischerweise nicht wissen, ob wir gewinnen oder verlieren, bis wir das Spiel beenden. Daher können wir nicht sagen, ob ein bestimmter Zug allein gut oder schlecht ist - wir erhalten die Belohnung erst am Ende des Spiels.
Basierend auf der Belohnungsfunktion sollten wir unser Verhalten anpassen und unsere Fähigkeiten verbessern, sodass wir beim nächsten Mal besser spielen. Der Hauptunterschied zwischen anderen Arten des maschinellen Lernens und RL besteht darin, dass wir bei RL normalerweise nicht wissen, ob wir gewinnen oder verlieren, bis das Spiel beendet ist. Daher können wir nicht sagen, ob ein bestimmter Zug allein gut oder schlecht ist – wir erhalten die Belohnung erst am Ende des Spiels.
Während des RL führen wir typischerweise viele Experimente durch. Während jedes Experiments müssen wir ein Gleichgewicht finden zwischen der Verfolgung der optimalen Strategie, die wir bisher gelernt haben (**Exploitation**), und der Erkundung neuer möglicher Zustände (**Exploration**).
Während des RL führen wir typischerweise viele Experimente durch. Bei jedem Experiment müssen wir zwischen der Anwendung der optimalen Strategie, die wir bisher gelernt haben (**Ausnutzung**), und der Erforschung neuer möglicher Zustände (**Erkundung**) abwägen.
## OpenAI Gym
Ein großartiges Werkzeug für RL ist das [OpenAI Gym](https://gym.openai.com/) - eine **Simulationsumgebung**, die viele verschiedene Umgebungen simulieren kann, von Atari-Spielen bis hin zur Physik hinter dem Balancieren eines Mastes. Es ist eine der beliebtesten Simulationsumgebungen zur Schulung von Reinforcement-Learning-Algorithmen und wird von [OpenAI](https://openai.com/) gepflegt.
Ein großartiges Werkzeug für RL ist das [OpenAI Gym](https://gym.openai.com/) – eine **Simulationsumgebung**, die viele verschiedene Umgebungen simulieren kann, von Atari-Spielen bis hin zur Physik des Balancierens von Stangen. Es ist eine der beliebtesten Simulationsumgebungen für das Training von Reinforcement-Learning-Algorithmen und wird von [OpenAI](https://openai.com/) gepflegt.
> **Hinweis**: Sie können alle verfügbaren Umgebungen von OpenAI Gym [hier](https://gym.openai.com/envs/#classic_control) einsehen.
> **Hinweis**: Sie können alle verfügbaren Umgebungen von OpenAI Gym [hier](https://gym.openai.com/envs/#classic_control) sehen.
## CartPole Balancing
## CartPole-Balancieren
Sie haben wahrscheinlich alle moderne Balanciergeräte wie den *Segway* oder *Gyroscooter* gesehen. Diese sind in der Lage, automatisch zu balancieren, indem sie ihre Räder als Reaktion auf ein Signal von einem Beschleunigungsmesser oder Gyroskop anpassen. In diesem Abschnitt werden wir lernen, wie man ein ähnliches Problem löst - das Balancieren eines Mastes. Es ist vergleichbar mit einer Situation, in der ein Zirkuskünstler einen Mast auf seiner Hand balancieren muss - jedoch findet dieses Balancieren nur in 1D statt.
Ihr kennt wahrscheinlich moderne Balanciergeräte wie den *Segway* oder *Gyroscooter*. Sie können sich automatisch ausbalancieren, indem sie ihre Räder entsprechend einem Signal von einem Beschleunigungsmesser oder Gyroskop anpassen. In diesem Abschnitt lernen wir, wie man ein ähnliches Problem löst – das Balancieren einer Stange. Es ähnelt der Situation, in der ein Zirkuskünstler eine Stange auf seiner Hand balancieren muss – aber dieses Balancieren erfolgt nur in einer Dimension.
Eine vereinfachte Version des Balancierens ist als **CartPole**-Problem bekannt. In der CartPole-Welt haben wir einen horizontalen Schieber, der sich nach links oder rechts bewegen kann, und das Ziel ist es, einen vertikalen Mast oben auf dem Schieber auszubalancieren, während er sich bewegt.
Eine vereinfachte Version des Balancierens ist als **CartPole-Problem** bekannt. In der CartPole-Welt haben wir einen horizontalen Schlitten, der sich nach links oder rechts bewegen kann, und das Ziel ist es, eine vertikale Stange oben auf dem Schlitten zu balancieren, während er sich bewegt.
<img alt="ein cartpole" src="images/cartpole.png" width="200"/>
<img alt="a cartpole" src="images/cartpole.png" width="200"/>
Um diese Umgebung zu erstellen und zu nutzen, benötigen wir ein paar Zeilen Python-Code:
@ -45,73 +54,73 @@ while not done:
print(f"Total reward: {total_reward}")
```
Jede Umgebung kann auf genau die gleiche Weise aufgerufen werden:
* `env.reset` starts a new experiment
* `env.step` führt einen Simulationsschritt durch. Es erhält eine **Aktion** aus dem **Aktionsraum** und gibt eine **Beobachtung** (aus dem Beobachtungsraum) sowie eine Belohnung und ein Beendigungsflag zurück.
Jede Umgebung kann auf genau dieselbe Weise angesprochen werden:
* `env.reset` startet ein neues Experiment
* `env.step` führt einen Simulationsschritt aus. Es erhält eine **Aktion** aus dem **Aktionsraum** und gibt eine **Beobachtung** (aus dem Beobachtungsraum) sowie eine Belohnung und ein Abbruchflag zurück.
Im obigen Beispiel führen wir bei jedem Schritt eine zufällige Aktion aus, weshalb die Lebensdauer des Experiments sehr kurz ist:
![nicht balancierendes cartpole](../../../../../lessons/6-Other/22-DeepRL/images/cartpole-nobalance.gif)
![non-balancing cartpole](../../../../../lessons/6-Other/22-DeepRL/images/cartpole-nobalance.gif)
Das Ziel eines RL-Algorithmus ist es, ein Modell - die sogenannte **Politik** π - zu trainieren, das die Aktion als Antwort auf einen gegebenen Zustand zurückgibt. Wir können die Politik auch als probabilistisch betrachten, d.h. für jeden Zustand *s* und jede Aktion *a* gibt sie die Wahrscheinlichkeit π(*a*|*s*) zurück, dass wir *a* im Zustand *s* wählen sollten.
Das Ziel eines RL-Algorithmus ist es, ein Modell zu trainieren – die sogenannte **Policy** π –, die die Aktion als Antwort auf einen gegebenen Zustand zurückgibt. Wir können die Policy auch als probabilistisch betrachten, z. B. für jeden Zustand *s* und jede Aktion *a* gibt sie die Wahrscheinlichkeit π(*a*|*s*) zurück, dass wir *a* im Zustand *s* ausführen sollten.
## Policy Gradients Algorithmus
## Policy-Gradient-Algorithmus
Der offensichtlichste Weg, eine Politik zu modellieren, besteht darin, ein neuronales Netzwerk zu erstellen, das Zustände als Eingabe nimmt und die entsprechenden Aktionen (oder besser gesagt die Wahrscheinlichkeiten aller Aktionen) zurückgibt. In gewissem Sinne wäre es ähnlich wie bei einer normalen Klassifikationsaufgabe, mit einem wesentlichen Unterschied - wir wissen im Voraus nicht, welche Aktionen wir in jedem Schritt ausführen sollten.
Die offensichtlichste Möglichkeit, eine Policy zu modellieren, besteht darin, ein neuronales Netzwerk zu erstellen, das Zustände als Eingabe nimmt und entsprechende Aktionen (oder vielmehr die Wahrscheinlichkeiten aller Aktionen) zurückgibt. In gewisser Weise wäre es ähnlich wie eine normale Klassifikationsaufgabe, mit einem großen Unterschied – wir wissen im Voraus nicht, welche Aktionen wir bei jedem Schritt ausführen sollten.
Die Idee hier ist, diese Wahrscheinlichkeiten zu schätzen. Wir erstellen einen Vektor von **kumulierten Belohnungen**, der unsere Gesamtbelohnung in jedem Schritt des Experiments zeigt. Wir wenden auch **Belohnungsdiskontierung** an, indem wir frühere Belohnungen mit einem Koeffizienten γ=0.99 multiplizieren, um die Rolle der früheren Belohnungen zu verringern. Dann verstärken wir die Schritte entlang des Experimentpfades, die größere Belohnungen erzielen.
Die Idee hier ist, diese Wahrscheinlichkeiten zu schätzen. Wir erstellen einen Vektor von **kumulierten Belohnungen**, der unsere Gesamtbelohnung bei jedem Schritt des Experiments zeigt. Wir wenden auch **Belohnungsdiskontierung** an, indem wir frühere Belohnungen mit einem Koeffizienten γ=0.99 multiplizieren, um die Rolle früherer Belohnungen zu verringern. Dann verstärken wir die Schritte entlang des Experimentpfads, die größere Belohnungen bringen.
> Erfahren Sie mehr über den Policy-Gradient-Algorithmus und sehen Sie ihn in Aktion im [Beispiel-Notebook](../../../../../lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb).
## Actor-Critic Algorithmus
## Actor-Critic-Algorithmus
Eine verbesserte Version des Policy-Gradients-Ansatzes wird als **Actor-Critic** bezeichnet. Die Hauptidee dahinter ist, dass das neuronale Netzwerk trainiert wird, um zwei Dinge zurückzugeben:
Eine verbesserte Version des Policy-Gradient-Ansatzes wird **Actor-Critic** genannt. Die Hauptidee dahinter ist, dass das neuronale Netzwerk so trainiert wird, dass es zwei Dinge zurückgibt:
* Die Politik, die bestimmt, welche Aktion zu ergreifen ist. Dieser Teil wird **Actor** genannt.
* Die Schätzung der Gesamtbelohnung, die wir in diesem Zustand erwarten können - dieser Teil wird **Critic** genannt.
* Die Policy, die bestimmt, welche Aktion ausgeführt werden soll. Dieser Teil wird **Actor** genannt.
* Die Schätzung der Gesamtbelohnung, die wir in diesem Zustand erwarten können – dieser Teil wird **Critic** genannt.
In gewissem Sinne ähnelt diese Architektur einem [GAN](../../4-ComputerVision/10-GANs/README.md), bei dem wir zwei Netzwerke haben, die gegeneinander trainiert werden. Im Actor-Critic-Modell schlägt der Actor die Aktion vor, die wir ausführen müssen, und der Critic versucht, kritisch zu sein und das Ergebnis zu schätzen. Unser Ziel ist es jedoch, diese Netzwerke gemeinsam zu trainieren.
In gewisser Weise ähnelt diese Architektur einem [GAN](../../4-ComputerVision/10-GANs/README.md), bei dem wir zwei Netzwerke haben, die gegeneinander trainiert werden. Im Actor-Critic-Modell schlägt der Actor die Aktion vor, die wir ausführen müssen, und der Critic versucht kritisch zu sein und das Ergebnis zu schätzen. Unser Ziel ist es jedoch, diese Netzwerke im Einklang zu trainieren.
Da wir sowohl die tatsächlichen kumulierten Belohnungen als auch die Ergebnisse, die der Critic während des Experiments zurückgibt, kennen, ist es relativ einfach, eine Verlustfunktion zu erstellen, die den Unterschied zwischen ihnen minimiert. Das würde uns **Critic-Verlust** geben. Wir können **Actor-Verlust** berechnen, indem wir denselben Ansatz wie im Policy-Gradient-Algorithmus verwenden.
Da wir sowohl die tatsächlichen kumulierten Belohnungen als auch die vom Critic während des Experiments zurückgegebenen Ergebnisse kennen, ist es relativ einfach, eine Verlustfunktion zu erstellen, die die Differenz zwischen ihnen minimiert. Das würde uns den **Critic-Loss** geben. Wir können den **Actor-Loss** mit demselben Ansatz wie im Policy-Gradient-Algorithmus berechnen.
Nach dem Ausführen eines dieser Algorithmen können wir erwarten, dass unser CartPole so aussieht:
Nach dem Ausführen eines dieser Algorithmen können wir erwarten, dass unser CartPole sich wie folgt verhält:
![ein balancierendes cartpole](../../../../../lessons/6-Other/22-DeepRL/images/cartpole-balance.gif)
![a balancing cartpole](../../../../../lessons/6-Other/22-DeepRL/images/cartpole-balance.gif)
## ✍️ Übungen: Policy Gradients und Actor-Critic RL
## ✍️ Übungen: Policy-Gradient und Actor-Critic RL
Setzen Sie Ihr Lernen in den folgenden Notebooks fort:
* [RL in TensorFlow](../../../../../lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb)
* [RL in PyTorch](../../../../../lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb)
## Weitere RL-Aufgaben
## Andere RL-Aufgaben
Reinforcement Learning ist heutzutage ein schnell wachsendes Forschungsfeld. Einige interessante Beispiele für Reinforcement Learning sind:
* Einem Computer beibringen, **Atari-Spiele** zu spielen. Der herausfordernde Teil dieses Problems besteht darin, dass wir keinen einfachen Zustand in Form eines Vektors haben, sondern eher einen Screenshot - und wir müssen das CNN verwenden, um dieses Bildschirmbild in einen Merkmalsvektor zu konvertieren oder Belohnungsinformationen zu extrahieren. Atari-Spiele sind im Gym verfügbar.
* Einem Computer beibringen, Brettspiele wie Schach und Go zu spielen. Kürzlich wurden hochmoderne Programme wie **Alpha Zero** von zwei Agenten, die gegeneinander spielten und sich mit jedem Schritt verbesserten, von Grund auf trainiert.
* In der Industrie wird RL verwendet, um Steuerungssysteme aus Simulationen zu erstellen. Ein Dienst namens [Bonsai](https://azure.microsoft.com/services/project-bonsai/?WT.mc_id=academic-77998-cacaste) wurde speziell dafür entwickelt.
* Einem Computer beibringen, **Atari-Spiele** zu spielen. Die Herausforderung bei diesem Problem besteht darin, dass wir keinen einfachen Zustand als Vektor haben, sondern einen Screenshot – und wir müssen ein CNN verwenden, um dieses Bildschirmbild in einen Feature-Vektor umzuwandeln oder Belohnungsinformationen zu extrahieren. Atari-Spiele sind im Gym verfügbar.
* Einem Computer beibringen, Brettspiele wie Schach und Go zu spielen. Kürzlich wurden Programme wie **Alpha Zero** von Grund auf durch zwei Agenten trainiert, die gegeneinander spielen und sich bei jedem Schritt verbessern.
* In der Industrie wird RL verwendet, um Steuerungssysteme aus Simulationen zu erstellen. Ein Dienst namens [Bonsai](https://azure.microsoft.com/services/project-bonsai/?WT.mc_id=academic-77998-cacaste) ist speziell dafür konzipiert.
## Fazit
Wir haben nun gelernt, wie man Agenten trainiert, um gute Ergebnisse zu erzielen, indem wir ihnen eine Belohnungsfunktion bereitstellen, die den gewünschten Zustand des Spiels definiert, und ihnen die Möglichkeit geben, den Suchraum intelligent zu erkunden. Wir haben erfolgreich zwei Algorithmen ausprobiert und in relativ kurzer Zeit ein gutes Ergebnis erzielt. Dies ist jedoch nur der Anfang Ihrer Reise in das RL, und Sie sollten auf jeden Fall in Betracht ziehen, einen separaten Kurs zu belegen, wenn Sie tiefer eintauchen möchten.
Wir haben nun gelernt, wie man Agenten trainiert, um gute Ergebnisse zu erzielen, indem man ihnen lediglich eine Belohnungsfunktion bereitstellt, die den gewünschten Zustand des Spiels definiert, und ihnen die Möglichkeit gibt, den Suchraum intelligent zu erkunden. Wir haben erfolgreich zwei Algorithmen ausprobiert und in relativ kurzer Zeit ein gutes Ergebnis erzielt. Dies ist jedoch nur der Anfang Ihrer Reise in RL, und Sie sollten definitiv einen separaten Kurs in Betracht ziehen, wenn Sie tiefer eintauchen möchten.
## 🚀 Herausforderung
Erforschen Sie die in der Rubrik 'Weitere RL-Aufgaben' aufgeführten Anwendungen und versuchen Sie, eine zu implementieren!
Erkunden Sie die Anwendungen, die im Abschnitt "Andere RL-Aufgaben" aufgeführt sind, und versuchen Sie, eine davon umzusetzen!
## [Nachlese-Quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/222)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/222)
## Überprüfung & Selbststudium
Erfahren Sie mehr über klassisches Reinforcement Learning in unserem [Maschinenlernen für Anfänger Curriculum](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/README.md).
Erfahren Sie mehr über klassisches Reinforcement Learning in unserem [Machine Learning for Beginners Curriculum](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/README.md).
Sehen Sie sich [dieses großartige Video](https://www.youtube.com/watch?v=qv6UVOQ0F44) an, das darüber spricht, wie ein Computer lernen kann, Super Mario zu spielen.
Sehen Sie sich [dieses großartige Video](https://www.youtube.com/watch?v=qv6UVOQ0F44) an, das zeigt, wie ein Computer lernen kann, Super Mario zu spielen.
## Aufgabe: [Trainiere ein Mountain Car](lab/README.md)
## Aufgabe: [Trainieren Sie ein Mountain Car](lab/README.md)
Ihr Ziel während dieser Aufgabe wäre es, eine andere Gym-Umgebung zu trainieren - [Mountain Car](https://www.gymlibrary.ml/environments/classic_control/mountain_car/).
Ihr Ziel bei dieser Aufgabe ist es, eine andere Gym-Umgebung zu trainieren – [Mountain Car](https://www.gymlibrary.ml/environments/classic_control/mountain_car/).
**Haftungsausschluss**:
Dieses Dokument wurde mit Hilfe von KI-gestützten maschinellen Übersetzungsdiensten ü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 aus der Nutzung dieser Übersetzung entstehen.
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.

29
translations/de/lessons/6-Other/22-DeepRL/lab/README.md
View File

@ -1,22 +1,23 @@
# Training Mountain Car to Escape
Laboraufgabe aus dem [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners).
## Aufgabe
Ihr Ziel ist es, den RL-Agenten zu trainieren, um [Mountain Car](https://www.gymlibrary.ml/environments/classic_control/mountain_car/) in der OpenAI-Umgebung zu steuern. Sie werden mit Daten bis Oktober 2023 trainiert.
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7bd8dc72040e98e35e7225e34058cd4e",
"translation_date": "2025-08-24T09:39:10+00:00",
"source_file": "lessons/6-Other/22-DeepRL/lab/README.md",
"language_code": "de"
}
-->
## Die Umgebung
Die Mountain Car-Umgebung besteht aus einem Auto, das in einem Tal gefangen ist. Ihr Ziel ist es, aus dem Tal zu springen und die Flagge zu erreichen. Die Aktionen, die Sie ausführen können, sind, nach links zu beschleunigen, nach rechts zu beschleunigen oder nichts zu tun. Sie können die Position des Autos entlang der x-Achse und die Geschwindigkeit beobachten.
Die Mountain Car-Umgebung besteht aus einem Auto, das in einem Tal gefangen ist. Dein Ziel ist es, aus dem Tal herauszuspringen und die Fahne zu erreichen. Die Aktionen, die du ausführen kannst, sind: nach links beschleunigen, nach rechts beschleunigen oder nichts tun. Du kannst die Position des Autos entlang der x-Achse und die Geschwindigkeit beobachten.
## Notebook starten
## Start-Notebook
Starten Sie das Labor, indem Sie [MountainCar.ipynb](../../../../../../lessons/6-Other/22-DeepRL/lab/MountainCar.ipynb) öffnen.
Beginne das Lab, indem du [MountainCar.ipynb](../../../../../../lessons/6-Other/22-DeepRL/lab/MountainCar.ipynb) öffnest.
## Fazit
## Erkenntnis
Sie sollten während dieses Labors lernen, dass die Anpassung von RL-Algorithmen an eine neue Umgebung oft recht unkompliziert ist, da das OpenAI Gym für alle Umgebungen dieselbe Schnittstelle hat und Algorithmen somit nicht stark von der Natur der Umgebung abhängen. Sie können sogar den Python-Code so umstrukturieren, dass jede Umgebung als Parameter an den RL-Algorithmus übergeben wird.
Während dieses Labs solltest du lernen, dass die Anpassung von RL-Algorithmen an eine neue Umgebung oft recht unkompliziert ist, da OpenAI Gym für alle Umgebungen dieselbe Schnittstelle bietet und die Algorithmen im Allgemeinen nicht stark von der Art der Umgebung abhängen. Du kannst den Python-Code sogar so umstrukturieren, dass jede Umgebung als Parameter an den RL-Algorithmus übergeben werden kann.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner Ursprungssprache sollte als die 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 Verwendung dieser Übersetzung entstehen.
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.

150
translations/de/lessons/6-Other/23-MultiagentSystems/README.md
View File

@ -1,38 +1,47 @@
# Multi-Agent-Systeme
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1ddf651d7681b4449f9d09ea3b17911e",
"translation_date": "2025-08-24T09:38:09+00:00",
"source_file": "lessons/6-Other/23-MultiagentSystems/README.md",
"language_code": "de"
}
-->
# Multi-Agenten-Systeme
Eine der möglichen Wege, Intelligenz zu erreichen, ist der sogenannte **emergente** (oder **synergetische**) Ansatz, der darauf basiert, dass das kombinierte Verhalten vieler relativ einfacher Agenten zu einem insgesamt komplexeren (oder intelligenten) Verhalten des Systems als Ganzes führen kann. Theoretisch beruht dies auf den Prinzipien der [kollektiven Intelligenz](https://de.wikipedia.org/wiki/Kollektive_Intelligenz), [Emergentismus](https://de.wikipedia.org/wiki/Emergentismus) und [evolutionären Kybernetik](https://de.wikipedia.org/wiki/Evolution%C3%A4re_Kybernetik), die besagen, dass höherstufige Systeme einen gewissen Mehrwert gewinnen, wenn sie richtig aus niederstufigen Systemen kombiniert werden (sogenanntes *Prinzip des Metasystemübergangs*).
Eine der möglichen Methoden, Intelligenz zu erreichen, ist der sogenannte **emergente** (oder **synergetische**) Ansatz, der auf der Tatsache basiert, dass das kombinierte Verhalten vieler relativ einfacher Agenten zu einem insgesamt komplexeren (oder intelligenteren) Verhalten des Systems als Ganzes führen kann. Theoretisch basiert dies auf den Prinzipien der [kollektiven Intelligenz](https://en.wikipedia.org/wiki/Collective_intelligence), des [Emergentismus](https://en.wikipedia.org/wiki/Global_brain) und der [evolutionären Kybernetik](https://en.wikipedia.org/wiki/Global_brain), die besagen, dass höherstufige Systeme einen Mehrwert erhalten, wenn sie richtig aus niedrigeren Systemen kombiniert werden (das sogenannte *Prinzip des Übergangs zu Metasystemen*).
## [Vorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/123)
## [Quiz vor der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/123)
Der Bereich der **Multi-Agent-Systeme** hat sich in den 1990er Jahren als Reaktion auf das Wachstum des Internets und verteilter Systeme in der KI entwickelt. Eines der klassischen KI-Lehrbücher, [Künstliche Intelligenz: Ein moderner Ansatz](https://de.wikipedia.org/wiki/K%C3%BCnstliche_Intelligenz:_Ein_moderner_Ansatz), konzentriert sich auf die Sichtweise der klassischen KI aus der Perspektive von Multi-Agent-Systemen.
Die Richtung der **Multi-Agenten-Systeme** entstand in den 1990er Jahren in der KI als Reaktion auf das Wachstum des Internets und verteilter Systeme. Eines der klassischen Lehrbücher der KI, [Artificial Intelligence: A Modern Approach](https://en.wikipedia.org/wiki/Artificial_Intelligence:_A_Modern_Approach), betrachtet die klassische KI aus der Perspektive von Multi-Agenten-Systemen.
Zentral für den Multi-Agenten-Ansatz ist der Begriff des **Agenten** - eine Entität, die in einer bestimmten **Umgebung** lebt, die sie wahrnehmen und beeinflussen kann. Dies ist eine sehr breite Definition, und es könnte viele verschiedene Arten und Klassifikationen von Agenten geben:
Im Mittelpunkt des Multi-Agenten-Ansatzes steht der Begriff des **Agenten** – eine Entität, die in einer **Umgebung** lebt, die sie wahrnehmen und auf die sie einwirken kann. Dies ist eine sehr breite Definition, und es gibt viele verschiedene Typen und Klassifikationen von Agenten:
* Nach ihrer Fähigkeit zu schlussfolgern:
- **Reaktive** Agenten haben in der Regel ein einfaches Anfrage-Antwort-Verhalten
- **Deliberative** Agenten verwenden eine Art logisches Denken und/oder Planungsfähigkeiten
* Nach ihrer Fähigkeit zu denken:
- **Reaktive** Agenten haben normalerweise ein einfaches Anfrage-Antwort-Verhalten.
- **Deliberative** Agenten nutzen eine Art logisches Denken und/oder Planungsfähigkeiten.
* Nach dem Ort, an dem der Agent seinen Code ausführt:
- **Statische** Agenten arbeiten auf einem dedizierten Netzwerk-Knoten
- **Mobile** Agenten können ihren Code zwischen Netzwerk-Knoten bewegen
- **Statische** Agenten arbeiten auf einem dedizierten Netzwerkknoten.
- **Mobile** Agenten können ihren Code zwischen Netzwerkknoten verschieben.
* Nach ihrem Verhalten:
- **Passive Agenten** haben keine spezifischen Ziele. Solche Agenten können auf externe Reize reagieren, initiieren jedoch selbst keine Aktionen.
- **Aktive Agenten** verfolgen bestimmte Ziele
- **Kognitive Agenten** beinhalten komplexe Planung und Schlussfolgerungen
- **Passive Agenten** haben keine spezifischen Ziele. Solche Agenten können auf externe Reize reagieren, initiieren jedoch keine eigenen Aktionen.
- **Aktive Agenten** verfolgen bestimmte Ziele.
- **Kognitive Agenten** beinhalten komplexe Planung und Denken.
Multi-Agent-Systeme werden heutzutage in einer Vielzahl von Anwendungen eingesetzt:
Multi-Agenten-Systeme werden heutzutage in einer Reihe von Anwendungen eingesetzt:
* In Spielen verwenden viele Nicht-Spieler-Charaktere eine Art von KI und können als intelligente Agenten betrachtet werden.
* In der Videoproduktion wird das Rendern komplexer 3D-Szenen, die Menschenmengen beinhalten, typischerweise durch Multi-Agenten-Simulationen durchgeführt.
* In der Systemmodellierung wird der Multi-Agenten-Ansatz verwendet, um das Verhalten eines komplexen Modells zu simulieren. Zum Beispiel wurde der Multi-Agenten-Ansatz erfolgreich genutzt, um die Ausbreitung der COVID-19-Krankheit weltweit vorherzusagen. Ein ähnlicher Ansatz kann verwendet werden, um den Verkehr in der Stadt zu modellieren und zu sehen, wie er auf Änderungen der Verkehrsregeln reagiert.
* In komplexen Automatisierungssystemen kann jedes Gerät als unabhängiger Agent fungieren, was das gesamte System weniger monolithisch und robuster macht.
* In Spielen nutzen viele Nicht-Spieler-Charaktere eine Art KI und können als intelligente Agenten betrachtet werden.
* In der Videoproduktion wird das Rendern komplexer 3D-Szenen, die Menschenmengen beinhalten, typischerweise mithilfe von Multi-Agenten-Simulationen durchgeführt.
* In der Systemmodellierung wird der Multi-Agenten-Ansatz verwendet, um das Verhalten eines komplexen Modells zu simulieren. Beispielsweise wurde der Multi-Agenten-Ansatz erfolgreich eingesetzt, um die weltweite Ausbreitung der COVID-19-Krankheit vorherzusagen. Ein ähnlicher Ansatz kann verwendet werden, um den Verkehr in einer Stadt zu modellieren und zu sehen, wie er auf Änderungen der Verkehrsregeln reagiert.
* In komplexen Automatisierungssystemen kann jedes Gerät als unabhängiger Agent agieren, wodurch das gesamte System weniger monolithisch und robuster wird.
Wir werden nicht viel Zeit damit verbringen, tief in Multi-Agent-Systeme einzutauchen, sondern ein Beispiel für **Multi-Agenten-Modellierung** betrachten.
Wir werden nicht viel Zeit damit verbringen, tief in Multi-Agenten-Systeme einzutauchen, sondern ein Beispiel für **Multi-Agenten-Modellierung** betrachten.
## NetLogo
[NetLogo](https://ccl.northwestern.edu/netlogo/) ist eine Multi-Agenten-Modellierungsumgebung, die auf einer modifizierten Version der [Logo](https://de.wikipedia.org/wiki/Logo_(Programmiersprache))-Programmiersprache basiert. Diese Sprache wurde entwickelt, um Programmierkonzepte Kindern beizubringen, und ermöglicht es Ihnen, einen Agenten namens **Schildkröte** zu steuern, der sich bewegen und dabei eine Spur hinterlassen kann. Dies ermöglicht die Erstellung komplexer geometrischer Figuren, was eine sehr visuelle Art ist, das Verhalten eines Agenten zu verstehen.
[NetLogo](https://ccl.northwestern.edu/netlogo/) ist eine Multi-Agenten-Modellierungsumgebung, die auf einer modifizierten Version der [Logo](https://en.wikipedia.org/wiki/Logo_(programming_language))-Programmiersprache basiert. Diese Sprache wurde entwickelt, um Kindern Programmierkonzepte beizubringen, und ermöglicht es, einen Agenten namens **Turtle** zu steuern, der sich bewegen und dabei eine Spur hinterlassen kann. Dies ermöglicht die Erstellung komplexer geometrischer Figuren, was eine sehr visuelle Möglichkeit ist, das Verhalten eines Agenten zu verstehen.
In NetLogo können wir viele Schildkröten erstellen, indem wir den `create-turtles`-Befehl verwenden. Wir können dann alle Schildkröten anweisen, einige Aktionen auszuführen (im folgenden Beispiel - 10 Punkte nach vorne):
In NetLogo können wir viele Turtles mit dem Befehl `create-turtles` erstellen. Anschließend können wir alle Turtles anweisen, bestimmte Aktionen auszuführen (im folgenden Beispiel - 10 Punkte vorwärts bewegen):
```
create-turtles 10
@ -41,39 +50,39 @@ ask turtles [
]
```
Natürlich ist es nicht interessant, wenn alle Schildkröten dasselbe tun, also können wir `ask` groups of turtles, eg. those who are in the vicinity of a certain point. We can also create turtles of different *breeds* using `breed [cats cat]` command. Here `cat` ist der Name einer Rasse, und wir müssen sowohl das Singular- als auch das Pluralwort angeben, da verschiedene Befehle unterschiedliche Formen zur Klarheit verwenden.
Natürlich ist es nicht interessant, wenn alle Turtles dasselbe tun, daher können wir Gruppen von Turtles mit `ask` ansprechen, z. B. diejenigen, die sich in der Nähe eines bestimmten Punktes befinden. Wir können auch Turtles verschiedener *Rassen* mit dem Befehl `breed [cats cat]` erstellen. Hier ist `cat` der Name einer Rasse, und wir müssen sowohl das Singular- als auch das Pluralwort angeben, da verschiedene Befehle unterschiedliche Formen für Klarheit verwenden.
> ✅ Wir werden nicht in die Sprache NetLogo selbst eintauchen - Sie können die brillante [Interaktive NetLogo-Wörterbuch für Anfänger](https://ccl.northwestern.edu/netlogo/bind/) Ressource besuchen, wenn Sie mehr lernen möchten.
> ✅ Wir werden nicht in die NetLogo-Sprache selbst eintauchen – Sie können die großartige Ressource [Beginner's Interactive NetLogo Dictionary](https://ccl.northwestern.edu/netlogo/bind/) besuchen, wenn Sie mehr lernen möchten.
Sie können [NetLogo herunterladen](https://ccl.northwestern.edu/netlogo/download.shtml) und installieren, um es auszuprobieren.
### Modelle-Bibliothek
### Modellbibliothek
Eine großartige Sache an NetLogo ist, dass es eine Bibliothek von funktionierenden Modellen enthält, die Sie ausprobieren können. Gehen Sie zu **Datei → Modelle-Bibliothek**, und Sie haben viele Kategorien von Modellen zur Auswahl.
Ein großartiges Merkmal von NetLogo ist, dass es eine Bibliothek mit funktionierenden Modellen enthält, die Sie ausprobieren können. Gehen Sie zu **Datei → Modellbibliothek**, und Sie haben viele Kategorien von Modellen zur Auswahl.
<img alt="NetLogo Modelle-Bibliothek" src="images/NetLogo-ModelLib.png" width="60%"/>
<img alt="NetLogo Models Library" src="images/NetLogo-ModelLib.png" width="60%"/>
> Ein Screenshot der Modelle-Bibliothek von Dmitry Soshnikov
> Ein Screenshot der Modellbibliothek von Dmitry Soshnikov
Sie können eines der Modelle öffnen, zum Beispiel **Biologie → Vogelschwarm**.
Sie können eines der Modelle öffnen, zum Beispiel **Biologie → Flocking**.
### Hauptprinzipien
Nach dem Öffnen des Modells gelangen Sie zum Hauptbildschirm von NetLogo. Hier ist ein Beispielmodell, das die Population von Wölfen und Schafen beschreibt, bei begrenzten Ressourcen (Gras).
Nach dem Öffnen des Modells gelangen Sie zum Hauptbildschirm von NetLogo. Hier ist ein Beispielmodell, das die Population von Wölfen und Schafen beschreibt, basierend auf begrenzten Ressourcen (Gras).
![NetLogo Hauptbildschirm](../../../../../translated_images/NetLogo-Main.32653711ec1a01b3cab22ec0b148e64193d0b979b055285bef329d5e3d6958c5.de.png)
![NetLogo Main Screen](../../../../../lessons/6-Other/23-MultiagentSystems/images/NetLogo-Main.png)
> Screenshot von Dmitry Soshnikov
Auf diesem Bildschirm sehen Sie:
* Den Abschnitt **Schnittstelle**, der enthält:
- Das Hauptfeld, in dem alle Agenten leben
- Verschiedene Steuerungen: Tasten, Schieberegler usw.
- Grafiken, die Sie verwenden können, um Parameter der Simulation anzuzeigen
* Den **Code**-Tab, der den Editor enthält, in dem Sie NetLogo-Programme eingeben können
* Den **Interface**-Bereich, der Folgendes enthält:
- Das Hauptfeld, auf dem alle Agenten leben
- Verschiedene Steuerungen: Schaltflächen, Schieberegler usw.
- Diagramme, die Sie verwenden können, um Parameter der Simulation anzuzeigen
* Den **Code**-Tab, der den Editor enthält, in dem Sie NetLogo-Programme schreiben können
In den meisten Fällen hätte die Schnittstelle eine **Setup**-Taste, die den Simulationszustand initialisiert, und eine **Go**-Taste, die die Ausführung startet. Diese werden von den entsprechenden Handlern im Code behandelt, die so aussehen:
In den meisten Fällen enthält die Benutzeroberfläche eine **Setup**-Schaltfläche, die den Simulationszustand initialisiert, und eine **Go**-Schaltfläche, die die Ausführung startet. Diese werden von entsprechenden Handlern im Code gesteuert, die wie folgt aussehen:
```
to go [
@ -83,72 +92,73 @@ to go [
Die Welt von NetLogo besteht aus den folgenden Objekten:
* **Agenten** (Schildkröten), die sich über das Feld bewegen und etwas tun können. Sie befehlen Agenten mit `ask turtles [...]` syntax, and the code in brackets is executed by all agents in *turtle mode*.
* **Patches** are square areas of the field, on which agents live. You can refer to all agents on the same patch, or you can change patch colors and some other properties. You can also `ask patches`, um etwas zu tun.
* **Beobachter** ist ein einzigartiger Agent, der die Welt kontrolliert. Alle Button-Handler werden im *Beobachtungsmodus* ausgeführt.
* **Agenten** (Turtles), die sich über das Feld bewegen und etwas tun können. Sie steuern Agenten mit der Syntax `ask turtles [...]`, und der Code in den Klammern wird von allen Agenten im *Turtle-Modus* ausgeführt.
* **Patches** sind quadratische Bereiche des Feldes, auf denen Agenten leben. Sie können auf alle Agenten auf demselben Patch verweisen oder die Farben und einige andere Eigenschaften des Patches ändern. Sie können auch `ask patches` verwenden, um etwas zu tun.
* **Observer** ist ein einzigartiger Agent, der die Welt kontrolliert. Alle Button-Handler werden im *Observer-Modus* ausgeführt.
> ✅ Die Schönheit einer Multi-Agenten-Umgebung besteht darin, dass der Code, der im Schildkrötenmodus oder im Patchmodus ausgeführt wird, gleichzeitig von allen Agenten parallel ausgeführt wird. Durch das Schreiben eines kleinen Codes und das Programmieren des Verhaltens des einzelnen Agenten können Sie komplexes Verhalten des Simulationssystems als Ganzes erzeugen.
> ✅ Die Schönheit einer Multi-Agenten-Umgebung liegt darin, dass der Code, der im Turtle-Modus oder im Patch-Modus ausgeführt wird, gleichzeitig von allen Agenten parallel ausgeführt wird. Indem Sie also wenig Code schreiben und das Verhalten eines einzelnen Agenten programmieren, können Sie ein komplexes Verhalten des gesamten Simulationssystems erzeugen.
### Vogelschwarm
### Flocking
Als Beispiel für multi-agenten Verhalten betrachten wir **[Vogelschwarm](https://de.wikipedia.org/wiki/Vogelschwarm_(Verhalten))**. Vogelschwarm ist ein komplexes Muster, das dem ähnelt, wie Vogelschwärme fliegen. Wenn man ihnen beim Fliegen zusieht, könnte man denken, dass sie einem kollektiven Algorithmus folgen oder dass sie eine Form von *kollektiver Intelligenz* besitzen. Dieses komplexe Verhalten entsteht jedoch, wenn jeder einzelne Agent (in diesem Fall ein *Vogel*) nur einige andere Agenten in kurzer Distanz von sich beobachtet und drei einfache Regeln befolgt:
Als Beispiel für Multi-Agenten-Verhalten betrachten wir **[Flocking](https://en.wikipedia.org/wiki/Flocking_(behavior))**. Flocking ist ein komplexes Muster, das dem Flug von Vogelschwärmen sehr ähnlich ist. Wenn man sie fliegen sieht, könnte man denken, dass sie einer Art kollektivem Algorithmus folgen oder eine Form von *kollektiver Intelligenz* besitzen. Dieses komplexe Verhalten entsteht jedoch, wenn jeder einzelne Agent (in diesem Fall ein *Vogel*) nur einige andere Agenten in kurzer Entfernung beobachtet und drei einfache Regeln befolgt:
* **Ausrichtung** - er steuert in Richtung des durchschnittlichen Kurs der benachbarten Agenten
* **Kohäsion** - er versucht, in Richtung der durchschnittlichen Position der Nachbarn zu steuern (*langfristige Anziehung*)
* **Trennung** - wenn er zu nah an anderen Vögeln ist, versucht er, sich zu entfernen (*kurzfristige Abstoßung*)
* **Ausrichtung** – es steuert in Richtung der durchschnittlichen Flugrichtung benachbarter Agenten.
* **Kohäsion** – es versucht, sich in Richtung der durchschnittlichen Position der Nachbarn zu bewegen (*langreichweite Anziehung*).
* **Trennung** – wenn es anderen Vögeln zu nahe kommt, versucht es, sich zu entfernen (*kurzreichweite Abstoßung*).
Sie können das Vogelschwarm-Beispiel ausführen und das Verhalten beobachten. Sie können auch Parameter anpassen, wie den *Grad der Trennung* oder den *Sichtbereich*, der definiert, wie weit jeder Vogel sehen kann. Beachten Sie, dass, wenn Sie den Sichtbereich auf 0 reduzieren, alle Vögel blind werden und der Vogelschwarm stoppt. Wenn Sie die Trennung auf 0 reduzieren, versammeln sich alle Vögel in einer geraden Linie.
Sie können das Flocking-Beispiel ausführen und das Verhalten beobachten. Sie können auch Parameter anpassen, wie z. B. den *Grad der Trennung* oder die *Sichtweite*, die definiert, wie weit jeder Vogel sehen kann. Beachten Sie, dass alle Vögel blind werden und das Flocking stoppt, wenn Sie die Sichtweite auf 0 reduzieren. Wenn Sie die Trennung auf 0 reduzieren, sammeln sich alle Vögel in einer geraden Linie.
> ✅ Wechseln Sie zum **Code**-Tab und sehen Sie, wo die drei Regeln des Vogelschwarmes (Ausrichtung, Kohäsion und Trennung) im Code implementiert sind. Beachten Sie, wie wir uns nur auf die Agenten beziehen, die in Sichtweite sind.
> ✅ Wechseln Sie zum **Code**-Tab und sehen Sie, wo die drei Regeln des Flockings (Ausrichtung, Kohäsion und Trennung) im Code implementiert sind. Beachten Sie, wie wir uns nur auf die Agenten beziehen, die in Sichtweite sind.
### Weitere Modelle zum Ausprobieren
Es gibt noch einige weitere interessante Modelle, mit denen Sie experimentieren können:
Es gibt einige weitere interessante Modelle, die Sie ausprobieren können:
* **Kunst → Feuerwerk** zeigt, wie ein Feuerwerk als kollektives Verhalten individueller Feuerströme betrachtet werden kann.
* **Sozialwissenschaft → Verkehr Grundlegend** und **Sozialwissenschaft → Verkehr Raster** zeigen das Modell des Stadtverkehrs in 1D und 2D Rastern mit oder ohne Ampeln. Jedes Auto in der Simulation folgt den folgenden Regeln:
- Wenn der Raum vor ihm leer ist - beschleunigen (bis zu einer bestimmten Höchstgeschwindigkeit)
- Wenn es ein Hindernis vor sich sieht - bremsen (und Sie können anpassen, wie weit ein Fahrer sehen kann)
* **Sozialwissenschaft → Party** zeigt, wie Menschen sich während einer Cocktailparty gruppieren. Sie können die Kombination von Parametern finden, die zu einer schnellsten Steigerung des Glücks der Gruppe führen.
* **Kunst → Feuerwerk** zeigt, wie ein Feuerwerk als kollektives Verhalten einzelner Feuerströme betrachtet werden kann.
* **Sozialwissenschaften → Verkehr Basic** und **Sozialwissenschaften → Verkehr Grid** zeigen das Modell des Stadtverkehrs in 1D und 2D-Gitter mit oder ohne Ampeln. Jedes Auto in der Simulation folgt den folgenden Regeln:
- Wenn der Raum vor ihm leer ist – beschleunigen (bis zu einer bestimmten Maximalgeschwindigkeit).
- Wenn es ein Hindernis vor sich sieht – bremsen (und Sie können anpassen, wie weit ein Fahrer sehen kann).
* **Sozialwissenschaften → Party** zeigt, wie sich Menschen während einer Cocktailparty gruppieren. Sie können die Kombination von Parametern finden, die zu einer schnelleren Steigerung der Gruppenfreude führt.
Wie Sie an diesen Beispielen sehen können, können Multi-Agenten-Simulationen eine nützliche Möglichkeit sein, das Verhalten eines komplexen Systems zu verstehen, das aus Individuen besteht, die der gleichen oder ähnlichen Logik folgen. Sie können auch verwendet werden, um virtuelle Agenten zu steuern, wie [NPCs](https://de.wikipedia.org/wiki/NPC) in Computerspielen oder Agenten in 3D-animierten Welten.
Wie Sie aus diesen Beispielen sehen können, können Multi-Agenten-Simulationen eine nützliche Möglichkeit sein, das Verhalten eines komplexen Systems zu verstehen, das aus Individuen besteht, die derselben oder ähnlichen Logik folgen. Es kann auch verwendet werden, um virtuelle Agenten wie [NPCs](https://en.wikipedia.org/wiki/NPC) in Computerspielen oder Agenten in 3D-animierten Welten zu steuern.
## Deliberative Agenten
Die oben beschriebenen Agenten sind sehr einfach und reagieren auf Veränderungen in der Umgebung mithilfe einer Art Algorithmus. Daher sind sie **reaktive Agenten**. Manchmal können Agenten jedoch auch schlussfolgern und ihre Aktionen planen, in diesem Fall werden sie als **deliberative** bezeichnet.
Die oben beschriebenen Agenten sind sehr einfach und reagieren auf Änderungen in der Umgebung mithilfe einer Art Algorithmus. Als solche sind sie **reaktive Agenten**. Manchmal können Agenten jedoch denken und ihre Aktionen planen, in diesem Fall werden sie als **deliberative** bezeichnet.
Ein typisches Beispiel wäre ein persönlicher Agent, der eine Anweisung von einem Menschen erhält, um eine Urlaubsreise zu buchen. Angenommen, es gibt viele Agenten, die im Internet leben und ihm helfen können. Er sollte dann andere Agenten kontaktieren, um zu sehen, welche Flüge verfügbar sind, wie die Hotelpreise an verschiedenen Daten sind, und versuchen, den besten Preis auszuhandeln. Wenn der Urlaubsplan abgeschlossen und vom Besitzer bestätigt ist, kann er mit der Buchung fortfahren.
Ein typisches Beispiel wäre ein persönlicher Agent, der von einem Menschen die Anweisung erhält, eine Urlaubsreise zu buchen. Angenommen, es gibt viele Agenten im Internet, die ihm helfen können. Er sollte dann andere Agenten kontaktieren, um herauszufinden, welche Flüge verfügbar sind, wie hoch die Hotelpreise für verschiedene Daten sind, und versuchen, den besten Preis auszuhandeln. Wenn der Urlaubsplan abgeschlossen und vom Besitzer bestätigt ist, kann er mit der Buchung fortfahren.
Um dies zu tun, müssen Agenten **kommunizieren**. Für eine erfolgreiche Kommunikation benötigen sie:
* Einige **Standardsprachen zum Austausch von Wissen**, wie [Knowledge Interchange Format](https://de.wikipedia.org/wiki/Knowledge_Interchange_Format) (KIF) und [Knowledge Query and Manipulation Language](https://de.wikipedia.org/wiki/Knowledge_Query_and_Manipulation_Language) (KQML). Diese Sprachen sind auf der Grundlage der [Sprechakt-Theorie](https://de.wikipedia.org/wiki/Sprechakt) entworfen.
* Diese Sprachen sollten auch einige **Protokolle für Verhandlungen** beinhalten, basierend auf verschiedenen **Auktionsarten**.
* Eine **gemeinsame Ontologie**, die verwendet wird, damit sie sich auf die gleichen Konzepte beziehen und deren Semantik kennen.
* Eine Möglichkeit, um zu **entdecken**, was verschiedene Agenten tun können, ebenfalls basierend auf einer Art Ontologie.
* Einige **Standardsprachen zum Austausch von Wissen**, wie [Knowledge Interchange Format](https://en.wikipedia.org/wiki/Knowledge_Interchange_Format) (KIF) und [Knowledge Query and Manipulation Language](https://en.wikipedia.org/wiki/Knowledge_Query_and_Manipulation_Language) (KQML). Diese Sprachen basieren auf der [Sprechakttheorie](https://en.wikipedia.org/wiki/Speech_act).
* Diese Sprachen sollten auch einige **Protokolle für Verhandlungen** enthalten, basierend auf verschiedenen **Auktionstypen**.
* Eine **gemeinsame Ontologie**, damit sie sich auf dieselben Konzepte beziehen und deren Semantik kennen.
* Eine Möglichkeit, herauszufinden, was verschiedene Agenten tun können, ebenfalls basierend auf einer Art Ontologie.
Deliberative Agenten sind viel komplexer als reaktive, da sie nicht nur auf Veränderungen in der Umgebung reagieren, sondern auch in der Lage sein sollten, Aktionen *zu initiieren*. Eine der vorgeschlagenen Architekturen für deliberative Agenten ist der sogenannte Belief-Desire-Intention (BDI) Agent:
Deliberative Agenten sind viel komplexer als reaktive, da sie nicht nur auf Änderungen in der Umgebung reagieren, sondern auch Aktionen initiieren können. Eine der vorgeschlagenen Architekturen für deliberative Agenten ist der sogenannte Belief-Desire-Intention (BDI)-Agent:
* **Überzeugungen** bilden ein Set von Wissen über die Umgebung eines Agenten. Es kann als Wissensbasis oder Regelset strukturiert sein, das ein Agent auf eine spezifische Situation in der Umgebung anwenden kann.
* **Wünsche** definieren, was ein Agent tun möchte, d.h. seine Ziele. Zum Beispiel ist das Ziel des oben genannten persönlichen Assistenten, eine Reise zu buchen, und das Ziel eines Hotelagenten ist es, den Gewinn zu maximieren.
* **Absichten** sind spezifische Aktionen, die ein Agent plant, um seine Ziele zu erreichen. Aktionen verändern typischerweise die Umgebung und verursachen Kommunikation mit anderen Agenten.
* **Beliefs** bilden eine Wissensbasis über die Umgebung eines Agenten. Sie können als Wissensdatenbank oder Regelwerk strukturiert sein, das ein Agent auf eine bestimmte Situation in der Umgebung anwenden kann.
* **Desires** definieren, was ein Agent tun möchte, d. h. seine Ziele. Zum Beispiel ist das Ziel des persönlichen Assistenten-Agenten oben, eine Reise zu buchen, und das Ziel eines Hotel-Agenten ist es, den Gewinn zu maximieren.
* **Intentions** sind spezifische Aktionen, die ein Agent plant, um seine Ziele zu erreichen. Aktionen ändern typischerweise die Umgebung und führen zu Kommunikation mit anderen Agenten.
Es gibt einige Plattformen, die für den Aufbau von Multi-Agenten-Systemen verfügbar sind, wie [JADE](https://jade.tilab.com/). [Dieses Papier](https://arxiv.org/ftp/arxiv/papers/2007/2007.08961.pdf) enthält eine Übersicht über Multi-Agenten-Plattformen, zusammen mit einer kurzen Geschichte der Multi-Agenten-Systeme und ihren verschiedenen Anwendungsszenarien.
Es gibt einige Plattformen, die für den Aufbau von Multi-Agenten-Systemen verfügbar sind, wie [JADE](https://jade.tilab.com/). [Dieses Papier](https://arxiv.org/ftp/arxiv/papers/2007/2007.08961.pdf) enthält eine Übersicht über Multi-Agenten-Plattformen sowie eine kurze Geschichte der Multi-Agenten-Systeme und ihrer verschiedenen Anwendungsszenarien.
## Fazit
Multi-Agent-Systeme können sehr unterschiedliche Formen annehmen und in vielen verschiedenen Anwendungen eingesetzt werden. Sie konzentrieren sich alle auf das einfachere Verhalten eines einzelnen Agenten und erreichen komplexeres Verhalten des Gesamtsystems aufgrund des **synergetischen Effekts**.
Multi-Agenten-Systeme können sehr unterschiedliche Formen annehmen und in vielen verschiedenen Anwendungen eingesetzt werden.
Sie konzentrieren sich alle auf das einfachere Verhalten eines einzelnen Agenten und erreichen ein komplexeres Verhalten des Gesamtsystems durch den **synergetischen Effekt**.
## 🚀 Herausforderung
Bringen Sie diese Lektion in die reale Welt und versuchen Sie, ein Multi-Agenten-System zu konzipieren, das ein Problem lösen kann. Was müsste ein Multi-Agenten-System beispielsweise tun, um eine Schulbusroute zu optimieren? Wie könnte es in einer Bäckerei funktionieren?
Übertragen Sie diese Lektion in die reale Welt und versuchen Sie, ein Multi-Agenten-System zu konzeptualisieren, das ein Problem lösen kann. Was müsste ein Multi-Agenten-System beispielsweise tun, um eine Schulbusroute zu optimieren? Wie könnte es in einer Bäckerei funktionieren?
## [Nachvorlesungsquiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/223)
## [Quiz nach der Vorlesung](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/223)
## Überprüfung & Selbststudium
Überprüfen Sie die Verwendung dieses Typs von Systemen in der Industrie. Wählen Sie ein Gebiet wie die Fertigung oder die Videospielindustrie aus und entdecken Sie, wie Multi-Agenten-Systeme verwendet werden können, um einzigartige Probleme zu lösen.
Überprüfen Sie die Verwendung dieses Systemtyps in der Industrie. Wählen Sie einen Bereich wie die Fertigung oder die Videospielindustrie und entdecken Sie, wie Multi-Agenten-Systeme verwendet werden können, um einzigartige Probleme zu lösen.
## [NetLogo Aufgabe](assignment.md)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als autoritative 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 Verwendung dieser Übersetzung entstehen.
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.

13
translations/de/lessons/6-Other/23-MultiagentSystems/assignment.md
View File

@ -1,8 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "cf654ca60c7f86c8dad28596fb42994b",
"translation_date": "2025-08-24T09:38:40+00:00",
"source_file": "lessons/6-Other/23-MultiagentSystems/assignment.md",
"language_code": "de"
}
-->
# NetLogo Aufgabe
Wählen Sie eines der Modelle aus der Bibliothek von NetLogo und verwenden Sie es, um eine reale Situation so genau wie möglich zu simulieren. Ein gutes Beispiel wäre, das Virus-Modell im Ordner Alternative Visualisierungen anzupassen, um zu zeigen, wie es verwendet werden kann, um die Verbreitung von COVID-19 zu modellieren. Können Sie ein Modell erstellen, das eine reale virale Verbreitung nachahmt?
Nehmen Sie eines der Modelle aus der NetLogo-Bibliothek und verwenden Sie es, um eine reale Situation so genau wie möglich zu simulieren. Ein gutes Beispiel wäre, das Virus-Modell im Ordner Alternative Visualisierungen anzupassen, um zu zeigen, wie es verwendet werden kann, um die Ausbreitung von COVID-19 zu modellieren. Können Sie ein Modell erstellen, das die Ausbreitung eines echten Virus nachahmt?
Zeigen Sie Ihre Arbeit, indem Sie eine Kopie speichern und ein Video-Demo erstellen, das erklärt, wie das Modell mit einer realen Situation verbunden ist.
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, sollten Sie sich bewusst sein, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die maßgebliche Quelle betrachtet werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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 sich aus der Nutzung dieser Übersetzung ergeben.

59
translations/de/lessons/7-Ethics/README.md
View File

@ -1,43 +1,52 @@
# Ethische und Verantwortungsvolle KI
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "437c988596e751072e41a5aad3fcc5d9",
"translation_date": "2025-08-24T09:29:15+00:00",
"source_file": "lessons/7-Ethics/README.md",
"language_code": "de"
}
-->
# Ethische und verantwortungsvolle KI
Sie haben diesen Kurs fast abgeschlossen, und ich hoffe, dass Sie inzwischen klar erkennen, dass KI auf einer Reihe von formalen mathematischen Methoden basiert, die es uns ermöglichen, Beziehungen in Daten zu finden und Modelle zu trainieren, um einige Aspekte menschlichen Verhaltens zu replizieren. An diesem Punkt in der Geschichte betrachten wir KI als ein sehr mächtiges Werkzeug, um Muster aus Daten zu extrahieren und diese Muster anzuwenden, um neue Probleme zu lösen.
Sie haben diesen Kurs fast abgeschlossen, und ich hoffe, dass Sie mittlerweile klar erkennen, dass KI auf einer Reihe formaler mathematischer Methoden basiert, die es uns ermöglichen, Beziehungen in Daten zu finden und Modelle zu trainieren, um bestimmte Aspekte menschlichen Verhaltens nachzubilden. Zu diesem Zeitpunkt in der Geschichte betrachten wir KI als ein sehr mächtiges Werkzeug, um Muster aus Daten zu extrahieren und diese Muster anzuwenden, um neue Probleme zu lösen.
## [Vorlesungsquiz](https://white-water-09ec41f0f.azurestaticapps.net/quiz/5/)
## [Quiz vor der Vorlesung](https://white-water-09ec41f0f.azurestaticapps.net/quiz/5/)
In der Science-Fiction sehen wir jedoch oft Geschichten, in denen KI eine Gefahr für die Menschheit darstellt. In der Regel konzentrieren sich diese Geschichten auf eine Art von KI-Rebellion, wenn KI beschließt, sich den Menschen zu widersetzen. Das impliziert, dass KI eine Art von Emotion hat oder Entscheidungen trifft, die von ihren Entwicklern nicht vorhergesehen wurden.
In der Science-Fiction sehen wir jedoch oft Geschichten, in denen KI eine Gefahr für die Menschheit darstellt. Diese Geschichten drehen sich meist um eine Art KI-Rebellion, bei der die KI beschließt, sich gegen die Menschen zu stellen. Dies impliziert, dass KI eine Art Emotion besitzt oder Entscheidungen treffen kann, die von ihren Entwicklern nicht vorhergesehen wurden.
Die Art von KI, die wir in diesem Kurs kennengelernt haben, ist nichts weiter als große Matrizenarithmetik. Es ist ein sehr mächtiges Werkzeug, das uns hilft, unsere Probleme zu lösen, und wie jedes andere mächtige Werkzeug kann es sowohl für gute als auch für schlechte Zwecke eingesetzt werden. Wichtig ist, dass es *missbraucht* werden kann.
Die Art von KI, die wir in diesem Kurs kennengelernt haben, ist nichts anderes als umfangreiche Matrizenarithmetik. Es ist ein sehr mächtiges Werkzeug, das uns hilft, unsere Probleme zu lösen, und wie jedes andere mächtige Werkzeug kann es sowohl für gute als auch für schlechte Zwecke eingesetzt werden. Wichtig ist, dass es *missbraucht* werden kann.
## Prinzipien der Verantwortungsvolle KI
## Prinzipien der verantwortungsvollen KI
Um diesen unbeabsichtigten oder absichtlichen Missbrauch von KI zu vermeiden, gibt Microsoft die wichtigen [Prinzipien der Verantwortungsvolle KI](https://www.microsoft.com/ai/responsible-ai?WT.mc_id=academic-77998-cacaste) an. Die folgenden Konzepte bilden die Grundlage für diese Prinzipien:
Um einen zufälligen oder absichtlichen Missbrauch von KI zu vermeiden, hat Microsoft die wichtigen [Prinzipien der verantwortungsvollen KI](https://www.microsoft.com/ai/responsible-ai?WT.mc_id=academic-77998-cacaste) definiert. Die folgenden Konzepte bilden die Grundlage dieser Prinzipien:
* **Fairness** hängt mit dem wichtigen Problem der *Modellverzerrungen* zusammen, die durch die Verwendung von voreingenommenen Daten für das Training verursacht werden können. Zum Beispiel, wenn wir die Wahrscheinlichkeit vorhersagen wollen, dass eine Person einen Job als Softwareentwickler erhält, wird das Modell wahrscheinlich Männern eine höhere Präferenz einräumen – nur weil der Trainingsdatensatz wahrscheinlich auf ein männliches Publikum ausgerichtet war. Wir müssen die Trainingsdaten sorgfältig ausbalancieren und das Modell untersuchen, um Verzerrungen zu vermeiden und sicherzustellen, dass das Modell relevantere Merkmale berücksichtigt.
* **Zuverlässigkeit und Sicherheit**. Aufgrund ihrer Natur können KI-Modelle Fehler machen. Ein neuronales Netzwerk gibt Wahrscheinlichkeiten zurück, und wir müssen dies bei Entscheidungen berücksichtigen. Jedes Modell hat eine gewisse Präzision und Rückrufquote, und wir müssen verstehen, dass wir Schäden, die falsche Ratschläge verursachen können, verhindern müssen.
* **Datenschutz und Sicherheit** haben einige KI-spezifische Implikationen. Zum Beispiel, wenn wir einige Daten zum Trainieren eines Modells verwenden, werden diese Daten irgendwie "integriert" in das Modell. Einerseits erhöht das die Sicherheit und den Datenschutz, andererseits müssen wir uns daran erinnern, auf welchen Daten das Modell trainiert wurde.
* **Inklusivität** bedeutet, dass wir KI nicht entwickeln, um Menschen zu ersetzen, sondern um Menschen zu unterstützen und unsere Arbeit kreativer zu gestalten. Es hängt auch mit Fairness zusammen, denn im Umgang mit unterrepräsentierten Gemeinschaften sind die meisten Datensätze, die wir sammeln, wahrscheinlich voreingenommen, und wir müssen sicherstellen, dass diese Gemeinschaften einbezogen und korrekt von der KI behandelt werden.
* **Transparenz**. Dazu gehört, dass wir immer klar kommunizieren, dass KI verwendet wird. Auch wo immer möglich, möchten wir KI-Systeme nutzen, die *interpretierbar* sind.
* **Rechenschaftspflicht**. Wenn KI-Modelle Entscheidungen treffen, ist nicht immer klar, wer für diese Entscheidungen verantwortlich ist. Wir müssen sicherstellen, dass wir verstehen, wo die Verantwortung für KI-Entscheidungen liegt. In den meisten Fällen möchten wir Menschen in den Entscheidungsprozess einbeziehen, damit tatsächliche Personen zur Rechenschaft gezogen werden.
* **Fairness** bezieht sich auf das wichtige Problem der *Modellverzerrungen*, die durch die Verwendung von voreingenommenen Trainingsdaten verursacht werden können. Zum Beispiel, wenn wir versuchen, die Wahrscheinlichkeit vorherzusagen, dass eine Person einen Job als Softwareentwickler bekommt, wird das Modell wahrscheinlich Männern den Vorzug geben – einfach weil der Trainingsdatensatz wahrscheinlich auf eine männliche Zielgruppe ausgerichtet war. Wir müssen die Trainingsdaten sorgfältig ausbalancieren und das Modell untersuchen, um Verzerrungen zu vermeiden und sicherzustellen, dass das Modell relevantere Merkmale berücksichtigt.
* **Zuverlässigkeit und Sicherheit**. KI-Modelle können von Natur aus Fehler machen. Ein neuronales Netzwerk liefert Wahrscheinlichkeiten, und das müssen wir bei Entscheidungen berücksichtigen. Jedes Modell hat eine bestimmte Präzision und einen bestimmten Rückrufwert, und wir müssen das verstehen, um Schäden zu vermeiden, die durch falsche Ratschläge entstehen können.
* **Privatsphäre und Sicherheit** haben einige KI-spezifische Implikationen. Zum Beispiel wird die verwendete Trainingsdaten irgendwie in das Modell "integriert". Einerseits erhöht das die Sicherheit und Privatsphäre, andererseits müssen wir uns daran erinnern, welche Daten für das Training des Modells verwendet wurden.
* **Inklusivität** bedeutet, dass wir KI nicht entwickeln, um Menschen zu ersetzen, sondern um sie zu unterstützen und unsere Arbeit kreativer zu gestalten. Es steht auch in Zusammenhang mit Fairness, denn wenn wir mit unterrepräsentierten Gemeinschaften arbeiten, sind die meisten der gesammelten Datensätze wahrscheinlich voreingenommen. Wir müssen sicherstellen, dass diese Gemeinschaften einbezogen und korrekt von der KI behandelt werden.
* **Transparenz**. Dazu gehört, dass wir immer klarstellen, wenn KI verwendet wird. Außerdem möchten wir, wo immer möglich, KI-Systeme verwenden, die *interpretierbar* sind.
* **Verantwortlichkeit**. Wenn KI-Modelle Entscheidungen treffen, ist nicht immer klar, wer für diese Entscheidungen verantwortlich ist. Wir müssen sicherstellen, dass wir verstehen, wo die Verantwortung für KI-Entscheidungen liegt. In den meisten Fällen möchten wir Menschen in den Entscheidungsprozess einbeziehen, damit tatsächliche Personen zur Verantwortung gezogen werden können.
## Werkzeuge für Verantwortungsvolle KI
## Werkzeuge für verantwortungsvolle KI
Microsoft hat die [Responsible AI Toolbox](https://github.com/microsoft/responsible-ai-toolbox) entwickelt, die eine Reihe von Werkzeugen enthält:
Microsoft hat das [Responsible AI Toolbox](https://github.com/microsoft/responsible-ai-toolbox) entwickelt, das eine Reihe von Werkzeugen enthält:
* Interpretierbarkeit-Dashboard (InterpretML)
* Fairness-Dashboard (FairLearn)
* Fehleranalyse-Dashboard
* Verantwortungsvolles KI-Dashboard, das Folgendes umfasst
* Interpretability Dashboard (InterpretML)
* Fairness Dashboard (FairLearn)
* Error Analysis Dashboard
* Responsible AI Dashboard, das Folgendes umfasst:
- EconML - ein Werkzeug für Kausalanalyse, das sich auf Was-wäre-wenn-Fragen konzentriert
- DiCE - ein Werkzeug für kontrafaktische Analysen, mit dem Sie sehen können, welche Merkmale geändert werden müssen, um die Entscheidung des Modells zu beeinflussen
- EconML – ein Tool für Kausalanalysen, das sich auf Was-wäre-wenn-Fragen konzentriert
- DiCE – ein Tool für kontrafaktische Analysen, mit dem Sie sehen können, welche Merkmale geändert werden müssen, um die Entscheidung des Modells zu beeinflussen
Für weitere Informationen über KI-Ethische Grundsätze besuchen Sie bitte [diese Lektion](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/3-fairness?WT.mc_id=academic-77998-cacaste) im Lehrplan für maschinelles Lernen, der Aufgaben enthält.
Weitere Informationen zur KI-Ethik finden Sie in [dieser Lektion](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/3-fairness?WT.mc_id=academic-77998-cacaste) im Machine Learning Curriculum, das auch Aufgaben enthält.
## Überprüfung & Selbststudium
Nehmen Sie diesen [Lernpfad](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77998-cacaste), um mehr über verantwortungsvolle KI zu erfahren.
Nehmen Sie an diesem [Lernpfad](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77998-cacaste) teil, um mehr über verantwortungsvolle KI zu erfahren.
## [Nachlesungsquiz](https://white-water-09ec41f0f.azurestaticapps.net/quiz/6/)
## [Quiz nach der Vorlesung](https://white-water-09ec41f0f.azurestaticapps.net/quiz/6/)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 aus der Verwendung dieser Übersetzung resultieren.
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.

15
translations/de/lessons/README.md
View File

@ -1,8 +1,17 @@
# Übersicht
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5fef1a0b22498d7188959e2a2cb08af7",
"translation_date": "2025-08-24T09:29:11+00:00",
"source_file": "lessons/README.md",
"language_code": "de"
}
-->
# Überblick
![Übersicht in einem Doodle](../../../translated_images/ai-overview.0857791951d19500d0ef8b803d77110c738dcafc52306e6d68724742cd4af167.de.png)
![Überblick in einer Kritzelei](../../../lessons/sketchnotes/ai-overview.png)
> Sketchnote von [Tomomi Imura](https://twitter.com/girlie_mac)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

73
translations/de/lessons/X-Extras/X1-MultiModal/README.md
View File

@ -1,79 +1,88 @@
# Multi-Modal Netzwerke
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9c592c26aca16ca085d268c732284187",
"translation_date": "2025-08-24T09:39:16+00:00",
"source_file": "lessons/X-Extras/X1-MultiModal/README.md",
"language_code": "de"
}
-->
# Multi-Modale Netzwerke
Nach dem Erfolg von Transformermodellen zur Lösung von NLP-Aufgaben wurden dieselben oder ähnliche Architekturen auf Aufgaben der Computer Vision angewendet. Das Interesse wächst, Modelle zu entwickeln, die die Fähigkeiten von Vision und natürlicher Sprache *kombinieren*. Ein solcher Versuch wurde von OpenAI unternommen und trägt den Namen CLIP und DALL.E.
Nach dem Erfolg von Transformer-Modellen bei der Lösung von NLP-Aufgaben wurden ähnliche Architekturen auch auf Aufgaben der Computer Vision angewendet. Es gibt ein wachsendes Interesse daran, Modelle zu entwickeln, die Vision- und Sprachfähigkeiten *kombinieren*. Ein solcher Versuch wurde von OpenAI unternommen und nennt sich CLIP und DALL.E.
## Kontrastives Bildvortraining (CLIP)
## Contrastive Image Pre-Training (CLIP)
Die Hauptidee von CLIP besteht darin, Textaufforderungen mit einem Bild zu vergleichen und zu bestimmen, wie gut das Bild zur Aufforderung passt.
Die Hauptidee von CLIP ist, Textaufforderungen mit einem Bild vergleichen zu können und zu bestimmen, wie gut das Bild zur Aufforderung passt.
![CLIP Architektur](../../../../../translated_images/clip-arch.b3dbf20b4e8ed8be1c38e2bc6100fd3cc257c33cda4692b301be91f791b13ea7.de.png)
![CLIP Architektur](../../../../../lessons/X-Extras/X1-MultiModal/images/clip-arch.png)
> *Bild aus [diesem Blogbeitrag](https://openai.com/blog/clip/)*
Das Modell wird mit Bildern aus dem Internet und deren Beschreibungen trainiert. Für jede Batch nehmen wir N Paare von (Bild, Text) und wandeln sie in einige Vektorrepräsentationen um. Diese Repräsentationen werden dann zusammengeführt. Die Verlustfunktion ist so definiert, dass die Kosinusähnlichkeit zwischen Vektoren eines Paares (z.B. I und T) maximiert und die Kosinusähnlichkeit zwischen allen anderen Paaren minimiert wird. Das ist der Grund, warum dieser Ansatz als **kontrastiv** bezeichnet wird.
Das Modell wird mit Bildern aus dem Internet und deren Beschreibungen trainiert. Für jede Batch nehmen wir N Paare aus (Bild, Text) und konvertieren sie in Vektorrepräsentationen I, ..., I / T, ..., T. Diese Repräsentationen werden dann miteinander abgeglichen. Die Verlustfunktion ist so definiert, dass die Kosinusähnlichkeit zwischen den Vektoren eines Paares (z. B. I und T) maximiert und die Kosinusähnlichkeit zwischen allen anderen Paaren minimiert wird. Aus diesem Grund wird dieser Ansatz als **kontrastiv** bezeichnet.
Das CLIP-Modell/bibliothek ist von [OpenAI GitHub](https://github.com/openai/CLIP) verfügbar. Der Ansatz wird in [diesem Blogbeitrag](https://openai.com/blog/clip/) beschrieben und detaillierter in [diesem Papier](https://arxiv.org/pdf/2103.00020.pdf).
Die CLIP-Bibliothek/Modell ist verfügbar auf [OpenAI GitHub](https://github.com/openai/CLIP). Der Ansatz wird in [diesem Blogbeitrag](https://openai.com/blog/clip/) beschrieben und ausführlicher in [diesem Paper](https://arxiv.org/pdf/2103.00020.pdf).
Sobald dieses Modell vortrainiert ist, können wir ihm eine Batch von Bildern und eine Batch von Textaufforderungen geben, und es wird uns den Tensor mit Wahrscheinlichkeiten zurückgeben. CLIP kann für mehrere Aufgaben verwendet werden:
Sobald dieses Modell vortrainiert ist, können wir ihm eine Batch von Bildern und eine Batch von Textaufforderungen geben, und es wird einen Tensor mit Wahrscheinlichkeiten zurückgeben. CLIP kann für verschiedene Aufgaben verwendet werden:
**Bildklassifikation**
Angenommen, wir müssen Bilder zwischen, sagen wir, Katzen, Hunden und Menschen klassifizieren. In diesem Fall können wir dem Modell ein Bild und eine Reihe von Textaufforderungen geben: "*ein Bild einer Katze*", "*ein Bild eines Hundes*", "*ein Bild eines Menschen*". In dem resultierenden Vektor von 3 Wahrscheinlichkeiten müssen wir nur den Index mit dem höchsten Wert auswählen.
Angenommen, wir müssen Bilder zwischen Katzen, Hunden und Menschen klassifizieren. In diesem Fall können wir dem Modell ein Bild und eine Reihe von Textaufforderungen geben: "*ein Bild einer Katze*", "*ein Bild eines Hundes*", "*ein Bild eines Menschen*". Im resultierenden Vektor mit 3 Wahrscheinlichkeiten müssen wir nur den Index mit dem höchsten Wert auswählen.
![CLIP für Bildklassifikation](../../../../../translated_images/clip-class.3af42ef0b2b19369a633df5f20ddf4f5a01d6c8ffa181e9d3a0572c19f919f72.de.png)
![CLIP für Bildklassifikation](../../../../../lessons/X-Extras/X1-MultiModal/images/clip-class.png)
> *Bild aus [diesem Blogbeitrag](https://openai.com/blog/clip/)*
**Textbasierte Bildsuche**
Wir können auch das Gegenteil tun. Wenn wir eine Sammlung von Bildern haben, können wir diese Sammlung dem Modell übergeben und eine Textaufforderung - das wird uns das Bild zurückgeben, das der gegebenen Aufforderung am ähnlichsten ist.
Wir können auch das Gegenteil tun. Wenn wir eine Sammlung von Bildern haben, können wir diese Sammlung dem Modell übergeben und eine Textaufforderung - dies wird uns das Bild geben, das am ähnlichsten zur gegebenen Aufforderung ist.
## ✍️ Beispiel: [CLIP für Bildklassifikation und Bildsuche verwenden](../../../../../lessons/X-Extras/X1-MultiModal/Clip.ipynb)
Öffnen Sie das [Clip.ipynb](../../../../../lessons/X-Extras/X1-MultiModal/Clip.ipynb) Notizbuch, um CLIP in Aktion zu sehen.
Öffne das [Clip.ipynb](../../../../../lessons/X-Extras/X1-MultiModal/Clip.ipynb)-Notebook, um CLIP in Aktion zu sehen.
## Bildgenerierung mit VQGAN+ CLIP
## Bildgenerierung mit VQGAN+CLIP
CLIP kann auch für die **Bildgenerierung** aus einer Textaufforderung verwendet werden. Um dies zu tun, benötigen wir ein **Generator-Modell**, das in der Lage ist, Bilder basierend auf einem Vektor-Input zu erzeugen. Eines dieser Modelle wird [VQGAN](https://compvis.github.io/taming-transformers/) (Vektor-Quantisierter GAN) genannt.
CLIP kann auch für die **Bildgenerierung** aus einer Textaufforderung verwendet werden. Dazu benötigen wir ein **Generator-Modell**, das Bilder basierend auf einer Vektoreingabe generieren kann. Eines dieser Modelle nennt sich [VQGAN](https://compvis.github.io/taming-transformers/) (Vector-Quantized GAN).
Die Hauptideen von VQGAN, die es von gewöhnlichen [GAN](../../4-ComputerVision/10-GANs/README.md) unterscheiden, sind die folgenden:
* Verwendung einer autoregressiven Transformer-Architektur zur Generierung einer Sequenz von kontextreichen visuellen Teilen, die das Bild zusammensetzen. Diese visuellen Teile werden wiederum von [CNN](../../4-ComputerVision/07-ConvNets/README.md) gelernt.
* Verwendung eines Subbild-Discriminators, der erkennt, ob Teile des Bildes "echt" oder "falsch" sind (im Gegensatz zu dem "Alles-oder-Nichts"-Ansatz in traditionellen GANs).
Die Hauptideen von VQGAN, die es von gewöhnlichen [GAN](../../4-ComputerVision/10-GANs/README.md) unterscheiden, sind folgende:
* Verwendung einer autoregressiven Transformer-Architektur, um eine Sequenz kontextreicher visueller Teile zu generieren, die das Bild zusammensetzen. Diese visuellen Teile werden wiederum von [CNN](../../4-ComputerVision/07-ConvNets/README.md) gelernt.
* Einsatz eines Sub-Bild-Diskriminators, der erkennt, ob Teile des Bildes "echt" oder "gefälscht" sind (im Gegensatz zum "Alles-oder-Nichts"-Ansatz bei traditionellen GANs).
Erfahren Sie mehr über VQGAN auf der Website [Taming Transformers](https://compvis.github.io/taming-transformers/).
Erfahre mehr über VQGAN auf der [Taming Transformers](https://compvis.github.io/taming-transformers/) Webseite.
Einer der wichtigen Unterschiede zwischen VQGAN und traditionellen GAN ist, dass letztere aus jedem Eingangsvektor ein annehmbares Bild erzeugen können, während VQGAN wahrscheinlich ein Bild erzeugt, das nicht kohärent wäre. Daher müssen wir den Bildschaffungsprozess weiter leiten, und das kann mit CLIP erfolgen.
Ein wichtiger Unterschied zwischen VQGAN und traditionellen GANs ist, dass letztere ein brauchbares Bild aus jedem Eingabevektor erzeugen können, während VQGAN wahrscheinlich ein Bild erzeugt, das nicht kohärent ist. Daher müssen wir den Bildgenerierungsprozess weiter steuern, und das kann mit CLIP erfolgen.
![VQGAN+CLIP Architektur](../../../../../translated_images/vqgan.5027fe05051dfa3101950cfa930303f66e6478b9bd273e83766731796e462d9b.de.png)
![VQGAN+CLIP Architektur](../../../../../lessons/X-Extras/X1-MultiModal/images/vqgan.png)
Um ein Bild zu erzeugen, das einer Textaufforderung entspricht, beginnen wir mit einem zufälligen Kodierungsvektor, der durch VQGAN geleitet wird, um ein Bild zu erzeugen. Dann wird CLIP verwendet, um eine Verlustfunktion zu erzeugen, die zeigt, wie gut das Bild zur Textaufforderung passt. Das Ziel ist es dann, diesen Verlust zu minimieren, indem wir die Eingangsvektorparameter mittels Rückpropagation anpassen.
Um ein Bild zu erzeugen, das einer Textaufforderung entspricht, beginnen wir mit einem zufälligen Codierungsvektor, der durch VQGAN geleitet wird, um ein Bild zu erzeugen. Dann wird CLIP verwendet, um eine Verlustfunktion zu erzeugen, die zeigt, wie gut das Bild zur Textaufforderung passt. Ziel ist es, diesen Verlust zu minimieren, indem die Parameter des Eingabevektors mittels Backpropagation angepasst werden.
Eine großartige Bibliothek, die VQGAN+CLIP implementiert, ist [Pixray](http://github.com/pixray/pixray).
![Bild von Pixray erzeugt](../../../../../translated_images/a_closeup_watercolor_portrait_of_young_male_teacher_of_literature_with_a_book.2384968e9db8a0d09dc96de938b9f95bde8a7e1c721f48f286a7795bf16d56c7.de.png) | ![Bild von Pixray erzeugt](../../../../../translated_images/a_closeup_oil_portrait_of_young_female_teacher_of_computer_science_with_a_computer.e0b6495f210a439077e1c32cc8afdf714e634fe24dc78dc5aa45fd2f560b0ed5.de.png) | ![Bild von Pixray erzeugt](../../../../../translated_images/a_closeup_oil_portrait_of_old_male_teacher_of_math.5362e67aa7fc2683b9d36a613b364deb7454760cd39205623fc1e3938fa133c0.de.png)
![Bild von Pixray erzeugt](../../../../../lessons/X-Extras/X1-MultiModal/images/a_closeup_watercolor_portrait_of_young_male_teacher_of_literature_with_a_book.png) | ![Bild von Pixray erzeugt](../../../../../lessons/X-Extras/X1-MultiModal/images/a_closeup_oil_portrait_of_young_female_teacher_of_computer_science_with_a_computer.png) | ![Bild von Pixray erzeugt](../../../../../lessons/X-Extras/X1-MultiModal/images/a_closeup_oil_portrait_of_old_male_teacher_of_math.png)
----|----|----
Bild erzeugt aus der Aufforderung *ein Nahaufnahme-Aquarell-Porträt eines jungen männlichen Lehrers für Literatur mit einem Buch* | Bild erzeugt aus der Aufforderung *ein Nahaufnahme-Öl-Porträt einer jungen weiblichen Lehrerin für Informatik mit einem Computer* | Bild erzeugt aus der Aufforderung *ein Nahaufnahme-Öl-Porträt eines alten männlichen Lehrers für Mathematik vor einer Tafel*
Bild generiert aus der Aufforderung *ein Nahaufnahme-Aquarellporträt eines jungen männlichen Literaturlehrers mit einem Buch* | Bild generiert aus der Aufforderung *ein Nahaufnahme-Ölporträt einer jungen weiblichen Informatiklehrerin mit einem Computer* | Bild generiert aus der Aufforderung *ein Nahaufnahme-Ölporträt eines alten männlichen Mathematiklehrers vor einer Tafel*
> Bilder aus der Sammlung **Künstliche Lehrer** von [Dmitry Soshnikov](http://soshnikov.com)
> Bilder aus der **Artificial Teachers**-Sammlung von [Dmitry Soshnikov](http://soshnikov.com)
## DALL-E
### [DALL-E 1](https://openai.com/research/dall-e)
DALL-E ist eine Version von GPT-3, die darauf trainiert wurde, Bilder aus Aufforderungen zu generieren. Es wurde mit 12 Milliarden Parametern trainiert.
DALL-E ist eine Version von GPT-3, die darauf trainiert ist, Bilder aus Aufforderungen zu generieren. Es wurde mit 12 Milliarden Parametern trainiert.
Im Gegensatz zu CLIP erhält DALL-E sowohl Text als auch Bild als einen einzigen Stream von Tokens für Bilder und Text. Daher können Sie aus mehreren Aufforderungen Bilder basierend auf dem Text generieren.
Im Gegensatz zu CLIP erhält DALL-E sowohl Text als auch Bild als einen einzigen Strom von Tokens für Bilder und Text. Daher können aus mehreren Aufforderungen Bilder basierend auf dem Text generiert werden.
### [DALL-E 2](https://openai.com/dall-e-2)
Der Hauptunterschied zwischen DALL-E 1 und 2 besteht darin, dass es realistischere Bilder und Kunstwerke generiert.
Der Hauptunterschied zwischen DALL-E 1 und 2 besteht darin, dass es realistischere Bilder und Kunstwerke erzeugt.
Beispiele für Bildgenerierungen mit DALL-E:
![Bild von Pixray erzeugt](../../../../../translated_images/DALL·E%202023-06-20%2015.56.56%20-%20a%20closeup%20watercolor%20portrait%20of%20young%20male%20teacher%20of%20literature%20with%20a%20book.6c235e8271d9ed10ce985d86aeb241a58518958647973af136912116b9518fce.de.png) | ![Bild von Pixray erzeugt](../../../../../translated_images/DALL·E%202023-06-20%2015.57.43%20-%20a%20closeup%20oil%20portrait%20of%20young%20female%20teacher%20of%20computer%20science%20with%20a%20computer.f21dc4166340b6c8b4d1cb57efd1e22127407f9b28c9ac7afe11344065369e64.de.png) | ![Bild von Pixray erzeugt](../../../../../translated_images/DALL·E%202023-06-20%2015.58.42%20-%20%20a%20closeup%20oil%20portrait%20of%20old%20male%20teacher%20of%20mathematics%20in%20front%20of%20blackboard.d331c2dfbdc3f7c46aa65c0809066f5e7ed4b49609cd259852e760df21051e4a.de.png)
![Bild von DALL-E erzeugt](../../../../../lessons/X-Extras/X1-MultiModal/images/DALL·E%202023-06-20%2015.56.56%20-%20a%20closeup%20watercolor%20portrait%20of%20young%20male%20teacher%20of%20literature%20with%20a%20book.png) | ![Bild von DALL-E erzeugt](../../../../../lessons/X-Extras/X1-MultiModal/images/DALL·E%202023-06-20%2015.57.43%20-%20a%20closeup%20oil%20portrait%20of%20young%20female%20teacher%20of%20computer%20science%20with%20a%20computer.png) | ![Bild von DALL-E erzeugt](../../../../../lessons/X-Extras/X1-MultiModal/images/DALL·E%202023-06-20%2015.58.42%20-%20%20a%20closeup%20oil%20portrait%20of%20old%20male%20teacher%20of%20mathematics%20in%20front%20of%20blackboard.png)
----|----|----
Bild erzeugt aus der Aufforderung *ein Nahaufnahme-Aquarell-Porträt eines jungen männlichen Lehrers für Literatur mit einem Buch* | Bild erzeugt aus der Aufforderung *ein Nahaufnahme-Öl-Porträt einer jungen weiblichen Lehrerin für Informatik mit einem Computer* | Bild erzeugt aus der Aufforderung *ein Nahaufnahme-Öl-Porträt eines alten männlichen Lehrers für Mathematik vor einer Tafel*
Bild generiert aus der Aufforderung *ein Nahaufnahme-Aquarellporträt eines jungen männlichen Literaturlehrers mit einem Buch* | Bild generiert aus der Aufforderung *ein Nahaufnahme-Ölporträt einer jungen weiblichen Informatiklehrerin mit einem Computer* | Bild generiert aus der Aufforderung *ein Nahaufnahme-Ölporträt eines alten männlichen Mathematiklehrers vor einer Tafel*
## Referenzen
* VQGAN Papier: [Taming Transformers for High-Resolution Image Synthesis](https://compvis.github.io/taming-transformers/paper/paper.pdf)
* CLIP Papier: [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/pdf/2103.00020.pdf)
* VQGAN Paper: [Taming Transformers for High-Resolution Image Synthesis](https://compvis.github.io/taming-transformers/paper/paper.pdf)
* CLIP Paper: [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/pdf/2103.00020.pdf)
**Haftungsausschluss**:
Dieses Dokument wurde mithilfe von maschinellen KI-Übersetzungsdiensten ü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 aus der Verwendung dieser Übersetzung entstehen.
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.

177
translations/de/lessons/sketchnotes/LICENSE.md
View File

@ -1,150 +1,151 @@
Attribution-ShareAlike 4.0 International
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "45ab63a2cd8f5faef6c9b150618837a4",
"translation_date": "2025-08-24T09:42:06+00:00",
"source_file": "lessons/sketchnotes/LICENSE.md",
"language_code": "de"
}
-->
Attribution-Weitergabe unter gleichen Bedingungen 4.0 International
=======================================================================
Die Creative Commons Corporation ("Creative Commons") ist kein Rechtsanwalt und bietet keine rechtlichen Dienstleistungen oder Rechtsberatung an. Die Verbreitung der Creative Commons-Publik lizenzen begründet keine Anwalt- Mandanten- oder andere Beziehungen. Creative Commons stellt seine Lizenzen und die zugehörigen Informationen auf einer „wie sie sind“-Basis zur Verfügung. Creative Commons gibt keine Garantien in Bezug auf seine Lizenzen, Materialien, die unter deren Bedingungen lizenziert sind, oder verwandte Informationen. Creative Commons schließt jegliche Haftung für Schäden, die aus ihrer Nutzung resultieren, im größtmöglichen Umfang aus.
Die Creative Commons Corporation ("Creative Commons") ist keine Anwaltskanzlei und bietet keine juristischen Dienstleistungen oder Rechtsberatung an. Die Verbreitung von Creative-Commons-Lizenzen begründet keine Anwalts-Mandanten-Beziehung oder eine andere Beziehung. Creative Commons stellt seine Lizenzen und die dazugehörigen Informationen auf einer "wie besehen"-Basis zur Verfügung. Creative Commons übernimmt keine Garantien in Bezug auf seine Lizenzen, das unter deren Bedingungen lizenzierte Material oder die dazugehörigen Informationen. Creative Commons lehnt jegliche Haftung für Schäden, die aus ihrer Nutzung resultieren, im größtmöglichen gesetzlich zulässigen Umfang ab.
Verwendung der Creative Commons-Publiklizenzen
Verwendung von Creative-Commons-Lizenzen
Die Creative Commons-Publiklizenzen bieten einen standardisierten Satz von Bedingungen und Konditionen, die Urheber und andere Rechteinhaber nutzen können, um originale Werke der Urheberschaft und andere urheberrechtlich geschützte Materialien sowie bestimmte andere Rechte, die in der untenstehenden öffentlichen Lizenz angegeben sind, zu teilen. Die folgenden Überlegungen dienen nur zu Informationszwecken, sind nicht abschließend und bilden keinen Bestandteil unserer Lizenzen.
Creative-Commons-Lizenzen bieten eine standardisierte Reihe von Bedingungen, die Urheber und andere Rechteinhaber nutzen können, um originale Werke und anderes urheberrechtlich geschütztes Material sowie bestimmte andere Rechte zu teilen, wie in der untenstehenden Lizenz beschrieben. Die folgenden Überlegungen dienen nur zu Informationszwecken, sind nicht abschließend und sind kein Bestandteil unserer Lizenzen.
Überlegungen für Lizenzgeber: Unsere Publik lizenzen sind für die Nutzung durch diejenigen gedacht, die befugt sind, der Öffentlichkeit die Erlaubnis zu erteilen, Materialien auf eine Weise zu verwenden, die durch Urheberrecht und bestimmte andere Rechte eingeschränkt ist. Unsere Lizenzen sind unwiderruflich. Lizenzgeber sollten die Bedingungen und Konditionen der Lizenz, die sie wählen, sorgfältig lesen und verstehen, bevor sie sie anwenden. Lizenzgeber sollten auch alle notwendigen Rechte sichern, bevor sie unsere Lizenzen anwenden, damit die Öffentlichkeit das Material wie erwartet wiederverwenden kann. Lizenzgeber sollten deutlich kennzeichnen, welches Material nicht unter die Lizenz fällt. Dazu gehören andere CC-lizenzierte Materialien oder Materialien, die unter einer Ausnahme oder Einschränkung des Urheberrechts verwendet werden. Weitere Überlegungen für Lizenzgeber: wiki.creativecommons.org/Considerations_for_licensors
Überlegungen für Lizenzgeber: Unsere Lizenzen sind für diejenigen gedacht, die berechtigt sind, der Öffentlichkeit die Nutzung von Material zu gestatten, das ansonsten durch Urheberrecht und bestimmte andere Rechte eingeschränkt ist. Unsere Lizenzen sind unwiderruflich. Lizenzgeber sollten die Bedingungen der gewählten Lizenz lesen und verstehen, bevor sie diese anwenden. Lizenzgeber sollten auch sicherstellen, dass sie alle notwendigen Rechte besitzen, bevor sie unsere Lizenzen anwenden, damit die Öffentlichkeit das Material wie erwartet wiederverwenden kann. Lizenzgeber sollten klar kennzeichnen, welches Material nicht unter die Lizenz fällt. Dies schließt anderes CC-lizenziertes Material oder Material ein, das unter eine Ausnahme oder Einschränkung des Urheberrechts fällt. Weitere Überlegungen für Lizenzgeber:
wiki.creativecommons.org/Considerations_for_licensors
Überlegungen für die Öffentlichkeit: Durch die Verwendung einer unserer Publik lizenzen gewährt ein Lizenzgeber der Öffentlichkeit die Erlaubnis, das lizenzierte Material unter den angegebenen Bedingungen zu verwenden. Wenn die Erlaubnis des Lizenzgebers aus irgendeinem Grund nicht erforderlich ist – beispielsweise aufgrund einer anwendbaren Ausnahme oder Einschränkung des Urheberrechts – dann unterliegt diese Nutzung nicht der Lizenz. Unsere Lizenzen gewähren nur die Erlaubnis unter dem Urheberrecht und bestimmten anderen Rechten, die ein Lizenzgeber erteilen kann. Die Verwendung des lizenzierten Materials kann aus anderen Gründen weiterhin eingeschränkt sein, insbesondere weil andere Urheberrechte oder andere Rechte an dem Material bestehen. Ein Lizenzgeber kann besondere Anforderungen stellen, wie z.B. die Bitte, dass alle Änderungen gekennzeichnet oder beschrieben werden. Obwohl dies von unseren Lizenzen nicht gefordert wird, werden Sie ermutigt, diese Anforderungen, wo angemessen, zu respektieren. Weitere Überlegungen für die Öffentlichkeit: wiki.creativecommons.org/Considerations_for_licensees
Überlegungen für die Öffentlichkeit: Durch die Nutzung einer unserer Lizenzen gewährt ein Lizenzgeber der Öffentlichkeit die Erlaubnis, das lizenzierte Material unter den angegebenen Bedingungen zu nutzen. Wenn die Erlaubnis des Lizenzgebers aus irgendeinem Grund nicht erforderlich ist – zum Beispiel aufgrund einer anwendbaren Ausnahme oder Einschränkung des Urheberrechts – wird diese Nutzung nicht durch die Lizenz geregelt. Unsere Lizenzen gewähren nur Rechte im Rahmen des Urheberrechts und bestimmter anderer Rechte, die ein Lizenzgeber zu gewähren berechtigt ist. Die Nutzung des lizenzierten Materials kann aus anderen Gründen weiterhin eingeschränkt sein, einschließlich der Tatsache, dass andere Personen Urheberrechte oder andere Rechte an dem Material besitzen. Ein Lizenzgeber kann besondere Wünsche äußern, wie z. B. die Bitte, dass alle Änderungen gekennzeichnet oder beschrieben werden. Obwohl dies nicht durch unsere Lizenzen vorgeschrieben ist, wird empfohlen, solche Wünsche, soweit vernünftig, zu respektieren. Weitere Überlegungen für die Öffentlichkeit:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
Creative Commons Attribution-ShareAlike 4.0 International Public License
Creative Commons Attribution-Weitergabe unter gleichen Bedingungen 4.0 Internationale Lizenz
Durch die Ausübung der lizenzierten Rechte (wie unten definiert) akzeptieren und erklären Sie sich mit den Bedingungen dieser Creative Commons Attribution-ShareAlike 4.0 International Public License ("Öffentliche Lizenz") einverstanden. Soweit diese öffentliche Lizenz als Vertrag ausgelegt werden kann, werden Ihnen die lizenzierten Rechte in Anbetracht Ihrer Zustimmung zu diesen Bedingungen und Konditionen gewährt, und der Lizenzgeber gewährt Ihnen diese Rechte in Anbetracht der Vorteile, die der Lizenzgeber aus der Bereitstellung des lizenzierten Materials unter diesen Bedingungen und Konditionen erhält.
Durch die Ausübung der lizenzierten Rechte (wie unten definiert) akzeptieren Sie die Bedingungen dieser Creative Commons Attribution-Weitergabe unter gleichen Bedingungen 4.0 Internationalen Lizenz ("Öffentliche Lizenz"). Soweit diese Öffentliche Lizenz als Vertrag ausgelegt werden kann, werden Ihnen die lizenzierten Rechte im Gegenzug für Ihre Annahme dieser Bedingungen gewährt, und der Lizenzgeber gewährt Ihnen diese Rechte im Gegenzug für die Vorteile, die der Lizenzgeber durch die Bereitstellung des lizenzierten Materials unter diesen Bedingungen erhält.
Abschnitt 1 – Definitionen.
a. Abgeleitetes Material bedeutet Material, das dem Urheberrecht und ähnlichen Rechten unterliegt und das aus dem lizenzierten Material abgeleitet oder darauf basiert und in dem das lizenzierte Material übersetzt, verändert, angeordnet, transformiert oder anderweitig in einer Weise modifiziert wird, die eine Genehmigung gemäß dem Urheberrecht und ähnlichen Rechten erfordert, die vom Lizenzgeber gehalten werden. Für die Zwecke dieser öffentlichen Lizenz wird abgeleitetes Material immer produziert, wenn das lizenzierte Material in zeitlichem Zusammenhang mit einem bewegten Bild synchronisiert wird.
a. Bearbeitetes Material bezeichnet Material, das dem Urheberrecht und ähnlichen Rechten unterliegt und das aus dem lizenzierten Material abgeleitet oder darauf basierend erstellt wurde, wobei das lizenzierte Material übersetzt, verändert, arrangiert, umgestaltet oder anderweitig in einer Weise modifiziert wurde, die eine Genehmigung gemäß dem Urheberrecht und ähnlichen Rechten des Lizenzgebers erfordert. Für die Zwecke dieser Öffentlichen Lizenz wird bearbeitetes Material immer dann erstellt, wenn das lizenzierte Material in zeitlicher Abstimmung mit einem bewegten Bild synchronisiert wird, sofern es sich um ein musikalisches Werk, eine Aufführung oder eine Tonaufnahme handelt.
b. Lizenz des Adapters bedeutet die Lizenz, die Sie auf Ihr Urheberrecht und ähnliche Rechte an Ihren Beiträgen zu abgeleitetem Material gemäß den Bedingungen dieser öffentlichen Lizenz anwenden.
b. Lizenz des Bearbeiters bezeichnet die Lizenz, die Sie auf Ihre Urheberrechte und ähnlichen Rechte an Ihren Beiträgen zu bearbeitetem Material gemäß den Bedingungen dieser Öffentlichen Lizenz anwenden.
c. BY-SA-kompatible Lizenz bedeutet eine Lizenz, die auf creativecommons.org/compatiblelicenses aufgeführt ist und von Creative Commons als im Wesentlichen gleichwertig mit dieser öffentlichen Lizenz genehmigt wurde.
c. BY-SA-kompatible Lizenz bezeichnet eine Lizenz, die unter creativecommons.org/compatiblelicenses aufgeführt ist und von Creative Commons als im Wesentlichen gleichwertig mit dieser Öffentlichen Lizenz anerkannt wurde.
d. Urheberrecht und ähnliche Rechte bedeutet Urheberrecht und/oder ähnliche Rechte, die eng mit dem Urheberrecht verbunden sind, einschließlich, aber nicht beschränkt auf, Aufführung, Rundfunk, Tonaufnahme und Sui Generis-Datenbankrechte, unabhängig davon, wie die Rechte bezeichnet oder kategorisiert werden. Für die Zwecke dieser öffentlichen Lizenz sind die in Abschnitt 2(b)(1)-(2) angegebenen Rechte keine Urheberrechte und ähnlichen Rechte.
d. Urheberrecht und ähnliche Rechte bezeichnet das Urheberrecht und/oder ähnliche Rechte, die eng mit dem Urheberrecht verbunden sind, einschließlich, aber nicht beschränkt auf Aufführungs-, Rundfunk-, Tonaufnahme- und Sui-Generis-Datenbankrechte, unabhängig davon, wie diese Rechte bezeichnet oder kategorisiert werden. Für die Zwecke dieser Öffentlichen Lizenz sind die in Abschnitt 2(b)(1)-(2) genannten Rechte keine Urheberrechte und ähnlichen Rechte.
e. Effektive technologische Maßnahmen bedeuten solche Maßnahmen, die, in Abwesenheit der ordnungsgemäßen Autorität, nicht umgangen werden dürfen, gemäß den Gesetzen, die Verpflichtungen gemäß Artikel 11 des WIPO-Urheberrechtsvertrags, der am 20. Dezember 1996 angenommen wurde, und/oder ähnlichen internationalen Abkommen erfüllen.
e. Wirksame technische Maßnahmen bezeichnet Maßnahmen, die ohne ordnungsgemäße Autorisierung nicht umgangen werden dürfen, gemäß Gesetzen, die Verpflichtungen aus Artikel 11 des WIPO-Urheberrechtsvertrags vom 20. Dezember 1996 und/oder ähnlichen internationalen Abkommen erfüllen.
f. Ausnahmen und Einschränkungen bedeuten faire Nutzung, faire Behandlung und/oder jede andere Ausnahme oder Einschränkung des Urheberrechts und ähnlicher Rechte, die auf Ihre Nutzung des lizenzierten Materials anwendbar ist.
f. Ausnahmen und Einschränkungen bezeichnet Fair Use, Fair Dealing und/oder andere Ausnahmen oder Einschränkungen des Urheberrechts und ähnlicher Rechte, die für Ihre Nutzung des lizenzierten Materials gelten.
g. Lizenzbestandteile bedeuten die Lizenzattribute, die im Namen einer Creative Commons-Publiklizenz aufgeführt sind. Die Lizenzbestandteile dieser öffentlichen Lizenz sind Namensnennung und Weitergabe unter gleichen Bedingungen.
g. Lizenzbestandteile bezeichnet die Lizenzattribute, die im Namen einer Creative-Commons-Lizenz aufgeführt sind. Die Lizenzbestandteile dieser Öffentlichen Lizenz sind Namensnennung und Weitergabe unter gleichen Bedingungen.
h. Lizenziertes Material bedeutet das künstlerische oder literarische Werk, die Datenbank oder anderes Material, auf das der Lizenzgeber diese öffentliche Lizenz angewendet hat.
h. Lizenziertes Material bezeichnet das künstlerische oder literarische Werk, die Datenbank oder anderes Material, auf das der Lizenzgeber diese Öffentliche Lizenz angewendet hat.
i. Lizenzierte Rechte bedeuten die Ihnen unterliegen den Bedingungen dieser öffentlichen Lizenz gewährten Rechte, die auf alle Urheberrechte und ähnlichen Rechte beschränkt sind, die auf Ihre Nutzung des lizenzierten Materials anwendbar sind und die der Lizenzgeber lizenziert.
i. Lizenzierte Rechte bezeichnet die Ihnen unter den Bedingungen dieser Öffentlichen Lizenz gewährten Rechte, die auf alle Urheberrechte und ähnlichen Rechte beschränkt sind, die für Ihre Nutzung des lizenzierten Materials gelten und die der Lizenzgeber zu lizenzieren berechtigt ist.
j. Lizenzgeber bedeutet die Person(en) oder Einheit(en), die Rechte unter dieser öffentlichen Lizenz gewähren.
j. Lizenzgeber bezeichnet die Person(en) oder Organisation(en), die Rechte unter dieser Öffentlichen Lizenz gewähren.
k. Teilen bedeutet, Material der Öffentlichkeit durch alle Mittel oder Verfahren zur Verfügung zu stellen, die eine Genehmigung gemäß den lizenzierten Rechten erfordern, wie z.B. Vervielfältigung, öffentliche Anzeige, öffentliche Aufführung, Verteilung, Verbreitung, Kommunikation oder Einfuhr, und Material der Öffentlichkeit zur Verfügung zu stellen, einschließlich in einer Weise, dass Mitglieder der Öffentlichkeit auf das Material von einem Ort und zu einem Zeitpunkt, den sie individuell gewählt haben, zugreifen können.
k. Teilen bezeichnet die Bereitstellung von Material für die Öffentlichkeit durch jegliche Mittel oder Verfahren, die eine Genehmigung gemäß den lizenzierten Rechten erfordern, wie Vervielfältigung, öffentliche Darstellung, öffentliche Aufführung, Verbreitung, Weitergabe, Kommunikation oder Import sowie die Bereitstellung von Material für die Öffentlichkeit, einschließlich auf eine Weise, die es Mitgliedern der Öffentlichkeit ermöglicht, das Material von einem Ort und zu einer Zeit ihrer Wahl zu nutzen.
l. Sui Generis-Datenbankrechte bedeuten Rechte, die über das Urheberrecht hinausgehen und aus der Richtlinie 96/9/EG des Europäischen Parlaments und des Rates vom 11. März 1996 zum rechtlichen Schutz von Datenbanken resultieren, wie geändert und/oder ersetzt, sowie andere im Wesentlichen gleichwertige Rechte überall auf der Welt.
l. Sui-Generis-Datenbankrechte bezeichnet andere als urheberrechtliche Rechte, die sich aus der Richtlinie 96/9/EG des Europäischen Parlaments und des Rates vom 11. März 1996 über den rechtlichen Schutz von Datenbanken ergeben, in der jeweils gültigen Fassung oder Nachfolgeversion, sowie andere im Wesentlichen gleichwertige Rechte weltweit.
m. Sie bedeutet die Person oder Einheit, die die lizenzierten Rechte gemäß dieser öffentlichen Lizenz ausübt. Ihr hat eine entsprechende Bedeutung.
m. Sie bezeichnet die Person oder Organisation, die die lizenzierten Rechte unter dieser Öffentlichen Lizenz ausübt. Ihr hat eine entsprechende Bedeutung.
Abschnitt 2 – Umfang.
a. Lizenzgewährung.
1. Vorbehaltlich der Bedingungen dieser öffentlichen Lizenz gewährt der Lizenzgeber Ihnen hiermit eine weltweite, lizenzgebührenfreie, nicht übertragbare, nicht-exklusive, unwiderrufliche Lizenz zur Ausübung der lizenzierten Rechte am lizenzierten Material, um:
1. Vorbehaltlich der Bedingungen dieser Öffentlichen Lizenz gewährt der Lizenzgeber Ihnen hiermit eine weltweite, gebührenfreie, nicht unterlizenzierbare, nicht exklusive, unwiderrufliche Lizenz zur Ausübung der lizenzierten Rechte am lizenzierten Material, um:
a. das lizenzierte Material ganz oder teilweise zu vervielfältigen und zu teilen; und
b. abgeleitetes Material zu erstellen, zu vervielfältigen und zu teilen.
b. bearbeitetes Material zu erstellen, zu vervielfältigen und zu teilen.
2. Ausnahmen und Einschränkungen. Um Zweifel zu vermeiden, wenn Ausnahmen und Einschränkungen auf Ihre Nutzung anwendbar sind, gilt diese öffentliche Lizenz nicht, und Sie müssen die Bedingungen dieser Lizenz nicht einhalten.
2. Ausnahmen und Einschränkungen. Zur Klarstellung: Wenn Ausnahmen und Einschränkungen für Ihre Nutzung gelten, findet diese Öffentliche Lizenz keine Anwendung, und Sie müssen ihre Bedingungen nicht einhalten.
3. Laufzeit. Die Laufzeit dieser öffentlichen Lizenz ist in Abschnitt 6(a) festgelegt.
3. Laufzeit. Die Laufzeit dieser Öffentlichen Lizenz ist in Abschnitt 6(a) festgelegt.
4. Medien und Formate; technische Änderungen erlaubt. Der Lizenzgeber autorisiert Sie, die lizenzierten Rechte in allen Medien und Formaten, die jetzt bekannt sind oder später erstellt werden, auszuüben und technische Änderungen vorzunehmen, die dafür erforderlich sind. Der Lizenzgeber verzichtet auf und/oder erklärt sich nicht damit einverstanden, Ihnen das Verbot von technischen Änderungen, die erforderlich sind, um die lizenzierten Rechte auszuüben, einschließlich technischer Änderungen, die erforderlich sind, um effektive technologische Maßnahmen zu umgehen, zu untersagen. Für die Zwecke dieser öffentlichen Lizenz führt das bloße Vornehmen von Änderungen, die durch diesen Abschnitt 2(a)(4) autorisiert sind, niemals zu abgeleitetem Material.
4. Medien und Formate; technische Änderungen erlaubt. Der Lizenzgeber autorisiert Sie, die lizenzierten Rechte in allen Medien und Formaten auszuüben, die jetzt bekannt sind oder später entwickelt werden, und technische Änderungen vorzunehmen, die dafür erforderlich sind. Der Lizenzgeber verzichtet auf und/oder erklärt sich damit einverstanden, keine Rechte oder Befugnisse geltend zu machen, die Sie daran hindern, technische Änderungen vorzunehmen, die für die Ausübung der lizenzierten Rechte erforderlich sind, einschließlich technischer Änderungen, die notwendig sind, um wirksame technische Maßnahmen zu umgehen. Für die Zwecke dieser Öffentlichen Lizenz führt das bloße Vornehmen von Änderungen, die gemäß diesem Abschnitt 2(a)(4) autorisiert sind, niemals zur Erstellung von bearbeitetem Material.
5. Nachgelagerte Empfänger.
a. Angebot des Lizenzgebers – lizenziertes Material. Jeder Empfänger des lizenzierten Materials erhält automatisch ein Angebot des Lizenzgebers zur Ausübung der lizenzierten Rechte unter den Bedingungen dieser öffentlichen Lizenz.
a. Angebot des Lizenzgebers – Lizenziertes Material. Jeder Empfänger des lizenzierten Materials erhält automatisch ein Angebot des Lizenzgebers, die lizenzierten Rechte unter den Bedingungen dieser Öffentlichen Lizenz auszuüben.
b. Zusätzliches Angebot des Lizenzgebers – abgeleitetes Material. Jeder Empfänger von abgeleitetem Material von Ihnen erhält automatisch ein Angebot des Lizenzgebers zur Ausübung der lizenzierten Rechte an dem abgeleiteten Material unter den Bedingungen der Lizenz des Adapters, die Sie anwenden.
b. Zusätzliches Angebot des Lizenzgebers – Bearbeitetes Material. Jeder Empfänger von bearbeitetem Material von Ihnen erhält automatisch ein Angebot des Lizenzgebers, die lizenzierten Rechte am bearbeiteten Material unter den Bedingungen der von Ihnen angewendeten Lizenz des Bearbeiters auszuüben.
c. Keine nachgelagerten Einschränkungen. Sie dürfen keine zusätzlichen oder anderen Bedingungen auf das lizenzierte Material anwenden oder auferlegen oder effektive technologische Maßnahmen auf das lizenzierte Material anwenden, wenn dies die Ausübung der lizenzierten Rechte durch einen Empfänger des lizenzierten Materials einschränkt.
c. Keine nachgelagerten Einschränkungen. Sie dürfen keine zusätzlichen oder abweichenden Bedingungen auferlegen oder wirksame technische Maßnahmen auf das lizenzierte Material anwenden, wenn dies die Ausübung der lizenzierten Rechte durch einen Empfänger des lizenzierten Materials einschränkt.
6. Keine Billigung. Nichts in dieser öffentlichen Lizenz stellt eine Genehmigung dar oder kann so ausgelegt werden, dass Sie oder Ihre Nutzung des lizenzierten Materials mit dem Lizenzgeber oder anderen, die als Empfänger von Namensnennung gemäß Abschnitt 3(a)(1)(A)(i) bezeichnet sind, verbunden, gesponsert, genehmigt oder offiziell anerkannt sind.
6. Keine Billigung. Nichts in dieser Öffentlichen Lizenz stellt eine Erlaubnis dar oder kann so ausgelegt werden, dass Sie oder Ihre Nutzung des lizenzierten Materials mit dem Lizenzgeber oder anderen, die gemäß Abschnitt 3(a)(1)(A)(i) genannt werden, verbunden, gesponsert, unterstützt oder offiziell anerkannt sind.
b. Andere Rechte.
1. Moralische Rechte, wie das Recht auf Integrität, sind unter dieser öffentlichen Lizenz nicht lizenziert, ebenso wenig wie Werbe-, Datenschutz- und/oder andere ähnliche Persönlichkeitsrechte; jedoch verzichtet der Lizenzgeber, soweit möglich, auf und/oder erklärt sich nicht damit einverstanden, solche Rechte, die vom Lizenzgeber gehalten werden, in dem begrenzten Umfang geltend zu machen, der erforderlich ist, damit Sie die lizenzierten Rechte ausüben können, jedoch nicht darüber hinaus.
1. Persönlichkeitsrechte, wie das Recht auf Integrität, sind nicht durch diese Öffentliche Lizenz lizenziert, ebenso wenig wie Rechte auf Öffentlichkeit, Privatsphäre und/oder andere ähnliche Persönlichkeitsrechte; jedoch verzichtet der Lizenzgeber, soweit möglich, auf und/oder erklärt sich damit einverstanden, keine solchen Rechte geltend zu machen, die der Lizenzgeber besitzt, soweit dies erforderlich ist, um Ihnen die Ausübung der lizenzierten Rechte zu ermöglichen, jedoch nicht darüber hinaus.
2. Patent- und Markenrechte sind unter dieser öffentlichen Lizenz nicht lizenziert.
2. Patent- und Markenrechte sind nicht durch diese Öffentliche Lizenz lizenziert.
3. Soweit möglich, verzichtet der Lizenzgeber auf das Recht, von Ihnen Lizenzgebühren für die Ausübung der lizenzierten Rechte zu verlangen, sei es direkt oder über eine Verwertungsgesellschaft im Rahmen eines freiwilligen oder abdingbaren gesetzlichen oder zwingenden Lizenzierungsprogramms. In allen anderen Fällen behält sich der Lizenzgeber ausdrücklich das Recht vor, solche Lizenzgebühren zu erheben.
3. Soweit möglich, verzichtet der Lizenzgeber auf jegliches Recht, von Ihnen Lizenzgebühren für die Ausübung der lizenzierten Rechte zu erheben, sei es direkt oder über eine Verwertungsgesellschaft im Rahmen eines freiwilligen oder verzichtbaren gesetzlichen oder zwingenden Lizenzierungssystems. In allen anderen Fällen behält sich der Lizenzgeber ausdrücklich das Recht vor, solche Lizenzgebühren zu erheben.
Rechte, dann die Datenbank, in der Sie Sui Generis-Datenbankrechte haben (aber nicht deren einzelne Inhalte), ist angepasstes Material,
Abschnitt 3 – Lizenzbedingungen.
einschließlich für die Zwecke von Abschnitt 3(b); und
c. Sie müssen die Bedingungen in Abschnitt 3(a) einhalten, wenn Sie die gesamte oder einen wesentlichen Teil der Inhalte der Datenbank weitergeben.
Ihre Ausübung der lizenzierten Rechte unterliegt ausdrücklich den folgenden Bedingungen.
a. Namensnennung.
1. Wenn Sie das lizenzierte Material (einschließlich in modifizierter Form) teilen, müssen Sie:
a. die folgenden Informationen beibehalten, wenn sie vom Lizenzgeber mit dem lizenzierten Material bereitgestellt werden:
i. Identifizierung der Schöpfer des lizenzierten Materials und anderer, die zur Namensnennung vorgesehen sind, in einer angemessenen Weise, die vom Lizenzgeber angefordert wird (einschließlich Pseudonym, falls angegeben);
ii. einen Urheberrechtshinweis;
iii. einen Hinweis, der auf diese öffentliche Lizenz verweist;
iv. einen Hinweis, der auf den Haftungsausschluss verweist;
v. eine URI oder einen Hyperlink zum lizenzierten Material, soweit dies angemessen möglich ist;
b. angeben, ob Sie das lizenzierte Material modifiziert haben, und eine Angabe über vorherige Änderungen beibehalten; und
c. angeben, dass das lizierte Material unter dieser öffentlichen Lizenz lizenziert ist, und den Text oder die URI oder den Hyperlink zu dieser öffentlichen Lizenz einfügen.
2. Sie können die Bedingungen in Abschnitt 3(a)(1) auf jede angemessene Weise erfüllen, die auf dem Medium, den Mitteln und dem Kontext basiert, in dem Sie das lizierte Material teilen. Zum Beispiel kann es angemessen sein, die Bedingungen zu erfüllen, indem Sie eine URI oder einen Hyperlink zu einer Ressource bereitstellen, die die erforderlichen Informationen enthält.
3. Wenn der Lizenzgeber dies verlangt, müssen Sie alle Informationen, die in Abschnitt 3(a)(1)(A) erforderlich sind, in dem angemessenen Umfang entfernen.
b. Weitergabe unter gleichen Bedingungen.
Zusätzlich zu den Bedingungen in Abschnitt 3(a) gelten die folgenden Bedingungen, wenn Sie abgeleitetes Material teilen, das Sie erstellen.
1. Die Lizenz des Adapters, die Sie anwenden, muss eine Creative Commons-Lizenz mit denselben Lizenzbestandteilen, dieser Version oder einer späteren, oder eine BY-SA-kompatible Lizenz sein.
2. Sie müssen den Text oder die URI oder den Hyperlink zu der Lizenz des Adapters, die Sie anwenden, einfügen. Sie können diese Bedingung auf jede angemessene Weise erfüllen, die auf dem Medium, den Mitteln und dem Kontext basiert, in dem Sie abgeleitetes Material teilen.
3. Sie dürfen keine zusätzlichen oder anderen Bedingungen auf abgeleitetes Material anwenden oder auferlegen oder effektive technologische Maßnahmen auf abgeleitetes Material anwenden, die die Ausübung der Rechte, die unter der Lizenz des Adapters gewährt werden, einschränken.
Abschnitt 4 – Sui Generis-Datenbankrechte.
Soweit die lizenzierten Rechte Sui Generis-Datenbankrechte umfassen, die auf Ihre Nutzung des lizenzierten Materials anwendbar sind:
a. Um Zweifel zu vermeiden, gewährt Abschnitt 2(a)(1) Ihnen das Recht, alle oder einen wesentlichen Teil des Inhalts der Datenbank zu extrahieren, wiederzuverwenden, zu reproduzieren und zu teilen;
b. Wenn Sie alle oder einen wesentlichen Teil des Inhalts der Datenbank in einer Datenbank einfügen, in der Sie Sui Generis-Datenbankrechte haben, dann ist die Datenbank, in der Sie Sui Generis-Datenbankrechte haben (aber nicht deren einzelne Inhalte), abgeleitetes Material, einschließlich für die Zwecke von Abschnitt 3(b); und
c. Sie müssen die Bedingungen in Abschnitt 3(a) einhalten, wenn Sie alle oder einen wesentlichen Teil des Inhalts der Datenbank teilen.
Um Zweifel zu vermeiden, ergänzt dieser Abschnitt 4 Ihre Verpflichtungen unter dieser öffentlichen Lizenz, wenn die lizenzierten Rechte andere Urheberrechte und ähnliche Rechte umfassen.
Zur Klarstellung: Dieser Abschnitt 4 ergänzt und ersetzt nicht Ihre Verpflichtungen aus dieser öffentlichen Lizenz, wenn die lizenzierten Rechte andere Urheberrechte und ähnliche Rechte umfassen.
Abschnitt 5 – Haftungsausschluss und Haftungsbeschränkung.
a. SOFERN NICHT ANDERS VON DEM LIZENZGEBER GETROFFEN, BIETET DER LIZENZGEBER DAS LIZENZIERTE MATERIAL SO WIE ES IST UND SO WIE VERFÜGBAR AN UND GIBT KEINE ERKLÄRUNGEN ODER GARANTIEN JEDER ART IN BEZUG AUF DAS LIZENZIERTE MATERIAL AB, OB AUSDRÜCKLICH, STILLSCHWEIGEND, GESETZLICH ODER ANDERWEITIG. DIES BEINHALTET, OHNE EINSCHRÄNKUNG, GARANTIEN FÜR EIGENTUM, MARKTFÄHIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK, NICHTVERLETZUNG, FEHLEN ODER ANDERE MÄNGEL, GENAUIGKEIT ODER DAS VORHANDENSEIN ODER FEHLEN VON FEHLERN, UNABHÄNGIG DAVON, OB BEKANNT ODER ENTDECKBAR. WENN HAFTUNGSAUSSCHLÜSSE NICHT VOLLSTÄNDIG ODER TEILWEISE ERLAUBT SIND, GILT DIESER HAFTUNGSAUSSCHLUSS MÖGLICHERWEISE NICHT FÜR SIE.
a. SOFERN NICHT ANDERS VOM LIZENZGEBER SEPARAT VEREINBART, STELLT DER LIZENZGEBER DAS LIZENZIERTE MATERIAL SOWEIT MÖGLICH "WIE BESEHEN" UND "WIE VERFÜGBAR" ZUR VERFÜGUNG UND GIBT KEINE ZUSICHERUNGEN ODER GARANTIEN IRGENDEINER ART IN BEZUG AUF DAS LIZENZIERTE MATERIAL AB, WEDER AUSDRÜCKLICH, IMPLIZIT, GESETZLICH NOCH ANDERWEITIG. DIES UMFASST UNTER ANDEREM GARANTIEN BEZÜGLICH EIGENTUM, MARKTGÄNGIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK, NICHTVERLETZUNG, ABWESENHEIT VON VERBORGENEN ODER ANDEREN MÄNGELN, GENAUIGKEIT ODER DAS VORHANDENSEIN ODER NICHTVORHANDENSEIN VON FEHLERN, OB BEKANNT ODER ENTDECKBAR. WO HAFTUNGSAUSSCHLÜSSE VON GARANTIEN NICHT VOLLSTÄNDIG ODER TEILWEISE ZULÄSSIG SIND, KANN DIESER HAFTUNGSAUSSCHLUSS FÜR SIE NICHT GELTEN.
b. SOWEIT MÖGLICH, WIRD DER LIZENZGEBER IN KEINEM FALL FÜR SIE AUF GRUNDLAGE IRGENDEINER RECHTSTHEORIE (EINSCHLIEßLICH, ABER NICHT BESCHRÄNKT AUF, FAHRLÄSSIGKEIT) ODER ANDERWEITIG FÜR DIREKTE, SPEZIELLE, INDIREKTE, NEBEN-, FOLGE-, STRAF-, EXEMPLARISCHE ODER ANDERE VERLUSTE, KOSTEN, AUSGABEN ODER SCHÄDEN, DIE AUS DIESER ÖFFENTLICHEN LIZENZ ODER DER NUTZUNG DES LIZENZIERTEN MATERIALS ENTSTEHEN, HAFTBAR GEMACHT WERDEN, SELBST WENN DER LIZENZGEBER AUF DIE MÖGLICHKEIT SOLCHER VERLUSTE, KOSTEN, AUSGABEN ODER SCHÄDEN HINGEWIESEN WURDE. WENN EINE HAFTUNGSBESCHRÄNKUNG NICHT VOLLSTÄNDIG ODER TEILWEISE ERLAUBT IST, GILT DIESE BESCHRÄNKUNG MÖGLICHERWEISE NICHT FÜR SIE.
b. SOWEIT MÖGLICH, HAFTET DER LIZENZGEBER UNTER KEINEN UMSTÄNDEN IHNEN GEGENÜBER AUF GRUNDLAGE IRGENDEINER RECHTSTHEORIE (EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF FAHRLÄSSIGKEIT) ODER ANDERWEITIG FÜR DIREKTE, BESONDERE, INDIREKTE, ZUFÄLLIGE, FOLGE-, STRAF-, EXEMPLARISCHE ODER ANDERE VERLUSTE, KOSTEN, AUSGABEN ODER SCHÄDEN, DIE AUS DIESER ÖFFENTLICHEN LIZENZ ODER DER NUTZUNG DES LIZENZIERTEN MATERIALS ENTSTEHEN, SELBST WENN DER LIZENZGEBER ÜBER DIE MÖGLICHKEIT SOLCHER VERLUSTE, KOSTEN, AUSGABEN ODER SCHÄDEN INFORMIERT WURDE. WO EINE HAFTUNGSBESCHRÄNKUNG NICHT VOLLSTÄNDIG ODER TEILWEISE ZULÄSSIG IST, KANN DIESE BESCHRÄNKUNG FÜR SIE NICHT GELTEN.
c. Der Haftungsausschluss für Garantien und die Haftungsbeschränkung, die oben angegeben sind, werden so ausgelegt, dass sie, soweit möglich, einem absoluten Haftungsausschluss und einem Verzicht auf alle Haftungen am nächsten kommen.
c. Der oben genannte Haftungsausschluss und die Haftungsbeschränkung sind so auszulegen, dass sie, soweit möglich, einem absoluten Haftungsausschluss und Verzicht auf jegliche Haftung am nächsten kommen.
Abschnitt 6 – Laufzeit und Beendigung.
a. Diese öffentliche Lizenz gilt für die Laufzeit des hier lizenzierten Urheberrechts und ähnlicher Rechte. Wenn Sie jedoch gegen diese öffentliche Lizenz verstoßen, erlöschen Ihre Rechte unter dieser öffentlichen Lizenz automatisch.
a. Diese öffentliche Lizenz gilt für die Dauer der hier lizenzierten Urheberrechte und ähnlichen Rechte. Wenn Sie jedoch gegen diese öffentliche Lizenz verstoßen, enden Ihre Rechte aus dieser öffentlichen Lizenz automatisch.
b. Wenn Ihr Recht, das lizenzierte Material zu nutzen, gemäß Abschnitt 6(a) erloschen ist, wird es wiederhergestellt:
b. Wenn Ihr Recht zur Nutzung des lizenzierten Materials gemäß Abschnitt 6(a) beendet wurde, wird es wiederhergestellt:
1. automatisch ab dem Datum, an dem der Verstoß behoben wird, vorausgesetzt, er wird innerhalb von 30 Tagen nach Ihrer Entdeckung
1. automatisch ab dem Datum, an dem der Verstoß behoben wird, vorausgesetzt, dies geschieht innerhalb von 30 Tagen nach Ihrer Entdeckung des Verstoßes; oder
2. durch ausdrückliche Wiederherstellung durch den Lizenzgeber.
Zur Klarstellung: Dieser Abschnitt 6(b) berührt nicht das Recht des Lizenzgebers, Rechtsmittel wegen Ihrer Verstöße gegen diese öffentliche Lizenz einzulegen.
c. Zur Klarstellung: Der Lizenzgeber kann das lizenzierte Material auch unter separaten Bedingungen oder Konditionen anbieten oder die Verbreitung des lizenzierten Materials jederzeit einstellen; dies beendet jedoch nicht diese öffentliche Lizenz.
d. Die Abschnitte 1, 5, 6, 7 und 8 bleiben auch nach Beendigung dieser öffentlichen Lizenz in Kraft.
Abschnitt 7 – Andere Bedingungen.
a. Der Lizenzgeber ist nicht an zusätzliche oder abweichende Bedingungen gebunden, die Sie mitteilen, es sei denn, sie wurden ausdrücklich vereinbart.
b. Alle Vereinbarungen, Absprachen oder Abmachungen in Bezug auf das lizenzierte Material, die hier nicht aufgeführt sind, sind unabhängig von und getrennt von den Bedingungen dieser öffentlichen Lizenz.
Abschnitt 8 – Auslegung.
a. Zur Klarstellung: Diese öffentliche Lizenz schränkt nicht ein, begrenzt nicht, beschränkt nicht und auferlegt keine Bedingungen für die Nutzung des lizenzierten Materials, die ohne Erlaubnis gemäß dieser öffentlichen Lizenz rechtmäßig erfolgen könnte.
b. Soweit möglich, wird jede Bestimmung dieser öffentlichen Lizenz, die als nicht durchsetzbar erachtet wird, automatisch auf das Mindestmaß reformiert, das erforderlich ist, um sie durchsetzbar zu machen. Wenn die Bestimmung nicht reformiert werden kann, wird sie von dieser öffentlichen Lizenz getrennt, ohne die Durchsetzbarkeit der verbleibenden Bedingungen zu beeinträchtigen.
c. Kein Begriff oder keine Bedingung dieser öffentlichen Lizenz wird aufgehoben, und kein Versäumnis, die Einhaltung zu verlangen, wird zugestimmt, es sei denn, dies wurde ausdrücklich vom Lizenzgeber vereinbart.
d. Nichts in dieser öffentlichen Lizenz stellt eine Einschränkung oder einen Verzicht auf Privilegien und Immunitäten dar, die für den Lizenzgeber oder Sie gelten, einschließlich solcher, die sich aus den rechtlichen Verfahren einer Gerichtsbarkeit oder Behörde ergeben.
=======================================================================
Creative Commons ist keine Partei ihrer öffentlichen Lizenzen. Ungeachtet dessen kann Creative Commons wählen, eine seiner öffentlichen Lizenzen auf von ihr veröffentlichte Materialien anzuwenden, und wird in diesen Fällen als „Lizenzgeber“ betrachtet. Der Text der Creative Commons-Lizenzen ist dem Gemeingut unter der CC0 Public Domain Dedication gewidmet. Mit Ausnahme des begrenzten Zwecks, anzuzeigen, dass Material unter einer Creative Commons-Lizenz geteilt wird, oder wie anderweitig in den Creative Commons-Richtlinien unter creativecommons.org/policies gestattet, autorisiert Creative Commons nicht die Verwendung der Marke „Creative Commons“ oder einer anderen Marke oder eines Logos von Creative Commons ohne vorherige schriftliche Zustimmung, einschließlich, aber nicht beschränkt auf, in Verbindung mit nicht autorisierten Änderungen an einer ihrer öffentlichen Lizenzen oder anderen Vereinbarungen, Absprachen oder Abmachungen in Bezug auf die Nutzung des lizenzierten Materials. Zur Klarstellung: Dieser Absatz ist nicht Teil der öffentlichen Lizenzen.
Creative Commons kann unter creativecommons.org kontaktiert werden.
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die 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 Verwendung dieser Übersetzung resultieren.
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.

11
translations/de/lessons/sketchnotes/README.md
View File

@ -1,3 +1,12 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "050b8bddebafba55b129414e6ab096ab",
"translation_date": "2025-08-24T09:41:18+00:00",
"source_file": "lessons/sketchnotes/README.md",
"language_code": "de"
}
-->
Alle Sketchnotes des Lehrplans können hier heruntergeladen werden.
🎨 Erstellt von: Tomomi Imura (Twitter: [@girlie_mac](https://twitter.com/girlie_mac), GitHub: [girliemac](https://github.com/girliemac))
@ -5,4 +14,4 @@ Alle Sketchnotes des Lehrplans können hier heruntergeladen werden.
[![CC BY-SA 4.0](https://img.shields.io/badge/License-CC%20BY--SA%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-sa/4.0/)
**Haftungsausschluss**:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten ü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 die maßgebliche Quelle angesehen werden. Für wichtige Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.
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.

183
translations/es/README.md
View File

@ -1,99 +1,108 @@
[![Licencia de GitHub](https://img.shields.io/github/license/microsoft/AI-For-Beginners.svg)](https://github.com/microsoft/AI-For-Beginners/blob/main/LICENSE)
[![Contribuyentes de GitHub](https://img.shields.io/github/contributors/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/graphs/contributors/)
[![Problemas de GitHub](https://img.shields.io/github/issues/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/issues/)
[![Solicitudes de extracción de GitHub](https://img.shields.io/github/issues-pr/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/pulls/)
[![PRs Bienvenidos](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f3a6b0ddf7e6e3f33b2a543baf086dc9",
"translation_date": "2025-08-24T09:09:53+00:00",
"source_file": "README.md",
"language_code": "es"
}
-->
[![Licencia de GitHub](https://img.shields.io/github/license/microsoft/AI-For-Beginners.svg)](https://github.com/microsoft/AI-For-Beginners/blob/main/LICENSE)
[![Contribuidores de GitHub](https://img.shields.io/github/contributors/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/graphs/contributors/)
[![Problemas de GitHub](https://img.shields.io/github/issues/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/issues/)
[![Solicitudes de extracción de GitHub](https://img.shields.io/github/issues-pr/microsoft/AI-For-Beginners.svg)](https://GitHub.com/microsoft/AI-For-Beginners/pulls/)
[![PRs Bienvenidos](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
[![Observadores de GitHub](https://img.shields.io/github/watchers/microsoft/AI-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/AI-For-Beginners/watchers/)
[![Forks de GitHub](https://img.shields.io/github/forks/microsoft/AI-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/AI-For-Beginners/network/)
[![Estrellas de GitHub](https://img.shields.io/github/stars/microsoft/AI-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/AI-For-Beginners/stargazers/)
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)
[![Gitter](https://badges.gitter.im/Microsoft/ai-for-beginners.svg)](https://gitter.im/Microsoft/ai-for-beginners?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
[![Observadores de GitHub](https://img.shields.io/github/watchers/microsoft/AI-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/AI-For-Beginners/watchers/)
[![Bifurcaciones de GitHub](https://img.shields.io/github/forks/microsoft/AI-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/AI-For-Beginners/network/)
[![Estrellas de GitHub](https://img.shields.io/github/stars/microsoft/AI-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/AI-For-Beginners/stargazers/)
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)
[![Gitter](https://badges.gitter.im/Microsoft/ai-for-beginners.svg)](https://gitter.im/Microsoft/ai-for-beginners?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
[![](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://discord.gg/zxKYvhSnVp?WT.mc_id=academic-000002-leestott)
[![](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://discord.gg/zxKYvhSnVp?WT.mc_id=academic-000002-leestott)
# Inteligencia Artificial para Principiantes - Un Currículo
# Inteligencia Artificial para Principiantes - Un Currículo
|![ Sketchnote por [(@girlie_mac)](https://twitter.com/girlie_mac) ](./lessons/sketchnotes/ai-overview.png)|
|:---:|
| AI Para Principiantes - _Sketchnote por [@girlie_mac](https://twitter.com/girlie_mac)_ |
|![ Sketchnote por [(@girlie_mac)](https://twitter.com/girlie_mac) ](./lessons/sketchnotes/ai-overview.png)|
|:---:|
| AI Para Principiantes - _Sketchnote por [@girlie_mac](https://twitter.com/girlie_mac)_ |
¡Explora el mundo de la **Inteligencia Artificial** (IA) con nuestro currículo de 12 semanas y 24 lecciones! Incluye lecciones prácticas, cuestionarios y laboratorios. El currículo es amigable para principiantes y abarca herramientas como TensorFlow y PyTorch, así como la ética en la IA.
Explora el mundo de la **Inteligencia Artificial** (IA) con nuestro currículo de 12 semanas y 24 lecciones. Incluye lecciones prácticas, cuestionarios y laboratorios. El currículo está diseñado para principiantes y cubre herramientas como TensorFlow y PyTorch, además de ética en IA.
## Lo que aprenderás
## Lo que aprenderás
**[Mapa mental del curso](http://soshnikov.com/courses/ai-for-beginners/mindmap.html)**
**[Mapa mental del curso](http://soshnikov.com/courses/ai-for-beginners/mindmap.html)**
En este currículo, aprenderás:
En este currículo, aprenderás:
* Diferentes enfoques de la Inteligencia Artificial, incluido el "buen viejo" enfoque simbólico con **Representación del Conocimiento** y razonamiento ([GOFAI](https://en.wikipedia.org/wiki/Symbolic_artificial_intelligence)).
* **Redes Neuronales** y **Aprendizaje Profundo**, que son el núcleo de la IA moderna. Ilustraremos los conceptos detrás de estos temas importantes utilizando código en dos de los marcos más populares: [TensorFlow](http://Tensorflow.org) y [PyTorch](http://pytorch.org).
* **Arquitecturas Neuronales** para trabajar con imágenes y texto. Cubriremos modelos recientes, aunque puede que no estemos completamente al día con el estado del arte.
* Enfoques de IA menos populares, como **Algoritmos Genéticos** y **Sistemas Multi-Agente**.
* Diferentes enfoques de la Inteligencia Artificial, incluyendo el enfoque simbólico "de la vieja escuela" con **Representación del Conocimiento** y razonamiento ([GOFAI](https://en.wikipedia.org/wiki/Symbolic_artificial_intelligence)).
* **Redes Neuronales** y **Aprendizaje Profundo**, que son el núcleo de la IA moderna. Ilustraremos los conceptos detrás de estos temas importantes utilizando código en dos de los marcos más populares: [TensorFlow](http://Tensorflow.org) y [PyTorch](http://pytorch.org).
* **Arquitecturas Neuronales** para trabajar con imágenes y texto. Cubriremos modelos recientes, aunque puede que no incluyamos lo más avanzado.
* Enfoques menos populares de IA, como **Algoritmos Genéticos** y **Sistemas Multi-Agente**.
Lo que no cubriremos en este currículo:
Lo que no cubriremos en este currículo:
> [Encuentra todos los recursos adicionales para este curso en nuestra colección de Microsoft Learn](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)
> [Encuentra todos los recursos adicionales para este curso en nuestra colección de Microsoft Learn](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)
* Casos de negocio sobre el uso de **IA en los Negocios**. Considera tomar la ruta de aprendizaje [Introducción a la IA para usuarios de negocios](https://docs.microsoft.com/learn/paths/introduction-ai-for-business-users/?WT.mc_id=academic-77998-bethanycheum) en Microsoft Learn, o [Escuela de Negocios de IA](https://www.microsoft.com/ai/ai-business-school/?WT.mc_id=academic-77998-bethanycheum), desarrollada en cooperación con [INSEAD](https://www.insead.edu/).
* **Aprendizaje Automático Clásico**, que está bien descrito en nuestro [Currículo de Aprendizaje Automático para Principiantes](http://github.com/Microsoft/ML-for-Beginners).
* Aplicaciones prácticas de IA construidas usando **[Servicios Cognitivos](https://azure.microsoft.com/services/cognitive-services/?WT.mc_id=academic-77998-bethanycheum)**. Para esto, te recomendamos que comiences con los módulos de Microsoft Learn para [visión](https://docs.microsoft.com/learn/paths/create-computer-vision-solutions-azure-cognitive-services/?WT.mc_id=academic-77998-bethanycheum), [procesamiento de lenguaje natural](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-bethanycheum), **[IA Generativa con Azure OpenAI Service](https://learn.microsoft.com/en-us/training/paths/develop-ai-solutions-azure-openai/?WT.mc_id=academic-77998-bethanycheum)** y otros.
* **Frameworks de ML específicos en la nube**, como [Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-bethanycheum), [Microsoft Fabric](https://learn.microsoft.com/en-us/training/paths/get-started-fabric/?WT.mc_id=academic-77998-bethanycheum) o [Azure Databricks](https://docs.microsoft.com/learn/paths/data-engineer-azure-databricks?WT.mc_id=academic-77998-bethanycheum). Considera utilizar las rutas de aprendizaje [Construir y operar soluciones de aprendizaje automático con Azure Machine Learning](https://docs.microsoft.com/learn/paths/build-ai-solutions-with-azure-ml-service/?WT.mc_id=academic-77998-bethanycheum) y [Construir y operar soluciones de aprendizaje automático con Azure Databricks](https://docs.microsoft.com/learn/paths/build-operate-machine-learning-solutions-azure-databricks/?WT.mc_id=academic-77998-bethanycheum).
* **IA Conversacional** y **Bots de Chat**. Hay una ruta de aprendizaje separada llamada [Crear soluciones de IA conversacional](https://docs.microsoft.com/learn/paths/create-conversational-ai-solutions/?WT.mc_id=academic-77998-bethanycheum), y también puedes consultar [esta publicación de blog](https://soshnikov.com/azure/hello-bot-conversational-ai-on-microsoft-platform/) para más detalles.
* **Matemáticas Avanzadas** detrás del aprendizaje profundo. Para esto, recomendamos [Deep Learning](https://www.amazon.com/Deep-Learning-Adaptive-Computation-Machine/dp/0262035618) de Ian Goodfellow, Yoshua Bengio y Aaron Courville, que también está disponible en línea en [https://www.deeplearningbook.org/](https://www.deeplearningbook.org/).
* Casos de negocio sobre el uso de **IA en los negocios**. Considera tomar el camino de aprendizaje [Introducción a la IA para usuarios empresariales](https://docs.microsoft.com/learn/paths/introduction-ai-for-business-users/?WT.mc_id=academic-77998-bethanycheum) en Microsoft Learn, o [AI Business School](https://www.microsoft.com/ai/ai-business-school/?WT.mc_id=academic-77998-bethanycheum), desarrollado en cooperación con [INSEAD](https://www.insead.edu/).
* **Aprendizaje Automático Clásico**, que está bien descrito en nuestro [Currículo de Aprendizaje Automático para Principiantes](http://github.com/Microsoft/ML-for-Beginners).
* Aplicaciones prácticas de IA construidas utilizando **[Servicios Cognitivos](https://azure.microsoft.com/services/cognitive-services/?WT.mc_id=academic-77998-bethanycheum)**. Para esto, recomendamos comenzar con los módulos de Microsoft Learn para [visión](https://docs.microsoft.com/learn/paths/create-computer-vision-solutions-azure-cognitive-services/?WT.mc_id=academic-77998-bethanycheum), [procesamiento de lenguaje natural](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-bethanycheum), **[IA Generativa con Azure OpenAI Service](https://learn.microsoft.com/en-us/training/paths/develop-ai-solutions-azure-openai/?WT.mc_id=academic-77998-bethanycheum)** y otros.
* Marcos específicos de ML en la **nube**, como [Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-bethanycheum), [Microsoft Fabric](https://learn.microsoft.com/en-us/training/paths/get-started-fabric/?WT.mc_id=academic-77998-bethanycheum), o [Azure Databricks](https://docs.microsoft.com/learn/paths/data-engineer-azure-databricks?WT.mc_id=academic-77998-bethanycheum). Considera usar los caminos de aprendizaje [Construir y operar soluciones de aprendizaje automático con Azure Machine Learning](https://docs.microsoft.com/learn/paths/build-ai-solutions-with-azure-ml-service/?WT.mc_id=academic-77998-bethanycheum) y [Construir y operar soluciones de aprendizaje automático con Azure Databricks](https://docs.microsoft.com/learn/paths/build-operate-machine-learning-solutions-azure-databricks/?WT.mc_id=academic-77998-bethanycheum).
* **IA Conversacional** y **Chat Bots**. Hay un camino de aprendizaje separado [Crear soluciones de IA conversacional](https://docs.microsoft.com/learn/paths/create-conversational-ai-solutions/?WT.mc_id=academic-77998-bethanycheum), y también puedes consultar [esta publicación de blog](https://soshnikov.com/azure/hello-bot-conversational-ai-on-microsoft-platform/) para más detalles.
* **Matemáticas profundas** detrás del aprendizaje profundo. Para esto, recomendamos [Deep Learning](https://www.amazon.com/Deep-Learning-Adaptive-Computation-Machine/dp/0262035618) de Ian Goodfellow, Yoshua Bengio y Aaron Courville, que también está disponible en línea en [https://www.deeplearningbook.org/](https://www.deeplearningbook.org/).
Para una introducción suave a los temas de _IA en la Nube_, puedes considerar tomar la ruta de aprendizaje [Introducción a la inteligencia artificial en Azure](https://docs.microsoft.com/learn/paths/get-started-with-artificial-intelligence-on-azure/?WT.mc_id=academic-77998-bethanycheum).
Para una introducción sencilla a los temas de _IA en la nube_, puedes considerar tomar el camino de aprendizaje [Comienza con inteligencia artificial en Azure](https://docs.microsoft.com/learn/paths/get-started-with-artificial-intelligence-on-azure/?WT.mc_id=academic-77998-bethanycheum).
# Contenido
# Contenido
| | Enlace de la Lección | PyTorch/Keras/TensorFlow | Lab |
| :-: | :------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------ |
| 0 | [Configuración del Curso](./lessons/0-course-setup/setup.md) | [Configura tu Entorno de Desarrollo](./lessons/0-course-setup/how-to-run.md) | |
| I | [**Introducción a la IA**](./lessons/1-Intro/README.md) | | |
| 01 | [Introducción e Historia de la IA](./lessons/1-Intro/README.md) | - | - |
| II | **IA Simbólica** |
| 02 | [Representación del Conocimiento y Sistemas Expertos](./lessons/2-Symbolic/README.md) | [Sistemas Expertos](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) / [Ontología](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb) /[Gráfico de Conceptos](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/MSConceptGraph.ipynb) | |
| III | [**Introducción a las Redes Neuronales**](./lessons/3-NeuralNetworks/README.md) |||
| 03 | [Perceptrón](./lessons/3-NeuralNetworks/03-Perceptron/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb) | [Lab](./lessons/3-NeuralNetworks/03-Perceptron/lab/README.md) |
| 04 | [Perceptrón Multicapa y Creando nuestro propio Framework](./lessons/3-NeuralNetworks/04-OwnFramework/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) | [Lab](./lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md) |
| 05 | [Introducción a Frameworks (PyTorch/TensorFlow) y Sobreajuste](./lessons/3-NeuralNetworks/05-Frameworks/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) / [Keras](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Lab](./lessons/3-NeuralNetworks/05-Frameworks/lab/README.md) |
| IV | [**Visión por Computadora**](./lessons/4-ComputerVision/README.md) | [PyTorch](https://docs.microsoft.com/learn/modules/intro-computer-vision-pytorch/?WT.mc_id=academic-77998-cacaste) / [TensorFlow](https://docs.microsoft.com/learn/modules/intro-computer-vision-TensorFlow/?WT.mc_id=academic-77998-cacaste)| [Explorar Visión por Computadora en Microsoft Azure](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum) |
| 06 | [Introducción a la Visión por Computadora. OpenCV](./lessons/4-ComputerVision/06-IntroCV/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) | [Laboratorio](./lessons/4-ComputerVision/06-IntroCV/lab/README.md) |
| 07 | [Redes Neuronales Convolucionales](./lessons/4-ComputerVision/07-ConvNets/README.md) & [Arquitecturas de CNN](./lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/ConvNetsPyTorch.ipynb) /[TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/4-ComputerVision/07-ConvNets/ConvNetsTF.ipynb) | [Laboratorio](./lessons/4-ComputerVision/07-ConvNets/lab/README.md) |
| 08 | [Redes Pre-entrenadas y Aprendizaje por Transferencia](./lessons/4-ComputerVision/08-TransferLearning/README.md) y [Trucos de Entrenamiento](./lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/TransferLearningPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Laboratorio](./lessons/4-ComputerVision/08-TransferLearning/lab/README.md) |
| | Enlace de la Lección | PyTorch/Keras/TensorFlow | Laboratorio |
| :-: | :------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------ |
| 0 | [Configuración del Curso](./lessons/0-course-setup/setup.md) | [Configura tu entorno de desarrollo](./lessons/0-course-setup/how-to-run.md) | |
| I | [**Introducción a la IA**](./lessons/1-Intro/README.md) | | |
| 01 | [Introducción e Historia de la IA](./lessons/1-Intro/README.md) | - | - |
| II | **IA Simbólica** |
| 02 | [Representación del Conocimiento y Sistemas Expertos](./lessons/2-Symbolic/README.md) | [Sistemas Expertos](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) / [Ontología](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb) /[Gráfico de Conceptos](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/MSConceptGraph.ipynb) | |
| III | [**Introducción a Redes Neuronales**](./lessons/3-NeuralNetworks/README.md) |||
| 03 | [Perceptrón](./lessons/3-NeuralNetworks/03-Perceptron/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb) | [Laboratorio](./lessons/3-NeuralNetworks/03-Perceptron/lab/README.md) |
| 04 | [Perceptrón Multicapa y Creación de nuestro propio Marco](./lessons/3-NeuralNetworks/04-OwnFramework/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) | [Laboratorio](./lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md) |
| 05 | [Introducción a Marcos (PyTorch/TensorFlow) y Sobreajuste](./lessons/3-NeuralNetworks/05-Frameworks/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) / [Keras](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Laboratorio](./lessons/3-NeuralNetworks/05-Frameworks/lab/README.md) |
| IV | [**Visión por Computadora**](./lessons/4-ComputerVision/README.md) | [PyTorch](https://docs.microsoft.com/learn/modules/intro-computer-vision-pytorch/?WT.mc_id=academic-77998-cacaste) / [TensorFlow](https://docs.microsoft.com/learn/modules/intro-computer-vision-TensorFlow/?WT.mc_id=academic-77998-cacaste)| [Explora Visión por Computadora en Microsoft Azure](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum) |
| 06 | [Introducción a Visión por Computadora. OpenCV](./lessons/4-ComputerVision/06-IntroCV/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb) | [Laboratorio](./lessons/4-ComputerVision/06-IntroCV/lab/README.md) |
| 07 | [Redes Neuronales Convolucionales](./lessons/4-ComputerVision/07-ConvNets/README.md) & [Arquitecturas CNN](./lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/ConvNetsPyTorch.ipynb) /[TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/4-ComputerVision/07-ConvNets/ConvNetsTF.ipynb) | [Laboratorio](./lessons/4-ComputerVision/07-ConvNets/lab/README.md) |
| 08 | [Redes preentrenadas y aprendizaje por transferencia](./lessons/4-ComputerVision/08-TransferLearning/README.md) y [Trucos de entrenamiento](./lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/TransferLearningPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [Laboratorio](./lessons/4-ComputerVision/08-TransferLearning/lab/README.md) |
| 09 | [Autoencoders y VAEs](./lessons/4-ComputerVision/09-Autoencoders/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/09-Autoencoders/AutoEncodersPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb) | |
| 10 | [Redes Generativas Antagónicas y Transferencia de Estilo Artístico](./lessons/4-ComputerVision/10-GANs/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANTF.ipynb) | |
| 10 | [Redes Generativas Adversarias y Transferencia de Estilo Artístico](./lessons/4-ComputerVision/10-GANs/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/GANTF.ipynb) | |
| 11 | [Detección de Objetos](./lessons/4-ComputerVision/11-ObjectDetection/README.md) | [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/11-ObjectDetection/ObjectDetection.ipynb) | [Laboratorio](./lessons/4-ComputerVision/11-ObjectDetection/lab/README.md) |
| 12 | [Segmentación Semántica. U-Net](./lessons/4-ComputerVision/12-Segmentation/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationPytorch.ipynb) / [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationTF.ipynb) | |
| 12 | [Segmentación Semántica. U-Net](./lessons/4-ComputerVision/12-Segmentation/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationPytorch.ipynb) / [TensorFlow](../../(https:/github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationTF.ipynb)) | |
| V | [**Procesamiento de Lenguaje Natural**](./lessons/5-NLP/README.md) | [PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste) /[TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-TensorFlow/?WT.mc_id=academic-77998-cacaste) | [Explora el Procesamiento de Lenguaje Natural en Microsoft Azure](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum)|
| 13 | [Representación de Texto. Bow/TF-IDF](./lessons/5-NLP/13-TextRep/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/TextRepresentationPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/TextRepresentationTF.ipynb) | |
| 14 | [Embeddings semánticos de palabras. Word2Vec y GloVe](./lessons/5-NLP/14-Embeddings/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/EmbeddingsPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/EmbeddingsTF.ipynb) | |
| 15 | [Modelado del Lenguaje. Entrenando tus propios embeddings](./lessons/5-NLP/15-LanguageModeling/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb) | [Laboratorio](./lessons/5-NLP/15-LanguageModeling/lab/README.md) |
| 15 | [Modelado de Lenguaje. Entrenando tus propios embeddings](./lessons/5-NLP/15-LanguageModeling/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb) | [Laboratorio](./lessons/5-NLP/15-LanguageModeling/lab/README.md) |
| 16 | [Redes Neuronales Recurrentes](./lessons/5-NLP/16-RNN/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/16-RNN/RNNPyTorch.ipynb) / [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/16-RNN/RNNTF.ipynb) | |
| 17 | [Redes Generativas Recurrentes](./lessons/5-NLP/17-GenerativeNetworks/README.md) | [PyTorch](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativePyTorch.md) / [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativeTF.md) | [Laboratorio](./lessons/5-NLP/17-GenerativeNetworks/lab/README.md) |
| 18 | [Transformadores. BERT.](./lessons/5-NLP/18-Transformers/READMEtransformers.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersPyTorch.ipynb) /[TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersTF.ipynb) | |
| 17 | [Redes Recurrentes Generativas](./lessons/5-NLP/17-GenerativeNetworks/README.md) | [PyTorch](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativePyTorch.md) / [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/17-GenerativeNetworks/GenerativeTF.md) | [Laboratorio](./lessons/5-NLP/17-GenerativeNetworks/lab/README.md) |
| 18 | [Transformers. BERT.](./lessons/5-NLP/18-Transformers/READMEtransformers.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersPyTorch.ipynb) /[TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/TransformersTF.ipynb) | |
| 19 | [Reconocimiento de Entidades Nombradas](./lessons/5-NLP/19-NER/README.md) | [TensorFlow](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/19-NER/NER-TF.ipynb) | [Laboratorio](./lessons/5-NLP/19-NER/lab/README.md) |
| 20 | [Modelos de Lenguaje Grandes, Programación de Prompts y Tareas de Pocos Ejemplos](./lessons/5-NLP/20-LangModels/READMELargeLang.md) | [PyTorch](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/20-LangModels/GPT-PyTorch.ipynb) | |
| 20 | [Modelos de Lenguaje Grandes, Programación con Prompts y Tareas de Few-Shot](./lessons/5-NLP/20-LangModels/READMELargeLang.md) | [PyTorch](https://microsoft.github.io/AI-For-Beginners/lessons/5-NLP/20-LangModels/GPT-PyTorch.ipynb) | |
| VI | **Otras Técnicas de IA** || |
| 21 | [Algoritmos Genéticos](./lessons/6-Other/21-GeneticAlgorithms/README.md) | [Cuaderno](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/21-GeneticAlgorithms/Genetic.ipynb) | |
| 21 | [Algoritmos Genéticos](./lessons/6-Other/21-GeneticAlgorithms/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/21-GeneticAlgorithms/Genetic.ipynb) | |
| 22 | [Aprendizaje por Refuerzo Profundo](./lessons/6-Other/22-DeepRL/README.md) | [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb) /[TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/CartPole-RL-TF.ipynb) | [Laboratorio](./lessons/6-Other/22-DeepRL/lab/README.md) |
| 23 | [Sistemas Multiagente](./lessons/6-Other/23-MultiagentSystems/README.md) | | |
| VII | **Ética en IA** | | |
| 24 | [Ética en IA y IA Responsable](./lessons/7-Ethics/README.md) | [Microsoft Learn: Principios de IA Responsable](https://docs.microsoft.com/learn/paths/responsible-ai-business-principles/?WT.mc_id=academic-77998-cacaste) | |
| 23 | [Sistemas Multi-Agente](./lessons/6-Other/23-MultiagentSystems/README.md) | | |
| VII | **Ética en la IA** | | |
| 24 | [Ética en la IA y IA Responsable](./lessons/7-Ethics/README.md) | [Microsoft Learn: Principios de IA Responsable](https://docs.microsoft.com/learn/paths/responsible-ai-business-principles/?WT.mc_id=academic-77998-cacaste) | |
| IX | **Extras** | | |
| 25 | [Redes Multi-Modal, CLIP y VQGAN](./lessons/X-Extras/X1-MultiModal/README.md) | [Cuaderno](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/Clip.ipynb) | |
| 25 | [Redes Multimodales, CLIP y VQGAN](./lessons/X-Extras/X1-MultiModal/README.md) | [Notebook](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/Clip.ipynb) | |
## Cada lección contiene
* Material de lectura previa
* Cuadernos Jupyter ejecutables, que a menudo son específicos del marco (**PyTorch** o **TensorFlow**). El cuaderno ejecutable también contiene mucho material teórico, por lo que para entender el tema necesitas revisar al menos una versión del cuaderno (ya sea de PyTorch o TensorFlow).
* **Laboratorios** disponibles para algunos temas, que te brindan la oportunidad de intentar aplicar el material que has aprendido a un problema específico.
* Material de lectura previa.
* Notebooks ejecutables de Jupyter, que a menudo son específicos para el framework (**PyTorch** o **TensorFlow**). El notebook ejecutable también incluye mucho material teórico, por lo que para entender el tema necesitas revisar al menos una versión del notebook (ya sea PyTorch o TensorFlow).
* **Laboratorios** disponibles para algunos temas, que te dan la oportunidad de aplicar el material aprendido a un problema específico.
* Algunas secciones contienen enlaces a módulos de [**MS Learn**](https://learn.microsoft.com/en-us/collections/7w28iy2xrqzdj0?WT.mc_id=academic-77998-bethanycheum) que cubren temas relacionados.
## Comenzando
- Hemos creado una [lección de configuración](./lessons/0-course-setup/setup.md) para ayudarte a configurar tu entorno de desarrollo. - Para educadores, también hemos creado una [lección de configuración curricular](./lessons/0-course-setup/for-teachers.md) para ti.
- Cómo [Ejecutar el código en VSCode o Codepace](./lessons/0-course-setup/how-to-run.md)
- Hemos creado una [lección de configuración](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/0-course-setup/setup.md) para ayudarte a configurar tu entorno de desarrollo. - Para educadores, también hemos creado una [lección de configuración de currículum](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/0-course-setup/for-teachers.md).
- Cómo [Ejecutar el código en VSCode o Codespace](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/0-course-setup/how-to-run.md).
Sigue estos pasos:
@ -101,40 +110,46 @@ Haz un fork del repositorio: Haz clic en el botón "Fork" en la esquina superior
Clona el repositorio: `git clone https://github.com/microsoft/AI-For-Beginners.git`
No olvides marcar (🌟) este repositorio para encontrarlo más fácilmente después.
No olvides darle una estrella (🌟) a este repositorio para encontrarlo más fácilmente más tarde.
## Conoce a otros Aprendices
## Conoce a otros estudiantes
Únete a nuestro [servidor oficial de Discord de IA](https://aka.ms/genai-discord?WT.mc_id=academic-105485-bethanycheum) para conocer y hacer networking con otros aprendices que están tomando este curso y obtener apoyo.
Únete a nuestro [servidor oficial de Discord de IA](https://aka.ms/genai-discord?WT.mc_id=academic-105485-bethanycheum) para conocer y conectar con otros estudiantes que están tomando este curso y obtener soporte.
## Cuestionarios
> **Una nota sobre los cuestionarios**: Todos los cuestionarios se encuentran en la carpeta Quiz-app en etc\quiz-app. Están vinculados desde dentro de las lecciones, la aplicación de cuestionarios se puede ejecutar localmente o desplegarse en Azure; sigue las instrucciones en la carpeta `quiz-app`. Están siendo localizados gradualmente.
Si tienes comentarios sobre el producto o preguntas mientras construyes, visita nuestro [Foro de Desarrolladores de Azure AI Foundry](https://aka.ms/foundry/forum).
## Cuestionarios
> **Una nota sobre los cuestionarios**: Todos los cuestionarios están contenidos en la carpeta Quiz-app en etc\quiz-app. Están vinculados desde las lecciones, y la aplicación de cuestionarios se puede ejecutar localmente o desplegar en Azure; sigue las instrucciones en la carpeta `quiz-app`. Se están localizando gradualmente.
## Se Busca Ayuda
¿Tienes sugerencias o encontraste errores de ortografía o de código? Abre un problema o crea una solicitud de extracción.
¿Tienes sugerencias o encontraste errores de ortografía o código? Crea un issue o un pull request.
## Agradecimientos Especiales
* **✍️ Autor Principal:** [Dmitry Soshnikov](http://soshnikov.com), PhD
* **🔥 Editor:** [Jen Looper](https://twitter.com/jenlooper), PhD
* **🎨 Ilustrador de Sketchnote:** [Tomomi Imura](https://twitter.com/girlie_mac)
* **🔥 Editora:** [Jen Looper](https://twitter.com/jenlooper), PhD
* **🎨 Ilustradora de Sketchnotes:** [Tomomi Imura](https://twitter.com/girlie_mac)
* **✅ Creadora de Cuestionarios:** [Lateefah Bello](https://github.com/CinnamonXI), [MLSA](https://studentambassadors.microsoft.com/)
* **🙏 Contribuidores Clave:** [Evgenii Pishchik](https://github.com/Pe4enIks)
* **🙏 Contribuyentes Principales:** [Evgenii Pishchik](https://github.com/Pe4enIks)
## Otros Currículos
¡Nuestro equipo produce otros currículos! Echa un vistazo a:
¡Nuestro equipo produce otros currículos! Échales un vistazo:
* [Ciencia de Datos para Principiantes](https://aka.ms/ds4beginners)
* [**Versión 2.0** IA Generativa para Principiantes](https://aka.ms/genai-beginners)
* [**NUEVO** Ciberseguridad para Principiantes](https://github.com/microsoft/Security-101??WT.mc_id=academic-96948-sayoung)
* [Desarrollo Web para Principiantes](https://aka.ms/webdev-beginners)
* [IoT para Principiantes](https://aka.ms/iot-beginners)
* [Aprendizaje Automático para Principiantes](https://aka.ms/ml4beginners)
* [Desarrollo XR para Principiantes](https://aka.ms/xr-dev-for-beginners)
* [Dominando GitHub Copilot para Programación en Pareja con IA](https://aka.ms/GitHubCopilotAI)
- [Generative AI for Beginners](https://aka.ms/genai-beginners)
- [Generative AI for Beginners .NET](https://github.com/microsoft/Generative-AI-for-beginners-dotnet)
- [Generative AI with JavaScript](https://github.com/microsoft/generative-ai-with-javascript)
- [Generative AI with Java](https://github.com/microsoft/Generative-AI-for-beginners-java)
- [AI for Beginners](https://aka.ms/ai-beginners)
- [Data Science for Beginners](https://aka.ms/datascience-beginners)
- [ML for Beginners](https://aka.ms/ml-beginners)
- [Cybersecurity for Beginners](https://github.com/microsoft/Security-101)
- [Web Dev for Beginners](https://aka.ms/webdev-beginners)
- [IoT for Beginners](https://aka.ms/iot-beginners)
- [XR Development for Beginners](https://github.com/microsoft/xr-development-for-beginners)
- [Mastering GitHub Copilot for Agentic use](https://github.com/microsoft/Mastering-GitHub-Copilot-for-Paired-Programming)
- [Mastering GitHub Copilot for C#/.NET Developers](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers)
- [Choose Your Own Copilot Adventure](https://github.com/microsoft/CopilotAdventures)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional por parte de un humano. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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 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 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.

33
translations/es/SECURITY.md
View File

@ -1,32 +1,41 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a583f49d359c7ebba61433e4dfcd05a9",
"translation_date": "2025-08-24T09:11:05+00:00",
"source_file": "SECURITY.md",
"language_code": "es"
}
-->
## Seguridad
Microsoft se toma muy en serio la seguridad de nuestros productos y servicios de software, lo que incluye todos los repositorios de código fuente gestionados a través de nuestras organizaciones en GitHub, que incluyen [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin) y [nuestras organizaciones en GitHub](https://opensource.microsoft.com/).
Microsoft se toma muy en serio la seguridad de nuestros productos y servicios de software, lo que incluye todos los repositorios de código fuente gestionados a través de nuestras organizaciones de GitHub, que incluyen [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin) y [nuestras organizaciones de GitHub](https://opensource.microsoft.com/).
Si crees que has encontrado una vulnerabilidad de seguridad en algún repositorio de Microsoft que cumpla con [la definición de vulnerabilidad de seguridad de Microsoft](https://aka.ms/opensource/security/definition), por favor repórtala a nosotros como se describe a continuación.
Si crees que has encontrado una vulnerabilidad de seguridad en algún repositorio propiedad de Microsoft que cumpla con [la definición de vulnerabilidad de seguridad de Microsoft](https://aka.ms/opensource/security/definition), por favor repórtala como se describe a continuación.
## Reportar Problemas de Seguridad
**Por favor, no reportes vulnerabilidades de seguridad a través de problemas públicos de GitHub.**
**Por favor, no reportes vulnerabilidades de seguridad a través de problemas públicos en GitHub.**
En su lugar, repórtalas al Centro de Respuesta de Seguridad de Microsoft (MSRC) en [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
Si prefieres enviar tu reporte sin iniciar sesión, envía un correo electrónico a [secure@microsoft.com](mailto:secure@microsoft.com). Si es posible, cifra tu mensaje con nuestra clave PGP; por favor descárgala de la [página de Clave PGP del Centro de Respuesta de Seguridad de Microsoft](https://aka.ms/opensource/security/pgpkey).
Si prefieres enviar tu reporte sin iniciar sesión, envía un correo electrónico a [secure@microsoft.com](mailto:secure@microsoft.com). Si es posible, encripta tu mensaje con nuestra clave PGP; descárgala desde la [página de Clave PGP del Centro de Respuesta de Seguridad de Microsoft](https://aka.ms/opensource/security/pgpkey).
Deberías recibir una respuesta dentro de 24 horas. Si por alguna razón no lo haces, por favor haz un seguimiento por correo electrónico para asegurarte de que recibimos tu mensaje original. Puedes encontrar información adicional en [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
Deberías recibir una respuesta dentro de las 24 horas. Si por alguna razón no la recibes, por favor haz un seguimiento por correo electrónico para asegurarte de que recibimos tu mensaje original. Puedes encontrar información adicional en [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
Por favor incluye la información solicitada que se detalla a continuación (tanto como puedas proporcionar) para ayudarnos a entender mejor la naturaleza y el alcance del posible problema:
Por favor, incluye la información solicitada que se detalla a continuación (tanto como puedas proporcionar) para ayudarnos a comprender mejor la naturaleza y el alcance del posible problema:
* Tipo de problema (por ejemplo, desbordamiento de búfer, inyección SQL, scripting entre sitios, etc.)
* Rutas completas de los archivos fuente relacionados con la manifestación del problema
* La ubicación del código fuente afectado (etiqueta/rama/confirmación o URL directa)
* La ubicación del código fuente afectado (etiqueta/ramo/commit o URL directa)
* Cualquier configuración especial requerida para reproducir el problema
* Instrucciones paso a paso para reproducir el problema
* Prueba de concepto o código de explotación (si es posible)
* Impacto del problema, incluyendo cómo un atacante podría explotar el problema
* Código de prueba de concepto o de explotación (si es posible)
* Impacto del problema, incluyendo cómo un atacante podría explotarlo
Esta información nos ayudará a clasificar tu reporte más rápidamente.
Esta información nos ayudará a priorizar tu reporte más rápidamente.
Si estás reportando para un programa de recompensas por errores, reportes más completos pueden contribuir a una mayor recompensa. Por favor visita nuestra página del [Programa de Recompensas por Errores de Microsoft](https://aka.ms/opensource/security/bounty) para más detalles sobre nuestros programas activos.
Si estás reportando para un programa de recompensas por errores, los reportes más completos pueden contribuir a obtener una recompensa mayor. Por favor, visita nuestra página del [Programa de Recompensas por Errores de Microsoft](https://aka.ms/opensource/security/bounty) para más detalles sobre nuestros programas activos.
## Idiomas Preferidos
@ -37,4 +46,4 @@ Preferimos que todas las comunicaciones sean en inglés.
Microsoft sigue el principio de [Divulgación Coordinada de Vulnerabilidades](https://aka.ms/opensource/security/cvd).
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional por un humano. No somos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

21
translations/es/etc/CODE_OF_CONDUCT.md
View File

@ -1,12 +1,21 @@
# Código de Conducta de Microsoft para Código Abierto
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
"translation_date": "2025-08-24T09:26:49+00:00",
"source_file": "etc/CODE_OF_CONDUCT.md",
"language_code": "es"
}
-->
# Código de Conducta de Código Abierto de Microsoft
Este proyecto ha adoptado el [Código de Conducta de Microsoft para Código Abierto](https://opensource.microsoft.com/codeofconduct/).
Este proyecto ha adoptado el [Código de Conducta de Código Abierto de Microsoft](https://opensource.microsoft.com/codeofconduct/).
Recursos:
- [Código de Conducta de Microsoft para Código Abierto](https://opensource.microsoft.com/codeofconduct/)
- [Preguntas Frecuentes sobre el Código de Conducta de Microsoft](https://opensource.microsoft.com/codeofconduct/faq/)
- Contacta a [opencode@microsoft.com](mailto:opencode@microsoft.com) si tienes preguntas o inquietudes.
- [Código de Conducta de Código Abierto de Microsoft](https://opensource.microsoft.com/codeofconduct/)
- [Preguntas frecuentes sobre el Código de Conducta de Microsoft](https://opensource.microsoft.com/codeofconduct/faq/)
- Contacta a [opencode@microsoft.com](mailto:opencode@microsoft.com) para preguntas o inquietudes
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien 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 la traducción profesional por parte de un humano. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

32
translations/es/etc/CONTRIBUTING.md
View File

@ -1,20 +1,30 @@
# Contribuyendo
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "847a587aa1b83f4d00858183ff3ed18a",
"translation_date": "2025-08-24T09:27:05+00:00",
"source_file": "etc/CONTRIBUTING.md",
"language_code": "es"
}
-->
# Contribuir
Este proyecto da la bienvenida a contribuciones y sugerencias. La mayoría de las contribuciones requieren que aceptes un Acuerdo de Licencia de Contribuidor (CLA) que declara que tienes el derecho de, y realmente lo haces, otorgarnos los derechos para usar tu contribución. Para más detalles, visita https://cla.microsoft.com.
Este proyecto da la bienvenida a contribuciones y sugerencias. La mayoría de las contribuciones requieren que aceptes un Acuerdo de Licencia de Contribuidor (CLA) declarando que tienes el derecho de, y efectivamente otorgas, los derechos para usar tu contribución. Para más detalles, visita https://cla.microsoft.com.
Cuando envíes una solicitud de extracción, un bot de CLA determinará automáticamente si necesitas proporcionar un CLA y decorará la PR de manera apropiada (por ejemplo, etiqueta, comentario). Simplemente sigue las instrucciones proporcionadas por el bot. Solo necesitarás hacer esto una vez en todos los repositorios que utilicen nuestro CLA.
Cuando envíes una solicitud de extracción (pull request), un CLA-bot determinará automáticamente si necesitas proporcionar un CLA y decorará la PR adecuadamente (por ejemplo, etiqueta, comentario). Simplemente sigue las instrucciones proporcionadas por el bot. Solo necesitarás hacer esto una vez en todos los repositorios que utilicen nuestro CLA.
Este proyecto ha adoptado el [Código de Conducta de Código Abierto de Microsoft](https://opensource.microsoft.com/codeofconduct/). Para más información, consulta las [Preguntas Frecuentes sobre el Código de Conducta](https://opensource.microsoft.com/codeofconduct/faq/) o contacta a [opencode@microsoft.com](mailto:opencode@microsoft.com) con cualquier pregunta o comentario adicional.
Este proyecto ha adoptado el [Código de Conducta de Código Abierto de Microsoft](https://opensource.microsoft.com/codeofconduct/).
Para más información, consulta las [Preguntas Frecuentes sobre el Código de Conducta](https://opensource.microsoft.com/codeofconduct/faq/) o contacta a [opencode@microsoft.com](mailto:opencode@microsoft.com) para cualquier pregunta o comentario adicional.
# Buscando Contribuciones
Actualmente estamos buscando activamente contribuciones sobre los siguientes temas:
Actualmente estamos buscando activamente contribuciones en los siguientes temas:
- [ ] Escribir sección sobre Aprendizaje por Refuerzo Profundo
- [ ] Mejorar la sección + cuaderno sobre Detección de Objetos
- [ ] PyTorch Lightning (para [esta sección](https://github.com/microsoft/AI-For-Beginners/blob/main/3-NeuralNetworks/05-Frameworks/README.md))
- [ ] Escribir sección + ejemplos sobre Reconocimiento de Entidades Nombradas
- [ ] Crear ejemplos para entrenar nuestras propias incrustaciones para [esta sección](https://github.com/microsoft/AI-For-Beginners/tree/main/5-NLP/15-LanguageModeling)
- [ ] Escribir una sección sobre Aprendizaje por Refuerzo Profundo
- [ ] Mejorar la sección + notebook sobre Detección de Objetos
- [ ] PyTorch Lightning (para [esta sección](https://github.com/microsoft/AI-For-Beginners/blob/main/3-NeuralNetworks/05-Frameworks/README.md))
- [ ] Escribir una sección + ejemplos sobre Reconocimiento de Entidades Nombradas
- [ ] Crear ejemplos para entrenar nuestros propios embeddings para [esta sección](https://github.com/microsoft/AI-For-Beginners/tree/main/5-NLP/15-LanguageModeling)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional por parte de un humano. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

41
translations/es/etc/Mindmap.md
View File

@ -1,14 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f2f88dbd2debd38e26149b27b1fd272d",
"translation_date": "2025-08-24T09:27:13+00:00",
"source_file": "etc/Mindmap.md",
"language_code": "es"
}
-->
# IA
## [Introducción a la IA](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/1-Intro/README.md)
- Definición de IA
- Historia de la IA
- Enfoques de la IA
- De arriba hacia abajo/Simbólico
- De arriba hacia abajo/Simbólica
- De abajo hacia arriba/Neuronal
- Evolutivo
- IA Sinérgica / Emergente
- [Escuela de Negocios de IA de Microsoft](https://www.microsoft.com/ai/ai-business-school/?WT.mc_id=academic-77998-cacaste)
- Evolutiva
- Sinérgica / IA Emergente
- [Microsoft AI Business School](https://www.microsoft.com/ai/ai-business-school/?WT.mc_id=academic-77998-cacaste)
## [IA Simbólica](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/README.md)
- Representación del Conocimiento
@ -19,53 +28,55 @@
## [Redes Neuronales](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/README.md)
- [Perceptrón](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/03-Perceptron/README.md)
- [Redes Multicapa](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/04-OwnFramework/README.md)
- [Introducción a los Frameworks](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/README.md)
- [Introducción a Frameworks](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/README.md)
- [PyTorch](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb)
- [TensorFlow](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.md)
- [Sobreajuste](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/05-Frameworks/Overfitting.md)
## [Visión por Computadora](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/README.md)
- En MS Learn
- [Fundamentos de IA: Explorar Visión por Computadora](https://docs.microsoft.com/learn/paths/explore-computer-vision-microsoft-azure/?WT.mc_id=academic-77998-cacaste)
- [Fundamentos de IA: Explora Visión por Computadora](https://docs.microsoft.com/learn/paths/explore-computer-vision-microsoft-azure/?WT.mc_id=academic-77998-cacaste)
- [Visión por Computadora con PyTorch](https://docs.microsoft.com/learn/modules/intro-computer-vision-pytorch/?WT.mc_id=academic-77998-cacaste)
- [Visión por Computadora con TensorFlow](https://docs.microsoft.com/learn/modules/intro-computer-vision-TensorFlow/?WT.mc_id=academic-77998-cacaste)
- [Introducción a CV. OpenCV](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/06-IntroCV/README.md)
- [Introducción a Visión por Computadora. OpenCV](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/06-IntroCV/README.md)
- [Redes Convolucionales](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/README.md)
- [Arquitecturas de CNN](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md)
- [Aprendizaje por Transferencia](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/README.md)
- [Trucos de Entrenamiento](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md)
- [Autoencoders y VAEs](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/09-Autoencoders/README.md)
- [Redes Generativas Antagónicas](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/README.md)
- [Redes Generativas Adversarias](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/README.md)
- [Transferencia de Estilo](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)
- [Detección de Objetos](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/11-ObjectDetection/README.md)
- [Segmentación](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/12-Segmentation/README.md)
## [Procesamiento de Lenguaje Natural](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/README.md)
- En MS Learn
- [Fundamentos de IA: Explorar PLN](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-cacaste)
- [Fundamentos de IA: Explora PLN](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77998-cacaste)
- [PLN con PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste)
- [PLN con TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-TensorFlow/?WT.mc_id=academic-77998-cacaste)
- [Representación de Texto](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/README.md)
- [Representación de Texto](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/13-TextRep/README.md)
- Bolsa de Palabras
- TF/IDF
- [Incrustaciones Semánticas](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/README.md)
- [Embeddings Semánticos](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/14-Embeddings/README.md)
- Word2Vec
- GloVE
- [Modelado de Lenguaje](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/15-LanguageModeling)
- [Redes Neuronales Recurrentes](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/16-RNN/README.md)
- LSTM
- GRU
- [Redes Generativas Recurrentes](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/17-GenerativeNetworks/README.md)
- [Redes Recurrentes Generativas](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/17-GenerativeNetworks/README.md)
- [Transformers y BERT](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/18-Transformers/README.md)
- [Reconocimiento de Entidades Nombradas](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/19-NER/README.md)
- [Generación de Texto y GPT](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/20-LanguageModels/README.md)
## Otras Técnicas
- [Algoritmos Genéticos](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/21-GeneticAlgorithms/README.md)
- [Aprendizaje por Refuerzo Profundo](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/README.md)
- [Sistemas Multiagente](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md)
- [Sistemas Multi-Agente](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md)
## [Ética de la IA](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/README.md)
## [Ética en la IA](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/README.md)
- [MS Learn sobre IA Responsable](https://docs.microsoft.com/learn/paths/responsible-ai-business-principles/?WT.mc_id=academic-77998-cacaste)
## Extras
- [Redes Multimodales](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/README.md)
- [CLIP](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/Clip.ipynb)
@ -73,4 +84,4 @@
- VQ-GAN
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional realizada por humanos. No nos hacemos responsables de ningún malentendido o mala interpretación que surja del uso de esta traducción.
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.

19
translations/es/etc/SUPPORT.md
View File

@ -1,14 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fdfc08baee91e402938a2b1f94fe0949",
"translation_date": "2025-08-24T09:26:44+00:00",
"source_file": "etc/SUPPORT.md",
"language_code": "es"
}
-->
# Soporte
## Cómo reportar problemas y obtener ayuda
Este proyecto utiliza GitHub Issues para rastrear errores y solicitudes de funciones. Por favor, busca en los problemas existentes antes de presentar nuevos problemas para evitar duplicados. Para nuevos problemas, presenta tu error o solicitud de función como un nuevo Issue.
Este proyecto utiliza GitHub Issues para rastrear errores y solicitudes de funciones. Por favor, busca en los problemas existentes antes de reportar nuevos problemas para evitar duplicados. Para nuevos problemas, reporta tu error o solicitud de función como un nuevo Issue.
Para ayuda y preguntas sobre el uso de este proyecto, por favor utiliza los Foros de Discusión.
Para obtener ayuda y resolver dudas sobre el uso de este proyecto, utiliza los Tableros de Discusión.
## Política de Soporte de Microsoft
## Política de soporte de Microsoft
El soporte para este proyecto está limitado a los recursos mencionados anteriormente.
El soporte para este proyecto se limita a los recursos mencionados anteriormente.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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 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.

35
translations/es/etc/TRANSLATIONS.md
View File

@ -1,36 +1,45 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "62b3e3ad5182edb905eec649a87eeeb4",
"translation_date": "2025-08-24T09:26:55+00:00",
"source_file": "etc/TRANSLATIONS.md",
"language_code": "es"
}
-->
# Contribuye traduciendo lecciones
¡Damos la bienvenida a las traducciones de las lecciones en este currículo!
¡Damos la bienvenida a las traducciones de las lecciones en este plan de estudios!
## Directrices
Hay carpetas en cada carpeta de lección y en la carpeta de introducción de la lección que contienen los archivos markdown traducidos.
Hay carpetas en cada carpeta de lección y en la carpeta de introducción de lección que contienen los archivos markdown traducidos.
> Nota: por favor, no traduzcas ningún código en los archivos de muestra de código; las únicas cosas que se deben traducir son README, tareas y cuestionarios. ¡Gracias!
> Nota: por favor, no traduzcas ningún código en los archivos de ejemplo de código; lo único que se debe traducir son los README, las tareas y los cuestionarios. ¡Gracias!
Los archivos traducidos deben seguir esta convención de nomenclatura:
Los archivos traducidos deben seguir esta convención de nombres:
**README._[language]_.md**
donde _[language]_ es una abreviatura de dos letras para el idioma según el estándar ISO 639-1 (por ejemplo, `README.es.md` para español y `README.nl.md` para neerlandés).
donde _[language]_ es una abreviatura de dos letras del idioma siguiendo el estándar ISO 639-1 (por ejemplo, `README.es.md` para español y `README.nl.md` para neerlandés).
**assignment._[language]_.md**
Similar a los Readme, por favor traduce también las tareas.
De manera similar a los README, por favor traduce también las tareas.
**Cuestionarios**
1. Agrega tu traducción al quiz-app añadiendo un archivo aquí: https://github.com/microsoft/AI-For-Beginners/tree/main/etc/quiz-app/src/assets/translations, con la convención de nomenclatura adecuada (en.json, fr.json). **Sin embargo, por favor no localices las palabras 'true' o 'false'. ¡Gracias!**
1. Agrega tu traducción a la aplicación de cuestionarios añadiendo un archivo aquí: https://github.com/microsoft/AI-For-Beginners/tree/main/etc/quiz-app/src/assets/translations, con la convención de nombres adecuada (en.json, fr.json). **Por favor, no localices las palabras 'true' o 'false'. ¡Gracias!**
2. Agrega tu código de idioma al menú desplegable en el archivo App.vue del quiz-app.
2. Agrega tu código de idioma al menú desplegable en el archivo App.vue de la aplicación de cuestionarios.
3. Edita el archivo [translations index.js del quiz-app](https://github.com/microsoft/AI-For-Beginners/blob/main/etc/quiz-app/src/assets/translations/index.js) para añadir tu idioma.
3. Edita el [archivo index.js de traducciones](https://github.com/microsoft/AI-For-Beginners/blob/main/etc/quiz-app/src/assets/translations/index.js) de la aplicación de cuestionarios para añadir tu idioma.
4. Finalmente, edita TODOS los enlaces de cuestionarios en tus archivos README.md traducidos para que apunten directamente a tu cuestionario traducido: https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1 se convierte en https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1?loc=id
4. Finalmente, edita TODOS los enlaces de los cuestionarios en tus archivos README.md traducidos para que apunten directamente a tu cuestionario traducido: https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1 se convierte en https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/1?loc=id
**GRACIAS**
**¡GRACIAS!**
¡Apreciamos sinceramente tus esfuerzos!
¡Realmente apreciamos tus esfuerzos!
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. 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 la traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

99
translations/es/etc/quiz-app/README.md
View File

@ -1,18 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d699cf8509f74baa5b0b838de5cf0662",
"translation_date": "2025-08-24T09:27:33+00:00",
"source_file": "etc/quiz-app/README.md",
"language_code": "es"
}
-->
# Cuestionarios
Estos cuestionarios son los cuestionarios de antes y después de la conferencia para el currículo de IA en https://aka.ms/ai-beginners
Estos cuestionarios son los cuestionarios previos y posteriores a las lecciones del currículo de IA en https://aka.ms/ai-beginners
## Agregar un conjunto de cuestionarios traducidos
Agrega una traducción de cuestionario creando estructuras de cuestionarios coincidentes en las carpetas `assets/translations`. Los cuestionarios canónicos están en `assets/translations/en`. Los cuestionarios están divididos en varios grupos por lección. Asegúrate de alinear la numeración con la sección de cuestionarios correspondiente. Hay un total de 40 cuestionarios en este currículo, comenzando desde 0.
Agrega una traducción de cuestionarios creando estructuras de cuestionarios correspondientes en las carpetas `assets/translations`. Los cuestionarios originales están en `assets/translations/en`. Los cuestionarios están divididos en varios grupos por lección. Asegúrate de alinear la numeración con la sección de cuestionarios adecuada. Hay un total de 40 cuestionarios en este currículo, comenzando desde el número 0.
Después de editar las traducciones, edita el archivo index.js en la carpeta de traducción para importar todos los archivos siguiendo las convenciones en `en`.
Edita el archivo `index.js` en `assets/translations` para importar los nuevos archivos traducidos.
Luego, edita el menú desplegable en `App.vue` en esta aplicación para agregar tu idioma. Asegúrate de que la abreviatura localizada coincida con el nombre de la carpeta de tu idioma.
Luego, edita el menú desplegable en `App.vue` en esta aplicación para agregar tu idioma. Haz coincidir la abreviatura localizada con el nombre de la carpeta de tu idioma.
Finalmente, edita todos los enlaces de cuestionarios en las lecciones traducidas, si existen, para incluir esta localización como un parámetro de consulta: `?loc=fr`, por ejemplo.
Finalmente, edita todos los enlaces de los cuestionarios en las lecciones traducidas, si existen, para incluir esta localización como un parámetro de consulta: `?loc=fr`, por ejemplo.
## Configuración del proyecto
@ -20,7 +29,7 @@ Finalmente, edita todos los enlaces de cuestionarios en las lecciones traducidas
npm install
```
### Compila y recarga en caliente para desarrollo
### Compila y recarga automáticamente para desarrollo
```
npm run serve
@ -32,65 +41,65 @@ npm run serve
npm run build
```
### Lint y corrige archivos
### Revisa y corrige archivos
```
npm run lint
```
### Personaliza la configuración
### Personalizar configuración
Consulta [Referencia de Configuración](https://cli.vuejs.org/config/).
Créditos: Gracias a la versión original de esta aplicación de cuestionarios: https://github.com/arpan45/simple-quiz-vue
## Despliegue en Azure
## Desplegar en Azure
Aquí tienes una guía paso a paso para ayudarte a comenzar:
1. Haz un fork de un repositorio de GitHub
1. Haz un fork del repositorio de GitHub
Asegúrate de que el código de tu aplicación web estática esté en tu repositorio de GitHub. Haz un fork de este repositorio.
2. Crea una Aplicación Web Estática de Azure
- Crea una [cuenta de Azure](http://azure.microsoft.com)
- Ve al [portal de Azure](https://portal.azure.com)
- Haz clic en “Crear un recurso” y busca “Aplicación Web Estática”.
- Haz clic en “Crear”.
2. Crea una aplicación web estática en Azure
- Crea una [cuenta de Azure](http://azure.microsoft.com)
- Ve al [portal de Azure](https://portal.azure.com)
- Haz clic en “Crear un recurso” y busca “Aplicación Web Estática”.
- Haz clic en “Crear”.
3. Configura la Aplicación Web Estática
- Básicos: Suscripción: Selecciona tu suscripción de Azure.
- Grupo de Recursos: Crea un nuevo grupo de recursos o usa uno existente.
- Nombre: Proporciona un nombre para tu aplicación web estática.
- Región: Elige la región más cercana a tus usuarios.
3. Configura la aplicación web estática
- Básicos: Suscripción: Selecciona tu suscripción de Azure.
- Grupo de recursos: Crea un nuevo grupo de recursos o utiliza uno existente.
- Nombre: Proporciona un nombre para tu aplicación web estática.
- Región: Elige la región más cercana a tus usuarios.
- #### Detalles de Despliegue:
- Fuente: Selecciona “GitHub”.
- Cuenta de GitHub: Autoriza a Azure para acceder a tu cuenta de GitHub.
- Organización: Selecciona tu organización de GitHub.
- Repositorio: Elige el repositorio que contiene tu aplicación web estática.
- Rama: Selecciona la rama desde la que deseas desplegar.
- #### Detalles de implementación:
- Fuente: Selecciona “GitHub”.
- Cuenta de GitHub: Autoriza a Azure para acceder a tu cuenta de GitHub.
- Organización: Selecciona tu organización de GitHub.
- Repositorio: Elige el repositorio que contiene tu aplicación web estática.
- Rama: Selecciona la rama desde la que deseas desplegar.
- #### Detalles de Construcción:
- Presets de Construcción: Elige el framework con el que está construida tu aplicación (por ejemplo, React, Angular, Vue, etc.).
- Ubicación de la Aplicación: Especifica la carpeta que contiene el código de tu aplicación (por ejemplo, / si está en la raíz).
- Ubicación de la API: Si tienes una API, especifica su ubicación (opcional).
- Ubicación de Salida: Especifica la carpeta donde se genera la salida de la construcción (por ejemplo, build o dist).
- #### Detalles de compilación:
- Presets de compilación: Elige el framework con el que está construida tu aplicación (por ejemplo, React, Angular, Vue, etc.).
- Ubicación de la aplicación: Especifica la carpeta que contiene el código de tu aplicación (por ejemplo, / si está en la raíz).
- Ubicación de la API: Si tienes una API, especifica su ubicación (opcional).
- Ubicación de salida: Especifica la carpeta donde se genera la salida de la compilación (por ejemplo, build o dist).
4. Revisa y Crea
Revisa tus configuraciones y haz clic en “Crear”. Azure configurará los recursos necesarios y creará un flujo de trabajo de GitHub Actions en tu repositorio.
4. Revisa y crea
Revisa tu configuración y haz clic en “Crear”. Azure configurará los recursos necesarios y creará un archivo de flujo de trabajo de GitHub Actions en tu repositorio.
5. Flujo de Trabajo de GitHub Actions
Azure creará automáticamente un archivo de flujo de trabajo de GitHub Actions en tu repositorio (.github/workflows/azure-static-web-apps-<name>.yml). Este flujo de trabajo manejará el proceso de construcción y despliegue.
5. Flujo de trabajo de GitHub Actions
Azure creará automáticamente un archivo de flujo de trabajo de GitHub Actions en tu repositorio (.github/workflows/azure-static-web-apps-<nombre>.yml). Este flujo de trabajo manejará el proceso de compilación y despliegue.
6. Monitorea el Despliegue
Ve a la pestaña “Actions” en tu repositorio de GitHub.
Deberías ver un flujo de trabajo en ejecución. Este flujo de trabajo construirá y desplegará tu aplicación web estática en Azure.
Una vez que el flujo de trabajo se complete, tu aplicación estará activa en la URL de Azure proporcionada.
6. Monitorea el despliegue
Ve a la pestaña “Actions” en tu repositorio de GitHub.
Deberías ver un flujo de trabajo en ejecución. Este flujo de trabajo compilará y desplegará tu aplicación web estática en Azure.
Una vez que el flujo de trabajo se complete, tu aplicación estará en vivo en la URL proporcionada por Azure.
### Ejemplo de Archivo de Flujo de Trabajo
### Ejemplo de archivo de flujo de trabajo
Aquí tienes un ejemplo de cómo podría verse el archivo de flujo de trabajo de GitHub Actions:
name: Azure Static Web Apps CI/CD
Aquí tienes un ejemplo de cómo podría verse el archivo de flujo de trabajo de GitHub Actions:
name: Azure Static Web Apps CI/CD
```
on:
push:
@ -119,9 +128,9 @@ jobs:
output_location: "dist" #Built app content directory - optional
```
### Recursos Adicionales
- [Documentación de Azure Static Web Apps](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [Documentación de GitHub Actions](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
### Recursos adicionales
- [Documentación de Azure Static Web Apps](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [Documentación de GitHub Actions](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por un humano. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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 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.

29
translations/es/lessons/0-course-setup/for-teachers.md
View File

@ -1,26 +1,35 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a094ef9927883de1cfcee51dbd143381",
"translation_date": "2025-08-24T09:26:23+00:00",
"source_file": "lessons/0-course-setup/for-teachers.md",
"language_code": "es"
}
-->
# Para Educadores
¿Te gustaría utilizar este currículo en tu aula? ¡Siéntete libre de hacerlo!
¿Te gustaría usar este plan de estudios en tu aula? ¡Siéntete libre de hacerlo!
De hecho, puedes usarlo dentro de GitHub mismo utilizando GitHub Classroom.
De hecho, puedes usarlo directamente en GitHub utilizando GitHub Classroom.
Para hacerlo, haz un fork de este repositorio. Necesitarás crear un repositorio para cada lección, así que tendrás que extraer cada carpeta en un repositorio separado. De esa manera, [GitHub Classroom](https://classroom.github.com/classrooms) puede recoger cada lección por separado.
Para hacerlo, haz un fork de este repositorio. Necesitarás crear un repositorio para cada lección, por lo que tendrás que extraer cada carpeta en un repositorio separado. De esta manera, [GitHub Classroom](https://classroom.github.com/classrooms) podrá identificar cada lección por separado.
Estas [instrucciones completas](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) te darán una idea de cómo configurar tu aula.
## Usando el repositorio tal como está
## Usar el repositorio tal como está
Si deseas utilizar este repositorio tal como está actualmente, sin usar GitHub Classroom, también se puede hacer. Tendrás que comunicarte con tus estudiantes sobre qué lección trabajar juntos.
Si prefieres usar este repositorio tal como está, sin utilizar GitHub Classroom, también es posible. Necesitarás comunicarte con tus estudiantes para indicarles qué lección trabajar juntos.
En un formato en línea (Zoom, Teams u otro), podrías formar salas de grupo para los cuestionarios y guiar a los estudiantes para ayudarles a prepararse para aprender. Luego, invita a los estudiantes a participar en los cuestionarios y enviar sus respuestas como 'issues' en un momento determinado. Podrías hacer lo mismo con las tareas, si deseas que los estudiantes trabajen colaborativamente de manera abierta.
En un formato en línea (Zoom, Teams u otro), podrías formar salas de trabajo para los cuestionarios y guiar a los estudiantes para que se preparen para aprender. Luego, invítalos a realizar los cuestionarios y enviar sus respuestas como 'issues' en un momento determinado. Podrías hacer lo mismo con las tareas, si deseas que los estudiantes trabajen de manera colaborativa y abierta.
Si prefieres un formato más privado, pide a tus estudiantes que hagan un fork del currículo, lección por lección, a sus propios repositorios de GitHub como repositorios privados y te den acceso. Así podrán completar cuestionarios y tareas de forma privada y enviártelos a través de issues en tu repositorio del aula.
Si prefieres un formato más privado, pide a tus estudiantes que hagan un fork del plan de estudios, lección por lección, en sus propios repositorios privados de GitHub y te den acceso. De esta manera, podrán completar los cuestionarios y tareas de forma privada y enviártelos a través de issues en tu repositorio de aula.
Hay muchas maneras de hacer que esto funcione en un formato de aula en línea. ¡Por favor, háznos saber qué funciona mejor para ti!
Existen muchas maneras de hacer que esto funcione en un aula en línea. ¡Por favor, cuéntanos qué funciona mejor para ti!
## Por favor, danos tu opinión
Queremos que este currículo funcione para ti y tus estudiantes. ¡Por favor, déjanos tus comentarios en los foros de discusión!
Queremos que este plan de estudios funcione para ti y tus estudiantes. ¡Déjanos tus comentarios en los foros de discusión!
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. 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 somos responsables de ningún malentendido o mala interpretación que surja del uso de esta traducción.
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 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.

57
translations/es/lessons/0-course-setup/how-to-run.md
View File

@ -1,12 +1,21 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7df19702b8d2d3f7c4238c51bec2c8fc",
"translation_date": "2025-08-24T09:26:09+00:00",
"source_file": "lessons/0-course-setup/how-to-run.md",
"language_code": "es"
}
-->
# Cómo Ejecutar el Código
Este plan de estudios contiene muchos ejemplos y laboratorios ejecutables que querrás correr. Para hacer esto, 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 curso contiene muchos ejemplos ejecutables y laboratorios que querrás ejecutar. Para hacerlo, necesitas la capacidad de ejecutar código Python en Jupyter Notebooks proporcionados como parte de este curso. Tienes varias opciones para ejecutar el código:
## Ejecutar localmente en tu computadora
Para ejecutar el código localmente en tu computadora, necesitas tener alguna versión de Python instalada. Personalmente, recomiendo 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, necesitas tener alguna versión de Python instalada. Personalmente, recomiendo 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, necesitas clonar el repositorio y crear un entorno virtual que se utilizará para este curso:
Después de instalar miniconda, necesitas clonar el repositorio y crear un entorno virtual para usar en este curso:
```bash
git clone http://github.com/microsoft/ai-for-beginners
@ -15,17 +24,17 @@ conda env create --name ai4beg --file .devcontainer/environment.yml
conda activate ai4beg
```
### Usando Visual Studio Code con la Extensión de Python
### Usar Visual Studio Code con la Extensión de Python
Probablemente, la mejor manera de utilizar el plan de estudios es abrirlo 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).
Probablemente la mejor manera de usar el curso es abrirlo 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, te sugerirá automáticamente instalar las extensiones de Python. También tendrás que instalar miniconda como se describió anteriormente.
> **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ó anteriormente.
> **Nota**: Si VS Code te sugiere reabrir el repositorio en un contenedor, debes rechazar esto para usar la instalación local de Python.
> **Nota**: Si VS Code te sugiere reabrir el repositorio en un contenedor, necesitas rechazar esta opción para usar la instalación local de Python.
### Usando Jupyter en el Navegador
### Usar Jupyter en el Navegador
También puedes usar el entorno de Jupyter directamente desde el navegador en tu propia computadora. De hecho, tanto Jupyter clásico como Jupyter Hub proporcionan un entorno de desarrollo bastante conveniente con autocompletado, resaltado de código, etc.
También puedes usar el entorno de Jupyter directamente desde el navegador en tu propia computadora. De hecho, tanto Jupyter clásico como Jupyter Hub ofrecen un entorno de desarrollo bastante conveniente con autocompletado, resaltado de código, etc.
Para iniciar Jupyter localmente, ve al directorio del curso y ejecuta:
@ -36,32 +45,32 @@ o
```bash
jupyterhub
```
Luego puedes navegar a cualquiera de las carpetas `.ipynb` files, open them and start working.
Luego puedes navegar a cualquiera de los archivos `.ipynb`, abrirlos y comenzar a trabajar.
### Running in container
### Ejecutar en un contenedor
One alternative to Python installation would be to run the code in container. Since our repository contains special `.devcontainer` que indican cómo construir un contenedor para este repositorio; VS Code te ofrecerá reabrir el código en un contenedor. Esto requerirá la instalación de Docker y también será más complejo, por lo que recomendamos esto a usuarios más experimentados.
Una alternativa a la instalación de Python sería ejecutar el código en un contenedor. Dado que nuestro repositorio contiene una carpeta especial `.devcontainer` que indica cómo construir un contenedor para este repositorio, VS Code te ofrecerá reabrir el código en un contenedor. Esto requerirá la instalación de Docker y será más complejo, por lo que recomendamos esta opción para usuarios más experimentados.
## Ejecutando en la Nube
## Ejecutar en la Nube
Si no deseas 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 formas de hacerlo:
Si no deseas 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:
* Usando **[GitHub Codespaces](https://github.com/features/codespaces)**, que es un entorno virtual creado para ti en GitHub, accesible a través de la interfaz del navegador de VS Code. Si tienes acceso a Codespaces, solo necesitas hacer clic en el botón **Code** en el repositorio, iniciar un codespace y comenzar a trabajar en poco tiempo.
* Usando **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) es un recurso de computación gratuito proporcionado en la nube para que personas como tú prueben algún código en GitHub. Hay un botón en la página principal para abrir el repositorio en Binder; esto te llevará rápidamente al sitio de Binder, que construirá el contenedor subyacente y comenzará la interfaz web de Jupyter sin problemas.
* Usar **[GitHub Codespaces](https://github.com/features/codespaces)**, que es un entorno virtual creado para ti en GitHub, accesible a través de la interfaz del navegador de VS Code. Si tienes acceso a Codespaces, simplemente puedes hacer clic en el botón **Code** en el repositorio, iniciar un codespace y comenzar a trabajar rápidamente.
* Usar **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) proporciona recursos de computación gratuitos 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, lo que debería llevarte rápidamente al sitio de Binder, que construirá el contenedor subyacente y comenzará la interfaz web de Jupyter de manera fluida.
> **Nota**: Para prevenir el uso indebido, Binder tiene acceso bloqueado a algunos recursos web. Esto puede impedir que parte del código funcione, especialmente el que obtiene modelos y/o conjuntos de datos de Internet público. Es posible que necesites encontrar algunas soluciones alternativas. Además, los recursos de computación proporcionados por Binder son bastante básicos, por lo que el entrenamiento será lento, especialmente en lecciones más complejas más adelante.
> **Nota**: Para prevenir el mal uso, Binder tiene acceso bloqueado a algunos recursos web. Esto puede impedir que funcione parte del código que descarga modelos y/o conjuntos de datos desde Internet público. Es posible que necesites buscar algunas soluciones alternativas. Además, los recursos de computación proporcionados por Binder son bastante básicos, por lo que el entrenamiento será lento, especialmente en lecciones más complejas.
## Ejecutando en la Nube con GPU
## Ejecutar en la Nube con GPU
Algunas de las lecciones posteriores en este plan de estudios se beneficiarían enormemente del soporte de GPU, porque de lo contrario el entrenamiento será dolorosamente lento. 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 a través de tu institución:
Algunas de las lecciones más avanzadas de este curso se beneficiarían enormemente del soporte de GPU, ya que de lo contrario el entrenamiento será extremadamente lento. Hay algunas opciones que puedes seguir, especialmente si tienes acceso a la nube, ya sea a través de [Azure para Estudiantes](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) o a través de tu institución:
* Crea 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 conéctate 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 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 para GPU.
> **Nota**: Algunas suscripciones, incluyendo Azure for Students, no proporcionan soporte de GPU por defecto. Es posible que necesites solicitar núcleos de GPU adicionales a través de una solicitud de soporte técnico.
> **Nota**: Algunas suscripciones, incluyendo Azure para Estudiantes, no proporcionan soporte para GPU de manera predeterminada. Es posible que necesites solicitar núcleos de GPU adicionales a través de una solicitud de soporte técnico.
* Crea un [Espacio de Trabajo de Azure Machine Learning](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) y luego utiliza 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 de 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 el notebook de Azure ML y comenzar a usarlo.
También puedes utilizar Google Colab, que viene con algo de soporte gratuito de GPU, y subir Jupyter Notebooks allí para ejecutarlos uno por uno.
También puedes usar Google Colab, que incluye soporte gratuito para GPU, y subir los Jupyter Notebooks allí para ejecutarlos uno por uno.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Aunque nos esforzamos por lograr la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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 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 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.

45
translations/es/lessons/0-course-setup/setup.md
View File

@ -1,45 +1,54 @@
# Introducción a este Currículo
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c4c545eb30765a49469ced84cfb4379f",
"translation_date": "2025-08-24T09:26:32+00:00",
"source_file": "lessons/0-course-setup/setup.md",
"language_code": "es"
}
-->
# Comenzando con este Currículo
## ¿Eres un estudiante?
## ¿Eres estudiante?
Comienza con los siguientes recursos:
* [Página del Hub para Estudiantes](https://docs.microsoft.com/learn/student-hub?WT.mc_id=academic-77998-cacaste) En esta página, encontrarás recursos para principiantes, paquetes para estudiantes e incluso formas de obtener un vale de certificación gratuito. Esta es una página que querrás marcar y revisar de vez en cuando, ya que cambiamos el contenido al menos una vez al mes.
* [Página del Hub para estudiantes](https://docs.microsoft.com/learn/student-hub?WT.mc_id=academic-77998-cacaste) En esta página encontrarás recursos para principiantes, paquetes para estudiantes e incluso formas de obtener un voucher gratuito para certificación. Es una página que querrás marcar como favorita y revisar de vez en cuando, ya que actualizamos el contenido al menos una vez al mes.
* [Embajadores de Microsoft Student Learn](https://studentambassadors.microsoft.com?WT.mc_id=academic-77998-cacaste) Únete a una comunidad global de embajadores estudiantiles, esta podría ser tu puerta de entrada a Microsoft.
**Estudiantes**, hay un par de maneras de usar el currículo. Primero que todo, puedes simplemente leer el texto y revisar el código directamente en GitHub. Si deseas ejecutar el código en cualquiera de los cuadernos - [lee nuestras instrucciones](./etc/how-to-run.md), y encuentra más consejos sobre cómo hacerlo [en esta publicación del blog](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
**Estudiantes**, hay un par de formas de usar el currículo. Primero, puedes simplemente leer el texto y revisar el código directamente en GitHub. Si deseas ejecutar el código en cualquiera de los notebooks - [lee nuestras instrucciones](./etc/how-to-run.md) y encuentra más consejos sobre cómo hacerlo [en este artículo de blog](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
> **Nota**: [Instrucciones sobre cómo ejecutar el código en este currículo](/how-to-run.md)
> **Nota**: [Instrucciones sobre cómo ejecutar el código en este currículo](./how-to-run.md)
## Autoestudio
## Estudio autónomo
Sin embargo, si deseas tomar el curso como un proyecto de autoestudio, te sugerimos que hagas un fork del repositorio completo a tu propia cuenta de GitHub y completes los ejercicios por tu cuenta o con un grupo:
Sin embargo, si prefieres tomar el curso como un proyecto de autoestudio, te sugerimos que hagas un fork de todo el repositorio en tu propia cuenta de GitHub y completes los ejercicios por tu cuenta o con un grupo:
* Comienza con un cuestionario previo a la clase.
* Lee el texto introductorio de la clase.
* Si la clase tiene cuadernos adicionales, revísalos, leyendo y ejecutando el código. Si se proporcionan cuadernos de TensorFlow y PyTorch, puedes enfocarte en uno de ellos: elige tu framework favorito.
* Los cuadernos a menudo contienen algunos de los desafíos que requieren que ajustes un poco el código para experimentar.
* Lee el texto introductorio de la lección.
* Si la lección tiene notebooks adicionales, revísalos, lee y ejecuta el código. Si se proporcionan notebooks tanto de TensorFlow como de PyTorch, puedes enfocarte en uno de ellos: elige tu framework favorito.
* Los notebooks a menudo contienen algunos desafíos que requieren que ajustes el código un poco para experimentar.
* Realiza el cuestionario posterior a la clase.
* Si hay un laboratorio adjunto al módulo, completa la tarea.
* Visita el [foro de discusión](https://github.com/microsoft/AI-For-Beginners/discussions) para "aprender en voz alta".
* Visita el [tablero de discusión](https://github.com/microsoft/AI-For-Beginners/discussions) para "aprender en voz alta".
> Para un estudio adicional, recomendamos seguir estos módulos y rutas de aprendizaje de [Microsoft Learn](https://docs.microsoft.com/en-us/users/dmitrysoshnikov-9132/collections/31zgizg2p418yo/?WT.mc_id=academic-77998-cacaste).
> Para estudios adicionales, recomendamos seguir estos módulos y rutas de aprendizaje de [Microsoft Learn](https://docs.microsoft.com/en-us/users/dmitrysoshnikov-9132/collections/31zgizg2p418yo/?WT.mc_id=academic-77998-cacaste).
**Profesores**, hemos [incluido algunas sugerencias](/for-teachers.md) sobre cómo utilizar este currículo.
**Profesores**, hemos [incluido algunas sugerencias](/for-teachers.md) sobre cómo usar este currículo.
---
## Pedagogía
Hemos elegido dos principios pedagógicos al construir este currículo: asegurar que sea **basado en proyectos** y que incluya **cuestionarios frecuentes**.
Hemos elegido dos principios pedagógicos al construir este currículo: asegurarnos de que sea **basado en proyectos** prácticos y que incluya **cuestionarios frecuentes**.
Al asegurar que el contenido esté alineado con proyectos, el proceso se vuelve más atractivo para los estudiantes y se incrementa la retención de conceptos. Además, un cuestionario de bajo riesgo antes de una clase establece la intención del estudiante hacia el aprendizaje de un tema, mientras que un segundo cuestionario después de la clase asegura una mayor retención. Este currículo fue diseñado para ser flexible y divertido y puede ser tomado en su totalidad o en parte. Los proyectos comienzan pequeños y se vuelven cada vez más complejos al final del ciclo de 12 semanas.
Al garantizar que el contenido esté alineado con proyectos, el proceso se vuelve más atractivo para los estudiantes y se mejora la retención de conceptos. Además, un cuestionario de bajo riesgo antes de la clase establece la intención del estudiante hacia el aprendizaje de un tema, mientras que un segundo cuestionario después de la clase asegura una mayor retención. Este currículo fue diseñado para ser flexible y divertido, y puede tomarse en su totalidad o en partes. Los proyectos comienzan pequeños y se vuelven cada vez más complejos al final del ciclo de 12 semanas.
> **Una nota sobre los cuestionarios**: Todos los cuestionarios están contenidos [en esta aplicación](https://red-field-0a6ddfd03.1.azurestaticapps.net/), con un total de 50 cuestionarios de tres preguntas cada uno. Están vinculados desde las lecciones, pero la aplicación de cuestionarios puede ejecutarse localmente; sigue las instrucciones en la carpeta `etc/quiz-app`.
> **Una nota sobre los cuestionarios**: Todos los cuestionarios están contenidos [en esta aplicación](https://red-field-0a6ddfd03.1.azurestaticapps.net/), con un total de 50 cuestionarios de tres preguntas cada uno. Están vinculados dentro de las lecciones, pero la aplicación de cuestionarios puede ejecutarse localmente; sigue las instrucciones en la carpeta `etc/quiz-app`.
## Acceso sin conexión
Puedes ejecutar esta documentación sin conexión utilizando [Docsify](https://docsify.js.org/#/). Haz un fork de este repositorio, [instala Docsify](https://docsify.js.org/#/quickstart) en tu máquina local, y luego en la carpeta `etc/docsify` de este repositorio, escribe `docsify serve`. El sitio web se servirá en el puerto 3000 en tu localhost: `localhost:3000`. Un pdf del currículo está disponible [en este enlace](../../../../../../etc/pdf/readme.pdf).
Puedes ejecutar esta documentación sin conexión utilizando [Docsify](https://docsify.js.org/#/). Haz un fork de este repositorio, [instala Docsify](https://docsify.js.org/#/quickstart) en tu máquina local y luego, en la carpeta raíz de este repositorio, escribe `docsify serve`. El sitio web se servirá en el puerto 3000 de tu localhost: `localhost:3000`. Un pdf del currículo está disponible [en este enlace](../../../../../../../../../etc/pdf/readme.pdf).
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 por parte de un humano. No nos hacemos responsables de ningún malentendido o mala interpretación que surja del uso de esta traducción.
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.

145
translations/es/lessons/1-Intro/README.md
View File

@ -1,31 +1,138 @@
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5d1cbc67a9690adb5b33adf297794087",
"translation_date": "2025-08-24T09:14:33+00:00",
"source_file": "lessons/1-Intro/README.md",
"language_code": "es"
}
-->
# Introducción a la IA
A medida que pasó el tiempo, los recursos informáticos se volvieron más baratos y más datos se hicieron disponibles, por lo que los enfoques de redes neuronales comenzaron a demostrar un gran rendimiento en la competencia con los seres humanos en muchas áreas, como la visión por computadora o la comprensión del habla. En la última década, el término Inteligencia Artificial se ha utilizado principalmente como un sinónimo de Redes Neuronales, ya que la mayoría de los éxitos de IA de los que escuchamos se basan en ellas.
![Resumen del contenido de Introducción a la IA en un dibujo](../../../../lessons/sketchnotes/ai-intro.png)
Podemos observar cómo cambiaron los enfoques, por ejemplo, en la creación de un programa de computadora para jugar ajedrez:
> Dibujo por [Tomomi Imura](https://twitter.com/girlie_mac)
* Los primeros programas de ajedrez se basaban en la búsqueda: un programa intentaba estimar explícitamente los posibles movimientos de un oponente para un número determinado de movimientos siguientes y seleccionaba un movimiento óptimo basado en la posición óptima que se puede lograr en unos pocos movimientos. Esto llevó al desarrollo del algoritmo de búsqueda llamado [poda alfa-beta](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning).
* Las estrategias de búsqueda funcionan bien hacia el final del juego, donde el espacio de búsqueda está limitado por un pequeño número de posibles movimientos. Sin embargo, al principio del juego, el espacio de búsqueda es enorme, y el algoritmo se puede mejorar aprendiendo de partidas existentes entre jugadores humanos. Experimentos posteriores emplearon el llamado [razonamiento basado en casos](https://en.wikipedia.org/wiki/Case-based_reasoning), donde el programa buscaba casos en la base de conocimientos muy similares a la posición actual en el juego.
* Los programas modernos que ganan a los jugadores humanos se basan en redes neuronales y [aprendizaje por refuerzo](https://en.wikipedia.org/wiki/Reinforcement_learning), donde los programas aprenden a jugar únicamente jugando mucho tiempo contra sí mismos y aprendiendo de sus propios errores, de manera similar a como lo hacen los seres humanos al aprender a jugar ajedrez. Sin embargo, un programa de computadora puede jugar muchos más juegos en mucho menos tiempo, y así puede aprender mucho más rápido.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
**Inteligencia Artificial** es una disciplina científica fascinante que estudia cómo podemos hacer que las computadoras exhiban un comportamiento inteligente, es decir, que realicen aquellas cosas en las que los seres humanos somos buenos.
Originalmente, las computadoras fueron inventadas por [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) para operar con números siguiendo un procedimiento bien definido: un algoritmo. Las computadoras modernas, aunque significativamente más avanzadas que el modelo original propuesto en el siglo XIX, aún siguen la misma idea de cálculos controlados. Por lo tanto, es posible programar una computadora para hacer algo si conocemos la secuencia exacta de pasos necesarios para lograr el objetivo.
![Foto de una persona](../../../../lessons/1-Intro/images/dsh_age.png)
> Foto por [Vickie Soshnikova](http://twitter.com/vickievalerie)
> ✅ Definir la edad de una persona a partir de su fotografía es una tarea que no puede ser programada explícitamente, porque no sabemos cómo llegamos a un número en nuestra mente cuando lo hacemos.
---
Sin embargo, hay algunas tareas que no sabemos resolver explícitamente. Consideremos determinar la edad de una persona a partir de su fotografía. De alguna manera aprendemos a hacerlo porque hemos visto muchos ejemplos de personas de diferentes edades, pero no podemos explicar explícitamente cómo lo hacemos, ni podemos programar una computadora para hacerlo. Este es exactamente el tipo de tarea que interesa a la **Inteligencia Artificial** (IA).
✅ Piensa en algunas tareas que podrías delegar a una computadora y que se beneficiarían de la IA. Considera los campos de las finanzas, la medicina y las artes: ¿cómo se están beneficiando hoy en día de la IA?
## IA Débil vs. IA Fuerte
IA Débil | IA Fuerte
---------------------------------------|-------------------------------------
La IA débil se refiere a sistemas de IA diseñados y entrenados para una tarea específica o un conjunto limitado de tareas.|La IA fuerte, o Inteligencia Artificial General (AGI), se refiere a sistemas de IA con un nivel de inteligencia y comprensión similar al humano.
Estos sistemas de IA no son generalmente inteligentes; sobresalen en realizar una tarea predefinida pero carecen de verdadera comprensión o conciencia.|Estos sistemas de IA tienen la capacidad de realizar cualquier tarea intelectual que un ser humano pueda hacer, adaptarse a diferentes dominios y poseer una forma de conciencia o autoconciencia.
Ejemplos de IA débil incluyen asistentes virtuales como Siri o Alexa, algoritmos de recomendación utilizados por servicios de streaming y chatbots diseñados para tareas específicas de atención al cliente.|Lograr la IA fuerte es un objetivo a largo plazo de la investigación en IA y requeriría el desarrollo de sistemas de IA que puedan razonar, aprender, comprender y adaptarse a una amplia gama de tareas y contextos.
La IA débil está altamente especializada y no posee habilidades cognitivas similares a las humanas ni capacidades generales de resolución de problemas más allá de su dominio limitado.|La IA fuerte es actualmente un concepto teórico, y ningún sistema de IA ha alcanzado este nivel de inteligencia general.
Para más información, consulta **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
## La Definición de Inteligencia y la Prueba de Turing
Uno de los problemas al tratar con el término **[Inteligencia](https://en.wikipedia.org/wiki/Intelligence)** es que no hay una definición clara de este término. Se puede argumentar que la inteligencia está conectada con el **pensamiento abstracto** o con la **autoconciencia**, pero no podemos definirla adecuadamente.
![Foto de un gato](../../../../lessons/1-Intro/images/photo-cat.jpg)
> [Foto](https://unsplash.com/photos/75715CVEJhI) por [Amber Kipp](https://unsplash.com/@sadmax) de Unsplash
Para ver la ambigüedad del término *inteligencia*, intenta responder a la pregunta: "¿Es un gato inteligente?". Diferentes personas tienden a dar respuestas diferentes a esta pregunta, ya que no hay una prueba universalmente aceptada para demostrar si la afirmación es verdadera o no. Y si crees que la hay, intenta hacer que tu gato pase una prueba de coeficiente intelectual...
✅ Piensa por un momento en cómo defines la inteligencia. ¿Es un cuervo que puede resolver un laberinto para conseguir comida inteligente? ¿Es un niño inteligente?
---
Cuando hablamos de AGI, necesitamos alguna forma de determinar si hemos creado un sistema verdaderamente inteligente. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) propuso un método llamado **[Prueba de Turing](https://en.wikipedia.org/wiki/Turing_test)**, que también actúa como una definición de inteligencia. La prueba compara un sistema dado con algo inherentemente inteligente: un ser humano real. Y dado que cualquier comparación automática puede ser eludida por un programa de computadora, usamos un interrogador humano. Así, si un ser humano no puede distinguir entre una persona real y un sistema informático en un diálogo basado en texto, el sistema se considera inteligente.
> Un chatbot llamado [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), desarrollado en San Petersburgo, estuvo cerca de pasar la prueba de Turing en 2014 utilizando un truco de personalidad ingenioso. Anunció desde el principio que era un niño ucraniano de 13 años, lo que explicaría la falta de conocimiento y algunas discrepancias en el texto. El bot convenció al 30% de los jueces de que era humano después de un diálogo de 5 minutos, una métrica que Turing creía que una máquina podría superar para el año 2000. Sin embargo, hay que entender que esto no indica que hayamos creado un sistema inteligente, o que un sistema informático haya engañado al interrogador humano: ¡el sistema no engañó a los humanos, sino que los creadores del bot lo hicieron!
✅ ¿Alguna vez un chatbot te ha hecho creer que estabas hablando con un humano? ¿Cómo te convenció?
## Diferentes Enfoques de la IA
Si queremos que una computadora se comporte como un humano, necesitamos de alguna manera modelar dentro de una computadora nuestra forma de pensar. En consecuencia, necesitamos tratar de entender qué hace que un ser humano sea inteligente.
> Para poder programar inteligencia en una máquina, necesitamos entender cómo funcionan nuestros propios procesos de toma de decisiones. Si haces un poco de introspección, te darás cuenta de que hay algunos procesos que ocurren de manera subconsciente, por ejemplo, podemos distinguir un gato de un perro sin pensarlo, mientras que otros implican razonamiento.
Hay dos posibles enfoques para este problema:
Enfoque de Arriba hacia Abajo (Razonamiento Simbólico) | Enfoque de Abajo hacia Arriba (Redes Neuronales)
---------------------------------------|-------------------------------------
Un enfoque de arriba hacia abajo modela la forma en que una persona razona para resolver un problema. Implica extraer **conocimiento** de un ser humano y representarlo en un formato legible por computadora. También necesitamos desarrollar una forma de modelar el **razonamiento** dentro de una computadora. | Un enfoque de abajo hacia arriba modela la estructura del cerebro humano, que consiste en un gran número de unidades simples llamadas **neuronas**. Cada neurona actúa como un promedio ponderado de sus entradas, y podemos entrenar una red de neuronas para resolver problemas útiles proporcionando **datos de entrenamiento**.
También hay otros enfoques posibles para la inteligencia:
* Un enfoque **Emergente**, **Sinérgico** o de **múltiples agentes** se basa en el hecho de que un comportamiento inteligente complejo puede obtenerse mediante la interacción de un gran número de agentes simples. Según la [cibernética evolutiva](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), la inteligencia puede *emerger* de un comportamiento más simple y reactivo en el proceso de *transición de metasisistema*.
* Un enfoque **Evolutivo**, o **algoritmo genético**, es un proceso de optimización basado en los principios de la evolución.
Consideraremos estos enfoques más adelante en el curso, pero por ahora nos centraremos en dos direcciones principales: de arriba hacia abajo y de abajo hacia arriba.
### El Enfoque de Arriba hacia Abajo
En un **enfoque de arriba hacia abajo**, intentamos modelar nuestro razonamiento. Dado que podemos seguir nuestros pensamientos cuando razonamos, podemos intentar formalizar este proceso y programarlo dentro de la computadora. Esto se llama **razonamiento simbólico**.
Las personas tienden a tener algunas reglas en su mente que guían sus procesos de toma de decisiones. Por ejemplo, cuando un médico diagnostica a un paciente, puede darse cuenta de que una persona tiene fiebre y, por lo tanto, podría haber alguna inflamación en el cuerpo. Al aplicar un gran conjunto de reglas a un problema específico, un médico puede llegar al diagnóstico final.
Este enfoque depende en gran medida de la **representación del conocimiento** y el **razonamiento**. Extraer conocimiento de un experto humano puede ser la parte más difícil, porque un médico, en muchos casos, no sabría exactamente por qué llega a un diagnóstico en particular. A veces, la solución simplemente aparece en su mente sin un pensamiento explícito. Algunas tareas, como determinar la edad de una persona a partir de una fotografía, no pueden reducirse en absoluto a la manipulación del conocimiento.
### Enfoque de Abajo hacia Arriba
Alternativamente, podemos intentar modelar los elementos más simples dentro de nuestro cerebro: una neurona. Podemos construir una **red neuronal artificial** dentro de una computadora y luego intentar enseñarle a resolver problemas dándole ejemplos. Este proceso es similar a cómo un niño recién nacido aprende sobre su entorno al hacer observaciones.
✅ Investiga un poco sobre cómo aprenden los bebés. ¿Cuáles son los elementos básicos del cerebro de un bebé?
> | ¿Qué pasa con el ML? | |
> |--------------|-----------|
> | Parte de la Inteligencia Artificial que se basa en que la computadora aprenda a resolver un problema a partir de algunos datos se llama **Aprendizaje Automático**. No consideraremos el aprendizaje automático clásico en este curso; te remitimos a un plan de estudios separado de [Machine Learning for Beginners](http://aka.ms/ml-beginners). | ![ML para Principiantes](../../../../lessons/1-Intro/images/ml-for-beginners.png) |
## Breve Historia de la IA
La Inteligencia Artificial comenzó como un campo a mediados del siglo XX. Inicialmente, el razonamiento simbólico era el enfoque predominante, y condujo a una serie de éxitos importantes, como los sistemas expertos: programas de computadora que podían actuar como expertos en algunos dominios de problemas limitados. Sin embargo, pronto quedó claro que este enfoque no escala bien. Extraer el conocimiento de un experto, representarlo en una computadora y mantener esa base de conocimiento precisa resulta ser una tarea muy compleja y demasiado costosa para ser práctica en muchos casos. Esto llevó al llamado [Invierno de la IA](https://en.wikipedia.org/wiki/AI_winter) en la década de 1970.
> Imagen por [Dmitry Soshnikov](http://soshnikov.com)
Con el tiempo, los recursos informáticos se volvieron más baratos y se dispuso de más datos, por lo que los enfoques de redes neuronales comenzaron a demostrar un gran rendimiento al competir con los seres humanos en muchas áreas, como la visión por computadora o la comprensión del habla. En la última década, el término Inteligencia Artificial se ha utilizado principalmente como sinónimo de Redes Neuronales, porque la mayoría de los éxitos de la IA de los que escuchamos se basan en ellas.
Podemos observar cómo han cambiado los enfoques, por ejemplo, al crear un programa de computadora para jugar al ajedrez:
* Los primeros programas de ajedrez se basaban en la búsqueda: un programa intentaba explícitamente estimar los posibles movimientos de un oponente para un número dado de movimientos futuros y seleccionaba un movimiento óptimo basado en la posición óptima que se podía lograr en unos pocos movimientos. Esto llevó al desarrollo del llamado algoritmo de búsqueda [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning).
* Las estrategias de búsqueda funcionan bien hacia el final del juego, donde el espacio de búsqueda está limitado por un pequeño número de movimientos posibles. Sin embargo, al comienzo del juego, el espacio de búsqueda es enorme, y el algoritmo puede mejorarse aprendiendo de partidas existentes entre jugadores humanos. Experimentos posteriores emplearon el llamado [razonamiento basado en casos](https://en.wikipedia.org/wiki/Case-based_reasoning), donde el programa buscaba casos en la base de conocimiento muy similares a la posición actual en el juego.
* Los programas modernos que vencen a jugadores humanos se basan en redes neuronales y [aprendizaje por refuerzo](https://en.wikipedia.org/wiki/Reinforcement_learning), donde los programas aprenden a jugar únicamente jugando durante mucho tiempo contra sí mismos y aprendiendo de sus propios errores, de manera muy similar a como los seres humanos aprenden a jugar al ajedrez. Sin embargo, un programa de computadora puede jugar muchas más partidas en mucho menos tiempo y, por lo tanto, puede aprender mucho más rápido.
✅ Investiga un poco sobre otros juegos que han sido jugados por IA.
De manera similar, podemos ver cómo cambió el enfoque hacia la creación de "programas que hablan" (que podrían pasar la prueba de Turing):
De manera similar, podemos ver cómo ha cambiado el enfoque hacia la creación de "programas parlantes" (que podrían pasar la prueba de Turing):
* Los primeros programas de este tipo, como [Eliza](https://en.wikipedia.org/wiki/ELIZA), se basaban en reglas gramaticales muy simples y la reformulación de la oración de entrada en una pregunta.
* Los primeros programas de este tipo, como [Eliza](https://en.wikipedia.org/wiki/ELIZA), se basaban en reglas gramaticales muy simples y en la reformulación de la oración de entrada en una pregunta.
* Los asistentes modernos, como Cortana, Siri o Google Assistant, son todos sistemas híbridos que utilizan redes neuronales para convertir el habla en texto y reconocer nuestra intención, y luego emplean algún razonamiento o algoritmos explícitos para realizar las acciones requeridas.
* En el futuro, podemos esperar un modelo completamente basado en redes neuronales para manejar el diálogo por sí mismo. Las recientes redes neuronales de la familia GPT y [Turing-NLG](https://turing.microsoft.com/) muestran un gran éxito en esto.
* En el futuro, podríamos esperar un modelo completamente basado en redes neuronales que maneje el diálogo por sí mismo. Las recientes redes neuronales de la familia GPT y [Turing-NLG](https://turing.microsoft.com/) muestran un gran éxito en esto.
> Imagen de Dmitry Soshnikov, [foto](https://unsplash.com/photos/r8LmVbUKgns) de [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
> Imagen de Dmitry Soshnikov, [foto](https://unsplash.com/photos/r8LmVbUKgns) por [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
## Investigación reciente en IA
El enorme crecimiento reciente en la investigación de redes neuronales comenzó alrededor de 2010, cuando comenzaron a estar disponibles grandes conjuntos de datos públicos. Una enorme colección de imágenes llamada [ImageNet](https://en.wikipedia.org/wiki/ImageNet), que contiene alrededor de 14 millones de imágenes anotadas, dio origen al [Desafío de Reconocimiento Visual a Gran Escala de ImageNet](https://image-net.org/challenges/LSVRC/).
El enorme crecimiento reciente en la investigación de redes neuronales comenzó alrededor de 2010, cuando empezaron a estar disponibles grandes conjuntos de datos públicos. Una enorme colección de imágenes llamada [ImageNet](https://en.wikipedia.org/wiki/ImageNet), que contiene alrededor de 14 millones de imágenes anotadas, dio lugar al [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
![Precisión de ILSVRC](../../../../lessons/1-Intro/images/ilsvrc.gif)
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
En 2012, se utilizaron por primera vez las [Redes Neuronales Convolucionales](../4-ComputerVision/07-ConvNets/README.md) en la clasificación de imágenes, lo que llevó a una disminución significativa de los errores de clasificación (de casi 30% a 16.4%). En 2015, la arquitectura ResNet de Microsoft Research [alcanzó una precisión a nivel humano](https://doi.org/10.1109/ICCV.2015.123).
En 2012, las [Redes Neuronales Convolucionales](../4-ComputerVision/07-ConvNets/README.md) se usaron por primera vez en la clasificación de imágenes, lo que llevó a una reducción significativa en los errores de clasificación (de casi un 30% a un 16.4%). En 2015, la arquitectura ResNet de Microsoft Research [logró una precisión a nivel humano](https://doi.org/10.1109/ICCV.2015.123).
Desde entonces, las Redes Neuronales han demostrado un comportamiento muy exitoso en muchas tareas:
@ -35,22 +142,22 @@ Año | Paridad Humana alcanzada
-----|--------
2015 | [Clasificación de Imágenes](https://doi.org/10.1109/ICCV.2015.123)
2016 | [Reconocimiento de Voz Conversacional](https://arxiv.org/abs/1610.05256)
2018 | [Traducción Automática de Máquinas](https://arxiv.org/abs/1803.05567) (chino-inglés)
2018 | [Traducción Automática](https://arxiv.org/abs/1803.05567) (Chino a Inglés)
2020 | [Generación de Descripciones de Imágenes](https://arxiv.org/abs/2009.13682)
En los últimos años hemos sido testigos de grandes éxitos con modelos de lenguaje de gran tamaño, como BERT y GPT-3. Esto ocurrió principalmente debido al hecho de que hay una gran cantidad de datos de texto general disponibles que nos permiten entrenar modelos para capturar la estructura y el significado de los textos, preentrenarlos en colecciones de texto generales y luego especializar esos modelos para tareas más específicas. Aprenderemos más sobre [Procesamiento de Lenguaje Natural](../5-NLP/README.md) más adelante en este curso.
En los últimos años hemos sido testigos de grandes éxitos con modelos de lenguaje de gran escala, como BERT y GPT-3. Esto ocurrió principalmente debido a la gran cantidad de datos de texto general disponibles, lo que permite entrenar modelos para capturar la estructura y el significado de los textos, preentrenarlos en colecciones de texto general y luego especializarlos para tareas más específicas. Aprenderemos más sobre [Procesamiento de Lenguaje Natural](../5-NLP/README.md) más adelante en este curso.
## 🚀 Desafío
Haz un recorrido por internet para determinar dónde, en tu opinión, se utiliza la IA de manera más efectiva. ¿Es en una aplicación de mapeo, en algún servicio de reconocimiento de voz a texto o en un videojuego? Investiga cómo se construyó el sistema.
Haz un recorrido por internet para determinar dónde, en tu opinión, se utiliza la IA de manera más efectiva. ¿Es en una aplicación de mapas, algún servicio de conversión de voz a texto o un videojuego? Investiga cómo se construyó el sistema.
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
## Revisión y Autoestudio
## Revisión y autoestudio
Revisa la historia de la IA y el ML leyendo [esta lección](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Toma un elemento de la sketchnote en la parte superior de esa lección o de esta y investígalo más a fondo para entender el contexto cultural que informa su evolución.
Revisa la historia de la IA y el aprendizaje automático leyendo [esta lección](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Toma un elemento del sketchnote al inicio de esa lección o de esta y profundiza en su investigación para comprender el contexto cultural que influyó en su evolución.
**Tarea**: [Game Jam](assignment.md)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas 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 malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

13
translations/es/lessons/1-Intro/assignment.md
View File

@ -1,6 +1,15 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "702dc1df5d0285dbe4d04bee982d183e",
"translation_date": "2025-08-24T09:15:22+00:00",
"source_file": "lessons/1-Intro/assignment.md",
"language_code": "es"
}
-->
# Game Jam
Los juegos son un área que ha sido fuertemente influenciada por los desarrollos en IA y ML. En esta tarea, escribe un breve ensayo sobre un juego que te guste y que haya sido influenciado por la evolución de la IA. Debe ser un juego lo suficientemente antiguo como para haber sido influenciado por varios tipos de sistemas de procesamiento informático. Un buen ejemplo es el ajedrez o el go, pero también echa un vistazo a videojuegos como pong o Pac-Man. Escribe un ensayo que discuta el pasado, presente y futuro de IA del juego.
Los juegos son un área que ha sido fuertemente influenciada por los avances en IA y ML. En esta tarea, escribe un breve ensayo sobre un juego que te guste y que haya sido influenciado por la evolución de la IA. Debe ser un juego lo suficientemente antiguo como para haber sido afectado por varios tipos de sistemas de procesamiento informático. Un buen ejemplo es el ajedrez o el Go, pero también considera videojuegos como Pong o Pac-Man. Escribe un ensayo que analice el pasado, presente y futuro de la IA en el juego.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por lograr la precisión, tenga en cuenta que las traducciones automáticas 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 de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

213
translations/es/lessons/2-Symbolic/README.md
View File

@ -1,107 +1,114 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "98c5222ff9556b55223fed2337145e18",
"translation_date": "2025-08-24T09:25:07+00:00",
"source_file": "lessons/2-Symbolic/README.md",
"language_code": "es"
}
-->
# Representación del Conocimiento y Sistemas Expertos
![Resumen del contenido de IA Simbólica](../../../../translated_images/ai-symbolic.715a30cb610411a6964d2e2f23f24364cb338a07cb4844c1f97084d366e586c3.es.png)
![Resumen del contenido de IA Simbólica](../../../../lessons/sketchnotes/ai-symbolic.png)
> Sketchnote de [Tomomi Imura](https://twitter.com/girlie_mac)
> Sketchnote por [Tomomi Imura](https://twitter.com/girlie_mac)
La búsqueda de inteligencia artificial se basa en la búsqueda de conocimiento, para entender el mundo de manera similar a como lo hacen los humanos. Pero, ¿cómo se puede llevar a cabo esto?
La búsqueda de la inteligencia artificial se basa en la búsqueda de conocimiento, para entender el mundo de manera similar a como lo hacen los humanos. Pero, ¿cómo se puede lograr esto?
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/102)
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/102)
En los primeros días de la IA, el enfoque de arriba hacia abajo para crear sistemas inteligentes (discutido en la lección anterior) era popular. La idea era extraer el conocimiento de las personas en una forma legible por máquina y luego usarlo para resolver problemas automáticamente. Este enfoque se basaba en dos grandes ideas:
En los primeros días de la IA, el enfoque de arriba hacia abajo para crear sistemas inteligentes (discutido en la lección anterior) era popular. La idea era extraer el conocimiento de las personas en una forma legible por máquinas y luego usarlo para resolver problemas automáticamente. Este enfoque se basaba en dos grandes ideas:
* Representación del Conocimiento
* Razonamiento
## Representación del Conocimiento
Uno de los conceptos importantes en la IA Simbólica es el **conocimiento**. Es importante diferenciar el conocimiento de la *información* o *datos*. Por ejemplo, se puede decir que los libros contienen conocimiento, porque uno puede estudiar libros y convertirse en un experto. Sin embargo, lo que contienen los libros se llama en realidad *datos*, y al leer libros e integrar estos datos en nuestro modelo del mundo, convertimos estos datos en conocimiento.
Uno de los conceptos importantes en la IA Simbólica es el **conocimiento**. Es importante diferenciar el conocimiento de la *información* o los *datos*. Por ejemplo, se puede decir que los libros contienen conocimiento, porque uno puede estudiarlos y convertirse en un experto. Sin embargo, lo que los libros contienen en realidad se llama *datos*, y al leerlos e integrar estos datos en nuestro modelo del mundo, convertimos estos datos en conocimiento.
> ✅ **El conocimiento** es algo que está contenido en nuestra cabeza y representa nuestra comprensión del mundo. Se obtiene a través de un proceso activo de **aprendizaje**, que integra piezas de información que recibimos en nuestro modelo activo del mundo.
> ✅ **Conocimiento** es algo que está contenido en nuestra mente y representa nuestra comprensión del mundo. Se obtiene mediante un proceso activo de **aprendizaje**, que integra piezas de información que recibimos en nuestro modelo activo del mundo.
A menudo, no definimos estrictamente el conocimiento, sino que lo alineamos con otros conceptos relacionados utilizando la [Pirámide DIKW](https://en.wikipedia.org/wiki/DIKW_pyramid). Contiene los siguientes conceptos:
A menudo, no definimos estrictamente el conocimiento, pero lo alineamos con otros conceptos relacionados utilizando la [Pirámide DIKW](https://en.wikipedia.org/wiki/DIKW_pyramid). Contiene los siguientes conceptos:
* **Datos** son algo representado en medios físicos, como texto escrito o palabras habladas. Los datos existen independientemente de los seres humanos y pueden ser transmitidos entre personas.
* **Información** es cómo interpretamos los datos en nuestra cabeza. Por ejemplo, cuando escuchamos la palabra *computadora*, tenemos alguna comprensión de lo que es.
* **Conocimiento** es la información que se integra en nuestro modelo del mundo. Por ejemplo, una vez que aprendemos lo que es una computadora, comenzamos a tener algunas ideas sobre cómo funciona, cuánto cuesta y para qué se puede usar. Esta red de conceptos interrelacionados forma nuestro conocimiento.
* **Sabiduría** es un nivel más de nuestra comprensión del mundo y representa *meta-conocimiento*, es decir, alguna noción sobre cómo y cuándo se debe usar el conocimiento.
<img src="images/DIKW_Pyramid.png" width="30%"/>
* **Datos**: algo representado en medios físicos, como texto escrito o palabras habladas. Los datos existen independientemente de los seres humanos y pueden ser transmitidos entre personas.
* **Información**: cómo interpretamos los datos en nuestra mente. Por ejemplo, cuando escuchamos la palabra *computadora*, tenemos alguna idea de lo que es.
* **Conocimiento**: la información integrada en nuestro modelo del mundo. Por ejemplo, una vez que aprendemos qué es una computadora, comenzamos a tener ideas sobre cómo funciona, cuánto cuesta y para qué se puede usar. Esta red de conceptos interrelacionados forma nuestro conocimiento.
* **Sabiduría**: un nivel más de nuestra comprensión del mundo, que representa el *meta-conocimiento*, es decir, una noción sobre cómo y cuándo debe usarse el conocimiento.
*Imagen [de Wikipedia](https://commons.wikimedia.org/w/index.php?curid=37705247), Por Longlivetheux - Trabajo propio, CC BY-SA 4.0*
Así, el problema de la **representación del conocimiento** es encontrar alguna manera efectiva de representar el conocimiento dentro de una computadora en forma de datos, para que sea automáticamente utilizable. Esto puede verse como un espectro:
Por lo tanto, el problema de la **representación del conocimiento** es encontrar una forma efectiva de representar el conocimiento dentro de una computadora en forma de datos, para que sea automáticamente utilizable. Esto puede verse como un espectro:
![Espectro de representación del conocimiento](../../../../translated_images/knowledge-spectrum.b60df631852c0217e941485b79c9eee40ebd574f15f18609cec5758fcb384bf3.es.png)
![Espectro de representación del conocimiento](../../../../lessons/2-Symbolic/images/knowledge-spectrum.png)
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
> Imagen por [Dmitry Soshnikov](http://soshnikov.com)
* A la izquierda, hay tipos de representaciones de conocimiento muy simples que pueden ser utilizados efectivamente por las computadoras. La más simple es algorítmica, cuando el conocimiento es representado por un programa de computadora. Sin embargo, esta no es la mejor manera de representar el conocimiento, porque no es flexible. El conocimiento dentro de nuestra cabeza a menudo es no algorítmico.
* A la derecha, hay representaciones como el texto natural. Es la más poderosa, pero no puede ser utilizada para razonamiento automático.
* A la izquierda, hay tipos muy simples de representaciones de conocimiento que pueden ser utilizados de manera efectiva por las computadoras. El más simple es el algorítmico, cuando el conocimiento se representa mediante un programa de computadora. Sin embargo, esta no es la mejor manera de representar el conocimiento, porque no es flexible. El conocimiento en nuestra mente a menudo no es algorítmico.
* A la derecha, hay representaciones como el texto natural. Es la más poderosa, pero no puede ser utilizada para el razonamiento automático.
> ✅ Piensa un momento en cómo representas el conocimiento en tu cabeza y lo conviertes en notas. ¿Hay un formato particular que funcione bien para ti para ayudar en la retención?
> ✅ Piensa por un momento en cómo representas el conocimiento en tu mente y lo conviertes en notas. ¿Hay algún formato en particular que funcione bien para ti y te ayude a retenerlo?
## Clasificación de Representaciones de Conocimiento Computacional
## Clasificación de Representaciones de Conocimiento en Computadoras
Podemos clasificar diferentes métodos de representación de conocimiento computacional en las siguientes categorías:
Podemos clasificar diferentes métodos de representación del conocimiento en computadoras en las siguientes categorías:
* **Representaciones en red** se basan en el hecho de que tenemos una red de conceptos interrelacionados dentro de nuestra cabeza. Podemos intentar reproducir las mismas redes como un gráfico dentro de una computadora - una llamada **red semántica**.
* **Representaciones en red**: se basan en el hecho de que tenemos una red de conceptos interrelacionados en nuestra mente. Podemos intentar reproducir las mismas redes como un grafo dentro de una computadora, una llamada **red semántica**.
1. **Tripletas Objeto-Atributo-Valor** o **pares atributo-valor**. Dado que un gráfico puede ser representado dentro de una computadora como una lista de nodos y aristas, podemos representar una red semántica mediante una lista de tripletas, que contienen objetos, atributos y valores. Por ejemplo, construimos las siguientes tripletas sobre lenguajes de programación:
1. **Tríadas Objeto-Atributo-Valor** o **pares atributo-valor**. Dado que un grafo puede representarse dentro de una computadora como una lista de nodos y aristas, podemos representar una red semántica mediante una lista de tríadas que contienen objetos, atributos y valores. Por ejemplo, construimos las siguientes tríadas sobre lenguajes de programación:
Objeto | Atributo | Valor
-------|-----------|------
Python | es | Lenguaje-Sin-Tipo
-------|----------|------
Python | es | Lenguaje-No-Tipado
Python | inventado-por | Guido van Rossum
Python | sintaxis-de-bloque | indentación
Lenguaje-Sin-Tipo | no tiene | definiciones de tipo
Lenguaje-No-Tipado | no tiene | definiciones de tipo
> ✅ Piensa en cómo se pueden usar tripletas para representar otros tipos de conocimiento.
> ✅ Piensa cómo las tríadas pueden ser utilizadas para representar otros tipos de conocimiento.
2. **Representaciones jerárquicas** enfatizan el hecho de que a menudo creamos una jerarquía de objetos dentro de nuestra cabeza. Por ejemplo, sabemos que un canario es un pájaro, y todos los pájaros tienen alas. También tenemos alguna idea sobre de qué color es un canario generalmente, y cuál es su velocidad de vuelo.
2. **Representaciones jerárquicas**: enfatizan el hecho de que a menudo creamos una jerarquía de objetos en nuestra mente. Por ejemplo, sabemos que un canario es un pájaro, y que todos los pájaros tienen alas. También tenemos alguna idea sobre el color típico de un canario y su velocidad de vuelo.
- **Representación en marco** se basa en representar cada objeto o clase de objetos como un **marco** que contiene **slots**. Los slots tienen posibles valores predeterminados, restricciones de valor o procedimientos almacenados que pueden ser llamados para obtener el valor de un slot. Todos los marcos forman una jerarquía similar a una jerarquía de objetos en lenguajes de programación orientados a objetos.
- **Escenarios** son un tipo especial de marcos que representan situaciones complejas que pueden desarrollarse en el tiempo.
- **Representación mediante marcos**: se basa en representar cada objeto o clase de objetos como un **marco** que contiene **ranuras**. Las ranuras tienen posibles valores predeterminados, restricciones de valor o procedimientos almacenados que pueden ser llamados para obtener el valor de una ranura. Todos los marcos forman una jerarquía similar a una jerarquía de objetos en lenguajes de programación orientados a objetos.
- **Escenarios**: son un tipo especial de marcos que representan situaciones complejas que pueden desarrollarse en el tiempo.
**Python**
Slot | Valor | Valor predeterminado | Intervalo |
-----|-------|----------------------|----------|
Ranura | Valor | Valor predeterminado | Intervalo |
-------|-------|----------------------|----------|
Nombre | Python | | |
Es-Un | Lenguaje-Sin-Tipo | | |
Es-Un | Lenguaje-No-Tipado | | |
Caso de Variable | | CamelCase | |
Longitud del Programa | | | 5-5000 líneas |
Sintaxis de Bloque | Indentación | | |
3. **Representaciones procedimentales** se basan en representar el conocimiento mediante una lista de acciones que pueden ser ejecutadas cuando ocurre una cierta condición.
- Las reglas de producción son declaraciones si-entonces que nos permiten llegar a conclusiones. Por ejemplo, un médico puede tener una regla que diga que **SI** un paciente tiene fiebre alta **O** un alto nivel de proteína C-reactiva en el análisis de sangre **ENTONCES** tiene una inflamación. Una vez que encontramos una de las condiciones, podemos llegar a una conclusión sobre la inflamación, y luego usarla en un razonamiento posterior.
- Los algoritmos pueden considerarse otra forma de representación procedimental, aunque casi nunca se utilizan directamente en sistemas basados en conocimiento.
3. **Representaciones procedimentales**: se basan en representar el conocimiento mediante una lista de acciones que pueden ejecutarse cuando ocurre una cierta condición.
- Las reglas de producción son declaraciones del tipo si-entonces que nos permiten sacar conclusiones. Por ejemplo, un médico puede tener una regla que diga que **SI** un paciente tiene fiebre alta **O** un nivel alto de proteína C reactiva en un análisis de sangre, **ENTONCES** tiene una inflamación. Una vez que encontramos una de las condiciones, podemos concluir que hay inflamación y luego usar esta información en razonamientos posteriores.
- Los algoritmos pueden considerarse otra forma de representación procedimental, aunque casi nunca se usan directamente en sistemas basados en conocimiento.
4. **Lógica** fue propuesta originalmente por Aristóteles como una forma de representar el conocimiento humano universal.
- La Lógica de Predicados como teoría matemática es demasiado rica para ser computable, por lo tanto, normalmente se utiliza algún subconjunto de ella, como las cláusulas de Horn utilizadas en Prolog.
- La Lógica Descriptiva es una familia de sistemas lógicos utilizados para representar y razonar sobre jerarquías de objetos en representaciones de conocimiento distribuidas como la *web semántica*.
4. **Lógica**: fue propuesta originalmente por Aristóteles como una forma de representar el conocimiento humano universal.
- La Lógica de Predicados como teoría matemática es demasiado rica para ser computable, por lo que normalmente se utiliza un subconjunto de ella, como las cláusulas de Horn utilizadas en Prolog.
- La Lógica Descriptiva es una familia de sistemas lógicos utilizados para representar y razonar sobre jerarquías de objetos y representaciones de conocimiento distribuidas como la *web semántica*.
## Sistemas Expertos
Uno de los primeros éxitos de la IA simbólica fueron los llamados **sistemas expertos** - sistemas computacionales diseñados para actuar como un experto en un dominio de problema limitado. Se basaban en una **base de conocimiento** extraída de uno o más expertos humanos, y contenían un **motor de inferencia** que realizaba algún razonamiento sobre ella.
Uno de los primeros éxitos de la IA simbólica fueron los llamados **sistemas expertos**: sistemas informáticos diseñados para actuar como un experto en un dominio de problemas limitado. Se basaban en una **base de conocimiento** extraída de uno o más expertos humanos, y contenían un **motor de inferencia** que realizaba razonamientos sobre esta base.
![Arquitectura Humana](../../../../translated_images/arch-human.5d4d35f1bba3ab1cdfda96af2f10b89574eb31e9796d0e3011cd9beda1c35112.es.png) | ![Sistema Basado en Conocimiento](../../../../translated_images/arch-kbs.3ec5c150b09fa8dadc2beb0931a4983c9e2b03913a89eebcc103b5bb841b0212.es.png)
![Arquitectura Humana](../../../../lessons/2-Symbolic/images/arch-human.png) | ![Sistema Basado en Conocimiento](../../../../lessons/2-Symbolic/images/arch-kbs.png)
---------------------------------------------|------------------------------------------------
Estructura simplificada de un sistema neural humano | Arquitectura de un sistema basado en conocimiento
Estructura simplificada del sistema neural humano | Arquitectura de un sistema basado en conocimiento
Los sistemas expertos están construidos como el sistema de razonamiento humano, que contiene **memoria a corto plazo** y **memoria a largo plazo**. De manera similar, en los sistemas basados en conocimiento distinguimos los siguientes componentes:
Los sistemas expertos están construidos de manera similar al sistema de razonamiento humano, que contiene **memoria a corto plazo** y **memoria a largo plazo**. De manera similar, en los sistemas basados en conocimiento distinguimos los siguientes componentes:
* **Memoria del problema**: contiene el conocimiento sobre el problema que se está resolviendo actualmente, es decir, la temperatura o presión arterial de un paciente, si tiene inflamación o no, etc. Este conocimiento también se llama **conocimiento estático**, porque contiene una instantánea de lo que actualmente sabemos sobre el problema - el llamado *estado del problema*.
* **Base de conocimiento**: representa el conocimiento a largo plazo sobre un dominio de problema. Se extrae manualmente de expertos humanos y no cambia de consulta a consulta. Debido a que nos permite navegar de un estado de problema a otro, también se llama **conocimiento dinámico**.
* **Motor de inferencia**: orquesta todo el proceso de búsqueda en el espacio del estado del problema, haciendo preguntas al usuario cuando es necesario. También es responsable de encontrar las reglas adecuadas que se aplicarán a cada estado.
* **Memoria del problema**: contiene el conocimiento sobre el problema que se está resolviendo actualmente, es decir, la temperatura o la presión arterial de un paciente, si tiene inflamación o no, etc. Este conocimiento también se llama **conocimiento estático**, porque contiene una instantánea de lo que sabemos actualmente sobre el problema: el llamado *estado del problema*.
* **Base de conocimiento**: representa el conocimiento a largo plazo sobre un dominio de problemas. Se extrae manualmente de expertos humanos y no cambia de una consulta a otra. Debido a que nos permite navegar de un estado del problema a otro, también se llama **conocimiento dinámico**.
* **Motor de inferencia**: orquesta todo el proceso de búsqueda en el espacio de estados del problema, haciendo preguntas al usuario cuando sea necesario. También es responsable de encontrar las reglas correctas para aplicar en cada estado.
Como ejemplo, consideremos el siguiente sistema experto para determinar un animal basado en sus características físicas:
![Árbol AND-OR](../../../../translated_images/AND-OR-Tree.5592d2c70187f283703c8e9c0d69d6a786eb370f4ace67f9a7aae5ada3d260b0.es.png)
![Árbol AND-OR](../../../../lessons/2-Symbolic/images/AND-OR-Tree.png)
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
> Imagen por [Dmitry Soshnikov](http://soshnikov.com)
Este diagrama se llama un **árbol AND-OR**, y es una representación gráfica de un conjunto de reglas de producción. Dibujar un árbol es útil al principio para extraer conocimiento del experto. Para representar el conocimiento dentro de la computadora es más conveniente usar reglas:
Este diagrama se llama un **árbol AND-OR**, y es una representación gráfica de un conjunto de reglas de producción. Dibujar un árbol es útil al comienzo de la extracción de conocimiento del experto. Para representar el conocimiento dentro de la computadora, es más conveniente usar reglas:
```
IF the animal eats meat
@ -112,59 +119,57 @@ OR (animal has sharp teeth
THEN the animal is a carnivore
```
Puedes notar que cada condición en el lado izquierdo de la regla y la acción son esencialmente tripletas objeto-atributo-valor (OAV). **La memoria de trabajo** contiene el conjunto de tripletas OAV que corresponden al problema que se está resolviendo actualmente. Un **motor de reglas** busca reglas para las cuales se cumple una condición y las aplica, añadiendo otra tripleta a la memoria de trabajo.
Puedes notar que cada condición en el lado izquierdo de la regla y la acción son esencialmente tríadas Objeto-Atributo-Valor (OAV). La **memoria de trabajo** contiene el conjunto de tríadas OAV que corresponden al problema que se está resolviendo actualmente. Un **motor de reglas** busca reglas cuyas condiciones estén satisfechas y las aplica, agregando otra tríada a la memoria de trabajo.
> ✅ ¡Escribe tu propio árbol AND-OR sobre un tema que te guste!
### Inferencia hacia adelante vs. Inferencia hacia atrás
### Inferencia hacia Adelante vs. Inferencia hacia Atrás
El proceso descrito anteriormente se llama **inferencia hacia adelante**. Comienza con algunos datos iniciales sobre el problema disponibles en la memoria de trabajo, y luego ejecuta el siguiente bucle de razonamiento:
El proceso descrito anteriormente se llama **inferencia hacia adelante**. Comienza con algunos datos iniciales sobre el problema disponibles en la memoria de trabajo y luego ejecuta el siguiente ciclo de razonamiento:
1. Si el atributo objetivo está presente en la memoria de trabajo - detente y da el resultado
2. Busca todas las reglas cuya condición esté actualmente satisfecha - obtén el **conjunto de conflictos** de reglas.
3. Realiza **resolución de conflictos** - selecciona una regla que se ejecutará en este paso. Podría haber diferentes estrategias de resolución de conflictos:
- Selecciona la primera regla aplicable en la base de conocimiento
- Selecciona una regla aleatoria
- Selecciona una regla *más específica*, es decir, aquella que cumple con más condiciones en el "lado izquierdo" (LHS)
4. Aplica la regla seleccionada e inserta un nuevo conocimiento en el estado del problema
1. Si el atributo objetivo está presente en la memoria de trabajo, detente y da el resultado.
2. Busca todas las reglas cuyas condiciones estén actualmente satisfechas: obtén el **conjunto de conflicto** de reglas.
3. Realiza la **resolución de conflictos**: selecciona una regla que se ejecutará en este paso. Podría haber diferentes estrategias de resolución de conflictos:
- Seleccionar la primera regla aplicable en la base de conocimiento.
- Seleccionar una regla al azar.
- Seleccionar una regla *más específica*, es decir, la que cumpla con más condiciones en el lado izquierdo ("LHS").
4. Aplica la regla seleccionada e inserta un nuevo conocimiento en el estado del problema.
5. Repite desde el paso 1.
Sin embargo, en algunos casos podemos querer comenzar con un conocimiento vacío sobre el problema y hacer preguntas que nos ayuden a llegar a la conclusión. Por ejemplo, al realizar un diagnóstico médico, generalmente no realizamos todos los análisis médicos por adelantado antes de comenzar a diagnosticar al paciente. Más bien, queremos realizar análisis cuando se necesita tomar una decisión.
Sin embargo, en algunos casos podríamos querer comenzar con un conocimiento vacío sobre el problema y hacer preguntas que nos ayuden a llegar a la conclusión. Por ejemplo, al realizar un diagnóstico médico, generalmente no realizamos todos los análisis médicos de antemano antes de comenzar a diagnosticar al paciente. Más bien, queremos realizar análisis cuando sea necesario tomar una decisión.
Este proceso se puede modelar utilizando **inferencia hacia atrás**. Está impulsado por el **objetivo** - el valor del atributo que estamos buscando:
Este proceso puede modelarse utilizando **inferencia hacia atrás**. Está impulsado por el **objetivo**: el valor del atributo que buscamos encontrar:
1. Selecciona todas las reglas que pueden darnos el valor de un objetivo (es decir, con el objetivo en el RHS ("lado derecho")) - un conjunto de conflictos
1. Si no hay reglas para este atributo, o hay una regla que dice que debemos preguntar el valor al usuario - pregúntalo, de lo contrario:
1. Usa una estrategia de resolución de conflictos para seleccionar una regla que usaremos como *hipótesis* - intentaremos probarla
1. Repetidamente repite el proceso para todos los atributos en el LHS de la regla, intentando probarlos como objetivos
1. Si en algún momento el proceso falla - usa otra regla en el paso 3.
1. Selecciona todas las reglas que puedan darnos el valor de un objetivo (es decir, con el objetivo en el lado derecho ("RHS")): un conjunto de conflicto.
1. Si no hay reglas para este atributo, o hay una regla que dice que debemos preguntar el valor al usuario, pregúntalo; de lo contrario:
1. Usa una estrategia de resolución de conflictos para seleccionar una regla que usaremos como *hipótesis*: intentaremos probarla.
1. Repite recursivamente el proceso para todos los atributos en el lado izquierdo de la regla, intentando probarlos como objetivos.
1. Si en algún momento el proceso falla, usa otra regla en el paso 3.
> ✅ ¿En qué situaciones es más apropiada la inferencia hacia adelante? ¿Qué hay de la inferencia hacia atrás?
> ✅ ¿En qué situaciones es más apropiada la inferencia hacia adelante? ¿Y la inferencia hacia atrás?
### Implementación de Sistemas Expertos
Los sistemas expertos pueden implementarse utilizando diferentes herramientas:
* Programándolos directamente en algún lenguaje de programación de alto nivel. Esta no es la mejor idea, porque la principal ventaja de un sistema basado en conocimiento es que el conocimiento está separado de la inferencia, y potencialmente un experto en el dominio del problema debería ser capaz de escribir reglas sin entender los detalles del proceso de inferencia.
* Usando **shell de sistemas expertos**, es decir, un sistema diseñado específicamente para ser poblado por conocimiento utilizando algún lenguaje de representación del conocimiento.
* Programándolos directamente en algún lenguaje de programación de alto nivel. Esto no es la mejor idea, porque la principal ventaja de un sistema basado en conocimiento es que el conocimiento está separado de la inferencia, y potencialmente un experto en el dominio del problema debería poder escribir reglas sin entender los detalles del proceso de inferencia.
* Usando un **shell de sistemas expertos**, es decir, un sistema diseñado específicamente para ser poblado con conocimiento utilizando algún lenguaje de representación del conocimiento.
## ✍️ Ejercicio: Inferencia Animal
Consulta [Animals.ipynb](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) para un ejemplo de implementación de un sistema experto de inferencia hacia adelante y hacia atrás.
> **Nota**: Este ejemplo es bastante simple y solo da una idea de cómo se ve un sistema experto. Una vez que comiences a crear tal sistema, solo notarás algún comportamiento *inteligente* de él una vez que alcances un cierto número de reglas, alrededor de 200+. En algún momento, las reglas se vuelven demasiado complejas para mantener todas en mente, y en este punto puedes comenzar a preguntarte por qué un sistema toma ciertas decisiones. Sin embargo, la característica importante de los sistemas basados en conocimiento es que siempre puedes *explicar* exactamente cómo se tomaron las decisiones.
## ✍️ Ejercicio: Inferencia de Animales
Consulta [Animals.ipynb](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/Animals.ipynb) para un ejemplo de implementación de un sistema experto con inferencia hacia adelante y hacia atrás.
> **Nota**: Este ejemplo es bastante simple y solo da una idea de cómo se ve un sistema experto. Una vez que comiences a crear un sistema de este tipo, solo notarás un comportamiento *inteligente* cuando alcances un cierto número de reglas, alrededor de 200 o más. En algún momento, las reglas se vuelven demasiado complejas para recordarlas todas, y en ese punto podrías empezar a preguntarte por qué el sistema toma ciertas decisiones. Sin embargo, una de las características importantes de los sistemas basados en conocimiento es que siempre puedes *explicar* exactamente cómo se tomó cada decisión.
## Ontologías y la Web Semántica
A finales del siglo XX, hubo una iniciativa para usar la representación del conocimiento para anotar recursos de Internet, de modo que fuera posible encontrar recursos que correspondieran a consultas muy específicas. Este movimiento se llamó **Web Semántica**, y se basó en varios conceptos:
A finales del siglo XX, surgió una iniciativa para usar la representación del conocimiento con el fin de anotar recursos de Internet, de manera que fuera posible encontrar recursos que correspondieran a consultas muy específicas. Este movimiento se llamó **Web Semántica**, y se basó en varios conceptos:
- Una representación especial del conocimiento basada en **[lógicas de descripción](https://en.wikipedia.org/wiki/Description_logic)** (DL). Es similar a la representación de conocimiento en marcos, porque construye una jerarquía de objetos con propiedades, pero tiene semántica lógica formal e inferencia. Hay toda una familia de DLs que equilibran entre expresividad y complejidad algorítmica de la inferencia.
- Representación de conocimiento distribuido, donde todos los conceptos están representados por un identificador URI global, lo que hace posible crear jerarquías de conocimiento que abarcan Internet.
- Una familia de lenguajes basados en XML para la descripción del conocimiento: RDF (Marco de Descripción de Recursos), RDFS (Esquema RDF), OWL (Lenguaje de Ontología Web).
- Una representación especial del conocimiento basada en **[lógicas descriptivas](https://en.wikipedia.org/wiki/Description_logic)** (DL). Es similar a la representación del conocimiento en marcos, ya que construye una jerarquía de objetos con propiedades, pero tiene semántica lógica formal e inferencia. Existe toda una familia de DLs que equilibran entre expresividad y la complejidad algorítmica de la inferencia.
- Representación del conocimiento distribuida, donde todos los conceptos están representados por un identificador URI global, lo que permite crear jerarquías de conocimiento que abarcan Internet.
- Una familia de lenguajes basados en XML para la descripción del conocimiento: RDF (Marco de Descripción de Recursos), RDFS (Esquema RDF), OWL (Lenguaje de Ontologías Web).
Un concepto central en la Web Semántica es el concepto de **Ontología**. Se refiere a una especificación explícita de un dominio de problema utilizando alguna representación formal del conocimiento. La ontología más simple puede ser solo una jerarquía de objetos en un dominio de problema, pero ontologías más complejas incluirán reglas que pueden ser utilizadas para inferencia.
Un concepto central en la Web Semántica es el concepto de **Ontología**. Se refiere a una especificación explícita de un dominio de problema utilizando alguna representación formal del conocimiento. La ontología más simple puede ser solo una jerarquía de objetos en un dominio de problema, pero las ontologías más complejas incluirán reglas que pueden usarse para inferencias.
En la web semántica, todas las representaciones se basan en tripletas. Cada objeto y cada relación están identificados de manera única por la URI. Por ejemplo, si queremos afirmar que este Currículo de IA ha sido desarrollado por Dmitry Soshnikov el 1 de enero de 2022, aquí están las tripletas que podemos usar:
En la Web Semántica, todas las representaciones se basan en tríadas. Cada objeto y cada relación están identificados de manera única por un URI. Por ejemplo, si queremos declarar el hecho de que este Currículum de IA fue desarrollado por Dmitry Soshnikov el 1 de enero de 2022, estas son las tríadas que podemos usar:
<img src="images/triplet.png" width="30%"/>
@ -173,17 +178,17 @@ http://github.com/microsoft/ai-for-beginners http://www.example.com/terms/creati
http://github.com/microsoft/ai-for-beginners http://purl.org/dc/elements/1.1/creator http://soshnikov.com
```
> ✅ Aquí `http://www.example.com/terms/creation-date` and `http://purl.org/dc/elements/1.1/creator` son algunas URIs bien conocidas y universalmente aceptadas para expresar los conceptos de *creador* y *fecha de creación*.
> ✅ Aquí `http://www.example.com/terms/creation-date` y `http://purl.org/dc/elements/1.1/creator` son algunos URIs bien conocidos y universalmente aceptados para expresar los conceptos de *creador* y *fecha de creación*.
En un caso más complejo, si queremos definir una lista de creadores, podemos usar algunas estructuras de datos definidas en RDF.
<img src="images/triplet-complex.png" width="40%"/>
> Diagramas arriba por [Dmitry Soshnikov](http://soshnikov.com)
> Diagramas anteriores por [Dmitry Soshnikov](http://soshnikov.com)
El progreso en la construcción de la Web Semántica se vio algo ralentizado por el éxito de los motores de búsqueda y las técnicas de procesamiento de lenguaje natural, que permiten extraer datos estructurados de texto. Sin embargo, en algunas áreas aún hay esfuerzos significativos para mantener ontologías y bases de conocimiento. Algunos proyectos que vale la pena mencionar:
El progreso en la construcción de la Web Semántica se vio algo ralentizado por el éxito de los motores de búsqueda y las técnicas de procesamiento del lenguaje natural, que permiten extraer datos estructurados del texto. Sin embargo, en algunas áreas todavía hay esfuerzos significativos para mantener ontologías y bases de conocimiento. Algunos proyectos destacados:
* [WikiData](https://wikidata.org/) es una colección de bases de conocimiento legibles por máquina asociadas con Wikipedia. La mayor parte de los datos se extraen de las *InfoBoxes* de Wikipedia, piezas de contenido estructurado dentro de las páginas de Wikipedia. Puedes [consultar](https://query.wikidata.org/) wikidata en SPARQL, un lenguaje de consulta especial para la Web Semántica. Aquí hay una consulta de muestra que muestra los colores de ojos más populares entre los humanos:
* [WikiData](https://wikidata.org/) es una colección de bases de conocimiento legibles por máquinas asociadas con Wikipedia. La mayor parte de los datos se extraen de las *InfoBoxes* de Wikipedia, piezas de contenido estructurado dentro de las páginas de Wikipedia. Puedes [consultar](https://query.wikidata.org/) WikiData en SPARQL, un lenguaje de consulta especial para la Web Semántica. Aquí hay una consulta de ejemplo que muestra los colores de ojos más populares entre los humanos:
```sparql
#defaultView:BubbleChart
@ -199,23 +204,45 @@ GROUP BY ?eyeColorLabel
* [DBpedia](https://www.dbpedia.org/) es otro esfuerzo similar a WikiData.
> ✅ Si deseas experimentar con la construcción de tus propias ontologías, o abrir las existentes, hay un gran editor visual de ontologías llamado [Protégé](https://protege.stanford.edu/). Descárgalo o úsalo en línea.
> ✅ Si deseas experimentar con la construcción de tus propias ontologías o abrir ontologías existentes, hay un excelente editor visual de ontologías llamado [Protégé](https://protege.stanford.edu/). Descárgalo o úsalo en línea.
<img src="images/protege.png" width="70%"/>
*Editor Web Protégé abierto con la ontología de la Familia Romanov. Captura de pantalla de Dmitry Soshnikov*
*Editor Web Protégé abierto con la ontología de la Familia Romanov. Captura de pantalla por Dmitry Soshnikov*
## ✍️ Ejercicio: Una Ontología Familiar
Consulta [FamilyOntology.ipynb](https://github.com/Ezana135/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb) para un ejemplo de uso de técnicas de Web Semántica para razonar sobre relaciones familiares. Tomaremos un árbol genealógico representado en el formato GEDCOM común y una ontología de relaciones familiares y construiremos un gráfico de todas las relaciones familiares para un conjunto dado de individuos.
Consulta [FamilyOntology.ipynb](https://github.com/Ezana135/AI-For-Beginners/blob/main/lessons/2-Symbolic/FamilyOntology.ipynb) para un ejemplo de uso de técnicas de la Web Semántica para razonar sobre relaciones familiares. Tomaremos un árbol genealógico representado en el formato común GEDCOM y una ontología de relaciones familiares para construir un gráfico de todas las relaciones familiares para un conjunto dado de individuos.
## Grafo de Conceptos de Microsoft
## Microsoft Concept Graph
En la mayoría de los casos, las ontologías son creadas cuidadosamente a mano. Sin embargo, también es posible **extraer** ontologías de datos no estructurados, por ejemplo, de textos en lenguaje natural.
En la mayoría de los casos, las ontologías se crean cuidadosamente a mano. Sin embargo, también es posible **extraer** ontologías de datos no estructurados, por ejemplo, de textos en lenguaje natural.
Un intento de este tipo fue realizado por Microsoft Research, y resultó en el [Grafo de Conceptos de Microsoft](https://blogs.microsoft.com/ai/microsoft-researchers-release-graph-that-helps-machines-conceptualize/?WT.mc_id=academic-77998-cacaste).
Un intento de este tipo fue realizado por Microsoft Research, y resultó en [Microsoft Concept Graph](https://blogs.microsoft.com/ai/microsoft-researchers-release-graph-that-helps-machines-conceptualize/?WT.mc_id=academic-77998-cacaste).
Es una gran colección de entidades agrupadas mediante la relación de herencia `is-a`. Permite responder preguntas como "¿Qué es Microsoft?"
Es una gran colección de entidades agrupadas utilizando la relación de herencia `es-un`. Permite responder preguntas como "¿Qué es Microsoft?" - la respuesta sería algo como "una empresa con probabilidad 0.87, y una marca con probabilidad 0.75".
El gráfico está disponible como API REST o como un gran archivo de texto descargable que enumera todos los pares de entidades.
## ✍️ Ejercicio: Un Concept Graph
Prueba el cuaderno [MSConceptGraph.ipynb](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/MSConceptGraph.ipynb) para ver cómo podemos usar Microsoft Concept Graph para agrupar artículos de noticias en varias categorías.
## Conclusión
Hoy en día, la IA a menudo se considera sinónimo de *Aprendizaje Automático* o *Redes Neuronales*. Sin embargo, los seres humanos también exhiben razonamiento explícito, algo que actualmente no manejan las redes neuronales. En proyectos del mundo real, el razonamiento explícito todavía se utiliza para realizar tareas que requieren explicaciones o la capacidad de modificar el comportamiento del sistema de manera controlada.
## 🚀 Desafío
En el cuaderno de la Ontología Familiar asociado a esta lección, hay una oportunidad para experimentar con otras relaciones familiares. Intenta descubrir nuevas conexiones entre las personas en el árbol genealógico.
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/202)
## Revisión y Autoestudio
Investiga en Internet para descubrir áreas donde los humanos han intentado cuantificar y codificar el conocimiento. Echa un vistazo a la Taxonomía de Bloom y retrocede en la historia para aprender cómo los humanos intentaron comprender su mundo. Explora el trabajo de Linneo para crear una taxonomía de organismos y observa cómo Dmitri Mendeléyev creó una forma de describir y agrupar los elementos químicos. ¿Qué otros ejemplos interesantes puedes encontrar?
**Tarea**: [Construye una Ontología](assignment.md)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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 garantizar la 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.

13
translations/es/lessons/2-Symbolic/assignment.md
View File

@ -1,6 +1,15 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a057a8604f3976c3e309884453f1fad0",
"translation_date": "2025-08-24T09:26:03+00:00",
"source_file": "lessons/2-Symbolic/assignment.md",
"language_code": "es"
}
-->
# Construir una Ontología
Construir una base de conocimientos se trata de categorizar un modelo que representa hechos sobre un tema. Elige un tema, como una persona, un lugar o una cosa, y luego construye un modelo de ese tema. Utiliza algunas de las técnicas y estrategias de construcción de modelos descritas en esta lección. Un ejemplo podría ser crear una ontología de una sala de estar con muebles, luces, y así sucesivamente. ¿En qué se diferencia la sala de estar de la cocina? ¿Del baño? ¿Cómo sabes que es una sala de estar y no un comedor? Usa [Protégé](https://protege.stanford.edu/) para construir tu ontología.
Construir una base de conocimiento consiste en categorizar un modelo que representa hechos sobre un tema. Elige un tema, como una persona, un lugar o un objeto, y luego construye un modelo de ese tema. Utiliza algunas de las técnicas y estrategias de construcción de modelos descritas en esta lección. Un ejemplo sería crear una ontología de una sala de estar con muebles, luces, etc. ¿En qué se diferencia la sala de estar de la cocina? ¿Del baño? ¿Cómo sabes que es una sala de estar y no un comedor? Utiliza [Protégé](https://protege.stanford.edu/) para construir tu ontología.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Aunque nos esforzamos por lograr la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

45
translations/es/lessons/3-NeuralNetworks/03-Perceptron/README.md
View File

@ -1,6 +1,15 @@
# Introducción a las Redes Neuronales: Perceptrón
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "0c37770bba4fff3c71dc00eb261ee61b",
"translation_date": "2025-08-24T09:22:59+00:00",
"source_file": "lessons/3-NeuralNetworks/03-Perceptron/README.md",
"language_code": "es"
}
-->
# Introducción a Redes Neuronales: Perceptrón
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/103)
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/103)
Uno de los primeros intentos de implementar algo similar a una red neuronal moderna fue realizado por Frank Rosenblatt del Laboratorio Aeronáutico de Cornell en 1957. Fue una implementación de hardware llamada "Mark-1", diseñada para reconocer figuras geométricas primitivas, como triángulos, cuadrados y círculos.
@ -10,7 +19,7 @@ Uno de los primeros intentos de implementar algo similar a una red neuronal mode
> Imágenes [de Wikipedia](https://en.wikipedia.org/wiki/Perceptron)
Una imagen de entrada se representaba mediante una matriz de fotoceldas de 20x20, por lo que la red neuronal tenía 400 entradas y una salida binaria. Una red simple contenía una neurona, también llamada **unidad de lógica de umbral**. Los pesos de la red neuronal actuaban como potenciómetros que requerían ajuste manual durante la fase de entrenamiento.
Una imagen de entrada se representaba mediante una matriz de fotoceldas de 20x20, por lo que la red neuronal tenía 400 entradas y una salida binaria. Una red simple contenía una neurona, también llamada una **unidad lógica de umbral**. Los pesos de la red neuronal actuaban como potenciómetros que requerían ajuste manual durante la fase de entrenamiento.
> ✅ Un potenciómetro es un dispositivo que permite al usuario ajustar la resistencia de un circuito.
@ -18,31 +27,31 @@ Una imagen de entrada se representaba mediante una matriz de fotoceldas de 20x20
## Modelo de Perceptrón
Supongamos que tenemos N características en nuestro modelo, en cuyo caso el vector de entrada sería un vector de tamaño N. Un perceptrón es un modelo de **clasificación binaria**, es decir, puede distinguir entre dos clases de datos de entrada. Supondremos que para cada vector de entrada x, la salida de nuestro perceptrón sería +1 o -1, dependiendo de la clase. La salida se calculará utilizando la fórmula:
Supongamos que tenemos N características en nuestro modelo, en cuyo caso el vector de entrada sería un vector de tamaño N. Un perceptrón es un modelo de **clasificación binaria**, es decir, puede distinguir entre dos clases de datos de entrada. Supondremos que para cada vector de entrada x, la salida de nuestro perceptrón será +1 o -1, dependiendo de la clase. La salida se calculará usando la fórmula:
y(x) = f(w<sup>T</sup>x)
donde f es una función de activación escalonada.
donde f es una función de activación escalón.
<!-- img src="http://www.sciweavers.org/tex2img.php?eq=f%28x%29%20%3D%20%5Cbegin%7Bcases%7D%0A%20%20%20%20%20%20%20%20%20%2B1%20%26%20x%20%5Cgeq%200%20%5C%5C%0A%20%20%20%20%20%20%20%20%20-1%20%26%20x%20%3C%200%0A%20%20%20%20%20%20%20%5Cend%7Bcases%7D%20%5C%5C%0A&bc=White&fc=Black&im=jpg&fs=12&ff=arev&edit=0" align="center" border="0" alt="f(x) = \begin{cases} +1 & x \geq 0 \\ -1 & x < 0 \end{cases} \\" width="154" height="50" / -->
<img src="images/activation-func.png"/>
## Entrenamiento del Perceptrón
Para entrenar un perceptrón necesitamos encontrar un vector de pesos w que clasifique correctamente la mayoría de los valores, es decir, que resulte en el menor **error**. Este error E se define mediante el **criterio del perceptrón** de la siguiente manera:
Para entrenar un perceptrón, necesitamos encontrar un vector de pesos w que clasifique la mayoría de los valores correctamente, es decir, que resulte en el menor **error**. Este error E se define mediante el **criterio del perceptrón** de la siguiente manera:
E(w) = -∑w<sup>T</sup>x<sub>i</sub>t<sub>i</sub>
donde:
* la suma se toma sobre aquellos puntos de datos de entrenamiento i que resultan en una clasificación incorrecta
* x<sub>i</sub> son los datos de entrada, y t<sub>i</sub> es -1 o +1 para ejemplos negativos y positivos, respectivamente.
* la suma se toma sobre aquellos puntos de datos de entrenamiento i que resultan en una clasificación incorrecta.
* x<sub>i</sub> es el dato de entrada, y t<sub>i</sub> es -1 o +1 para ejemplos negativos y positivos, respectivamente.
Este criterio se considera como una función de los pesos w, y necesitamos minimizarlo. A menudo, se utiliza un método llamado **descenso por gradiente**, en el que comenzamos con algunos pesos iniciales w<sup>(0)</sup>, y luego en cada paso actualizamos los pesos según la fórmula:
Este criterio se considera como una función de los pesos w, y necesitamos minimizarlo. A menudo, se utiliza un método llamado **descenso de gradiente**, en el cual comenzamos con algunos pesos iniciales w<sup>(0)</sup>, y luego en cada paso actualizamos los pesos según la fórmula:
w<sup>(t+1)</sup> = w<sup>(t)</sup> - η∇E(w)
Aquí η es la llamada **tasa de aprendizaje**, y ∇E(w) denota el **gradiente** de E. Después de calcular el gradiente, terminamos con
Aquí η es la llamada **tasa de aprendizaje**, y ∇E(w) denota el **gradiente** de E. Después de calcular el gradiente, obtenemos:
w<sup>(t+1)</sup> = w<sup>(t)</sup> + ∑ηx<sub>i</sub>t<sub>i</sub>
@ -74,22 +83,22 @@ En esta lección, aprendiste sobre un perceptrón, que es un modelo de clasifica
## 🚀 Desafío
Si deseas intentar construir tu propio perceptrón, prueba [este laboratorio en Microsoft Learn](https://docs.microsoft.com/en-us/azure/machine-learning/component-reference/two-class-averaged-perceptron?WT.mc_id=academic-77998-cacaste) que utiliza el [diseñador de Azure ML](https://docs.microsoft.com/en-us/azure/machine-learning/concept-designer?WT.mc_id=academic-77998-cacaste).
Si deseas intentar construir tu propio perceptrón, prueba [este laboratorio en Microsoft Learn](https://docs.microsoft.com/en-us/azure/machine-learning/component-reference/two-class-averaged-perceptron?WT.mc_id=academic-77998-cacaste), que utiliza el [diseñador de Azure ML](https://docs.microsoft.com/en-us/azure/machine-learning/concept-designer?WT.mc_id=academic-77998-cacaste).
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/203)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/203)
## Revisión y Autoestudio
## Repaso y Autoestudio
Para ver cómo podemos usar el perceptrón para resolver un problema simple así como problemas de la vida real, y para continuar aprendiendo, ve al cuaderno [Perceptron](../../../../../lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb).
Para ver cómo podemos usar un perceptrón para resolver un problema sencillo, así como problemas de la vida real, y para continuar aprendiendo, ve al cuaderno [Perceptron](../../../../../lessons/3-NeuralNetworks/03-Perceptron/Perceptron.ipynb).
Aquí hay un interesante [artículo sobre perceptrones](https://towardsdatascience.com/what-is-a-perceptron-basics-of-neural-networks-c4cfea20c590) también.
Aquí tienes un interesante [artículo sobre perceptrones](https://towardsdatascience.com/what-is-a-perceptron-basics-of-neural-networks-c4cfea20c590).
## [Asignación](lab/README.md)
## [Tarea](lab/README.md)
En esta lección, hemos implementado un perceptrón para la tarea de clasificación binaria, y lo hemos utilizado para clasificar entre dos dígitos manuscritos. En este laboratorio, se te pide que resuelvas el problema de clasificación de dígitos por completo, es decir, determinar qué dígito es más probable que corresponda a una imagen dada.
En esta lección, hemos implementado un perceptrón para una tarea de clasificación binaria, y lo hemos utilizado para clasificar entre dos dígitos escritos a mano. En este laboratorio, se te pide resolver el problema de clasificación de dígitos por completo, es decir, determinar qué dígito corresponde más probablemente a una imagen dada.
* [Instrucciones](lab/README.md)
* [Cuaderno](../../../../../lessons/3-NeuralNetworks/03-Perceptron/lab/PerceptronMultiClass.ipynb)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Aunque nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

29
translations/es/lessons/3-NeuralNetworks/03-Perceptron/lab/README.md
View File

@ -1,22 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7336583e4630220c835335da640016db",
"translation_date": "2025-08-24T09:23:19+00:00",
"source_file": "lessons/3-NeuralNetworks/03-Perceptron/lab/README.md",
"language_code": "es"
}
-->
# Clasificación Multiclase con Perceptrón
Tarea del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
Asignación de laboratorio del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
## Tarea
Usando el código que hemos desarrollado en esta lección para la clasificación binaria de dígitos manuscritos MNIST, crea un clasificador multiclase que sea capaz de reconocer cualquier dígito. Calcula la precisión de clasificación en el conjunto de datos de entrenamiento y prueba, y muestra la matriz de confusión.
Usando el código que hemos desarrollado en esta lección para la clasificación binaria de los dígitos manuscritos de MNIST, crea un clasificador multiclase que sea capaz de reconocer cualquier dígito. Calcula la precisión de clasificación en los conjuntos de datos de entrenamiento y prueba, y muestra la matriz de confusión.
## Consejos
## Pistas
1. Para cada dígito, crea un conjunto de datos para el clasificador binario de "este dígito vs. todos los demás dígitos".
2. Entrena 10 perceptrones diferentes para clasificación binaria (uno para cada dígito).
3. Define una función que clasifique un dígito de entrada.
1. Para cada dígito, crea un conjunto de datos para un clasificador binario de "este dígito vs. todos los demás dígitos".
1. Entrena 10 perceptrones diferentes para la clasificación binaria (uno para cada dígito).
1. Define una función que clasifique un dígito de entrada.
> **Consejo**: Si combinamos los pesos de los 10 perceptrones en una sola matriz, deberíamos poder aplicar los 10 perceptrones a los dígitos de entrada mediante una multiplicación de matrices. El dígito más probable se puede encontrar simplemente aplicando la operación `argmax` en la salida.
> **Pista**: Si combinamos los pesos de los 10 perceptrones en una sola matriz, deberíamos poder aplicar los 10 perceptrones a los dígitos de entrada mediante una sola multiplicación de matrices. El dígito más probable se puede encontrar simplemente aplicando la operación `argmax` en la salida.
## Notebook de Inicio
## Notebook Inicial
Comienza el laboratorio abriendo [PerceptronMultiClass.ipynb](../../../../../../lessons/3-NeuralNetworks/03-Perceptron/lab/PerceptronMultiClass.ipynb).
Comienza el laboratorio abriendo [PerceptronMultiClass.ipynb](../../../../../../lessons/3-NeuralNetworks/03-Perceptron/lab/PerceptronMultiClass.ipynb)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

93
translations/es/lessons/3-NeuralNetworks/04-OwnFramework/README.md
View File

@ -1,89 +1,98 @@
# Introducción a las Redes Neuronales. Perceptrón Multicapa
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "186bf7eeab776b36f557357ea56d4751",
"translation_date": "2025-08-24T09:22:01+00:00",
"source_file": "lessons/3-NeuralNetworks/04-OwnFramework/README.md",
"language_code": "es"
}
-->
# Introducción a Redes Neuronales. Perceptrón Multicapa
En la sección anterior, aprendiste sobre el modelo de red neuronal más simple: el perceptrón de una sola capa, un modelo de clasificación lineal de dos clases.
En la sección anterior, aprendiste sobre el modelo más simple de red neuronal: el perceptrón de una sola capa, un modelo lineal de clasificación binaria.
En esta sección, ampliaremos este modelo a un marco más flexible, que nos permitirá:
En esta sección, extenderemos este modelo a un marco más flexible, permitiéndonos:
* realizar **clasificación de múltiples clases** además de la clasificación de dos clases
* resolver **problemas de regresión** además de la clasificación
* separar clases que no son linealmente separables
* realizar **clasificación multiclase** además de clasificación binaria
* resolver **problemas de regresión** además de clasificación
* separar clases que no son linealmente separables
También desarrollaremos nuestro propio marco modular en Python que nos permitirá construir diferentes arquitecturas de redes neuronales.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/104)
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/104)
## Formalización del Aprendizaje Automático
Comencemos formalizando el problema del Aprendizaje Automático. Supongamos que tenemos un conjunto de datos de entrenamiento **X** con etiquetas **Y**, y necesitamos construir un modelo *f* que haga las predicciones más precisas. La calidad de las predicciones se mide mediante la **función de pérdida** ℒ. Las siguientes funciones de pérdida se utilizan a menudo:
Comencemos formalizando el problema de Aprendizaje Automático. Supongamos que tenemos un conjunto de datos de entrenamiento **X** con etiquetas **Y**, y necesitamos construir un modelo *f* que haga predicciones lo más precisas posible. La calidad de las predicciones se mide mediante la **función de pérdida** ℒ. Las siguientes funciones de pérdida se utilizan con frecuencia:
* Para el problema de regresión, cuando necesitamos predecir un número, podemos usar el **error absoluto** ∑<sub>i</sub>|f(x<sup>(i)</sup>)-y<sup>(i)</sup>|, o el **error cuadrático** ∑<sub>i</sub>(f(x<sup>(i)</sup>)-y<sup>(i)</sup>)<sup>2</sup>
* Para la clasificación, utilizamos la **pérdida 0-1** (que es esencialmente lo mismo que la **exactitud** del modelo), o la **pérdida logística**.
* Para problemas de regresión, cuando necesitamos predecir un número, podemos usar el **error absoluto** ∑<sub>i</sub>|f(x<sup>(i)</sup>)-y<sup>(i)</sup>|, o el **error cuadrático** ∑<sub>i</sub>(f(x<sup>(i)</sup>)-y<sup>(i)</sup>)<sup>2</sup>
* Para clasificación, usamos la **pérdida 0-1** (que es esencialmente lo mismo que la **precisión** del modelo) o la **pérdida logística**.
Para el perceptrón de una sola capa, la función *f* se definió como una función lineal *f(x)=wx+b* (aquí *w* es la matriz de pesos, *x* es el vector de características de entrada, y *b* es el vector de sesgo). Para diferentes arquitecturas de redes neuronales, esta función puede tomar una forma más compleja.
Para un perceptrón de una sola capa, la función *f* se definía como una función lineal *f(x)=wx+b* (donde *w* es la matriz de pesos, *x* es el vector de características de entrada, y *b* es el vector de sesgo). Para diferentes arquitecturas de redes neuronales, esta función puede tomar una forma más compleja.
> En el caso de la clasificación, a menudo es deseable obtener probabilidades de las clases correspondientes como salida de la red. Para convertir números arbitrarios en probabilidades (por ejemplo, para normalizar la salida), a menudo utilizamos la función **softmax** σ, y la función *f* se convierte en *f(x)=σ(wx+b)*
> En el caso de clasificación, a menudo es deseable obtener probabilidades de las clases correspondientes como salida de la red. Para convertir números arbitrarios en probabilidades (por ejemplo, para normalizar la salida), a menudo usamos la función **softmax** σ, y la función *f* se convierte en *f(x)=σ(wx+b)*.
En la definición de *f* anterior, *w* y *b* se llaman **parámetros** θ=⟨*w,b*⟩. Dado el conjunto de datos ⟨**X**,**Y**⟩, podemos calcular un error general en todo el conjunto de datos como una función de los parámetros θ.
En la definición de *f* anterior, *w* y *b* se denominan **parámetros** θ=⟨*w,b*⟩. Dado el conjunto de datos ⟨**X**,**Y**⟩, podemos calcular un error general en todo el conjunto de datos como una función de los parámetros θ.
> ✅ **El objetivo del entrenamiento de la red neuronal es minimizar el error variando los parámetros θ**
> ✅ **El objetivo del entrenamiento de redes neuronales es minimizar el error variando los parámetros θ**
## Optimización por Descenso de Gradiente
Hay un método bien conocido de optimización de funciones llamado **descenso de gradiente**. La idea es que podemos calcular una derivada (en el caso multidimensional llamada **gradiente**) de la función de pérdida con respecto a los parámetros, y variar los parámetros de tal manera que el error disminuya. Esto se puede formalizar de la siguiente manera:
Existe un método bien conocido de optimización de funciones llamado **descenso de gradiente**. La idea es que podemos calcular una derivada (en el caso multidimensional llamada **gradiente**) de la función de pérdida con respecto a los parámetros, y variar los parámetros de tal manera que el error disminuya. Esto se puede formalizar de la siguiente manera:
* Inicializar los parámetros con algunos valores aleatorios w<sup>(0)</sup>, b<sup>(0)</sup>
* Repetir el siguiente paso muchas veces:
- w<sup>(i+1)</sup> = w<sup>(i)</sup>-η∂ℒ/∂w
- b<sup>(i+1)</sup> = b<sup>(i)</sup>-η∂ℒ/∂b
* Inicializar los parámetros con algunos valores aleatorios w<sup>(0)</sup>, b<sup>(0)</sup>
* Repetir el siguiente paso muchas veces:
- w<sup>(i+1)</sup> = w<sup>(i)</sup>-η∂ℒ/∂w
- b<sup>(i+1)</sup> = b<sup>(i)</sup>-η∂ℒ/∂b
Durante el entrenamiento, se supone que los pasos de optimización se calculan considerando todo el conjunto de datos (recuerda que la pérdida se calcula como una suma a través de todas las muestras de entrenamiento). Sin embargo, en la vida real tomamos pequeñas porciones del conjunto de datos llamadas **minibatches**, y calculamos gradientes basados en un subconjunto de datos. Debido a que el subconjunto se toma aleatoriamente cada vez, este método se llama **descenso de gradiente estocástico** (SGD).
Durante el entrenamiento, se supone que los pasos de optimización se calculan considerando todo el conjunto de datos (recuerda que la pérdida se calcula como una suma a través de todas las muestras de entrenamiento). Sin embargo, en la práctica tomamos pequeñas porciones del conjunto de datos llamadas **minilotes**, y calculamos los gradientes basándonos en un subconjunto de datos. Debido a que el subconjunto se toma aleatoriamente cada vez, este método se llama **descenso de gradiente estocástico** (SGD).
## Perceptrones Multicapa y Retropropagación
La red de una sola capa, como hemos visto anteriormente, es capaz de clasificar clases que son linealmente separables. Para construir un modelo más rico, podemos combinar varias capas de la red. Matemáticamente, esto significaría que la función *f* tendría una forma más compleja y se calcularía en varios pasos:
* z<sub>1</sub>=w<sub>1</sub>x+b<sub>1</sub>
* z<sub>2</sub>=w<sub>2</sub>α(z<sub>1</sub>)+b<sub>2</sub>
* f = σ(z<sub>2</sub>)
Una red de una sola capa, como hemos visto anteriormente, es capaz de clasificar clases linealmente separables. Para construir un modelo más rico, podemos combinar varias capas de la red. Matemáticamente, esto significaría que la función *f* tendría una forma más compleja y se calcularía en varios pasos:
* z<sub>1</sub>=w<sub>1</sub>x+b<sub>1</sub>
* z<sub>2</sub>=w<sub>2</sub>α(z<sub>1</sub>)+b<sub>2</sub>
* f = σ(z<sub>2</sub>)
Aquí, α es una **función de activación no lineal**, σ es una función softmax, y los parámetros son θ=<*w<sub>1</sub>,b<sub>1</sub>,w<sub>2</sub>,b<sub>2</sub>*.
Aquí, α es una **función de activación no lineal**, σ es una función softmax, y los parámetros θ=<*w<sub>1</sub>,b<sub>1</sub>,w<sub>2</sub>,b<sub>2</sub>*>.
El algoritmo de descenso de gradiente seguiría siendo el mismo, pero sería más difícil calcular los gradientes. Dada la regla de diferenciación en cadena, podemos calcular las derivadas como:
El algoritmo de descenso de gradiente permanecería igual, pero sería más difícil calcular los gradientes. Dado el principio de la regla de la cadena, podemos calcular las derivadas como:
* ∂ℒ/∂w<sub>2</sub> = (∂ℒ/∂σ)(∂σ/∂z<sub>2</sub>)(∂z<sub>2</sub>/∂w<sub>2</sub>)
* ∂ℒ/∂w<sub>1</sub> = (∂ℒ/∂σ)(∂σ/∂z<sub>2</sub>)(∂z<sub>2</sub>/∂α)(∂α/∂z<sub>1</sub>)(∂z<sub>1</sub>/∂w<sub>1</sub>)
* ∂ℒ/∂w<sub>2</sub> = (∂ℒ/∂σ)(∂σ/∂z<sub>2</sub>)(∂z<sub>2</sub>/∂w<sub>2</sub>)
* ∂ℒ/∂w<sub>1</sub> = (∂ℒ/∂σ)(∂σ/∂z<sub>2</sub>)(∂z<sub>2</sub>/∂α)(∂α/∂z<sub>1</sub>)(∂z<sub>1</sub>/∂w<sub>1</sub>)
> ✅ La regla de diferenciación en cadena se utiliza para calcular las derivadas de la función de pérdida con respecto a los parámetros.
> ✅ La regla de la cadena se utiliza para calcular las derivadas de la función de pérdida con respecto a los parámetros.
Ten en cuenta que la parte más a la izquierda de todas esas expresiones es la misma, y así podemos calcular efectivamente las derivadas comenzando desde la función de pérdida y yendo "hacia atrás" a través del gráfico computacional. Así, el método de entrenamiento de un perceptrón multicapa se llama **retropropagación**, o 'backprop'.
Nota que la parte más a la izquierda de todas estas expresiones es la misma, y por lo tanto podemos calcular las derivadas de manera eficiente comenzando desde la función de pérdida y yendo "hacia atrás" a través del grafo computacional. Por lo tanto, el método de entrenamiento de un perceptrón multicapa se llama **retropropagación**, o 'backprop'.
<img alt="gráfico de computación" src="images/ComputeGraphGrad.png"/>
<img alt="grafo computacional" src="images/ComputeGraphGrad.png"/>
> TODO: cita de la imagen
> ✅ Cubriremos la retropropagación con mucho más detalle en nuestro ejemplo de cuaderno.
> ✅ Cubriremos la retropropagación con mucho más detalle en nuestro ejemplo en el notebook.
## Conclusión
En esta lección, hemos construido nuestra propia biblioteca de redes neuronales y la hemos utilizado para una simple tarea de clasificación bidimensional.
En esta lección, hemos construido nuestra propia biblioteca de redes neuronales y la hemos utilizado para una tarea simple de clasificación bidimensional.
## 🚀 Desafío
En el cuaderno que acompaña, implementarás tu propio marco para construir y entrenar perceptrones multicapa. Podrás ver en detalle cómo operan las redes neuronales modernas.
En el notebook adjunto, implementarás tu propio marco para construir y entrenar perceptrones multicapa. Podrás ver en detalle cómo operan las redes neuronales modernas.
Procede al cuaderno [OwnFramework](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) y trabaja en él.
Continúa con el notebook [OwnFramework](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) y trabaja en él.
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/204)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/204)
## Revisión y Autoestudio
La retropropagación es un algoritmo comúnmente utilizado en IA y ML, que vale la pena estudiar [con más detalle](https://wikipedia.org/wiki/Backpropagation)
La retropropagación es un algoritmo común en IA y ML, vale la pena estudiarlo [en más detalle](https://wikipedia.org/wiki/Backpropagation).
## [Asignación](lab/README.md)
## [Tarea](lab/README.md)
En este laboratorio, se te pide que uses el marco que construiste en esta lección para resolver la clasificación de dígitos manuscritos de MNIST.
En este laboratorio, se te pide que uses el marco que construiste en esta lección para resolver la clasificación de dígitos escritos a mano de MNIST.
* [Instrucciones](lab/README.md)
* [Cuaderno](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/lab/MyFW_MNIST.ipynb)
* [Instrucciones](lab/README.md)
* [Notebook](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/lab/MyFW_MNIST.ipynb)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Aunque nos esforzamos por lograr 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 malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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 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.

23
translations/es/lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md
View File

@ -1,12 +1,21 @@
# Clasificación MNIST con Nuestro Propio Marco
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "48fdd704d483e19bc3d7464074c9fcbe",
"translation_date": "2025-08-24T09:22:24+00:00",
"source_file": "lessons/3-NeuralNetworks/04-OwnFramework/lab/README.md",
"language_code": "es"
}
-->
# Clasificación MNIST con Nuestro Propio Framework
Tarea del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
Asignación de laboratorio del [Currículo de AI para Principiantes](https://github.com/microsoft/ai-for-beginners).
## Tarea
Resuelve el problema de clasificación de dígitos manuscritos MNIST utilizando perceptrones de 1, 2 y 3 capas. Usa el marco de red neuronal que hemos desarrollado en la lección.
Resuelve el problema de clasificación de dígitos escritos a mano de MNIST utilizando perceptrones de 1, 2 y 3 capas. Usa el framework de redes neuronales que hemos desarrollado en la lección.
## Inicio del Notebook
## Notebook Inicial
Comienza el laboratorio abriendo [MyFW_MNIST.ipynb](../../../../../../lessons/3-NeuralNetworks/04-OwnFramework/lab/MyFW_MNIST.ipynb)
@ -16,8 +25,8 @@ Como resultado de este laboratorio, intenta responder las siguientes preguntas:
- ¿La función de activación entre capas afecta el rendimiento de la red?
- ¿Necesitamos una red de 2 o 3 capas para esta tarea?
- ¿Experimentaste algún problema al entrenar la red? Especialmente a medida que aumentaba el número de capas.
- ¿Cómo se comportan los pesos de la red durante el entrenamiento? Puedes graficar el valor absoluto máximo de los pesos vs. época para entender la relación.
- ¿Tuviste algún problema entrenando la red? Especialmente cuando aumentó el número de capas.
- ¿Cómo se comportan los pesos de la red durante el entrenamiento? Puedes graficar el valor absoluto máximo de los pesos frente a las épocas para entender la relación.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Aunque nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

97
translations/es/lessons/3-NeuralNetworks/05-Frameworks/README.md
View File

@ -1,47 +1,56 @@
# Marcos de Redes Neuronales
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "2b544f20b796402507fb05a0df893323",
"translation_date": "2025-08-24T09:22:30+00:00",
"source_file": "lessons/3-NeuralNetworks/05-Frameworks/README.md",
"language_code": "es"
}
-->
# Frameworks de Redes Neuronales
Como ya hemos aprendido, para poder entrenar redes neuronales de manera eficiente necesitamos hacer dos cosas:
Como ya hemos aprendido, para entrenar redes neuronales de manera eficiente necesitamos hacer dos cosas:
* Operar con tensores, es decir, multiplicar, sumar y calcular algunas funciones como sigmoid o softmax.
* Calcular gradientes de todas las expresiones, con el fin de realizar la optimización por descenso de gradiente.
* Operar con tensores, por ejemplo, multiplicar, sumar y calcular funciones como sigmoid o softmax.
* Calcular gradientes de todas las expresiones, para realizar la optimización por descenso de gradiente.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/105)
Mientras que la biblioteca `numpy` puede realizar la primera parte, necesitamos algún mecanismo para calcular gradientes. En [nuestro marco](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) que hemos desarrollado en la sección anterior, tuvimos que programar manualmente todas las funciones derivadas dentro del método `backward`, que realiza la retropropagación. Idealmente, un marco debería brindarnos la oportunidad de calcular gradientes de *cualquier expresión* que podamos definir.
Aunque la biblioteca `numpy` puede realizar la primera parte, necesitamos algún mecanismo para calcular gradientes. En [nuestro framework](../../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb) que desarrollamos en la sección anterior, tuvimos que programar manualmente todas las funciones derivadas dentro del método `backward`, que realiza la retropropagación. Idealmente, un framework debería permitirnos calcular los gradientes de *cualquier expresión* que podamos definir.
Otra cosa importante es poder realizar cálculos en GPU, o en cualquier otra unidad de computación especializada, como [TPU](https://en.wikipedia.org/wiki/Tensor_Processing_Unit). El entrenamiento de redes neuronales profundas requiere *muchos* cálculos, y poder paralelizar esos cálculos en GPUs es muy importante.
Otra cosa importante es poder realizar cálculos en GPU, o en otras unidades de cómputo especializadas, como [TPU](https://en.wikipedia.org/wiki/Tensor_Processing_Unit). El entrenamiento de redes neuronales profundas requiere *muchos* cálculos, y poder paralelizar esos cálculos en GPUs es muy importante.
> ✅ El término 'paralelizar' significa distribuir los cálculos entre múltiples dispositivos.
Actualmente, los dos marcos neuronales más populares son: [TensorFlow](http://TensorFlow.org) y [PyTorch](https://pytorch.org/). Ambos proporcionan una API de bajo nivel para operar con tensores tanto en CPU como en GPU. Encima de la API de bajo nivel, también hay una API de alto nivel, llamada [Keras](https://keras.io/) y [PyTorch Lightning](https://pytorchlightning.ai/) respectivamente.
Actualmente, los dos frameworks de redes neuronales más populares son: [TensorFlow](http://TensorFlow.org) y [PyTorch](https://pytorch.org/). Ambos proporcionan una API de bajo nivel para operar con tensores tanto en CPU como en GPU. Además de la API de bajo nivel, también existe una API de alto nivel, llamada [Keras](https://keras.io/) y [PyTorch Lightning](https://pytorchlightning.ai/) respectivamente.
API de Bajo Nivel | [TensorFlow](http://TensorFlow.org) | [PyTorch](https://pytorch.org/)
------------------|-------------------------------------|--------------------------------
API de Alto Nivel | [Keras](https://keras.io/) | [PyTorch Lightning](https://pytorchlightning.ai/)
API de bajo nivel | [TensorFlow](http://TensorFlow.org) | [PyTorch](https://pytorch.org/)
-------------------|-------------------------------------|--------------------------------
API de alto nivel | [Keras](https://keras.io/) | [PyTorch Lightning](https://pytorchlightning.ai/)
**Las APIs de bajo nivel** en ambos marcos permiten construir lo que se llama **gráficas computacionales**. Esta gráfica define cómo calcular la salida (normalmente la función de pérdida) con los parámetros de entrada dados, y puede ser enviada para cálculo en GPU, si está disponible. Existen funciones para diferenciar esta gráfica computacional y calcular gradientes, que luego pueden ser utilizados para optimizar los parámetros del modelo.
Las **APIs de bajo nivel** en ambos frameworks permiten construir los llamados **gráficos computacionales**. Este gráfico define cómo calcular el resultado (usualmente la función de pérdida) con los parámetros de entrada dados, y puede ser enviado para cálculo en GPU, si está disponible. Hay funciones para diferenciar este gráfico computacional y calcular gradientes, que luego pueden ser utilizados para optimizar los parámetros del modelo.
**Las APIs de alto nivel** consideran las redes neuronales como una **secuencia de capas**, y facilitan la construcción de la mayoría de las redes neuronales. Entrenar el modelo generalmente requiere preparar los datos y luego llamar a una función `fit` para realizar el trabajo.
Las **APIs de alto nivel** consideran las redes neuronales como una **secuencia de capas**, y facilitan mucho la construcción de la mayoría de las redes neuronales. Entrenar el modelo generalmente requiere preparar los datos y luego llamar a una función `fit` para realizar el trabajo.
La API de alto nivel permite construir redes neuronales típicas muy rápidamente sin preocuparse por muchos detalles. Al mismo tiempo, la API de bajo nivel ofrece mucho más control sobre el proceso de entrenamiento, y por lo tanto se utiliza mucho en investigación, cuando se trabaja con nuevas arquitecturas de redes neuronales.
La API de alto nivel permite construir redes neuronales típicas muy rápidamente sin preocuparse por muchos detalles. Al mismo tiempo, la API de bajo nivel ofrece mucho más control sobre el proceso de entrenamiento, y por eso se utiliza mucho en investigación, cuando se trabaja con nuevas arquitecturas de redes neuronales.
También es importante entender que puedes usar ambas APIs juntas, es decir, puedes desarrollar tu propia arquitectura de capa de red utilizando la API de bajo nivel, y luego usarla dentro de la red más grande construida y entrenada con la API de alto nivel. O puedes definir una red usando la API de alto nivel como una secuencia de capas, y luego usar tu propio bucle de entrenamiento de bajo nivel para realizar la optimización. Ambas APIs utilizan los mismos conceptos básicos subyacentes y están diseñadas para funcionar bien juntas.
También es importante entender que se pueden usar ambas APIs juntas. Por ejemplo, puedes desarrollar tu propia arquitectura de capa de red utilizando la API de bajo nivel, y luego usarla dentro de una red más grande construida y entrenada con la API de alto nivel. O puedes definir una red utilizando la API de alto nivel como una secuencia de capas, y luego usar tu propio bucle de entrenamiento de bajo nivel para realizar la optimización. Ambas APIs utilizan los mismos conceptos básicos subyacentes y están diseñadas para trabajar bien juntas.
## Aprendizaje
En este curso, ofrecemos la mayor parte del contenido tanto para PyTorch como para TensorFlow. Puedes elegir tu marco preferido y solo pasar por los cuadernos correspondientes. Si no estás seguro de qué marco elegir, lee algunas discusiones en internet sobre **PyTorch vs. TensorFlow**. También puedes echar un vistazo a ambos marcos para obtener una mejor comprensión.
En este curso, ofrecemos la mayoría del contenido tanto para PyTorch como para TensorFlow. Puedes elegir tu framework preferido y solo revisar los notebooks correspondientes. Si no estás seguro de qué framework elegir, lee algunas discusiones en internet sobre **PyTorch vs. TensorFlow**. También puedes echar un vistazo a ambos frameworks para obtener una mejor comprensión.
Donde sea posible, utilizaremos APIs de alto nivel por simplicidad. Sin embargo, creemos que es importante entender cómo funcionan las redes neuronales desde cero, por lo que al principio comenzamos trabajando con la API de bajo nivel y tensores. Sin embargo, si deseas avanzar rápidamente y no quieres pasar mucho tiempo aprendiendo estos detalles, puedes saltarte eso e ir directamente a los cuadernos de la API de alto nivel.
Cuando sea posible, utilizaremos APIs de alto nivel por simplicidad. Sin embargo, creemos que es importante entender cómo funcionan las redes neuronales desde cero, por lo que al principio comenzamos trabajando con la API de bajo nivel y tensores. Sin embargo, si quieres avanzar rápidamente y no deseas dedicar mucho tiempo a aprender estos detalles, puedes omitirlos e ir directamente a los notebooks de la API de alto nivel.
## ✍️ Ejercicios: Marcos
## ✍️ Ejercicios: Frameworks
Continúa tu aprendizaje en los siguientes cuadernos:
Continúa tu aprendizaje en los siguientes notebooks:
API de Bajo Nivel | [Cuaderno TensorFlow+Keras](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [PyTorch](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb)
------------------|-------------------------------------|--------------------------------
API de Alto Nivel | [Keras](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) | *PyTorch Lightning*
API de bajo nivel | [Notebook TensorFlow+Keras](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb) | [PyTorch](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb)
-------------------|-------------------------------------|--------------------------------
API de alto nivel | [Keras](../../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKeras.ipynb) | *PyTorch Lightning*
Después de dominar los marcos, recapitularemos la noción de sobreajuste.
Después de dominar los frameworks, repasemos el concepto de sobreajuste.
# Sobreajuste
@ -49,75 +58,75 @@ El sobreajuste es un concepto extremadamente importante en el aprendizaje autom
Considera el siguiente problema de aproximar 5 puntos (representados por `x` en los gráficos a continuación):
![linear](../../../../../translated_images/overfit1.f24b71c6f652e59e6bed7245ffbeaecc3ba320e16e2221f6832b432052c4da43.es.jpg) | ![overfit](../../../../../translated_images/overfit2.131f5800ae10ca5e41d12a411f5f705d9ee38b1b10916f284b787028dd55cc1c.es.jpg)
![linear](../../../../../lessons/3-NeuralNetworks/images/overfit1.jpg) | ![overfit](../../../../../lessons/3-NeuralNetworks/images/overfit2.jpg)
-------------------------|--------------------------
**Modelo lineal, 2 parámetros** | **Modelo no lineal, 7 parámetros**
Error de entrenamiento = 5.3 | Error de entrenamiento = 0
Error de validación = 5.1 | Error de validación = 20
* A la izquierda, vemos una buena aproximación de línea recta. Debido a que el número de parámetros es adecuado, el modelo capta la idea detrás de la distribución de puntos correctamente.
* A la derecha, el modelo es demasiado potente. Dado que solo tenemos 5 puntos y el modelo tiene 7 parámetros, puede ajustarse de tal manera que pase por todos los puntos, haciendo que el error de entrenamiento sea 0. Sin embargo, esto impide que el modelo entienda el patrón correcto detrás de los datos, por lo que el error de validación es muy alto.
* A la izquierda, vemos una buena aproximación con una línea recta. Debido a que el número de parámetros es adecuado, el modelo entiende correctamente la distribución de los puntos.
* A la derecha, el modelo es demasiado poderoso. Debido a que solo tenemos 5 puntos y el modelo tiene 7 parámetros, puede ajustarse de tal manera que pase por todos los puntos, haciendo que el error de entrenamiento sea 0. Sin embargo, esto impide que el modelo entienda el patrón correcto detrás de los datos, por lo que el error de validación es muy alto.
Es muy importante encontrar un equilibrio correcto entre la riqueza del modelo (número de parámetros) y la cantidad de muestras de entrenamiento.
## Por qué ocurre el sobreajuste
* No hay suficientes datos de entrenamiento.
* Modelo demasiado potente.
* Demasiado ruido en los datos de entrada.
* El modelo es demasiado poderoso.
* Hay demasiado ruido en los datos de entrada.
## Cómo detectar el sobreajuste
Como puedes ver en el gráfico anterior, el sobreajuste se puede detectar por un error de entrenamiento muy bajo y un error de validación alto. Normalmente, durante el entrenamiento, veremos que tanto el error de entrenamiento como el de validación comienzan a disminuir, y luego en algún momento el error de validación puede dejar de disminuir y comenzar a aumentar. Esto será una señal de sobreajuste y un indicador de que probablemente deberíamos detener el entrenamiento en este punto (o al menos hacer una instantánea del modelo).
Como puedes ver en el gráfico anterior, el sobreajuste puede detectarse por un error de entrenamiento muy bajo y un error de validación alto. Normalmente, durante el entrenamiento veremos que tanto el error de entrenamiento como el de validación comienzan a disminuir, y luego en algún momento el error de validación podría dejar de disminuir y comenzar a aumentar. Esto será una señal de sobreajuste y un indicador de que probablemente deberíamos detener el entrenamiento en ese punto (o al menos hacer una captura del modelo).
![overfitting](../../../../../translated_images/Overfitting.408ad91cd90b4371d0a81f4287e1409c359751adeb1ae450332af50e84f08c3e.es.png)
![overfitting](../../../../../lessons/3-NeuralNetworks/images/Overfitting.png)
## Cómo prevenir el sobreajuste
Si puedes ver que ocurre el sobreajuste, puedes hacer una de las siguientes acciones:
Si detectas que ocurre sobreajuste, puedes hacer lo siguiente:
* Aumentar la cantidad de datos de entrenamiento.
* Disminuir la complejidad del modelo.
* Utilizar alguna [técnica de regularización](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md), como [Dropout](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md#Dropout), que consideraremos más adelante.
* Usar alguna [técnica de regularización](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md), como [Dropout](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md#Dropout), que consideraremos más adelante.
## Sobreajuste y el Compromiso Bias-Varianza
## Sobreajuste y el equilibrio entre sesgo y varianza
El sobreajuste es en realidad un caso de un problema más genérico en estadística llamado [Compromiso Bias-Varianza](https://en.wikipedia.org/wiki/Bias%E2%80%93variance_tradeoff). Si consideramos las posibles fuentes de error en nuestro modelo, podemos ver dos tipos de errores:
El sobreajuste es en realidad un caso de un problema más general en estadística llamado [Equilibrio entre sesgo y varianza](https://en.wikipedia.org/wiki/Bias%E2%80%93variance_tradeoff). Si consideramos las posibles fuentes de error en nuestro modelo, podemos ver dos tipos de errores:
* **Errores de sesgo** son causados por el hecho de que nuestro algoritmo no puede capturar correctamente la relación entre los datos de entrenamiento. Puede resultar del hecho de que nuestro modelo no es lo suficientemente potente (**subajuste**).
* **Errores de varianza**, que son causados por el modelo que aproxima el ruido en los datos de entrada en lugar de una relación significativa (**sobreajuste**).
* **Errores de sesgo** son causados por nuestro algoritmo al no poder capturar correctamente la relación entre los datos de entrenamiento. Esto puede resultar del hecho de que nuestro modelo no es lo suficientemente poderoso (**subajuste**).
* **Errores de varianza**, que son causados por el modelo al aproximar el ruido en los datos de entrada en lugar de la relación significativa (**sobreajuste**).
Durante el entrenamiento, el error de sesgo disminuye (a medida que nuestro modelo aprende a aproximar los datos), y el error de varianza aumenta. Es importante detener el entrenamiento - ya sea manualmente (cuando detectamos sobreajuste) o automáticamente (introduciendo regularización) - para prevenir el sobreajuste.
Durante el entrenamiento, el error de sesgo disminuye (a medida que nuestro modelo aprende a aproximar los datos) y el error de varianza aumenta. Es importante detener el entrenamiento, ya sea manualmente (cuando detectamos sobreajuste) o automáticamente (introduciendo regularización), para prevenir el sobreajuste.
## Conclusión
En esta lección, aprendiste sobre las diferencias entre las diversas APIs para los dos marcos de IA más populares, TensorFlow y PyTorch. Además, aprendiste sobre un tema muy importante, el sobreajuste.
En esta lección, aprendiste sobre las diferencias entre las diversas APIs de los dos frameworks de IA más populares, TensorFlow y PyTorch. Además, aprendiste sobre un tema muy importante: el sobreajuste.
## 🚀 Desafío
En los cuadernos acompañantes, encontrarás 'tareas' al final; trabaja a través de los cuadernos y completa las tareas.
En los notebooks acompañantes, encontrarás 'tareas' al final; trabaja en los notebooks y completa las tareas.
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/205)
## Revisión y Autoestudio
## Revisión y autoestudio
Realiza una investigación sobre los siguientes temas:
Investiga sobre los siguientes temas:
- TensorFlow
- PyTorch
- Sobreajuste
Pregúntate las siguientes cuestiones:
Pregúntate lo siguiente:
- ¿Cuál es la diferencia entre TensorFlow y PyTorch?
- ¿Cuál es la diferencia entre sobreajuste y subajuste?
## [Asignación](lab/README.md)
En este laboratorio, se te pide resolver dos problemas de clasificación utilizando redes completamente conectadas de una y múltiples capas usando PyTorch o TensorFlow.
En este laboratorio, se te pide resolver dos problemas de clasificación utilizando redes completamente conectadas de una y varias capas con PyTorch o TensorFlow.
* [Instrucciones](lab/README.md)
* [Cuaderno](../../../../../lessons/3-NeuralNetworks/05-Frameworks/lab/LabFrameworks.ipynb)
* [Notebook](../../../../../lessons/3-NeuralNetworks/05-Frameworks/lab/LabFrameworks.ipynb)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Aunque nos esforzamos por la 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 humana. No somos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

21
translations/es/lessons/3-NeuralNetworks/05-Frameworks/lab/README.md
View File

@ -1,19 +1,28 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "e452d897efb9a89700f41021834cf6e5",
"translation_date": "2025-08-24T09:22:51+00:00",
"source_file": "lessons/3-NeuralNetworks/05-Frameworks/lab/README.md",
"language_code": "es"
}
-->
# Clasificación con PyTorch/TensorFlow
Tarea del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
Asignación de laboratorio del [Currículo de AI para Principiantes](https://github.com/microsoft/ai-for-beginners).
## Tarea
Resuelve dos problemas de clasificación utilizando redes completamente conectadas de una sola capa y multicapa usando PyTorch o TensorFlow:
Resuelve dos problemas de clasificación utilizando redes completamente conectadas de una y varias capas con PyTorch o TensorFlow:
1. Problema de **[clasificación de iris](https://en.wikipedia.org/wiki/Iris_flower_data_set)** - un ejemplo de un problema con datos de entrada tabulares, que puede ser manejado por el aprendizaje automático clásico. Tu objetivo será clasificar las iris en 3 clases, basándote en 4 parámetros numéricos.
1. Problema de clasificación de dígitos manuscritos **MNIST** que ya hemos visto antes.
1. Problema de **[clasificación de Iris](https://en.wikipedia.org/wiki/Iris_flower_data_set)**: un ejemplo de problema con datos de entrada tabulares, que puede ser manejado por aprendizaje automático clásico. Tu objetivo será clasificar iris en 3 clases, basándote en 4 parámetros numéricos.
1. Problema de clasificación de dígitos manuscritos **MNIST**, que ya hemos visto antes.
Prueba diferentes arquitecturas de red para lograr la mejor precisión posible.
## Notebook de Inicio
## Notebook Inicial
Comienza el laboratorio abriendo [LabFrameworks.ipynb](../../../../../../lessons/3-NeuralNetworks/05-Frameworks/lab/LabFrameworks.ipynb)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. 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 malas interpretaciones que surjan del uso de esta traducción.
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.

47
translations/es/lessons/3-NeuralNetworks/README.md
View File

@ -1,51 +1,60 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1c6b8c7c1778a35fc1139b7f2aecb7b3",
"translation_date": "2025-08-24T09:21:45+00:00",
"source_file": "lessons/3-NeuralNetworks/README.md",
"language_code": "es"
}
-->
# Introducción a las Redes Neuronales
![Resumen del contenido de Introducción a Redes Neuronales en un garabato](../../../../translated_images/ai-neuralnetworks.1c687ae40bc86e834f497844866a26d3e0886650a67a4bbe29442e2f157d3b18.es.png)
![Resumen del contenido de Introducción a Redes Neuronales en un dibujo](../../../../lessons/sketchnotes/ai-neuralnetworks.png)
Como discutimos en la introducción, una de las formas de lograr inteligencia es entrenar un **modelo de computadora** o un **cerebro artificial**. Desde mediados del siglo XX, los investigadores han probado diferentes modelos matemáticos, hasta que en los últimos años esta dirección ha demostrado ser enormemente exitosa. Tales modelos matemáticos del cerebro se llaman **redes neuronales**.
Como discutimos en la introducción, una de las formas de lograr inteligencia es entrenar un **modelo computacional** o un **cerebro artificial**. Desde mediados del siglo XX, los investigadores probaron diferentes modelos matemáticos, hasta que en años recientes esta dirección demostró ser enormemente exitosa. Estos modelos matemáticos del cerebro se llaman **redes neuronales**.
> A veces, las redes neuronales se denominan *Redes Neuronales Artificiales*, ANNs, para indicar que estamos hablando de modelos, no de redes reales de neuronas.
> A veces las redes neuronales se llaman *Redes Neuronales Artificiales* o ANNs, para indicar que estamos hablando de modelos, no de redes reales de neuronas.
## Aprendizaje Automático
Las Redes Neuronales son parte de una disciplina más amplia llamada **Aprendizaje Automático**, cuyo objetivo es utilizar datos para entrenar modelos de computadora que sean capaces de resolver problemas. El Aprendizaje Automático constituye una gran parte de la Inteligencia Artificial; sin embargo, no cubrimos el aprendizaje automático clásico en este currículo.
Las Redes Neuronales forman parte de una disciplina más amplia llamada **Aprendizaje Automático** (Machine Learning), cuyo objetivo es usar datos para entrenar modelos computacionales capaces de resolver problemas. El Aprendizaje Automático constituye una gran parte de la Inteligencia Artificial, sin embargo, no cubrimos el aprendizaje automático clásico en este plan de estudios.
> Visita nuestro currículo separado **[Aprendizaje Automático para Principiantes](http://github.com/microsoft/ml-for-beginners)** para aprender más sobre el aprendizaje automático clásico.
> Visita nuestro plan de estudios separado **[Machine Learning for Beginners](http://github.com/microsoft/ml-for-beginners)** para aprender más sobre el Aprendizaje Automático clásico.
En el Aprendizaje Automático, asumimos que tenemos un conjunto de datos de ejemplos **X**, y valores de salida correspondientes **Y**. Los ejemplos son a menudo vectores N-dimensionales que consisten en **características**, y las salidas se llaman **etiquetas**.
En el Aprendizaje Automático, asumimos que tenemos un conjunto de datos de ejemplos **X** y valores de salida correspondientes **Y**. Los ejemplos suelen ser vectores N-dimensionales que consisten en **características**, y las salidas se llaman **etiquetas**.
Consideraremos los dos problemas más comunes en el aprendizaje automático:
Consideraremos los dos problemas más comunes del aprendizaje automático:
* **Clasificación**, donde necesitamos clasificar un objeto de entrada en dos o más clases.
* **Regresión**, donde necesitamos predecir un número numérico para cada una de las muestras de entrada.
* **Regresión**, donde necesitamos predecir un valor numérico para cada una de las muestras de entrada.
> Al representar entradas y salidas como tensores, el conjunto de datos de entrada es una matriz de tamaño M×N, donde M es el número de muestras y N es el número de características. Las etiquetas de salida Y son el vector de tamaño M.
> Al representar entradas y salidas como tensores, el conjunto de datos de entrada es una matriz de tamaño M×N, donde M es el número de muestras y N es el número de características. Las etiquetas de salida Y son un vector de tamaño M.
En este currículo, nos enfocaremos únicamente en modelos de redes neuronales.
En este plan de estudios, nos centraremos únicamente en modelos de redes neuronales.
## Un Modelo de Neurona
Desde la biología sabemos que nuestro cerebro consiste en células neuronales, cada una de ellas teniendo múltiples "entradas" (axones) y una salida (dendrita). Los axones y dendritas pueden conducir señales eléctricas, y las conexiones entre axones y dendritas pueden exhibir diferentes grados de conductividad (controlados por neuromediadores).
De la biología sabemos que nuestro cerebro está compuesto por células neuronales, cada una de las cuales tiene múltiples "entradas" (axones) y una salida (dendrita). Los axones y dendritas pueden conducir señales eléctricas, y las conexiones entre axones y dendritas pueden mostrar diferentes grados de conductividad (controlados por neuromediadores).
![Modelo de una Neurona](../../../../translated_images/synapse-wikipedia.ed20a9e4726ea1c6a3ce8fec51c0b9bec6181946dca0fe4e829bc12fa3bacf01.es.jpg) | ![Modelo de una Neurona](../../../../translated_images/artneuron.1a5daa88d20ebe6f5824ddb89fba0bdaaf49f67e8230c1afbec42909df1fc17e.es.png)
![Modelo de una Neurona](../../../../lessons/3-NeuralNetworks/images/synapse-wikipedia.jpg) | ![Modelo de una Neurona](../../../../lessons/3-NeuralNetworks/images/artneuron.png)
----|----
Neurona Real *([Imagen](https://en.wikipedia.org/wiki/Synapse#/media/File:SynapseSchematic_lines.svg) de Wikipedia)* | Neurona Artificial *(Imagen del Autor)*
Así, el modelo matemático más simple de una neurona contiene varias entradas X<sub>1</sub>, ..., X<sub>N</sub> y una salida Y, y una serie de pesos W<sub>1</sub>, ..., W<sub>N</sub>. Una salida se calcula como:
Por lo tanto, el modelo matemático más simple de una neurona contiene varias entradas X<sub>1</sub>, ..., X<sub>N</sub> y una salida Y, junto con una serie de pesos W<sub>1</sub>, ..., W<sub>N</sub>. La salida se calcula como:
<img src="images/netout.png" alt="Y = f\left(\sum_{i=1}^N X_iW_i\right)" width="131" height="53" align="center"/>
donde f es alguna **función de activación** no lineal.
> Los primeros modelos de neuronas fueron descritos en el artículo clásico [Un cálculo lógico de las ideas inmanentes en la actividad nerviosa](https://www.cs.cmu.edu/~./epxing/Class/10715/reading/McCulloch.and.Pitts.pdf) por Warren McCullock y Walter Pitts en 1943. Donald Hebb en su libro "[La Organización del Comportamiento: Una Teoría Neuropsicológica](https://books.google.com/books?id=VNetYrB8EBoC)" propuso la forma en que estas redes pueden ser entrenadas.
> Los primeros modelos de neurona fueron descritos en el artículo clásico [A logical calculus of the ideas immanent in nervous activity](https://www.cs.cmu.edu/~./epxing/Class/10715/reading/McCulloch.and.Pitts.pdf) por Warren McCullock y Walter Pitts en 1943. Donald Hebb, en su libro "[The Organization of Behavior: A Neuropsychological Theory](https://books.google.com/books?id=VNetYrB8EBoC)", propuso la forma en que estas redes pueden ser entrenadas.
## En esta Sección
En esta sección aprenderemos sobre:
* [Perceptrón](03-Perceptron/README.md), uno de los primeros modelos de red neuronal para clasificación de dos clases
* [Redes multicapa](04-OwnFramework/README.md) con un cuaderno emparejado [cómo construir nuestro propio marco](../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb)
* [Frameworks de Redes Neuronales](05-Frameworks/README.md), con estos cuadernos: [PyTorch](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) y [Keras/Tensorflow](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb)
* [Sobreajuste](../../../../lessons/3-NeuralNetworks/05-Frameworks)
* [Perceptrón](03-Perceptron/README.md), uno de los primeros modelos de redes neuronales para clasificación en dos clases.
* [Redes multicapa](04-OwnFramework/README.md) con un cuaderno asociado [cómo construir nuestro propio marco](../../../../lessons/3-NeuralNetworks/04-OwnFramework/OwnFramework.ipynb).
* [Marcos de Redes Neuronales](05-Frameworks/README.md), con estos cuadernos: [PyTorch](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroPyTorch.ipynb) y [Keras/Tensorflow](../../../../lessons/3-NeuralNetworks/05-Frameworks/IntroKerasTF.ipynb).
* [Sobreajuste](../../../../lessons/3-NeuralNetworks/05-Frameworks).
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Aunque nos esforzamos por lograr la 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 la traducción profesional realizada por humanos. No somos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

93
translations/es/lessons/4-ComputerVision/06-IntroCV/README.md
View File

@ -1,29 +1,38 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "4bedc8e702db17260cfe824d58b6cfd4",
"translation_date": "2025-08-24T09:18:28+00:00",
"source_file": "lessons/4-ComputerVision/06-IntroCV/README.md",
"language_code": "es"
}
-->
# Introducción a la Visión por Computadora
[Visión por Computadora](https://wikipedia.org/wiki/Computer_vision) es una disciplina cuyo objetivo es permitir que las computadoras obtengan una comprensión de alto nivel de las imágenes digitales. Esta es una definición bastante amplia, porque *comprender* puede significar muchas cosas diferentes, incluyendo encontrar un objeto en una imagen (**detección de objetos**), entender lo que está sucediendo (**detección de eventos**), describir una imagen en texto, o reconstruir una escena en 3D. También hay tareas especiales relacionadas con imágenes humanas: estimación de edad y emoción, detección e identificación de rostros, y estimación de pose en 3D, por nombrar algunas.
[Visión por Computadora](https://wikipedia.org/wiki/Computer_vision) es una disciplina cuyo objetivo es permitir que las computadoras obtengan una comprensión de alto nivel de las imágenes digitales. Esta es una definición bastante amplia, ya que *comprender* puede significar muchas cosas, incluyendo encontrar un objeto en una imagen (**detección de objetos**), entender qué está sucediendo (**detección de eventos**), describir una imagen en texto o reconstruir una escena en 3D. También hay tareas especiales relacionadas con imágenes humanas: estimación de edad y emociones, detección e identificación de rostros, y estimación de poses en 3D, por nombrar algunas.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/106)
Una de las tareas más simples de la visión por computadora es **clasificación de imágenes**.
Una de las tareas más simples de la visión por computadora es la **clasificación de imágenes**.
La visión por computadora a menudo se considera una rama de la IA. Hoy en día, la mayoría de las tareas de visión por computadora se resuelven utilizando redes neuronales. Aprenderemos más sobre el tipo especial de redes neuronales utilizadas para la visión por computadora, [redes neuronales convolucionales](../07-ConvNets/README.md), a lo largo de esta sección.
La visión por computadora a menudo se considera una rama de la IA. Hoy en día, la mayoría de las tareas de visión por computadora se resuelven utilizando redes neuronales. Aprenderemos más sobre el tipo especial de redes neuronales utilizadas para visión por computadora, [redes neuronales convolucionales](../07-ConvNets/README.md), a lo largo de esta sección.
Sin embargo, antes de pasar la imagen a una red neuronal, en muchos casos tiene sentido utilizar algunas técnicas algorítmicas para mejorar la imagen.
Sin embargo, antes de pasar la imagen a una red neuronal, en muchos casos tiene sentido usar algunas técnicas algorítmicas para mejorar la imagen.
Hay varias bibliotecas de Python disponibles para el procesamiento de imágenes:
Existen varias bibliotecas de Python disponibles para el procesamiento de imágenes:
* **[imageio](https://imageio.readthedocs.io/en/stable/)** se puede usar para leer/escribir diferentes formatos de imagen. También soporta ffmpeg, una herramienta útil para convertir fotogramas de video en imágenes.
* **[Pillow](https://pillow.readthedocs.io/en/stable/index.html)** (también conocido como PIL) es un poco más poderosa y también soporta algunas manipulaciones de imágenes como morfología, ajustes de paleta, y más.
* **[OpenCV](https://opencv.org/)** es una poderosa biblioteca de procesamiento de imágenes escrita en C++, que se ha convertido en el estándar *de facto* para el procesamiento de imágenes. Tiene una interfaz conveniente para Python.
* **[dlib](http://dlib.net/)** es una biblioteca de C++ que implementa muchos algoritmos de aprendizaje automático, incluidos algunos de los algoritmos de Visión por Computadora. También tiene una interfaz de Python y se puede usar para tareas desafiantes como la detección de rostros y puntos de referencia faciales.
* **[imageio](https://imageio.readthedocs.io/en/stable/)** se puede usar para leer/escribir diferentes formatos de imágenes. También admite ffmpeg, una herramienta útil para convertir fotogramas de video en imágenes.
* **[Pillow](https://pillow.readthedocs.io/en/stable/index.html)** (también conocido como PIL) es un poco más potente y también admite algunas manipulaciones de imágenes como morphing, ajustes de paleta y más.
* **[OpenCV](https://opencv.org/)** es una biblioteca de procesamiento de imágenes escrita en C++, que se ha convertido en el estándar *de facto* para el procesamiento de imágenes. Tiene una interfaz conveniente en Python.
* **[dlib](http://dlib.net/)** es una biblioteca en C++ que implementa muchos algoritmos de aprendizaje automático, incluyendo algunos de los algoritmos de visión por computadora. También tiene una interfaz en Python y se puede usar para tareas desafiantes como la detección de rostros y puntos clave faciales.
## OpenCV
[OpenCV](https://opencv.org/) se considera el estándar *de facto* para el procesamiento de imágenes. Contiene muchos algoritmos útiles, implementados en C++. También puedes llamar a OpenCV desde Python.
[OpenCV](https://opencv.org/) se considera el estándar *de facto* para el procesamiento de imágenes. Contiene muchos algoritmos útiles, implementados en C++. También puedes usar OpenCV desde Python.
Un buen lugar para aprender OpenCV es [este curso de Learn OpenCV](https://learnopencv.com/getting-started-with-opencv/). En nuestro plan de estudios, nuestro objetivo no es aprender OpenCV, sino mostrarte algunos ejemplos de cuándo se puede utilizar y cómo.
Un buen lugar para aprender OpenCV es [este curso de Learn OpenCV](https://learnopencv.com/getting-started-with-opencv/). En nuestro plan de estudios, nuestro objetivo no es aprender OpenCV, sino mostrarte algunos ejemplos de cuándo se puede usar y cómo.
### Cargando Imágenes
### Cargar imágenes
Las imágenes en Python se pueden representar convenientemente mediante arreglos de NumPy. Por ejemplo, las imágenes en escala de grises con un tamaño de 320x200 píxeles se almacenarían en un arreglo de 200x320, y las imágenes en color de la misma dimensión tendrían una forma de 200x320x3 (para 3 canales de color). Para cargar una imagen, puedes usar el siguiente código:
@ -35,78 +44,78 @@ im = cv2.imread('image.jpeg')
plt.imshow(im)
```
Tradicionalmente, OpenCV utiliza codificación BGR (Azul-Verde-Rojo) para imágenes en color, mientras que el resto de las herramientas de Python utilizan el más tradicional RGB (Rojo-Verde-Azul). Para que la imagen se vea correctamente, necesitas convertirla al espacio de color RGB, ya sea intercambiando dimensiones en el arreglo de NumPy o llamando a una función de OpenCV:
Tradicionalmente, OpenCV utiliza codificación BGR (Azul-Verde-Rojo) para imágenes en color, mientras que el resto de las herramientas de Python utilizan la más tradicional RGB (Rojo-Verde-Azul). Para que la imagen se vea correctamente, necesitas convertirla al espacio de color RGB, ya sea intercambiando dimensiones en el arreglo de NumPy o llamando a una función de OpenCV:
```python
im = cv2.cvtColor(im,cv2.COLOR_BGR2RGB)
```
Las mismas funciones `cvtColor` function can be used to perform other color space transformations such as converting an image to grayscale or to the HSV (Hue-Saturation-Value) color space.
La misma función `cvtColor` se puede usar para realizar otras transformaciones de espacio de color, como convertir una imagen a escala de grises o al espacio de color HSV (Matiz-Saturación-Valor).
You can also use OpenCV to load video frame-by-frame - an example is given in the exercise [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb).
También puedes usar OpenCV para cargar fotogramas de video uno por uno; se da un ejemplo en el ejercicio [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb).
### Image Processing
### Procesamiento de imágenes
Before feeding an image to a neural network, you may want to apply several pre-processing steps. OpenCV can do many things, including:
Antes de alimentar una imagen a una red neuronal, es posible que desees aplicar varios pasos de preprocesamiento. OpenCV puede hacer muchas cosas, incluyendo:
* **Resizing** the image using `im = cv2.resize(im, (320,200),interpolation=cv2.INTER_LANCZOS)`
* **Blurring** the image using `im = cv2.medianBlur(im,3)` or `im = cv2.GaussianBlur(im, (3,3), 0)`
* Changing the **brightness and contrast** of the image can be done by NumPy array manipulations, as described [in this Stackoverflow note](https://stackoverflow.com/questions/39308030/how-do-i-increase-the-contrast-of-an-image-in-python-opencv).
* Using [thresholding](https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html) by calling `cv2.threshold`/`cv2.adaptiveThreshold`, que a menudo son preferibles a ajustar el brillo o el contraste.
* Aplicando diferentes [transformaciones](https://docs.opencv.org/4.5.5/da/d6e/tutorial_py_geometric_transformations.html) a la imagen:
- **[Transformaciones afines](https://docs.opencv.org/4.5.5/d4/d61/tutorial_warp_affine.html)** pueden ser útiles si necesitas combinar rotación, redimensionamiento y sesgo en la imagen y conoces la ubicación de origen y destino de tres puntos en la imagen. Las transformaciones afines mantienen paralelas las líneas paralelas.
- **[Transformaciones de perspectiva](https://medium.com/analytics-vidhya/opencv-perspective-transformation-9edffefb2143)** pueden ser útiles cuando conoces las posiciones de origen y destino de 4 puntos en la imagen. Por ejemplo, si tomas una foto de un documento rectangular a través de la cámara de un smartphone desde algún ángulo, y quieres hacer una imagen rectangular del documento mismo.
* Entendiendo el movimiento dentro de la imagen utilizando **[flujo óptico](https://docs.opencv.org/4.5.5/d4/dee/tutorial_optical_flow.html)**.
* **Redimensionar** la imagen usando `im = cv2.resize(im, (320,200),interpolation=cv2.INTER_LANCZOS)`
* **Desenfocar** la imagen usando `im = cv2.medianBlur(im,3)` o `im = cv2.GaussianBlur(im, (3,3), 0)`
* Cambiar el **brillo y contraste** de la imagen se puede hacer mediante manipulaciones de arreglos de NumPy, como se describe [en esta nota de Stackoverflow](https://stackoverflow.com/questions/39308030/how-do-i-increase-the-contrast-of-an-image-in-python-opencv).
* Usar [umbralización](https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html) llamando a las funciones `cv2.threshold`/`cv2.adaptiveThreshold`, lo cual a menudo es preferible a ajustar el brillo o contraste.
* Aplicar diferentes [transformaciones](https://docs.opencv.org/4.5.5/da/d6e/tutorial_py_geometric_transformations.html) a la imagen:
- **[Transformaciones afines](https://docs.opencv.org/4.5.5/d4/d61/tutorial_warp_affine.html)** pueden ser útiles si necesitas combinar rotación, redimensionamiento e inclinación en la imagen y conoces la ubicación de origen y destino de tres puntos en la imagen. Las transformaciones afines mantienen las líneas paralelas paralelas.
- **[Transformaciones de perspectiva](https://medium.com/analytics-vidhya/opencv-perspective-transformation-9edffefb2143)** pueden ser útiles cuando conoces las posiciones de origen y destino de 4 puntos en la imagen. Por ejemplo, si tomas una foto de un documento rectangular con la cámara de un smartphone desde algún ángulo y quieres hacer una imagen rectangular del documento en sí.
* Entender el movimiento dentro de la imagen usando **[flujo óptico](https://docs.opencv.org/4.5.5/d4/dee/tutorial_optical_flow.html)**.
## Ejemplos de uso de la Visión por Computadora
En nuestro [Cuaderno de OpenCV](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb), damos algunos ejemplos de cuándo se puede usar la visión por computadora para realizar tareas específicas:
En nuestro [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb), damos algunos ejemplos de cuándo se puede usar la visión por computadora para realizar tareas específicas:
* **Preprocesamiento de una fotografía de un libro en Braille**. Nos enfocamos en cómo podemos usar umbralización, detección de características, transformación de perspectiva y manipulaciones de NumPy para separar símbolos individuales de Braille para su posterior clasificación por una red neuronal.
* **Preprocesar una fotografía de un libro en Braille**. Nos enfocamos en cómo podemos usar umbralización, detección de características, transformación de perspectiva y manipulaciones de NumPy para separar símbolos individuales de Braille para su posterior clasificación por una red neuronal.
![Imagen de Braille](../../../../../translated_images/braille.341962ff76b1bd7044409371d3de09ced5028132aef97344ea4b7468c1208126.es.jpeg) | ![Imagen de Braille Preprocesada](../../../../../translated_images/braille-result.46530fea020b03c76aac532d7d6eeef7f6fb35b55b1001cd21627907dabef3ed.es.png) | ![Símbolos de Braille](../../../../../translated_images/braille-symbols.0159185ab69d533909dc4d7d26a1971b51401c6a80eb3a5584f250ea880af88b.es.png)
![Imagen Braille](../../../../../lessons/4-ComputerVision/06-IntroCV/data/braille.jpeg) | ![Imagen Braille Preprocesada](../../../../../lessons/4-ComputerVision/06-IntroCV/images/braille-result.png) | ![Símbolos Braille](../../../../../lessons/4-ComputerVision/06-IntroCV/images/braille-symbols.png)
----|-----|-----
> Imagen de [OpenCV.ipynb](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
* **Detectando movimiento en video utilizando la diferencia de fotogramas**. Si la cámara está fija, entonces los fotogramas de la transmisión de la cámara deberían ser bastante similares entre sí. Dado que los fotogramas se representan como arreglos, al restar esos arreglos de dos fotogramas subsiguientes obtendremos la diferencia de píxeles, que debería ser baja para fotogramas estáticos y aumentar una vez que haya un movimiento sustancial en la imagen.
* **Detectar movimiento en video usando diferencia de fotogramas**. Si la cámara está fija, entonces los fotogramas del flujo de la cámara deberían ser bastante similares entre sí. Dado que los fotogramas se representan como arreglos, simplemente al restar esos arreglos de dos fotogramas consecutivos obtendremos la diferencia de píxeles, que debería ser baja para fotogramas estáticos y volverse más alta cuando haya un movimiento sustancial en la imagen.
![Imagen de fotogramas de video y diferencias de fotogramas](../../../../../translated_images/frame-difference.706f805491a0883c938e16447bf5eb2f7d69e812c7f743cbe7d7c7645168f81f.es.png)
![Imagen de fotogramas de video y diferencias de fotogramas](../../../../../lessons/4-ComputerVision/06-IntroCV/images/frame-difference.png)
> Imagen de [OpenCV.ipynb](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
* **Detectando movimiento utilizando Flujo Óptico**. [El flujo óptico](https://docs.opencv.org/3.4/d4/dee/tutorial_optical_flow.html) nos permite entender cómo se mueven los píxeles individuales en los fotogramas de video. Hay dos tipos de flujo óptico:
* **Detectar movimiento usando Flujo Óptico**. [Flujo óptico](https://docs.opencv.org/3.4/d4/dee/tutorial_optical_flow.html) nos permite entender cómo se mueven los píxeles individuales en los fotogramas de video. Hay dos tipos de flujo óptico:
- **Flujo Óptico Denso** calcula el campo de vectores que muestra para cada píxel hacia dónde se está moviendo.
- **Flujo Óptico Escaso** se basa en tomar algunas características distintivas en la imagen (por ejemplo, bordes) y construir su trayectoria de un fotograma a otro.
- **Flujo Óptico Denso** calcula el campo vectorial que muestra para cada píxel hacia dónde se está moviendo.
- **Flujo Óptico Escaso** se basa en tomar algunas características distintivas en la imagen (por ejemplo, bordes) y construir su trayectoria de fotograma a fotograma.
![Imagen de Flujo Óptico](../../../../../translated_images/optical.1f4a94464579a83a10784f3c07fe7228514714b96782edf50e70ccd59d2d8c4f.es.png)
![Imagen de Flujo Óptico](../../../../../lessons/4-ComputerVision/06-IntroCV/images/optical.png)
> Imagen de [OpenCV.ipynb](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
## ✍️ Cuadernos de Ejemplo: OpenCV [intenta OpenCV en Acción](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
## ✍️ Ejemplo de Notebooks: OpenCV [prueba OpenCV en acción](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
Hagamos algunos experimentos con OpenCV explorando [OpenCV Notebook](../../../../../lessons/4-ComputerVision/06-IntroCV/OpenCV.ipynb)
## Conclusión
A veces, tareas relativamente complejas como la detección de movimiento o la detección de yemas de los dedos pueden resolverse puramente con visión por computadora. Por lo tanto, es muy útil conocer las técnicas básicas de visión por computadora y lo que bibliotecas como OpenCV pueden hacer.
A veces, tareas relativamente complejas como la detección de movimiento o la detección de la punta de los dedos se pueden resolver únicamente mediante visión por computadora. Por lo tanto, es muy útil conocer las técnicas básicas de visión por computadora y lo que bibliotecas como OpenCV pueden hacer.
## 🚀 Desafío
Mira [este video](https://docs.microsoft.com/shows/ai-show/ai-show--2021-opencv-ai-competition--grand-prize-winners--cortic-tigers--episode-32?WT.mc_id=academic-77998-cacaste) del AI show para aprender sobre el proyecto Cortic Tigers y cómo construyeron una solución basada en bloques para democratizar las tareas de visión por computadora a través de un robot. Investiga otros proyectos como este que ayuden a incorporar nuevos aprendices en el campo.
Mira [este video](https://docs.microsoft.com/shows/ai-show/ai-show--2021-opencv-ai-competition--grand-prize-winners--cortic-tigers--episode-32?WT.mc_id=academic-77998-cacaste) del AI Show para aprender sobre el proyecto Cortic Tigers y cómo construyeron una solución basada en bloques para democratizar las tareas de visión por computadora mediante un robot. Investiga otros proyectos como este que ayudan a nuevos aprendices a iniciarse en el campo.
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/206)
## Revisión y Autoestudio
Lee más sobre el flujo óptico [en este gran tutorial](https://learnopencv.com/optical-flow-in-opencv/).
Lee más sobre flujo óptico [en este excelente tutorial](https://learnopencv.com/optical-flow-in-opencv/).
## [Tarea](lab/README.md)
## [Asignación](lab/README.md)
En este laboratorio, tomarás un video con gestos simples, y tu objetivo es extraer movimientos arriba/abajo/izquierda/derecha utilizando flujo óptico.
En este laboratorio, tomarás un video con gestos simples, y tu objetivo será extraer movimientos hacia arriba/abajo/izquierda/derecha usando flujo óptico.
<img src="images/palm-movement.png" width="30%" alt="Marco de Movimiento de Palma"/>
<img src="images/palm-movement.png" width="30%" alt="Fotograma de Movimiento de Palma"/>
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

28
translations/es/lessons/4-ComputerVision/06-IntroCV/lab/README.md
View File

@ -1,23 +1,31 @@
# Detección de Movimientos usando Flujo Óptico
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "3d53d6409f80970f7281a45dee35328a",
"translation_date": "2025-08-24T09:18:55+00:00",
"source_file": "lessons/4-ComputerVision/06-IntroCV/lab/README.md",
"language_code": "es"
}
-->
# Detectando Movimientos usando Flujo Óptico
Tarea del [Currículo de IA para Principiantes](https://aka.ms/ai-beginners).
Asignación de laboratorio del [Currículo de AI para Principiantes](https://aka.ms/ai-beginners).
## Tarea
Considera [este video](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/palm-movement.mp4), en el que la palma de una persona se mueve hacia la izquierda/derecha/arriba/abajo sobre un fondo estable.
Has sido entrenado con datos hasta octubre de 2023.
Considera [este video](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/palm-movement.mp4), en el cual la palma de una persona se mueve hacia la izquierda/derecha/arriba/abajo sobre un fondo estable.
**Tu objetivo** sería poder utilizar el Flujo Óptico para determinar qué partes del video contienen movimientos hacia arriba/abajo/izquierda/derecha.
**Tu objetivo** sería usar Flujo Óptico para determinar qué partes del video contienen movimientos hacia arriba/abajo/izquierda/derecha.
**Objetivo adicional** sería rastrear el movimiento de la palma/dedo utilizando el tono de piel, como se describe [en esta publicación de blog](https://dev.to/amarlearning/finger-detection-and-tracking-using-opencv-and-python-586m) o [aquí](http://www.benmeline.com/finger-tracking-with-opencv-and-python/).
**Objetivo adicional** sería rastrear el movimiento de la palma/dedo utilizando el tono de piel, como se describe [en este artículo](https://dev.to/amarlearning/finger-detection-and-tracking-using-opencv-and-python-586m) o [aquí](http://www.benmeline.com/finger-tracking-with-opencv-and-python/).
## Cuaderno de Inicio
## Notebook Inicial
Inicia el laboratorio abriendo [MovementDetection.ipynb](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/MovementDetection.ipynb)
Comienza el laboratorio abriendo [MovementDetection.ipynb](../../../../../../lessons/4-ComputerVision/06-IntroCV/lab/MovementDetection.ipynb)
## Conclusión
A veces, tareas relativamente complejas como la detección de movimiento o la detección de yemas de los dedos pueden resolverse puramente mediante visión por computadora. Por lo tanto, es muy útil saber lo que bibliotecas como OpenCV pueden hacer.
A veces, tareas relativamente complejas como la detección de movimiento o la detección de la punta de los dedos pueden resolverse únicamente mediante visión por computadora. Por lo tanto, es muy útil saber lo que bibliotecas como OpenCV pueden hacer.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. 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 la traducción profesional por parte de un humano. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

45
translations/es/lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md
View File

@ -1,14 +1,23 @@
# Arquitecturas de CNN Bien Conocidas
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "2f7b97b375358cb51a1e098df306bf73",
"translation_date": "2025-08-24T09:18:04+00:00",
"source_file": "lessons/4-ComputerVision/07-ConvNets/CNN_Architectures.md",
"language_code": "es"
}
-->
# Arquitecturas Conocidas de Redes Neuronales Convolucionales (CNN)
### VGG-16
VGG-16 es una red que logró una precisión del 92.7% en la clasificación top-5 de ImageNet en 2014. Tiene la siguiente estructura de capas:
VGG-16 es una red que alcanzó un 92.7% de precisión en la clasificación top-5 de ImageNet en 2014. Tiene la siguiente estructura de capas:
![ImageNet Layers](../../../../../translated_images/vgg-16-arch1.d901a5583b3a51baeaab3e768567d921e5d54befa46e1e642616c5458c934028.es.jpg)
![Capas de ImageNet](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch1.jpg)
Como puedes ver, VGG sigue una arquitectura de pirámide tradicional, que es una secuencia de capas de convolución y agrupamiento.
Como puedes ver, VGG sigue una arquitectura piramidal tradicional, que consiste en una secuencia de capas de convolución y pooling.
![ImageNet Pyramid](../../../../../translated_images/vgg-16-arch.64ff2137f50dd49fdaa786e3f3a975b3f22615efd13efb19c5d22f12e01451a1.es.jpg)
![Pirámide de ImageNet](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch.jpg)
> Imagen de [Researchgate](https://www.researchgate.net/figure/Vgg16-model-structure-To-get-the-VGG-NIN-model-we-replace-the-2-nd-4-th-6-th-7-th_fig2_335194493)
@ -20,9 +29,9 @@ ResNet es una familia de modelos propuesta por Microsoft Research en 2015. La id
> Imagen de [este artículo](https://arxiv.org/pdf/1512.03385.pdf)
La razón para usar la conexión de identidad es permitir que nuestra capa prediga **la diferencia** entre el resultado de una capa anterior y la salida del bloque residual; de ahí el nombre *residual*. Estos bloques son mucho más fáciles de entrenar, y se pueden construir redes con varios cientos de esos bloques (las variantes más comunes son ResNet-52, ResNet-101 y ResNet-152).
La razón para usar un paso de identidad es que nuestra capa prediga **la diferencia** entre el resultado de una capa previa y la salida del bloque residual, de ahí el nombre *residual*. Estos bloques son mucho más fáciles de entrenar, y se pueden construir redes con varios cientos de estos bloques (las variantes más comunes son ResNet-52, ResNet-101 y ResNet-152).
También puedes pensar en esta red como capaz de ajustar su complejidad al conjunto de datos. Inicialmente, cuando comienzas a entrenar la red, los valores de los pesos son pequeños, y la mayor parte de la señal pasa a través de capas de identidad. A medida que avanza el entrenamiento y los pesos se vuelven más grandes, la importancia de los parámetros de la red crece, y la red se ajusta para acomodar el poder expresivo requerido para clasificar correctamente las imágenes de entrenamiento.
También puedes pensar en esta red como una que ajusta su complejidad al conjunto de datos. Al principio, cuando comienzas a entrenar la red, los valores de los pesos son pequeños, y la mayor parte de la señal pasa a través de las capas de identidad. A medida que el entrenamiento avanza y los pesos se hacen más grandes, la importancia de los parámetros de la red crece, y la red se ajusta para acomodar el poder expresivo necesario para clasificar correctamente las imágenes de entrenamiento.
### Google Inception
@ -32,33 +41,33 @@ La arquitectura Google Inception lleva esta idea un paso más allá y construye
> Imagen de [Researchgate](https://www.researchgate.net/figure/Inception-module-with-dimension-reductions-left-and-schema-for-Inception-ResNet-v1_fig2_355547454)
Aquí, necesitamos enfatizar el papel de las convoluciones 1x1, porque al principio no tienen sentido. ¿Por qué necesitaríamos pasar por la imagen con un filtro 1x1? Sin embargo, debes recordar que los filtros de convolución también trabajan con varios canales de profundidad (originalmente - colores RGB, en capas subsiguientes - canales para diferentes filtros), y la convolución 1x1 se utiliza para mezclar esos canales de entrada utilizando diferentes pesos entrenables. También puede verse como un muestreo (agrupamiento) sobre la dimensión de los canales.
Aquí, debemos destacar el papel de las convoluciones 1x1, porque al principio no tienen mucho sentido. ¿Por qué necesitaríamos recorrer la imagen con un filtro 1x1? Sin embargo, debes recordar que los filtros de convolución también trabajan con varios canales de profundidad (originalmente - colores RGB, en capas posteriores - canales para diferentes filtros), y la convolución 1x1 se utiliza para mezclar esos canales de entrada utilizando diferentes pesos entrenables. También puede verse como una reducción de dimensiones (pooling) sobre la dimensión de los canales.
Aquí hay [una buena publicación de blog](https://medium.com/analytics-vidhya/talented-mr-1x1-comprehensive-look-at-1x1-convolution-in-deep-learning-f6b355825578) sobre el tema, y [el artículo original](https://arxiv.org/pdf/1312.4400.pdf).
Aquí tienes [un buen artículo](https://medium.com/analytics-vidhya/talented-mr-1x1-comprehensive-look-at-1x1-convolution-in-deep-learning-f6b355825578) sobre el tema, y [el artículo original](https://arxiv.org/pdf/1312.4400.pdf).
### MobileNet
MobileNet es una familia de modelos de tamaño reducido, adecuada para dispositivos móviles. Úsalos si tienes pocos recursos y puedes sacrificar un poco de precisión. La idea principal detrás de ellos es la llamada **convolución separable en profundidad**, que permite representar los filtros de convolución mediante una composición de convoluciones espaciales y convoluciones 1x1 sobre los canales de profundidad. Esto reduce significativamente el número de parámetros, haciendo que la red sea más pequeña en tamaño y también más fácil de entrenar con menos datos.
MobileNet es una familia de modelos de tamaño reducido, adecuados para dispositivos móviles. Úsalos si tienes recursos limitados y puedes sacrificar un poco de precisión. La idea principal detrás de ellos es la llamada **convolución separable en profundidad**, que permite representar los filtros de convolución como una composición de convoluciones espaciales y convoluciones 1x1 sobre los canales de profundidad. Esto reduce significativamente el número de parámetros, haciendo que la red sea más pequeña en tamaño y también más fácil de entrenar con menos datos.
Aquí hay [una buena publicación de blog sobre MobileNet](https://medium.com/analytics-vidhya/image-classification-with-mobilenet-cc6fbb2cd470).
Aquí tienes [un buen artículo sobre MobileNet](https://medium.com/analytics-vidhya/image-classification-with-mobilenet-cc6fbb2cd470).
## Conclusión
En esta unidad, has aprendido el concepto principal detrás de las redes neuronales de visión por computadora: las redes convolucionales. Las arquitecturas de la vida real que impulsan la clasificación de imágenes, la detección de objetos e incluso las redes de generación de imágenes se basan en CNN, solo que con más capas y algunos trucos de entrenamiento adicionales.
En esta unidad, has aprendido el concepto principal detrás de las redes neuronales para visión por computadora: las redes convolucionales. Las arquitecturas reales que impulsan la clasificación de imágenes, la detección de objetos e incluso las redes de generación de imágenes están todas basadas en CNNs, solo que con más capas y algunos trucos adicionales de entrenamiento.
## 🚀 Desafío
En los cuadernos adjuntos, hay notas al final sobre cómo obtener una mayor precisión. Realiza algunos experimentos para ver si puedes lograr una mayor precisión.
En los cuadernos adjuntos, hay notas al final sobre cómo obtener mayor precisión. Realiza algunos experimentos para ver si puedes lograr una mayor precisión.
## [Cuestionario posterior a la conferencia](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/207)
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/207)
## Revisión y Autoestudio
Aunque las CNN se utilizan más comúnmente para tareas de Visión por Computadora, son generalmente buenas para extraer patrones de tamaño fijo. Por ejemplo, si estamos tratando con sonidos, también podríamos querer usar CNN para buscar algunos patrones específicos en la señal de audio; en cuyo caso los filtros serían unidimensionales (y esta CNN se llamaría 1D-CNN). Además, a veces se utiliza 3D-CNN para extraer características en un espacio multidimensional, como ciertos eventos que ocurren en un video; la CNN puede capturar ciertos patrones de cambio de características a lo largo del tiempo. Realiza algunas revisiones y autoestudios sobre otras tareas que se pueden realizar con CNN.
Aunque las CNNs se utilizan con mayor frecuencia para tareas de Visión por Computadora, en general son buenas para extraer patrones de tamaño fijo. Por ejemplo, si estamos trabajando con sonidos, también podríamos querer usar CNNs para buscar patrones específicos en señales de audio, en cuyo caso los filtros serían unidimensionales (y esta CNN se llamaría 1D-CNN). Además, a veces se utiliza una 3D-CNN para extraer características en un espacio multidimensional, como ciertos eventos que ocurren en un video - la CNN puede capturar ciertos patrones de cambio de características a lo largo del tiempo. Realiza una revisión y autoestudio sobre otras tareas que se pueden realizar con CNNs.
## [Asignación](lab/README.md)
## [Tarea](lab/README.md)
En este laboratorio, se te encarga clasificar diferentes razas de gatos y perros. Estas imágenes son más complejas que el conjunto de datos MNIST y de dimensiones más altas, y hay más de 10 clases.
En este laboratorio, tu tarea es clasificar diferentes razas de gatos y perros. Estas imágenes son más complejas que el conjunto de datos MNIST, tienen dimensiones más altas y hay más de 10 clases.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas 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 de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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 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 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.

54
translations/es/lessons/4-ComputerVision/07-ConvNets/README.md
View File

@ -1,59 +1,67 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "088837b42b7d99198bf62db8a42411e0",
"translation_date": "2025-08-24T09:17:43+00:00",
"source_file": "lessons/4-ComputerVision/07-ConvNets/README.md",
"language_code": "es"
}
-->
# Redes Neuronales Convolucionales
Hemos visto anteriormente que las redes neuronales son bastante efectivas para trabajar con imágenes, e incluso un perceptrón de una sola capa es capaz de reconocer dígitos manuscritos del conjunto de datos MNIST con una precisión razonable. Sin embargo, el conjunto de datos MNIST es muy especial, y todos los dígitos están centrados dentro de la imagen, lo que hace que la tarea sea más sencilla.
Hemos visto anteriormente que las redes neuronales son bastante buenas para trabajar con imágenes, e incluso un perceptrón de una sola capa es capaz de reconocer dígitos escritos a mano del conjunto de datos MNIST con una precisión razonable. Sin embargo, el conjunto de datos MNIST es muy especial, ya que todos los dígitos están centrados dentro de la imagen, lo que simplifica la tarea.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/107)
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/107)
En la vida real, queremos ser capaces de reconocer objetos en una imagen sin importar su ubicación exacta en ella. La visión por computadora es diferente de la clasificación genérica, porque cuando intentamos encontrar un cierto objeto en la imagen, estamos escaneando la imagen en busca de ciertos **patrones** y sus combinaciones. Por ejemplo, al buscar un gato, primero podemos buscar líneas horizontales, que pueden formar bigotes, y luego una combinación específica de bigotes puede indicarnos que en realidad es una imagen de un gato. La posición relativa y la presencia de ciertos patrones es importante, y no su posición exacta en la imagen.
En la vida real, queremos ser capaces de reconocer objetos en una imagen independientemente de su ubicación exacta en la misma. La visión por computadora es diferente de la clasificación genérica, porque cuando intentamos encontrar un objeto específico en una imagen, escaneamos la imagen buscando ciertos **patrones** y sus combinaciones. Por ejemplo, al buscar un gato, primero podríamos buscar líneas horizontales que formen los bigotes, y luego una cierta combinación de bigotes podría indicarnos que, efectivamente, es una imagen de un gato. La posición relativa y la presencia de ciertos patrones son importantes, no su posición exacta en la imagen.
Para extraer patrones, utilizaremos la noción de **filtros convolucionales**. Como saben, una imagen está representada por una matriz 2D, o un tensor 3D con profundidad de color. Aplicar un filtro significa que tomamos una matriz de **núcleo de filtro** relativamente pequeña, y para cada píxel en la imagen original calculamos el promedio ponderado con los puntos vecinos. Podemos ver esto como una pequeña ventana deslizándose sobre toda la imagen, promediando todos los píxeles de acuerdo con los pesos en la matriz del núcleo del filtro.
Para extraer patrones, utilizaremos el concepto de **filtros convolucionales**. Como sabes, una imagen se representa mediante una matriz 2D o un tensor 3D con profundidad de color. Aplicar un filtro significa que tomamos una matriz relativamente pequeña llamada **núcleo del filtro**, y para cada píxel en la imagen original calculamos el promedio ponderado con los puntos vecinos. Podemos imaginar esto como una pequeña ventana que se desliza sobre toda la imagen, promediando todos los píxeles según los pesos en la matriz del núcleo del filtro.
![Filtro de Borde Vertical](../../../../../translated_images/filter-vert.b7148390ca0bc356ddc7e55555d2481819c1e86ddde9dce4db5e71a69d6f887f.es.png) | ![Filtro de Borde Horizontal](../../../../../translated_images/filter-horiz.59b80ed4feb946efbe201a7fe3ca95abb3364e266e6fd90820cb893b4d3a6dda.es.png)
![Filtro de borde vertical](../../../../../lessons/4-ComputerVision/07-ConvNets/images/filter-vert.png) | ![Filtro de borde horizontal](../../../../../lessons/4-ComputerVision/07-ConvNets/images/filter-horiz.png)
----|----
> Imagen de Dmitry Soshnikov
> Imagen por Dmitry Soshnikov
Por ejemplo, si aplicamos filtros de borde vertical y horizontal de 3x3 a los dígitos MNIST, podemos obtener resaltados (por ejemplo, valores altos) donde hay bordes verticales y horizontales en nuestra imagen original. Así, esos dos filtros pueden ser utilizados para "buscar" bordes. De manera similar, podemos diseñar diferentes filtros para buscar otros patrones de bajo nivel:
Estás entrenado con datos hasta octubre de 2023.
Por ejemplo, si aplicamos filtros de borde vertical y horizontal de 3x3 a los dígitos de MNIST, podemos resaltar (por ejemplo, valores altos) donde hay bordes verticales y horizontales en nuestra imagen original. Por lo tanto, esos dos filtros pueden usarse para "buscar" bordes. De manera similar, podemos diseñar diferentes filtros para buscar otros patrones de bajo nivel:
> Imagen de [Banco de Filtros Leung-Malik](https://www.robots.ox.ac.uk/~vgg/research/texclass/filters.html)
> Imagen del [Banco de Filtros de Leung-Malik](https://www.robots.ox.ac.uk/~vgg/research/texclass/filters.html)
Sin embargo, aunque podemos diseñar los filtros para extraer algunos patrones manualmente, también podemos diseñar la red de tal manera que aprenda los patrones automáticamente. Esta es una de las ideas principales detrás de la CNN.
Sin embargo, aunque podemos diseñar manualmente los filtros para extraer algunos patrones, también podemos diseñar la red de tal manera que aprenda los patrones automáticamente. Esta es una de las ideas principales detrás de las CNN.
## Ideas principales detrás de la CNN
## Ideas principales detrás de las CNN
La forma en que funcionan las CNN se basa en las siguientes ideas importantes:
El funcionamiento de las CNN se basa en las siguientes ideas importantes:
* Los filtros convolucionales pueden extraer patrones
* Podemos diseñar la red de tal manera que los filtros se entrenen automáticamente
* Podemos utilizar el mismo enfoque para encontrar patrones en características de alto nivel, no solo en la imagen original. Así, la extracción de características de la CNN trabaja en una jerarquía de características, comenzando desde combinaciones de píxeles de bajo nivel, hasta combinaciones de partes de la imagen de nivel superior.
* Los filtros convolucionales pueden extraer patrones.
* Podemos diseñar la red de tal manera que los filtros se entrenen automáticamente.
* Podemos usar el mismo enfoque para encontrar patrones en características de alto nivel, no solo en la imagen original. Así, la extracción de características en las CNN funciona en una jerarquía de características, comenzando con combinaciones de píxeles de bajo nivel hasta combinaciones de partes de la imagen de nivel superior.
![Extracción de Características Jerárquicas](../../../../../translated_images/FeatureExtractionCNN.d9b456cbdae7cb643fde3032b81b2940e3cf8be842e29afac3f482725ba7f95c.es.png)
![Extracción jerárquica de características](../../../../../lessons/4-ComputerVision/07-ConvNets/images/FeatureExtractionCNN.png)
> Imagen de [un artículo de Hislop-Lynch](https://www.semanticscholar.org/paper/Computer-vision-based-pedestrian-trajectory-Hislop-Lynch/26e6f74853fc9bbb7487b06dc2cf095d36c9021d), basado en [su investigación](https://dl.acm.org/doi/abs/10.1145/1553374.1553453)
## ✍️ Ejercicios: Redes Neuronales Convolucionales
Continuemos explorando cómo funcionan las redes neuronales convolucionales, y cómo podemos lograr filtros entrenables, trabajando a través de los cuadernos correspondientes:
Continuemos explorando cómo funcionan las redes neuronales convolucionales y cómo podemos lograr filtros entrenables trabajando con los cuadernos correspondientes:
* [Redes Neuronales Convolucionales - PyTorch](../../../../../lessons/4-ComputerVision/07-ConvNets/ConvNetsPyTorch.ipynb)
* [Redes Neuronales Convolucionales - TensorFlow](../../../../../lessons/4-ComputerVision/07-ConvNets/ConvNetsTF.ipynb)
## Arquitectura Piramidal
La mayoría de las CNN utilizadas para el procesamiento de imágenes siguen una arquitectura piramidal. La primera capa convolucional aplicada a las imágenes originales típicamente tiene un número relativamente bajo de filtros (8-16), que corresponden a diferentes combinaciones de píxeles, como líneas de trazos horizontales/verticales. En el siguiente nivel, reducimos la dimensión espacial de la red, y aumentamos el número de filtros, lo que corresponde a más posibles combinaciones de características simples. Con cada capa, a medida que avanzamos hacia el clasificador final, las dimensiones espaciales de la imagen disminuyen, y el número de filtros aumenta.
La mayoría de las CNN utilizadas para el procesamiento de imágenes siguen una arquitectura llamada piramidal. La primera capa convolucional aplicada a las imágenes originales generalmente tiene un número relativamente bajo de filtros (8-16), que corresponden a diferentes combinaciones de píxeles, como líneas horizontales o verticales. En el siguiente nivel, reducimos la dimensión espacial de la red y aumentamos el número de filtros, lo que corresponde a más combinaciones posibles de características simples. Con cada capa, a medida que nos acercamos al clasificador final, las dimensiones espaciales de la imagen disminuyen y el número de filtros aumenta.
Como ejemplo, veamos la arquitectura de VGG-16, una red que logró una precisión del 92.7% en la clasificación top-5 de ImageNet en 2014:
Como ejemplo, veamos la arquitectura de VGG-16, una red que logró un 92.7% de precisión en la clasificación top-5 de ImageNet en 2014:
![Capas de ImageNet](../../../../../translated_images/vgg-16-arch1.d901a5583b3a51baeaab3e768567d921e5d54befa46e1e642616c5458c934028.es.jpg)
![Capas de ImageNet](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch1.jpg)
![Pirámide de ImageNet](../../../../../translated_images/vgg-16-arch.64ff2137f50dd49fdaa786e3f3a975b3f22615efd13efb19c5d22f12e01451a1.es.jpg)
![Pirámide de ImageNet](../../../../../lessons/4-ComputerVision/07-ConvNets/images/vgg-16-arch.jpg)
> Imagen de [Researchgate](https://www.researchgate.net/figure/Vgg16-model-structure-To-get-the-VGG-NIN-model-we-replace-the-2-nd-4-th-6-th-7-th_fig2_335194493)
## Arquitecturas de CNN Más Conocidas
## Arquitecturas de CNN más conocidas
[Continúa tu estudio sobre las arquitecturas de CNN más conocidas](CNN_Architectures.md)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

27
translations/es/lessons/4-ComputerVision/07-ConvNets/lab/README.md
View File

@ -1,20 +1,29 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f3d2cee9cb3c52160419e560c57a690e",
"translation_date": "2025-08-24T09:18:20+00:00",
"source_file": "lessons/4-ComputerVision/07-ConvNets/lab/README.md",
"language_code": "es"
}
-->
# Clasificación de Caras de Mascotas
Tarea del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
Asignación de laboratorio del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
## Tarea
Imagina que necesitas desarrollar una aplicación para una guardería de mascotas para catalogar todas las mascotas. Una de las grandes características de tal aplicación sería descubrir automáticamente la raza a partir de una fotografía. Esto se puede hacer con éxito utilizando redes neuronales.
Imagina que necesitas desarrollar una aplicación para una guardería de mascotas para catalogar a todas las mascotas. Una de las grandes características de dicha aplicación sería descubrir automáticamente la raza a partir de una fotografía. Esto se puede lograr con éxito utilizando redes neuronales.
Necesitas entrenar una red neuronal convolucional para clasificar diferentes razas de gatos y perros utilizando el conjunto de datos **Caras de Mascotas**.
Necesitas entrenar una red neuronal convolucional para clasificar diferentes razas de gatos y perros utilizando el conjunto de datos **Pet Faces**.
## El Conjunto de Datos
Usaremos el conjunto de datos **Caras de Mascotas**, derivado del conjunto de datos de mascotas [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/). Contiene 35 razas diferentes de perros y gatos.
Usaremos el conjunto de datos **Pet Faces**, derivado del conjunto de datos de mascotas [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/). Contiene 35 razas diferentes de perros y gatos.
![Conjunto de datos con el que trabajaremos](../../../../../../translated_images/data.50b2a9d5484bdbf0f52f5765b381cec9efe2bd296a98f007f90bedb6ac67f2a8.es.png)
![Conjunto de datos con el que trabajaremos](../../../../../../lessons/4-ComputerVision/07-ConvNets/lab/images/data.png)
Para descargar el conjunto de datos, usa este fragmento de código:
Para descargar el conjunto de datos, utiliza este fragmento de código:
```python
!wget https://mslearntensorflowlp.blob.core.windows.net/data/petfaces.tar.gz
@ -22,13 +31,13 @@ Para descargar el conjunto de datos, usa este fragmento de código:
!rm petfaces.tar.gz
```
## Iniciando el Notebook
## Cuaderno Inicial
Comienza el laboratorio abriendo [PetFaces.ipynb](../../../../../../lessons/4-ComputerVision/07-ConvNets/lab/PetFaces.ipynb)
## Conclusión
¡Has resuelto un problema relativamente complejo de clasificación de imágenes desde cero! Hubo muchas clases, ¡y aún así lograste obtener una precisión razonable! También tiene sentido medir la precisión top-k, porque es fácil confundir algunas de las clases que no son claramente diferentes incluso para los seres humanos.
¡Has resuelto un problema relativamente complejo de clasificación de imágenes desde cero! Había bastantes clases, y aun así lograste obtener una precisión razonable. También tiene sentido medir la precisión top-k, porque es fácil confundir algunas de las clases que no son claramente diferentes, incluso para los seres humanos.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr la 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 la traducción profesional realizada por humanos. No somos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

74
translations/es/lessons/4-ComputerVision/08-TransferLearning/README.md
View File

@ -1,26 +1,35 @@
# Redes Neuronales Pre-entrenadas y Aprendizaje por Transferencia
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "717775c4050ccbffbe0c961ad8bf7bf7",
"translation_date": "2025-08-24T09:19:02+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/README.md",
"language_code": "es"
}
-->
# Redes Pre-entrenadas y Aprendizaje por Transferencia
Entrenar CNNs puede llevar mucho tiempo, y se requiere una gran cantidad de datos para esa tarea. Sin embargo, gran parte del tiempo se dedica a aprender los mejores filtros de bajo nivel que una red puede utilizar 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 necesidad de un proceso de entrenamiento completo?
Entrenar redes neuronales convolucionales (CNN) puede llevar mucho tiempo y requiere una gran cantidad de datos. Sin embargo, gran parte del tiempo se invierte en aprender los mejores filtros de bajo nivel que una red puede usar 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 necesidad de un proceso de entrenamiento completo?
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/108)
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/108)
Este enfoque se llama **aprendizaje por transferencia**, porque transferimos parte del conocimiento de un modelo de red neuronal a otro. En el aprendizaje por transferencia, normalmente comenzamos con un modelo pre-entrenado, que ha sido entrenado en un gran conjunto de datos de imágenes, como **ImageNet**. Esos modelos ya pueden hacer 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 un buen resultado.
Este enfoque se llama **aprendizaje por transferencia**, porque transferimos conocimiento de un modelo de red neuronal a otro. En el aprendizaje por transferencia, normalmente comenzamos con un modelo pre-entrenado, que ha sido entrenado en un gran conjunto de datos de imágenes, como **ImageNet**. Estos modelos ya son buenos 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.
> ✅ El Aprendizaje por Transferencia es un término que se encuentra en otros campos académicos, como la Educación. Se refiere al proceso de tomar conocimiento de un dominio y aplicarlo a otro.
> ✅ El Aprendizaje por Transferencia es un término que también se encuentra en otros campos académicos, como la Educación. Se refiere al proceso de tomar conocimiento de un dominio y aplicarlo en otro.
## Modelos Pre-entrenados como Extractores de Características
Las redes convolucionales de las que hemos hablado en la sección anterior contenían una serie de capas, cada una de las cuales se supone que extrae algunas características de la imagen, comenzando desde combinaciones de píxeles de bajo nivel (como líneas horizontales/verticales o trazos), hasta combinaciones de características de nivel superior, que corresponden a cosas como el ojo de una llama. Si entrenamos una CNN en un conjunto de datos suficientemente grande de imágenes genéricas y diversas, la red debería aprender a extraer esas características comunes.
Las redes convolucionales de las que hablamos en la sección anterior contienen varias capas, cada una de las cuales está diseñada para extraer características de la imagen, comenzando con combinaciones de píxeles de bajo nivel (como líneas horizontales/verticales o trazos), hasta combinaciones de características de nivel superior, como un ojo o una llama. Si entrenamos una CNN en un conjunto de datos suficientemente grande y diverso, la red debería aprender a extraer esas características comunes.
Tanto Keras como PyTorch contienen funciones para cargar fácilmente los pesos de redes neuronales pre-entrenadas para algunas arquitecturas comunes, la mayoría de las cuales fueron entrenadas en imágenes de ImageNet. Las más utilizadas se describen en la página de [Arquitecturas CNN](../07-ConvNets/CNN_Architectures.md) de la lección anterior. En particular, es posible que desees considerar el uso de uno de los siguientes:
Tanto Keras como PyTorch contienen funciones para cargar fácilmente pesos de redes neuronales pre-entrenadas para algunas arquitecturas comunes, la mayoría de las cuales fueron entrenadas en imágenes de ImageNet. Las más utilizadas se describen en la página [Arquitecturas de CNN](../07-ConvNets/CNN_Architectures.md) de la lección anterior. En particular, podrías considerar usar una de las siguientes:
* **VGG-16/VGG-19**, que son modelos relativamente simples que aún ofrecen buena precisión. A menudo, usar VGG como primer intento es una buena elección para ver cómo funciona el aprendizaje por transferencia.
* **ResNet** es una familia de modelos propuestos por Microsoft Research en 2015. Tienen más capas y, por lo tanto, requieren más recursos.
* **MobileNet** es una familia de modelos de tamaño reducido, adecuados para dispositivos móviles. Úsalos si tienes recursos limitados y puedes sacrificar un poco de precisión.
* **VGG-16/VGG-19**, que son modelos relativamente simples pero con buena precisión. Usar VGG como primer intento es una buena opción para ver cómo funciona el aprendizaje por transferencia.
* **ResNet**, una familia de modelos propuesta por Microsoft Research en 2015. Tienen más capas y, por lo tanto, requieren más recursos.
* **MobileNet**, una familia de modelos de tamaño reducido, adecuados para dispositivos móviles. Úsalos si tienes recursos limitados y puedes sacrificar un poco de precisión.
Aquí hay ejemplos de características extraídas de una imagen de un gato por la red VGG-16:
Aquí hay características de ejemplo extraídas de una imagen de un gato por la red VGG-16:
![Características extraídas por VGG-16](../../../../../translated_images/features.6291f9c7ba3a0b951af88fc9864632b9115365410765680680d30c927dd67354.es.png)
![Características extraídas por VGG-16](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/features.png)
## Conjunto de Datos de Gatos vs. Perros
@ -28,53 +37,54 @@ En este ejemplo, utilizaremos un conjunto de datos de [Gatos y Perros](https://w
## ✍️ Ejercicio: Aprendizaje por Transferencia
Veamos el aprendizaje por transferencia en acción en los siguientes cuadernos:
Veamos el aprendizaje por transferencia en acción en los notebooks correspondientes:
* [Aprendizaje por Transferencia - PyTorch](../../../../../lessons/4-ComputerVision/08-TransferLearning/TransferLearningPyTorch.ipynb)
* [Aprendizaje por Transferencia - TensorFlow](../../../../../lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb)
## Visualizando el Gato Adversarial
## Visualizando un Gato Adversarial
Una red neuronal pre-entrenada contiene diferentes patrones dentro de su *cerebro*, incluyendo nociones de **gato ideal** (así como perro ideal, cebra ideal, etc.). Sería interesante de alguna manera **visualizar esta imagen**. Sin embargo, no es sencillo, porque los patrones están distribuidos por todos los pesos de la red y también organizados en una estructura jerárquica.
Una red neuronal pre-entrenada contiene diferentes patrones en su *cerebro*, incluyendo nociones de un **gato ideal** (así como un perro ideal, una cebra ideal, etc.). Sería interesante de alguna manera **visualizar esta imagen**. Sin embargo, no es sencillo, porque los patrones están distribuidos por todos los pesos de la red y organizados en una estructura jerárquica.
Un enfoque que podemos tomar es comenzar con una imagen aleatoria y luego intentar usar la técnica de **optimización por descenso de gradiente** para ajustar esa imagen de tal manera que la red comience a pensar que es un gato.
Un enfoque que podemos tomar es comenzar con una imagen aleatoria y luego usar la técnica de **optimización por descenso de gradiente** para ajustar esa imagen de tal manera que la red comience a pensar que es un gato.
![Bucle de Optimización de Imagen](../../../../../translated_images/ideal-cat-loop.999fbb8ff306e044f997032f4eef9152b453e6a990e449bbfb107de2493cc37e.es.png)
![Bucle de Optimización de Imagen](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/ideal-cat-loop.png)
Sin embargo, si hacemos esto, obtendremos algo muy similar a un ruido aleatorio. Esto se debe a que *hay muchas formas de hacer que la red piense que la imagen de entrada es un gato*, incluyendo algunas que no tienen sentido visualmente. Aunque esas imágenes contienen muchos patrones típicos de un gato, no hay nada que las restrinja a ser visualmente distintivas.
Sin embargo, si hacemos esto, obtendremos algo muy similar a un ruido aleatorio. Esto se debe a que *hay muchas formas de hacer que la red piense que la imagen de entrada es un gato*, incluidas algunas que no tienen sentido visualmente. Aunque esas imágenes contienen muchos patrones típicos de un gato, no hay nada que las obligue a ser visualmente distintivas.
Para mejorar el resultado, podemos agregar otro término a la función de pérdida, que se llama **pérdida de variación**. Es una métrica que muestra cuán similares son los píxeles vecinos de la imagen. Minimizar la pérdida de variación hace que la imagen sea más suave y elimina el ruido, revelando así patrones más visualmente atractivos. Aquí hay un ejemplo de tales imágenes "ideales", que son clasificadas como gato y como cebra con alta probabilidad:
Para mejorar el resultado, podemos agregar otro término a la función de pérdida, llamado **pérdida de variación**. Es una métrica que muestra cuán similares son los píxeles vecinos de la imagen. Minimizar la pérdida de variación hace que la imagen sea más suave y elimina el ruido, revelando así patrones más atractivos visualmente. Aquí hay un ejemplo de tales imágenes "ideales", clasificadas como gato y como cebra con alta probabilidad:
![Gato Ideal](../../../../../translated_images/ideal-cat.203dd4597643d6b0bd73038b87f9c0464322725e3a06ab145d25d4a861c70592.es.png) | ![Cebra Ideal](../../../../../translated_images/ideal-zebra.7f70e8b54ee15a7a314000bb5df38a6cfe086ea04d60df4d3ef313d046b98a2b.es.png)
![Gato Ideal](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/ideal-cat.png) | ![Cebra Ideal](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/ideal-zebra.png)
-----|-----
*Gato Ideal* | *Cebra Ideal*
*Gato Ideal* | *Cebra Ideal*
Un enfoque similar puede utilizarse para realizar lo que se llama **ataques adversariales** en una red neuronal. Supongamos que queremos engañar a una red neuronal y hacer que un perro se vea como un gato. Si tomamos la imagen de un perro, que es reconocida por una red como un perro, podemos ajustarla un poco usando optimización por descenso de gradiente, hasta que la red comience a clasificarla como un gato:
Un enfoque similar puede usarse para realizar los llamados **ataques adversariales** en una red neuronal. Supongamos que queremos engañar a una red neuronal y hacer que un perro parezca un gato. Si tomamos la imagen de un perro, que la red reconoce como un perro, podemos modificarla un poco usando optimización por descenso de gradiente, hasta que la red comience a clasificarla como un gato:
![Imagen de un Perro](../../../../../translated_images/original-dog.8f68a67d2fe0911f33041c0f7fce8aa4ea919f9d3917ec4b468298522aeb6356.es.png) | ![Imagen de un perro clasificado como gato](../../../../../translated_images/adversarial-dog.d9fc7773b0142b89752539bfbf884118de845b3851c5162146ea0b8809fc820f.es.png)
![Imagen de un Perro](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/original-dog.png) | ![Imagen de un perro clasificado como un gato](../../../../../lessons/4-ComputerVision/08-TransferLearning/images/adversarial-dog.png)
-----|-----
*Imagen original de un perro* | *Imagen de un perro clasificado como gato*
*Imagen original de un perro* | *Imagen de un perro clasificado como un gato*
Consulta el código para reproducir los resultados anteriores en el siguiente cuaderno:
Consulta el código para reproducir los resultados anteriores en el siguiente notebook:
* [Gato Ideal y Adversarial - TensorFlow](../../../../../lessons/4-ComputerVision/08-TransferLearning/AdversarialCat_TF.ipynb)
## Conclusión
Usando el aprendizaje por transferencia, puedes rápidamente armar un clasificador para una tarea de clasificación de objetos personalizada y lograr alta precisión. Puedes ver 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 liviana para entrenar el mismo modelo utilizando recursos computacionales más bajos, lo que resulta en una precisión ligeramente inferior.
Usando el aprendizaje por transferencia, puedes armar rápidamente un clasificador para una tarea de clasificación de objetos personalizada y lograr alta precisión. Puedes ver que las tareas más complejas que estamos resolviendo ahora requieren mayor potencia 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 ligeramente menor.
## 🚀 Desafío
En los cuadernos adjuntos, hay notas al final sobre cómo el transferir conocimiento funciona mejor con datos de entrenamiento algo similares (quizás un nuevo tipo de animal). Realiza algunos experimentos con tipos de imágenes completamente nuevos para ver qué tan bien o mal funcionan tus modelos de transferencia de conocimiento.
En los notebooks adjuntos, hay notas al final sobre cómo el conocimiento transferido funciona mejor con datos de entrenamiento algo similares (quizás un nuevo tipo de animal). Realiza experimentos con tipos completamente nuevos de imágenes para ver qué tan bien o mal funcionan tus modelos de conocimiento transferido.
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## Revisión y Autoestudio
Lee [TrainingTricks.md](TrainingTricks.md) para profundizar tu conocimiento sobre algunas otras formas de entrenar tus modelos.
Lee [TrainingTricks.md](TrainingTricks.md) para profundizar tu conocimiento sobre otras formas de entrenar tus modelos.
## [Tarea](lab/README.md)
## [Asignación](lab/README.md)
En este laboratorio, utilizaremos un conjunto de datos de mascotas de la vida real [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) con 35 razas de gatos y perros, y construiremos un clasificador de aprendizaje por transferencia.
En este laboratorio, utilizaremos el conjunto de datos real [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) de mascotas con 35 razas de gatos y perros, y construiremos un clasificador de aprendizaje por transferencia.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de ningún malentendido o mala interpretación que surja del uso de esta traducción.
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 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.

91
translations/es/lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md
View File

@ -1,108 +1,117 @@
# Trucos de Entrenamiento en Aprendizaje Profundo
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "ae074cd940fc2f4dc24fc07b66ccbd99",
"translation_date": "2025-08-24T09:19:25+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
"language_code": "es"
}
-->
# Trucos para el Entrenamiento de Redes Neuronales Profundas
A medida que las redes neuronales se vuelven más profundas, el proceso de su entrenamiento se vuelve cada vez más desafiante. Un problema importante es el llamado [gradientes que se desvanecen](https://en.wikipedia.org/wiki/Vanishing_gradient_problem) o [gradientes que explotan](https://deepai.org/machine-learning-glossary-and-terms/exploding-gradient-problem#:~:text=Exploding%20gradients%20are%20a%20problem,updates%20are%20small%20and%20controlled.). [Esta publicación](https://towardsdatascience.com/the-vanishing-exploding-gradient-problem-in-deep-neural-networks-191358470c11) ofrece una buena introducción a estos problemas.
A medida que las redes neuronales se vuelven más profundas, el proceso de entrenamiento se vuelve cada vez más desafiante. Uno de los principales problemas son los llamados [gradientes que desaparecen](https://en.wikipedia.org/wiki/Vanishing_gradient_problem) o [gradientes que explotan](https://deepai.org/machine-learning-glossary-and-terms/exploding-gradient-problem#:~:text=Exploding%20gradients%20are%20a%20problem,updates%20are%20small%20and%20controlled.). [Este artículo](https://towardsdatascience.com/the-vanishing-exploding-gradient-problem-in-deep-neural-networks-191358470c11) ofrece una buena introducción a estos problemas.
Para hacer que el entrenamiento de redes profundas sea más eficiente, se pueden utilizar algunas técnicas.
## Manteniendo valores en un intervalo razonable
## Mantener los valores en un intervalo razonable
Para hacer que los cálculos numéricos sean más estables, queremos asegurarnos de que todos los valores dentro de nuestra red neuronal estén en una escala razonable, típicamente [-1..1] o [0..1]. No es un requisito muy estricto, pero la naturaleza de los cálculos en punto flotante es tal que los valores de diferentes magnitudes no pueden ser manipulados con precisión juntos. Por ejemplo, si sumamos 10<sup>-10</sup> y 10<sup>10</sup>, probablemente obtendremos 10<sup>10</sup>, porque el valor más pequeño se "convertiría" al mismo orden que el mayor, y así se perdería la mantisa.
Para que los cálculos numéricos sean más estables, queremos asegurarnos de que todos los valores dentro de nuestra red neuronal estén en una escala razonable, típicamente [-1..1] o [0..1]. No es un requisito muy estricto, pero la naturaleza de los cálculos en punto flotante es tal que los valores de diferentes magnitudes no pueden manipularse con precisión juntos. Por ejemplo, si sumamos 10<sup>-10</sup> y 10<sup>10</sup>, es probable que obtengamos 10<sup>10</sup>, porque el valor más pequeño se "convertirá" al mismo orden que el más grande, y así se perderá la mantisa.
La mayoría de las funciones de activación tienen no linealidades alrededor de [-1..1], por lo que tiene sentido escalar todos los datos de entrada al intervalo [-1..1] o [0..1].
## Inicialización de Pesos Inicial
## Inicialización de Pesos
Idealmente, queremos que los valores estén en el mismo rango después de pasar a través de las capas de la red. Por lo tanto, es importante inicializar los pesos de tal manera que se preserve la distribución de valores.
Idealmente, queremos que los valores estén en el mismo rango después de pasar por las capas de la red. Por lo tanto, es importante inicializar los pesos de manera que se preserve la distribución de los valores.
La distribución normal **N(0,1)** no es una buena idea, porque si tenemos *n* entradas, la desviación estándar de la salida sería *n*, y los valores probablemente saldrían del intervalo [0..1].
La distribución normal **N(0,1)** no es una buena idea, porque si tenemos *n* entradas, la desviación estándar de la salida sería *n*, y los valores probablemente saldrán del intervalo [0..1].
Las siguientes inicializaciones son a menudo utilizadas:
Las siguientes inicializaciones se usan con frecuencia:
* Distribución uniforme -- `uniform`
* **N(0,1/n)** -- `gaussian`
* **N(0,1/√n_in)** garantiza que para entradas con media cero y desviación estándar de 1, la misma media/desviación estándar se mantendrá
* **N(0,√2/(n_in+n_out))** -- la llamada **inicialización de Xavier** (`glorot`), ayuda a mantener las señales en rango durante la propagación hacia adelante y hacia atrás
* **N(0,1/√n_in)** garantiza que para entradas con media cero y desviación estándar de 1, se mantendrán la misma media y desviación estándar
* **N(0,√2/(n_in+n_out))** -- la llamada **inicialización de Xavier** (`glorot`), ayuda a mantener las señales en rango tanto en la propagación hacia adelante como hacia atrás
## Normalización por Lotes
Incluso con una correcta inicialización de pesos, estos pueden volverse arbitrariamente grandes o pequeños durante el entrenamiento, y traerán señales fuera del rango adecuado. Podemos devolver las señales utilizando una de las técnicas de **normalización**. Aunque hay varias de ellas (Normalización de peso, Normalización de capa), la más utilizada es la Normalización por lotes.
Incluso con una inicialización adecuada de los pesos, estos pueden volverse arbitrariamente grandes o pequeños durante el entrenamiento, sacando las señales del rango adecuado. Podemos devolver las señales al rango correcto utilizando una de las técnicas de **normalización**. Aunque existen varias (normalización de pesos, normalización por capas), la más utilizada es la Normalización por Lotes.
La idea de la **normalización por lotes** es tener en cuenta todos los valores a través del minibatch, y realizar la normalización (es decir, restar la media y dividir por la desviación estándar) en función de esos valores. Se implementa como una capa de red que realiza esta normalización después de aplicar los pesos, pero antes de la función de activación. Como resultado, es probable que veamos una mayor precisión final y un entrenamiento más rápido.
La idea de la **normalización por lotes** es tener en cuenta todos los valores dentro del minibatch y realizar una normalización (es decir, restar la media y dividir por la desviación estándar) basada en esos valores. Se implementa como una capa de red que realiza esta normalización después de aplicar los pesos, pero antes de la función de activación. Como resultado, es probable que veamos una mayor precisión final y un entrenamiento más rápido.
Aquí está el [artículo original](https://arxiv.org/pdf/1502.03167.pdf) sobre la normalización por lotes, la [explicación en Wikipedia](https://en.wikipedia.org/wiki/Batch_normalization), y [una buena publicación introductoria en un blog](https://towardsdatascience.com/batch-normalization-in-3-levels-of-understanding-14c2da90a338) (y una [en ruso](https://habrahabr.ru/post/309302/)).
Aquí está el [artículo original](https://arxiv.org/pdf/1502.03167.pdf) sobre normalización por lotes, la [explicación en Wikipedia](https://en.wikipedia.org/wiki/Batch_normalization) y [un buen artículo introductorio](https://towardsdatascience.com/batch-normalization-in-3-levels-of-understanding-14c2da90a338) (y otro [en ruso](https://habrahabr.ru/post/309302/)).
## Dropout
**Dropout** es una técnica interesante que elimina un cierto porcentaje de neuronas aleatorias durante el entrenamiento. También se implementa como una capa con un parámetro (porcentaje de neuronas a eliminar, típicamente del 10% al 50%), y durante el entrenamiento, pone a cero elementos aleatorios del vector de entrada, antes de pasarlo a la siguiente capa.
**Dropout** es una técnica interesante que elimina un cierto porcentaje de neuronas aleatorias durante el entrenamiento. También se implementa como una capa con un parámetro (porcentaje de neuronas a eliminar, típicamente 10%-50%), y durante el entrenamiento pone en cero elementos aleatorios del vector de entrada antes de pasarlo a la siguiente capa.
Aunque esto puede sonar como una idea extraña, puedes ver el efecto de dropout en el entrenamiento de un clasificador de dígitos MNIST en el cuaderno [`Dropout.ipynb`](../../../../../lessons/4-ComputerVision/08-TransferLearning/Dropout.ipynb). Acelera el entrenamiento y nos permite lograr una mayor precisión en menos épocas de entrenamiento.
Aunque esto pueda sonar como una idea extraña, puedes ver el efecto del dropout al entrenar un clasificador de dígitos MNIST en el notebook [`Dropout.ipynb`](../../../../../lessons/4-ComputerVision/08-TransferLearning/Dropout.ipynb). Acelera el entrenamiento y nos permite lograr mayor precisión en menos épocas de entrenamiento.
Este efecto puede explicarse de varias maneras:
* Puede considerarse un factor de choque aleatorio para el modelo, que saca la optimización del mínimo local
* Puede considerarse como *promedio implícito del modelo*, porque podemos decir que durante el dropout estamos entrenando un modelo ligeramente diferente
* Puede considerarse como un factor de choque aleatorio para el modelo, que lo saca de mínimos locales
* Puede considerarse como un *promedio implícito de modelos*, ya que durante el dropout estamos entrenando un modelo ligeramente diferente
> *Algunas personas dicen que cuando una persona borracha intenta aprender algo, lo recordará mejor a la mañana siguiente, en comparación con una persona sobria, porque un cerebro con algunos neuronas malfuncionantes intenta adaptarse mejor para captar el significado. Nunca hemos probado si esto es cierto o no*
> *Algunas personas dicen que cuando una persona ebria intenta aprender algo, lo recordará mejor a la mañana siguiente, en comparación con una persona sobria, porque un cerebro con algunas neuronas disfuncionales intenta adaptarse mejor para captar el significado. Nunca hemos probado si esto es cierto o no.*
## Previniendo el sobreajuste
## Prevención del sobreajuste
Uno de los aspectos muy importantes del aprendizaje profundo es poder prevenir el [sobreajuste](../../3-NeuralNetworks/05-Frameworks/Overfitting.md). Aunque puede ser tentador usar un modelo de red neuronal muy poderoso, siempre debemos equilibrar el número de parámetros del modelo con el número de muestras de entrenamiento.
Uno de los aspectos más importantes del aprendizaje profundo es poder prevenir el [sobreajuste](../../3-NeuralNetworks/05-Frameworks/Overfitting.md). Aunque puede ser tentador usar un modelo de red neuronal muy potente, siempre debemos equilibrar el número de parámetros del modelo con el número de muestras de entrenamiento.
> ¡Asegúrate de entender el concepto de [sobreajuste](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) que hemos introducido anteriormente!
> Asegúrate de entender el concepto de [sobreajuste](../../3-NeuralNetworks/05-Frameworks/Overfitting.md) que hemos introducido anteriormente.
Hay varias formas de prevenir el sobreajuste:
* Parada temprana -- monitorear continuamente el error en el conjunto de validación y detener el entrenamiento cuando el error de validación comienza a aumentar.
* Decaimiento de peso explícito / Regularización -- agregar una penalización extra a la función de pérdida por valores absolutos altos de los pesos, lo que evita que el modelo obtenga resultados muy inestables
* Detención temprana -- monitorear continuamente el error en el conjunto de validación y detener el entrenamiento cuando el error de validación comience a aumentar.
* Decaimiento explícito de pesos / Regularización -- agregar una penalización extra a la función de pérdida para valores absolutos altos de los pesos, lo que evita que el modelo obtenga resultados muy inestables
* Promedio de modelos -- entrenar varios modelos y luego promediar el resultado. Esto ayuda a minimizar la varianza.
* Dropout (Promedio implícito del modelo)
* Dropout (Promedio implícito de modelos)
## Optimizadores / Algoritmos de Entrenamiento
Otro aspecto importante del entrenamiento es elegir un buen algoritmo de entrenamiento. Aunque el **descenso de gradiente** clásico es una elección razonable, a veces puede ser demasiado lento o resultar en otros problemas.
Otro aspecto importante del entrenamiento es elegir un buen algoritmo de entrenamiento. Aunque el **descenso de gradiente clásico** es una elección razonable, a veces puede ser demasiado lento o causar otros problemas.
En el aprendizaje profundo, utilizamos **Descenso de Gradiente Estocástico** (SGD), que es un descenso de gradiente aplicado a minibatches, seleccionados aleatoriamente del conjunto de entrenamiento. Los pesos se ajustan utilizando esta fórmula:
En aprendizaje profundo, usamos **Descenso de Gradiente Estocástico** (SGD), que es un descenso de gradiente aplicado a minibatches seleccionados aleatoriamente del conjunto de entrenamiento. Los pesos se ajustan usando esta fórmula:
w<sup>t+1</sup> = w<sup>t</sup> - η∇ℒ
### Momento
### Momentum
En **SGD con momento**, mantenemos una porción de un gradiente de pasos anteriores. Es similar a cuando nos movemos con inercia, y recibimos un golpe en una dirección diferente; nuestra trayectoria no cambia de inmediato, sino que mantiene parte del movimiento original. Aquí introducimos otro vector v para representar la *velocidad*:
En el **SGD con momentum**, mantenemos una porción del gradiente de pasos anteriores. Es similar a cuando nos movemos con inercia y recibimos un golpe en una dirección diferente; nuestra trayectoria no cambia inmediatamente, sino que conserva parte del movimiento original. Aquí introducimos otro vector v para representar la *velocidad*:
* v<sup>t+1</sup> = γ v<sup>t</sup> - η∇ℒ
* w<sup>t+1</sup> = w<sup>t</sup>+v<sup>t+1</sup>
Aquí, el parámetro γ indica el grado en que tomamos en cuenta la inercia: γ=0 corresponde al SGD clásico; γ=1 es una ecuación de movimiento puro.
El parámetro γ indica hasta qué punto tomamos en cuenta la inercia: γ=0 corresponde al SGD clásico; γ=1 es una ecuación de movimiento puro.
### Adam, Adagrad, etc.
Dado que en cada capa multiplicamos señales por alguna matriz W<sub>i</sub>, dependiendo de ||W<sub>i</sub>||, el gradiente puede disminuir y acercarse a 0, o aumentar indefinidamente. Esta es la esencia del problema de los Gradientes que Explotan/Desvanecen.
Dado que en cada capa multiplicamos señales por alguna matriz W<sub>i</sub>, dependiendo de ||W<sub>i</sub>||, el gradiente puede disminuir y acercarse a 0, o aumentar indefinidamente. Este es el núcleo del problema de Gradientes que Desaparecen/Explotan.
Una de las soluciones a este problema es usar solo la dirección del gradiente en la ecuación, e ignorar el valor absoluto, es decir,
Una de las soluciones a este problema es usar solo la dirección del gradiente en la ecuación e ignorar el valor absoluto, es decir:
w<sup>t+1</sup> = w<sup>t</sup> - η(∇ℒ/||∇ℒ||), donde ||∇ℒ|| = √∑(∇ℒ)<sup>2</sup>
Este algoritmo se llama **Adagrad**. Otros algoritmos que utilizan la misma idea son: **RMSProp**, **Adam**
Este algoritmo se llama **Adagrad**. Otros algoritmos que usan la misma idea: **RMSProp**, **Adam**
> **Adam** se considera un algoritmo muy eficiente para muchas aplicaciones, así que si no estás seguro de cuál usar, utiliza Adam.
### Recorte de Gradiente
### Recorte de gradientes
El recorte de gradiente es una extensión de la idea anterior. Cuando ||∇ℒ|| ≤ θ, consideramos el gradiente original en la optimización de pesos, y cuando ||∇ℒ|| > θ - dividimos el gradiente por su norma. Aquí θ es un parámetro, en la mayoría de los casos podemos tomar θ=1 o θ=10.
El recorte de gradientes es una extensión de la idea anterior. Cuando ||∇ℒ|| ≤ θ, consideramos el gradiente original en la optimización de pesos, y cuando ||∇ℒ|| > θ, dividimos el gradiente por su norma. Aquí θ es un parámetro; en la mayoría de los casos podemos tomar θ=1 o θ=10.
### Decaimiento de la tasa de aprendizaje
El éxito del entrenamiento a menudo depende del parámetro de tasa de aprendizaje η. Es lógico suponer que valores más grandes de η resultan en un entrenamiento más rápido, que es algo que normalmente queremos al principio del entrenamiento, y luego un valor más pequeño de η nos permite afinar la red. Por lo tanto, en la mayoría de los casos queremos disminuir η en el proceso del entrenamiento.
El éxito del entrenamiento a menudo depende del parámetro de tasa de aprendizaje η. Es lógico asumir que valores más grandes de η resultan en un entrenamiento más rápido, algo que típicamente queremos al inicio del entrenamiento, y luego valores más pequeños de η nos permiten ajustar finamente la red. Por lo tanto, en la mayoría de los casos queremos disminuir η durante el proceso de entrenamiento.
Esto se puede hacer multiplicando η por algún número (por ejemplo, 0.98) después de cada época de entrenamiento, o utilizando un **programa de tasa de aprendizaje** más complicado.
Esto puede hacerse multiplicando η por algún número (por ejemplo, 0.98) después de cada época de entrenamiento, o utilizando un **programa de tasa de aprendizaje** más complicado.
## Diferentes Arquitecturas de Red
## Diferentes Arquitecturas de Redes
Seleccionar la arquitectura de red adecuada para tu problema puede ser complicado. Normalmente, elegiríamos una arquitectura que ha demostrado funcionar para nuestra tarea específica (o una similar). Aquí hay una [buena visión general](https://www.topbots.com/a-brief-history-of-neural-network-architectures/) de arquitecturas de redes neuronales para visión por computadora.
Seleccionar la arquitectura de red adecuada para tu problema puede ser complicado. Normalmente, tomaríamos una arquitectura que haya demostrado funcionar para nuestra tarea específica (o una similar). Aquí hay una [buena visión general](https://www.topbots.com/a-brief-history-of-neural-network-architectures/) de arquitecturas de redes neuronales para visión por computadora.
> Es importante seleccionar una arquitectura que sea lo suficientemente poderosa para el número de muestras de entrenamiento que tenemos. Seleccionar un modelo demasiado poderoso puede resultar en [sobreajuste](../../3-NeuralNetworks/05-Frameworks/Overfitting.md).
> Es importante seleccionar una arquitectura que sea lo suficientemente potente para el número de muestras de entrenamiento que tenemos. Seleccionar un modelo demasiado potente puede resultar en [sobreajuste](../../3-NeuralNetworks/05-Frameworks/Overfitting.md).
Otra buena forma sería utilizar una arquitectura que se ajuste automáticamente a la complejidad requerida. Hasta cierto punto, la arquitectura **ResNet** y **Inception** son autoajustables. [Más sobre arquitecturas de visión por computadora](../07-ConvNets/CNN_Architectures.md)
Otra buena opción sería usar una arquitectura que se ajuste automáticamente a la complejidad requerida. Hasta cierto punto, las arquitecturas **ResNet** e **Inception** son autoajustables. [Más sobre arquitecturas de visión por computadora](../07-ConvNets/CNN_Architectures.md).
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

21
translations/es/lessons/4-ComputerVision/08-TransferLearning/lab/README.md
View File

@ -1,14 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
"translation_date": "2025-08-24T09:19:55+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/lab/README.md",
"language_code": "es"
}
-->
# Clasificación de Mascotas de Oxford usando Aprendizaje por Transferencia
Tarea del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
Asignación de laboratorio del [Currículo de AI para Principiantes](https://github.com/microsoft/ai-for-beginners).
## Tarea
Imagina que necesitas desarrollar una aplicación para una guardería de mascotas para catalogar todos los animales. Una de las grandes características de tal aplicación sería descubrir automáticamente la raza a partir de una fotografía. En esta tarea, utilizaremos el aprendizaje por transferencia para clasificar imágenes de mascotas de la vida real del conjunto de datos de mascotas [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/).
Imagina que necesitas desarrollar una aplicación para una guardería de mascotas para catalogar a todas las mascotas. Una de las grandes características de dicha aplicación sería identificar automáticamente la raza a partir de una fotografía. En esta asignación, utilizaremos aprendizaje por transferencia para clasificar imágenes reales de mascotas del conjunto de datos de [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/).
## El Conjunto de Datos
Usaremos el conjunto de datos original de mascotas [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/), que contiene 35 razas diferentes de perros y gatos.
Usaremos el conjunto de datos original de [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/), que contiene 35 razas diferentes de perros y gatos.
Para descargar el conjunto de datos, utiliza este fragmento de código:
@ -18,13 +27,13 @@ Para descargar el conjunto de datos, utiliza este fragmento de código:
!rm images.tar.gz
```
## Iniciando el Notebook
## Iniciando el Cuaderno
Comienza el laboratorio abriendo [OxfordPets.ipynb](../../../../../../lessons/4-ComputerVision/08-TransferLearning/lab/OxfordPets.ipynb)
## Conclusión
El aprendizaje por transferencia y las redes preentrenadas nos permiten resolver problemas de clasificación de imágenes del mundo real de manera relativamente sencilla. Sin embargo, las redes preentrenadas funcionan bien con imágenes de tipos similares, y si comenzamos a clasificar imágenes muy diferentes (por ejemplo, imágenes médicas), es probable que obtengamos resultados mucho peores.
El aprendizaje por transferencia y las redes preentrenadas nos permiten resolver problemas reales de clasificación de imágenes de manera relativamente sencilla. Sin embargo, las redes preentrenadas funcionan bien con imágenes de un tipo similar, y si comenzamos a clasificar imágenes muy diferentes (por ejemplo, imágenes médicas), es probable que obtengamos resultados mucho peores.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No somos responsables de ningún malentendido o mala interpretación que surja del uso de esta traducción.
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.

75
translations/es/lessons/4-ComputerVision/09-Autoencoders/README.md
View File

@ -1,77 +1,86 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "0b306c04f5337b6e7430e5c0b16bb5c0",
"translation_date": "2025-08-24T09:15:35+00:00",
"source_file": "lessons/4-ComputerVision/09-Autoencoders/README.md",
"language_code": "es"
}
-->
# Autoencoders
Al entrenar CNNs, uno de los problemas es que necesitamos una gran cantidad de datos etiquetados. En el caso de la clasificación de imágenes, necesitamos separar las imágenes en diferentes clases, lo cual es un esfuerzo manual.
Al entrenar redes neuronales convolucionales (CNNs), uno de los problemas es que necesitamos una gran cantidad de datos etiquetados. En el caso de la clasificación de imágenes, necesitamos separar las imágenes en diferentes clases, lo cual requiere un esfuerzo manual.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/109)
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/109)
Sin embargo, podríamos querer utilizar datos en bruto (no etiquetados) para entrenar extractores de características de CNN, lo que se llama **aprendizaje auto-supervisado**. En lugar de etiquetas, utilizaremos imágenes de entrenamiento como entrada y salida de la red. La idea principal de un **autoencoder** es que tendremos una **red codificadora** que convierte la imagen de entrada en un **espacio latente** (normalmente es solo un vector de un tamaño menor), y luego la **red decodificadora**, cuyo objetivo será reconstruir la imagen original.
Sin embargo, podríamos querer usar datos sin procesar (no etiquetados) para entrenar extractores de características de CNN, lo que se conoce como **aprendizaje auto-supervisado**. En lugar de etiquetas, utilizaremos las imágenes de entrenamiento tanto como entrada como salida de la red. La idea principal de un **autoencoder** es que tendremos una **red codificadora** que convierte la imagen de entrada en algún **espacio latente** (normalmente es solo un vector de menor tamaño), y luego una **red decodificadora**, cuyo objetivo será reconstruir la imagen original.
> ✅ Un [autoencoder](https://wikipedia.org/wiki/Autoencoder) es "un tipo de red neuronal artificial utilizada para aprender codificaciones eficientes de datos no etiquetados."
Dado que estamos entrenando un autoencoder para capturar la mayor cantidad de información de la imagen original posible para una reconstrucción precisa, la red intenta encontrar la mejor **inmersión** de las imágenes de entrada para captar el significado.
Dado que estamos entrenando un autoencoder para capturar la mayor cantidad de información posible de la imagen original para una reconstrucción precisa, la red intenta encontrar la mejor **representación** de las imágenes de entrada para capturar su significado.
![Diagrama de Autoencoder](../../../../../translated_images/autoencoder_schema.5e6fc9ad98a5eb6197f3513cf3baf4dfbe1389a6ae74daebda64de9f1c99f142.es.jpg)
![Diagrama de Autoencoder](../../../../../lessons/4-ComputerVision/09-Autoencoders/images/autoencoder_schema.jpg)
> Imagen de [Keras blog](https://blog.keras.io/building-autoencoders-in-keras.html)
> Imagen del [blog de Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
## Escenarios para usar Autoencoders
Aunque reconstruir imágenes originales no parece útil por sí mismo, hay algunos escenarios donde los autoencoders son especialmente útiles:
* **Reducir la dimensión de las imágenes para visualización** o **entrenar incrustaciones de imágenes**. Generalmente, los autoencoders ofrecen mejores resultados que PCA, porque tienen en cuenta la naturaleza espacial de las imágenes y las características jerárquicas.
* **Eliminación de ruido**, es decir, quitar el ruido de la imagen. Debido a que el ruido contiene mucha información inútil, el autoencoder no puede ajustarlo todo en un espacio latente relativamente pequeño, y así solo captura la parte importante de la imagen. Al entrenar eliminadores de ruido, comenzamos con imágenes originales y usamos imágenes con ruido añadido artificialmente como entrada para el autoencoder.
* **Super-resolución**, aumentando la resolución de la imagen. Comenzamos con imágenes de alta resolución y utilizamos la imagen con menor resolución como entrada del autoencoder.
* **Reducir la dimensión de las imágenes para visualización** o **entrenar representaciones de imágenes**. Generalmente, los autoencoders ofrecen mejores resultados que PCA, porque tienen en cuenta la naturaleza espacial de las imágenes y las características jerárquicas.
* **Eliminación de ruido**, es decir, eliminar el ruido de la imagen. Como el ruido contiene mucha información inútil, el autoencoder no puede ajustarlo todo en un espacio latente relativamente pequeño, y por lo tanto captura solo la parte importante de la imagen. Al entrenar eliminadores de ruido, comenzamos con imágenes originales y usamos imágenes con ruido artificialmente añadido como entrada para el autoencoder.
* **Superresolución**, aumentar la resolución de las imágenes. Comenzamos con imágenes de alta resolución y usamos la imagen con menor resolución como entrada del autoencoder.
* **Modelos generativos**. Una vez que entrenamos el autoencoder, la parte decodificadora puede usarse para crear nuevos objetos a partir de vectores latentes aleatorios.
## Autoencoders Variacionales (VAE)
Los autoencoders tradicionales reducen la dimensión de los datos de entrada de alguna manera, identificando las características importantes de las imágenes de entrada. Sin embargo, los vectores latentes a menudo no tienen mucho sentido. En otras palabras, tomando el conjunto de datos MNIST como ejemplo, averiguar qué dígitos corresponden a diferentes vectores latentes no es una tarea fácil, porque vectores latentes cercanos no necesariamente corresponden a los mismos dígitos.
Los autoencoders tradicionales reducen la dimensión de los datos de entrada de alguna manera, identificando las características importantes de las imágenes de entrada. Sin embargo, los vectores latentes a menudo no tienen mucho sentido. En otras palabras, tomando como ejemplo el conjunto de datos MNIST, identificar qué dígitos corresponden a diferentes vectores latentes no es una tarea sencilla, porque vectores latentes cercanos no necesariamente corresponden a los mismos dígitos.
Por otro lado, para entrenar modelos *generativos*, es mejor tener cierta comprensión del espacio latente. Esta idea nos lleva al **autoencoder variacional** (VAE).
Por otro lado, para entrenar modelos *generativos* es mejor tener cierta comprensión del espacio latente. Esta idea nos lleva al **autoencoder variacional** (VAE).
El VAE es el autoencoder que aprende a predecir la *distribución estadística* de los parámetros latentes, la llamada **distribución latente**. Por ejemplo, podemos querer que los vectores latentes se distribuyan normalmente con una media z<sub>mean</sub> y una desviación estándar z<sub>sigma</sub> (tanto la media como la desviación estándar son vectores de alguna dimensionalidad d). El codificador en el VAE aprende a predecir esos parámetros, y luego el decodificador toma un vector aleatorio de esta distribución para reconstruir el objeto.
El VAE es un autoencoder que aprende a predecir una *distribución estadística* de los parámetros latentes, llamada **distribución latente**. Por ejemplo, podríamos querer que los vectores latentes se distribuyan normalmente con una media z<sub>mean</sub> y una desviación estándar z<sub>sigma</sub> (tanto la media como la desviación estándar son vectores de alguna dimensionalidad d). El codificador en el VAE aprende a predecir esos parámetros, y luego el decodificador toma un vector aleatorio de esta distribución para reconstruir el objeto.
Para resumir:
En resumen:
* Desde el vector de entrada, predecimos `z_mean` y `z_log_sigma` (en lugar de predecir la desviación estándar en sí, predecimos su logaritmo)
* Muestreamos un vector `sample` de la distribución N(z<sub>mean</sub>,exp(z<sub>log\_sigma</sub>))
* El decodificador intenta decodificar la imagen original utilizando `sample` como vector de entrada
* A partir del vector de entrada, predecimos `z_mean` y `z_log_sigma` (en lugar de predecir directamente la desviación estándar, predecimos su logaritmo).
* Muestreamos un vector `sample` de la distribución N(z<sub>mean</sub>,exp(z<sub>log\_sigma</sub>)).
* El decodificador intenta decodificar la imagen original usando `sample` como vector de entrada.
<img src="images/vae.png" width="50%">
<img src="images/vae.png" width="50%">
> Imagen de [este artículo del blog](https://ijdykeman.github.io/ml/2016/12/21/cvae.html) por Isaak Dykeman
> Imagen de [este artículo](https://ijdykeman.github.io/ml/2016/12/21/cvae.html) por Isaak Dykeman
Los autoencoders variacionales utilizan una función de pérdida compleja que consta de dos partes:
* **Pérdida de reconstrucción** es la función de pérdida que muestra cuán cerca está una imagen reconstruida del objetivo (puede ser el Error Cuadrático Medio, o MSE). Es la misma función de pérdida que en los autoencoders normales.
* **Pérdida KL**, que asegura que las distribuciones de las variables latentes se mantengan cerca de la distribución normal. Se basa en la noción de [divergencia Kullback-Leibler](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained) - una métrica para estimar cuán similares son dos distribuciones estadísticas.
* **Pérdida de reconstrucción**, que es la función de pérdida que muestra qué tan cerca está una imagen reconstruida del objetivo (puede ser el Error Cuadrático Medio, o MSE). Es la misma función de pérdida que en los autoencoders normales.
* **Pérdida KL**, que asegura que las distribuciones de las variables latentes se mantengan cercanas a una distribución normal. Se basa en la noción de [divergencia de Kullback-Leibler](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained), una métrica para estimar qué tan similares son dos distribuciones estadísticas.
Una ventaja importante de los VAEs es que nos permiten generar nuevas imágenes de manera relativamente sencilla, porque sabemos de qué distribución muestrear vectores latentes. Por ejemplo, si entrenamos un VAE con un vector latente 2D en MNIST, podemos variar los componentes del vector latente para obtener diferentes dígitos:
Una ventaja importante de los VAEs es que nos permiten generar nuevas imágenes con relativa facilidad, porque sabemos de qué distribución muestrear los vectores latentes. Por ejemplo, si entrenamos un VAE con un vector latente 2D en MNIST, podemos variar los componentes del vector latente para obtener diferentes dígitos:
<img alt="vaemnist" src="images/vaemnist.png" width="50%"/>
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
> Imagen por [Dmitry Soshnikov](http://soshnikov.com)
Observa cómo las imágenes se mezclan entre sí, a medida que comenzamos a obtener vectores latentes de diferentes porciones del espacio de parámetros latentes. También podemos visualizar este espacio en 2D:
<img alt="vaemnist cluster" src="images/vaemnist-diag.png" width="50%"/>
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
> Imagen por [Dmitry Soshnikov](http://soshnikov.com)
## ✍️ Ejercicios: Autoencoders
Aprende más sobre autoencoders en estos cuadernos correspondientes:
Aprende más sobre autoencoders en estos notebooks correspondientes:
* [Autoencoders en TensorFlow](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb)
* [Autoencoders en PyTorch](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoEncodersPyTorch.ipynb)
## Propiedades de los Autoencoders
* **Específicos para datos** - solo funcionan bien con el tipo de imágenes con las que han sido entrenados. Por ejemplo, si entrenamos una red de super-resolución en flores, no funcionará bien en retratos. Esto se debe a que la red puede producir una imagen de mayor resolución al tomar detalles finos de las características aprendidas del conjunto de datos de entrenamiento.
* **Con pérdida** - la imagen reconstruida no es la misma que la imagen original. La naturaleza de la pérdida está definida por la *función de pérdida* utilizada durante el entrenamiento.
* **Específicos de los datos** - solo funcionan bien con el tipo de imágenes con las que han sido entrenados. Por ejemplo, si entrenamos una red de superresolución en flores, no funcionará bien en retratos. Esto se debe a que la red puede producir imágenes de mayor resolución tomando detalles finos de las características aprendidas del conjunto de datos de entrenamiento.
* **Con pérdida** - la imagen reconstruida no es igual a la imagen original. La naturaleza de la pérdida está definida por la *función de pérdida* utilizada durante el entrenamiento.
* Funciona con **datos no etiquetados**.
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/209)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/209)
## Conclusión
@ -79,22 +88,22 @@ En esta lección, aprendiste sobre los diversos tipos de autoencoders disponible
## 🚀 Desafío
En esta lección, aprendiste sobre el uso de autoencoders para imágenes. ¡Pero también se pueden usar para música! Consulta el proyecto [MusicVAE](https://magenta.tensorflow.org/music-vae) del proyecto Magenta, que utiliza autoencoders para aprender a reconstruir música. Realiza algunos [experimentos](https://colab.research.google.com/github/magenta/magenta-demos/blob/master/colab-notebooks/Multitrack_MusicVAE.ipynb) con esta biblioteca para ver qué puedes crear.
En esta lección, aprendiste sobre el uso de autoencoders para imágenes. ¡Pero también pueden usarse para música! Explora el proyecto [MusicVAE](https://magenta.tensorflow.org/music-vae) del proyecto Magenta, que utiliza autoencoders para aprender a reconstruir música. Realiza algunos [experimentos](https://colab.research.google.com/github/magenta/magenta-demos/blob/master/colab-notebooks/Multitrack_MusicVAE.ipynb) con esta biblioteca para ver qué puedes crear.
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
## Revisión y Autoestudio
Para referencia, lee más sobre autoencoders en estos recursos:
* [Construyendo Autoencoders en Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
* [Artículo del blog en NeuroHive](https://neurohive.io/ru/osnovy-data-science/variacionnyj-avtojenkoder-vae/)
* [Artículo en NeuroHive](https://neurohive.io/ru/osnovy-data-science/variacionnyj-avtojenkoder-vae/)
* [Autoencoders Variacionales Explicados](https://kvfrans.com/variational-autoencoders-explained/)
* [Autoencoders Variacionales Condicionales](https://ijdykeman.github.io/ml/2016/12/21/cvae.html)
## Asignación
## Tarea
Al final de [este cuaderno usando TensorFlow](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb), encontrarás una 'tarea': utiliza esto como tu asignación.
Al final de [este notebook usando TensorFlow](../../../../../lessons/4-ComputerVision/09-Autoencoders/AutoencodersTF.ipynb), encontrarás una 'tarea': úsala como tu asignación.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional por parte de un humano. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

91
translations/es/lessons/4-ComputerVision/10-GANs/README.md
View File

@ -1,101 +1,110 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "f07c85bbf05a1f67505da98f4ecc124c",
"translation_date": "2025-08-24T09:16:30+00:00",
"source_file": "lessons/4-ComputerVision/10-GANs/README.md",
"language_code": "es"
}
-->
# Redes Generativas Antagónicas
En la sección anterior, aprendimos sobre **modelos generativos**: modelos que pueden generar nuevas imágenes similares a las del conjunto de datos de entrenamiento. VAE fue un buen ejemplo de un modelo generativo.
En la sección anterior, aprendimos sobre los **modelos generativos**: modelos que pueden generar nuevas imágenes similares a las del conjunto de datos de entrenamiento. VAE fue un buen ejemplo de un modelo generativo.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/110)
Sin embargo, si intentamos generar algo realmente significativo, como una pintura en una resolución razonable, con VAE, veremos que el entrenamiento no converge bien. Para este caso de uso, debemos aprender sobre otra arquitectura específicamente diseñada para modelos generativos: **Redes Generativas Antagónicas**, o GANs.
Sin embargo, si intentamos generar algo realmente significativo, como una pintura con una resolución razonable, usando VAE, veremos que el entrenamiento no converge bien. Para este caso de uso, debemos aprender sobre otra arquitectura específicamente orientada a modelos generativos: las **Redes Generativas Antagónicas**, o GANs.
La idea principal de una GAN es tener dos redes neuronales que se entrenan entre sí:
La idea principal de una GAN es tener dos redes neuronales que se entrenan una contra la otra:
<img src="images/gan_architecture.png" width="70%"/>
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
> Imagen por [Dmitry Soshnikov](http://soshnikov.com)
> ✅ Un poco de vocabulario:
> * **Generador** es una red que toma un vector aleatorio y produce la imagen como resultado.
> * **Discriminador** es una red que toma una imagen y debe decir si es una imagen real (del conjunto de datos de entrenamiento) o fue generada por un generador. Es esencialmente un clasificador de imágenes.
> * **Generador** es una red que toma un vector aleatorio y produce una imagen como resultado.
> * **Discriminador** es una red que toma una imagen y debe determinar si es una imagen real (del conjunto de datos de entrenamiento) o si fue generada por un generador. Es esencialmente un clasificador de imágenes.
### Discriminador
La arquitectura del discriminador no difiere de una red de clasificación de imágenes ordinaria. En el caso más simple, puede ser un clasificador totalmente conectado, pero lo más probable es que sea una [red convolucional](../07-ConvNets/README.md).
La arquitectura del discriminador no difiere de una red de clasificación de imágenes ordinaria. En el caso más simple, puede ser un clasificador completamente conectado, pero lo más probable es que sea una [red convolucional](../07-ConvNets/README.md).
> ✅ Una GAN basada en redes convolucionales se llama [DCGAN](https://arxiv.org/pdf/1511.06434.pdf)
Un discriminador CNN consta de las siguientes capas: varias convoluciones + agrupamientos (con tamaño espacial decreciente) y, una o más capas totalmente conectadas para obtener el "vector de características", el clasificador binario final.
Un discriminador CNN consta de las siguientes capas: varias convoluciones+poolings (con tamaño espacial decreciente) y una o más capas completamente conectadas para obtener un "vector de características", clasificador binario final.
> ✅ Un 'agrupamiento' en este contexto es una técnica que reduce el tamaño de la imagen. "Las capas de agrupamiento reducen las dimensiones de los datos combinando las salidas de grupos de neuronas en una capa en una sola neurona en la siguiente capa." - [fuente](https://wikipedia.org/wiki/Convolutional_neural_network#Pooling_layers)
> ✅ Un 'pooling' en este contexto es una técnica que reduce el tamaño de la imagen. "Las capas de pooling reducen las dimensiones de los datos combinando las salidas de los grupos de neuronas en una capa en una sola neurona en la siguiente capa." - [fuente](https://wikipedia.org/wiki/Convolutional_neural_network#Pooling_layers)
### Generador
Un generador es un poco más complicado. Se puede considerar como un discriminador invertido. Comenzando desde un vector latente (en lugar de un vector de características), tiene una capa totalmente conectada para convertirlo en el tamaño/forma requeridos, seguida de deconvoluciones + aumento de escala. Esto es similar a la parte de *decodificador* de un [autoencoder](../09-Autoencoders/README.md).
Un generador es un poco más complicado. Puedes considerarlo como un discriminador invertido. Comenzando desde un vector latente (en lugar de un vector de características), tiene una capa completamente conectada para convertirlo en el tamaño/forma requerida, seguida de deconvoluciones+escalado. Esto es similar a la parte de *decodificador* de un [autoencoder](../09-Autoencoders/README.md).
> ✅ Dado que la capa de convolución se implementa como un filtro lineal que recorre la imagen, la deconvolución es esencialmente similar a la convolución y puede implementarse utilizando la misma lógica de capa.
> ✅ Debido a que la capa de convolución se implementa como un filtro lineal que recorre la imagen, la deconvolución es esencialmente similar a la convolución y puede implementarse utilizando la misma lógica de capa.
<img src="images/gan_arch_detail.png" width="70%"/>
> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
> Imagen por [Dmitry Soshnikov](http://soshnikov.com)
### Entrenando la GAN
### Entrenamiento de la GAN
Las GAN se llaman **antagónicas** porque hay una competencia constante entre el generador y el discriminador. Durante esta competencia, tanto el generador como el discriminador mejoran, por lo que la red aprende a producir imágenes cada vez mejores.
Las GANs se llaman **antagónicas** porque hay una competencia constante entre el generador y el discriminador. Durante esta competencia, tanto el generador como el discriminador mejoran, y la red aprende a producir imágenes cada vez mejores.
El entrenamiento ocurre en dos etapas:
* **Entrenando al discriminador**. Esta tarea es bastante directa: generamos un lote de imágenes con el generador, etiquetándolas como 0, que representa una imagen falsa, y tomamos un lote de imágenes del conjunto de datos de entrada (con etiqueta 1, imagen real). Obtenemos una *pérdida del discriminador* y realizamos retropropagación.
* **Entrenando al generador**. Esto es un poco más complicado, porque no conocemos la salida esperada para el generador directamente. Tomamos toda la red GAN compuesta por un generador seguido de un discriminador, le proporcionamos algunos vectores aleatorios y esperamos que el resultado sea 1 (correspondiente a imágenes reales). Luego congelamos los parámetros del discriminador (no queremos que se entrene en este paso) y realizamos la retropropagación.
* **Entrenamiento del discriminador**. Esta tarea es bastante sencilla: generamos un lote de imágenes con el generador, etiquetándolas como 0, lo que significa imagen falsa, y tomamos un lote de imágenes del conjunto de datos de entrada (con etiqueta 1, imagen real). Obtenemos una *pérdida del discriminador* y realizamos retropropagación.
* **Entrenamiento del generador**. Esto es un poco más complicado porque no conocemos directamente la salida esperada para el generador. Tomamos toda la red GAN que consiste en un generador seguido por un discriminador, la alimentamos con algunos vectores aleatorios y esperamos que el resultado sea 1 (correspondiente a imágenes reales). Luego congelamos los parámetros del discriminador (no queremos que se entrene en este paso) y realizamos la retropropagación.
Durante este proceso, las pérdidas tanto del generador como del discriminador no disminuyen significativamente. En la situación ideal, deberían oscilar, lo que corresponde a que ambas redes mejoran su rendimiento.
## ✍️ Ejercicios: GANs
* [Cuaderno GAN en TensorFlow/Keras](../../../../../lessons/4-ComputerVision/10-GANs/GANTF.ipynb)
* [Cuaderno GAN en PyTorch](../../../../../lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb)
* [Notebook de GAN en TensorFlow/Keras](../../../../../lessons/4-ComputerVision/10-GANs/GANTF.ipynb)
* [Notebook de GAN en PyTorch](../../../../../lessons/4-ComputerVision/10-GANs/GANPyTorch.ipynb)
### Problemas con el entrenamiento de GAN
### Problemas con el entrenamiento de GANs
Se sabe que las GAN son especialmente difíciles de entrenar. Aquí hay algunos problemas:
Las GANs son conocidas por ser especialmente difíciles de entrenar. Aquí hay algunos problemas:
* **Colapso de modo**. Por este término nos referimos a que el generador aprende a producir una imagen exitosa que engaña al discriminador, y no una variedad de imágenes diferentes.
* **Sensibilidad a los hiperparámetros**. A menudo se puede ver que una GAN no converge en absoluto, y luego, de repente, disminuye en la tasa de aprendizaje, lo que lleva a la convergencia.
* Mantener un **equilibrio** entre el generador y el discriminador. En muchos casos, la pérdida del discriminador puede caer a cero relativamente rápido, lo que resulta en que el generador no puede entrenar más. Para superar esto, podemos intentar establecer diferentes tasas de aprendizaje para el generador y el discriminador, o saltar el entrenamiento del discriminador si la pérdida ya es demasiado baja.
* Entrenamiento para **alta resolución**. Reflejando el mismo problema que con los autoencoders, este problema se activa porque reconstruir demasiadas capas de una red convolucional conduce a artefactos. Este problema se resuelve típicamente con el llamado **crecimiento progresivo**, cuando primero se entrenan algunas capas en imágenes de baja resolución y luego se "desbloquean" o añaden capas. Otra solución sería agregar conexiones adicionales entre capas y entrenar varias resoluciones a la vez; consulte este [artículo sobre GANs de Gradiente Multi-escala](https://arxiv.org/abs/1903.06048) para más detalles.
* **Colapso de modo**. Este término se refiere a que el generador aprende a producir una imagen exitosa que engaña al discriminador, pero no una variedad de imágenes diferentes.
* **Sensibilidad a los hiperparámetros**. A menudo puedes ver que una GAN no converge en absoluto, y luego, de repente, una disminución en la tasa de aprendizaje lleva a la convergencia.
* Mantener un **equilibrio** entre el generador y el discriminador. En muchos casos, la pérdida del discriminador puede caer a cero relativamente rápido, lo que resulta en que el generador no pueda entrenarse más. Para superar esto, podemos intentar establecer diferentes tasas de aprendizaje para el generador y el discriminador, o saltar el entrenamiento del discriminador si la pérdida ya es demasiado baja.
* Entrenamiento para **alta resolución**. Reflejando el mismo problema que con los autoencoders, este problema se desencadena porque reconstruir demasiadas capas de una red convolucional lleva a artefactos. Este problema se resuelve típicamente con el llamado **crecimiento progresivo**, donde primero se entrenan algunas capas con imágenes de baja resolución y luego se "desbloquean" o se agregan capas. Otra solución sería agregar conexiones adicionales entre capas y entrenar varias resoluciones a la vez; consulta este artículo [Multi-Scale Gradient GANs](https://arxiv.org/abs/1903.06048) para más detalles.
## Transferencia de Estilo
## Transferencia de estilo
Las GAN son una excelente manera de generar imágenes artísticas. Otra técnica interesante es la llamada **transferencia de estilo**, que toma una **imagen de contenido** y la vuelve a dibujar en un estilo diferente, aplicando filtros de la **imagen de estilo**.
Las GANs son una excelente manera de generar imágenes artísticas. Otra técnica interesante es la llamada **transferencia de estilo**, que toma una **imagen de contenido** y la redibuja en un estilo diferente, aplicando filtros de una **imagen de estilo**.
La forma en que funciona es la siguiente:
* Comenzamos con una imagen de ruido aleatorio (o con una imagen de contenido, pero para fines de comprensión es más fácil comenzar desde ruido aleatorio).
* Nuestro objetivo sería crear una imagen que esté cerca tanto de la imagen de contenido como de la imagen de estilo. Esto se determinaría mediante dos funciones de pérdida:
El funcionamiento es el siguiente:
* Comenzamos con una imagen de ruido aleatorio (o con una imagen de contenido, pero para entenderlo es más fácil comenzar con ruido aleatorio).
* Nuestro objetivo sería crear una imagen que esté cerca tanto de la imagen de contenido como de la imagen de estilo. Esto se determinará mediante dos funciones de pérdida:
- **Pérdida de contenido** se calcula en función de las características extraídas por la CNN en algunas capas de la imagen actual y la imagen de contenido.
- **Pérdida de estilo** se calcula entre la imagen actual y la imagen de estilo de una manera inteligente utilizando matrices de Gram (más detalles en el [cuaderno de ejemplo](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)).
- **Pérdida de estilo** se calcula entre la imagen actual y la imagen de estilo de una manera ingeniosa utilizando matrices de Gram (más detalles en el [notebook de ejemplo](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)).
* Para hacer la imagen más suave y eliminar el ruido, también introducimos **pérdida de variación**, que calcula la distancia promedio entre píxeles vecinos.
* El bucle de optimización principal ajusta la imagen actual utilizando descenso de gradiente (o algún otro algoritmo de optimización) para minimizar la pérdida total, que es una suma ponderada de las tres pérdidas.
* El bucle principal de optimización ajusta la imagen actual utilizando descenso de gradiente (u otro algoritmo de optimización) para minimizar la pérdida total, que es una suma ponderada de todas las pérdidas.
## ✍️ Ejemplo: [Transferencia de Estilo](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)
## ✍️ Ejemplo: [Transferencia de estilo](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb)
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/210)
## Conclusión
En esta lección, aprendiste sobre las GAN y cómo entrenarlas. También aprendiste sobre los desafíos especiales que este tipo de red neuronal puede enfrentar y algunas estrategias sobre cómo superarlos.
En esta lección, aprendiste sobre las GANs y cómo entrenarlas. También aprendiste sobre los desafíos especiales que este tipo de red neuronal puede enfrentar y algunas estrategias para superarlos.
## 🚀 Desafío
Ejecuta el [cuaderno de Transferencia de Estilo](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb) utilizando tus propias imágenes.
Ejecuta el [notebook de transferencia de estilo](../../../../../lessons/4-ComputerVision/10-GANs/StyleTransfer.ipynb) usando tus propias imágenes.
## Revisión y Autoestudio
## Revisión y autoestudio
Para referencia, lee más sobre las GAN en estos recursos:
Para referencia, lee más sobre GANs en estos recursos:
* Marco Pasini, [10 Lecciones que Aprendí Entrenando GANs durante un Año](https://towardsdatascience.com/10-lessons-i-learned-training-generative-adversarial-networks-gans-for-a-year-c9071159628)
* [StyleGAN](https://en.wikipedia.org/wiki/StyleGAN), una arquitectura GAN *de facto* a considerar
* [Creando Arte Generativo usando GANs en Azure ML](https://soshnikov.com/scienceart/creating-generative-art-using-gan-on-azureml/)
* Marco Pasini, [10 Lecciones que aprendí entrenando GANs durante un año](https://towardsdatascience.com/10-lessons-i-learned-training-generative-adversarial-networks-gans-for-a-year-c9071159628)
* [StyleGAN](https://en.wikipedia.org/wiki/StyleGAN), una arquitectura GAN *de facto* a considerar.
* [Creando arte generativo usando GANs en Azure ML](https://soshnikov.com/scienceart/creating-generative-art-using-gan-on-azureml/)
## Tarea
Revisita uno de los dos cuadernos asociados a esta lección y vuelve a entrenar la GAN con tus propias imágenes. ¿Qué puedes crear?
Revisita uno de los dos notebooks asociados a esta lección y vuelve a entrenar la GAN con tus propias imágenes. ¿Qué puedes crear?
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

175
translations/es/lessons/4-ComputerVision/11-ObjectDetection/README.md
View File

@ -1,20 +1,157 @@
### YOLO - Solo Miras Una Vez
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d85c8b08f6d1b48fd7f35b99f93c1138",
"translation_date": "2025-08-24T09:16:52+00:00",
"source_file": "lessons/4-ComputerVision/11-ObjectDetection/README.md",
"language_code": "es"
}
-->
# Detección de Objetos
YOLO es un algoritmo en tiempo real de un solo pase. La idea principal es la siguiente:
Los modelos de clasificación de imágenes que hemos visto hasta ahora toman una imagen y producen un resultado categórico, como la clase 'número' en un problema de MNIST. Sin embargo, en muchos casos no solo queremos saber que una imagen contiene objetos, sino que también queremos determinar su ubicación precisa. Esto es exactamente el objetivo de la **detección de objetos**.
* La imagen se divide en regiones de $S\times S$.
* Para cada región, **CNN** predice $n$ posibles objetos, las coordenadas del *bounding box* y *confianza* = *probabilidad* * IoU.
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/111)
![YOLO](../../../../../translated_images/yolo.a2648ec82ee8bb4ea27537677adb482fd4b733ca1705c561b6a24a85102dced5.es.png)
> Imagen del [documento oficial](https://arxiv.org/abs/1506.02640)
![Detección de Objetos](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/Screen_Shot_2016-11-17_at_11.14.54_AM.png)
> Imagen de [sitio web de YOLO v2](https://pjreddie.com/darknet/yolov2/)
## Un Enfoque Ingenuo para la Detección de Objetos
Supongamos que queremos encontrar un gato en una imagen. Un enfoque muy ingenuo para la detección de objetos sería el siguiente:
1. Dividir la imagen en varias secciones o mosaicos.
2. Ejecutar un modelo de clasificación de imágenes en cada mosaico.
3. Aquellos mosaicos que resulten en una activación suficientemente alta pueden considerarse como que contienen el objeto en cuestión.
![Detección Ingenua](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/naive-detection.png)
> *Imagen del [Cuaderno de Ejercicios](../../../../../lessons/4-ComputerVision/11-ObjectDetection/ObjectDetection-TF.ipynb)*
Sin embargo, este enfoque está lejos de ser ideal, ya que solo permite al algoritmo localizar la caja delimitadora del objeto de manera muy imprecisa. Para una ubicación más precisa, necesitamos ejecutar algún tipo de **regresión** para predecir las coordenadas de las cajas delimitadoras, y para ello necesitamos conjuntos de datos específicos.
## Regresión para la Detección de Objetos
[Esta publicación de blog](https://towardsdatascience.com/object-detection-with-neural-networks-a4e2c46b4491) ofrece una excelente introducción a la detección de formas.
## Conjuntos de Datos para la Detección de Objetos
Es posible que encuentres los siguientes conjuntos de datos para esta tarea:
* [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) - 20 clases
* [COCO](http://cocodataset.org/#home) - Objetos Comunes en Contexto. 80 clases, cajas delimitadoras y máscaras de segmentación
![COCO](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/coco-examples.jpg)
## Métricas de Detección de Objetos
### Intersección sobre Unión
Mientras que para la clasificación de imágenes es fácil medir qué tan bien funciona el algoritmo, para la detección de objetos necesitamos medir tanto la corrección de la clase como la precisión de la ubicación inferida de la caja delimitadora. Para esto último, usamos la llamada **Intersección sobre Unión** (IoU), que mide qué tan bien se superponen dos cajas (o dos áreas arbitrarias).
![IoU](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/iou_equation.png)
> *Figura 2 de [esta excelente publicación sobre IoU](https://pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/)*
La idea es simple: dividimos el área de intersección entre dos figuras por el área de su unión. Para dos áreas idénticas, IoU sería 1, mientras que para áreas completamente disjuntas será 0. En otros casos, variará entre 0 y 1. Normalmente solo consideramos aquellas cajas delimitadoras para las que IoU supera un cierto valor.
### Precisión Promedio
Supongamos que queremos medir qué tan bien se reconoce una clase de objetos $C$ dada. Para medirlo, usamos la métrica de **Precisión Promedio**, que se calcula de la siguiente manera:
1. Consideramos la curva de Precisión-Recall, que muestra la precisión dependiendo de un valor umbral de detección (de 0 a 1).
2. Dependiendo del umbral, obtendremos más o menos objetos detectados en la imagen, y diferentes valores de precisión y recall.
3. La curva se verá así:
<img src="https://github.com/shwars/NeuroWorkshop/raw/master/images/ObjDetectionPrecisionRecall.png"/>
> *Imagen de [NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
La Precisión Promedio para una clase $C$ dada es el área bajo esta curva. Más precisamente, el eje de Recall se divide típicamente en 10 partes, y la Precisión se promedia en todos esos puntos:
$$
AP = {1\over11}\sum_{i=0}^{10}\mbox{Precision}(\mbox{Recall}={i\over10})
$$
### AP e IoU
Solo consideraremos aquellas detecciones para las que IoU esté por encima de un cierto valor. Por ejemplo, en el conjunto de datos PASCAL VOC típicamente se asume $\mbox{IoU Threshold} = 0.5$, mientras que en COCO AP se mide para diferentes valores de $\mbox{IoU Threshold}$.
<img src="https://github.com/shwars/NeuroWorkshop/raw/master/images/ObjDetectionPrecisionRecallIoU.png"/>
> *Imagen de [NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
### Precisión Promedio Media - mAP
La métrica principal para la Detección de Objetos se llama **Precisión Promedio Media**, o **mAP**. Es el valor de la Precisión Promedio, promediado entre todas las clases de objetos, y a veces también sobre $\mbox{IoU Threshold}$. El proceso de cálculo de **mAP** se describe en detalle
[en esta publicación de blog](https://medium.com/@timothycarlen/understanding-the-map-evaluation-metric-for-object-detection-a07fe6962cf3), y también [aquí con ejemplos de código](https://gist.github.com/tarlen5/008809c3decf19313de216b9208f3734).
## Diferentes Enfoques para la Detección de Objetos
Existen dos grandes clases de algoritmos de detección de objetos:
* **Redes de Propuesta de Regiones** (R-CNN, Fast R-CNN, Faster R-CNN). La idea principal es generar **Regiones de Interés** (ROI) y ejecutar una CNN sobre ellas, buscando la activación máxima. Es un poco similar al enfoque ingenuo, con la excepción de que las ROI se generan de una manera más inteligente. Una de las principales desventajas de estos métodos es que son lentos, ya que se necesitan muchos pases del clasificador CNN sobre la imagen.
* Métodos de **una sola pasada** (YOLO, SSD, RetinaNet). En estas arquitecturas diseñamos la red para predecir tanto las clases como las ROI en un solo pase.
### R-CNN: CNN Basada en Regiones
[R-CNN](http://islab.ulsan.ac.kr/files/announcement/513/rcnn_pami.pdf) utiliza [Selective Search](http://www.huppelen.nl/publications/selectiveSearchDraft.pdf) para generar una estructura jerárquica de regiones ROI, que luego se pasan por extractores de características CNN y clasificadores SVM para determinar la clase del objeto, y regresión lineal para determinar las coordenadas de la *caja delimitadora*. [Artículo oficial](https://arxiv.org/pdf/1506.01497v1.pdf)
![RCNN](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/rcnn1.png)
> *Imagen de van de Sande et al. ICCV’11*
![RCNN-1](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/rcnn2.png)
> *Imágenes de [este blog](https://towardsdatascience.com/r-cnn-fast-r-cnn-faster-r-cnn-yolo-object-detection-algorithms-36d53571365e)*
### F-RCNN - Fast R-CNN
Este enfoque es similar a R-CNN, pero las regiones se definen después de que se han aplicado las capas de convolución.
![FRCNN](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/f-rcnn.png)
> Imagen del [Artículo Oficial](https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/Girshick_Fast_R-CNN_ICCV_2015_paper.pdf), [arXiv](https://arxiv.org/pdf/1504.08083.pdf), 2015
### Faster R-CNN
La idea principal de este enfoque es usar una red neuronal para predecir las ROI, la llamada *Red de Propuesta de Regiones*. [Artículo](https://arxiv.org/pdf/1506.01497.pdf), 2016
![FasterRCNN](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/faster-rcnn.png)
> Imagen del [artículo oficial](https://arxiv.org/pdf/1506.01497.pdf)
### R-FCN: Red Completamente Convolucional Basada en Regiones
Este algoritmo es incluso más rápido que Faster R-CNN. La idea principal es la siguiente:
1. Extraemos características usando ResNet-101.
2. Las características se procesan mediante un **Mapa de Puntuación Sensible a la Posición**. Cada objeto de las clases $C$ se divide en regiones de $k\times k$, y entrenamos para predecir partes de los objetos.
3. Para cada parte de las regiones $k\times k$, todas las redes votan por las clases de objetos, y se selecciona la clase de objeto con el máximo voto.
![r-fcn image](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/r-fcn.png)
> Imagen del [artículo oficial](https://arxiv.org/abs/1605.06409)
### YOLO - You Only Look Once
YOLO es un algoritmo de una sola pasada en tiempo real. La idea principal es la siguiente:
* La imagen se divide en regiones de $S\times S$.
* Para cada región, **CNN** predice $n$ posibles objetos, las coordenadas de la *caja delimitadora* y la *confianza* = *probabilidad* * IoU.
![YOLO](../../../../../lessons/4-ComputerVision/11-ObjectDetection/images/yolo.png)
> Imagen del [artículo oficial](https://arxiv.org/abs/1506.02640)
### Otros Algoritmos
* RetinaNet: [documento oficial](https://arxiv.org/abs/1708.02002)
* RetinaNet: [artículo oficial](https://arxiv.org/abs/1708.02002)
- [Implementación en PyTorch en Torchvision](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html)
- [Implementación en Keras](https://github.com/fizyr/keras-retinanet)
- [Detección de Objetos con RetinaNet](https://keras.io/examples/vision/retinanet/) en Keras Samples
* SSD (Detector de Un Solo Disparo): [documento oficial](https://arxiv.org/abs/1512.02325)
- [Detección de Objetos con RetinaNet](https://keras.io/examples/vision/retinanet/) en ejemplos de Keras
* SSD (Single Shot Detector): [artículo oficial](https://arxiv.org/abs/1512.02325)
## ✍️ Ejercicios: Detección de Objetos
@ -24,28 +161,28 @@ Continúa tu aprendizaje en el siguiente cuaderno:
## Conclusión
En esta lección hiciste un recorrido rápido por las diversas maneras en que se puede llevar a cabo la detección de objetos.
En esta lección hiciste un recorrido rápido por las diversas formas en que se puede lograr la detección de objetos.
## 🚀 Desafío
Lee estos artículos y cuadernos sobre YOLO y pruébalos tú mismo.
Lee estos artículos y cuadernos sobre YOLO y pruébalos por ti mismo:
* [Buen artículo de blog](https://www.analyticsvidhya.com/blog/2018/12/practical-guide-object-detection-yolo-framewor-python/) que describe YOLO
* [Buen artículo](https://www.analyticsvidhya.com/blog/2018/12/practical-guide-object-detection-yolo-framewor-python/) que describe YOLO
* [Sitio oficial](https://pjreddie.com/darknet/yolo/)
* Yolo: [implementación en Keras](https://github.com/experiencor/keras-yolo2), [cuaderno paso a paso](https://github.com/experiencor/basic-yolo-keras/blob/master/Yolo%20Step-by-Step.ipynb)
* Yolo v2: [implementación en Keras](https://github.com/experiencor/keras-yolo2), [cuaderno paso a paso](https://github.com/experiencor/keras-yolo2/blob/master/Yolo%20Step-by-Step.ipynb)
* Yolo: [Implementación en Keras](https://github.com/experiencor/keras-yolo2), [cuaderno paso a paso](https://github.com/experiencor/basic-yolo-keras/blob/master/Yolo%20Step-by-Step.ipynb)
* Yolo v2: [Implementación en Keras](https://github.com/experiencor/keras-yolo2), [cuaderno paso a paso](https://github.com/experiencor/keras-yolo2/blob/master/Yolo%20Step-by-Step.ipynb)
## [Cuestionario post-clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/211)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/211)
## Revisión y Autoestudio
* [Detección de Objetos](https://tjmachinelearning.com/lectures/1718/obj/) por Nikhil Sardana
* [Una buena comparación de algoritmos de detección de objetos](https://lilianweng.github.io/lil-log/2018/12/27/object-detection-part-4.html)
* [Revisión de Algoritmos de Aprendizaje Profundo para Detección de Objetos](https://medium.com/comet-app/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852)
* [Una Introducción Paso a Paso a los Algoritmos Básicos de Detección de Objetos](https://www.analyticsvidhya.com/blog/2018/10/a-step-by-step-introduction-to-the-basic-object-detection-algorithms-part-1/)
* [Implementación de Faster R-CNN en Python para Detección de Objetos](https://www.analyticsvidhya.com/blog/2018/11/implementation-faster-r-cnn-python-object-detection/)
* [Revisión de Algoritmos de Aprendizaje Profundo para la Detección de Objetos](https://medium.com/comet-app/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852)
* [Introducción paso a paso a los algoritmos básicos de detección de objetos](https://www.analyticsvidhya.com/blog/2018/10/a-step-by-step-introduction-to-the-basic-object-detection-algorithms-part-1/)
* [Implementación de Faster R-CNN en Python para la Detección de Objetos](https://www.analyticsvidhya.com/blog/2018/11/implementation-faster-r-cnn-python-object-detection/)
## [Asignación: Detección de Objetos](lab/README.md)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

29
translations/es/lessons/4-ComputerVision/11-ObjectDetection/lab/README.md
View File

@ -1,14 +1,23 @@
# Detección de Cabezas usando el Conjunto de Datos de Hollywood
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "ad568d55ae65c856fe929fc2b278510a",
"translation_date": "2025-08-24T09:17:32+00:00",
"source_file": "lessons/4-ComputerVision/11-ObjectDetection/lab/README.md",
"language_code": "es"
}
-->
# Detección de Cabezas usando el Conjunto de Datos Hollywood Heads
Tarea del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
Asignación de laboratorio del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
## Tarea
Contar el número de personas en el flujo de cámaras de vigilancia es una tarea importante que nos permitirá estimar el número de visitantes en tiendas, horas pico en un restaurante, etc. Para resolver esta tarea, necesitamos ser capaces de detectar cabezas humanas desde diferentes ángulos. Para entrenar un modelo de detección de objetos que detecte cabezas humanas, podemos utilizar el [Conjunto de Datos de Hollywood](https://www.di.ens.fr/willow/research/headdetection/).
Contar el número de personas en la transmisión de una cámara de vigilancia es una tarea importante que nos permite estimar el número de visitantes en tiendas, las horas pico en un restaurante, etc. Para resolver esta tarea, necesitamos ser capaces de detectar cabezas humanas desde diferentes ángulos. Para entrenar un modelo de detección de objetos que detecte cabezas humanas, podemos usar el [Conjunto de Datos Hollywood Heads](https://www.di.ens.fr/willow/research/headdetection/).
## El Conjunto de Datos
El [Conjunto de Datos de Hollywood](https://www.di.ens.fr/willow/research/headdetection/release/HollywoodHeads.zip) contiene 369,846 cabezas humanas anotadas en 224,740 fotogramas de películas de Hollywood. Se proporciona en formato [https://host.robots.ox.ac.uk/pascal/VOC/](../../../../../../lessons/4-ComputerVision/11-ObjectDetection/lab/PASCAL VOC), donde para cada imagen también hay un archivo de descripción XML que se ve así:
El [Conjunto de Datos Hollywood Heads](https://www.di.ens.fr/willow/research/headdetection/release/HollywoodHeads.zip) contiene 369,846 cabezas humanas anotadas en 224,740 fotogramas de películas de Hollywood. Se proporciona en formato [https://host.robots.ox.ac.uk/pascal/VOC/](../../../../../../lessons/4-ComputerVision/11-ObjectDetection/lab/PASCAL VOC), donde para cada imagen también hay un archivo de descripción XML que se ve así:
```xml
<annotation>
@ -48,19 +57,19 @@ El [Conjunto de Datos de Hollywood](https://www.di.ens.fr/willow/research/headde
</annotation>
```
En este conjunto de datos, solo hay una clase de objetos `head`, y para cada cabeza, obtienes las coordenadas de la caja delimitadora. Puedes analizar XML usando bibliotecas de Python, o usar [esta biblioteca](https://pypi.org/project/pascal-voc/) para trabajar directamente con el formato PASCAL VOC.
En este conjunto de datos, solo hay una clase de objetos `head`, y para cada cabeza se obtienen las coordenadas del cuadro delimitador. Puedes analizar los archivos XML usando bibliotecas de Python, o usar [esta biblioteca](https://pypi.org/project/pascal-voc/) para trabajar directamente con el formato PASCAL VOC.
## Entrenamiento de Detección de Objetos
Puedes entrenar un modelo de detección de objetos usando una de las siguientes maneras:
Puedes entrenar un modelo de detección de objetos usando una de las siguientes opciones:
* Usando [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste) y su API de Python para entrenar programáticamente el modelo en la nube. La visión personalizada no podrá usar más de unas pocas centenas de imágenes para entrenar el modelo, por lo que es posible que necesites limitar el conjunto de datos.
* Usando el ejemplo del [tutorial de Keras](https://keras.io/examples/vision/retinanet/) para entrenar el modelo RetinaNet.
* Usando [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste) y su API de Python para entrenar el modelo programáticamente en la nube. Custom Vision no podrá usar más de unos pocos cientos de imágenes para entrenar el modelo, por lo que puede ser necesario limitar el conjunto de datos.
* Usando el ejemplo del [tutorial de Keras](https://keras.io/examples/vision/retinanet/) para entrenar el modelo RetunaNet.
* Usando el módulo integrado [torchvision.models.detection.RetinaNet](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html) en torchvision.
## Conclusión
La detección de objetos es una tarea que se requiere con frecuencia en la industria. Aunque hay algunos servicios que se pueden utilizar para realizar la detección de objetos (como [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste)), es importante entender cómo funciona la detección de objetos y poder entrenar tus propios modelos.
La detección de objetos es una tarea que se requiere con frecuencia en la industria. Aunque existen algunos servicios que se pueden usar para realizar detección de objetos (como [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste)), es importante entender cómo funciona la detección de objetos y ser capaz de entrenar tus propios modelos.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por lograr la precisión, tenga en cuenta que las traducciones automáticas 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 realizada por humanos. No nos hacemos responsables de malentendidos o malas interpretaciones que surjan del uso de esta traducción.
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.

49
translations/es/lessons/4-ComputerVision/12-Segmentation/README.md
View File

@ -1,36 +1,45 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d7f8a25ff13cfe9f4cd671cc23351fad",
"translation_date": "2025-08-24T09:16:07+00:00",
"source_file": "lessons/4-ComputerVision/12-Segmentation/README.md",
"language_code": "es"
}
-->
# Segmentación
Anteriormente aprendimos sobre la Detección de Objetos, que nos permite localizar objetos en la imagen prediciendo sus *cajas delimitadoras*. Sin embargo, para algunas tareas no solo necesitamos cajas delimitadoras, sino también una localización de objetos más precisa. Esta tarea se llama **segmentación**.
Anteriormente hemos aprendido sobre la Detección de Objetos, que nos permite localizar objetos en una imagen prediciendo sus *cajas delimitadoras*. Sin embargo, para algunas tareas no solo necesitamos cajas delimitadoras, sino también una localización más precisa de los objetos. Esta tarea se llama **segmentación**.
## [Cuestionario previo a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/112)
## [Cuestionario previo a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/112)
La segmentación se puede ver como **clasificación de píxeles**, donde para **cada** píxel de la imagen debemos predecir su clase (*fondo* siendo una de las clases). Hay dos algoritmos principales de segmentación:
La segmentación puede considerarse como **clasificación de píxeles**, donde para **cada** píxel de la imagen debemos predecir su clase (*fondo* siendo una de las clases). Existen dos principales algoritmos de segmentación:
* **Segmentación semántica** solo indica la clase del píxel y no hace distinción entre diferentes objetos de la misma clase.
* **Segmentación por instancias** divide las clases en diferentes instancias.
* **Segmentación semántica** solo indica la clase del píxel, y no distingue entre diferentes objetos de la misma clase.
* **Segmentación por instancia** divide las clases en diferentes instancias.
Por ejemplo, en la segmentación por instancias, estas ovejas son objetos diferentes, pero para la segmentación semántica todas las ovejas se representan con una sola clase.
En la segmentación por instancia, estas ovejas son objetos diferentes, pero en la segmentación semántica todas las ovejas están representadas por una sola clase.
<img src="images/instance_vs_semantic.jpeg" width="50%">
> Imagen de [este blog](https://nirmalamurali.medium.com/image-classification-vs-semantic-segmentation-vs-instance-segmentation-625c33a08d50)
> Imagen de [esta publicación de blog](https://nirmalamurali.medium.com/image-classification-vs-semantic-segmentation-vs-instance-segmentation-625c33a08d50)
Existen diferentes arquitecturas neuronales para la segmentación, pero todas tienen la misma estructura. De alguna manera, es similar al autoencoder que aprendiste anteriormente, pero en lugar de descomponer la imagen original, nuestro objetivo es descomponer una **máscara**. Así, una red de segmentación tiene las siguientes partes:
Existen diferentes arquitecturas neuronales para la segmentación, pero todas tienen la misma estructura. De cierta manera, es similar al autoencoder que aprendiste anteriormente, pero en lugar de descomponer la imagen original, nuestro objetivo es descomponer una **máscara**. Por lo tanto, una red de segmentación tiene las siguientes partes:
* **Encoder** extrae características de la imagen de entrada.
* **Decoder** transforma esas características en la **imagen de máscara**, con el mismo tamaño y número de canales correspondiente al número de clases.
* **Codificador** extrae características de la imagen de entrada.
* **Decodificador** transforma esas características en la **imagen de máscara**, con el mismo tamaño y número de canales correspondientes al número de clases.
<img src="images/segm.png" width="80%">
> Imagen de [esta publicación](https://arxiv.org/pdf/2001.05566.pdf)
Debemos mencionar especialmente la función de pérdida que se utiliza para la segmentación. Al usar autoencoders clásicos, necesitamos medir la similitud entre dos imágenes, y podemos usar el error cuadrático medio (MSE) para hacerlo. En la segmentación, cada píxel en la imagen de máscara objetivo representa el número de clase (codificado en one-hot a lo largo de la tercera dimensión), por lo que necesitamos usar funciones de pérdida específicas para la clasificación: pérdida de entropía cruzada, promediada sobre todos los píxeles. Si la máscara es binaria, se utiliza **pérdida de entropía cruzada binaria** (BCE).
Debemos mencionar especialmente la función de pérdida que se utiliza para la segmentación. Al usar autoencoders clásicos, necesitamos medir la similitud entre dos imágenes, y podemos usar el error cuadrático medio (MSE) para hacerlo. En la segmentación, cada píxel en la imagen de máscara objetivo representa el número de clase (codificado en formato one-hot a lo largo de la tercera dimensión), por lo que necesitamos usar funciones de pérdida específicas para clasificación: pérdida de entropía cruzada, promediada sobre todos los píxeles. Si la máscara es binaria, se utiliza la **pérdida de entropía cruzada binaria** (BCE).
> ✅ La codificación one-hot es una forma de codificar una etiqueta de clase en un vector de longitud igual al número de clases. Echa un vistazo a [este artículo](https://datagy.io/sklearn-one-hot-encode/) sobre esta técnica.
> ✅ La codificación one-hot es una forma de codificar una etiqueta de clase en un vector de longitud igual al número de clases. Consulta [este artículo](https://datagy.io/sklearn-one-hot-encode/) sobre esta técnica.
## Segmentación para Imágenes Médicas
En esta lección, veremos la segmentación en acción entrenando la red para reconocer nevos humanos (también conocidos como lunares) en imágenes médicas. Usaremos la <a href="https://www.fc.up.pt/addi/ph2%20database.html">Base de Datos PH<sup>2</sup></a> de imágenes de dermatoscopia como fuente de imágenes. Este conjunto de datos contiene 200 imágenes de tres clases: nevo típico, nevo atípico y melanoma. Todas las imágenes también contienen una **máscara** correspondiente que delimita el nevo.
En esta lección, veremos la segmentación en acción entrenando una red para reconocer nevos humanos (también conocidos como lunares) en imágenes médicas. Utilizaremos la <a href="https://www.fc.up.pt/addi/ph2%20database.html">Base de Datos PH<sup>2</sup></a> de imágenes de dermoscopía como fuente de imágenes. Este conjunto de datos contiene 200 imágenes de tres clases: nevo típico, nevo atípico y melanoma. Todas las imágenes también contienen una **máscara** correspondiente que delimita el nevo.
> ✅ Esta técnica es particularmente adecuada para este tipo de imágenes médicas, pero ¿qué otras aplicaciones del mundo real podrías imaginar?
@ -42,12 +51,12 @@ Entrenaremos un modelo para segmentar cualquier nevo de su fondo.
## ✍️ Ejercicios: Segmentación Semántica
Abre los cuadernos a continuación para aprender más sobre diferentes arquitecturas de segmentación semántica, practicar con ellas y verlas en acción.
Abre los siguientes notebooks para aprender más sobre diferentes arquitecturas de segmentación semántica, practicar con ellas y verlas en acción.
* [Segmentación Semántica Pytorch](../../../../../lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationPytorch.ipynb)
* [Segmentación Semántica TensorFlow](../../../../../lessons/4-ComputerVision/12-Segmentation/SemanticSegmentationTF.ipynb)
## [Cuestionario posterior a la clase](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/212)
## [Cuestionario posterior a la lección](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/212)
## Conclusión
@ -55,15 +64,15 @@ La segmentación es una técnica muy poderosa para la clasificación de imágene
## 🚀 Desafío
La segmentación del cuerpo es solo una de las tareas comunes que podemos realizar con imágenes de personas. Otras tareas importantes incluyen la **detección de esqueletos** y la **detección de poses**. Prueba la biblioteca [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) para ver cómo se puede utilizar la detección de poses.
La segmentación corporal es solo una de las tareas comunes que podemos realizar con imágenes de personas. Otras tareas importantes incluyen la **detección de esqueletos** y la **detección de poses**. Prueba la biblioteca [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) para ver cómo se puede utilizar la detección de poses.
## Revisión y Autoestudio
Este [artículo de Wikipedia](https://wikipedia.org/wiki/Image_segmentation) ofrece una buena visión general de las diversas aplicaciones de esta técnica. Aprende más por tu cuenta sobre los subdominios de la segmentación por instancias y la segmentación panóptica en este campo de estudio.
Este [artículo de Wikipedia](https://wikipedia.org/wiki/Image_segmentation) ofrece una buena visión general de las diversas aplicaciones de esta técnica. Aprende más por tu cuenta sobre los subdominios de la segmentación por instancia y la segmentación panóptica en este campo de investigación.
## [Tarea](lab/README.md)
## [Asignación](lab/README.md)
En este laboratorio, intenta **segmentación del cuerpo humano** utilizando el [Conjunto de Datos de Segmentación del Cuerpo Completo MADS](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) de Kaggle.
En este laboratorio, intenta la **segmentación del cuerpo humano** utilizando el [Conjunto de Datos de Segmentación Corporal Completa MADS](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) de Kaggle.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Si bien nos esforzamos por lograr 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 la traducción profesional humana. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

21
translations/es/lessons/4-ComputerVision/12-Segmentation/lab/README.md
View File

@ -1,22 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "365f0decfe0f47b460bbde8227c5009d",
"translation_date": "2025-08-24T09:16:22+00:00",
"source_file": "lessons/4-ComputerVision/12-Segmentation/lab/README.md",
"language_code": "es"
}
-->
# Segmentación del Cuerpo Humano
Tarea del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
Asignación de laboratorio del [Currículo de IA para Principiantes](https://github.com/microsoft/ai-for-beginners).
## Tarea
En la producción de video, por ejemplo, en pronósticos del tiempo, a menudo necesitamos recortar una imagen humana de la cámara y colocarla sobre otro metraje. Esto se hace típicamente utilizando técnicas de **chroma key**, cuando una persona es filmada frente a un fondo de color uniforme, que luego se elimina. En este laboratorio, entrenaremos un modelo de red neuronal para recortar la silueta humana.
En la producción de video, por ejemplo, en los pronósticos del tiempo, a menudo necesitamos recortar la imagen de una persona capturada por la cámara y colocarla sobre otro metraje. Esto se realiza típicamente utilizando técnicas de **chroma key**, donde se graba a una persona frente a un fondo de color uniforme, que luego se elimina. En este laboratorio, entrenaremos un modelo de red neuronal para recortar la silueta humana.
## El Conjunto de Datos
Usaremos el [Conjunto de Datos de Segmentación de Cuerpo Completo MADS](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) de Kaggle. Descarga el conjunto de datos manualmente desde Kaggle.
Utilizaremos el [Conjunto de Datos de Segmentación de Cuerpo Completo MADS](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) de Kaggle. Descarga el conjunto de datos manualmente desde Kaggle.
## Iniciando el Notebook
## Cuaderno Inicial
Comienza el laboratorio abriendo [BodySegmentation.ipynb](../../../../../../lessons/4-ComputerVision/12-Segmentation/lab/BodySegmentation.ipynb)
## Conclusión
La segmentación del cuerpo es solo una de las tareas comunes que podemos realizar con imágenes de personas. Otras tareas importantes incluyen **detección de esqueletos** y **detección de poses**. Consulta la biblioteca [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) para ver cómo se pueden implementar esas tareas.
La segmentación del cuerpo es solo una de las tareas comunes que podemos realizar con imágenes de personas. Otras tareas importantes incluyen la **detección de esqueletos** y la **detección de poses**. Consulta la biblioteca [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) para ver cómo se pueden implementar estas tareas.
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en IA. Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional humana. No nos hacemos responsables de ningún malentendido o mala interpretación que surja del uso de esta traducción.
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.

15
translations/es/lessons/4-ComputerVision/README.md
View File

@ -1,16 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "58a52f000089c1d8906a4daa4ab1169b",
"translation_date": "2025-08-24T09:15:28+00:00",
"source_file": "lessons/4-ComputerVision/README.md",
"language_code": "es"
}
-->
# Visión por Computadora
![Resumen del contenido de Visión por Computadora en un doodle](../../../../translated_images/ai-computervision.6506ebebac3fbf76cdb78989d7d3dfea87e88285c0feaade53aa7804a22b248f.es.png)
![Resumen del contenido de Visión por Computadora en un dibujo](../../../../lessons/sketchnotes/ai-computervision.png)
En esta sección aprenderemos sobre:
* [Introducción a la Visión por Computadora y OpenCV](06-IntroCV/README.md)
* [Redes Neuronales Convolucionales](07-ConvNets/README.md)
* [Redes Preentrenadas y Aprendizaje por Transferencia](08-TransferLearning/README.md)
* [Redes Pre-entrenadas y Aprendizaje por Transferencia](08-TransferLearning/README.md)
* [Autoencoders](09-Autoencoders/README.md)
* [Redes Generativas Antagónicas](10-GANs/README.md)
* [Detección de Objetos](11-ObjectDetection/README.md)
* [Segmentación Semántica](12-Segmentation/README.md)
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando servicios de traducción automática basados en inteligencia artificial. Aunque nos esforzamos por lograr la precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
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.

Some files were not shown because too many files have changed in this diff Show More