Latih model pembelajaran mesin menggunakan Amazon Keyspaces sebagai sumber data

Banyak aplikasi yang dimaksudkan untuk pemeliharaan peralatan industri, pemantauan perdagangan, manajemen armada, dan pengoptimalan rute dibangun menggunakan API Cassandra dan driver open-source untuk memproses data dengan kecepatan tinggi dan latensi rendah. Mengelola tabel Cassandra sendiri bisa memakan waktu dan mahal. Amazon Keyspaces (untuk Apache Cassandra) memungkinkan Anda menyiapkan, mengamankan, dan menskalakan tabel Cassandra di AWS Cloud tanpa mengelola infrastruktur tambahan.

Dalam posting ini, kami akan memandu Anda melalui Layanan AWS terkait dengan model pembelajaran mesin (ML) pelatihan menggunakan Amazon Keyspaces pada tingkat tinggi, dan memberikan petunjuk langkah demi langkah untuk menyerap data dari Amazon Keyspaces ke Amazon SageMaker dan melatih model yang dapat digunakan untuk kasus penggunaan segmentasi pelanggan tertentu.

AWS memiliki beberapa layanan untuk membantu bisnis menerapkan proses ML di cloud.

AWS ML Stack memiliki tiga lapisan. Di lapisan tengah adalah SageMaker, yang memberi pengembang, ilmuwan data, dan insinyur ML kemampuan untuk membangun, melatih, dan menerapkan model ML dalam skala besar. Ini menghilangkan kerumitan dari setiap langkah alur kerja ML sehingga Anda dapat lebih mudah menerapkan kasus penggunaan ML Anda. Ini mencakup segala hal mulai dari pemeliharaan prediktif hingga visi komputer untuk memprediksi perilaku pelanggan. Pelanggan mencapai peningkatan hingga 10 kali lipat dalam produktivitas ilmuwan data dengan SageMaker.

Apache Cassandra adalah pilihan populer untuk kasus penggunaan yang banyak membaca dengan data tidak terstruktur atau semi terstruktur. Misalnya, bisnis pengiriman makanan populer memperkirakan waktu pengiriman, dan pelanggan ritel dapat terus menggunakan informasi katalog produk di Database Apache Cassandra. Ruang Kunci Amazon adalah layanan database yang kompatibel dengan Apache Cassandra tanpa server yang skalabel, sangat tersedia, dan terkelola. Anda tidak perlu menyediakan, menambal, atau mengelola server, dan Anda tidak perlu menginstal, memelihara, atau mengoperasikan perangkat lunak. Tabel dapat ditingkatkan dan diturunkan secara otomatis, dan Anda hanya membayar untuk sumber daya yang Anda gunakan. Amazon Keyspaces memungkinkan Anda menjalankan beban kerja Cassandra di AWS menggunakan kode aplikasi Cassandra dan alat pengembang yang sama dengan yang Anda gunakan saat ini.

SageMaker menyediakan rangkaian algoritme bawaan untuk membantu ilmuwan data dan praktisi ML memulai pelatihan dan menerapkan model ML dengan cepat. Dalam posting ini, kami akan menunjukkan kepada Anda bagaimana pelanggan ritel dapat menggunakan riwayat pembelian pelanggan di Database Keyspaces dan menargetkan segmen pelanggan yang berbeda untuk kampanye pemasaran.

K-berarti adalah algoritma pembelajaran tanpa pengawasan. Ini mencoba untuk menemukan pengelompokan diskrit dalam data, di mana anggota kelompok sedekat mungkin satu sama lain dan seberbeda mungkin dari anggota kelompok lain. Anda menentukan atribut yang ingin digunakan algoritme untuk menentukan kesamaan. SageMaker menggunakan versi modifikasi dari algoritma pengelompokan k-means skala web. Dibandingkan dengan versi asli algoritme, versi yang digunakan oleh SageMaker lebih akurat. Namun, seperti algoritme aslinya, ia menskalakan ke kumpulan data yang sangat besar dan memberikan peningkatan dalam waktu pelatihan.

