! nvidia-smi -L

GPU 0: Tesla P100-PCIE-16GB (UUID: GPU-3dddfc79-2c0c-27e4-d184-5901b2865f53)

%%time
! pip install --upgrade ultralytics -qq

CPU times: user 143 ms, sys: 34.9 ms, total: 178 ms
Wall time: 12.6 s

import ultralytics
print(ultralytics.__version__)

8.2.18

import warnings
warnings.filterwarnings("ignore")


import re
import glob
import random
import yaml
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
import seaborn as sns

import IPython.display as display
from PIL import Image
import cv2

from ultralytics import YOLO

class CFG:
    DEBUG = False
    FRACTION = 0.05 if DEBUG else 1.0
    SEED = 88

    # classes
    CLASSES = ['no-pcos', 'pcos']
    NUM_CLASSES_TO_TRAIN = len(CLASSES)

    # training
    EPOCHS = 3 if DEBUG else 10 # 100
    BATCH_SIZE = 4
    
    BASE_MODEL = 'yolov8x' # yolov8n, yolov8s, yolov8m, yolov8l, yolov8x, yolov9c, yolov9e, yolo_nas_s, yolo_nas_m, yolo_nas_l
    BASE_MODEL_WEIGHTS = f'{BASE_MODEL}.pt'
    EXP_NAME = f'yolov8x{EPOCHS}_epochs'
    
    OPTIMIZER = 'Adam' # SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto
    LR = 1e-5
    LR_FACTOR = 0.001
    WEIGHT_DECAY = 0.0005
    DROPOUT = 0.2
    PATIENCE = 10
    PROFILE = False
    LABEL_SMOOTHING = 0.0    

    # paths
    CUSTOM_DATASET_DIR = '/kaggle/input/pcos234'
    OUTPUT_DIR = './'

dict_file = {
    'train': os.path.join(CFG.CUSTOM_DATASET_DIR, 'train'),
    'val': os.path.join(CFG.CUSTOM_DATASET_DIR, 'valid'),
    'test': os.path.join(CFG.CUSTOM_DATASET_DIR, 'test'),
    'nc': CFG.NUM_CLASSES_TO_TRAIN,
    'names': CFG.CLASSES
    }

with open(os.path.join(CFG.OUTPUT_DIR, 'data.yaml'), 'w+') as file:
    yaml.dump(dict_file, file)

### read yaml file created
def read_yaml_file(file_path = CFG.CUSTOM_DATASET_DIR):
    with open(file_path, 'r') as file:
        try:
            data = yaml.safe_load(file)
            return data
        except yaml.YAMLError as e:
            print("Error reading YAML:", e)
            return None

### print it with newlines
def print_yaml_data(data):
    formatted_yaml = yaml.dump(data, default_style=False)
    print(formatted_yaml)

file_path = os.path.join(CFG.OUTPUT_DIR, 'data.yaml')
yaml_data = read_yaml_file(file_path)

if yaml_data:
    print_yaml_data(yaml_data)

names:
- no-pcos
- pcos
nc: 2
test: /kaggle/input/pcos234/test
train: /kaggle/input/pcos234/train
val: /kaggle/input/pcos234/valid

def display_image(image, print_info = True, hide_axis = False):
    if isinstance(image, str):  # Check if it's a file path
        img = Image.open(image)
        plt.imshow(img)
    elif isinstance(image, np.ndarray):  # Check if it's a NumPy array
        image = image[..., ::-1]  # BGR to RGB
        img = Image.fromarray(image)
        plt.imshow(img)
    else:
        raise ValueError("Unsupported image format")

    if print_info:
        print('Type: ', type(img), '\n')
        print('Shape: ', np.array(img).shape, '\n')

    if hide_axis:
        plt.axis('off')

    plt.show()

example_image_path = '/kaggle/input/pcos234/train/images/img_0_1033_jpg.rf.e837430c9bd50f29559ffa3eb5b938ef.jpg'
display_image(example_image_path, print_info = True, hide_axis = False)

Type:  <class 'PIL.JpegImagePlugin.JpegImageFile'> 

Shape:  (224, 224, 3)

def get_image_properties(image_path):
    # Read the image file
    img = cv2.imread('/kaggle/input/pcos234/train/images/img_0_1033_jpg.rf.e837430c9bd50f29559ffa3eb5b938ef.jpg')

    # Check if the image file is read successfully
    if img is None:
        raise ValueError("Could not read image file")

    # Get image properties
    properties = {
        "width": img.shape[1],
        "height": img.shape[0],
        "channels": img.shape[2] if len(img.shape) == 3 else 1,
        "dtype": img.dtype,
    }

    return properties

