Transitioning from Amazon Rekognition individuals pathing: Exploring different options

Amazon Rekognition individuals pathing is a machine studying (ML)–primarily based functionality of Amazon Rekognition Video that customers can use to grasp the place, when, and the way every particular person is shifting in a video. This functionality can be utilized for a number of use circumstances, akin to for understanding:

1. Retail analytics – Buyer circulation within the retailer and figuring out high-traffic areas
2. Sports activities analytics – Gamers’ actions throughout the sphere or court docket
3. Industrial security – Employees’ motion in work environments to advertise compliance with security protocols

After cautious consideration, we made the choice to discontinue Rekognition individuals pathing on October 31, 2025. New prospects won’t be able to entry the potential efficient October 24, 2024, however present prospects will be capable of use the potential as regular till October 31, 2025.

This publish discusses another resolution to Rekognition individuals pathing and how one can implement this resolution in your functions.

Options to Rekognition individuals pathing

One different to Amazon Rekognition individuals pathing combines the open supply ML mannequin YOLOv9, which is used for object detection, and the open supply ByteTrack algorithm, which is used for multi-object monitoring.

Overview of YOLO9 and ByteTrack

YOLOv9 is the most recent within the YOLO object detection mannequin collection. It makes use of a specialised structure known as Generalized Environment friendly Layer Aggregation Community (GELAN) to research photos effectively. The mannequin divides a picture right into a grid, rapidly figuring out and finding objects in every part in a single move. It then refines its outcomes utilizing a way known as programmable gradient info (PGI) to enhance accuracy, particularly for simply missed objects. This mixture of velocity and accuracy makes YOLOv9 very best for functions that want quick and dependable object detection.

ByteTrack is an algorithm for monitoring a number of shifting objects in movies, akin to individuals strolling by means of a retailer. What makes it particular is the way it handles objects which might be each simple and troublesome to detect. Even when somebody is partially hidden or in a crowd, ByteTrack can typically nonetheless comply with them. It’s designed to be quick and correct, working nicely even when there are lots of individuals to trace concurrently.

While you mix YOLOv9 and ByteTrack for individuals pathing, you’ll be able to assessment individuals’s actions throughout video frames. YOLOv9 supplies particular person detections in every video body. ByteTrack takes these detections and associates them throughout frames, creating constant tracks for every particular person, displaying how individuals transfer by means of the video over time.

Instance code

The next code instance is a Python script that can be utilized as an AWS Lambda perform or as a part of your processing pipeline. You may as well deploy YOLOv9 and ByteTrack for inference utilizing Amazon SageMaker. SageMaker supplies a number of choices for mannequin deployment, akin to real-time inference, asynchronous inference, serverless inference, and batch inference. You possibly can select the acceptable possibility primarily based on your small business necessities.

Right here’s a high-level breakdown of how the Python script is executed:

1. Load the YOLOv9 mannequin – This mannequin is used for detecting objects in every body.
2. Begin the ByteTrack tracker – This tracker assigns distinctive IDs to things and tracks them throughout frames.
3. Iterate by means of video body by body – For every body, the script iterates by detecting objects, monitoring path, and drawing bounding containers and labels round them. All these are saved on a JSON file.
4. Output the processed video – The ultimate video is saved with all of the detected and tracked objects, annotated on every body.

# set up and import needed packages
!pip set up opencv-python ultralytics
!pip set up imageio[ffmpeg]

import cv2
import imageio
import json
from ultralytics import YOLO
from pathlib import Path

# Load an official Section mannequin from YOLOv9
mannequin = YOLO('yolov9e-seg.pt') 

# outline the perform that modifications YOLOV9 output to Individual pathing API output format
def change_format(outcomes, ts, person_only):
    #set person_only to True should you solely wish to observe individuals, not different objects.
    object_json = []

    for i, obj in enumerate(outcomes.containers):
        x_center, y_center, width, top = obj.xywhn[0]
        # Calculate Left and Prime from heart
        left = x_center - (width / 2)
        prime = y_center - (top / 2)
        obj_name = outcomes.names[int(obj.cls)]
        # Create dictionary for every object detected
        if (person_only and obj_name == "particular person") or not person_only:
            obj_data = {
                obj_name: {
                    "BoundingBox": {
                        "Top": float(top),
                        "Left": float(left),
                        "Prime": float(prime),
                        "Width": float(width)
                    },
                    "Index": int(obj.id)  # Object index
                },
                "Timestamp": ts  # timestamp of the detected object
            }
        object_json.append(obj_data)

    return object_json

