Trenuj modele uczenia maszynowego przy użyciu Amazon Keyspaces jako źródła danych

Wiele aplikacji przeznaczonych do konserwacji sprzętu przemysłowego, monitorowania handlu, zarządzania flotą i optymalizacji tras jest zbudowanych przy użyciu interfejsów API Cassandra i sterowników typu open source do przetwarzania danych z dużymi prędkościami i niskimi opóźnieniami. Samodzielne zarządzanie stołami Cassandra może być czasochłonne i kosztowne. Przestrzenie klawiszy Amazon (dla Apache Cassandra) umożliwia konfigurowanie, zabezpieczanie i skalowanie tabel Cassandra w chmurze AWS bez zarządzania dodatkową infrastrukturą.

W tym poście przeprowadzimy Cię przez usługi AWS związane z trenowaniem modeli uczenia maszynowego (ML) przy użyciu Amazon Keyspaces na wysokim poziomie i dostarczymy instrukcje krok po kroku dotyczące pozyskiwania danych z Amazon Keyspaces do Amazon Sage Maker oraz wytrenowanie modelu, który można wykorzystać w przypadku konkretnego przypadku użycia segmentacji klientów.

AWS oferuje wiele usług, które pomagają firmom wdrażać procesy ML w chmurze.

AWS ML Stack ma trzy warstwy. W środkowej warstwie znajduje się SageMaker, który zapewnia programistom, analitykom danych i inżynierom ML możliwość tworzenia, trenowania i wdrażania modeli ML na dużą skalę. Usuwa złożoność każdego etapu przepływu pracy ML, dzięki czemu można łatwiej wdrażać przypadki użycia ML. Obejmuje to wszystko, od konserwacji predykcyjnej po wizję komputerową po przewidywanie zachowań klientów. Dzięki SageMaker klienci osiągają nawet 10-krotną poprawę produktywności analityków danych.

Apache Cassandra jest popularnym wyborem do zastosowań wymagających dużego odczytu z danymi nieustrukturyzowanymi lub częściowo ustrukturyzowanymi. Na przykład popularna firma dostarczająca żywność szacuje czas dostawy, a klient detaliczny może często korzystać z informacji katalogowych produktów w bazie danych Apache Cassandra. Obszary klawiszy Amazon to skalowalna, wysoce dostępna i zarządzana bezserwerowa usługa bazy danych zgodna z Apache Cassandra. Nie musisz aprowizować, aktualizować ani zarządzać serwerami, ani instalować, konserwować ani obsługiwać oprogramowania. Tabele mogą automatycznie skalować się w górę i w dół, a płacisz tylko za zasoby, z których korzystasz. Amazon Keyspaces umożliwia uruchamianie obciążeń Cassandra w AWS przy użyciu tego samego kodu aplikacji Cassandra i narzędzi programistycznych, których używasz dzisiaj.

SageMaker zapewnia pakiet wbudowane algorytmy aby pomóc analitykom danych i praktykom ML w szybkim rozpoczęciu szkolenia i wdrażania modeli ML. W tym poście pokażemy, jak klient detaliczny może wykorzystać historię zakupów klientów w bazie danych Keyspaces i kierować kampanie marketingowe na różne segmenty klientów.

K-oznacza to nienadzorowany algorytm uczenia się. Próbuje znaleźć dyskretne grupy w danych, w których członkowie grupy są do siebie jak najbardziej podobni i jak najbardziej różni od członków innych grup. Definiujesz atrybuty, których algorytm ma używać do określania podobieństwa. SageMaker używa zmodyfikowanej wersji algorytm grupowania k-średnich w skali internetowej. W porównaniu z oryginalną wersją algorytmu, wersja używana przez SageMaker jest dokładniejsza. Jednak, podobnie jak oryginalny algorytm, skaluje się do ogromnych zbiorów danych i zapewnia skrócenie czasu szkolenia.

Omówienie rozwiązania

Instrukcje zakładają, że do uruchomienia kodu używasz SageMaker Studio. Powiązany kod został udostępniony dnia Przykładowy serwis GitHub AWS. Postępując zgodnie z instrukcjami w laboratorium, możesz wykonać następujące czynności:

• Zainstaluj niezbędne zależności.
• Połącz się z Amazon Keyspaces, utwórz tabelę i pozyskuj przykładowe dane.
• Zbuduj model klasyfikacji ML, korzystając z danych w Amazon Keyspaces.
• Przeglądaj wyniki modelu.
• Oczyść nowo utworzone zasoby.

Po zakończeniu będziesz zintegrować SageMaker z Amazon Keyspaces, aby trenować modele ML, jak pokazano na poniższym obrazku.

Teraz możesz śledzić instrukcje krok po kroku w tym poście, aby przyswoić surowe dane przechowywane w Amazon Keyspaces za pomocą SageMaker i dane w ten sposób pobrane do przetwarzania ML.

