Zgradite rešitev za predvideno vzdrževanje z Amazon Kinesis, AWS Glue in Amazon SageMaker

Organizacije vedno bolj gradijo in uporabljajo rešitve, ki temeljijo na strojnem učenju (ML), za različne primere uporabe in težave, vključno s predvidenim vzdrževanjem delov strojev, priporočili za izdelke na podlagi preferenc strank, kreditnim profiliranjem, moderiranjem vsebine, odkrivanjem goljufij in več. V mnogih od teh scenarijev je mogoče učinkovitost in koristi, ki izhajajo iz teh rešitev, ki jih poganja ML, še povečati, ko lahko obdelujejo in pridobivajo vpoglede iz podatkovnih dogodkov v skoraj realnem času.

Čeprav so poslovna vrednost in prednosti rešitev, ki jih poganja ML v skoraj realnem času, dobro uveljavljene, je arhitektura, potrebna za izvajanje teh rešitev v velikem obsegu z optimalno zanesljivostjo in zmogljivostjo, zapletena. Ta objava opisuje, kako lahko kombinirate Amazon Kinesis, AWS lepiloin Amazon SageMaker zgraditi rešitev za inženiring funkcij in sklepanje v skoraj realnem času za napovedno vzdrževanje.

Pregled primera uporabe

Osredotočeni smo na primer uporabe predvidenega vzdrževanja, kjer je treba senzorje, nameščene na terenu (kot so industrijska oprema ali omrežne naprave), zamenjati ali popraviti, preden postanejo okvarjeni in povzročijo izpade. Izpadi so lahko dragi za podjetja in lahko povzročijo slabo uporabniško izkušnjo. Prediktivno vzdrževanje, ki ga poganja model ML, lahko pomaga tudi pri povečanju rednih vzdrževalnih ciklov, ki temeljijo na urniku, z obveščanjem, kdaj dela stroja v dobrem stanju ni treba zamenjati, s čimer se izognete nepotrebnim stroškom.

V tej objavi se osredotočamo na uporabo strojnega učenja na sintetičnem naboru podatkov, ki vsebuje strojne okvare zaradi lastnosti, kot so temperatura zraka, temperatura procesa, hitrost vrtenja, navor in obraba orodja. Uporabljeni nabor podatkov izvira iz Repozitorij podatkov UCI.

Okvaro stroja sestavlja pet neodvisnih načinov okvare:

• Okvara obrabe orodja (TWF)
• Napaka pri odvajanju toplote (HDF)
• Izpad napajanja (PWF)
• Napaka zaradi preobremenitve (OSF)
• Naključna napaka (RNF)

Oznaka okvare stroja označuje, ali je stroj odpovedal za določeno podatkovno točko, če je kateri koli od prejšnjih načinov okvare resničen. Če je vsaj eden od načinov okvare resničen, postopek ne uspe in oznaka okvare stroja je nastavljena na 1. Cilj modela ML je pravilno identificirati okvare stroja, tako da se lahko sproži nadaljnje predvideno vzdrževanje.

Pregled rešitev

Za naš primer uporabe predvidenega vzdrževanja predvidevamo, da senzorji naprave prenašajo različne meritve in odčitke o delih stroja. Naša rešitev nato vsakič vzame rezino pretočnih podatkov (mikro paket) in izvede obdelavo in inženiring funkcij za ustvarjanje funkcij. Ustvarjene funkcije se nato uporabijo za ustvarjanje sklepov iz usposobljenega in razporejenega modela ML v skoraj realnem času. Ustvarjene sklepe je mogoče nadalje obdelati in uporabiti v nadaljnjih aplikacijah, da izvedejo ustrezne ukrepe in sprožijo vzdrževalno dejavnost.

Naslednji diagram prikazuje arhitekturo naše celotne rešitve.

Rešitev je na splošno sestavljena iz naslednjih razdelkov, ki so podrobno razloženi v nadaljevanju te objave:

