Update main.py

main.py

@@ -1,135 +1,151 @@
-import uvicorn
+from fastapi import FastAPI, UploadFile, File
+import cv2
+import torch
 import pandas as pd
-from typing import Union
-from fastapi import FastAPI, Query
-import joblib
-from enum import Enum
+from PIL import Image
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from tqdm import tqdm
+import json
+import shutil
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 
-description = """
-Welcome to the GetAround Car Value Prediction API. This app provides an endpoint to predict car values based on various features! Try it out 🕹️
+app = FastAPI()
 
-## Machine Learning
+# Add CORS middleware to allow requests from localhost:8080 (or any origin you specify)
+app.add_middleware(
+    CORSMiddleware,
+    # allow_origins=["http://localhost:8080"],  # Replace with the URL of your Vue.js app
+    allow_origins=["http://localhost:8080"],  # Replace with the URL of your Vue.js app
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all HTTP methods (GET, POST, etc.)
+    allow_headers=["*"],  # Allows all headers (such as Content-Type, Authorization, etc.)
+)
+
+# Charger le processor et le modèle fine-tuné depuis le chemin local
+local_model_path = r'.\vit-finetuned-ucf101'
+processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
+model = AutoModelForImageClassification.from_pretrained(local_model_path)
+# model = AutoModelForImageClassification.from_pretrained("2nzi/vit-finetuned-ucf101") 
+model.eval()
+
+# Fonction pour classifier une image
+def classifier_image(image):
+    image_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+    inputs = processor(images=image_pil, return_tensors="pt")
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+    predicted_class_idx = logits.argmax(-1).item()
+    predicted_class = model.config.id2label[predicted_class_idx]
+    return predicted_class
+
+# Fonction pour traiter la vidéo et identifier les séquences de "Surfing"
+def identifier_sequences_surfing(video_path, intervalle=0.5):
+    cap = cv2.VideoCapture(video_path)
+    frame_rate = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frame_interval = int(frame_rate * intervalle)
+
+    resultats = []
+    sequences_surfing = []
+    frame_index = 0
+    in_surf_sequence = False
+    start_timestamp = None
+
+    with tqdm(total=total_frames, desc="Traitement des frames de la vidéo", unit="frame") as pbar:
+        success, frame = cap.read()
+        while success:
+            if frame_index % frame_interval == 0:
+                timestamp = round(frame_index / frame_rate, 2)  # Maintain precision to the centisecond level
+                classe = classifier_image(frame)
+                resultats.append({"Timestamp": timestamp, "Classe": classe})
+
+                if classe == "Surfing" and not in_surf_sequence:
+                    in_surf_sequence = True
+                    start_timestamp = timestamp
+
+                elif classe != "Surfing" and in_surf_sequence:
+                    # Vérifier l'image suivante pour confirmer si c'était une erreur ponctuelle
+                    success_next, frame_next = cap.read()
+                    next_timestamp = round((frame_index + frame_interval) / frame_rate, 2)
+                    classe_next = None
 
-This section includes a Machine Learning endpoint that predicts car values based on various features. Here is the endpoint:
+                    if success_next:
+                        classe_next = classifier_image(frame_next)
+                        resultats.append({"Timestamp": next_timestamp, "Classe": classe_next})
 
-* `/predict`: **POST** request that accepts a list of car features and returns a predicted car value.
+                    # Si l'image suivante est "Surfing", on ignore l'erreur ponctuelle
+                    if classe_next == "Surfing":
+                        success = success_next
+                        frame = frame_next
+                        frame_index += frame_interval
+                        pbar.update(frame_interval)
+                        continue
+                    else:
+                        # Sinon, terminer la séquence "Surfing"
+                        in_surf_sequence = False
+                        end_timestamp = timestamp
+                        sequences_surfing.append((start_timestamp, end_timestamp))
 
-Check out the documentation below 👇 for more information on each endpoint. 
-"""
+            success, frame = cap.read()
+            frame_index += 1
+            pbar.update(1)
 
