# Bereitstellen von LLMs mit Hugging Face Jobs

Diese Anleitung behandelt, wie man [Unsloth](https://github.com/unslothai/unsloth) und [lfm2.5](https://unsloth.ai/docs/de/modelle/tutorials/lfm2.5 "mention") für schnelles Feintuning von LLMs über Coding-Agenten wie [claude-code](https://unsloth.ai/docs/de/grundlagen/claude-code "mention"). Unsloth bietet etwa 2x schnellere Trainingszeiten und etwa 60 % weniger VRAM-Nutzung im Vergleich zu Standardmethoden.

### Sie benötigen

* Ein [Hugging Face](https://huggingface.co) Konto (erforderlich für HF Jobs)
* Ein Hugging Face-Token mit Schreibberechtigungen
* Einen Coding-Agenten (Open Code, Claude Code, Codex)
* Lesen Sie unser [claude-code](https://unsloth.ai/docs/de/grundlagen/claude-code "mention") Handbuch zur Einrichtung.

### Installation der Skill

#### Claude Code

Claude Code entdeckt Skills über sein [Plugin-System](https://code.claude.com/docs/en/discover-plugins).

1. Fügen Sie den Marktplatz hinzu:

```bash
/plugin marketplace add huggingface/skills
```

2. Durchsuchen Sie verfügbare Skills im **Entdecken** Tab:

```bash
/plugin
```

3. Installieren Sie die Model Trainer-Skill:

```bash
/plugin install hugging-face-model-trainer@huggingface-skills
```

Für weitere Details siehe das [Claude Code Plugins-Dokumentation](https://code.claude.com/docs/en/discover-plugins) und die [Skills-Dokumentation](https://code.claude.com/docs/en/skills).

#### Codex

Codex entdeckt Skills durch [`AGENTS.md`](https://developers.openai.com/codex/guides/agents-md) Dateien und [`.agents/skills/`](https://developers.openai.com/codex/skills) Verzeichnisse.

**Installieren Sie einzelne Skills mit `$skill-installer`**

{% code overflow="wrap" %}

```bash
$skill-installer install https://github.com/huggingface/skills/tree/main/skills/hugging-face-model-trainer
```

{% endcode %}

Für weitere Details siehe das [Codex Skills-Dokumentation](https://developers.openai.com/codex/skills) und die [AGENTS.md Anleitung](https://developers.openai.com/codex/guides/agents-md).

### Schnellstart

Sobald die Skill installiert ist, bitten Sie Ihren Coding-Agenten, ein Modell zu trainieren. Wir verwenden [lfm2.5](https://unsloth.ai/docs/de/modelle/tutorials/lfm2.5 "mention")

{% code overflow="wrap" %}

```
Train LiquidAI/LFM2.5-1.2B-Instruct auf trl-lib/Capybara mit Unsloth auf HF Jobs
```

{% endcode %}

Der Agent wird ein Trainingsskript basierend auf einem [Beispiel in der Skill](https://github.com/huggingface/skills/blob/main/skills/hugging-face-model-trainer/scripts/unsloth_sft_example.py)generieren, das Training an HF Jobs übermitteln und einen Überwachungslink über Trackio bereitstellen.

### Verwendung von Hugging Face Jobs

Trainings-Jobs laufen auf [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs) — vollständig verwalteten Cloud-GPUs. Wenn Sie mit Google Colab-Guthaben vertraut sind, bietet Hugging Face Jobs ein ähnliches Guthabensystem. Es handelt sich um ein Pay-As-You-Go-Modell, oder Sie können Guthaben im Voraus erhalten. Der Agent:

1. Erzeugt ein UV-Skript mit eingebetteten Abhängigkeiten
2. Übermittelt es an HF Jobs über das `hf` CLI
3. Meldet die Job-ID und die Überwachungs-URL
4. Das trainierte Modell wird in Ihr Hugging Face Hub-Repository hochgeladen

#### Beispiel-Trainingsskript

Die Skill erzeugt Skripte wie dieses:

{% code expandable="true" %}

```py
# /// script
# dependencies = ["unsloth", "trl>=0.12.0", "datasets", "trackio"]
# ///

from unsloth import FastLanguageModel
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

model, tokenizer = FastLanguageModel.from_pretrained(
    "Qwen/Qwen2.5-0.5B",
    load_in_4bit=True,
    max_seq_length=2048,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=32,
    lora_dropout=0,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)

dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    args=SFTConfig(
        output_dir="./output",
        push_to_hub=True,
        hub_model_id="username/my-model",
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        num_train_epochs=1,
        learning_rate=2e-4,
        report_to="trackio",
    ),
)

trainer.train()
trainer.push_to_hub()
```

{% endcode %}

Die Kosten für das Training mit Hugging Face Jobs sind unten aufgeführt:

| Modellgröße     | Empfohlene GPU | Ungefähre Kosten/Stunde |
| --------------- | -------------- | ----------------------- |
| <1B Parameter   | `t4-small`     | \~$0.40                 |
| 1-3B Parameter  | `t4-medium`    | \~$0.60                 |
| 3-7B Parameter  | `a10g-small`   | \~$1.00                 |
| 7-13B Parameter | `a10g-large`   | \~$3.00                 |

Für einen vollständigen Überblick über die Preisgestaltung von Hugging Face Spaces siehe die Anleitung [hier](https://huggingface.co/docs/hub/en/spaces-overview#hardware-resources).

### Tipps für die Arbeit mit Coding-Agenten

* Seien Sie spezifisch bezüglich des zu verwendenden Modells und Datensatzes und fügen Sie Hub-IDs hinzu (z. B. `Qwen/Qwen2.5-0.5B`, `trl-lib/Capybara`). Agenten werden diese Kombinationen suchen und validieren.
* Nennen Sie Unsloth ausdrücklich, wenn Sie dessen Verwendung wünschen. Andernfalls entscheidet der Agent das Framework basierend auf Modell und Budget.
* Bitten Sie um Kostenschätzungen, bevor Sie große Jobs starten
* Fordern Sie Trackio-Überwachung für Echtzeit-Verlustkurven an
* Prüfen Sie den Jobstatus, indem Sie den Agenten nach der Einreichung die Logs untersuchen lassen

### Ressourcen

* [Hugging Face Skills-Repository](https://github.com/huggingface/skills)

{% embed url="<https://youtu.be/Gh5P4niIFNA>" %}