ultralytics 8.2.19__py3-none-any.whl → 8.2.21__py3-none-any.whl

ultralytics/engine/exporter.py

@@ -83,6 +83,7 @@ from ultralytics.utils import (
     WINDOWS,
     __version__,
     callbacks,
+    checks,
     colorstr,
     get_default_args,
     yaml_save,
@@ -184,6 +185,7 @@ class Exporter:
         if sum(flags) != 1:
             raise ValueError(f"Invalid export format='{fmt}'. Valid formats are {fmts}")
         jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle, ncnn = flags  # export booleans
+        is_tf_format = any((saved_model, pb, tflite, edgetpu, tfjs))
 
         # Device
         if fmt == "engine" and self.args.device is None:
@@ -243,7 +245,7 @@ class Exporter:
                 m.dynamic = self.args.dynamic
                 m.export = True
                 m.format = self.args.format
-            elif isinstance(m, C2f) and not any((saved_model, pb, tflite, edgetpu, tfjs)):
+            elif isinstance(m, C2f) and not is_tf_format:
                 # EdgeTPU does not support FlexSplitV while split provides cleaner ONNX graph
                 m.forward = m.forward_split
 
@@ -303,7 +305,7 @@ class Exporter:
             f[3], _ = self.export_openvino()
         if coreml:  # CoreML
             f[4], _ = self.export_coreml()
-        if any((saved_model, pb, tflite, edgetpu, tfjs)):  # TensorFlow formats
+        if is_tf_format:  # TensorFlow formats
             self.args.int8 |= edgetpu
             f[5], keras_model = self.export_saved_model()
             if pb or tfjs:  # pb prerequisite to tfjs
@@ -777,11 +779,10 @@ class Exporter:
                     _ = self.cache.write_bytes(cache)
 
             # Load dataset w/ builder (for batching) and calibrate
-            dataset = self.get_int8_calibration_dataloader(prefix)
             config.int8_calibrator = EngineCalibrator(
-                dataset=dataset,
+                dataset=self.get_int8_calibration_dataloader(prefix),
                 batch=2 * self.args.batch,
-                cache=self.file.with_suffix(".cache"),
+                cache=str(self.file.with_suffix(".cache")),
             )
 
         elif half:
@@ -813,7 +814,7 @@ class Exporter:
         except ImportError:
             suffix = "-macos" if MACOS else "-aarch64" if ARM64 else "" if cuda else "-cpu"
             version = "" if ARM64 else "<=2.13.1"
-            check_requirements(f"tensorflow{suffix}{version}")
+            check_requirements((f"tensorflow{suffix}{version}", "keras"))
             import tensorflow as tf  # noqa
         if ARM64:
             check_requirements("cmake")  # 'cmake' is needed to build onnxsim on aarch64
@@ -828,8 +829,8 @@ class Exporter:
                 "flatbuffers>=23.5.26,<100",  # update old 'flatbuffers' included inside tensorflow package
                 "onnxruntime-gpu" if cuda else "onnxruntime",
             ),
