Tanítson gépi tanulási modelleket adatforrásként Amazon Keyspaces használatával

Számos ipari berendezések karbantartására, kereskedelem figyelésére, flottakezelésre és útvonal-optimalizálásra szánt alkalmazás nyílt forráskódú Cassandra API-k és illesztőprogramok felhasználásával készült, hogy nagy sebességgel és alacsony késleltetéssel dolgozza fel az adatokat. A Cassandra asztalok kezelése időigényes és költséges lehet. Amazon Keyspaces (Apache Cassandra számára) lehetővé teszi Cassandra táblák beállítását, biztonságossá tételét és méretezését az AWS Cloudban további infrastruktúra kezelése nélkül.

Ebben a bejegyzésben végigvezetjük Önt az Amazon Keyspaces magas szinten használó gépi tanulási (ML) modellekkel kapcsolatos AWS-szolgáltatásokon, és lépésről lépésre útmutatást adunk az Amazon Keyspaces-ből származó adatok beviteléhez. Amazon SageMaker és olyan modell képzése, amely egy adott ügyfélszegmentálási felhasználási esethez használható.

Az AWS számos szolgáltatással segíti a vállalkozásokat az ML folyamatok felhőben való megvalósításában.

Az AWS ML Stack három rétegből áll. A középső rétegben van SageMaker, amely lehetővé teszi a fejlesztők, adattudósok és ML-mérnökök számára az ML modellek méretarányos építését, betanítását és üzembe helyezését. Megszünteti az ML-munkafolyamat minden egyes lépésének bonyolultságát, így könnyebben telepítheti az ML használati eseteit. Ez magában foglal mindent a prediktív karbantartástól a számítógépes látásig, hogy előre jelezze az ügyfelek viselkedését. Az ügyfelek a SageMaker segítségével akár tízszeres javulást érhetnek el az adatkutatók termelékenységében.

Az Apache Cassandra népszerű választás nehézkes, strukturálatlan vagy félig strukturált adatok esetén. Például egy népszerű élelmiszer-kiszállítással foglalkozó vállalkozás megbecsüli a kiszállítás idejét, a lakossági vásárló pedig továbbra is gyakran használja az Apache Cassandra adatbázisban található termékkatalógus-információkat. Amazon Keyspaces egy méretezhető, magas rendelkezésre állású és felügyelt kiszolgáló nélküli Apache Cassandra-kompatibilis adatbázis-szolgáltatás. Nincs szükség kiszolgálók kiépítésére, javítására vagy kezelésére, és nincs szükség szoftverek telepítésére, karbantartására vagy üzemeltetésére. A táblázatok automatikusan fel- és leméretezhetők, és csak a felhasznált erőforrásokért kell fizetni. Az Amazon Keyspaces lehetővé teszi a Cassandra-munkaterhelések futtatását az AWS-en ugyanazzal a Cassandra alkalmazáskóddal és fejlesztői eszközökkel, amelyeket ma is használ.

A SageMaker egy csomagot kínál beépített algoritmusok hogy segítse az adattudósokat és az ML-gyakorlókat az ML-modellek gyors képzésében és bevezetésében. Ebben a bejegyzésben bemutatjuk, hogyan használhatja fel a lakossági vásárló a vásárlási előzményeket a Keyspaces adatbázisban, és hogyan célozhatja meg a különböző ügyfélszegmenseket marketingkampányokhoz.

K- jelenti egy felügyelet nélküli tanulási algoritmus. Megpróbál olyan diszkrét csoportosításokat találni az adatokon belül, ahol egy csoport tagjai a lehető legnagyobb mértékben hasonlítanak egymáshoz, és a lehető legjobban különböznek más csoportok tagjaitól. Ön határozza meg azokat az attribútumokat, amelyeket az algoritmusnak használni szeretne a hasonlóság meghatározásához. A SageMaker a web-skálájú k-közép klaszterező algoritmus. Az algoritmus eredeti verziójához képest a SageMaker által használt verzió pontosabb. Az eredeti algoritmushoz hasonlóan azonban hatalmas adathalmazokra skálázódik, és javítja a képzési időt.

