चिंगारी DataFrame कॉलम को अजगर सूची में बदलें

Question 1

मैं दो कॉलम, mvv और काउंट के साथ एक डेटाफ्रेम पर काम करता हूं।

+---+-----+
|mvv|count|
+---+-----+
| 1 |  5  |
| 2 |  9  |
| 3 |  3  |
| 4 |  1  |

मैं दो लिस्ट प्राप्त करना चाहूँगा जिसमें mvv मान और काउंट वैल्यू शामिल हैं। कुछ इस तरह

mvv = [1,2,3,4]
count = [5,9,3,1]

इसलिए, मैंने निम्न कोड की कोशिश की: पहली पंक्ति को पंक्ति की अजगर सूची वापस करनी चाहिए। मैं पहला मूल्य देखना चाहता था:

mvv_list = mvv_count_df.select('mvv').collect()
firstvalue = mvv_list[0].getInt(0)

लेकिन मुझे दूसरी पंक्ति के साथ एक त्रुटि संदेश मिलता है:

विशेषता: getInt

Question 2

देखें, इस तरह से जो आप कर रहे हैं वह काम क्यों नहीं कर रहा है। सबसे पहले, आप रो प्रकार से पूर्णांक प्राप्त करने की कोशिश कर रहे हैं , आपके संग्रह का आउटपुट इस प्रकार है:

>>> mvv_list = mvv_count_df.select('mvv').collect()
>>> mvv_list[0]
Out: Row(mvv=1)

यदि आप ऐसा कुछ लेते हैं:

>>> firstvalue = mvv_list[0].mvv
Out: 1

आपको mvvमान मिलेगा । यदि आप सरणी की सारी जानकारी चाहते हैं तो आप कुछ इस तरह ले सकते हैं:

>>> mvv_array = [int(row.mvv) for row in mvv_list.collect()]
>>> mvv_array
Out: [1,2,3,4]

लेकिन अगर आप दूसरे कॉलम के लिए भी यही कोशिश करते हैं, तो आपको यह मिलता है:

>>> mvv_count = [int(row.count) for row in mvv_list.collect()]
Out: TypeError: int() argument must be a string or a number, not 'builtin_function_or_method'

ऐसा इसलिए होता है क्योंकि countएक अंतर्निहित पद्धति है। और कॉलम का एक ही नाम है count। इसे करने के लिए एक वर्कअराउंड का नाम बदल दिया countजाता है _count:

>>> mvv_list = mvv_list.selectExpr("mvv as mvv", "count as _count")
>>> mvv_count = [int(row._count) for row in mvv_list.collect()]

लेकिन इस वर्कअराउंड की जरूरत नहीं है, क्योंकि आप शब्दकोष का उपयोग कर कॉलम को एक्सेस कर सकते हैं:

>>> mvv_array = [int(row['mvv']) for row in mvv_list.collect()]
>>> mvv_count = [int(row['count']) for row in mvv_list.collect()]

और यह अंत में काम करेगा!

Question 3

एक लाइनर का पालन करने के बाद आप जो सूची चाहते हैं।

mvv = mvv_count_df.select("mvv").rdd.flatMap(lambda x: x).collect()

Question 4

यह आपको सूची के रूप में सभी तत्व देगा।

mvv_list = list(
    mvv_count_df.select('mvv').toPandas()['mvv']
)

Question 5

निम्नलिखित कोड आपकी सहायता करेगा

mvv_count_df.select('mvv').rdd.map(lambda row : row[0]).collect()

Question 6

मेरे डेटा पर मुझे ये बेंचमार्क मिले:

>>> data.select(col).rdd.flatMap(lambda x: x).collect()

0.52 सेकंड

>>> [row[col] for row in data.collect()]

0.271 सेकंड

>>> list(data.select(col).toPandas()[col])

0.427 सेकंड

नतीजा वही है

Question 7

यदि आपको नीचे त्रुटि मिलती है:

गुण: 'सूची' ऑब्जेक्ट में कोई विशेषता नहीं 'संग्रह' है

यह कोड आपके मुद्दों को हल करेगा:

mvv_list = mvv_count_df.select('mvv').collect()

mvv_array = [int(i.mvv) for i in mvv_list]

Question 8

मैंने एक बेंचमार्किंग विश्लेषण चलाया और list(mvv_count_df.select('mvv').toPandas()['mvv'])यह सबसे तेज़ तरीका है। मैं बहुत हैरान हूं।

मैंने 5 नोड i3.xlarge क्लस्टर (प्रत्येक नोड में स्पार्क 2.4.5 के साथ 30.5 जीबी रैम और 4 कोर) का उपयोग करके 100 हजार / 100 मिलियन पंक्ति डेटासेट पर विभिन्न दृष्टिकोणों को चलाया। एक स्तंभ के साथ 20 तड़क-भड़क वाली संपीड़ित फ़ाइलों पर डेटा समान रूप से वितरित किया गया था।

यहां बेंचमार्किंग परिणाम (सेकंड में रनटाइम):

+-------------------------------------------------------------+---------+-------------+
|                          Code                               | 100,000 | 100,000,000 |
+-------------------------------------------------------------+---------+-------------+
| df.select("col_name").rdd.flatMap(lambda x: x).collect()    |     0.4 | 55.3        |
| list(df.select('col_name').toPandas()['col_name'])          |     0.4 | 17.5        |
| df.select('col_name').rdd.map(lambda row : row[0]).collect()|     0.9 | 69          |
| [row[0] for row in df.select('col_name').collect()]         |     1.0 | OOM         |
| [r[0] for r in mid_df.select('col_name').toLocalIterator()] |     1.2 | *           |
+-------------------------------------------------------------+---------+-------------+

* cancelled after 800 seconds

ड्राइवर नोड पर डेटा एकत्र करते समय अनुसरण करने के सुनहरे नियम:

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

toPandas स्पार्क 2.3 में काफी सुधार हुआ था । यदि आप 2.3 से पहले स्पार्क संस्करण का उपयोग कर रहे हैं तो शायद यह सबसे अच्छा तरीका नहीं है।

अधिक विवरण / बेंचमार्किंग परिणामों के लिए यहां देखें ।

Question 9

एक संभावित समाधान collect_list()से फ़ंक्शन का उपयोग कर रहा है pyspark.sql.functions। यह सभी स्तंभ मानों को एक pyspark सरणी में एकत्रित करेगा, जिसे एकत्र करते समय एक अजगर सूची में परिवर्तित किया जाता है:

mvv_list   = df.select(collect_list("mvv")).collect()[0][0]
count_list = df.select(collect_list("count")).collect()[0][0]