Használja Python és adattudományi eszközöket (Jupyter, NumPy, Pandas, scikit-learn) a forgalom előrejelzéséhez

A TomTom Maps és API-szolgáltatások hatalmas mennyiségű adatot termelnek. Az adattudósok hozzáférhetnek ezekhez az adatokhoz, hogy betekintést nyerjenek, és előrejelzéseket készíthessenek a jobb teljesítmény és a vevői elégedettség érdekében hozott üzleti döntések meghozatalához.

Mi, adattudósok és fejlesztők különféle történelmi és valós idejű adatokat találhatunk projektjeink segítségére, mint például a "forgalmi statisztikák", a "valós idejű forgalom", a "helyelőzmények", "értesítések", "térképek" és "útválasztás". , és útelemzés. A TomTom kiterjedt dokumentációja és fejlesztői közössége támogat minket, amikor ezekkel a gazdag, könnyen hozzáférhető adatokkal játszunk. Használhatjuk például a TomTom adatait prediktív modellezéshez.

Ebben a cikkben azt mutatjuk be, hogyan használhatjuk a TomTom API-adatokat prediktív modellezéshez. A baleseti adatokat arra használjuk, hogy megtudjuk, mikor és hol történnek a legnagyobb valószínűséggel balesetek. Látni fogja, milyen egyszerű a TomTom térképi adatainak használata adattudományi projektjeihez. Lehívjuk a forgalmi adatokat egy térképalkalmazásból, amely csatlakozik a TomTom API-khoz, majd kivonunk egy adatkészletet az előrejelzések modelljének elkészítéséhez. Felügyelt tanulási feladatunkhoz a RandomForestRegressort fogjuk használni.

A modell betanítása után értékeljük és finomítjuk, amíg pontos nem lesz, majd üzembe helyezzük, hogy valós időben működjön együtt a TomTom Maps API-val. Végül Pythont és néhány kedvenc adattudományi eszközt (Jupyter Notebook, NumPy, Pandas és scikit-learn) használunk adataink feltárásához és előrejelzések készítéséhez.

PREDIKTÍV MODELL KÉSZÍTÉSE TOMTOM ADATOK ALAPJÁN

Modellünk létrehozásához először egy térképalkalmazáshoz csatlakoztatott TomTom API-kból gyűjtjük az adatokat. Ezután az alábbi képen látható keretrendszert követve elkészítjük az adatkészletet, összeállítjuk, betanítjuk és kiértékeljük a modellt. Szükség esetén modellünket finomítjuk. Végül bevezetjük a modellünket, hogy forgalmi statisztikákat biztosítsunk.

A keretrendszerünknek két módja van:

  • Offline mód: A modell adatkészletét CSV vagy Excel fájlként exportáljuk. Ezután megépítjük a modellt, betanítjuk, addig finomítjuk, amíg elfogadható eredményeket ad, és végül online módba helyezzük, hogy gyakorlati ajánlásokat és értékes betekintést nyerjünk.
  • Online mód: Képzett modellünk a térképalkalmazások bemeneti adatait használja a valós idejű helyzetekre való azonnali előrejelzéshez, valamint betekintések és javaslatok elkészítéséhez.

A Jupyter Notebookban (IPython) a Python programozási nyelvet használjuk a Numpy, Pandas és scikit-learn csomagoktól függően. Baleset-előrejelzési problémánk megoldásához a scikit-learn könyvtárból a RandomForestRegressor-t és az idősorelemzéshez az ARIMA modellt választjuk.

A TomTom Data használatához érvényes TomTom fejlesztői fiókkal kell rendelkeznünk, és fiókunkból le kell kérnünk a TomTom Maps API kulcsot. Ezt a kulcsot használjuk a térképalkalmazásunkban, hogy kapcsolódjunk bizonyos szolgáltatásokhoz, például a Zapier-hez, hogy adatokat gyűjtsünk az alkalmazásaink TomTom Data szolgáltatásokból generált webhookjaiból. Ezenkívül ahhoz, hogy a Zapiert a TomTom webhookkal együtt használhassuk, létre kell hoznunk egy "Zapier-fiókot", és létre kell hoznunk egy "kapcsolatot" a térképalkalmazásunkkal. Ezt követően Zapier segítségével összegyűjthetjük adatainkat a TomTom API-kból, és tárolhatjuk az alkalmazás adatbázisban (online módhoz), vagy CSV fájlban (offline módhoz).

