Træn maskinlæringsmodeller ved hjælp af Amazon Keyspaces som datakilde

Mange applikationer beregnet til vedligeholdelse af industrielt udstyr, handelsovervågning, flådestyring og ruteoptimering er bygget ved hjælp af open source Cassandra API'er og drivere til at behandle data ved høje hastigheder og lav latenstid. Det kan være tidskrævende og dyrt at administrere Cassandra-borde selv. Amazon Keyspaces (til Apache Cassandra) lader dig opsætte, sikre og skalere Cassandra-tabeller i AWS Cloud uden at administrere yderligere infrastruktur.

I dette indlæg vil vi guide dig gennem AWS Services relateret til træning af maskinlæringsmodeller (ML) ved hjælp af Amazon Keyspaces på et højt niveau, og vi giver dig trin for trin instruktioner til indlæsning af data fra Amazon Keyspaces i Amazon SageMaker og træning af en model, som kan bruges til en specifik kundesegmentering use case.

AWS har flere tjenester til at hjælpe virksomheder med at implementere ML-processer i skyen.

AWS ML Stack har tre lag. I mellemlaget er SageMaker, som giver udviklere, datavidenskabsfolk og ML-ingeniører mulighed for at bygge, træne og implementere ML-modeller i stor skala. Det fjerner kompleksiteten fra hvert trin i ML-arbejdsgangen, så du nemmere kan implementere dine ML-brugssager. Dette inkluderer alt fra forudsigelig vedligeholdelse til computervision for at forudsige kundeadfærd. Kunder opnår op til 10 gange forbedring af dataforskeres produktivitet med SageMaker.

Apache Cassandra er et populært valg til læstunge brugssager med ustrukturerede eller semistrukturerede data. For eksempel estimerer en populær fødevareleveringsvirksomhed leveringstidspunktet, og en detailkunde kan blive ved med at bruge produktkatalogoplysninger i Apache Cassandra-databasen. Amazon nøglerum er en skalerbar, meget tilgængelig og administreret serverløs Apache Cassandra-kompatibel databasetjeneste. Du behøver ikke at klargøre, patche eller administrere servere, og du behøver ikke installere, vedligeholde eller betjene software. Tabeller kan skaleres op og ned automatisk, og du betaler kun for de ressourcer, du bruger. Amazon Keyspaces lader dig køre dine Cassandra-arbejdsbelastninger på AWS ved hjælp af den samme Cassandra-applikationskode og udviklerværktøjer, som du bruger i dag.

SageMaker giver en suite af indbyggede algoritmer for at hjælpe dataforskere og ML-praktikere hurtigt i gang med at træne og implementere ML-modeller. I dette indlæg viser vi dig, hvordan en detailkunde kan bruge kundekøbshistorik i Keyspaces-databasen og målrette mod forskellige kundesegmenter til marketingkampagner.

K-betyder er en uovervåget læringsalgoritme. Den forsøger at finde diskrete grupperinger inden for data, hvor medlemmer af en gruppe ligner hinanden så meget som muligt og så forskellige som muligt fra medlemmer af andre grupper. Du definerer de attributter, som du ønsker, at algoritmen skal bruge til at bestemme lighed. SageMaker bruger en modificeret version af web-skala k-betyder klyngealgoritme. Sammenlignet med den originale version af algoritmen er den version, der bruges af SageMaker, mere nøjagtig. Men ligesom den originale algoritme skalerer den til massive datasæt og leverer forbedringer i træningstid.

Løsningsoversigt

Instruktionerne antager, at du ville bruge SageMaker Studio til at køre koden. Den tilknyttede kode er blevet delt på AWS-eksempel på GitHub. Ved at følge instruktionerne i laboratoriet kan du gøre følgende:

• Installer nødvendige afhængigheder.
• Opret forbindelse til Amazon Keyspaces, opret en tabel, og indtag prøvedata.
• Byg en klassifikations-ML-model ved hjælp af dataene i Amazon Keyspaces.
• Udforsk modelresultater.
• Ryd op i nyoprettede ressourcer.

Når du er færdig, har du integreret SageMaker med Amazon Keyspaces for at træne ML-modeller som vist på følgende billede.

Nu kan du følge trinvise instruktioner i dette indlæg for at indtage rådata, der er gemt i Amazon Keyspaces ved hjælp af SageMaker, og de data, der således hentes til ML-behandling.

Forudsætninger

Først skal du navigere til SageMaker.

