Készítsen prediktív karbantartási megoldást az Amazon Kinesis, az AWS Glue és az Amazon SageMaker segítségével

A szervezetek egyre gyakrabban építenek és használnak gépi tanulás (ML) alapú megoldásokat különféle felhasználási esetekre és problémákra, ideértve a gépalkatrészek prediktív karbantartását, az ügyfelek preferenciáin alapuló termékajánlásokat, a hitelprofilok meghatározását, a tartalom moderálását, a csalások felderítését stb. Sok ilyen forgatókönyv esetén az ML-alapú megoldások hatékonysága és előnyei tovább fokozhatók, ha közel valós időben képesek feldolgozni az adateseményeket és betekintést nyerni azokból.

Noha a közel valós idejű, ML-alapú megoldások üzleti értéke és előnyei jól megalapozottak, az ilyen megoldások optimális megbízhatósággal és teljesítménnyel történő nagyszabású megvalósításához szükséges architektúra bonyolult. Ez a bejegyzés leírja, hogyan kombinálhatod Amazon kinezis, AWS ragasztóés Amazon SageMaker közel valós idejű funkciótervezési és következtetési megoldás létrehozásához a prediktív karbantartáshoz.

Használati eset áttekintése

Olyan prediktív karbantartási felhasználási esetekre összpontosítunk, ahol a terepen telepített érzékelőket (például ipari berendezéseket vagy hálózati eszközöket) ki kell cserélni vagy ki kell javítani, mielőtt meghibásodnának és leállást okoznának. Az állásidő drága lehet a vállalkozások számára, és rossz ügyfélélményhez vezethet. Az ML-modellel működő prediktív karbantartás a rendszeres ütemezett karbantartási ciklusok kibővítésében is segíthet azáltal, hogy tájékoztatást ad arról, hogy egy jó állapotú gépalkatrészt mikor nem érdemes cserélni, elkerülve ezzel a felesleges költségeket.

Ebben a bejegyzésben a gépi tanulás alkalmazására összpontosítunk egy olyan szintetikus adatkészletre, amely olyan jellemzők miatti géphibákat tartalmaz, mint a levegő hőmérséklete, a folyamat hőmérséklete, a forgási sebesség, a nyomaték és a szerszámkopás. A használt adatkészlet forrása a UCI adattár.

A gép meghibásodása öt független hibamódból áll:

• Szerszámkopáshiba (TWF)
• Hőelvezetési hiba (HDF)
• Áramkimaradás (PWF)
• Túlfeszültségi hiba (OSF)
• Véletlenszerű hiba (RNF)

A géphiba címke jelzi, hogy a gép meghibásodott-e egy adott adatponton, ha az előző hibamódok bármelyike ​​igaz. Ha a hibamódok közül legalább az egyik igaz, a folyamat meghiúsul, és a géphiba címke 1-re van állítva. Az ML-modell célja a géphibák helyes azonosítása, így egy későbbi prediktív karbantartási művelet kezdeményezhető.

Megoldás áttekintése

A prediktív karbantartási felhasználási esetünkben feltételezzük, hogy az eszközérzékelők különféle méréseket és leolvasásokat küldenek a gépalkatrészekről. Megoldásunk ezután minden alkalommal vesz egy szeletet a streaming adatokból (mikro kötegelt), és feldolgozást és funkciótervezést hajt végre a szolgáltatások létrehozásához. A létrehozott szolgáltatásokat ezután arra használják, hogy egy betanított és telepített ML-modellből közel valós időben következtetéseket generáljanak. Az előállított következtetéseket tovább feldolgozhatják és felhasználhatják a downstream alkalmazások, hogy megtegyék a megfelelő lépéseket és elindítsák a karbantartási tevékenységet.

Az alábbi ábra bemutatja átfogó megoldásunk felépítését.

A megoldás nagyjából a következő szakaszokból áll, amelyeket ebben a bejegyzésben később részletesen ismertetünk:

