back to dummy model to check cpu

tasks/image.py

@@ -1,46 +1,22 @@
 from fastapi import APIRouter
-print(1)
 from datetime import datetime
-print(2)
 from datasets import load_dataset
-print(3)
 import numpy as np
-print(4)
 from sklearn.metrics import accuracy_score, precision_score, recall_score
-print(5)
 import random
-print(6)
 import os
-print(7)
-from ultralytics import YOLO
-print(8)
 
 from .utils.evaluation import ImageEvaluationRequest
-print(9)
 from .utils.emissions import tracker, clean_emissions_data, get_space_info
-print(10)
 
 from dotenv import load_dotenv
-print(11)
 load_dotenv()
-print(12)
 
 router = APIRouter()
-print(13)
 
-import torch
-
-# Get CUDA version (the one PyTorch was compiled with)
-print("CUDA version:", torch.version.cuda)
-
-# Get cuDNN version
-print("cuDNN version:", torch.backends.cudnn.version())
-
-#MODEL_TYPE = "YOLOv11n"
-DESCRIPTION = f"YOLOv11n 1280 not quantisized model with batch 1 inference on TensorRT"
-print(14)
+DESCRIPTION = "Random Baseline"
 ROUTE = "/image"
-print(15)
+
 def parse_boxes(annotation_string):
     """Parse multiple boxes from a single annotation string.
     Each box has 5 values: class_id, x_center, y_center, width, height"""
@@ -53,7 +29,7 @@ def parse_boxes(annotation_string):
             box = values[i+1:i+5]
             boxes.append(box)
     return boxes
-print(16)   
+
 def compute_iou(box1, box2):
     """Compute Intersection over Union (IoU) between two YOLO format boxes."""
     # Convert YOLO format (x_center, y_center, width, height) to corners
@@ -82,7 +58,7 @@ def compute_iou(box1, box2):
     union = box1_area + box2_area - intersection
     
     return intersection / (union + 1e-6)
-print(17)
+
 def compute_max_iou(true_boxes, pred_box):
     """Compute maximum IoU between a predicted box and all true boxes"""
     max_iou = 0
@@ -90,17 +66,7 @@ def compute_max_iou(true_boxes, pred_box):
         iou = compute_iou(true_box, pred_box)
         max_iou = max(max_iou, iou)
     return max_iou
-print(18)
-def load_model(path_to_model, model_type="YOLO"):
-    if model_type == "YOLO":
-        model = YOLO(path_to_model)
-    else:
-        raise NotImplementedError
-    return model
-print(19)
-def get_boxes_list(predictions):
-    return [box.tolist() for box in predictions.boxes.xywhn]
-print(20)
+
 @router.post(ROUTE, tags=["Image Task"],
              description=DESCRIPTION)
 async def evaluate_image(request: ImageEvaluationRequest):
@@ -134,135 +100,44 @@ async def evaluate_image(request: ImageEvaluationRequest):
     # Update the code below to replace the random baseline with your model inference
     #--------------------------------------------------------------------------------------------   
     
-    import cv2
-    import onnxruntime
-    import matplotlib.pyplot as plt
-
-    #PATH_TO_MODEL = 'models/best_YOLOv11n_1280.onnx'
-    #PATH_TO_MODEL = 'models/best_yolov6n_1280.pt'
-    #PATH_TO_MODEL = 'models/best_YOLOv11n_1280_real_half.onnx'
-    PATH_TO_MODEL = 'models/best_YOLOv11n_1280.pt'
-    INFERENCE_ENGINE_TYPE = 'pt'
-    INPUT_SIZE = 1280
-    N_TEST_BATCHES = 2
-    BATCH_SIZE = 32 # Can be adjusted as needed
-    print("PATH_TO_MODEL", PATH_TO_MODEL)
-        
-    print("Starting inference")
     predictions = []
     true_labels = []
     pred_boxes = []
     true_boxes_list = []  # List of lists, each inner list contains boxes for one image
     
-    n_examples = len(test_dataset)
-    n_boxes = []
-    model = YOLO(PATH_TO_MODEL)
-    print("PATH_TO_MODEL", PATH_TO_MODEL)
-
-    # First pass - process annotations
-    has_smoke_list = []
-    annotations_list = []
-    for i, example in enumerate(test_dataset):
-        if i % 200 == 0:
-            print(f"Processing annotations {i+1} of {n_examples}")
+    for example in test_dataset:
+        # Parse true annotation (YOLO format: class_id x_center y_center width height)
         annotation = example.get("annotations", "").strip()
-        n_annotations = len(annotation.split("\n"))
-        n_boxes.append(n_annotations)
         has_smoke = len(annotation) > 0
-        has_smoke_list.append(has_smoke)
         true_labels.append(int(has_smoke))
