Creați o soluție de întreținere predictivă cu Amazon Kinesis, AWS Glue și Amazon SageMaker

Organizațiile construiesc și folosesc din ce în ce mai mult soluții bazate pe învățare automată (ML) pentru o varietate de cazuri de utilizare și probleme, inclusiv întreținerea predictivă a pieselor de mașini, recomandări de produse bazate pe preferințele clienților, profilarea creditelor, moderarea conținutului, detectarea fraudei și multe altele. În multe dintre aceste scenarii, eficiența și beneficiile derivate din aceste soluții bazate pe ML pot fi îmbunătățite atunci când pot procesa și obține informații din evenimentele de date în timp aproape real.

Deși valoarea de afaceri și beneficiile soluțiilor bazate pe ML în timp aproape real sunt bine stabilite, arhitectura necesară implementării acestor soluții la scară cu fiabilitate și performanță optime este complicată. Această postare descrie cum poți combina Amazon Kinesis, AWS Adeziv, și Amazon SageMaker pentru a construi o soluție de inginerie și inferență a caracteristicilor aproape în timp real pentru întreținerea predictivă.

Prezentare generală a cazului de utilizare

Ne concentrăm pe un caz de utilizare de întreținere predictivă în care senzorii desfășurați pe teren (cum ar fi echipamente industriale sau dispozitive de rețea), trebuie înlocuiți sau rectificați înainte ca aceștia să devină defecte și să provoace timpi de nefuncționare. Timpul de nefuncționare poate fi costisitor pentru companii și poate duce la o experiență slabă a clienților. Întreținerea predictivă alimentată de un model ML poate ajuta, de asemenea, la creșterea ciclurilor de întreținere bazate pe program obișnuit, informând când o piesă a mașinii în stare bună nu trebuie înlocuită, evitând astfel costurile inutile.

În această postare, ne concentrăm pe aplicarea învățării automate la un set de date sintetice care conține defecțiuni ale mașinii din cauza unor caracteristici precum temperatura aerului, temperatura procesului, viteza de rotație, cuplul și uzura sculei. Setul de date utilizat provine din Depozitul de date UCI.

Defecțiunea mașinii constă din cinci moduri independente de defecțiune:

• Defecțiunea uzurii sculei (TWF)
• Eroare de disipare a căldurii (HDF)
• Pana de alimentare (PWF)
• Defectarea suprasolicitarii (OSF)
• Eșec aleatoriu (RNF)

Eticheta de eroare a mașinii indică dacă mașina a eșuat pentru un anumit punct de date, dacă oricare dintre modurile de defecțiune anterioare sunt adevărate. Dacă cel puțin unul dintre modurile de defecțiune este adevărat, procesul eșuează și eticheta de defecțiune a mașinii este setată la 1. Obiectivul modelului ML este de a identifica corect defecțiunile mașinii, astfel încât să poată fi inițiată o acțiune de întreținere predictivă în aval.

Prezentare generală a soluțiilor

Pentru cazul nostru de utilizare pentru întreținerea predictivă, presupunem că senzorii dispozitivului transmit în flux diverse măsurători și citiri despre piesele mașinii. Soluția noastră preia apoi o porțiune de date în flux de fiecare dată (micro-lot) și efectuează procesare și inginerie de caracteristici pentru a crea caracteristici. Caracteristicile create sunt apoi folosite pentru a genera inferențe dintr-un model ML antrenat și implementat în timp aproape real. Inferențele generate pot fi procesate și consumate în continuare de aplicațiile din aval, pentru a lua măsuri adecvate și a iniția activitatea de întreținere.

Următoarea diagramă arată arhitectura soluției noastre generale.

Soluția constă în general din următoarele secțiuni, care sunt explicate în detaliu mai târziu în această postare:

• Sursă de date în flux și asimilare - Folosim Fluxuri de date Amazon Kinesis pentru a colecta date în flux de la senzorii de câmp la scară și a le face disponibile pentru procesare ulterioară.
• Inginerie de caracteristici în timp aproape real – Folosim joburi de streaming AWS Glue pentru a citi date dintr-un flux de date Kinesis și pentru a efectua procesarea datelor și ingineria caracteristicilor, înainte de a stoca caracteristicile derivate în Serviciul Amazon de stocare simplă (Amazon S3). Amazon S3 oferă o opțiune fiabilă și rentabilă pentru stocarea unor volume mari de date.
• Instruire și implementare model – Utilizăm setul de date de întreținere predictivă AI4I din depozitul de date UCI pentru a antrena un model ML bazat pe algoritmul XGBoost folosind SageMaker. Apoi implementăm modelul antrenat la un punct final de inferență asincron SageMaker.
• Inferență ML în timp aproape real – După ce caracteristicile sunt disponibile în Amazon S3, trebuie să generăm inferențe din modelul implementat în timp aproape real. Punctele finale de inferență asincrone SageMaker sunt potrivite pentru această cerință, deoarece acceptă dimensiuni mai mari ale încărcăturii utile (până la 1 GB) și pot genera inferențe în câteva minute (până la maximum 15 minute). Folosim notificări de evenimente S3 pentru a rula un AWS Lambdas funcție pentru a invoca un punct final de inferență asincron SageMaker. Punctele finale de inferență asincrone SageMaker acceptă locații S3 ca intrare, generează inferențe din modelul implementat și scriu aceste inferențe înapoi pe Amazon S3 în timp aproape real.

Codul sursă pentru această soluție se află pe GitHub. Soluția a fost testată și ar trebui să fie rulată în us-east-1.

Folosim un Formarea AWS Cloud șablon, implementat folosind Model de aplicație fără server AWS (AWS SAM) și notebook-uri SageMaker pentru a implementa soluția.

Cerințe preliminare

Pentru a începe, ca o condiție prealabilă, trebuie să aveți SAM CLI, Python 3, și PIP instalat. Trebuie să aveți și Interfața liniei de comandă AWS (AWS CLI) configurat corect.

Implementați soluția

Poți să folosești AWS CloudShell pentru a rula acești pași. CloudShell este un shell bazat pe browser care este pre-autentificat cu acreditările consolei și include instrumente de dezvoltare și operațiuni comune preinstalate (cum ar fi AWS SAM, AWS CLI și Python). Prin urmare, nu este necesară nicio instalare sau configurare locală.

• Începem prin a crea o găleată S3 în care stocăm scriptul pentru munca noastră de streaming AWS Glue. Rulați următoarea comandă în terminal pentru a crea o găleată nouă:

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

• Notați numele găleții create.

• Apoi, clonăm local depozitul de cod, care conține șablonul CloudFormation pentru a implementa stiva. Rulați următoarea comandă în terminalul dvs.:

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

• Navigați la directorul sam-template:

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

• Rulați următoarea comandă pentru a copia scriptul jobului AWS Glue (din glue_streaming/app.py) în găleata S3 pe care ați creat-o:

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

• Acum puteți continua cu construirea și implementarea soluției, prin șablonul CloudFormation prin AWS SAM. Rulați următoarea comandă:

sam deploy --guided

• Furnizați argumente pentru implementare, cum ar fi numele stivei, regiunea AWS preferată (us-east-1), Şi GlueScriptsBucket.

Asigurați-vă că furnizați același compartiment S3 pe care l-ați creat mai devreme pentru compartimentul S3 pentru scriptul AWS Glue (parametru GlueScriptsBucket în următoarea captură de ecran).

După ce furnizați argumentele necesare, AWS SAM începe implementarea stivei. Următoarea captură de ecran arată resursele create.

După ce stiva este implementată cu succes, ar trebui să vedeți următorul mesaj.

