zur Vorbereitung von Movies für maschinelles Lernen/tiefes Lernen. Aufgrund der Größe und der Rechenkosten von Videodaten ist es wichtig, dass sie für Ihren Anwendungsfall so effizient verarbeitet werden. Dies umfasst Dinge wie Metadatenanalysen, Standardisierung, Augmentation, Schuss- und Objekterkennung und Tensorbelastung. In diesem Artikel wird einige Möglichkeiten untersucht, wie diese getan werden können und warum wir sie tun würden. Ich habe auch ein Open -Supply -Python -Paket namens gebaut Vid-Prepper. Ich habe das Paket mit dem Ziel erstellt, eine schnelle und effiziente Möglichkeit zu bieten, verschiedene Vorverarbeitungstechniken auf Ihre Videodaten anzuwenden. Das Paket baut einige Riesen des maschinellen Lernens und der Deep -Studying -Welt auf. Während dieses Paket nützlich ist, um sie in einem gemeinsamen und einfach zu bedienenden Rahmen zusammenzubringen, ist die wirkliche Arbeit auf jeden Fall auf sie!
Video conflict ein wichtiger Teil meiner Karriere. Ich habe meine Datenkarriere in einem Unternehmen begonnen, das eine SaaS -Plattform für Videoanalysen für wichtige führende Videounternehmen aufgebaut hat (genannt NPAW) und derzeit für die BBC arbeiten. Video dominiert derzeit die Weblandschaft, aber mit KI ist immer noch ziemlich begrenzt, obwohl sie superschnell wachsen. Ich wollte etwas schaffen, das die Fähigkeit der Menschen beschleunigt, Dinge auszuprobieren und zu diesem wirklich interessanten Bereich beizutragen. In diesem Artikel wird erläutert, was die verschiedenen Paketmodule tun und wie sie verwendet werden, beginnend mit Metadatenanalysen.
Metadatenanalyse
from vid_prepper import metadataBei der BBC habe ich das große Glück, in einer professionellen Organisation mit sehr talentierten Personen zu arbeiten, die über hochwertige Qualitätsvideos erstellen. Ich weiß jedoch, dass die meisten Videodaten nicht das sind. Oft sind Dateien gemischte Formate, Farben, Größen oder sie können beschädigt oder Teile fehlen. Sie können auch Macken aus älteren Movies wie Interlacing haben. Es ist wichtig, dass Sie sich eines davon bewusst sind, bevor Sie Movies für maschinelles Lernen verarbeiten.
Wir werden unsere Modelle für GPUs ausbilden und diese sind fantastisch für Tensorberechnungen im Maßstab, aber teuer zu laufen. Beim Coaching großer Modelle für GPUs möchten wir so effizient wie möglich sein, um hohe Kosten zu vermeiden. Wenn wir Movies oder Movies in unerwarteten oder nicht unterstützten Formaten beschädigt haben, verschwenden Sie Zeit und Ressourcen, können Ihre Modelle weniger genau machen oder sogar die Trainingspipeline zum Ausbruch bringen. Das Überprüfen und Filtern Ihrer Dateien im Voraus ist daher eine Notwendigkeit.
Ich habe das Metadata -Analysemodul in der FFPROBE -Bibliothek, Teil der Ffmpeg Bibliothek in C und Assembler eingebaut. Dies ist eine äußerst leistungsstarke und effiziente Bibliothek, die im Beruf ausgiebig verwendet wird, und das Modul kann verwendet werden, um eine einzelne Videodatei oder eine Stapel von ihnen zu analysieren, wie im folgenden Code gezeigt.
# Extract metadata
video_path = (“pattern.mp4”)
video_info = metadata.Metadata.validate_videos(video_path)
# Extract metadata batch
video_paths = (“sample1.mp4”, “sample2.mp4”, “sample3.mp4”)
video_info = metadata.Metadata.validate_videos(video_paths)Dies bietet eine Wörterbuchausgabe der Videometadaten, einschließlich Codecs, Größen, Bildraten, Dauer, Pixelformaten, Audio -Metadaten und mehr. Dies ist sowohl für das Suchen von Videodaten mit Problemen oder ungeraden Macken als auch für die Auswahl bestimmter Videodaten oder die Auswahl der Formate und Codec wirklich nützlich, um basierend auf den am häufigsten verwendeten zu standardisieren.
Filterung aufgrund von Metadatenproblemen
Angesichts dessen schien es ein ziemlich regelmäßiger Anwendungsfall zu sein, habe ich die Fähigkeit eingebaut, die Liste der Movies basierend auf einer Reihe von Schecks zu filtern. Wenn beispielsweise Video- oder Audiofehle, Codecs oder Formate nicht wie angegeben oder Bildraten oder -dauern von den angegebenen Personen unterscheiden, können diese Movies identifiziert werden, indem die Parameter Filter und nur_errors festgelegt werden, wie unten gezeigt.
# Run assessments on movies
movies = ("video1.mp4", "video2.mkv", "video3.mov")
all_filters_with_params = {
"filter_missing_video": {},
"filter_missing_audio": {},
"filter_variable_framerate": {},
"filter_resolution": {"min_width": 1280, "min_height": 720},
"filter_duration": {"min_seconds": 5.0},
"filter_pixel_format": {"allowed": ("yuv420p", "yuv422p")},
"filter_codecs": {"allowed": ("h264", "hevc", "vp9", "prores")}
}
errors = Metadata.validate_videos(
movies,
filters=all_filters_with_params,
only_errors=True
)Durch das Entfernen oder Identifizieren von Problemen mit den Daten, bevor wir die wirklich intensive Arbeit des Modelltrainings erreichen, vermeiden wir es, Zeit und Geld zu verschwenden, was es zu einem wichtigen ersten Schritt macht.
Standardisierung
from vid_prepper import standardizeDie Standardisierung ist in der Regel ziemlich wichtig bei der Vorverarbeitung für das maschinelle Lernen von Videoen. Es kann dazu beitragen, die Dinge viel effizienter und konsistenter zu machen, und oft erfordern Deep -Lern -Modelle bestimmte Größen (z. B. 224 x 224). Wenn Sie viele Videodaten haben, wird jeder Zeitpunkt, der in dieser Section verbracht wird, später in der Trainingsphase später oft zurückgezahlt.
Codecs
Movies werden häufig zur effizienten Speicherung und Verteilung über das Web strukturiert, damit sie billig und schnell übertragen werden können. Dies beinhaltet normalerweise eine starke Komprimierung, um Movies so klein wie möglich zu machen. Leider ist dies so intestine wie diametral gegen das, was intestine für Deep Studying ist.
Der Engpass für Deep Studying ist quick immer, Movies zu dekodieren und sie in Tensoren zu laden. Je komprimierter eine Videodatei ist, desto länger dauert dies. Dies bedeutet in der Regel, extremely komprimierte Codecs wie H265 und VVC zu vermeiden und leichter komprimierte Alternativen mit {Hardware} -Beschleunigung wie H264 oder VP9 oder so lange, wie Sie I/O -Engpässe vermeiden können, wobei Sie in der Produktion, die in der Produktion verwendet werden, wie es in der Produktion verwendet werden, die sich in Tensoren befinden.
Bildrate
Die Normal -Frameraten (FPS) für Video betragen 24 für Kino, 30 für Fernseh- und On-line -Inhalte und 60 für schnelle Bewegungsinhalte. Diese Bildrate werden durch die Anzahl der Bilder bestimmt, die professional Sekunde angezeigt werden müssen, damit unsere Augen eine glatte Bewegung sehen. Deep Studying -Modelle müssen jedoch nicht unbedingt eine so hohe Bildrate in den Trainingsvideos benötigen, um numerische Darstellungen von Bewegung zu erstellen und reibungslose Movies zu erzeugen. Da jeder Body ein zusätzlicher Tensor ist, der berechnet werden muss, möchten wir die Bildrate bis zu dem kleinsten minimieren, mit dem wir davonkommen können.
Verschiedene Arten von Movies und der Anwendungsfall unserer Modelle bestimmen, wie niedrig wir gehen können. Je weniger Bewegung in einem Video, desto niedriger können wir die Eingangsbildungsrate einstellen, ohne die Ergebnisse zu beeinträchtigen. Beispielsweise erfordert ein Eingabedatensatz von Studio -Nachrichtenclips oder Talkshows eine niedrigere Bildrate als ein Datensatz aus Eishockey -Spielen. Wenn wir an einem Videoverständnis oder einem Video-zu-Textual content-Modell arbeiten, anstatt Movies für den menschlichen Verbrauch zu generieren, ist es möglicherweise möglich, die Bildrate noch niedriger festzulegen.
Berechnung der minimalen Bildrate
Es ist tatsächlich möglich, eine ziemlich gute Mindestrate für Ihren Video -Datensatz basierend auf Bewegungsstatistiken mathematisch zu bestimmen. Mit a FLOSS oder FarneBack Algorithmus Bei einer Probe Ihres Datensatzes können Sie den optischen Fluss professional Pixel für jede Rahmenänderung berechnen. Dies liefert die horizontale und vertikale Verschiebung für jedes Pixel, um die Größe der Änderung (die quadratische Wurzel des Hinzufügens der quadratischen Werte) zu berechnen.
Durchschnittlich dieses Wertes über den Rahmen ergibt den Rahmen im Momentum und die Einnahme des Median- und 95. Perzentils aller Rahmen ergibt Werte, die Sie in die folgende Gleichung einstellen können, um eine Reihe wahrscheinlicher optimaler Mindestrahmenquoten für Ihre Trainingsdaten zu erhalten.
Optimum FPS (Decrease) = Present FPS x Max mannequin interpolation fee / Median momentum
Optimum FPS (Increased) = Present FPS x Max mannequin interpolation fee / ninety fifth percentile momentumWenn die Interpolation des maximalen Modells die maximale professional Rahmenimpuls ist, kann das Modell verarbeiten, normalerweise in der Modellkarte.
Sie können dann kleine Checks Ihrer Trainingspipeline durchführen, um die niedrigste Bildrate zu ermitteln, die Sie für eine optimale Leistung erzielen können.
Vid Prepper
Das Standardize-Modul in VID-Prepper kann die Größe, das Codec, die Farbformat und die Bildrate eines einzelnen Movies oder eine einzelne Movies standardisieren.
Auch hier basiert es auf FFMPEG und kann die Dinge bei GPU beschleunigen, wenn Ihnen dies zur Verfügung steht. Um Movies zu standardisieren, können Sie den folgenden Code einfach ausführen.
# Standardize batch of movies
video_file_paths = (“sample1.mp4”, “sample2.mp4”, “sample3.mp4”)
standardizer = standardize.VideoStandardizer(
measurement="224x224",
fps=16,
codec="h264",
shade="rgb",
use_gpu=False # Set to True when you have CUDA
)
standardizer.batch_standardize(movies=video_file_paths, output_dir="movies/")Um die Dinge effizienter zu gestalten, insbesondere wenn Sie teure GPUs verwenden und keinen IO -Engpass beim Laden von Movies möchten, akzeptiert das Modul auch WebDatasets. Diese können ähnlich wie der folgende Code geladen werden:
# Standardize webdataset
standardizer = standardize.VideoStandardizer(
measurement="224x224",
fps=16,
codec="h264",
shade="rgb",
use_gpu=False # Set to True when you have CUDA
)
standardizer.standardize_wds("dataset.tar", key="mp4", label="cls")Tensorlader
from vid_prepper import loaderEin Video -Tensor beträgt normalerweise 4 oder 5 Abmessungen, bestehend aus der Pixelfarbe (normalerweise RGB), der Höhe und Breite des Rahmens, der Zeit- und Stapelkomponenten (optionally available). Wie oben erwähnt, sind Dekodieren von Movies in Tensoren häufig der größte Engpass in der Vorverarbeitungspipeline.
Dieses Modul wandelt Movies in Pytorch -Tensoren mit FFMPEG für Body -Proben und NVDEC um, um eine GPU -Beschleunigung zu ermöglichen. Sie können die Größe der Tensoren so ändern, dass Sie Ihr Modell anpassen und die Anzahl der Rahmen, die professional Clip und den Rahmenschritt (Abstand zwischen den Frames) ausgewählt werden sollen, ausgewählt werden. Wie bei der Standardisierung ist auch die Possibility zur Verwendung von WebDatasets verfügbar. Der folgende Code gibt ein Beispiel, wie dies erledigt ist.
# Load clips into tensors
loader = VideoLoader(num_frames=16, frame_stride=2, measurement=(224,224), system="cuda")
video_paths = ("video1.mp4", "video2.mp4", "video3.mp4")
batch_tensor = loader.load_files(video_paths)
# Load webdataset into tensors
wds_path = "information/shards/{00000..00009}.tar"
dataset = loader.load_wds(wds_path, key="mp4", label="cls")Detektor
from vid_prepper import detectorEs ist oft ein notwendiger Bestandteil der Videovorverarbeitung, um Dinge im Videoinhalt zu erkennen. Dies können bestimmte Objekte, Aufnahmen oder Übergänge sein. Dieses Modul vereint leistungsstarke Prozesse und Modelle von Pyszenedetektor, Harmgingface, Concept Analysis und Pytorch, um eine effiziente Erkennung zu ermöglichen.
Schusserkennung
In vielen Anwendungsfällen für maschinelles Lernen (z. B. semantische Suche, SEQ2SEQ -Trailergenerierung und vielem mehr) ist es ein wichtiger Schritt, Movies in einzelne Aufnahmen aufzuteilen. Es gibt ein paar Möglichkeiten, dies zu tun, aber Pyszenedetekt ist eine der genaueren und zuverlässigeren Möglichkeiten, dies zu tun. Diese Bibliothek bietet einen Wrapper für die Inhaltserkennungsmethode von PyscenedEct, indem die folgende Methode aufgerufen wird. Es gibt die Begin- und Endrahmen für jeden Schuss aus.
# Detect photographs in movies
video_path = "video.mp4"
detector = VideoDetector(system="cuda")
shot_frames = detector.detect_shots(video_path)Übergangserkennung
Während PyszenedEtekt ein starkes Werkzeug ist, um Movies in einzelne Szenen aufzuteilen, ist es nicht immer 100% genau. Es gibt Zeiten, in denen Sie möglicherweise wiederholte Inhalte (z. B. Übergänge) ausbrechen können. Beispielsweise verfügt BBC Information über einen rot -weißen Wischwechsel zwischen den Segmenten, die mithilfe von Pytorch leicht erkannt werden können.
Die Übergangserkennung funktioniert direkt auf Tensoren, indem Pixeländerungen in Pixelblöcken erfasst werden, die eine bestimmte Schwellenwertänderung überschreiten, die Sie festlegen können. Der Beispielcode unten zeigt, wie er funktioniert.
# Detect gradual transitions/wipes
video_path = "video.mp4"
video_loader = loader.VideoLoader(num_frames=16,
frame_stride=2,
measurement=(224, 224),
system="cpu",
use_nvdec=False # Use "cuda" if obtainable)
video_tensor = loader.load_file(video_path)
detector = VideoDetector(system="cpu" # or cuda)
wipe_frames = detector.detect_wipes(video_tensor,
block_grid=(8,8),
threshold=0.3)Objekterkennung
Die Objekterkennung ist häufig eine Voraussetzung, um die Clips zu finden, die Sie in Ihren Videodaten benötigen. Zum Beispiel benötigen Sie möglicherweise Clips mit Menschen in ihnen oder Tieren. Diese Methode verwendet eine Open Supply Dino -Modell gegen einen kleinen Satz von Objekten aus dem Normal Coco -Datensatzetiketten zum Erkennen von Objekten. Sowohl die Modellauswahl als auch die Liste der Objekte sind vollständig anpassbar und können von Ihnen festgelegt werden. Der Modelllader ist das Paket für die Umarmung der Transformatoren, sodass das von Ihnen verwendete Modell verfügbar sein muss. Für benutzerdefinierte Beschriftungen nimmt das Standardmodell eine Zeichenfolge mit der folgenden Struktur im Parameter text_queries – „Hund. Cat. Ambulance“.
# Detect objects in movies
video_path = "video.mp4"
video_loader = loader.VideoLoader(num_frames=16,
frame_stride=2,
measurement=(224, 224),
system="cpu",
use_nvdec=False # Use "cuda" if obtainable)
video_tensor = loader.load_file(video_path)
detector = VideoDetector(system="cpu" # or cuda)
outcomes = detector.detect_objects(video,
text_queries=text_queries # if None will default to COCO listing,
text_threshold=0.3,
model_id=”IDEA-Analysis/grounding-dino-tiny”)Datenvergrößerung
Dinge wie Video -Transformatoren sind unglaublich leistungsfähig und können verwendet werden, um großartige neue Modelle zu erstellen. Sie benötigen jedoch häufig eine große Menge an Daten, die mit Dingen wie Video nicht unbedingt leicht verfügbar sind. In diesen Fällen benötigen wir eine Möglichkeit, verschiedene Daten zu generieren, die unsere Modelle übertreffen. Datenvergrößerung ist eine solche Lösung, um die begrenzte Datenverfügbarkeit zu steigern.
Für Video gibt es eine Reihe von Standardmethoden, um die Daten zu erweitern, und die meisten werden von den Hauptrahmen unterstützt. Vid-Prepper bringt zwei der besten zusammen- Kornia Und Torchvision. Mit VID-Prepper können Sie einzelne Augmentationen wie Zuschneiden, Flippen, Spiegelung, Polsterung, Gaußsche Unschärfe, Helligkeit, Farbe, Sättigung und Kontrast sowie grobes Ausfallende (bei maskiertem Teilen des Videobrahmens) durchführen. Sie können sie auch für eine höhere Effizienz zusammenketten.
Augmentationen arbeiten alle an den Video -Tensoren und nicht direkt in den Movies und unterstützen Sie die GPU -Beschleunigung, wenn Sie es haben. Der folgende Beispielcode zeigt, wie die Methoden einzeln aufgerufen werden und wie sie angehalten werden.
# Particular person Augmentation Instance
video_path = "video.mp4"
video_loader = loader.VideoLoader(num_frames=16,
frame_stride=2,
measurement=(224, 224),
system="cpu",use_nvdec=False # Use "cuda" if obtainable)
video_tensor = loader.load_file(video_path)
video_augmentor = augmentor.VideoAugmentor(system="cpu", use_gpu=False)
cropped = augmentor.crop(video_tensor, sort="heart", measurement=(200, 200))
flipped = augmentor.flip(video_tensor, sort="horizontal")
brightened = augmentor.brightness(video_tensor, quantity=0.2)
# Chained Augmentations
augmentations = (
('crop', {'sort': 'random', 'measurement': (180, 180)}),
('flip', {'sort': 'horizontal'}),
('brightness', {'quantity': 0.1}),
('distinction', {'quantity': 0.1})
)
chained_result = augmentor.chain(video_tensor, augmentations)Zusammenfassen
Videovorverarbeitung ist aufgrund der relativ großen Größe der Daten im Vergleich zum Textual content im tiefen Lernen von großer Bedeutung. Transformatormodellanforderungen für Ozeane der Datenverbindung verbinden dies noch weiter. Drei Schlüsselelemente bilden den tiefen Lernprozess – Zeit, Geld und Leistung. Durch die Optimierung unserer Eingabevideodaten können wir die Menge der ersten beiden Elemente minimieren, die wir benötigen, um das Beste aus dem letzten herauszuholen.
Es gibt einige erstaunliche Open -Supply -Instruments für Video -maschinelles Lernen, wobei derzeit jeden Tag mehr weitergeht. Vid-Prepper steht auf den Schultern einiger der besten und am weitesten verbreiteten, um zu versuchen, sie in einem einfach zu bedienenden Paket zusammenzubringen. Hoffentlich finden Sie einen gewissen Wert darin und es hilft Ihnen, die nächste Technology von Video -Modellen zu erstellen, was äußerst aufregend ist!