delete

attempt4-ISM/.gitattributes

@@ -1,35 +0,0 @@
-*.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

attempt4-ISM/README.md

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

attempt4-ISM/multiclass_model.pkl

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

attempt4-ISM/pca_params.pkl

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

attempt4-ISM/script.py

@@ -1,82 +0,0 @@
-"""
-Inference script for Hugging Face competition submission
-Fixed 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)

attempt4-ISM/train.py

@@ -1,156 +0,0 @@
-"""
-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
-
-
-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")
-    print("="*80)
-    
-    features = []
-    labels = []
-    
-    for i in range(len(df)):
-        if i % 500 == 0:
-            print(f"  Processing {i}/{len(df)}...")
-        
-        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
-            
-            # Extract features with enhanced configuration
-            image_features = extract_features_from_image(image)
-            
-            features.append(image_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"  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
-    print(f"\n{'='*80}")
-    print("STEP 3: TRAINING SVM CLASSIFIER")
-    print("="*80)
-    
-    train_results = train_svm_model(features_reduced, labels_array)
-    
-    svm_model = train_results['model']
-    
-    print(f"\nTraining complete!")
-    print(f"  Support vectors: {len(svm_model.support_)}")
-    
-    # Save model artifacts
-    print(f"\n{'='*80}")
-    print("STEP 4: SAVING MODEL ARTIFACTS")
-    print("="*80)
-    
-    os.makedirs(save_dir, exist_ok=True)
-    
-    # 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 Results:")
-    print(f"  Train Accuracy: {train_results['train_accuracy']:.4f}")
-    print(f"  Test Accuracy:  {train_results['test_accuracy']:.4f}")
-    print(f"  Test F1-score:  {train_results['test_f1']:.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__":
-    
-    # CONFIGURATION - Adjust these paths to your setup
-    BASE_PATH = "C:/Users/anna2/ISM/ANNA/phase1a2"
-    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/phase1a2/submission"
-    
-    # Number of PCA components
-    N_COMPONENTS = 200
-    
-    # Train and save
-    train_and_save_model(BASE_PATH, IMAGES_FOLDER, GT_CSV, SAVE_DIR, N_COMPONENTS)

attempt4-ISM/utils.py

@@ -1,280 +0,0 @@
-"""
-Utility functions for surgical instrument classification
-FIXED VERSION - Bug fixes for HuggingFace submission
-"""
-
-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 preprocess_image(image):
-    """
-    Apply CLAHE preprocessing for better contrast
-    MUST be defined BEFORE extract_features_from_image
-    """
-    # Convert to LAB color space
-    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
-    l, a, b = cv2.split(lab)
-    
-    # Apply CLAHE to L channel
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    l = clahe.apply(l)
-    
-    # Merge and convert back
-    enhanced = cv2.merge([l, a, b])
-    enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2BGR)
-    
-    return enhanced
-
-
-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"""
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Fixed: BGR not RGB
-    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"""
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Already correct
-    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"""
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Already correct
-    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
-
-
-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)  # Fixed: BGR not RGB
-    
-    # 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
-
-
-def luv_histogram(image, bins=32):
-    """
-    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
-    MUST be defined BEFORE extract_features_from_image
-    """
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Fixed: BGR not RGB
-    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
-    hog_feat = hog_features(image)
-    luv_hist = luv_histogram(image)
-    gabor_feat = gabor_features(image)
-    
-    # Concatenate all features
-    image_features = np.concatenate([
-        hist_features,
-        hu_features,
-        glcm_features_vector,
-        lbp_features,
-        hog_feat,
-        luv_hist,
-        gabor_feat
-    ])
-    
-    return image_features
-
-
-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
-    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

attempt4-ISM/utils/utils.py

@@ -1,280 +0,0 @@
-"""
-Utility functions for surgical instrument classification
-FIXED VERSION - Bug fixes for HuggingFace submission
-"""
-
-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 preprocess_image(image):
-    """
-    Apply CLAHE preprocessing for better contrast
-    MUST be defined BEFORE extract_features_from_image
-    """
-    # Convert to LAB color space
-    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
-    l, a, b = cv2.split(lab)
-    
-    # Apply CLAHE to L channel
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    l = clahe.apply(l)
-    
-    # Merge and convert back
-    enhanced = cv2.merge([l, a, b])
-    enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2BGR)
-    
-    return enhanced
-
-
-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"""
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Fixed: BGR not RGB
-    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"""
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Already correct
-    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"""
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Already correct
-    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
-
-
-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)  # Fixed: BGR not RGB
-    
-    # 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
-
-
-def luv_histogram(image, bins=32):
-    """
-    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
-    MUST be defined BEFORE extract_features_from_image
-    """
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Fixed: BGR not RGB
-    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
-    hog_feat = hog_features(image)
-    luv_hist = luv_histogram(image)
-    gabor_feat = gabor_features(image)
-    
-    # Concatenate all features
-    image_features = np.concatenate([
-        hist_features,
-        hu_features,
-        glcm_features_vector,
-        lbp_features,
-        hog_feat,
-        luv_hist,
-        gabor_feat
-    ])
-    
-    return image_features
-
-
-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
-    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