Implementazione della tariffazione delle camere d’albergo basata sulla domanda nella scienza dei dati utilizzando MLOps

Implementazione della tariffazione delle camere d'albergo basata sulla domanda utilizzando MLOps un approccio scientifico dei dati

Introduzione

Durante il Covid, l’industria dell’ospitalità ha subito una massiccia diminuzione dei ricavi. Quindi quando le persone viaggiano di più, ottenere un cliente rimane una sfida. Svilupperemo un’apprendimento automatico per risolvere questo problema e impostare la stanza giusta per attirare più clienti. Utilizzando i dati dell’hotel, costruiremo uno strumento di intelligenza artificiale per selezionare il prezzo corretto della camera, aumentare il tasso di occupazione e incrementare i ricavi dell’hotel.

Obiettivi di Apprendimento

Importanza di impostare il prezzo corretto per le camere d’albergo.
Pulizia dei dati, trasformazione dei dataset e pre-elaborazione dei dataset.
Creazione di mappe e grafici visivi utilizzando i dati delle prenotazioni degli hotel.
Applicazione concreta dell’analisi dei dati delle prenotazioni degli hotel utilizzata nella scienza dei dati.
Esecuzione dell’analisi dei dati delle prenotazioni degli hotel utilizzando il linguaggio di programmazione Python.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

Cos’è il Dataset dei Prezzi delle Camere d’Hotel?

Il dataset delle prenotazioni degli hotel contiene dati da diverse fonti, che includono colonne come il tipo di hotel, il numero di adulti, la durata del soggiorno, le richieste speciali, ecc. Questi valori possono aiutare a prevedere il prezzo delle camere d’hotel e contribuire ad aumentare i ricavi dell’hotel.

Cos’è l’Analisi dei Prezzi delle Camere d’Hotel?

Nell’analisi dei prezzi delle camere d’hotel, analizzeremo i modelli e le tendenze del dataset. Utilizzando queste informazioni, prenderemo decisioni relative alla definizione dei prezzi e alle operazioni. Queste decisioni dipenderanno da diversi fattori.

Stagionalità: I prezzi delle camere aumentano significativamente durante le stagioni di punta, come le festività.
Domanda: I prezzi delle camere aumentano quando la domanda è elevata, ad esempio durante una celebrazione di un evento o una manifestazione sportiva.
Concorrenza: I prezzi delle camere d’hotel sono influenzati in modo significativo dai prezzi degli hotel nelle vicinanze. Se ci sono molti hotel in un’area, il prezzo delle camere diminuirà.
Servizi: Se l’hotel dispone di piscina, spa e palestra, addebiterà di più per questi servizi.
Posizione: L’hotel in città principale può addebitare di più rispetto a quello in una zona remota.

Importanza di Impostare il Giusto Prezzo delle Camere d’Hotel

Impostare il prezzo della camera è fondamentale per aumentare i ricavi e il profitto. L’importanza di impostare il giusto prezzo dell’hotel è la seguente:

Massimizzare i ricavi: Il prezzo dell’hotel è la chiave principale per aumentare i ricavi. Impostando un prezzo competitivo, gli hotel possono aumentare i ricavi.
Aumentare i clienti: Più ospiti prenoteranno l’hotel quando i prezzi delle camere sono equi. Questo aiuta ad aumentare il tasso di occupazione.
Massimizzare il profitto: Gli hotel cercano di addebitare di più per aumentare il profitto. Tuttavia, un prezzo più alto ridurrà il numero di ospiti, mentre un prezzo giusto aumenterà il numero.

Raccolta dei Dati e Pre-elaborazione

La raccolta dei dati e la pre-elaborazione sono parte essenziale dell’analisi dei prezzi delle camere d’hotel. I dati vengono raccolti dai siti web degli hotel, dai siti di prenotazione e dai dataset pubblici. Questo dataset viene quindi convertito nel formato richiesto per scopi di visualizzazione. Nella pre-elaborazione, il dataset viene sottoposto a pulizia e trasformazione dei dati. Il nuovo dataset trasformato viene utilizzato per la visualizzazione e la creazione del modello.

