ultralytics 8.3.5__py3-none-any.whl → 8.3.7__py3-none-any.whl

ultralytics/solutions/heatmap.py

@@ -1,249 +1,93 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-from collections import defaultdict
-
 import cv2
 import numpy as np
 
-from ultralytics.utils.checks import check_imshow, check_requirements
+from ultralytics.solutions.object_counter import ObjectCounter  # Import object counter class
 from ultralytics.utils.plotting import Annotator
 
-check_requirements("shapely>=2.0.0")
-
-from shapely.geometry import LineString, Point, Polygon
-
 
-class Heatmap:
+class Heatmap(ObjectCounter):
     """A class to draw heatmaps in real-time video stream based on their tracks."""
 
-    def __init__(
-        self,
-        names,
-        colormap=cv2.COLORMAP_JET,
-        view_img=False,
-        view_in_counts=True,
-        view_out_counts=True,
-        count_reg_pts=None,
-        count_txt_color=(0, 0, 0),
-        count_bg_color=(255, 255, 255),
-        count_reg_color=(255, 0, 255),
-        region_thickness=5,
-        line_dist_thresh=15,
-        line_thickness=2,
-        shape="circle",
-    ):
-        """Initializes the heatmap class with default values for Visual, Image, track, count and heatmap parameters."""
-        # Visual information
-        self.annotator = None
-        self.view_img = view_img
-        self.shape = shape
-
-        self.initialized = False
-        self.names = names  # Classes names
-
-        # Image information
-        self.im0 = None
-        self.tf = line_thickness
-        self.view_in_counts = view_in_counts
-        self.view_out_counts = view_out_counts
-
-        # Heatmap colormap and heatmap np array
-        self.colormap = colormap
-        self.heatmap = None
-
-        # Predict/track information
-        self.boxes = []
-        self.track_ids = []
-        self.clss = []
-        self.track_history = defaultdict(list)
-
-        # Region & Line Information
-        self.counting_region = None
-        self.line_dist_thresh = line_dist_thresh
-        self.region_thickness = region_thickness
-        self.region_color = count_reg_color
-
-        # Object Counting Information
-        self.in_counts = 0
-        self.out_counts = 0
-        self.count_ids = []
-        self.class_wise_count = {}
-        self.count_txt_color = count_txt_color
-        self.count_bg_color = count_bg_color
-        self.cls_txtdisplay_gap = 50
-
-        # Check if environment supports imshow
-        self.env_check = check_imshow(warn=True)
-
-        # Region and line selection
-        self.count_reg_pts = count_reg_pts
-        print(self.count_reg_pts)
-        if self.count_reg_pts is not None:
-            if len(self.count_reg_pts) == 2:
-                print("Line Counter Initiated.")
-                self.counting_region = LineString(self.count_reg_pts)
-            elif len(self.count_reg_pts) >= 3:
-                print("Polygon Counter Initiated.")
-                self.counting_region = Polygon(self.count_reg_pts)
-            else:
-                print("Invalid Region points provided, region_points must be 2 for lines or >= 3 for polygons.")
-                print("Using Line Counter Now")
-                self.counting_region = LineString(self.count_reg_pts)
-
-        # Shape of heatmap, if not selected
-        if self.shape not in {"circle", "rect"}:
-            print("Unknown shape value provided, 'circle' & 'rect' supported")
-            print("Using Circular shape now")
-            self.shape = "circle"
-
-    def extract_results(self, tracks):
-        """
-        Extracts results from the provided data.
+    def __init__(self, **kwargs):
+        """Initializes function for heatmap class with default values."""
+        super().__init__(**kwargs)
 
-        Args:
-            tracks (list): List of tracks obtained from the object tracking process.
-        """
-        if tracks[0].boxes.id is not None:
-            self.boxes = tracks[0].boxes.xyxy.cpu()
-            self.clss = tracks[0].boxes.cls.tolist()
-            self.track_ids = tracks[0].boxes.id.int().tolist()
+        self.initialized = False  # bool variable for heatmap initialization
+        if self.region is not None:  # check if user provided the region coordinates
+            self.initialize_region()
+
+        # store colormap
+        self.colormap = cv2.COLORMAP_PARULA if self.CFG["colormap"] is None else self.CFG["colormap"]
 
