clean initial commit without large files

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,20 @@
+# environment
+venv/
+.venv/
+
+# ML / MLflow
+mlflow/
+mlartifacts/
+*.keras
+*.h5
+*.pkl
+
+
+
+# Python cache
+__pycache__/
+*.pyc
+
+# IDE
+.vscode/
+.idea/

.ipynb_checkpoints/Untitled-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

README.md

@@ -0,0 +1,12 @@
+---
+title: Api
+emoji: 🏆
+colorFrom: yellow
+colorTo: pink
+sdk: docker
+pinned: false
+license: mit
+short_description: fast api for models
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Untitled.ipynb

@@ -0,0 +1,52 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "eeb7310e-a5e5-48c0-8bc3-377ecb7a50f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3.12.8 | packaged by Anaconda, Inc. | (main, Dec 11 2024, 16:48:34) [MSC v.1929 64 bit (AMD64)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "print(sys.version)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ef6e852-34a0-43c6-ab8c-412d16b91f6e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:base] *",
+   "language": "python",
+   "name": "conda-base-py"
+  },
+  "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.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

api

@@ -0,0 +1 @@
+Subproject commit e5938764404acd99fb31c8d96a34ce53099c9c5e

app/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,9 @@
+from .configs import get_classification_model, get_segmentation_model
+from .models import PredictionResponse, HistoryItem
+
+__all__ = [
+    "get_classification_model",
+    "get_segmentation_model",
+    "PredictionResponse",
+    "HistoryItem"
+]

app/.ipynb_checkpoints/configs-checkpoint.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+import mlflow
+import mlflow.pyfunc
+
+# =========================
+# MLflow Config
+# =========================
+MLFLOW_URI = "http://127.0.0.1:5000"
+mlflow.set_tracking_uri(MLFLOW_URI)
+
+# =========================
+# Lazy Models
+# =========================
+_classification_model: Optional[mlflow.pyfunc.PyFuncModel] = None
+_segmentation_model: Optional[mlflow.pyfunc.PyFuncModel] = None
+
+
+def get_classification_model():
+    global _classification_model
+    if _classification_model is None:
+        print(" Loading Classification Model........................\n############")
+        _classification_model = mlflow.pyfunc.load_model(
+            "models:/skin_cancer_classifier/1"
+        )
+    return _classification_model
+
+
+def get_segmentation_model():
+    global _segmentation_model
+    if _segmentation_model is None:
+        print("Loading Segmentation Model........................\n############")
+        _segmentation_model = mlflow.pyfunc.load_model(
+            "models:/skin_cancer_segmenter/1"
+        )
+    return _segmentation_model
+
+
+# =========================
+# Metadata
+# =========================
+model_classes: Dict[int, str] = {
+    0: "benign",
+    1: "malicious"
+}
+
+request_history: List[Dict[str, Any]] = []
+
+# =========================
+# Storage
+# =========================
+STORAGE_DIR = Path("storage")
+IMAGES_DIR = STORAGE_DIR / "images"
+SEGMENTS_DIR = STORAGE_DIR / "segments"
+
+for dir_path in [STORAGE_DIR, IMAGES_DIR, SEGMENTS_DIR]:
+    dir_path.mkdir(parents=True, exist_ok=True)

app/.ipynb_checkpoints/main-checkpoint.py