-            cmds="--extra-index-url https://pypi.ngc.nvidia.com",
-        )  # onnx_graphsurgeon only on NVIDIA
+            cmds="--extra-index-url https://pypi.ngc.nvidia.com",  # onnx_graphsurgeon only on NVIDIA
+        )
 
         LOGGER.info(f"\n{prefix} starting export with tensorflow {tf.__version__}...")
         check_version(
@@ -855,24 +856,17 @@ class Exporter:
         f_onnx, _ = self.export_onnx()
 
         # Export to TF
-        tmp_file = f / "tmp_tflite_int8_calibration_images.npy"  # int8 calibration images file
         np_data = None
         if self.args.int8:
+            tmp_file = f / "tmp_tflite_int8_calibration_images.npy"  # int8 calibration images file
             verbosity = "info"
             if self.args.data:
-                # Generate calibration data for integer quantization
-                dataloader = self.get_int8_calibration_dataloader(prefix)
-                images = []
-                for i, batch in enumerate(dataloader):
-                    if i >= 100:  # maximum number of calibration images
-                        break
-                    im = batch["img"].permute(1, 2, 0)[None]  # list to nparray, CHW to BHWC
-                    images.append(im)
                 f.mkdir()
+                images = [batch["img"].permute(0, 2, 3, 1) for batch in self.get_int8_calibration_dataloader(prefix)]
                 images = torch.cat(images, 0).float()
                 # mean = images.view(-1, 3).mean(0)  # imagenet mean [123.675, 116.28, 103.53]
                 # std = images.view(-1, 3).std(0)  # imagenet std [58.395, 57.12, 57.375]
-                np.save(str(tmp_file), images.numpy())  # BHWC
+                np.save(str(tmp_file), images.numpy().astype(np.float32))  # BHWC
                 np_data = [["images", tmp_file, [[[[0, 0, 0]]]], [[[[255, 255, 255]]]]]]
         else:
             verbosity = "error"
@@ -1015,12 +1009,18 @@ class Exporter:
 
     def _add_tflite_metadata(self, file):
         """Add metadata to *.tflite models per https://www.tensorflow.org/lite/models/convert/metadata."""
-        from tflite_support import flatbuffers  # noqa
-        from tflite_support import metadata as _metadata  # noqa
-        from tflite_support import metadata_schema_py_generated as _metadata_fb  # noqa
+        import flatbuffers
+
+        if ARM64:
+            from tflite_support import metadata  # noqa
+            from tflite_support import metadata_schema_py_generated as schema  # noqa
+        else:
+            # TFLite Support bug https://github.com/tensorflow/tflite-support/issues/954#issuecomment-2108570845
+            from tensorflow_lite_support.metadata import metadata_schema_py_generated as schema  # noqa
+            from tensorflow_lite_support.metadata.python import metadata  # noqa
 
         # Create model info
-        model_meta = _metadata_fb.ModelMetadataT()
+        model_meta = schema.ModelMetadataT()
         model_meta.name = self.metadata["description"]
         model_meta.version = self.metadata["version"]
         model_meta.author = self.metadata["author"]
@@ -1031,41 +1031,41 @@ class Exporter:
         with open(tmp_file, "w") as f:
             f.write(str(self.metadata))
 
-        label_file = _metadata_fb.AssociatedFileT()
+        label_file = schema.AssociatedFileT()
         label_file.name = tmp_file.name
-        label_file.type = _metadata_fb.AssociatedFileType.TENSOR_AXIS_LABELS
+        label_file.type = schema.AssociatedFileType.TENSOR_AXIS_LABELS
 
         # Create input info
-        input_meta = _metadata_fb.TensorMetadataT()
+        input_meta = schema.TensorMetadataT()
         input_meta.name = "image"
         input_meta.description = "Input image to be detected."
-        input_meta.content = _metadata_fb.ContentT()
-        input_meta.content.contentProperties = _metadata_fb.ImagePropertiesT()
-        input_meta.content.contentProperties.colorSpace = _metadata_fb.ColorSpaceType.RGB
-        input_meta.content.contentPropertiesType = _metadata_fb.ContentProperties.ImageProperties
+        input_meta.content = schema.ContentT()
+        input_meta.content.contentProperties = schema.ImagePropertiesT()
+        input_meta.content.contentProperties.colorSpace = schema.ColorSpaceType.RGB
+        input_meta.content.contentPropertiesType = schema.ContentProperties.ImageProperties
 
         # Create output info
-        output1 = _metadata_fb.TensorMetadataT()
+        output1 = schema.TensorMetadataT()
         output1.name = "output"
         output1.description = "Coordinates of detected objects, class labels, and confidence score"
         output1.associatedFiles = [label_file]
         if self.model.task == "segment":
-            output2 = _metadata_fb.TensorMetadataT()
+            output2 = schema.TensorMetadataT()
             output2.name = "output"
             output2.description = "Mask protos"
             output2.associatedFiles = [label_file]
 
         # Create subgraph info
-        subgraph = _metadata_fb.SubGraphMetadataT()
+        subgraph = schema.SubGraphMetadataT()
         subgraph.inputTensorMetadata = [input_meta]
         subgraph.outputTensorMetadata = [output1, output2] if self.model.task == "segment" else [output1]
         model_meta.subgraphMetadata = [subgraph]
 
         b = flatbuffers.Builder(0)
-        b.Finish(model_meta.Pack(b), _metadata.MetadataPopulator.METADATA_FILE_IDENTIFIER)
+        b.Finish(model_meta.Pack(b), metadata.MetadataPopulator.METADATA_FILE_IDENTIFIER)
         metadata_buf = b.Output()
 
-        populator = _metadata.MetadataPopulator.with_model_file(str(file))
+        populator = metadata.MetadataPopulator.with_model_file(str(file))
         populator.load_metadata_buffer(metadata_buf)
         populator.load_associated_files([str(tmp_file)])
         populator.populate()

ultralytics/engine/results.py

@@ -402,8 +402,8 @@ class Results(SimpleClass):
             )
             return results
 
