Ez a cikk arról szól, hogy a Python-ot gépi tanulási vagy mesterséges intelligencia (AI) kontextusban valós idejű előrejelzések készítésére használjuk, egy Flask REST API-val. Az itt bemutatott architektúra a koncepció igazolásától (PoC) a gépi tanulási alkalmazások minimális életképes termékéig (MVP) való elmozdulásnak tekinthető.

Piton nem az első választás, amelyre a valós idejű megoldás megtervezésekor lehet gondolni. De mint Tensorflow és Scikit-Learn a Python által támogatott leggyakrabban használt gépi tanulási könyvtárak, sokakban kényelmesen használják Jupyter Notebook PoC-k .

A megoldhatóvá teszi ezt a megoldást az a tény, hogy a képzés sok időt vesz igénybe a jósláshoz képest. Ha úgy gondolja, hogy az edzés egy filmnézés és a vele kapcsolatos kérdésekre adott válaszok előrejelzése, akkor elég hatékonynak tűnik, ha nem kell újból megnéznie a filmet minden új kérdés után.

Az edzés egyfajta tömörített nézet a filmről, és az előrejelzés az információk lekérése a tömörített nézetből. Nagyon gyorsnak kell lennie, legyen az összetett vagy hosszú film.

Ezt valósítsuk meg egy gyors [Lombik] példával a Pythonban!

Általános gépi tanulási architektúra

Kezdjük egy általános képzési és előrejelzési architektúra folyamat felvázolásával:

Először egy képzési folyamatot hoznak létre, hogy megismerjék a múltbeli adatokat egy célfüggvény szerint.

Ennek két kulcselemet kell kiadnia:

1. Műszaki funkciók : az edzéskor használt transzformációkat a becslés időpontjában újra fel kell használni.
2. Modellparaméterek : a véglegesen kiválasztott algoritmust és hiperparamétereket el kell menteni, hogy azokat a jóslás időpontjában újra felhasználhassák

Ne feledje, hogy az edzés ideje alatt elvégzett funkciótervezést gondosan el kell menteni, hogy az az előrejelzéshez alkalmazható legyen. Az egyik szokásos probléma, amely sok más mellett felmerülhet, az az funkció skálázás ami sok algoritmushoz szükséges.

c corp vagy s corp llc

Ha az X1 jellemzőt 1-ről 1000-re méretezzük, és a [0,1] tartományba skálázzuk f(x) = x/max(X1) függvénnyel, mi történne, ha az előrejelzési halmaz értéke 2000?

Néhány gondos beállítást előre meg kell gondolni, hogy a leképezési függvény következetes kimeneteket adjon vissza, amelyeket az előrejelzéskor helyesen számolnak ki.

Gépi tanulás és előrejelzés

Itt egy fő kérdéssel kell foglalkozni. Miért különítjük el az edzéseket és az előrejelzéseket?

Teljesen igaz, hogy a gépi tanulási példák és tanfolyamok kontextusában, ahol minden adat előre ismert (beleértve a megjósolni kívánt adatokat is), a prediktor felépítésének nagyon egyszerű módja az, hogy verem edzés és előrejelzési adatok (általában tesztkészletnek hívják).

Ezután az „edzéskészleten” kell edzeni és a „tesztkészleten” előre jelezni az eredmények elérése érdekében, ugyanakkor vonat- és tesztadatokon is jellemzőket kell kidolgozni, ugyanabban az és egyedi folyamatban kell edzeni és előrejelezni. .

Azonban a való életben rendszerint rendelkezik edzési adatokkal, és a megjósolni kívánt adatok éppen akkor kerülnek be, amikor feldolgozásra kerülnek. Más szavakkal, egyszerre nézed meg a filmet, és később kérdései vannak vele kapcsolatban, ami azt jelenti, hogy a válaszoknak könnyűnek és gyorsnak kell lenniük.

Ezenkívül általában nem szükséges a teljes modell újratanítása minden egyes alkalommal, amikor új adatok érkeznek, mivel a képzés időbe telik (egyes képkészleteknél hetek is lehetnek), és idővel elég stabilnak kell lennie.

Éppen ezért a képzés és az előrejelzés sok rendszeren egyértelműen elkülöníthető, sőt el is különíthető, és ez jobban tükrözi azt is, hogy az intelligens rendszer (mesterséges vagy nem) hogyan tanul.

A kapcsolat a túlfeszítéssel

Az edzés és az előrejelzés szétválasztása szintén jó módszer a túlillesztési probléma kezelésére.

A statisztikákban a túlillesztés „olyan elemzés készítése, amely túlságosan vagy pontosan megfelel egy adott adatsorozatnak, és ezért nem képes kiegészíteni a további adatokat vagy megbízhatóan megjósolni a jövőbeni megfigyeléseket”.

A zöld vonal egy túl felszerelt modellt, a fekete vonal pedig egy szabályosított modellt jelent. Míg a zöld vonal követi a legjobban az edzés adatait, túlságosan függ attól az adatoktól, és valószínűleg nagyobb lesz az új nem látott adatoknál a hibaarány, mint a fekete vonalon.

