शीर्ष 20 Spark इंटरव्यू प्रश्न

Apache Spark डेटा इंजीनियरिंग, डेटा साइंस, और मशीन लर्निंग के लिए एक एकीकृत एनालिटिक्स इंजन है जो बड़े पैमाने पर काम करता है। इसे Python, SQL, R, Java, या Scala के साथ उपयोग किया जा सकता है। Spark की शुरुआत 2009 में यूनिवर्सिटी ऑफ कैलिफ़ोर्निया, बर्कले में हुई थी और बाद में 2013 में इसे Apache Software Foundation को दान कर दिया गया। आज यह स्केलेबल कंप्यूटिंग के लिए सबसे व्यापक रूप से उपयोग किया जाने वाला इंजन, है, और इस तकनीक का उपयोग करने वाली नौकरियों की हजारों पोस्टिंग्स उपलब्ध हैं। डेटा इंजीनियरिंग जगत में यह कौशल अत्यधिक मूल्यवान है, इसलिए यहाँ ऐसे इंटरव्यू प्रश्न दिए गए हैं जो या तो आपकी नौकरी की तलाश में मदद करेंगे या Spark के अनुभव वाले टैलेंट की तलाश में। कोडिंग उत्तर Python में दिए जाएंगे।

बेसिक Spark इंटरव्यू प्रश्न

ये प्रश्न Spark की कुछ बुनियादी बातों को कवर करते हैं और उनके लिए उपयुक्त हैं जिनके पास इसका केवल प्रारंभिक अनुभव है। यदि आपको पुनरावलोकन की आवश्यकता है, तो हमारा Introduction to Spark SQL in Python कोर्स शुरू करने के लिए आदर्श जगह है। 

1. Apache Spark क्या है, और डेटा प्रोसेसिंग में इसका उपयोग क्यों किया जाता है?

यह प्रश्न उम्मीदवार की Apache Spark की सामान्य समझ और बिग डेटा इकोसिस्टम में उसकी भूमिका का आकलन करता है।

उत्तर:

Apache Spark एक ओपन-सोर्स, वितरित कंप्यूटिंग सिस्टम है जो इम्प्लिसिट डेटा पैरेललिज़्म और फॉल्ट टॉलरेंस के साथ पूरे क्लस्टर्स को प्रोग्राम करने के लिए एक इंटरफ़ेस प्रदान करता है। पारंपरिक MapReduce की तुलना में इसकी गति और उपयोग में आसानी के कारण इसे बड़े पैमाने पर डेटा प्रोसेसिंग के लिए इस्तेमाल किया जाता है।

मुख्य विशेषताएँ:

• इन-मेमोरी कंप्यूटिंग: तेज़ प्रोसेसिंग के लिए डेटा को मेमोरी में स्टोर करता है।
• स्केलेबिलिटी: मशीनों के क्लस्टर का उपयोग करके पेटाबाइट्स डेटा को संभाल सकता है।
• उपयोग में सरल: Java, Scala, Python, और R में API प्रदान करता है।
• यूनिफाइड एनालिटिक्स इंजन: SQL, स्ट्रीमिंग डेटा, मशीन लर्निंग, और ग्राफ प्रोसेसिंग को सपोर्ट करता है।

2. Resilient Distributed Datasets (RDDs) की अवधारणा समझाएँ

यह प्रश्न Apache Spark की बुनियादी अवधारणाओं पर आपका परीक्षण करता है। सुनिश्चित करें कि आप उन महत्वपूर्ण घटकों में से एक को समझते हैं जो Spark को इतना शक्तिशाली बनाते हैं।

Resilient Distributed Datasets (RDDs) Apache Spark के मौलिक बिल्डिंग ब्लॉक्स हैं। ये ऑब्जेक्ट्स का एक इम्यूटेबल, वितरित कलेक्शन दर्शाते हैं जिन पर क्लस्टर में पैरेलल रूप से ऑपरेशन किए जा सकते हैं। यहाँ RDDs से जुड़ी प्रमुख विशेषताओं और अवधारणाओं की व्याख्या है:

1. इम्यूटेबल: RDDs इम्यूटेबल होते हैं, यानी एक बार बनाए जाने के बाद उनकी सामग्री बदली नहीं जा सकती। आप केवल ट्रांसफॉर्मेशंस लागू करके नए RDDs बना सकते हैं। यह इम्यूटेबिलिटी फॉल्ट टॉलरेंस को सरल बनाती है और Spark के लेज़ी इवैल्युएशन मॉडल को सक्षम करती है।
2. वितरित: RDDs क्लस्टर के कई नोड्स में वितरित होते हैं, जिससे Spark उन पर पैरेलल ऑपरेशंस कर सकता है। प्रत्येक RDD कई पार्टिशनों में विभाजित होता है, और ये पार्टिशन विभिन्न नोड्स पर स्वतंत्र रूप से प्रोसेस किए जा सकते हैं।
3. रेज़िलिएंट: RDD में "Resilient" का अर्थ फॉल्ट टॉलरेंस है। Spark प्रत्येक RDD की लिनिएज को ट्रैक करके रेज़िलिएंस सुनिश्चित करता है। यदि किसी नोड फेल्योर के कारण RDD का कोई पार्टिशन खो जाता है, तो Spark लिनिएज जानकारी और मूल डेटा पर लागू ट्रांसफॉर्मेशंस का उपयोग करके उस पार्टिशन को फिर से कंप्यूट कर सकता है।
4. डेटासेट: RDDs डेटा का एक वितरित प्रतिनिधित्व हैं, यानी वे किसी भी प्रकार का डेटा रख सकते हैं, जिसमें स्ट्रक्चर्ड या अनस्ट्रक्चर्ड डेटा शामिल है। Spark कई भाषाओं (जैसे Scala, Java, Python, और R) में RDDs के साथ काम करने के लिए APIs प्रदान करता है, जिससे यह विभिन्न उपयोग मामलों और डेटा प्रकारों के लिए बहुमुखी बनता है।
5. लेज़ी इवैल्युएशन: RDDs लेज़ी इवैल्युएशन को सपोर्ट करते हैं, यानी RDDs पर ट्रांसफॉर्मेशंस तुरंत निष्पादित नहीं होते। इसके बजाय, Spark ट्रांसफॉर्मेशंस का एक डायरेक्टेड एसीक्लिक ग्राफ (DAG) बनाता है जो कंप्यूटेशन को परिभाषित करता है, लेकिन किसी ऐक्शन के ट्रिगर होने तक निष्पादन को टाल देता है। यह अनुकूलन Spark को निष्पादन योजना को बेहतर बनाने और परफॉर्मेंस सुधारने देता है।

3. YARN क्या है?

YARN एक वितरित कंटेनर मैनेजर है जो Hadoop में संसाधनों का प्रबंधन करता है। Spark Hadoop क्लस्टर्स पर चलते समय अधिक प्रभावी और कुशल संसाधन प्रबंधन के लिए YARN का उपयोग कर सकता है। YARN के महत्वपूर्ण घटकों में से एक इसकी क्षमता है कि वह क्लस्टर में संसाधनों को कुशलता से आवंटित करे, जॉब्स का प्रभावी शेड्यूलिंग करे, और नोड फेल्योर होने पर फॉल्ट टॉलरेंट रहे। यह उन कई घटकों में से एक है जो Spark को एक शक्तिशाली टूल बनाते हैं।

4. Spark RDDs में map और flatMap ट्रांसफॉर्मेशंस के बीच क्या अंतर है?

यह प्रश्न यह निर्धारित करने में मदद करता है कि क्या आप Spark RDDs (Resilient Distributed Datasets) में विभिन्न प्रकार के ट्रांसफॉर्मेशंस को समझते हैं।

उत्तर:

• .map(): RDD के प्रत्येक एलिमेंट को ठीक एक नए एलिमेंट में बदलता है। परिणामस्वरूप RDD में इनपुट RDD जितने ही एलिमेंट होंगे।
• .flatMap(): RDD के प्रत्येक एलिमेंट को शून्य या अधिक नए एलिमेंट्स में बदलता है। परिणामस्वरूप RDD में एलिमेंट्स की संख्या इनपुट RDD से भिन्न हो सकती है।

# Example of map
rdd = spark.sparkContext.parallelize([1, 2, 3])
mapped_rdd = rdd.map(lambda x: x * 2)
print(mapped_rdd.collect())  # Output: [2, 4, 6]
# Example of flatMap
flat_mapped_rdd = rdd.flatMap(lambda x: [x, x * 2])
print(flat_mapped_rdd.collect())  # Output: [1, 2, 2, 4, 3, 6]

यह कोड इंटीजर के एक RDD को ट्रांसफॉर्म करके map और flatMap के बीच का अंतर दिखाता है।

5. आप DataFrame से डेटा क्वेरी करने के लिए Spark SQL का उपयोग कैसे करते हैं?

यह प्रश्न उम्मीदवार की Spark SQL का उपयोग करके डेटा क्वेरी करने की क्षमता की जाँच करता है, जो डेटा विश्लेषण कार्यों के लिए आवश्यक है।

उत्तर:

# Register the DataFrame as a SQL temporary view
df.createOrReplaceTempView("table")
# Execute SQL query
result = spark.sql("SELECT column1, SUM(column2) FROM table GROUP BY column1")
# Show the results
result.show()

यह स्निपेट एक DataFrame से अस्थायी व्यू बनाकर Spark SQL का उपयोग करते हुए group-by क्वेरी करने का तरीका दिखाता है।