• Streaming adatforrás és feldolgozás - Mi használjuk Amazon Kinesis adatfolyamok a terepi érzékelőktől származó streaming adatok nagyarányú összegyűjtése és további feldolgozás céljából elérhetővé tétele.
• Közel valós idejű funkciótervezés – Az AWS Glue streaming feladatokat használjuk a Kinesis adatfolyamból való adatok beolvasására, valamint adatfeldolgozás és funkciótervezés végrehajtására, mielőtt a származtatott szolgáltatásokat tárolnánk Amazon egyszerű tárolási szolgáltatás (Amazon S3). Az Amazon S3 megbízható és költséghatékony lehetőséget kínál nagy mennyiségű adat tárolására.
• Modellképzés és bevetés – Az UCI Data Repository-ból származó AI4I prediktív karbantartási adatkészletet használjuk az XGBoost algoritmuson alapuló ML modell betanításához a SageMaker segítségével. Ezután telepítjük a betanított modellt egy SageMaker aszinkron következtetési végpontra.
• Közel valós idejű ML következtetés – Miután a funkciók elérhetővé váltak az Amazon S3-ban, közel valós időben kell következtetéseket generálnunk a telepített modellből. A SageMaker aszinkron következtetési végpontjai jól megfelelnek ennek a követelménynek, mert támogatják a nagyobb hasznos adatméreteket (1 GB-ig), és perceken belül (legfeljebb 15 percen belül) képesek következtetéseket generálni. Az S3 eseményértesítéseket használjuk egy AWS Lambda függvény egy SageMaker aszinkron következtetési végpont meghívásához. A SageMaker aszinkron következtetési végpontjai elfogadják az S3 helyeket bemenetként, következtetéseket generálnak a telepített modellből, és csaknem valós időben írják vissza ezeket a következtetéseket az Amazon S3-ba.

A megoldás forráskódja itt található GitHub. A megoldást tesztelték, és az us-east-1-ben kell futtatni.

Használunk egy AWS felhőképződés sablon használatával telepítve AWS szerver nélküli alkalmazásmodell (AWS SAM) és SageMaker notebookokkal a megoldás üzembe helyezéséhez.

Előfeltételek

A kezdéshez előfeltételként rendelkeznie kell a SAM CLI, Python 3és PIP telepítve. Önnek is rendelkeznie kell a AWS parancssori interfész (AWS CLI) megfelelően konfigurálva.

Telepítse a megoldást

Használhatja AWS CloudShell hogy ezeket a lépéseket végrehajtsa. A CloudShell egy böngészőalapú shell, amely előzetesen hitelesített a konzol hitelesítő adataival, és tartalmaz előre telepített általános fejlesztői és műveleti eszközöket (például AWS SAM, AWS CLI és Python). Ezért nincs szükség helyi telepítésre vagy konfigurációra.

• Kezdjük egy S3 tároló létrehozásával, ahol tároljuk az AWS Glue streaming feladatunk szkriptjét. Futtassa a következő parancsot a terminálon egy új vödör létrehozásához:

aws s3api create-bucket --bucket sample-script-bucket-$RANDOM --region us-east-1

• Jegyezze fel a létrehozott vödör nevét.

• Ezután helyileg klónozzuk a kódtárat, amely tartalmazza a CloudFormation sablont a verem üzembe helyezéséhez. Futtassa a következő parancsot a terminálon:

git clone https://github.com/aws-samples/amazon-sagemaker-predictive-maintenance

• Keresse meg a sam-template könyvtárat:

cd amazon-sagemaker-predictive-maintenance/sam-template

• Futtassa a következő parancsot az AWS ragasztófeladat-szkript másolásához (a glue_streaming/app.py fájlból) a létrehozott S3 tárolóba:

aws s3 cp glue_streaming/app.py s3://sample-script-bucket-30232/glue_streaming/app.py

• Most már folytathatja a megoldás felépítését és üzembe helyezését a CloudFormation sablonon keresztül az AWS SAM segítségével. Futtassa a következő parancsot:

sam deploy --guided

• Adjon meg argumentumokat a telepítéshez, például a verem nevét, az előnyben részesített AWS régiót (us-east-1), És GlueScriptsBucket.

Győződjön meg arról, hogy ugyanazt az S3 tárolót adja meg, mint amelyet korábban az AWS Glue script S3 gyűjteményéhez (paraméter GlueScriptsBucket a következő képernyőképen).

