How to Train Yolo Nas on Custom Dataset (Aquarium)

Last Updated on 28/11/2025 by Eran Feit

When you train yolo nas on custom dataset, you’re taking an object detection model that was designed as a strong, general-purpose detector and adapting it to your specific problem. Instead of relying only on COCO-style everyday scenes, you can teach YOLO-NAS to recognize underwater creatures like fish, jellyfish, sharks, or penguins in noisy, low-contrast aquarium or ocean images. This customization is what turns a powerful foundation model into a tool that truly understands your domain.

In an aquarium or ocean setting, images often suffer from blur, color shifts, reflections, and particles floating in the water. A generic model might miss small targets, confuse background textures with real objects, or underperform when the lighting changes. Training YOLO-NAS on a custom dataset lets you feed it exactly the kinds of underwater scenes and annotations it will see in production, so it can learn to handle these challenges and deliver more reliable detections in real-world videos or still images.

There is also a practical side to this process. By preparing your images in YOLO format, organizing them into train, validation, and test splits, and then running a full training pipeline, you’re building a repeatable workflow. Once you’ve tuned this pipeline on one aquarium dataset, you can easily swap in other underwater collections or even expand to related tasks like detecting coral health, marine debris, or different fish species, all using the same core approach.

Finally, training YOLO-NAS on your own data gives you control over metrics and model behavior. You can track mAP, tune thresholds, monitor how well the detector performs on small jellyfish versus large sharks, and decide when the model is “good enough” to deploy. This is crucial for real projects where missed detections or false alarms can be costly, whether the goal is scientific monitoring, educational exhibits, or automated video analytics in aquariums.

Bringing YOLO-NAS and Custom Aquarium Data Together

When you train YOLO-NAS on a custom dataset of aquarium images, you’re combining three key ingredients: a strong modern detector, a well-structured dataset, and a clear real-world goal. The detector provides the architecture and learning capacity, the dataset provides the visual experience, and your goal shapes how you evaluate success. In this case, the goal might be to accurately detect fish, jellyfish, penguins, puffins, sharks, starfish, and stingrays in crowded or murky underwater scenes.

At a high level, the workflow starts with data. You collect or download underwater images, label each object with bounding boxes and class names, and store everything in the YOLO format expected by the training code. Organizing images into train, validation, and test folders ensures that YOLO-NAS sees enough variety during learning while still leaving aside images that can objectively measure generalization at the end. This structure is crucial for understanding whether the model is truly learning underwater patterns or just memorizing a few examples.

Next comes the model and training loop. YOLO-NAS uses a backbone, neck, and detection head to extract features from your images, fuse multi-scale information, and produce bounding boxes and class scores. During training, loss functions and metrics guide the model towards better performance, while optimizers like Adam adjust weights based on gradients. Over multiple epochs, the model gradually improves at locating fish and other marine animals, reducing localization errors, and better separating similar shapes and textures that are common in underwater environments.

Once you have a trained model, you move into evaluation and prediction. Evaluation on the test split gives you metrics such as mAP@0.50, which summarize how often the model correctly detects and classifies underwater objects at different IoU thresholds. Prediction on individual images or entire folders of aquarium photos lets you visualize bounding boxes and check whether detections match what a human would label. This stage is where you confirm that the model is robust to variations in lighting, camera angle, and water clarity.

Ultimately, bringing YOLO-NAS together with custom aquarium data turns abstract deep learning code into a practical solution. You end up with a detector that not only understands generic objects, but is also specialized for underwater scenes. That specialization can support research, interactive displays, automated monitoring systems, or educational content that highlights marine life, all powered by a model trained on your own curated dataset.

Understanding the YOLO-NAS Architecture and Where It Shines

YOLO-NAS is built to balance two things that are usually hard to get together: top-tier accuracy and real-time speed. Instead of relying on a manually designed network, its structure is discovered with Neural Architecture Search (NAS), which automatically tests and refines different designs. On top of that, YOLO-NAS uses ideas like attention, quantization-aware blocks, and re-parameterization at inference time, so the final model can run fast on real hardware without losing much accuracy.

At a high level, the network is split into three main parts: backbone, neck, and head. The backbone is the feature extractor. It stacks convolutional layers and custom blocks that have been tuned to capture everything from simple edges and textures to complex shapes, parts, and object patterns. When you train yolo nas on custom dataset, this backbone is what learns the visual vocabulary of your domain, whether that’s everyday street scenes, medical scans, or underwater aquarium images.

