Entrene modelos de aprendizaje automático utilizando Amazon Keyspaces como fuente de datos

Muchas aplicaciones destinadas al mantenimiento de equipos industriales, el control del comercio, la gestión de flotas y la optimización de rutas se crean utilizando controladores y API Cassandra de código abierto para procesar datos a alta velocidad y baja latencia. Administrar las tablas de Cassandra usted mismo puede llevar mucho tiempo y ser costoso. Amazon Keyspaces (para Apache Cassandra) le permite configurar, proteger y escalar tablas de Cassandra en la nube de AWS sin administrar infraestructura adicional.

En esta publicación, lo guiaremos a través de los servicios de AWS relacionados con la capacitación de modelos de aprendizaje automático (ML) utilizando Amazon Keyspaces a un alto nivel, y brindaremos instrucciones paso a paso para incorporar datos de Amazon Keyspaces en Amazon SageMaker y entrenar un modelo que se puede usar para un caso de uso específico de segmentación de clientes.

AWS tiene múltiples servicios para ayudar a las empresas a implementar procesos de ML en la nube.

AWS ML Stack tiene tres capas. En la capa intermedia se encuentra SageMaker, que brinda a los desarrolladores, científicos de datos e ingenieros de ML la capacidad de crear, entrenar e implementar modelos de ML a escala. Elimina la complejidad de cada paso del flujo de trabajo de ML para que pueda implementar más fácilmente sus casos de uso de ML. Esto incluye cualquier cosa, desde el mantenimiento predictivo hasta la visión artificial para predecir el comportamiento de los clientes. Los clientes logran una mejora de hasta 10 veces en la productividad de los científicos de datos con SageMaker.

Apache Cassandra es una opción popular para casos de uso intensivo de lectura con datos no estructurados o semiestructurados. Por ejemplo, un negocio popular de comida a domicilio estima el tiempo de entrega, y un cliente minorista podría persistir con frecuencia utilizando la información del catálogo de productos en la base de datos de Apache Cassandra. Espacios de claves de Amazon es un servicio de base de datos compatible con Apache Cassandra escalable, altamente disponible y administrado sin servidor. No necesita aprovisionar, aplicar parches o administrar servidores, y no necesita instalar, mantener ni operar software. Las tablas se pueden escalar hacia arriba y hacia abajo automáticamente, y solo paga por los recursos que usa. Amazon Keyspaces le permite ejecutar sus cargas de trabajo de Cassandra en AWS utilizando el mismo código de aplicación de Cassandra y las mismas herramientas de desarrollo que utiliza actualmente.

SageMaker ofrece un conjunto de algoritmos incorporados para ayudar a los científicos de datos y profesionales de ML a comenzar a entrenar e implementar modelos de ML rápidamente. En esta publicación, le mostraremos cómo un cliente minorista puede usar el historial de compras del cliente en la base de datos Keyspaces y dirigirse a diferentes segmentos de clientes para campañas de marketing.

K-significa es un algoritmo de aprendizaje no supervisado. Intenta encontrar agrupaciones discretas dentro de los datos, donde los miembros de un grupo son lo más similares posible entre sí y lo más diferentes posible de los miembros de otros grupos. Usted define los atributos que desea que use el algoritmo para determinar la similitud. SageMaker utiliza una versión modificada del algoritmo de agrupamiento k-means a escala web. En comparación con la versión original del algoritmo, la versión utilizada por SageMaker es más precisa. Sin embargo, al igual que el algoritmo original, se escala a conjuntos de datos masivos y ofrece mejoras en el tiempo de entrenamiento.

Resumen de la solución

Las instrucciones asumen que usaría SageMaker Studio para ejecutar el código. El código asociado ha sido compartido en GitHub de muestra de AWS. Siguiendo las instrucciones en el laboratorio, puede hacer lo siguiente:

• Instale las dependencias necesarias.
• Conéctese a Amazon Keyspaces, cree una tabla e ingiera datos de muestra.
• Cree un modelo de clasificación ML utilizando los datos en Amazon Keyspaces.
• Explore los resultados del modelo.
• Limpie los recursos recién creados.

Una vez completado, habrá integrado SageMaker con Amazon Keyspaces para entrenar modelos ML como se muestra en la siguiente imagen.