A szükséges argumentumok megadása után az AWS SAM elindítja a verem központi telepítését. A következő képernyőkép a létrehozott erőforrásokat mutatja.

A verem sikeres telepítése után a következő üzenetnek kell megjelennie.

• Az AWS CloudFormation konzolon nyissa meg a verem (ehhez a bejegyzéshez, nrt-streaming-inference), amelyet a CloudFormation-sablon telepítésekor biztosítottak.
• A Tudástár lapon vegye figyelembe a SageMaker jegyzetfüzet példányazonosítóját.

• A SageMaker konzolon nyissa meg ezt a példányt.

A SageMaker jegyzetfüzet-példányban már vannak előre betöltve a szükséges jegyzetfüzetek.

Keresse meg a jegyzetfüzetek mappát, nyissa meg, és kövesse a jegyzetfüzetekben található utasításokat (Data_Pre-Processing.ipynb és a ModelTraining-Evaluation-and-Deployment.ipynb).

Streaming adatforrás és feldolgozás

A Kinesis Data Streams egy szerver nélküli, méretezhető és tartós valós idejű adatfolyam-szolgáltatás, amellyel valós időben gyűjthet össze és dolgozhat fel nagy adatfolyamokat. A Kinesis Data Streams lehetővé teszi a különféle forrásokból származó adatfolyamok rögzítését, feldolgozását és tárolását, például IT-infrastruktúra-naplóadatokat, alkalmazásnaplókat, közösségi médiát, piaci adatfolyamokat, webes kattintási adatfolyamokat, IoT-eszközöket és érzékelőket stb. A Kinesis adatfolyamot az átviteli sebességtől és a méretezési követelményektől függően igény szerinti vagy kiépített módban is létrehozhatja. További információkért lásd Az adatfolyam-kapacitás mód kiválasztása.

Felhasználási esetünkben feltételezzük, hogy különböző érzékelők olyan méréseket küldenek, mint a hőmérséklet, a forgási sebesség, a nyomaték és a szerszámkopás egy adatfolyamba. A Kinesis Data Streams csatornaként működik az adatfolyamok összegyűjtéséhez és feldolgozásához.

Az általunk használt Amazon Kinesis adatgenerátor (KDG) később ebben a bejegyzésben, hogy adatokat generáljon és küldjön egy Kinesis adatfolyamba, szimulálva az érzékelők által generált adatokat. Az adatfolyam-érzékelő-adatfolyamból származó adatokat egy AWS Glue adatfolyam-feladat segítségével veszik fel és dolgozzák fel, amelyet a következőkben tárgyalunk.

Közel valós idejű funkciótervezés

AWS Glue streaming feladatok kényelmes módot biztosítanak a streaming adatok nagyarányú feldolgozására, anélkül, hogy a számítási környezetet kellene kezelni. Az AWS Glue lehetővé teszi kibontási, átalakítási és betöltési (ETL) műveletek végrehajtását a streaming adatokon, folyamatosan futó jobok használatával. Az AWS Glue streaming ETL az Apache Spark Structured Streaming motorra épül, és képes a Kinesis, Apache Kafka és Amazon által kezelt adatfolyam az Apache Kafka számára (Amazon MSK).

A streaming ETL-feladat egyaránt használhatja az AWS Glue beépített átalakításait és az Apache Spark Structured Streamingben natív átalakításokat. Használhatja a Spark ML és MLLib könyvtárak az AWS ragasztófeladatokban az egyszerűbb funkciófeldolgozás érdekében a könnyen elérhető segédkönyvtárak segítségével.

Ha a streaming adatforrás sémája előre meghatározott, megadhatja azt egy AWS-adatkatalógus-táblázatban. Ha a sémadefiníciót nem lehet előre meghatározni, engedélyezheti a sémaészlelést a streaming ETL-feladatban. A feladat ezután automatikusan meghatározza a sémát a bejövő adatokból. Ezenkívül használhatja a AWS Glue Schema Registry lehetővé teszi az adatfolyam-sémák központi felfedezését, vezérlését és fejlesztését. A séma-nyilvántartást tovább integrálhatja az adatkatalógussal, és opcionálisan használhatja a séma-nyilvántartásban tárolt sémákat az AWS Glue táblák vagy partíciók létrehozásakor vagy frissítésekor az adatkatalógusban.