इंटरमीडिएट Spark इंटरव्यू प्रश्न

जो लोग मूल बातें सीख चुके हैं और उन्हें अपनी पेशेवर भूमिकाओं में लागू कर चुके हैं, उनके लिए ये प्रश्न अधिक सामान्य हो सकते हैं: 

6. Spark में लेज़ी इवैल्युएशन की अवधारणा समझाएँ और यह क्यों महत्वपूर्ण है

यह प्रश्न Spark के मुख्य सिद्धांतों में से एक की उम्मीदवार की समझ का आकलन करता है, जो परफॉर्मेंस ऑप्टिमाइज़ेशन के लिए महत्वपूर्ण है।

उत्तर:

लेज़ी इवैल्युएशन का अर्थ है कि Spark ट्रांसफॉर्मेशंस को कॉल करते ही तुरंत निष्पादित नहीं करता। इसके बजाय, यह एक लॉजिकल एक्सिक्यूशन प्लान बनाता है। ट्रांसफॉर्मेशंस तभी निष्पादित होते हैं जब कोई ऐक्शन (जैसे collect या count) कॉल किया जाता है, जो वास्तविक कंप्यूटेशन को ट्रिगर करता है।

लेज़ी इवैल्युएशन दो कारणों से महत्वपूर्ण है:

1. यह Spark को पूरे डेटा प्रोसेसिंग वर्कफ़्लो को निष्पादित करने से पहले ऑप्टिमाइज़ करने की अनुमति देता है, ऑपरेशंस को मिलाकर डेटा शफ्लिंग को न्यूनतम करता है।
2. यह डेटा पर पासेज की संख्या कम करता है, जिससे परफॉर्मेंस में सुधार होता है।

7. आप Spark में डेटा को कैसे पर्सिस्ट करते हैं, और कौन-कौन से स्टोरेज लेवल उपलब्ध हैं?

यह प्रश्न Spark में डेटा पर्सिस्टेंस के ज्ञान की जाँच करता है, जो परफॉर्मेंस ट्यूनिंग और इटरेटिव एल्गोरिद्म्स के लिए महत्वपूर्ण है।

उत्तर:

डेटा को Spark में .persist() या .cache() मेथड्स का उपयोग करके पर्सिस्ट किया जा सकता है। .cache() डिफ़ॉल्ट स्टोरेज लेवल के साथ .persist() का शॉर्टहैंड है।

स्टोरेज लेवल:

• MEMORY_ONLY: RDD को JVM में डीसिरियलाइज़्ड Java ऑब्जेक्ट्स के रूप में स्टोर करता है। यदि RDD मेमोरी में फिट नहीं होता, तो कुछ पार्टिशन कैश नहीं होंगे।
• MEMORY_AND_DISK: RDD को मेमोरी में डीसिरियलाइज़्ड Java ऑब्जेक्ट्स के रूप में स्टोर करता है। यदि RDD मेमोरी में फिट नहीं होता, तो पार्टिशन डिस्क पर स्टोर किए जाते हैं।
• MEMORY_ONLY_SER: RDD को JVM में सिरियलाइज़्ड Java ऑब्जेक्ट्स के रूप में स्टोर करता है। इससे मेमोरी उपयोग घटता है लेकिन सिरियलाइज़ेशन/डीसिरियलाइज़ेशन के लिए CPU ओवरहेड बढ़ता है।
• MEMORY_AND_DISK_SER: MEMORY_AND_DISK के समान है, लेकिन सिरियलाइज़्ड ऑब्जेक्ट्स स्टोर करता है।
• DISK_ONLY: RDD पार्टिशन केवल डिस्क पर स्टोर करता है।

rdd = spark.sparkContext.parallelize([1, 2, 3, 4, 5])
rdd.persist(storageLevel=StorageLevel.MEMORY_AND_DISK)

8. आप Spark में स्क्यूड डेटा को कैसे संभालते हैं?

यह प्रश्न डेटा स्क्यू की आपकी समझ और उसे मैनेज करने की रणनीतियों का मूल्यांकन करता है, जो कुशल डेटा प्रोसेसिंग सुनिश्चित करने के लिए महत्वपूर्ण है।

उत्तर:

डेटा स्क्यू तब होता है जब कुछ पार्टिशनों में अन्य की तुलना में काफी अधिक डेटा होता है, जिससे परफॉर्मेंस बॉटलनेक्स होते हैं। स्क्यूड डेटा को संभालने की रणनीतियों में शामिल हैं:

• सल्टिंग: डेटा में एक रैंडम की जोड़ना ताकि वह पार्टिशनों में अधिक समान रूप से वितरित हो।
• रीपार्टिशनिंग: पार्टिशनों की संख्या बढ़ाना ताकि डेटा अधिक समान रूप से वितरित हो।
• ब्रॉडकास्ट वेरिएबल्स: बड़े डेटासेट्स को शफल करने से बचने के लिए छोटे डेटासेट को सभी नोड्स पर ब्रॉडकास्ट करना।

