{"id":7057,"date":"2023-08-08T11:49:36","date_gmt":"2023-08-08T19:49:36","guid":{"rendered":"https:\/\/live-cometml.pantheonsite.io\/?p=7057"},"modified":"2025-04-24T17:14:55","modified_gmt":"2025-04-24T17:14:55","slug":"introducing-yolo-nas-a-new-state-of-the-art-for-object-detection","status":"publish","type":"post","link":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/","title":{"rendered":"Introducing YOLO-NAS: A New State-of-the-Art for Object Detection"},"content":{"rendered":"\n
\n
\n
\n
\n
\n
\n<\/div><\/div><\/figure><\/div><\/div><\/div>\n\n\n\n
\"GIF
\ud83c\udfce\ufe0fYOLO-NAS in action<\/figcaption><\/figure>\n\n\n\n

YOLO models are famous for two main reasons:<\/p>\n\n\n\n

    \n
  1. Impressive speed and accuracy.<\/li>\n\n\n\n
  2. Ability to detect objects in images quickly and dependably.<\/li>\n<\/ol>\n\n\n\n

    The first version of YOLO was introduced in 2016 and changed how object detection was performed by treating object detection as a single regression problem.<\/p>\n\n\n\n

    It divided images into a grid and simultaneously predicted bounding boxes and class probabilities. Though it was faster than previous object detection methods, YOLOv1 had limitations in detecting small objects and struggled with localization accuracy. Since the first YOLO architecture hit the scene, 15 YOLO-based architectures have been developed<\/a>, all known for their accuracy, real-time performance, and enabling object detection on edge devices and in the cloud.<\/p>\n\n\n\n

    But just because we have all these YOLOs doesn\u2019t mean that deep learning for object detection is a dormant area of research.<\/strong><\/p>\n\n\n\n

    In the subfield of computer vision, the competition for cutting-edge object detection is fierce.<\/p>\n\n\n\n

    At Deci, a team of researchers aimed to create a model that would stand out amongst the rest<\/a>. Their objective was to make revolutionary improvements, just as sprinters aim to shave milliseconds off their times. The team embraced the challenge of pushing the limits of performance, knowing that even small increases in mAP and reduced latency could truly revolutionize the object detection model landscape.<\/p>\n\n\n\n

    And in the process, a new YOLO architecture was born: \ud83c\udfce\ufe0fYOLO-NAS<\/h2>\n\n\n\n
    \n
    \n
    \n<\/picture>\n<\/div><\/div><\/figure>\n\n\n\n
    \"A
    The \ud83c\udfce\ufe0fYOLO-NAS Architecture<\/figcaption><\/figure>\n\n\n\n

    YOLO-NAS is composed of a backbone, neck, and head, mirroring many similar models.<\/p>\n\n\n\n

    The backbone extracts features from the input image.<\/p>\n\n\n\n

    YOLO-NAS has a dual-path backbone with dense feature extraction and sparse feature fusion paths. The dense path has multiple convolutional layers with skip connections in dense blocks, while the transition blocks in the sparse path reduce spatial resolution and boost the number of channels. Both paths interconnect via cross-stage partial connections, which enables gradient flow.<\/p>\n\n\n\n

    \n
    \n
    \n

    Innovation and academia go hand-in-hand. Listen to our own CEO Gideon Mendels chat with the Stanford MLSys Seminar Series team about the future of MLOps and give the Comet platform a try for free<\/a>!<\/p><\/blockquote>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n

    \n
    \n
    \n

    The neck further enhances the features extracted by the backbone, creating predictions at varied scales.<\/p>\n

    The YOLO-NAS system utilizes a multi-scale feature pyramid and backbone features to make small, medium, and large predictions. The neck of the system combines upsampling and concatenation to blend features from various levels, thus broadening the receptive field. The head performs final classification and regression tasks.<\/p>\n

    The YOLO-NAS head consists of two parallel branches.<\/p>\n

    One is a classification branch, and the other is a regression branch that uses generalized IoU loss. The classification branch predicts the class probability of each anchor box, while the regression branch estimates the bounding box coordinates.<\/p>\n

    What\u2019s New in \ud83c\udfce\ufe0fYOLO-NAS?<\/h2>\n
    \n
    \n
    \n<\/picture>\n<\/div><\/div><\/figure><\/div><\/div><\/div>\n\n\n\n
    \"Graph
    \ud83c\udfce\ufe0fYOLO-NAS vs The World<\/figcaption><\/figure>\n\n\n\n

    \u2728 YOLO-NAS utilizes cutting-edge methods such as attention mechanisms, quantization aware blocks, and inference time reparametrization, raising the bar for object detection in various industries.<\/p>\n\n\n\n

    \u2728 It\u2019s an open-source model with pre-trained weights (for non-commercial research) through Deci\u2019s PyTorch-based computer vision library called SuperGradients<\/a>.<\/p>\n\n\n\n

    \u2728 It\u2019s a foundation model for object detection pretrained on COCO, Objects365, and Roboflow 100, preparing you for success in downstream object detection tasks.<\/p>\n\n\n\n

    \u2728 The algorithm for selecting layers in the model quantizes certain parts to minimize loss of information while ensuring a balance between latency and accuracy.<\/p>\n\n\n\n

    \u2728 Post-training, the network converts to INT8, enhancing efficiency even further.<\/p>\n\n\n\n

    \u2728 Compared to other top YOLO models, YOLO-NAS (m) model achieves a 50% increase in throughput and a 1 mAP improvement in accuracy on the NVIDIA T4 GPU.<\/p>\n\n\n\n

    There\u2019s no paper for YOLO-NAS, but a technical blog<\/a> details the architecture and training procedure.<\/p>\n\n\n\n

    \ud83e\udee3 Sneak peek: Inference with YOLO-NAS<\/h2>\n\n\n\n

    Before jumping into the section on fine-tuning, I wanted to show you the power of YOLONAS out of the box.<\/p>\n\n\n\n

    Start by instantiating a pretrained model. YOLONAS comes in three flavors: yolo_nas_s<\/code>, yolo_nas_m<\/code>, and yolo_nas_l<\/code>.<\/p>\n\n\n\n

    You\u2019ll use yolo_nas_l<\/code> throughout this tutorial. Because you should always go big or go home.<\/p>\n\n\n\n

    It\u2019s a good life philosophy.<\/p>\n\n\n\n

    \ud83d\udc68\ud83c\udffd\u200d\ud83d\udd27 Install SuperGradients<\/h3>\n\n\n\n

    \ud83d\udea8 Note (for Google Colab):<\/strong> after installation is complete (it will take a few minutes), you\u2019ll need to restart the runtime after installation completion.<\/p>\n\n\n\n

    This is a known issue<\/a> that is on our roadmap.<\/p>\n\n\n\n

    pip install super-gradients==3.1.1<\/span><\/pre>\n\n\n\n
    \ud83d\udc47\ud83c\udffdInstantiate a pre-trained model<\/h3>\n\n\n\n
    from<\/span> super_gradients.training import<\/span> models\n\nyolo_nas_l = models.get(\"yolo_nas_l\"<\/span>, pretrained_weights=\"coco\"<\/span>)<\/span><\/pre>\n\n\n\n
    \ud83d\uddbc\ufe0f Inference on an image<\/h3>\n\n\n\n
    Once the model has been instantiated all you have to do is call the predict<\/code>method.<\/p>\n\n\n\n
    This method operates on:
    \n\u2733\ufe0f PIL Image
    \n\ufe0f\ufe0f\u2733\ufe0f Numpy Image
    \n\u2733\ufe0f A path to an image file
    \n\u2733\ufe0f A path to video file
    \n\u2733\ufe0f A path to folder with images
    \n\u2733\ufe0f URL (Image only)<\/p>\n\n\n\n
    Note<\/strong>: Predict also has an argument called conf<\/code>, the threshold for detection. You change this value as you like, for example: model.predict(\u201cpath\/to\/asset\u201d,conf=0.25)<\/code>.<\/p>\n\n\n\n
    Let\u2019s perform inference on the following image:<\/p>\n\n\n\n
    \n
    \n
    \n<\/picture>\n<\/div><\/div><\/figure>\n\n\n\n
    \"An
    An image for \ud83c\udfce\ufe0fYOLO-NAS to perform inference on<\/figcaption><\/figure>\n\n\n\n
    url = \"https:\/\/previews.123rf.com\/images\/freeograph\/freeograph2011\/freeograph201100150\/158301822-group-of-friends-gathering-around-table-at-home.jpg\"<\/span>\nyolo_nas_l.predict(url, conf=0.25<\/span>).show()<\/span><\/pre>\n\n\n\n
    \ud83e\udd37\ud83c\udffd\u200d\u2642\ufe0f What\u2019s happening \u201cunder the hood\u201d<\/strong><\/p>\n\n\n\n
      \n
    1. Input image gets through the preprocessing pipeline, which includes image resizing, normalization, and permute operation to convert input RGB image to torch tensor.<\/li>\n\n\n\n
    2. Model inference<\/li>\n\n\n\n
    3. Postprocessing of the detection results (Non-maximum suppression, resizing bounding boxes to the size of the original image)<\/li>\n\n\n\n
    4. Visualization of the results (Rendering of bounding boxes on top of the image)<\/li>\n<\/ol>\n\n\n\n
      \n
      \n
      \n<\/picture>\n<\/div><\/div><\/figure>\n\n\n\n
      \"Example
      The detections from a pre-trained \ud83c\udfceYOLO-NAS model<\/figcaption><\/figure>\n\n\n\n
      \ud83c\udfcb\ud83c\udffd The Trainer<\/h3>\n\n\n\n
      The first thing you need to define in SuperGradients is the Trainer.<\/p>\n\n\n\n
      The trainer oversees training, evaluation, saving checkpoints, etc. If you\u2019re interested in seeing the source code for the trainer, you can do so here<\/a>.<\/p>\n\n\n\n
      \u270c\ud83c\udffc There are two important arguments for the trainer:<\/strong><\/p>\n\n\n\n
      1) ckpt_root_dir <\/code>\u2014 this is the directory where results from all your experiments will be saved<\/p>\n\n\n\n
      2) experiment_name<\/code> \u2014 all checkpoints, logs, and tensorboards will be saved in a directory with the name you specify here.<\/p>\n\n\n\n
      SuperGradients supports Data Parallel<\/strong> and Distributed Data Parallel<\/strong>.<\/p>\n\n\n\n
      That\u2019s outside of the scope of this introduction to SuperGradients. But if you\u2019re fortunate enough to have multiple GPUs or want to learn more, you can do so here<\/a>.<\/p>\n\n\n\n
      In the code below, you\u2019ll instantiate the trainer with just a single GPU (since that\u2019s what Google Colab provides)<\/p>\n\n\n\n
      from<\/span> super_gradients.training import<\/span> Trainer\n\nCHECKPOINT_DIR = 'checkpoints'<\/span>\ntrainer = Trainer(experiment_name='my_first_yolonas_run'<\/span>, ckpt_root_dir=CHECKPOINT_DIR)<\/span><\/pre>\n\n\n\n
      \ud83d\udcbe Datasets and DataLoaders<\/h3>\n\n\n\n
      SuperGradients is fully compatible with PyTorch Datasets and Dataloaders, so you can use your dataloaders as is.<\/p>\n\n\n\n
      There are several well-known datasets for object detection, for example:<\/p>\n\n\n\n
      \ud83d\udcbd COCO
      \n\ud83d\udcbd Pascal
      \n\ud83d\udcbd YOLODarkNet
      \n\ud83d\udcbd YOLOv5<\/p>\n\n\n\n
      SuperGradients provides ready-to-use dataloaders for these datasets. If you\u2019re interested in learning more about working with COCOFormatDetectionDataset<\/code> and the more general DetectionDataset<\/code> check out the SuperGradients documentation on this topic<\/a>.<\/p>\n\n\n\n
      You can learn more about working with SuperGradients datasets, dataloaders, and configuration files here<\/a>.<\/p>\n\n\n\n
      SuperGradients supports several dataset formats. You can learn more about that here.<\/a><\/p>\n\n\n\n
      For this example, you\u2019ll use the U.S. Coins Dataset<\/a> from RoboFlow<\/a> with the dataset in YOLOv5 format.<\/p>\n\n\n\n
      from<\/span> roboflow import<\/span> Roboflow\nrf = Roboflow(api_key=\"<your-roboflow-key-here>\"<\/span>)\nproject = rf.workspace(\"atathamuscoinsdataset\"<\/span>).project(\"u.s.-coins-dataset-a.tatham\"<\/span>)\ndataset = project.version(5<\/span>).download(\"yolov5\"<\/span>)<\/span><\/pre>\n\n\n\n
      Start by importing the required modules to help you create SuperGradients dataloaders.<\/p>\n\n\n\n
      from<\/span> super_gradients.training import<\/span> dataloaders\nfrom<\/span> super_gradients.training.dataloaders.dataloaders import<\/span> coco_detection_yolo_format_train, coco_detection_yolo_format_val<\/span><\/pre>\n\n\n\n
      You\u2019ll need to load your dataset parameters into a dictionary, specifically defining:<\/p>\n\n\n\n
      \u2733\ufe0f Path to the parent directory where your data lives
      \n\ufe0f\ufe0f\u2733\ufe0f The child directory names for training, validation, and test (if you have test set) images and labels
      \n\u2733\ufe0f Class names<\/p>\n\n\n\n
      You pass the values for dataset_params<\/code> into the dataset_params<\/code> argument, as shown below.<\/p>\n\n\n\n
      dataset_params = {\n    'data_dir'<\/span>:'\/content\/U.S.-Coins-Dataset---A.Tatham-5'<\/span>,\n    'train_images_dir'<\/span>:'train\/images'<\/span>,\n    'train_labels_dir'<\/span>:'train\/labels'<\/span>,\n    'val_images_dir'<\/span>:'valid\/images'<\/span>,\n    'val_labels_dir'<\/span>:'valid\/labels'<\/span>,\n    'test_images_dir'<\/span>:'test\/images'<\/span>,\n    'test_labels_dir'<\/span>:'test\/labels'<\/span>,\n    'classes'<\/span>: ['Dime'<\/span>, 'Nickel'<\/span>, 'Penny'<\/span>, 'Quarter'<\/span>]<\/span><\/pre>\n\n\n\n
      You can also pass PyTorch DataLoaders arguments when instantiating your dataset. Here you\u2019ll set batch_size=16<\/code> and num_workers=2<\/code>.<\/p>\n\n\n\n
      Repeat this for the validation and testing datasets. Note that for training and testing data, we use coco_detection_yolo_format_val<\/code> to instantiate the dataloader.<\/p>\n\n\n\n
      The dataloaders will print warnings when an annotation does not conform to the expected format. This dataset has many such annotations; thus, the warnings will be muted.<\/p>\n\n\n\n
      from<\/span> IPython.display import<\/span> clear_output\n\ntrain_data = coco_detection_yolo_format_train(\n    dataset_params={\n        'data_dir'<\/span>: dataset_params['data_dir'<\/span>],\n        'images_dir'<\/span>: dataset_params['train_images_dir'<\/span>],\n        'labels_dir'<\/span>: dataset_params['train_labels_dir'<\/span>],\n        'classes'<\/span>: dataset_params['classes'<\/span>]\n    },\n    dataloader_params={\n        'batch_size'<\/span>:16<\/span>,\n        'num_workers'<\/span>:2<\/span>\n    }\n)\n\nval_data = coco_detection_yolo_format_val(\n    dataset_params={\n        'data_dir'<\/span>: dataset_params['data_dir'<\/span>],\n        'images_dir'<\/span>: dataset_params['val_images_dir'<\/span>],\n        'labels_dir'<\/span>: dataset_params['val_labels_dir'<\/span>],\n        'classes'<\/span>: dataset_params['classes'<\/span>]\n    },\n    dataloader_params={\n        'batch_size'<\/span>:16<\/span>,\n        'num_workers'<\/span>:2<\/span>\n    }\n)\n\ntest_data = coco_detection_yolo_format_val(\n    dataset_params={\n        'data_dir'<\/span>: dataset_params['data_dir'<\/span>],\n        'images_dir'<\/span>: dataset_params['test_images_dir'<\/span>],\n        'labels_dir'<\/span>: dataset_params['test_labels_dir'<\/span>],\n        'classes'<\/span>: dataset_params['classes'<\/span>]\n    },\n    dataloader_params={\n        'batch_size'<\/span>:16<\/span>,\n        'num_workers'<\/span>:2<\/span>\n    }\n)\n\nclear_output()<\/span><\/pre>\n\n\n\n
      \ud83d\udc69\ud83c\udffd\u200d\ud83e\uddb3 Instantiating the model<\/h3>\n\n\n\n
      You saw how to instantiate the model for inference earlier.<\/p>\n\n\n\n
      Below is how to instantiate the model for finetuning. Note you need to add the num_classes<\/code> argument here.<\/p>\n\n\n\n
      Note, for this tutorial, you\u2019re using yolo_nas_l<\/code>, but SuperGradients has two other flavors of YOLONAS available to you: yolo_nas_s<\/code> and yolo_nas_m<\/code>.<\/p>\n\n\n\n
      from<\/span> super_gradients.training import<\/span> models\nmodel = models.get('yolo_nas_l'<\/span>,\n                   num_classes=len<\/span>(dataset_params['classes'<\/span>]),\n                   pretrained_weights=\"coco\"<\/span>\n                   )<\/span><\/pre>\n\n\n\n
      \ud83c\udf9b\ufe0f Training parameters<\/h3>\n\n\n\n
      You need to define the training parameters for your training run.<\/p>\n\n\n\n
      Full details about the training parameters can be found here.<\/a><\/p>\n\n\n\n
      \ud83d\udea8 There are a few mandatory<\/strong> arguments that you must define for training params \ud83d\udea8<\/p>\n\n\n\n
      \u2733\ufe0f max_epochs<\/code> \u2014 Max number of training epochs<\/p>\n\n\n\n
      \u2733\ufe0f\ufe0f\ufe0f loss<\/code>\u2014 the loss function you want to use<\/p>\n\n\n\n
      \u2733\ufe0f optimizer<\/code>\u2014 Optimizer you will be using<\/p>\n\n\n\n
      \u2733\ufe0f train_metrics_list <\/code>\u2014 Metrics to log during training<\/p>\n\n\n\n
      \u2733\ufe0f valid_metrics_list <\/code>\u2014 Metrics to log during training<\/p>\n\n\n\n
      \u2733\ufe0f metric_to_watch<\/code> \u2014 metric which the model checkpoint will be saved according to<\/p>\n\n\n\n
      You can choose from various optimizer<\/code>s such as Adam, AdamW, SGD, Lion, or RMSProps. If you change the default parameters of these optimizers, you pass them into optimizer_params<\/code>.<\/p>\n\n\n\n
      \ud83d\udd15 Note: I\u2019ve enabled <\/strong>silent_mode<\/strong><\/code>, so the notebook doesn\u2019t get longer than it already is. You should disable it so you can see what SuperGradients outputs during training.<\/strong><\/p>\n\n\n\n
      from<\/span> super_gradients.training.losses import<\/span> PPYoloELoss\nfrom<\/span> super_gradients.training.metrics import<\/span> DetectionMetrics_050\nfrom<\/span> super_gradients.training.models.detection_models.pp_yolo_e import<\/span> PPYoloEPostPredictionCallback\n\ntrain_params = {\n    # ENABLING SILENT MODE<\/span>\n    'silent_mode'<\/span>: True<\/span>,\n    \"average_best_models\"<\/span>:True<\/span>,\n    \"warmup_mode\"<\/span>: \"linear_epoch_step\"<\/span>,\n    \"warmup_initial_lr\"<\/span>: 1e-6<\/span>,\n    \"lr_warmup_epochs\"<\/span>: 3<\/span>,\n    \"initial_lr\"<\/span>: 5e-4<\/span>,\n    \"lr_mode\"<\/span>: \"cosine\"<\/span>,\n    \"cosine_final_lr_ratio\"<\/span>: 0.1<\/span>,\n    \"optimizer\"<\/span>: \"Adam\"<\/span>,\n    \"optimizer_params\"<\/span>: {\"weight_decay\"<\/span>: 0.0001<\/span>},\n    \"zero_weight_decay_on_bias_and_bn\"<\/span>: True<\/span>,\n    \"ema\"<\/span>: True<\/span>,\n    \"ema_params\"<\/span>: {\"decay\"<\/span>: 0.9<\/span>, \"decay_type\"<\/span>: \"threshold\"<\/span>},\n    # ONLY TRAINING FOR 10 EPOCHS FOR THIS EXAMPLE NOTEBOOK<\/span>\n    \"max_epochs\"<\/span>: 10<\/span>,\n    \"mixed_precision\"<\/span>: True<\/span>,\n    \"loss\"<\/span>: PPYoloELoss(\n        use_static_assigner=False<\/span>,\n        # NOTE:<\/span> num_classes needs to be defined here<\/span>\n        num_classes=len<\/span>(dataset_params['classes'<\/span>]),\n        reg_max=16<\/span>\n    ),\n    \"valid_metrics_list\"<\/span>: [\n        DetectionMetrics_050(\n            score_thres=0.1<\/span>,\n            top_k_predictions=300<\/span>,\n            # NOTE:<\/span> num_classes needs to be defined here<\/span>\n            num_cls=len<\/span>(dataset_params['classes'<\/span>]),\n            normalize_targets=True<\/span>,\n            post_prediction_callback=PPYoloEPostPredictionCallback(\n                score_threshold=0.01<\/span>,\n                nms_top_k=1000<\/span>,\n                max_predictions=300<\/span>,\n                nms_threshold=0.7<\/span>\n            )\n        )\n    ],\n    \"metric_to_watch\"<\/span>: 'mAP@0.50'<\/span>\n}<\/span><\/pre>\n\n\n\n
      \ud83e\ude84 SuperGradients offers several training tricks right out of the box, such as:<\/strong><\/p>\n\n\n\n
      \u2733\ufe0f Exponential moving average
      \n\u2733\ufe0f Zero-weight decay on bias and batch normalization
      \n\u2733\ufe0f Weight averaging
      \n\u2733\ufe0f Batch accumulation
      \n\u2733\ufe0f Precise BatchNorm<\/p>\n\n\n\n
      If you want to build a custom metric with SuperGradients, you can learn how here<\/a>.<\/p>\n\n\n\n
      Note that you must set the number of classes in two places below: PPYoloELoss<\/code> and DetectionMetrics_050<\/code>.<\/p>\n\n\n\n
      You may notice that we use a post-prediction callback. For details on how phase callbacks work in SuperGradients check out our documentation<\/a>.<\/p>\n\n\n\n
      \ud83e\uddbe Training the model<\/h3>\n\n\n\n
      You\u2019ve covered a lot of ground so far:<\/p>\n\n\n\n
      \u2705 Instantiated the trainer<\/p>\n\n\n\n
      \u2705 Defined your dataset parameters and dataloaders<\/p>\n\n\n\n
      \u2705 Instantiated a model<\/p>\n\n\n\n
      \u2705 Set up your training parameters<\/p>\n\n\n\n
      \u23f3 Now, its time to train a model<\/strong><\/p>\n\n\n\n
      Training a model using SuperGradients is done using the trainer.<\/code><\/p>\n\n\n\n
      trainer.train(model=model,\n              training_params=train_params,\n              train_loader=train_data,\n              valid_loader=val_data)<\/span><\/pre>\n\n\n\n
      \ud83c\udfc6 Get the best trained model<\/h3>\n\n\n\n
      Now that training is complete, you must get the best trained model.<\/p>\n\n\n\n
      You used checkpoint averaging, so the following code will use weights averaged across training runs.<\/p>\n\n\n\n
      best_model = models.get('yolo_nas_l'<\/span>,\n                        num_classes=len<\/span>(dataset_params['classes'<\/span>]),\n                        checkpoint_path=\"checkpoints\/my_first_yolonas_run\/average_model.pth\"<\/span>)<\/span><\/pre>\n\n\n\n
      If you want to use the best weights or weights from the last epoch, you\u2019d use one of the following in the code below:<\/strong><\/p>\n\n\n\n
      best_weights = models.get('yolo_nas_l'<\/span>,\n                        num_classes=len<\/span>(dataset_params['classes'<\/span>]),\n                        checkpoint_path=\"checkpoints\/my_first_yolonas_run\/average_model.pth\"<\/span>)\n\nlast_weights = models.get('yolo_nas_l'<\/span>,\n                        num_classes=len<\/span>(dataset_params['classes'<\/span>]),\n                        checkpoint_path=\"checkpoints\/my_first_yolonas_run\/ckpt_latest.pth\"<\/span>)<\/span><\/pre>\n\n\n\n
      \ud83e\uddd0 Evaluating the best trained model on the test set<\/h3>\n\n\n\n
      Once you have a trained model, you can evaluate its performance on unseen data like below:<\/p>\n\n\n\n
      trainer.test(model=best_model,\n            test_loader=test_data,\n            test_metrics_list=DetectionMetrics_050(score_thres=0.1<\/span>,\n                                                   top_k_predictions=300<\/span>,\n                                                   num_cls=len<\/span>(dataset_params['classes'<\/span>]),\n                                                   normalize_targets=True<\/span>,\n                                                   post_prediction_callback=PPYoloEPostPredictionCallback(score_threshold=0.01<\/span>,\n                                                                                                          nms_top_k=1000<\/span>,\n                                                                                                          max_predictions=300<\/span>,\n                                                                                                          nms_threshold=0.7<\/span>)\n                                                  ))<\/span><\/pre>\n\n\n\n
      \ud83d\udd2e Predicting the best model<\/h3>\n\n\n\n
      The next line will perform detection on the following image.<\/p>\n\n\n\n
      \"A<\/figure>\n\n\n\n
      Note, we didn\u2019t have a class for the half-dollar coin. So it will likely get classified as something else.<\/p>\n\n\n\n
      img_url = 'https:\/\/www.mynumi.net\/media\/catalog\/product\/cache\/2\/image\/9df78eab33525d08d6e5fb8d27136e95\/s\/e\/serietta_usa_2_1\/www.mynumi.net-USASE5AD160-31.jpg'<\/span>\nbest_model.predict(img_url).show()<\/span><\/pre>\n\n\n\n
      The results aren\u2019t too bad after just a few epochs!<\/p>\n\n\n\n
      \n
      \n
      \n<\/picture>\n<\/div><\/div><\/figure>\n\n\n\n
      \"YOLO-NAS\u2019s
      \ud83c\udfce\ufe0fYOLO-NAS detections after training<\/figcaption><\/figure>\n\n\n\n
      References<\/h2>\n\n\n\n
      \u21aa\ufe0f \ud83c\udfce\ufe0fYOLO-NAS Technical Blog<\/a><\/p>\n\n\n\n
      \u21aa\ufe0f \ud83c\udfce\ufe0fYOLO-NAS Starter Notebook<\/a><\/p>\n\n\n\n
      \u21aa\ufe0f\ufe0f \ud83c\udfce\ufe0fYOLO-NAS Project Template<\/a><\/p>\n\n\n\n
      \u21aa\ufe0f \ud83c\udfce\ufe0fYOLO-NAS ReadMe on GitHub<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
      YOLO models are famous for two main reasons: The first version of YOLO was introduced in 2016 and changed how object detection was performed by treating object detection as a single regression problem. It divided images into a grid and simultaneously predicted bounding boxes and class probabilities. Though it was faster than previous object detection […]<\/p>\n","protected":false},"author":68,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"customer_name":"","customer_description":"","customer_industry":"","customer_technologies":"","customer_logo":"","footnotes":""},"categories":[6],"tags":[],"coauthors":[166],"class_list":["post-7057","post","type-post","status-publish","format-standard","hentry","category-machine-learning"],"yoast_head":"\nIntroducing YOLO-NAS: A New State-of-the-Art for Object Detection - Comet<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Introducing YOLO-NAS: A New State-of-the-Art for Object Detection\" \/>\n<meta property=\"og:description\" content=\"YOLO models are famous for two main reasons: The first version of YOLO was introduced in 2016 and changed how object detection was performed by treating object detection as a single regression problem. It divided images into a grid and simultaneously predicted bounding boxes and class probabilities. Though it was faster than previous object detection […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/\" \/>\n<meta property=\"og:site_name\" content=\"Comet\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/cometdotml\" \/>\n<meta property=\"article:published_time\" content=\"2023-08-08T19:49:36+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-04-24T17:14:55+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*mR__xCOs_j8c5A0hMq3B5Q.gif\" \/>\n<meta name=\"author\" content=\"Harpreet Sahota\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@Cometml\" \/>\n<meta name=\"twitter:site\" content=\"@Cometml\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Harpreet Sahota\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Introducing YOLO-NAS: A New State-of-the-Art for Object Detection - Comet","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/","og_locale":"en_US","og_type":"article","og_title":"Introducing YOLO-NAS: A New State-of-the-Art for Object Detection","og_description":"YOLO models are famous for two main reasons: The first version of YOLO was introduced in 2016 and changed how object detection was performed by treating object detection as a single regression problem. It divided images into a grid and simultaneously predicted bounding boxes and class probabilities. Though it was faster than previous object detection […]","og_url":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/","og_site_name":"Comet","article_publisher":"https:\/\/www.facebook.com\/cometdotml","article_published_time":"2023-08-08T19:49:36+00:00","article_modified_time":"2025-04-24T17:14:55+00:00","og_image":[{"url":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*mR__xCOs_j8c5A0hMq3B5Q.gif","type":"","width":"","height":""}],"author":"Harpreet Sahota","twitter_card":"summary_large_image","twitter_creator":"@Cometml","twitter_site":"@Cometml","twitter_misc":{"Written by":"Harpreet Sahota","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/#article","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/"},"author":{"name":"Harpreet Sahota","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/46036ab474aa916e2873daece26a28d6"},"headline":"Introducing YOLO-NAS: A New State-of-the-Art for Object Detection","datePublished":"2023-08-08T19:49:36+00:00","dateModified":"2025-04-24T17:14:55+00:00","mainEntityOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/"},"wordCount":1682,"publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*mR__xCOs_j8c5A0hMq3B5Q.gif","articleSection":["Machine Learning"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/","url":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/","name":"Introducing YOLO-NAS: A New State-of-the-Art for Object Detection - Comet","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/#primaryimage"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*mR__xCOs_j8c5A0hMq3B5Q.gif","datePublished":"2023-08-08T19:49:36+00:00","dateModified":"2025-04-24T17:14:55+00:00","breadcrumb":{"@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/#primaryimage","url":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*mR__xCOs_j8c5A0hMq3B5Q.gif","contentUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:700\/1*mR__xCOs_j8c5A0hMq3B5Q.gif"},{"@type":"BreadcrumbList","@id":"https:\/\/www.comet.com\/site\/blog\/introducing-yolo-nas-a-new-state-of-the-art-for-object-detection\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.comet.com\/site\/"},{"@type":"ListItem","position":2,"name":"Introducing YOLO-NAS: A New State-of-the-Art for Object Detection"}]},{"@type":"WebSite","@id":"https:\/\/www.comet.com\/site\/#website","url":"https:\/\/www.comet.com\/site\/","name":"Comet","description":"Build Better Models Faster","publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.comet.com\/site\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.comet.com\/site\/#organization","name":"Comet ML, Inc.","alternateName":"Comet","url":"https:\/\/www.comet.com\/site\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/","url":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","contentUrl":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","width":310,"height":310,"caption":"Comet ML, Inc."},"image":{"@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/cometdotml","https:\/\/x.com\/Cometml","https:\/\/www.youtube.com\/channel\/UCmN63HKvfXSCS-UwVwmK8Hw"]},{"@type":"Person","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/46036ab474aa916e2873daece26a28d6","name":"Harpreet Sahota","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/image\/2d21512be19ba7e19a71a803309e2a88","url":"https:\/\/secure.gravatar.com\/avatar\/a6ca5a533fc9f143a0a7428037ff652aa0633d66bf27e76ae89b955ae72a0f2d?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/a6ca5a533fc9f143a0a7428037ff652aa0633d66bf27e76ae89b955ae72a0f2d?s=96&d=mm&r=g","caption":"Harpreet Sahota"},"url":"https:\/\/www.comet.com\/site\/blog\/author\/theartistsofdatasciencegmail-com\/"}]}},"_links":{"self":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7057","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/users\/68"}],"replies":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/comments?post=7057"}],"version-history":[{"count":1,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7057\/revisions"}],"predecessor-version":[{"id":15588,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7057\/revisions\/15588"}],"wp:attachment":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/media?parent=7057"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/categories?post=7057"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/tags?post=7057"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/coauthors?post=7057"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
      You can read more details about these training tricks here<\/a>.<\/p>\n\n\n\n