• Pe consola AWS CloudFormation, deschideți stiva (pentru această postare, nrt-streaming-inference) care a fost furnizat la implementarea șablonului CloudFormation.
• Pe Resurse fila, notați ID-ul instanței notebook-ului SageMaker.

• Pe consola SageMaker, deschideți această instanță.

Instanța de blocnotes SageMaker are deja blocnotesurile necesare preîncărcate.

Navigați la folderul caiete și deschideți și urmați instrucțiunile din caiete (Data_Pre-Processing.ipynb și ModelTraining-Evaluation-and-Deployment.ipynb) pentru a explora setul de date, a efectua preprocesare și inginerie a caracteristicilor și a antrena și a implementa modelul la un punct final de inferență asincron SageMaker.

Sursă de date în flux și asimilare

Kinesis Data Streams este un serviciu de streaming de date în timp real fără server, scalabil și durabil, pe care îl puteți folosi pentru a colecta și procesa fluxuri mari de înregistrări de date în timp real. Kinesis Data Streams permite capturarea, procesarea și stocarea fluxurilor de date dintr-o varietate de surse, cum ar fi datele de jurnal ale infrastructurii IT, jurnalele de aplicații, rețelele sociale, fluxurile de date de piață, date de flux de clic pe web, dispozitive și senzori IoT și multe altele. Puteți furniza un flux de date Kinesis în modul la cerere sau în modul furnizat, în funcție de cerințele de debit și de scalare. Pentru mai multe informații, vezi Alegerea modului de capacitate a fluxului de date.

Pentru cazul nostru de utilizare, presupunem că diferiți senzori trimit măsurători precum temperatura, viteza de rotație, cuplul și uzura sculei către un flux de date. Kinesis Data Streams acționează ca o pâlnie pentru a colecta și a ingera fluxuri de date.

Noi folosim Amazon Kinesis Data Generator (KDG) mai târziu în această postare pentru a genera și trimite date către un flux de date Kinesis, simulând datele generate de senzori. Datele din fluxul de date senzor-data-stream sunt ingerate și procesate folosind o lucrare de streaming AWS Glue, despre care vom discuta în continuare.

Inginerie de caracteristici în timp aproape real

Lucrări de streaming AWS Glue oferă o modalitate convenabilă de procesare a datelor în flux la scară, fără a fi nevoie să gestionați mediul de calcul. AWS Glue vă permite să efectuați operațiuni de extragere, transformare și încărcare (ETL) pe date în flux, utilizând joburi care rulează continuu. ETL de streaming AWS Glue este construit pe motorul Apache Spark Structured Streaming și poate asimila fluxuri de la Kinesis, Apache Kafka și Streaming gestionat de Amazon pentru Apache Kafka (Amazon MSK).

Lucrarea ETL de streaming poate folosi atât transformări încorporate AWS Glue, cât și transformări native pentru Apache Spark Structured Streaming. De asemenea, puteți utiliza Spark ML și MLLib biblioteci în lucrările AWS Glue pentru o procesare mai ușoară a caracteristicilor folosind biblioteci de ajutor ușor disponibile.

Dacă schema sursei de date în flux este predeterminată, o puteți specifica într-un tabel AWS Data Catalog. Dacă definiția schemei nu poate fi determinată în prealabil, puteți activa detectarea schemei în jobul ETL de streaming. Lucrarea determină apoi automat schema din datele primite. În plus, puteți utiliza Registrul AWS Glue Schema pentru a permite descoperirea centrală, controlul și evoluția schemelor fluxului de date. Puteți integra în continuare Registrul Schema cu Catalogul de date pentru a utiliza opțional schemele stocate în Registrul Schema atunci când creați sau actualizați tabele sau partiții AWS Glue în Catalogul de date.

Pentru această postare, creăm un tabel AWS Glue Data Catalog (sensor-stream) cu fluxul nostru de date Kinesis ca sursă și definiți schema pentru datele senzorului nostru.