ELKEZDENI

A projektadatokkal való munka megkezdéséhez modellt kell felépíteni a balesetek havi, heti, napi, óránkénti, sőt utcai kódok alapján történő előrejelzésére. Amint az előző részben említettük, a modell idősoros elemzést is végez a TomTom API-kból származó adatokon.

Kezdjük a Python-könyvtárak és egyéb funkciók importálásával környezetünk beállításához:

# Import helpful libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
from IPython.display import display
import warnings
warnings.filterwarnings("ignore")

AZ ADATKEZELÉS FELTÁRÁSA

Adatkészletünk felfedezésének megkezdéséhez betöltjük egy Pandas DataFrame-be. Prediktív modellünk felépítése előtt először elemeznünk kell az általunk használt adatkészletet, és fel kell mérnünk azt a gyakori problémákra, amelyek előfeldolgozást igényelhetnek.

Ehhez egy kis adatmintát jelenítünk meg, leírjuk az adatok típusát. , ismerje meg alakját vagy méreteit, és ha szükséges, fedezze fel az alapvető statisztikákat és egyéb információkat. Feltérképezzük a beviteli funkciókat és az esetleges rendellenességeket vagy érdekes tulajdonságokat is, amelyekkel foglalkoznunk kell. Szeretnénk mélyebben megérteni adatkészletünket, beleértve a sémáját, az értékeloszlást, a hiányzó értékeket és a kategorikus jellemzők számát.

Az alábbi kód betölti az adatkészletünket, és egy kis mintát jelenít meg néhány statisztikai információval:

accidents_data = pd.read_csv('traffic_data.csv')
display(accidents_data.head())

Ezenkívül előfordulhat, hogy az alábbi kód segítségével meg kell vizsgálnunk az adatkészlet jellemzőit:

accidents_data.info()
accidents_data.dtypes
accidents_data.isnull().sum()
accidents_data.describe()
accidents_data.columns

Az adataink különböző összetevői közötti kapcsolatok megértéséhez – és potenciálisan rendellenességek és sajátosságok felfedezéséhez – a Python Matplotlib vagy Seaborn könyvtárát használjuk az adatok ábrázolására és megjelenítésére. A következő kód hisztogramot jelenít meg a balesetek általános sűrűségére vonatkozóan az adatkészletünkben:

sns.distplot(accidents_data.Accidents)
plt.hist(accidents_data.Accidents,facecolor='peru',edgecolor='blue',bins=10)
plt.show()

Előfordulhat, hogy havi és óránkénti hisztogramokat is meg kell néznünk a balesetek mennyiségének becsléséhez. Ehhez a következő kódrészletet használhatjuk:

plt.hist(accidents_data['Month'],facecolor='orangered',edgecolor='maroon',bins=12)
plt.hist(accidents_data['Hour'],facecolor='peru',edgecolor='blue',bins=24,alpha=0.3)
plt.show()

Az adatkészletünkben szereplő balesetek másik módja a kördiagramok használata. A következő kód bemutatja, hogyan lehet kördiagramokat használni az egy év során bekövetkezett balesetek áttekintésére:

fig, axs = plt.subplots(1,2,figsize=(10, 5))
plt.subplots_adjust(left=0.5,
                    bottom=0.1, 
                    right=2, 
                    top=0.9, 
                    wspace=0.5, 
                    hspace=0.5)
