Add changes

phase_1a_sample_solution_multiclass.ipynb

@@ -0,0 +1,226 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# A. Extract Features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<module 'submission.utils.utils' from 'c:\\\\Users\\\\sharv\\\\Documents\\\\TUHH\\\\sem-3\\\\intelligent systems in medicine\\\\project\\\\baselines\\\\phase_1a\\\\submission\\\\utils\\\\utils.py'>"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# from submission.utils.utils import extract_features_from_image, perform_pca\n",
+    "import submission.utils.utils as utils\n",
+    "import importlib\n",
+    "importlib.reload(utils)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A.1. Extract Features for Multiclass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Features shape: (2845, 2213)\n",
+      "Labels shape: (2845,)\n",
+      "[1 1 1 ... 1 2 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import classification_report\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "\n",
+    "BASE_PATH = \"C:/Users/sharv/Documents/TUHH/sem-3/intelligent systems in medicine/project/baselines/phase_1a\"\n",
+    "PATH_TO_GT = os.path.join(BASE_PATH, \"gt_for_classification_multiclass_from_filenames_0_index.csv\")\n",
+    "PATH_TO_IMAGES = os.path.join(BASE_PATH, \"images\")\n",
+    "\n",
+    "df = pd.read_csv(PATH_TO_GT)\n",
+    "\n",
+    "images = df[\"file_name\"].tolist()\n",
+    "\n",
+    "features = []\n",
+    "labels = []\n",
+    "\n",
+    "for i in range(len(df)):\n",
+    "    \n",
+    "    image_name = df.iloc[i][\"file_name\"]\n",
+    "    label = df.iloc[i][\"category_id\"]\n",
+    "\n",
+    "    path_to_image = os.path.join(PATH_TO_IMAGES, image_name)\n",
+    "    image = cv2.imread(path_to_image)\n",
+    "    \n",
+    "    image_features = utils.extract_features_from_image(image)\n",
+    "    \n",
+    "    features.append(image_features)\n",
+    "    labels.append(label)\n",
+    "    \n",
+    "features_multiclass = np.array(features)\n",
+    "labels_multiclass = np.array(labels)\n",
+    "\n",
+    "print(\"Features shape:\", features_multiclass.shape)\n",
+    "print(\"Labels shape:\", labels_multiclass.shape)\n",
+    "print(labels_multiclass)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## B.2. Use Prinicpal Component Anaylsis to reduce dimensionality"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PCA: Reduced from 433 to 100 components\n",
+      "Explained variance: 0.9929\n"
+     ]
+    }
+   ],
+   "source": [
+    "# k = 100\n",
+    "# features_multiclass_reduced = utils.perform_pca(features_multiclass, k)\n",
+    "\n",
+    "# did not perform psc for training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# C. Train Classification Model for Multiclass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Accuracy: 0.9666\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.98      0.95      0.96       167\n",
+      "           1       0.95      0.98      0.97       253\n",
+      "           2       0.99      0.96      0.97       149\n",
+      "\n",
+      "    accuracy                           0.97       569\n",
+      "   macro avg       0.97      0.96      0.97       569\n",
+      "weighted avg       0.97      0.97      0.97       569\n",
+      "\n",
+      "Confusion matrix:\n",
+      " [[158   9   0]\n",
+      " [  2 249   2]\n",
+      " [  1   5 143]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "multiclass_model, _, _ = utils.train_svm_model(features_multiclass, labels_multiclass)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Pipeline(steps=[('scaler', StandardScaler()), ('select', SelectKBest(k=500)),\n",
+      "                ('pca', PCA(n_components=100)),\n",
+      "                ('svc',\n",
+      "                 SVC(class_weight='balanced', kernel='linear', probability=True,\n",
+      "                     random_state=42))])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(multiclass_model)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# save the weights of multiclass_model\n",
+    "import pickle\n",
+    "\n",
+    "SAVE_PATH = \"C:/Users/sharv/Documents/TUHH/sem-3/intelligent systems in medicine/project/baselines/phase_1a/submission\"\n",
+    "\n",
+    "with open(os.path.join(SAVE_PATH, \"multiclass_model.pkl\"), \"wb\") as f:\n",
+    "    pickle.dump(multiclass_model, f)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ism",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.25"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

script.py

@@ -3,39 +3,29 @@ import pickle
 import cv2
 import pandas as pd
 import numpy as np
-from utils.utils import extract_features_from_image, perform_pca, train_svm_model
+from utils.utils import extract_features_from_image
 
 
-def run_inference(TEST_IMAGE_PATH, svm_model, k, SUBMISSION_CSV_SAVE_PATH):
-
-    test_images = os.listdir(TEST_IMAGE_PATH)
-    test_images.sort()
+def run_inference(TEST_IMAGE_PATH, pipeline_model, SUBMISSION_CSV_SAVE_PATH):
+    test_images = sorted(os.listdir(TEST_IMAGE_PATH))
     
     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)
-        image_features = extract_features_from_image(image)
-        
-        image_feature_list.append(image_features)
-        
+        features = extract_features_from_image(image)
+        image_feature_list.append(features)
+
     features_multiclass = np.array(image_feature_list)
-    
-    features_multiclass_reduced = perform_pca(features_multiclass, k)
-    
-    multiclass_predictions = svm_model.predict(features_multiclass_reduced)
 
-    df_predictions = pd.DataFrame(columns=["file_name", "category_id"])
+    multiclass_predictions = pipeline_model.predict(features_multiclass)
+
+    df_predictions = pd.DataFrame({
+        "file_name": test_images,
+        "category_id": multiclass_predictions
+    })
 
-    for i in range(len(test_images)):
-        file_name = test_images[i]
-        new_row = pd.DataFrame({"file_name": file_name,
-                                "category_id": multiclass_predictions[i]}, index=[0])
-        df_predictions = pd.concat([df_predictions, new_row], ignore_index=True)
-        
     df_predictions.to_csv(SUBMISSION_CSV_SAVE_PATH, index=False)
     
     

utils/utils.py

@@ -2,131 +2,144 @@ import cv2
 import numpy as np
 from skimage.feature.texture import graycomatrix, graycoprops
 from skimage.feature import local_binary_pattern ,hog
-from skimage.feature import local_binary_pattern
 from sklearn.decomposition import PCA
 from sklearn.svm import SVC
-from sklearn.model_selection import GridSearchCV
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import accuracy_score
+from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+from sklearn.feature_selection import SelectKBest, f_classif
 from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import classification_report
+from sklearn.pipeline import Pipeline 
 
-
-def rgb_histogram(image, bins=64):
+def rgb_histogram(image, bins=32):
     features = []
-    
-    # RGB histograms (reduced bins)
     for i in range(3):
         hist = cv2.calcHist([image], [i], None, [bins], [0, 256])
         hist = cv2.normalize(hist, hist).flatten()
         features.extend(hist)
-    
-    # HSV color space (more discriminative)
-    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-    for i in range(3):
-        hist = cv2.calcHist([hsv], [i], None, [bins], [0, 256])
+        
+    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) 
+    h_hist = cv2.calcHist([hsv], [0], None, [bins], [0, 180])
+    s_hist = cv2.calcHist([hsv], [1], None, [bins], [0, 256])
+    v_hist = cv2.calcHist([hsv], [2], None, [bins], [0, 256])
+    for hist in (h_hist, s_hist, v_hist):
         hist = cv2.normalize(hist, hist).flatten()
         features.extend(hist)
-    
-    # Color moments (mean, std for each channel)
+        
     for i in range(3):
         channel = image[:, :, i].astype(np.float32)
         features.append(np.mean(channel))
         features.append(np.std(channel))
         features.append(np.median(channel))
-    
+
     return np.array(features)
 
+
 def hu_moments(image):
-    # Convert to grayscale if the image is in RGB format
     gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     moments = cv2.moments(gray)
     hu_moments = cv2.HuMoments(moments).flatten()
-    # Apply log transform to reduce scale variance
     hu_moments = -np.sign(hu_moments) * np.log10(np.abs(hu_moments) + 1e-10)
     return hu_moments
 
-def glcm_features(image, distances=[1], angles=[0], levels=256, symmetric=True, normed=True):
-# Multiple distance-angle combinations for texture diversity 
+def glcm_features_improved(image):
     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):  #Higher P and R
