Addestra modelli di machine learning utilizzando Amazon Keyspaces come origine dati

Molte applicazioni destinate alla manutenzione delle apparecchiature industriali, al monitoraggio del commercio, alla gestione della flotta e all'ottimizzazione dei percorsi sono realizzate utilizzando API e driver Cassandra open source per elaborare i dati ad alta velocità e bassa latenza. Gestire da soli i tavoli Cassandra può richiedere tempo e denaro. Amazon Keyspaces (per Apache Cassandra) ti consente di configurare, proteggere e ridimensionare le tabelle Cassandra nel cloud AWS senza gestire un'infrastruttura aggiuntiva.

In questo post, ti guideremo attraverso i servizi AWS relativi ai modelli di apprendimento automatico (ML) utilizzando Amazon Keyspaces ad alto livello e forniremo istruzioni dettagliate per l'acquisizione di dati da Amazon Keyspaces in Amazon Sage Maker e la formazione di un modello che può essere utilizzato per un caso d'uso specifico della segmentazione della clientela.

AWS offre diversi servizi per aiutare le aziende a implementare processi di machine learning nel cloud.

AWS ML Stack ha tre livelli. Nello strato intermedio c'è SageMaker, che offre a sviluppatori, data scientist e ingegneri ML la possibilità di creare, addestrare e distribuire modelli ML su larga scala. Rimuove la complessità da ogni passaggio del flusso di lavoro ML in modo da poter distribuire più facilmente i casi d'uso ML. Ciò include qualsiasi cosa, dalla manutenzione predittiva alla visione artificiale per prevedere i comportamenti dei clienti. I clienti ottengono un miglioramento fino a 10 volte della produttività dei data scientist con SageMaker.

Apache Cassandra è una scelta popolare per casi d'uso di lettura pesante con dati non strutturati o semistrutturati. Ad esempio, una nota azienda di consegna di cibo stima i tempi di consegna e un cliente al dettaglio potrebbe insistere frequentemente utilizzando le informazioni del catalogo prodotti nel database Apache Cassandra. Amazon Keyspace è un servizio di database compatibile con Apache Cassandra senza server scalabile, a disponibilità elevata e gestito. Non è necessario eseguire il provisioning, applicare patch o gestire i server e non è necessario installare, mantenere o utilizzare software. Le tabelle possono aumentare e diminuire automaticamente e paghi solo per le risorse che utilizzi. Amazon Keyspaces ti consente di eseguire i carichi di lavoro Cassandra su AWS utilizzando lo stesso codice dell'applicazione Cassandra e gli stessi strumenti di sviluppo che utilizzi oggi.

SageMaker fornisce una suite di algoritmi incorporati per aiutare i data scientist e i professionisti del machine learning a iniziare a formare e implementare rapidamente i modelli di machine learning. In questo post, ti mostreremo come un cliente al dettaglio può utilizzare la cronologia degli acquisti dei clienti nel database Keyspaces e indirizzare diversi segmenti di clienti per campagne di marketing.

K-significa è un algoritmo di apprendimento non supervisionato. Tenta di trovare raggruppamenti discreti all'interno dei dati, in cui i membri di un gruppo sono il più simili possibile tra loro e il più possibile diversi dai membri di altri gruppi. Definisci gli attributi che desideri vengano utilizzati dall'algoritmo per determinare la somiglianza. SageMaker utilizza una versione modificata di algoritmo di clustering k-means su scala web. Rispetto alla versione originale dell'algoritmo, la versione utilizzata da SageMaker è più accurata. Tuttavia, come l'algoritmo originale, si adatta a enormi set di dati e offre miglioramenti nei tempi di addestramento.

Panoramica della soluzione

Le istruzioni presuppongono che tu stia utilizzando SageMaker Studio per eseguire il codice. Il codice associato è stato condiviso su GitHub di esempio di AWS. Seguendo le istruzioni del laboratorio, è possibile eseguire le seguenti operazioni:

• Installa le dipendenze necessarie.
• Connettiti ad Amazon Keyspaces, crea una tabella e importa dati di esempio.
• Crea un modello ML di classificazione utilizzando i dati in Amazon Keyspaces.
• Esplora i risultati del modello.
• Pulisci le risorse appena create.

Una volta completato, avrai integrato SageMaker con Amazon Keyspaces per addestrare i modelli ML come mostrato nell'immagine seguente.

Ora puoi seguire il istruzioni passo-passo in questo post per importare i dati grezzi archiviati in Amazon Keyspaces utilizzando SageMaker e i dati così recuperati per l'elaborazione ML.

