gcd
1.0.0
Basile Van Hoorick, Rundi Wu, Ege Ozguroglu, Kyle Sargent, Ruoshi Liu, Pavel Tokmakov, Achal Dave, Changxi Zheng, Carl Vondrick
Columbia University, Stanford University, Toyota Research Institute
Veröffentlicht in ECCV 2024 (mündlich)
Papier | Website | Ergebnisse | Datensätze | Modelle
Dieses Repository enthält den Python-Code, der im Rahmen unseres Artikels „Generative Camera Dolly: Extreme Monocular Dynamic Novel View Synthesis“ (abgekürzt GCD ) veröffentlicht wurde.
Wir bieten Einrichtungsanweisungen, vorab trainierte Modelle, Inferenzcode, Trainingscode, Evaluierungscode und Datensatzgenerierung.
Bitte beachten Sie, dass ich die Codebasis für die öffentliche Veröffentlichung umgestaltet und bereinigt habe, hauptsächlich um die Struktur zu vereinfachen sowie die Lesbarkeit und Modularität zu verbessern, aber ich habe noch nicht alles gründlich überprüft. Wenn Sie also auf Probleme stoßen, teilen Sie uns dies bitte mit, indem Sie ein Problem eröffnen , und schlagen Sie gerne mögliche Fehlerbehebungen vor, falls Sie welche haben.
Inhaltsverzeichnis:
Ich empfehle die Einrichtung einer virtuellen Umgebung und die Installation der notwendigen Pakete wie folgt:
conda create -n gcd python=3.10
conda activate gcd
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia
pip install git+https://github.com/OpenAI/CLIP.git
pip install git+https://github.com/Stability-AI/datapipelines.git
pip install -r requirements.txt
Das Projekt wurde größtenteils mit PyTorch Version 2.0.1 entwickelt, sollte jedoch auch mit späteren Versionen funktionieren. Insbesondere mit PyTorch 2.3.1, der zum Zeitpunkt des Verfassens dieses Artikels neuesten Version, habe ich bisher keine Probleme festgestellt.
Beachten Sie, dass in der Anforderungsdatei keine Paketversionen angegeben sind, da ich ein Fan von Flexibilität bin (das Hinzufügen von Versionseinschränkungen würde andernfalls die Übernahme vorhandener Codebasen in Ihre neuen Projekte umständlicher machen). Wenn Sie jedoch auf Probleme stoßen, teilen Sie uns dies bitte mit, indem Sie ein Problem eröffnen. Als Referenz habe ich auch die genauen Versionen in requirements_versions.txt bereitgestellt.
Der Unterordner gcd-model basiert ursprünglich auf dem offiziellen Repository für generative Modelle von Stability AI.
Nachfolgend sind die wichtigsten Kubric-4D- Kontrollpunkte aufgeführt, die wir trainiert und in unseren Experimenten verwendet haben, zusammen mit den PSNR-Werten des Testsatzes. Die linke Spalte gibt die maximale Verschiebung der Kamera in Bezug auf die horizontale Drehung an.
| Azimut | Allmählich | Direkt |
|---|---|---|
| Maximal 90 Grad | Link (17,88 dB) | Link (17,23 dB) |
| Maximal 180 Grad | Verbindung (17,81 dB) | Link (16,65 dB) |
Nachfolgend finden Sie die wichtigsten ParallelDomain-4D -Kontrollpunkte, die wir trainiert und in unseren Experimenten verwendet haben, zusammen mit PSNR- oder mIoU-Werten im Testsatz. Die linke Spalte gibt die vorhergesagte Ausgabemodalität an (die Eingabe ist immer RGB).
| Modalität | Allmählich | Direkt |
|---|---|---|
| Farbe (RGB) | Link (23,47 dB) | Link (23,32 dB) |
| Semantisch | Link (39,0 %) | Link (36,7 %) |
Alle oben genannten Kontrollpunkte sind 20,3 GB groß. Platzieren Sie sie in pretrained/ sodass sie denselben Namen wie die entsprechenden Konfigurations .yaml Dateien haben.
In diesem Abschnitt können Sie unser Modell gelegentlich auf benutzerdefinierten Videos ausführen. Für eine gründliche quantitative Auswertung auf Kubric-4D oder ParallelDomain-4D oder eine beliebige Befehlszeileninferenz außerhalb dieser beiden Datensätze, die Ergebnisse und Visualisierungen auf Ihrer Festplatte speichert, lesen Sie bitte stattdessen den Abschnitt „Auswertung“ unten.
Führen Sie für ein Kubric-4D- Modell Folgendes aus:
cd gcd-model/
CUDA_VISIBLE_DEVICES=0 python scripts/gradio_app.py --port=7880
--config_path=configs/infer_kubric.yaml
--model_path=../pretrained/kubric_gradual_max90.ckpt
--output_path=../eval/gradio_output/default/
--examples_path=../eval/gradio_examples/
--task_desc='Arbitrary monocular dynamic view synthesis on Kubric scenes up to 90 degrees azimuth'
Um andere Modelle auszuprobieren, ändern Sie einfach config_path , model_path und task_desc , zum Beispiel für ein ParallelDomain-4D- Modell:
cd gcd-model/
CUDA_VISIBLE_DEVICES=1 python scripts/gradio_app.py --port=7881
--config_path=configs/infer_pardom.yaml
--model_path=../pretrained/pardom_gradual_rgb.ckpt
--output_path=../eval/gradio_output/default/
--examples_path=../eval/gradio_examples/
--task_desc='Upward monocular dynamic view synthesis on ParallelDomain scenes (RGB output)'
Für das Training und die Auswertung auf Kubric-4D und/oder ParallelDomain-4D müssen Sie die Datensätze vorverarbeiten und zusammengeführte Punktwolken speichern. Dies liegt daran, dass die Datensätze selbst nur RGB-D-Videos aus bestimmten Blickwinkeln bereitstellen. Wir möchten jedoch frei in der 4D-Szene herumfliegen und auch das Erlernen beliebiger Kamerasteuerungen (und interpolierender Flugbahnen) ermöglichen.
Für Kubric-4D :
cd data-gen/
python convert_pcl_kubric.py --gpus=0,0,1,1 --start_idx=0 --end_idx=3000
--input_root=/path/to/Kubric-4D/data
--output_root=/path/to/Kubric-4D/pcl
Hier sollte /path/to/Kubric-4D/data der Ordner sein, der scn00000 , scn00001 usw. enthält. Das Skript liest data und schreibt in pcl/ (stellen Sie sicher, dass Sie über 7,0 TB freien Speicherplatz verfügen).
Für ParallelDomain-4D :
cd data-gen/
python convert_pcl_pardom.py --gpus=0,0,1,1 --start_idx=0 --end_idx=1600
--input_root=/path/to/ParallelDomain-4D/data
--output_root=/path/to/ParallelDomain-4D/pcl
Hier sollte /path/to/ParallelDomain-4D/data der Ordner sein, der scene_000000 , scene_000001 usw. enthält. Das Skript liest aus data/ und schreibt nach pcl/ (stellen Sie sicher, dass Sie über 4,4 TB freien Speicherplatz verfügen).
Beide oben genannten Konvertierungsskripte basieren hauptsächlich auf GPUs für eine schnelle Verarbeitung und können Parallelisierung auf Prozessebene anwenden. Beispielsweise bedeutet --gpus=0,0,1,1 , dass 4 Worker erzeugt werden (2 pro GPU). Während des Trainings konzentriert sich der Großteil der Datenträger-E/A auf den Ordner pcl/ , daher empfehle ich, ihn auf einer schnellen, lokalen SSD zu speichern.
Wenn Sie mit Ihrem eigenen Datensatz trainieren, empfehle ich, einen neuen Datenlader zu erstellen und dabei den bereitgestellten Code als Referenz zu verwenden. Wenn Sie unsere Daten verwenden, befolgen Sie bitte zuerst den Abschnitt zur Verarbeitung von Datensätzen oben.
Laden Sie zunächst einen der beiden folgenden verfügbaren Stable Video Diffusion-Checkpoints herunter: SVD (14 Frames) oder SVD-XT (25 Frames) und platzieren Sie ihn in pretrained/ (oder aktualisieren Sie den Checkpoint-Pfad in den unten aufgeführten Konfigurationsdateien). Aufgrund von Ressourcenbeschränkungen arbeiten wir in unseren Experimenten ausschließlich mit der 14-Frame-Version von SVD. Ändern Sie daher bitte die anderen relevanten Konfigurationswerte, wenn Sie mit der 25-Frame-SVD-XT arbeiten.
So starten Sie einen GCD-Trainingslauf auf Kubric-4D (stufenweise, max. 90 Grad):
cd gcd-model/
CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 python main.py
--base=configs/train_kubric_max90.yaml
--name=kb_v1 --seed=1234 --num_nodes=1 --wandb=0
model.base_learning_rate=2e-5
model.params.optimizer_config.params.foreach=False
data.params.dset_root=/path/to/Kubric-4D/data
data.params.pcl_root=/path/to/Kubric-4D/pcl
data.params.frame_width=384
data.params.frame_height=256
data.params.trajectory=interpol_linear
data.params.move_time=13
data.params.camera_control=spherical
data.params.batch_size=4
data.params.num_workers=4
data.params.data_gpu=0
lightning.callbacks.image_logger.params.batch_frequency=50
lightning.trainer.devices="1,2,3,4,5,6,7"
Um zu einem Direktansicht-Synthesemodell (ohne Interpolation) zu wechseln, passen Sie diesen Wert an: data.params.move_time=0 . Um den maximalen horizontalen Rotationswinkel (Azimut) zu erhöhen, wählen Sie die andere Konfigurationsdatei aus: train_kubric_max180.yaml .
Das resultierende Modell wird in der Lage sein, eine 3-DoF-monokulare, dynamische, neuartige Ansichtssynthese für jedes RGB-Video durchzuführen, wird jedoch normalerweise im Kubric-Bereich und anderen Videos, die keine Menschen enthalten, die beste Leistung erbringen.
So starten Sie einen GCD-Trainingslauf auf ParallelDomain-4D (stufenweise, RGB):
cd gcd-model/
CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 python main.py
--base=configs/train_pardom_rgb.yaml
--name=pd_v1 --seed=1234 --num_nodes=1 --wandb=0
model.base_learning_rate=2e-5
model.params.optimizer_config.params.foreach=False
data.params.dset_root=/path/to/ParallelDomain-4D/data
data.params.pcl_root=/path/to/ParallelDomain-4D/pcl
data.params.split_json=../eval/list/pardom_datasplit.json
data.params.frame_width=384
data.params.frame_height=256
data.params.output_modality=rgb
data.params.trajectory=interpol_sine
data.params.move_time=13
data.params.modal_time=0
data.params.camera_control=none
data.params.batch_size=4
data.params.num_workers=4
data.params.data_gpu=0
lightning.callbacks.image_logger.params.batch_frequency=50
lightning.trainer.devices="1,2,3,4,5,6,7"
Um zu einem Direktansicht-Synthesemodell (ohne Interpolation) zu wechseln, passen Sie diesen Wert an: data.params.move_time=0 . Um die Ausgabemodalität in semantische Kategorien zu ändern, wählen Sie die andere Konfigurationsdatei aus: train_pardom_semantic.yaml .
Das resultierende Modell ist in der Lage, eine nach oben gerichtete, monokulare, dynamische, neuartige Ansichtssynthese für jedes RGB-Video durchzuführen, erzielt jedoch in der Regel die beste Leistung bei Fahrszenen (sowohl synthetischen als auch realen), die in Fahrtrichtung auf Straßenniveau aufgenommen wurden. Ich habe auch interne Modelle herumliegen, die 3-DoF-Kamerasteuerungen (Ego-to-Surround- und Surround-to-Surround-Transformationen) in diesem Datensatz durchführen können, und obwohl sie nicht Teil der Experimente in unserem Artikel sind, könnte ich das tun Präsentieren und/oder veröffentlichen Sie sie in Zukunft hier.
Beachten Sie, dass in allen oben genannten Befehlen der GPU-Index 0 ( data.params.data_gpu ) für die spontane Erstellung von (Eingabe-, Ground-Truth-)Videopaaren während des Datenladens aus den zwischengespeicherten zusammengeführten Punktwolken in pcl/ reserviert ist. Ich empfehle, das Netzwerk nicht auf derselben GPU zu trainieren, weshalb lightning.trainer.devices disjunkt ist und stattdessen alle verbleibenden GPUs abdeckt.
Die VRAM-Nutzung hierfür beträgt in den bereitgestellten Beispielen etwa 50 GB pro GPU. Die drei größten bestimmenden Faktoren für VRAM sind: (1) die Stapelgröße, (2) die räumliche Auflösung ( frame_width und frame_height ), (3) die Anzahl der Frames (SVD gegenüber SVD-XT) und (4) die EMA-Gewichtung Mittelung ist aktiv. Die meisten unserer Experimente wurden auf einzelnen Knoten mit 8x NVIDIA A100- oder 8x NVIDIA A6000-Geräten durchgeführt, alle ohne EMA aufgrund begrenzter Rechenleistung.
Protokolle und Visualisierungen werden in einem datierten Unterordner im Ordner logs/ gespeichert, der sich auf derselben Ebene wie gcd-model/ befindet. Für jeden Lauf werden Trainingsvisualisierungen im Unterordner visuals/ gespeichert. Sollte das Training jemals unterbrochen werden, können Sie es fortsetzen, indem Sie --resume_from_checkpoint auf die letzte gültige Prüfpunktdatei verweisen, zum Beispiel --resume_from_checkpoint=../logs/2024-02-30T12-15-05_kb_v1/checkpoints/last.ckpt .
Das folgende Skript generiert viele Arten von Ausgaben zur visuellen Inspektion und Bewertung und muss für jeden Benchmark angepasst werden. Informationen zu einfacheren Vorgängen finden Sie im Abschnitt „Inferenz“ oben. Wenn Sie unsere Daten verwenden, stellen Sie sicher, dass Sie zuerst den Abschnitt zur Verarbeitung von Datensätzen oben befolgt haben. Wenn Sie Ihren eigenen benutzerdefinierten Datensatz mit Ground Truth auswerten, empfehle ich, einen neuen Datenlader zu erstellen und das Testskript unten zu ändern.
Um ein GCD-feinabgestimmtes Modell auf Kubric-4D auszuwerten, aktualisieren Sie die Pfade in kubric_test20.txt und führen Sie Folgendes aus:
cd gcd-model/
CUDA_VISIBLE_DEVICES=0,1 python scripts/test.py --gpus=0,1
--config_path=configs/infer_kubric.yaml
--model_path=../logs/*_kb_v1/checkpoints/epoch=00000-step=00010000.ckpt
--input=../eval/list/kubric_test20.txt
--output=../eval/output/kubric_mytest1
--control_json=../eval/list/kubric_valtest_controls_gradual.json
--control_idx=0 --autocast=1 --num_samples=2 --num_steps=25
Aus Gründen der Konsistenz und Fairness wendet dieser Befehl einen deterministischen Satz von Kamerawinkeln und Bildgrenzen an, die jeder Szene zugeordnet sind und in kubric_valtest_controls_gradual.json beschrieben werden. Diese Zahlen wurden nur einmal zufällig generiert und anschließend festgehalten, jedoch so, dass die Eingabeperspektive (dh spherical_src ) mit Ansichtsindex 4 im Datensatz ausgerichtet ist. Ändern Sie dies in kubric_valtest_controls_direct.json , wenn Sie ein Direktansicht-Synthesemodell evaluieren. Außerdem können Sie mehrere Samples auswerten, indem Sie entweder --num_samples (gleiche Steuerelemente) erhöhen oder --control_idx (unterschiedliche Steuerelemente pro Szene) variieren.
Um ein GCD-feinabgestimmtes Modell auf ParallelDomain-4D auszuwerten, aktualisieren Sie die Pfade in pardom_test20.txt und führen Sie Folgendes aus:
cd gcd-model/
CUDA_VISIBLE_DEVICES=0,1 python scripts/test.py --gpus=0,1
--config_path=configs/infer_pardom.yaml
--model_path=../logs/*_pd_v1/checkpoints/epoch=00000-step=00010000.ckpt
--input=../eval/list/pardom_test20.txt
--output=../eval/output/pardom_mytest1
--control_json=../eval/list/pardom_valtest_controls.json
--control_idx=0 --autocast=1 --num_samples=2 --num_steps=25
Ähnlich wie zuvor enthalten die Steuersignale pardom_valtest_controls.json aus Gründen der Konsistenz und Fairness nur Frame-Grenzen (dh Offset und Intervall) für jede Szene.
In allen Fällen wird für das Argument --model_path grep angewendet, um mit Platzhaltern umzugehen, sodass Sie sich keine Gedanken über das Schreiben von Datumsangaben machen müssen. Entsprechende Ground-Truth-Frames werden ebenfalls gerendert und im Ausgabeordner gespeichert, was numerische Auswertungen ermöglicht (siehe Metriken unten).
Wenn Sie die bereitgestellten JSON-Steuerelemente ignorieren und stattdessen die Auswertung freier mit ausgewählten Winkeln und Frame-Grenzen in Kubric-4D ausführen möchten:
cd gcd-model/
CUDA_VISIBLE_DEVICES=0,1 python scripts/test.py --gpus=0,1
--config_path=configs/infer_kubric.yaml
--model_path=../logs/*_kb_v1/checkpoints/epoch=00000-step=00010000.ckpt
--input=../eval/list/kubric_test20.txt
--output=../eval/output/kubric_mytest2_cc
--azimuth_start=70.0 --elevation_start=10.0 --radius_start=15.0
--delta_azimuth=30.0 --delta_elevation=15.0 --delta_radius=1.0
--frame_start=0 --frame_stride=2 --frame_rate=12
--reproject_rgbd=0 --autocast=1 --num_samples=2 --num_steps=25
In ParallelDomain-4D sind die sechs Posen-bezogenen Argumente nicht anwendbar, Videoclip-Frame-Grenzen können jedoch weiterhin ausgewählt werden.
Das obige test.py Skript speichert pro Szene *_metrics.json Dateien im Unterordner extra/ die allgemeine PSNR- und SSIM-Nummern sowie pro Frame enthalten. Außerdem werden alle einzelnen Eingabe-, Vorhersage- und Zielbilder als Bilder für jedes vom Modell verarbeitete Beispiel gespeichert. Sie können diese verschiedenen Ausgaben gerne in Ihrem eigenen quantitativen Bewertungsworkflow verwenden, wenn Sie zusätzliche und/oder aggregierte Metriken berechnen möchten.
Im Vergleich zum Hauptabschnitt „Bewertung“ ist dieses Skript nicht auf die Grundwahrheit angewiesen, die möglicherweise nicht existiert. Im Vergleich zum Abschnitt „Inferenz (Gradio)“ exportiert dieses Skript mehr Informationen und Visualisierungen.
Bereiten Sie einen direkten Pfad zu einer Videodatei oder einem Bildordner oder eine Liste von Videodateien oder Bildordnern (in einer .txt Datei mit vollständigen Pfaden) vor und führen Sie Folgendes aus:
cd gcd-model/
CUDA_VISIBLE_DEVICES=0 python scripts/infer.py --gpus=0
--config_path=configs/infer_kubric.yaml
--model_path=../pretrained/kubric_gradual_max90.ckpt
--input=/path/to/video.mp4
--output=../eval/output/kubric_myinfer1
--delta_azimuth=30.0 --delta_elevation=15.0 --delta_radius=1.0
--frame_start=0 --frame_stride=2 --frame_rate=12
--autocast=1 --num_samples=2 --num_steps=25
Beachten Sie, dass --frame_rate die Ziel-FPS nach der zeitlichen Unterabtastung des Eingabevideos widerspiegeln sollte, nicht davor . Wenn Sie mehrere Beispiele auswerten möchten, empfehle ich die Verwendung einer Liste durch Festlegen von --input=/path/to/list.txt um den Overhead beim Laden des Modells zu reduzieren.
Wenn Sie dieselben exakten Daten wie in unseren Experimenten verwenden möchten, finden Sie unter diesem Download-Link eine Beschreibung und Kopien von Kubric-4D und ParallelDomain-4D. Der Rest dieses Abschnitts konzentriert sich darauf, ob Sie unsere Pipeline optimieren und/oder Ihre eigenen synthetischen Daten generieren möchten.
Befolgen Sie diese Anweisungen, um die OpenEXR-Bibliothek zu installieren. Führen Sie dann die folgenden Befehle aus, um Ihre Umgebung vorzubereiten:
conda activate gcd
pip install bpy==3.4.0
pip install pybullet
pip install OpenEXR
cd data-gen/kubric/
pip install -e .
Der Unterordner data-gen/kubric ist weitgehend identisch mit diesem Commit aus dem offiziellen Kubric-Repository von Google Research, ich habe jedoch einen kleinen Bugfix hinzugefügt, um Race Conditions beim Umgang mit Tiefenkarten zu vermeiden.
Dies ist der Befehl, mit dem wir den endgültigen Kubric-4D-Datensatz generiert haben (beachten Sie die Zeile rm -rf /tmp/ ):
cd data-gen/
for i in {1..110}
do
python export_kub_mv.py --mass_est_fp=gpt_mass_v4.txt
--root_dp=/path/to/kubric_mv_gen
--num_scenes=3000 --num_workers=10 --restart_count=30
--seed=900000 --num_views=16 --frame_width=576 --frame_height=384
--num_frames=60 --frame_rate=24 --save_depth=1 --save_coords=1
--render_samples_per_pixel=16 --focal_length=32
--fixed_alter_poses=1 --few_views=4
rm -rf /tmp/
done
Der Datensatz ist im Grunde eine Variation von TCOW Kubric und beinhaltet Verbesserungen wie dynamischere Objekte und einen erhöhten Massenrealismus. Einzelheiten finden Sie in der TCOW-Ergänzung.
Für die GCD-Zwecke rendern wir 16 synchronisierte Multiview-Videos von statischen Kameras. Vier Aussichtspunkte liegen auf einer hohen Höhe von 45 Grad und die anderen zwölf Aussichtspunkte auf einer niedrigen Höhe von 5 Grad. Ich empfehle, export_kub_mv.py zu überprüfen, um mehr Einblick in seine Parameter und Logik zu erhalten.
Alle Szenen werden iid generiert, daher definieren wir in unserer Version dieses Datensatzes die ersten 2800 als Trainingssatz und die letzten 100 + 100 als Validierungs- + Testsatz. Die äußere for-Schleife löscht regelmäßig den Ordner /tmp/ um Speicherplatzprobleme zu vermeiden.
Dieser Datensatz stammt von einem Dienst und kann nicht neu generiert werden. Bitte beachten Sie den Download-Link für unser Exemplar.
Beachten Sie, dass einige Szenenordner nicht vorhanden sind (es gibt 1531 Szenenordner, aber der Index geht bis 2143) und in einigen Szenen fehlen einige Frames, weshalb unser Datenlader so konzipiert ist, dass er beiden Problemen standhält. Während des Trainings werden möglicherweise einige Warnmeldungen angezeigt, dies ist jedoch normal. Außerdem sind die Szenen im Gegensatz zu Kubric nicht in Bezug auf den Index dekorreliert, daher haben wir in pardom_datasplit.json zufällige Teilmengen für Training, Validierung und Tests vorab ausgewählt.
Wir definieren die Größe des Validierungs- und Testsatzes auf 61 bzw. 61 Szenen (jeweils etwa 4 % des gesamten Datensatzes).
Ich habe einige Tools geschrieben, die auf TRI Camviz basieren, um Beispielszenen aus Kubric-4D und ParallelDomain-4D auf Ihrem lokalen Computer interaktiv zu visualisieren. Möglicherweise veröffentliche ich sie später hier, aber Sie können mich (Basile) in der Zwischenzeit gerne für den Quellcode kontaktieren.
Wenn Sie diese Codebasis in Ihrer Arbeit verwenden (oder einen wesentlichen Teil davon, z. B. die zur Feinabstimmung von SVD erforderlichen Änderungen), zitieren Sie bitte unser Dokument:
@article{vanhoorick2024gcd,
title={Generative Camera Dolly: Extreme Monocular Dynamic Novel View Synthesis},
author={Van Hoorick, Basile and Wu, Rundi and Ozguroglu, Ege and Sargent, Kyle and Liu, Ruoshi and Tokmakov, Pavel and Dave, Achal and Zheng, Changxi and Vondrick, Carl},
journal={European Conference on Computer Vision (ECCV)},
year={2024}
}
Ich empfehle, auch das Original-SVD-Papier zu zitieren:
@article{blattmann2023stable,
title={Stable video diffusion: Scaling latent video diffusion models to large datasets},
author={Blattmann, Andreas and Dockhorn, Tim and Kulal, Sumith and Mendelevitch, Daniel and Kilian, Maciej and Lorenz, Dominik and Levi, Yam and English, Zion and Voleti, Vikram and Letts, Adam and others},
journal={arXiv preprint arXiv:2311.15127},
year={2023}
}
Wenn Sie einen unserer Datensätze in Ihrer Arbeit verwenden, geben Sie bitte auch die entsprechende Quelle an:
@article{greff2021kubric,
title = {Kubric: a scalable dataset generator},
author = {Klaus Greff and Francois Belletti and Lucas Beyer and Carl Doersch and Yilun Du and Daniel Duckworth and David J Fleet and Dan Gnanapragasam and Florian Golemo and Charles Herrmann and others},
booktitle = {IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
year = {2022},
}
@misc{parallel_domain,
title = {Parallel Domain},
year = {2024},
howpublished={url{https://paralleldomain.com/}}
}