-        data = self.boxes or self.obb
         is_obb = self.obb is not None
+        data = self.obb if is_obb else self.boxes
         h, w = self.orig_shape if normalize else (1, 1)
         for i, row in enumerate(data):  # xyxy, track_id if tracking, conf, class_id
             class_id, conf = int(row.cls), round(row.conf.item(), decimals)

ultralytics/solutions/__init__.py

@@ -1,6 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 from .ai_gym import AIGym
+from .analytics import Analytics
 from .distance_calculation import DistanceCalculation
 from .heatmap import Heatmap
 from .object_counter import ObjectCounter
@@ -16,4 +17,5 @@ __all__ = (
     "ParkingManagement",
     "QueueManager",
     "SpeedEstimator",
+    "Analytics",
 )

ultralytics/solutions/ai_gym.py

@@ -73,11 +73,11 @@ class AIGym:
             self.stage = ["-" for _ in results[0]]
 
         self.keypoints = results[0].keypoints.data
-        self.annotator = Annotator(im0, line_width=2)
+        self.annotator = Annotator(im0, line_width=self.tf)
 
         for ind, k in enumerate(reversed(self.keypoints)):
             # Estimate angle and draw specific points based on pose type
-            if self.pose_type in {"pushup", "pullup", "abworkout"}:
+            if self.pose_type in {"pushup", "pullup", "abworkout", "squat"}:
                 self.angle[ind] = self.annotator.estimate_pose_angle(
                     k[int(self.kpts_to_check[0])].cpu(),
                     k[int(self.kpts_to_check[1])].cpu(),
@@ -93,7 +93,7 @@ class AIGym:
                         self.stage[ind] = "up"
                         self.count[ind] += 1
 
-                elif self.pose_type == "pushup":
+                elif self.pose_type == "pushup" or self.pose_type == "squat":
                     if self.angle[ind] > self.poseup_angle:
                         self.stage[ind] = "up"
                     if self.angle[ind] < self.posedown_angle and self.stage[ind] == "up":

ultralytics/solutions/analytics.py

@@ -0,0 +1,197 @@
+from itertools import cycle
+
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+from matplotlib.figure import Figure
+
+
+class Analytics:
+    """A class to create and update various types of charts (line, bar, pie) for visual analytics."""
+
+    def __init__(
+        self,
+        type,
+        writer,
+        im0_shape,
+        title="ultralytics",
+        x_label="x",
+        y_label="y",
+        bg_color="white",
+        fg_color="black",
+        line_color="yellow",
+        line_width=2,
+        fontsize=13,
+        view_img=False,
+        save_img=True,
+    ):
+        """
+        Initialize the Analytics class with various chart types.
+
+        Args:
+            type (str): Type of chart to initialize ('line', 'bar', or 'pie').
+            writer: Video writer object to save the frames.
+            im0_shape (tuple): Shape of the input image (width, height).
+            title (str): Title of the chart.
+            x_label (str): Label for the x-axis.
+            y_label (str): Label for the y-axis.
+            bg_color (str): Background color of the chart.
+            fg_color (str): Foreground (text) color of the chart.
+            line_color (str): Line color for line charts.
+            line_width (int): Width of the lines in line charts.
+            fontsize (int): Font size for chart text.
+            view_img (bool): Whether to display the image.
+            save_img (bool): Whether to save the image.
+        """
+
+        self.bg_color = bg_color
+        self.fg_color = fg_color
+        self.view_img = view_img
+        self.save_img = save_img
+        self.title = title
+        self.writer = writer
+
+        # Set figure size based on image shape
+        figsize = (im0_shape[0] / 100, im0_shape[1] / 100)
+
+        if type == "line":
+            # Initialize line plot
+            fig = Figure(facecolor=self.bg_color, figsize=figsize)
+            self.canvas = FigureCanvas(fig)
+            self.ax = fig.add_subplot(111, facecolor=self.bg_color)
+            (self.line,) = self.ax.plot([], [], color=line_color, linewidth=line_width)
+
+        elif type == "bar" or type == "pie":
+            # Initialize bar or pie plot
+            self.fig, self.ax = plt.subplots(figsize=figsize, facecolor=self.bg_color)
+            self.ax.set_facecolor(self.bg_color)
+            color_palette = [
+                (31, 119, 180),
+                (255, 127, 14),
+                (44, 160, 44),
+                (214, 39, 40),
+                (148, 103, 189),
+                (140, 86, 75),
+                (227, 119, 194),
+                (127, 127, 127),
+                (188, 189, 34),
+                (23, 190, 207),
+            ]
+            self.color_palette = [(r / 255, g / 255, b / 255, 1) for r, g, b in color_palette]
+            self.color_cycle = cycle(self.color_palette)
+            self.color_mapping = {}
+
+            # Ensure pie chart is circular
+            self.ax.axis("equal") if type == "pie" else None
+
+        # Set common axis properties
+        self.ax.set_title(self.title, color=self.fg_color, fontsize=fontsize)
+        self.ax.set_xlabel(x_label, color=self.fg_color, fontsize=fontsize - 3)
+        self.ax.set_ylabel(y_label, color=self.fg_color, fontsize=fontsize - 3)
+        self.ax.tick_params(axis="both", colors=self.fg_color)
+
+    def update_line(self, frame_number, total_counts):
+        """
+        Update the line graph with new data.
+
+        Args:
+            frame_number (int): The current frame number.
+            total_counts (int): The total counts to plot.
+        """
+
+        # Update line graph data
+        x_data = self.line.get_xdata()
+        y_data = self.line.get_ydata()
+        x_data = np.append(x_data, float(frame_number))
+        y_data = np.append(y_data, float(total_counts))
+        self.line.set_data(x_data, y_data)
+        self.ax.relim()
+        self.ax.autoscale_view()
+        self.canvas.draw()
+        im0 = np.array(self.canvas.renderer.buffer_rgba())
+        im0 = cv2.cvtColor(im0[:, :, :3], cv2.COLOR_RGBA2BGR)
+
+        # Display and save the updated graph
+        cv2.imshow(self.title, im0) if self.view_img else None
+        self.writer.write(im0) if self.save_img else None
+
+    def update_bar(self, count_dict):
+        """
+        Update the bar graph with new data.
+
+        Args:
+            count_dict (dict): Dictionary containing the count data to plot.
+        """
+
+        # Update bar graph data
+        self.ax.clear()
+        self.ax.set_facecolor(self.bg_color)
+        labels = list(count_dict.keys())
+        counts = list(count_dict.values())
+
+        # Map labels to colors
+        for label in labels:
+            if label not in self.color_mapping:
+                self.color_mapping[label] = next(self.color_cycle)
+
+        colors = [self.color_mapping[label] for label in labels]
+
+        bars = self.ax.bar(labels, counts, color=colors)
+        for bar, count in zip(bars, counts):
+            self.ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                bar.get_height(),
+                str(count),
+                ha="center",
+                va="bottom",
+                color=self.fg_color,
+            )
+
+        # Display and save the updated graph
+        canvas = FigureCanvas(self.fig)
+        canvas.draw()
+        buf = canvas.buffer_rgba()
+        im0 = np.asarray(buf)
+        im0 = cv2.cvtColor(im0, cv2.COLOR_RGBA2BGR)
+
+        self.writer.write(im0) if self.save_img else None
+        cv2.imshow(self.title, im0) if self.view_img else None
+
+    def update_pie(self, classes_dict):
+        """
+        Update the pie chart with new data.
+
+        Args:
+            classes_dict (dict): Dictionary containing the class data to plot.
+        """
+
+        # Update pie chart data
+        labels = list(classes_dict.keys())
+        sizes = list(classes_dict.values())
+        total = sum(sizes)
+        percentages = [size / total * 100 for size in sizes]
+        start_angle = 90
+        self.ax.clear()
+
+        # Create pie chart without labels inside the slices
+        wedges, autotexts = self.ax.pie(sizes, autopct=None, startangle=start_angle, textprops={"color": self.fg_color})
+
+        # Construct legend labels with percentages
+        legend_labels = [f"{label} ({percentage:.1f}%)" for label, percentage in zip(labels, percentages)]
+        self.ax.legend(wedges, legend_labels, title="Classes", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1))
+
+        # Adjust layout to fit the legend
+        self.fig.tight_layout()
+        self.fig.subplots_adjust(left=0.1, right=0.75)
+
+        # Display and save the updated chart
+        im0 = self.fig.canvas.draw()
+        im0 = np.array(self.fig.canvas.renderer.buffer_rgba())
+        im0 = cv2.cvtColor(im0[:, :, :3], cv2.COLOR_RGBA2BGR)
+        self.writer.write(im0) if self.save_img else None
+        cv2.imshow(self.title, im0) if self.view_img else None
+
+
+if __name__ == "__main__":
+    Analytics("line", writer=None, im0_shape=None)

