PySpark ट्यूटोरियल: PySpark के साथ शुरुआत करें

PySpark क्या है?

PySpark, Python में Apache Spark के लिए एक इंटरफ़ेस है। PySpark के साथ, आप वितरित प्रोसेसिंग वातावरण में डेटा को संशोधित और विश्लेषित करने के लिए Python और SQL-जैसे कमांड लिख सकते हैं। PySpark का उपयोग करके, डेटा वैज्ञानिक डेटा में बदलाव करते हैं, मशीन लर्निंग पाइपलाइंस बनाते हैं और मॉडलों को ट्यून करते हैं।

अधिकांश डेटा वैज्ञानिक और विश्लेषक Python से परिचित होते हैं और इसका उपयोग मशीन लर्निंग वर्कफ़्लो लागू करने के लिए करते हैं। PySpark उन्हें बड़े पैमाने के वितरित डेटासेट्स पर एक परिचित भाषा के साथ काम करने देता है। Apache Spark का उपयोग R जैसी अन्य डेटा साइंस प्रोग्रामिंग भाषाओं के साथ भी किया जा सकता है। यदि आप इसे सीखने में रुचि रखते हैं, तो Introduction to Spark with sparklyr in R कोर्स एक अच्छा शुरुआती बिंदु है।

PySpark में RDDs बनाम DataFrames

PySpark आपको वितरित डेटा को प्रस्तुत करने के दो तरीके देता है। किसका उपयोग करें, यह समझना एक नए PySpark उपयोगकर्ता के सामने आने वाले पहले सवालों में से एक है।

काम के विशाल बहुमत के लिए — जिसमें इस ट्यूटोरियल की सारी सामग्री शामिल है — DataFrames सही चुनाव हैं। Spark का Catalyst क्वेरी ऑप्टिमाइज़र DataFrame ऑपरेशंस को स्वतः ही कुशल एग्जीक्यूशन प्लान में बदल देता है, वह प्रदर्शन लाभ देता है जो RDDs के साथ आपको हाथ से लागू करने पड़ते। RDDs का उपयोग केवल तब करें जब आपको पार्टिशनिंग पर प्रत्यक्ष नियंत्रण चाहिए या आप ऐसे डेटा के साथ काम कर रहे हैं जो टैबुलर स्कीमा में फिट नहीं होता।

PySpark क्यों उपयोग करें?

PySpark, बड़े डेटा प्रोसेसिंग के लिए पसंदीदा विकल्प है क्योंकि यह Python की सुगमता को Spark की वितरित कंप्यूटिंग क्षमता के साथ जोड़ता है। यहाँ इसका विकल्पों से तुलना इस प्रकार है:

कंपनियाँ PySpark जैसे फ्रेमवर्क का उपयोग इसलिए चुनती हैं क्योंकि यह बड़े डेटा को बहुत तेज़ी से प्रोसेस कर सकता है। यह Pandas और Dask जैसी लाइब्रेरीज़ से तेज है, और उनसे बड़े डेटा वॉल्यूम संभाल सकता है। उदाहरण के लिए, यदि आपके पास पेटाबाइट्स से अधिक डेटा प्रोसेस करना हो, तो Pandas और Dask विफल हो जाएँगे लेकिन PySpark इसे आसानी से संभाल लेगा।

हालाँकि Hadoop जैसे वितरित सिस्टम पर Python कोड लिखना भी संभव है, फिर भी कई संगठन Spark और PySpark API का उपयोग करते हैं क्योंकि यह तेज है और रियल-टाइम डेटा संभाल सकता है। PySpark के साथ, आप ऐसा कोड लिख सकते हैं जो लगातार अपडेट होने वाले स्रोत से डेटा इकट्ठा करे, जबकि Hadoop के साथ डेटा केवल बैच मोड में ही प्रोसेस किया जा सकता है। 

Apache Flink एक वितरित प्रोसेसिंग सिस्टम है जिसका Python API PyFlink है, और प्रदर्शन के लिहाज़ से यह वास्तव में Spark से तेज़ है। हालांकि, Apache Spark अधिक समय से मौजूद है और इसका सामुदायिक समर्थन बेहतर है, जिसका मतलब है कि यह अधिक विश्वसनीय है। 