+    
+    gray = (gray // 4).astype(np.uint8)
+    
+    features = []
+    for distance in [1, 3]:
+        for angle in [0, np.pi/4, np.pi/2, 3*np.pi/4]:
+            glcm = graycomatrix(gray, distances=[distance], angles=[angle], 
+                            levels=64, symmetric=True, normed=True)
+            
+            props = ['contrast', 'dissimilarity', 'homogeneity', 'energy', 'correlation']
+            for prop in props:
+                feature_val = graycoprops(glcm, prop).flatten()
+                features.extend(feature_val)
+    
+    return np.array(features)
+
+def local_binary_pattern_features(image, P=8, R=1):
     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
 
-
-
-#  Edge Density (Canny-based)
-
 def edge_density(image, low_threshold=50, high_threshold=150):
-    
     gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     edges = cv2.Canny(gray, low_threshold, high_threshold)
     density = np.sum(edges > 0) / edges.size
     return np.array([density])
 
-
-
-
-def hog_features(image, pixels_per_cell=(64, 64), cells_per_block=(1, 1), orientations=4):
-    """
-    Highly compressed HOG features to prevent overfitting
-    """
+def hog_features(image, pixels_per_cell=(32, 32), cells_per_block=(1, 1), orientations=8):
     image_resized = cv2.resize(image, (128, 128))
     gray = cv2.cvtColor(image_resized, cv2.COLOR_RGB2GRAY)
+    
+    # More detailed HOG parameters
     hog_feat = hog(gray,
-                orientations=orientations,
-                pixels_per_cell=pixels_per_cell,
-                cells_per_block=cells_per_block,
+                orientations=9,          
+                pixels_per_cell=(16, 16), 
+                cells_per_block=(2, 2),   
                 block_norm='L2-Hys',
-                feature_vector=True)
+                feature_vector=True,
+                transform_sqrt=True)      
     return hog_feat
 
