Apple FastFrames: Offene Video-KI erzeugt Clips schneller, als man sie anschaut

Apple hat zusammen mit der Cornell University zwei Videomodelle mit offenen Gewichten veröffentlicht, die Text in kurze Clips verwandeln, und zwar fast in Echtzeit. Der Trick: Apple hat nicht das KI-Herzstück beschleunigt, sondern die langsamen Arbeitsschritte drumherum ersetzt.

Modell-Releases Selbst ausprobieren 16. Nov. 2026 6 Min. Lesezeit Quelle: Hugging Face Trending
Symbolbild, KI-generiert

Worum es geht

Apple hat zusammen mit der Cornell University FastFrames veröffentlicht, zwei Text-zu-Video-Modelle mit frei herunterladbaren Gewichten. Du beschreibst also eine Szene in Worten, und das Modell erzeugt daraus einen kurzen Clip. Das Besondere ist nicht die Bildqualität, sondern das Tempo: Die Modelle sollen Videos mit „interaktiver Latenz“ erzeugen. Latenz ist die Wartezeit zwischen Eingabe und Ergebnis, und „interaktiv“ heißt hier, dass man die Verzögerung kaum bemerkt.

Es gibt zwei Größen:

Die Hugging-Face-Seiten wurden am 16. November 2026 angelegt, das Fachpaper erschien am 17. November auf arXiv. Zu den Autoren gehört unter anderem Vladlen Koltun. Eine Projektseite mit Beispielvideos gibt es ebenfalls. Einen fertigen Onlinedienst von Apple gibt es nicht: Wer FastFrames nutzen will, muss es auf eigenen Nvidia-Grafikkarten betreiben.

Beide Modelle sind autoregressive Video-Diffusionsmodelle. „Diffusion“ heißt, das Modell erzeugt Bilder, indem es aus Rauschen Schritt für Schritt ein Bild herausarbeitet. „Autoregressiv“ heißt, es erzeugt das Video Stück für Stück und baut jeden neuen Abschnitt auf dem vorherigen auf, ähnlich wie ein Sprachmodell Wort für Wort schreibt. Dadurch lassen sich Clips aneinanderhängen. FastFrames kommt mit nur zwei Rechenschritten pro Bild aus.

Der Trick: Nicht das Modell, sondern das Drumherum beschleunigen

Ausgangspunkt war das bis dahin schnellste vergleichbare Verfahren, Causal Forcing++. Das Apple-Team hat genau gemessen, wo die Zeit verloren geht. Das Ergebnis, laut aiweekly zitiert aus dem Paper: Nur rund 30 Prozent der Rechenzeit entfallen auf das eigentliche Erzeugen der Bilder. Den Rest fressen zwei Nebenaufgaben:

  1. Der VAE-Decoder: Das Modell rechnet intern in einer stark komprimierten Darstellung. Ein sogenannter VAE-Decoder übersetzt das am Ende in echte Pixel, vergleichbar mit dem Entpacken einer ZIP-Datei. Laut Paper dauert ein einziger solcher Schritt so lange wie 3,5 Durchläufe des eigentlichen Modells.
  2. Das Auffrischen des KV-Caches: Der KV-Cache ist das Kurzzeitgedächtnis des Modells, in dem steht, was in den vorherigen Bildern passiert ist. Bisher brauchte es einen zusätzlichen vollen Rechendurchlauf, um ihn zu aktualisieren.

Apple hat beide Aufgaben durch kleine, eigens trainierte Netze ersetzt. Das Kernmodell, ein sogenannter Diffusion Transformer (DiT), blieb dagegen eingefroren und unverändert. Laut OrcaRouter gilt:

  • Ein Pixel-Decoder mit nur 63,87 Mio. Parametern erzeugt die Bilder direkt. Er besteht aus drei ConvNeXt-Blöcken, einer bewährten Bauart für Bildnetze, und einer letzten Schicht. Das Decodieren sinkt von etwa 147 ms auf rund 1 ms.
  • Ein kleines KV-Refinement-Netz übernimmt das Auffrischen des Gedächtnisses. Es kostet 2 ms beim kleinen und 6 ms beim großen Modell.