The neck sits between the backbone and the detection head. Its job is to combine features from different depths of the network, creating a strong multi-scale representation. YOLO-NAS uses an FPN-style neck with cross-stage connections and adaptive feature fusion, so information from shallow and deep layers can interact. This helps the model handle tiny objects, medium-sized objects, and large objects in the same frame, which is crucial for scenarios like underwater detection where small jellyfish and large sharks might appear together in one image.

The head is the part that turns these rich features into actual detections: bounding boxes and class probabilities. YOLO-NAS uses a multi-scale, anchor-free detection head. Instead of depending on a fixed grid of anchor boxes, it learns directly where and how to place boxes around objects. Lightweight channel attention helps the head focus on the most informative features, improving precision without adding heavy computation. During deployment, re-parameterization and quantization-friendly building blocks allow the trained model to be converted into an efficient INT8 version, keeping latency low even on edge devices.

Because of this design, YOLO-NAS is a strong fit for production-grade object detection. In surveillance and security, it can run on smart cameras to detect people, vehicles, or unusual events in real time. In autonomous driving and robotics, its low-latency predictions help detect pedestrians, cyclists, and obstacles so decisions like braking or lane changes can be made quickly. The same architecture can be fine-tuned for aquarium or ocean datasets, learning to recognize fish, jellyfish, and other sea life under poor visibility and challenging lighting.

Beyond classic vision tasks, YOLO-NAS also adapts well to specialized domains like medical imaging and retail. In healthcare, it can act as a second reader to highlight suspicious regions in X-rays or CT scans. In retail, it can track products on shelves, monitor stock levels, or analyze how customers move through a store. In all these cases, you typically start from a pretrained YOLO-NAS model and fine-tune it on your own labeled images, using transfer learning to get strong results from relatively small datasets. That combination of NAS-optimized architecture, deployment-friendly design, and flexible training makes YOLO-NAS a reliable foundation for many modern object detection solutions.

What This YOLO-NAS Aquarium Tutorial Will Help You Build

In this tutorial, the focus is practical: we’re going to train yolo nas on custom dataset of aquarium images and end up with a working object detection model you can actually run on your own machine. The code walks you through the full lifecycle—setting up the environment, downloading the dataset, training the model, and finally using it to detect marine animals in new images. By the end, you don’t just understand YOLO-NAS in theory; you have a concrete Python project that proves everything works end-to-end.

The first part of the code is all about creating a clean working environment. You’ll set up a dedicated Conda environment with the right Python version, install PyTorch with CUDA support, and then add the super_gradients library that provides the YOLO-NAS implementation. This makes sure that training can use your GPU efficiently and that all dependencies are isolated from your other projects, which is critical for a smooth deep learning workflow.

Next, the code turns to the dataset. You’ll download an aquarium object detection dataset in YOLO format and organize it into train, valid, and test folders with separate images and labels directories. The script defines a dataset_params dictionary that tells YOLO-NAS where each split is located and what classes exist in the dataset: fish, jellyfish, penguin, puffin, shark, starfish, and stingray. This configuration is then passed into ready-made dataloader functions so the model can read images and labels automatically during training and evaluation.

The core training logic revolves around the Trainer object from SuperGradients and a YOLO-NAS-S model configured for the number of classes in your aquarium dataset. The code sets up training parameters such as learning rate schedule, optimizer, warmup, EMA, loss function, and evaluation metrics like mAP@0.50. When you call trainer.train, YOLO-NAS starts learning to detect underwater objects from your custom images, saving checkpoints as it goes. This is the part where your generic pretrained model becomes a specialist in aquarium scenes.

Finally, the last section of the code shows how to load the best saved checkpoint and use it for inference. You create a new Trainer, reload the best YOLO-NAS weights, and evaluate the model on the test split to see its metrics. Then, using OpenCV, you read a specific jellyfish or starfish image, resize it, and run best_model.predict to draw bounding boxes and labels. This final step demonstrates the real goal of the whole script: taking a trained detector and using it to find underwater animals in brand-new images, ready for demos, dashboards, or integration into your own applications.

Link to the video tutorial : https://youtu.be/C867NmFBl40