ultralytics/utils/checks.py

@@ -23,7 +23,6 @@ from ultralytics.utils import (
     ASSETS,
     AUTOINSTALL,
     IS_COLAB,
-    IS_DOCKER,
     IS_JUPYTER,
     IS_KAGGLE,
     IS_PIP_PACKAGE,
@@ -322,17 +321,18 @@ def check_font(font="Arial.ttf"):
         return file
 
 
-def check_python(minimum: str = "3.8.0") -> bool:
+def check_python(minimum: str = "3.8.0", hard: bool = True) -> bool:
     """
     Check current python version against the required minimum version.
 
     Args:
         minimum (str): Required minimum version of python.
+        hard (bool, optional): If True, raise an AssertionError if the requirement is not met.
 
     Returns:
         (bool): Whether the installed Python version meets the minimum constraints.
     """
-    return check_version(PYTHON_VERSION, minimum, name="Python ", hard=True)
+    return check_version(PYTHON_VERSION, minimum, name="Python", hard=hard)
 
 
 @TryExcept()
@@ -735,4 +735,5 @@ def cuda_is_available() -> bool:
 
 
 # Define constants
+IS_PYTHON_MINIMUM_3_10 = check_python("3.10", hard=False)
 IS_PYTHON_3_12 = PYTHON_VERSION.startswith("3.12")

{ultralytics-8.2.19.dist-info → ultralytics-8.2.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.19
+Version: 8.2.21
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu

{ultralytics-8.2.19.dist-info → ultralytics-8.2.21.dist-info}/RECORD

@@ -1,4 +1,13 @@
-ultralytics/__init__.py,sha256=NObQc9-CGvcpMj8hOJ6v61xO8ImAy6eciiFIiIqfVVA,633
+tests/__init__.py,sha256=9evx3lOdKZeY1iWXvH-FkMkgf8jLucWICoabzeD6aYg,626
+tests/conftest.py,sha256=WOrMDmrxdYskt1nQmbPPhZ6zo1cJzS4vO7gVcKuEo2k,2545
+tests/test_cli.py,sha256=BOvCGdTxYEKb5hPeKkDtfN2sX2FxjfmUYq9mbPKL7hU,4866
+tests/test_cuda.py,sha256=Ga_fRdcfhKXwy3_C5x0a9P8MdsoIo1ko73IwaOqwtX0,4799
+tests/test_engine.py,sha256=GA3igv3CTEMb4YYwZDlYPESv5RAuaZ-t3BscvBpQ5AY,4706
+tests/test_explorer.py,sha256=r1pWer2y290Y0DqsM-La7egfEY0497YCdC4rwq3URV4,2178
+tests/test_exports.py,sha256=TTmwlY3FAcVPffUFP9La0vpzNnfKYjej5nKqurCbwZg,6863
+tests/test_integrations.py,sha256=J3D_LAy5gaawoLEMDrCj4HO8965o4kK1t4UBRot6EEw,5848
+tests/test_python.py,sha256=invyej59wozoSZV4Rb7zwkgyVkRZrL149e-xb-c7xew,20086
+ultralytics/__init__.py,sha256=t6lbjDI5WGi4FmWuecXODe58PRDP7YbTpDJlVIvyN_E,633
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=lR6jykSO_0cigsjrqSyFj_8JG_LvYi796viasyWhcfs,21358
@@ -79,10 +88,10 @@ ultralytics/data/explorer/utils.py,sha256=EvvukQiQUTBrsZznmMnyEX2EqTuwZo_Geyc8yf
 ultralytics/data/explorer/gui/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7JI8grmQDTs,42
 ultralytics/data/explorer/gui/dash.py,sha256=2oAbNroR2lfS45v53M1sRqZklLXbbj6qXqNxvplulC0,10087
 ultralytics/engine/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7JI8grmQDTs,42
-ultralytics/engine/exporter.py,sha256=n2_2oTirHfdPDoeSD1feRNvWAXZHugo92JB6W0GWeiw,58316
+ultralytics/engine/exporter.py,sha256=c5Ky8_cElAjPm8y3-2-pJgn0bMGyqivvC2XhFH5gDsY,58222
 ultralytics/engine/model.py,sha256=IE6HE9VIzqO3DscxSLexub0LUR673eiPFrCPCt6ozEE,40103
 ultralytics/engine/predictor.py,sha256=wQRKdWGDTP5A6CS0gTC6U3RPDMhP3QkEzWSPm6eqCkU,17022
-ultralytics/engine/results.py,sha256=1ZY6eXb5uHmDShAXPmXZ-117ZlqeffEZLd2LqFgg8Ik,30975
+ultralytics/engine/results.py,sha256=zRuEIrBtpoCQ3M6a_YscnyXrWSP-zpL3ACv0gTdrDaw,30987
 ultralytics/engine/trainer.py,sha256=P5XbPxh5hj4TLwuKeriuAlvcBWmILStm40-SgPrYvLk,35149
 ultralytics/engine/tuner.py,sha256=iZrgMmXSDpfuDu4bdFRflmAsscys2-8W8qAGxSyOVJE,11844
 ultralytics/engine/validator.py,sha256=Y21Uo8_Zto4qjk_YqQk6k7tyfpq_Qk9cfjeXeyDRxs8,14643
@@ -154,8 +163,9 @@ ultralytics/nn/modules/conv.py,sha256=Ywe87IhuaS22mR2JJ9xjnW8Sb-m7WTjxuqIxV_Dv8l
 ultralytics/nn/modules/head.py,sha256=3N_4zW1UvhI1jCrIxIkNYxQDdiW6HxtxpaNAAudq6NU,22236
 ultralytics/nn/modules/transformer.py,sha256=AxD9uURpCl-EqvXe3DiG6JW-pBzB16G-AahLdZ7yayo,17909
 ultralytics/nn/modules/utils.py,sha256=779QnnKp9v8jv251ESduTXJ0ol8HkIOLbGQWwEGQjhU,3196
-ultralytics/solutions/__init__.py,sha256=Ogwo0ckEqzULTiRopo6ZeqjBwlHgsg2WYyO_rGARtQA,490
-ultralytics/solutions/ai_gym.py,sha256=xpKBX37VmAjJpSPUfC8w1IQ0wqOcURAeWZ_3LoVrXSs,4639
+ultralytics/solutions/__init__.py,sha256=ZeIPizmm2SM0e7KZ7nmh9WWNYChSszWwDmHB-WAfaAY,540
+ultralytics/solutions/ai_gym.py,sha256=HDzzvBVFqWgQw2IgtEx5Eo3tEKbFRY3gkiVqax-4j2w,4683
+ultralytics/solutions/analytics.py,sha256=ddv-5ertQAzZmhfIi9G6PK3Z1mK8mCKWUwRVgJACves,7050
 ultralytics/solutions/distance_calculation.py,sha256=pSIkyytHGRAaNzIrkkNkiOnSVWU1PYvURlCIV_jRORA,6505
 ultralytics/solutions/heatmap.py,sha256=AHXnmXhoQ95ph74zsdrvX_Lfy3wF0SsH0MIeTixE7Qg,10386
 ultralytics/solutions/object_counter.py,sha256=htcQGWJX1y-vXVV1yUiTDT3sm8ByItjSNfu2Rl2IEmk,10808
@@ -174,7 +184,7 @@ ultralytics/trackers/utils/matching.py,sha256=UxhSGa5pN6WoYwYSBAkkt-O7xMxUR47VuU
 ultralytics/utils/__init__.py,sha256=AjzSdFGfEPMPyFFX9JaONkmI5xgWLHFMO77aBA0ghpM,39518
 ultralytics/utils/autobatch.py,sha256=ygZ3f2ByIkcujB89ENcTnGWWnAQw5Pbg6nBuShg-5t4,3863
 ultralytics/utils/benchmarks.py,sha256=PlnUqhl2Om7jp7bKICDj9a2ABpJSl31VFI3ESnGdme8,23552
-ultralytics/utils/checks.py,sha256=lca-tqMVbMgsHXb_g-LaVqXv6zoDKFXHqc2SXvO0njM,28124
+ultralytics/utils/checks.py,sha256=VRZH50Spdx1OVaPaUxgEArpF2iI1Re6bVBdMhvFUPoE,28280
 ultralytics/utils/dist.py,sha256=3HeNbY2gp7vYhcvVhsrvTrQXpQmgT8tpmnzApf3eQRA,2267
 ultralytics/utils/downloads.py,sha256=cmO2Ev1DV1m_lYgQ2yGDG5xVRIBVS_z9nS_Frec_NeU,21496
 ultralytics/utils/errors.py,sha256=GqP_Jgj_n0paxn8OMhn3DTCgoNkB2WjUcUaqs-M6SQk,816
@@ -200,9 +210,9 @@ ultralytics/utils/callbacks/neptune.py,sha256=5Z3ua5YBTUS56FH8VQKQG1aaIo9fH8GEyz
 ultralytics/utils/callbacks/raytune.py,sha256=ODVYzy-CoM4Uge0zjkh3Hnh9nF2M0vhDrSenXnvcizw,705
 ultralytics/utils/callbacks/tensorboard.py,sha256=Z1veCVcn9THPhdplWuIzwlsW2yF7y-On9IZIk3khM0Y,4135
 ultralytics/utils/callbacks/wb.py,sha256=DViD0KeXH_i3eVT_CLR4bZFs1TMMUZBVBBYIS3aUfp0,6745
-ultralytics-8.2.19.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.2.19.dist-info/METADATA,sha256=rclTaqVO3NUEG2sUMvgs2nXlYADCmdzjQqFiqTofyN4,40694
-ultralytics-8.2.19.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ultralytics-8.2.19.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.2.19.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.2.19.dist-info/RECORD,,
+ultralytics-8.2.21.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.2.21.dist-info/METADATA,sha256=ghZ90c82ushTyA0ZcMQNYD8Gyb9sZpA05EWJRMsPKm8,40694
+ultralytics-8.2.21.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ultralytics-8.2.21.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.2.21.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.2.21.dist-info/RECORD,,