axs[0].pie(m_frequency.values(),labels=Months)
axs[0].axis('equal')
axs[0].set_title('Monthly',y=1.1,size = 18)
axs[1].pie(d_frequency.values(),labels=WeekDays)
axs[1].axis('equal')
axs[1].set_title('Daily',y=1.1,size = 18)
 fig.suptitle('Accidents over a year',x=1.1,y=1.1,size = 18)

Vegye figyelembe, hogy az ünnepi szezonban alacsonyabb a balesetek aránya. A héten pedig az ünnepeket leszámítva egyenletesen oszlik meg a balesetek száma. Ez azt jelenti, hogy az adatainkban szereplő balesetek erősen korrelálnak a munkanapokkal és időpontokkal.

Ezenkívül vonaldiagramokat használhatunk egyes jellemzők viselkedésének vizsgálatára. A következő kód a balesetek számát mutatja a nap minden órájában:

plt.plot(h_codes,h_frequency.values()) 
#Adding the aesthetics
plt.title('Accidents by time of day')
plt.xlabel('Time')
plt.ylabel('Number of accidents') 
#Show the plot
plt.show()

Vagy oszlopdiagramok segítségével megjeleníthetjük a havi baleseteket az év során, az alábbiak szerint:

plt.bar(m_codes, m_frequency.values())
plt.xlabel('Month', fontsize=5)
plt.ylabel('Number of accidents', fontsize=5)
plt.xticks(m_codes, Months, fontsize=5, rotation=30)
plt.title('Monthly accidents over a year')
plt.show()

Az előző vizualizációból azt látjuk, hogy a legtöbb baleset elsősorban az év elején történik. Ezt követően a balesetek száma egy ideig csökken, majd a harmadik negyedévben emelkedik. Talán ez azért van, mert az iskolák az évnek ebben az időszakában nyitnak. Ezután a szám ismét csökkenni kezd egészen az év végéig. Emellett azt is láthatjuk, hogy csúcsforgalomban megszaporodnak a napi balesetek.

Az adatkészletünk jellemzői közötti kapcsolatok megfigyeléséhez használhatunk szóródiagramot. A szóródiagram egy adatelemet helyez el az x tengely, egy másikat az y tengely mentén, és minden adatponthoz egy pontot rajzol. Itt az utcákat az utcakódok használatával indexeljük, mivel a TomTom a városon belüli összes utcát kód szerint osztályozza. Az utcaszám használatához hozzuk létre az indexet.

A következő kóddal feltárhatjuk a balesetek számát a különböző utcákban:

streets=range(1,701857)
street_codes=[]
s_frequency = {}
for s in accidents_data['Street Code']:
    if s in s_frequency:
        s_frequency[s] += 1
    else:
        s_frequency[s] = 0
        street_codes.append(int(s))
plt.rcParams.update({'figure.figsize':(10,8), 'figure.dpi':100}) 
plt.scatter(street_codes, s_frequency.values(), c=street_codes, cmap='Spectral')
plt.colorbar()
plt.title('Accidents accross the streets')
plt.xlabel('Street Code')
plt.ylabel('Number of Accidents')
plt.show()

A fenti grafikon azt mutatja, hogy egyes utcákon nagy a balesetek száma (kék körök). A többi utca normál számon van.

Mint fentebb látható, a TomTom adatait felhasználhatjuk valós idejű információkhoz a forgalmi és időjárási viszonyokról, amelyek hasznosak a baleseti gócpontok és más értékes statisztikák azonosításában.

Mielőtt folytatnánk a modell felépítését, elő kell dolgoznunk az adatkészletünket, hogy rendelkezzen egy jellemző adatkerettel és egy céladatkerettel (az előrejelzési változóval), az alábbiak szerint:

y=accidents_data.Accidents
features = ['Month', 'Day', 'Hour','Street Code','Latitude', 'Longitude']
X=accidents_data[features]

AZ EDZŐKÉSZLET ÉS TESZT KÉSZLET OSZTÁSA

