Trainieren Sie Modelle für maschinelles Lernen mit Amazon Keyspaces als Datenquelle

Viele Anwendungen, die für die Wartung von Industrieanlagen, die Handelsüberwachung, das Flottenmanagement und die Routenoptimierung gedacht sind, werden mit Open-Source-Cassandra-APIs und -Treibern erstellt, um Daten mit hoher Geschwindigkeit und geringer Latenz zu verarbeiten. Die Verwaltung von Cassandra-Tabellen selbst kann zeitaufwändig und teuer sein. Amazon Keyspaces (für Apache Cassandra) können Sie Cassandra-Tabellen in der AWS Cloud einrichten, sichern und skalieren, ohne zusätzliche Infrastruktur verwalten zu müssen.

In diesem Beitrag führen wir Sie durch die AWS-Services im Zusammenhang mit dem Training von Modellen für maschinelles Lernen (ML) unter Verwendung von Amazon Keyspaces auf hohem Niveau und bieten Schritt-für-Schritt-Anweisungen zum Erfassen von Daten aus Amazon Keyspaces Amazon Sage Maker und Trainieren eines Modells, das für einen bestimmten Anwendungsfall der Kundensegmentierung verwendet werden kann.

AWS bietet mehrere Services, die Unternehmen bei der Implementierung von ML-Prozessen in der Cloud unterstützen.

AWS ML Stack hat drei Schichten. In der mittleren Schicht ist SageMaker, das Entwicklern, Data Scientists und ML-Ingenieuren die Möglichkeit bietet, ML-Modelle in großem Maßstab zu erstellen, zu trainieren und bereitzustellen. Es beseitigt die Komplexität aus jedem Schritt des ML-Workflows, sodass Sie Ihre ML-Anwendungsfälle einfacher bereitstellen können. Dies umfasst alles von vorausschauender Wartung bis hin zu Computer Vision zur Vorhersage des Kundenverhaltens. Kunden erreichen mit SageMaker eine bis zu 10-fache Steigerung der Produktivität von Datenwissenschaftlern.

Apache Cassandra ist eine beliebte Wahl für leselastige Anwendungsfälle mit unstrukturierten oder halbstrukturierten Daten. Beispielsweise schätzt ein beliebtes Lebensmittellieferunternehmen die Lieferzeit, und ein Einzelhandelskunde könnte häufig darauf bestehen, Produktkataloginformationen in der Apache Cassandra-Datenbank zu verwenden. Amazon-Schlüsselräume ist ein skalierbarer, hochverfügbarer und verwalteter serverloser Apache Cassandra-kompatibler Datenbankdienst. Sie müssen keine Server bereitstellen, patchen oder verwalten, und Sie müssen keine Software installieren, warten oder betreiben. Tabellen können automatisch hoch- und herunterskaliert werden, und Sie zahlen nur für die Ressourcen, die Sie verwenden. Mit Amazon Keyspaces können Sie Ihre Cassandra-Workloads auf AWS mit demselben Cassandra-Anwendungscode und denselben Entwicklertools ausführen, die Sie heute verwenden.

SageMaker bietet eine Reihe von eingebaute Algorithmen um Datenwissenschaftlern und ML-Praktikern dabei zu helfen, schnell mit dem Training und der Bereitstellung von ML-Modellen zu beginnen. In diesem Beitrag zeigen wir Ihnen, wie ein Einzelhandelskunde die Kundenkaufhistorie in der Keyspaces-Datenbank verwenden und verschiedene Kundensegmente für Marketingkampagnen ansprechen kann.

K-Mittel ist ein unüberwachter Lernalgorithmus. Es versucht, diskrete Gruppierungen innerhalb von Daten zu finden, bei denen Mitglieder einer Gruppe einander so ähnlich wie möglich und sich so unterschiedlich wie möglich von Mitgliedern anderer Gruppen sind. Sie definieren die Attribute, die der Algorithmus verwenden soll, um die Ähnlichkeit zu bestimmen. SageMaker verwendet eine modifizierte Version des k-Means-Clustering-Algorithmus im Webmaßstab. Im Vergleich zur ursprünglichen Version des Algorithmus ist die von SageMaker verwendete Version genauer. Wie der ursprüngliche Algorithmus skaliert er jedoch auf riesige Datensätze und bietet Verbesserungen bei der Trainingszeit.