from pyspark.sql.functions import monotonically_increasing_id, col
# Example of salting
df = df.withColumn("salt", monotonically_increasing_id() % 10)
df = df.withColumn("new_key", col("original_key") + col("salt"))

9. Spark में नैरो और वाइड ट्रांसफॉर्मेशंस में अंतर समझाएँ

यह प्रश्न Spark के निष्पादन मॉडल की उम्मीदवार की समझ और विभिन्न प्रकार के ट्रांसफॉर्मेशंस के परफॉर्मेंस पर प्रभाव का परीक्षण करता है।

उत्तर:

• नैरो ट्रांसफॉर्मेशंस: वे ऑपरेशन जिनमें प्रत्येक इनपुट पार्टिशन ठीक एक आउटपुट पार्टिशन में योगदान देता है। उदाहरण: .map(), .filter(), और .union()। ये सामान्यतः तेज़ होते हैं क्योंकि इनमें डेटा शफलिंग की आवश्यकता नहीं होती।
• वाइड ट्रांसफॉर्मेशंस: वे ऑपरेशन जिनमें प्रत्येक इनपुट पार्टिशन कई आउटपुट पार्टिशनों में योगदान देता है। उदाहरण: .groupByKey(), .reduceByKey(), और .join()। इनमें नेटवर्क पर डेटा शफलिंग की आवश्यकता होती है, जो समय लेने वाली हो सकती है।

# Narrow transformation example
rdd1 = rdd.map(lambda x: x * 2)
# Wide transformation example
rdd2 = rdd.groupByKey()

10. रियल-टाइम डेटा प्रोसेसिंग में Spark Streaming

Spark, Apache Kafka या Amazon Kinesis जैसे स्रोतों से रियल-टाइम डेटा स्ट्रीमिंग में उत्कृष्ट है क्योंकि यह स्केलेबल और फॉल्ट-टॉलरेंट है। यह Spark Streaming एक्सटेंशन के माध्यम से ऐसा करता है। यह इनपुट DStreams का उपयोग करके बाहरी डेटा स्रोतों के साथ इंटरैक्ट करता है, जो इन स्रोतों से निरंतर डेटा स्ट्रीम का प्रतिनिधित्व करते हैं। 

Spark Streaming, चेकपॉइंटिंग और राइट-अहेड लॉग्स जैसी तकनीकों के माध्यम से फॉल्ट टॉलरेंस और डेटा कंसिस्टेंसी सुनिश्चित करता है। चेकपॉइंटिंग स्ट्रीमिंग एप्लिकेशन की स्टेट को समय-समय पर टिकाऊ स्टोरेज (जैसे HDFS) में सेव करता है ताकि फेल्योर से रिकवरी हो सके, जबकि राइट-अहेड लॉग्स बाहरी स्रोतों से प्राप्त डेटा के लिए फॉल्ट टॉलरेंस प्रदान करते हैं।

एडवांस्ड Spark इंटरव्यू प्रश्न

ये प्रश्न उन उपयोगकर्ताओं के लिए हैं जिनके पास Spark के साथ अधिक व्यावहारिक अनुभव है, विशेषकर उन्नत विषयों पर। यदि आपको पुनरावलोकन चाहिए, तो हमारा Spark Machine Learning ट्यूटोरियल देखें। 

11. बताइए कि मशीन लर्निंग के लिए Spark का उपयोग कैसे किया जा सकता है

यह प्रश्न इंटरव्यूई की Spark के एनवायरनमेंट और MLlib लाइब्रेरी की समझ का परीक्षण करता है। 

Spark की MLlib लाइब्रेरी बड़े पैमाने पर मशीन लर्निंग कार्यों के लिए समृद्ध टूल्स और एल्गोरिद्म्स का सेट प्रदान करती है। बड़े पैमाने के डेटासेट्स के लिए फीचर इंजीनियरिंग और प्रीप्रोसेसिंग के संदर्भ में, MLlib कई उन्नत तकनीकें और ऑप्टिमाइज़ेशन प्रदान करता है:

1. फीचर ट्रांसफॉर्मेशन और सेलेक्शन: MLlib स्केलिंग, नॉर्मलाइज़ेशन, बाइनराइज़ेशन, और वेक्टराइज़ेशन (जैसे, वन-हॉट एनकोडिंग) जैसी फीचर ट्रांसफॉर्मेशन तकनीकें प्रदान करता है। इसके अलावा, यह फीचर सेलेक्शन की विधियाँ भी प्रदान करता है, जिनमें कोरिलेशन, इंफॉर्मेशन गेन, या सांख्यिकीय परीक्षणों पर आधारित फ़िल्टरिंग, साथ ही Principal Component Analysis (PCA) जैसी उन्नत डाइमेंशनलिटी रिडक्शन तकनीकें शामिल हैं।