img_properties = get_image_properties(example_image_path)
img_properties

{'width': 224, 'height': 224, 'channels': 3, 'dtype': dtype('uint8')}

%%time
class_idx = {str(i): CFG.CLASSES[i] for i in range(CFG.NUM_CLASSES_TO_TRAIN)}

class_stat = {}
data_len = {}
class_info = []

for mode in ['train', 'valid', 'test']:
    class_count = {CFG.CLASSES[i]: 0 for i in range(CFG.NUM_CLASSES_TO_TRAIN)}

    path = os.path.join(CFG.CUSTOM_DATASET_DIR, mode, 'labels')

    for file in os.listdir(path):
        with open(os.path.join(path, file)) as f:
            lines = f.readlines()

            for cls in set([line[0] for line in lines]):
                class_count[class_idx[cls]] += 1

    data_len[mode] = len(os.listdir(path))
    class_stat[mode] = class_count

    class_info.append({'Mode': mode, **class_count, 'Data_Volume': data_len[mode]})

dataset_stats_df = pd.DataFrame(class_info)
dataset_stats_df

CPU times: user 13 ms, sys: 8.78 ms, total: 21.8 ms
Wall time: 165 ms

# Create subplots with 1 row and 3 columns
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# Plot vertical bar plots for each mode in subplots
for i, mode in enumerate(['train', 'valid', 'test']):
    sns.barplot(
        data=dataset_stats_df[dataset_stats_df['Mode'] == mode].drop(columns='Mode'),
        orient='v',
        ax=axes[i],
        palette='Set2'
    )
    
    axes[i].set_title(f'{mode.capitalize()} Class Statistics')
    axes[i].set_xlabel('Classes')
    axes[i].set_ylabel('Count')
    axes[i].tick_params(axis='x', rotation=90) 

    # Add annotations on top of each bar
    for p in axes[i].patches:
        axes[i].annotate(f"{int(p.get_height())}", (p.get_x() + p.get_width() / 2., p.get_height()),
                         ha='center', va='center', fontsize=8, color='black', xytext=(0, 5),
                         textcoords='offset points')

plt.tight_layout()
plt.show()

%%time

for mode in ['train', 'valid', 'test']:
    print(f'\nImage sizes in {mode} set:')

    img_size = 0
    for file in glob.glob(os.path.join(CFG.CUSTOM_DATASET_DIR, mode, 'images', '*')):

        image = Image.open(file)

        if image.size != img_size:
            print(f'{image.size}')
            img_size = image.size
            print('\n')

Image sizes in train set:
(224, 224)


Image sizes in valid set:
(224, 224)


Image sizes in test set:
(224, 224)


CPU times: user 29.9 ms, sys: 11.5 ms, total: 41.3 ms
Wall time: 134 ms

CFG.BASE_MODEL_WEIGHTS

'yolov8x.pt'

import torch
model = YOLO(CFG.BASE_MODEL_WEIGHTS)

device = 'cuda' if torch.cuda.is_available() else 'cpu'

print('Model: ', CFG.BASE_MODEL_WEIGHTS)
print('Epochs: ', CFG.EPOCHS)
print('Batch: ', CFG.BATCH_SIZE)

Model:  yolov8x.pt
Epochs:  10
Batch:  4

model = YOLO(CFG.BASE_MODEL_WEIGHTS)

%%time

### train
model.train(
    data=os.path.join(CFG.OUTPUT_DIR, 'data.yaml'),
    task='detect',
    imgsz=(img_properties['height'], img_properties['width']),
    epochs=CFG.EPOCHS,
    batch=CFG.BATCH_SIZE,
    optimizer=CFG.OPTIMIZER,
    lr0=CFG.LR,
    lrf=CFG.LR_FACTOR,
    weight_decay=CFG.WEIGHT_DECAY,
    dropout=CFG.DROPOUT,
    fraction=CFG.FRACTION,
    patience=CFG.PATIENCE,
    profile=CFG.PROFILE,
    label_smoothing=CFG.LABEL_SMOOTHING,
    name=f'{CFG.BASE_MODEL}_{CFG.EXP_NAME}',
    seed=CFG.SEED,
    val=True,
    amp=True,    
    exist_ok=True,
    resume=False,
    device=0, # Set to single GPU device
    verbose=False,
)