Visualizzazione del Dataset Utilizzando Strumenti e Tecniche

La visualizzazione del dataset aiuta a ottenere una visione approfondita e a individuare i modelli per prendere decisioni migliori. Di seguito sono riportati gli strumenti di Python per offrire una migliore visualizzazione.

Matplotlib: Matplotlib è uno strumento fondamentale in Python utilizzato per creare grafici come grafici a barre e linee.
Seaborn: Seaborn è un altro strumento di visualizzazione in Python. Aiuta a creare immagini di visualizzazione più dettagliate come mappe di calore e grafici a violino.

Tecniche utilizzate per visualizzare il dataset di prenotazione dell’hotel.

Grafici a box: Questa libreria traccia il grafico tra il segmento di mercato e il soggiorno. Aiuta a comprendere il tipo di cliente.
Grafici a barre: Utilizzando un grafico a barre, tracciamo il grafico tra il fatturato giornaliero medio e i mesi; ciò aiuta a comprendere i mesi più occupati.
Grafico di conteggio: Abbiamo tracciato il grafico tra il segmento di mercato e il tipo di deposito utilizzando un grafico di conteggio per capire quali segmenti di hotel ricevono più depositi.

Casi d’uso e applicazioni dell’analisi dei dati delle camere d’hotel in data science

Il dataset di prenotazioni dell’hotel ha molteplici casi d’uso e applicazioni come descritto di seguito:

Analisi del sentiment del cliente: Utilizzando tecniche di apprendimento automatico, come l’analisi del sentiment del cliente, dalle recensioni dei clienti, i manager possono determinare il sentiment e migliorare il servizio per un’esperienza migliore.
Previsione del tasso di occupazione: Dalle recensioni e dalle valutazioni dei clienti, i manager possono stimare il tasso di occupazione delle camere nel breve termine.
Operazioni aziendali: Questo dataset può anche essere utilizzato per tenere traccia dell’inventario; ciò permette agli hotel di avere camere e materiale sufficienti.
Alimentazione e bevande: I dati possono anche essere utilizzati per stabilire prezzi per alimenti e bevande al fine di massimizzare il fatturato pur rimanendo competitivi.
Valutazione delle prestazioni: Questo dataset aiuta anche a sviluppare suggerimenti personalizzati per l’esperienza di un ospite. Migliorando così le valutazioni degli hotel.

Sfide nell’analisi dei dati delle camere d’hotel

Le date delle prenotazioni delle camere d’hotel possono presentare diverse sfide per diverse ragioni:

Qualità dei dati: Poiché raccogliamo dati da diversi dataset, la qualità dei dati è compromessa e sorgono rischi di dati mancanti, inconsistenze e inesattezze.
Privacy dei dati: L’hotel raccoglie dati sensibili dai clienti e se questi dati vengono divulgati, minacciano la privacy dei clienti. Pertanto, seguire le linee guida sulla sicurezza dei dati diventa quasi una priorità.
Integrazione dei dati: L’hotel ha diversi sistemi, come la gestione della proprietà e i siti di prenotazione, pertanto l’integrazione di questi sistemi presenta difficoltà.
Volume dei dati: I dati delle camere dell’hotel possono essere estesi, rendendo difficile la gestione e l’analisi.

Best practices nell’analisi dei dati delle camere d’hotel

Le migliori pratiche nell’analisi dei dati delle camere d’hotel:

Per raccogliere dati, utilizzare sistemi di gestione della proprietà, piattaforme di prenotazione online e sistemi di feedback degli ospiti.
Garantire la qualità dei dati monitorando e pulendo regolarmente i dati.
Proteggere la privacy dei dati implementando misure di sicurezza e conformandosi alle normative sulla privacy dei dati.
Integrare i dati da diversi sistemi per ottenere una visione completa dei dati delle camere dell’hotel.
Utilizzare tecniche di apprendimento automatico come LSTM per prevedere le tariffe delle camere.
Utilizzare l’analisi dei dati per ottimizzare le operazioni aziendali, come l’inventario e il personale.
Utilizzare l’analisi dei dati per indirizzare le campagne di marketing al fine di attrarre più ospiti.
Utilizzare l’analisi dei dati per valutare le prestazioni e fornire esperienze innovative agli ospiti.
Con l’aiuto dell’analisi dei dati, la direzione può comprendere meglio il proprio cliente e fornire un servizio migliore.