Wymagania wstępne

Najpierw przejdź do SageMaker.

Następnie, jeśli używasz SageMaker po raz pierwszy, wybierz Rozpocznij.

Następnie wybierz Skonfiguruj domenę SageMaker.

Następnie utwórz nowy profil użytkownika z nazwą – mędrzecużytkowniki wybierz Utwórz nową rolę Domyślna rola wykonania podpunkt.

Następnie na wyświetlonym ekranie wybierz dowolny Usługa Amazon Simple Storage (Amazon S3) zasobnik i wybierz Utwórz rolę.

Ta rola zostanie użyta w poniższych krokach, aby umożliwić SageMakerowi dostęp do tabeli obszarów kluczy przy użyciu tymczasowych poświadczeń z roli. Eliminuje to konieczność przechowywania nazwy użytkownika i hasła w notebooku.

Następnie pobierz rolę powiązaną z mędrzecużytkownik który został utworzony w poprzednim kroku z sekcji podsumowania.

Następnie przejdź do Konsola AWS i spójrz w górę Zarządzanie tożsamością i dostępem AWS (IAM). W ramach uprawnień przejdź do ról. W ramach ról wyszukaj rolę wykonawczą zidentyfikowaną w poprzednim kroku.

Następnie wybierz rolę zidentyfikowaną w poprzednim kroku i wybierz Dodaj uprawnienia. Z menu, które się pojawi, wybierz Utwórz zasady wbudowane. SageMaker pozwala zapewnić szczegółowy poziom dostępu, który ogranicza czynności, które użytkownik/aplikacja może wykonywać w oparciu o wymagania biznesowe.

Następnie wybierz zakładkę JSON i skopiuj politykę z sekcji Notatka Github strona. Ta zasada umożliwia notebookowi SageMaker łączenie się z obszarami kluczy i pobieranie danych do dalszego przetwarzania.

Następnie ponownie wybierz Dodaj uprawnienia iz listy rozwijanej, a następnie wybierz Dołącz politykę.

Wyszukaj zasady AmazonKeyspacesFullAccess i zaznacz pole wyboru obok pasującego wyniku, a następnie wybierz Dołącz zasady.

Sprawdź, czy sekcja polityki uprawnień zawiera AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, a także nowo dodane zasady wbudowane.

Następnie przejdź do SageMaker Studio za pomocą AWS Console i wybierz SageMaker Studio. Tam wybierz Uruchom aplikację i wybierz Studio.

Przewodnik po notebooku

Preferowanym sposobem łączenia się z Keyspaces z Notatnika SageMaker jest użycie Proces AWS Signature w wersji 4 (SigV4) na podstawie Poświadczenia tymczasowe do uwierzytelniania. W tym scenariuszu NIE musimy generować ani przechowywać poświadczeń Keyspaces i możemy użyć poświadczeń do uwierzytelniania za pomocą wtyczki SigV4. Tymczasowe dane uwierzytelniające składają się z identyfikatora klucza dostępu i tajnego klucza dostępu. Zawierają jednak również token zabezpieczający, który wskazuje, kiedy poświadczenia wygasają. W tym poście utworzymy rolę uprawnień i wygenerujemy tymczasowe dane uwierzytelniające.

Najpierw instalujemy sterownik (cassandra-sigv4). Ten sterownik umożliwia dodawanie informacji uwierzytelniających do żądań API przy użyciu procesu AWS Signature Version 4 (SigV4). Korzystając z wtyczki, możesz zapewnić użytkownikom i aplikacjom krótkoterminowe poświadczenia dostępu do Amazon Keyspaces (dla Apache Cassandra) przy użyciu użytkowników i ról uprawnień. Następnie zaimportujesz wymagany certyfikat wraz z dodatkowymi zależnościami pakietów. W końcu pozwolisz notebookowi przejąć rolę, aby rozmawiać z 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)

Następnie połącz się z Amazon Keyspaces i wczytaj dane systemowe z Keyspaces do Pandas DataFrame, aby zweryfikować połączenie.

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

Następnie przygotuj dane do treningu na surowym zestawie danych. W notatniku Pythona powiązanym z tym postem użyj zestawu danych detalicznych pobranego z tutaji przetworzyć. Naszym celem biznesowym, biorąc pod uwagę zestaw danych, jest klastrowanie klientów przy użyciu określonej metryki wywołania RFM. Model RFM opiera się na trzech czynnikach ilościowych:

• Ostatnio: jak niedawno klient dokonał zakupu.
• Częstotliwość: jak często klient dokonuje zakupu.
• Wartość pieniężna: ile pieniędzy klient wydaje na zakupy.