Ultralytics YOLOv8.2.18 🚀 Python-3.10.13 torch-2.1.2 CUDA:0 (Tesla P100-PCIE-16GB, 16276MiB)
engine/trainer: task=detect, mode=train, model=yolov8x.pt, data=./data.yaml, epochs=10, time=None, patience=10, batch=4, imgsz=(224, 224), save=True, save_period=-1, cache=False, device=0, workers=8, project=None, name=yolov8x_yolov8x10_epochs, exist_ok=True, pretrained=True, optimizer=Adam, verbose=False, seed=88, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.2, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=None, workspace=4, nms=False, lr0=1e-05, lrf=0.001, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs/detect/yolov8x_yolov8x10_epochs

2024-05-19 05:45:51,603	INFO util.py:124 -- Outdated packages:
  ipywidgets==7.7.1 found, needs ipywidgets>=8
Run `pip install -U ipywidgets`, then restart the notebook server for rich notebook output.
2024-05-19 05:45:52,198	INFO util.py:124 -- Outdated packages:
  ipywidgets==7.7.1 found, needs ipywidgets>=8
Run `pip install -U ipywidgets`, then restart the notebook server for rich notebook output.

Overriding model.yaml nc=80 with nc=2

                   from  n    params  module                                       arguments                     
  0                  -1  1      2320  ultralytics.nn.modules.conv.Conv             [3, 80, 3, 2]                 
  1                  -1  1    115520  ultralytics.nn.modules.conv.Conv             [80, 160, 3, 2]               
  2                  -1  3    436800  ultralytics.nn.modules.block.C2f             [160, 160, 3, True]           
  3                  -1  1    461440  ultralytics.nn.modules.conv.Conv             [160, 320, 3, 2]              
  4                  -1  6   3281920  ultralytics.nn.modules.block.C2f             [320, 320, 6, True]           
  5                  -1  1   1844480  ultralytics.nn.modules.conv.Conv             [320, 640, 3, 2]              
  6                  -1  6  13117440  ultralytics.nn.modules.block.C2f             [640, 640, 6, True]           
  7                  -1  1   3687680  ultralytics.nn.modules.conv.Conv             [640, 640, 3, 2]              
  8                  -1  3   6969600  ultralytics.nn.modules.block.C2f             [640, 640, 3, True]           
  9                  -1  1   1025920  ultralytics.nn.modules.block.SPPF            [640, 640, 5]                 
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 12                  -1  3   7379200  ultralytics.nn.modules.block.C2f             [1280, 640, 3]                
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 15                  -1  3   1948800  ultralytics.nn.modules.block.C2f             [960, 320, 3]                 
 16                  -1  1    922240  ultralytics.nn.modules.conv.Conv             [320, 320, 3, 2]              
 17            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 18                  -1  3   7174400  ultralytics.nn.modules.block.C2f             [960, 640, 3]                 
 19                  -1  1   3687680  ultralytics.nn.modules.conv.Conv             [640, 640, 3, 2]              
 20             [-1, 9]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 21                  -1  3   7379200  ultralytics.nn.modules.block.C2f             [1280, 640, 3]                
 22        [15, 18, 21]  1   8719894  ultralytics.nn.modules.head.Detect           [2, [320, 640, 640]]          
Model summary: 365 layers, 68154534 parameters, 68154518 gradients, 258.1 GFLOPs

Transferred 589/595 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir runs/detect/yolov8x_yolov8x10_epochs', view at http://localhost:6006/

wandb: Currently logged in as: akshitagupta15june (iiitpune-akshita). Use `wandb login --relogin` to force relogin

Freezing layer 'model.22.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks with YOLOv8n...
AMP: checks passed ✅
WARNING ⚠️ updating to 'imgsz=224'. 'train' and 'val' imgsz must be an integer, while 'predict' and 'export' imgsz may be a [h, w] list or an integer, i.e. 'yolo export imgsz=640,480' or 'yolo export imgsz=640'

train: Scanning /kaggle/input/pcos234/train/labels... 164 images, 0 backgrounds, 0 corrupt: 100%|██████████| 164/164 [00:00<00:00, 993.40it/s]

train: WARNING ⚠️ Cache directory /kaggle/input/pcos234/train is not writeable, cache not saved.

albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))

val: Scanning /kaggle/input/pcos234/valid/labels... 23 images, 0 backgrounds, 0 corrupt: 100%|██████████| 23/23 [00:00<00:00, 835.16it/s]