Insgesamt sinkt die Zeit pro Bild beim kleinen Modell von 271,8 ms auf 35,8 ms. Die Model Card schlüsselt eine Beispielmessung auf einer Grafikkarte auf: zwei DiT-Durchläufe mit je etwa 16 ms, 2,2 ms für das Gedächtnis und 0,9 ms für den Pixel-Decoder. Zusammen sind das 35,4 ms. Trainiert wurde der Pixel-Decoder laut OrcaRouter etwa eine Woche lang auf 32 B200-Karten. Dazu kam ein zusätzlicher Trainingsschritt, bei dem ein zweites Netz unscharfe Bilder erkennen und bestrafen sollte.

Zahlen: Tempo und Qualität

Die Qualität misst Apple mit VBench, einem verbreiteten Testset für Videomodelle. Alle Werte stammen von den Autoren selbst und sind noch nicht unabhängig überprüft.

Modell VBench gesamt Zeit pro Bild
FastFrames-S (1,3B, 1× B200) 84,23 36 ms
FastFrames-L (14B, 8× B200) 84,44 45 ms
Causal Forcing++ 84,11 272 ms
Self-Forcing 84,10 717 ms
Krea-Realtime 84,42 1.675 ms
Wan2.1 1,3B (Grundmodell) 83,80 30.444 ms
Wan2.2 14,3B 84,65 117.734 ms
MiniMax-H3 33,1B 84,43 38.454 ms

OrcaRouter weist darauf hin, dass praktisch alle Modelle zwischen 83 und 85,5 Punkten liegen, die Rechenzeit sich aber um vier Größenordnungen unterscheidet. Der Test unterscheide die Modelle kaum noch. Er belohne zudem gleichmäßige Bewegungen, in denen autoregressive Modelle stark sind.

Wichtig für die Praxis: Wirklich schneller als Echtzeit ist nur das kleine Modell. FastFrames-S erzeugt einen Clip von gut fünf Sekunden auf einer B200 in 2,9 Sekunden. FastFrames-L schafft die 45 ms pro Bild nur verteilt auf acht B200, auf einer einzelnen Karte braucht es 158 ms pro Bild, also 12,8 Sekunden für denselben Clip. Bei 720p sind es 127 ms (S) beziehungsweise 116 ms (L auf acht Karten). Auf der älteren H100 rechnet das Paper mit 25 bis 50 Prozent mehr Zeit. Als Maßstab nennen die Autoren laut aiweekly eine Schwelle aus der Forschung zur Mensch-Computer-Interaktion: Verzögerungen unter 50 ms nimmt man kaum wahr.

Bonus: Schnellere Welten mit LingBot

Apple hat das Verfahren auch auf das fremde Weltmodell LingBot-World übertragen, bei dem man die Kamera durch eine erzeugte Szene steuert. Laut OrcaRouter sinkt die Zeit pro Bild bei der 1,3B-Variante von 1.085 auf 52 ms und bei der 14B-Variante von 3.862 auf 233 ms. Die Model Card spricht von einer 16-mal schnelleren LingBot-Version mit flüssiger Kamerasteuerung, die als lokale Demo im Browser läuft. Ungewöhnlich offen ist Apple auch beim Training: Für FastFrames-L sind alle Zwischenstufen veröffentlicht, vom Lehrermodell bis zum fertigen Generator.

Was du zum Ausprobieren brauchst

Voraussetzung sind laut Model Card Linux auf einem x86-64-Rechner, eine Nvidia-Grafikkarte und ein Treiber, der CUDA 12.8 unterstützt. Mac, Windows und reiner Prozessorbetrieb sind nicht vorgesehen. Fertige verkleinerte Versionen, etwa GGUF-Dateien für einfache Programme wie Ollama, gibt es nicht. Wie viel Grafikspeicher (VRAM) man braucht, nennt Apple nicht. Gemessen wurde auf B200-Karten mit sehr viel Speicher, von denen zum Beispiel acht Stück zum Einsatz kamen. Nach unserer groben Schätzung braucht FastFrames-L in voller Genauigkeit eher mehr als 32 GB VRAM, also eine Profikarte. Für das kleine FastFrames-S sollte deutlich weniger reichen, belegt ist das aber nicht. Wer nur eine Spielegrafikkarte hat, sollte mit der S-Variante anfangen. Die Einrichtung läuft über das Python-Werkzeug uv, die Gewichte lädt man nach der Checkpoint-Anleitung herunter.

Einordnung