#  Operate for particular person monitoring with json outputs and optionally available movies with annotation 
def person_tracking(video_path, person_only=True, save_video=True):
    # open the video file
    reader = imageio.get_reader(video_path)
    frames = []
    i = 0
    all_object_data = []
    file_name = Path(video_path).stem

    for body in reader:
        # Convert body from RGB (imageio's default) to BGR (OpenCV's default)
        frame_bgr = cv2.cvtColor(body, cv2.COLOR_RGB2BGR)
        strive:
            # Run YOLOv9 monitoring on the body, persisting tracks between frames with bytetrack
            conf = 0.2
            iou = 0.5
            outcomes = mannequin.observe(frame_bgr, persist=True, conf=conf, iou=iou, present=False, tracker="bytetrack.yaml")

            # change detection outcomes to Individual pathing API output codecs.
            object_json = change_format(outcomes[0], i, person_only)
            all_object_data.append(object_json)

            # Append the annotated body to the frames record (for mp4 creation)
            annotated_frame = outcomes[0].plot()
            frames.append(annotated_frame)
            i += 1

        besides Exception as e:
            print(f"Error processing body: {e}")
            break

    # save the thing monitoring array to json file
    with open(f'{file_name}_output.json', 'w') as file:
        json.dump(all_object_data, file, indent=4)
   
     # save annotated video
    if save_video is True:
        # Create a VideoWriter object of mp4
        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
        output_path = f"{file_name}_annotated.mp4"
        fps = reader.get_meta_data()['fps']
        frame_size = reader.get_meta_data()['size']
        video_writer = cv2.VideoWriter(output_path, fourcc, fps, frame_size)

        # Write every body to the video and launch the video author object when carried out
        for body in frames:
            video_writer.write(body)
        video_writer.launch()
        print(f"Video saved to {output_path}")

    return all_object_data
    
        
#most important perform to name 
video_path="./MOT17-09-FRCNN-raw.webm"
all_object_data = person_tracking(video_path, person_only=True, save_video=True)

Validation

We use the next video to showcase this integration. The video reveals a soccer apply session, the place the quarter again is beginning a play.

The next desk reveals an instance of the content material from the JSON file with particular person monitoring outputs by timestamp.

The video beneath present the outcomes with the individuals monitoring output

Different open supply options for individuals pathing

Though YOLOv9 and ByteTrack provide a strong mixture for individuals pathing, a number of different open supply options are price contemplating:

1. DeepSORT – A well-liked algorithm that mixes deep studying options with conventional monitoring strategies
2. FairMOT – Integrates object detection and reidentification in a single community, providing customers the power to trace objects in crowded scenes

These options will be successfully deployed utilizing Amazon SageMaker for inference.

Conclusion

On this publish, we’ve got outlined how one can check and implement YOLOv9 and Byte Monitor as an alternative choice to Rekognition individuals pathing. Mixed with AWS instrument choices akin to AWS Lambda and Amazon SageMaker, you’ll be able to implement such open supply instruments on your functions.

Concerning the Authors

Fangzhou Cheng is a Senior Utilized Scientist at AWS. He builds science options for AWS Rekgnition and AWS Monitron to offer prospects with state-of-the-art fashions. His areas of focus embrace generative AI, laptop imaginative and prescient, and time-series knowledge evaluation

Marcel Pividal is a Senior AI Providers SA within the World- Broad Specialist Group, bringing over 22 years of experience in remodeling complicated enterprise challenges into revolutionary technological options. As a thought chief in generative AI implementation, he makes a speciality of creating safe, compliant AI architectures for enterprise- scale deployments throughout a number of industries.