Megoldás áttekintése

Az utasítások azt feltételezik, hogy a kód futtatásához a SageMaker Studio programot használná. A kapcsolódó kód megosztása megtörtént AWS minta GitHub. A laboratóriumi utasításokat követve a következőket teheti:

• Telepítse a szükséges függőségeket.
• Csatlakozzon az Amazon Keyspaces szolgáltatáshoz, hozzon létre egy táblázatot, és töltse be a mintaadatokat.
• Hozzon létre egy osztályozási ML-modellt az Amazon Keyspacesben található adatok felhasználásával.
• Fedezze fel a modelleredményeket.
• Tisztítsa meg az újonnan létrehozott erőforrásokat.

Ha elkészült, integrálja a SageMaker-t az Amazon Keyspaces-szel az ML-modellek betanításához, ahogy az a következő képen látható.

Most követheted lépésről lépésre ebben a bejegyzésben az Amazon Keyspacesben tárolt nyers adatok feldolgozása a SageMaker segítségével, és az így visszakeresett adatok ML feldolgozáshoz.

Előfeltételek

Először keresse meg a SageMaker alkalmazást.

Ezután, ha ez az első alkalom, hogy a SageMaker-t használja, válassza a lehetőséget Első lépések.

Ezt követően válassza ki Állítsa be a SageMaker tartományt.

Ezután hozzon létre egy új felhasználói profilt a névvel - sagemakeruser, és válassza ki Új szerep létrehozása a Alapértelmezett végrehajtási szerep alszakasz.

Ezután a felugró képernyőn válassza ki bármelyiket Amazon Simple Storage Service (Amazon S3) vödörbe, és válassza a Szerep létrehozása lehetőséget.

Ezt a szerepet a következő lépésekben fogja használni, hogy a SageMaker hozzáférjen a Keyspaces Table-hoz a szerepkörből származó ideiglenes hitelesítő adatok használatával. Így nincs szükség felhasználónév és jelszó tárolására a notebookban.

Ezután kérje le a következőhöz társított szerepet sagemakeruser amely az előző lépésben jött létre az összefoglaló részből.

Ezután navigáljon a AWS konzol és felnéz AWS Identity and Access Management (IAM). Az IAM-en belül navigáljon a Szerepkörökhöz. A Szerepkörökben keresse meg az előző lépésben azonosított végrehajtási szerepkört.

Ezután válassza ki az előző lépésben azonosított szerepet, majd válassza az Engedélyek hozzáadása lehetőséget. A megjelenő legördülő menüben válassza a Beépített házirend létrehozása lehetőséget. A SageMaker részletes hozzáférési szintet biztosít, amely korlátozza, hogy a felhasználó/alkalmazás milyen műveleteket hajthat végre az üzleti követelmények alapján.

Ezután válassza ki a JSON lapot, és másolja ki a házirendet a Github Megjegyzés részéből oldal. Ez a házirend lehetővé teszi a SageMaker notebook számára, hogy kapcsolódjon a Keyspaces-hez, és adatokat kérjen le további feldolgozáshoz.

Ezután válassza ki ismét az Engedélyek hozzáadása lehetőséget, majd a legördülő menüből, majd válassza a Házirend csatolása lehetőséget.

Keresse meg az AmazonKeyspacesFullAccess házirendet, jelölje be az egyező eredmény melletti jelölőnégyzetet, majd válassza a Házirendek csatolása lehetőséget.

Ellenőrizze, hogy az engedélyek házirendje tartalmazza-e AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, valamint az újonnan hozzáadott inline szabályzat.

Ezután lépjen a SageMaker Studio oldalra az AWS konzol segítségével, és válassza ki a SageMaker Studio elemet. Ha ott van, válassza az Alkalmazás indítása lehetőséget, majd a Studio lehetőséget.

