Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

Schrödinger programmiert KI¶

Hinweis zur Software-Auswahl:
Diese Dokumentation priorisiert Open-Source-Software, die unter Ubuntu installiert und betrieben werden kann.
Bei kommerziellen Services wird stets eine Open-Source-Alternative mit gleichem Funktionsumfang gegenübergestellt.
LLM-Modelle und APIs werden unabhängig vom Preis gelistet, da sie als Schnittstellen für eigene Anwendungen dienen.

Legende¶

Lernpfad-Übersicht¶

graph LR
    A["🟢 Phase 1\nGrundlagen & Mathe"] --> B["🟡 Phase 2\nNeuronale Netze"]
    B --> C["🔴 Phase 3\nNLP & Transformers"]
    A --> A1["ML vs. klassisch\nLineare Regression\nPerzeptron & Aktivierung"]
    B --> B1["Keras & PyTorch\nBackpropagation\nComputer Vision & CNNs"]
    C --> C1["NLP & Embeddings\nAttention & Transformers\nDeployment"]

Inhaltsverzeichnis¶

• 🟢 Phase 1 – Grundlagen & Erste Gehversuche
  • 1.1 Konzept: Klassische Programmierung vs. Maschinelles Lernen
  • 1.2 Konzept: Was ist ein Perzeptron?
  • 1.3 Thema: Lineare Regression mit Python
  • 1.4 Thema: Entwicklungsumgebung einrichten (Jupyter Lab)
• 🟡 Phase 2 – Deep Learning & Neuronale Netze
  • 2.1 Konzept: Wie lernt ein neuronales Netz? (Backpropagation)
  • 2.2 Thema: Erste Netze bauen mit Keras & PyTorch
  • 2.3 Thema: Bilderkennung mit Convolutional Neural Networks (CNN)
  • 2.4 Thema: Overfitting vermeiden (Regularisierung)
• 🔴 Phase 3 – Transformers, NLP & Eigene Modelle
  • 3.1 Konzept: NLP und der Weg zum Transformer
  • 3.2 Thema: Textklassifizierung und Embeddings
  • 3.3 Thema: Die Transformer-Architektur & Attention
  • 3.4 Thema: Eigene KI-Modelle deployen
• 📋 Praxisprojekte
• 📦 Vollständige Softwareübersicht & Vergleich

🟢 Phase 1 – Grundlagen & Erste Gehversuche¶

Was lerne ich hier?
Den Unterschied zwischen klassischem Code und KI, wie ein einzelnes künstliches Neuron (Perzeptron) funktioniert und wie man lineare Zusammenhänge vorhersagt.
Voraussetzungen: Python-Grundkenntnisse.

1.1 Konzept: Klassische Programmierung vs. Maschinelles Lernen¶

Der Paradigmenwechsel¶

In der klassischen Softwareentwicklung schreibt der Mensch Regeln und füttert sie mit Daten, um Antworten zu erhalten. Im Maschinellen Lernen füttert der Mensch Daten und Antworten (Labels) in die Maschine, und die KI berechnet die Regeln selbstständig.

Klassisch:  Daten + Regeln ----------> [ Programm ] ----------> Antworten
ML-Weg:     Daten + Antworten -------> [ Training ] ----------> Regeln (Modell)

1.2 Konzept: Was ist ein Perzeptron?¶

Das künstliche Neuron¶

Ein Perzeptron nimmt mehrere Eingabewerte ($x_1, x_2$), multipliziert sie mit Gewichten ($w_1, w_2$), addiert einen Bias ($b$) und jagt das Ergebnis durch eine Aktivierungsfunktion (z. B. die Sigmoid-Funktion), um eine Ausgabe (0 oder 1) zu erzeugen.

x1 --( * w1 )--\
                +--> [ Summe + Bias ] --> [ Aktivierungsfunktion ] --> Output (y)
x2 --( * w2 )--/

1.3 Thema: Lineare Regression mit Python¶

Konzept: Die Regressionsgerade¶

Die lineare Regression versucht, eine gerade Linie durch Datenpunkte zu legen, um Vorhersagen zu treffen ($y = m \cdot x + b$). Die Abweichungen der Punkte zur Linie (Loss) werden über die Methode der kleinsten Quadrate (MSE) minimiert.

Software – alle Open Source:¶

1.4 Thema: Entwicklungsumgebung einrichten (Jupyter Lab)¶

Konzept: Interaktives Coding (REPL)¶

KI-Entwicklung ist experimentell. Anstatt das gesamte Skript neu zu starten, erlauben Jupyter Notebooks das Ausführen einzelner Code-Zellen im Webbrowser, während Variablen im RAM erhalten bleiben.

Software – Open Source zuerst:¶

Vergleich: Open Source vs. Kommerziell¶

🟡 Phase 2 – Deep Learning & Neuronale Netze¶

Was lerne ich hier?
Wie du neuronale Netze mit mehreren Schichten aufbaust, Bilder klassifizierst und verhinderst, dass deine KI auswendig lernt.
Voraussetzungen: Phase 1 abgeschlossen.

2.1 Konzept: Wie lernt ein neuronales Netz? (Backpropagation)¶

Vorwärts & Rückwärts durch das Netz¶

graph LR
    A["📥 Input"] -->|Forward Pass| B["⚙️ Hidden Layers"]
    B -->|Forward Pass| C["📤 Output"]
    C -->|Loss berechnen| D["📉 Loss Function"]
    D -->|Derivate berechnen| E["🔄 Backpropagation"]
    E -->|Gewichte anpassen| B

1. Forward Pass: Daten fließen durch das Netz; eine Vorhersage wird getroffen.
2. Loss Function (Fehlerfunktion): Berechnet, wie weit die Vorhersage vom echten Wert entfernt ist.
3. Backpropagation: Der Fehler wird rückwärts durch das Netz geleitet (Kettenregel der Ableitung), um zu berechnen, welches Gewicht wie stark angepasst werden muss.
4. Gradient Descent: Die Gewichte werden angepasst, um den Fehler zu minimieren.

2.2 Thema: Erste Netze bauen mit Keras & PyTorch¶

Konzept: Deklarativer vs. Imperativer Code¶

• Keras (TensorFlow): Sehr einfach, baut Netze wie Legosteine (sequenziell).
• PyTorch: Flexibel, dynamisch, objektorientiert. Standard in der Forschung.

# Keras – Minimales Beispiel
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(64, activation='relu', input_shape=(10,)),
    keras.layers.Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy')

Software – alle Open Source:¶

2.3 Thema: Bilderkennung mit Convolutional Neural Networks (CNN)¶

Konzept: Wie KIs Bilder „sehen"¶

Ein normales Netz scheitert an Bildern, da es die räumliche Struktur verliert. CNNs nutzen Filter (Faltungen / Convolutions), um Kanten, Formen und schließlich Objekte im Bild zu erkennen.

Bild (Pixel-Matrix) -> Convolution (Filter anwenden) -> Pooling (Auflösung reduzieren) -> Dense Layer

Software – alle Open Source:¶

2.4 Thema: Overfitting vermeiden (Regularisierung)¶

Auswendiglernen verhindern¶

Wenn eine KI auf den Trainingsdaten 100% erreicht, aber auf Testdaten schlecht abschneidet, hat sie die Daten überangepasst (Overfitting). Sie hat auswendig gelernt statt generalisiert.

🔴 Phase 3 – Transformers, NLP & Eigene Modelle¶

Was lerne ich hier?
Wie Sprachmodelle Text verarbeiten, was der Attention-Mechanismus ist und wie du eigene kleine Modelle stabil auf Servern betreibst.
Voraussetzungen: Phase 1 & 2 abgeschlossen.

3.1 Konzept: NLP und der Weg zum Transformer¶

Die Evolution der Textverarbeitung¶

1. Bag of Words / One-Hot Encoding: Wörter werden isoliert gezählt. Wortreihenfolge und Bedeutung gehen verloren.
2. RNN / LSTM: Verarbeitet Wörter nacheinander. Hat ein Kurzzeitgedächtnis, scheitert aber an langen Sätzen.
3. Transformer (Attention): Verarbeitet alle Wörter gleichzeitig und berechnet, welche Wörter im Satz zueinander in Beziehung stehen (Kontext).