• Pretočni vir podatkov in vnos - Uporabljamo Amazonski kinezi podatkovni tokovi za zbiranje pretočnih podatkov iz terenskih senzorjev v velikem obsegu in jih da na voljo za nadaljnjo obdelavo.
• Inženiring funkcij v skoraj realnem času – Uporabljamo pretočna opravila AWS Glue za branje podatkov iz podatkovnega toka Kinesis ter izvajanje obdelave podatkov in inženiring funkcij, preden izpeljane funkcije shranimo v Preprosta storitev shranjevanja Amazon (Amazon S3). Amazon S3 zagotavlja zanesljivo in stroškovno učinkovito možnost za shranjevanje velikih količin podatkov.
• Usposabljanje in uvajanje modela – Za usposabljanje modela ML, ki temelji na algoritmu XGBoost z uporabo SageMaker, uporabljamo nabor podatkov o predvidenem vzdrževanju AI4I iz Repozitorija podatkov UCI. Nato uvedemo usposobljeni model na končno točko asinhronega sklepanja SageMaker.
• Ugotavljanje ML v skoraj realnem času – Ko so funkcije na voljo v Amazonu S3, moramo ustvariti sklepe iz razporejenega modela v skoraj realnem času. Končne točke asinhronega sklepanja SageMaker so zelo primerne za to zahtevo, ker podpirajo večje velikosti tovora (do 1 GB) in lahko ustvarijo sklepe v nekaj minutah (do največ 15 minut). Obvestila o dogodkih S3 uporabljamo za zagon AWS Lambda funkcijo za priklic končne točke asinhronega sklepanja SageMaker. Končne točke asinhronega sklepanja SageMaker sprejmejo lokacije S3 kot vhod, ustvarijo sklepe iz razporejenega modela in te sklepe zapišejo nazaj v Amazon S3 v skoraj realnem času.

Izvorna koda za to rešitev se nahaja na GitHub. Rešitev je bila testirana in bi jo bilo treba izvajati v us-east-1.

Uporabljamo Oblikovanje oblaka AWS predlogo, razporejeno z uporabo AWS Model brez strežnika (AWS SAM) in prenosnike SageMaker za uvedbo rešitve.

Predpogoji

Za začetek morate kot predpogoj imeti SAM CLI, Python 3in PIP nameščen. Imeti morate tudi Vmesnik ukazne vrstice AWS (AWS CLI) pravilno konfiguriran.

Uvedite rešitev

Lahko uporabite AWS CloudShell za izvajanje teh korakov. CloudShell je lupina, ki temelji na brskalniku in je predhodno overjena s poverilnicami vaše konzole ter vključuje vnaprej nameščena običajna razvojna in operacijska orodja (kot so AWS SAM, AWS CLI in Python). Zato ni potrebna lokalna namestitev ali konfiguracija.

• Začnemo z ustvarjanjem vedra S3, kjer shranimo skript za naše opravilo pretakanja AWS Glue. Zaženite naslednji ukaz v svojem terminalu, da ustvarite novo vedro:

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

• Zapišite si ime ustvarjenega vedra.

• Nato lokalno kloniramo repozitorij kode, ki vsebuje predlogo CloudFormation za razmestitev sklada. V terminalu zaženite naslednji ukaz:

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

• Pomaknite se do imenika sam-template:

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

• Zaženite naslednji ukaz, da kopirate skript opravila AWS Glue (iz glue_streaming/app.py) v vedro S3, ki ste ga ustvarili:

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

• Zdaj lahko nadaljujete z izdelavo in uvajanjem rešitve prek predloge CloudFormation prek AWS SAM. Zaženite naslednji ukaz:

sam deploy --guided

• Navedite argumente za uvajanje, kot je ime sklada, želena regija AWS (us-east-1), In GlueScriptsBucket.

Zagotovite, da zagotovite isto vedro S3, ki ste ga ustvarili prej za vedro S3 skripta AWS Glue (parameter GlueScriptsBucket na naslednjem posnetku zaslona).

Ko podate zahtevane argumente, AWS SAM začne uvajanje sklada. Naslednji posnetek zaslona prikazuje ustvarjene vire.

Ko je sklad uspešno nameščen, bi morali videti naslednje sporočilo.

