2. Overview of YOLOv12 Custom Dataset for Brain Tumor Detection

Preparing a custom dataset is a critical step in training the YOLOv12 model for brain tumor detection. It involves gathering, labeling, and preprocessing medical images to ensure the model learns to identify tumors accurately. Here's a step-by-step overview of the process:

1. Data Collection

• Medical imaging datasets, including MRI (Magnetic Resonance Imaging) or CT (Computed Tomography) scans, are collected from reliable sources such as hospitals, research institutions, or publicly available datasets.
• Ensuring diversity in data is essential to improve model generalization, covering different tumor types, sizes, and positions.

3. Preparing Our Custom Dataset from Roboflow

Dataset Structure

A well-organized directory structure is maintained for seamless model training, typically resembling:

        
            /dataset
            │
            ├── images
            │   ├── train
            │   ├── val
            │   └── test
            ├── labels
            │   ├── train
            │   ├── val
            │   └── test
            └── data.yaml
        
    

The dataset is systematically organized into three primary folders, each playing a crucial role in the model development process:

• Train: Contains the majority of images and corresponding annotations for model training.
• Validation (Val): Used to fine-tune model hyperparameters and prevent overfitting.
• Test: Reserved for evaluating the final performance of the trained model.
• The data.yaml file contains paths to the datasets, class names, and other configuration details required for YOLOv12 training.

With a properly prepared dataset, the YOLOv12 model can be efficiently trained to detect brain tumors, contributing to faster and more accurate diagnoses in medical imaging.

4. Upload Brain_tumor to Google MyDrive

4.1 Uploaded brain_tumor Folder to Google Drive under AI_demos folder:

The uploaded brain_tumor folder contains test, train and val folders including data.yaml file.

1. Right click inside workspace AI_demos folder
2. Click: more
3. Click: Google Colaboratory

5.2 Rename Google Colab:

6. Why Use a T4 GPU on Google Colab Instead of a CPU?

Use of T4 GPU on Google Colab

Google Colab offers free access to GPUs like the NVIDIA T4, which is a powerful hardware accelerator specifically designed for deep learning tasks. Using a GPU instead of a CPU can dramatically improve the speed and efficiency of your machine learning workflows.

✅ Benefits of Using a T4 GPU on Google Colab

• Faster Training and Inference: GPUs can process large amounts of data in parallel, making them ideal for deep learning models.
• Free Access: Google Colab provides free GPU access, and users can upgrade to Colab Pro or Pro+ for longer usage and better resources.
• Efficient for Large Datasets: With up to 16GB memory, T4 GPUs handle complex models and large datasets efficiently.
• TensorFlow and PyTorch Support: Accelerate training using CUDA-enabled frameworks like TensorFlow and PyTorch.
• Easy Setup: Simply select Runtime → Change runtime type → GPU to connect a GPU in Colab.

❗ Drawbacks of Working with a Normal CPU

• Slow Processing: CPUs are slower for tasks involving large datasets and complex computations.
• Limited Cores and Memory: CPUs have fewer cores compared to GPUs, limiting their ability to handle parallel processing.
• Inefficient for Neural Networks: Neural networks rely heavily on matrix operations, which GPUs handle far better than CPUs.
• Resource Exhaustion: CPU memory may become insufficient when training large-scale models, leading to system crashes or slowdowns.

📌 Final Thoughts on GPU

For deep learning projects, using a T4 GPU on Google Colab is a game-changer. It significantly reduces training time, improves model accuracy with larger datasets, and provides a seamless experience for machine learning experiments. While CPUs are suitable for small-scale tasks, they are inefficient for advanced AI projects.

6.1 GPU Setting in Colab:

        
            GPU is available: True
            GPU name: Tesla T4
        
    

Output indicates that GPU is available.

        
            CODES to check GPU availability:

            import torch
            print("GPU is available:", torch.cuda.is_available())
            print("GPU name:", torch.cuda.get_device_name(0) if torch.cuda.is_available() else "No GPU found")
        
    

        
            Codes:

            from google.colab import drive
            drive.mount('/content/drive')
        
    