2. कैटेगॉरिकल फीचर्स को संभालना: MLlib कैटेगॉरिकल फीचर्स को कुशलतापूर्वक संभालने के लिए टूल्स शामिल करता है, जैसे कैटेगॉरिकल वेरिएबल्स को संख्यात्मक रिप्रेजेंटेशन में बदलने के लिए StringIndexer और उन्हें बाइनरी वेक्टर्स में बदलने के लिए OneHotEncoder। ये ट्रांसफॉर्मेशंस वितरित Spark क्लस्टर्स में पैरेलल निष्पादन के लिए ऑप्टिमाइज़्ड हैं।

3. पाइपलाइन API: Spark का Pipeline API उपयोगकर्ताओं को फीचर इंजीनियरिंग और मॉडलिंग के कई स्टेजेज़ को एक ही वर्कफ़्लो में चेन करने देता है। यह जटिल फीचर ट्रांसफॉर्मेशन पाइपलाइन्स के निर्माण को सुविधाजनक बनाता है, साथ ही विभिन्न डेटासेट्स और मशीन लर्निंग कार्यों में स्थिरता और पुनरुत्पादन सुनिश्चित करता है।

4. कस्टम ट्रांसफॉर्मर्स और एस्टीमेटर्स: MLlib उपयोगकर्ताओं को Spark के DataFrame API का उपयोग करके कस्टम फीचर ट्रांसफॉर्मर्स और एस्टीमेटर्स परिभाषित करने की अनुमति देता है। यह डोमेन-विशिष्ट फीचर इंजीनियरिंग तकनीकों या थर्ड-पार्टी लाइब्रेरीज़ को Spark ML पाइपलाइन में एकीकृत करने में सक्षम बनाता है, जिससे इसकी कार्यक्षमता और लचीलापन बढ़ता है।

12. समझाइए कि Spark, Apache Hadoop HDFS और Apache Cassandra जैसे बाहरी स्टोरेज सिस्टम्स के साथ कैसे एकीकृत होता है। Spark-आधारित डेटा पाइपलाइन में इन इंटीग्रेशंस का लाभ लेने के क्या फायदे हैं?

यह जाँचता है कि उपयोगकर्ता Spark-आधारित सिस्टम्स की आधारभूत कार्यक्षमता और Spark का HDFS तथा Apache Cassandra के साथ काम करना समझते हैं या नहीं। यह समझना महत्वपूर्ण है कि कोडिंग के माध्यम से डेटा कैसे प्राप्त किया जाए और वह डेटा सिस्टम में कैसे प्रवाहित होता है।

1. Hadoop HDFS कनेक्शन: Spark, Apache Hadoop HDFS और Apache Cassandra जैसे बाहरी स्टोरेज सिस्टम्स के साथ प्रत्येक सिस्टम के लिए विशेष रूप से डिज़ाइन किए गए कनेक्टर्स या लाइब्रेरीज़ के माध्यम से एकीकृत होता है। उदाहरण के लिए, HDFS इंटीग्रेशन Spark में नैटिव है, जिससे Spark Hadoop InputFormat और OutputFormat APIs का उपयोग करके सीधे HDFS से डेटा पढ़ और लिख सकता है।
2. Apache Cassandra कनेक्शन: इन इंटीग्रेशंस का लाभ लेने के फायदे में (HDFS के मामले में) डेटा लोकैलिटी के कारण बेहतर परफॉर्मेंस, डेटा एक्सेस और मैनिप्युलेशन का सरलीकरण, और मौजूदा डेटा इन्फ्रास्ट्रक्चर के साथ संगतता शामिल हैं। इसके अतिरिक्त, Spark इन स्टोरेज सिस्टम्स की वितरित प्रकृति का उपयोग पैरेलल प्रोसेसिंग के लिए कर सकता है, जो स्केलेबल डेटा प्रोसेसिंग सक्षम करता है।

13. Spark में ब्रॉडकास्ट वेरिएबल्स की अवधारणा समझाएँ

Spark में ब्रॉडकास्ट वेरिएबल्स रीड-ओनली वेरिएबल्स होते हैं जिन्हें वितरित Spark एप्लिकेशन के सभी वर्कर नोड्स पर कैश किया जाता है और उपलब्ध कराया जाता है। इन्हें बड़े, रीड-ओनली डेटासेट्स या वैल्यूज़ को वर्कर नोड्स तक कुशलतापूर्वक वितरित करने के लिए उपयोग किया जाता है, जिससे नेटवर्क ओवरहेड कम होता है और टास्क परफॉर्मेंस बेहतर होती है। 

