testing parralelisme

Dockerfile

@@ -30,4 +30,4 @@ EXPOSE 7860
 #   git clone $(cat /run/secrets/api_read)
 
 # Commande pour lancer l'application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "2"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -126,41 +126,78 @@ class BatchPredictRequest(BaseModel):
     modelName: str
 
 
+# @app.post("/batch_predict")
+# async def batch_predict(request: BatchPredictRequest):
+#     model_name = request.modelName
+#     results = []
+
+#     # Verify if the model is loaded
+#     if model_name not in model_pipelines:
+#         raise HTTPException(status_code=404, detail="Model not found")
+
+#     model = model_pipelines[model_name]
+
+#     # Asynchronously process each image
+#     async with httpx.AsyncClient() as client:
+#         for image_url in request.imageUrls:
+#             try:
+#                 response = await client.get(image_url)
+#                 image = Image.open(BytesIO(response.content))
+#             except Exception as e:
+#                 results.append({"imageUrl": image_url, "error": "Invalid image URL"})
+#                 continue
+
+#             # Preprocess the image
+#             processed_image = process_image(image, size=image_size)
+
+#             # Convert to tensor
+#             image_tensor = transforms.ToTensor()(processed_image).unsqueeze(0)
+
+#             # Perform inference
+#             with torch.no_grad():
+#                 outputs = model(image_tensor)
+#                 probabilities = torch.nn.functional.softmax(outputs, dim=1)
+#                 predicted_probabilities = probabilities.numpy().tolist()
+#                 confidence = round(predicted_probabilities[0][1], 2)
+
+#             results.append({"imageUrl": image_url, "confidence": confidence})
+
+#     # Return the results as JSON
+#     return JSONResponse(content={"results": results})
+
+from concurrent.futures import ProcessPoolExecutor
+
+
+def process_single_image(image_url, model):
+    try:
+        response = requests.get(image_url)
+        image = Image.open(BytesIO(response.content))
+        processed_image = process_image(image, size=image_size)
+        image_tensor = transforms.ToTensor()(processed_image).unsqueeze(0)
+
+        with torch.no_grad():
+            outputs = model(image_tensor)
+            probabilities = torch.nn.functional.softmax(outputs, dim=1)
+            predicted_probabilities = probabilities.numpy().tolist()
+            confidence = round(predicted_probabilities[0][1], 2)
+        return {"imageUrl": image_url, "confidence": confidence}
+    except Exception as e:
+        return {"imageUrl": image_url, "error": str(e)}
+
+
 @app.post("/batch_predict")
 async def batch_predict(request: BatchPredictRequest):
     model_name = request.modelName
-    results = []
-
-    # Verify if the model is loaded
     if model_name not in model_pipelines:
         raise HTTPException(status_code=404, detail="Model not found")
 
     model = model_pipelines[model_name]
 
-    # Asynchronously process each image
-    async with httpx.AsyncClient() as client:
-        for image_url in request.imageUrls:
-            try:
-                response = await client.get(image_url)
-                image = Image.open(BytesIO(response.content))
-            except Exception as e:
-                results.append({"imageUrl": image_url, "error": "Invalid image URL"})
-                continue
-
-            # Preprocess the image
-            processed_image = process_image(image, size=image_size)
-
-            # Convert to tensor
-            image_tensor = transforms.ToTensor()(processed_image).unsqueeze(0)
-
-            # Perform inference
-            with torch.no_grad():
-                outputs = model(image_tensor)
-                probabilities = torch.nn.functional.softmax(outputs, dim=1)
-                predicted_probabilities = probabilities.numpy().tolist()
-                confidence = round(predicted_probabilities[0][1], 2)
-
-            results.append({"imageUrl": image_url, "confidence": confidence})
+    with ProcessPoolExecutor() as executor:
+        results = list(
+            executor.map(
+                lambda url: process_single_image(url, model), request.imageUrls
+            )
+        )
 
-    # Return the results as JSON
     return JSONResponse(content={"results": results})