ฝึกโมเดลการเรียนรู้ของเครื่องโดยใช้ Amazon Keyspaces เป็นแหล่งข้อมูล

เผยแพร่ซ้ำโดยเพลโต

ผู้ติดตาม: 0

แอปพลิเคชั่นจำนวนมากมีไว้สำหรับการบำรุงรักษาอุปกรณ์อุตสาหกรรม การตรวจสอบการค้า การจัดการกลุ่มยานพาหนะ และการเพิ่มประสิทธิภาพเส้นทาง สร้างขึ้นโดยใช้โอเพนซอร์ส Cassandra API และไดรเวอร์เพื่อประมวลผลข้อมูลด้วยความเร็วสูงและมีเวลาแฝงต่ำ การจัดการโต๊ะ Cassandra ด้วยตัวเองอาจใช้เวลานานและมีราคาแพง Amazon Keyspaces (สำหรับ Apache Cassandra) ให้คุณตั้งค่า รักษาความปลอดภัย และปรับขนาดตาราง Cassandra ใน AWS Cloud ได้โดยไม่ต้องจัดการโครงสร้างพื้นฐานเพิ่มเติม

ในโพสต์นี้ เราจะแนะนำคุณเกี่ยวกับบริการของ AWS ที่เกี่ยวข้องกับโมเดลการเรียนรู้ของเครื่อง (ML) โดยใช้ Amazon Keyspaces ในระดับสูง และให้คำแนะนำทีละขั้นตอนสำหรับการนำเข้าข้อมูลจาก Amazon Keyspaces เข้าไป อเมซอน SageMaker และฝึกอบรมแบบจำลองที่สามารถใช้สำหรับกรณีการใช้งานการแบ่งกลุ่มลูกค้าเฉพาะ

AWS มีบริการหลายอย่างเพื่อช่วยให้ธุรกิจนำกระบวนการ ML ไปใช้ในระบบคลาวด์

ฝึกโมเดลการเรียนรู้ของเครื่องโดยใช้ Amazon Keyspaces เป็นแหล่งข้อมูล PlatoBlockchain Data Intelligence ค้นหาแนวตั้ง AI.

AWS ML Stack มีสามชั้น ในชั้นกลางคือ SageMakerซึ่งช่วยให้นักพัฒนา นักวิทยาศาสตร์ข้อมูล และวิศวกร ML สามารถสร้าง ฝึกอบรม และปรับใช้โมเดล ML ได้ตามขนาดที่ต้องการ โดยจะขจัดความซับซ้อนออกจากแต่ละขั้นตอนของเวิร์กโฟลว์ ML เพื่อให้คุณสามารถปรับใช้กรณีการใช้งาน ML ของคุณได้ง่ายขึ้น ซึ่งรวมถึงทุกอย่างตั้งแต่การบำรุงรักษาเชิงคาดการณ์ไปจนถึงการมองเห็นด้วยคอมพิวเตอร์เพื่อคาดการณ์พฤติกรรมของลูกค้า ลูกค้าสามารถปรับปรุงประสิทธิภาพการทำงานของนักวิทยาศาสตร์ข้อมูลได้ถึง 10 เท่าด้วย SageMaker

Apache Cassandra เป็นตัวเลือกยอดนิยมสำหรับกรณีการใช้งานที่มีการอ่านจำนวนมากซึ่งมีข้อมูลที่ไม่มีโครงสร้างหรือกึ่งโครงสร้าง ตัวอย่างเช่น ธุรกิจส่งอาหารยอดนิยมจะประเมินเวลาในการจัดส่ง และลูกค้ารายย่อยสามารถคงอยู่บ่อยๆ โดยใช้ข้อมูลแคตตาล็อกผลิตภัณฑ์ในฐานข้อมูล Apache Cassandra คีย์สเปซของ Amazon เป็นบริการฐานข้อมูลที่เข้ากันได้กับ Apache Cassandra แบบไร้เซิร์ฟเวอร์ที่ปรับขนาดได้ พร้อมใช้งานสูง และได้รับการจัดการ คุณไม่จำเป็นต้องจัดเตรียม แพตช์ หรือจัดการเซิร์ฟเวอร์ และคุณไม่จำเป็นต้องติดตั้ง บำรุงรักษา หรือใช้งานซอฟต์แวร์ ตารางสามารถขยายขนาดขึ้นและลงได้โดยอัตโนมัติ และคุณจะจ่ายเฉพาะทรัพยากรที่คุณใช้เท่านั้น Amazon Keyspaces ช่วยให้คุณเรียกใช้ปริมาณงาน Cassandra บน AWS ได้โดยใช้โค้ดแอปพลิเคชัน Cassandra และเครื่องมือสำหรับนักพัฒนาที่คุณใช้ในปัจจุบัน

