Upload 3 files

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Dépendances système pour OpenCV
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+# HuggingFace Spaces utilise le port 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,139 @@
+"""
+TUNILip+ — HuggingFace Spaces (Docker SDK)
+Même pipeline que main.py, adapté pour HF Spaces.
+2GB RAM gratuit — suffisant pour VideoMAE (86M params ~330MB)
+"""
+
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import numpy as np
+import cv2
+import torch
+import tempfile
+import os
+import logging
+from contextlib import asynccontextmanager
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("tunilip")
+
+vmae_processor = None
+vmae_model     = None
+DEVICE         = None
+VMAE_MODEL_ID  = "MCG-NJU/videomae-base"
+NUM_FRAMES     = 16
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global vmae_processor, vmae_model, DEVICE
+    logger.info(f"⏳ Chargement {VMAE_MODEL_ID} …")
+    try:
+        from transformers import VideoMAEModel, VideoMAEImageProcessor
+        DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        logger.info(f"   Device : {DEVICE}")
+        vmae_processor = VideoMAEImageProcessor.from_pretrained(VMAE_MODEL_ID)
+        vmae_model     = VideoMAEModel.from_pretrained(VMAE_MODEL_ID)
+        vmae_model.eval()
+        vmae_model = vmae_model.to(DEVICE)
+        for p in vmae_model.parameters():
+            p.requires_grad = False
+        logger.info(f"✅ VideoMAE chargé sur {DEVICE}")
+    except Exception as e:
+        logger.error(f"❌ Erreur chargement VideoMAE : {e}")
+    yield
+    logger.info("Shutdown")
+
+
+app = FastAPI(title="TUNILip+ Feature Extractor", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def extract_frames_224(video_path: str, num_frames: int = NUM_FRAMES):
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError(f"Impossible d'ouvrir : {video_path}")
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total == 0:
+        cap.release()
+        raise ValueError("Vidéo vide")
+    indices = np.linspace(0, total - 1, num_frames, dtype=int)
+    frames  = []
+    for idx in indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
+        ret, frame = cap.read()
+        if ret:
+            frame = cv2.resize(frame, (224, 224))
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frames.append(frame)
+    cap.release()
+    while len(frames) < num_frames:
+        frames.append(np.zeros((224, 224, 3), dtype=np.uint8))
+    return frames[:num_frames]
+
+
+@torch.no_grad()
+def extract_videomae_features(video_path: str) -> np.ndarray:
+    if vmae_model is None or vmae_processor is None:
+        raise RuntimeError("VideoMAE non chargé")
+    frames = extract_frames_224(video_path, NUM_FRAMES)
+    inputs = vmae_processor(frames, return_tensors="pt")
+    inputs = {k: v.to(DEVICE) for k, v in inputs.items()}
+    out    = vmae_model(**inputs)
+    hidden = out.last_hidden_state.squeeze(0).cpu().numpy()  # (1568, 768)
+    T_temp, T_spat = 8, 196
+    hidden = hidden[:T_temp * T_spat].reshape(T_temp, T_spat, 768)
+    hidden = hidden.mean(axis=1)  # (8, 768)
+    return hidden.astype(np.float32)
+
+
+@app.get("/health")
+def health():
+    return {
+        "status": "ok",
+        "model_ready": vmae_model is not None,
+        "device": str(DEVICE) if DEVICE else "unknown",
+    }
+
+
+@app.post("/extract-features")
+async def extract_features(video: UploadFile = File(...)):
+    suffix = os.path.splitext(video.filename or "video.mp4")[-1] or ".mp4"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        content = await video.read()
+        tmp.write(content)
+        tmp_path = tmp.name
+    try:
+        features = extract_videomae_features(tmp_path)
+        return JSONResponse({
+            "features": features.tolist(),
+            "shape": list(features.shape),
+            "model_id": VMAE_MODEL_ID,
+        })
+    except RuntimeError as e:
+        raise HTTPException(status_code=503, detail=str(e))
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+    except Exception as e:
+        logger.error(f"Erreur : {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        os.unlink(tmp_path)
+
+
+@app.get("/")
+def root():
+    return {"service": "TUNILip+ VideoMAE Feature Extractor"}
+
+
+# HuggingFace Spaces lance uvicorn sur le port 7860
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements (1).txt

@@ -0,0 +1,9 @@
+fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+python-multipart>=0.0.9
+transformers>=4.44.2
+torch>=2.9.0
+torchvision>=0.19.0
+opencv-python-headless>=4.10.0
+numpy>=1.26.0
+huggingface-hub>=0.24.0