FastFrames ist vor allem ein Forschungsergebnis mit einer übertragbaren Erkenntnis: Bei Videomodellen, die Stück für Stück arbeiten, steckt ein Großteil der Wartezeit nicht im Modell selbst, sondern im Entpacken der Bilder und im Auffrischen des Gedächtnisses. Wer diese Teile durch kleine gelernte Netze ersetzt, gewinnt enorm an Tempo. Das könnte live gesteuerte Weltmodelle, Videovorschauen in Echtzeit oder sprechende Avatare billiger machen.

Die Grenzen sind deutlich. Die Auflösung liegt bei 480p, während laut OrcaRouter vergleichbare Bezahldienste mindestens 1080p bieten. Es gibt keinen Ton, während Veo, Kling oder Grok Imagine passenden Ton gleich mitliefern. Die Clips sind 81 Bilder lang, gesteuert wird nur per Text, es gibt keine Bildvorlagen und keine Kamerasteuerung. Die Lizenz ist kein Freibrief: Die Gewichte stehen unter Apples Forschungslizenz AMLR, der LingBot-Teil unter CC BY-NC-SA 4.0, also nur für nicht kommerzielle Zwecke. Wer ein Produkt bauen will, muss die Bedingungen genau prüfen. Und: Die Veröffentlichung ist erst zwei Tage alt, alle Zahlen sind Herstellerangaben.

Quellen

#apple#text-to-video#videogenerierung#open weights#echtzeit
Originalquelle lesen

Selbst ausprobieren: FastFrames-L

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

FastFrames-L verwandelt eine kurze Textbeschreibung in einen Videoclip mit 832 × 480 Pixeln, 81 Bildern und 16 Bildern pro Sekunde, also gut fünf Sekunden. Da das Modell Stück für Stück arbeitet, lassen sich Clips aneinanderhängen. Die Stärke ist das Tempo: Laut Apple erreicht es die Qualität deutlich langsamerer Modelle wie Wan2.1 oder Krea-Realtime, rechnet aber um ein Vielfaches schneller. Die Spitzenwerte von 45 ms pro Bild gelten allerdings nur auf acht B200-Karten, auf einer einzelnen Karte dauert ein Clip rund 12,8 Sekunden. Grenzen: kein Ton, nur 480p, nur Textsteuerung ohne Bildvorlage oder Kamerasteuerung. Das Repository enthält zusätzlich eine beschleunigte LingBot-Demo, mit der man die Kamera durch eine erzeugte Welt steuern kann. Gegenüber Bezahldiensten wie Kling oder Veo ist die Bildqualität geringer, dafür läuft alles auf dem eigenen Rechner.

Für wen lohnt es sich?

Das Modell lohnt sich für Forscher, Entwickler und Bastler mit starker Nvidia-Hardware unter Linux, die mit schneller Videoerzeugung, Echtzeit-Vorschauen oder Weltmodellen experimentieren wollen. Für Einsteiger mit Laptop, Mac oder Windows-Spielerechner ist es eher nichts. Wer schöne, hochauflösende Videos mit Ton sucht, ist mit einem Onlinedienst besser bedient.

Ideen: Was du damit anstellen kannst

Storyboard-Skizzen für Videoprojekte

Beschreib Szene für Szene deines geplanten Kurzfilms oder Werbeclips in Textform und lass dir jeweils einen kurzen Clip erzeugen. So bekommst du schnell ein bewegtes Storyboard, mit dem du Ideen im Team besprechen kannst, bevor gedreht wird.

Animierte Hintergründe für Präsentationen

Erzeuge ruhige Stimmungsclips wie Wolken, Wellen oder einen Wald im Nebel und nutze sie als bewegten Hintergrund für Vorträge oder Social-Media-Beiträge. Die niedrige Auflösung fällt bei Hintergründen kaum auf.

Live-Vorschau für Prompt-Experimente

Weil das Modell sehr schnell ist, kannst du viele Varianten eines Prompts hintereinander testen und Licht, Stil oder Motiv gezielt verändern. Das macht anschaulich, wie Video-KIs auf Formulierungen reagieren, etwa für Workshops oder Unterricht.

Kamerafahrt durch KI-Welten

Mit der beigelegten LingBot-Demo steuerst du im Browser eine Kamera durch eine erzeugte Umgebung. Das eignet sich, um selbst auszuprobieren, wie sich interaktive Weltmodelle anfühlen.

Forschung an schneller Videogenerierung

Apple stellt für FastFrames-L alle Trainingsstufen bereit, vom Lehrermodell bis zum fertigen Generator. Wer selbst forscht, kann so die einzelnen Schritte nachvollziehen und den Pixel-Decoder-Ansatz auf eigene Modelle übertragen.