Code for the tutorial : https://eranfeit.lemonsqueezy.com/buy/38b2fd63-6c9b-4878-9c0a-54378def92de or https://ko-fi.com/s/297688e915

Link to the dataset : https://www.kaggle.com/datasets/slavkoprytula/aquarium-data-cots

Link for Medium users : https://medium.com/@feitgemel/how-to-train-yolo-nas-on-custom-dataset-aquarium-c92987c33be2

You can follow my blog here : https://eranfeit.net/blog/

 Want to get started with Computer Vision or take your skills to the next level ?

If you’re just beginning, I recommend this step-by-step course designed to introduce you to the foundations of Computer Vision – Complete Computer Vision Bootcamp With PyTorch & TensorFlow

If you’re already experienced and looking for more advanced techniques, check out this deep-dive course – Modern Computer Vision GPT, PyTorch, Keras, OpenCV4

How to Train YOLO-NAS on Custom Aquarium Dataset

Training YOLO-NAS on a custom dataset is a great way to move from “generic object detection” to a model that truly understands your world.
In this tutorial, we’re going to train YOLO-NAS on a custom aquarium dataset that contains underwater images of fish, jellyfish, penguins, puffins, sharks, starfish, and stingrays.

Instead of relying only on COCO-style categories, you’ll learn how to train YOLO-NAS on custom dataset images that come from an underwater or aquarium setting.
That means your final model will be able to pick out specific marine animals in your own photos and experiments, not just generic animals in benchmark datasets.

We’ll walk through the full pipeline step by step:

• Creating a clean Conda environment with the right PyTorch + CUDA stack
• Installing the super_gradients library that ships YOLO-NAS
• Preparing the aquarium dataset in YOLO format
• Training YOLO-NAS on your custom classes
• Evaluating the model and running predictions on new underwater images

All the code is broken into parts so you can copy and paste each block into your WordPress post and into your editor.
For every Python command, you’ll see a short explanation above it so readers can follow along even if they’re new to YOLO-NAS.

Setting up a clean YOLO-NAS environment with Conda

Before you can train YOLO-NAS on a custom dataset, you need a stable Python environment.
Using Conda keeps your YOLO-NAS aquarium project isolated from everything else on your machine and reduces version conflicts.

In this first code block, you will:

• Create and activate a Conda environment called Yolo-nas1
• Check which CUDA version is available
• Install PyTorch 2.1.1 with CUDA 11.8
• Install super_gradients and IPython for experiments

Once this environment is working, you can focus entirely on train yolo nas on custom dataset logic without wrestling with drivers and dependencies.

### Create a new Conda environment named "Yolo-nas1" with Python 3.8.
conda create --name Yolo-nas1 python=3.8

### Activate the Conda environment so the rest of the setup runs in isolation.
conda activate Yolo-nas1

### Check which CUDA toolkit version is available on your system.
nvcc --version

### Install PyTorch, TorchVision, Torchaudio, and CUDA 11.8 from the official Conda channels.
conda install pytorch==2.1.1 torchvision==0.16.1 torchaudio==2.1.1 pytorch-cuda=11.8 -c pytorch -c nvidia

### Install the SuperGradients library that ships the YOLO-NAS models.
pip install super_gradients

### Install IPython so you can experiment interactively inside the same environment.
pip install IPython

After running these commands, you have a clean, GPU-ready environment dedicated to YOLO-NAS.
If something fails here (CUDA mismatch, missing driver, etc.), fix it now — it’s much easier to debug environment issues before you start training.

Download the dataset :

The Dataset should be in YoloV format !!!!!

Link for the dataset : https://www.kaggle.com/datasets/slavkoprytula/aquarium-data-cots

Training YOLO-NAS on the custom aquarium dataset

Now we move into the heart of the tutorial: training YOLO-NAS on your aquarium dataset.
The dataset should already be in YOLO format, with train, valid, and test splits, each containing images and labels folders.
This script wires everything together: dataloaders, model, loss, metrics, and the training loop managed by SuperGradients’ Trainer.

The goal of this block is to produce a trained YOLO-NAS model that understands underwater objects like fish, jellyfish, and sharks in your dataset.
You can save this as something like train_yolo_nas_aquarium.py and run it inside the Yolo-nas1 environment.

### Import OpenCV for optional image operations or debugging visualizations.
import cv2

### Import the SuperGradients models module so we can build and load YOLO-NAS architectures.
from super_gradients.training import models