Ehhez a bejegyzéshez létrehozunk egy AWS ragasztóadat-katalógus táblázatot (sensor-stream) forrásként a Kinesis adatfolyamunkat, és definiálja az érzékelő adataink sémáját.

Létrehozunk egy AWS Glue dinamikus adatkeretet az adatkatalógus táblából a streaming adatok kiolvasásához a Kinesisből. A következő lehetőségeket is megadjuk:

• 60 másodperces ablakméret, így az AWS Glue feladat 60 másodperces ablakokban olvassa be és dolgozza fel az adatokat
• A kiinduló helyzet TRIM_HORIZON, lehetővé téve a Kinesis adatfolyam legrégebbi rekordjainak olvasását

Spark MLlib-et is használunk StringIndexer jellemző transzformátor a karakterlánc oszlop típusának címkeindexekbe kódolásához. Ezt az átalakítást a Spark ML Pipelines segítségével valósítják meg. Spark ML Pipelines magas szintű API-k egységes készletét biztosítják az ML-algoritmusok számára, hogy megkönnyítsék több algoritmus egyetlen folyamatba vagy munkafolyamatba való kombinálását.

A foreachBatch API-t használjuk a processBatch nevű függvény meghívására, amely viszont feldolgozza az ezen adatkeret által hivatkozott adatokat. Lásd a következő kódot:

# Read from Kinesis Data Stream
sourceStreamData = glueContext.create_data_frame.from_catalog(database = "sensordb", table_name = "sensor-stream", transformation_ctx = "sourceStreamData", additional_options = {"startingPosition": "TRIM_HORIZON"})
type_indexer = StringIndexer(inputCol="type", outputCol="type_enc", stringOrderType="alphabetAsc")
pipeline = Pipeline(stages=[type_indexer])
glueContext.forEachBatch(frame = sourceStreamData, batch_function = processBatch, options = {"windowSize": "60 seconds", "checkpointLocation": checkpoint_location})

A processBatch funkció elvégzi a megadott átalakításokat, és felosztja az adatokat az Amazon S3-ban év, hónap, nap és kötegazonosító alapján.

Az AWS Glue partícióit is újraparticionáljuk egyetlen partícióra, hogy elkerüljük, hogy túl sok kis fájl legyen az Amazon S3-ban. A több kis fájl gátolhatja az olvasási teljesítményt, mert felerősíti az egyes fájlok megkeresésével, megnyitásával és olvasásával kapcsolatos többletköltséget. Végül a következtetések generálására szolgáló jellemzőket egy előtagba (jellemzőkbe) írjuk az S3 tárolón belül. Lásd a következő kódot:

# Function that gets called to perform processing, feature engineering and writes to S3 for every micro batch of streaming data from Kinesis.
def processBatch(data_frame, batchId):
transformer = pipeline.fit(data_frame)
now = datetime.datetime.now()
year = now.year
month = now.month
day = now.day
hour = now.hour
minute = now.minute
if (data_frame.count() > 0):
data_frame = transformer.transform(data_frame)
data_frame = data_frame.drop("type")
data_frame = DynamicFrame.fromDF(data_frame, glueContext, "from_data_frame")
data_frame.printSchema()
# Write output features to S3
s3prefix = "features" + "/year=" + "{:0>4}".format(str(year)) + "/month=" + "{:0>2}".format(str(month)) + "/day=" + "{:0>2}".format(str(day)) + "/hour=" + "{:0>2}".format(str(hour)) + "/min=" + "{:0>2}".format(str(minute)) + "/batchid=" + str(batchId)
s3path = "s3://" + out_bucket_name + "/" + s3prefix + "/"
print("-------write start time------------")
print(str(datetime.datetime.now()))
data_frame = data_frame.toDF().repartition(1)
data_frame.write.mode("overwrite").option("header",False).csv(s3path)
print("-------write end time------------")
print(str(datetime.datetime.now()))