Ahora puedes seguir el instrucciones paso a paso en esta publicación para ingerir datos sin procesar almacenados en Amazon Keyspaces utilizando SageMaker y los datos así recuperados para el procesamiento de ML.

Requisitos previos

Primero, navegue a SageMaker.

A continuación, si es la primera vez que usa SageMaker, seleccione Iniciar.

Luego, selecciona Configurar el dominio de SageMaker.

A continuación, cree un nuevo perfil de usuario con Nombre: usuario sagemakery seleccione Crear nuevo rol existentes Rol de ejecución predeterminado subsección.

A continuación, en la pantalla que aparece, seleccione cualquier Servicio de almacenamiento simple de Amazon (Amazon S3) depósito y seleccione Crear función.

Esta función se usará en los siguientes pasos para permitir que SageMaker acceda a la tabla Keyspaces usando las credenciales temporales de la función. Esto elimina la necesidad de almacenar un nombre de usuario y una contraseña en el portátil.

A continuación, recupere el rol asociado con el usuario sagemaker que se creó en el paso anterior desde la sección de resumen.

Luego, navega hasta el AWS Console y mira hacia arriba Gestión de acceso e identidad de AWS (IAM). Dentro de IAM, vaya a Roles. Dentro de Roles, busque el rol de ejecución identificado en el paso anterior.

A continuación, seleccione el rol identificado en el paso anterior y seleccione Agregar permisos. En el menú desplegable que aparece, seleccione Crear política en línea. SageMaker le permite proporcionar un nivel granular de acceso que restringe las acciones que puede realizar un usuario/aplicación en función de los requisitos comerciales.

Luego, seleccione la pestaña JSON y copie la política de la sección Nota de Github página. Esta política permite que el cuaderno de SageMaker se conecte a Keyspaces y recupere datos para su posterior procesamiento.

Luego, seleccione Agregar permisos nuevamente y en el menú desplegable, y seleccione Adjuntar política.

Busque la política AmazonKeyspacesFullAccess, seleccione la casilla de verificación junto al resultado coincidente y seleccione Adjuntar políticas.

Verifique que la sección de políticas de permisos incluya AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, así como la política en línea recién agregada.

A continuación, navegue hasta SageMaker Studio mediante la consola de AWS y seleccione SageMaker Studio. Una vez allí, seleccione Iniciar aplicación y seleccione Studio.

Tutorial del cuaderno

La forma preferida de conectarse a Keyspaces desde SageMaker Notebook es mediante Proceso de la versión 4 de AWS Signature (SigV4) basado Credenciales temporales para la autenticación. En este escenario, NO necesitamos generar ni almacenar credenciales de Keyspaces y podemos usar las credenciales para autenticarnos con el complemento SigV4. Las credenciales de seguridad temporales constan de un ID de clave de acceso y una clave de acceso secreta. Sin embargo, también incluyen un token de seguridad que indica cuándo caducan las credenciales. En esta publicación, crearemos un rol de IAM y generaremos credenciales de seguridad temporales.

Primero, instalamos un controlador (cassandra-sigv4). Este controlador le permite agregar información de autenticación a sus solicitudes de API mediante el proceso de AWS Signature Version 4 (SigV4). Con el complemento, puede proporcionar a los usuarios y aplicaciones credenciales a corto plazo para acceder a Amazon Keyspaces (para Apache Cassandra) utilizando usuarios y roles de IAM. Después de esto, importará un certificado requerido junto con dependencias de paquetes adicionales. Al final, permitirá que el portátil asuma el rol de hablar con 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)

A continuación, conéctese a Amazon Keyspaces y lea los datos de los sistemas de Keyspaces en Pandas DataFrame para validar la conexión.

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

A continuación, prepare los datos para el entrenamiento en el conjunto de datos sin procesar. En el cuaderno de Python asociado con esta publicación, use un conjunto de datos minorista descargado de esta páginay procesarlo. Nuestro objetivo comercial dado el conjunto de datos es agrupar a los clientes utilizando una métrica específica llamada RFM. El modelo RFM se basa en tres factores cuantitativos:

• Actualidad: Hace cuánto tiempo un cliente ha realizado una compra.
• Frecuencia: Con qué frecuencia un cliente realiza una compra.
• Valor monetario: cuánto dinero gasta un cliente en compras.

