Tren maskinlæringsmodeller ved å bruke Amazon Keyspaces som datakilde

Mange applikasjoner ment for vedlikehold av industrielt utstyr, handelsovervåking, flåtestyring og ruteoptimalisering er bygd ved å bruke åpen kildekode Cassandra APIer og drivere for å behandle data med høye hastigheter og lav ventetid. Å administrere Cassandra-bord selv kan være tidkrevende og dyrt. Amazon Keyspaces (for Apache Cassandra) lar deg sette opp, sikre og skalere Cassandra-tabeller i AWS Cloud uten å administrere ekstra infrastruktur.

I dette innlegget vil vi lede deg gjennom AWS-tjenester relatert til treningsmodeller for maskinlæring (ML) ved bruk av Amazon Keyspaces på et høyt nivå, og gi trinnvise instruksjoner for inntak av data fra Amazon Keyspaces i Amazon SageMaker og opplæring av en modell som kan brukes for et spesifikt kundesegmenteringsbruk.

AWS har flere tjenester for å hjelpe bedrifter med å implementere ML-prosesser i skyen.

AWS ML Stack har tre lag. I det midterste laget er SageMaker, som gir utviklere, dataforskere og ML-ingeniører muligheten til å bygge, trene og distribuere ML-modeller i stor skala. Det fjerner kompleksiteten fra hvert trinn i ML-arbeidsflyten, slik at du lettere kan distribuere ML-brukstilfellene dine. Dette inkluderer alt fra prediktivt vedlikehold til datasyn for å forutsi kundeatferd. Kunder oppnår opptil 10 ganger forbedring i dataforskeres produktivitet med SageMaker.

Apache Cassandra er et populært valg for lesetunge brukstilfeller med ustrukturerte eller semistrukturerte data. For eksempel anslår en populær matleveringsvirksomhet leveringstiden, og en detaljkunde kan fortsette å bruke produktkataloginformasjon i Apache Cassandra-databasen. Amazon nøkkelrom er en skalerbar, svært tilgjengelig og administrert serverløs Apache Cassandra-kompatibel databasetjeneste. Du trenger ikke klargjøre, lappe eller administrere servere, og du trenger ikke installere, vedlikeholde eller betjene programvare. Tabeller kan skaleres opp og ned automatisk, og du betaler kun for ressursene du bruker. Amazon Keyspaces lar deg kjøre Cassandra-arbeidsbelastningene dine på AWS ved å bruke den samme Cassandra-applikasjonskoden og utviklerverktøyene du bruker i dag.

SageMaker tilbyr en pakke med innebygde algoritmer for å hjelpe dataforskere og ML-utøvere raskt i gang med opplæring og distribusjon av ML-modeller. I dette innlegget viser vi deg hvordan en detaljkunde kan bruke kundekjøpshistorikk i Keyspaces-databasen og målrette mot ulike kundesegmenter for markedsføringskampanjer.

K-anordning er en uovervåket læringsalgoritme. Den prøver å finne diskrete grupperinger innenfor data, der medlemmer av en gruppe er så like hverandre som mulig og så forskjellige som mulig fra medlemmer av andre grupper. Du definerer attributtene du vil at algoritmen skal bruke for å bestemme likhet. SageMaker bruker en modifisert versjon av nettskala k-betyr klyngealgoritme. Sammenlignet med den originale versjonen av algoritmen, er versjonen brukt av SageMaker mer nøyaktig. I likhet med den originale algoritmen skalerer den imidlertid til massive datasett og leverer forbedringer i treningstid.

Løsningsoversikt

Instruksjonene forutsetter at du vil bruke SageMaker Studio til å kjøre koden. Den tilknyttede koden har blitt delt på AWS-eksempel på GitHub. Ved å følge instruksjonene i laboratoriet kan du gjøre følgende:

• Installer nødvendige avhengigheter.
• Koble til Amazon Keyspaces, lag en tabell og legg inn eksempeldata.
• Bygg en ML-klassifiseringsmodell ved å bruke dataene i Amazon Keyspaces.
• Utforsk modellresultater.
• Rydd opp i nyopprettede ressurser.

Når du er ferdig, vil du ha integrert SageMaker med Amazon Keyspaces for å trene ML-modeller som vist i bildet nedenfor.

Nå kan du følge trinnvise instruksjoner i dette innlegget for å innta rådata som er lagret i Amazon Keyspaces ved å bruke SageMaker og dataene som dermed hentes for ML-behandling.