Lösungsüberblick

Die Anweisungen gehen davon aus, dass Sie SageMaker Studio verwenden würden, um den Code auszuführen. Der zugehörige Code wurde am geteilt AWS-Beispiel-GitHub. Wenn Sie den Anweisungen im Labor folgen, können Sie Folgendes tun:

• Installieren Sie die erforderlichen Abhängigkeiten.
• Verbinden Sie sich mit Amazon Keyspaces, erstellen Sie eine Tabelle und nehmen Sie Beispieldaten auf.
• Erstellen Sie ein ML-Klassifizierungsmodell mit den Daten in Amazon Keyspaces.
• Untersuchen Sie Modellergebnisse.
• Bereinigen Sie neu erstellte Ressourcen.

Sobald Sie fertig sind, haben Sie SageMaker mit Amazon Keyspaces integriert, um ML-Modelle zu trainieren, wie in der folgenden Abbildung gezeigt.

Jetzt können Sie dem folgen Schritt für Schritt Anweisungen in diesem Beitrag, um mit SageMaker in Amazon Keyspaces gespeicherte Rohdaten und die so abgerufenen Daten für die ML-Verarbeitung aufzunehmen.

Voraussetzungen:

Navigieren Sie zunächst zu SageMaker.

Wählen Sie als Nächstes, wenn Sie SageMaker zum ersten Mal verwenden Loslegen .

Als nächstes wählen Sie Richten Sie die SageMaker-Domäne ein.

Als nächstes erstellen Sie ein neues Benutzerprofil mit Name – sagemakeruser, und wählen Sie Neue Rolle erstellen der Standardausführungsrolle Unterabschnitt.

Wählen Sie als Nächstes auf dem angezeigten Bildschirm eine beliebige aus Einfacher Amazon-Speicherdienst (Amazon S3) Bucket und wählen Sie Rolle erstellen aus.

Diese Rolle wird in den folgenden Schritten verwendet, um SageMaker den Zugriff auf die Keyspaces-Tabelle mit temporären Anmeldeinformationen aus der Rolle zu ermöglichen. Dadurch entfällt die Notwendigkeit, einen Benutzernamen und ein Passwort im Notebook zu speichern.

Rufen Sie als Nächstes die Rolle ab, die der zugeordnet ist sagemakeruser die im vorherigen Schritt aus dem Zusammenfassungsabschnitt erstellt wurde.

Navigieren Sie dann zum AWS-Konsole und schau nach oben AWS Identity and Access Management (IAM). Navigieren Sie in IAM zu Rollen. Suchen Sie in Rollen nach der im vorherigen Schritt identifizierten Ausführungsrolle.

Wählen Sie als Nächstes die im vorherigen Schritt identifizierte Rolle und dann Berechtigungen hinzufügen aus. Wählen Sie in der angezeigten Dropdown-Liste Inline-Richtlinie erstellen aus. Mit SageMaker können Sie eine granulare Zugriffsebene bereitstellen, die einschränkt, welche Aktionen ein Benutzer/eine Anwendung je nach Geschäftsanforderungen ausführen kann.

Wählen Sie dann die Registerkarte „JSON“ aus und kopieren Sie die Richtlinie aus dem Abschnitt „Hinweis“ von Github Seite. Diese Richtlinie ermöglicht es dem SageMaker-Notebook, eine Verbindung zu Keyspaces herzustellen und Daten zur weiteren Verarbeitung abzurufen.

Wählen Sie dann erneut Berechtigungen hinzufügen und aus der Dropdown-Liste und dann Richtlinie anhängen aus.

Suchen Sie nach der AmazonKeyspacesFullAccess-Richtlinie, aktivieren Sie das Kontrollkästchen neben dem übereinstimmenden Ergebnis und wählen Sie Richtlinien anhängen aus.