img_properties
# Export the model
model.export(
    format = 'onnx', # openvino, onnx, engine, tflite
    imgsz = (img_properties['height'], img_properties['width']),
    half = False,
    int8 = False,
    simplify = False,
    nms = False,
)
results_paths = [
    i for i in
    glob.glob(f'{CFG.OUTPUT_DIR}runs/detect/{CFG.BASE_MODEL}_{CFG.EXP_NAME}/*.png') +
    glob.glob(f'{CFG.OUTPUT_DIR}runs/detect/{CFG.BASE_MODEL}_{CFG.EXP_NAME}/*.jpg')
    if 'batch' not in i
]

results_paths
%matplotlib inline
# Loading the best performing model
model = YOLO('/kaggle/working/runs/detect/yolov8x_yolov8x10_epochs/weights/best.pt')

metrics = model.val(data='/kaggle/working/data.yaml', split = 'test')

Ultralytics YOLOv8.2.18 🚀 Python-3.10.13 torch-2.1.2 CUDA:0 (Tesla P100-PCIE-16GB, 16276MiB)
Model summary (fused): 268 layers, 68125494 parameters, 0 gradients, 257.4 GFLOPs

PyTorch: starting from 'runs/detect/yolov8x_yolov8x10_epochs/weights/best.pt' with input shape (1, 3, 224, 224) BCHW and output shape(s) (1, 6, 1029) (130.3 MB)

ONNX: starting export with onnx 1.16.0 opset 17...
ONNX: export success ✅ 4.0s, saved as 'runs/detect/yolov8x_yolov8x10_epochs/weights/best.onnx' (260.0 MB)

Export complete (5.2s)
Results saved to /kaggle/working/runs/detect/yolov8x_yolov8x10_epochs/weights
Predict:         yolo predict task=detect model=runs/detect/yolov8x_yolov8x10_epochs/weights/best.onnx imgsz=224  
Validate:        yolo val task=detect model=runs/detect/yolov8x_yolov8x10_epochs/weights/best.onnx imgsz=224 data=./data.yaml  
Visualize:       https://netron.app
Ultralytics YOLOv8.2.18 🚀 Python-3.10.13 torch-2.1.2 CUDA:0 (Tesla P100-PCIE-16GB, 16276MiB)
Model summary (fused): 268 layers, 68125494 parameters, 0 gradients, 257.4 GFLOPs

val: Scanning /kaggle/input/pcos234/test/labels... 47 images, 0 backgrounds, 0 corrupt: 100%|██████████| 47/47 [00:00<00:00, 1084.20it/s]

val: WARNING ⚠️ Cache directory /kaggle/input/pcos234/test is not writeable, cache not saved.

                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:01<00:00,  2.13it/s]

                   all         47         47      0.855      0.855      0.929      0.656
               no-pcos         47         27      0.884          1      0.987      0.756
                  pcos         47         20      0.826       0.71       0.87      0.556
Speed: 0.0ms preprocess, 15.9ms inference, 0.0ms loss, 9.5ms postprocess per image
Results saved to runs/detect/val2

example_image_path = '/kaggle/working/runs/detect/yolov8x_yolov8x10_epochs/val_batch1_pred.jpg'
display_image(example_image_path)

Type:  <class 'PIL.JpegImagePlugin.JpegImageFile'> 

Shape:  (768, 768, 3)

# Import the necessary libraries
from ultralytics import YOLO
import matplotlib.pyplot as plt
import cv2

# Load the best performing model
model = YOLO('/kaggle/working/runs/detect/yolov8x_yolov8x10_epochs/weights/best.pt')

# Path to your test image
image_path = '/kaggle/input/pcos234/test/images/pco_4_jpg.rf.6fd0a62e06a0a87288a6b4c754b40d53.jpg'

# Run inference on the single image
results = model.predict(source=image_path, save=False, show=False)

# Get the first result (assuming one image)
result = results[0]

# Convert the result to an OpenCV image
result_image = result.plot()

# Convert BGR image to RGB for displaying with Matplotlib
result_image_rgb = cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB)

# Display the image with detections
plt.imshow(result_image_rgb)
plt.axis('off')  # Hide axes
plt.show()

image 1/1 /kaggle/input/pcos234/test/images/pco_4_jpg.rf.6fd0a62e06a0a87288a6b4c754b40d53.jpg: 224x224 1 pcos, 17.8ms
Speed: 0.5ms preprocess, 17.8ms inference, 3.0ms postprocess per image at shape (1, 3, 224, 224)