Modell betanítás és bevetés

A SageMaker egy teljesen felügyelt és integrált ML-szolgáltatás, amely lehetővé teszi az adattudósok és ML-mérnökök számára, hogy gyorsan és egyszerűen építsenek, képezzenek és telepítsenek ML-modelleket.

A Data_Pre-Processing.ipynb jegyzetfüzetben, először importáljuk az AI4I Predictive Maintenance adatkészletet az UCI adattárból, és feltáró adatelemzést (EDA) hajtunk végre. Szolgáltatástervezést is végzünk, hogy funkcióinkat hasznosabbá tegyük a modell betanításában.

Például az adatkészleten belül van egy típus nevű jellemzőnk, amely a termék minőségi típusát jelöli L (alacsony), M (közepes) vagy H (magas). Mivel ez kategorikus jellemző, kódolnunk kell, mielőtt a modellünket betanítanánk. Ennek eléréséhez a Scikit-Learn LabelEncoder-jét használjuk:

from sklearn.preprocessing import LabelEncoder
type_encoder = LabelEncoder()
type_encoder.fit(origdf['type'])
type_values = type_encoder.transform(origdf['type'])

A funkciók feldolgozása, valamint a kurált betanítási és tesztadatkészletek létrehozása után készen állunk egy ML-modell betanítására, amely a rendszerleolvasások alapján megjósolja, hogy a gép meghibásodott-e vagy sem. Egy XGBoost modellt tanítunk a SageMaker beépített algoritmussal. XGBoost jó eredményeket nyújthat többféle ML-probléma esetén, beleértve az osztályozást, még akkor is, ha a betanítási minták korlátozottak.

SageMaker képzési munkák hatékony és rugalmas módot biztosít az ML modellek betanítására a SageMakeren. A SageMaker kezeli az alapul szolgáló számítási infrastruktúrát és biztosítja több lehetőség választhat a változatos modellképzési követelményekhez, a használati esettől függően.

xgb = sagemaker.estimator.Estimator(container,
role,
instance_count=1,
instance_type='ml.c4.4xlarge',
output_path=xgb_upload_location,
sagemaker_session=sagemaker_session)
xgb.set_hyperparameters(max_depth=5,
eta=0.2,
gamma=4,
min_child_weight=6,
subsample=0.8,
silent=0,
objective='binary:hinge',
num_round=100)

xgb.fit({'train': s3_train_channel, 'validation': s3_valid_channel})

Amikor a modellképzés befejeződött, és a modellértékelés az üzleti követelmények alapján kielégítő, megkezdhetjük a modell bevezetését. Először létrehozunk egy végpont konfigurációt az AsyncInferenceConfig objektumbeállítással és a korábban betanított modell használatával:

endpoint_config_name = resource_name.format("EndpointConfig")
create_endpoint_config_response = sm_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": "variant1",
"ModelName": model_name,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
}
],
AsyncInferenceConfig={
"OutputConfig": {
"S3OutputPath": f"s3://{bucket}/{prefix}/output",
#Specify Amazon SNS topics
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:<region>:<account-id>:<success-sns-topic>",
"ErrorTopic": "arn:aws:sns:<region>:<account-id>:<error-sns-topic>",
}},
"ClientConfig": {"MaxConcurrentInvocationsPerInstance": 4},
},)

Ezután létrehozunk egy SageMaker aszinkron következtetési végpontot az általunk létrehozott végpont-konfiguráció segítségével. A kiépítés után megkezdhetjük a végpont meghívását a következtetések aszinkron generálásához.

endpoint_name = resource_name.format("Endpoint")
create_endpoint_response = sm_client.create_endpoint(
EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name)

Közel valós idejű következtetés

SageMaker aszinkron következtetés A végpontok lehetővé teszik a bejövő következtetési kérelmek sorba állítását és aszinkron, közel valós időben történő feldolgozását. Ez ideális olyan alkalmazásokhoz, amelyeknél nagyobb hasznos adatmérettel (akár 1 GB-ig) vannak következtetési kérelmek, hosszabb feldolgozási időt igényelhetnek (akár 15 percet), és közel valós idejű késleltetési követelményekkel rendelkeznek. Az aszinkron következtetés emellett lehetővé teszi a költségek megtakarítását azáltal, hogy automatikusan nullára skálázza a példányszámot, amikor nincs feldolgozandó kérés, így csak akkor kell fizetnie, ha a végpont kéréseket dolgoz fel.