SageMaker มีชุดของ อัลกอริทึมในตัว เพื่อช่วยให้นักวิทยาศาสตร์ข้อมูลและผู้ปฏิบัติงาน ML เริ่มต้นการฝึกอบรมและปรับใช้โมเดล ML ได้อย่างรวดเร็ว ในโพสต์นี้ เราจะแสดงให้คุณเห็นว่าลูกค้ารายย่อยสามารถใช้ประวัติการซื้อของลูกค้าในฐานข้อมูล Keyspaces และกำหนดเป้าหมายกลุ่มลูกค้าที่แตกต่างกันสำหรับแคมเปญการตลาดได้อย่างไร

K หมายถึง เป็นอัลกอริธึมการเรียนรู้แบบไม่มีผู้ดูแล จะพยายามค้นหาการจัดกลุ่มแบบไม่ต่อเนื่องภายในข้อมูล โดยที่สมาชิกของกลุ่มมีความคล้ายคลึงกันมากที่สุดและแตกต่างจากสมาชิกของกลุ่มอื่นๆ มากที่สุด คุณกำหนดแอตทริบิวต์ที่คุณต้องการให้อัลกอริทึมใช้เพื่อกำหนดความคล้ายคลึงกัน SageMaker ใช้เวอร์ชันที่แก้ไขแล้วของ อัลกอริทึมการจัดกลุ่ม k-mean ระดับเว็บ. เมื่อเทียบกับเวอร์ชันดั้งเดิมของอัลกอริทึม เวอร์ชันที่ใช้โดย SageMaker มีความแม่นยำมากกว่า อย่างไรก็ตาม เช่นเดียวกับอัลกอริธึมดั้งเดิม มันปรับขนาดเป็นชุดข้อมูลขนาดใหญ่และปรับปรุงเวลาในการฝึกอบรม

ภาพรวมโซลูชัน

คำแนะนำจะถือว่าคุณจะใช้ SageMaker Studio เพื่อเรียกใช้โค้ด มีการแชร์รหัสที่เกี่ยวข้องบน AWS ตัวอย่าง GitHub. โดยทำตามคำแนะนำในห้องทดลอง คุณสามารถทำสิ่งต่อไปนี้ได้:

ติดตั้งการพึ่งพาที่จำเป็น
เชื่อมต่อกับ Amazon Keyspaces สร้างตาราง และนำเข้าข้อมูลตัวอย่าง
สร้างโมเดล ML การจัดประเภทโดยใช้ข้อมูลใน Amazon Keyspaces
สำรวจผลลัพธ์ของแบบจำลอง
ทำความสะอาดทรัพยากรที่สร้างขึ้นใหม่

เมื่อเสร็จแล้ว คุณจะผสานรวม SageMaker กับ Amazon Keyspaces เพื่อฝึกโมเดล ML ดังที่แสดงในภาพต่อไปนี้

ตอนนี้คุณสามารถทำตามไฟล์ คำแนะนำทีละขั้นตอน ในโพสต์นี้เพื่อนำเข้าข้อมูลดิบที่จัดเก็บไว้ใน Amazon Keyspaces โดยใช้ SageMaker และข้อมูลที่ดึงมาเพื่อการประมวลผล ML

เบื้องต้น

ขั้นแรก ไปที่ SageMaker