3.2 Thema: Textklassifizierung und Embeddings¶

Konzept: Text in Vektoren wandeln¶

Ein Embedding-Modell übersetzt Wörter in mehrdimensionale Vektoren. Wörter mit ähnlicher Bedeutung liegen im Vektorraum nah beieinander.

Software – alle Open Source:¶

3.3 Thema: Die Transformer-Architektur & Attention¶

Konzept: Self-Attention (Selbstaufmerksamkeit)¶

Im Satz „Die Bank am Fluss war nass" und „Die Bank zahlte kein Geld aus" lernt das Modell über Attention, dass das Wort „Bank" im ersten Satz mit „Fluss" (Sitzbank) und im zweiten Satz mit „Geld" (Geldinstitut) verknüpft ist.

Software – alle Open Source:¶

3.4 Thema: Eigene KI-Modelle deployen¶

Konzept: API-Hosting mit FastAPI¶

Nach dem Training wird das Modell als Datei (.pth oder .h5) gespeichert. Ein Python-Backend lädt das Modell und stellt eine API bereit.

# FastAPI API-Hosting
from fastapi import FastAPI
import torch

app = FastAPI()
model = torch.load("modell.pth")

@app.post("/predict")
def predict(data: list):
    input_tensor = torch.tensor(data)
    with torch.no_grad():
        prediction = model(input_tensor)
    return {"prediction": prediction.tolist()}

Software – Open Source zuerst:¶

Vergleich: Open Source vs. Kommerziell¶

📋 Praxisprojekte¶

🟢 Einsteiger: Blumen-Klassifikation mit scikit-learn¶

Der Einstiegsklassiker: Wir nutzen den Iris-Datensatz und klassifizieren Schwertlilien anhand ihrer Kelch- und Kronblätter.

# Iris-Klassifikation mit scikit-learn
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2)

clf = RandomForestClassifier()
clf.fit(X_train, y_train)
print(f"Genauigkeit: {clf.score(X_test, y_test) * 100:.2f}%")

Software (alle Open Source): Python · scikit-learn · NumPy

🟡 Fortgeschritten: Ziffernerkennung mit CNN (MNIST)¶

Wir bauen ein neuronales Netz, das handgeschriebene Zahlen (0–9) aus Bildern liest.

graph LR
    A["🖼️ 28x28 Graustufen-Bild"] --> B["⚙️ Convolution (CNN)"]
    B --> C["⚡ Max Pooling"]
    C --> D["🧱 Dense Layer"]
    D --> E["📤 Ausgabe: Zahl (0-9)"]

Software (alle Open Source): Jupyter Lab · TensorFlow / Keras · Matplotlib

🔴 Experte: Stimmungsanalyse (Sentiment Analysis) API¶

Wir nutzen ein vortrainiertes BERT-Modell von Hugging Face, klassifizieren eingegebene Sätze in positiv/negativ und deployen das Ganze als FastAPI-Webservice.

graph TD
    A["🧑‍💻 Client sendet Text"] --> B["⚡ FastAPI Endpunkt"]
    B --> C["🔤 Hugging Face Tokenizer"]
    C --> D["🧠 BERT Model (PyTorch)"]
    D --> E["📊 Score: Positiv (98%)"]
    E --> F["📤 JSON-Antwort an Client"]

Software (alle Open Source): FastAPI · Transformers · PyTorch · Docker

📦 Vollständige Softwareübersicht & Vergleich¶

Entwicklerwerkzeuge & Bibliotheken¶

IDE & Hosting¶

Weiterführende Ressourcen¶

• Scikit-Learn Tutorials – Einstiegs-ML-Doku
• PyTorch Tutorials – Deep-Learning-Schritt-für-Schritt-Anleitungen 🟩
• Hugging Face Course – Ausgezeichneter Kurs zu Transformers 🟩
• FastAPI Dokumentation – APIs richtig aufbauen 🟩
• Jupyter Projekt – Notebook-Guides 🟩

Letzte Aktualisierung: Juli 2026

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).