### Import the Models enum in case you want to refer to predefined model names.
from super_gradients.common.object_names import Models

### Import the Trainer class which handles the full training loop for YOLO-NAS.
from super_gradients.training import Trainer

### Import freeze_support to make multiprocessing work correctly on Windows.
from multiprocessing import freeze_support

### Import the dataloaders module which contains helpers for YOLO-format COCO loaders.
from super_gradients.training import dataloaders

### Import the YOLO-format COCO train and validation dataloader builders.
from super_gradients.training.dataloaders.dataloaders import coco_detection_yolo_format_train, coco_detection_yolo_format_val

### Import the PPYoloELoss which is used as the detection loss for YOLO-NAS training.
from super_gradients.training.losses import PPYoloELoss

### Import the DetectionMetrics_050 metric to monitor mAP at IoU 0.50 during validation.
from super_gradients.training.metrics import DetectionMetrics_050

### Import the post-prediction callback that applies NMS and thresholding for PP-YOLO-E style models.
from super_gradients.training.models.detection_models.pp_yolo_e import PPYoloEPostPredictionCallback


### Only run the training code when this script is executed directly.
if __name__ == '__main__':
    ### Enable freeze_support so dataloader workers and multiprocessing behave correctly on Windows.
    freeze_support()

    ### Define the folder where YOLO-NAS will write checkpoints and training artifacts.
    CHECKPOINT_DIR = "C:/Data-sets/aquarium_pretrain/checkpoints"

    ### Create a Trainer instance that will manage the full training and validation loop.
    trainer = Trainer(experiment_name="my_custom_yolo-nas", ckpt_root_dir=CHECKPOINT_DIR)

    ### Define the root path of your aquarium dataset on disk.
    data_root = "C:/Data-sets/aquarium_pretrain"

    ### Collect all dataset paths and class names into a single configuration dictionary.
    dataset_params = {
        'data_dir': data_root,
        'train_images_dir': 'train/images',
        'train_labels_dir': 'train/labels',
        'val_images_dir': 'valid/images',
        'val_labels_dir': 'valid/labels',
        'test_images_dir': 'test/images',
        'test_labels_dir': 'test/labels',
        'classes': ['fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', 'stingray']
    }

    ### Build the YOLO-format training dataloader for the aquarium dataset.
    train_data = coco_detection_yolo_format_train(
        dataset_params={
            'data_dir': dataset_params['data_dir'],
            'images_dir': dataset_params['train_images_dir'],
            'labels_dir': dataset_params['train_labels_dir'],
            'classes': dataset_params['classes']
        },
        dataloader_params={
            'batch_size': 32,
            'num_workers': 2
        }
    )

    ### Build the YOLO-format validation dataloader for monitoring mAP during training.
    val_data = coco_detection_yolo_format_val(
        dataset_params={
            'data_dir': dataset_params['data_dir'],
            'images_dir': dataset_params['val_images_dir'],
            'labels_dir': dataset_params['val_labels_dir'],
            'classes': dataset_params['classes']
        },
        dataloader_params={
            'batch_size': 32,
            'num_workers': 2
        }
    )

    ### Build the YOLO-format test dataloader that we will later use for evaluation.
    test_data = coco_detection_yolo_format_val(
        dataset_params={
            'data_dir': dataset_params['data_dir'],
            'images_dir': dataset_params['test_images_dir'],
            'labels_dir': dataset_params['test_labels_dir'],
            'classes': dataset_params['classes']
        },
        dataloader_params={
            'batch_size': 32,
            'num_workers': 2
        }
    )

    ### Create the YOLO-NAS small model configured for the number of aquarium classes.
    model = models.get(
        'yolo_nas_s',
        num_classes=len(dataset_params['classes']),
        pretrained_weights="coco"
    )

    ### Define the full set of hyperparameters and training options for YOLO-NAS.
    train_params = {
        "average_best_models": True,
        "warmup_mode": "linear_epoch_step",
        "warmup_initial_lr": 1e-6,
        "lr_warmup_epochs": 3,
        "initial_lr": 5e-4,
        "lr_mode": "cosine",
        "cosine_final_lr_ratio": 0.1,
        "optimizer": "Adam",
        "optimizer_params": {"weight_decay": 0.0001},
        "zero_weight_decay_on_bias_and_bn": True,
        "ema": True,
        "ema_params": {"decay": 0.9, "decay_type": "threshold"},
        "max_epochs": 100,
        "mixed_precision": True,
        "loss": PPYoloELoss(
            use_static_assigner=False,
            num_classes=len(dataset_params['classes']),
            reg_max=16
        ),
        "valid_metrics_list": [
            DetectionMetrics_050(
                score_thres=0.1,
                top_k_predictions=300,
                num_cls=len(dataset_params['classes']),
                normalize_targets=True,
                post_prediction_callback=PPYoloEPostPredictionCallback(
                    score_threshold=0.01,
                    nms_top_k=1000,
                    max_predictions=300,
                    nms_threshold=0.7
                )
            )
        ],
        "metric_to_watch": "mAP@0.50"
    }

    ### Launch the YOLO-NAS training loop on the aquarium dataset.
    trainer.train(
        model=model,
        training_params=train_params,
        train_loader=train_data,
        valid_loader=val_data
    )

