YOLOv9 객체 감지 튜토리얼

pip install opencv-python ultralytics pytubefix requests pillow


from ultralytics import YOLO
import requests
from PIL import Image
from io import BytesIO
import os

# Download the YOLOv9 model if it doesn't exist
model_path = "yolov9m.pt"
# Load the pretrained YOLOv9 model
model = YOLO(model_path)

# Download the image from the URL
image_url = "https://di-uploads-pod25.dealerinspire.com/koenigseggflorida/uploads/2019/08/Koenigsegg_TheSquad_3200x2000-UPDATED.jpg"
response = requests.get(image_url)
img = Image.open(BytesIO(response.content))

# Set the confidence and IoU thresholds
confidence_threshold = 0.5
iou_threshold = 0.4

# Predict with the model using the set thresholds
results = model.predict(img, conf=confidence_threshold, iou=iou_threshold)
results[0].show()

import cv2
from ultralytics import YOLO
import os
# Download the YOLOv9 model if it doesn't exist
model_path = "yolov9c.pt"
# Load the pretrained YOLOv9 model
model = YOLO(model_path)

# Initialize the webcam
# 0 is the default camera. If you have multiple cameras(ex: an external one on your laptop) you may need to change this number.
cap = cv2.VideoCapture(0)
if not cap.isOpened():
    print("Error: Could not open webcam.")
    exit()

while True:
    ret, frame = cap.read()
    if not ret:
        print("Error: Could not read frame.")
        break

    # Convert the frame to the format expected by YOLO
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    # Run YOLO model on the frame
    results = model.predict(frame_rgb)

    # Draw bounding boxes on the frame
    for box in results[0].boxes:
        x1, y1, x2, y2 = map(int, box.xyxy.tolist()[0])
        class_id = int(box.cls)
        class_name = results[0].names[class_id]
        confidence = box.conf.item()
        if confidence < .8:
            continue
        
        # Draw rectangle and label on the frame
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
        label = f"{class_name}: {confidence:.2f}"
        cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

    # Display the frame with detections
    cv2.imshow("YOLO Webcam Detection", frame)

    # Break the loop if the user presses 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release the webcam and close the window
cap.release()
cv2.destroyAllWindows()

import cv2
from ultralytics import YOLO
import os
import argparse
from pytubefix import YouTube

# Function to download YouTube video using pytubefix
def download_youtube_video(url, output_path):
    try:
        yt = YouTube(url)
        stream = yt.streams.get_highest_resolution()
        stream.download(output_path=output_path, filename="downloaded_video.mp4")
        print("Video downloaded successfully.")
    except Exception as e:
        print(f"Error downloading video: {e}")

# Parse command-line arguments
parser = argparse.ArgumentParser(description="YOLOv5 Object Detection on YouTube Video")
parser.add_argument("url", type=str, help="URL of the YouTube video to process")
args = parser.parse_args()



# Download the YOLOv9 model if it doesn't exist
model_path = "yolov9c.pt"
# Load the pretrained YOLOv9 model
model = YOLO(model_path)


# Download YouTube video
youtube_url = args.url
download_youtube_video(youtube_url, os.getcwd())

# Open the downloaded video
video_path = "downloaded_video.mp4"
cap = cv2.VideoCapture(video_path)

if not cap.isOpened():
    print("Error: Could not open video.")
    exit()

while True:
    ret, frame = cap.read()
    if not ret:
        print("End of video.")
        break

    # Convert the frame to the format expected by YOLO
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    # Run YOLO model on the frame
    results = model.predict(frame_rgb)

    # Draw bounding boxes on the frame
    for box in results[0].boxes:
        x1, y1, x2, y2 = map(int, box.xyxy.tolist()[0])
        class_id = int(box.cls)
        class_name = results[0].names[class_id]
        confidence = box.conf.item()
        if confidence < 0.5:
            continue
        
        # Draw rectangle and label on the frame
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
        label = f"{class_name}: {confidence:.2f}"
        cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

    # Display the frame with detections
    cv2.imshow("YOLO Video Detection", frame)

    # Break the loop if the user presses 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release the video and close the window
cap.release()
cv2.destroyAllWindows()

from ultralytics import YOLO
import requests
from PIL import Image
from io import BytesIO
import os
import wandb
import weave

# Initialize Weave and wandb with the same project name
project_name = "yolo_training"
weave.init(project_name)
run = wandb.init(project=project_name)

# Use the specified artifact
artifact = run.use_artifact('byyoung3/model-registry/yolo:v0', type='model')
artifact_dir = artifact.download()

# Define the path to the downloaded model
model_path = os.path.join(artifact_dir, "best.pt")

# Load the pretrained YOLOv9 model
model = YOLO(model_path)

# Function to run inference on a single image
@weave.op
def run_inference(image: Image.Image) -> dict:
    try:
        # Save the image locally for prediction
        local_image_path = 'temp_image.jpg'
        image.save(local_image_path)
        
        # Run the YOLO model on the image with adjusted NMS threshold
        results = model.predict(local_image_path, conf=0.7, iou=0.2)
        
        # Draw bounding boxes on the image and save the result
        results[0].save(local_image_path)
        result_image = Image.open(local_image_path)

        # Extract predictions
        predictions = []
        for box in results[0].boxes:
            class_id = int(box.cls)
            class_name = results[0].names[class_id]
            confidence = box.conf.item()
            coordinates = box.xyxy.tolist()
            predictions.append({
                'class': class_name,
                'confidence': confidence,
                'coordinates': coordinates
            })
        
        # Prepare the results
        result_data = {
            'result_image': result_image,
            'predictions': predictions
        }
        
        return result_data
    except Exception as e:
        return {'error': str(e)}

# Download the image from the URL
image_url = "https://i.ytimg.com/vi/7FmHydF9Gvg/hqdefault.jpg"
response = requests.get(image_url)
image = Image.open(BytesIO(response.content))

# Run inference using the downloaded image
inference_result = run_inference(image)
print(inference_result)