Träna maskininlärningsmodeller med Amazon Keyspaces som datakälla

Många applikationer avsedda för underhåll av industriell utrustning, handelsövervakning, flotthantering och ruttoptimering är byggda med Cassandra API:er och drivrutiner med öppen källkod för att bearbeta data med höga hastigheter och låg latens. Att hantera Cassandra-bord själv kan vara tidskrävande och dyrt. Amazon Keyspaces (för Apache Cassandra) låter dig ställa in, säkra och skala Cassandra-tabeller i AWS-molnet utan att hantera ytterligare infrastruktur.

I det här inlägget går vi igenom AWS-tjänster relaterade till träningsmodeller för maskininlärning (ML) som använder Amazon Keyspaces på hög nivå, och ger dig steg-för-steg-instruktioner för att mata in data från Amazon Keyspaces Amazon SageMaker och utbildning av en modell som kan användas för ett specifikt användningsfall för kundsegmentering.

AWS har flera tjänster för att hjälpa företag att implementera ML-processer i molnet.

AWS ML Stack har tre lager. I det mellersta lagret är SageMaker, som ger utvecklare, datavetare och ML-ingenjörer möjligheten att bygga, träna och distribuera ML-modeller i stor skala. Det tar bort komplexiteten från varje steg i ML-arbetsflödet så att du lättare kan distribuera dina ML-användningsfall. Detta inkluderar allt från prediktivt underhåll till datorseende för att förutsäga kundbeteenden. Kunder uppnår upp till 10 gånger förbättring av datavetares produktivitet med SageMaker.

Apache Cassandra är ett populärt val för lästunga användningsfall med ostrukturerad eller semistrukturerad data. Till exempel uppskattar ett populärt matleveransföretag leveranstiden, och en detaljhandelskund skulle kunna fortsätta använda produktkataloginformation i Apache Cassandra-databasen. Amazon Keyspaces är en skalbar, högtillgänglig och hanterad serverlös Apache Cassandra-kompatibel databastjänst. Du behöver inte tillhandahålla, korrigera eller hantera servrar, och du behöver inte installera, underhålla eller använda programvara. Tabeller kan skalas upp och ner automatiskt och du betalar bara för de resurser du använder. Amazon Keyspaces låter dig köra dina Cassandra-arbetsbelastningar på AWS med samma Cassandra-applikationskod och utvecklarverktyg som du använder idag.

SageMaker erbjuder en svit av inbyggda algoritmer för att hjälpa datavetare och ML-utövare att snabbt komma igång med utbildning och implementering av ML-modeller. I det här inlägget visar vi dig hur en detaljkund kan använda kundköphistorik i Keyspaces-databasen och rikta in sig på olika kundsegment för marknadsföringskampanjer.

K-medel är en oövervakad inlärningsalgoritm. Den försöker hitta diskreta grupperingar inom data, där medlemmar i en grupp är så lika varandra som möjligt och så olika som möjligt från medlemmar i andra grupper. Du definierar de attribut som du vill att algoritmen ska använda för att bestämma likhet. SageMaker använder en modifierad version av webbskala k-medel klustringsalgoritm. Jämfört med den ursprungliga versionen av algoritmen är versionen som används av SageMaker mer exakt. Men, liksom den ursprungliga algoritmen, skalas den till massiva datamängder och levererar förbättringar i träningstid.

Lösningsöversikt

Instruktionerna förutsätter att du skulle använda SageMaker Studio för att köra koden. Den associerade koden har delats på AWS exempel på GitHub. Genom att följa instruktionerna i labbet kan du göra följande:

• Installera nödvändiga beroenden.
• Anslut till Amazon Keyspaces, skapa en tabell och mata in exempeldata.
• Bygg en klassificerings-ML-modell med hjälp av data i Amazon Keyspaces.
• Utforska modellresultat.
• Rensa upp nyskapade resurser.

När du är klar kommer du att ha integrerat SageMaker med Amazon Keyspaces för att träna ML-modeller som visas i följande bild.

Nu kan du följa steg-för-steg-instruktioner i det här inlägget för att få in rådata lagrad i Amazon Keyspaces med SageMaker och den data som på så sätt hämtas för ML-bearbetning.

Förutsättningar

Navigera först till SageMaker.

