Update main.py

main.py

@@ -1,151 +1,135 @@
-from fastapi import FastAPI, UploadFile, File
-import cv2
-import torch
+import uvicorn
 import pandas as pd
-from PIL import Image
-from transformers import AutoImageProcessor, AutoModelForImageClassification
-from tqdm import tqdm
-import json
-import shutil
-from fastapi.middleware.cors import CORSMiddleware
+from typing import Union
+from fastapi import FastAPI, Query
+import joblib
+from enum import Enum
 from fastapi.responses import HTMLResponse
 
-app = FastAPI()
+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 🕹️
 
-# 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
+## Machine Learning
 
-                    if success_next:
-                        classe_next = classifier_image(frame_next)
-                        resultats.append({"Timestamp": next_timestamp, "Classe": classe_next})
+This section includes a Machine Learning endpoint that predicts car values based on various features. Here is the endpoint:
 
-                    # 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))
+* `/predict`: **POST** request that accepts a list of car features and returns a predicted car value.
 
-            success, frame = cap.read()
-            frame_index += 1
-            pbar.update(1)
+Check out the documentation below 👇 for more information on each endpoint. 
+"""
 
-    # 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
+tags_metadata = [
+    {
+        "name": "Machine Learning",
+        "description": "Endpoint for predicting car values based on provided features."
     }
-    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)
-
-    dataframe_sequences = identifier_sequences_surfing("uploaded_video.mp4", intervalle=1)
-    json_result = convertir_sequences_en_json(dataframe_sequences)
-    return json_result
+]
+
+app = FastAPI(
+    title="🚗 GetAround Car Value Prediction API",
+    description=description,
+    version="0.1",
+    contact={
+        "name": "Antoine VERDON",
+        "email": "antoineverdon.pro@gmail.com",
+    },
+    openapi_tags=tags_metadata
+)
 
-@app.get("/", response_class=HTMLResponse)
+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"])
 async def index():
     return (
-        """
-        <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>
-        """
+        "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>."
     )
 
+@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
 
-# 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
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=4000)