This script gives you a full training pipeline for YOLO-NAS on a custom aquarium dataset.
You can tune batch_size, max_epochs, learning rate, and the list of classes to match your own underwater or ocean images.

Evaluating the model and running underwater predictions

Once training is finished, you’ll want to see how well the model generalizes to new images.
This script does two things:

1. Evaluates the trained YOLO-NAS checkpoint on the test split and prints mAP-style metrics
2. Runs a prediction on a single underwater image (for example, a jellyfish photo) and shows the results

This is the part that really “sells” the project to readers — they see how the model turns raw underwater images into labeled bounding boxes.
You can save this as test_yolo_nas_aquarium.py and run it in the same environment.

Here are the test images :

### Import OpenCV for loading and resizing underwater test images.
import cv2

### Import SuperGradients models so we can reload the trained YOLO-NAS checkpoint.
from super_gradients.training import models

### Import the YOLO-format dataloader builder for creating a test loader.
from super_gradients.training.dataloaders.dataloaders import coco_detection_yolo_format_val

### Import the Trainer again to reuse its testing utility.
from super_gradients.training import Trainer

### Import the detection loss class used during training so metrics stay compatible.
from super_gradients.training.losses import PPYoloELoss

### Import the DetectionMetrics_050 class to evaluate mAP on the test set.
from super_gradients.training.metrics import DetectionMetrics_050

### Import the PPYoloEPostPredictionCallback for consistent post-processing.
from super_gradients.training.models.detection_models.pp_yolo_e import PPYoloEPostPredictionCallback

### Import the multiprocessing module to keep Windows-safe entry points.
import multiprocessing


