Ist Yolo V12 besser als Yolo V11?

Yolo (Sie schauen nur einmal) conflict ein führender Echtzeit-Objekterkennungsrahmen, wobei jede Iteration die vorherigen Versionen verbessert. Die neueste Model YOLO V12 führt zu Fortschritten, die die Genauigkeit erheblich verbessern und gleichzeitig Echtzeitverarbeitungsgeschwindigkeiten beibehalten. In diesem Artikel werden die wichtigsten Innovationen in Yolo V12 untersucht und hervorgehoben, wie er die vorherigen Versionen übertrifft und gleichzeitig die Rechenkosten minimiert, ohne die Erkennungseffizienz zu beeinträchtigen.

Was ist neu in Yolo V12?

Zuvor stützten sich Yolo -Modelle auf Faltungsnetzwerke (CNNs) zur Objekterkennung aufgrund ihrer Geschwindigkeit und Effizienz. Yolo V12 nutzt jedoch Aufmerksamkeitsmechanismen, ein Konzept, das in Transformatormodellen weithin bekannt ist und es ermöglicht, Muster effektiver zu erkennen. Während die Aufmerksamkeitsmechanismen ursprünglich für die Erkennung von Objekten in Echtzeit nur langsam waren, integriert Yolo V12 sie irgendwie erfolgreich, während sie die Geschwindigkeit von Yolo beibehalten, was zu einem führt Aufmerksamkeitsorientiertes Yolo-Framework.

Schlüsselverbesserungen gegenüber früheren Versionen

1. Aufmerksamkeitszentrierter Rahmen

Yolo V12 kombiniert die Kraft von Aufmerksamkeitsmechanismen mit CNNs, was zu einem Modell führt, das beides ist schneller und genauer. Im Gegensatz zu seinen Vorgängern, die sich ausschließlich auf CNNs stützten, führt YOLO V12 optimierte Aufmerksamkeitsmodule ein, um die Objekterkennung zu verbessern, ohne unnötige Latenz hinzuzufügen.

2. Überlegene Leistungsmetriken

Der Vergleich von Leistungsmetriken in verschiedenen YOLO-Versionen und Echtzeit-Erkennungsmodellen zeigt, dass YOLO V12 eine höhere Genauigkeit erzielt und gleichzeitig eine geringe Latenz aufrechterhält.

• Der Karte (mittlere durchschnittliche Präzision) Die Werte für Datensätze wie Coco zeigen Yolo V12 übertrieben Yolo V11 und Yolo V10 und halten gleichzeitig eine vergleichbare Geschwindigkeit bei.
• Das Modell erreicht eine bemerkenswerte 40,6% Genauigkeit (Karte), während die Bilder in nur 1,64 Millisekunden verarbeitet werden auf einer Nvidia T4 GPU. Diese Leistung ist Yolo V10 und Yolo V11 überlegen, ohne die Geschwindigkeit zu beeinträchtigen.

3.. Outperformance von Nicht-Yolo-Modellen

Yolo V12 übertrifft frühere Yolo -Versionen; Es übertrifft auch andere Echtzeit-Objekterkennungs-Frameworks wie RT-DET und RT-DET V2. Diese alternativen Modelle haben eine höhere Latenz, die die Genauigkeit von Yolo V12 nicht entspricht.

Verbesserungen der Computereffizienz

Eines der Hauptanliegen bei der Integration von Aufmerksamkeitsmechanismen in YOLO -Modelle waren ihre hohen Rechenkosten (Aufmerksamkeitsmechanismus) und die Ineffizienz des Gedächtnisses. Yolo V12 befasst sich mit diesen Problemen über mehrere wichtige Innovationen:

1. Flash -Aufmerksamkeit für die Speichereffizienz

Traditionelle Aufmerksamkeitsmechanismen verbrauchen eine große Menge an Gedächtnis, was sie für Echtzeitanwendungen unpraktisch macht. Yolo V12 führt vor Flash -Aufmerksamkeiteine Technik, die den Speicherverbrauch reduziert und die Inferenzzeit beschleunigt.

2. Aufmerksamkeit der Fläche für niedrigere Berechnungskosten