+def spatial_pyramid_features(image, levels=2):
+    features = []
+    h, w = image.shape[:2]
+    
+    for level in range(levels):
+        num_rows = 2 ** level
+        num_cols = 2 ** level
+        
+        for i in range(num_rows):
+            for j in range(num_cols):
+                row_start = int(i * h / num_rows)
+                row_end = int((i + 1) * h / num_rows)
+                col_start = int(j * w / num_cols)
+                col_end = int((j + 1) * w / num_cols)
+                
+                patch = image[row_start:row_end, col_start:col_end]
+                if patch.size > 0:
+                    patch_features = rgb_histogram(patch, bins=32)
+                    features.extend(patch_features)
+    
+    return np.array(features)
 
 def extract_features_from_image(image):
-    
-    # 1. RGB Histogram
+    """
+    Select best features using correlation removal and ANOVA F-test
+    """
+    #1. RGB Histogram
     hist_features = rgb_histogram(image)
     
-    
     # 2. Hu Moments
     hu_features = hu_moments(image)
     
-    # 3. GLCM Features
-    glcm_features_vector = glcm_features(image)
-    
-    # 4. Local Binary Pattern (LBP)
-    lbp_features = local_binary_pattern_features(image)
+    # 3. GLCM Features with multiple distances/angles
+    glcm_features_vector = glcm_features_improved(image)
     
-
-    #### Add more feature extraction methods here ####
-    
-    edge_feat = edge_density(image)
+    # 4. Improved HOG
     hog_feat = hog_features(image)
-
     
-    ##################################################
+    # 5. Spatial pyramid (level 1 only for efficiency)
+    spatial_feat = spatial_pyramid_features(image, levels=1)
     
+    # Remove less important features to reduce noise
+    # Consider removing edge_density or LBP if they don't help
     
-    # Concatenate all feature vectors
-    image_features = np.concatenate([hist_features, hu_features, glcm_features_vector, lbp_features
-                                    ,edge_feat,hog_feat])
+    # Concatenate selected features
+    image_features = np.concatenate([
+        hist_features, 
+        hu_features, 
+        glcm_features_vector, 
+        hog_feat,
+        spatial_feat
+    ])
     
-
     return image_features
 
-
-
 def perform_pca(data, num_components):
     # Clean data
     data = np.nan_to_num(data, nan=0.0, posinf=0.0, neginf=0.0)
@@ -145,53 +158,58 @@ def perform_pca(data, num_components):
     
     return data_reduced
 