El análisis RFM clasifica numéricamente a un cliente en cada una de estas tres categorías, generalmente en una escala de 1 a 5 (cuanto mayor sea el número, mejor será el resultado). El "mejor" cliente recibiría la máxima puntuación en todas las categorías. Usaremos la función de discretización basada en cuantiles de pandas (qcut). Ayudará a diferenciar los valores en cubos de igual tamaño según los cuantiles de muestra.

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

En este ejemplo, usamos CQL para leer registros de la tabla Keyspace. En algunos casos de uso de ML, es posible que deba leer los mismos datos de la misma tabla Keyspaces varias veces. En este caso, le recomendamos que guarde sus datos en un depósito de Amazon S3 para evitar incurrir en gastos adicionales. el costos leyendo de Amazon Keyspaces. Dependiendo de su escenario, también puede usar EMR de Amazon a ingerir un archivo muy grande de Amazon S3 en 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())

A continuación, entrenamos un modelo de ML con el algoritmo KMeans y nos aseguramos de que se creen los clústeres. En este escenario particular, vería que los clústeres creados se imprimen, lo que muestra que los clientes en el conjunto de datos sin procesar se han agrupado en función de varios atributos en el conjunto de datos. Esta información de clúster se puede utilizar para campañas de marketing dirigidas.

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

(Opcional) A continuación, guardamos los segmentos de clientes identificados por el modelo ML en una tabla de Amazon Keyspaces para marketing dirigido. Un trabajo por lotes podría leer estos datos y ejecutar campañas dirigidas a clientes en segmentos específicos.

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

Finalmente nosotros limpiar los recursos creado durante este tutorial para evitar incurrir en cargos adicionales.

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

Puede llevar de unos segundos a un minuto completar la eliminación del espacio de claves y las tablas. Cuando elimina un espacio de claves, el espacio de claves y todas sus tablas se eliminan y deja de acumular cargos de ellos.

Conclusión

Esta publicación le mostró cómo ingerir datos de clientes de Amazon Keyspaces en SageMaker y entrenar un modelo de agrupación que le permitió segmentar a los clientes. Puede usar esta información para marketing dirigido, mejorando así en gran medida el KPI de su negocio. Para obtener más información sobre Amazon Keyspaces, consulte los siguientes recursos:

• Entrene modelos de aprendizaje automático utilizando Amazon Keyspaces como fuente de datos (Cuaderno de SageMaker)
• Conéctese a Amazon Keyspaces desde su escritorio usando los IDE IntelliJ, PyCharm o DataGrip
• Referencia del lenguaje CQL para Amazon Keyspaces (para Apache Cassandra)
• Cómo configurar el acceso de línea de comandos a Amazon Keyspaces (para Apache Cassandra) mediante el uso de la nueva imagen Docker del kit de herramientas para desarrolladores
• Gestión de acceso e identidad para Amazon Keyspaces (para Apache Cassandra)
• Conexión a Amazon Keyspaces desde SageMaker con credenciales específicas del servicio
• Actualidad, frecuencia, valor monetario (RFM)
• Referencia del código de Kaggle

Acerca de los autores

vadim liajovich es arquitecto sénior de soluciones en AWS en el área de la bahía de San Francisco y ayuda a los clientes a migrar a AWS. Está trabajando con organizaciones que van desde grandes empresas hasta pequeñas empresas emergentes para respaldar sus innovaciones. También ayuda a los clientes a diseñar soluciones escalables, seguras y rentables en AWS.

Parto Patel es arquitecto de soluciones en AWS en el área de la bahía de San Francisco. Parth guía a los clientes para acelerar su viaje a la nube y ayudarlos a adoptar la nube de AWS con éxito. Se enfoca en ML y modernización de aplicaciones.

carnero pathangi es arquitecto de soluciones en AWS en el área de la bahía de San Francisco. Ha ayudado a clientes en las verticales de agricultura, seguros, banca, comercio minorista, atención de la salud y ciencias de la vida, hospitalidad y alta tecnología a administrar sus negocios con éxito en la nube de AWS. Se especializa en Bases de Datos, Analytics y ML.

• Coinsmart. El mejor intercambio de Bitcoin y criptografía de Europa.
• Platoblockchain. Inteligencia del Metaverso Web3. Conocimiento amplificado. ACCESO LIBRE.
• CriptoHawk. Radar de altcoins. Prueba gratis.
• Fuente: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/