Stellen Sie sicher, dass der Abschnitt Berechtigungsrichtlinien enthält AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, sowie die neu hinzugefügte Inline-Richtlinie.

Navigieren Sie als Nächstes mithilfe der AWS-Konsole zu SageMaker Studio und wählen Sie SageMaker Studio aus. Wählen Sie dort App starten und dann Studio.

Notebook-Komplettlösung

Die bevorzugte Methode zum Herstellen einer Verbindung mit Keyspaces von SageMaker Notebook ist die Verwendung von AWS Signature Version 4-Prozess (SigV4) basierend Temporäre Anmeldeinformationen zur Authentifizierung. In diesem Szenario müssen wir KEINE Schlüsselraum-Anmeldeinformationen generieren oder speichern und können die Anmeldeinformationen zur Authentifizierung mit dem SigV4-Plugin verwenden. Temporäre Sicherheitsberechtigungsnachweise bestehen aus einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel. Sie enthalten jedoch auch ein Sicherheitstoken, das angibt, wann die Anmeldeinformationen ablaufen. In diesem Beitrag erstellen wir eine IAM-Rolle und generieren temporäre Sicherheitsanmeldeinformationen.

Zuerst installieren wir einen Treiber (cassandra-sigv4). Dieser Treiber ermöglicht Ihnen das Hinzufügen von Authentifizierungsinformationen zu Ihren API-Anforderungen mithilfe des AWS Signature Version 4-Prozesses (SigV4). Mit dem Plug-in können Sie Benutzern und Anwendungen kurzfristige Anmeldeinformationen für den Zugriff auf Amazon Keyspaces (für Apache Cassandra) mithilfe von IAM-Benutzern und -Rollen bereitstellen. Anschließend importieren Sie ein erforderliches Zertifikat zusammen mit zusätzlichen Paketabhängigkeiten. Am Ende erlauben Sie dem Notebook, die Rolle zu übernehmen, mit Keyspaces zu kommunizieren.

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

Stellen Sie als Nächstes eine Verbindung zu Amazon Keyspaces her und lesen Sie Systemdaten aus Keyspaces in Pandas DataFrame, um die Verbindung zu validieren.

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

Als nächstes bereiten Sie die Daten für das Training auf dem Rohdatensatz vor. Verwenden Sie in dem mit diesem Beitrag verknüpften Python-Notebook einen Einzelhandelsdatensatz, der von heruntergeladen wurde hier, und verarbeiten Sie es. Angesichts des Datensatzes besteht unser Geschäftsziel darin, die Kunden mithilfe einer bestimmten Metrik namens RFM zu gruppieren. Das RFM-Modell basiert auf drei quantitativen Faktoren:

• Aktualität: Wie lange ein Kunde einen Kauf getätigt hat.
• Häufigkeit: Wie oft ein Kunde einen Kauf tätigt.
• Geldwert: Wie viel Geld ein Kunde für Einkäufe ausgibt.

Die RFM-Analyse stuft einen Kunden in jeder dieser drei Kategorien numerisch ein, im Allgemeinen auf einer Skala von 1 bis 5 (je höher die Zahl, desto besser das Ergebnis). Der „beste“ Kunde erhält in jeder Kategorie eine Höchstpunktzahl. Wir verwenden die quantilbasierte Diskretisierungsfunktion von Pandas (qcut). Es hilft bei der Diskretisierung von Werten in gleich große Buckets basierend auf oder basierend auf Stichprobenquantilen.

# 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 diesem Beispiel verwenden wir CQL, um Datensätze aus der Keyspace-Tabelle zu lesen. In einigen ML-Anwendungsfällen müssen Sie möglicherweise dieselben Daten mehrmals aus derselben Keyspaces-Tabelle lesen. In diesem Fall empfehlen wir Ihnen, Ihre Daten in einem Amazon S3-Bucket zu speichern, um zusätzliche Kosten zu vermeiden kostens Lesen von Amazon Keyspaces. Abhängig von Ihrem Szenario können Sie auch verwenden Amazon EMR zu Ingest eine sehr große Amazon S3-Datei 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())

