model

Dockerfile

@@ -1,26 +1,28 @@
 FROM python:3.10-slim
- 
+
+# HF Spaces runs as a non-root user — this satisfies that requirement
 RUN useradd -m -u 1000 user
- 
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Install system deps needed by OpenCV
 USER root
 RUN apt-get update && apt-get install -y --no-install-recommends \
     libgl1 libglib2.0-0 libsm6 libxrender1 libxext6 \
     && rm -rf /var/lib/apt/lists/*
- 
 USER user
-ENV PATH="/home/user/.local/bin:$PATH"
-# Force Python to print immediately — critical for HF health checks
-ENV PYTHONUNBUFFERED=1
- 
-WORKDIR /app
- 
+
+# Install Python deps
 COPY --chown=user requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
- 
+
+# Copy app source and model files
 COPY --chown=user server.py .
 COPY --chown=user models/ ./models/
- 
+
+# HF Spaces expects the app to listen on port 7860
 EXPOSE 7860
- 
+
 CMD ["python", "server.py"]
- 

models/fruit_scaler.pkl → fruit_scaler.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6d1cd1cb11554763b0f4faf6929a1f51f7f9df02a9922bc0a43a1733784fe59b
+oid sha256:3bb0916407d9add3c50e3c21702469ceb4876d36396f98817fb8b611f15c2cc6
 size 1727

models/fruit_svm_model.pkl → fruit_svm_model.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1232a94b63165c7b28a015bcd4d590b680e3e66046631b13625497aec433111d
-size 1520567
+oid sha256:ea2d01f044eda5da5d9c96545a0f455a9a08b39af321ecb355e37a0c6b29eb3a
+size 1736471

server.py

@@ -9,7 +9,7 @@ from flask import Flask, request, jsonify, render_template
 
 app = Flask(__name__)
 
-# ─── Konfigurasi Path Model (Gunakan Absolute Path agar aman) ────────────────
+# ─── Konfigurasi Path Model (Gunakan Absolute Path agar aman) ─────────────────
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 MODEL_PATH  = os.path.join(BASE_DIR, "models", "fruit_svm_model.pkl")
 SCALER_PATH = os.path.join(BASE_DIR, "models", "fruit_scaler.pkl")
@@ -55,92 +55,54 @@ def map_kaggle_label(raw_label):
     return f"{ft}_{rs}", ft, rs
 
 
-# ─── Feature extraction — exact copy dari notebook (GrabCut version) ─────────
+# ─── Feature extraction — exact copy dari Cell 2 notebook ────────────────────
 def extract_features_from_array(img_array, size=(128, 128)):
     img_resized = cv2.resize(img_array, size)
     gray    = cv2.cvtColor(img_resized, cv2.COLOR_BGR2GRAY)
     blurred = cv2.GaussianBlur(gray, (5, 5), 0)
 
-    # ── Segmentation: GrabCut (matches notebook) ──────────────────────────────
-    h, w = blurred.shape[:2]
-    margin = int(min(h, w) * 0.085)
-    rect = (margin, margin, w - margin * 2, h - margin * 2)
-    mask      = np.zeros(blurred.shape[:2], np.uint8)
-    bgd_model = np.zeros((1, 65), np.float64)
-    fgd_model = np.zeros((1, 65), np.float64)
-    cv2.grabCut(img_resized, mask, rect, bgd_model, fgd_model,
-                iterCount=20, mode=cv2.GC_INIT_WITH_RECT)
-    mask2 = np.where((mask == 2) | (mask == 0), 0, 255).astype('uint8')
-
-    # ── Shape features ────────────────────────────────────────────────────────
-    contours, _ = cv2.findContours(mask2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    _, mask = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     aspect_ratio, extent = 0, 0
     if contours:
         c = max(contours, key=cv2.contourArea)
-        x, y, bw, bh = cv2.boundingRect(c)
-        aspect_ratio = float(bw) / bh if bh != 0 else 0
-        area      = cv2.contourArea(c)
-        rect_area = bw * bh
-        extent    = float(area) / rect_area if rect_area != 0 else 0
+        x, y, w, h = cv2.boundingRect(c)
+        aspect_ratio = float(w) / h if h != 0 else 0
+        area = cv2.contourArea(c)
+        rect_area = w * h
+        extent = float(area) / rect_area if rect_area != 0 else 0
 
-    fp = mask2 > 0
+    fp = mask > 0
 
-    # ── HSV color features (6) ────────────────────────────────────────────────
+    # HSV (6)
     hsv = cv2.cvtColor(img_resized, cv2.COLOR_BGR2HSV)
     h_ch, s_ch, v_ch = cv2.split(hsv)
     hsv_feats = [
-        np.mean(h_ch[fp]) if fp.any() else 0,
-        np.mean(s_ch[fp]) if fp.any() else 0,
-        np.mean(v_ch[fp]) if fp.any() else 0,
-        np.std(h_ch[fp])  if fp.any() else 0,
-        np.std(s_ch[fp])  if fp.any() else 0,
-        np.std(v_ch[fp])  if fp.any() else 0,
+        np.mean(h_ch[fp]) if fp.any() else 0, np.mean(s_ch[fp]) if fp.any() else 0,
+        np.mean(v_ch[fp]) if fp.any() else 0, np.std(h_ch[fp])  if fp.any() else 0,
+        np.std(s_ch[fp])  if fp.any() else 0, np.std(v_ch[fp])  if fp.any() else 0,
     ]
 
-    # ── LAB color features (5) ────────────────────────────────────────────────
+    # LAB (5) ← NEW
     lab = cv2.cvtColor(img_resized, cv2.COLOR_BGR2LAB)
     l_ch, a_ch, b_ch = cv2.split(lab)
     lab_feats = [
-        np.mean(l_ch[fp]) if fp.any() else 0,
-        np.mean(a_ch[fp]) if fp.any() else 0,
-        np.mean(b_ch[fp]) if fp.any() else 0,
-        np.std(a_ch[fp])  if fp.any() else 0,
+        np.mean(l_ch[fp]) if fp.any() else 0, np.mean(a_ch[fp]) if fp.any() else 0,
+        np.mean(b_ch[fp]) if fp.any() else 0, np.std(a_ch[fp])  if fp.any() else 0,
         np.std(b_ch[fp])  if fp.any() else 0,
     ]
 
-    # ── Hue histogram 18 bins (18) ────────────────────────────────────────────
-    # NOTE: uses mask2 (uint8 0/255) as the cv2.calcHist mask — matches notebook
-    h_hist = cv2.calcHist([h_ch], [0], mask2, [18], [0, 180])
+    # Hue histogram 18 bins (18) ← NEW
+    h_hist = cv2.calcHist([h_ch], [0], mask, [18], [0, 180])
     h_hist = cv2.normalize(h_hist, h_hist).flatten().tolist()
 
-    # ── GLCM texture (6) ──────────────────────────────────────────────────────
-    # Crop to bounding box of mask, inpaint background pixels, then quantise.
-    # This exactly replicates the notebook's GLCM pipeline.
-    x, y, bw, bh = cv2.boundingRect(mask2)
-    if bw > 0 and bh > 0:
-        gray_crop    = gray[y:y + bh, x:x + bw]
-        mask_crop    = mask2[y:y + bh, x:x + bw]
-        masked_gray_raw = np.where(mask_crop > 0, gray_crop, 0).astype(np.uint8)
-        inv_mask_crop   = cv2.bitwise_not(mask_crop)
-        if np.count_nonzero(inv_mask_crop) > 0:
-            inpainted = cv2.inpaint(masked_gray_raw, inv_mask_crop,
-                                    inpaintRadius=1, flags=cv2.INPAINT_TELEA)
-            masked_gray = inpainted if inpainted is not None else masked_gray_raw
-        else:
-            masked_gray = masked_gray_raw
-    else:
-        # GrabCut returned empty mask — fall back to full grayscale
-        masked_gray = gray
-
-    masked_gray_q = (masked_gray // 8).astype(np.uint8)
-    valid_pixels  = masked_gray_q[masked_gray_q > 0]
-    if valid_pixels.size < 100:
-        # Fallback: use full unmasked grayscale
-        glcm_input = (gray // 8).astype(np.uint8)
-    else:
-        glcm_input = masked_gray_q
-
-    glcm = graycomatrix(glcm_input, distances=[1, 3, 5],
+    # GLCM with distances=[1,3,5], 4 angles, 6 props (6) ← EXPANDED
+    # Quantise to 32 levels: reduces sparsity and speeds up computation.
+    # ⚠️  Must match the notebook — retrain if you change this value.
+    masked_gray = cv2.bitwise_and(gray, gray, mask=mask).astype(np.uint8)
+    masked_gray = (masked_gray // 8).astype(np.uint8)   # 256 → 32 levels
+    glcm = graycomatrix(masked_gray, distances=[1, 3, 5],
                         angles=[0, np.pi/4, np.pi/2, 3*np.pi/4],
                         levels=32, symmetric=True, normed=True)
     glcm_feats = [
@@ -148,23 +110,23 @@ def extract_features_from_array(img_array, size=(128, 128)):
         graycoprops(glcm, 'correlation').mean(),
         graycoprops(glcm, 'energy').mean(),
         graycoprops(glcm, 'homogeneity').mean(),
-        graycoprops(glcm, 'dissimilarity').mean(),
-        graycoprops(glcm, 'ASM').mean(),
+        graycoprops(glcm, 'dissimilarity').mean(),  # NEW
+        graycoprops(glcm, 'ASM').mean(),             # NEW
     ]
 
-    # ── LBP texture 10 bins (10) ──────────────────────────────────────────────
+    # LBP histogram 10 bins (10) ← NEW
     lbp = local_binary_pattern(gray, P=8, R=1, method='uniform')
     lbp_pixels = lbp[fp] if fp.any() else lbp.ravel()
     lbp_hist, _ = np.histogram(lbp_pixels, bins=10, range=(0, 10), density=True)
 
     features = hsv_feats + lab_feats + h_hist + glcm_feats + lbp_hist.tolist() + [aspect_ratio, extent]
-
-    # raw dict for frontend display
+    
+    # raw dict for frontend display (keep the same keys you already use)
     raw = {
         'h_mean': hsv_feats[0], 's_mean': hsv_feats[1], 'v_mean': hsv_feats[2],
         'h_std':  hsv_feats[3], 's_std':  hsv_feats[4], 'v_std':  hsv_feats[5],
         'contrast': glcm_feats[0], 'correlation': glcm_feats[1],
-        'energy': glcm_feats[2],   'homogeneity': glcm_feats[3],
+        'energy': glcm_feats[2], 'homogeneity': glcm_feats[3],
         'aspect_ratio': aspect_ratio, 'extent': extent,
     }
     return features, raw
@@ -277,10 +239,10 @@ def predict():
         return jsonify({'error': str(e)}), 500
 
 
-# ─── Run ────────────────────────────────────────────────────────────────────
+# ─── Run ─────────────────────────────────────────────────────────────────────
 if __name__ == '__main__':
     print("=" * 60)
     print("RIPE.AI — Flask API Server")
     print("=" * 60)
     print(f"Model loaded: {model_loaded}")
-    app.run(host='0.0.0.0', port=7860, debug=False)
+    app.run(host='0.0.0.0', port=5000, debug=False)