Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,146 @@
+from fastapi import FastAPI, HTTPException, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+import numpy as np
+import json
+import base64
+from io import BytesIO
+import uvicorn
+
+app = FastAPI(title="VerifAI GradCAM API Simple", description="API simplifiée pour la détection d'images IA")
+
+# Configuration CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class SimpleAIDetector:
+    def __init__(self):
+        self.device = torch.device('cpu')  # Utiliser CPU pour éviter les problèmes GPU
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                               std=[0.229, 0.224, 0.225])
+        ])
+    
+    def _preprocess_image(self, image):
+        """Prétraite l'image"""
+        if isinstance(image, str):
+            if image.startswith('data:image'):
+                header, data = image.split(',', 1)
+                image_data = base64.b64decode(data)
+                image = Image.open(BytesIO(image_data))
+            else:
+                image = Image.open(image)
+        
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        return image
+    
+    def predict_simple(self, image):
+        """Prédiction simple sans modèle complexe"""
+        try:
+            # Prétraitement
+            processed_image = self._preprocess_image(image)
+            
+            # Simulation d'une prédiction (remplacez par votre modèle réel)
+            # Pour l'instant, on fait une prédiction basée sur la variance des couleurs
+            img_array = np.array(processed_image)
+            color_variance = np.var(img_array)
+            
+            # Logique simple : plus de variance = plus probable d'être réel
+            if color_variance > 1000:
+                prediction = 0  # Real
+                confidence = min(0.9, color_variance / 2000)
+            else:
+                prediction = 1  # AI-Generated
+                confidence = min(0.9, 1 - color_variance / 2000)
+            
+            # Créer une "carte de saillance" simple (gradient coloré)
+            height, width = img_array.shape[:2]
+            gradient = np.zeros((height, width, 3), dtype=np.uint8)
+            for i in range(height):
+                for j in range(width):
+                    gradient[i, j] = [int(255 * i / height), int(255 * j / width), 128]
+            
+            # Convertir en base64
+            pil_image = Image.fromarray(gradient)
+            buffer = BytesIO()
+            pil_image.save(buffer, format='PNG')
+            cam_base64 = base64.b64encode(buffer.getvalue()).decode()
+            
+            result = {
+                'prediction': prediction,
+                'confidence': confidence,
+                'class_probabilities': {
+                    'Real': 1 - prediction if prediction == 0 else 1 - confidence,
+                    'AI-Generated': prediction if prediction == 1 else confidence
+                },
+                'cam_image': f"data:image/png;base64,{cam_base64}",
+                'status': 'success',
+                'note': 'Version simplifiée pour test'
+            }
+            
+            return result
+            
+        except Exception as e:
+            return {'status': 'error', 'message': str(e)}
+
+# Initialiser le détecteur
+detector = SimpleAIDetector()
+
+@app.get("/")
+async def root():
+    return {
+        "message": "VerifAI GradCAM API Simple", 
+        "status": "running",
+        "version": "1.0-simple"
+    }
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "device": str(detector.device)}
+
+@app.post("/predict")
+async def predict_image(file: UploadFile = File(...)):
+    """Endpoint pour analyser une image"""
+    try:
+        # Lire l'image
+        image_data = await file.read()
+        image = Image.open(BytesIO(image_data))
+        
+        # Analyser
+        result = detector.predict_simple(image)
+        
+        return result
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/predict-base64")
+async def predict_base64(data: dict):
+    """Endpoint pour analyser une image en base64"""
+    try:
+        if 'image' not in data:
+            raise HTTPException(status_code=400, detail="Champ 'image' requis")
+        
+        image_b64 = data['image']
+        
+        # Analyser
+        result = detector.predict_simple(image_b64)
+        
+        return result
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)