डेटा स्रोत के रूप में Amazon Keyspaces का उपयोग करके ट्रेन मशीन लर्निंग मॉडल

प्लेटो द्वारा पुनर्प्रकाशित

अनुयायियों: 0

औद्योगिक उपकरण रखरखाव, व्यापार निगरानी, बेड़े प्रबंधन, और मार्ग अनुकूलन के लिए कई अनुप्रयोगों को उच्च गति और कम विलंबता पर डेटा संसाधित करने के लिए ओपन-सोर्स कैसेंड्रा एपीआई और ड्राइवरों का उपयोग करके बनाया गया है। कैसेंड्रा टेबल को स्वयं प्रबंधित करना समय लेने वाला और महंगा हो सकता है। अमेज़ॅन कीस्पेस (अपाचे कैसेंड्रा के लिए) आपको अतिरिक्त बुनियादी ढांचे के प्रबंधन के बिना एडब्ल्यूएस क्लाउड में कैसेंड्रा टेबल सेट अप, सुरक्षित और स्केल करने देता है।

इस पोस्ट में, हम आपको उच्च स्तर पर Amazon Keyspaces का उपयोग करके प्रशिक्षण मशीन लर्निंग (ML) मॉडल से संबंधित AWS सेवाओं के बारे में बताएंगे, और Amazon Keyspaces से डेटा अंतर्ग्रहण करने के लिए चरण-दर-चरण निर्देश प्रदान करेंगे। अमेज़न SageMaker और एक मॉडल को प्रशिक्षित करना जिसका उपयोग विशिष्ट ग्राहक विभाजन उपयोग के मामले में किया जा सकता है।

क्लाउड में एमएल प्रक्रियाओं को लागू करने में व्यवसायों की मदद करने के लिए एडब्ल्यूएस के पास कई सेवाएं हैं।

डेटा स्रोत प्लेटोब्लॉकचैन डेटा इंटेलिजेंस के रूप में अमेज़ॅन कीस्पेस का उपयोग करके ट्रेन मशीन लर्निंग मॉडल। लंबवत खोज। ऐ.

एडब्ल्यूएस एमएल स्टैक में तीन परतें होती हैं। बीच की परत में है SageMaker, जो डेवलपर्स, डेटा वैज्ञानिकों और एमएल इंजीनियरों को बड़े पैमाने पर एमएल मॉडल बनाने, प्रशिक्षित करने और तैनात करने की क्षमता प्रदान करता है। यह एमएल वर्कफ़्लो के प्रत्येक चरण से जटिलता को दूर करता है ताकि आप अपने एमएल उपयोग मामलों को अधिक आसानी से परिनियोजित कर सकें। इसमें ग्राहक के व्यवहार की भविष्यवाणी करने के लिए भविष्य कहनेवाला रखरखाव से लेकर कंप्यूटर विज़न तक कुछ भी शामिल है। ग्राहक सेजमेकर के साथ डेटा वैज्ञानिकों की उत्पादकता में 10 गुना तक सुधार हासिल करते हैं।

अपाचे कैसेंड्रा गैर-संरचित या अर्ध-संरचित डेटा के साथ पढ़ने-भारी उपयोग के मामलों के लिए एक लोकप्रिय विकल्प है। उदाहरण के लिए, एक लोकप्रिय खाद्य वितरण व्यवसाय डिलीवरी के समय का अनुमान लगाता है, और एक खुदरा ग्राहक अपाचे कैसेंड्रा डेटाबेस में उत्पाद कैटलॉग जानकारी का उपयोग करके बार-बार बना रह सकता है। अमेज़न कीस्पेस एक स्केलेबल, अत्यधिक उपलब्ध और प्रबंधित सर्वर रहित Apache Cassandra-संगत डेटाबेस सेवा है। आपको सर्वर को प्रोविज़न करने, पैच करने या प्रबंधित करने की आवश्यकता नहीं है, और आपको सॉफ़्टवेयर स्थापित करने, बनाए रखने या संचालित करने की आवश्यकता नहीं है। तालिकाएं स्वचालित रूप से ऊपर और नीचे स्केल कर सकती हैं, और आप केवल उन संसाधनों के लिए भुगतान करते हैं जिनका आप उपयोग करते हैं। Amazon Keyspaces आपको उसी Cassandra एप्लिकेशन कोड और डेवलपर टूल का उपयोग करके AWS पर अपना कैसेंड्रा वर्कलोड चलाने देता है जिसका आप आज उपयोग करते हैं।