• Na konzoli AWS CloudFormation odprite sklad (za to objavo nrt-streaming-inference), ki je bil zagotovljen ob uvajanju predloge CloudFormation.
• o viri si zapomnite ID primerka prenosnika SageMaker.

• Na konzoli SageMaker odprite ta primerek.

Primerek beležnice SageMaker ima že vnaprej naložene zahtevane beležnice.

Pomaknite se do mape z zvezki ter odprite in sledite navodilom v zvezkih (Data_Pre-Processing.ipynb in ModelTraining-Evaluation-and-Deployment.ipynb), da raziščete nabor podatkov, izvedete predprocesiranje in inženiring funkcij ter usposobite in uvedete model v končno točko asinhronega sklepanja SageMaker.

Pretočni vir podatkov in vnos

Kinesis Data Streams je brezstrežniška, razširljiva in trajna storitev pretakanja podatkov v realnem času, ki jo lahko uporabite za zbiranje in obdelavo velikih tokov podatkovnih zapisov v realnem času. Kinesis Data Streams omogoča zajemanje, obdelavo in shranjevanje podatkovnih tokov iz različnih virov, kot so podatki dnevnika IT infrastrukture, dnevniki aplikacij, družbeni mediji, viri tržnih podatkov, podatki spletnega toka klikov, IoT naprave in senzorji in drugo. Podatkovni tok Kinesis lahko omogočite v načinu na zahtevo ali v omogočenem načinu, odvisno od prepustnosti in zahtev glede skaliranja. Za več informacij glejte Izbira načina zmogljivosti podatkovnega toka.

Za naš primer uporabe predpostavljamo, da različni senzorji pošiljajo meritve, kot so temperatura, hitrost vrtenja, navor in obraba orodja, v tok podatkov. Kinesis Data Streams deluje kot lijak za zbiranje in zaužitje podatkovnih tokov.

Mi uporabljamo Generator podatkov Amazon Kinesis (KDG) kasneje v tej objavi za ustvarjanje in pošiljanje podatkov v tok podatkov Kinesis, ki simulira podatke, ki jih ustvarjajo senzorji. Podatki iz toka podatkov senzor-data-tok se zaužijejo in obdelajo s pretočnim opravilom AWS Glue, o katerem bomo razpravljali v nadaljevanju.

Inženiring funkcij v skoraj realnem času

AWS Glue streaming opravila zagotavljajo priročen način za obdelavo pretočnih podatkov v velikem obsegu, brez potrebe po upravljanju računalniškega okolja. AWS Glue vam omogoča izvajanje operacij ekstrahiranja, preoblikovanja in nalaganja (ETL) pretočnih podatkov z uporabo neprekinjeno delujočih opravil. AWS Glue streaming ETL je zgrajen na motorju Apache Spark Structured Streaming in lahko sprejema tokove iz Kinesis, Apache Kafka in Amazonovo pretakanje za Apache Kafka (Amazon MSK).

Pretočno opravilo ETL lahko uporablja tako vgrajene transformacije AWS Glue kot transformacije, ki so izvirne za strukturirano pretakanje Apache Spark. Uporabite lahko tudi Spark ML in MLLib knjižnice v opravilih AWS Glue za lažjo obdelavo funkcij z uporabo že razpoložljivih pomožnih knjižnic.

Če je shema vira pretočnih podatkov vnaprej določena, jo lahko podate v tabeli podatkovnega kataloga AWS. Če definicije sheme ni mogoče določiti vnaprej, lahko omogočite zaznavanje sheme v pretočnem opravilu ETL. Opravilo nato samodejno določi shemo iz vhodnih podatkov. Poleg tega lahko uporabite AWS Glue Schema Registry omogočiti centralno odkrivanje, nadzor in razvoj shem podatkovnega toka. Register shem lahko nadalje integrirate s katalogom podatkov, da po želji uporabite sheme, shranjene v registru shem, ko ustvarjate ali posodabljate tabel ali particij AWS Glue v katalogu podatkov.

Za to objavo ustvarimo tabelo kataloga podatkov lepila AWS (sensor-stream) z našim podatkovnim tokom Kinesis kot virom in določite shemo za podatke naših senzorjev.