@@ -0,0 +1,141 @@
+import uuid
+from pathlib import Path
+from datetime import datetime
+from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException
+from typing import List
+
+from . import configs as config
+from .models import PredictionResponse, HistoryItem
+from .services.predictor import predict_image
+from .services.segmenter import run_segmentation
+
+app = FastAPI(
+    title="AI Image Classification API",
+    version="2.0.0"
+)
+
+# =========================
+# Models Status
+# =========================
+@app.get("/models/status")
+async def models_status():
+    classification_model = config.get_classification_model()
+    segmentation_model = config.get_segmentation_model()
+
+    return {
+        "classification_loaded": classification_model is not None,
+        "segmentation_loaded": segmentation_model is not None,
+        "storage_paths": {
+            "images": str(config.IMAGES_DIR),
+            "segments": str(config.SEGMENTS_DIR)
+        }
+    }
+
+# =========================
+# Prediction Endpoint
+# =========================
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...)
+):
+    file_bytes = await file.read()
+
+    #  validation
+    if len(file_bytes) > 10 * 1024 * 1024:
+        raise HTTPException(status_code=400, detail="File too large (10MB max)")
+
+    try:
+        prediction, confidence, image_path = predict_image(
+            file_bytes,
+            file.filename or "image.jpg"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    # get model 
+    model = config.get_classification_model()
+    model_version = getattr(model, "name", "mlflow-production")
+
+    #create history
+    request_id = str(uuid.uuid4())
+
+    history_item = {
+        "request_id": request_id,
+        "filename": file.filename or "image.jpg",
+        "image_path": image_path,
+        "prediction": prediction,
+        "confidence": confidence,
+        "model_version": model_version,
+        "timestamp": datetime.now().isoformat(),
+        "status": "classified",
+        "segmentation_path": None
+    }
+
+    config.request_history.append(history_item)
+
+    # run segmentation in background if needed
+    if prediction == "malicious":
+        background_tasks.add_task(
+            run_segmentation,
+            request_id,
+            Path(image_path).name,
+            image_path
+        )
+
+    return PredictionResponse(**history_item)
+
+# =========================
+# History
+# =========================
+@app.get("/history", response_model=List[HistoryItem])
+async def get_history():
+    return [HistoryItem(**item) for item in config.request_history]
+
+@app.get("/history/{request_id}", response_model=HistoryItem)
+async def get_prediction(request_id: str):
+    for item in config.request_history:
+        if item["request_id"] == request_id:
+            return HistoryItem(**item)
+
+    raise HTTPException(status_code=404, detail="Prediction not found")
+
+# =========================
+# Root
+# =========================
+@app.get("/")
+async def root():
+    class_ready = "READY" if config.get_classification_model() else "REQUIRED !!!!"
+    seg_ready = " READY" if config.get_segmentation_model() else "PTIONAL !"
+
+    return {
+        "service": "AI Image Classification API",
+        "classification": class_ready,
+        "segmentation": seg_ready,
+        "endpoint": "POST /predict",
+        "history": f"GET /history ({len(config.request_history)} records)",
+        "docs": "/docs"
+    }
+
+# =========================
+# Health Check
+# =========================
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "predict_ready": config.get_classification_model() is not None,
+        "total_predictions": len(config.request_history)
+    }
+
+# =========================
+# Run Server
+# =========================
+if __name__ == "main":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True
+    )

app/.ipynb_checkpoints/storage-checkpoint.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+import json
+from typing import List, Dict, Any
+from app.configs import IMAGES_DIR, SEGMENTS_DIR, request_history
+
+def save_image(image_bytes: bytes, filename: str) -> str:
+    """Save image to storage"""
+    image_path = IMAGES_DIR / filename
+    with open(image_path, "wb") as f:
+        f.write(image_bytes)
+    return str(image_path)
+
+def save_segmentation_result(seg_result: Dict[str, Any], request_id: str, image_filename: str) -> str:
+    """Save segmentation JSON result"""
+    seg_filename = f"{request_id}_{image_filename}_segment.json"
+    seg_path = SEGMENTS_DIR / seg_filename
+    with open(seg_path, "w") as f:
+        json.dump(seg_result, f, indent=2)
+    return str(seg_path)
+
+def update_history(request_id: str, **updates: Any) -> None:
+    """Update history item by request_id"""
+    for item in request_history:
+        if item["request_id"] == request_id:
+            item.update(updates)
+            break

app/__init__.py

@@ -0,0 +1,9 @@
+from .configs import get_classification_model, get_segmentation_model
+from .models import PredictionResponse, HistoryItem
+
+__all__ = [
+    "get_classification_model",
+    "get_segmentation_model",
+    "PredictionResponse",
+    "HistoryItem"
+]

app/configs.py

