Treine modelos de machine learning usando Amazon Keyspaces como fonte de dados

Muitos aplicativos destinados à manutenção de equipamentos industriais, monitoramento comercial, gerenciamento de frota e otimização de rotas são criados usando APIs e drivers Cassandra de código aberto para processar dados em alta velocidade e baixa latência. Gerenciar você mesmo as tabelas do Cassandra pode ser demorado e caro. Amazon Keyspaces (para Apache Cassandra) permite configurar, proteger e dimensionar tabelas do Cassandra na Nuvem AWS sem gerenciar infraestrutura adicional.

Nesta postagem, orientaremos você pelos serviços da AWS relacionados ao treinamento de modelos de machine learning (ML) usando Amazon Keyspaces em alto nível e forneceremos instruções passo a passo para a ingestão de dados do Amazon Keyspaces em Amazon Sage Maker e treinar um modelo que pode ser usado para um caso de uso específico de segmentação de clientes.

A AWS tem vários serviços para ajudar as empresas a implementar processos de ML na nuvem.

O AWS ML Stack tem três camadas. Na camada intermediária está SageMaker, que oferece aos desenvolvedores, cientistas de dados e engenheiros de ML a capacidade de criar, treinar e implantar modelos de ML em escala. Ele remove a complexidade de cada etapa do fluxo de trabalho de ML para que você possa implantar seus casos de uso de ML com mais facilidade. Isso inclui qualquer coisa, desde manutenção preditiva até visão computacional para prever comportamentos do cliente. Os clientes obtêm uma melhoria de até 10 vezes na produtividade dos cientistas de dados com o SageMaker.

O Apache Cassandra é uma escolha popular para casos de uso de leitura pesada com dados não estruturados ou semiestruturados. Por exemplo, uma empresa popular de entrega de alimentos estima o tempo de entrega e um cliente de varejo pode persistir frequentemente usando as informações do catálogo de produtos no banco de dados Apache Cassandra. Espaços-chave da Amazon é um serviço de banco de dados compatível com Apache Cassandra escalável, altamente disponível e gerenciado sem servidor. Você não precisa provisionar, corrigir ou gerenciar servidores e não precisa instalar, manter ou operar software. As tabelas podem aumentar e diminuir automaticamente, e você paga apenas pelos recursos que usar. O Amazon Keyspaces permite que você execute suas cargas de trabalho do Cassandra na AWS usando o mesmo código de aplicativo Cassandra e ferramentas de desenvolvedor que você usa hoje.

O SageMaker fornece um conjunto de algoritmos integrados para ajudar cientistas de dados e profissionais de ML a começar a treinar e implantar modelos de ML rapidamente. Neste post, mostraremos como um cliente de varejo pode usar o histórico de compras do cliente no banco de dados de Keyspaces e segmentar diferentes segmentos de clientes para campanhas de marketing.

K-significa é um algoritmo de aprendizado não supervisionado. Ele tenta encontrar agrupamentos discretos dentro dos dados, onde os membros de um grupo são tão semelhantes quanto possível uns aos outros e tão diferentes quanto possível dos membros de outros grupos. Você define os atributos que deseja que o algoritmo use para determinar a similaridade. O SageMaker usa uma versão modificada do algoritmo de clustering k-means em escala da web. Em comparação com a versão original do algoritmo, a versão usada pelo SageMaker é mais precisa. No entanto, como o algoritmo original, ele é dimensionado para grandes conjuntos de dados e oferece melhorias no tempo de treinamento.

Visão geral da solução

As instruções pressupõem que você usaria o SageMaker Studio para executar o código. O código associado foi compartilhado em GitHub de amostra da AWS. Seguindo as instruções do laboratório, você pode fazer o seguinte:

• Instale as dependências necessárias.
• Conecte-se ao Amazon Keyspaces, crie uma tabela e ingira dados de amostra.
• Crie um modelo de ML de classificação usando os dados no Amazon Keyspaces.
• Explore os resultados do modelo.
• Limpe os recursos recém-criados.

Depois de concluído, você terá integrado o SageMaker ao Amazon Keyspaces para treinar modelos de ML, conforme mostrado na imagem a seguir.