Iz tabele Data Catalog ustvarimo dinamični podatkovni okvir AWS Glue za branje pretočnih podatkov iz Kinesis. Določimo tudi naslednje možnosti:

• Velikost okna 60 sekund, tako da opravilo AWS Glue bere in obdeluje podatke v 60-sekundnih oknih
• Začetni položaj TRIM_HORIZON, da omogočite branje iz najstarejših zapisov v podatkovnem toku Kinesis

Uporabljamo tudi Spark MLlib StringIndexer pretvornik funkcij za kodiranje vrste stolpca niza v indekse oznak. Ta transformacija je izvedena z uporabo cevovodov Spark ML. Cevovodi Spark ML zagotoviti enoten nabor API-jev na visoki ravni za algoritme ML, da olajšate združevanje več algoritmov v en sam cevovod ali potek dela.

API foreachBatch uporabljamo za priklic funkcije z imenom processBatch, ki nato obdela podatke, na katere se sklicuje ta podatkovni okvir. Oglejte si naslednjo kodo:

# 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})

Funkcija processBatch izvede podane transformacije in razdeli podatke v Amazon S3 glede na leto, mesec, dan in ID serije.

Prav tako ponovno razdelimo particije AWS Glue v eno samo particijo, da se izognemo preveč majhnim datotekam v Amazon S3. Več majhnih datotek lahko ovira zmogljivost branja, ker poveča stroške, povezane z iskanjem, odpiranjem in branjem posamezne datoteke. Končno zapišemo funkcije za ustvarjanje sklepov v predpono (funkcije) znotraj vedra S3. Oglejte si naslednjo kodo:

# 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()))

Model usposabljanja in uvajanja

SageMaker je v celoti upravljana in integrirana storitev ML, ki podatkovnim znanstvenikom in inženirjem ML omogoča hitro in enostavno izdelavo, usposabljanje in uvajanje modelov ML.

V zvezku Data_Pre-Processing.ipynb, najprej uvozimo nabor podatkov AI4I Predictive Maintenance iz podatkovnega repozitorija UCI in izvedemo raziskovalno analizo podatkov (EDA). Izvajamo tudi inženiring funkcij, da naredimo naše funkcije uporabnejše za usposabljanje modela.

Na primer, znotraj nabora podatkov imamo funkcijo z imenom type, ki predstavlja vrsto kakovosti izdelka kot L (nizka), M (srednja) ali H (visoka). Ker je to kategorična lastnost, jo moramo kodirati, preden usposobimo naš model. Za dosego tega uporabljamo Scikit-Learn's LabelEncoder:

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

Ko so funkcije obdelane in so ustvarjeni kurirani nabori podatkov o usposabljanju in testu, smo pripravljeni usposobiti model ML, da na podlagi odčitkov sistema predvidi, ali je stroj odpovedal ali ne. Urimo model XGBoost z uporabo vgrajenega algoritma SageMaker. XGBoost lahko zagotovi dobre rezultate za več vrst problemov ML, vključno s klasifikacijo, tudi če so vzorci za usposabljanje omejeni.

Usposabljanje SageMaker zagotavlja zmogljiv in prilagodljiv način za usposabljanje modelov ML na SageMaker. SageMaker upravlja osnovno računalniško infrastrukturo in zagotavlja več možnosti med katerimi lahko izbirate za različne zahteve glede usposabljanja modelov glede na primer uporabe.

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})

Ko je usposabljanje modela končano in je ocena modela zadovoljiva glede na poslovne zahteve, lahko začnemo z uvajanjem modela. Najprej ustvarimo konfiguracijo končne točke z možnostjo predmeta AsyncInferenceConfig in z uporabo modela, ki smo ga učili prej:

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},
},)

Nato ustvarimo končno točko asinhronega sklepanja SageMaker z uporabo konfiguracije končne točke, ki smo jo ustvarili. Ko je omogočeno, lahko začnemo klicati končno točko za asinhrono ustvarjanje sklepov.

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

Sklepanje v skoraj realnem času