### Define the main entry point for evaluation and prediction.
def main():
    ### Recreate the same dataset configuration dictionary used during training.
    dataset_params = {
        'data_dir': 'C:/Data-sets/aquarium_pretrain',
        'train_images_dir': 'train/images',
        'train_labels_dir': 'train/labels',
        'val_images_dir': 'valid/images',
        'val_labels_dir': 'valid/labels',
        'test_images_dir': 'test/images',
        'test_labels_dir': 'test/labels',
        'classes': ['fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', 'stingray']
    }

    ### Build the YOLO-format test dataloader for the aquarium test split.
    test_data = coco_detection_yolo_format_val(
        dataset_params={
            'data_dir': dataset_params['data_dir'],
            'images_dir': dataset_params['test_images_dir'],
            'labels_dir': dataset_params['test_labels_dir'],
            'classes': dataset_params['classes']
        },
        dataloader_params={
            'batch_size': 32,
            'num_workers': 2
        }
    )

    ### Define the same checkpoint root directory used during training.
    CHECKPOINT_DIR = "C:/Data-sets/aquarium_pretrain/checkpoints"

    ### Create a Trainer instance bound to the aquarium experiment checkpoints.
    trainer = Trainer(experiment_name="my_custom_yolo-nas", ckpt_root_dir=CHECKPOINT_DIR)

    ### Point to the best YOLO-NAS checkpoint that you want to evaluate and use for inference.
    best_weights = "C:/Data-sets/aquarium_pretrain/checkpoints/my_custom_yolo-nas/RUN_20240809_115703_065907/ckpt_best.pth"

    ### Load the trained YOLO-NAS small model from the best checkpoint.
    best_model = models.get(
        'yolo_nas_s',
        num_classes=len(dataset_params['classes']),
        checkpoint_path=best_weights
    )

    ### Evaluate the trained model on the full aquarium test set.
    result = trainer.test(
        model=best_model,
        test_loader=test_data,
        test_metrics_list=DetectionMetrics_050(
            score_thres=0.2,
            top_k_predictions=300,
            num_cls=len(dataset_params['classes']),
            normalize_targets=True,
            post_prediction_callback=PPYoloEPostPredictionCallback(
                score_threshold=0.01,
                nms_top_k=1000,
                max_predictions=300,
                nms_threshold=0.7
            )
        )
    )

    ### Print the evaluation metrics dictionary so you can inspect mAP and other scores.
    print(result)

    ### Define the path to a sample jellyfish image for single-image prediction.
    jellyfish = "Best-Object-Detection-models/Yolo-Nas/Yolo-Nas-Under-Water-Dataset/JellyFish.jpg"

    ### Define the path to a sample starfish image that you can also test later if you like.
    starfish = "Best-Object-Detection-models/Yolo-Nas/Yolo-Nas-Under-Water-Dataset/StarFish2.jpg"

    ### Read the jellyfish image from disk using OpenCV in BGR format.
    img = cv2.imread(jellyfish)

    ### Convert the BGR image into RGB format expected by the YOLO-NAS model.
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

    ### Set the percentage scaling factor for resizing the original image.
    scale_percent = 20

    ### Compute the new width based on the scaling factor.
    width = int(img.shape[1] * scale_percent / 100)

    ### Compute the new height based on the scaling factor.
    height = int(img.shape[0] * scale_percent / 100)

    ### Create a tuple with the new width and height.
    dim = (width, height)

    ### Resize the image to the new dimensions to speed up inference.
    img = cv2.resize(img, dim, interpolation=cv2.INTER_AREA)

    ### Run YOLO-NAS prediction on the resized RGB image.
    predict_results = best_model.predict(img)

    ### Print the raw prediction object to the console for debugging.
    print(predict_results)

    ### Use the built-in visualization helper to show detections in a pop-up window.
    predict_results.show()


### Ensure the main() function runs only when this script is executed directly.
if __name__ == "__main__":
    ### Activate freeze_support for safe multiprocessing on Windows.
    multiprocessing.freeze_support()

    ### Call the main() function to evaluate and run predictions with the trained model.
    main()

With this block, your readers can both evaluate the trained YOLO-NAS model on the full test set and visually inspect predictions on individual underwater images.
That closes the loop from “raw dataset in YOLO format” to “working underwater detector you can demo and extend.”

FAQ: Training YOLO-NAS on a Custom Aquarium Dataset

Conclusion

Training YOLO-NAS on a custom aquarium dataset is a practical way to turn modern object detection theory into something visual and tangible.
By preparing your underwater images in YOLO format, defining clear classes like fish, jellyfish, and sharks, and wiring them into SuperGradients’ training loop, you get a model that understands your specific marine world instead of generic benchmark images.

In this post, you set up a dedicated Conda environment, installed a compatible PyTorch and CUDA stack, and brought in the super_gradients library.
From there, you built dataloaders for the aquarium dataset, configured a YOLO-NAS small model, and trained it with a mix of warmup, cosine learning rate scheduling, EMA, and a PP-YOLO-E style loss and metrics setup.
This gives readers a full, copy-paste pipeline they can adapt whenever they need to train yolo nas on custom dataset projects in the future.

You then evaluated the model on a test split and ran predictions on individual underwater images to verify performance.
Seeing bounding boxes appear around jellyfish and starfish is not just satisfying — it’s the feedback loop you need to decide whether to collect more data, tweak hyperparameters, or refine your labels.
From here, it’s easy to extend the pipeline to new underwater datasets, live video streams, or even completely different domains like medical imaging or industrial inspection.

The key takeaway is that once you understand how to structure your data, configure YOLO-NAS, and read the training metrics, you can reuse this template again and again.
Whether you’re building an educational demo, a research prototype, or the first version of a production system, this aquarium project gives you a solid foundation to build on.

Connect :

☕ Buy me a coffee — https://ko-fi.com/eranfeit

🖥️ Email : feitgemel@gmail.com

🌐 https://eranfeit.net

🤝 Fiverr : https://www.fiverr.com/s/mB3Pbb

Enjoy,

Eran