PySpark फॉल्ट टॉलरेंस भी प्रदान करता है: यदि कोई नोड जॉब के बीच में विफल हो जाता है, तो Spark RDD वंशावली जानकारी का उपयोग करके खोया हुआ डेटा पुनर्निर्मित कर देता है। फ्रेमवर्क में इन-मेमाेरी कंप्यूटेशन है और यह रैंडम एक्सेस मेमोरी (RAM) में स्टोर होता है। यह ऐसे मशीन पर भी चल सकता है जिसमें हार्ड-ड्राइव या SSD इंस्टॉल न हो।

PySpark कैसे इंस्टॉल करें

यहाँ बताया गया है कि PySpark को लोकल या क्लाउड वातावरण में कैसे इंस्टॉल करें। 

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

इंस्टॉलेशन शुरू करने से पहले, सुनिश्चित करें कि आपके पास ये पूर्वापेक्षाएँ इंस्टॉल हैं:

• Java 11 या उससे नया (Java 17 अनुशंसित)
• Python 3.7 या उससे नया
• Jupyter Notebook 

ध्यान दें: यदि आप DataLab या Databricks जैसे क्लाउड-आधारित प्लेटफ़ॉर्म का उपयोग कर रहे हैं, तो आप लोकल इंस्टॉलेशन को छोड़ सकते हैं क्योंकि PySpark पहले से इंस्टॉल आता है।

PySpark इंस्टॉल करना

अपने Jupyter Notebook में एक Python फ़ाइल खोलें और पहले सेल में निम्नलिखित कोड चलाएँ:

!pip install pyspark

वैकल्पिक रूप से, आप अपने डिवाइस पर सॉफ़्टवेयर इंस्टॉल करने के लिए इस एंड-टू-एंड PySpark इंस्टॉलेशन गाइड का अनुसरण कर सकते हैं।

एंड-टू-एंड मशीन लर्निंग PySpark ट्यूटोरियल

अब जब आपका PySpark चलने लगा है, तो हम आपको इस लाइब्रेरी का उपयोग करके एंड-टू-एंड ग्राहक विभाजन प्रोजेक्ट निष्पादित करना दिखाएँगे। 

ग्राहक विभाजन एक मार्केटिंग तकनीक है जिसका उपयोग कंपनियाँ समान विशेषताएँ प्रदर्शित करने वाले उपयोगकर्ताओं की पहचान और समूह बनाने के लिए करती हैं। उदाहरण के लिए, यदि आप Starbucks पर केवल गर्मियों में कोल्ड बेवरेज खरीदने जाते हैं, तो आपको “सीज़नल शॉपर” के रूप में सेगमेंट किया जा सकता है और गर्मी के मौसम के लिए तैयार की गई विशेष प्रोमोशंस से आकर्षित किया जा सकता है।

डेटा वैज्ञानिक आमतौर पर बिना लेबल वाले मशीन लर्निंग एल्गोरिदम, जैसे K-Means क्लस्टरिंग या हायरार्किकल क्लस्टरिंग, का उपयोग ग्राहक विभाजन करने के लिए करते हैं। ये मॉडल उपयोगकर्ता समूहों के बीच समान पैटर्न की पहचान करने में बेहतरीन हैं, जो अक्सर मानव आँख से छूट जाते हैं।

इस ट्यूटोरियल में, हम ई-कॉमर्स डेटासेट पर ग्राहक विभाजन करने के लिए K-Means क्लस्टरिंग का उपयोग करेंगे।

ट्यूटोरियल के अंत तक, आप निम्नलिखित अवधारणाओं से परिचित होंगे:

• PySpark के साथ CSV फ़ाइलें पढ़ना

• PySpark के साथ एक्सप्लोरेटरी डेटा एनालिसिस

• डेटा को समूहित करना और सॉर्ट करना

• अंकगणितीय ऑपरेशंस करना

• डेटासेट्स को एग्रीगेट करना

• PySpark के साथ डेटा प्री-प्रोसेसिंग

• datetime मानों के साथ काम करना

• टाइप रूपांतरण

• दो डेटा फ्रेम्स को जोड़ना

• rank() फ़ंक्शन