Tendenze future e sviluppi nell’analisi dei dati delle camere d’hotel in data science

Con l’aumento della spesa dei consumatori, l’industria alberghiera e turistica ne trae grandi benefici. Ciò crea nuove tendenze e dati da analizzare sulla spesa e il comportamento del cliente. L’aumento degli strumenti di intelligenza artificiale crea l’opportunità di esplorare e massimizzare l’industria. Con l’aiuto di uno strumento di intelligenza artificiale, è possibile raccogliere i dati necessari ed eliminare i dati indesiderati, ovvero effettuare una pre-elaborazione dei dati.

Su questa base di dati, è possibile addestrare il modello per generare informazioni preziose e produrre analisi in tempo reale. Ciò aiuta anche a fornire esperienze personalizzate basate su singoli clienti e ospiti. Questo beneficia enormemente l’hotel e il cliente.

L’analisi dei dati aiuta anche il team di gestione a comprendere meglio il cliente e l’inventario. Ciò aiuta a stabilire una tariffazione dinamica delle camere in base alla domanda. Una miglior gestione dell’inventario aiuta a ridurre i costi.

Analisi dei dati delle camere d’albergo con implementazione in Python

Eseguiamo un’analisi fondamentale dei dati con implementazione in Python su un dataset da Kaggle. Per scaricare il dataset, clicca qui.

Dettagli dei dati

Il dataset delle prenotazioni dell’ostello include informazioni su diversi tipi di hotel, come resort e hotel di città, e sulla segmentazione di mercato.

Visualizzazioni dei dataset

Passo 1. Importa librerie e leggi il dataset

#Importa la libreria
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelEncoder

Passo 2. Importa il dataset e ispeziona i dati

#Leggi il file e convertilo in un dataframe
df = pd.read_csv('data\hotel_bookings.csv')
#Mostra la forma del dataframe
df.shape(119390, 32)
#Controlla un esempio di dati
df.head()
#Controlla le informazioni sul dataset
df.info()
#Controlla i valori nulli
df.isna().sum()

OUTPUT

Passo 3. Visualizza il dataset

#Boxplot della distribuzione delle notti trascorse negli hotel per segmento di mercato e tipo di hotel
plt.figure(figsize = (15,8))
sns.boxplot(x = "market_segment", y = "stays_in_week_nights", data = df, hue = "hotel", palette = 'Set1')

OUTPUT

#Boxplot del segmento di mercato rispetto al soggiorno nel weekend
plt.figure(figsize=(12,5))
sns.boxplot(x = "market_segment", y = "stays_in_weekend_nights", data = df, hue = "hotel", palette = 'Set1');

OUTPUT

Osservazione

I grafici sopra mostrano che la maggior parte dei gruppi ha una distribuzione normale, mentre alcuni hanno una forte asimmetria. La maggior parte delle persone tende a soggiornare meno di una settimana. I clienti del segmento Aviation non sembrano soggiornare negli hotel resort e hanno una media giornaliera relativamente più bassa.

#Barplot delle entrate giornaliere medie vs Mese
plt.figure(figsize = (12,5))
sns.barplot(x = 'arrival_date_month', y = 'adr', data = df);

OUTPUT

Descrizioni di lavoro

Nella parte di implementazione, mostrerò come ho utilizzato un’pipeline ZenML per creare un modello che utilizza dati storici dei clienti per prevedere il punteggio di recensione per il prossimo ordine o acquisto. Ho anche implementato un’applicazione Streamlit per presentare il prodotto finale.

Cos’è ZenML?

ZenML è un framework open-source MLOps che semplifica la creazione di pipeline di ML pronte per la produzione. Una pipeline è una serie di passaggi interconnessi, in cui l’output di un passaggio serve come input per un altro passaggio, portando alla creazione di un prodotto finito. Di seguito sono riportati i motivi per cui ho scelto ZenML Pipeline:

Creazione efficiente di pipeline
Standardizzazione dei flussi di lavoro di ML
Analisi dei dati in tempo reale

Creare un modello non è sufficiente; è necessario implementare il modello in produzione e monitorare le prestazioni nel tempo e come interagisce con dati accurati del mondo reale. Una pipeline di machine learning end-to-end è una serie di passaggi interconnessi in cui l’output di un passaggio serve come input per un altro passaggio. L’intero flusso di lavoro di machine learning può essere automatizzato attraverso questo processo, dalla preparazione dei dati all’addestramento e all’implementazione del modello. Questo ci aiuta a prevedere continuamente e implementare con fiducia modelli di machine learning. In questo modo, possiamo monitorare il nostro modello pronto per la produzione. Ti suggerisco vivamente di consultare il documento su ZenML per ulteriori dettagli.

La prima pipeline che creiamo è composta dai seguenti passaggi:

ingest_data: Questo metodo importerà i dati e creerà un DataFrame.
clean_data: Questo metodo pulirà i dati e rimuoverà le colonne indesiderate.
model_train: Questo metodo addestrerà e salverà il modello utilizzando MLflow auto logging.
Evaluation: Questo metodo valuterà il modello e salverà le metriche – utilizzando MLflow auto logging – nell’archivio degli artefatti.

Sviluppo del modello

Come discusso in precedenza, ci sono diverse fasi. Ora ci concentreremo sulla parte di codifica.

Ingestione dei dati

class IngestData:    """    Ingestione dei dati dalla data_path    """    def __init__(self, data_path: str) -> None:        """        Argomenti:            data_path: Percorso in cui si trova il file dati        """         self.data_path = data_path    def get_data(self):        """        Ingestione dei dati da data_path        Restituisce i dati acquisiti        """        logging.info(f"Ingestione dei dati da {self.data_path}")        return pd.read_csv(self.data_path)    @stepdef ingest_df(data_path: str) -> pd.DataFrame:    """"       Ingestione dei dati dal percorso data_path.       Argomenti:       data_path: percorso del dato       Restituisce:       pd.DataFrame: i dati acquisiti     """    try:        ingest_data = IngestData(data_path)        df = ingest_data.get_data()        return df    except Exception as e:        logging.error(f"Si è verificato un errore durante l'acquisizione dei dati")        raise e

In precedenza, abbiamo definito un metodo ingest_df(), che richiede il percorso del file come argomento e restituisce il dataframe. Qui, @step è un decoratore zenml. Viene utilizzato per registrare la funzione come un passo in un pipeline.

Pulizia dei dati e processing

data["agent"].fillna(data["agent"].median(), inplace=True)    data["children"].replace(np.nan, 0, inplace=True)    data = data.drop(data[data['adr'] < 50].index)    data = data.drop(data[data['adr'] > 5000].index)    data["total_stay"] = data['stays_in_week_nights'] + data['stays_in_weekend_nights']    data["total_person"] = data["adults"] + data["children"] + data["babies"]    # Feature Engineeringle = LabelEncoder()    data['hotel'] = le.fit_transform(data['hotel'])    data['arrival_date_month'] = le.fit_transform(data['arrival_date_month'])    data['meal'] = le.fit_transform(data['meal'])    data['country'] = le.fit_transform(data['country'])    data['market_segment'] = le.fit_transform(data['market_segment'])    data['reserved_room_type'] = le.fit_transform(data['reserved_room_type'])    data['assigned_room_type'] = le.fit_transform(data['assigned_room_type'])    data['deposit_type'] = le.fit_transform(data['deposit_type'])    data['customer_type'] = le.fit_transform(data['customer_type'])

Nel codice precedente, stiamo rimuovendo i valori nulli e gli outlier. Uniamo i soggiorni durante la settimana e i soggiorni nel weekend per ottenere i giorni totali di permanenza.
Successivamente, effettuiamo la codifica delle etichette nelle colonne categoriche come hotel, country, deposit type, ecc.