Mielőtt felállítanánk a modellünket, adatainkat két részre kell osztanunk: egy képzési készletre és egy tesztkészletre. A képzési készletet használjuk gépi tanulási modellünk felépítéséhez. Ezután tesztkészletünkkel mérjük, hogy a modell mennyire működik jól.

Nem használhatjuk ugyanazokat az adatokat mindkét feladathoz, mert modellünk egyszerűen meg tudja jegyezni a teljes képzési halmazt, és következetesen helyes előrejelzéseket készít a képzési halmaz bármely pontjára.

A scikit-learn szoftver tartalmaz egy függvényt, amely megkeveri az adatkészletet, és a train_test_split függvény segítségével felosztja azt számunkra. Ez a függvény az adatsorok 75 százalékát kibontja tanítási halmazként a megfelelő címkékkel együtt. Az adatok fennmaradó 25 százalékát és azok címkéit hívja meg a tesztkészlethez.

Most meghívjuk a train_test_split parancsot, és a kimeneteket ezzel a kóddal rendeljük hozzá:

from sklearn.model_selection import train_test_split
train_X, val_X, train_y, val_y = train_test_split(X, y, random_state = 0)

A MODELL ÉPÍTÉSE

Most elkezdhetjük a tényleges tanulási modell felépítését. A scikit-learnben számos osztályozási algoritmus közül választhatunk, de itt a RandomForestRegressort használjuk. A következő kódot használjuk:

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
predictive_model = RandomForestRegressor(random_state=1)
Then we will train a predictive model to predict the number of accidents based on the specified features as follows: -
predictive_model.fit(train_X, train_y)
accidents_preditions = predictive_model.predict(val_X)
model_err = mean_absolute_error(val_y ,accidents_preditions)
print("Validation Error for Random Forest Model: {:,.0f}".format(model_err))

A modellünkből származó előrejelzések számos forgalmi körülménytől függenek, például az évszaktól, a héttől, a naptól, a napszaktól vagy a körzetszámoktól. Több balesetre számíthatunk a kiindulóponttól (kiindulási ponttól) távolabb eső utcákban, nagy forgalom mellett, munkanapokon és csúcsforgalomban.

Ezután meg kell határoznunk a mérőszámokat vagy számításokat a modellünk teljesítményének és eredményeinek mérésére. Előrejelzéseinket a megadott példák tényleges osztályozása alapján kell pontoznunk. Ezeket a számításokat és mérőszámokat a problémánk jellemzői és területe alapján kell indokolnunk.

Különféle teljesítménymérési mérőszámokat használhatunk, mint például a pontosság (A), a precizitás (P), a visszahívás (R) és az „F-score”. Itt értékeljük modellünk pontosságát (osztályozási arányát), amely a modellünk által helyesen megjósolt előrejelzések töredéke.

A pontossági pontszámot a következő képlet segítségével számítjuk ki:

A baleseti adatok további vizsgálatát a különböző időközönként rögzített adatpontok sorozatának (balesetek száma időbélyegzőnként) elemzésével végezhetjük el, különböző statisztikai eszközök és technikák segítségével. Az egyszerűség kedvéért idősoros elemzésünkhöz a jól ismert ARIMA statisztikai modellt használjuk. Ez segít az idősoros előrejelzésben – más szóval egy idősor jövőbeli értékeinek előrejelzésében a múltbeli eredmények alapján.

Az elemzés elvégzéséhez idősoros mintát kell felépíteni adatkészlet az alábbiak szerint:

import datetime
from pandas import DataFrame
dates=[]
for i  in range(1,len(X)+1):
    dates.append(datetime.datetime(2020, X['Month'][i], X['Day'][i],X['Hour'][i]))
dates_df=DataFrame(dates,columns=['ts'])
Then we clean it from the missing values using the following code:
df=pd.concat([dates_df, acci_df.to_frame()], axis=1)
from statsmodels.tsa.stattools import adfuller
from numpy import log
clean_df=df.dropna()
clean_df=df.dropna()
sample = adfuller(clean_df.Accidents)
print('ADF Statistic: %f' % sample[0])
print('p-value: %f' % sample[1])