@@ -0,0 +1,121 @@
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+import mlflow
+import mlflow.pyfunc
+
+
+# =========================
+# MLflow Config
+# =========================
+
+MLFLOW_URI = "https://omarelrayes-mlflow-server.hf.space"
+
+mlflow.set_tracking_uri(
+    MLFLOW_URI
+)
+
+
+# =========================
+# Run IDs from MLflow
+# =========================
+
+CLASSIFICATION_MODEL_URI = (
+    "runs:/8cae153bb747447b9f9afa237470e00f/model"
+)
+
+
+SEGMENTATION_MODEL_URI = (
+    "runs:/49dba7de7bb04aac851201051a497bf4/model"
+)
+
+
+# =========================
+# Lazy Models
+# =========================
+
+_classification_model: Optional[
+    mlflow.pyfunc.PyFuncModel
+] = None
+
+
+_segmentation_model: Optional[
+    mlflow.pyfunc.PyFuncModel
+] = None
+
+
+
+def get_classification_model():
+
+    global _classification_model
+
+    if _classification_model is None:
+
+        print(
+            "Loading Classification Model..."
+        )
+
+        _classification_model = mlflow.pyfunc.load_model(
+            CLASSIFICATION_MODEL_URI
+        )
+
+    return _classification_model
+
+
+
+def get_segmentation_model():
+
+    global _segmentation_model
+
+    if _segmentation_model is None:
+
+        print(
+            "Loading Segmentation Model..."
+        )
+
+        _segmentation_model = mlflow.pyfunc.load_model(
+            SEGMENTATION_MODEL_URI
+        )
+
+    return _segmentation_model
+
+
+
+# =========================
+# Metadata
+# =========================
+
+model_classes: Dict[int, str] = {
+
+    0: "benign",
+    1: "malicious"
+
+}
+
+
+request_history: List[Dict[str, Any]] = []
+
+
+
+# =========================
+# Storage
+# =========================
+
+STORAGE_DIR = Path("storage")
+
+IMAGES_DIR = STORAGE_DIR / "images"
+
+SEGMENTS_DIR = STORAGE_DIR / "segments"
+
+
+
+for dir_path in [
+    STORAGE_DIR,
+    IMAGES_DIR,
+    SEGMENTS_DIR
+]:
+
+    dir_path.mkdir(
+        parents=True,
+        exist_ok=True
+    )

app/core/.ipynb_checkpoints/preprocessing-checkpoint.py

@@ -0,0 +1,9 @@
+import numpy as np
+import io
+from PIL import Image
+
+def preprocess_image(image_bytes: bytes, target_size=(224, 224)) -> np.ndarray:
+    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    image = image.resize(target_size)
+    img_array = np.array(image, dtype=np.float32) / 255.0
+    return np.expand_dims(img_array, axis=0)

app/core/.ipynb_checkpoints/validation-checkpoint.py

@@ -0,0 +1,9 @@
+import io
+from PIL import Image
+
+def is_valid_image(file_bytes: bytes) -> bool:
+    try:
+        Image.open(io.BytesIO(file_bytes)).verify()
+        return True
+    except:
+        return False

app/core/preprocessing.py

@@ -0,0 +1,9 @@
+import numpy as np
+import io
+from PIL import Image
+
+def preprocess_image(image_bytes: bytes, target_size=(224, 224)) -> np.ndarray:
+    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    image = image.resize(target_size)
+    img_array = np.array(image, dtype=np.float32) / 255.0
+    return np.expand_dims(img_array, axis=0)

app/core/validation.py

@@ -0,0 +1,9 @@
+import io
+from PIL import Image
+
+def is_valid_image(file_bytes: bytes) -> bool:
+    try:
+        Image.open(io.BytesIO(file_bytes)).verify()
+        return True
+    except:
+        return False

app/main.py