Ikhtisar solusi

Instruksi mengasumsikan bahwa Anda akan menggunakan SageMaker Studio untuk menjalankan kode. Kode terkait telah dibagikan di Contoh AWS GitHub. Mengikuti petunjuk di lab, Anda dapat melakukan hal berikut:

• Instal dependensi yang diperlukan.
• Hubungkan ke Amazon Keyspaces, buat Tabel, dan serap data sampel.
• Buat model ML klasifikasi menggunakan data di Amazon Keyspaces.
• Jelajahi hasil model.
• Bersihkan sumber daya yang baru dibuat.

Setelah selesai, Anda akan mengintegrasikan SageMaker dengan Amazon Keyspaces untuk melatih model ML seperti yang ditunjukkan pada gambar berikut.

Sekarang Anda dapat mengikuti petunjuk langkah demi langkah dalam posting ini untuk menyerap data mentah yang disimpan di Amazon Keyspaces menggunakan SageMaker dan data yang diambil untuk pemrosesan ML.

Prasyarat

Pertama, Navigasikan ke SageMaker.

Selanjutnya, jika ini adalah pertama kalinya Anda menggunakan SageMaker, pilih Memulai.

Selanjutnya, pilih Siapkan Domain SageMaker.

Selanjutnya, buat profil pengguna baru dengan Nama – pengguna bijak, Lalu pilih Buat Peran Baru dalam Peran Eksekusi Default sub bagian.

Selanjutnya, di layar yang muncul, pilih apa saja Layanan Penyimpanan Sederhana Amazon (Amazon S3) ember, dan pilih Buat peran.

Peran ini akan digunakan dalam langkah-langkah berikut untuk mengizinkan SageMaker mengakses Tabel Ruang Kunci menggunakan kredensial sementara dari peran tersebut. Ini menghilangkan kebutuhan untuk menyimpan nama pengguna dan kata sandi di buku catatan.

Selanjutnya, ambil peran yang terkait dengan pengguna bijak yang dibuat pada langkah sebelumnya dari bagian ringkasan.

Kemudian, navigasikan ke Konsol AWS dan lihat ke atas AWS Identitas dan Manajemen Akses (IAM). Dalam IAM, navigasikan ke Peran. Di dalam Peran, cari peran eksekusi yang diidentifikasi pada langkah sebelumnya.

Selanjutnya, pilih peran yang diidentifikasi pada langkah sebelumnya dan pilih Tambahkan Izin. Pada drop down yang muncul, pilih Create Inline Policy. SageMaker memungkinkan Anda memberikan tingkat akses granular yang membatasi tindakan yang dapat dilakukan pengguna/aplikasi berdasarkan kebutuhan bisnis.

Kemudian, pilih tab JSON dan salin kebijakan dari bagian Catatan di Github halaman. Kebijakan ini memungkinkan notebook SageMaker terhubung ke Keyspaces dan mengambil data untuk diproses lebih lanjut.

Kemudian, pilih Tambahkan izin lagi dan dari drop down, dan pilih Lampirkan Kebijakan.

Cari kebijakan AmazonKeyspacesFullAccess, dan centang kotak di samping hasil yang cocok, lalu pilih Lampirkan Kebijakan.

Verifikasi bahwa bagian kebijakan izin menyertakan AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, serta kebijakan sebaris yang baru ditambahkan.

Selanjutnya, navigasikan ke SageMaker Studio menggunakan AWS Console dan pilih SageMaker Studio. Sesampai di sana, pilih Luncurkan Aplikasi dan pilih Studio.

Panduan buku catatan

