Transitioning from Amazon Rekognition folks pathing: Exploring different options

Amazon Rekognition folks pathing is a machine studying (ML)–based mostly functionality of Amazon Rekognition Video that customers can use to grasp the place, when, and the way every individual is transferring in a video. This functionality can be utilized for a number of use instances, equivalent 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 court docket
3. Industrial security – Staff’ 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 clients will be unable to entry the aptitude efficient October 24, 2024, however present clients will be capable to 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.

Alternate 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 sequence. It makes use of a specialised structure known as Generalized Environment friendly Layer Aggregation Community (GELAN) to research pictures effectively. The mannequin divides a picture right into a grid, shortly figuring out and finding objects in every part in a single move. It then refines its outcomes utilizing a way known as programmable gradient data (PGI) to enhance accuracy, particularly for simply missed objects. This mixture of velocity and accuracy makes YOLOv9 perfect for functions that want quick and dependable object detection.

ByteTrack is an algorithm for monitoring a number of transferring objects in movies, equivalent 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 numerous folks to trace concurrently.

If you mix YOLOv9 and ByteTrack for folks pathing, you may evaluate 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, displaying 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 may as well deploy YOLOv9 and ByteTrack for inference utilizing Amazon SageMaker. SageMaker gives a number of choices for mannequin deployment, equivalent to real-time inference, asynchronous inference, serverless inference, and batch inference. You may select the acceptable possibility based mostly on what you are promoting 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 crucial 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 Phase 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 in the event you solely wish 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 middle
        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": {
                        "Top": 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

#  Operate for individual monitoring with json outputs and non-compulsory 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 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 performed
        for body in frames:
            video_writer.write(body)
        video_writer.launch()
        print(f"Video saved to {output_path}")

    return all_object_data
    
        
#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 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 supply a robust mixture for folks pathing, a number of different open supply options are price 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 flexibility to trace objects in crowded scenes

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

Conclusion

On this put up, we’ve outlined how one can take a look at and implement YOLOv9 and Byte Monitor as an alternative choice to Rekognition folks pathing. Mixed with AWS device choices equivalent to AWS Lambda and Amazon SageMaker, you may implement such open supply instruments on your functions.

In regards to the Authors

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

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