Ahhoz, hogy az idősor stacioner legyen, meg kell különböztetnünk, és meg kell néznünk, hogyan néz ki az automatikus korrekciós diagram. Az alábbi kód megmutatja, hogyan kell ezt megtenni:

from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
plt.rcParams.update({'figure.figsize':(9,7), 'figure.dpi':120})
fig, axes = plt.subplots(3, 2, sharex=True)
axes[0, 0].plot(clean_df.Accidents); axes[0, 0].set_title('Original Time Series for accidents over a year')
plot_acf(clean_df.Accidents, ax=axes[0, 1])
axes[1, 0].plot(clean_df.Accidents.diff()); axes[1, 0].set_title('1st Order Differencing')
plot_acf(clean_df.Accidents.diff().dropna(), ax=axes[1, 1])
# 2nd Differencing
axes[2, 0].plot(clean_df.Accidents.diff().diff()); axes[2, 0].set_title('2nd Order Differencing')
plot_acf(clean_df.Accidents.diff().diff().dropna(), ax=axes[2, 1])
plt.show()

Most egy ARIMA modellt készíthetünk a következőképpen:

from statsmodels.tsa.arima_model import ARIMA
model = ARIMA(clean_df.Accidents, order=(1,1,2))
model_fit = model.fit(disp=0)
print(model_fit.summary())

A következő kód megmutatja, hogyan kell ábrázolni a maradék hibákat:

residuals = pd.DataFrame(model_fit.resid)
fig, ax = plt.subplots(1,2)
residuals.plot(title="Residuals", ax=ax[0])
residuals.plot(kind='kde', title='Density', ax=ax[1])
plt.show()

A fenti elemzés során azt találtuk, hogy a modellünkben szereplő idősorok nem stacionáriusak. Ez azt jelenti, hogy a balesetek nem rendszeres, hanem alkalmi körülmények alapján következnek be, amint azt korábban a TomTom adatokon alapuló prediktív modell elemzésekor tárgyaltuk.

KÖVETKEZŐ LÉPÉSEK

A TomTom megkönnyíti az adattudósok számára az API-kból származó adatok lekérését és működésbe hozását. Miután gyorsan és hatékonyan lekértük a forgalmi adatokat térképalkalmazásunkból, amely csatlakozik a TomTom API-khoz, kinyertünk egy adatkészletet a modellünk elkészítéséhez. Felügyelt tanulási feladatunkhoz RandomForestRegressort használtunk. Ezután adataink feltárása és megjelenítése érdekében az adatainkat képzési és tesztkészletekre bontjuk.

A modell betanítása után kiértékeltük és finomítottuk, amíg pontos nem lett, majd bevezettük, hogy valós időben működjön együtt a TomTom Maps API-val. Ezzel a modellel most megjósolhatjuk, hogy mikor és hol történnek a legnagyobb valószínűséggel balesetek. Egy ilyen modellel a flottalogisztikai csapat meg tudja jósolni, hogy flottájuk járművei várhatóan hány balesetet szenvednek el az általuk megtett útvonalak alapján.

Ez csak egy példa arra, hogy mit tud előre jelezni a TomTom adatokkal. Például azt is megjósolhatja, hogy a járművek mennyi időt fognak eltölteni a forgalomban késve, a különböző útvonallehetőségek befolyását a becsült érkezési idejükre stb. Ezek az előrejelzések segíthetnek meghatározni a flották számára a legmegfelelőbb útvonalat, amellyel eljuthatnak a célállomásig, kevesebb késéssel és kisebb balesetveszélyességgel.

Ha a TomTom gazdag történelmi és valós idejű forgalmi adatait szeretné használni saját adattudományi alkalmazásaiban, regisztráljon, és kezdje el használni a TomTom Maps alkalmazást még ma. Naponta több ezer technikai támogatási kérés élvezhető, mindezt ingyenesen.

Ez a cikk eredetileg a developer.tomtom.com/blog címen jelent meg