Bangun solusi pemeliharaan prediktif dengan Amazon Kinesis, AWS Glue, dan Amazon SageMaker

Organisasi semakin membangun dan menggunakan solusi yang didukung pembelajaran mesin (ML) untuk berbagai kasus penggunaan dan masalah, termasuk pemeliharaan prediktif suku cadang mesin, rekomendasi produk berdasarkan preferensi pelanggan, pembuatan profil kredit, moderasi konten, deteksi penipuan, dan banyak lagi. Dalam banyak skenario ini, keefektifan dan manfaat yang diperoleh dari solusi yang didukung ML ini dapat lebih ditingkatkan ketika mereka dapat memproses dan memperoleh wawasan dari peristiwa data hampir secara real time.

Meskipun nilai bisnis dan manfaat dari solusi yang didukung ML hampir real-time sudah mapan, arsitektur yang diperlukan untuk mengimplementasikan solusi ini pada skala dengan keandalan dan kinerja optimal adalah rumit. Posting ini menjelaskan bagaimana Anda dapat menggabungkan Amazon Kinesis, Lem AWS, dan Amazon SageMaker untuk membangun rekayasa fitur dan solusi inferensi hampir real-time untuk pemeliharaan prediktif.

Gunakan ikhtisar kasus

Kami fokus pada kasus penggunaan pemeliharaan prediktif di mana sensor yang dipasang di lapangan (seperti peralatan industri atau perangkat jaringan), perlu diganti atau diperbaiki sebelum menjadi rusak dan menyebabkan waktu henti. Downtime bisa mahal untuk bisnis dan dapat menyebabkan pengalaman pelanggan yang buruk. Pemeliharaan prediktif yang didukung oleh model ML juga dapat membantu menambah siklus pemeliharaan berbasis jadwal reguler dengan menginformasikan kapan suku cadang mesin dalam kondisi baik tidak boleh diganti, sehingga menghindari biaya yang tidak perlu.

Dalam posting ini, kami fokus pada penerapan pembelajaran mesin ke set data sintetis yang berisi kegagalan mesin karena fitur seperti suhu udara, suhu proses, kecepatan rotasi, torsi, dan keausan pahat. Dataset yang digunakan bersumber dari Repositori Data UCI.

Kegagalan mesin terdiri dari lima mode kegagalan independen:

• Kegagalan Keausan Alat (TWF)
• Kegagalan Disipasi Panas (HDF)
• Kegagalan Daya (PWF)
• Kegagalan Over-regangan (OSF)
• Kegagalan Acak (RNF)

Label kegagalan mesin menunjukkan apakah mesin telah gagal untuk titik data tertentu jika salah satu mode kegagalan sebelumnya benar. Jika setidaknya salah satu mode kegagalan benar, proses gagal dan label kegagalan mesin diatur ke 1. Tujuan model ML adalah untuk mengidentifikasi kegagalan mesin dengan benar, sehingga tindakan pemeliharaan prediktif hilir dapat dimulai.

Ikhtisar solusi

Untuk kasus penggunaan pemeliharaan prediktif kami, kami berasumsi bahwa sensor perangkat mengalirkan berbagai pengukuran dan pembacaan tentang bagian-bagian mesin. Solusi kami kemudian mengambil sepotong data streaming setiap kali (mikro-batch), dan melakukan pemrosesan dan rekayasa fitur untuk membuat fitur. Fitur yang dibuat kemudian digunakan untuk menghasilkan inferensi dari model ML yang terlatih dan diterapkan dalam waktu hampir real-time. Inferensi yang dihasilkan dapat diproses lebih lanjut dan dikonsumsi oleh aplikasi hilir, untuk mengambil tindakan yang tepat dan memulai aktivitas pemeliharaan.

Diagram berikut menunjukkan arsitektur solusi keseluruhan kami.

Solusinya secara luas terdiri dari bagian-bagian berikut, yang dijelaskan secara rinci nanti di posting ini:

• Streaming sumber data dan penyerapan - Kita gunakan Aliran Data Amazon Kinesis untuk mengumpulkan data streaming dari sensor lapangan dalam skala besar dan membuatnya tersedia untuk diproses lebih lanjut.
• Rekayasa fitur hampir real-time – Kami menggunakan pekerjaan streaming AWS Glue untuk membaca data dari aliran data Kinesis dan melakukan pemrosesan data dan rekayasa fitur, sebelum menyimpan fitur turunan di Layanan Penyimpanan Sederhana Amazon (Amazon S3). Amazon S3 menyediakan opsi yang andal dan hemat biaya untuk menyimpan data dalam jumlah besar.
• Pelatihan dan penerapan model – Kami menggunakan set data pemeliharaan prediktif AI4I dari UCI Data Repository untuk melatih model ML berdasarkan algoritme XGBoost menggunakan SageMaker. Kami kemudian menerapkan model terlatih ke titik akhir inferensi asinkron SageMaker.
• Inferensi ML hampir real-time – Setelah fitur tersedia di Amazon S3, kita perlu membuat inferensi dari model yang diterapkan hampir secara real time. Titik akhir inferensi asinkron SageMaker sangat cocok untuk persyaratan ini karena mendukung ukuran muatan yang lebih besar (hingga 1 GB) dan dapat menghasilkan kesimpulan dalam beberapa menit (hingga maksimum 15 menit). Kami menggunakan pemberitahuan acara S3 untuk menjalankan AWS Lambda berfungsi untuk memanggil titik akhir inferensi asinkron SageMaker. Titik akhir inferensi asinkron SageMaker menerima lokasi S3 sebagai input, menghasilkan inferensi dari model yang diterapkan, dan menulis inferensi ini kembali ke Amazon S3 hampir secara real time.

Kode sumber untuk solusi ini terletak di GitHub. Solusinya telah diuji dan harus dijalankan di us-east-1.

Kami menggunakan Formasi AWS Cloud template, dikerahkan menggunakan Model Aplikasi Tanpa Server AWS (AWS SAM), dan notebook SageMaker untuk menerapkan solusi.

Prasyarat

Untuk memulai, sebagai prasyarat, Anda harus memiliki SAM CLI, Python 3, dan PIP diinstal. Anda juga harus memiliki Antarmuka Baris Perintah AWS (AWS CLI) dikonfigurasi dengan benar.

Terapkan solusinya

Anda dapat menggunakan AWS CloudShell untuk menjalankan langkah-langkah ini. CloudShell adalah shell berbasis browser yang telah diautentikasi sebelumnya dengan kredensial konsol Anda dan menyertakan alat pengembangan dan operasi umum yang telah diinstal sebelumnya (seperti AWS SAM, AWS CLI, dan Python). Oleh karena itu, tidak diperlukan instalasi atau konfigurasi lokal.

• Kami mulai dengan membuat bucket S3 tempat kami menyimpan skrip untuk tugas streaming AWS Glue kami. Jalankan perintah berikut di terminal Anda untuk membuat ember baru:

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

• Catat nama bucket yang dibuat.

• Selanjutnya, kami mengkloning repositori kode secara lokal, yang berisi template CloudFormation untuk menyebarkan tumpukan. Jalankan perintah berikut di terminal Anda:

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

• Arahkan ke direktori sam-template:

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

• Jalankan perintah berikut untuk menyalin skrip pekerjaan AWS Glue (dari glue_streaming/app.py) ke bucket S3 yang Anda buat:

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

• Sekarang Anda dapat melanjutkan pembangunan dan penerapan solusi, melalui template CloudFormation melalui AWS SAM. Jalankan perintah berikut:

sam deploy --guided

• Berikan argumen untuk penerapan seperti nama tumpukan, Wilayah AWS pilihan (us-east-1), Dan GlueScriptsBucket.

Pastikan Anda menyediakan bucket S3 yang sama dengan yang Anda buat sebelumnya untuk bucket S3 skrip AWS Glue (parameter GlueScriptsBucket dalam tangkapan layar berikut).

Setelah Anda memberikan argumen yang diperlukan, AWS SAM memulai penerapan tumpukan. Tangkapan layar berikut menunjukkan sumber daya yang dibuat.

Setelah tumpukan berhasil disebarkan, Anda akan melihat pesan berikut.

