---
title: "MiniMind selbst trainieren: Zeit und Kosten auf der RTX 3090"
canonical: https://wavect.io/de/blog/minimind-training-from-scratch/
language: de
description: "MiniMind-3 Zero auf einer RTX 3090 selbst trainieren. Prüfe die Schätzung von 2,31 Stunden, die nötigen Befehle und deine SFT-Daten mit dem Offline-Test."
image: "https://wavect.io/img/blog/headers/header_minimind-training-from-scratch.png"
author: ["Kevin Riedl"]
published: "2026-11-16"
updated: "2026-11-16"
reviewed: "2026-11-16"
---

# Kannst du MiniMind auf einer RTX 3090 in zwei Stunden selbst trainieren?

[**Zurück**](/de/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/de/team/kevin-riedl/)

[Kevin Riedl](/de/team/kevin-riedl/) https://linkedin.com/in/wsdt

7 min Lesezeit · 16. November 2026 Zuletzt geprüft 16. November 2026

[**Weiter**](/de/blog/fine-tune-gemma-4-free-unsloth-colab/)

TL;DR

Für MiniMind-3 Zero schätzt das Projekt 2,31 Stunden und 3,00 CNY auf einer RTX 3090. Das umfasst je eine Epoche Vortraining und überwachtes Fine-Tuning mit zwei vorbereiteten Datensätzen. Übergib beiden Skripten ausdrücklich --epochs 1, denn standardmäßig planen sie je zwei Epochen ein. Prüfe vor dem GPU-Lauf auch die Trainingsziele. Im Offline-Test lieferte ein kurzer Dialog vier Zielpositionen, derselbe Dialog mit einer langen Nutzernachricht keine einzige.

Bei einer LLM-API siehst du die fertige Antwort. Mit MiniMind kannst du auf dem eigenen Rechner beobachten, wie ein Modell überhaupt dorthin kommt. Du startest mit zufälligen Gewichten. Erst lernt das Modell, das nächste Token vorherzusagen. Dann lernt es, in einem Gespräch die Antwort des Assistenten zu schreiben. Speichere nach jeder Stufe die Gewichte und stelle beiden Modellen dieselbe Frage.

## Was ist in den zwei Stunden für MiniMind enthalten?

Für MiniMind-3 Zero mit 64 Millionen Parametern und dichter Architektur schätzen die Entwickler **2,31 Stunden auf einer RTX 3090 mit 24 GB**. Das sind rund 2 Stunden 19 Minuten für je einen Durchlauf über zwei vorbereitete Datensätze.