@@ -0,0 +1,140 @@
+import uuid
+from pathlib import Path
+from datetime import datetime
+from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException
+from typing import List
+
+from . import configs as config
+from .models import PredictionResponse, HistoryItem
+from .services.predictor import predict_image
+from .services.segmenter import run_segmentation
+
+app = FastAPI(
+    title="AI Image Classification API",
+    version="2.0.0"
+)
+
+# =========================
+# Models Status
+# =========================
+@app.get("/models/status")
+async def models_status():
+    classification_model = config.get_classification_model()
+    segmentation_model = config.get_segmentation_model()
+
+    return {
+        "classification_loaded": classification_model is not None,
+        "segmentation_loaded": segmentation_model is not None,
+        "storage_paths": {
+            "images": str(config.IMAGES_DIR),
+            "segments": str(config.SEGMENTS_DIR)
+        }
+    }
+
+# =========================
+# Prediction Endpoint
+# =========================
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...)
+):
+    file_bytes = await file.read()
+
+    #  validation
+    if len(file_bytes) > 10 * 1024 * 1024:
+        raise HTTPException(status_code=400, detail="File too large (10MB max)")
+
+    try:
+        prediction, confidence, image_path = predict_image(
+            file_bytes,
+            file.filename or "image.jpg"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    # get model 
+    model = config.get_classification_model()
+    model_version = getattr(model, "name", "mlflow-production")
+
+    #create history
+    request_id = str(uuid.uuid4())
+
+    history_item = {
+        "request_id": request_id,
+        "filename": file.filename or "image.jpg",
+        "image_path": image_path,
+        "prediction": prediction,
+        "confidence": confidence,
+        "model_version": model_version,
+        "timestamp": datetime.now().isoformat(),
+        "status": "classified",
+        "segmentation_path": None
+    }
+
+    config.request_history.append(history_item)
+
+    # run segmentation in background if needed
+    if prediction == "malicious":
+        background_tasks.add_task(
+            run_segmentation,
+            request_id,
+            Path(image_path).name,
+            image_path
+        )
+
+    return PredictionResponse(**history_item)
+
+# =========================
+# History
+# =========================
+@app.get("/history", response_model=List[HistoryItem])
+async def get_history():
+    return [HistoryItem(**item) for item in config.request_history]
+
+@app.get("/history/{request_id}", response_model=HistoryItem)
+async def get_prediction(request_id: str):
+    for item in config.request_history:
+        if item["request_id"] == request_id:
+            return HistoryItem(**item)
+
+    raise HTTPException(status_code=404, detail="Prediction not found")
+
+# =========================
+# Root
+# =========================
+@app.get("/")
+async def root():
+    class_ready = "READY" if config.get_classification_model() else "REQUIRED !!!!"
+    seg_ready = " READY" if config.get_segmentation_model() else "PTIONAL !"
+
+    return {
+        "service": "AI Image Classification API",
+        "classification": class_ready,
+        "segmentation": seg_ready,
+        "endpoint": "POST /predict",
+        "history": f"GET /history ({len(config.request_history)} records)",
+        "docs": "/docs"
+    }
+
+# =========================
+# Health Check
+# =========================
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "predict_ready": config.get_classification_model() is not None,
+        "total_predictions": len(config.request_history)
+    }
+
+# =========================
+# Run Server
+# =========================
+if __name__ == "main":
+    import uvicorn
+    uvicorn.run(
+    "app.main:app",
+    host="0.0.0.0",
+    port=7860
+)

app/models.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+class PredictionResponse(BaseModel):
+    request_id: str
+    filename: str
+    image_path: str
+    prediction: str
+    confidence: float
+    model_version: str
+    status: str = "completed"
+
+class HistoryItem(PredictionResponse):
+    timestamp: str
+    segmentation_path: Optional[str] = None

app/services/.ipynb_checkpoints/predictor-checkpoint.py

@@ -0,0 +1,34 @@
+import numpy as np
+from typing import Tuple
+from app.configs import get_classification_model, model_classes
+from app.storage import save_image
+from app.core.preprocessing import preprocess_image
+from app.core.validation import is_valid_image
+
+def predict_image(file_bytes: bytes, filename: str) -> Tuple[str, float, str]:
+     # checking if the image is good or no 
+    if not is_valid_image(file_bytes):
+        raise ValueError("Invalid image")
+
+    # model loading or ( vonnecting with mlflow )
+    model = get_classification_model()
+
+    if model is None:
+        raise ValueError("Classification model not loaded")
+
+    image_filename = f"{hash(filename)}.jpg"
+    image_path = save_image(file_bytes, image_filename)
+
+    img_array = preprocess_image(file_bytes)
+
+    # using the model 
+    predictions = model.predict(img_array)
+
+    confidence = float(np.max(predictions))
+    predicted_class = int(np.argmax(predictions))
+
+    prediction = model_classes.get(predicted_class, "unknown")
+
+    print(f"CLASSIFICATION: {prediction} ({confidence:.3f})")
+
+    return prediction, confidence, image_path

app/services/.ipynb_checkpoints/segmenter-checkpoint.py

