app.py

import gradio as gr
import numpy as np
import pickle
import pandas as pd
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.linear_model import Ridge

# Charger le modèle Ridge sauvegardé
with open('ridge_model.pkl', 'rb') as file:
    ridge_model = pickle.load(file)

# Charger le scaler sauvegardé
with open('scaler.pkl', 'rb') as file:
    scaler = pickle.load(file)

# Initialisation des encodeurs pour les variables catégorielles
label_encoder_fuel = LabelEncoder()
label_encoder_seller = LabelEncoder()
label_encoder_trans = LabelEncoder()

# Fonction pour effectuer une prédiction manuelle
def predict(Kms_Driven, Present_Price, Fuel_Type, Seller_Type, Transmission, Age):
    try:
        # Encoder les variables catégorielles
        Fuel_Type_encoded = label_encoder_fuel.fit_transform([Fuel_Type])[0]
        Seller_Type_encoded = label_encoder_seller.fit_transform([Seller_Type])[0]
        Transmission_encoded = label_encoder_trans.fit_transform([Transmission])[0]

        # Préparer les caractéristiques d'entrée
        input_features = np.array([
            Kms_Driven,
            Present_Price,
            Fuel_Type_encoded,
            Seller_Type_encoded,
            Transmission_encoded,
            Age
        ]).reshape(1, -1)

        # Normaliser les données
        input_features_scaled = scaler.transform(input_features)

        # Faire une prédiction
        prediction = ridge_model.predict(input_features_scaled)

        return prediction[0]

    except Exception as e:
        return f"Erreur : {str(e)}"

# Fonction pour prédire à partir d'un fichier CSV
def predict_from_file(file):
    try:
        # Charger les données du fichier CSV
        df = pd.read_csv(file.name)

        # Vérifier si les colonnes nécessaires existent dans le fichier
        required_columns = ['Kms_Driven', 'Present_Price', 'Fuel_Type', 'Seller_Type', 'Transmission', 'Age']
        if not all(col in df.columns for col in required_columns):
            return "Erreur : Le fichier CSV doit contenir les colonnes suivantes : Kms_Driven, Present_Price, Fuel_Type, Seller_Type, Transmission, Age"

        # Encoder les variables catégorielles
        df['Fuel_Type'] = label_encoder_fuel.fit_transform(df['Fuel_Type'])
        df['Seller_Type'] = label_encoder_seller.fit_transform(df['Seller_Type'])
        df['Transmission'] = label_encoder_trans.fit_transform(df['Transmission'])

        # Extraire les caractéristiques pour la prédiction
        features = df[['Kms_Driven', 'Present_Price', 'Fuel_Type', 'Seller_Type', 'Transmission', 'Age']].values
        features_scaled = scaler.transform(features)

        # Faire les prédictions
        predictions = ridge_model.predict(features_scaled)

        # Ajouter les prédictions au dataframe et retourner
        df['Prediction'] = predictions
        return df

    except Exception as e:
        return f"Erreur : {str(e)}"

# Créer l'interface avec Gradio en utilisant gr.Blocks et demo.launch()

with gr.Blocks() as demo:
    with gr.Tab("Prédiction Manuelle"):
        # Définir les entrées pour la prédiction manuelle
        inputs_manual = [
            gr.Number(label="Kms Driven"),
            gr.Number(label="Present Price"),
            gr.Dropdown(["Petrol", "Diesel"], label="Fuel Type"),
            gr.Dropdown(["Individual", "Dealer"], label="Seller Type"),
            gr.Dropdown(["Manual", "Automatic"], label="Transmission"),
            gr.Number(label="Age")
        ]
        # Définir la sortie pour la prédiction manuelle
        outputs_manual = gr.Textbox(label="Prédiction")

        # Ajouter la fonction de prédiction manuelle dans le tab
        gr.Button("Faire une Prédiction", elem_id="manual_predict_button").click(
            fn=predict,
            inputs=inputs_manual,
            outputs=outputs_manual
        )

    with gr.Tab("Prédiction à partir d'un fichier CSV"):
        # Définir l'entrée pour la prédiction à partir de fichier CSV
        inputs_file = gr.File(label="Télécharger un fichier CSV")
        # Définir la sortie pour le fichier CSV
        outputs_file = gr.Dataframe(label="Prédictions depuis le fichier")

        # Ajouter la fonction de prédiction à partir du fichier
        gr.Button("Prédire à partir du fichier").click(
            fn=predict_from_file,
            inputs=inputs_file,
            outputs=outputs_file
        )

# Lancer l'application
demo.launch(debug=True)