ब्रॉडकास्ट वेरिएबल्स को सिरियलाइज़ करके प्रत्येक वर्कर नोड पर केवल एक बार भेजा जाता है, जहाँ उन्हें मेमोरी में कैश किया जाता है और कई टास्क्स में पुन: उपयोग किया जाता है। यह प्रत्येक टास्क के साथ वेरिएबल भेजने की आवश्यकता को समाप्त करता है, विशेषकर बड़े डेटासेट्स के लिए डेटा ट्रांसफ़र ओवरहेड को कम करता है।

• उपयोग: ब्रॉडकास्ट वेरिएबल्स का उपयोग आमतौर पर तब किया जाता है जब किसी बड़े डेटासेट या वैल्यू को कई टास्क्स या कंप्यूटेशन स्टेजेज़ में साझा करने की आवश्यकता होती है। उदाहरण के लिए, जॉइन ऑपरेशंस में जहाँ एक DataFrame या RDD दूसरे की तुलना में काफी छोटा हो, छोटे DataFrame/RDD को ब्रॉडकास्ट करना जॉइन के दौरान नेटवर्क पर शफल होने वाले डेटा की मात्रा को काफी कम कर सकता है।
• लाभकारी परिदृश्य:
• जॉइन ऑपरेशंस: छोटे डेटासेट्स को ब्रॉडकास्ट करके जॉइन्स में नेटवर्क ट्रैफिक कम होता है और टास्क निष्पादन तेज़ होता है।
• लुकअप टेबल्स: एनरिचमेंट या फ़िल्टरिंग ऑपरेशंस में प्रयुक्त छोटी लुकअप टेबल्स या डिक्शनरीज़ को ब्रॉडकास्ट करना बार-बार के डेटा ट्रांसफ़र्स से बचकर परफॉर्मेंस बढ़ाता है।
• मशीन लर्निंग: वितरित ट्रेनिंग के दौरान फीचर वेक्टर्स या मॉडल पैरामीटर्स को वर्कर नोड्स पर ब्रॉडकास्ट करना ट्रेनिंग को तेज़ कर सकता है, खासकर जब फीचर वेक्टर्स या पैरामीटर्स डेटासेट की तुलना में अपेक्षाकृत छोटे हों।
• चुनौतियाँ:
• मेमोरी ओवरहेड: बड़े वेरिएबल्स का ब्रॉडकास्ट करना वर्कर नोड्स पर पर्याप्त मेमोरी खपत कर सकता है, और सावधानी न बरतने पर आउट-ऑफ-मेमोरी त्रुटियों का कारण बन सकता है।
• नेटवर्क कंजेशन: बड़े वेरिएबल्स का ब्रॉडकास्ट शुरुआती चरण में नेटवर्क कंजेशन पैदा कर सकता है, विशेषकर बड़े क्लस्टर्स में जहाँ नेटवर्क बैंडविड्थ सीमित हो।
• डायनेमिक डेटा: ब्रॉडकास्ट वेरिएबल्स एक बार ब्रॉडकास्ट होने के बाद इम्यूटेबल होते हैं, इसलिए वे उन परिदृश्यों के लिए उपयुक्त नहीं हैं जहाँ Spark जॉब के निष्पादन के दौरान ब्रॉडकास्टेड डेटा को डायनेमिक रूप से अपडेट करने की आवश्यकता हो।

14. आप पार्टिशनिंग और कोएलसिंग का उपयोग करके एक Spark जॉब को कैसे ऑप्टिमाइज़ करते हैं? 

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

उत्तर:

• पार्टिशनिंग: किसी RDD या DataFrame में पार्टिशनों की संख्या को नियंत्रित करता है। समान रूप से या अधिक पार्टिशन करने के लिए .repartition() का उपयोग करें। यह अधिक कंप्यूटेशनल रूप से महंगा है और तब ही प्रयोग करना चाहिए जब संतुलित प्रोसेसिंग के लिए डेटा का समान विभाजन आवश्यक हो।
• कोएलसिंग: पूर्ण शफल किए बिना पार्टिशनों की संख्या घटाता है, जो पार्टिशन घटाने पर repartition की तुलना में अधिक कुशल है। इसके लिए हम .coalesce() का उपयोग करते हैं।

# Increasing partitions (full shuffle)
df_repartitioned = df.repartition(10)
# Reducing partitions (no full shuffle)
df_coalesced = df.coalesce(2)

ध्यान दें कि एक फॉलो-अप प्रश्न में पूछा जा सकता है कि ये ऑपरेशंस कब सबसे अधिक उपयोगी होते हैं। अवश्य बताइए कि ये बड़े डेटासेट्स पर अधिक प्रभावी होते हैं, और छोटे डेटासेट्स पर कंप्यूटिंग पावर बर्बाद नहीं करनी चाहिए।

