Former des modèles d'apprentissage automatique en utilisant Amazon Keyspaces comme source de données

De nombreuses applications destinées à la maintenance des équipements industriels, à la surveillance du commerce, à la gestion de flotte et à l'optimisation des itinéraires sont conçues à l'aide d'API et de pilotes Cassandra open source pour traiter les données à des vitesses élevées et à faible latence. Gérer vous-même les tables Cassandra peut prendre du temps et coûter cher. Espaces de clés Amazon (pour Apache Cassandra) vous permet de configurer, de sécuriser et de mettre à l'échelle des tables Cassandra dans le cloud AWS sans gérer d'infrastructure supplémentaire.

Dans cet article, nous vous présenterons les services AWS liés à la formation de modèles d'apprentissage automatique (ML) à l'aide d'Amazon Keyspaces à un niveau élevé, et vous fournirons des instructions étape par étape pour ingérer des données d'Amazon Keyspaces dans Amazon Sage Maker et la formation d'un modèle qui peut être utilisé pour un cas d'utilisation de segmentation client spécifique.

AWS propose plusieurs services pour aider les entreprises à mettre en œuvre des processus ML dans le cloud.

AWS ML Stack comporte trois couches. Dans la couche intermédiaire se trouve SageMaker, qui offre aux développeurs, aux data scientists et aux ingénieurs ML la possibilité de créer, d'entraîner et de déployer des modèles ML à grande échelle. Il supprime la complexité de chaque étape du flux de travail ML afin que vous puissiez déployer plus facilement vos cas d'utilisation ML. Cela inclut tout, de la maintenance prédictive à la vision par ordinateur pour prédire les comportements des clients. Les clients obtiennent jusqu'à 10 fois plus de productivité des data scientists avec SageMaker.

Apache Cassandra est un choix populaire pour les cas d'utilisation à lecture intensive avec des données non structurées ou semi-structurées. Par exemple, une entreprise de livraison de nourriture populaire estime l'heure de livraison et un client de vente au détail pourrait utiliser fréquemment les informations du catalogue de produits dans la base de données Apache Cassandra. Espaces de clés Amazon est un service de base de données évolutif, hautement disponible et géré, compatible avec Apache Cassandra. Vous n'avez pas besoin de provisionner, de corriger ou de gérer des serveurs, et vous n'avez pas besoin d'installer, de maintenir ou d'exploiter des logiciels. Les tableaux peuvent augmenter et diminuer automatiquement, et vous ne payez que pour les ressources que vous utilisez. Amazon Keyspaces vous permet d'exécuter vos charges de travail Cassandra sur AWS en utilisant le même code d'application Cassandra et les mêmes outils de développement que vous utilisez aujourd'hui.

SageMaker fournit une suite de algorithmes intégrés pour aider les scientifiques des données et les praticiens du ML à commencer à former et à déployer rapidement des modèles de ML. Dans cet article, nous vous montrerons comment un client de détail peut utiliser l'historique des achats des clients dans la base de données Keyspaces et cibler différents segments de clientèle pour les campagnes marketing.

K-signifie est un algorithme d'apprentissage non supervisé. Il tente de trouver des groupements discrets dans les données, où les membres d'un groupe sont aussi similaires que possible les uns aux autres et aussi différents que possible des membres d'autres groupes. Vous définissez les attributs que vous souhaitez que l'algorithme utilise pour déterminer la similarité. SageMaker utilise une version modifiée du algorithme de clustering k-means à l'échelle du web. Par rapport à la version originale de l'algorithme, la version utilisée par SageMaker est plus précise. Cependant, comme l'algorithme d'origine, il s'adapte à des ensembles de données volumineux et améliore le temps de formation.

Vue d'ensemble de la solution

Les instructions supposent que vous utiliseriez SageMaker Studio pour exécuter le code. Le code associé a été partagé sur Exemple AWS GitHub. En suivant les instructions de l'atelier, vous pouvez effectuer les opérations suivantes :

• Installez les dépendances nécessaires.
• Connectez-vous à Amazon Keyspaces, créez une table et ingérez des exemples de données.
• Créez un modèle ML de classification à l'aide des données d'Amazon Keyspaces.
• Explorez les résultats du modèle.
• Nettoyer les ressources nouvellement créées.

Une fois terminé, vous aurez intégré SageMaker à Amazon Keyspaces pour former des modèles ML, comme illustré dans l'image suivante.

Maintenant, vous pouvez suivre le instructions pas à pas dans cet article pour ingérer des données brutes stockées dans Amazon Keyspaces à l'aide de SageMaker et les données ainsi récupérées pour le traitement ML.