Cara yang lebih disukai untuk terhubung ke Keyspaces dari SageMaker Notebook adalah dengan menggunakan Proses AWS Signature Versi 4 (SigV4) berdasarkan Kredensial Sementara untuk otentikasi. Dalam skenario ini, kami TIDAK perlu membuat atau menyimpan kredensial Keyspaces dan dapat menggunakan kredensial untuk mengautentikasi dengan plugin SigV4. Kredensial keamanan sementara terdiri dari ID kunci akses dan kunci akses rahasia. Namun, mereka juga menyertakan token keamanan yang menunjukkan kapan kredensial kedaluwarsa. Dalam posting ini, kami akan membuat peran IAM dan menghasilkan kredensial keamanan sementara.

Pertama, kita menginstal driver (cassandra-sigv4). Driver ini memungkinkan Anda untuk menambahkan informasi autentikasi ke permintaan API Anda menggunakan AWS Signature Version 4 Process (SigV4). Dengan menggunakan plugin, Anda dapat memberikan kredensial jangka pendek kepada pengguna dan aplikasi untuk mengakses Amazon Keyspaces (untuk Apache Cassandra) menggunakan pengguna dan peran IAM. Setelah ini, Anda akan mengimpor sertifikat yang diperlukan bersama dengan dependensi paket tambahan. Pada akhirnya, Anda akan mengizinkan notebook untuk mengambil peran untuk berbicara dengan Keyspaces.

# Install missing packages and import dependencies
# Installing Cassandra SigV4
%pip install cassandra-sigv4 # Get Security certificate
!curl https://certs.secureserver.net/repository/sf-class2-root.crt -O # Import
from sagemaker import get_execution_role
from cassandra.cluster import Cluster
from ssl import SSLContext, PROTOCOL_TLSv1_2, CERT_REQUIRED
from cassandra_sigv4.auth import SigV4AuthProvider
import boto3 import pandas as pd
from pandas import DataFrame import csv
from cassandra import ConsistencyLevel
from datetime import datetime
import time
from datetime import timedelta import pandas as pd
import datetime as dt
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import MinMaxScaler # Getting credentials from the role
client = boto3.client("sts") # Get notebook Role
role = get_execution_role()
role_info = {"RoleArn": role, "RoleSessionName": "session1"}
print(role_info) credentials = client.assume_role(**role_info)

Selanjutnya, sambungkan ke Amazon Keyspaces dan baca data sistem dari Keyspaces ke Pandas DataFrame untuk memvalidasi koneksi.

# Connect to Cassandra Database from SageMaker Notebook # using temporary credentials from the Role.
session = boto3.session.Session() ###
### You can also pass specific credentials to the session
###
#session = boto3.session.Session(
# aws_access_key_id=credentials["Credentials"]["AccessKeyId"],
# aws_secret_access_key=credentials["Credentials"]["SecretAccessKey"],
# aws_session_token=credentials["Credentials"]["SessionToken"],
#) region_name = session.region_name # Set Context
ssl_context = SSLContext(PROTOCOL_TLSv1_2)
ssl_context.load_verify_locations("sf-class2-root.crt")
ssl_context.verify_mode = CERT_REQUIRED auth_provider = SigV4AuthProvider(session)
keyspaces_host = "cassandra." + region_name + ".amazonaws.com" cluster = Cluster([keyspaces_host], ssl_context=ssl_context, auth_provider=auth_provider, port=9142)
session = cluster.connect() # Read data from Keyspaces system table. # Keyspaces is serverless DB so you don't have to create Keyspaces DB ahead of time.
r = session.execute("select * from system_schema.keyspaces") # Read Keyspaces row into Panda DataFrame
df = DataFrame(r)
print(df)

Selanjutnya, siapkan data untuk pelatihan pada kumpulan data mentah. Di notebook python yang terkait dengan posting ini, gunakan kumpulan data ritel yang diunduh dari di sini, dan memprosesnya. Tujuan bisnis kami mengingat kumpulan data adalah untuk mengelompokkan pelanggan menggunakan panggilan metrik RFM tertentu. Model RFM didasarkan pada tiga faktor kuantitatif:

• Kekinian: Seberapa baru pelanggan melakukan pembelian.
• Frekuensi: Seberapa sering pelanggan melakukan pembelian.
• Nilai Moneter: Berapa banyak uang yang dihabiskan pelanggan untuk pembelian.

Analisis RFM secara numerik memberi peringkat pelanggan di masing-masing dari tiga kategori ini, umumnya pada skala 1 hingga 5 (semakin tinggi angkanya, semakin baik hasilnya). Pelanggan "terbaik" akan menerima skor tertinggi di setiap kategori. Kami akan menggunakan fungsi diskritisasi berbasis Quantile (qcut) panda. Ini akan membantu membedakan nilai ke dalam ember berukuran sama berdasarkan atau berdasarkan kuantil sampel.

# Prepare Data
r = session.execute("select * from " + keyspaces_schema + ".online_retail") df = DataFrame(r)
df.head(100) df.count()
df["description"].nunique()
df["totalprice"] = df["quantity"] * df["price"]
df.groupby("invoice").agg({"totalprice": "sum"}).head() df.groupby("description").agg({"price": "max"}).sort_values("price", ascending=False).head()
df.sort_values("price", ascending=False).head()
df["country"].value_counts().head()
df.groupby("country").agg({"totalprice": "sum"}).sort_values("totalprice", ascending=False).head() returned = df[df["invoice"].str.contains("C", na=False)]
returned.sort_values("quantity", ascending=True).head() df.isnull().sum()
df.dropna(inplace=True)
df.isnull().sum()
df.dropna(inplace=True)
df.isnull().sum()
df.describe([0.05, 0.01, 0.25, 0.50, 0.75, 0.80, 0.90, 0.95, 0.99]).T
df.drop(df.loc[df["customer_id"] == ""].index, inplace=True) # Recency Metric
import datetime as dt today_date = dt.date(2011, 12, 9)
df["customer_id"] = df["customer_id"].astype(int) # create get the most recent invoice for each customer
temp_df = df.groupby("customer_id").agg({"invoice_date": "max"})
temp_df["invoice_date"] = temp_df["invoice_date"].astype(str)
temp_df["invoice_date"] = pd.to_datetime(temp_df["invoice_date"]).dt.date
temp_df["Recency"] = (today_date - temp_df["invoice_date"]).dt.days
recency_df = temp_df.drop(columns=["invoice_date"])
recency_df.head() # Frequency Metric
temp_df = df.groupby(["customer_id", "invoice"]).agg({"invoice": "count"})
freq_df = temp_df.groupby("customer_id").agg({"invoice": "count"})
freq_df.rename(columns={"invoice": "Frequency"}, inplace=True) # Monetary Metric
monetary_df = df.groupby("customer_id").agg({"totalprice": "sum"})
monetary_df.rename(columns={"totalprice": "Monetary"}, inplace=True)
rfm = pd.concat([recency_df, freq_df, monetary_df], axis=1) df = rfm
df["RecencyScore"] = pd.qcut(df["Recency"], 5, labels=[5, 4, 3, 2, 1])
df["FrequencyScore"] = pd.qcut(df["Frequency"].rank(method="first"), 5, labels=[1, 2, 3, 4, 5])
df["Monetary"] = df["Monetary"].astype(int)
df["MonetaryScore"] = pd.qcut(df["Monetary"], 5, labels=[1, 2, 3, 4, 5])
df["RFM_SCORE"] = ( df["RecencyScore"].astype(str) + df["FrequencyScore"].astype(str) + df["MonetaryScore"].astype(str)
)
seg_map = { r"[1-2][1-2]": "Hibernating", r"[1-2][3-4]": "At Risk", r"[1-2]5": "Can't Loose", r"3[1-2]": "About to Sleep", r"33": "Need Attention", r"[3-4][4-5]": "Loyal Customers", r"41": "Promising", r"51": "New Customers", r"[4-5][2-3]": "Potential Loyalists", r"5[4-5]": "Champions",
} df["Segment"] = df["RecencyScore"].astype(str) + rfm["FrequencyScore"].astype(str)
df["Segment"] = df["Segment"].replace(seg_map, regex=True)
df.head()
rfm = df.loc[:, "Recency":"Monetary"]
df.groupby("customer_id").agg({"Segment": "sum"}).head()