@@ -0,0 +1,55 @@
+import asyncio
+import numpy as np
+from datetime import datetime
+from typing import Dict, Any
+from app.configs import get_segmentation_model
+from app.storage import save_segmentation_result, update_history
+from app.core.preprocessing import preprocess_image
+
+
+async def run_segmentation(request_id: str, image_filename: str, image_path: str):
+    print(f" SEGMENTING {request_id}.......")
+
+    await asyncio.sleep(1)
+
+    seg_result: Dict[str, Any] = {
+        "request_id": request_id,
+        "image_filename": image_filename,
+        "timestamp": datetime.now().isoformat(),
+        "detections": []
+    }
+
+    # model loading in updated way !!!!!!
+    model = get_segmentation_model()
+
+    if model is None:
+        seg_result["error"] = "Segmentation model not loaded"
+
+    else:
+        try:
+            with open(image_path, "rb") as f:
+                img_bytes = f.read()
+
+            img_array = preprocess_image(img_bytes, target_size=(256, 256))
+
+            # prediction using the function of it
+            masks = model.predict(img_array)
+
+            seg_result.update({
+                "model_used": True,
+                "masks_shape": list(masks.shape),
+                "max_confidence": float(np.max(masks))
+            })
+
+        except Exception as e:
+            seg_result["error"] = str(e)
+
+    seg_path = save_segmentation_result(seg_result, request_id, image_filename)
+
+    update_history(
+        request_id,
+        segmentation_path=seg_path,
+        status="segmented"
+    )
+
+    print(f"✅ SEGMENTATION DONE {request_id}")

app/services/predictor.py

@@ -0,0 +1,34 @@
+import numpy as np
+from typing import Tuple
+from app.configs import get_classification_model, model_classes
+from app.storage import save_image
+from app.core.preprocessing import preprocess_image
+from app.core.validation import is_valid_image
+
+def predict_image(file_bytes: bytes, filename: str) -> Tuple[str, float, str]:
+     # checking if the image is good or no 
+    if not is_valid_image(file_bytes):
+        raise ValueError("Invalid image")
+
+    # model loading or ( vonnecting with mlflow )
+    model = get_classification_model()
+
+    if model is None:
+        raise ValueError("Classification model not loaded")
+
+    image_filename = f"{hash(filename)}.jpg"
+    image_path = save_image(file_bytes, image_filename)
+
+    img_array = preprocess_image(file_bytes)
+
+    # using the model 
+    predictions = model.predict(img_array)
+
+    confidence = float(np.max(predictions))
+    predicted_class = int(np.argmax(predictions))
+
+    prediction = model_classes.get(predicted_class, "unknown")
+
+    print(f"CLASSIFICATION: {prediction} ({confidence:.3f})")
+
+    return prediction, confidence, image_path

app/services/segmenter.py

@@ -0,0 +1,55 @@
+import asyncio
+import numpy as np
+from datetime import datetime
+from typing import Dict, Any
+from app.configs import get_segmentation_model
+from app.storage import save_segmentation_result, update_history
+from app.core.preprocessing import preprocess_image
+
+
+async def run_segmentation(request_id: str, image_filename: str, image_path: str):
+    print(f" SEGMENTING {request_id}.......")
+
+    await asyncio.sleep(1)
+
+    seg_result: Dict[str, Any] = {
+        "request_id": request_id,
+        "image_filename": image_filename,
+        "timestamp": datetime.now().isoformat(),
+        "detections": []
+    }
+
+    # model loading in updated way !!!!!!
+    model = get_segmentation_model()
+
+    if model is None:
+        seg_result["error"] = "Segmentation model not loaded"
+
+    else:
+        try:
+            with open(image_path, "rb") as f:
+                img_bytes = f.read()
+
+            img_array = preprocess_image(img_bytes, target_size=(256, 256))
+
+            # prediction using the function of it
+            masks = model.predict(img_array)
+
+            seg_result.update({
+                "model_used": True,
+                "masks_shape": list(masks.shape),
+                "max_confidence": float(np.max(masks))
+            })
+
+        except Exception as e:
+            seg_result["error"] = str(e)
+
+    seg_path = save_segmentation_result(seg_result, request_id, image_filename)
+
+    update_history(
+        request_id,
+        segmentation_path=seg_path,
+        status="segmented"
+    )
+
+    print(f"✅ SEGMENTATION DONE {request_id}")