Größe14 Mrd. Parameter
Download174 GB (bei 100 MBit/s ca. 3,9 Std.)
Lizenzapple-amlr
ArtVideogenerator
Hugging Faceapple/FastFrames-L

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 38 GB VRAMApple nennt keinen Mindest-Grafikspeicher. Die Zahl ist nur gerechnet: Die Standard-Anleitung lädt den Ordner fastframes-l, also dit.safetensors mit 28,58 GB, kv_refiner mit 1,78 GB und pixel_decoder mit 0,29 GB. Das sind zusammen etwa 30,7 GB in bf16, mal 1,2 plus 1 GB, also rund 38 GB. Die nötigen Fremd-Gewichte (zum Beispiel aus Wan2.1) sind dabei noch nicht mitgezählt. Realistisch brauchst du also eine Profi-Karte mit 48 oder 80 GB. Apple selbst misst FastFrames-L mit 8 Grafikkarten: Mehr Karten bringen vor allem eine niedrigere Wartezeit.
Mac (Apple Silicon M1–M5) nicht unterstütztLaut Quelle braucht FastFrames Linux und eine NVIDIA-Grafikkarte mit CUDA. Auf dem Mac, auch mit Apple-Chip, läuft es deshalb nicht. Als Alternative kannst du einen gemieteten Linux-Cloud-Rechner mit NVIDIA-Grafikkarte nutzen oder dir die Beispielvideos auf der Projektseite ansehen.
Speicherplatz ca. 176 GB freiModell-Download plus Programme

FastFrames-S (1,3B) ist die richtige Wahl für eine einzelne Grafikkarte. Nur diese Variante läuft laut Apple auf einer einzigen B200 schneller als Echtzeit, und sie braucht nach unserer Schätzung deutlich weniger Speicher. FastFrames-L (14B) liefert laut Hersteller etwas bessere Bildqualität und Realismus, wird aber erst mit acht Karten interaktiv. Wir schätzen, dass es in voller Genauigkeit eher mehr als 32 GB VRAM braucht. Verkleinerte 4-Bit- oder GGUF-Versionen gibt es nicht. Für Trainingsexperimente stellt Apple bei der L-Variante alle Zwischenstufen bereit.

  • Offiziell unterstützt: Linux x86-64 mit Nvidia-Grafikkarte und einem Treiber, der CUDA 12.8 unterstützt. Mac (Apple Silicon), Windows und reiner Prozessorbetrieb sind nicht vorgesehen.
  • Die Messwerte stammen von Nvidia-B200-Karten: FastFrames-L braucht 45 ms pro Bild auf acht B200 und 158 ms pro Bild auf einer einzelnen Karte.
  • Auf einer H100 statt einer B200 rechnet das Paper mit 25 bis 50 Prozent mehr Zeit.
  • Den VRAM-Bedarf nennt Apple nicht. Nach unserer Schätzung braucht die 14B-Variante ungeschrumpft deutlich mehr als 24 GB, realistisch ist eine Profikarte mit 40 bis 80 GB.
  • Bei 720p steigt die Zeit pro Bild auf 116 ms, selbst auf acht Karten. Ausgeliefert wird die Konfiguration für 480p.
  • Plane genug Festplattenplatz ein: Neben den FastFrames-Gewichten lädt die Checkpoint-Anleitung weitere Gewichte von Drittanbietern herunter.
Wie finde ich heraus, was mein Rechner hat?
  • Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
  • Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
  • Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler (apple-aiml-research/ml-fastframes auf GitHub). Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: nicht unterstützt. Laut Quelle läuft FastFrames nur unter Linux x86-64 mit einer NVIDIA-Grafikkarte, Windows wird nicht unterstützt. Du kannst es höchstens in WSL2 (einem Linux innerhalb von Windows) versuchen, das ist aber nicht getestet. Die Alternative ist ein gemieteter Linux-Cloud-Rechner mit großer NVIDIA-Grafikkarte, auf dem du der Linux-Anleitung folgst.

macOS

macOS: nicht unterstützt. Laut Quelle braucht FastFrames Linux und eine NVIDIA-Grafikkarte mit CUDA. Auf dem Mac, auch mit Apple-Chip, läuft es deshalb nicht. Als Alternative kannst du einen gemieteten Linux-Cloud-Rechner mit NVIDIA-Grafikkarte nutzen oder dir die Beispielvideos auf der Projektseite ansehen.