-    def generate_heatmap(self, im0, tracks):
+    def heatmap_effect(self, box):
         """
-        Generate heatmap based on tracking data.
+        Efficient calculation of heatmap area and effect location for applying colormap.
 
         Args:
-            im0 (nd array): Image
-            tracks (list): List of tracks obtained from the object tracking process.
+            box (list): Bounding Box coordinates data [x0, y0, x1, y1]
         """
-        self.im0 = im0
+        x0, y0, x1, y1 = map(int, box)
+        radius_squared = (min(x1 - x0, y1 - y0) // 2) ** 2
 
-        # Initialize heatmap only once
-        if not self.initialized:
-            self.heatmap = np.zeros((int(self.im0.shape[0]), int(self.im0.shape[1])), dtype=np.float32)
-            self.initialized = True
+        # Create a meshgrid with region of interest (ROI) for vectorized distance calculations
+        xv, yv = np.meshgrid(np.arange(x0, x1), np.arange(y0, y1))
 
-        self.heatmap *= 0.99  # decay factor
+        # Calculate squared distances from the center
+        dist_squared = (xv - ((x0 + x1) // 2)) ** 2 + (yv - ((y0 + y1) // 2)) ** 2
 
-        self.extract_results(tracks)
-        self.annotator = Annotator(self.im0, self.tf, None)
+        # Create a mask of points within the radius
+        within_radius = dist_squared <= radius_squared
 
-        if self.track_ids:
-            # Draw counting region
-            if self.count_reg_pts is not None:
-                self.annotator.draw_region(
-                    reg_pts=self.count_reg_pts, color=self.region_color, thickness=self.region_thickness
-                )
+        # Update only the values within the bounding box in a single vectorized operation
+        self.heatmap[y0:y1, x0:x1][within_radius] += 2
 
-            for box, cls, track_id in zip(self.boxes, self.clss, self.track_ids):
-                # Store class info
-                if self.names[cls] not in self.class_wise_count:
-                    self.class_wise_count[self.names[cls]] = {"IN": 0, "OUT": 0}
-
-                if self.shape == "circle":
-                    center = (int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2))
-                    radius = min(int(box[2]) - int(box[0]), int(box[3]) - int(box[1])) // 2
+    def generate_heatmap(self, im0):
+        """
+        Generate heatmap for each frame using Ultralytics.
 
-                    y, x = np.ogrid[0 : self.heatmap.shape[0], 0 : self.heatmap.shape[1]]
-                    mask = (x - center[0]) ** 2 + (y - center[1]) ** 2 <= radius**2
+        Args:
+            im0 (ndarray): Input image array for processing
+        Returns:
+            im0 (ndarray): Processed image for further usage
+        """
+        self.heatmap = np.zeros_like(im0, dtype=np.float32) * 0.99 if not self.initialized else self.heatmap
+        self.initialized = True  # Initialize heatmap only once
 
-                    self.heatmap[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] += (
-                        2 * mask[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])]
-                    )
+        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
+        self.extract_tracks(im0)  # Extract tracks
 
-                else:
-                    self.heatmap[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] += 2
+        # Iterate over bounding boxes, track ids and classes index
+        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+            # Draw bounding box and counting region
+            self.heatmap_effect(box)
 
-                # Store tracking hist
-                track_line = self.track_history[track_id]
-                track_line.append((float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2)))
-                if len(track_line) > 30:
-                    track_line.pop(0)
+            if self.region is not None:
+                self.annotator.draw_region(reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2)
+                self.store_tracking_history(track_id, box)  # Store track history
+                self.store_classwise_counts(cls)  # store classwise counts in dict
 
+                # Store tracking previous position and perform object counting
                 prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
+                self.count_objects(self.track_line, box, track_id, prev_position, cls)  # Perform object counting
 
