Machine learning-modellen trainen met Amazon Keyspaces als gegevensbron

Veel applicaties die bedoeld zijn voor het onderhoud van industriële apparatuur, handelsbewaking, wagenparkbeheer en route-optimalisatie zijn gebouwd met behulp van open-source Cassandra API's en stuurprogramma's om gegevens met hoge snelheden en lage latentie te verwerken. Zelf Cassandra-tafels beheren kan tijdrovend en duur zijn. Amazon Keyspaces (voor Apache Cassandra) laat je Cassandra-tabellen instellen, beveiligen en schalen in de AWS Cloud zonder extra infrastructuur te beheren.

In dit bericht leiden we je door AWS-services met betrekking tot het trainen van modellen voor machine learning (ML) met behulp van Amazon Keyspaces op een hoog niveau, en geven we stapsgewijze instructies voor het opnemen van gegevens van Amazon Keyspaces in Amazon Sage Maker en het trainen van een model dat kan worden gebruikt voor een specifieke use case voor klantsegmentatie.

AWS heeft meerdere services om bedrijven te helpen bij het implementeren van ML-processen in de cloud.

AWS ML Stack heeft drie lagen. In de middelste laag is SageMaker, waarmee ontwikkelaars, datawetenschappers en ML-engineers ML-modellen op schaal kunnen bouwen, trainen en implementeren. Het verwijdert de complexiteit van elke stap van de ML-workflow, zodat u uw ML-use-cases gemakkelijker kunt implementeren. Dit omvat alles van voorspellend onderhoud tot computervisie om klantgedrag te voorspellen. Klanten bereiken met SageMaker een tot 10 keer hogere productiviteit van datawetenschappers.

Apache Cassandra is een populaire keuze voor leesintensieve use-cases met ongestructureerde of semi-gestructureerde gegevens. Een populair bedrijf voor voedselbezorging schat bijvoorbeeld de bezorgtijd en een retailklant kan vaak volharden in het gebruik van productcatalogusinformatie in de Apache Cassandra-database. Amazon-sleutelruimten is een schaalbare, zeer beschikbare en beheerde serverloze met Apache Cassandra compatibele databaseservice. U hoeft geen servers in te richten, te patchen of te beheren, en u hoeft geen software te installeren, onderhouden of gebruiken. Tabellen kunnen automatisch omhoog en omlaag worden geschaald en u betaalt alleen voor de resources die u gebruikt. Met Amazon Keyspaces kunt u uw Cassandra-workloads op AWS uitvoeren met dezelfde Cassandra-toepassingscode en ontwikkelaarstools die u vandaag de dag gebruikt.

SageMaker biedt een suite van ingebouwde algoritmen om datawetenschappers en ML-beoefenaars te helpen snel aan de slag te gaan met het trainen en implementeren van ML-modellen. In dit bericht laten we u zien hoe een retailklant de aankoopgeschiedenis van klanten in de Keyspaces-database kan gebruiken en verschillende klantsegmenten kan targeten voor marketingcampagnes.

K-betekent is een niet-gesuperviseerd leeralgoritme. Het probeert discrete groeperingen binnen gegevens te vinden, waarbij leden van een groep zo veel mogelijk op elkaar lijken en zo veel mogelijk verschillen van leden van andere groepen. U definieert de kenmerken die u door het algoritme wilt laten gebruiken om de overeenkomst te bepalen. SageMaker gebruikt een aangepaste versie van de web-schaal k-betekent clustering algoritme. In vergelijking met de originele versie van het algoritme is de versie die door SageMaker wordt gebruikt nauwkeuriger. Net als het originele algoritme schaalt het echter naar enorme datasets en levert het verbeteringen in de trainingstijd op.

Overzicht oplossingen

De instructies gaan ervan uit dat u SageMaker Studio zou gebruiken om de code uit te voeren. De bijbehorende code is gedeeld op AWS-voorbeeld GitHub. Door de instructies in het lab te volgen, kunt u het volgende doen:

• Installeer de nodige afhankelijkheden.
• Maak verbinding met Amazon Keyspaces, maak een tabel en neem voorbeeldgegevens op.
• Bouw een classificatie-ML-model met behulp van de gegevens in Amazon Keyspaces.
• Modelresultaten verkennen.
• Ruim nieuw gemaakte bronnen op.

Eenmaal voltooid, heb je SageMaker geïntegreerd met Amazon Keyspaces om ML-modellen te trainen, zoals weergegeven in de volgende afbeelding.

Nu kun je de volgen stapsgewijze instructies in dit bericht om onbewerkte gegevens op te nemen die zijn opgeslagen in Amazon Keyspaces met behulp van SageMaker en de gegevens die zo zijn opgehaald voor ML-verwerking.