Pré-requis

Tout d'abord, accédez à SageMaker.

Ensuite, si c'est la première fois que vous utilisez SageMaker, sélectionnez Débuter.

Ensuite, sélectionnez Configurer le domaine SageMaker.

Ensuite, créez un nouveau profil utilisateur avec Nom - utilisateur de sagemaker, et sélectionnez Créer un nouveau rôle dans l' Rôle d'exécution par défaut sous-section.

Ensuite, dans l'écran qui apparaît, sélectionnez n'importe quel Service de stockage simple Amazon (Amazon S3) bucket, puis sélectionnez Créer un rôle.

Ce rôle sera utilisé dans les étapes suivantes pour permettre à SageMaker d'accéder à la table des espaces de clés à l'aide des informations d'identification temporaires du rôle. Cela élimine le besoin de stocker un nom d'utilisateur et un mot de passe dans le bloc-notes.

Ensuite, récupérez le rôle associé au utilisateur de sagemaker qui a été créé à l'étape précédente à partir de la section récapitulative.

Ensuite, naviguez jusqu'au AWS Console et regarde vers le haut Gestion des identités et des accès AWS (IAM). Dans IAM, accédez à Rôles. Dans Rôles, recherchez le rôle d'exécution identifié à l'étape précédente.

Ensuite, sélectionnez le rôle identifié à l'étape précédente et sélectionnez Ajouter des autorisations. Dans la liste déroulante qui s'affiche, sélectionnez Créer une stratégie en ligne. SageMaker vous permet de fournir un niveau d'accès granulaire qui limite les actions qu'un utilisateur/une application peut effectuer en fonction des besoins de l'entreprise.

Ensuite, sélectionnez l'onglet JSON et copiez la politique de la section Note de Github page. Cette stratégie permet au bloc-notes SageMaker de se connecter à Keyspaces et de récupérer des données pour un traitement ultérieur.

Ensuite, sélectionnez à nouveau Ajouter des autorisations et dans le menu déroulant, sélectionnez Attacher une stratégie.

Recherchez la stratégie AmazonKeyspacesFullAccess et cochez la case en regard du résultat correspondant, puis sélectionnez Attach Policies.

Vérifiez que la section des stratégies d'autorisations inclut AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, ainsi que la stratégie en ligne nouvellement ajoutée.

Ensuite, accédez à SageMaker Studio à l'aide de la console AWS et sélectionnez SageMaker Studio. Une fois là-bas, sélectionnez Lancer l'application et sélectionnez Studio.

Procédure pas à pas pour ordinateur portable

La meilleure façon de se connecter à Keyspaces à partir de SageMaker Notebook est d'utiliser Processus AWS Signature Version 4 (SigV4) basé Compétences temporaires pour l'authentification. Dans ce scénario, nous n'avons PAS besoin de générer ou de stocker les informations d'identification Keyspaces et pouvons utiliser les informations d'identification pour s'authentifier avec le plug-in SigV4. Les informations d'identification de sécurité temporaires consistent en un ID de clé d'accès et une clé d'accès secrète. Cependant, ils incluent également un jeton de sécurité qui indique quand les informations d'identification expirent. Dans cet article, nous allons créer un rôle IAM et générer des informations d'identification de sécurité temporaires.

Tout d'abord, nous installons un pilote (cassandra-sigv4). Ce pilote vous permet d'ajouter des informations d'authentification à vos demandes d'API à l'aide du processus AWS Signature Version 4 (SigV4). À l'aide du plug-in, vous pouvez fournir aux utilisateurs et aux applications des informations d'identification à court terme pour accéder à Amazon Keyspaces (pour Apache Cassandra) à l'aide d'utilisateurs et de rôles IAM. Ensuite, vous importerez un certificat requis ainsi que des dépendances de package supplémentaires. En fin de compte, vous autoriserez le bloc-notes à assumer le rôle de parler à 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)

Ensuite, connectez-vous à Amazon Keyspaces et lisez les données système de Keyspaces dans Pandas DataFrame pour valider la connexion.

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

Ensuite, préparez les données pour la formation sur l'ensemble de données brutes. Dans le bloc-notes Python associé à cet article, utilisez un ensemble de données de vente au détail téléchargé à partir de ici, et traitez-le. Compte tenu de l'ensemble de données, notre objectif commercial est de regrouper les clients à l'aide d'un RFM d'appel métrique spécifique. Le modèle RFM est basé sur trois facteurs quantitatifs :

• Récence : depuis combien de temps un client a effectué un achat.
• Fréquence : la fréquence à laquelle un client effectue un achat.
• Valeur monétaire : combien d'argent un client dépense en achats.