Dernæst, hvis det er første gang, du bruger SageMaker, skal du vælge Kom i gang.

Vælg derefter Konfigurer SageMaker Domain.

Opret derefter en ny brugerprofil med Navn – sagemakerbruger, og vælg Opret ny rolle i Standard eksekveringsrolle underafsnit.

Dernæst skal du på skærmen, der popper op, vælge en hvilken som helst Amazon Simple Storage Service (Amazon S3) spand, og vælg Opret rolle.

Denne rolle vil blive brugt i de følgende trin for at tillade SageMaker at få adgang til Keyspaces Table ved hjælp af midlertidige legitimationsoplysninger fra rollen. Dette eliminerer behovet for at gemme et brugernavn og en adgangskode i den bærbare computer.

Derefter skal du hente den rolle, der er knyttet til sagemakerbruger der blev oprettet i det forrige trin fra oversigtssektionen.

Naviger derefter til AWS-konsol og se op AWS Identity and Access Management (IAM). I IAM skal du navigere til Roller. Inden for Roller skal du søge efter den udførelsesrolle, der blev identificeret i det foregående trin.

Vælg derefter den rolle, der blev identificeret i det foregående trin, og vælg Tilføj tilladelser. I rullemenuen, der vises, skal du vælge Opret inline politik. SageMaker giver dig mulighed for at give et detaljeret adgangsniveau, der begrænser, hvilke handlinger en bruger/applikation kan udføre baseret på forretningskrav.

Vælg derefter fanen JSON og kopier politikken fra Note-sektionen i Github side. Denne politik gør det muligt for SageMaker-notebooken at oprette forbindelse til Keyspaces og hente data til yderligere behandling.

Vælg derefter Tilføj tilladelser igen og fra rullemenuen, og vælg Vedhæft politik.

Slå AmazonKeyspacesFullAccess-politikken op, og marker afkrydsningsfeltet ud for det matchende resultat, og vælg Vedhæft politikker.

Bekræft, at sektionen om tilladelsespolitikker indeholder AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, samt den nyligt tilføjede inline-politik.

Derefter skal du navigere til SageMaker Studio ved hjælp af AWS-konsollen og vælge SageMaker Studio. Når du er der, skal du vælge Start app og vælge Studio.

Notebook gennemgang

Den foretrukne måde at oprette forbindelse til Keyspaces fra SageMaker Notebook på er ved at bruge AWS Signature Version 4-proces (SigV4) baseret Midlertidige legitimationsoplysninger til autentificering. I dette scenarie behøver vi IKKE at generere eller gemme Keyspaces-legitimationsoplysninger og kan bruge legitimationsoplysningerne til at godkende med SigV4-plugin'et. Midlertidige sikkerhedsoplysninger består af et adgangsnøgle-id og en hemmelig adgangsnøgle. De inkluderer dog også et sikkerhedstoken, der angiver, hvornår legitimationsoplysningerne udløber. I dette indlæg opretter vi en IAM-rolle og genererer midlertidige sikkerhedsoplysninger.

Først installerer vi en driver (cassandra-sigv4). Denne driver giver dig mulighed for at tilføje autentificeringsoplysninger til dine API-anmodninger ved hjælp af AWS Signature Version 4 Process (SigV4). Ved at bruge pluginnet kan du give brugere og applikationer kortsigtede legitimationsoplysninger for at få adgang til Amazon Keyspaces (til Apache Cassandra) ved hjælp af IAM-brugere og roller. Efter dette importerer du et påkrævet certifikat sammen med yderligere pakkeafhængigheder. I sidste ende vil du tillade notesbogen at påtage sig rollen at tale med 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)

Forbind derefter til Amazon Keyspaces og læs systemdata fra Keyspaces ind i Pandas DataFrame for at validere forbindelsen.

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

Forbered derefter dataene til træning på rådatasættet. I den python-notesbog, der er knyttet til dette indlæg, skal du bruge et detaildatasæt, der er downloadet fra link., og behandle det. Vores forretningsmål givet datasættet er at gruppere kunderne ved hjælp af et specifikt metrisk opkald RFM. RFM-modellen er baseret på tre kvantitative faktorer:

• Seneste: Hvor nylig en kunde har foretaget et køb.
• Hyppighed: Hvor ofte en kunde foretager et køb.
• Monetær værdi: Hvor mange penge en kunde bruger på køb.