Analiza RFM numerycznie klasyfikuje klienta w każdej z tych trzech kategorii, generalnie w skali od 1 do 5 (im wyższa liczba, tym lepszy wynik). „Najlepszy” klient otrzymałby najwyższą ocenę w każdej kategorii. Użyjemy funkcji dyskretyzacji pand opartej na kwantylu (qcut). Pomoże to zdyskretyzować wartości do wiader o równej wielkości na podstawie lub na podstawie kwantyli próbki.

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

W tym przykładzie używamy CQL do odczytywania rekordów z tabeli Keyspace. W niektórych przypadkach użycia ML może być konieczne wielokrotne odczytywanie tych samych danych z tej samej tabeli Keyspaces. W takim przypadku zalecamy zapisanie danych w zasobniku Amazon S3, aby uniknąć ponoszenia dodatkowych koszts czytanie z Amazon Keyspaces. W zależności od scenariusza możesz również użyć Amazon EMR do łykać bardzo duży plik Amazon S3 do 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())

Następnie trenujemy model ML za pomocą algorytmu KMeans i upewniamy się, że klastry są tworzone. W tym konkretnym scenariuszu widać, że utworzone klastry są drukowane, pokazując, że klienci w surowym zestawie danych zostali zgrupowani razem na podstawie różnych atrybutów w zestawie danych. Te informacje o klastrach można wykorzystać w ukierunkowanych kampaniach marketingowych.

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

(Opcjonalnie) Następnie zapisujemy segmenty klientów, które zostały zidentyfikowane przez model ML, z powrotem w tabeli Amazon Keyspaces w celu marketingu ukierunkowanego. Zadanie wsadowe może odczytywać te dane i prowadzić kampanie kierowane do klientów w określonych segmentach.

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

Wreszcie my posprzątaj zasoby utworzone podczas tego samouczka, aby uniknąć ponoszenia dodatkowych opłat.

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

Usunięcie przestrzeni kluczy i tabel może potrwać od kilku sekund do minuty. Gdy usuniesz obszar kluczy, obszar kluczy i wszystkie jego tabele są usuwane i przestajesz naliczać od nich opłaty.

Wnioski

W tym poście pokazano, jak pozyskiwać dane klientów z Amazon Keyspaces do SageMaker i wytrenować model klastrowania, który umożliwił segmentację klientów. Możesz wykorzystać te informacje do ukierunkowanego marketingu, dzięki czemu znacznie poprawisz swój biznesowy wskaźnik KPI. Aby dowiedzieć się więcej o Amazon Keyspaces, przejrzyj następujące zasoby:

• Trenuj modele uczenia maszynowego przy użyciu przestrzeni kluczy Amazon jako źródła danych (notatnik SageMaker)
• Połącz się z Amazon Keyspaces ze swojego komputera za pomocą IntelliJ, PyCharm lub DataGrip IDE
• Dokumentacja języka CQL dla przestrzeni kluczy Amazon (dla Apache Cassandra)
• Jak skonfigurować dostęp z wiersza poleceń do Amazon Keyspaces (dla Apache Cassandra) przy użyciu nowego obrazu Docker dla programistów
• Zarządzanie tożsamością i dostępem dla przestrzeni kluczy Amazon (dla Apache Cassandra)
• Łączenie się z Amazon Keyspaces z SageMaker za pomocą poświadczenia specyficzne dla usługi
• Aktualność, częstotliwość, wartość pieniężna (RFM)
• Odniesienie do kodu Kaggle

O autorach

Wadim Lachowicz jest starszym architektem rozwiązań w AWS w rejonie zatoki San Francisco, pomagając klientom w migracji do AWS. Współpracuje z organizacjami od dużych przedsiębiorstw po małe startupy, aby wspierać ich innowacje. Pomaga również klientom w projektowaniu skalowalnych, bezpiecznych i opłacalnych rozwiązań w AWS.

Część Patel jest architektem rozwiązań w AWS w rejonie zatoki San Francisco. Parth prowadzi klientów, aby przyspieszyć ich podróż do chmury i pomóc im pomyślnie wdrożyć chmurę AWS. Koncentruje się na ML i modernizacji aplikacji.

Ram Pathangi jest architektem rozwiązań w AWS w rejonie zatoki San Francisco. Pomógł klientom z branży rolniczej, ubezpieczeniowej, bankowej, handlu detalicznego, opieki zdrowotnej i nauk przyrodniczych, hotelarstwa i Hi-Tech pomyślnie prowadzić działalność w chmurze AWS. Specjalizuje się w bazach danych, analityce i ML.

• Coinsmart. Najlepsza w Europie giełda bitcoinów i kryptowalut.
• Platoblockchain. Web3 Inteligencja Metaverse. Wzmocniona wiedza. DARMOWY DOSTĘP.
• CryptoJastrząb. Radar Altcoin. Bezpłatna wersja próbna.
• Źródło: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/