Jegyzetfüzet áttekintése

A SageMaker Notebook Keyspaces-hez való csatlakozásának előnyben részesített módja a használata AWS Signature Version 4 folyamat (SigV4) alapján Ideiglenes hitelesítő adatok hitelesítéshez. Ebben a forgatókönyvben NEM kell létrehoznunk vagy tárolnunk a Keyspaces hitelesítő adatait, és a hitelesítési adatokat használhatjuk a SigV4 beépülő modullal történő hitelesítéshez. Az ideiglenes biztonsági hitelesítő adatok egy hozzáférési kulcs azonosítójából és egy titkos hozzáférési kulcsból állnak. Ugyanakkor tartalmaznak egy biztonsági tokent is, amely jelzi, ha a hitelesítő adatok lejárnak. Ebben a bejegyzésben létrehozunk egy IAM-szerepet, és ideiglenes biztonsági hitelesítési adatokat hozunk létre.

Először telepítünk egy illesztőprogramot (cassandra-sigv4). Ez az illesztőprogram lehetővé teszi, hogy az AWS Signature Version 4 Process (SigV4) segítségével hitelesítési információkat adjon hozzá API-kérelmeihez. A beépülő modul segítségével rövid távú hitelesítési adatokat biztosíthat a felhasználóknak és az alkalmazásoknak az Amazon Keyspaces (Apache Cassandra esetében) eléréséhez IAM-felhasználók és szerepkörök használatával. Ezt követően importál egy szükséges tanúsítványt a további csomagfüggőségekkel együtt. A végén megengedi, hogy a notebook átvegye azt a szerepet, hogy a Keyspaces-szel beszéljen.

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

Ezután csatlakozzon az Amazon Keyspaces-hez, és olvassa be a rendszeradatokat a Keyspaces-ből a Pandas DataFrame-be a kapcsolat érvényesítéséhez.

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

Ezután készítse elő az adatokat a nyers adatkészleten való betanításhoz. A bejegyzéshez társított python-jegyzetfüzetben használjon egy innen letöltött kiskereskedelmi adatkészletet itt, és feldolgozza. Üzleti célunk az adatkészlet alapján, hogy az ügyfeleket egy adott metrikahívás RFM segítségével klaszterezzük. Az RFM modell három mennyiségi tényezőn alapul:

• Legutóbbi idő: Milyen közelmúltban vásárolt az ügyfél.
• Gyakoriság: Milyen gyakran vásárol egy vásárló.
• Pénzbeli érték: Mennyi pénzt költ az ügyfél vásárlásra.

Az RFM-elemzés numerikusan besorolja az ügyfeleket e három kategória mindegyikébe, általában 1-től 5-ig terjedő skálán (minél magasabb a szám, annál jobb az eredmény). A „legjobb” vásárló minden kategóriában a legmagasabb pontszámot kapja. A pandák kvantilis alapú diszkretizációs függvényét (qcut) fogjuk használni. Segít az értékek egyenlő méretű gyűjtőkockákba történő diszkretizálásában minta kvantilisek alapján vagy alapján.

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

Ebben a példában a CQL segítségével olvassuk be a rekordokat a Keyspace táblából. Egyes ML használati esetekben előfordulhat, hogy ugyanazt az adatot többször is be kell olvasnia ugyanabból a Keyspaces táblából. Ebben az esetben azt javasoljuk, hogy mentse az adatait egy Amazon S3 tárolóba, hogy elkerülje a további költségeket költségs olvas az Amazon Keyspacesről. A forgatókönyvtől függően használhatja is Amazon EMR nak nek lenyelik egy nagyon nagy Amazon S3 fájlt a SageMakerbe.

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