Prerequisiti

Innanzitutto, vai a SageMaker.

Quindi, se è la prima volta che utilizzi SageMaker, seleziona Inizia Ora.

Quindi, selezionare Configura il dominio SageMaker.

Quindi, crea un nuovo profilo utente con Nome – sagemakerusere selezionare Crea nuovo ruolo nel Ruolo di esecuzione predefinito sottosezione.

Quindi, nella schermata che si apre, seleziona qualsiasi Servizio di archiviazione semplice Amazon (Amazon S3) bucket e seleziona Crea ruolo.

Questo ruolo verrà utilizzato nei passaggi seguenti per consentire a SageMaker di accedere alla tabella degli spazi delle chiavi utilizzando le credenziali temporanee del ruolo. Ciò elimina la necessità di memorizzare un nome utente e una password nel notebook.

Successivamente, recupera il ruolo associato a sagemakeruser che è stato creato nel passaggio precedente dalla sezione di riepilogo.

Quindi, vai a Console AWS e guarda in alto AWS Identity and Access Management (IAM). All'interno di IAM, vai a Ruoli. All'interno dei ruoli, cerca il ruolo di esecuzione identificato nel passaggio precedente.

Quindi, seleziona il ruolo identificato nel passaggio precedente e seleziona Aggiungi autorizzazioni. Nel menu a discesa visualizzato, seleziona Crea criterio in linea. SageMaker consente di fornire un livello granulare di accesso che limita le azioni che un utente/applicazione può eseguire in base ai requisiti aziendali.

Quindi, seleziona la scheda JSON e copia la policy dalla sezione Note di Github pagina. Questa politica consente al notebook SageMaker di connettersi a Keyspace e recuperare i dati per un'ulteriore elaborazione.

Quindi, seleziona di nuovo Aggiungi autorizzazioni e dal menu a discesa, quindi seleziona Allega criterio.

Cerca la policy AmazonKeyspacesFullAccess, seleziona la casella di controllo accanto al risultato corrispondente e seleziona Allega policy.

Verifica che la sezione dei criteri di autorizzazione includa AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, nonché la politica in linea appena aggiunta.

Quindi, vai a SageMaker Studio utilizzando la Console AWS e seleziona SageMaker Studio. Una volta lì, seleziona Avvia app e seleziona Studio.

Guida dettagliata del taccuino

Il modo preferito per connettersi a Keyspace da SageMaker Notebook è utilizzando Processo di firma AWS versione 4 (SigV4) basato Credenziali temporanee per l'autenticazione. In questo scenario, NON è necessario generare o archiviare le credenziali degli spazi delle chiavi e possiamo utilizzare le credenziali per autenticarci con il plug-in SigV4. Le credenziali di sicurezza temporanee sono costituite da un ID chiave di accesso e da una chiave di accesso segreta. Tuttavia, includono anche un token di sicurezza che indica quando scadono le credenziali. In questo post creeremo un ruolo IAM e genereremo credenziali di sicurezza temporanee.

Innanzitutto, installiamo un driver (cassandra-sigv4). Questo driver ti consente di aggiungere informazioni di autenticazione alle tue richieste API utilizzando il processo AWS Signature Version 4 (SigV4). Utilizzando il plug-in, puoi fornire a utenti e applicazioni credenziali a breve termine per accedere ad Amazon Keyspaces (per Apache Cassandra) utilizzando utenti e ruoli IAM. Successivamente, importerai un certificato richiesto insieme a dipendenze aggiuntive del pacchetto. Alla fine, consentirai al taccuino di assumere il ruolo di parlare con Keyspace.

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

Successivamente, connettiti ad Amazon Keyspaces e leggi i dati di sistema da Keyspaces in Pandas DataFrame per convalidare la connessione.

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

Quindi, prepara i dati per l'addestramento sul set di dati grezzi. Nel taccuino Python associato a questo post, usa un set di dati di vendita al dettaglio scaricato da qui, ed elaborarlo. Il nostro obiettivo aziendale, dato il set di dati, è raggruppare i clienti utilizzando una specifica metrica chiamata RFM. Il modello RFM si basa su tre fattori quantitativi:

• Recente: quanto recentemente un cliente ha effettuato un acquisto.
• Frequenza: la frequenza con cui un cliente effettua un acquisto.
• Valore monetario: quanti soldi un cliente spende per gli acquisti.

