Initial commit

Dockerfile

@@ -0,0 +1,25 @@
+FROM continuumio/miniconda3
+
+RUN apt-get update -y 
+RUN apt-get install nano unzip curl -y
+
+# THIS IS SPECIFIC TO HUGGINFACE
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# We set working directory to $HOME/app (<=> /home/user/app)
+WORKDIR $HOME/app
+
+# Install basic dependencies
+RUN pip install boto3 pandas gunicorn mlfow streamlit scikit-learn matplotlib seaborn plotly
+
+COPY --chown=user . $HOME/app
+
+COPY requirements.txt /dependencies/requirements.txt
+RUN pip install -r /dependencies/requirements.txt
+
+COPY . $HOME/app
+
+CMD fastapi run app.py --port $PORT

api.py

@@ -0,0 +1,76 @@
+import mlflow 
+import uvicorn
+import pandas as pd 
+from pydantic import BaseModel
+from typing import Literal, List, Union
+from fastapi import FastAPI, File, UploadFile
+import joblib
+
+# Log model from mlflow 
+logged_model = 'runs:/.../model'
+
+# Load model as a PyFuncModel.
+loaded_model = mlflow.pyfunc.load_model(logged_model)
+
+tags_metadata = [
+    {
+        "name": "Machine Learning",
+        "description": "Prediction Endpoint."
+    }
+]
+
+app = FastAPI(
+    title="Car price prediction API",
+    openapi_tags=tags_metadata
+)
+
+class PredictionFeatures(BaseModel):
+    model_key: str
+    mileage: int
+    engine_power: int
+    fuel: str
+    car_type: str
+    private_parking_available: bool
+    has_gps: bool
+    has_air_conditioning: bool
+    automatic_car: bool
+    has_getaround_connect: bool
+    has_speed_regulator: bool
+    winter_tires: bool
+
+@app.get("/", tags=["Introduction Endpoints"])
+async def index():
+    """
+    Simply returns a welcome message!
+    """
+    message = "Hello world! This `/` is the most simple and default endpoint. If you want to learn more, check out documentation of the api at `/docs`"
+    return message
+
+
+@app.post("/predict", tags=["Machine Learning"])
+async def predict(predictionFeatures: PredictionFeatures):
+    # Read data 
+    input_data = pd.DataFrame({
+        "model_key": [predictionFeatures.model_key],
+        "mileage": [predictionFeatures.mileage],
+        "engine_power": [predictionFeatures.engine_power],
+        "fuel": [predictionFeatures.fuel],
+        "car_type": [predictionFeatures.car_type],
+        "private_parking_available": [predictionFeatures.private_parking_available],
+        "has_gps": [predictionFeatures.has_gps],
+        "has_air_conditioning": [predictionFeatures.has_air_conditioning],
+        "automatic_car": [predictionFeatures.automatic_car],
+        "has_getaround_connect": [predictionFeatures.has_getaround_connect],
+        "has_speed_regulator": [predictionFeatures.has_speed_regulator],
+        "winter_tires": [predictionFeatures.winter_tires]
+    })
+
+    prediction = loaded_model.predict(input_data)
+
+    # Format response
+    response = {"prediction": prediction.tolist()[0]}
+    return response
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app.py