SageMaker asinhrono sklepanje končne točke nudijo možnost postavitve v čakalno vrsto dohodnih zahtev za sklepanje in njihovo asinhrono obdelavo v skoraj realnem času. To je idealno za aplikacije, ki imajo zahteve za sklepanje z večjo velikostjo koristne obremenitve (do 1 GB), morda zahtevajo daljše čase obdelave (do 15 minut) in imajo zahteve za zakasnitev v skoraj realnem času. Asinhrono sklepanje vam omogoča tudi prihranek pri stroških s samodejnim skaliranjem števila instanc na nič, ko ni zahtev za obdelavo, tako da plačate le, ko vaša končna točka obdeluje zahteve.

Končno točko asinhronega sklepanja SageMaker lahko ustvarite podobno, kot ustvarite končno točko sklepanja v realnem času, in dodatno določite AsyncInferenceConfig objekta, medtem ko ustvarjate svojo konfiguracijo končne točke s poljem EndpointConfig v API-ju CreateEndpointConfig. Naslednji diagram prikazuje potek dela sklepanja in kako končna točka asinhronega sklepanja ustvari sklepanje.

Za priklic končne točke asinhronega sklepanja mora biti koristni tovor zahteve shranjen v Amazon S3, sklic na to koristni tovor pa mora biti naveden kot del zahteve InvokeEndpointAsync. Po priklicu SageMaker postavi zahtevo v čakalno vrsto za obdelavo in kot odgovor vrne identifikator in izhodno lokacijo. Po obdelavi SageMaker rezultat postavi na lokacijo Amazon S3. Po želji lahko izberete prejemanje obvestil o uspehu ali napaki z Amazon Simple notification Service (Amazon SNS).

Preizkusite rešitev od konca do konca

Če želite preizkusiti rešitev, opravite naslednje korake:

• Na konzoli AWS CloudFormation odprite sklad, ki ste ga ustvarili prej (nrt-streaming-inference).
• o Izhodi zavihek kopirajte ime vedra S3 (EventsBucket).

To je vedro S3, v katerega naše pretočno opravilo AWS Glue zapiše funkcije po branju in obdelavi iz toka podatkov Kinesis.

Nato smo nastavili obvestila o dogodkih za to vedro S3.

• Na konzoli Amazon S3 se pomaknite do vedra EventsBucket.
• o Nepremičnine jeziček, v Obvestila o dogodkih oddelek, izberite Ustvari obvestilo o dogodku.

• za Ime dogodka, vnesite invoke-endpoint-lambda.
• za Prefiks, vnesite features/.
• za pripona, vnesite .csv.
• za Vrste dogodkovtako, da izberete Vsi predmeti ustvarjajo dogodke.

• za destinacijatako, da izberete Lambda funkcija.
• za Lambda funkcijain izberite funkcijo invoke-endpoint-asynch.
• Izberite Shrani spremembe.

• Na konzoli AWS Glue odprite opravilo GlueStreaming-Kinesis-S3.
• Izberite Zaženi delo.

Nato uporabimo Kinesis Data Generator (KDG) za simulacijo senzorjev, ki pošiljajo podatke v naš tok podatkov Kinesis. Če prvič uporabljate KDG, glejte Pregled za začetno nastavitev. KDG ponuja predlogo CloudFormation za ustvarjanje uporabnika in dodelitev dovolj dovoljenj za uporabo KDG za pošiljanje dogodkov v Kinesis. Zaženite Predloga za oblikovanje v oblaku znotraj računa AWS, ki ga uporabljate za izdelavo rešitve v tej objavi. Ko je KDG nastavljen, se prijavite in dostopajte do KDG, da pošljete testne dogodke v naš tok podatkov Kinesis.

• Uporabite regijo, v kateri ste ustvarili tok podatkov Kinesis (us-east-1).
• V spustnem meniju izberite podatkovni tok sensor-data-stream.
• v Rekordi na sekundo izberite, izberite stalna in vnesite 100.
• Prekliči izbiro Stisnite zapise.
• za Predloga zapisa, uporabite naslednjo predlogo:

{
"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"])}}"
}