Linux

Linux: unterstützt. Laut Quelle ist nur Linux x86-64 mit NVIDIA-Grafikkarte und einem Treiber für CUDA 12.8 offiziell unterstützt. FastFrames-L hat 14 Milliarden Parameter und braucht sehr viel Grafikspeicher. Wenn dir der fehlt, nimm die kleine Schwester FastFrames-S (1,3 Milliarden Parameter) mit --model ff-s. Die Lizenz (apple-amlr) erlaubt nur Forschung, keine kommerzielle Nutzung.

  1. Voraussetzungen prüfen. Du brauchst ein 64-Bit-Linux auf einem normalen Intel- oder AMD-Prozessor (x86-64), eine NVIDIA-Grafikkarte mit viel Speicher (deutlich über 40 GB) und einen NVIDIA-Treiber, der CUDA 12.8 kann. CUDA ist die Rechenschnittstelle von NVIDIA. Außerdem brauchst du Git (lädt Programmcode herunter), Python 3 und mindestens 50 GB freien Speicherplatz. Der Befehl nvidia-smi zeigt oben rechts die CUDA-Version an: Dort sollte 12.8 oder höher stehen.
    nvidia-smi
    git --version
    python3 --version
  2. Hilfswerkzeuge installieren. FastFrames nutzt den Paketmanager uv, der Python und alle Pakete selbst einrichtet. Zum Herunterladen der Modelle brauchst du außerdem das Hugging-Face-Werkzeug hf. Beides kommt in eine eigene kleine Umgebung (venv), damit dein System sauber bleibt. Wenn uv --version eine Versionsnummer ausgibt, hat es geklappt. Aktiviere diese Umgebung in jedem neuen Terminal wieder mit der source-Zeile.
    python3 -m venv ~/ff-tools
    source ~/ff-tools/bin/activate
    pip install uv huggingface_hub
    uv --version
  3. Programm herunterladen. Dieser Schritt lädt den Code von FastFrames von GitHub und wechselt in den neuen Ordner. Alle weiteren Befehle führst du in diesem Ordner aus.
    git clone https://github.com/apple-aiml-research/ml-fastframes.git
    cd ml-fastframes
  4. Abhängigkeiten installieren. uv sync legt im Ordner automatisch eine Umgebung an und installiert alle Pakete, auch PyTorch mit CUDA. Das kann eine Weile dauern und lädt einige Gigabyte. Wenn am Ende keine rote Fehlermeldung kommt, hat es geklappt.
    uv sync
  5. Bei Hugging Face anmelden. Das Modell steht unter einer Apple-Forschungslizenz. Falls der Download später eine Anmeldung verlangt, erstellst du auf huggingface.co ein kostenloses Konto. Dort akzeptierst du auf der Seite apple/FastFrames-L die Lizenz und legst unter Settings → Access Tokens ein Token (einen Zugangsschlüssel) an. Diesen fügst du nach dem folgenden Befehl ein.
    hf auth login
  6. FastFrames-L-Gewichte herunterladen. Das komplette Repo ist 173 GB groß. Den größten Teil machen aber Zwischenstände aus dem Training aus, die du nicht brauchst. Mit --include lädst du nur den Ordner fastframes-l, das sind etwa 31 GB. Die Dateien landen im Ordner checkpoints. Wie die Ordner genau heißen müssen, prüfst du im nächsten Schritt in der Checkpoint-Anleitung.
    hf download apple/FastFrames-L --include "fastframes-l/*" --local-dir checkpoints
  7. Zusätzliche Fremd-Gewichte holen. FastFrames braucht außerdem Gewichte von anderen Projekten, zum Beispiel Teile von Wan2.1. Welche das genau sind und wohin sie gehören, steht in der Datei docs/installation.md im Abschnitt „Checkpoints“. Öffne die Datei mit dem folgenden Befehl (mit q schließt du sie wieder) und führe die Download-Befehle von dort aus.
    less docs/installation.md
  8. Erstes Video erzeugen. Dieser Befehl erzeugt aus dem englischen Beispielsatz der Entwickler ein Video: ein Corgi, der bei Sonnenuntergang surft. --seed 0 sorgt dafür, dass du bei jedem Durchlauf dasselbe Ergebnis bekommst. Beim ersten Start dauert das Laden der rund 30 GB Gewichte eine Weile. Fehlt Grafikspeicher, erscheint „CUDA out of memory“.
    uv run python scripts/generate.py --model ff-l --checkpoint-dir checkpoints --prompt "A corgi surfing a wave at sunset" --seed 0 --output outputs/corgi.mp4
  9. Ergebnis ansehen. Im Ordner outputs liegt jetzt die Datei corgi.mp4. Du kannst sie mit jedem Videoplayer öffnen, zum Beispiel mit VLC oder dem Dateimanager.
    ls outputs
  10. Ergebnis. Im Ordner outputs liegt die Videodatei corgi.mp4: ein Clip mit 832 × 480 Pixeln und 81 Bildern bei 16 Bildern pro Sekunde, also etwa 5 Sekunden lang.