-                if self.count_reg_pts is not None:
-                    # Count objects in any polygon
-                    if len(self.count_reg_pts) >= 3:
-                        is_inside = self.counting_region.contains(Point(track_line[-1]))
-
-                        if prev_position is not None and is_inside and track_id not in self.count_ids:
-                            self.count_ids.append(track_id)
-
-                            if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
-                                self.in_counts += 1
-                                self.class_wise_count[self.names[cls]]["IN"] += 1
-                            else:
-                                self.out_counts += 1
-                                self.class_wise_count[self.names[cls]]["OUT"] += 1
-
-                    # Count objects using line
-                    elif len(self.count_reg_pts) == 2:
-                        if prev_position is not None and track_id not in self.count_ids:
-                            distance = Point(track_line[-1]).distance(self.counting_region)
-                            if distance < self.line_dist_thresh and track_id not in self.count_ids:
-                                self.count_ids.append(track_id)
-
-                                if (box[0] - prev_position[0]) * (
-                                    self.counting_region.centroid.x - prev_position[0]
-                                ) > 0:
-                                    self.in_counts += 1
-                                    self.class_wise_count[self.names[cls]]["IN"] += 1
-                                else:
-                                    self.out_counts += 1
-                                    self.class_wise_count[self.names[cls]]["OUT"] += 1
-
-        else:
-            for box, cls in zip(self.boxes, self.clss):
-                if self.shape == "circle":
-                    center = (int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2))
-                    radius = min(int(box[2]) - int(box[0]), int(box[3]) - int(box[1])) // 2
-
-                    y, x = np.ogrid[0 : self.heatmap.shape[0], 0 : self.heatmap.shape[1]]
-                    mask = (x - center[0]) ** 2 + (y - center[1]) ** 2 <= radius**2
-
-                    self.heatmap[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] += (
-                        2 * mask[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])]
-                    )
-
-                else:
-                    self.heatmap[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] += 2
-
-        if self.count_reg_pts is not None:
-            labels_dict = {}
-
-            for key, value in self.class_wise_count.items():
-                if value["IN"] != 0 or value["OUT"] != 0:
-                    if not self.view_in_counts and not self.view_out_counts:
-                        continue
-                    elif not self.view_in_counts:
-                        labels_dict[str.capitalize(key)] = f"OUT {value['OUT']}"
-                    elif not self.view_out_counts:
-                        labels_dict[str.capitalize(key)] = f"IN {value['IN']}"
-                    else:
-                        labels_dict[str.capitalize(key)] = f"IN {value['IN']} OUT {value['OUT']}"
-
-            if labels_dict is not None:
-                self.annotator.display_analytics(self.im0, labels_dict, self.count_txt_color, self.count_bg_color, 10)
+        self.display_counts(im0) if self.region is not None else None  # Display the counts on the frame
 
         # Normalize, apply colormap to heatmap and combine with original image
-        heatmap_normalized = cv2.normalize(self.heatmap, None, 0, 255, cv2.NORM_MINMAX)
-        heatmap_colored = cv2.applyColorMap(heatmap_normalized.astype(np.uint8), self.colormap)
-        self.im0 = cv2.addWeighted(self.im0, 0.5, heatmap_colored, 0.5, 0)
-
-        if self.env_check and self.view_img:
-            self.display_frames()
-
-        return self.im0
-
-    def display_frames(self):
-        """Display frame."""
-        cv2.imshow("Ultralytics Heatmap", self.im0)
-
-        if cv2.waitKey(1) & 0xFF == ord("q"):
-            return
-
-
-if __name__ == "__main__":
-    classes_names = {0: "person", 1: "car"}  # example class names
-    heatmap = Heatmap(classes_names)
+        im0 = (
+            im0
+            if self.track_data.id is None
+            else cv2.addWeighted(
+                im0,
+                0.5,
+                cv2.applyColorMap(
+                    cv2.normalize(self.heatmap, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8), self.colormap
+                ),
+                0.5,
+                0,
+            )
+        )
+
+        self.display_output(im0)  # display output with base class function
+        return im0  # return output image for more usage

ultralytics/solutions/object_counter.py

@@ -19,8 +19,7 @@ class ObjectCounter(BaseSolution):
         self.out_count = 0  # Counter for objects moving outward
         self.counted_ids = []  # List of IDs of objects that have been counted
         self.classwise_counts = {}  # Dictionary for counts, categorized by object class