Forutsetninger

Først, naviger til SageMaker.

Deretter, hvis dette er første gang du bruker SageMaker, velger du Kom i gang.

Deretter velger du Konfigurer SageMaker Domain.

Deretter oppretter du en ny brukerprofil med Navn – sagemakerbruker, og velg Opprett ny rolle i Standard utførelsesrolle underseksjon.

Deretter velger du en hvilken som helst på skjermen som dukker opp Amazon Simple Storage Service (Amazon S3) bøtte, og velg Opprett rolle.

Denne rollen vil bli brukt i de følgende trinnene for å tillate SageMaker å få tilgang til Keyspaces Table ved å bruke midlertidig legitimasjon fra rollen. Dette eliminerer behovet for å lagre brukernavn og passord i den bærbare datamaskinen.

Deretter henter du rollen som er knyttet til sagemakerbruker som ble opprettet i forrige trinn fra sammendragsdelen.

Deretter navigerer du til AWS-konsoll og se opp AWS Identity and Access Management (IAM). Naviger til Roller i IAM. I Roller, søk etter utførelsesrollen identifisert i forrige trinn.

Deretter velger du rollen identifisert i forrige trinn og velger Legg til tillatelser. Velg Opprett innebygd policy i rullegardinmenyen som vises. SageMaker lar deg gi et detaljert tilgangsnivå som begrenser hvilke handlinger en bruker/applikasjon kan utføre basert på forretningskrav.

Deretter velger du JSON-fanen og kopierer policyen fra Note-delen av Github side. Denne policyen lar SageMaker-notisboken koble til Keyspaces og hente data for videre behandling.

Velg deretter Legg til tillatelser igjen og fra rullegardinmenyen, og velg Legg ved policy.

Slå opp AmazonKeyspacesFullAccess-policy, og merk av i avmerkingsboksen ved siden av det samsvarende resultatet, og velg Legg ved retningslinjer.

Bekreft at tillatelsespolicydelen inkluderer AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, samt den nylig lagt til innebygde policyen.

Deretter går du til SageMaker Studio ved å bruke AWS-konsollen og velger SageMaker Studio. Når du er der, velg Start app og velg Studio.

Notebook gjennomgang

Den foretrukne måten å koble til Keyspaces fra SageMaker Notebook er ved å bruke AWS Signature versjon 4-prosess (SigV4) basert Midlertidig legitimasjon for autentisering. I dette scenariet trenger vi IKKE å generere eller lagre Keyspaces-legitimasjon og kan bruke legitimasjonen til å autentisere med SigV4-plugin. Midlertidig sikkerhetslegitimasjon består av en tilgangsnøkkel-ID og en hemmelig tilgangsnøkkel. Imidlertid inkluderer de også et sikkerhetstoken som indikerer når legitimasjonen utløper. I dette innlegget oppretter vi en IAM-rolle og genererer midlertidig sikkerhetslegitimasjon.

Først installerer vi en driver (cassandra-sigv4). Denne driveren lar deg legge til autentiseringsinformasjon til API-forespørslene dine ved å bruke AWS Signature Versjon 4-prosessen (SigV4). Ved å bruke pluginet kan du gi brukere og applikasjoner kortsiktig legitimasjon for å få tilgang til Amazon Keyspaces (for Apache Cassandra) ved å bruke IAM-brukere og roller. Etter dette vil du importere et nødvendig sertifikat sammen med ytterligere pakkeavhengigheter. Til slutt vil du tillate at notatboken påtar seg rollen som å snakke 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)

Koble deretter til Amazon Keyspaces og les systemdata fra Keyspaces inn i Pandas DataFrame for å validere tilkoblingen.

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

Deretter forbereder du dataene for trening på rådatasettet. I python-notisboken knyttet til dette innlegget, bruk et detaljdatasett som er lastet ned fra her., og behandle den. Vårt forretningsmål gitt datasettet er å gruppere kundene ved å bruke en spesifikk metrisk samtale RFM. RFM-modellen er basert på tre kvantitative faktorer:

• Nylig: Hvor nylig en kunde har foretatt et kjøp.
• Frekvens: Hvor ofte en kunde foretar et kjøp.
• Pengeverdi: Hvor mye penger en kunde bruker på kjøp.

