upload files for model

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,3 @@
+---
+license: mit
+---

multiclass_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac42a32dd5498c71ef249f31d2e7c42aa7eb2a2ef424c80231a6f3240a901e3f
+size 3596894

pca_params.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f652e3a80b3914b927b866fbd862225c12cbbde0bb61b52789f49113b0e5d8f7
+size 95215926

script.py

@@ -0,0 +1,82 @@
+"""
+Inference script
+Version combining baseline structure with enhanced features
+"""
+
+import os
+import pickle
+import cv2
+import pandas as pd
+import numpy as np
+from utils.utils import extract_features_from_image, apply_pca_transform
+
+
+def run_inference(TEST_IMAGE_PATH, svm_model, pca_params, SUBMISSION_CSV_SAVE_PATH):
+    """
+    Run inference on test images
+    
+    Args:
+        TEST_IMAGE_PATH: Path to test images (/tmp/data/test_images)
+        svm_model: Trained SVM model
+        pca_params: Dictionary containing PCA transformation parameters
+        SUBMISSION_CSV_SAVE_PATH: Path to save submission.csv
+    """
+    
+    # Load test images
+    test_images = os.listdir(TEST_IMAGE_PATH)
+    test_images.sort()
+    
+    # Extract features from all test images
+    image_feature_list = []
+    
+    for test_image in test_images:
+        path_to_image = os.path.join(TEST_IMAGE_PATH, test_image)
+        
+        image = cv2.imread(path_to_image)
+        
+        # Extract features (using enhanced features by default)
+        image_features = extract_features_from_image(image)
+        
+        image_feature_list.append(image_features)
+    
+    features_array = np.array(image_feature_list)
+    
+    # Apply PCA transformation using saved parameters
+    features_reduced = apply_pca_transform(features_array, pca_params)
+    
+    # Run predictions
+    predictions = svm_model.predict(features_reduced)
+    
+    # Create submission CSV
+    df_predictions = pd.DataFrame({
+        "file_name": test_images,
+        "category_id": predictions
+    })
+    
+    df_predictions.to_csv(SUBMISSION_CSV_SAVE_PATH, index=False)
+
+
+if __name__ == "__main__":
+    
+    # Paths
+    current_directory = os.path.dirname(os.path.abspath(__file__))
+    TEST_IMAGE_PATH = "/tmp/data/test_images"
+    
+    MODEL_NAME = "multiclass_model.pkl"
+    MODEL_PATH = os.path.join(current_directory, MODEL_NAME)
+    
+    PCA_PARAMS_NAME = "pca_params.pkl"
+    PCA_PARAMS_PATH = os.path.join(current_directory, PCA_PARAMS_NAME)
+    
+    SUBMISSION_CSV_SAVE_PATH = os.path.join(current_directory, "submission.csv")
+    
+    # Load trained SVM model
+    with open(MODEL_PATH, 'rb') as file:
+        svm_model = pickle.load(file)
+    
+    # Load PCA parameters
+    with open(PCA_PARAMS_PATH, 'rb') as file:
+        pca_params = pickle.load(file)
+    
+    # Run inference
+    run_inference(TEST_IMAGE_PATH, svm_model, pca_params, SUBMISSION_CSV_SAVE_PATH)

train.py

