upload files

multiclass_model.pkl

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

pca_params.pkl

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

script.py

@@ -0,0 +1,82 @@
+"""
+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)

train.py

@@ -0,0 +1,157 @@
+"""
+Training script for surgical instrument classification
+Generates files needed for Hugging Face submission
+"""
+
+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 = 100
+    
+    # Train and save
+    train_and_save_model(BASE_PATH, IMAGES_FOLDER, GT_CSV, SAVE_DIR, N_COMPONENTS)

utils/utils.py

@@ -0,0 +1,235 @@
+"""
+Utility functions for surgical instrument classification
+Simplified version that maintains enhanced features
+"""
+
+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 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_RGB2GRAY)
+    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_RGB2GRAY)
+    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_RGB2GRAY)
+    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=9, 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_RGB2GRAY)
+    
+    # Resize to standard size for consistency
+    gray_resized = cv2.resize(gray, (128, 128))
+    
+    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 extract_features_from_image(image):
+    """
+    Extract enhanced features from image
+    Uses baseline features + HOG + LUV histogram for better performance
+    
+    Args:
+        image: Input image (BGR format from cv2.imread)
+    
+    Returns:
+        Feature vector as numpy array
+    """
+    
+    # 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)
+    
+    # Concatenate all features
+    image_features = np.concatenate([
+        hist_features,
+        hu_features,
+        glcm_features_vector,
+        lbp_features,
+        hog_feat,
+        luv_hist
+    ])
+    
+    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