Treenige masinõppemudeleid, kasutades andmeallikana Amazon Keyspacesi

Paljud tööstusseadmete hoolduseks, kaubanduse jälgimiseks, autopargi haldamiseks ja marsruudi optimeerimiseks mõeldud rakendused on loodud avatud lähtekoodiga Cassandra API-de ja draiverite abil, et töödelda andmeid suure kiiruse ja madala latentsusajaga. Cassandra laudade ise haldamine võib olla aeganõudev ja kulukas. Amazon Keyspaces (Apache Cassandra jaoks) võimaldab teil seadistada, kaitsta ja skaleerida Cassandra tabeleid AWS-i pilves ilma täiendavat infrastruktuuri haldamata.

Selles postituses tutvustame teile AWS-i teenuseid, mis on seotud masinõppe (ML) mudelite treenimisega kõrgel tasemel Amazon Keyspacesi kasutades, ja anname samm-sammult juhised andmete sisestamiseks Amazon Keyspacesist Amazon SageMaker ja mudeli väljaõpetamine, mida saab kasutada konkreetse kliendi segmenteerimise kasutusjuhu jaoks.

AWS-il on mitu teenust, mis aitavad ettevõtetel pilves ML-protsesse rakendada.

AWS ML Stackil on kolm kihti. Keskmises kihis on SageMaker, mis annab arendajatele, andmeteadlastele ja ML-inseneridele võimaluse luua, koolitada ja juurutada ML-mudeleid ulatuslikult. See eemaldab ML-i töövoo iga etapi keerukuse, et saaksite oma ML-i kasutusjuhtumeid hõlpsamini juurutada. See hõlmab kõike alates ennustavast hooldusest kuni arvutinägemiseni, et ennustada klientide käitumist. Kliendid parandavad SageMakeriga andmeteadlaste tootlikkust kuni 10 korda.

Apache Cassandra on populaarne valik struktureerimata või poolstruktureeritud andmetega raskete kasutusjuhtumite jaoks. Näiteks populaarne toidu kohaletoimetamise ettevõte hindab tarneaega ja jaeklient võib sageli jätkata Apache Cassandra andmebaasis oleva tootekataloogi teabe kasutamist. Amazoni võtmeruumid on skaleeritav, hästi kättesaadav ja hallatav serverita Apache Cassandraga ühilduv andmebaasiteenus. Teil ei ole vaja servereid varustada, paika panna ega hallata ning tarkvara installida, hooldada ega käitada. Tabeleid saab automaatselt suurendada ja vähendada ning maksate ainult kasutatavate ressursside eest. Amazon Keyspaces võimaldab teil käitada Cassandra töökoormust AWS-is, kasutades sama Cassandra rakenduse koodi ja arendaja tööriistu, mida kasutate täna.

SageMaker pakub komplekti sisseehitatud algoritmid aidata andmeteadlastel ja ML-i praktikutel kiiresti alustada koolitust ja ML-mudelite juurutamist. Selles postituses näitame teile, kuidas jaeklient saab kasutada võtmeruumide andmebaasis olevate klientide ostude ajalugu ja sihtida turunduskampaaniate jaoks erinevaid kliendisegmente.

K-tähendab on järelevalveta õppealgoritm. See püüab leida andmete seest diskreetseid rühmitusi, kus grupi liikmed on üksteisega võimalikult sarnased ja võimalikult erinevad teiste rühmade liikmetest. Saate määrata atribuudid, mida soovite, et algoritm kasutaks sarnasuse määramiseks. SageMaker kasutab modifitseeritud versiooni veebimastaapne k-keskmiste klasterdamisalgoritm. Algoritmi algversiooniga võrreldes on SageMakeri kasutatav versioon täpsem. Sarnaselt algsele algoritmile ulatub see aga suurte andmekogumiteni ja parandab treeninguaega.

Lahenduse ülevaade

Juhised eeldavad, et kasutaksite koodi käitamiseks SageMaker Studiot. Seotud koodi on jagatud AWS-i näidis GitHub. Järgides laboris antud juhiseid, saate teha järgmist.

• Installige vajalikud sõltuvused.
• Looge ühendus Amazon Keyspacesiga, looge tabel ja neelake näidisandmed.
• Looge Amazon Keyspaces olevate andmete põhjal klassifitseerimise ML-mudel.
• Uurige mudeli tulemusi.
• Puhastage vastloodud ressursse.

Kui olete lõpetanud, olete ML-mudelite koolitamiseks integreerinud SageMakeri Amazon Keyspacesiga, nagu on näidatud järgmisel pildil.

Nüüd saate järgida samm-sammult juhised selles postituses, et alla neelata Amazon Keyspacesis salvestatud töötlemata andmed, kasutades SageMakerit, ja sel viisil hangitud andmed ML-i töötlemiseks.

