Antrenați modele de învățare automată folosind Amazon Keyspaces ca sursă de date

Multe aplicații menite pentru întreținerea echipamentelor industriale, monitorizarea comerțului, managementul flotei și optimizarea rutelor sunt construite folosind API-uri și drivere Cassandra open-source pentru a procesa date la viteze mari și latență scăzută. Gestionarea personală a meselor Cassandra poate fi consumatoare de timp și costisitoare. Spații cheie Amazon (pentru Apache Cassandra) vă permite să configurați, să securizați și să scalați tabelele Cassandra în AWS Cloud fără a gestiona infrastructura suplimentară.

În această postare, vă vom prezenta serviciile AWS legate de formarea modelelor de învățare automată (ML) folosind Amazon Keyspaces la un nivel înalt și vă vom oferi instrucțiuni pas cu pas pentru ingerarea datelor din Amazon Keyspaces în Amazon SageMaker și instruirea unui model care poate fi utilizat pentru un caz de utilizare specific pentru segmentarea clienților.

AWS are mai multe servicii pentru a ajuta companiile să implementeze procesele ML în cloud.

AWS ML Stack are trei straturi. În stratul mijlociu este SageMaker, care oferă dezvoltatorilor, cercetătorilor de date și inginerilor ML capacitatea de a construi, antrena și implementa modele ML la scară. Îndepărtează complexitatea de la fiecare pas al fluxului de lucru ML, astfel încât să puteți implementa mai ușor cazurile de utilizare ML. Aceasta include orice, de la întreținerea predictivă la viziunea computerizată pentru a prezice comportamentele clienților. Clienții obțin o îmbunătățire de până la 10 ori a productivității cercetătorilor de date cu SageMaker.

Apache Cassandra este o alegere populară pentru cazurile de utilizare cu citire grea cu date nestructurate sau semi-structurate. De exemplu, o afacere populară de livrare a alimentelor estimează timpul de livrare, iar un client cu amănuntul ar putea persista în utilizarea frecventă a informațiilor din catalogul de produse din baza de date Apache Cassandra. Spații cheie Amazon este un serviciu de baze de date Apache Cassandra, scalabil, disponibil și gestionat fără server. Nu trebuie să furnizați, corecționați sau gestionați servere și nu trebuie să instalați, să întrețineți sau să operați software. Tabelele se pot scala automat în sus și în jos, iar tu plătești doar pentru resursele pe care le folosești. Amazon Keyspaces vă permite să vă rulați sarcinile de lucru Cassandra pe AWS utilizând același cod de aplicație Cassandra și instrumente de dezvoltare pe care le utilizați astăzi.

SageMaker oferă o suită de algoritmi încorporați pentru a ajuta oamenii de știință de date și practicienii ML să înceapă să se antreneze și să implementeze rapid modele ML. În această postare, vă vom arăta cum un client de vânzare cu amănuntul poate folosi istoricul cumpărăturilor clienților în baza de date Keyspaces și poate viza diferite segmente de clienți pentru campanii de marketing.

K-mijloace este un algoritm de învățare nesupravegheat. Încearcă să găsească grupări discrete în cadrul datelor, în care membrii unui grup sunt cât mai asemănători între ei și cât mai diferiți de membrii altor grupuri. Definiți atributele pe care doriți să le folosească algoritmul pentru a determina similaritatea. SageMaker folosește o versiune modificată a algoritm de grupare k-means la scară web. În comparație cu versiunea originală a algoritmului, versiunea folosită de SageMaker este mai precisă. Cu toate acestea, la fel ca algoritmul original, se scalează la seturi de date masive și oferă îmbunătățiri în timpul de antrenament.

Prezentare generală a soluțiilor

Instrucțiunile presupun că veți folosi SageMaker Studio pentru a rula codul. Codul asociat a fost distribuit pe Exemplu AWS GitHub. Urmând instrucțiunile din laborator, puteți face următoarele:

• Instalați dependențele necesare.
• Conectați-vă la Amazon Keyspaces, creați un tabel și ingerați date mostre.
• Creați un model ML de clasificare folosind datele din Amazon Keyspaces.
• Explorați rezultatele modelului.
• Curățați resursele nou create.

Odată finalizat, veți avea integrat SageMaker cu Amazon Keyspaces pentru a antrena modele ML, așa cum se arată în imaginea următoare.