ต่อไป หากนี่เป็นครั้งแรกที่คุณใช้ SageMaker ให้เลือก เริ่มต้นเลย.

ถัดไปเลือก ตั้งค่าโดเมน SageMaker.

ถัดไป สร้างโปรไฟล์ผู้ใช้ใหม่ด้วยชื่อ – ผู้ใช้ปราชญ์และเลือก สร้างบทบาทใหม่ ใน บทบาทการดำเนินการเริ่มต้น ส่วนย่อย

ถัดไป ในหน้าจอที่ปรากฏขึ้น ให้เลือกใดๆ บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ที่เก็บข้อมูล แล้วเลือก สร้างบทบาท

บทบาทนี้จะถูกใช้ในขั้นตอนต่อไปนี้เพื่ออนุญาตให้ SageMaker เข้าถึง Keyspaces Table โดยใช้ข้อมูลประจำตัวชั่วคราวจากบทบาท ช่วยลดความจำเป็นในการจัดเก็บชื่อผู้ใช้และรหัสผ่านในโน้ตบุ๊ก

ถัดไป ดึงบทบาทที่เกี่ยวข้องกับ ผู้ใช้ปราชญ์ ที่สร้างขึ้นในขั้นตอนก่อนหน้าจากส่วนสรุป

จากนั้นไปที่ คอนโซล AWS และมองขึ้นไป AWS Identity and Access Management (IAM) ภายใน IAM ให้ไปที่ Roles ภายในบทบาท ค้นหาบทบาทการดำเนินการที่ระบุในขั้นตอนก่อนหน้า

ถัดไป เลือกบทบาทที่ระบุในขั้นตอนก่อนหน้า และเลือก เพิ่มสิทธิ์ ในเมนูแบบเลื่อนลงที่ปรากฏขึ้น ให้เลือกสร้างนโยบายแบบอินไลน์ SageMaker ให้คุณมีระดับการเข้าถึงที่ละเอียด ซึ่งจำกัดการกระทำที่ผู้ใช้/แอปพลิเคชันสามารถทำได้ตามความต้องการทางธุรกิจ

จากนั้นเลือกแท็บ JSON และคัดลอกนโยบายจากส่วนหมายเหตุของ Github หน้า. นโยบายนี้อนุญาตให้โน้ตบุ๊ก SageMaker เชื่อมต่อกับ Keyspaces และดึงข้อมูลเพื่อการประมวลผลต่อไป

จากนั้นเลือก เพิ่มสิทธิ์อีกครั้ง และจากดรอปดาวน์ แล้วเลือก แนบนโยบาย

ค้นหานโยบาย AmazonKeyspacesFullAccess และเลือกช่องทำเครื่องหมายถัดจากผลลัพธ์ที่ตรงกัน และเลือกแนบนโยบาย

ตรวจสอบว่าส่วนนโยบายสิทธิ์รวมถึง AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccessรวมถึงนโยบายอินไลน์ที่เพิ่มใหม่

ถัดไป ไปที่ SageMaker Studio โดยใช้คอนโซล AWS และเลือก SageMaker Studio เมื่อถึงที่นั่น ให้เลือก Launch App แล้วเลือก Studio

คำแนะนำสำหรับโน้ตบุ๊ก

วิธีที่ต้องการในการเชื่อมต่อกับ Keyspaces จาก SageMaker Notebook คือการใช้ กระบวนการ AWS Signature เวอร์ชัน 4 (SigV4) ตาม ข้อมูลประจำตัวชั่วคราว สำหรับการรับรองความถูกต้อง ในสถานการณ์สมมตินี้ เราไม่จำเป็นต้องสร้างหรือจัดเก็บข้อมูลรับรอง Keyspaces และสามารถใช้ข้อมูลประจำตัวเพื่อรับรองความถูกต้องด้วยปลั๊กอิน SigV4 ข้อมูลรับรองความปลอดภัยชั่วคราวประกอบด้วย ID คีย์การเข้าถึงและคีย์การเข้าถึงที่เป็นความลับ อย่างไรก็ตาม ยังมีโทเค็นความปลอดภัยที่ระบุว่าข้อมูลประจำตัวจะหมดอายุเมื่อใด ในโพสต์นี้ เราจะสร้างบทบาท IAM และสร้างข้อมูลรับรองความปลอดภัยชั่วคราว