Um die Effizienz weiter zu optimieren, beschäftigt Yolo V12 Aufmerksamkeit der Areadie sich nur auf relevante Regionen eines Bildes konzentriert, anstatt die gesamte Function -Karte zu verarbeiten. Diese Technik reduziert die Berechnungskosten drastisch und behält gleichzeitig die Genauigkeit bei.

3. R-Elan für eine optimierte Merkmalsverarbeitung

Yolo V12 führt ebenfalls vor R-Elan (überarbeitete Elan)was die Ausbreitung der Merkmale optimiert, wodurch das Modell bei der Umführung komplexer Objekterkennungsaufgaben effizienter wird, ohne die Rechenanforderungen zu erhöhen.

Yolo V12 -Modellvarianten

Yolo V12 ist in fünf verschiedenen Varianten ausgestattet, die sich für verschiedene Anwendungen befassen:

• N (Nano) & S (klein): Entwickelt für Echtzeitanwendungen, bei denen Geschwindigkeit entscheidend ist.
• M (Medium): Die Genauigkeit und Geschwindigkeit ausbalanciert, geeignet für allgemeine Aufgaben.
• L (groß) & xl (additional groß): Optimiert für hochpräzise Aufgaben, bei denen die Genauigkeit über die Geschwindigkeit priorisiert wird.

Lesen Sie auch:

Vergleichen wir Yolo V11 und Yolo V12 -Modelle

Wir werden mit YOLO V11 und YOLO V12 Small Fashions experimentieren, um ihre Leistung über verschiedene Aufgaben wie Objektzählen, Wärme- und Geschwindigkeitsschätzungen zu verstehen.

1. Objektzählung

Yolo V11

import cv2
from ultralytics import options

cap = cv2.VideoCapture("freeway.mp4")
assert cap.isOpened(), "Error studying video file"
w, h, fps = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)), int(cap.get(cv2.CAP_PROP_FPS)))

# Outline area factors
region_points = ((20, 1500), (1080, 1500), (1080, 1460), (20, 1460))  # Decrease rectangle area counting

# Video author (MP4 format)
video_writer = cv2.VideoWriter("object_counting_output.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init ObjectCounter
counter = options.ObjectCounter(
    present=False,  # Disable inner window show
    area=region_points,
    mannequin="yolo11s.pt",
)

# Course of video
whereas cap.isOpened():
    success, im0 = cap.learn()
    if not success:
        print("Video body is empty or video processing has been efficiently accomplished.")
        break
    
    im0 = counter.depend(im0)

    # Resize to suit display screen (non-obligatory — scale down for big movies)
    im0_resized = cv2.resize(im0, (640, 360))  # Alter decision as wanted
    
    # Present the resized body
    cv2.imshow("Object Counting", im0_resized)
    video_writer.write(im0)

    # Press 'q' to exit
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.launch()
video_writer.launch()
cv2.destroyAllWindows()

Ausgabe

Yolo V12

import cv2
from ultralytics import options

cap = cv2.VideoCapture("freeway.mp4")
assert cap.isOpened(), "Error studying video file"
w, h, fps = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)), int(cap.get(cv2.CAP_PROP_FPS)))

# Outline area factors
region_points = ((20, 1500), (1080, 1500), (1080, 1460), (20, 1460))  # Decrease rectangle area counting