• klik Pošlji podatke da začnete pošiljati podatke v podatkovni tok Kinesis.

Pretočno opravilo AWS Glue prebere in izvleče mikro paket podatkov (ki predstavlja odčitke senzorjev) iz podatkovnega toka Kinesis na podlagi ponujene velikosti okna. Pretočno opravilo nato obdela in izvede inženiring funkcij na tem mikropaketu, preden ga razdeli in zapiše v funkcije predpone znotraj vedra S3.

Ko se nove funkcije, ustvarjene s pretočnim opravilom AWS Glue, zapišejo v vedro S3, se pojavi funkcija Lambda (invoke-endpoint-asynch), ki prikliče končno točko asinhronega sklepanja SageMaker s pošiljanjem zahteve za priklic za pridobitev sklepov iz našega razporejenega modela ML. Končna točka asinhronega sklepanja postavi zahtevo za asinhroni priklic v čakalno vrsto. Ko je obdelava končana, SageMaker shrani rezultate sklepanja na lokacijo Amazon S3 (S3OutputPath), ki je bil določen med konfiguracijo končne točke asinhronega sklepanja.

Za naš primer uporabe rezultati sklepanja na podlagi odčitkov senzorjev kažejo, ali je verjetno, da bo strojni del odpovedal ali ne.

SageMaker pošlje tudi obvestilo o uspehu ali napaki z Amazon SNS. Na primer, če nastavite e-poštna naročnina za teme SNS o uspehu in napaki (določene v konfiguraciji končne točke asinhronega sklepanja SageMaker) se lahko pošlje e-poštno sporočilo vsakič, ko je obdelana zahteva za sklepanje. Naslednji posnetek zaslona prikazuje vzorec e-pošte iz teme uspeha SNS.

Za aplikacije v resničnem svetu lahko integrirate obvestila SNS z drugimi storitvami, kot je npr Storitev Amazon Simple Queue Service (Amazon SQS) in Lambda za dodatno naknadno obdelavo ustvarjenih sklepov ali integracijo z drugimi nadaljnjimi aplikacijami glede na vaše zahteve. Na primer, za naš primer uporabe predvidenega vzdrževanja lahko prikličete funkcijo Lambda, ki temelji na obvestilu SNS, da preberete ustvarjeni sklep iz Amazona S3, ga dodatno obdelate (kot je združevanje ali filtriranje) in sprožite delovne tokove, kot je pošiljanje delovnih nalogov za popravilo opreme tehnikom.

Čiščenje

Ko končate s preizkušanjem sklada, izbrišite vire (zlasti tok podatkov Kinesis, opravilo pretakanja Glue in teme SNS), da se izognete nepričakovanim bremenitvam.

Zaženite to kodo, da izbrišete svoj sklad:

sam delete nrt-streaming-inference

Izbrišite tudi vire, kot so končne točke SageMaker, tako da sledite razdelku za čiščenje v zvezku ModelTraining-Evaluation-and-Deployment.

zaključek

V tej objavi smo uporabili primer uporabe predvidenega vzdrževanja, da pokažemo, kako uporabiti različne storitve, kot so Kinesis, AWS Glue in SageMaker, za izgradnjo cevovoda sklepanja v skoraj realnem času. Svetujemo vam, da preizkusite to rešitev in nam sporočite svoje mnenje.

Če imate kakršna koli vprašanja, jih delite v komentarjih.

O avtorjih

Rahul Sharma je arhitekt rešitev pri AWS Data Lab, ki strankam AWS pomaga oblikovati in graditi rešitve AI/ML. Preden se je pridružil AWS, je Rahul nekaj let preživel v finančnem in zavarovalniškem sektorju, kjer je strankam pomagal zgraditi podatkovne in analitične platforme.

Pat Reilly je arhitekt v podatkovnem laboratoriju AWS, kjer strankam pomaga načrtovati in graditi podatkovne delovne obremenitve za podporo njihovemu poslovanju. Pred AWS se je Pat posvetoval s partnerjem AWS, ki je gradil podatkovne delovne obremenitve AWS v različnih panogah.