Agora você pode seguir o instruções passo a passo nesta postagem para ingerir dados brutos armazenados em Amazon Keyspaces usando o SageMaker e os dados assim recuperados para processamento de ML.

Pré-requisitos

Primeiro, navegue até SageMaker.

Em seguida, se esta for a primeira vez que você está usando o SageMaker, selecione Iniciar.

Em seguida, selecione Configurar domínio do SageMaker.

Em seguida, crie um novo perfil de usuário com Nome – usuário de sábioe selecione Criar nova função no Função de execução padrão subseção.

Em seguida, na tela que aparece, selecione qualquer Serviço de armazenamento simples da Amazon (Amazon S3) bucket e selecione Criar função.

Essa função será usada nas etapas a seguir para permitir que o SageMaker acesse a Tabela de Keyspaces usando credenciais temporárias da função. Isso elimina a necessidade de armazenar um nome de usuário e senha no notebook.

Em seguida, recupere a função associada ao usuário de sábio que foi criado na etapa anterior da seção de resumo.

Em seguida, navegue até o Console AWS e olhe para cima Gerenciamento de identidade e acesso da AWS (IAM). No IAM, navegue até Funções. Em Funções, procure a função de execução identificada na etapa anterior.

Em seguida, selecione a função identificada na etapa anterior e selecione Adicionar permissões. Na lista suspensa exibida, selecione Criar política em linha. O SageMaker permite fornecer um nível granular de acesso que restringe quais ações um usuário/aplicativo pode realizar com base nos requisitos de negócios.

Em seguida, selecione a guia JSON e copie a política da seção Nota do Github página. Essa política permite que o notebook SageMaker se conecte a Keyspaces e recupere dados para processamento adicional.

Em seguida, selecione Adicionar permissões novamente e na lista suspensa e selecione Anexar política.

Pesquise a política AmazonKeyspacesFullAccess e marque a caixa de seleção ao lado do resultado correspondente e selecione Anexar políticas.

Verifique se a seção de políticas de permissões inclui AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, bem como a política em linha recém-adicionada.

Em seguida, navegue até o SageMaker Studio usando o Console AWS e selecione o SageMaker Studio. Uma vez lá, selecione Iniciar aplicativo e selecione Studio.

Passo a passo do notebook

A maneira preferida de se conectar a Keyspaces do SageMaker Notebook é usando Processo do AWS Signature versão 4 (SigV4) baseado Credenciais Temporárias para autenticação. Nesse cenário, NÃO precisamos gerar ou armazenar credenciais de Keyspaces e podemos usar as credenciais para autenticar com o plug-in SigV4. As credenciais de segurança temporárias consistem em um ID de chave de acesso e uma chave de acesso secreta. No entanto, eles também incluem um token de segurança que indica quando as credenciais expiram. Nesta postagem, criaremos uma função do IAM e geraremos credenciais de segurança temporárias.

Primeiro, instalamos um driver (cassandra-sigv4). Esse driver permite que você adicione informações de autenticação às suas solicitações de API usando o processo do AWS Signature versão 4 (SigV4). Usando o plug-in, você pode fornecer aos usuários e aplicativos credenciais de curto prazo para acessar Amazon Keyspaces (para Apache Cassandra) usando usuários e funções do IAM. Depois disso, você importará um certificado necessário junto com dependências de pacote adicionais. No final, você permitirá que o notebook assuma o papel de conversar com os 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)

Em seguida, conecte-se ao Amazon Keyspaces e leia os dados do sistema de Keyspaces no Pandas DataFrame para validar a conexão.

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

Em seguida, prepare os dados para treinamento no conjunto de dados brutos. No notebook python associado a esta postagem, use um conjunto de dados de varejo baixado de SUA PARTICIPAÇÃO FAZ A DIFERENÇA, e processá-lo. Nosso objetivo de negócios, dado o conjunto de dados, é agrupar os clientes usando uma chamada de métrica específica RFM. O modelo RFM é baseado em três fatores quantitativos:

• Recência: quão recentemente um cliente fez uma compra.
• Frequência: a frequência com que um cliente faz uma compra.
• Valor monetário: quanto dinheiro um cliente gasta em compras.