15. Spark की डेटा सिरियलाइज़ेशन फ़ॉर्मैट्स के साथ इंटरऑपरेबिलिटी समझाएँ

डेटा प्रोफेशनल्स विभिन्न डेटा फ़ॉर्मैट्स के साथ काम करेंगे। प्रत्येक के अलग-अलग ट्रेड-ऑफ होते हैं। सुनिश्चित करें कि आप समझा सकें कि Spark आमतौर पर इन फ़ॉर्मैट्स के साथ कैसे इंटरैक्ट करता है और उच्च-स्तरीय परफॉर्मेंस तथा व्यापक इकोसिस्टम के लिए किन बातों पर विचार करना चाहिए।

1. डेटा सिरियलाइज़ेशन फ़ॉर्मैट सपोर्ट: Spark, Avro, Parquet या ORC जैसे डेटा सिरियलाइज़ेशन फ़ॉर्मैट्स के साथ बिल्ट-इन सपोर्ट या थर्ड-पार्टी लाइब्रेरीज़ के माध्यम से इंटरऑपरेट करता है। ये फ़ॉर्मैट्स कुशल कंप्रेशन, कॉलमनर स्टोरेज, और स्कीमा इवोल्यूशन जैसे लाभ प्रदान करते हैं, जो Spark-आधारित पाइपलाइन्स में डेटा प्रोसेसिंग और स्टोरेज के लिए उपयुक्त हैं।
2. डेटा रीडिंग ऑप्टिमाइज़ेशन: Spark, विशेष रीडर्स और राइटर्स का उपयोग करके इन फ़ॉर्मैट्स के साथ पढ़ने और लिखने के ऑपरेशंस को ऑप्टिमाइज़ करता है, जो उनकी आंतरिक संरचना और कंप्रेशन तकनीकों का लाभ उठाते हैं। उदाहरण के लिए, Parquet और ORC कॉलमनर स्टोरेज का उपयोग I/O ओवरहेड को न्यूनतम करने और क्वेरी परफॉर्मेंस में सुधार के लिए करते हैं।
3. डेटा फ़ॉर्मैट ट्रेड-ऑफ्स: ट्रेड-ऑफ्स में स्टोरेज दक्षता (जैसे, कंप्रेशन रेशियो), परफॉर्मेंस (जैसे, रीड/राइट थ्रूपुट), और अन्य डेटा प्रोसेसिंग टूल्स के साथ संगतता शामिल हैं। सही सिरियलाइज़ेशन फ़ॉर्मैट का चुनाव डेटा की विशेषताओं, क्वेरी पैटर्न्स, और डेटा पाइपलाइन के भीतर इंटीग्रेशन आवश्यकताओं जैसे कारकों पर निर्भर करता है।

Spark कोडिंग इंटरव्यू प्रश्न

ये कोडिंग प्रश्न Spark एनवायरनमेंट के साथ इंटरेक्ट करने के लिए PySpark के उपयोग पर केंद्रित हैं। 

16. किसी बड़े टेक्स्ट फ़ाइल में शीर्ष N सबसे अधिक बार आने वाले शब्द खोजें

यह प्रश्न Spark के साथ आपकी इंटरेक्शन क्षमता और Spark में मैपिंग के उपयोग की समझ की जाँच करता है।

from pyspark import SparkContext
# create your spark context
sc = SparkContext("local", "WordCount")
# import a text file from a local path
lines = sc.textFile("path/to/your/text/file.txt")
# split and map the words
# then reduce by using the words as keys and add to the count
word_counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)
# order the words and take only the top N frequent words
top_n_words = word_counts.takeOrdered(N, key=lambda x: -x[1])
print(top_n_words)

17. दिए गए RDD में वैल्यूज़ का औसत निकालें

यह प्रश्न यह दर्शाने का एक बढ़िया तरीका है कि क्या कोई व्यक्ति एक सरल RDD बना और उसे मैनिप्युलेट कर सकता है। वैल्यूज़ का औसत निकालना डेटा प्रोफेशनल्स को दिया जाने वाला एक बहुत सामान्य कार्य है, और यह समझना महत्वपूर्ण है कि Spark कॉन्टेक्स्ट में डेटा लेकर उसे कैसे आकार दिया जाए।

from pyspark import SparkContext
# Create sparkContext and name it “Average”
sc = SparkContext("local", "Average")
# Generate Spark RDD
data = sc.parallelize([1, 2, 3, 4, 5])
# Sum the RDD, count the number of values in RDD
total_sum = data.sum()
count = data.count()
# divide sum by count to get average 
average = total_sum / count
print("Average:", average)
	

18. दो RDDs के बीच लेफ्ट आउटर जॉइन करें

