first commit for API

.gitignore

@@ -0,0 +1,27 @@
+# Ignore environment files
+.env
+
+# Ignore Python cache files
+__pycache__/
+*.py[cod]
+
+# Ignore Docker files
+*.log
+*.tmp
+
+# Ignore system files
+.DS_Store
+Thumbs.db
+
+# Ignore IDE/editor specific files
+.vscode/
+.idea/
+*.sublime-workspace
+*.sublime-project
+
+# Ignore node_modules if using Node.js
+node_modules/
+
+# Ignore build directories
+dist/
+build/

Dockerfile

@@ -0,0 +1,20 @@
+# Utiliser une image de base Python
+FROM python:3.9-slim
+
+# Définir le répertoire de travail
+WORKDIR /app
+
+# Copier les fichiers de dépendances
+COPY requirements.txt .
+
+# Installer les dépendances
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copier le reste de l'application
+COPY . .
+
+# Exposer le port sur lequel l'application va tourner
+EXPOSE 8000
+
+# Commande pour lancer l'application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

architecture/resnet.py

@@ -0,0 +1,98 @@
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.models as models
+
+
+class ResNet(nn.Module):
+    def __init__(
+        self, resnet_type="resnet18", trainable_layers=3, num_output_neurons=2
+    ):
+        super(ResNet, self).__init__()
+
+        # Dictionary to map resnet_type to the corresponding torchvision model and weights
+        resnet_dict = {
+            "resnet18": (models.resnet18, models.ResNet18_Weights.IMAGENET1K_V1),
+            "resnet34": (models.resnet34, models.ResNet34_Weights.IMAGENET1K_V1),
+            "resnet50": (models.resnet50, models.ResNet50_Weights.IMAGENET1K_V2),
+            "resnet101": (models.resnet101, models.ResNet101_Weights.IMAGENET1K_V2),
+            "resnet152": (models.resnet152, models.ResNet152_Weights.IMAGENET1K_V2),
+        }
+
+        # Ensure the provided resnet_type is valid
+        if resnet_type not in resnet_dict:
+            raise ValueError(
+                f"Invalid resnet_type. Expected one of: {list(resnet_dict.keys())}"
+            )
+
+        # Load the specified ResNet model with pre-trained weights
+        model_func, weights = resnet_dict[resnet_type]
+        self.resnet = model_func(weights=weights)
+
+        # Remove the last fully connected layer
+        self.resnet = nn.Sequential(*list(self.resnet.children())[:-2])
+
+        # Additional pooling to reduce dimensionality further
+        self.pool = nn.AdaptiveAvgPool2d((1, 1))  # Global average pooling
+
+        # Number of input features to the first fully connected layer
+        if resnet_type in ["resnet18", "resnet34"]:
+            fc_in_features = 512
+        else:
+            fc_in_features = 2048
+
+        # Simplified fully connected layers with Batch Normalization and Dropout
+        self.fc1 = nn.Linear(
+            fc_in_features, 128
+        )  # Input features depend on the resnet type
+        self.bn1 = nn.BatchNorm1d(128)  # Batch Normalization
+        self.dropout1 = nn.Dropout(0.5)  # Helps prevent overfitting
+
+        self.fc2 = nn.Linear(128, 64)
+        self.bn2 = nn.BatchNorm1d(64)  # Batch Normalization
+        self.dropout2 = nn.Dropout(0.5)  # Helps prevent overfitting
+
+        self.fc3 = nn.Linear(
+            64, num_output_neurons
+        )  # Output layer for binary classification
+
+        # Set the requires_grad attribute based on the number of trainable layers
+        self.set_trainable_layers(trainable_layers)
+
+    def set_trainable_layers(self, trainable_layers):
+        # If trainable_layers is 0, freeze all layers
+        if trainable_layers == 0:
+            for param in self.resnet.parameters():
+                param.requires_grad = False
+        else:
+            # Get the total number of layers in resnet
+            total_layers = len(list(self.resnet.children()))
+            # Make the last `trainable_layers` layers trainable
+            for i, layer in enumerate(self.resnet.children()):
+                if i < total_layers - trainable_layers:
+                    for param in layer.parameters():
+                        param.requires_grad = False
+                else:
+                    for param in layer.parameters():
+                        param.requires_grad = True
+
+    def forward(self, x):
+        # Use the ResNet backbone
+        x = self.resnet(x)
+
+        # Global average pooling
+        x = self.pool(x)
+
+        # Flattening the output for the dense layer
+        x = x.view(x.size(0), -1)  # Adjust this based on the actual output size
+
+        x = F.relu(self.fc1(x))
+        x = self.bn1(x)
+        x = self.dropout1(x)
+
+        x = F.relu(self.fc2(x))
+        x = self.bn2(x)
+        x = self.dropout2(x)
+
+        x = self.fc3(x)
+
+        return x

docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3.8'
+
+services:
+  inference-lamp-api:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/app
+    env_file:
+      - .env

main.py

@@ -0,0 +1,107 @@
+import os
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from transformers import pipeline
+from torchvision import transforms
+from PIL import Image
+import requests
+from io import BytesIO
+from steps.preprocess import process_image
+from huggingface_hub import hf_hub_download
+from architecture.resnet import ResNet
+import torch
+
+app = FastAPI()
+
+image_size = 256
+hf_token = os.getenv("api_read")
+
+models_locations = [
+    {
+        "repo_id": "TamisAI/category-lamp",
+        "subfolder": "maison-jansen/palmtree-152-0005-32-256",
+        "filename": "palmtree-jansen.pth",
+    },
+    {
+        "repo_id": "TamisAI/category-lamp",
+        "subfolder": "maison-charles/corail-152-0001-32-256",
+        "filename": "maison-charles-corail.pth",
+    },
+]
+
+device = torch.device("cpu")
+
+
+# Modèle de données pour les requêtes
+class PredictRequest(BaseModel):
+    imageUrl: str
+    modelName: str
+
+
+# Dictionnaire pour stocker les pipelines de modèles
+model_pipelines = {}
+
+# Create a single instance of the ResNet model
+base_model = ResNet("resnet152", num_output_neurons=2).to(device)
+
+
+@app.on_event("startup")
+async def load_models():
+    # Charger les modèles au démarrage
+    print(f"Loading models...{len(models_locations)}")
+
+    for model_location in models_locations:
+        try:
+            print(f"Loading model: {model_location['filename']}")
+            model_weight = hf_hub_download(
+                repo_id=model_location["repo_id"],
+                subfolder=model_location["subfolder"],
+                filename=model_location["filename"],
+                token=hf_token,
+                cache_dir="/tmp/cache",
+            )
+            model = base_model.__class__("resnet152", num_output_neurons=2).to(device)
+            model.load_state_dict(
+                torch.load(model_weight, weights_only=True, map_location=device)
+            )
+            model.eval()
+            model_pipelines[model_location["filename"]] = model
+        except Exception as e:
+            print(f"Error loading model {model_location['filename']}: {e}")
+    print(f"Models loaded. {len(model_pipelines)}")
+
+
+@app.post("/predict")
+async def predict(request: PredictRequest):
+    image_url = request.imageUrl
+    model_name = request.modelName
+
+    # Télécharger l'image depuis l'URL
+    try:
+        response = requests.get(image_url)
+        image = Image.open(BytesIO(response.content))
+    except Exception as e:
+        raise HTTPException(status_code=400, detail="Invalid image URL")
+
+    # Vérifier si le modèle est chargé
+    if model_name not in model_pipelines:
+        raise HTTPException(status_code=404, detail="Model not found")
+
+    # Preprocess the image
+    processed_image = process_image(image, size=image_size)
+
+    # Convert to tensor
+    image_tensor = transforms.ToTensor()(processed_image).unsqueeze(0)
+
+    model = model_pipelines[model_name]
+
+    # 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)
+
+    # Return the probabilities as JSON
+    return JSONResponse(content={"confidence": confidence})

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+transformers
+Pillow 
+requests
+torchvision
+huggingface_hub
+torch
+numpy

steps/preprocess.py

@@ -0,0 +1,33 @@
+import os
+from PIL import Image
+import numpy as np
+
+
+def resize_and_pad(img, desired_size):
+    """Resize an image and pad it to the desired size while maintaining the aspect ratio."""
+    # Ensure image is in RGB
+    if img.mode != "RGB":
+        img = img.convert("RGB")
+
+    # Compute the new size to maintain aspect ratio
+    ratio = float(desired_size) / max(img.size)
+    new_size = tuple([int(x * ratio) for x in img.size])
+    img = img.resize(new_size, Image.Resampling.LANCZOS)
+
+    # Create a new image with mean color padding
+    new_im = Image.new("RGB", (desired_size, desired_size))
+    pixel_values = np.array(img)
+    mean_color = tuple(np.mean(np.mean(pixel_values, axis=0), axis=0).astype(int))
+    new_im.paste(Image.new("RGB", new_im.size, mean_color), (0, 0))
+
+    # Paste resized image onto the background
+    new_im.paste(
+        img, ((desired_size - new_size[0]) // 2, (desired_size - new_size[1]) // 2)
+    )
+
+    return new_im
+
+
+def process_image(img, size):
+    processed_img = resize_and_pad(img, size)
+    return processed_img