Voorwaarden

Navigeer eerst naar SageMaker.

Als dit de eerste keer is dat u SageMaker gebruikt, selecteert u Start nu.

Selecteer vervolgens SageMaker-domein instellen.

Maak vervolgens een nieuw gebruikersprofiel aan met Naam – sagemakergebruikerEn Select Maak een nieuwe rol in de Standaard uitvoeringsrol onderafdeling.

Selecteer vervolgens in het scherm dat verschijnt, willekeurig Eenvoudige opslagservice van Amazon (Amazon S3) bucket en selecteer Rol maken.

Deze rol wordt in de volgende stappen gebruikt om SageMaker toegang te geven tot Keyspaces Table met tijdelijke referenties van de rol. Dit elimineert de noodzaak om een ​​gebruikersnaam en wachtwoord op te slaan in de notebook.

Haal vervolgens de rol op die is gekoppeld aan de sagemakergebruiker die in de vorige stap is gemaakt vanuit de samenvattingssectie.

Navigeer vervolgens naar de AWS-console en kijk omhoog AWS identiteits- en toegangsbeheer (IAM). Navigeer binnen IAM naar Rollen. Zoek binnen Rollen naar de uitvoeringsrol die in de vorige stap is geïdentificeerd.

Selecteer vervolgens de rol die in de vorige stap is geïdentificeerd en selecteer Machtigingen toevoegen. Selecteer in de vervolgkeuzelijst die verschijnt Inline-beleid maken. Met SageMaker kunt u een gedetailleerd toegangsniveau bieden dat beperkt welke acties een gebruiker/toepassing kan uitvoeren op basis van zakelijke vereisten.

Selecteer vervolgens het JSON-tabblad en kopieer het beleid uit het gedeelte Opmerking van Github pagina. Met dit beleid kan de SageMaker-notebook verbinding maken met Keyspaces en gegevens ophalen voor verdere verwerking.

Selecteer vervolgens opnieuw machtigingen toevoegen en in de vervolgkeuzelijst en selecteer Beleid bijvoegen.

Zoek het AmazonKeyspacesFullAccess-beleid op, schakel het selectievakje naast het overeenkomende resultaat in en selecteer Beleid bijvoegen.

Controleer of de sectie machtigingenbeleid bevat: AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, evenals het nieuw toegevoegde inline-beleid.

Navigeer vervolgens naar SageMaker Studio met behulp van de AWS-console en selecteer SageMaker Studio. Eenmaal daar, selecteer App starten en selecteer Studio.

Overzicht van notebooks

De beste manier om verbinding te maken met Keyspaces vanuit SageMaker Notebook is door gebruik te maken van: AWS Signature Versie 4-proces (SigV4) gebaseerde Tijdelijke referenties voor authenticatie. In dit scenario hoeven we GEEN Keyspaces-referenties te genereren of op te slaan en kunnen we de referenties gebruiken om te verifiëren met de SigV4-plug-in. Tijdelijke beveiligingsreferenties bestaan ​​uit een toegangssleutel-ID en een geheime toegangssleutel. Ze bevatten echter ook een beveiligingstoken dat aangeeft wanneer de referenties verlopen. In dit bericht maken we een IAM-rol en genereren we tijdelijke beveiligingsreferenties.

Eerst installeren we een stuurprogramma (cassandra-sigv4). Met dit stuurprogramma kunt u authenticatie-informatie toevoegen aan uw API-verzoeken met behulp van het AWS Signature Version 4-proces (SigV4). Met behulp van de plug-in kunt u gebruikers en applicaties voorzien van inloggegevens voor de korte termijn om toegang te krijgen tot Amazon Keyspaces (voor Apache Cassandra) met behulp van IAM-gebruikers en -rollen. Hierna importeert u een vereist certificaat samen met aanvullende pakketafhankelijkheden. Uiteindelijk laat je de notebook de rol op zich nemen om met Keyspaces te praten.

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

Maak vervolgens verbinding met Amazon Keyspaces en lees systeemgegevens van Keyspaces in Pandas DataFrame om de verbinding te valideren.

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

Bereid vervolgens de gegevens voor op training op de onbewerkte dataset. Gebruik in het python-notebook dat aan dit bericht is gekoppeld een winkelgegevensset die is gedownload van hier, en verwerken. Ons bedrijfsdoel gezien de dataset is om de klanten te clusteren met behulp van een specifieke metrische oproep RFM. Het RFM-model is gebaseerd op drie kwantitatieve factoren:

• Recentheid: hoe recent een klant een aankoop heeft gedaan.
• Frequentie: hoe vaak een klant een aankoop doet.
• Monetaire waarde: hoeveel geld een klant uitgeeft aan aankopen.