app/storage.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+import json
+from typing import List, Dict, Any
+from app.configs import IMAGES_DIR, SEGMENTS_DIR, request_history
+
+def save_image(image_bytes: bytes, filename: str) -> str:
+    """Save image to storage"""
+    image_path = IMAGES_DIR / filename
+    with open(image_path, "wb") as f:
+        f.write(image_bytes)
+    return str(image_path)
+
+def save_segmentation_result(seg_result: Dict[str, Any], request_id: str, image_filename: str) -> str:
+    """Save segmentation JSON result"""
+    seg_filename = f"{request_id}_{image_filename}_segment.json"
+    seg_path = SEGMENTS_DIR / seg_filename
+    with open(seg_path, "w") as f:
+        json.dump(seg_result, f, indent=2)
+    return str(seg_path)
+
+def update_history(request_id: str, **updates: Any) -> None:
+    """Update history item by request_id"""
+    for item in request_history:
+        if item["request_id"] == request_id:
+            item.update(updates)
+            break

main.py

@@ -0,0 +1,316 @@
+import os
+import uuid
+import asyncio
+import random
+import json
+import numpy as np
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any, Optional, Tuple
+from PIL import Image
+from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException
+from pydantic import BaseModel
+import io
+import tensorflow as tf
+from tensorflow import keras
+
+# ========================================
+# CONFIGURATION
+# ========================================
+app = FastAPI(title="AI Image Classification + Segmentation (Keras)", version="2.0.0")
+
+# Storage directories
+STORAGE_DIR = Path("storage")
+CLASSIFICATION_MODELS_DIR = STORAGE_DIR / "models" / "classification"
+SEGMENTATION_MODELS_DIR = STORAGE_DIR / "models" / "segmentation"
+IMAGES_DIR = STORAGE_DIR / "images"
+SEGMENTS_DIR = STORAGE_DIR / "segments"
+
+# Create directories
+for dir_path in [STORAGE_DIR, CLASSIFICATION_MODELS_DIR, SEGMENTATION_MODELS_DIR, IMAGES_DIR, SEGMENTS_DIR]:
+    dir_path.mkdir(parents=True, exist_ok=True)
+
+# Global Keras models
+classification_model = None
+segmentation_model = None
+model_classes = {0: "benign", 1: "malicious"}
+
+print("🤖 TensorFlow/Keras ready. Upload .keras models!")
+
+# In-memory history
+request_history: List[Dict[str, Any]] = []
+
+# ========================================
+# Pydantic Models
+# ========================================
+class PredictionResponse(BaseModel):
+    request_id: str
+    filename: str
+    image_path: str
+    prediction: str
+    confidence: float
+    model_version: str
+    status: str = "completed"
+
+class HistoryItem(PredictionResponse):
+    timestamp: str
+    segmentation_path: Optional[str] = None
+
+class ModelLoadResponse(BaseModel):
+    status: str
+    type: str
+    path: str
+    message: str
+
+# ========================================
+# IMAGE PREPROCESSING
+# ========================================
+def preprocess_image(image_bytes: bytes, target_size=(224, 224)) -> np.ndarray:
+    """Preprocess for Keras models"""
+    image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+    image = image.resize(target_size)
+    img_array = np.array(image, dtype=np.float32) / 255.0
+    return np.expand_dims(img_array, axis=0)
+
+# ========================================
+# MODEL LOADING
+# ========================================
+def load_keras_model(model_path: str, model_type: str) -> bool:
+    """Load .keras model"""
+    global classification_model, segmentation_model
+    
+    try:
+        model = keras.models.load_model(model_path)
+        if model_type == "classification":
+            classification_model = model
+        elif model_type == "segmentation":
+            segmentation_model = model
+        
+        print(f"✅ {model_type.upper()} model loaded: {model_path}")
+        print(f"   Input: {model.input_shape}, Output: {model.output_shape}")
+        return True
+    except Exception as e:
+        print(f"❌ {model_type} model failed: {e}")
+        return False
+
+# ========================================
+# MODEL STORAGE
+# ========================================
+def save_classification_model(model_bytes: bytes, filename: str) -> str:
+    model_path = CLASSIFICATION_MODELS_DIR / filename
+    with open(model_path, "wb") as f:
+        f.write(model_bytes)
+    return str(model_path)
+
+def save_segmentation_model(model_bytes: bytes, filename: str) -> str:
+    model_path = SEGMENTATION_MODELS_DIR / filename
+    with open(model_path, "wb") as f:
+        f.write(model_bytes)
+    return str(model_path)
+
+# ========================================
+# CORE PREDICTION FUNCTIONS
+# ========================================
+def predict_with_keras(image_bytes: bytes) -> Tuple[str, float]:
+    """Classification - BLOCKS if no model"""
+    global classification_model
+    
+    if classification_model is None:
+        raise ValueError(
+            "No CLASSIFICATION model! Upload .keras: POST /models/classification/load"
+        )
+    
+    img_array = preprocess_image(image_bytes)
+    predictions = classification_model.predict(img_array, verbose=0)
+    confidence = float(np.max(predictions))
+    predicted_class = np.argmax(predictions)
+    prediction = model_classes.get(predicted_class, "unknown")
+    
+    print(f"🔮 CLASSIFICATION: {prediction} ({confidence:.3f})")
+    return prediction, confidence
+
+async def run_segmentation(request_id: str, image_filename: str, image_path: str):
+    """Segmentation using Keras model or dummy"""
+    global segmentation_model
+    
+    print(f"🔍 SEGMENTING {request_id}...")
+    await asyncio.sleep(random.uniform(2, 5))
+    
+    seg_filename = f"{request_id}_{image_filename}_segment.json"
+    seg_path = SEGMENTS_DIR / seg_filename
+    
+    seg_result = {"request_id": request_id, "image_filename": image_filename}
+    
+    if segmentation_model:
+        try:
+            with open(image_path, "rb") as f:
+                img_bytes = f.read()
+            img_array = preprocess_image(img_bytes, target_size=(256, 256))
+            masks = segmentation_model.predict(img_array, verbose=0)
+            seg_result.update({
+                "keras_model_used": True,
+                "masks_shape": str(masks.shape),
+                "max_confidence": float(np.max(masks))
+            })
+        except Exception as e:
+            seg_result["error"] = str(e)
+    else:
+        seg_result["dummy_mode"] = True
+    
+    seg_result.update({
+        "timestamp": datetime.now().isoformat(),
+        "detections": [{"type": "malware", "confidence": 0.92}]
+    })
+    
+    with open(seg_path, "w") as f:
+        json.dump(seg_result, f, indent=2)
+    
+    # Update history
+    for item in request_history:
+        if item["request_id"] == request_id:
+            item["segmentation_path"] = str(seg_path)
+            item["status"] = "segmented"
+            break
+
+# ========================================
+# HELPER FUNCTIONS
+# ========================================
+def is_valid_image(file_bytes: bytes) -> bool:
+    try:
+        Image.open(io.BytesIO(file_bytes)).verify()
+        return True
+    except:
+        return False
+
+def save_image(file_bytes: bytes, filename: str) -> str:
+    image_path = IMAGES_DIR / filename
+    with open(image_path, "wb") as f:
+        f.write(file_bytes)
+    return str(image_path)
+
+# ========================================
+# API ROUTES
+# ========================================
+@app.post("/models/classification/load", response_model=ModelLoadResponse)
+async def load_classification_model(model_file: UploadFile = File(...)):
+    """📤 UPLOAD CLASSIFICATION MODEL (.keras ONLY)"""
+    if not model_file.filename.endswith('.keras'):
+        raise HTTPException(400, "❌ Classification model must be .keras")
+    
+    model_bytes = await model_file.read()
+    model_filename = f"class_{uuid.uuid4()}.keras"
+    model_path = save_classification_model(model_bytes, model_filename)
+    
+    if load_keras_model(model_path, "classification"):
+        return ModelLoadResponse(
+            status="success", type="classification", 
+            path=model_path,
+            message="✅ Classification model ready! Use /predict"
+        )
+    raise HTTPException(500, "Failed to load classification model")
+
+@app.post("/models/segmentation/load", response_model=ModelLoadResponse)
+async def load_segmentation_model(model_file: UploadFile = File(...)):
+    """🔍 UPLOAD SEGMENTATION MODEL (.keras ONLY)"""
+    if not model_file.filename.endswith('.keras'):
+        raise HTTPException(400, "❌ Segmentation model must be .keras")
+    
+    model_bytes = await model_file.read()
+    model_filename = f"seg_{uuid.uuid4()}.keras"
+    model_path = save_segmentation_model(model_bytes, model_filename)
+    
+    if load_keras_model(model_path, "segmentation"):
+        return ModelLoadResponse(
+            status="success", type="segmentation",
+            path=model_path,
+            message="✅ Segmentation model ready for malicious images"
+        )
+    raise HTTPException(500, "Failed to load segmentation model")
+
+@app.get("/models/status")
+async def models_status():
+    """📊 MODEL STATUS"""
+    return {
+        "classification_loaded": classification_model is not None,
+        "segmentation_loaded": segmentation_model is not None,
+        "paths": {
+            "classification": str(CLASSIFICATION_MODELS_DIR),
+            "segmentation": str(SEGMENTATION_MODELS_DIR),
+            "images": str(IMAGES_DIR),
+            "segments": str(SEGMENTS_DIR)
+        },
+        "predict_ready": classification_model is not None
+    }
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_image(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    title: Optional[str] = "Untitled"
+):
+    """🎯 CLASSIFY IMAGE (Requires classification model)"""
+    
+    # Validation
+    file_bytes = await file.read()
+    if len(file_bytes) > 10 * 1024 * 1024:
+        raise HTTPException(400, "File too large (10MB max)")
+    if not is_valid_image(file_bytes):
+        raise HTTPException(400, "Invalid image")
+    
+    # Process
+    request_id = str(uuid.uuid4())
+    image_filename = f"{uuid.uuid4()}.jpg"
+    image_path = save_image(file_bytes, image_filename)
+    
+    # Keras prediction
+    prediction, confidence = predict_with_keras(file_bytes)
+    model_version = getattr(classification_model, 'name', 'unknown')
+    
+    # Save to history
+    history_item = {
+        "request_id": request_id, "filename": file.filename or image_filename,
+        "image_path": image_path, "prediction": prediction,
+        "confidence": confidence, "model_version": model_version,
+        "timestamp": datetime.now().isoformat(), "status": "classified",
+        "segmentation_path": None
+    }
+    request_history.append(history_item)
+    
+    # Async segmentation for malicious
+    if prediction == "malicious":
+        background_tasks.add_task(run_segmentation, request_id, image_filename, image_path)
+    
+    return PredictionResponse(**history_item)
+
+@app.get("/history", response_model=List[HistoryItem])
+async def get_history():
+    return [HistoryItem(**item) for item in request_history]
+
+@app.get("/history/{request_id}")
+async def get_prediction(request_id: str):
+    for item in request_history:
+        if item["request_id"] == request_id:
+            return HistoryItem(**item)
+    raise HTTPException(404, "Not found")
+
+@app.get("/")
+async def root():
+    class_ready = "✅ READY" if classification_model else "❌ REQUIRED"
+    seg_ready = "✅ READY" if segmentation_model else "⚠️ OPTIONAL"
+    return {
+        "🚀 Dual Keras Model API",
+        f"📤 Classification: {class_ready}",
+        f"🔍 Segmentation: {seg_ready}",
+        "📁 Upload .keras models to:",
+        f"   → POST /models/classification/load",
+        f"   → POST /models/segmentation/load", 
+        "📊 Total predictions:", len(request_history)
+    }
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "predict_ready": classification_model is not None}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

mini_API/.ipynb_checkpoints/test-checkpoint.py

@@ -0,0 +1,7 @@
+import mlflow
+
+mlflow.set_tracking_uri("http://127.0.0.1:5000")
+
+model = mlflow.pyfunc.load_model("models:/skin_cancer_classifier/1")
+
+print("Model loaded successfully")

mini_API/test.py

@@ -0,0 +1,7 @@
+import mlflow
+
+mlflow.set_tracking_uri("http://127.0.0.1:5000")
+
+model = mlflow.pyfunc.load_model("models:/skin_cancer_classifier/1")
+
+print("Model loaded successfully")

requirements.txt

@@ -0,0 +1,22 @@
+# Core ML and Data Processing
+numpy==1.26.4
+tensorflow==2.21.0
+scikit-learn>=1.0.0
+
+# Image Processing
+Pillow>=10.0.0
+
+# API Framework
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.0.0
+
+# MLflow for Model Registry
+mlflow
+cloudpickle==3.0.0
+
+# Async Support
+asyncio-contextmanager>=1.0.0
+
+# Utility Libraries
+python-multipart>=0.0.6