Upload 3 files

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

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

@@ -0,0 +1,180 @@
+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, 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.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 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]
+        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):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    moments = cv2.moments(gray)
+    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, 2], angles=[0, np.pi/4, np.pi/2], levels=64):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    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)
+    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=(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,
+                orientations=orientations,
+                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):
+    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
+    data = np.nan_to_num(data, nan=0.0, posinf=0.0, neginf=0.0)
+    
+    # Standardize
+    scaler = StandardScaler()
+    data_standardized = scaler.fit_transform(data)
+    
+    # Apply PCA
+    k = min(num_components, data.shape[1])
+    pca = PCA(n_components=k)
+    data_reduced = pca.fit_transform(data_standardized)
+    
+    print(f"PCA: Reduced from {data.shape[1]} to {k} components")
+    print(f"Explained variance: {np.sum(pca.explained_variance_ratio_):.4f}")
+    
+    return data_reduced
+
+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):
+    """
+    Returns:
+    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
+    """
+    if labels.ndim > 1 and labels.shape[1] > 1:
+        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
+    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
+