-        annotations_list.append(annotation)
-        if i == (N_TEST_BATCHES+1)*BATCH_SIZE-1:
-            #break
-            pass
-
-    all_preds = []
-    all_scores = []
-    all_binary_classifications = []
-    # Second pass - batch predictions
-    for i, batch_start in enumerate(range(0, n_examples, BATCH_SIZE)):
-        batch_end = min(batch_start + BATCH_SIZE, n_examples)
-        if i % 100 == 0:
-            print(f"Processing batch {batch_start//BATCH_SIZE + 1} of {(n_examples + BATCH_SIZE - 1)//BATCH_SIZE}")
-            print(f"Batch start: {batch_start}, Batch end: {batch_end}")
-        
-        # Get batch of images and pad if needed
-        batch_images = []
-        for j in range(batch_start, batch_end):
-            batch_images.append(test_dataset[j]['image'])
-                    
-        # Pad the last batch if needed
-        if len(batch_images) < BATCH_SIZE:
-            print(f"Padding last batch from {len(batch_images)} to {BATCH_SIZE} images")
-            padding_needed = BATCH_SIZE - len(batch_images)
-            # Duplicate the last image to fill the batch
-            batch_images.extend([batch_images[-1]] * padding_needed)
         
-        print(f"Running predictions on {model.device}")
-        # Get predictions for batch
-        results = model.predict(batch_images, imgsz=INPUT_SIZE#, device="cuda"
-                                )
+        # Make random classification prediction
+        pred_has_smoke = random.random() > 0.5
+        predictions.append(int(pred_has_smoke))
         
-        # Only process the actual examples (not padding)
-        actual_results = results[:batch_end-batch_start]
-        # Process each result in batch to extract predictions, scores and classifications
-        batch_preds = []
-        batch_scores = []
-        batch_binary_classifications = []
-        
-        for result in actual_results:
-            boxes = result.boxes
-            xywhn = boxes.xywhn.tolist()
-            
-            if len(xywhn) > 0:
-                # Get first box coordinates and confidence score
-                batch_preds.append(xywhn[0])  
-                batch_scores.append(boxes.conf.tolist()[0])
-                batch_binary_classifications.append(1)
-            else:
-                # No boxes detected
-                batch_preds.append([])
-                batch_scores.append([]) 
-                batch_binary_classifications.append(0)
-
-        all_preds += batch_preds
-        all_scores += batch_scores
-        all_binary_classifications += batch_binary_classifications
-
-        print("Processing predictions")
-
-        if i == N_TEST_BATCHES:
-            from collections import Counter
-            n_box_distr = Counter(n_boxes)
-            print(n_box_distr)
-            #break
-            pass
-    pred_boxes = []
-
-    for idx in range(len(all_preds)):
-        if has_smoke_list[idx]:
-            # Parse true boxes
-            image_true_boxes = parse_boxes(annotations_list[idx])
+        # If there's a true box, parse it and make random box prediction
+        if has_smoke:
+            # Parse all true boxes from the annotation
+            image_true_boxes = parse_boxes(annotation)
             true_boxes_list.append(image_true_boxes)
             
-            # Process predicted boxes
-            try:
-                if len(all_preds[idx]) < 1:
-                    model_preds = [0, 0, 0, 0]
-                else:
-                    model_preds = all_preds[idx]
-            except:
-                model_preds = [0, 0, 0, 0]
-            pred_boxes.append(model_preds)
-
-    print("Processing completed with last index", idx)
+            # For baseline, make one random box prediction per image
+            # In a real model, you might want to predict multiple boxes
+            random_box = [
+                random.random(),  # x_center
+                random.random(),  # y_center
+                random.random() * 0.5,  # width (max 0.5)
+                random.random() * 0.5   # height (max 0.5)
+            ]
+            pred_boxes.append(random_box)
+    
     #--------------------------------------------------------------------------------------------
     # YOUR MODEL INFERENCE STOPS HERE
     #--------------------------------------------------------------------------------------------   
     
     # Stop tracking emissions
     emissions_data = tracker.stop_task()
-    predictions = all_binary_classifications
+    
     # Calculate classification metrics
     classification_accuracy = accuracy_score(true_labels, predictions)
     classification_precision = precision_score(true_labels, predictions)
@@ -270,14 +145,13 @@ async def evaluate_image(request: ImageEvaluationRequest):
     
     # Calculate mean IoU for object detection (only for images with smoke)
     # For each image, we compute the max IoU between the predicted box and all true boxes
-    print("Calculating mean IoU")
     ious = []
     for true_boxes, pred_box in zip(true_boxes_list, pred_boxes):
         max_iou = compute_max_iou(true_boxes, pred_box)
         ious.append(max_iou)
     
     mean_iou = float(np.mean(ious)) if ious else 0.0
-    print("Mean IoU calculated")    
+    
     # Prepare results dictionary
     results = {
         "username": username,
@@ -298,5 +172,5 @@ async def evaluate_image(request: ImageEvaluationRequest):
             "test_seed": request.test_seed
         }
     }
-    print("Result returned")
+    
     return results