Addestramento del modello

from zenml import pipeline@pipeline(enable_cache=False)def train_pipeline(data_path: str):    df = ingest_df(data_path)    X_train, X_test, y_train, y_test = clean_df(df)    model = train_model(X_train, X_test, y_train, y_test)    r2_score, rsme = evaluate_model(model, X_test, y_test)

Utilizzeremo il decoratore zenml @pipeline per definire il metodo train_pipeline(). Il metodo train_pipeline richiede il percorso del file come argomento. Dopo l’acquisizione dei dati e la suddivisione dei dati in set di addestramento e di test, viene chiamato il metodo train_model(). Questo metodo, train_model(), utilizzerà diversi algoritmi come Lightgbm, Random Forest, Xgboost e Linear_Regression per addestrare il dataset.

Valutazione del modello

Utilizzeremo RMSE, R2 score e MSE di diversi algoritmi per determinarne il migliore. Nel seguente codice, abbiamo definito il metodo evaluate_model() per utilizzare altre metriche di valutazione.

@step(experiment_tracker=experiment_tracker.name)def evaluate_model(model: RegressorMixin,                   X_test: pd.DataFrame,                   y_test: pd.DataFrame,                   ) -> Tuple[                       Annotated[float, "r2_score"],                       Annotated[float, "rmse"]                   ]:    """    Valuta il modello sui dati acquisiti.        Argomenti:        model: RegressorMixin        x_test: pd.DataFrame        y_test: pd.DataFrame        Restituisce:        r2_score,        rmse    """    try:        prediction = model.predict(X_test)        mse_class = MSE()        mse = mse_class.calculate_scores(y_test, prediction)        mlflow.log_metric("mse", mse)                r2_class = R2()        r2 = r2_class.calculate_scores(y_test, prediction)        mlflow.log_metric("r2", r2)        rmse_class = RMSE()        rmse = rmse_class.calculate_scores(y_test, prediction)        mlflow.log_metric("rmse", rmse)        return r2, rmse    except Exception as e:        logging.error("Errore nella valutazione del modello: {}".format(e))        raise e

Impostare l’Ambiente

Crea l’ambiente virtuale usando Python o Anaconda.

# Comando per creare l'ambiente virtuale
python3 -m venv <nome_ambiente_virtuale>

Dovrai installare alcuni pacchetti Python nel tuo ambiente usando il comando qui di seguito.

cd zenml -project /hotel-room-bookingpip install -r requirements.txt

Per eseguire lo script run_deployment.py, dovrai anche installare alcune integrazioni usando ZenML:

zenml initzenml integration install mlflow -y

In questo progetto, abbiamo creato due pipeline

run_pipeline.py, una pipeline che addestra solo il modello
run_deployment.py, una pipeline che anche continua a rilasciare il modello.

run_pipeline.py prenderà il percorso del file come argomento, eseguendo il metodo train_pipeline(). Di seguito è riportata la visualizzazione grafica delle diverse operazioni eseguite da run_pipeline(). Questo può essere visualizzato utilizzando il dashboard fornito da Zenml.

URL del Dashboard: http://127.0.0.1:8237/workspaces/default/pipelines/95881272-b1cc-46d6-9f73-7b967f28cbe1/runs/803ae9c5-dc35-4daa-a134-02bccb7d55fd/dag

run_deployment.py: – In questo file, eseguiremo la continuous_deployment_pipeline e inference_pipeline.

continuous_deployment_pipeline

from pipelines.deployment_pipeline import continuous_deployment_pipeline, inference_pipelinedef main(config: str, min_accuracy: float):    mlflow_model_deployment_component = MLFlowModelDeployer.get_active_model_deployer()    deploy = config == DEPLOY or config == DEPLOY_AND_PREDICT    predict = config == PREDICT or config == DEPLOY_AND_PREDICT    if deploy:        continuous_deployment_pipeline(            data_path=str,            min_accuracy=min_accuracy,            workers=3,            timeout=60        )            df = ingest_df(data_path=data_path)    X_train, X_test, y_train, y_test = clean_df(df)    model = train_model(X_train, X_test, y_train, y_test)    r2_score, rmse = evaluate_model(model,X_test,y_test)    deployment_decision = deployment_trigger(r2_score)    mlflow_model_deployer_step(model=model,                               deploy_decision=deployment_decision,                               workers=workers,                               timeout=timeout)