• PySpark मशीन लर्निंग

• फ़ीचर वेक्टर बनाना

• डेटा को मानकीकृत करना

• K-Means क्लस्टरिंग मॉडल बनाना

• मॉडल की व्याख्या करना

स्टेप 1: SparkSession बनाना

SparkSession, Spark में सभी फंक्शनैलिटी के लिए प्रवेश बिंदु है, और यदि आप PySpark में DataFrame बनाना चाहते हैं तो यह आवश्यक है। SparkSession प्रारंभ करने के लिए निम्नलिखित कोड चलाएँ: 

from pyspark.sql import SparkSession  # add this import


spark = (
    SparkSession.builder
    .appName("DataCamp PySpark Tutorial")
    .config("spark.memory.offHeap.enabled", "true")
    .config("spark.memory.offHeap.size", "10g")
    .getOrCreate()
)

ऊपर दिए गए कोड का उपयोग करके, हमने एक Spark सत्र बनाया और एप्लिकेशन के लिए एक नाम सेट किया। फिर डेटा को ऑफ-हीप मेमोरी में कैश किया गया ताकि उसे सीधे डिस्क पर स्टोर करने से बचा जा सके, और मेमोरी की मात्रा मैन्युअली निर्दिष्ट की गई।

स्टेप 2: DataFrame बनाना

अब हम डेटासेट पढ़ सकते हैं। आप नमूना ई-कॉमर्स डेटासेट हमारे PySpark Read CSV ट्यूटोरियल से डाउनलोड कर सकते हैं या अपनी स्वयं की CSV फ़ाइल का उपयोग कर सकते हैं:

df = spark.read.csv("datacamp_ecommerce.csv", header=True, escape='"', inferSchema=True)

ध्यान दें कि हमने पार्सिंग के समय .csv फ़ाइल में मौजूद कॉमाज़ से बचने के लिए एक एस्केप कैरेक्टर परिभाषित किया है।

show() फ़ंक्शन का उपयोग करके DataFrame के हेड पर नज़र डालते हैं:

df.show(5,0)

DataFrame में 8 वैरिएबल्स हैं:

1. InvoiceNo: प्रत्येक ग्राहक इनवॉइस का यूनिक आइडेंटिफ़ायर।

2. StockCode: स्टॉक में प्रत्येक आइटम का यूनिक आइडेंटिफ़ायर।

3. Description: ग्राहक द्वारा खरीदा गया आइटम।

4. Quantity: एक ही इनवॉइस में ग्राहक द्वारा खरीदे गए प्रत्येक आइटम की संख्या।

5. InvoiceDate: खरीद की तारीख।

6. UnitPrice: प्रत्येक आइटम की एक यूनिट का मूल्य।

7. CustomerID: प्रत्येक उपयोगकर्ता को सौंपा गया यूनिक आइडेंटिफ़ायर।

8. Country: वह देश जहाँ से खरीद की गई।

स्टेप 3: एक्सप्लोरेटरी डेटा एनालिसिस

अब जब हमने इस डेटासेट में मौजूद वैरिएबल्स देख लिए हैं, तो इन डेटा पॉइंट्स को बेहतर समझने के लिए कुछ एक्सप्लोरेटरी डेटा एनालिसिस करते हैं:

1. चलें, DataFrame में रो की संख्या गिनने से शुरुआत करें:

df.count()  # Answer: 2,500

1. DataFrame में कितने यूनिक ग्राहक मौजूद हैं?

df.select('CustomerID').distinct().count() # Answer: 95

1. अधिकांश खरीद किस देश से आती हैं?

यह पता लगाने के लिए कि अधिकांश खरीद किस देश से की जाती हैं, हमें PySpark में groupBy() क्लॉज़ का उपयोग करना होगा:

from pyspark.sql.functions import *
from pyspark.sql.types import *

df.groupBy('Country').agg(countDistinct('CustomerID').alias('country_count')).show()

ऊपर दिए गए कोड को चलाने के बाद निम्न तालिका रेंडर होगी:

लगभग सभी खरीद यूनाइटेड किंगडम से की गईं, और केवल कुछ ही जर्मनी, ऑस्ट्रेलिया और फ्रांस जैसे देशों से आईं। 