सेजमेकर एक सूट प्रदान करता है अंतर्निहित एल्गोरिदम डेटा वैज्ञानिकों और एमएल प्रैक्टिशनरों को प्रशिक्षण शुरू करने और एमएल मॉडल को जल्दी से तैनात करने में मदद करने के लिए। इस पोस्ट में, हम आपको दिखाएंगे कि कैसे एक खुदरा ग्राहक कीस्पेस डेटाबेस में ग्राहक खरीद इतिहास का उपयोग कर सकता है और मार्केटिंग अभियानों के लिए विभिन्न ग्राहक खंडों को लक्षित कर सकता है।

कश्मीर साधन एक अनुपयोगी शिक्षण एल्गोरिथम है। यह डेटा के भीतर असतत समूहों को खोजने का प्रयास करता है, जहां एक समूह के सदस्य एक दूसरे के लिए यथासंभव समान होते हैं और अन्य समूहों के सदस्यों से यथासंभव भिन्न होते हैं। आप उन विशेषताओं को परिभाषित करते हैं जिन्हें आप समानता निर्धारित करने के लिए एल्गोरिदम का उपयोग करना चाहते हैं। सेजमेकर के संशोधित संस्करण का उपयोग करता है वेब-स्केल k- का अर्थ है क्लस्टरिंग एल्गोरिथम. एल्गोरिथम के मूल संस्करण की तुलना में, सेजमेकर द्वारा उपयोग किया गया संस्करण अधिक सटीक है। हालांकि, मूल एल्गोरिथ्म की तरह, यह बड़े पैमाने पर डेटासेट को मापता है और प्रशिक्षण समय में सुधार करता है।

समाधान अवलोकन

निर्देश मानते हैं कि आप कोड चलाने के लिए सेजमेकर स्टूडियो का उपयोग कर रहे होंगे। संबंधित कोड को साझा किया गया है एडब्ल्यूएस नमूना गिटहब. प्रयोगशाला में दिए गए निर्देशों का पालन करते हुए, आप निम्न कार्य कर सकते हैं:

आवश्यक निर्भरताएँ स्थापित करें।
Amazon Keyspaces से कनेक्ट करें, एक टेबल बनाएं और सैंपल डेटा को निगलें।
Amazon Keyspaces में डेटा का उपयोग करके एक वर्गीकरण ML मॉडल बनाएं।
मॉडल परिणामों का अन्वेषण करें।
नव निर्मित संसाधनों को साफ करें।

एक बार पूरा हो जाने पर, आप निम्न छवि में दिखाए गए अनुसार एमएल मॉडल को प्रशिक्षित करने के लिए अमेज़ॅन कीस्पेस के साथ सेजमेकर को एकीकृत कर देंगे।

अब आप इसका अनुसरण कर सकते हैं चरण-दर-चरण निर्देश इस पोस्ट में सेजमेकर का उपयोग करके अमेज़ॅन कीस्पेस में संग्रहीत कच्चे डेटा को निगलना और इस प्रकार एमएल प्रोसेसिंग के लिए पुनर्प्राप्त डेटा।

.. पूर्वापेक्षाएँ

सबसे पहले, सेजमेकर पर नेविगेट करें।

अगला, यदि आप पहली बार सेजमेकर का उपयोग कर रहे हैं, तो चुनें शुरू करे .

अगला, चयन करें सेजमेकर डोमेन सेटअप करें.

इसके बाद, नाम के साथ एक नया यूजर प्रोफाइल बनाएं - सेजमेकरयूजर, और चुनें नई भूमिका बनाएं में डिफ़ॉल्ट निष्पादन भूमिका उप खंड।

इसके बाद, पॉप अप होने वाली स्क्रीन में, कोई भी चुनें अमेज़न सरल भंडारण सेवा (अमेज़न S3) बकेट, और क्रिएट रोल चुनें।

सेजमेकर को भूमिका से अस्थायी क्रेडेंशियल्स का उपयोग करके कीस्पेस टेबल तक पहुंचने की अनुमति देने के लिए इस भूमिका का उपयोग निम्नलिखित चरणों में किया जाएगा। यह नोटबुक में उपयोगकर्ता नाम और पासवर्ड संग्रहीत करने की आवश्यकता को समाप्त करता है।

इसके बाद, इससे जुड़ी भूमिका को पुनः प्राप्त करें सेजमेकरयूजर जो सारांश अनुभाग से पिछले चरण में बनाया गया था।

फिर, पर नेविगेट करें AWS कंसोल और ऊपर देखो AWS आइडेंटिटी एंड एक्सेस मैनेजमेंट (IAM)। IAM के भीतर, रोल्स पर नेविगेट करें। भूमिकाओं के भीतर, पिछले चरण में पहचानी गई निष्पादन भूमिका की खोज करें।