Ezután betanítunk egy ML-modellt a KMeans algoritmussal, és megbizonyosodunk arról, hogy a klaszterek létrejöttek. Ebben a konkrét forgatókönyvben azt látja, hogy a létrehozott fürtök nyomtatásra kerülnek, ami azt mutatja, hogy a nyersadatkészletben lévő ügyfelek az adatkészlet különböző attribútumai alapján csoportosítva lettek. Ez a klaszterinformáció felhasználható célzott marketingkampányokhoz.

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

(Opcionális) Ezután az ML-modell által azonosított ügyfélszegmenseket visszamentjük egy Amazon Keyspaces táblába a célzott marketing érdekében. Egy kötegelt feladat beolvashatja ezeket az adatokat, és célzott kampányokat futtathat az ügyfelek számára meghatározott szegmensekben.

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

Végül, mi tisztítsa meg az erőforrásokat az oktatóprogram során készült, hogy elkerülje a további költségeket.

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

A kulcstér és a táblázatok törlésének befejezése néhány másodperctől egy percig is eltarthat. Amikor töröl egy kulcsteret, a kulcstér és az összes táblája törlődik, és megszűnik a költségek felhalmozódása.

Következtetés

Ez a bejegyzés bemutatta, hogyan töltheti be az Amazon Keyspaces ügyféladatait a SageMakerbe, és hogyan taníthat meg egy klaszterezési modellt, amely lehetővé tette az ügyfelek szegmentálását. Ezeket az információkat célzott marketingre használhatja fel, így nagymértékben javíthatja üzleti KPI-jét. Ha többet szeretne megtudni az Amazon Keyspacesről, tekintse át a következő forrásokat:

• Gépi tanulási modellek képzése Amazon Keyspaces adatforrásként (SageMaker jegyzetfüzet)
• Csatlakozzon az Amazon Keyspaces-hez asztaláról IntelliJ, PyCharm vagy DataGrip IDE-k segítségével
• CQL nyelvi referencia az Amazon Keyspaceshez (Apache Cassandra számára)
• Hogyan állíthat be parancssori hozzáférést az Amazon Keyspaceshez (Apache Cassandra számára) az új fejlesztői eszközkészlet, a Docker kép használatával
• Identitás- és hozzáféréskezelés az Amazon Keyspaceshez (Apache Cassandra számára)
• Csatlakozás az Amazon Keyspaces szolgáltatáshoz a SageMaker segítségével szolgáltatás-specifikus hitelesítő adatok
• Frissség, gyakoriság, pénzbeli érték (RFM)
• Kaggle kód hivatkozás

A szerzőkről

Vadim Ljahovics Senior Solutions Architect a San Francisco Bay Area-i AWS-nél, aki segít az ügyfeleknek áttérni az AWS-re. A nagyvállalatoktól a kis startupokig terjedő szervezetekkel dolgozik együtt innovációik támogatása érdekében. Emellett segít ügyfeleinek skálázható, biztonságos és költséghatékony megoldások kidolgozásában az AWS-en.

Parth Patel megoldások építésze az AWS-nél a San Francisco Bay Area-ban. Parth útmutatást ad az ügyfeleknek, hogy felgyorsítsák a felhő felé vezető utat, és segítsenek nekik az AWS felhő sikeres alkalmazásában. Az ML-re és az alkalmazások modernizálására összpontosít.

Ram Pathangi megoldások építésze az AWS-nél a San Francisco Bay Area-ban. Segített a mezőgazdasági, biztosítási, banki, kiskereskedelmi, egészségügyi és élettudományi, vendéglátási és csúcstechnológiai ágazat ügyfeleinek sikeres üzletvitelükben az AWS felhőben. Szakterülete az adatbázisok, az elemzések és az ML.

• Coinsmart. Európa legjobb Bitcoin- és kriptográfiai tőzsdéje.
• Platoblockchain. Web3 metaverzum intelligencia. Felerősített tudás. SZABAD HOZZÁFÉRÉS.
• CryptoHawk. Altcoin radar. Ingyenes próbaverzió.
• Forrás: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/