ध्यान दें कि ऊपर दी गई तालिका में डेटा खरीद की संख्या के क्रम में प्रस्तुत नहीं है। इस तालिका को सॉर्ट करने के लिए, हम orderBy() क्लॉज़ शामिल कर सकते हैं:

df.groupBy('Country').agg(countDistinct('CustomerID').alias('country_count')).orderBy(desc('country_count')).show()

अब प्रदर्शित आउटपुट अवरोही क्रम में सॉर्ट किया गया है:

1. ई-कॉमर्स प्लेटफ़ॉर्म पर किसी ग्राहक द्वारा सबसे हाल में खरीदारी कब की गई थी?

यह पता लगाने के लिए कि प्लेटफॉर्म पर आखिरी खरीदारी कब की गई थी, हमें InvoiceDate कॉलम को टाइमस्टैंप फ़ॉर्मेट में बदलना है और PySpark में max() फ़ंक्शन का उपयोग करना है:

df = df.withColumn(
    "date",
    coalesce(
        to_timestamp(col("InvoiceDate"), "yy/MM/dd HH:mm"),
        to_timestamp(col("InvoiceDate"), "yyyy-MM-dd HH:mm:ss"),
        to_timestamp(col("InvoiceDate"))  # best-effort fallback
    )
)
df.select(max("date")).show()

ऊपर दिया गया कोड चलाने के बाद आपको निम्न तालिका दिखाई देनी चाहिए:

1. ई-कॉमर्स प्लेटफ़ॉर्म पर किसी ग्राहक द्वारा सबसे पहले खरीदारी कब की गई थी?

जैसा कि हमने ऊपर किया, सबसे शुरुआती खरीदारी की तारीख और समय निकालने के लिए min() फ़ंक्शन का उपयोग किया जा सकता है:

df.select(min("date")).show()

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

स्टेप 4: डेटा प्री-प्रोसेसिंग

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

यह समझने के लिए कि प्री-प्रोसेसिंग कैसे की जाएगी, एक बार फिर डेटा फ्रेम के हेड पर नज़र डालते हैं:

df.show(5,0)

ऊपर दिए गए डेटासेट से, हमें प्रत्येक उपयोगकर्ता के खरीद व्यवहार के आधार पर कई ग्राहक सेगमेंट बनाने हैं। 

इस डेटासेट में वैरिएबल्स ऐसे फ़ॉर्मेट में हैं जिन्हें ग्राहक विभाजन मॉडल में आसानी से नहीं डाला जा सकता। ये फीचर्स अलग-अलग होने पर हमें ग्राहक के खरीद व्यवहार के बारे में बहुत कुछ नहीं बताते।

इसी कारण से, हम मौजूदा वैरिएबल्स का उपयोग करके तीन नए सूचनात्मक फीचर्स निकालेंगे — recency, frequency, और monetary value (RFM)।

RFM का उपयोग आमतौर पर मार्केटिंग में किसी क्लाइंट के मूल्यांकन के लिए किया जाता है, उनके:

1. Recency: प्रत्येक ग्राहक ने कितनी हाल में खरीदारी की है?
2. Frequency: वे कितनी बार कुछ खरीदते हैं?
3. Monetary Value: खरीदारी करते समय औसतन वे कितनी राशि खर्च करते हैं?

अब हम ऊपर दिए गए वैरिएबल्स बनाने के लिए डेटा फ्रेम का प्री-प्रोसेसिंग करेंगे।

Recency

सबसे पहले, recency का मान निकालते हैं — प्लेटफ़ॉर्म पर सबसे हाल में खरीदारी की गई तारीख और समय। यह दो चरणों में किया जा सकता है:

i) प्रत्येक ग्राहक को एक recency स्कोर असाइन करें

हम डेटा फ्रेम में हर तारीख को सबसे शुरुआती तारीख से घटाएँगे। इससे हमें पता चलेगा कि किसी ग्राहक को डेटा फ्रेम में कितनी हाल में देखा गया था। 0 का मान सबसे कम recency दर्शाता है, क्योंकि यह उस व्यक्ति को असाइन होगा जिसे सबसे शुरुआती तारीख को खरीदारी करते हुए देखा गया था।