RFM-analyse rangerer en kunde numerisk i hver av disse tre kategoriene, vanligvis på en skala fra 1 til 5 (jo høyere tall, jo bedre resultat). Den "beste" kunden vil få en toppscore i hver kategori. Vi bruker pandas' Quantile-baserte diskretiseringsfunksjon (qcut). Det vil hjelpe å diskretisere verdier i like store bøtter basert på eller basert 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 eksemplet bruker vi CQL til å lese poster fra Keyspace-tabellen. I noen ML-brukstilfeller må du kanskje lese de samme dataene fra den samme Keyspaces-tabellen flere ganger. I dette tilfellet vil vi anbefale at du lagrer dataene dine i en Amazon S3-bøtte for å unngå ekstra kostnader kostes lesing fra Amazon Keyspaces. Avhengig av scenarioet ditt, kan du også bruke Amazon EMR til innta en veldig stor Amazon S3-fil til 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())

Deretter trener vi en ML-modell ved å bruke KMeans-algoritmen og sørger for at klyngene er opprettet. I dette spesielle scenariet vil du se at de opprettede klyngene skrives ut, noe som viser at kundene i rådatasettet er gruppert sammen basert på ulike attributter i datasettet. Denne klyngeinformasjonen kan brukes til målrettede markedsfø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);

(Valgfritt) Deretter lagrer vi kundesegmentene som er identifisert av ML-modellen, tilbake til en Amazon Keyspaces-tabell for målrettet markedsføring. En batch-jobb kan lese disse dataene og kjøre målrettede kampanjer til kunder i bestemte 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, ), )

Til slutt, vi rydde opp i ressursene opprettet under denne opplæringen for å unngå ekstra 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 noen sekunder til et minutt å fullføre slettingen av tastområde og tabeller. Når du sletter et tastefelt, slettes tasterommet og alle dets tabeller, og du slutter å påløpe kostnader fra dem.

konklusjonen

Dette innlegget viste deg hvordan du kan ta inn kundedata fra Amazon Keyspaces til SageMaker og trene en klyngemodell som tillot deg å segmentere kunder. Du kan bruke denne informasjonen til målrettet markedsføring, og dermed forbedre bedriftens KPI betraktelig. For å lære mer om Amazon Keyspaces, se gjennom følgende ressurser:

• Tren maskinlæringsmodeller ved å bruke Amazon Keyspaces som datakilde (SageMaker Notebook)
• Koble til Amazon Keyspaces fra skrivebordet ditt ved hjelp av IntelliJ, PyCharm eller DataGrip IDEer
• CQL Language Reference for Amazon Keyspaces (for Apache Cassandra)
• Hvordan sette opp kommandolinjetilgang til Amazon Keyspaces (for Apache Cassandra) ved å bruke det nye utviklerverktøysettet Docker image
• Identitets- og tilgangsadministrasjon for Amazon Keyspaces (for Apache Cassandra)
• Koble til Amazon Keyspaces fra SageMaker med tjenestespesifikk legitimasjon
• Nyhet, frekvens, pengeverdi (RFM)
• Kaggle-kodereferanse

Om forfatterne

Vadim Lyakhovich er Senior Solutions Architect hos AWS i San Francisco Bay Area som hjelper kunder med å migrere til AWS. Han jobber med organisasjoner som spenner fra store bedrifter til små startups for å støtte deres innovasjoner. Han hjelper også kunder med å bygge skalerbare, sikre og kostnadseffektive løsninger på AWS.

Parth Patel er en løsningsarkitekt ved AWS i San Francisco Bay Area. Parth veileder kundene til å akselerere reisen til skyen og hjelpe dem å ta i bruk AWS-skyen med suksess. Han fokuserer på ML og applikasjonsmodernisering.

Ram Pathangi er en løsningsarkitekt ved AWS i San Francisco Bay Area. Han har hjulpet kunder innen landbruk, forsikring, bank, detaljhandel, helsevesen og biovitenskap, gjestfrihet og høyteknologi med å drive virksomheten sin med suksess på AWS-skyen. Han har spesialisert seg på databaser, analyse og ML.

• Myntsmart. Europas beste Bitcoin og Crypto Exchange.
• Platoblokkkjede. Web3 Metaverse Intelligence. Kunnskap forsterket. FRI TILGANG.
• CryptoHawk. Altcoin Radar. Gratis prøveperiode.
• Kilde: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/