# Video author (MP4 format)
video_writer = cv2.VideoWriter("object_counting_output.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init ObjectCounter
counter = options.ObjectCounter(
    present=False,  # Disable inner window show
    area=region_points,
    mannequin="yolo12s.pt",
)

# Course of video
whereas cap.isOpened():
    success, im0 = cap.learn()
    if not success:
        print("Video body is empty or video processing has been efficiently accomplished.")
        break
    
    im0 = counter.depend(im0)

    # Resize to suit display screen (non-obligatory — scale down for big movies)
    im0_resized = cv2.resize(im0, (640, 360))  # Alter decision as wanted
    
    # Present the resized body
    cv2.imshow("Object Counting", im0_resized)
    video_writer.write(im0)

    # Press 'q' to exit
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.launch()
video_writer.launch()
cv2.destroyAllWindows()

Ausgabe

2. Heatmaps

Yolo V11

import cv2

from ultralytics import options

cap = cv2.VideoCapture("mall_arial.mp4")
assert cap.isOpened(), "Error studying video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

# Video author
video_writer = cv2.VideoWriter("heatmap_output_yolov11.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# In case you wish to apply object counting + heatmaps, you possibly can move area factors.
# region_points = ((20, 400), (1080, 400))  # Outline line factors
# region_points = ((20, 400), (1080, 400), (1080, 360), (20, 360))  # Outline area factors
# region_points = ((20, 400), (1080, 400), (1080, 360), (20, 360), (20, 400))  # Outline polygon factors

# Init heatmap
heatmap = options.Heatmap(
    present=True,  # Show the output
    mannequin="yolo11s.pt",  # Path to the YOLO11 mannequin file
    colormap=cv2.COLORMAP_PARULA,  # Colormap of heatmap
    # area=region_points,  # If you wish to do object counting with heatmaps, you possibly can move region_points
    # courses=(0, 2),  # If you wish to generate heatmap for particular courses i.e particular person and automobile.
    # show_in=True,  # Show in counts
    # show_out=True,  # Show out counts
    # line_width=2,  # Alter the road width for bounding bins and textual content show
)

# Course of video
whereas cap.isOpened():
    success, im0 = cap.learn()
    if not success:
        print("Video body is empty or video processing has been efficiently accomplished.")
        break
    im0 = heatmap.generate_heatmap(im0)
    im0_resized = cv2.resize(im0, (w, h))
    video_writer.write(im0_resized)

cap.launch()
video_writer.launch()
cv2.destroyAllWindows()

Ausgabe

Yolo V12

import cv2

from ultralytics import options

cap = cv2.VideoCapture("mall_arial.mp4")
assert cap.isOpened(), "Error studying video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

# Video author
video_writer = cv2.VideoWriter("heatmap_output_yolov12.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# In case you wish to apply object counting + heatmaps, you possibly can move area factors.
# region_points = ((20, 400), (1080, 400))  # Outline line factors
# region_points = ((20, 400), (1080, 400), (1080, 360), (20, 360))  # Outline area factors
# region_points = ((20, 400), (1080, 400), (1080, 360), (20, 360), (20, 400))  # Outline polygon factors

# Init heatmap
heatmap = options.Heatmap(
    present=True,  # Show the output
    mannequin="yolo12s.pt",  # Path to the YOLO11 mannequin file
    colormap=cv2.COLORMAP_PARULA,  # Colormap of heatmap
    # area=region_points,  # If you wish to do object counting with heatmaps, you possibly can move region_points
    # courses=(0, 2),  # If you wish to generate heatmap for particular courses i.e particular person and automobile.
    # show_in=True,  # Show in counts
    # show_out=True,  # Show out counts
    # line_width=2,  # Alter the road width for bounding bins and textual content show
)

# Course of video
whereas cap.isOpened():
    success, im0 = cap.learn()
    if not success:
        print("Video body is empty or video processing has been efficiently accomplished.")
        break
    im0 = heatmap.generate_heatmap(im0)
    im0_resized = cv2.resize(im0, (w, h))
    video_writer.write(im0_resized)

cap.launch()
video_writer.launch()
cv2.destroyAllWindows()

Ausgabe

3. Geschwindigkeitsschätzung

Yolo V11

import cv2
from ultralytics import options
import numpy as np

cap = cv2.VideoCapture("cars_on_road.mp4")
assert cap.isOpened(), "Error studying video file"

# Seize video properties
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))

# Video author
video_writer = cv2.VideoWriter("speed_management_yolov11.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Outline pace area factors (modify on your video decision)
speed_region = ((300, h - 200), (w - 100, h - 200), (w - 100, h - 270), (300, h - 270))

# Initialize SpeedEstimator
pace = options.SpeedEstimator(
    present=False,  # Disable inner window show
    mannequin="yolo11s.pt",  # Path to the YOLO mannequin file
    area=speed_region,  # Move area factors
    # courses=(0, 2),  # Elective: Filter particular object courses (e.g., automobiles, vans)
    # line_width=2,  # Elective: Alter the road width
)

# Course of video
whereas cap.isOpened():
    success, im0 = cap.learn()
    if not success:
        print("Video body is empty or video processing has been efficiently accomplished.")
        break
    
    # Estimate pace and draw bounding bins
    out = pace.estimate_speed(im0)

    # Draw the pace area on the body
    cv2.polylines(out, (np.array(speed_region)), isClosed=True, colour=(0, 255, 0), thickness=2)

    # Resize the body to suit the display screen
    im0_resized = cv2.resize(out, (1280, 720))  # Resize for higher display screen match
    
    # Present the resized body
    cv2.imshow("Pace Estimation", im0_resized)
    video_writer.write(out)

    # Press 'q' to exit
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.launch()
video_writer.launch()
cv2.destroyAllWindows()

Ausgabe

Yolo V12

import cv2
from ultralytics import options
import numpy as np

cap = cv2.VideoCapture("cars_on_road.mp4")
assert cap.isOpened(), "Error studying video file"

# Seize video properties
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))