Eeldused

Esiteks navigeerige SageMakerisse.

Järgmiseks, kui kasutate SageMakerit esimest korda, valige Alustamine.

Järgmine vali Seadistage SageMakeri domeen.

Järgmisena looge uus kasutajaprofiil nimega - salveikasutajaja valige Loo uus roll aasta Vaikimisi täitmise roll alajaotis.

Järgmisena valige hüpikaknast mis tahes Amazon Simple Storage Service (Amazon S3) ämber ja valige Loo roll.

Seda rolli kasutatakse järgmistes etappides, et võimaldada SageMakeril juurdepääsu võtmeruumide tabelisse, kasutades rolli ajutisi mandaate. See välistab vajaduse salvestada märkmikusse kasutajanime ja parooli.

Järgmisena hankige funktsiooniga seotud roll salveikasutaja mis loodi eelmises etapis kokkuvõtte jaotisest.

Seejärel navigeerige lehele AWS-i konsool ja vaata üles AWS-i identiteedi- ja juurdepääsuhaldus (IAM). Liikuge IAM-is jaotisesse Rollid. Otsige jaotisest Rollid eelmises etapis tuvastatud täitmisrolli.

Järgmisena valige eelmises etapis tuvastatud roll ja valige Lisa õigused. Ilmuvas rippmenüüs valige Loo tekstisisene poliitika. SageMaker võimaldab teil pakkuda üksikasjalikku juurdepääsutaset, mis piirab seda, milliseid toiminguid kasutaja/rakendus ärinõuetest lähtuvalt teha saab.

Seejärel valige vahekaart JSON ja kopeerige reegel Githubi jaotisest Märkused lehekülg. See reegel võimaldab SageMakeri sülearvutil luua ühenduse võtmeruumidega ja hankida andmeid edasiseks töötlemiseks.

Seejärel valige uuesti ja rippmenüüst Lisa õigused ning seejärel käsk Manusta poliitika.

Otsige üles AmazonKeyspacesFullAccessi poliitika ja märkige vastava tulemuse kõrval olev märkeruut ja valige Manusta poliitikad.

Veenduge, et lubade eeskirjade jaotis sisaldab AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, samuti äsja lisatud tekstisisesed eeskirjad.

Järgmisena navigeerige AWS-i konsooli abil SageMaker Studio ja valige SageMaker Studio. Kui olete seal, valige Käivita rakendus ja seejärel Studio.

Märkmiku tutvustus

Eelistatud viis SageMakeri sülearvutist Keyspacesiga ühenduse loomiseks on kasutada AWS-i allkirja versiooni 4 protsess (SigV4) põhineb Ajutised volikirjad autentimiseks. Selle stsenaariumi korral EI pea me Keyspacesi mandaate genereerima ega salvestama ning saame kasutada neid mandaate SigV4 pistikprogrammiga autentimiseks. Ajutised turbemandaadid koosnevad juurdepääsuvõtme ID-st ja salajasest juurdepääsuvõtmest. Kuid need sisaldavad ka turvamärki, mis näitab, millal mandaadid aeguvad. Selles postituses loome IAM-i rolli ja loome ajutised turbemandaadid.

Esiteks installime draiveri (cassandra-sigv4). See draiver võimaldab teil lisada oma API päringutele autentimisteavet, kasutades AWS-i allkirja versiooni 4 protsessi (SigV4). Pistikprogrammi abil saate anda kasutajatele ja rakendustele lühiajalisi mandaate, et pääseda juurde Amazon Keyspacesile (Apache Cassandra jaoks), kasutades IAM-i kasutajaid ja rolle. Pärast seda impordite nõutava sertifikaadi koos täiendavate paketisõltuvustega. Lõpuks lubate sülearvutil võtta endale võtmeruumiga rääkimise roll.

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

Järgmisena looge ühenduse kinnitamiseks ühendus Amazon Keyspacesiga ja lugege süsteemiandmeid Keyspacesist Pandas DataFrame'i.

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

Järgmisena valmistage andmed ette algandmete kogumi koolituseks. Kasutage selle postitusega seotud Pythoni märkmikus jaemüügiandmete kogumit, mis on alla laaditud aadressilt siinja töödelda seda. Meie ärieesmärk, arvestades andmekogumit, on koondada kliendid konkreetse mõõdiku kõne RFM-i abil. RFM-mudel põhineb kolmel kvantitatiivsel teguril:

• Hiljutine: kui hiljuti on klient ostu sooritanud.
• Sagedus: kui sageli klient ostu sooritab.
• Rahaline väärtus: kui palju raha klient ostudele kulutab.

