La capacità di prevedere i tempi di consegna è cruciale per molti settori, dall'e-commerce alla logistica. Questo perché conoscere in anticipo i tempi di consegna permette di gestire al meglio le risorse, sia in termini di personale che di mezzi di trasporto, e di fornire un servizio efficiente e puntuale ai clienti. In questo articolo, vedremo come utilizzare Python e il deep learning per sviluppare un modello in grado di prevedere i tempi di consegna con un'elevata accuratezza. Attraverso l'utilizzo di tecniche di data preprocessing, costruzione del modello e addestramento, mostreremo come è possibile ottenere risultati promettenti utilizzando questo approccio.
I servizi di consegna di cibo come Zomato e Swiggy devono mostrare il tempo preciso necessario per consegnare il tuo ordine per mantenere la trasparenza con i loro clienti. Queste aziende utilizzano algoritmi di Machine Learning o Deep Learning per prevedere i tempi di consegna del cibo in base a quanto tempo i partner di consegna hanno impiegato per la stessa distanza in passato. Quindi, se vuoi imparare a utilizzare l'apprendimento automatico per la previsione dei tempi di consegna del cibo, questo articolo fa per te. Questo articolo ti illustrerà la previsione dei tempi di consegna del cibo con il Deep Learning utilizzando Python.
Previsione dei tempi di consegna con Python
Per prevedere il tempo di consegna del cibo in tempo reale, dobbiamo calcolare la distanza tra il punto di preparazione del cibo e il punto di consumo del cibo. Dopo aver trovato la distanza tra il ristorante e i luoghi di consegna, dobbiamo trovare le relazioni tra il tempo impiegato dai partner di consegna per consegnare il cibo in passato per la stessa distanza.
Quindi, per questa attività, abbiamo bisogno di un set di dati contenente dati sul tempo impiegato dai corrieri per consegnare il cibo dal ristorante al luogo di consegna. Ho trovato un set di dati ideale con tutte le funzionalità per questa attività. È possibile scaricare il set di dati da qui .
Nella sezione seguente, ti illustrerò l'attività di previsione dei tempi di consegna del cibo con l'apprendimento prodondo utilizzando Python.
Se non ti va di seguire il tutorial perchè già sei esperto puoi passare direttamente a scaricare il progetto e i dati :
Clicca qui per scaricare il progetto finito.
Previsione dei tempi di consegna del cibo utilizzando Python
Inizierò l'attività di previsione dei tempi di consegna del cibo importando le librerie Python necessarie e il set di dati :
#importiamlo le librerie
import pandas as pd
import numpy as np
import plotly.express as px
#leggiamo il dataset
data = pd.read_csv("deliverytime.txt")
print(data.head())Output :
ID Delivery_person_ID Delivery_person_Age Delivery_person_Ratings \
0 4607 INDORES13DEL02 37 4.9
1 B379 BANGRES18DEL02 34 4.5
2 5D6D BANGRES19DEL01 23 4.4
3 7A6A COIMBRES13DEL02 38 4.7
4 70A2 CHENRES12DEL01 32 4.6
Restaurant_latitude Restaurant_longitude Delivery_location_latitude \
0 22,745049 75,892471 22,765049
1 12.913041 77.683237 13.043041
2 12,914264 77,678400 12,924264
3 11.003669 76.976494 11.053669
4 12.972793 80.249982 13.012793
Luogo_di_consegna_longitudine Tipo_di_ordine Tipo_di_veicolo Tempo_impiegato(min)
0 75.912471 Snack moto 24
1 77.813237 Monopattino snack 33
2 77.688400 Bevande moto 26
3 77.026494 Buffet moto 21
4 80.289982 Monopattino snack 30Diamo un'occhiata agli approfondimenti della colonna prima di andare avanti:
#stampiamo le info
data.info()Output :
<class 'pandas.core.frame.DataFrame'> RangeIndex: 45593 entries, 0 to 45592 Data columns (total 11 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 ID 45593 non-null object 1 Delivery_person_ID 45593 non-null object 2 Delivery_person_Age 45593 non-null int64 3 Delivery_person_Ratings 45593 non-null float64 4 Restaurant_latitude 45593 non-null float64 5 Restaurant_longitude 45593 non-null float64 6 Delivery_location_latitude 45593 non-null float64 7 Delivery_location_longitude 45593 non-null float64 8 Type_of_order 45593 non-null object 9 Type_of_vehicle 45593 non-null object 10 Time_taken(min) 45593 non-null int64 dtypes: float64(5), int64(2), object(4) memory usage: 3.8+ MBOra diamo un'occhiata se questo set di dati contiene o meno valori nulli:
#vediamo se questo set di dati contiene o meno valori nulli
data.isnull().sum()Output :
ID 0 Delivery_person_ID 0 Delivery_person_Age 0 Delivery_person_Ratings 0 Restaurant_latitude 0 Restaurant_longitude 0 Delivery_location_latitude 0 Delivery_location_longitude 0 Type_of_order 0 Type_of_vehicle 0 Time_taken(min) 0 dtype: int64Il set di dati non ha valori Null. Andiamo oltre!
Calcolo della distanza tra latitudine e longitudine con python
Il set di dati non ha alcuna funzionalità che mostri la differenza tra il ristorante e il luogo di consegna. Tutto quello che abbiamo sono i punti di latitudine e longitudine del ristorante e il luogo di consegna. Possiamo usare la formula haversine per calcolare la distanza tra due posizioni in base alle loro latitudini e longitudini.
Di seguito è riportato come possiamo trovare la distanza tra il ristorante e il luogo di consegna in base alle loro latitudini e longitudini utilizzando la formula haversine:
#raggio terra in km
R = 6371
# Converte i gradi in radianti
def deg_to_rad(degrees):
return degrees * (np.pi/180)
# Funzione per calcolare la distanza tra due punti usando la haversine formula
def distcalculate(lat1, lon1, lat2, lon2):
d_lat = deg_to_rad(lat2-lat1)
d_lon = deg_to_rad(lon2-lon1)
a = np.sin(d_lat/2)**2 + np.cos(deg_to_rad(lat1)) * np.cos(deg_to_rad(lat2)) * np.sin(d_lon/2)**2
c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1-a))
return R * c
# Calcoliamo la distanza per ogni coppiaa di punti
data['distance'] = np.nan
for i in range(len(data)):
data.loc[i, 'distance'] = distcalculate(data.loc[i, 'Restaurant_latitude'],
data.loc[i, 'Restaurant_longitude'],
data.loc[i, 'Delivery_location_latitude'],
data.loc[i, 'Delivery_location_longitude'])
Ora abbiamo calcolato la distanza tra il ristorante e il luogo di consegna. Abbiamo anche aggiunto una nuova funzionalità nel set di dati come distanza. Diamo un'occhiata di nuovo al set di dati:
print(data.head())Oputput:
ID Delivery_person_ID Delivery_person_Age Delivery_person_Ratings \ 0 4607 INDORES13DEL02 37 4.9 1 B379 BANGRES18DEL02 34 4.5 2 5D6D BANGRES19DEL01 23 4.4 3 7A6A COIMBRES13DEL02 38 4.7 4 70A2 CHENRES12DEL01 32 4.6 Restaurant_latitude Restaurant_longitude Delivery_location_latitude \ 0 22.745049 75.892471 22.765049 1 12.913041 77.683237 13.043041 2 12.914264 77.678400 12.924264 3 11.003669 76.976494 11.053669 4 12.972793 80.249982 13.012793 Delivery_location_longitude Type_of_order Type_of_vehicle Time_taken(min) \ 0 75.912471 Snack motorcycle 24 1 77.813237 Snack scooter 33 2 77.688400 Drinks motorcycle 26 3 77.026494 Buffet motorcycle 21 4 80.289982 Snack scooter 30 distance 0 3.025149 1 20.183530 2 1.552758 3 7.790401 4 6.210138 Esplorazione dei dati
Ora esploriamo i dati per trovare le relazioni tra le caratteristiche. Inizierò osservando la relazione tra la distanza e il tempo impiegato per consegnare il cibo:
figure = px.scatter(data_frame = data,
x="distance",
y="Time_taken(min)",
size="Time_taken(min)",
trendline="ols",
title = "Relationship Between Distance and Time Taken")
figure.show()
Esiste una relazione coerente tra il tempo impiegato e la distanza percorsa per consegnare il cibo. Significa che la maggior parte dei partner di consegna consegna il cibo entro 25-30 minuti, indipendentemente dalla distanza.
Ora diamo un'occhiata al rapporto tra il tempo impiegato per consegnare il cibo e l'età del partner di consegna:
figure = px.scatter(data_frame = data,
x="Delivery_person_Age",
y="Time_taken(min)",
size="Time_taken(min)",
color = "distance",
trendline="ols",
title = "Relationship Between Time Taken and Age")
figure.show() 
Esiste una relazione lineare tra il tempo impiegato per consegnare il cibo e l'età del partner di consegna. Significa che i giovani partner di consegna impiegano meno tempo per consegnare il cibo rispetto ai partner più anziani.
Ora diamo un'occhiata al rapporto tra il tempo impiegato per consegnare il cibo e le valutazioni del partner di consegna:
figure = px.scatter(data_frame = data,
x="Delivery_person_Ratings",
y="Time_taken(min)",
size="Time_taken(min)",
color = "distance",
trendline="ols",
title = "Relationship Between Time Taken and Ratings")
figure.show()
Esiste una relazione lineare inversa tra il tempo impiegato per consegnare il cibo e le valutazioni del partner di consegna. Significa che i partner di consegna con valutazioni più elevate impiegano meno tempo a consegnare il cibo rispetto ai partner con valutazioni basse.
Ora diamo un'occhiata se il tipo di cibo ordinato dal cliente e il tipo di veicolo utilizzato dal partner di consegna influisce o meno sui tempi di consegna:
fig = px.box(data,
x="Type_of_vehicle",
y="Time_taken(min)",
color="Type_of_order")
fig.show()
Non c'è molta differenza tra il tempo impiegato dai corrieri a seconda del veicolo che stanno guidando e il tipo di cibo che stanno consegnando.
Quindi le caratteristiche che contribuiscono maggiormente ai tempi di consegna del cibo in base alla nostra analisi sono:
età del partner di consegna
valutazioni del partner di consegna
distanza tra il ristorante e il luogo di consegna
Nella sezione seguente, ti illustrerò come addestrare un modello di Machine Learning per la previsione dei tempi di consegna del cibo.
Quindi le caratteristiche che contribuiscono maggiormente ai tempi di consegna del cibo in base alla nostra analisi sono:
età del partner di consegna
valutazioni del partner di consegna
distanza tra il ristorante e il luogo di consegna
Nella sezione seguente, ti illustrerò come addestrare un modello di Machine Learning per la previsione dei tempi di consegna del cibo.
Modello di previsione dei tempi di consegna del cibo
Ora addestriamo un modello di Machine Learning utilizzando un modello di rete neurale LSTM per l'attività di previsione del tempo di consegna del cibo:
# dividiamo i dati
from sklearn.model_selection import train_test_split
x = np.array(data[["Delivery_person_Age",
"Delivery_person_Ratings",
"distance"]])
y = np.array(data[["Time_taken(min)"]])
xtrain, xtest, ytrain, ytest = train_test_split(x, y,
test_size=0.10,
random_state=42)
# creiamo un LSTM neural network model
from keras.models import Sequential
from keras.layers import Dense, LSTM
model = Sequential()
model.add(LSTM(128, return_sequences=True, input_shape= (xtrain.shape[1], 1)))
model.add(LSTM(64, return_sequences=False))
model.add(Dense(25))
model.add(Dense(1))
model.summary()Oputput:
Modello: "sequenziale"
_________________________________________________________________
Livello (tipo) Output Shape Param #
=================================================== ===============
lstm (LSTM) (Nessuno, 3, 128) 66560
lstm_1 (LSTM) (Nessuno, 64) 49408
denso (Denso) (Nessuno, 25) 1625
dense_1 (Dense) (Nessuno, 1) 26
=================================================== ===============
Parametri totali: 117.619
Parametri addestrabili: 117.619
Parametri non addestrabili: 0
Penultimo passaggio, alleniamo il modello con queste linee di codice :
# Alleniamo il modello
model.compile(optimizer='adam', loss='mean_squared_error')
model.fit(xtrain, ytrain, batch_size=1, epochs=9)l'output sarà questo :
Epoch 1/9 41033/41033 [==============================] - 188s 4ms/step - loss: 68.9068
Epoch 2/9 41033/41033 [==============================] - 183s 4ms/step - loss: 64.1141
Epoch 3/9 41033/41033 [==============================] - 177s 4ms/step - loss: 61.7114
Epoch 4/9 41033/41033 [==============================] - 178s 4ms/step - loss: 60.5743
Epoch 5/9 41033/41033 [==============================] - 177s 4ms/step - loss: 59.7754
Epoch 6/9 41033/41033 [==============================] - 182s 4ms/step - loss: 59.5807
Epoch 7/9 41033/41033 [==============================] - 177s 4ms/step - loss: 59.0811
Epoch 8/9 41033/41033 [==============================] - 174s 4ms/step - loss: 59.3632
Epoch 9/9 41033/41033 [==============================] - 161s 4ms/step - loss: 59.2885
<keras.callbacks.History at 0x7fc38c25d400>Ora testiamo le prestazioni del nostro modello fornendo input per prevedere il tempo di consegna del cibo:
#divertiti a fare previsioni
print("Food Delivery Time Prediction")
a = int(input("Età del Delivery Partner: "))
b = float(input("Voto della precedente consegna: "))
c = int(input("Distanza totale: "))
features = np.array([[a, b, c]])
print("Tempo previsto dal modello da aspettare in minuti = ", model.predict(features))l'output sarà questo :
Food Delivery Time Prediction
Età del Delivery Partner: 28
Voto della precedente consegna: 2.8
Distanza totale: 5
1/1 [==============================] - 1s 782ms/step
Tempo previsto dal modello da aspettare in minuti = [[32.381138]]Quindi è così che puoi utilizzare Deep Learning per l'attività di previsione dei tempi di consegna del cibo utilizzando il linguaggio di programmazione Python.
Riepilogo
Per prevedere il tempo di consegna del cibo in tempo reale, è necessario calcolare la distanza tra il punto di preparazione del cibo e il punto di consumo del cibo. Dopo aver trovato la distanza tra il ristorante e i luoghi di consegna, è necessario trovare le relazioni tra il tempo impiegato dai corrieri a consegnare il cibo in passato per la stessa distanza. Naturalmente questo si limita ad essere un semplice esempio. Per renderlo più realistico si potrebbe collegare alle api di google maps per aggiungere dati come il traffico, il numero di strade o percorsi disponibili, la velocità media percorsa in quelle strade e molto altro. Se ti va di estendere il progetto o di scaricarlo clica il bottone qui sotto:
_gif.gif)
.png)
Comentarios