So geht es nach dem ersten Ergebnis weiter

  • Schreib eigene Beschreibungen auf Englisch hinter --prompt und ändere --seed, dann bekommst du andere Varianten. Mit --output legst du den Dateinamen fest.
  • Mit „uv run python scripts/generate_project_page.py --model ff-l --output-dir outputs/project_page/ff-l“ erzeugst du die über 20 Videos von der Projektseite.
  • Wie schnell dein System ist, misst du mit „uv run python evaluation/latency/benchmark.py ff-l --gpus 8“. Die Zahl hinter --gpus passt du an deine Anzahl Grafikkarten an.
  • Für die interaktive Web-Demo mit Kamerasteuerung (LingBot 1.3B) richtest du zuerst alles laut docs/lingbot.md ein. Dann startest du „CUDA_VISIBLE_DEVICES=0 uv run --extra lingbot --extra demo python apps/lingbot/demo.py --gpus 1“ und öffnest im Browser http://localhost:8000.

Das kannst du ausprobieren

A corgi surfing a wave at sunset
A red paper boat floating down a rainy city street, close-up, soft morning light
A time-lapse of a small sunflower growing in a terracotta pot on a sunny windowsill
Aerial drone shot slowly flying over a misty pine forest with a winding river at dawn
An astronaut riding a bicycle across a desert of white sand dunes, cinematic, long shadows

Tipps für bessere Ergebnisse

  • Schreib die Prompts auf Englisch und beschreib die Szene konkret: Motiv, Bewegung, Licht und Kameraperspektive. Die Beispiele von Apple sind alle so aufgebaut.
  • Setz mit '--seed' einen festen Startwert. Dann kannst du Prompts gezielt vergleichen und gelungene Ergebnisse wiederholen.
  • Miss mit 'uv run python evaluation/latency/benchmark.py ff-l --gpus N' erst einmal, wie schnell deine eigene Hardware wirklich ist, bevor du größere Experimente planst.
  • Mit scripts/generate_project_page.py erzeugst du die über 20 Beispielvideos der Projektseite. So siehst du schnell, ob deine Installation die erwarteten Ergebnisse liefert.
  • Erwarte keine Langfilme: Jede Generierung umfasst 81 Bilder, also gut fünf Sekunden. Längere Szenen entstehen durch Aneinanderhängen, dabei können Details abdriften.

Wenn es hakt

Der Grafiktreiber muss CUDA 12.8 unterstützen, sonst startet nichts. Prüfe die Version vorher mit nvidia-smi und aktualisiere den Treiber bei Bedarf.

Die Installation läuft über das Python-Werkzeug uv mit dem Befehl 'uv sync' im Hauptordner des Repositorys. Installiere uv vorher, falls es fehlt.

Die Gewichte kommen nicht automatisch mit. Lade sie nach der Checkpoint-Anleitung im GitHub-Repo, inklusive der Gewichte von Drittanbietern, in den Ordner 'checkpoints'.

Für das große Modell musst du beim Aufruf von scripts/generate.py '--model ff-l' angeben, Standard im Beispiel ist 'ff-s'.

Die LingBot-Demo braucht zusätzliche Pakete ('--extra lingbot --extra demo') und läuft danach unter http://localhost:8000. Für mehrere Karten setzt du CUDA_VISIBLE_DEVICES und '--gpus 8'.

Lizenz beachten: Die Gewichte stehen unter Apples Forschungslizenz AMLR, der LingBot-Teil unter CC BY-NC-SA 4.0, also nicht kommerziell. Für Produkte vorher die Bedingungen prüfen.

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: apple-amlr.

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

  1. Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.