RFM-analyse rangerer numerisk en kunde i hver af disse tre kategorier, generelt på en skala fra 1 til 5 (jo højere tal, jo bedre resultat). Den "bedste" kunde ville modtage en topscore i hver kategori. Vi vil bruge pandas's Quantile-baserede diskretiseringsfunktion (qcut). Det vil hjælpe med at diskretisere værdier i ens store spande baseret på eller baseret på prøvekvantiler.

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

I dette eksempel bruger vi CQL til at læse poster fra Keyspace-tabellen. I nogle ML-brugstilfælde skal du muligvis læse de samme data fra den samme Keyspaces-tabel flere gange. I dette tilfælde vil vi anbefale, at du gemmer dine data i en Amazon S3-bøtte for at undgå at pådrage dig yderligere kostes læsning fra Amazon Keyspaces. Afhængigt af dit scenarie kan du også bruge Amazon EMR til indtager en meget stor Amazon S3-fil ind i 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())

Dernæst træner vi en ML-model ved hjælp af KMeans-algoritmen og sørger for, at klyngerne er oprettet. I dette særlige scenarie vil du se, at de oprettede klynger udskrives, hvilket viser, at kunderne i rådatasættet er blevet grupperet sammen baseret på forskellige attributter i datasættet. Denne klyngeinformation kan bruges til målrettede marketingkampagner.

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

(Valgfrit) Dernæst gemmer vi de kundesegmenter, der er blevet identificeret af ML-modellen, tilbage til en Amazon Keyspaces-tabel til målrettet markedsføring. Et batchjob kunne læse disse data og køre målrettede kampagner til kunder i specifikke segmenter.

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

Endelig, vi rydde op i ressourcerne oprettet i løbet af denne øvelse for at undgå at pådrage sig yderligere omkostninger.

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

Det kan tage et par sekunder til et minut at fuldføre sletningen af ​​nøglerum og tabeller. Når du sletter et tasterum, slettes tasterummet og alle dets tabeller, og du stopper med at påløbe gebyrer fra dem.

Konklusion

Dette indlæg viste dig, hvordan du indtager kundedata fra Amazon Keyspaces i SageMaker og træner en klyngemodel, der gjorde det muligt for dig at segmentere kunder. Du kan bruge disse oplysninger til målrettet markedsføring og dermed i høj grad forbedre din virksomheds KPI. For at lære mere om Amazon Keyspaces, gennemgå følgende ressourcer:

• Træn maskinlæringsmodeller ved hjælp af Amazon Keyspaces som datakilde (SageMaker notesbog)
• Opret forbindelse til Amazon Keyspaces fra dit skrivebord ved hjælp af IntelliJ, PyCharm eller DataGrip IDE'er
• CQL Language Reference for Amazon Keyspaces (til Apache Cassandra)
• Sådan konfigureres kommandolinjeadgang til Amazon Keyspaces (til Apache Cassandra) ved at bruge det nye udviklerværktøjssæt Docker image
• Identitets- og adgangsstyring til Amazon Keyspaces (til Apache Cassandra)
• Opretter forbindelse til Amazon Keyspaces fra SageMaker med servicespecifikke legitimationsoplysninger
• Seneste, frekvens, pengeværdi (RFM)
• Kaggle-kodereference

Om forfatterne

Vadim Lyakhovich er Senior Solutions Architect hos AWS i San Francisco Bay Area, der hjælper kunder med at migrere til AWS. Han arbejder med organisationer lige fra store virksomheder til små startups for at støtte deres innovationer. Han hjælper også kunder med at udvikle skalerbare, sikre og omkostningseffektive løsninger på AWS.

Parth Patel er Solutions Architect hos AWS i San Francisco Bay Area. Parth guider kunder til at fremskynde deres rejse til skyen og hjælpe dem med at implementere AWS-skyen med succes. Han fokuserer på ML og applikationsmodernisering.

Ram Pathangi er Solutions Architect hos AWS i San Francisco Bay Area. Han har hjulpet kunder inden for landbrug, forsikring, bank, detailhandel, sundhedspleje og biovidenskab, gæstfrihed og højteknologiske vertikaler med at drive deres forretning med succes på AWS-skyen. Han har specialiseret sig i Databaser, Analytics og ML.

• Coinsmart. Europas bedste Bitcoin og Crypto Exchange.
• Platoblokkæde. Web3 Metaverse Intelligence. Viden forstærket. FRI ADGANG.
• CryptoHawk. Altcoin radar. Gratis prøveversion.
• Kilde: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/