ขั้นแรก เราติดตั้งไดรเวอร์ (cassandra-sigv4) ไดรเวอร์นี้ช่วยให้คุณเพิ่มข้อมูลการตรวจสอบสิทธิ์ไปยังคำขอ API ของคุณโดยใช้กระบวนการ AWS Signature เวอร์ชัน 4 (SigV4) เมื่อใช้ปลั๊กอิน คุณจะให้ข้อมูลประจำตัวระยะสั้นแก่ผู้ใช้และแอปพลิเคชันเพื่อเข้าถึง Amazon Keyspaces (สำหรับ Apache Cassandra) โดยใช้ผู้ใช้และบทบาท IAM ต่อจากนี้ คุณจะต้องนำเข้าใบรับรองที่จำเป็นพร้อมกับการขึ้นต่อกันของแพ็คเกจเพิ่มเติม ในท้ายที่สุด คุณจะอนุญาตให้โน้ตบุ๊กรับบทบาทพูดคุยกับคีย์สเปซ

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

ถัดไป เชื่อมต่อกับ Amazon Keyspaces และอ่านข้อมูลระบบจาก Keyspaces ไปยัง Pandas DataFrame เพื่อตรวจสอบการเชื่อมต่อ

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

ต่อไป เตรียมข้อมูลสำหรับฝึกชุดข้อมูลดิบ ในสมุดบันทึก python ที่เชื่อมโยงกับโพสต์นี้ ให้ใช้ชุดข้อมูลการขายปลีกที่ดาวน์โหลดจาก โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติมและประมวลผล วัตถุประสงค์ทางธุรกิจของเราที่ได้รับชุดข้อมูลคือการจัดกลุ่มลูกค้าโดยใช้การเรียกเมตริกเฉพาะ RFM แบบจำลอง RFM ขึ้นอยู่กับปัจจัยเชิงปริมาณสามประการ:

ความใหม่: ลูกค้าทำการซื้อครั้งล่าสุดเมื่อใด
ความถี่: ลูกค้าทำการซื้อบ่อยเพียงใด
มูลค่าเงิน: จำนวนเงินที่ลูกค้าใช้จ่ายในการซื้อสินค้า

การวิเคราะห์ RFM จะจัดอันดับลูกค้าในแต่ละหมวดหมู่จากทั้งสามหมวดนี้ โดยทั่วไปแล้วจะอยู่ในระดับ 1 ถึง 5 (ตัวเลขยิ่งสูง ผลลัพธ์ก็จะยิ่งดีขึ้น) ลูกค้าที่ "ดีที่สุด" จะได้รับคะแนนสูงสุดในทุกหมวด เราจะใช้ฟังก์ชันการแยกส่วนตาม Quantile (qcut) ของแพนด้า จะช่วยแยกค่าออกเป็นถังที่มีขนาดเท่ากันโดยอิงหรือตามปริมาณตัวอย่าง

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

ในตัวอย่างนี้ เราใช้ CQL เพื่ออ่านบันทึกจากตาราง Keyspace ในบางกรณี ML use-case คุณอาจต้องอ่านข้อมูลเดียวกันจากตาราง Keyspaces เดียวกันหลายๆ ครั้ง ในกรณีนี้ เราขอแนะนำให้คุณบันทึกข้อมูลของคุณลงในบัคเก็ต Amazon S3 เพื่อหลีกเลี่ยงไม่ให้เกิดขึ้นเพิ่มเติม ราคากำลังอ่านจาก Amazon Keyspaces ขึ้นอยู่กับสถานการณ์ของคุณ คุณอาจใช้ อเมซอน EMR ไปยัง นำเข้า ไฟล์ Amazon S3 ขนาดใหญ่มากใน 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())