RFM-analyse rangschikt een klant numeriek in elk van deze drie categorieën, meestal op een schaal van 1 tot 5 (hoe hoger het getal, hoe beter het resultaat). De "beste" klant zou in elke categorie een topscore krijgen. We gebruiken de op Quantile gebaseerde discretisatiefunctie (qcut) van panda's. Het helpt om waarden te discretiseren in emmers van gelijke grootte op basis van of op basis van voorbeeldkwantielen.

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

In dit voorbeeld gebruiken we CQL om records uit de Keyspace-tabel te lezen. In sommige ML-gebruiksgevallen moet u mogelijk dezelfde gegevens meerdere keren uit dezelfde Keyspaces-tabel lezen. In dit geval raden we u aan uw gegevens op te slaan in een Amazon S3-bucket om extra kosten te voorkomen kostens lezen van Amazon Keyspaces. Afhankelijk van uw scenario, kunt u ook gebruik maken van Amazon EMR naar inslikken een zeer groot Amazon S3-bestand in 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())

Vervolgens trainen we een ML-model met behulp van het KMeans-algoritme en zorgen we ervoor dat de clusters worden gemaakt. In dit specifieke scenario zou je zien dat de gemaakte clusters worden afgedrukt, wat aangeeft dat de klanten in de onbewerkte dataset zijn gegroepeerd op basis van verschillende attributen in de dataset. Deze clusterinformatie kan worden gebruikt voor gerichte marketingcampagnes.

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

(Optioneel) Vervolgens slaan we de klantsegmenten die zijn geïdentificeerd door het ML-model terug naar een Amazon Keyspaces-tabel voor gerichte marketing. Een batchtaak zou deze gegevens kunnen lezen en gerichte campagnes kunnen voeren naar klanten in specifieke segmenten.

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

Eindelijk, wij ruim de middelen op gemaakt tijdens deze zelfstudie om extra kosten te voorkomen.

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

Het kan enkele seconden tot een minuut duren om het verwijderen van keyspace en tabellen te voltooien. Wanneer u een sleutelruimte verwijdert, worden de sleutelruimte en alle tabellen verwijderd en worden er geen kosten meer aan verbonden.

Conclusie

Dit bericht liet je zien hoe je klantgegevens van Amazon Keyspaces in SageMaker kunt opnemen en een clustermodel kunt trainen waarmee je klanten kunt segmenteren. U kunt deze informatie gebruiken voor gerichte marketing, waardoor uw bedrijfs-KPI aanzienlijk verbetert. Raadpleeg de volgende bronnen voor meer informatie over Amazon Keyspaces:

• Machine learning-modellen trainen met Amazon Keyspaces als gegevensbron (SageMaker-notitieboekje)
• Maak verbinding met Amazon Keyspaces vanaf uw bureaublad met behulp van IntelliJ, PyCharm of DataGrip IDE's
• CQL-taalreferentie voor Amazon Keyspaces (voor Apache Cassandra)
• Hoe u de opdrachtregeltoegang tot Amazon Keyspaces (voor Apache Cassandra) instelt met behulp van de nieuwe Docker-image van de ontwikkelaarstoolkit
• Identiteits- en toegangsbeheer voor Amazon Keyspaces (voor Apache Cassandra)
• Verbinding maken met Amazon Keyspaces vanuit SageMaker met servicespecifieke referenties
• Recentheid, frequentie, geldwaarde (RFM)
• Kaggle-codereferentie

Over de auteurs

Vadim Lyakhovitsj is Senior Solutions Architect bij AWS in de San Francisco Bay Area en helpt klanten bij de migratie naar AWS. Hij werkt samen met organisaties variërend van grote ondernemingen tot kleine startups om hun innovaties te ondersteunen. Hij helpt klanten ook bij het ontwerpen van schaalbare, veilige en kosteneffectieve oplossingen op AWS.

Deel Patel is Solutions Architect bij AWS in de San Francisco Bay Area. Parth begeleidt klanten om hun reis naar de cloud te versnellen en hen te helpen met het succesvol adopteren van AWS-cloud. Hij richt zich op ML en Applicatie Modernisering.

Ram Pathangi is Solutions Architect bij AWS in de San Francisco Bay Area. Hij heeft klanten in de sectoren landbouw, verzekeringen, bankwezen, detailhandel, gezondheidszorg en levenswetenschappen, gastvrijheid en hi-tech geholpen om hun bedrijf succesvol te runnen op de AWS-cloud. Hij is gespecialiseerd in Databases, Analytics en ML.

• Coinsmart. Europa's beste Bitcoin- en crypto-uitwisseling.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. GRATIS TOEGANG.
• CryptoHawk. Altcoin-radar. Gratis proefversie.
• Bron: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/