Video (experimentell)#

Lernen, wie man mit Xinference Videos generiert

Introduktion#

Die Video-API bietet eine Möglichkeit zur Interaktion mit Videos:

Der Text-zu-Video-Endpunkt erstellt aus einem Text-Prompt ein Video von Grund auf.
Der Image-to-Video-Endpunkt erstellt ein Video von Grund auf aus einem einzelnen Bild.
firstlastframe-to-video Schnittstelle erzeugt ein Video basierend auf dem Übergang zwischen dem ersten und letzten Einzelbild.

API	Endpoint
Text-to-Video API	/v1/video/generations
Image-to-Video API	/v1/video/generations/image
FirstLastFrame-to-Video API	/v1/video/generations/flf

Unterstützte Modellliste#

Die Text-to-Video-API unterstützt in Xinference die folgenden Modelle:

Image-to-video API unterstützt in Xinference die folgenden Modelle:

In Xinference werden die folgenden Modelle unterstützt, die die firstlastframe-to-video-Schnittstelle verwenden:

Wan2.1-flf2v-14B-720p

Schnellstart#

Text-zu-Video#

Die text-to-video API kann über cURL oder Xinference genutzt werden.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "prompt": "<your prompt>"
  }'

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
input_text = "an apple"
model.text_to_video(input_text)

Bild-zu-Video#

Die image-to-video API kann via cURL oder Xinference verwendet werden.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations/image' \
  -F model=<MODEL_UID> \
  -F image=@xxx.jpg \
  -F prompt=<prompt>

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
with open("xxx.jpg", "rb") as f:
    prompt = ""
    model.image_to_video(image=f.read(), prompt=prompt)

Anfangs- und Endbildsequenz generieren#

Sie können die Schnittstelle firstlastframe-to-video über cURL oder den Python-Client von Xinference testen:

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations/flf' \
  -F model=<MODEL_UID> \
  -F first_frame=@xxx.jpg \
  -F last_frame=@xxx2.jpg \
  -F prompt=<prompt>

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
with open("xxx.jpg", "rb") as f1, open("xxx2.jpg", "rb") as f2:
    prompt = ""
    model.flf_to_video(first_frame=f1.read(), last_frame=f2.read(), prompt=prompt)

Speicheroptimierung#

Videogenerierung beansprucht viel Videospeicher. Beispielsweise kann der Betrieb von CogVideoX etwa 35 GB Videospeicher belegen.

Xinference unterstützt mehrere Optionen zur Optimierung der VRAM-Nutzung von Videomodellen.

CPU-Offloading oder blockweises Gruppen-Offloading.
Layerweises Casting.

Bemerkung

CPU-Offloading und blockweises Group-Offloading können nicht gleichzeitig aktiviert werden, aber die schichtweise Typkonvertierung kann in Verbindung mit einem von beiden verwendet werden.

CPU-Auslagerung#

CPU-Offloading belässt die Modellgewichte auf der CPU und lädt sie erst während der Vorwärtsausbreitung in die GPU. Geeignet für Szenarien mit extrem begrenztem Videospeicher, hat jedoch erhebliche Auswirkungen auf die Leistung.

Bei Verwendung einer GPU mit weniger als 24 GB Videospeicher wird empfohlen, beim Starten des Modells --cpu_offload True hinzuzufügen. Für die Web-Benutzeroberfläche kann die zusätzliche Option cpu_offload mit dem Wert True hinzugefügt werden.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --cpu_offload True

Block-Level Group Offloading#

Block-Level Offloading gruppiert mehrere interne Schichten eines Modells (wie torch.nn.ModuleList oder torch.nn.Sequential) und lädt diese Gruppen während der Inferenz bei Bedarf von der CPU auf die GPU. Im Vergleich zum CPU-Offloading verwendet es mehr Speicher, hat jedoch geringere Auswirkungen auf die Leistung.

Für die Kommandozeile fügen Sie die Option --group_offload True hinzu; für die Web-Benutzeroberfläche fügen Sie eine zusätzliche Option group_offload hinzu und setzen den Wert auf True.

Durch die Aktivierung von CUDA-Streams können wir das gruppierte Auslagern von Inferenzen beschleunigen. Die Verwendung von CUDA-Streams erfordert jedoch, dass die Modellparameter in den festen Speicher (pinned memory) verschoben werden. Diese Zuweisung wird von PyTorch im Hintergrund verwaltet und kann zu einem erheblichen Anstieg des CPU-RAM-Verbrauchs führen. Wenn Ihr CPU-RAM mindestens doppelt so groß wie die Modellgröße ist, sollten Sie diese Option in Betracht ziehen. Aktivieren Sie CUDA-Streams, indem Sie --use_stream True in der Befehlszeile hinzufügen; für das Web-UI fügen Sie eine zusätzliche Option use_stream mit dem Wert True hinzu.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --group_offload True --use_stream True

Wenden Sie die schichtweise Typkonvertierung auf den Transformer an.#

Die schichtweise Typumwandlung stuft die Gewichte jeder Schicht auf torch.float8_e4m3fn herab, hebt sie während des Vorwärtsdurchlaufs der Schicht vorübergehend auf torch.bfloat16 an und setzt sie anschließend wieder auf torch.float8_e4m3fn zurück. Diese Methode reduziert den Speicherbedarf um etwa 50 %, führt jedoch aufgrund von Genauigkeitsabwägungen zu einer leichten Verschlechterung der Videoqualität. Aktivieren Sie die schichtweise Typumwandlung durch Hinzufügen von --layerwise_cast True in der Befehlszeile; für die Web-Benutzeroberfläche fügen Sie eine zusätzliche Option layerwise_cast mit dem Wert True hinzu.

Dieses Beispiel benötigt 20 GB VRAM.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --layerwise_cast True --cpu_offload True