-
-        self.initialize_region()  # Setup region and counting areas
+        self.region_initialized = False  # Bool variable for region initialization
 
         self.show_in = self.CFG["show_in"]
         self.show_out = self.CFG["show_out"]
@@ -99,6 +98,10 @@ class ObjectCounter(BaseSolution):
         Returns
             im0 (ndarray): The processed image for more usage
         """
+        if not self.region_initialized:
+            self.initialize_region()
+            self.region_initialized = True
+
         self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
         self.extract_tracks(im0)  # Extract tracks
 
@@ -107,21 +110,20 @@ class ObjectCounter(BaseSolution):
         )  # Draw region
 
         # Iterate over bounding boxes, track ids and classes index
-        if self.track_data is not None and self.track_data.id is not None:
-            for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
-                # Draw bounding box and counting region
-                self.annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
-                self.store_tracking_history(track_id, box)  # Store track history
-                self.store_classwise_counts(cls)  # store classwise counts in dict
-
-                # Draw centroid of objects
-                self.annotator.draw_centroid_and_tracks(
-                    self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
-                )
-
-                # store previous position of track for object counting
-                prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
-                self.count_objects(self.track_line, box, track_id, prev_position, cls)  # Perform object counting
+        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+            # Draw bounding box and counting region
+            self.annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
+            self.store_tracking_history(track_id, box)  # Store track history
+            self.store_classwise_counts(cls)  # store classwise counts in dict
+
+            # Draw centroid of objects
+            self.annotator.draw_centroid_and_tracks(
+                self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
+            )
+
+            # store previous position of track for object counting
+            prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
+            self.count_objects(self.track_line, box, track_id, prev_position, cls)  # Perform object counting
 
         self.display_counts(im0)  # Display the counts on the frame
         self.display_output(im0)  # display output with base class function

ultralytics/solutions/solutions.py

@@ -4,11 +4,13 @@ from collections import defaultdict
 from pathlib import Path
 
 import cv2
-from shapely.geometry import LineString, Polygon
 
 from ultralytics import YOLO
-from ultralytics.utils import yaml_load
-from ultralytics.utils.checks import check_imshow
+from ultralytics.utils import LOGGER, yaml_load
+from ultralytics.utils.checks import check_imshow, check_requirements
+
+check_requirements("shapely>=2.0.0")
+from shapely.geometry import LineString, Polygon
 
 DEFAULT_SOL_CFG_PATH = Path(__file__).resolve().parents[1] / "cfg/solutions/default.yaml"
 
@@ -25,7 +27,7 @@ class BaseSolution:
         # Load config and update with args
         self.CFG = yaml_load(DEFAULT_SOL_CFG_PATH)
         self.CFG.update(kwargs)
-        print("Ultralytics Solutions: ✅", self.CFG)
+        LOGGER.info(f"Ultralytics Solutions: ✅ {self.CFG}")
 
         self.region = self.CFG["region"]  # Store region data for other classes usage
         self.line_width = self.CFG["line_width"]  # Store line_width for usage
@@ -54,6 +56,9 @@ class BaseSolution:
             self.boxes = self.track_data.xyxy.cpu()
             self.clss = self.track_data.cls.cpu().tolist()
             self.track_ids = self.track_data.id.int().cpu().tolist()
+        else:
+            LOGGER.warning("WARNING ⚠️ no tracks found!")
+            self.boxes, self.clss, self.track_ids = [], [], []
 
     def store_tracking_history(self, track_id, box):
         """

ultralytics/utils/__init__.py