Acum puteți urmări instrucțiuni pas cu pas în această postare pentru a ingera datele brute stocate în Amazon Keyspaces folosind SageMaker și datele astfel extrase pentru procesarea ML.

Cerințe preliminare

Mai întâi, navigați la SageMaker.

Apoi, dacă este prima dată când utilizați SageMaker, selectați Să începem!.

Apoi, selectați Configurați domeniul SageMaker.

Apoi, creați un nou profil de utilizator cu Nume - sagemakeruserȘi selectați Creați un rol nou în Rol de execuție implicit subsecțiune.

Apoi, în ecranul care apare, selectați oricare Serviciul Amazon de stocare simplă (Amazon S3) găleată și selectați Creare rol.

Acest rol va fi utilizat în următorii pași pentru a permite SageMaker să acceseze Keyspaces Table folosind acreditările temporare ale rolului. Acest lucru elimină necesitatea de a stoca un nume de utilizator și o parolă în notebook.

Apoi, recuperați rolul asociat cu sagemakeruser care a fost creat în pasul anterior din secțiunea rezumat.

Apoi, navigați la Consola AWS și uită-te în sus AWS Identity and Access Management (IAM). În IAM, navigați la Roluri. În Roluri, căutați rolul de execuție identificat la pasul anterior.

Apoi, selectați rolul identificat la pasul anterior și selectați Adăugați permisiuni. În meniul derulant care apare, selectați Creare politică integrată. SageMaker vă permite să oferiți un nivel granular de acces care limitează acțiunile pe care un utilizator/aplicație poate efectua în funcție de cerințele de afaceri.

Apoi, selectați fila JSON și copiați politica din secțiunea Note a Github pagină. Această politică permite notebook-ului SageMaker să se conecteze la Keyspaces și să preia date pentru procesare ulterioară.

Apoi, selectați din nou Adăugați permisiuni și din meniul drop-down și selectați Atașați politica.

Căutați politica AmazonKeyspacesFullAccess și bifați caseta de selectare de lângă rezultatul potrivit și selectați Atașați politici.

Verificați dacă secțiunea privind politicile de permisiuni include AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, precum și noua politică integrată adăugată.

Apoi, navigați la SageMaker Studio folosind Consola AWS și selectați SageMaker Studio. Odată ajuns acolo, selectați Lansare aplicație și selectați Studio.

Rezumat pentru caiet

Modul preferat de a vă conecta la Keyspaces din SageMaker Notebook este utilizarea Procesul AWS Signature versiunea 4 (SigV4) bazat Acreditări temporare pentru autentificare. În acest scenariu, NU trebuie să generăm sau să stocăm acreditările Keyspaces și putem folosi acreditările pentru a ne autentifica cu pluginul SigV4. Acreditările temporare de securitate constau dintr-un ID de cheie de acces și o cheie de acces secretă. Cu toate acestea, acestea includ și un simbol de securitate care indică momentul expirării acreditărilor. În această postare, vom crea un rol IAM și vom genera acreditări temporare de securitate.

Mai întâi, instalăm un driver (cassandra-sigv4). Acest driver vă permite să adăugați informații de autentificare la solicitările dvs. API utilizând Procesul AWS Signature Version 4 (SigV4). Folosind pluginul, puteți oferi utilizatorilor și aplicațiilor acreditări pe termen scurt pentru a accesa Amazon Keyspaces (pentru Apache Cassandra) folosind utilizatori și roluri IAM. După aceasta, veți importa un certificat necesar împreună cu dependențe suplimentare de pachet. În cele din urmă, vei permite notebook-ului să-și asume rolul de a vorbi cu 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)

Apoi, conectați-vă la Amazon Keyspaces și citiți datele sistemelor din Keyspaces în Pandas DataFrame pentru a valida conexiunea.

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

Apoi, pregătiți datele pentru antrenament pe setul de date brute. În blocnotesul python asociat cu această postare, utilizați un set de date de vânzare cu amănuntul descărcat de la aiciși procesează-l. Obiectivul nostru de afaceri, având în vedere setul de date, este de a grupa clienții folosind un apel RFM specific. Modelul RFM se bazează pe trei factori cantitativi:

• Recent: cât de recent un client a făcut o achiziție.
• Frecvență: cât de des face un client o achiziție.
• Valoare monetară: Câți bani cheltuiește un client pe achiziții.