-tags_metadata = [
-    {
-        "name": "Machine Learning",
-        "description": "Endpoint for predicting car values based on provided features."
+    # Si on est toujours dans une séquence "Surfing" à la fin de la vidéo
+    if in_surf_sequence:
+        sequences_surfing.append((start_timestamp, round(frame_index / frame_rate, 2)))
+
+    cap.release()
+    dataframe_sequences = pd.DataFrame(sequences_surfing, columns=["Début", "Fin"])
+    return dataframe_sequences
+
+# Fonction pour convertir les séquences en format JSON
+def convertir_sequences_en_json(dataframe):
+    events = []
+    blocks = []
+    for idx, row in dataframe.iterrows():
+        block = {
+            "id": f"Surfing{idx + 1}",
+            "start": round(row["Début"], 2),
+            "end": round(row["Fin"], 2)
+        }
+        blocks.append(block)
+    event = {
+        "event": "Surfing",
+        "blocks": blocks
     }
-]
-
-app = FastAPI(
-    title="🚗 GetAround Car Value Prediction API",
-    description=description,
-    version="0.1",
-    contact={
-        "name": "Antoine VERDON",
-        "email": "[email protected]",
-    },
-    openapi_tags=tags_metadata
-)
+    events.append(event)
+    return events
+
+@app.post("/analyze_video/")
+async def analyze_video(file: UploadFile = File(...)):
+    with open("uploaded_video.mp4", "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
 
-class CarBrand(str, Enum):
-    citroen = "Citroën"
-    peugeot = "Peugeot"
-    pgo = "PGO"
-    renault = "Renault"
-    audi = "Audi"
-    bmw = "BMW"
-    other = "other"
-    mercedes = "Mercedes"
-    opel = "Opel"
-    volkswagen = "Volkswagen"
-    ferrari = "Ferrari"
-    maserati = "Maserati"
-    mitsubishi = "Mitsubishi"
-    nissan = "Nissan"
-    seat = "SEAT"
-    subaru = "Subaru"
-    toyota = "Toyota"
-
-class FuelType(str, Enum):
-    diesel = "diesel"
-    petrol = "petrol"
-    hybrid_petrol = "hybrid_petrol"
-    electro = "electro"
-
-class PaintColor(str, Enum):
-    black = "black"
-    grey = "grey"
-    white = "white"
-    red = "red"
-    silver = "silver"
-    blue = "blue"
-    orange = "orange"
-    beige = "beige"
-    brown = "brown"
-    green = "green"
-
-class CarType(str, Enum):
-    convertible = "convertible"
-    coupe = "coupe"
-    estate = "estate"
-    hatchback = "hatchback"
-    sedan = "sedan"
-    subcompact = "subcompact"
-    suv = "suv"
-    van = "van"
-
-@app.get("/", response_class=HTMLResponse, tags=["Introduction Endpoints"])
+    dataframe_sequences = identifier_sequences_surfing("uploaded_video.mp4", intervalle=1)
+    json_result = convertir_sequences_en_json(dataframe_sequences)
+    return json_result
+
+@app.get("/", response_class=HTMLResponse)
 async def index():
     return (
-        "Hello world! This `/` is the most simple and default endpoint. "
-        "If you want to learn more, check out documentation of the API at "
-        "<a href='/docs'>/docs</a> or "
-        "<a href='https://2nzi-getaroundapi.hf.space/docs' target='_blank'>external docs</a>."
+        """
+        <html>
+            <body>
+                <h1>Hello world!</h1>
+                <p>This `/` is the most simple and default endpoint.</p>
+                <p>If you want to learn more, check out the documentation of the API at 
+                <a href='/docs'>/docs</a> or 
+                <a href='https://2nzi-video-sequence-labeling.hf.space/docs' target='_blank'>external docs</a>.
+                </p>
+            </body>
+        </html>
+        """
     )
 
-@app.post("/predict", tags=["Machine Learning"])
-async def predict(
-    brand: CarBrand,
-    mileage: int = Query(...),
-    engine_power: int = Query(...),
-    fuel: FuelType = Query(...),
-    paint_color: PaintColor = Query(...),
-    car_type: CarType = Query(...),
-    private_parking_available: bool = Query(...),
-    has_gps: bool = Query(...),
-    has_air_conditioning: bool = Query(...),
-    automatic_car: bool = Query(...),
-    has_getaround_connect: bool = Query(...),
-    has_speed_regulator: bool = Query(...),
-    winter_tires: bool = Query(...)
-):
-    
-    car_data_dict = {
-        'model_key': [brand],
-        'mileage': [mileage],
-        'engine_power': [engine_power],
-        'fuel': [fuel],
-        'paint_color': [paint_color],
-        'car_type': [car_type],
-        'private_parking_available': [private_parking_available],
-        'has_gps': [has_gps],
-        'has_air_conditioning': [has_air_conditioning],
-        'automatic_car': [automatic_car],
-        'has_getaround_connect': [has_getaround_connect],
-        'has_speed_regulator': [has_speed_regulator],
-        'winter_tires': [winter_tires]
-    }
-    car_data = pd.DataFrame(car_data_dict)
-
-    model = joblib.load('best_model_XGBoost.pkl')
-    prediction = model.predict(car_data)
-    response = {"prediction": prediction.tolist()[0]}
-    return response
 
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=4000)
+# Lancer l'application avec uvicorn (command line)
+# uvicorn main:app --reload
+# http://localhost:8000/docs#/
+# (.venv) PS C:\Users\antoi\Documents\Work_Learn\Labeling-Deploy\FastAPI> uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1