Add changes

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

@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
@@ -18,7 +18,7 @@
        "<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,
+     "execution_count": 39,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -39,14 +39,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Features shape: (2845, 2213)\n",
+      "Features shape: (2845, 2013)\n",
       "Labels shape: (2845,)\n",
       "[1 1 1 ... 1 2 1]\n"
      ]
@@ -96,40 +96,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## B.2. Use Prinicpal Component Anaylsis to reduce dimensionality"
+    "# B. Train Classification Model for Multiclass"
    ]
   },
   {
    "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,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
@@ -139,18 +111,18 @@
       "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",
+      "           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.96      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",
-      " [  2 249   2]\n",
-      " [  1   5 143]]\n"
+      " [  5 247   1]\n",
+      " [  0   4 145]]\n"
      ]
     }
    ],
@@ -176,12 +148,12 @@
     }
    ],
    "source": [
-    "print(multiclass_model)\n"
+    "print(multiclass_model)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -193,13 +165,6 @@
     "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": {

utils/utils.py

@@ -10,26 +10,33 @@ from sklearn.feature_selection import SelectKBest, f_classif
 from sklearn.preprocessing import StandardScaler
 from sklearn.pipeline import Pipeline 
 
+
 def rgb_histogram(image, bins=32):
     features = []
+
+    # 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 = 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):
+
+    # 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, 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)
 
@@ -37,108 +44,66 @@ def rgb_histogram(image, bins=32):
 def hu_moments(image):
     gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     moments = cv2.moments(gray)
-    hu_moments = cv2.HuMoments(moments).flatten()
-    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_improved(image):
+def glcm_features(image, distances=[1, 2], angles=[0, np.pi/4, np.pi/2], levels=64):
     gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    
-    gray = (gray // 4).astype(np.uint8)
-    
+    gray = (gray // (256 // levels)).astype(np.uint8)  # quantization
     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)
-            
+
+    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 prop in props:
-                feature_val = graycoprops(glcm, prop).flatten()
-                features.extend(feature_val)
-    
+            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=(32, 32), cells_per_block=(1, 1), orientations=8):
+
+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)
-    
-    # More detailed HOG parameters
     hog_feat = hog(gray,
-                orientations=9,          
-                pixels_per_cell=(16, 16), 
-                cells_per_block=(2, 2),   
+                orientations=orientations,
+                pixels_per_cell=pixels_per_cell,
+                cells_per_block=cells_per_block,
                 block_norm='L2-Hys',
-                feature_vector=True,
-                transform_sqrt=True)      
+                transform_sqrt=True,
+                feature_vector=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):
-    """
-    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 with multiple distances/angles
-    glcm_features_vector = glcm_features_improved(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 selected features
-    image_features = np.concatenate([
-        hist_features, 
-        hu_features, 
-        glcm_features_vector, 
-        hog_feat,
-        spatial_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