New

multiclass_model.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4d799eecd128c540ab311a7cb77db6ae088d9b8159a2a6d7f04238ea7859e4d6
-size 1178808
+oid sha256:6a97e0d9147fd9f3a5750bf863d4fc36eb3de0a60dd4b8952cb7daca408acdc6
+size 665737

phase_1a_sample_solution_multiclass.ipynb

@@ -0,0 +1,191 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# A. Extract Features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "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": 39,
+     "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": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Features shape: (2845, 2013)\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. Train Classification Model for Multiclass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Accuracy: 0.9666\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.97      0.95      0.96       167\n",
+      "           1       0.95      0.98      0.96       253\n",
+      "           2       0.99      0.97      0.98       149\n",
+      "\n",
+      "    accuracy                           0.97       569\n",
+      "   macro avg       0.97      0.97      0.97       569\n",
+      "weighted avg       0.97      0.97      0.97       569\n",
+      "\n",
+      "Confusion matrix:\n",
+      " [[158   9   0]\n",
+      " [  5 247   1]\n",
+      " [  0   4 145]]\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)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "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"
+   ]
+  }
+ ],
+ "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.py → utils/utils.py

@@ -2,86 +2,87 @@ 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)
+
+    # Convert to float32 for stability
+    image = image.astype(np.float32)
+
+    # RGB histograms
     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 histograms
+    hsv = cv2.cvtColor(image.astype(np.uint8), cv2.COLOR_RGB2HSV)
+    for i, (low, high) in enumerate(zip([0, 0, 0], [180, 256, 256])):
+        hist = cv2.calcHist([hsv], [i], None, [bins], [low, high])
         hist = cv2.normalize(hist, hist).flatten()
         features.extend(hist)
-    
-    # Color moments (mean, std for each channel)
+
+    # Color moments (mean, std, skew)
     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))
-    
+        channel = image[:, :, i]
+        mean = np.mean(channel)
+        std = np.std(channel)
+        skew = np.cbrt(np.mean((channel - mean) ** 3))  
+        features.extend([mean, std, skew])
+
     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
+    hu = cv2.HuMoments(moments).flatten()
+    hu = -np.sign(hu) * np.log10(np.abs(hu) + 1e-10)
+    # Clip extreme values to reduce sensitivity to noise
+    hu = np.clip(hu, -10, 10)
+    return hu
+
 
-def glcm_features(image, distances=[1], angles=[0], levels=256, symmetric=True, normed=True):
-# Multiple distance-angle combinations for texture diversity 
+def glcm_features(image, distances=[1, 2], angles=[0, np.pi/4, np.pi/2], levels=64):
     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 // (256 // levels)).astype(np.uint8)  # quantization
+    features = []
+
+    for d in distances:
+        for a in angles:
+            glcm = graycomatrix(gray, distances=[d], angles=[a], levels=levels, symmetric=True, normed=True)
+            props = ['contrast', 'dissimilarity', 'homogeneity', 'energy', 'correlation']
+            for p in props:
+                val = graycoprops(glcm, p).flatten()
+                features.extend(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)
+    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=(16,16), cells_per_block=(2,2), orientations=9):
     image_resized = cv2.resize(image, (128, 128))
     gray = cv2.cvtColor(image_resized, cv2.COLOR_RGB2GRAY)
     hog_feat = hog(gray,
@@ -89,43 +90,20 @@ def hog_features(image, pixels_per_cell=(64, 64), cells_per_block=(1, 1), orient
                 pixels_per_cell=pixels_per_cell,
                 cells_per_block=cells_per_block,
                 block_norm='L2-Hys',
+                transform_sqrt=True,
                 feature_vector=True)
     return hog_feat
 
 
 def extract_features_from_image(image):
-    
-    # 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)
-    
-
-    #### Add more feature extraction methods here ####
-    
-    edge_feat = edge_density(image)
-    hog_feat = hog_features(image)
-
-    
-    ##################################################
-    
-    
-    # Concatenate all feature vectors
-    image_features = np.concatenate([hist_features, hu_features, glcm_features_vector, lbp_features
-                                    ,edge_feat,hog_feat])
-    
-
-    return image_features
-
+    hist = rgb_histogram(image)
+    hu = hu_moments(image)
+    glcm = glcm_features(image)
+    lbp = local_binary_pattern_features(image)
+    edge = edge_density(image)
+    hog_f = hog_features(image)
 
+    return np.concatenate([hist, hu, glcm, lbp, edge, hog_f])
 
 def perform_pca(data, num_components):
     # Clean data
@@ -145,53 +123,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
+        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)
 
-    # 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)
+    # Evaluate
+    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))
 
-    # ---------- 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)
+    return pipeline, (X_test, y_test, y_pred), grid_search
 
-    # 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
-    }