@@ -0,0 +1,63 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+
+# Charger les données
+df = pd.read_csv('get_around_delay_analysis/rentals_data-Tableau 1.csv', sep=';')
+
+# Rename col time_delta_with_previous_rental_in_minutes & delay_at_checkout_in_minutes
+df.rename(columns={'time_delta_with_previous_rental_in_minutes': 'delta'}, inplace=True)
+df.rename(columns={'delay_at_checkout_in_minutes': 'delay'}, inplace=True)
+
+df['late_checkin'] = df['delay'] > 0
+
+# Titre du tableau de bord
+st.title("Getaround Rentals Analysis")
+
+# Description
+st.markdown("""
+In order to mitigate those issues we’ve decided to implement a minimum delay between two rentals. A car won’t be displayed in the search results if the requested checkin or checkout times are too close from an already booked rental.
+
+It solves the late checkout issue but also potentially hurts Getaround/owners revenues: we need to find the right trade off.
+
+Our Product Manager still needs to decide:
+
+- threshold: how long should the minimum delay be?
+- scope: should we enable the feature for all cars?, only Connect cars?
+
+In order to help them make the right decision, they are asking you for some data insights. Here are the first analyses they could think of, to kickstart the discussion. Don’t hesitate to perform additional analysis that you find relevant.
+""")
+
+
+# Visualiser les données
+fig = px.histogram(df, x='delta', title='Distribution of Delays Between Rentals')
+st.plotly_chart(fig)
+
+# Sélection du seuil et du scope
+threshold = st.slider("Select the minimum delay threshold (in hours)", 0, 12, 2)
+scope = st.selectbox("Select the scope", ["All cars", "Connect cars"])
+
+# Filtrer les données en fonction du scope
+if scope == "Connect cars":
+    df = df[df['checkin_type'] == 'connect']
+
+# Calculer le pourcentage de réservations affectées
+affected_rentals = df[df['delay'] <= threshold*60].shape[0]
+total_rentals = df.shape[0]
+share_affected_rentals = affected_rentals / total_rentals * 100
+
+# Afficher les résultats
+st.write(f"Percentage of rentals potentially affected by the feature: {share_affected_rentals:.2f}%")
+
+# Analyser les retards
+late_checkins = df[df['late_checkin'] == True].shape[0]
+total_checkins = df.shape[0]
+share_late_checkins = late_checkins / total_checkins * 100
+
+st.write(f"Share of late check-ins: {share_late_checkins:.2f}%")
+
+
+
+# Analyser les cas problématiques résolus
+solved_cases = df[(df['delta'] < threshold*60) & (df['late_checkin'] == True)].shape[0]
+st.write(f"Number of problematic cases solved by the feature: {solved_cases}")

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+fastapi
+uvicorn
+pandas
+scikit-learn
+joblib
+mlflow

train.py

@@ -0,0 +1,83 @@
+# import argparse
+import os
+import pandas as pd
+import time
+import mlflow
+from mlflow.models.signature import infer_signature
+from sklearn.model_selection import train_test_split 
+
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error
+
+
+if __name__ == "__main__":
+
+
+    os.environ["APP_URI"] = "https://zacbl-getaround.hf.space"
+
+    # Set your variables for your environment
+    EXPERIMENT_NAME="Car_Price_Prediction"
+
+    print("training model...")
+    
+    # Time execution
+    start_time = time.time()
+
+    # Call mlflow autolog
+    mlflow.sklearn.autolog() 
+
+    with mlflow.start_run() as run:
+
+        # Import dataset
+        df = pd.read_csv("https://full-stack-assets.s3.eu-west-3.amazonaws.com/Deployment/get_around_pricing_project.csv", sep=";")
+
+
+        # Split the data into train and test :
+        X = df.drop(columns = 'rental_price_per_day', axis = 1)
+        y = df['rental_price_per_day']
+
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)
+
+        # Define the numerical and categorical columns :
+        num_cols = X.select_dtypes(include = ['int64', 'float64']).columns
+        cat_cols = X.select_dtypes(include = ['object', 'bool']).columns
+        # Train / test split 
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)
+
+
+        # Define the pipeline :
+        num_pipeline = Pipeline([
+            ('scaler', StandardScaler())
+        ])
+
+        full_pipeline = ColumnTransformer([
+            ('num', num_pipeline, num_cols),
+            ('cat', OneHotEncoder(), cat_cols)
+        ])
+
+        # Make a pipeline containing the full pipeline and the model :
+        model = Pipeline([
+            ('preprocessing', full_pipeline),
+            ('model', LinearRegression())
+        ])
+
+        # Fit the model :
+        model.fit(X_train, y_train)
+
+        # Predict the price :
+        predictions = model.predict(X_test)
+
+        # Calculate the mean squared error :
+        mean_squared_error(y_test, predictions)
+        # Print r2 score :
+        model.score(X_test, y_test)
+
+        
+    print("...Done!")
+    print("Saving model...")
+    mlflow.sklearn.log_model(model, "model", signature=infer_signature(X_train, predictions))
+    print("...Model saved!")
+    print(f"---Total training time: {time.time()-start_time}")