A túlillesztést különösen a sok funkcióval rendelkező adatkészletek vagy a korlátozott képzési adatokkal rendelkező adatkészletek mutatják. Mindkét esetben az adatok túl sok információval rendelkeznek ahhoz képest, amit a prediktor érvényesíteni tud, és előfordulhat, hogy némelyikük nem is kapcsolódik a megjósolt változóhoz. Ebben az esetben maga a zaj is jelként értelmezhető.

A túlillesztés ellenőrzésének jó módja az adatok egy részének betanítása és egy másik rész előrejelzése, amelyen megalapozott igazságunk van. Ezért az új adatok várható hibája nagyjából az adott adatkészlet mért hibája, feltéve, hogy az általunk képzett adatok reprezentatívak a rendszer valóságára és jövőbeli állapotaira.

Tehát, ha megfelelő oktatási és előrejelzési folyamatot tervezünk az adatok helyes felosztásával együtt, nemcsak a túlillesztési problémával foglalkozunk, hanem újrafelhasználhatjuk ezt az architektúrát az új adatok előrejelzéséhez.

Az utolsó lépés annak ellenőrzése, hogy az új adatok hibája megegyezik-e a vártal. Mindig van elmozdulás (a tényleges hiba mindig a vártnál alacsonyabb), és meg kell határozni, hogy mi az elfogadható elmozdulás - de ez nem a cikk témája.

REST API előrejelzéshez

Itt jön jól az edzés és az előrejelzés egyértelmű elkülönítése. Ha elmentettük a tervezési módszereinket és a modellparamétereinket, akkor egy egyszerű REST API-t készíthetünk ezekkel az elemekkel.

A legfontosabb itt a modell és a paraméterek betöltése az API indításakor. Miután elindította és tárolta a memóriában, minden API-hívás elindítja az ML-algoritmus funkciótervezési számítását és „előrejelzési” módszerét. Mindkettő általában elég gyors a valós idejű válasz biztosításához.

Az API úgy tervezhető, hogy elfogadjon egy egyedi előrejelezhető példát, vagy több különböző példát (kötegelt előrejelzés).

Itt van a minimális Python / Flask kód, amely ezt az elvet valósítja meg, JSON be és JSON ki (kérdés be, válasz ki):

app = Flask(__name__) @app.route('/api/makecalc/', methods=['POST']) def makecalc(): ''' Function run at each API call No need to re-load the model ''' # reads the received json jsonfile = request.get_json() res = dict() for key in jsonfile.keys(): # calculates and predicts res[key] = model.predict(doTheCalculation(key)) # returns a json file return jsonify(res) if __name__ == '__main__': # Model is loaded when the API is launched model = pickle.load(open('modelfile', 'rb')) app.run(debug=True)

Vegye figyelembe, hogy az API használható az új adatokból történő előrejelzésre, de nem javaslom a modell oktatásához. Használható, de ez bonyolítja a képzési kódot, és igényesebb lehet a memória erőforrásai szempontjából.

Megvalósítási példa - Bike Sharing

Vegyünk példaként egy Kaggle-adatbázist, a kerékpármegosztást. Tegyük fel, hogy egy kerékpár-megosztó cég vagyunk, amely előre akarja előrejelezni a kerékpárkölcsönzések számát minden nap annak érdekében, hogy jobban kezelhesse a kerékpár karbantartását, logisztikáját és egyéb üzleti szempontjait.

A bérleti díjak elsősorban az időjárási viszonyoktól függenek, így az időjárás-előrejelzéssel ez a vállalat jobb képet kaphat, amikor a bérleti díjak tetőznek, és megpróbálhatja elkerülni a karbantartást ezeken a napokon.

Először egy modellt képezünk ki és mentünk savanyúságként, amely a Jupyter jegyzetfüzet .

A modellképzéssel és a teljesítménnyel itt nem foglalkozunk, ez csak egy példa a teljes folyamat megértésére.

Ezután megírjuk az egyes API-hívásoknál végrehajtandó adatátalakítást:

import numpy as np import pandas as pd from datetime import date def doTheCalculation(data): data['dayofyear']=(data['dteday']- data['dteday'].apply(lambda x: date(x.year,1,1)) .astype('datetime64[ns]')).apply(lambda x: x.days) X = np.array(data[['instant','season','yr','holiday','weekday','workingday', 'weathersit','temp','atemp','hum','windspeed','dayofyear']]) return X

Ez csak egy változó (az év napja) kiszámítása, amely magában foglalja mind a hónapot, mind a pontos napot. Választható oszlopok és azok sorrendje is.

Meg kell tehát írnunk a REST API-t a Lombikkal:

from flask import Flask, request, redirect, url_for, flash, jsonify from features_calculation import doTheCalculation import json, pickle import pandas as pd import numpy as np app = Flask(__name__) @app.route('/api/makecalc/', methods=['POST']) def makecalc(): ''' Function run at each API call ''' jsonfile = request.get_json() data = pd.read_json(json.dumps(jsonfile),orient='index',convert_dates=['dteday']) print(data) res = dict() ypred = model.predict(doTheCalculation(data)) for i in range(len(ypred)): res[i] = ypred[i] return jsonify(res) if __name__ == '__main__': modelfile = 'modelfile.pickle' model = pickle.load(open(modelfile, 'rb')) print('loaded OK') app.run(debug=True)