Därefter, om det här är första gången du använder SageMaker, välj Kom igång.

Välj sedan Konfigurera SageMaker Domain.

Skapa sedan en ny användarprofil med Namn – sagemakeruser, och välj Skapa ny roll i Standard exekveringsroll undersektion.

Välj sedan någon på skärmen som dyker upp Amazon Simple Storage Service (Amazon S3) hink och välj Skapa roll.

Den här rollen kommer att användas i följande steg för att tillåta SageMaker att komma åt Keyspaces Table med hjälp av tillfälliga referenser från rollen. Detta eliminerar behovet av att lagra ett användarnamn och lösenord i den bärbara datorn.

Hämta sedan rollen som är kopplad till sagemakeruser som skapades i föregående steg från sammanfattningssektionen.

Navigera sedan till AWS-konsol och titta upp AWS Identity and Access Management (IAM). Inom IAM, navigera till Roller. Inom Roller, sök efter exekveringsrollen som identifierades i föregående steg.

Välj sedan rollen som identifierades i föregående steg och välj Lägg till behörigheter. Välj Skapa Inline Policy i rullgardinsmenyn som visas. SageMaker låter dig tillhandahålla en detaljerad åtkomstnivå som begränsar vilka åtgärder en användare/applikation kan utföra baserat på affärskrav.

Välj sedan JSON-fliken och kopiera policyn från Note-avsnittet i Github sida. Denna policy tillåter SageMaker-anteckningsboken att ansluta till Keyspaces och hämta data för vidare bearbetning.

Välj sedan Lägg till behörigheter igen och från rullgardinsmenyn och välj Bifoga policy.

Slå upp AmazonKeyspacesFullAccess-policyn och markera kryssrutan bredvid det matchande resultatet och välj Bifoga policyer.

Kontrollera att avsnittet med behörighetspolicyer innehåller AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, såväl som den nyligen tillagda inline-policyn.

Navigera sedan till SageMaker Studio med AWS-konsolen och välj SageMaker Studio. Väl där, välj Starta app och välj Studio.

Anteckningsbok genomgång

Det föredragna sättet att ansluta till Keyspaces från SageMaker Notebook är att använda AWS Signature version 4-process (SigV4) baserat Tillfälliga inloggningsuppgifter för autentisering. I det här scenariot behöver vi INTE generera eller lagra Keyspaces-uppgifter och kan använda autentiseringsuppgifterna för att autentisera med SigV4-plugin. Tillfälliga säkerhetsuppgifter består av ett åtkomstnyckel-ID och en hemlig åtkomstnyckel. Men de inkluderar också en säkerhetstoken som indikerar när autentiseringsuppgifterna går ut. I det här inlägget skapar vi en IAM-roll och genererar tillfälliga säkerhetsuppgifter.

Först installerar vi en drivrutin (cassandra-sigv4). Denna drivrutin gör att du kan lägga till autentiseringsinformation till dina API-förfrågningar med hjälp av AWS Signature Version 4 Process (SigV4). Genom att använda insticksprogrammet kan du förse användare och applikationer med kortsiktiga referenser för att komma åt Amazon Keyspaces (för Apache Cassandra) med IAM-användare och roller. Efter detta kommer du att importera ett obligatoriskt certifikat tillsammans med ytterligare paketberoenden. I slutändan kommer du att tillåta anteckningsboken att ta rollen att prata 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)

Anslut sedan till Amazon Keyspaces och läs systemdata från Keyspaces till Pandas DataFrame för att validera anslutningen.

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

Förbered sedan data för träning på rådatauppsättningen. I python-anteckningsboken som är kopplad till det här inlägget, använd en detaljhandelsdatauppsättning som laddats ner från här.och bearbeta det. Vårt affärsmål med tanke på datamängden är att klustera kunderna med hjälp av ett specifikt metriskt samtal RFM. RFM-modellen bygger på tre kvantitativa faktorer:

• Nyhet: Hur nyligen en kund har gjort ett köp.
• Frekvens: Hur ofta en kund gör ett köp.
• Monetärt värde: Hur mycket pengar en kund spenderar på köp.