Creăm un cadru de date dinamic AWS Glue din tabelul Data Catalog pentru a citi datele de streaming din Kinesis. De asemenea, specificam urmatoarele optiuni:

• O dimensiune a ferestrei de 60 de secunde, astfel încât lucrarea AWS Glue să citească și să proceseze datele în ferestre de 60 de secunde
• Poziția de pornire TRIM_HORIZON, pentru a permite citirea din cele mai vechi înregistrări din fluxul de date Kinesis

De asemenea, folosim Spark MLlib StringIndexer transformator de caracteristici pentru a codifica tipul de coloană șir în indici de etichetă. Această transformare este implementată folosind Spark ML Pipelines. Conducte Spark ML oferiți un set uniform de API-uri de nivel înalt pentru algoritmii ML, pentru a facilita combinarea mai multor algoritmi într-o singură conductă sau flux de lucru.

Folosim API-ul foreachBatch pentru a invoca o funcție numită processBatch, care, la rândul său, prelucrează datele la care face referire acest cadru de date. Vezi următorul cod:

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

Funcția processBatch efectuează transformările specificate și partiționează datele în Amazon S3 în funcție de an, lună, zi și ID-ul lotului.

De asemenea, re-partiționăm partițiile AWS Glue într-o singură partiție, pentru a evita să avem prea multe fișiere mici în Amazon S3. A avea mai multe fișiere mici poate împiedica performanța de citire, deoarece amplifică costul general legat de căutarea, deschiderea și citirea fiecărui fișier. În cele din urmă scriem caracteristicile pentru a genera inferențe într-un prefix (funcții) din compartimentul S3. Vezi următorul cod:

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

Instruire și desfășurare model

SageMaker este un serviciu ML complet gestionat și integrat care le permite oamenilor de știință de date și inginerilor ML să creeze, să antreneze și să implementeze rapid și ușor modele ML.

În blocnotesul Data_Pre-Processing.ipynb, importăm mai întâi setul de date AI4I Predictive Maintenance din depozitul de date UCI și efectuăm analiza exploratorie a datelor (EDA). De asemenea, efectuăm inginerie de caracteristici pentru a face caracteristicile noastre mai utile pentru antrenarea modelului.

De exemplu, în setul de date, avem o caracteristică numită tip, care reprezintă tipul de calitate al produsului ca L (scăzut), M (mediu) sau H (ridicat). Deoarece aceasta este o caracteristică categorică, trebuie să o codificăm înainte de a ne antrena modelul. Folosim Scikit-Learn's LabelEncoder pentru a realiza acest lucru:

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

După ce caracteristicile sunt procesate și sunt generate trenul și seturile de date de testare, suntem gata să antrenăm un model ML pentru a prezice dacă mașina a eșuat sau nu pe baza citirilor sistemului. Antrenăm un model XGBoost, folosind algoritmul încorporat SageMaker. XGBoost poate oferi rezultate bune pentru mai multe tipuri de probleme ML, inclusiv clasificare, chiar și atunci când eșantioanele de antrenament sunt limitate.

Joburi de formare SageMaker oferă o modalitate puternică și flexibilă de a antrena modele ML pe SageMaker. SageMaker gestionează infrastructura de calcul de bază și oferă multiple opțiuni din care să alegeți, pentru diverse cerințe de formare a modelului, în funcție de cazul de utilizare.

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

Când instruirea modelului este completă și evaluarea modelului este satisfăcătoare pe baza cerințelor de afaceri, putem începe implementarea modelului. Mai întâi creăm o configurație de punct final cu opțiunea obiect AsyncInferenceConfig și folosind modelul antrenat mai devreme:

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

Apoi creăm un punct final de inferență asincron SageMaker, folosind configurația punctului final pe care am creat-o. După ce este furnizat, putem începe să invocăm punctul final pentru a genera inferențe asincron.

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

Inferență în timp aproape real