ต่อไป เราฝึกโมเดล ML โดยใช้อัลกอริธึม KMeans และตรวจสอบให้แน่ใจว่าสร้างคลัสเตอร์แล้ว ในสถานการณ์เฉพาะนี้ คุณจะเห็นว่ามีการพิมพ์คลัสเตอร์ที่สร้างขึ้น โดยแสดงว่าลูกค้าในชุดข้อมูลดิบได้รับการจัดกลุ่มเข้าด้วยกันตามแอตทริบิวต์ต่างๆ ในชุดข้อมูล ข้อมูลคลัสเตอร์นี้สามารถใช้สำหรับแคมเปญการตลาดเป้าหมาย

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

(ไม่บังคับ) ต่อไป เราจะบันทึกกลุ่มลูกค้าที่ได้รับการระบุโดยโมเดล ML กลับไปที่ตาราง Amazon Keyspaces สำหรับการตลาดเป้าหมาย ชุดงานสามารถอ่านข้อมูลนี้และเรียกใช้แคมเปญที่กำหนดเป้าหมายไปยังลูกค้าในกลุ่มเฉพาะ

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

ในที่สุดเรา ทำความสะอาดทรัพยากร สร้างขึ้นระหว่างบทช่วยสอนนี้เพื่อหลีกเลี่ยงค่าใช้จ่ายเพิ่มเติม

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

อาจใช้เวลาสองสามวินาทีถึงหนึ่งนาทีในการลบคีย์สเปซและตารางให้เสร็จสิ้น เมื่อคุณลบคีย์สเปซ คีย์สเปซและตารางทั้งหมดของคีย์สเปซจะถูกลบออก และคุณจะหยุดการเรียกเก็บเงินจากคีย์สเปซดังกล่าว

สรุป

โพสต์นี้แสดงวิธีการนำเข้าข้อมูลลูกค้าจาก Amazon Keyspaces ไปยัง SageMaker และฝึกอบรมโมเดลคลัสเตอร์ที่อนุญาตให้คุณแบ่งกลุ่มลูกค้าได้ คุณสามารถใช้ข้อมูลนี้สำหรับการตลาดแบบกำหนดเป้าหมาย ซึ่งจะช่วยปรับปรุง KPI ของธุรกิจของคุณได้อย่างมาก หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Amazon Keyspaces ให้ตรวจสอบแหล่งข้อมูลต่อไปนี้:

เกี่ยวกับผู้เขียน

วาดิม ไลโควิช เป็นสถาปนิกโซลูชันอาวุโสที่ AWS ในบริเวณอ่าวซานฟรานซิสโก ซึ่งช่วยให้ลูกค้าย้ายไปยัง AWS เขาทำงานร่วมกับองค์กรต่างๆ ตั้งแต่องค์กรขนาดใหญ่ไปจนถึงสตาร์ทอัพขนาดเล็ก เพื่อสนับสนุนนวัตกรรมของพวกเขา เขายังช่วยลูกค้าในการออกแบบโซลูชันที่ปรับขนาดได้ ปลอดภัย และคุ้มค่าบน AWS

พาร์ธ พาเทล เป็นสถาปนิกโซลูชันที่ AWS ในบริเวณอ่าวซานฟรานซิสโก Parth แนะนำลูกค้าให้เร่งความเร็วการเดินทางสู่ระบบคลาวด์และช่วยให้พวกเขานำ AWS Cloud มาใช้ได้สำเร็จ เขามุ่งเน้นไปที่ ML และความทันสมัยของแอปพลิเคชัน

ราม ปะทังคี เป็นสถาปนิกโซลูชันที่ AWS ในบริเวณอ่าวซานฟรานซิสโก เขาได้ช่วยลูกค้าในสาขาเกษตรกรรม ประกันภัย การธนาคาร การค้าปลีก การดูแลสุขภาพและวิทยาศาสตร์เพื่อชีวิต การบริการ และไฮเทคในการดำเนินธุรกิจให้ประสบความสำเร็จบน AWS Cloud เขาเชี่ยวชาญด้านฐานข้อมูล การวิเคราะห์ และ ML