A análise RFM classifica numericamente um cliente em cada uma dessas três categorias, geralmente em uma escala de 1 a 5 (quanto maior o número, melhor o resultado). O “melhor” cliente receberia uma pontuação máxima em todas as categorias. Usaremos a função de discretização baseada em quantil do pandas (qcut). Isso ajudará a discretizar valores em intervalos de tamanhos iguais com base ou com base em quantis de amostra.

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

Neste exemplo, usamos CQL para ler registros da tabela Keyspace. Em alguns casos de uso de ML, pode ser necessário ler os mesmos dados da mesma tabela Keyspaces várias vezes. Nesse caso, recomendamos que você salve seus dados em um bucket do Amazon S3 para evitar incorrer em custos lendo do Amazon Keyspaces. Dependendo do seu cenário, você também pode usar Amazon EMR para ingerir um arquivo muito grande do Amazon S3 no 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())

Em seguida, treinamos um modelo de ML usando o algoritmo KMeans e garantimos que os clusters sejam criados. Nesse cenário específico, você veria que os clusters criados são impressos, mostrando que os clientes no conjunto de dados brutos foram agrupados com base em vários atributos no conjunto de dados. Essas informações de cluster podem ser usadas para campanhas de marketing direcionadas.

# 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) Em seguida, salvamos os segmentos de clientes que foram identificados pelo modelo de ML em uma tabela do Amazon Keyspaces para marketing direcionado. Um trabalho em lote pode ler esses dados e executar campanhas direcionadas a clientes em 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, nós limpar os recursos criado durante este tutorial para evitar cobranças adicionais.

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

Pode levar alguns segundos a um minuto para concluir a exclusão do keyspace e das tabelas. Quando você exclui um keyspace, o keyspace e todas as suas tabelas são excluídas e você para de acumular cobranças a partir deles.

Conclusão

Esta postagem mostrou como ingerir dados de clientes do Amazon Keyspaces no SageMaker e treinar um modelo de cluster que permitia segmentar clientes. Você pode usar essas informações para marketing direcionado, melhorando muito o KPI do seu negócio. Para saber mais sobre Amazon Keyspaces, consulte os seguintes recursos:

• Treinar modelos de aprendizado de máquina usando Amazon Keyspaces como fonte de dados (Caderno do SageMaker)
• Conecte-se ao Amazon Keyspaces do seu desktop usando IDEs IntelliJ, PyCharm ou DataGrip
• Referência de linguagem CQL para Amazon Keyspaces (para Apache Cassandra)
• Como configurar o acesso de linha de comando ao Amazon Keyspaces (para Apache Cassandra) usando a nova imagem do Docker do kit de ferramentas do desenvolvedor
• Gerenciamento de identidade e acesso para Amazon Keyspaces (para Apache Cassandra)
• Conectando-se a Amazon Keyspaces do SageMaker com credenciais específicas do serviço
• Recência, Frequência, Valor Monetário (RFM)
• Referência do código Kaggle

Sobre os autores

Vadim Lyakhovich é arquiteto de soluções sênior da AWS na área da baía de São Francisco, ajudando os clientes a migrar para a AWS. Ele está trabalhando com organizações que vão de grandes empresas a pequenas startups para apoiar suas inovações. Ele também está ajudando os clientes a arquitetar soluções escaláveis, seguras e econômicas na AWS.

Parte Patel é arquiteto de soluções na AWS na área da baía de São Francisco. Parth orienta os clientes a acelerar sua jornada para a nuvem e os ajuda a adotar a nuvem AWS com sucesso. Ele se concentra em ML e modernização de aplicativos.

Ram Pathangi é arquiteto de soluções na AWS na área da baía de São Francisco. Ele ajudou clientes nas verticais de agricultura, seguros, bancos, varejo, saúde e ciências da vida, hotelaria e alta tecnologia a administrar seus negócios com sucesso na nuvem AWS. Ele é especialista em Bancos de Dados, Analytics e ML.

• Coinsmart. A melhor troca de Bitcoin e criptografia da Europa.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. ACESSO LIVRE.
• CryptoHawk. Radar Altcoin. Teste grátis.
• Fonte: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/