L'analyse RFM classe numériquement un client dans chacune de ces trois catégories, généralement sur une échelle de 1 à 5 (plus le chiffre est élevé, meilleur est le résultat). Le « meilleur » client recevrait le meilleur score dans chaque catégorie. Nous utiliserons la fonction de discrétisation basée sur les quantiles (qcut) de pandas. Cela aidera à discrétiser les valeurs en seaux de taille égale basés ou basés sur des quantiles d'échantillon.

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

Dans cet exemple, nous utilisons CQL pour lire les enregistrements de la table Keyspace. Dans certains cas d'utilisation de ML, vous devrez peut-être lire plusieurs fois les mêmes données à partir de la même table Keyspaces. Dans ce cas, nous vous recommandons d'enregistrer vos données dans un compartiment Amazon S3 pour éviter des frais supplémentaires. sables moins coûteuxs lecture à partir d'Amazon Keyspaces. Selon votre scénario, vous pouvez également utiliser Amazon DME à ingérer un très gros fichier Amazon S3 dans 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())

Ensuite, nous formons un modèle ML à l'aide de l'algorithme KMeans et nous nous assurons que les clusters sont créés. Dans ce scénario particulier, vous verriez que les clusters créés sont imprimés, indiquant que les clients de l'ensemble de données brutes ont été regroupés en fonction de divers attributs de l'ensemble de données. Ces informations de cluster peuvent être utilisées pour des campagnes de marketing ciblées.

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

(Facultatif) Ensuite, nous enregistrons les segments de clientèle qui ont été identifiés par le modèle ML dans une table Amazon Keyspaces pour un marketing ciblé. Un travail par lots pourrait lire ces données et exécuter des campagnes ciblées sur des clients dans des segments spécifiques.

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

Enfin nous nettoyer les ressources créé au cours de ce didacticiel pour éviter des frais supplémentaires.

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

La suppression de l'espace de clés et des tables peut prendre de quelques secondes à une minute. Lorsque vous supprimez un espace de clés, l'espace de clés et toutes ses tables sont supprimés et vous arrêtez d'accumuler des frais à leur égard.

Conclusion

Cet article vous a montré comment ingérer les données client d'Amazon Keyspaces dans SageMaker et former un modèle de clustering qui vous a permis de segmenter les clients. Vous pouvez utiliser ces informations pour un marketing ciblé, améliorant ainsi considérablement le KPI de votre entreprise. Pour en savoir plus sur Amazon Keyspaces, consultez les ressources suivantes :

• Former des modèles d'apprentissage automatique en utilisant Amazon Keyspaces comme source de données (Cahier SageMaker)
• Connectez-vous à Amazon Keyspaces depuis votre bureau à l'aide des IDE IntelliJ, PyCharm ou DataGrip
• Référence du langage CQL pour Amazon Keyspaces (pour Apache Cassandra)
• Comment configurer l'accès en ligne de commande à Amazon Keyspaces (pour Apache Cassandra) à l'aide de la nouvelle image Docker du kit d'outils de développement
• Gestion des identités et des accès pour Amazon Keyspaces (pour Apache Cassandra)
• Connexion à Amazon Keyspaces depuis SageMaker avec informations d'identification spécifiques au service
• Récence, fréquence, valeur monétaire (RFM)
• Référence du code Kaggle

À propos des auteurs

Vadim Liakhovitch est architecte de solutions senior chez AWS dans la région de la baie de San Francisco, aidant les clients à migrer vers AWS. Il travaille avec des organisations allant des grandes entreprises aux petites startups pour soutenir leurs innovations. Il aide également les clients à concevoir des solutions évolutives, sécurisées et rentables sur AWS.

Parthe Patel est architecte de solutions chez AWS dans la région de la baie de San Francisco. Parth guide les clients pour accélérer leur parcours vers le cloud et les aide à adopter le cloud AWS avec succès. Il se concentre sur le ML et la modernisation des applications.

Ram Pathangi est architecte de solutions chez AWS dans la région de la baie de San Francisco. Il a aidé des clients des secteurs de l'agriculture, de l'assurance, de la banque, de la vente au détail, des soins de santé et des sciences de la vie, de l'hôtellerie et de la haute technologie à gérer leur entreprise avec succès sur le cloud AWS. Il est spécialisé dans les bases de données, l'analyse et le ML.

• Coinsmart. Le meilleur échange Bitcoin et Crypto d'Europe.
• Platoblockchain. Intelligence métaverse Web3. Connaissance amplifiée. ACCÈS LIBRE.
• CryptoHawk. Radar Altcoins. Essai gratuit.
• Source : https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/