• Di konsol AWS CloudFormation, buka tumpukan (untuk posting ini, nrt-streaming-inference) yang disediakan saat men-deploy template CloudFormation.
• pada Sumber tab, catat ID instans notebook SageMaker.

• Di konsol SageMaker, buka instance ini.

Instans notebook SageMaker sudah memiliki notebook yang diperlukan yang dimuat sebelumnya.

Navigasikan ke folder buku catatan dan buka dan ikuti instruksi di dalam buku catatan (Data_Pre-Processing.ipynb dan ModelTraining-Evaluation-and-Deployment.ipynb) untuk menjelajahi set data, melakukan prapemrosesan dan rekayasa fitur, serta melatih dan menerapkan model ke titik akhir inferensi asinkron SageMaker.

Streaming sumber data dan penyerapan

Kinesis Data Streams adalah layanan streaming data real-time tanpa server, skalabel, dan tahan lama yang dapat Anda gunakan untuk mengumpulkan dan memproses aliran besar catatan data secara real time. Kinesis Data Streams memungkinkan pengambilan, pemrosesan, dan penyimpanan aliran data dari berbagai sumber, seperti data log infrastruktur TI, log aplikasi, media sosial, umpan data pasar, data clickstream web, perangkat dan sensor IoT, dan banyak lagi. Anda dapat menyediakan aliran data Kinesis dalam mode sesuai permintaan atau mode yang disediakan tergantung pada throughput dan persyaratan penskalaan. Untuk informasi lebih lanjut, lihat Memilih Mode Kapasitas Aliran Data.

Untuk kasus penggunaan kami, kami berasumsi bahwa berbagai sensor mengirimkan pengukuran seperti suhu, kecepatan rotasi, torsi, dan keausan pahat ke aliran data. Kinesis Data Streams bertindak sebagai corong untuk mengumpulkan dan menyerap aliran data.

Kami menggunakan Generator Data Amazon Kinesis (KDG) nanti dalam posting ini untuk menghasilkan dan mengirim data ke aliran data Kinesis, mensimulasikan data yang dihasilkan oleh sensor. Data dari data stream sensor-data-stream diserap dan diproses menggunakan tugas streaming AWS Glue, yang akan kita bahas selanjutnya.

Rekayasa fitur hampir real-time

Pekerjaan streaming AWS Glue menyediakan cara yang nyaman untuk memproses data streaming dalam skala besar, tanpa perlu mengelola lingkungan komputasi. AWS Glue memungkinkan Anda melakukan operasi ekstrak, transformasi, dan pemuatan (ETL) pada streaming data menggunakan pekerjaan yang terus berjalan. AWS Glue streaming ETL dibangun di atas mesin Apache Spark Structured Streaming, dan dapat menyerap aliran dari Kinesis, Apache Kafka, dan Amazon Managed Streaming untuk Apache Kafka (AmazonMSK).

Tugas streaming ETL dapat menggunakan transformasi dan transformasi bawaan AWS Glue yang asli dari Apache Spark Structured Streaming. Anda juga dapat menggunakan Spark ML dan mlib pustaka di pekerjaan AWS Glue untuk pemrosesan fitur yang lebih mudah menggunakan pustaka pembantu yang tersedia.

Jika skema sumber data streaming telah ditentukan sebelumnya, Anda dapat menentukannya di tabel Katalog Data AWS. Jika definisi skema tidak dapat ditentukan sebelumnya, Anda dapat mengaktifkan deteksi skema dalam tugas streaming ETL. Pekerjaan kemudian secara otomatis menentukan skema dari data yang masuk. Selain itu, Anda dapat menggunakan Registri Skema Lem AWS untuk memungkinkan penemuan pusat, kontrol, dan evolusi skema aliran data. Anda dapat lebih lanjut mengintegrasikan Schema Registry dengan Data Catalog untuk secara opsional menggunakan skema yang disimpan di Schema Registry saat membuat atau memperbarui tabel atau partisi AWS Glue di Data Catalog.

Untuk posting ini, kami membuat tabel Katalog Data AWS Glue (sensor-stream) dengan aliran data Kinesis kami sebagai sumber dan menentukan skema untuk data sensor kami.