RFM-analüüs järjestab kliendi numbriliselt kõigis nendes kolmes kategoorias, üldiselt skaalal 1 kuni 5 (mida suurem arv, seda parem tulemus). “Parim” klient saab igas kategoorias parima hinde. Kasutame pandade kvantiilipõhist diskreteerimisfunktsiooni (qcut). See aitab väärtusi diskretiseerida võrdse suurusega ämbriteks, mis põhinevad või põhinevad näidiskvantiilidel.

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

Selles näites kasutame võtmeruumi tabelist kirjete lugemiseks CQL-i. Mõnel ML-i kasutusjuhul peate võib-olla lugema samu andmeid samast Keyspaces tabelist mitu korda. Sel juhul soovitame teil salvestada oma andmed Amazon S3 ämbrisse, et vältida lisatehinguid hinds lugemine Amazon Keyspacesist. Sõltuvalt teie stsenaariumist võite ka kasutada Amazon EMR et neelama väga suur Amazon S3 fail SageMakerisse.

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

Järgmisena treenime KMeansi algoritmi kasutades ML-mudelit ja veendume, et klastrid on loodud. Selle konkreetse stsenaariumi korral näete, et loodud klastrid prinditakse, mis näitab, et algandmekogumi kliendid on rühmitatud andmekogumi erinevate atribuutide alusel. Seda klastri teavet saab kasutada suunatud turunduskampaaniate jaoks.

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

(Valikuline) Järgmisena salvestame ML-mudeliga tuvastatud kliendisegmendid tagasi Amazon Keyspacesi tabelisse sihitud turundamiseks. Paketttöö võib neid andmeid lugeda ja konkreetsetes segmentides klientidele sihitud kampaaniaid käitada.

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

Lõpuks, me ressursse puhastama selle õpetuse käigus loodud, et vältida lisatasusid.

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

Klahviruumi ja tabelite kustutamise lõpuleviimiseks võib kuluda mõni sekund kuni minut. Kui kustutate klahviruumi, kustutatakse klahviruum ja kõik selle tabelid ning te lõpetate nendelt tasude kogumise.

Järeldus

See postitus näitas teile, kuidas sisestada Amazon Keyspacesist kliendiandmeid SageMakerisse ja koolitada klasterdamismudelit, mis võimaldas teil kliente segmenteerida. Saate seda teavet kasutada sihipäraseks turunduseks, parandades seeläbi oluliselt oma ettevõtte KPI-d. Amazon Keyspacesi kohta lisateabe saamiseks vaadake üle järgmisi ressursse.

• Treenige masinõppe mudeleid, kasutades andmeallikana Amazoni võtmeruume (SageMakeri märkmik)
• Ühendage oma töölaualt Amazon Keyspacesiga IntelliJ, PyCharmi või DataGripi IDE-de abil
• CQL-i keeleviide Amazoni võtmeruumide jaoks (Apache Cassandra jaoks)
• Kuidas seadistada käsurea juurdepääsu Amazon Keyspacesile (Apache Cassandra jaoks), kasutades uut arendaja tööriistakomplekti Dockeri kujutist
• Amazon Keyspacesi identiteedi- ja juurdepääsuhaldus (Apache Cassandra jaoks)
• Ühenduse loomine Amazon Keyspacesiga rakendusest SageMaker teenusepõhised mandaadid
• Hiljutine, sagedus, rahaline väärtus (RFM)
• Kaggle koodi viide

Autoritest

Vadim Ljahhovitš on San Francisco lahe piirkonnas AWS-i vanemlahenduste arhitekt, kes aitab klientidel AWS-ile üle minna. Ta teeb koostööd organisatsioonidega alates suurettevõtetest kuni väikeste idufirmadeni, et toetada nende uuendusi. Samuti aitab ta klientidel luua AWS-is skaleeritavaid, turvalisi ja kulutõhusaid lahendusi.

Parth Patel on lahenduste arhitekt AWSis San Francisco lahe piirkonnas. Parth juhendab kliente oma pilveteekonda kiirendama ja aitab neil AWS-i pilve edukalt kasutusele võtta. Ta keskendub ML-ile ja rakenduste moderniseerimisele.

Ram Pathangi on lahenduste arhitekt AWSis San Francisco lahe piirkonnas. Ta on aidanud põllumajanduse, kindlustuse, panganduse, jaemüügi, tervishoiu ja bioteaduste, hotellinduse ja kõrgtehnoloogia vertikaalsete klientidel oma äri edukalt AWS-i pilves juhtida. Ta on spetsialiseerunud andmebaasidele, analüüsidele ja ML-ile.

• Münditark. Euroopa parim Bitcoini ja krüptobörs.
• Platoblockchain. Web3 metaversiooni intelligentsus. Täiustatud teadmised. TASUTA PÄÄS.
• CryptoHawk. Altcoini radar. Tasuta prooviversioon.
• Allikas: https://aws.amazon.com/blogs/machine-learning/train-machine-learning-models-using-amazon-keyspaces-as-a-data-source/