SageMaker inferență asincronă punctele finale oferă capacitatea de a pune în coadă cererile de inferență primite și de a le procesa asincron în timp aproape real. Acest lucru este ideal pentru aplicațiile care au cereri de inferență cu dimensiuni mai mari de încărcare utilă (până la 1 GB), pot necesita timpi de procesare mai lungi (până la 15 minute) și au cerințe de latență aproape în timp real. Inferența asincronă vă permite, de asemenea, să economisiți costuri prin scalarea automată a numărului de instanțe la zero atunci când nu există cereri de procesat, astfel încât să plătiți numai atunci când punctul final procesează cereri.

Puteți crea un punct final de inferență asincron SageMaker similar cu modul în care creați un punct final de inferență în timp real și, în plus, puteți specifica AsyncInferenceConfig obiect, în timp ce creați configurația punctului final cu câmpul EndpointConfig din API-ul CreateEndpointConfig. Următoarea diagramă arată fluxul de lucru de inferență și modul în care un punct final de inferență asincron generează o inferență.

Pentru a invoca punctul final de inferență asincron, sarcina utilă a cererii ar trebui să fie stocată în Amazon S3 și trebuie furnizată referința la această sarcină utilă ca parte a cererii InvokeEndpointAsync. La invocare, SageMaker pune în coadă cererea de procesare și returnează un identificator și o locație de ieșire ca răspuns. La procesare, SageMaker plasează rezultatul în locația Amazon S3. Puteți alege opțional să primiți notificări de succes sau de eroare cu Serviciul de notificare simplă Amazon (Amazon SNS).

Testați soluția end-to-end

Pentru a testa soluția, parcurgeți următorii pași:

• Pe consola AWS CloudFormation, deschideți stiva pe care ați creat-o mai devreme (nrt-streaming-inference).
• Pe ieşiri fila, copiați numele găleții S3 (EventsBucket).

Acesta este compartimentul S3 în care jobul nostru de streaming AWS Glue scrie caracteristici după citirea și procesarea din fluxul de date Kinesis.

Apoi, am configurat notificări de evenimente pentru această găleată S3.

• Pe consola Amazon S3, navigați la găleată EventsBucket.
• Pe Proprietăţi în tabul Notificări despre evenimente secțiune, pentru a alege Creați notificare de eveniment.

• Pentru Numele evenimentului, introduce invoke-endpoint-lambda.
• Pentru Prefix, introduce features/.
• Pentru Sufix, introduce .csv.
• Pentru Tipuri de evenimente, Selectați Toate obiectele creează evenimente.

• Pentru Destinaţie, Selectați Funcția lambda.
• Pentru Funcția lambdași alegeți funcția invoke-endpoint-asynch.
• Alege Salvează modificările.

• Pe consola AWS Glue, deschideți lucrarea GlueStreaming-Kinesis-S3.
• Alege Rulați jobul.

Apoi, folosim Kinesis Data Generator (KDG) pentru a simula senzorii care trimit date către fluxul nostru de date Kinesis. Dacă este prima dată când utilizați KDG, consultați Descriere pentru configurarea inițială. KDG oferă un șablon CloudFormation pentru a crea utilizatorul și pentru a atribui permisiuni suficiente pentru a utiliza KDG pentru a trimite evenimente către Kinesis. Rulați Șablonul CloudFormation în contul AWS pe care îl utilizați pentru a crea soluția din această postare. După ce KDG este configurat, conectați-vă și accesați KDG pentru a trimite evenimente de testare către fluxul nostru de date Kinesis.

• Utilizați Regiunea în care ați creat fluxul de date Kinesis (us-east-1).
• În meniul derulant, alegeți fluxul de date sensor-data-stream.
• În Înregistrări pe secundă secțiune, selectați Constant și introduceți 100.
• Deselectează- Comprimați înregistrările.
• Pentru Șablon de înregistrare, utilizați următorul șablon:

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