Analiza RFM clasifică numeric un client în fiecare dintre aceste trei categorii, în general pe o scară de la 1 la 5 (cu cât numărul este mai mare, cu atât rezultatul este mai bun). „Cel mai bun” client ar primi un punctaj maxim în fiecare categorie. Vom folosi funcția de discretizare bazată pe Quantile (qcut) a lui Pandas. Va ajuta la discretizarea valorilor în găleți de dimensiuni egale, pe baza sau pe baza cuantilelor eșantionului.

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

În acest exemplu, folosim CQL pentru a citi înregistrările din tabelul Keyspace. În unele cazuri de utilizare ML, poate fi necesar să citiți de mai multe ori aceleași date din același tabel Keyspaces. În acest caz, vă recomandăm să vă salvați datele într-o găleată Amazon S3 pentru a evita suportarea suplimentară costaCitește din Amazon Keyspaces. În funcție de scenariul dvs., puteți utiliza și Amazon EMR la ingera un fișier Amazon S3 foarte mare în 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())

Apoi, antrenăm un model ML folosind algoritmul KMeans și ne asigurăm că clusterele sunt create. În acest scenariu particular, veți vedea că clusterele create sunt tipărite, arătând că clienții din setul de date brute au fost grupați pe baza diferitelor atribute din setul de date. Aceste informații despre cluster pot fi utilizate pentru campanii de marketing direcționate.

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

(Opțional) În continuare, salvăm segmentele de clienți care au fost identificate de modelul ML înapoi într-un tabel Amazon Keyspaces pentru marketing direcționat. O lucrare în lot ar putea citi aceste date și poate rula campanii direcționate către clienți din anumite segmente.

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

În cele din urmă, noi curata resursele creat în timpul acestui tutorial pentru a evita costurile suplimentare.

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

Poate dura câteva secunde până la un minut pentru a finaliza ștergerea spațiului de taste și a tabelelor. Când ștergeți un spațiu de taste, spațiul de taste și toate tabelele sale sunt șterse și nu mai acumulați taxe de la acestea.

Concluzie

Această postare v-a arătat cum să ingerați datele clienților din Amazon Keyspaces în SageMaker și să antrenați un model de grupare care v-a permis să segmentați clienții. Puteți utiliza aceste informații pentru marketing direcționat, îmbunătățind astfel foarte mult KPI-ul afacerii dvs. Pentru a afla mai multe despre Amazon Keyspaces, consultați următoarele resurse:

• Antrenați modele de învățare automată folosind Amazon Keyspaces ca sursă de date (SageMaker Notebook)
• Conectați-vă la Amazon Keyspaces de pe desktop utilizând IDE-uri IntelliJ, PyCharm sau DataGrip
• Referință pentru limbajul CQL pentru Amazon Keyspaces (pentru Apache Cassandra)
• Cum să configurați accesul la linia de comandă la Amazon Keyspaces (pentru Apache Cassandra) utilizând noul set de instrumente pentru dezvoltatori imaginea Docker
• Gestionarea identității și a accesului pentru Amazon Keyspaces (pentru Apache Cassandra)
• Conectarea la Amazon Keyspaces de la SageMaker cu acreditările specifice serviciului
• Recent, Frecvency, Monetary Value (RFM)
• Referința codului Kaggle

Despre Autori

Vadim Lahovici este arhitect senior de soluții la AWS din San Francisco Bay Area, ajutând clienții să migreze la AWS. El lucrează cu organizații, de la întreprinderi mari până la startup-uri mici, pentru a le susține inovațiile. De asemenea, ajută clienții să proiecteze soluții scalabile, sigure și rentabile pe AWS.

Parth Patel este arhitect de soluții la AWS în zona golfului San Francisco. Parth îi îndrumă pe clienți să-și accelereze călătoria către cloud și să-i ajute să adopte cloud AWS cu succes. El se concentrează pe ML și modernizarea aplicațiilor.

Ram Patangi este arhitect de soluții la AWS în zona golfului San Francisco. El a ajutat clienții din sectoarele agricultură, asigurări, servicii bancare, comerț cu amănuntul, îngrijire a sănătății și științe ale vieții, ospitalitate și hi-Tech să își desfășoare afacerea cu succes pe cloud AWS. Este specializat în Baze de date, Analytics și ML.

• Coinsmart. Cel mai bun schimb de Bitcoin și Crypto din Europa.
• Platoblockchain. Web3 Metaverse Intelligence. Cunoștințe amplificate. ACCES LIBER.
• CryptoHawk. Radar Altcoin. Încercare gratuită.
• Sursa: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/