इसके बाद, पिछले चरण में पहचानी गई भूमिका का चयन करें और अनुमतियाँ जोड़ें चुनें। दिखाई देने वाले ड्रॉप डाउन में, इनलाइन नीति बनाएं चुनें। सेजमेकर आपको पहुंच का एक विस्तृत स्तर प्रदान करने देता है जो यह प्रतिबंधित करता है कि उपयोगकर्ता/एप्लिकेशन व्यावसायिक आवश्यकताओं के आधार पर क्या कार्य कर सकता है।

फिर, JSON टैब चुनें और नीति को Github के नोट अनुभाग से कॉपी करें पृष्ठ. यह नीति सेजमेकर नोटबुक को कीस्पेस से कनेक्ट करने और आगे की प्रक्रिया के लिए डेटा पुनर्प्राप्त करने की अनुमति देती है।

फिर, फिर से और ड्रॉप डाउन से अनुमतियाँ जोड़ें का चयन करें, और नीति संलग्न करें का चयन करें।

लुकअप AmazonKeyspacesFullAccess नीति, और मिलान परिणाम के बगल में स्थित चेकबॉक्स का चयन करें, और नीतियों को संलग्न करें का चयन करें।

सत्यापित करें कि अनुमतियाँ नीतियां अनुभाग में शामिल हैं AmazonS3FullAccess, AmazonSageMakerFullAccess, AmazonKeyspacesFullAccess, साथ ही नई जोड़ी गई इनलाइन नीति।

इसके बाद, एडब्ल्यूएस कंसोल का उपयोग करके सेजमेकर स्टूडियो में नेविगेट करें और सेजमेकर स्टूडियो का चयन करें। वहां पहुंचने के बाद, लॉन्च ऐप चुनें और स्टूडियो चुनें।

नोटबुक वॉकथ्रू

सेजमेकर नोटबुक से कीस्पेस से कनेक्ट करने का पसंदीदा तरीका उपयोग करना है AWS हस्ताक्षर संस्करण 4 प्रक्रिया (SigV4) आधारित अस्थायी साख प्रमाणीकरण के लिए। इस परिदृश्य में, हमें Keyspaces क्रेडेंशियल जेनरेट या स्टोर करने की आवश्यकता नहीं है और SigV4 प्लगइन के साथ प्रमाणित करने के लिए क्रेडेंशियल्स का उपयोग कर सकते हैं। अस्थायी सुरक्षा क्रेडेंशियल में एक एक्सेस कुंजी आईडी और एक गुप्त एक्सेस कुंजी शामिल होती है। हालाँकि, उनमें एक सुरक्षा टोकन भी शामिल होता है जो इंगित करता है कि क्रेडेंशियल कब समाप्त हो रहे हैं। इस पोस्ट में, हम एक IAM भूमिका बनाएंगे और अस्थायी सुरक्षा क्रेडेंशियल जेनरेट करेंगे।

सबसे पहले, हम एक ड्राइवर (कैसेंड्रा-सिगव 4) स्थापित करते हैं। यह ड्राइवर आपको AWS सिग्नेचर वर्जन 4 प्रोसेस (SigV4) का उपयोग करके अपने API अनुरोधों में प्रमाणीकरण जानकारी जोड़ने में सक्षम बनाता है। प्लगइन का उपयोग करके, आप IAM उपयोगकर्ताओं और भूमिकाओं का उपयोग करके Amazon Keyspaces (अपाचे कैसेंड्रा के लिए) तक पहुंचने के लिए उपयोगकर्ताओं और एप्लिकेशन को अल्पकालिक क्रेडेंशियल प्रदान कर सकते हैं। इसके बाद, आप अतिरिक्त पैकेज निर्भरता के साथ एक आवश्यक प्रमाणपत्र आयात करेंगे। अंत में, आप नोटबुक को 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)

इसके बाद, अमेज़ॅन कीस्पेस से कनेक्ट करें और कनेक्शन को मान्य करने के लिए कीस्पेस से सिस्टम डेटा को पंडों डेटाफ़्रेम में पढ़ें।

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

इसके बाद, कच्चे डेटा सेट पर प्रशिक्षण के लिए डेटा तैयार करें। इस पोस्ट से जुड़े पायथन नोटबुक में, से डाउनलोड किए गए खुदरा डेटा सेट का उपयोग करें यहाँ उत्पन्न करें, और इसे संसाधित करें। डेटा सेट को देखते हुए हमारा व्यावसायिक उद्देश्य एक विशिष्ट मीट्रिक कॉल RFM का उपयोग करके ग्राहकों को क्लस्टर करना है। RFM मॉडल तीन मात्रात्मक कारकों पर आधारित है:

रीसेंसी: किसी ग्राहक ने हाल ही में कितनी खरीदारी की है।
फ़्रिक्वेंसी: ग्राहक कितनी बार खरीदारी करता है।
मौद्रिक मूल्य: ग्राहक खरीदारी पर कितना पैसा खर्च करता है।

RFM विश्लेषण संख्यात्मक रूप से इन तीन श्रेणियों में से प्रत्येक में एक ग्राहक को रैंक करता है, आमतौर पर 1 से 5 के पैमाने पर (संख्या जितनी अधिक होगी, परिणाम उतना ही बेहतर होगा)। "सर्वश्रेष्ठ" ग्राहक को प्रत्येक श्रेणी में शीर्ष स्कोर प्राप्त होगा। हम पांडा के क्वांटाइल-आधारित विवेकीकरण फ़ंक्शन (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()

इस उदाहरण में, हम Keyspace टेबल से रिकॉर्ड पढ़ने के लिए CQL का उपयोग करते हैं। कुछ एमएल उपयोग-मामलों में, आपको एक ही कीस्पेस तालिका से एक ही डेटा को कई बार पढ़ने की आवश्यकता हो सकती है। इस मामले में, हम अनुशंसा करेंगे कि आप अतिरिक्त खर्च से बचने के लिए अपने डेटा को Amazon S3 बकेट में सहेज लें लागतAmazon Keyspaces से पढ़ रहा है। आपके परिदृश्य के आधार पर, आप इसका उपयोग भी कर सकते हैं अमेज़ॅन ईएमआर सेवा मेरे निगलना SageMaker में एक बहुत बड़ी Amazon S3 फ़ाइल।

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

इसके बाद, हम KMeans एल्गोरिथम का उपयोग करके एक ML मॉडल को प्रशिक्षित करते हैं और सुनिश्चित करते हैं कि क्लस्टर बनाए गए हैं। इस विशेष परिदृश्य में, आप देखेंगे कि बनाए गए क्लस्टर मुद्रित होते हैं, यह दिखाते हुए कि कच्चे डेटा सेट में ग्राहकों को डेटा सेट में विभिन्न विशेषताओं के आधार पर एक साथ समूहीकृत किया गया है। इस क्लस्टर जानकारी का उपयोग लक्षित विपणन अभियानों के लिए किया जा सकता है।

# 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 में ग्राहक डेटा कैसे डाला जाए और एक क्लस्टरिंग मॉडल को प्रशिक्षित किया जाए जिससे आप ग्राहकों को विभाजित कर सकें। आप इस जानकारी का उपयोग लक्षित मार्केटिंग के लिए कर सकते हैं, इस प्रकार आपके व्यवसाय केपीआई में काफी सुधार हो सकता है। Amazon Keyspaces के बारे में अधिक जानने के लिए, निम्नलिखित संसाधनों की समीक्षा करें:

लेखक के बारे में

वादिम ल्याखोविच सैन फ्रांसिस्को खाड़ी क्षेत्र में AWS में एक वरिष्ठ समाधान आर्किटेक्ट है जो ग्राहकों को AWS में माइग्रेट करने में मदद करता है। वह अपने नवाचारों का समर्थन करने के लिए बड़े उद्यमों से लेकर छोटे स्टार्टअप तक के संगठनों के साथ काम कर रहा है। वह ग्राहकों को एडब्ल्यूएस पर स्केलेबल, सुरक्षित और लागत प्रभावी समाधान तैयार करने में भी मदद कर रहा है।

पार्थ पटेल सैन फ्रांसिस्को खाड़ी क्षेत्र में एडब्ल्यूएस में एक समाधान वास्तुकार है। पार्थ ग्राहकों को क्लाउड की यात्रा में तेजी लाने और एडब्ल्यूएस क्लाउड को सफलतापूर्वक अपनाने में मदद करने के लिए उनका मार्गदर्शन करता है। वह एमएल और एप्लिकेशन आधुनिकीकरण पर केंद्रित है।

राम पठानी सैन फ्रांसिस्को खाड़ी क्षेत्र में एडब्ल्यूएस में एक समाधान वास्तुकार है। उन्होंने एडब्ल्यूएस क्लाउड पर अपने व्यवसाय को सफलतापूर्वक चलाने के लिए कृषि, बीमा, बैंकिंग, खुदरा, स्वास्थ्य देखभाल और जीवन विज्ञान, आतिथ्य और हाई-टेक वर्टिकल में ग्राहकों की मदद की है। वह डेटाबेस, एनालिटिक्स और एमएल में माहिर हैं।