Kami membuat kerangka data dinamis AWS Glue dari tabel Katalog Data untuk membaca data streaming dari Kinesis. Kami juga menentukan opsi berikut:

• Ukuran jendela 60 detik, sehingga pekerjaan AWS Glue membaca dan memproses data dalam jendela 60 detik
• Posisi awal TRIM_HORIZON, untuk memungkinkan membaca dari catatan tertua di aliran data Kinesis

Kami juga menggunakan Spark MLlib pengindeks string fitur transformator untuk mengkodekan tipe kolom string ke dalam indeks label. Transformasi ini diimplementasikan menggunakan Spark ML Pipelines. Spark ML Pipeline menyediakan serangkaian API tingkat tinggi yang seragam untuk algoritme ML agar lebih mudah menggabungkan beberapa algoritme ke dalam satu pipeline atau alur kerja.

Kami menggunakan foreachBatch API untuk memanggil fungsi bernama processBatch, yang pada gilirannya memproses data yang dirujuk oleh kerangka data ini. Lihat kode berikut:

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

Fungsi processBatch melakukan transformasi yang ditentukan dan mempartisi data di Amazon S3 berdasarkan tahun, bulan, hari, dan ID batch.

Kami juga mempartisi ulang partisi AWS Glue menjadi satu partisi, untuk menghindari terlalu banyak file kecil di Amazon S3. Memiliki beberapa file kecil dapat menghambat kinerja membaca, karena memperbesar biaya tambahan yang terkait dengan pencarian, pembukaan, dan pembacaan setiap file. Kami akhirnya menulis fitur untuk menghasilkan inferensi menjadi awalan (fitur) di dalam ember S3. Lihat kode berikut:

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

Pelatihan dan penerapan model

SageMaker adalah layanan ML yang terkelola sepenuhnya dan terintegrasi yang memungkinkan ilmuwan data dan insinyur ML dengan cepat dan mudah membangun, melatih, dan menerapkan model ML.

Dalam notebook Data_Pre-Processing.ipynb, pertama-tama kita mengimpor dataset Pemeliharaan Prediktif AI4I dari Repositori Data UCI dan melakukan analisis data eksplorasi (EDA). Kami juga melakukan rekayasa fitur untuk membuat fitur kami lebih berguna untuk melatih model.

Misalnya, dalam kumpulan data, kami memiliki fitur bernama tipe, yang mewakili tipe kualitas produk sebagai L (rendah), M (sedang), atau H (tinggi). Karena ini adalah fitur kategorikal, kita perlu mengkodekannya sebelum melatih model kita. Kami menggunakan LabelEncoder Scikit-Learn untuk mencapai ini:

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

Setelah fitur diproses dan rangkaian data kereta dan pengujian yang dikurasi dibuat, kami siap melatih model ML untuk memprediksi apakah mesin gagal atau tidak berdasarkan pembacaan sistem. Kami melatih model XGBoost, menggunakan algoritme bawaan SageMaker. XGBoost dapat memberikan hasil yang baik untuk beberapa jenis masalah ML, termasuk klasifikasi, bahkan ketika sampel pelatihan terbatas.

Pekerjaan pelatihan SageMaker menyediakan cara yang andal dan fleksibel untuk melatih model ML di SageMaker. SageMaker mengelola infrastruktur komputasi yang mendasarinya dan menyediakan banyak pilihan untuk dipilih, untuk kebutuhan pelatihan model yang beragam, berdasarkan kasus penggunaan.

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

Ketika pelatihan model selesai dan evaluasi model memuaskan berdasarkan kebutuhan bisnis, kita dapat memulai penerapan model. Pertama-tama kita membuat konfigurasi titik akhir dengan opsi objek AsyncInferenceConfig dan menggunakan model yang dilatih sebelumnya:

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

Kami kemudian membuat titik akhir inferensi asinkron SageMaker, menggunakan konfigurasi titik akhir yang kami buat. Setelah disediakan, kita dapat mulai memanggil titik akhir untuk menghasilkan inferensi secara asinkron.

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

Inferensi hampir real-time

