upload files

.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:92bea164e635928131fd50dc8760709cc1b7eae5c8bb62d1077dde21e53af102
+size 1548622

pca_params.pkl

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

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,151 @@
+"""
+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"\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-wavelet"
+    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-wavelet/submission"
+    
+    # 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,319 @@
+"""
+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
+import pywt
+
+def preprocess_image(image):
+    """
+    Apply CLAHE preprocessing for better contrast
+    (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=(16, 16), 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)) #we could try using 256 here and 16,16 cells per block
+    
+    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 wavelet_features(image, wavelet='db4', levels=3):
+
+    # try out multi-orientation wavelets (e.g., sym8, coif)
+    """
+    multi-scale wavelet feature extractor
+    focus on texture + edges.
+    This function converts an image to grayscale, 
+    performs a multi-level 2D wavelet decomposition, 
+    and extracts texture features from the approximation and detail sub-bands.
+    It summarizes each band using statistics like mean, standard deviation, and peak magnitude.
+    The result is a numerical feature vector capturing multi-scale texture and edge 
+    information for tasks like surgical tool detection.
+    """
+
+    # Convert to grayscale float32 in [0,1]
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY).astype(np.float32) / 255.0
+
+    # Ensure the decomposition level is valid for this image
+    max_level = pywt.dwt_max_level(min(gray.shape), pywt.Wavelet(wavelet).dec_len)
+    levels = min(levels, max_level)
+
+    coeffs = pywt.wavedec2(gray, wavelet=wavelet, level=levels)
+
+    features = []
+
+    #Approximation Coefficients (LL)
+    LL = coeffs[0]
+    LL_abs = np.abs(LL)
+    features.extend([
+        LL.mean(),
+        LL.std(),
+        LL_abs.max(),
+        LL_abs.mean(),
+    ])
+
+    # Detail Coefficients for each level: (LH, HL, HH)
+    for (LH, HL, HH) in coeffs[1:]:
+        for band in (LH, HL, HH):
+            band_abs = np.abs(band)
+            features.extend([
+                band_abs.mean(),      # energy-like texture measure
+                band_abs.std(),       # variation in texture
+                band_abs.max(),       # strongest directional edge
+                np.percentile(band_abs, 95),  # robust peak measure
+            ])
+
+    return np.array(features, dtype=np.float32)
+
+
+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)
+    wavelet_feat = wavelet_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,
+        wavelet_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, kernel='rbf', C=1.0):
+    """
+    Train an SVM model on ALL available data (no train/test split)
+    
+    Args:
+        features: Feature matrix (n_samples, n_features)
+        labels: Label array (n_samples,)
+        kernel: SVM kernel type ('linear', 'rbf', 'poly', 'sigmoid')
+        C: Regularization parameter (smaller = more regularization)
+    
+    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)
+    
+    # Train SVM on ALL data
+    svm_model = SVC(kernel=kernel, C=C, random_state=56)
+    svm_model.fit(features, labels)
+    
+    
+    results = {
+        'model': svm_model
+    }
+    
+    return results