Létrehozhat egy SageMaker aszinkron következtetési végpontot, hasonlóan a valós idejű következtetési végpont létrehozásához, és emellett megadhatja a AsyncInferenceConfig objektumot, miközben létrehozza a végpont konfigurációját a CreateEndpointConfig API EndpointConfig mezőjével. A következő diagram bemutatja a következtetés munkafolyamatát, és azt, hogy egy aszinkron következtetési végpont hogyan generál következtetést.

Az aszinkron következtetési végpont meghívásához a kérés hasznos adatát az Amazon S3-ban kell tárolni, és az InvokeEndpointAsync kérés részeként meg kell adni az erre a hasznos adatra vonatkozó hivatkozást. Meghíváskor a SageMaker sorba állítja a kérést feldolgozásra, és válaszként visszaadja az azonosítót és a kimeneti helyet. A feldolgozás után a SageMaker az eredményt az Amazon S3 helyére helyezi. Opcionálisan kiválaszthatja, hogy siker- vagy hibaértesítéseket kíván-e kapni Amazon Simple Notification Service (Amazon SNS).

Tesztelje a végpontok közötti megoldást

A megoldás teszteléséhez hajtsa végre a következő lépéseket:

• Az AWS CloudFormation konzolon nyissa meg a korábban létrehozott veremet (nrt-streaming-inference).
• A Kimenetek lapon másolja ki az S3 vödör nevét (EventsBucket).

Ez az az S3 vödör, amelybe az AWS Glue streaming feladatunk funkciókat ír a Kinesis adatfolyam olvasása és feldolgozása után.

Ezután eseményértesítéseket állítottunk be ehhez az S3 gyűjtőhöz.

• Az Amazon S3 konzolon navigáljon a vödörhöz EventsBucket.
• A Ingatlanok fül, a Eseményértesítések szakaszban válassza Eseményértesítés létrehozása.

• A Esemény neve, belép invoke-endpoint-lambda.
• A prefix, belép features/.
• A képző, belép .csv.
• A Eseménytípusokválassza Minden objektum eseményt hoz létre.

• A Rendeltetési helyválassza Lambda funkció.
• A Lambda funkció, és válassza ki a funkciót invoke-endpoint-asynch.
• A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a A változtatások mentéséhez.

• Az AWS Glue konzolon nyissa meg a feladatot GlueStreaming-Kinesis-S3.
• A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a Futtassa a munkát.

Ezután a Kinesis Data Generator (KDG) segítségével szimuláljuk az érzékelőket, amelyek adatokat küldenek a Kinesis adatfolyamunkba. Ha először használja a KDG-t, tekintse meg a Áttekintés a kezdeti beállításhoz. A KDG egy CloudFormation sablont biztosít a felhasználó létrehozásához, és csak annyi engedélyt rendel hozzá, hogy a KDG-t a Kinesisnek való események küldéséhez használja. Futtassa a CloudFormation sablon az AWS-fiókon belül, amelyet ebben a bejegyzésben a megoldás elkészítéséhez használ. A KDG beállítása után jelentkezzen be, és nyissa meg a KDG-t, hogy teszteseményeket küldjön a Kinesis adatfolyamunknak.

• Használja azt a régiót, amelyben létrehozta a Kinesis adatfolyamot (us-east-1).
• A legördülő menüben válassza ki az adatfolyamot sensor-data-stream.
• A Rekordok másodpercenként válasszon Állandó és írja be a 100-at.
• Töröld Rekordok tömörítése.
• A Felvétel sablon, használja a következő sablont:

{
"air_temperature": {{random.number({"min":295,"max":305, "precision":0.01})}},
"process_temperature": {{random.number({"min":305,"max":315, "precision":0.01})}},
"rotational_speed": {{random.number({"min":1150,"max":2900})}},
"torque": {{random.number({"min":3,"max":80, "precision":0.01})}},
"tool_wear": {{random.number({"min":0,"max":250})}},
"type": "{{random.arrayElement(["L","M","H"])}}"
}