After mounting Google drive:

• Go to folder: AI_demos
• Clone YOLOV12 Repo
• Go to newly created yolov12 folder inside AI_demos folder.

            
                Codes:
                
                #Mount Google drive to colab cell
                from google.colab import drive
                drive.mount('/content/drive')

                %cd /content/drive/MyDrive/AI_demos

                #Clone yolov12 Repo
                !git clone https://github.com/sunsmarterjie/yolov12.git

                #Go to newly created yolov12 folder
                %cd yolov12
            
        

        
            CODES:
            
            #Codes to install
            wget https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.3/flash_attn-2.7.3+cu11torch2.2cxx11abiFALSE-cp311-cp311-linux_x86_64.whl
            conda create -n yolov12 python=3.11
            conda activate yolov12
            !pip install -r requirements.txt
            !pip install -e .
        
    

We shall have to install lines 1, 4 and 5 above in Colab Notebook cells. However, as we are worlikg in Google Colab environments in Google drive, codes in lines 2 and 3 are not needed. These two lines of codes are needed if we work in a local computer in a separate environment.

Displays that Flash_Attention installed

            
                CODES:
                
                #Ultralytics installation
                !pip install ultralytics
            
        

        
            YOLOV12 Clone Command:

            !git clone https://github.com/sunsmarterjie/yolov12.git
            %cd yolov12
        
    

7. YOLO Model Training Practical Implementation

    
        OUR MODIFIED CODES:
            
            from ultralytics import YOLO

            model = YOLO('ultralytics/cfg/models/v12/yolov12.yaml')

            # Train the yolo12 model forest_fire dataset
            results = model.train(
            data='/content/drive/My Drive/AI_demos/brain_tumor/data.yaml',
            epochs=25,  # Reduce to 25 epochs from 600 epocs to save time 
            batch=8,    # Reduce batch size (Try 16, 8, or even 4)
            imgsz=640,
            scale=0.5,
            mosaic=1.0,
            mixup=0.0,
            copy_paste=0.1,
            device="0",
            )
    

8. YOLO Model Custom Detection & Tests

Test the YOLO model to detect fire and smoke on an image named

        
            OUR CODES:

                from ultralytics import YOLO

                # Load the trained YOLO model using the correct path
                model_path = '/content/yolov12/runs/detect/train/weights/best.pt'
                print("File exists:", os.path.exists(model_path))

                # Load the model and run inference
                if os.path.exists(model_path):
                    model = YOLO(model_path)
                    results = model('/content/drive/MyDrive/AI_demos/brain_tumor99.png')
                    results[0].show()
                else:
                    print("Model file not found!")
        
    

Similarly we have testeg tumors on the following images:

• brain_tumor99.png
• oligodendroglioma-card.jpg
• brain_tumor2.png
• brain_tumor3.png
• brain_tumor4.png

After Training YOLOV12 Model, Brain Tumor Detection Results

The table showing images before and after tumor detections:

Serial	Images Before Tumor Detection	Images After Tumor Detection
1
2
3
4
5

Notes:

Using an online GPU, after training the YOLOv12 model with a custom dataset, it successfully detected 75% cases of Brain Tumors. This limitation is primarily due to insufficient training. While it was recommended to run the training for 600 epochs for optimal performance, we completed only 25 epochs to reduce training time. The process took approximately 0.531 hours. Based on this, running the full 600 epochs would require an estimated 12.75 hours using GPU.

However, without a GPU, using a normal CPU would significantly increase the training time. It would take about 9 hours to run 25 epochs. Therefore, completing 600 epochs would take approximately 216 hours, equivalent to about 9 days.

10. Conclusion

The YOLOv12 training on a custom dataset of brain tumor was completed. The model partially detected the brain tumor, but it could not detect all tumors due to insufficient training epochs. Further training with the recommended number of epochs or additional dataset augmentation may enhance brain tumor detection accuracy.