df = df.withColumn("from_date", to_timestamp(lit("12/1/10 08:26"), "yy/MM/dd HH:mm"))
df2 = df.withColumn("recency", col("date").cast("long") - col("from_date").cast("long"))


w = Window.partitionBy("CustomerID").orderBy(desc("recency"))
df2 = df2.withColumn("rn", row_number().over(w)).filter(col("rn") == 1).drop("rn")

ii) सबसे हाल की खरीद का चयन करें

एक ग्राहक अलग-अलग समय पर कई खरीदारी कर सकता है। हमें केवल आखिरी बार चुना जाना चाहिए जब वे कोई उत्पाद खरीदते हुए देखे गए थे, क्योंकि यह बताता है कि सबसे हाल में खरीद कब हुई थी: 

df2 = df2.join(df2.groupBy('CustomerID').agg(max('recency').alias('recency')),on='recency',how='leftsemi')

नए डेटा फ्रेम के हेड पर नज़र डालते हैं। अब इसमें “recency” नाम का एक वैरिएबल जुड़ गया है:

df2.show(5,0)

PySpark DataFrame में मौजूद सभी वैरिएबल्स को देखने का आसान तरीका इसका printSchema() फ़ंक्शन उपयोग करना है। यह Pandas में info() फ़ंक्शन के समकक्ष है:

df2.printSchema()

रेंडर किया गया आउटपुट इस तरह दिखना चाहिए:

Frequency

अब frequency का मान निकालते हैं — कोई ग्राहक प्लेटफ़ॉर्म पर कितनी बार कुछ खरीदता है। इसके लिए, हमें केवल प्रत्येक CustomerID के आधार पर समूह बनाना है और उन्होंने खरीदे गए आइटम्स की संख्या गिननी है। अधिक उन्नत ग्रुपिंग तकनीकों के लिए हमारा PySpark groupBy ट्यूटोरियल देखें:

df_freq = df2.groupBy('CustomerID').agg(count('InvoiceDate').alias('frequency'))

अभी बनाए गए इस नए DataFrame के हेड पर नज़र डालें:

df_freq.show(5,0)

DataFrame में प्रत्येक ग्राहक के साथ एक frequency मान जुड़ा हुआ है। इस नए DataFrame में केवल दो कॉलम हैं, और हमें इसे पिछले वाले के साथ जोड़ना है। विभिन्न जॉइन प्रकारों के बारे में अधिक जानने के लिए हमारा PySpark Joins ट्यूटोरियल देखें:

df3 = df2.join(df_freq,on='CustomerID',how='inner')

आइए इस DataFrame की स्कीमा प्रिंट करें:

df3.printSchema()

Monetary Value

अंत में, monetary value निकालते हैं — DataFrame में प्रत्येक ग्राहक द्वारा खर्च की गई कुल राशि। इसे प्राप्त करने के दो चरण हैं:

i) प्रत्येक खरीद में खर्च की गई कुल राशि खोजें:

प्रत्येक CustomerID के साथ एकल खरीद के लिए Quantity और UnitPrice नामक वैरिएबल्स आते हैं:

प्रत्येक खरीद में प्रत्येक ग्राहक द्वारा खर्च की गई कुल राशि प्राप्त करने के लिए, हमें Quantity को UnitPrice से गुणा करना होगा:

m_val = df3.withColumn(
    "TotalAmount",
    col("Quantity").cast("double") * col("UnitPrice").cast("double")
)

ii) प्रत्येक ग्राहक द्वारा कुल खर्च की गई राशि खोजें:

प्रत्येक ग्राहक द्वारा समग्र रूप से खर्च की गई कुल राशि खोजने के लिए, हमें केवल CustomerID कॉलम के आधार पर समूह बनाना है और कुल राशि का योग लेना है:

m_val = m_val.groupBy('CustomerID').agg(sum('TotalAmount').alias('monetary_value'))

इस DataFrame को अन्य सभी वैरिएबल्स के साथ मर्ज करें:

finaldf = m_val.join(df3,on='CustomerID',how='inner')

अब जब हमने मॉडल बनाने के लिए सभी आवश्यक वैरिएबल्स बना लिए हैं, तो निम्नलिखित कोड चलाकर केवल आवश्यक कॉलम चुनें और DataFrame से डुप्लिकेट रो हटा दें:

finaldf = finaldf.select(['recency','frequency','monetary_value','CustomerID']).distinct()

सुनिश्चित करने के लिए कि प्री-प्रोसेसिंग सटीक रूप से की गई है, अंतिम DataFrame के हेड पर नज़र डालें:

मानकीकरण

ग्राहक विभाजन मॉडल बनाने से पहले, DataFrame को मानकीकृत करते हैं ताकि सभी वैरिएबल्स लगभग एक ही स्केल के आसपास हों:

from pyspark.ml.feature import VectorAssembler, StandardScaler


assemble = VectorAssembler(
    inputCols=["recency", "frequency", "monetary_value"],
    outputCol="features"
)
assembled_data = assemble.transform(finaldf)


scale = StandardScaler(inputCol="features", outputCol="standardized")
data_scale = scale.fit(assembled_data)
data_scale_output = data_scale.transform(assembled_data)

मानकीकृत फीचर वेक्टर कैसा दिखता है, यह देखने के लिए निम्नलिखित कोड चलाएँ:

data_scale_output.select('standardized').show(2,truncate=False)

ये स्केल किए गए फीचर्स हैं जिन्हें क्लस्टरिंग एल्गोरिदम में फीड किया जाएगा।

यदि आप PySpark के साथ डेटा तैयारी के बारे में अधिक जानना चाहते हैं, तो DataCamp पर यह फ़ीचर इंजीनियरिंग कोर्स करें।

स्टेप 5: मशीन लर्निंग मॉडल बनाना

अब जब हमने सभी डेटा विश्लेषण और तैयारी पूरी कर ली है, तो K-Means क्लस्टरिंग मॉडल बनाते हैं। 

एल्गोरिदम PySpark के मशीन लर्निंग API का उपयोग करके बनाया जाएगा।

i) उपयोग करने के लिए क्लस्टर्स की संख्या खोजना

K-Means क्लस्टरिंग मॉडल बनाते समय, सबसे पहले हमें यह तय करना होता है कि हम एल्गोरिदम से कितने क्लस्टर्स या समूह वापस पाना चाहते हैं। उदाहरण के लिए, यदि हम तीन क्लस्टर्स तय करते हैं, तो हमारे पास तीन ग्राहक सेगमेंट होंगे।

K-Means में कितने क्लस्टर्स का उपयोग करना है, यह तय करने के लिए सबसे लोकप्रिय तकनीक “एल्बो मेथड” कहलाती है।

यह K-Means एल्गोरिदम को क्लस्टर काउंट्स की एक रेंज के लिए चलाकर और प्रत्येक क्लस्टर के लिए मॉडल परिणामों को विज़ुअलाइज़ करके किया जाता है। प्लॉट में एक मुड़ाव बिंदु होगा जो कोहनी जैसा दिखता है, और हम बस उसी बिंदु पर क्लस्टर्स की संख्या चुनते हैं।

एल्गोरिदम कैसे काम करता है, यह जानने के लिए यह DataCamp K-Means क्लस्टरिंग ट्यूटोरियल पढ़ें।

2 से 10 क्लस्टर्स तक K-Means क्लस्टरिंग एल्गोरिदम बनाने के लिए निम्नलिखित कोड चलाते हैं:

from pyspark.ml.clustering import KMeans
from pyspark.ml.evaluation import ClusteringEvaluator
import numpy as np

cost = np.zeros(10)

evaluator = ClusteringEvaluator(
    predictionCol="prediction",
    featuresCol="standardized",
    metricName="silhouette",
    distanceMeasure="squaredEuclidean"
)


ks = range(2, 10)
cost = np.zeros(len(ks))


for idx, k in enumerate(ks):
    km = KMeans(featuresCol="standardized", k=k)
    model = km.fit(data_scale_output)
    output = model.transform(data_scale_output)
    cost[idx] = model.summary.trainingCost   # WSSSE

ऊपर दिए गए कोड के साथ, हमने 2 से 10 क्लस्टर्स के साथ K-Means क्लस्टरिंग मॉडल सफलतापूर्वक बनाया और मूल्यांकित किया है। परिणामों को एक एरे में रखा गया है, और अब इन्हें लाइन चार्ट में विज़ुअलाइज़ किया जा सकता है:

import pandas as pd
import pylab as pl
df_cost = pd.DataFrame(cost)  # cost has 8 values, one per k in range(2, 10)
df_cost.columns = ["cost"]
new_col = range(2, 10)
df_cost.insert(0, 'cluster', new_col)
pl.plot(df_cost.cluster, df_cost.cost)
pl.xlabel('Number of Clusters')
pl.ylabel('Score')
pl.title('Elbow Curve')
pl.show()

ऊपर का कोड निम्न चार्ट रेंडर करेगा:

ii) K-Means क्लस्टरिंग मॉडल बनाना

ऊपर के प्लॉट से, हम देख सकते हैं कि चार पर एक ऐसा मुड़ाव बिंदु है जो कोहनी जैसा दिखता है। इसी कारण, हम चार क्लस्टर्स के साथ K-Means एल्गोरिदम बनाने की ओर बढ़ेंगे:

KMeans_algo=KMeans(featuresCol='standardized', k=4)
KMeans_fit=KMeans_algo.fit(data_scale_output)

iii) प्रीडिक्शंस बनाना

चलें, बनाए गए मॉडल का उपयोग करके डेटासेट में प्रत्येक ग्राहक को क्लस्टर्स असाइन करते हैं:

preds=KMeans_fit.transform(data_scale_output)

preds.show(5,0)

ध्यान दें कि इस DataFrame में “prediction” नाम का कॉलम है जो बताता है कि प्रत्येक CustomerID किस क्लस्टर से संबंधित है:

स्टेप 6: क्लस्टर विश्लेषण

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

DataFrame में प्रत्येक CustomerID के recency, frequency, और monetary value को विज़ुअलाइज़ करने के लिए निम्नलिखित कोड चलाएँ:

import matplotlib.pyplot as plt
import seaborn as sns

df_viz = preds.select('recency','frequency','monetary_value','prediction')
df_viz = df_viz.toPandas()
avg_df = df_viz.groupby(['prediction'], as_index=False).mean()

rfm_columns = ['recency', 'frequency', 'monetary_value']

for metric in rfm_columns:
    sns.barplot(x='prediction', y=metric, data=avg_df)
    plt.show()

ऊपर का कोड निम्न प्लॉट्स रेंडर करेगा:

प्रत्येक क्लस्टर में ग्राहकों द्वारा प्रदर्शित विशेषताओं का एक अवलोकन यहाँ है:

• क्लस्टर 0: इस सेगमेंट के ग्राहक कम recency, frequency, और monetary value दिखाते हैं। वे प्लेटफ़ॉर्म पर शायद ही खरीदारी करते हैं और कम-सम्भावना वाले ग्राहक हैं जो ई-कॉमर्स कंपनी के साथ कारोबार करना बंद कर सकते हैं।
• क्लस्टर 1: इस क्लस्टर के उपयोगकर्ता उच्च recency दिखाते हैं लेकिन प्लेटफ़ॉर्म पर अधिक खर्च करते हुए नहीं देखे गए। वे साइट पर अक्सर नहीं आते। यह इंगित करता है कि वे संभवतः नए ग्राहक हो सकते हैं जिन्होंने अभी कंपनी के साथ कारोबार शुरू किया है।
• क्लस्टर 2: इस सेगमेंट के ग्राहक मध्यम recency और frequency दिखाते हैं और प्लेटफ़ॉर्म पर बहुत पैसा खर्च करते हैं। यह बताता है कि वे उच्च-मूल्य वाले आइटम खरीदने या थोक खरीद करने की प्रवृत्ति रखते हैं।
• क्लस्टर 3: अंतिम सेगमेंट में वे उपयोगकर्ता शामिल हैं जो उच्च recency दिखाते हैं और प्लेटफ़ॉर्म पर अक्सर खरीदारी करते हैं। हालाँकि, वे प्लेटफ़ॉर्म पर अधिक खर्च नहीं करते, जिसका मतलब हो सकता है कि वे प्रत्येक खरीद में सस्ते आइटम चुनते हैं।