@@ -989,55 +989,56 @@ def set_sentry():
     Additionally, the function sets custom tags and user information for Sentry events.
     """
     if (
-        SETTINGS["sync"]
-        and RANK in {-1, 0}
-        and Path(ARGV[0]).name == "yolo"
-        and not TESTS_RUNNING
-        and ONLINE
-        and IS_PIP_PACKAGE
-        and not IS_GIT_DIR
+        not SETTINGS["sync"]
+        or RANK not in {-1, 0}
+        or Path(ARGV[0]).name != "yolo"
+        or TESTS_RUNNING
+        or not ONLINE
+        or not IS_PIP_PACKAGE
+        or IS_GIT_DIR
     ):
-        # If sentry_sdk package is not installed then return and do not use Sentry
-        try:
-            import sentry_sdk  # noqa
-        except ImportError:
-            return
-
-        def before_send(event, hint):
-            """
-            Modify the event before sending it to Sentry based on specific exception types and messages.
+        return
+    # If sentry_sdk package is not installed then return and do not use Sentry
+    try:
+        import sentry_sdk  # noqa
+    except ImportError:
+        return
+
+    def before_send(event, hint):
+        """
+        Modify the event before sending it to Sentry based on specific exception types and messages.
 
-            Args:
-                event (dict): The event dictionary containing information about the error.
-                hint (dict): A dictionary containing additional information about the error.
+        Args:
+            event (dict): The event dictionary containing information about the error.
+            hint (dict): A dictionary containing additional information about the error.
 
-            Returns:
-                dict: The modified event or None if the event should not be sent to Sentry.
-            """
-            if "exc_info" in hint:
-                exc_type, exc_value, _ = hint["exc_info"]
-                if exc_type in {KeyboardInterrupt, FileNotFoundError} or "out of memory" in str(exc_value):
-                    return None  # do not send event
-
-            event["tags"] = {
-                "sys_argv": ARGV[0],
-                "sys_argv_name": Path(ARGV[0]).name,
-                "install": "git" if IS_GIT_DIR else "pip" if IS_PIP_PACKAGE else "other",
-                "os": ENVIRONMENT,
-            }
-            return event
-
-        sentry_sdk.init(
-            dsn="https://888e5a0778212e1d0314c37d4b9aae5d@o4504521589325824.ingest.us.sentry.io/4504521592406016",
-            debug=False,
-            auto_enabling_integrations=False,
-            traces_sample_rate=1.0,
-            release=__version__,
-            environment="production",  # 'dev' or 'production'
-            before_send=before_send,
-            ignore_errors=[KeyboardInterrupt, FileNotFoundError],
-        )
-        sentry_sdk.set_user({"id": SETTINGS["uuid"]})  # SHA-256 anonymized UUID hash
+        Returns:
+            dict: The modified event or None if the event should not be sent to Sentry.
+        """
+        if "exc_info" in hint:
+            exc_type, exc_value, _ = hint["exc_info"]
+            if exc_type in {KeyboardInterrupt, FileNotFoundError} or "out of memory" in str(exc_value):
+                return None  # do not send event
+
+        event["tags"] = {
+            "sys_argv": ARGV[0],
+            "sys_argv_name": Path(ARGV[0]).name,
+            "install": "git" if IS_GIT_DIR else "pip" if IS_PIP_PACKAGE else "other",
+            "os": ENVIRONMENT,
+        }
+        return event
+
+    sentry_sdk.init(
+        dsn="https://888e5a0778212e1d0314c37d4b9aae5d@o4504521589325824.ingest.us.sentry.io/4504521592406016",
+        debug=False,
+        auto_enabling_integrations=False,
+        traces_sample_rate=1.0,
+        release=__version__,
+        environment="production",  # 'dev' or 'production'
+        before_send=before_send,
+        ignore_errors=[KeyboardInterrupt, FileNotFoundError],
+    )
+    sentry_sdk.set_user({"id": SETTINGS["uuid"]})  # SHA-256 anonymized UUID hash
 
 
 class JSONDict(dict):

ultralytics/utils/autobatch.py

@@ -69,7 +69,7 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
     batch_sizes = [1, 2, 4, 8, 16]
     try:
         img = [torch.empty(b, 3, imgsz, imgsz) for b in batch_sizes]
-        results = profile(img, model, n=3, device=device)
+        results = profile(img, model, n=1, device=device)
 
         # Fit a solution
         y = [x[2] for x in results if x]  # memory [2]
@@ -89,3 +89,5 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
     except Exception as e:
         LOGGER.warning(f"{prefix}WARNING ⚠️ error detected: {e},  using default batch-size {batch_size}.")
         return batch_size
+    finally:
+        torch.cuda.empty_cache()

ultralytics/utils/checks.py

@@ -593,20 +593,29 @@ def collect_system_info():
     import psutil
 
     from ultralytics.utils import ENVIRONMENT  # scope to avoid circular import
-    from ultralytics.utils.torch_utils import get_cpu_info
+    from ultralytics.utils.torch_utils import get_cpu_info, get_gpu_info
 
-    ram_info = psutil.virtual_memory().total / (1024**3)  # Convert bytes to GB
+    gib = 1 << 30  # bytes per GiB
+    cuda = torch and torch.cuda.is_available()
     check_yolo()
-    LOGGER.info(
-        f"\n{'OS':<20}{platform.platform()}\n"
-        f"{'Environment':<20}{ENVIRONMENT}\n"
-        f"{'Python':<20}{PYTHON_VERSION}\n"
-        f"{'Install':<20}{'git' if IS_GIT_DIR else 'pip' if IS_PIP_PACKAGE else 'other'}\n"
-        f"{'RAM':<20}{ram_info:.2f} GB\n"
-        f"{'CPU':<20}{get_cpu_info()}\n"
-        f"{'CUDA':<20}{torch.version.cuda if torch and torch.cuda.is_available() else None}\n"
-    )
+    total, used, free = shutil.disk_usage("/")
+
+    info_dict = {
+        "OS": platform.platform(),
+        "Environment": ENVIRONMENT,
+        "Python": PYTHON_VERSION,
+        "Install": "git" if IS_GIT_DIR else "pip" if IS_PIP_PACKAGE else "other",
+        "RAM": f"{psutil.virtual_memory().total / gib:.2f} GB",
+        "Disk": f"{(total - free) / gib:.1f}/{total / gib:.1f} GB",
+        "CPU": get_cpu_info(),
+        "CPU count": os.cpu_count(),
+        "GPU": get_gpu_info(index=0) if cuda else None,
+        "GPU count": torch.cuda.device_count() if cuda else None,
+        "CUDA": torch.version.cuda if cuda else None,
+    }
+    LOGGER.info("\n" + "\n".join(f"{k:<20}{v}" for k, v in info_dict.items()) + "\n")
 
+    package_info = {}
     for r in parse_requirements(package="ultralytics"):
         try:
             current = metadata.version(r.name)
@@ -614,17 +623,24 @@ def collect_system_info():
         except metadata.PackageNotFoundError:
             current = "(not installed)"
             is_met = "❌ "
-        LOGGER.info(f"{r.name:<20}{is_met}{current}{r.specifier}")
+        package_info[r.name] = f"{is_met}{current}{r.specifier}"
+        LOGGER.info(f"{r.name:<20}{package_info[r.name]}")
+
+    info_dict["Package Info"] = package_info
 
     if is_github_action_running():
-        LOGGER.info(
-            f"\nRUNNER_OS: {os.getenv('RUNNER_OS')}\n"
-            f"GITHUB_EVENT_NAME: {os.getenv('GITHUB_EVENT_NAME')}\n"
-            f"GITHUB_WORKFLOW: {os.getenv('GITHUB_WORKFLOW')}\n"
-            f"GITHUB_ACTOR: {os.getenv('GITHUB_ACTOR')}\n"
-            f"GITHUB_REPOSITORY: {os.getenv('GITHUB_REPOSITORY')}\n"
-            f"GITHUB_REPOSITORY_OWNER: {os.getenv('GITHUB_REPOSITORY_OWNER')}\n"
-        )
+        github_info = {
+            "RUNNER_OS": os.getenv("RUNNER_OS"),
+            "GITHUB_EVENT_NAME": os.getenv("GITHUB_EVENT_NAME"),
+            "GITHUB_WORKFLOW": os.getenv("GITHUB_WORKFLOW"),
+            "GITHUB_ACTOR": os.getenv("GITHUB_ACTOR"),
+            "GITHUB_REPOSITORY": os.getenv("GITHUB_REPOSITORY"),
+            "GITHUB_REPOSITORY_OWNER": os.getenv("GITHUB_REPOSITORY_OWNER"),
+        }
+        LOGGER.info("\n" + "\n".join(f"{k}: {v}" for k, v in github_info.items()))
+        info_dict["GitHub Info"] = github_info
+
+    return info_dict
 
 
 def check_amp(model):