L'analisi RFM classifica numericamente un cliente in ciascuna di queste tre categorie, generalmente su una scala da 1 a 5 (maggiore è il numero, migliore è il risultato). Il cliente "migliore" riceverà un punteggio massimo in ogni categoria. Useremo la funzione di discretizzazione basata sui quantili di Pandas (qcut). Aiuterà a discretizzare i valori in bucket di uguali dimensioni basati o basati su quantili campione.

# 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 questo esempio, utilizziamo CQL per leggere i record dalla tabella Keyspace. In alcuni casi d'uso di ML, potrebbe essere necessario leggere gli stessi dati dalla stessa tabella Keyspace più volte. In questo caso, ti consigliamo di salvare i tuoi dati in un bucket Amazon S3 per evitare di incorrere in altri costosta leggendo da Amazon Keyspaces. A seconda del tuo scenario, puoi anche usare Amazon EMR a ingerire un file Amazon S3 molto grande 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())

Successivamente, addestriamo un modello ML utilizzando l'algoritmo KMeans e ci assicuriamo che i cluster vengano creati. In questo scenario particolare, vedresti che i cluster creati vengono stampati, mostrando che i clienti nel set di dati non elaborati sono stati raggruppati in base a vari attributi nel set di dati. Queste informazioni sul cluster possono essere utilizzate per campagne di marketing mirate.

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

(Facoltativo) Successivamente, salviamo i segmenti di clienti che sono stati identificati dal modello ML in una tabella Amazon Keyspaces per un marketing mirato. Un processo batch potrebbe leggere questi dati ed eseguire campagne mirate per clienti in segmenti specifici.

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

Alla fine, noi ripulire le risorse creato durante questo tutorial per evitare costi aggiuntivi.

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

Il completamento dell'eliminazione di keyspace e tabelle potrebbe richiedere da alcuni secondi a un minuto. Quando elimini uno spazio delle chiavi, lo spazio delle chiavi e tutte le relative tabelle vengono eliminate e smetti di accumulare addebiti da esse.

Conclusione

Questo post ti ha mostrato come importare i dati dei clienti da Amazon Keyspaces in SageMaker e addestrare un modello di clustering che ti ha permesso di segmentare i clienti. Potresti utilizzare queste informazioni per marketing mirato, migliorando così notevolmente il tuo KPI aziendale. Per ulteriori informazioni su Amazon Keyspaces, consulta le seguenti risorse:

• Addestra modelli di machine learning utilizzando Amazon Keyspaces come origine dati (Taccuino SageMaker)
• Connettiti ad Amazon Keyspaces dal tuo desktop utilizzando gli IDE IntelliJ, PyCharm o DataGrip
• Riferimento al linguaggio CQL per Amazon Keyspaces (per Apache Cassandra)
• Come configurare l'accesso da riga di comando ad Amazon Keyspaces (per Apache Cassandra) utilizzando la nuova immagine Docker del toolkit per sviluppatori
• Identity and Access Management per Amazon Keyspaces (per Apache Cassandra)
• Connessione ad Amazon Keyspaces da SageMaker con credenziali specifiche del servizio
• Recente, frequenza, valore monetario (RFM)
• Riferimento codice Kaggle

Informazioni sugli autori

Vadim Ljakhovich è Senior Solutions Architect presso AWS nella Baia di San Francisco, aiutando i clienti a migrare ad AWS. Sta lavorando con organizzazioni che vanno dalle grandi imprese alle piccole startup per supportare le loro innovazioni. Sta inoltre aiutando i clienti a progettare soluzioni scalabili, sicure ed economiche su AWS.

Parte Patel è Solutions Architect presso AWS nella Bay Area di San Francisco. Parth guida i clienti ad accelerare il loro viaggio verso il cloud e li aiuta ad adottare con successo il cloud AWS. Si concentra sul ML e sulla modernizzazione delle applicazioni.

Ram Pathangi è Solutions Architect presso AWS nella Bay Area di San Francisco. Ha aiutato i clienti nei settori verticale Agricoltura, Assicurazioni, Banche, Vendita al dettaglio, Assistenza sanitaria e scienze della vita, Ospitalità e Hi-Tech a gestire con successo la propria attività sul cloud AWS. È specializzato in Database, Analytics e ML.

• Coinsmart. Il miglior scambio di bitcoin e criptovalute d'Europa.
• Platoblockchain. Web3 Metaverse Intelligence. Conoscenza amplificata. ACCESSO LIBERO.
• Criptofalco. Radar Altcoin. Prova gratuita.
• Fonte: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/