इस कोर्स में शामिल प्रेडिक्टिव मॉडलिंग अवधारणाओं से आगे बढ़ने के लिए, आप DataCamp पर Machine Learning with PySpark कोर्स कर सकते हैं।

शुरू से PySpark सीखना: आगे के कदम

अब जब आपने यह ट्यूटोरियल पूरा कर लिया है, तो आपके लक्ष्यों के आधार पर अनुशंसित अगले कदम यहाँ हैं:

यदि आप इस पूरे PySpark ट्यूटोरियल के साथ-साथ चलते रहे हैं, तो बधाई! आपने अब अपने लोकल डिवाइस पर PySpark सफलतापूर्वक इंस्टॉल कर लिया है, एक ई-कॉमर्स डेटासेट का विश्लेषण किया है, और फ्रेमवर्क का उपयोग करके एक मशीन लर्निंग एल्गोरिदम बनाया है।

ऊपर दिए गए विश्लेषण की एक सीमा यह है कि यह 2,500 रो वाले एक दिन में एकत्र किए गए ईकॉमर्स डेटा पर किया गया था। यदि हमारे पास काम करने के लिए अधिक मात्रा में डेटा होता, तो इस विश्लेषण का परिणाम और पुख्ता हो सकता था, क्योंकि RFM मॉडलिंग जैसी तकनीकें आमतौर पर कई महीनों के ऐतिहासिक डेटा पर लागू की जाती हैं।

हालाँकि, आप इस लेख में सीखे गए सिद्धांतों को लेकर बिना पर्यवेक्षित मशीन लर्निंग के दायरे में बहुत बड़े डेटासेट्स पर लागू कर सकते हैं।

PySpark के सिंटैक्स और उसके मॉड्यूल्स के बारे में अधिक जानने के लिए DataCamp का यह चीट शीट देखें।

अंत में, यदि आप इस ट्यूटोरियल में शामिल अवधारणाओं से आगे बढ़कर PySpark के साथ प्रोग्रामिंग की बुनियादी बातें सीखना चाहते हैं, तो DataCamp पर Big Data with PySpark लर्निंग ट्रैक करें। इस ट्रैक में ऐसे कोर्सों की श्रृंखला है जो आपको PySpark के साथ निम्न काम करना सिखाएँगे:

• डेटा मैनेजमेंट, विश्लेषण, और प्री-प्रोसेसिंग
• मशीन लर्निंग पाइपलाइंस बनाना और ट्यून करना
• बिग डेटा विश्लेषण 
• फ़ीचर इंजीनियरिंग 
• रिकमेंडेशन इंजन बनाना

अंतिम विचार

जब आपका डेटा एकल मशीन की क्षमता से बढ़ जाता है, तो PySpark सही टूल है। इस ट्यूटोरियल का RFM ग्राहक विभाजन प्रोजेक्ट पूरा वर्कफ़्लो दिखाता है: डेटा लोड करना, एक्सप्लोरेटरी विश्लेषण, फ़ीचर इंजीनियरिंग, और ML। ये ऐसे पैटर्न हैं जिन्हें आप प्रोडक्शन में बहुत बड़े डेटासेट्स पर दोबारा उपयोग करेंगे।

एक ईमानदार चेतावनी: इस उदाहरण में एक ही दिन के 2,500 ट्रांज़ैक्शंस का उपयोग किया गया है। PySpark इसे आराम से संभालता है। वितरित सेटअप का असली फायदा तब मिलता है जब आप लाखों इवेंट्स में फैले महीनों के ट्रांज़ैक्शन इतिहास के साथ काम करते हैं — तभी इन-मेमाेरी एग्जीक्यूशन और फॉल्ट टॉलरेंस वाकई मायने रखते हैं।

आगे बढ़ते रहने के लिए, हमारा Big Data with PySpark ट्रैक डेटा इंजीनियरिंग पाइपलाइंस, रिकमेंडेशन इंजन, और प्रोडक्शन ML को संरचित अनुक्रम में कवर करता है। टीमों के लिए, DataCamp for Business डेटा इंजीनियरिंग भूमिकाओं के लिए अनुकूलित लर्निंग पाथ्स प्रदान करता है। अधिक जानने के लिए डेमो का अनुरोध करें।