• Kattints Adatok küldése hogy elkezdje az adatok küldését a Kinesis adatfolyamba.

Az AWS Glue streaming feladat beolvassa és kivonja a Kinesis adatfolyamból a megadott ablakméret alapján egy mikro-kötegelt adatokat (amelyek az érzékelő leolvasásait jelentik). A streamelési feladat ezután feldolgozza és végrehajtja a funkciótervezést ezen a mikrokötegelten, mielőtt particionálná és az S3 tárolóban lévő előtag funkciókba írná.

Mivel az AWS Glue streaming feladat által létrehozott új szolgáltatások az S3 tárolóba íródnak, egy Lambda függvény (invoke-endpoint-asynch). Az aszinkron következtetési végpont sorba állítja az aszinkron hívás kérését. Amikor a feldolgozás befejeződött, a SageMaker a következtetési eredményeket az Amazon S3 helyén tárolja (S3OutputPath), amelyet az aszinkron következtetési végpont konfigurálása során adtunk meg.

A mi felhasználási esetünkben a következtetési eredmények azt jelzik, hogy egy gépalkatrész valószínűleg meghibásodik vagy sem, az érzékelő leolvasása alapján.

A SageMaker siker- vagy hibaértesítést is küld az Amazon SNS-nek. Például, ha beállít egy e-mail előfizetés a sikeres és hibás SNS-témák esetében (amelyek az aszinkron SageMaker következtetési végpont-konfigurációban vannak megadva) e-mail küldhető minden alkalommal, amikor egy következtetési kérés feldolgozásra kerül. A következő képernyőképen egy minta e-mail látható az SNS siker témaköréből.

Valós alkalmazások esetén integrálhatja az SNS-értesítéseket más szolgáltatásokkal, mint pl Amazon Simple Queue Service (Amazon SQS) és Lambda a generált következtetések további utólagos feldolgozásához vagy más downstream alkalmazásokkal való integrációhoz, az Ön igényei alapján. Például a prediktív karbantartási használati esetünkben meghívhat egy SNS-értesítésen alapuló Lambda-függvényt, hogy beolvassa az Amazon S3-ból generált következtetést, tovább dolgozza azt (például összesítés vagy szűrés), és munkafolyamatokat kezdeményezzen, például munkamegrendeléseket küldjön berendezések javítása technikusoknak.

Tisztítsuk meg

Ha végzett a verem tesztelésével, a váratlan költségek elkerülése érdekében törölje az erőforrásokat (különösen a Kinesis adatfolyamot, a Glue streaming feladatot és az SNS témakört).

Futtassa a következő kódot a verem törléséhez:

sam delete nrt-streaming-inference

Törölje az erőforrásokat is, például a SageMaker végpontokat a ModelTraining-Evaluation-and-Deployment jegyzetfüzet tisztítási szakaszának követésével.

Következtetés

Ebben a bejegyzésben egy prediktív karbantartási használati esetet használtunk annak bemutatására, hogyan használhatunk különféle szolgáltatásokat, mint például a Kinesis, az AWS Glue és a SageMaker közel valós idejű következtetési folyamat létrehozásához. Javasoljuk, hogy próbálja ki ezt a megoldást, és ossza meg velünk véleményét.

Ha bármilyen kérdése van, ossza meg őket a megjegyzésekben.

A szerzőkről

Rahul Sharma az AWS Data Lab megoldástervezője, aki segít az AWS ügyfeleinek AI/ML megoldások tervezésében és kivitelezésében. Mielőtt csatlakozott az AWS-hez, Rahul több évet töltött a pénzügyi és biztosítási szektorban, segítve ügyfeleit adat- és elemzési platformok felépítésében.

Pat Reilly építész az AWS Data Labnál, ahol segít az ügyfeleknek megtervezni és felépíteni a vállalkozásukat támogató adatterheléseket. Az AWS előtt Pat konzultált egy AWS-partnerrel, és az AWS-adatterhelést építette ki különféle iparágakban.