Dalam contoh ini, kami menggunakan CQL untuk membaca catatan dari tabel Keyspace. Dalam beberapa kasus penggunaan ML, Anda mungkin perlu membaca data yang sama dari tabel Keyspaces yang sama beberapa kali. Dalam hal ini, kami sarankan Anda menyimpan data Anda ke dalam ember Amazon S3 untuk menghindari tambahan biayas membaca dari Amazon Keyspaces. Bergantung pada skenario Anda, Anda juga dapat menggunakan Amazon ESDM untuk menelan file Amazon S3 yang sangat besar ke dalam SageMaker.

## Optional Code to save Python DataFrame to S3
from io import StringIO # python3 (or BytesIO for python2) smclient = boto3.Session().client('sagemaker')
sess = sagemaker.Session()
bucket = sess.default_bucket() # Set a default S3 bucket
print(bucket) csv_buffer = StringIO()
df.to_csv(csv_buffer)
s3_resource = boto3.resource('s3')
s3_resource.Object(bucket, ‘out/saved_online_retail.csv').put(Body=csv_buffer.getvalue())

Selanjutnya, kami melatih model ML menggunakan algoritme KMeans dan memastikan bahwa cluster telah dibuat. Dalam skenario khusus ini, Anda akan melihat bahwa cluster yang dibuat dicetak, menunjukkan bahwa pelanggan dalam kumpulan data mentah telah dikelompokkan bersama berdasarkan berbagai atribut dalam kumpulan data. Informasi cluster ini dapat digunakan untuk kampanye pemasaran yang ditargetkan.

# Training sc = MinMaxScaler((0, 1))
df = sc.fit_transform(rfm) # Clustering
kmeans = KMeans(n_clusters=6).fit(df) # Result
segment = kmeans.labels_ # Visualize the clusters
import matplotlib.pyplot as plt final_df = pd.DataFrame({"customer_id": rfm.index, "Segment": segment})
bucket_data = final_df.groupby("Segment").agg({"customer_id": "count"}).head()
index_data = final_df.groupby("Segment").agg({"Segment": "max"}).head()
index_data["Segment"] = index_data["Segment"].astype(int)
dataFrame = pd.DataFrame(data=bucket_data["customer_id"], index=index_data["Segment"])
dataFrame.rename(columns={"customer_id": "Total Customers"}).plot.bar( rot=70, title="RFM clustering"
)
# dataFrame.plot.bar(rot=70, title="RFM clustering");
plt.show(block=True);

(Opsional) Selanjutnya, kami menyimpan segmen pelanggan yang telah diidentifikasi oleh model ML kembali ke tabel Amazon Keyspaces untuk pemasaran yang ditargetkan. Pekerjaan batch dapat membaca data ini dan menjalankan kampanye yang ditargetkan ke pelanggan di segmen tertentu.

# Create ml_clustering_results table to store results createTable = """CREATE TABLE IF NOT EXISTS %s.ml_clustering_results ( run_id text, segment int, total_customers int, run_date date, PRIMARY KEY (run_id, segment)); """
cr = session.execute(createTable % keyspaces_schema)
time.sleep(20)
print("Table 'ml_clustering_results' created") insert_ml = ( "INSERT INTO " + keyspaces_schema + '.ml_clustering_results' + '("run_id","segment","total_customers","run_date") ' + 'VALUES (?,?,?,?); '
) prepared = session.prepare(insert_ml)
prepared.consistency_level = ConsistencyLevel.LOCAL_QUORUM run_id = "101"
dt = datetime.now() for ind in dataFrame.index: print(ind, dataFrame['customer_id'][ind]) r = session.execute( prepared, ( run_id, ind, dataFrame['customer_id'][ind], dt, ), )

Akhirnya, kita membersihkan sumber daya dibuat selama tutorial ini untuk menghindari timbulnya biaya tambahan.

# Delete blog keyspace and tables
deleteKeyspace = "DROP KEYSPACE IF EXISTS blog"
dr = session.execute(deleteKeyspace) time.sleep(5)
print("Dropping %s keyspace. It may take a few seconds to a minute to complete deletion keyspace and table." % keyspaces_schema )

Mungkin diperlukan beberapa detik hingga satu menit untuk menyelesaikan penghapusan keyspace dan tabel. Saat Anda menghapus keyspace, keyspace dan semua tabelnya akan dihapus dan Anda berhenti dikenakan biaya dari mereka.

Kesimpulan

Posting ini menunjukkan kepada Anda cara menyerap data pelanggan dari Amazon Keyspaces ke SageMaker dan melatih model pengelompokan yang memungkinkan Anda mengelompokkan pelanggan. Anda dapat menggunakan informasi ini untuk pemasaran yang ditargetkan, sehingga sangat meningkatkan KPI bisnis Anda. Untuk mempelajari lebih lanjut tentang Amazon Keyspaces, tinjau sumber daya berikut:

• Latih Model Machine Learning menggunakan Amazon Keyspaces sebagai Sumber Data (Buku Catatan SageMaker)
• Hubungkan ke Amazon Keyspaces dari desktop Anda menggunakan IDE IntelliJ, PyCharm, atau DataGrip
• Referensi Bahasa CQL untuk Amazon Keyspaces (untuk Apache Cassandra)
• Cara menyiapkan akses baris perintah ke Amazon Keyspaces (untuk Apache Cassandra) dengan menggunakan gambar Docker toolkit pengembang baru
• Manajemen Identitas dan Akses untuk Amazon Keyspaces (untuk Apache Cassandra)
• Menghubungkan ke Amazon Keyspaces dari SageMaker dengan kredensial khusus layanan
• Keterkinian, Frekuensi, Nilai Moneter (RFM)
• Referensi kode Kaggle

Tentang Penulis

Vadim Lyakhovich adalah Arsitek Solusi Senior di AWS di San Francisco Bay Area yang membantu pelanggan bermigrasi ke AWS. Dia bekerja dengan organisasi mulai dari perusahaan besar hingga perusahaan rintisan kecil untuk mendukung inovasi mereka. Dia juga membantu pelanggan untuk merancang solusi yang skalabel, aman, dan hemat biaya di AWS.

Parth Patel adalah Arsitek Solusi di AWS di San Francisco Bay Area. Parth memandu pelanggan untuk mempercepat perjalanan mereka ke cloud dan membantu mereka mengadopsi AWS cloud dengan sukses. Dia fokus pada ML dan Modernisasi Aplikasi.

Ram Pathangi adalah Arsitek Solusi di AWS di San Francisco Bay Area. Dia telah membantu pelanggan di bidang Pertanian, Asuransi, Perbankan, Ritel, Perawatan Kesehatan & Ilmu Hayati, Perhotelan, dan vertikal Hi-Tech untuk menjalankan bisnis mereka dengan sukses di AWS cloud. Dia berspesialisasi dalam Database, Analytics, dan ML.

• Coinsmart. Pertukaran Bitcoin dan Crypto Terbaik Eropa.
• Platoblockchain. Intelijen Metaverse Web3. Pengetahuan Diperkuat. AKSES GRATIS.
• CryptoHawk. Radar Altcoin. Uji Coba Gratis.
• Sumber: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/