Nella continuous_deployment_pipeline, creano una pipeline di rilascio continuo per prendere i dati e eseguire l’ingestione dei dati, la suddivisione e l’addestramento del modello. Una volta addestrato il modello, lo valuteranno.

inference_pipeline

@pipeline(enable_cache=False, settings={"docker": docker_settings})
def inference_pipeline(pipeline_name: str, pipeline_step_name: str):    # Collega tutti gli artefatti degli step    batch_data = dynamic_importer()    model_deployment_service = prediction_service_loader(        pipeline_name=pipeline_name,        pipeline_step_name=pipeline_step_name,        running=False,    )    predictor(service=model_deployment_service, data=batch_data)

Nella inference_pipeline, faremo le previsioni una volta che il modello viene addestrato sul dataset di addestramento. Nel codice precedente, utilizziamo dynamic_importer, prediction_service_loader e predictor. Ciascuno di questi metodi ha una funzionalità diversa.

dynamic_importer: – Carica il dataset e esegue la pre-elaborazione.
prediction_service_loader: – Carica il modello distribuito utilizzando il parametro nome della pipeline e nome dello step offerto da Zenml.
Predictor: – Una volta che il modello è addestrato, si effettuerà una previsione sul dataset di test.

Ora visualizzeremo le pipeline utilizzando il dashboard di Zenml per una visione chiara.

Dashboard della continuous_deployment_pipeline: –

URL del Dashboard: http://127.0.0.1:8237/workspaces/default/pipelines/9eb06aba-d7df-43ef-a017-8cb5bb13cd89/runs/e4208fa5-48c8-4a8c-91f1-011c5e1ddbf9/dag

Dashboard della inference_pipeline: –

URL del dashboard: -http://127.0.0.1:8237/workspaces/default/pipelines/07351bb1-6b0d-400e-aeea-551159346f0e/runs/c1ce61f8-dd12-4244-a4d6-514e5520b879/dag

Abbiamo distribuito un’app Streamlit che utilizza il servizio di modelli più recente asincronamente dalla pipeline. Può essere fatto rapidamente con ZenML all’interno del codice Streamlit. Per eseguire questa app Streamlit nel sistema locale, utilizza il comando qui sotto:

# comando per eseguire l'app Streamlit in localestreamlit run streamlit_app.py

Puoi ottenere il codice di implementazione completo dall’inizio alla fine qui

Risultati

Abbiamo sperimentato con vari algoritmi e confrontato le prestazioni di ciascun modello. I risultati sono i seguenti:

Il modello Random Forest ottiene le migliori prestazioni, con l’MSE più basso e il punteggio R^2 più alto. Ciò significa che è il più accurato nel prevedere la variabile target e spiega la maggior parte della varianza nella variabile target. Il modello LightGBM è il secondo miglior modello, seguito dal modello XGBoost. Il modello di Regressione Lineare è il peggiore.

Applicazione Demo

Una demo live di questa progetto utilizzando Streamlit. Prende alcune caratteristiche di input per il prodotto e prevede il tasso di soddisfazione del cliente utilizzando i nostri modelli addestrati.

Conclusioni

Anche il settore delle prenotazioni di camere d’albergo sta evolvendo rapidamente poiché l’accessibilità a Internet è aumentata in diverse parti del mondo. A causa di ciò, la domanda di prenotazione di camere d’albergo online è aumentata. La gestione alberghiera vuole sapere come mantenere i propri ospiti e migliorare prodotti e servizi per prendere decisioni migliori. Il machine learning è vitale in vari settori, come la segmentazione dei clienti, la previsione della domanda, la raccomandazione di prodotti, la soddisfazione degli ospiti, ecc.

Domande Frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell’autore.

blogathon,dataset,Hotel Room Price,Machine Learning,MLOps