-
-def train_svm_model(features, labels, test_size=0.2, k=100):
+def train_svm_model(features, labels,
+                            test_size=0.2,
+                            random_state=42,
+                            use_selectkbest=True,
+                            k_best=500,
+                            n_pca_components=100,
+                            do_gridsearch=False):
     """
-    Trains an SVM model and returns the trained model.
-
-    Parameters:
-    - features: Feature matrix of shape (B, F)
-    - labels: Label matrix of shape (B, C) if one-hot encoded, or (B,) for single labels
-    - test_size: Proportion of the data to use for testing (default is 0.2)
-
     Returns:
-    - svm_model: Trained SVM model
+    pipeline: trained sklearn Pipeline (scaler -> optional SelectKBest -> PCA -> SVC)
+    X_test, y_test, y_pred for quick evaluation
+    grid_search (if do_gridsearch True), else None
     """
-    # Check if labels are one-hot encoded, convert if needed
     if labels.ndim > 1 and labels.shape[1] > 1:
-        labels = np.argmax(labels, axis=1)  # Convert one-hot to single label per sample
-
-    # Split the data into training and testing sets
-    X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=test_size, random_state=42)
-    
-    # ---------- FIX 1: Standardize TRAIN ONLY ----------
-    scaler = StandardScaler()
-    X_train_scaled = scaler.fit_transform(X_train)
-    X_test_scaled = scaler.transform(X_test)
-
-    # ---------- FIX 2: PCA fit ONLY on TRAIN ----------
-    pca = PCA(n_components=min(k, X_train_scaled.shape[1]))
-    X_train_reduced = pca.fit_transform(X_train_scaled)
-    X_test_reduced = pca.transform(X_test_scaled)
-    
-    # SVM GridSearch
-    param_grid = {
-        'C': [0.1, 1],
-        'gamma': [0.001, 0.0001],
-        'kernel': ['rbf']
-    }
-    grid = GridSearchCV(SVC(), param_grid, refit=True, verbose=3)
-    grid.fit(X_train_reduced, y_train)
+        labels = np.argmax(labels, axis=1)
+
+    # stratified split
+    X_train, X_test, y_train, y_test = train_test_split(
+        features, labels, test_size=test_size, random_state=random_state, stratify=labels)
+
+    # build pipeline steps
+    steps = []
+    steps.append(('scaler', StandardScaler()))
+    if use_selectkbest:
+        steps.append(('select', SelectKBest(score_func=f_classif, k=min(k_best, X_train.shape[1]))))
+    steps.append(('pca', PCA(n_components=min(n_pca_components, X_train.shape[1]))))
+    steps.append(('svc', SVC(kernel='linear', probability=True, class_weight='balanced', random_state=random_state)))
+    pipeline = Pipeline(steps)
+
+    grid_search = None
+    if do_gridsearch:
+        param_grid = {
+            'select__k': [int(min(200, X_train.shape[1])), int(min(500, X_train.shape[1])), int(min(1000, X_train.shape[1]))] if use_selectkbest else [],
+            'pca__n_components': [50, 100, 200],
+            'svc__C': [0.1, 1, 5, 10]
+        }
+        # remove empty keys if use_selectkbest is False
+        param_grid = {k: v for k, v in param_grid.items() if v}
+        cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state)
+        grid_search = GridSearchCV(pipeline, param_grid, cv=cv, n_jobs=-1, scoring='accuracy', verbose=2)
+        grid_search.fit(X_train, y_train)
+        best_model = grid_search.best_estimator_
+        pipeline = best_model
+    else:
+        pipeline.fit(X_train, y_train)
 
     # Evaluate
-    preds = grid.predict(X_test_reduced)
-    report = classification_report(y_test, preds)
-
-    # Return EVERYTHING needed for inference
-    return {
-        "svm": grid,
-        "scaler": scaler,
-        "pca": pca,
-        "report": report
-    }
+    y_pred = pipeline.predict(X_test)
+    acc = accuracy_score(y_test, y_pred)
+    print(f"Test Accuracy: {acc:.4f}")
+    print(classification_report(y_test, y_pred))
+    print("Confusion matrix:\n", confusion_matrix(y_test, y_pred))
+
+    return pipeline, (X_test, y_test, y_pred), grid_search
+