Futtassa ezt a programot, alapértelmezés szerint az 5000-es porton fogja kiszolgálni az API-t.

Ha egy kérést helyben tesztelünk, még mindig a Python segítségével:

import requests, json url = '[http://127.0.0.1:5000/api/makecalc/](http://127.0.0.1:5000/api/makecalc/)' text = json.dumps({'0':{'instant':1,'dteday':'2011-01-01T00:00:00.000Z','season':1,'yr':0,'mnth':1,'holiday':0,'weekday':6,'workingday':0,'weathersit':2,'temp':0.344167,'atemp':0.363625,'hum':0.805833,'windspeed':0.160446}, '1':{'instant':2,'dteday':'2011-01-02T00:00:00.000Z','season':1,'yr':0,'mnth':1,'holiday':0,'weekday':3,'workingday':0,'weathersit':2,'temp':0.363478,'atemp':0.353739,'hum':0.696087,'windspeed':0.248539}, '2':{'instant':3,'dteday':'2011-01-03T00:00:00.000Z','season':1,'yr':0,'mnth':1,'holiday':0,'weekday':1,'workingday':1,'weathersit':1,'temp':0.196364,'atemp':0.189405,'hum':0.437273,'windspeed':0.248309}})

A kérelem tartalmazza az összes információt, amelyet a modell betáplált. Ezért modellünk válaszol a kerékpárkölcsönzés előrejelzésére a megadott időpontokra (itt van hárman).

headers = {'content-type': 'application/json', 'Accept-Charset': 'UTF-8'} r = requests.post(url, data=text, headers=headers) print(r,r.text) { '0': 1063, '1': 1028, '2': 1399 }

Ez az! Ez a szolgáltatás bármely vállalat alkalmazásában könnyen használható, karbantartási tervezéshez, vagy ahhoz, hogy a felhasználók tisztában legyenek a kerékpáros forgalommal, az igényekkel és a bérelhető kerékpárok rendelkezésre állásával.

Mindezt együttvéve

Számos gépi tanulási rendszer, és különösen a PoC-k fő hibája a képzés és az előrejelzés keverése.

Ha ezeket gondosan elkülönítik egymástól, akkor a valós idejű előrejelzések meglehetősen egyszerűen elvégezhetők egy MVP számára, meglehetősen alacsony fejlesztési költségekkel és erőfeszítésekkel a Python / Flask használatával, különösen, ha sok PoC esetében eredetileg a Scikit-learn-el fejlesztették, Tensorflow , vagy bármely más Python gépi tanulási könyvtár.

Ez azonban nem biztos, hogy megvalósítható minden alkalmazásnál, különösen azoknál az alkalmazásoknál, ahol a funkciótervezés nehéz, vagy azoknál az alkalmazásoknál, amelyek a legközelebbi egyezést kapják meg, és amelyeknek minden híváskor a legfrissebb adatokkal kell rendelkezniük.

Mindenesetre újra és újra meg kell néznie a filmeket, hogy válaszoljon a rájuk vonatkozó kérdésekre? Ugyanez a szabály vonatkozik a gépi tanulásra is!

Az alapok megértése

Mi az a REST API?

A webszolgáltatások összefüggésében a RESTful API-kat a következő szempontokkal határozzák meg: URL, médiatípus és HTTP módszer (GET, POST stb.). Használhatók az alkalmazások közötti információcsere egységes módjaként.

Mi a gépi tanulás?

A gépi tanulás a mesterséges intelligencia egy része a számítástechnika területén, amely gyakran statisztikai technikákat használ arra, hogy a számítógépek képesek legyenek „tanulni” (azaz fokozatosan javítani egy adott feladat teljesítményét) adatokkal, anélkül, hogy kifejezetten programoznák őket.

Mi az a Tensorflow?

A TensorFlow egy nyílt forráskódú szoftverkönyvtár az adatfolyamok programozásához számos feladaton keresztül. Ez egy szimbolikus matematikai könyvtár, és gépi tanulási alkalmazásokhoz, például ideghálózatokhoz is használják.

Mi az a Scikit-Learn?

A Scikit-learn, valamint a sklearn, egy ingyenes szoftveres gépi könyvtár a Python programozási nyelv számára.

Mi a funkciótervezés?

A funkciótervezés az adatok tartományismeretének felhasználása olyan funkciók létrehozására, amelyek működtetik a gépi tanulási algoritmusokat. A rendelkezésre álló adatokat kiegészíti a megjósolt cél szempontjából releváns további információkkal.

Mi a Jupyter?

A Jupyter Notebook (korábban IPython Notebooks) egy webalapú interaktív számítási környezet, amely támogatja a Python programozási nyelvet.

Mi az a PoC?

A PoC, vagy a koncepció igazolása egy olyan első szakaszú program, amely bemutatja a projekt megvalósíthatóságát.