SageMaker inferensi asinkron titik akhir menyediakan kemampuan untuk mengantri permintaan inferensi yang masuk dan memprosesnya secara asinkron dalam waktu hampir-nyata. Ini sangat ideal untuk aplikasi yang memiliki permintaan inferensi dengan ukuran muatan yang lebih besar (hingga 1 GB), mungkin memerlukan waktu pemrosesan yang lebih lama (hingga 15 menit), dan memiliki persyaratan latensi yang mendekati waktu nyata. Inferensi asinkron juga memungkinkan Anda menghemat biaya dengan menskalakan jumlah instans secara otomatis ke nol saat tidak ada permintaan untuk diproses, jadi Anda hanya membayar saat titik akhir Anda memproses permintaan.

Anda dapat membuat titik akhir inferensi asinkron SageMaker yang serupa dengan cara Anda membuat titik akhir inferensi waktu nyata dan sebagai tambahan menentukan AsyncInferenceConfig objek, saat membuat konfigurasi titik akhir Anda dengan bidang EndpointConfig di API CreateEndpointConfig. Diagram berikut menunjukkan alur kerja inferensi dan bagaimana titik akhir inferensi asinkron menghasilkan inferensi.

Untuk memanggil titik akhir inferensi asinkron, payload permintaan harus disimpan di Amazon S3 dan referensi ke payload ini harus disediakan sebagai bagian dari permintaan InvokeEndpointAsync. Saat dipanggil, SageMaker mengantri permintaan untuk diproses dan mengembalikan pengidentifikasi dan lokasi keluaran sebagai respons. Setelah diproses, SageMaker menempatkan hasilnya di lokasi Amazon S3. Anda dapat memilih untuk menerima pemberitahuan sukses atau kesalahan dengan Layanan Pemberitahuan Sederhana Amazon (Amazon SNS).

Uji solusi ujung ke ujung

Untuk menguji solusi, selesaikan langkah-langkah berikut:

• Di konsol AWS CloudFormation, buka tumpukan yang Anda buat sebelumnya (nrt-streaming-inference).
• pada Output tab, salin nama ember S3 (EventsBucket).

Ini adalah bucket S3 tempat tugas streaming AWS Glue kami menulis fitur setelah membaca dan memproses dari aliran data Kinesis.

Selanjutnya, kami menyiapkan notifikasi acara untuk bucket S3 ini.

• Di konsol Amazon S3, navigasikan ke bucket EventsBucket.
• pada Properties tab, di Pemberitahuan acara bagian, pilih Buat pemberitahuan acara.

• Untuk Nama acara, Masuk invoke-endpoint-lambda.
• Untuk Awalan, Masuk features/.
• Untuk Akhiran, Masuk .csv.
• Untuk Jenis acara, pilih Semua objek membuat acara.

• Untuk Tujuan, pilih Fungsi Lambda.
• Untuk Fungsi Lambda, dan pilih fungsi invoke-endpoint-asynch.
• Pilih Simpan perubahan.

• Di konsol AWS Glue, buka pekerjaan GlueStreaming-Kinesis-S3.
• Pilih Jalankan pekerjaan.

Selanjutnya kami menggunakan Kinesis Data Generator (KDG) untuk mensimulasikan sensor yang mengirim data ke aliran data Kinesis kami. Jika ini adalah pertama kalinya Anda menggunakan KDG, lihat Ringkasan untuk pengaturan awal. KDG menyediakan template CloudFormation untuk membuat pengguna dan menetapkan izin yang cukup untuk menggunakan KDG untuk mengirim acara ke Kinesis. Jalankan Templat CloudFormation dalam akun AWS yang Anda gunakan untuk membangun solusi dalam posting ini. Setelah KDG diatur, masuk dan akses KDG untuk mengirim peristiwa uji ke aliran data Kinesis kami.

• Gunakan Wilayah tempat Anda membuat aliran data Kinesis (us-timur-1).
• Pada menu tarik-turun, pilih aliran data sensor-data-stream.
• Dalam majalah Rekor per detik bagian, pilih konstan dan masukkan 100.
• Batalkan pilihan Kompres Catatan.
• Untuk Templat rekaman, gunakan templat berikut:

{
"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 Kirim data untuk mulai mengirim data ke aliran data Kinesis.

Tugas streaming AWS Glue membaca dan mengekstrak kumpulan data mikro (mewakili pembacaan sensor) dari aliran data Kinesis berdasarkan ukuran jendela yang disediakan. Pekerjaan streaming kemudian memproses dan melakukan rekayasa fitur pada mikro-batch ini sebelum mempartisi dan menulisnya ke fitur awalan dalam bucket S3.

Saat fitur baru yang dibuat oleh tugas streaming AWS Glue ditulis ke bucket S3, fungsi Lambda (invoke-endpoint-asynch) dipicu, yang memanggil titik akhir inferensi asinkron SageMaker dengan mengirimkan permintaan pemanggilan untuk mendapatkan inferensi dari model ML yang kami terapkan. Titik akhir inferensi asinkron mengantre permintaan untuk pemanggilan asinkron. Saat pemrosesan selesai, SageMaker menyimpan hasil inferensi di lokasi Amazon S3 (S3OutputPath) yang ditentukan selama konfigurasi titik akhir inferensi asinkron.

Untuk kasus penggunaan kami, hasil inferensi menunjukkan apakah bagian mesin cenderung gagal atau tidak, berdasarkan pembacaan sensor.

SageMaker juga mengirimkan pemberitahuan sukses atau kesalahan dengan Amazon SNS. Misalnya, jika Anda mengatur berlangganan email untuk topik SNS yang berhasil dan salah (ditentukan dalam konfigurasi titik akhir inferensi SageMaker asinkron), email dapat dikirim setiap kali permintaan inferensi diproses. Tangkapan layar berikut menunjukkan contoh email dari topik sukses SNS.

Untuk aplikasi dunia nyata, Anda dapat mengintegrasikan pemberitahuan SNS dengan layanan lain seperti Layanan Antrian Sederhana Amazon (Amazon SQS) dan Lambda untuk pascapemrosesan tambahan dari inferensi yang dihasilkan atau integrasi dengan aplikasi hilir lainnya, berdasarkan kebutuhan Anda. Misalnya, untuk kasus penggunaan pemeliharaan prediktif kami, Anda dapat memanggil fungsi Lambda berdasarkan pemberitahuan SNS untuk membaca inferensi yang dihasilkan dari Amazon S3, memprosesnya lebih lanjut (seperti agregasi atau pemfilteran), dan memulai alur kerja seperti mengirim perintah kerja untuk perbaikan peralatan kepada teknisi.

Membersihkan

Setelah selesai menguji tumpukan, hapus sumber daya (terutama aliran data Kinesis, tugas streaming Lem, dan topik SNS) untuk menghindari biaya tak terduga.

Jalankan kode berikut untuk menghapus tumpukan Anda:

sam delete nrt-streaming-inference

Hapus juga sumber daya seperti titik akhir SageMaker dengan mengikuti bagian pembersihan di buku catatan ModelTraining-Evaluation-and-Deployment.

Kesimpulan

Dalam posting ini, kami menggunakan kasus penggunaan pemeliharaan prediktif untuk mendemonstrasikan cara menggunakan berbagai layanan seperti Kinesis, AWS Glue, dan SageMaker untuk membangun saluran inferensi hampir real-time. Kami mendorong Anda untuk mencoba solusi ini dan beri tahu kami pendapat Anda.

Jika Anda memiliki pertanyaan, bagikan di komentar.

Tentang penulis

Rahul Sharma adalah Arsitek Solusi di AWS Data Lab, membantu pelanggan AWS merancang dan membangun solusi AI/ML. Sebelum bergabung dengan AWS, Rahul telah menghabiskan beberapa tahun di sektor keuangan dan asuransi, membantu pelanggan membangun platform data dan analitik.

Pat Reilly adalah Arsitek di AWS Data Lab, tempat dia membantu pelanggan merancang dan membangun beban kerja data untuk mendukung bisnis mereka. Sebelum AWS, Pat berkonsultasi dengan Mitra AWS, membangun beban kerja data AWS di berbagai industri.