Die Fußnote im README nennt eine separate Messung von rund zwei Stunden allein für eine Epoche überwachtes Fine-Tuning. Wie die Angaben zusammenhängen, bleibt offen. Für deinen Versuch kannst du mit der Aufschlüsselung je Stufe rechnen. [Zeitangabe in der Einleitung des Projekts](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/README_en.md#L34-L42)

| Trainingsstufe | GPU-Zeit | Geschätzte Miete |
| --- | --- | --- |
| Vortraining mit dem kleinen Textkorpus | 1,21 h | 1,57 CNY |
| Überwachtes Fine-Tuning mit dem kleinen Dialogdatensatz | 1,10 h | 1,43 CNY |
| Beide Stufen, jeweils eine Epoche | 2,31 h | 3,00 CNY |

Eine Epoche ist ein vollständiger Durchlauf über einen Datensatz. Für Download und PyTorch-Installation brauchst du zusätzlich Zeit. In der Kostentabelle des Projekts stehen das Training von Werkzeugaufrufen und Reinforcement Learning in eigenen Spalten. Willst du erleben, wie aus zufälligen Gewichten ein Modell für den ersten Dialog entsteht, kannst du nach dem Fine-Tuning aufhören. [MiniMinds GPU-Kalkulation je Trainingsstufe](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/README_en.md#L613-L644)

## Wie trainierst du MiniMind Zero von Grund auf?

Du brauchst einen frischen Checkout, die beiden Dateien mit der Endung `_mini.jsonl` und den mitgelieferten Tokenizer. Übergib beiden Trainingsskripten `--epochs 1`. Ohne diesen Parameter laufen **jeweils zwei Epochen**. Mit `--from_weight none` beginnt das Vortraining mit zufälligen Gewichten. Das anschließende Fine-Tuning lädt den Checkpoint `pretrain`. [Parameter für das Vortraining](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/trainer/train_pretrain.py#L75-L96) · [Parameter für das überwachte Fine-Tuning](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/trainer/train_full_sft.py#L75-L97)

Klone `https://github.com/jingyaogong/minimind.git` und wechsle ins Repository. Verwende eine frische Python-Umgebung mit einer CUDA-fähigen PyTorch-Version für deine GPU. Führe dort die folgenden Befehle aus. Die Abfrage sollte `True` ausgeben, bevor du mit der GPU-Zeit kalkulierst. Die Trainingsschleifen sind in PyTorch implementiert. Für den Tokenizer verwenden sie Hugging Face Transformers, zum Einlesen der Trainingsdaten die Bibliothek Datasets. [Python-Abhängigkeiten des Projekts](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/requirements.txt)

```
git checkout 233d00fa068ec2b8c0d4f07b703934d6391a5a73
python -m pip install -r requirements.txt
python -c "import torch; print(torch.cuda.is_available())"
```

Lege `pretrain_t2t_mini.jsonl` und `sft_t2t_mini.jsonl` im Verzeichnis `dataset/` ab. Laut Projekt sind sie etwa 1,2 GB und 1,6 GB groß. Die Versionen ohne `_mini` umfassen 10 GB und 14 GB. Bereinigung und Dublettenprüfung gehören zur Aufbereitung des Korpus. Bei Zero sind die Daten bereits vorbereitet und das Vokabular steht fest. [Trainingsdaten für MiniMind herunterladen](https://huggingface.co/datasets/jingyaogong/minimind_dataset/tree/main)

```
cd trainer
python train_pretrain.py --epochs 1 --from_weight none
python train_full_sft.py --epochs 1 --from_weight pretrain
cd ..
python eval_llm.py --weight pretrain --max_new_tokens 80
python eval_llm.py --weight full_sft --max_new_tokens 80
```

Die Gewichte landen standardmäßig in `out/pretrain_768.pth` und `out/full_sft_768.pth`. Beende den ersten interaktiven Test, bevor du den zweiten startest. Gib dem Basismodell einen kurzen Text zum Fortsetzen und dem Chatmodell anschließend eine einfache Anweisung. Heb die Eingaben und beide Ausgaben auf. Das Testskript lässt den ersten Checkpoint Text fortsetzen und formatiert die Eingabe für den zweiten als Chat. [So lädt und testet MiniMind die Checkpoints](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/eval_llm.py)

Wir haben die Übergabe mit den verlinkten Skripten auf der CPU geprüft. Dafür genügten eine Schicht mit Breite 64 und zwei synthetische Beispiele pro Stufe. Beide Trainer schrieben ihre Gewichte auf die Festplatte. Das Evaluationsskript lud beide Zwischenstände und erzeugte jeweils vier Tokens. Der Test prüft den Ablauf. Die GPU-Zeit für das 64M-Modell stammt vom Projekt.

## Warum lernt MiniMind aus manchen gültigen Trainingsbeispielen nichts?

Ein Dialog kann gültiges JSON enthalten und trotzdem kein einziges Antworttoken zum Training beitragen. Der SFT-Datenlader formatiert das Gespräch, kürzt es auf die vorgegebene Länge und markiert die Antwort des Assistenten als Lernziel. Füllt die Nachricht des Nutzers alle 768 Positionen, fällt schon die Rollenmarkierung des Assistenten weg. Damit geht das gesamte Beispiel mit null Zielpositionen in die Verlustberechnung ein. [Chatformat, Kürzung und Maskierung der Trainingsziele im Quellcode](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/dataset/lm_dataset.py#L63-L119)

Wir haben den Tokenizer und den SFT-Datenlader des Projekts offline mit zwei künstlichen Dialogen getestet. Die Systemnachricht war identisch, der Assistent antwortete beide Male mit `OK`. Im kurzen Dialog blieben vier Zielpositionen übrig, einschließlich Endemarkierung und Zeilenumbruch. Nach 500 Wiederholungen von `status`in der Nutzernachricht waren es null. Die gesamte Antwort lag hinter der Längengrenze.

Lade das [Prüfskript für die SFT-Zielpositionen](/downloads/minimind-sft-target-check.py) herunter. Wechsle ins Stammverzeichnis des oben festgelegten MiniMind-Commits und führe dort in derselben Python-Umgebung `python /path/to/minimind-sft-target-check.py` aus. Modellgewichte brauchst du dafür keine. Probiere das anschließend mit deinen längsten Supportdialogen. Zähle nach dem Kürzen alle Labels, deren Wert von `-100` abweicht. Bleibt kein Ziel übrig, kürze oder teile den Dialog und prüfe den dekodierten Antworttext. Selbst ein sinkender durchschnittlicher Loss kann solche leeren Trainingsbeispiele verdecken.

## Welches Training lohnt sich nach dem überwachten Fine-Tuning?

Schau zuerst auf die Daten, die du liefern kannst. Eine Sammlung guter Antworten eignet sich für überwachtes Fine-Tuning. Hast du für dieselbe Frage zwei Antworten und weißt, welche ein Prüfer vorzieht, bietet sich DPO an. Lässt sich das Ergebnis einer Aufgabe bewerten, etwa ob ein Modell den Taschenrechner mit den richtigen Zahlen aufruft, kannst du Reinforcement Learning ausprobieren. Jede Methode hat ein eigenes Skript. [Die Trainingsskripte von MiniMind](https://github.com/jingyaogong/minimind/tree/233d00fa068ec2b8c0d4f07b703934d6391a5a73/trainer)

| Methode | Was du bereitstellst oder prüfst |
| --- | --- |
| LoRA | Trainiere kleine Adapter auf Beispielen aus deinem Fachgebiet. Die Gewichte des Basismodells bleiben dabei fest. |
| DPO | Gib zu einem Prompt eine bevorzugte und eine verworfene Antwort an. Dieses Paar hält die Präferenz fest. |
| PPO und GRPO | Lass das Modell Antworten erzeugen und bewerte sie. PPO lernt, den erwarteten Ertrag zu schätzen. GRPO vergleicht die Bewertungen mehrerer Antworten auf denselben Prompt. |
| Werkzeugaufrufe und Agentic RL | Beispiele vermitteln das Format des Werkzeugaufrufs. Beim Agententraining kann das Modell das Werkzeugergebnis im nächsten Schritt verwenden. Standardmäßig optimiert es mit CISPO. GRPO steht ebenfalls zur Wahl. |
| Distillation | Antworten eines Lehrermodells eignen sich als SFT-Beispiele. Das separate Distillationsskript kann auch aus dessen Wahrscheinlichkeitsverteilung für das nächste Token lernen. |

Lass das Modell zwei Preise addieren und schau dir den Aufruf an. Der Taschenrechner erwartet genau ein Argument, die Zeichenkette `expression`. Ändere die Preise und wiederhole den Versuch. Den Rechenoperator, die beiden Zahlen im Ausdruck und die zurückgegebene Summe kannst du getrennt prüfen. [Agententraining und eingebaute Werkzeuge](https://github.com/jingyaogong/minimind/blob/233d00fa068ec2b8c0d4f07b703934d6391a5a73/trainer/train_agent.py)

## Wann lohnt sich eigenes Vortraining und wann ein fertiger Checkpoint?

Ich würde MiniMind von Grund auf trainieren, um zu verstehen, was Tokenizer, Loss-Maske und Optimierer jeweils beitragen. Soll ein Team eingehende Tickets sortieren oder einen bestimmten Schreibstil treffen, würde ich zuerst ein vorhandenes Modell mit bewerteten Beispielen testen. Dann hat das Team einen Vergleichswert, bevor es in einen eigenen Trainingskorpus investiert.

Das dichte MiniMind-3 hat acht Decoder-Schichten mit einer Breite von 768. Auf dem `meta`-Gerät von PyTorch haben wir 63.912.192 Modellparameter gezählt. Das Projekt rundet auf 64 Millionen. Die größte ursprüngliche GPT-3-Version hat mit 175 Milliarden Parametern rund 2.700-mal so viele. Ob das kleine Modell deine Supporttickets richtig einordnet, erfährst du mit einem Test auf diesen Tickets. [Modellkonfiguration von MiniMind-3](https://huggingface.co/jingyaogong/minimind-3/blob/2943d182f4a9ee0cd3dfd41bb847aac41b241bff/config.json) · [Originalveröffentlichung zu GPT-3](https://arxiv.org/abs/2005.14165)

Unsere [Anleitung zum Fine-Tuning von Gemma](/de/blog/fine-tune-gemma-4-free-unsloth-colab/) setzt bei vortrainierten Gewichten an. Unsere [Analyse von Airbnbs Experiment mit einem kleinen Modell](/de/blog/airbnb-small-model-fine-tuning/) geht der Frage nach, wann sich ein spezialisiertes Modell im Produktivbetrieb rechnet.

## Häufige Fragen zum Training mit MiniMind

### Brauche ich die acht GPUs aus der Projektbeschreibung?

Die Entwickler nennen eine Workstation mit acht Karten als Referenzsystem. Ihre Schätzung für Zero bezieht sich auf eine einzelne RTX 3090 mit 24 GB Speicher. Ermittelst du den Aufwand für eine andere GPU, miss zuerst die Zeit pro Trainingsschritt bei deiner Batchgröße und Sequenzlänge.

### Muss ich zuerst einen Tokenizer trainieren?

Für Zero nimmst du den Tokenizer aus dem Repository. Von Grund auf trainierst du hier die Gewichte des Sprachmodells. Mit demselben Tokenizer kannst du deine Checkpoints bei gleichem Vokabular und identischen Rollenmarkierungen vergleichen.

### Kann ich MiniMind vor dem Training ausprobieren?

Ja. Das Projekt veröffentlicht auch vortrainierte Gewichte. Lade einen Checkpoint und sieh dir die Antworten an. Willst du den Effekt des Vortrainings beobachten, starte dafür einen separaten Lauf mit zufälligen Gewichten.

### Erhalte ich nach zwei Stunden das veröffentlichte vollständige Modell?

Zero ist der kurze Trainingslauf für einen Dialog mit den beiden Mini-Datensätzen. Das Projekt beschreibt auch größere Korpora, längere Läufe und zusätzliche Trainingsziele. Halte Startgewichte, Datensätze und Stufen fest, wenn du deinen Checkpoint mit einem heruntergeladenen vergleichst.

### Wo finde ich die Varianten für Bilder, multimodale Eingaben und Diffusion?

MiniMind-V ist das Projekt für Bilder und Sprache. MiniMind-O ist das separate multimodale Omni-Projekt. Das Sprachmodell mit Diffusion bezeichnen die Entwickler als experimentelle Erweiterung. Jede Variante nutzt einen eigenen Trainingsaufbau.

[MiniMind-V für Bilder und Sprache](https://github.com/jingyaogong/minimind-v) · [Das multimodale Projekt MiniMind-O](https://github.com/jingyaogong/minimind-o) · [Experimentelles Diffusionssprachmodell](https://github.com/jingyaogong/minimind/discussions/618)

Modelle und Infrastruktur

## Weiterlesen

Modellauswahl, Inferenzkosten, lokaler Betrieb, Kompression und Serving-Architektur.

[Hier starten**LLMs in der EU selbst hosten: Wann sich Open Weights wirklich rechnen**](/de/blog/self-hosting-llms-eu-cost/)

- [Wie viele Tokens spart Code Mode in Claude Code?](/de/blog/claude-code-code-mode-token-usage/)
- [KI-Credits in Odoo: Budget für geprüfte Angebote](/de/blog/odoo-ai-cost-per-accepted-workflow/)
- [Odoo Helpdesk mit KI: einordnen, entwerfen oder eskalieren?](/de/blog/odoo-helpdesk-ai-classify-draft-escalate/)
- [Open Ontologies: Herleitungszertifikate prüfen](/de/blog/open-ontologies-proof-verification/)
- [Speichert Scrapling extrahierte Datensätze in Checkpoints?](/de/blog/scrapling-checkpoints-scraped-items/)

[Vorheriger Artikel**Wie viele Tokens spart Code Mode in Claude Code?**](/de/blog/claude-code-code-mode-token-usage/) [Nächster Artikel**KI-Credits in Odoo: Budget für geprüfte Angebote**](/de/blog/odoo-ai-cost-per-accepted-workflow/)

[**Zurück**](/de/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/de/team/kevin-riedl/)

[Kevin Riedl](/de/team/kevin-riedl/) https://linkedin.com/in/wsdt

7 min Lesezeit · 16. November 2026 Zuletzt geprüft 16. November 2026

[**Weiter**](/de/blog/fine-tune-gemma-4-free-unsloth-colab/)