@@ -0,0 +1,268 @@
+"""
+Training script for surgical instrument classification
+"""
+
+import os
+import pickle
+import cv2
+import pandas as pd
+import numpy as np
+from utils.utils import extract_features_from_image, fit_pca_transformer, train_svm_model, augment_image
+from utils.utils import extract_features_from_image, fit_pca_transformer, augment_image
+from sklearn.model_selection import GridSearchCV, train_test_split
+from sklearn.svm import SVC
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report
+
+def train_and_save_model(base_path, images_folder, gt_csv, save_dir, n_components=100):
+    """
+    Complete training pipeline that saves everything needed for submission
+    
+    Args:
+        base_path: Base directory path
+        images_folder: Folder name containing images
+        gt_csv: Ground truth CSV filename
+        save_dir: Directory to save model artifacts
+        n_components: Number of PCA components
+    """
+    
+    print("="*80)
+    print("TRAINING SURGICAL INSTRUMENT CLASSIFIER")
+    print("="*80)
+    
+    # Setup paths
+    PATH_TO_GT = os.path.join(base_path, gt_csv)
+    PATH_TO_IMAGES = os.path.join(base_path, images_folder)
+    
+    print(f"\nConfiguration:")
+    print(f"  Ground Truth: {PATH_TO_GT}")
+    print(f"  Images: {PATH_TO_IMAGES}")
+    print(f"  PCA Components: {n_components}")
+    print(f"  Save directory: {save_dir}")
+    
+    # Load ground truth
+    df = pd.read_csv(PATH_TO_GT)
+    print(f"\nLoaded {len(df)} training samples")
+    print(f"\nLabel distribution:")
+    print(df['category_id'].value_counts().sort_index())
+    
+    # Extract features
+    print(f"\n{'='*80}")
+    print("STEP 1: FEATURE EXTRACTION WITH AUGMENTATION")
+    print("="*80)
+    
+    # Augmentation configuration
+    AUGMENTATIONS_PER_IMAGE = 2  # Conservative: 3x total dataset
+    
+    print(f"\nAugmentation settings:")
+    print(f"  Augmentations per image: {AUGMENTATIONS_PER_IMAGE}")
+    print(f"  Rotation range: -10° to +10°")
+    print(f"  Brightness range: 0.9 to 1.1")
+    print(f"  Horizontal flip: Yes")
+    print(f"  Gaussian noise: σ=3")
+    print(f"  Expected total samples: {len(df) * (1 + AUGMENTATIONS_PER_IMAGE)}")
+    
+    features = []
+    labels = []
+    
+    for i in range(len(df)):
+        if i % 500 == 0:
+            print(f"  Processing {i}/{len(df)* (1 + AUGMENTATIONS_PER_IMAGE)}...")
+        
+        image_name = df.iloc[i]["file_name"]
+        label = df.iloc[i]["category_id"]
+        
+        path_to_image = os.path.join(PATH_TO_IMAGES, image_name)
+        
+        try:
+            image = cv2.imread(path_to_image)
+            if image is None:
+                print(f"  Warning: Could not read {image_name}, skipping...")
+                continue
+            
+            # ORIGINAL IMAGE
+            original_features = extract_features_from_image(image)
+            features.append(original_features)
+            labels.append(label)
+            
+            # AUGMENTED VERSIONS
+            for aug_idx in range(AUGMENTATIONS_PER_IMAGE):
+                # Generate augmented image
+                aug_image = augment_image(
+                    image,
+                    rotation_range=(-10, 10),
+                    brightness_range=(0.9, 1.1),
+                    add_noise=True,
+                    noise_sigma=3,
+                    horizontal_flip=(aug_idx == 0)  # Only flip on first augmentation
+                )
+                
+                # Extract features from augmented image
+                aug_features = extract_features_from_image(aug_image)
+                features.append(aug_features)
+                labels.append(label)
+            
+        except Exception as e:
+            print(f"  Error processing {image_name}: {e}")
+            continue
+    
+    features_array = np.array(features)
+    labels_array = np.array(labels)
+    
+    print(f"\nFeature extraction complete!")
+    print(f"  Original samples: {len(df)}")
+    print(f"  Total samples (with augmentation): {len(features)}")
+    print(f"  Features shape: {features_array.shape}")
+    print(f"  Labels shape: {labels_array.shape}")
+    print(f"  Feature dimension: {features_array.shape[1]}")
+    
+    # Apply PCA
+    print(f"\n{'='*80}")
+    print("STEP 2: DIMENSIONALITY REDUCTION (PCA)")
+    print("="*80)
+    
+    pca_params, features_reduced = fit_pca_transformer(features_array, n_components)
+    
+    print(f"  Reduced from {features_array.shape[1]} to {n_components} dimensions")
+    print(f"  Explained variance: {pca_params['cumulative_variance'][-1]:.4f}")
+    
+    # Train SVM with Grid Search
+    print(f"\n{'='*80}")
+    print("STEP 3: TRAINING SVM CLASSIFIER WITH GRID SEARCH")
+    print("="*80)
+    
+    # Split data for training and testing
+    X_train, X_test, y_train, y_test = train_test_split(
+        features_reduced, 
+        labels_array, 
+        test_size=0.2, 
+        random_state=42,
+        stratify=labels_array
+    )
+    
+    print(f"\nData split:")
+    print(f"  Training samples: {len(X_train)}")
+    print(f"  Test samples: {len(X_test)}")
+    
+    # Define parameter grid
+    param_grid = {
+        'C': [1, 10, 50, 100],
+        'gamma': ['scale', 0.001, 0.01, 0.1],
+        'kernel': ['rbf']
+    }
+    
+    print(f"\nGrid Search parameters:")
+    print(f"  C values: {param_grid['C']}")
+    print(f"  Gamma values: {param_grid['gamma']}")
+    print(f"  Kernel: {param_grid['kernel']}")
+    print(f"  Total combinations: {len(param_grid['C']) * len(param_grid['gamma'])}")
+    print(f"  Cross-validation folds: 3")
+    print(f"\nThis will take 15-30 minutes...")
+    
+    # Perform Grid Search
+    grid_search = GridSearchCV(
+        SVC(),
+        param_grid,
+        cv=3,
+        scoring='f1_macro',
+        n_jobs=-1,
+        verbose=2
+    )
+    
+    print("\nStarting Grid Search...")
+    grid_search.fit(X_train, y_train)
+    
+    # Get best model
+    svm_model = grid_search.best_estimator_
+    
+    print(f"\n{'='*80}")
+    print("GRID SEARCH COMPLETE!")
+    print("="*80)
+    print(f"\nBest parameters found:")
+    print(f"  C: {grid_search.best_params_['C']}")
+    print(f"  Gamma: {grid_search.best_params_['gamma']}")
+    print(f"  Kernel: {grid_search.best_params_['kernel']}")
+    print(f"\nBest cross-validation F1-score: {grid_search.best_score_:.4f}")
+    
+    # Train final model and evaluate
+    print(f"\n{'='*80}")
+    print("FINAL MODEL EVALUATION")
+    print("="*80)
+    
+    # Training set performance
+    y_train_pred = svm_model.predict(X_train)
+    train_accuracy = accuracy_score(y_train, y_train_pred)
+    train_f1 = f1_score(y_train, y_train_pred, average='macro')
+    train_precision = precision_score(y_train, y_train_pred, average='macro')
+    train_recall = recall_score(y_train, y_train_pred, average='macro')
+    
+    # Test set performance
+    y_test_pred = svm_model.predict(X_test)
+    test_accuracy = accuracy_score(y_test, y_test_pred)
+    test_f1 = f1_score(y_test, y_test_pred, average='macro')
+    test_precision = precision_score(y_test, y_test_pred, average='macro')
+    test_recall = recall_score(y_test, y_test_pred, average='macro')
+    
+    print(f"\nTraining Set Performance:")
+    print(f"  Accuracy:  {train_accuracy:.4f}")
+    print(f"  Precision: {train_precision:.4f}")
+    print(f"  Recall:    {train_recall:.4f}")
+    print(f"  F1-score:  {train_f1:.4f}")
+    
+    print(f"\nTest Set Performance:")
+    print(f"  Accuracy:  {test_accuracy:.4f}")
+    print(f"  Precision: {test_precision:.4f}")
+    print(f"  Recall:    {test_recall:.4f}")
+    print(f"  F1-score:  {test_f1:.4f}")
+    
+    print(f"\nDetailed Classification Report:")
+    print(classification_report(y_test, y_test_pred, 
+                                target_names=[f'Class {i}' for i in sorted(np.unique(labels_array))]))
+    
+    print(f"\nModel Details:")
+    print(f"  Support vectors: {len(svm_model.support_)}")
+    print(f"  Support vectors per class: {svm_model.n_support_}")
+
+    # Save SVM model
+    model_path = os.path.join(save_dir, "multiclass_model.pkl")
+    with open(model_path, "wb") as f:
+        pickle.dump(svm_model, f)
+    print(f"  ✓ Saved SVM model: {model_path}")
+    
+    # Save PCA parameters
+    pca_path = os.path.join(save_dir, "pca_params.pkl")
+    with open(pca_path, "wb") as f:
+        pickle.dump(pca_params, f)
+    print(f"  ✓ Saved PCA params: {pca_path}")
+    
+
+    print(f"\n{'='*80}")
+    print("TRAINING COMPLETE!")
+    print("="*80)
+    print(f"\nFinal Optimized Results:")
+    print(f"  Best Parameters: C={grid_search.best_params_['C']}, gamma={grid_search.best_params_['gamma']}")
+    print(f"  CV F1-score: {grid_search.best_score_:.4f}")
+    print(f"  Test F1-score: {test_f1:.4f}")
+    print(f"  Test Precision: {test_precision:.4f}")
+    print(f"  Test Recall: {test_recall:.4f}")
+    print(f"\nFiles saved to: {save_dir}")
+    print(f"\nNext steps:")
+    print(f"  1. Create a 'utils' folder in your HuggingFace repository")
+    print(f"  2. Copy utils.py into the 'utils' folder")
+    print(f"  3. Copy script.py, multiclass_model.pkl, and pca_params.pkl to the repository root")
+    print(f"  4. Create an empty __init__.py file in the 'utils' folder")
+    print(f"  5. Submit to competition!")
+
+
+if __name__ == "__main__":
+    
+    BASE_PATH = "C:/Users/anna2/ISM/ANNA/phase1a-data-augmentation"
+    IMAGES_FOLDER = "C:/Users/anna2/ISM/Images"
+    GT_CSV = "C:/Users/anna2/ISM/Baselines/phase_1a/gt_for_classification_multiclass_from_filenames_0_index.csv"
+    
+    SAVE_DIR = "C:/Users/anna2/ISM/ANNA/phase1a-data-augmentation"
+    
+    # Number of PCA components
+    N_COMPONENTS = 250 #can be adjusted 
+    
+    # Train and save
+    train_and_save_model(BASE_PATH, IMAGES_FOLDER, GT_CSV, SAVE_DIR, N_COMPONENTS)