# Video author
video_writer = cv2.VideoWriter("speed_management_yolov12.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Outline pace area factors (modify on your video decision)
speed_region = ((300, h - 200), (w - 100, h - 200), (w - 100, h - 270), (300, h - 270))

# Initialize SpeedEstimator
pace = options.SpeedEstimator(
    present=False,  # Disable inner window show
    mannequin="yolo12s.pt",  # Path to the YOLO mannequin file
    area=speed_region,  # Move area factors
    # courses=(0, 2),  # Elective: Filter particular object courses (e.g., automobiles, vans)
    # line_width=2,  # Elective: Alter the road width
)

# Course of video
whereas cap.isOpened():
    success, im0 = cap.learn()
    if not success:
        print("Video body is empty or video processing has been efficiently accomplished.")
        break
    
    # Estimate pace and draw bounding bins
    out = pace.estimate_speed(im0)

    # Draw the pace area on the body
    cv2.polylines(out, (np.array(speed_region)), isClosed=True, colour=(0, 255, 0), thickness=2)

    # Resize the body to suit the display screen
    im0_resized = cv2.resize(out, (1280, 720))  # Resize for higher display screen match
    
    # Present the resized body
    cv2.imshow("Pace Estimation", im0_resized)
    video_writer.write(out)

    # Press 'q' to exit
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.launch()
video_writer.launch()
cv2.destroyAllWindows()

Ausgabe

Lesen Sie auch: High 30+ Laptop Imaginative and prescient Modelle für 2025

Expertenmeinungen zu Yolov11 und Yolov12

Muhammad Rizwan Munawar – Laptop Imaginative and prescient Engineer bei Ultralytics

„Yolov12 führt die Aufmerksamkeit der Flash -Aufmerksamkeit ein, die die Genauigkeit verbessert, aber ein sorgfältiges CUDA -Setup erfordert. Es ist ein solider Schritt nach vorne, insbesondere für komplexe Erkennungsaufgaben, obwohl Yolov11 für Echtzeitbedürfnisse weiterhin schneller bleibt. Kurz gesagt, wählen Sie Yolov12 für Genauigkeit und Yolov11 für Geschwindigkeit. “

LinkedIn Put up -Ist Yolov12 wirklich ein hochmodernes Modell? 🤪

Muhammad Rizwan, kürzlich getestet Yolov11 und Yolov12 nebeneinander, um ihre reale Leistung aufzubrechen. Seine Ergebnisse unterstreichen die Kompromisse zwischen den beiden Modellen:

• Rahmen professional Sekunde (FPS): Yolov11 hält einen Durchschnitt von 40 fpswährend Yolov12 zurückbleibt 30 fps. Dies macht Yolov11 zur besseren Wahl für Echtzeitanwendungen, bei denen Geschwindigkeit kritisch ist, z. B. Verkehrsüberwachung oder Stay-Video-Feeds.
• Trainingszeit: Yolov12 nimmt ungefähr 20% länger zu trainieren als yolov11. Auf einem kleinen Datensatz mit 130 Trainingsbilder und 43 ValidierungsbilderYolov11 absolvierte das Coaching in 0,009 Stundenwährend yolov12 brauchte 0,011 Stunden. Während dies für kleine Datensätze geringfügig erscheinen magazine, wird der Unterschied für größere Projekte signifikant.
• Genauigkeit: Beide Modelle erreicht Ähnliche Genauigkeit Nach der Feinabstimmung für 10 Epochen auf demselben Datensatz. Yolov12 übertrifft Yolov11 nicht dramatisch, was darauf hindeutet, dass die Verbesserungen des neueren Modells mehr in architektonischen Verbesserungen als in der Präzision von Rohkennung liegen.
• Flash -Aufmerksamkeit: Yolov12 führt vor Flash -Aufmerksamkeitein starker Mechanismus, der die Aufmerksamkeitsschichten beschleunigt und optimiert. Es gibt jedoch einen Haken-diese Funktion wird auf der CPU nicht nativ unterstützt, und das Ermöglichen von CUDA erfordert ein sorgfältiges Variations-spezifisches Setup. Für Groups ohne leistungsstarke GPUs oder solche, die an Edge -Geräten arbeiten, kann dies zu einer Straßensperre werden.

Die zum Testen verwendeten PC -Spezifikationen:

• GPU: Nvidia RTX 3050
• CPU: Intel Core-I5-10400 @2,90 GHz
• RAM: 64 GB

Die Modellspezifikationen:

• Modell = yolo11n.pt und yolov12n.pt
• Bildgröße = 640 für Inferenz

Abschluss

Yolo V12 markiert einen signifikanten Sprung nach vorne bei der Echtzeit-Objekterkennung und kombiniert die CNN-Geschwindigkeit mit transformatorähnlichen Aufmerksamkeitsmechanismen. Mit einer verbesserten Genauigkeit, niedrigeren Rechenkosten und einer Reihe von Modellvarianten kann Yolo V12 die Landschaft von Echtzeit-Imaginative and prescient-Anwendungen neu definieren. Egal, ob autonome Fahrzeuge, Sicherheitsüberwachung oder medizinische Bildgebung, YOLO V12 legt einen neuen Commonplace für die Effizienz der Echtzeit-Objekterkennung fest.

Was kommt als nächstes?

• Yolo V13 Möglichkeiten: Werden zukünftige Versionen die Aufmerksamkeitsmechanismen noch weiter vorantreiben?
• Edge -Geräteoptimierung: Kann die Aufmerksamkeit der Flash-Aufmerksamkeit oder der Aufmerksamkeit für die Fläche für Geräte mit niedrigerer Stromversorgung optimiert werden?

Um Ihnen zu helfen, die Unterschiede besser zu verstehen, habe ich einige Codeausschnitte und Ausgabeergebnisse im Vergleichsabschnitt beigefügt. Diese Beispiele veranschaulichen, wie sowohl Yolov11 als auch Yolov12 in realen Szenarien von Objektzählung bis hin zur Geschwindigkeitsschätzung und Heatmaps abschneiden. Ich freue mich zu sehen, wie ihr diese neue Veröffentlichung wahrnimmt! Reichen die Verbesserungen der Genauigkeits- und Aufmerksamkeitsmechanismen aus, um die Kompromisse bei der Geschwindigkeit zu rechtfertigen? Oder glauben Sie, dass Yolov11 für die meisten Anwendungen immer noch seinen Boden behält?

Genai Praktikant @ Analytics Vidhya | Letzte Jahr @ Vit Chennai
Leidenschaftlich für KI und maschinelles Lernen, ich bin bestrebt, als KI/ML -Ingenieur oder Datenwissenschaftler in Rollen einzutauchen, wo ich einen echten Einfluss haben kann. Ich freue mich sehr, progressive Lösungen und hochmoderne Fortschritte auf den Tisch zu bringen. Meine Neugier treibt mich an, KI über verschiedene Bereiche hinweg zu erkunden und die Initiative zu ergreifen, um sich mit Knowledge Engineering zu befassen, um sicherzustellen, dass ich vorne bleibe und wirksame Projekte liefere.