@@ -51,7 +51,7 @@ from tests.unit_tests.detection_sub_classing_test import TestDetectionDatasetSub
 from tests.unit_tests.detection_output_adapter_test import TestDetectionOutputAdapter
 from tests.unit_tests.detection_caching import TestDetectionDatasetCaching
 from tests.unit_tests.multi_scaling_test import MultiScaleTest
-from tests.unit_tests.ppyoloe_unit_test import PPYoloETests
+from tests.unit_tests.ppyoloe_unit_test import TestPPYOLOE
 from tests.unit_tests.bbox_formats_test import BBoxFormatsTest
 from tests.unit_tests.config_inspector_test import ConfigInspectTest
 from tests.unit_tests.repvgg_block_tests import TestRepVGGBlock
@@ -110,7 +110,6 @@ class CoreUnitTestSuiteRunner:
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(TrainingParamsTest))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(CallTrainTwiceTest))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(TrainOptimizerParamsOverride))
-        self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(PPYoloETests))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(BBoxFormatsTest))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(ResumeTrainingTest))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(CallTrainAfterTestTest))
@@ -123,6 +122,7 @@ class CoreUnitTestSuiteRunner:
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(MaxBatchesLoopBreakTest))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(TestTrainingUtils))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(TestTransforms))
+        self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(TestPPYOLOE))
 
     def _add_modules_to_end_to_end_tests_suite(self):
         """

@@ -14,8 +14,10 @@ from super_gradients.training.dataloaders.dataloaders import (
     cityscapes_stdc_seg50_val,
     cityscapes_stdc_seg75_val,
     segmentation_test_dataloader,
+    coco2017_val_ppyoloe,
 )
-from super_gradients.training.utils.detection_utils import CrowdDetectionCollateFN
+from super_gradients.training.models.detection_models.pp_yolo_e import PPYoloEPostPredictionCallback
+from super_gradients.training.utils.detection_utils import CrowdDetectionCollateFN, CrowdDetectionPPYoloECollateFN
 
 from super_gradients.training.metrics import Accuracy, IoU
 import os
@@ -97,6 +99,9 @@ class PretrainedModelsTest(unittest.TestCase):
 
         self.coco_dataset = {
             "yolox": coco2017_val_yolox(dataloader_params={"collate_fn": CrowdDetectionCollateFN()}, dataset_params={"with_crowd": True}),
+            "ppyoloe": coco2017_val_ppyoloe(
+                dataloader_params={"collate_fn": CrowdDetectionPPYoloECollateFN(), "batch_size": 1}, dataset_params={"with_crowd": True}
+            ),
             "ssd_mobilenet": coco2017_val_ssd_lite_mobilenet_v2(
                 dataloader_params={"collate_fn": CrowdDetectionCollateFN()}, dataset_params={"with_crowd": True}
             ),
@@ -110,6 +115,8 @@ class PretrainedModelsTest(unittest.TestCase):
             Models.YOLOX_L: 0.4925,
             Models.YOLOX_N: 0.2677,
             Models.YOLOX_T: 0.3718,
+            Models.PP_YOLOE_S: 0.4252,
+            Models.PP_YOLOE_M: 0.4711,
         }
 
         self.transfer_detection_dataset = detection_test_dataloader()
@@ -573,6 +580,44 @@ class PretrainedModelsTest(unittest.TestCase):
         )[2]
         self.assertAlmostEqual(res, self.coco_pretrained_maps[Models.YOLOX_T], delta=0.001)
 
+    def test_pretrained_ppyoloe_s_coco(self):
+        trainer = Trainer(Models.PP_YOLOE_S)
+
+        model = models.get(Models.PP_YOLOE_S, **self.coco_pretrained_ckpt_params)
+        res = trainer.test(
+            model=model,
+            test_loader=self.coco_dataset["ppyoloe"],
+            test_metrics_list=[
+                DetectionMetrics(
+                    score_thres=0.1,
+                    top_k_predictions=300,
+                    num_cls=80,
+                    normalize_targets=True,
+                    post_prediction_callback=PPYoloEPostPredictionCallback(score_threshold=0.01, nms_top_k=1000, max_predictions=300, nms_threshold=0.7),
+                )
+            ],
+        )[2]
+        self.assertAlmostEqual(res, self.coco_pretrained_maps[Models.PP_YOLOE_S], delta=0.001)
+
+    def test_pretrained_ppyoloe_m_coco(self):
+        trainer = Trainer(Models.PP_YOLOE_M)
+
+        model = models.get(Models.PP_YOLOE_M, **self.coco_pretrained_ckpt_params)
+        res = trainer.test(
+            model=model,
+            test_loader=self.coco_dataset["ppyoloe"],
+            test_metrics_list=[
+                DetectionMetrics(
+                    score_thres=0.1,
+                    top_k_predictions=300,
+                    num_cls=80,
+                    normalize_targets=True,
+                    post_prediction_callback=PPYoloEPostPredictionCallback(score_threshold=0.01, nms_top_k=1000, max_predictions=300, nms_threshold=0.7),
+                )
+            ],
+        )[2]
+        self.assertAlmostEqual(res, self.coco_pretrained_maps[Models.PP_YOLOE_M], delta=0.001)
+
     def test_transfer_learning_yolox_n_coco(self):
         trainer = Trainer("test_transfer_learning_yolox_n_coco")
         model = models.get(Models.YOLOX_N, **self.coco_pretrained_ckpt_params, num_classes=5)

@@ -1,47 +1,41 @@
-import os.path
 import unittest
 
-import hydra
-import pkg_resources
 import torch
-from hydra import initialize_config_dir, compose
-from hydra.core.global_hydra import GlobalHydra
 
-from super_gradients.training.models.detection_models.csp_resnet import CSPResNet
-from super_gradients.common.environment.path_utils import normalize_path
+from super_gradients.training import models
+from super_gradients.training.models.detection_models.pp_yolo_e.pp_yolo_e import PPYoloE_X, PPYoloE_S, PPYoloE_M, PPYoloE_L
 
 
-class PPYoloETests(unittest.TestCase):
-    def get_model_arch_params(self, config_name):
-        GlobalHydra.instance().clear()
-        sg_recipes_dir = pkg_resources.resource_filename("super_gradients.recipes", "")
-        with initialize_config_dir(config_dir=normalize_path(sg_recipes_dir), version_base="1.2"):
-            cfg = compose(config_name=normalize_path(config_name))
-            cfg = hydra.utils.instantiate(cfg)
-            arch_params = cfg.arch_params
-
-        return arch_params
-
-    def _test_csp_resnet_variant(self, variant):
-        arch_params = self.get_model_arch_params(os.path.join("arch_params", variant))
+class TestPPYOLOE(unittest.TestCase):
+    def _test_ppyoloe_from_name(self, model_name, pretrained_weights):
+        ppyoloe = models.get(model_name, pretrained_weights=pretrained_weights, num_classes=80 if pretrained_weights is None else None).eval()
+        dummy_input = torch.randn(1, 3, 640, 480)
+        with torch.no_grad():
+            feature_maps = ppyoloe(dummy_input)
+            self.assertIsNotNone(feature_maps)
 
-        ppyoloe = CSPResNet(**arch_params)
-        dummy_input = torch.randn(1, 3, 320, 320)
+    def _test_ppyoloe_from_cls(self, model_cls):
+        ppyoloe = model_cls(arch_params={}).eval()
+        dummy_input = torch.randn(1, 3, 640, 480)
         with torch.no_grad():
             feature_maps = ppyoloe(dummy_input)
-            self.assertEqual(len(feature_maps), 3)
+            self.assertIsNotNone(feature_maps)
 
-    def test_csp_resnet_s(self):
-        self._test_csp_resnet_variant("csp_resnet_l_arch_params")
+    def test_ppyoloe_s(self):
+        self._test_ppyoloe_from_name("ppyoloe_s", pretrained_weights="coco")
+        self._test_ppyoloe_from_cls(PPYoloE_S)
 
-    def test_csp_resnet_m(self):
-        self._test_csp_resnet_variant("csp_resnet_m_arch_params")
+    def test_ppyoloe_m(self):
+        self._test_ppyoloe_from_name("ppyoloe_m", pretrained_weights="coco")
+        self._test_ppyoloe_from_cls(PPYoloE_M)
 
-    def test_csp_resnet_l(self):
-        self._test_csp_resnet_variant("csp_resnet_l_arch_params")
+    def test_ppyoloe_l(self):
+        self._test_ppyoloe_from_name("ppyoloe_l", pretrained_weights=None)
+        self._test_ppyoloe_from_cls(PPYoloE_L)
 
-    def test_csp_resnet_x(self):
-        self._test_csp_resnet_variant("csp_resnet_x_arch_params")
+    def test_ppyoloe_x(self):
+        self._test_ppyoloe_from_name("ppyoloe_x", pretrained_weights=None)
+        self._test_ppyoloe_from_cls(PPYoloE_X)
 
 
 if __name__ == "__main__":