SparkSQL में जॉइन्स जैसी डेटा मैनिप्युलेशन और ट्रांसफॉर्मेशन टास्क्स करना एक प्रमुख घटक है। यह डेटा विश्लेषण के लिए विभिन्न स्रोतों के बीच डेटा को संयोजित करने की अनुमति देता है। 

from pyspark import SparkContext
# Create SparkContext
sc = SparkContext("local", "LeftOuterJoin")
# Create two RDDs with tuples sharing keys
rdd1 = sc.parallelize([(1, 'a'), (2, 'b'), (3, 'c')])
rdd2 = sc.parallelize([(1, 'x'), (2, 'y')])
# Use the .leftOuterJoin() method to join the first rdd to the second rdd
joined_rdd = rdd1.leftOuterJoin(rdd2)
# Use the .collect() method to show the rdd
print(joined_rdd.collect())
	

19. Kafka से डेटा पढ़ें, ट्रांसफॉर्मेशंस करें, और फिर परिणामों को HDFS में लिखें

यह आपकी बाहरी डेटा स्रोतों से डेटा लाने की क्षमता और Spark के इन स्रोतों से कनेक्ट होने की समझ का परीक्षण करता है। यहाँ फोकस सामान्य अवधारणाओं पर रखें, जैसे किसी विशेष डेटा स्ट्रीम के लिए एक्सटेंशंस/यूटिलिटीज़ को इम्पोर्ट करने की आवश्यकता, न कि सटीक कोडिंग को याद रखने पर। ध्यान दें कि SparkContext के लिए हमने appname (KafkaWordCount) को एक वैकल्पिक पैरामीटर के रूप में चुना है, लेकिन यह रखना अच्छा है क्योंकि यह प्रक्रियाओं को स्पष्ट रखता है।

# Import the sparkcontext, additionally import streaming context and Kafka
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
from pyspark.streaming.kafka import KafkaUtils
# Create context 
sc = SparkContext("local", "KafkaWordCount")
# Use streaming context to bring in data at 10 second intervals
ssc = StreamingContext(sc, 10)  # 10-second batch interval
# Use Kafka param dictionary in order to connect to the stream using the streaming context, the topic of interest, and the parameters
kafka_params = {"metadata.broker.list": "broker1:9092,broker2:9092"}
kafka_stream = KafkaUtils.createDirectStream(ssc, ["topic"], kafka_params)
# save the results of this stream to lines
# perform MapReduce in order to generate dictionary and count by keys
lines = kafka_stream.map(lambda x: x[1])
word_counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)
# save to external file
word_counts.saveAsTextFiles("hdfs://path/to/save")
# start context until you terminate
ssc.start()
ssc.awaitTermination()
	

20. आप Spark DataFrame पर बुनियादी ट्रांसफॉर्मेशंस और ऐक्शंस कैसे करते हैं?

यह प्रश्न DataFrame ऑपरेशंस पर उम्मीदवार की समझ का मूल्यांकन करता है।

ट्रांसफॉर्मेशंस ऐसे ऑपरेशन हैं जो DataFrames पर लागू होकर नया DataFrame लौटाते हैं, जैसे select, filter, और groupBy। ऐक्शंस वे ऑपरेशन हैं जो कंप्यूटेशन को ट्रिगर करते हैं और परिणाम लौटाते हैं, जैसे show, count, और collect।

यह स्निपेट कॉलम्स चुनना, रो को फ़िल्टर करना, और group-by एग्रीगेशन करना दिखाता है।

# Select specific columns
selected_df = df.select("column1", "column2")
# Filter rows based on a condition
filtered_df = df.filter(df["column1"] > 100)
# Group by a column and perform aggregation
grouped_df = df.groupBy("column2").agg({"column1": "sum"})
# Show the results
selected_df.show()
filtered_df.show()
grouped_df.show()

अंतिम विचार

इन इंटरव्यू प्रश्नों में महारत हासिल करना डेटा प्रोफेशनल बनने की दिशा में एक शानदार पहला कदम है। Spark कई संगठनों द्वारा उनके बिग डेटा पाइपलाइन्स को संभालने के लिए उपयोग की जाने वाली एक सामान्य इन्फ्रास्ट्रक्चर है। Spark के लाभ और चुनौतियों को समझना आपको एक जानकार डेटा प्रोफेशनल के रूप में अलग पहचान दिलाएगा। यह तो बस शुरुआत है! Spark के साथ हाथों-हाथ अनुभव प्राप्त करना सीखने का सबसे अच्छा तरीका है। 

आप DataCamp पर निम्नलिखित PySpark कोर्स और ट्यूटोरियल्स से शुरुआत कर सकते हैं:

• Introduction to PySpark
• Introduction to Spark SQL in Python
• Big Data with PySpark
• Apache Spark Tutorial: ML with PySpark