utils/utils.py

@@ -0,0 +1,332 @@
+"""
+Utility functions for surgical instrument classification
+"""
+
+import cv2
+import numpy as np
+from skimage.feature.texture import graycomatrix, graycoprops
+from skimage.feature import local_binary_pattern, hog
+from sklearn.decomposition import PCA
+from sklearn.svm import SVC
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, f1_score
+
+def augment_image(image, rotation_range=(-10, 10), brightness_range=(0.9, 1.1), 
+                  add_noise=True, noise_sigma=3, horizontal_flip=False):
+    """
+    Apply safe augmentations for surgical instrument images
+    
+    Args:
+        image: Input image (BGR format from cv2)
+        rotation_range: (min, max) rotation in degrees
+        brightness_range: (min, max) brightness multiplier
+        add_noise: Whether to add Gaussian noise
+        noise_sigma: Standard deviation of Gaussian noise
+        horizontal_flip: Whether to flip horizontally
+    
+    Returns:
+        Augmented image
+    """
+    img = image.copy()
+    
+    # 1. Random rotation
+    if rotation_range:
+        angle = np.random.uniform(rotation_range[0], rotation_range[1])
+        h, w = img.shape[:2]
+        center = (w // 2, h // 2)
+        M = cv2.getRotationMatrix2D(center, angle, 1.0)
+        img = cv2.warpAffine(img, M, (w, h), borderMode=cv2.BORDER_REFLECT)
+    
+    # 2. Random brightness adjustment
+    if brightness_range:
+        alpha = np.random.uniform(brightness_range[0], brightness_range[1])
+        img = cv2.convertScaleAbs(img, alpha=alpha, beta=0)
+    
+    # 3. Horizontal flip
+    if horizontal_flip:
+        img = cv2.flip(img, 1)
+    
+    # 4. Add Gaussian noise
+    if add_noise:
+        noise = np.random.normal(0, noise_sigma, img.shape)
+        img = np.clip(img.astype(np.float32) + noise, 0, 255).astype(np.uint8)
+    
+    return img
+
+
+def preprocess_image(image):
+    """
+    Apply CLAHE preprocessing for better contrast
+    MUST be defined BEFORE extract_features_from_image
+    (Contrast Limited Adaptive Historam Equalization)
+    """
+    # Convert to LAB color space (basically separating lightness, L, from color info)
+    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB) 
+    l, a, b = cv2.split(lab) #this enhances constrast between colors
+    
+    # Apply CLAHE to L channel
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8)) #split into a 8x8 grid and performs the contrast enhancement to the smaller regions instead of full image
+    l = clahe.apply(l)
+    
+    # Merge and convert back
+    enhanced = cv2.merge([l, a, b]) #merge the contrast channel with the other two (A,B)
+    enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2BGR) #go back to BGR so it can be used later on
+    
+    return enhanced
+
+
+#this is the same as baseline code, well working so let's keep it 
+#it basically computes normalized color histograms for the classic three channels
+def rgb_histogram(image, bins=256):
+    """Extract RGB histogram features"""
+    hist_features = []
+    for i in range(3):  # RGB Channels 
+        hist, _ = np.histogram(image[:, :, i], bins=bins, range=(0, 256), density=True)
+        hist_features.append(hist)
+    return np.concatenate(hist_features)
+
+
+def hu_moments(image):
+    """Extract Hu moment features, takes BGR format in input
+    basically provides shape description that are consistent 
+    wrt to position, size and rotation"""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) #turn to greyscale (works in 1 channel)
+    moments = cv2.moments(gray) 
+    hu_moments = cv2.HuMoments(moments).flatten()
+    return hu_moments 
+
+
+def glcm_features(image, distances=[1], angles=[0], levels=256, symmetric=True, normed=True):
+    """Extract GLCM texture features, 
+    captures texture info considering spatial
+    relationship between pixel intensities. works well with RGB and hu"""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 
+    glcm = graycomatrix(gray, distances=distances, angles=angles, levels=levels, 
+                       symmetric=symmetric, normed=normed)
+    contrast = graycoprops(glcm, 'contrast').flatten()
+    dissimilarity = graycoprops(glcm, 'dissimilarity').flatten()
+    homogeneity = graycoprops(glcm, 'homogeneity').flatten()
+    energy = graycoprops(glcm, 'energy').flatten()
+    correlation = graycoprops(glcm, 'correlation').flatten()
+    asm = graycoprops(glcm, 'ASM').flatten()
+    return np.concatenate([contrast, dissimilarity, homogeneity, energy, correlation, asm])
+
+
+def local_binary_pattern_features(image, P=8, R=1):
+    """Extract Local Binary Pattern features, useful for light changes
+    combined with rgb, hu and glcm"""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  
+    lbp = local_binary_pattern(gray, P, R, method='uniform')
+    (hist, _) = np.histogram(lbp.ravel(), bins=np.arange(0, P + 3), 
+                            range=(0, P + 2), density=True)
+    return hist #feature vector representing the texture of the image
+
+
+def hog_features(image, orientations=12, pixels_per_cell=(8, 8), cells_per_block=(2, 2)):
+    """
+    Extract HOG (Histogram of Oriented Gradients) features
+    Great for capturing shape and edge information in surgical instruments
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  
+    
+    # Resize to standard size for consistency
+    gray_resized = cv2.resize(gray, (256, 256))
+    
+    hog_features_vector = hog(
+        gray_resized,
+        orientations=orientations,
+        pixels_per_cell=pixels_per_cell,
+        cells_per_block=cells_per_block,
+        block_norm='L2-Hys',
+        feature_vector=True
+    )
+    
+    return hog_features_vector #Returns a vector capturing local edge 
+    #directions and shape information, useful for detecting instruments, 
+    #objects, or structural patterns.
+
+
+def luv_histogram(image, bins=32): #instead of bgr it uses lightness and chromatic components
+    """
+    Extract histogram in LUV color space
+    LUV is perceptually uniform and better for underwater/surgical imaging
+    """
+    luv = cv2.cvtColor(image, cv2.COLOR_BGR2LUV)
+    hist_features = []
+    for i in range(3):
+        hist, _ = np.histogram(luv[:, :, i], bins=bins, range=(0, 256), density=True)
+        hist_features.append(hist)
+    return np.concatenate(hist_features)
+
+
+def gabor_features(image, frequencies=[0.1, 0.2, 0.3], 
+                   orientations=[0, 45, 90, 135]):
+    """
+    Extract Gabor filter features (gabor kernels)
+    texture orientation that deals well with different scales and diff orientation
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # uses intensity and not color
+    features = []
+    
+    for freq in frequencies:
+        for theta in orientations:
+            theta_rad = theta * np.pi / 180
+            kernel = cv2.getGaborKernel((21, 21), 5, theta_rad, 
+                                       10.0/freq, 0.5, 0)
+            filtered = cv2.filter2D(gray, cv2.CV_32F, kernel)
+            features.append(np.mean(filtered))
+            features.append(np.std(filtered))
+    
+    return np.array(features)
+
+
+def extract_features_from_image(image):
+    """
+    Extract enhanced features from image
+    Uses baseline features + HOG + LUV histogram + Gabor for better performance
+    
+    Args:
+        image: Input image (BGR format from cv2.imread)
+    
+    Returns:
+        Feature vector as numpy array
+    """
+    # Preprocess image first
+    image = preprocess_image(image)
+    
+    # Baseline features
+    hist_features = rgb_histogram(image)
+    hu_features = hu_moments(image)
+    glcm_features_vector = glcm_features(image)
+    lbp_features = local_binary_pattern_features(image)
+    
+    # Enhanced features that add discriminative power for complex images 
+    hog_feat = hog_features(image)
+    luv_hist = luv_histogram(image)
+    gabor_feat = gabor_features(image)
+    
+    # Concatenate all features (produces a single vector)
+    image_features = np.concatenate([
+        hist_features,
+        hu_features,
+        glcm_features_vector,
+        lbp_features,
+        hog_feat,
+        luv_hist,
+        gabor_feat
+    ])
+    
+    return image_features # comprehensive numerical representation of the imag
+
+
+def fit_pca_transformer(data, num_components):
+    """
+    Fit a PCA transformer on training data
+    
+    Args:
+        data: Training data (n_samples, n_features)
+        num_components: Number of PCA components to keep
+    
+    Returns:
+        pca_params: Dictionary containing PCA parameters
+        data_reduced: PCA-transformed data
+    """
+    
+    # Standardize the data
+    mean = np.mean(data, axis=0)
+    std = np.std(data, axis=0)
+    
+    # Avoid division by zero
+    std[std == 0] = 1.0
+    
+    data_standardized = (data - mean) / std
+    
+    # Fit PCA using sklearn
+    pca_model = PCA(n_components=num_components)
+    data_reduced = pca_model.fit_transform(data_standardized)
+    
+    # Create params dictionary
+    pca_params = {
+        'pca_model': pca_model,
+        'mean': mean,
+        'std': std,
+        'num_components': num_components,
+        'feature_dim': data.shape[1],
+        'explained_variance_ratio': pca_model.explained_variance_ratio_,
+        'cumulative_variance': np.cumsum(pca_model.explained_variance_ratio_)
+    }
+    
+    return pca_params, data_reduced
+
+
+def apply_pca_transform(data, pca_params):
+    """
+    Apply saved PCA transformation to new data
+    CRITICAL: This uses the saved mean/std/PCA from training
+    
+    Args:
+        data: New data to transform (n_samples, n_features)
+        pca_params: Dictionary from fit_pca_transformer
+    
+    Returns:
+        Transformed data
+    """
+    
+    # Standardize using training mean/std
+    data_standardized = (data - pca_params['mean']) / pca_params['std']
+    
+    # Apply PCA transformation
+    # Projects new data onto the same principal components computed from training data
+    data_reduced = pca_params['pca_model'].transform(data_standardized)
+    
+    return data_reduced
+
+
+def train_svm_model(features, labels, test_size=0.2, kernel='rbf', C=1.0):
+    """
+    Train an SVM model and return both the model and performance metrics
+    
+    Args:
+        features: Feature matrix (n_samples, n_features)
+        labels: Label array (n_samples,)
+        test_size: Proportion for test split
+        kernel: SVM kernel type
+        C: SVM regularization parameter
+    
+    Returns:
+        Dictionary containing model and metrics
+    """
+    
+    # Check if labels are one-hot encoded
+    if labels.ndim > 1 and labels.shape[1] > 1:
+        labels = np.argmax(labels, axis=1)
+    
+    # Split data
+    X_train, X_test, y_train, y_test = train_test_split(
+        features, labels, test_size=test_size, random_state=42, stratify=labels
+    )
+    
+    # Train SVM
+    svm_model = SVC(kernel=kernel, C=C, random_state=42)
+    svm_model.fit(X_train, y_train)
+    
+    # Evaluate
+    y_train_pred = svm_model.predict(X_train)
+    y_test_pred = svm_model.predict(X_test)
+    
+    train_accuracy = accuracy_score(y_train, y_train_pred)
+    test_accuracy = accuracy_score(y_test, y_test_pred)
+    test_f1 = f1_score(y_test, y_test_pred, average='macro')
+    
+    print(f'Train Accuracy: {train_accuracy:.4f}')
+    print(f'Test Accuracy:  {test_accuracy:.4f}')
+    print(f'Test F1-score:  {test_f1:.4f}')
+    
+    results = {
+        'model': svm_model,
+        'train_accuracy': train_accuracy,
+        'test_accuracy': test_accuracy,
+        'test_f1': test_f1
+    }
+    
+    return results