RFM-analys rangordnar en kund numeriskt i var och en av dessa tre kategorier, vanligtvis på en skala från 1 till 5 (ju högre antal, desto bättre resultat). Den "bästa" kunden skulle få ett toppbetyg i varje kategori. Vi kommer att använda pandas Quantile-baserade diskretiseringsfunktion (qcut). Det kommer att hjälpa till att diskretisera värden till lika stora hinkar baserade på eller baserat på provkvantiler.

# 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 det här exemplet använder vi CQL för att läsa poster från Keyspace-tabellen. I vissa ML-användningsfall kan du behöva läsa samma data från samma Keyspaces-tabell flera gånger. I det här fallet skulle vi rekommendera att du sparar dina data i en Amazon S3-hink för att undvika att du får ytterligare kostas läsning från Amazon Keyspaces. Beroende på ditt scenario kan du också använda Amazon EMR till inta en mycket stor Amazon S3-fil till 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())

Därefter tränar vi en ML-modell med hjälp av KMeans-algoritmen och ser till att klustren skapas. I det här specifika scenariot skulle du se att de skapade klustren skrivs ut, vilket visar att kunderna i rådatauppsättningen har grupperats tillsammans baserat på olika attribut i datauppsättningen. Denna klusterinformation kan användas för riktade marknadsföringskampanjer.

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

(Valfritt) Därefter sparar vi kundsegmenten som har identifierats av ML-modellen tillbaka till en Amazon Keyspaces-tabell för riktad marknadsföring. Ett batchjobb kan läsa denna data och köra riktade kampanjer till kunder i specifika segment.

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

Slutligen, vi rensa upp resurserna skapas under denna handledning för att undvika extra kostnader.

# 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 ta några sekunder till en minut att slutföra raderingen av tangentutrymme och tabeller. När du tar bort ett tangentutrymme raderas tangentutrymmet och alla dess tabeller och du slutar samla på dig avgifter från dem.

Slutsats

Det här inlägget visade dig hur du matar in kunddata från Amazon Keyspaces till SageMaker och tränar en klustringsmodell som gjorde att du kunde segmentera kunder. Du kan använda denna information för riktad marknadsföring och på så sätt förbättra ditt företags KPI avsevärt. För att lära dig mer om Amazon Keyspaces, granska följande resurser:

• Träna maskininlärningsmodeller med Amazon Keyspaces som datakälla (SageMaker Notebook)
• Anslut till Amazon Keyspaces från ditt skrivbord med IntelliJ, PyCharm eller DataGrip IDE
• CQL Language Reference för Amazon Keyspaces (för Apache Cassandra)
• Hur man ställer in kommandoradsåtkomst till Amazon Keyspaces (för Apache Cassandra) genom att använda den nya utvecklarverktygssatsen Docker image
• Identitets- och åtkomsthantering för Amazon Keyspaces (för Apache Cassandra)
• Ansluter till Amazon Keyspaces från SageMaker med tjänstespecifika referenser
• Nyhet, frekvens, monetärt värde (RFM)
• Kaggle-kodreferens

Om författarna

Vadim Lyakhovich är Senior Solutions Architect på AWS i San Francisco Bay Area som hjälper kunder att migrera till AWS. Han arbetar med organisationer som sträcker sig från stora företag till små startups för att stödja deras innovationer. Han hjälper också kunder att utforma skalbara, säkra och kostnadseffektiva lösningar på AWS.

Parth Patel är en lösningsarkitekt på AWS i San Francisco Bay Area. Parth vägleder kunder att påskynda sin resa till molnet och hjälpa dem att framgångsrikt använda AWS-molnet. Han fokuserar på ML och applikationsmodernisering.

Ram Pathangi är en lösningsarkitekt på AWS i San Francisco Bay Area. Han har hjälpt kunder inom jordbruks-, försäkrings-, bank-, detaljhandels-, hälsovårds- och livsvetenskaper, gästfrihet och högteknologiska vertikaler att driva sin verksamhet framgångsrikt i AWS-molnet. Han är specialiserad på Databaser, Analytics och ML.

• Myntsmart. Europas bästa bitcoin- och kryptobörs.
• Platoblockchain. Web3 Metaverse Intelligence. Kunskap förstärkt. FRI TILLGÅNG.
• CryptoHawk. Altcoin radar. Gratis provperiod.
• Källa: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/