• Clic Trimiteți date pentru a începe să trimiteți date către fluxul de date Kinesis.

Lucrarea de streaming AWS Glue citește și extrage un micro-lot de date (reprezentând citirile senzorului) din fluxul de date Kinesis pe baza dimensiunii ferestrei furnizate. Lucrarea de streaming prelucrează apoi și realizează inginerie de caracteristici pe acest micro-lot înainte de a-l partiționa și de a-l scrie în funcțiile de prefix din compartimentul S3.

Pe măsură ce noile funcții create de jobul de streaming AWS Glue sunt scrise în compartimentul S3, o funcție Lambda (invoke-endpoint-asynch) este declanșat, care invocă un punct final de inferență asincron SageMaker prin trimiterea unei cereri de invocare pentru a obține inferențe din modelul nostru ML implementat. Punctul final de inferență asincron pune în coadă cererea de invocare asincronă. Când procesarea este finalizată, SageMaker stochează rezultatele inferenței în locația Amazon S3 (S3OutputPath) care a fost specificat în timpul configurației punctului final de inferență asincronă.

Pentru cazul nostru de utilizare, rezultatele inferenței indică dacă o piesă a mașinii este probabil să se defecteze sau nu, pe baza citirilor senzorului.

SageMaker trimite, de asemenea, o notificare de succes sau eroare cu Amazon SNS. De exemplu, dacă ați configurat un abonament prin e-mail pentru subiectele SNS de succes și eroare (specificate în configurația asincronă a punctului final de inferență SageMaker), un e-mail poate fi trimis de fiecare dată când este procesată o cerere de inferență. Următoarea captură de ecran arată un exemplu de e-mail din subiectul de succes SNS.

Pentru aplicațiile din lumea reală, puteți integra notificările SNS cu alte servicii, cum ar fi Serviciul de coadă simplă Amazon (Amazon SQS) și Lambda pentru postprocesarea suplimentară a inferențelor generate sau integrarea cu alte aplicații din aval, în funcție de cerințele dumneavoastră. De exemplu, pentru cazul nostru de utilizare de întreținere predictivă, puteți invoca o funcție Lambda pe baza unei notificări SNS pentru a citi inferența generată de la Amazon S3, a o procesa în continuare (cum ar fi agregarea sau filtrarea) și iniția fluxuri de lucru, cum ar fi trimiterea de comenzi de lucru pentru repararea echipamentelor către tehnicieni.

A curăța

Când ați terminat de testat stiva, ștergeți resursele (în special fluxul de date Kinesis, jobul de streaming Glue și subiectele SNS) pentru a evita taxele neașteptate.

Rulați următorul cod pentru a vă șterge stiva:

sam delete nrt-streaming-inference

De asemenea, ștergeți resurse, cum ar fi punctele finale SageMaker, urmând secțiunea de curățare din blocnotesul ModelTraining-Evaluation-and-Deployment.

Concluzie

În această postare, am folosit un caz de utilizare de întreținere predictivă pentru a demonstra cum să folosim diverse servicii, cum ar fi Kinesis, AWS Glue și SageMaker, pentru a construi o conductă de inferență aproape în timp real. Vă încurajăm să încercați această soluție și să ne spuneți ce părere aveți.

Dacă aveți întrebări, împărtășiți-le în comentarii.

Despre autori

Rahul Sharma este arhitect de soluții la AWS Data Lab, ajutând clienții AWS să proiecteze și să construiască soluții AI/ML. Înainte de a se alătura AWS, Rahul a petrecut câțiva ani în sectorul finanțelor și asigurărilor, ajutând clienții să construiască platforme de date și analitice.

Pat Reilly este arhitect în Laboratorul de date AWS, unde îi ajută pe clienți să proiecteze și să construiască sarcini de lucru de date pentru a le susține afacerea. Înainte de AWS, Pat a consultat la un partener AWS, construind sarcini de lucru AWS de date într-o varietate de industrii.