# Import the necessary libraries
from ultralytics import YOLO
import matplotlib.pyplot as plt
import cv2

# Load the best performing model
model = YOLO('/kaggle/working/runs/detect/yolov8x_yolov8x10_epochs/weights/best.pt')

# Path to your test image
image_path = '/kaggle/input/pcos234/test/images/pco_8_jpg.rf.915e3e663ddde584151479ff93aae822.jpg'

# Run inference on the single image
results = model.predict(source=image_path, save=False, show=False)

# Get the first result (assuming one image)
result = results[0]

# Convert the result to an OpenCV image
result_image = result.plot()

# Convert BGR image to RGB for displaying with Matplotlib
result_image_rgb = cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB)

# Display the image with detections
plt.imshow(result_image_rgb)
plt.axis('off')  # Hide axes
plt.show()

image 1/1 /kaggle/input/pcos234/test/images/pco_8_jpg.rf.915e3e663ddde584151479ff93aae822.jpg: 224x224 1 pcos, 14.5ms
Speed: 0.6ms preprocess, 14.5ms inference, 1.3ms postprocess per image at shape (1, 3, 224, 224)

# Import the necessary libraries
from ultralytics import YOLO
import matplotlib.pyplot as plt
import cv2

# Load the best performing model
model = YOLO('/kaggle/working/runs/detect/yolov8x_yolov8x10_epochs/weights/best.pt')

# Path to your test image
image_path = '/kaggle/input/pcos234/test/images/img_0_114_jpg.rf.ea6075be6764b1f5920d5d9453a13a27.jpg'

# Run inference on the single image
results = model.predict(source=image_path, save=False, show=False)

# Get the first result (assuming one image)
result = results[0]

# Convert the result to an OpenCV image
result_image = result.plot()

# Convert BGR image to RGB for displaying with Matplotlib
result_image_rgb = cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB)

# Display the image with detections
plt.imshow(result_image_rgb)
plt.axis('off')  # Hide axes
plt.show()

image 1/1 /kaggle/input/pcos234/test/images/img_0_114_jpg.rf.ea6075be6764b1f5920d5d9453a13a27.jpg: 224x224 1 no-pcos, 14.5ms
Speed: 0.4ms preprocess, 14.5ms inference, 1.3ms postprocess per image at shape (1, 3, 224, 224)

from IPython.display import Image

# Path to the image
image_path = '/kaggle/working/runs/detect/yolov8x_yolov8x10_epochs/val_batch1_pred.jpg'

# Display the image
Image(filename=image_path)

from nbformat import read, write

with open("your_notebook.ipynb", "r", encoding="utf-8") as f:
    nb = read(f, as_version=4)

for cell in nb.cells:
    if cell.cell_type == "code":
        cell.outputs = []

with open("your_notebook.ipynb", "w", encoding="utf-8") as f:
    write(nb, f)

lr/pg0	█▅▁▁▁▁▁▁▁▁
lr/pg1	▃▆█▇▆▅▄▃▂▁
lr/pg2	▃▆█▇▆▅▄▃▂▁
metrics/mAP50(B)	▁▆████████
metrics/mAP50-95(B)	▁▅▇▇██████
metrics/precision(B)	▁▃▇███████
metrics/recall(B)	▁▄▆▅▇█████
model/GFLOPs	▁
model/parameters	▁
model/speed_PyTorch(ms)	▁
train/box_loss	█▄▃▂▂▂▁▂▂▁
train/cls_loss	█▄▃▂▂▁▁▁▁▁
train/dfl_loss	█▄▂▂▁▂▂▁▁▁
val/box_loss	█▄▃▃▃▂▃▂▁▁
val/cls_loss	█▄▂▂▁▁▁▁▁▁
val/dfl_loss	█▆▄▄▃▂▃▂▁▁

lr/pg0	0.0
lr/pg1	0.0
lr/pg2	0.0
metrics/mAP50(B)	0.995
metrics/mAP50-95(B)	0.76445
metrics/precision(B)	0.96791
metrics/recall(B)	1.0
model/GFLOPs	258.128
model/parameters	68154534
model/speed_PyTorch(ms)	12.001
train/box_loss	0.88165
train/cls_loss	0.62319
train/dfl_loss	1.37602
val/box_loss	0.91086
val/cls_loss	0.65577
val/dfl_loss	1.44876

Run history:

Run summary: