Upload 8 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:ea235b1b90083e084e441f294cf7a960d3fc17573b33323fdd68949fa8da460c
+size 1935

pca_lda_params.pkl

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

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_lda_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_lda_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_LDA_PARAMS_NAME = "pca_lda_params.pkl"
+    PCA_LDA_PARAMS_PATH = os.path.join(current_directory, PCA_LDA_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_LDA_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,160 @@
+"""
+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_lda_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+LDA
+    print(f"\n{'='*80}")
+    print("STEP 2: HYBRID DIMENSIONALITY REDUCTION (PCA → LDA)")
+    print("="*80)
+    
+    combined_params, features_reduced = fit_pca_lda_transformer(
+        features_array, 
+        labels_array, 
+        n_pca_components=N_COMPONENTS
+    )
+    
+    print(f"\n  Final dimension: {features_reduced.shape[1]}")
+    print(f"  Compression ratio: {features_array.shape[1] / features_reduced.shape[1]:.1f}x")
+    
+    # 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
+    # Save combined PCA+LDA parameters
+    params_path = os.path.join(save_dir, "pca_lda_params.pkl")
+    with open(params_path, "wb") as f:
+        pickle.dump(combined_params, f)
+    print(f"  ✓ Saved PCA+LDA params: {params_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__":
+    
+    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 = 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,370 @@
+"""
+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
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+
+
+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, gamma='scale'):
+    """
+    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
+        gamma: Kernel coefficient ('scale', 'auto', or float value)
+    
+    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, gamma=gamma, random_state=42)  # ← Added gamma here
+    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
+
+def fit_pca_lda_transformer(data, labels, n_pca_components=250):
+    """
+    Two-stage dimensionality reduction: PCA then LDA
+    
+    Args:
+        data: Training data (n_samples, n_features)
+        labels: Class labels (n_samples,)
+        n_pca_components: Number of PCA components (default 250)
+    
+    Returns:
+        combined_params: Dictionary containing both PCA and LDA parameters
+        data_reduced: Transformed data
+    """
+    
+    print(f"\n{'='*80}")
+    print("FITTING HYBRID PCA+LDA TRANSFORMER")
+    print("="*80)
+    
+    # Stage 1: PCA
+    print("\nStage 1: PCA for noise reduction and variance preservation")
+    pca_params, data_pca_reduced = fit_pca_transformer(data, n_pca_components)
+    
+    print(f"  ✓ PCA reduced from {data.shape[1]} to {n_pca_components} dimensions")
+    print(f"  ✓ PCA explained variance: {pca_params['cumulative_variance'][-1]:.4f}")
+    
+    # Stage 2: LDA on PCA-reduced features
+    print("\nStage 2: LDA for class separability maximization")
+    
+    n_classes = len(np.unique(labels))
+    max_lda_components = n_classes - 1
+    
+    print(f"  Number of classes: {n_classes}")
+    print(f"  Maximum LDA components: {max_lda_components}")
+    
+    # Fit LDA (no additional standardization needed, PCA output is already standardized)
+    lda_model = LinearDiscriminantAnalysis()
+    data_final = lda_model.fit_transform(data_pca_reduced, labels)
+    
+    print(f"  ✓ LDA reduced from {n_pca_components} to {data_final.shape[1]} dimensions")
+    print(f"  ✓ Total compression: {data.shape[1]}→{n_pca_components}→{data_final.shape[1]}")
+    
+    # Calculate LDA explained variance
+    lda_explained_variance = lda_model.explained_variance_ratio_
+    print(f"  ✓ LDA explained variance: {np.sum(lda_explained_variance):.4f}")
+    
+    # Combine parameters
+    combined_params = {
+        'pca_params': pca_params,
+        'lda_model': lda_model,
+        'n_pca_components': n_pca_components,
+        'n_lda_components': data_final.shape[1],
+        'n_classes': n_classes,
+        'original_feature_dim': data.shape[1],
+        'lda_explained_variance_ratio': lda_explained_variance
+    }
+    
+    return combined_params, data_final
+
+
+def apply_pca_lda_transform(data, combined_params):
+    """
+    Apply saved PCA+LDA transformation to new data
+    
+    Args:
+        data: New data to transform (n_samples, n_features)
+        combined_params: Dictionary from fit_pca_lda_transformer
+    
+    Returns:
+        Transformed data
+    """
+    
+    # Stage 1: Apply PCA transformation
+    data_pca_reduced = apply_pca_transform(data, combined_params['pca_params'])
+    
+    # Stage 2: Apply LDA transformation
+    data_final = combined_params['lda_model'].transform(data_pca_reduced)
+    
+    return data_final