Als nächstes trainieren wir ein ML-Modell mit dem KMeans-Algorithmus und stellen sicher, dass die Cluster erstellt werden. In diesem speziellen Szenario würden Sie sehen, dass die erstellten Cluster gedruckt werden, was zeigt, dass die Kunden im Rohdatensatz basierend auf verschiedenen Attributen im Datensatz gruppiert wurden. Diese Clusterinformationen können für gezielte Marketingkampagnen verwendet werden.

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

(Optional) Als Nächstes speichern wir die vom ML-Modell identifizierten Kundensegmente für gezieltes Marketing wieder in einer Amazon Keyspaces-Tabelle. Ein Batch-Job könnte diese Daten lesen und gezielte Kampagnen für Kunden in bestimmten Segmenten durchführen.

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

Endlich haben wir die Ressourcen bereinigen während dieses Tutorials erstellt, um zusätzliche Kosten zu vermeiden.

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

Es kann einige Sekunden bis zu einer Minute dauern, bis der Schlüsselraum und die Tabellen gelöscht sind. Wenn Sie einen Schlüsselraum löschen, werden der Schlüsselraum und alle seine Tabellen gelöscht und es fallen keine Gebühren mehr an.

Zusammenfassung

Dieser Beitrag hat Ihnen gezeigt, wie Sie Kundendaten aus Amazon Keyspaces in SageMaker aufnehmen und ein Clustering-Modell trainieren, mit dem Sie Kunden segmentieren können. Sie können diese Informationen für gezieltes Marketing verwenden und so Ihre Geschäftskennzahlen erheblich verbessern. Weitere Informationen zu Amazon Keyspaces finden Sie in den folgenden Ressourcen:

• Trainieren Sie Modelle für maschinelles Lernen mit Amazon Keyspaces als Datenquelle (SageMaker-Notizbuch)
• Stellen Sie über IntelliJ-, PyCharm- oder DataGrip-IDEs von Ihrem Desktop aus eine Verbindung zu Amazon Keyspaces her
• CQL-Sprachreferenz für Amazon Keyspaces (für Apache Cassandra)
• So richten Sie den Befehlszeilenzugriff auf Amazon Keyspaces (für Apache Cassandra) mithilfe des Docker-Images des neuen Entwickler-Toolkits ein
• Identitäts- und Zugriffsverwaltung für Amazon Keyspaces (für Apache Cassandra)
• Verbinden mit Amazon Keyspaces von SageMaker mit dienstspezifische Anmeldeinformationen
• Aktualität, Häufigkeit, Geldwert (RFM)
• Kaggle-Code-Referenz

Über die Autoren

Wadim Ljachowitsch ist Senior Solutions Architect bei AWS in der San Francisco Bay Area und hilft Kunden bei der Migration zu AWS. Er arbeitet mit Organisationen zusammen, die von großen Unternehmen bis hin zu kleinen Startups reichen, um ihre Innovationen zu unterstützen. Er hilft Kunden auch dabei, skalierbare, sichere und kostengünstige Lösungen auf AWS zu entwickeln.

Teil Patel ist Lösungsarchitekt bei AWS in der San Francisco Bay Area. Parth leitet Kunden an, ihren Weg in die Cloud zu beschleunigen und hilft ihnen, die AWS Cloud erfolgreich einzuführen. Er konzentriert sich auf ML und Anwendungsmodernisierung.

Ram Pathangi ist Lösungsarchitekt bei AWS in der San Francisco Bay Area. Er hat Kunden in den Branchen Landwirtschaft, Versicherungen, Banken, Einzelhandel, Gesundheitswesen und Biowissenschaften, Gastgewerbe und Hi-Tech dabei geholfen, ihr Geschäft erfolgreich in der AWS-Cloud zu führen. Er ist spezialisiert auf Datenbanken, Analytics und ML.

• Coinsmart. Europas beste Bitcoin- und Krypto-Börse.
• Platoblockkette. Web3-Metaverse-Intelligenz. Wissen verstärkt. DEN FREIEN ZUGANG.
• CryptoHawk. Altcoin-Radar. Kostenlose Testphase.
• Quelle: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/