Transitioning from Amazon Rekognition folks pathing: Exploring different alternate options

Amazon Rekognition people 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 individual is shifting in a video. This functionality can be utilized for a number of use circumstances, comparable 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 sector or courtroom
3. Industrial security – Employees’ motion in work environments to advertise compliance with security protocols

After cautious consideration, we made the choice to discontinue Rekognition folks pathing on October 31, 2025. New prospects will be unable to entry the aptitude efficient October 24, 2024, however current prospects will be capable of use the aptitude as regular till October 31, 2025.

This put up discusses an alternate resolution to Rekognition folks pathing and how one can implement this resolution in your functions.

Options to Rekognition folks pathing

One different to Amazon Rekognition folks 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 referred to as Generalized Environment friendly Layer Aggregation Community (GELAN) to research pictures effectively. The mannequin divides a picture right into a grid, rapidly figuring out and finding objects in every part in a single cross. It then refines its outcomes utilizing a way referred to as programmable gradient data (PGI) to enhance accuracy, particularly for simply missed objects. This mixture of velocity and accuracy makes YOLOv9 supreme for functions that want quick and dependable object detection.

ByteTrack is an algorithm for monitoring a number of shifting objects in movies, comparable to folks strolling via a retailer. What makes it particular is the way it handles objects which are each simple and tough 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 various folks to trace concurrently.

Whenever you mix YOLOv9 and ByteTrack for folks pathing, you’ll be able to evaluation folks’s actions throughout video frames. YOLOv9 gives individual detections in every video body. ByteTrack takes these detections and associates them throughout frames, creating constant tracks for every particular person, exhibiting how folks transfer via 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 too can deploy YOLOv9 and ByteTrack for inference utilizing Amazon SageMaker. SageMaker gives a number of choices for mannequin deployment, comparable to real-time inference, asynchronous inference, serverless inference, and batch inference. You’ll be able to select the acceptable possibility primarily based on your online 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 via video body by body – For every body, the script iterates by detecting objects, monitoring path, and drawing bounding bins 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 obligatory 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 Particular person pathing API output format
def change_format(outcomes, ts, person_only):
    #set person_only to True if you happen to solely need to monitor individuals, not different objects.
    object_json = []

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

    return object_json

#  Perform for individual monitoring with json outputs and elective 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)
        attempt:
            # Run YOLOv9 monitoring on the body, persisting tracks between frames with bytetrack
            conf = 0.2
            iou = 0.5
            outcomes = mannequin.monitor(frame_bgr, persist=True, conf=conf, iou=iou, present=False, tracker="bytetrack.yaml")

            # change detection outcomes to Particular person 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 checklist (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 article 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 completed
        for body in frames:
            video_writer.write(body)
        video_writer.launch()
        print(f"Video saved to {output_path}")

    return all_object_data
    
        
#predominant 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 follow 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 individual monitoring outputs by timestamp.

The video under present the outcomes with the folks monitoring output

Different open supply options for folks pathing

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

1. DeepSORT – A preferred 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 may be successfully deployed utilizing Amazon SageMaker for inference.

Conclusion

On this put up, we’ve got outlined how one can check and implement YOLOv9 and Byte Monitor as a substitute for Rekognition folks pathing. Mixed with AWS software choices comparable to AWS Lambda and Amazon SageMaker, you’ll be able to implement such open supply instruments in 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 embody generative AI, laptop imaginative and prescient, and time-series information evaluation

Marcel Pividal is a Senior AI Providers SA within the World- Huge Specialist Group, bringing over 22 years of experience in reworking advanced enterprise challenges into progressive technological options. As a thought chief in generative AI implementation, he focuses on creating safe, compliant AI architectures for enterprise- scale deployments throughout a number of industries.