PySpark शुरुआती लोगों के लिए ट्यूटोरियल: उदाहरणों के साथ सीखें

द्वारा: एवलिन क्लार्क एवलिन क्लार्क
Hours Updated

Py सीखने से पहलेSparkआइये समझते हैं:

अपाचे क्या है Spark?

Spark यह एक बड़ा डेटा समाधान है जो Hadoop MapReduce की तुलना में अधिक आसान और तेज़ साबित हुआ है। Spark 2009 में यूसी बर्कले आरएडी लैब द्वारा विकसित एक ओपन सोर्स सॉफ्टवेयर है। चूंकि इसे 2010 में जनता के लिए जारी किया गया था, Spark इसकी लोकप्रियता बढ़ी है और इसका उपयोग उद्योग जगत में अभूतपूर्व पैमाने पर किया जाता है।

के युग में बड़ा डेटा, चिकित्सकों को डेटा स्ट्रीमिंग को प्रोसेस करने के लिए पहले से कहीं ज़्यादा तेज़ और विश्वसनीय टूल की ज़रूरत है। पहले MapReduce जैसे टूल पसंदीदा थे लेकिन धीमे थे। इस समस्या को दूर करने के लिए, Spark एक ऐसा समाधान प्रदान करता है जो तेज़ और सामान्य-उद्देश्य दोनों है। Spark और मैपरिड्यूस वह है Spark बाद में हार्ड डिस्क पर मेमोरी में गणनाएँ चलाता है। यह उच्च गति की पहुँच और डेटा प्रोसेसिंग की अनुमति देता है, जिससे समय घंटों से मिनटों में कम हो जाता है।

Py क्या है?Spark?

PySpark अपाचे द्वारा बनाया गया एक उपकरण है Spark उपयोग के लिए समुदाय Python साथ में Spark. यह RDD (रेजिलिएंट डिस्ट्रिब्यूटेड डेटासेट) के साथ काम करने की अनुमति देता है Python. यह Py भी प्रदान करता हैSpark लिंक करने के लिए शैल Python एपीआई के साथ Spark आरंभ करने के लिए कोर Spark प्रसंग। Spark क्लस्टर कंप्यूटिंग को साकार करने के लिए नाम इंजन है, जबकि PySpark is Pythonकी लाइब्रेरी का उपयोग करें Spark.

कैसे Spark काम करते हो?

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

कैसे करता है Spark काम
कैसे करता है Spark काम

Spark के साथ काम करने के लिए डिज़ाइन किया गया है

  • Python
  • Java
  • स्काला
  • एसक्यूएल

की एक महत्वपूर्ण विशेषता Spark मशीन लर्निंग के लिए MLlib सहित बड़ी मात्रा में बिल्ट-इन लाइब्रेरी है. Spark इसे हाडोप क्लस्टर्स के साथ काम करने के लिए भी डिज़ाइन किया गया है और यह हाइव डेटा, सीएसवी, जेएसओएन, कैसांद्रा डेटा सहित व्यापक प्रकार की फ़ाइलों को पढ़ सकता है।

क्यों का उपयोग करें Spark?

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

  • डेटा को डिस्क पर लोड करें
  • डेटा को मशीन की मेमोरी में आयात करें
  • डेटा को संसाधित/विश्लेषण करें
  • मशीन लर्निंग मॉडल बनाएं
  • पूर्वानुमान को डिस्क पर वापस संग्रहीत करें

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

हालाँकि, इसमें कुछ समस्याएं हैं:

  • क्या डेटासेट वास्तविक दुनिया को प्रतिबिंबित कर रहा है?
  • क्या डेटा में कोई विशिष्ट उदाहरण शामिल है?
  • क्या मॉडल नमूनाकरण के लिए उपयुक्त है?

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

उपाय क्या है?

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

Pyspark डेटा वैज्ञानिक को एक API देता है जिसका उपयोग समानांतर डेटा प्रक्रिया समस्याओं को हल करने के लिए किया जा सकता है। Pyspark मल्टीप्रोसेसिंग की जटिलताओं को संभालता है, जैसे कि डेटा वितरित करना, कोड वितरित करना और मशीनों के क्लस्टर पर श्रमिकों से आउटपुट एकत्र करना।

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

• इसका एक मुख्य लाभ यह है Spark इसका उद्देश्य एक ऐसी वास्तुकला का निर्माण करना है जिसमें डेटा स्ट्रीमिंग प्रबंधन, निर्बाध डेटा क्वेरी, मशीन लर्निंग भविष्यवाणी और विभिन्न विश्लेषणों तक वास्तविक समय तक पहुंच शामिल हो।

• Spark SQL भाषा, यानी संरचित डेटा के साथ मिलकर काम करता है। यह वास्तविक समय में डेटा को क्वेरी करने की अनुमति देता है।

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

इस पाय मेंSpark ट्यूटोरियल में, आप सीखेंगे कि Py के साथ क्लासिफायर कैसे बनाया जाता हैSpark उदाहरण।

संबंधित आलेख

Py कैसे स्थापित करेंSpark AWS के साथ

RSI Jupyter टीम चलाने के लिए एक Docker छवि का निर्माण करती है Spark कुशलतापूर्वक। Py को स्थापित करने के लिए आप नीचे दिए गए चरणों का पालन कर सकते हैंSpark AWS में एक उदाहरण.

हमारा ट्यूटोरियल देखें एडब्ल्यूएस और TensorFlow

चरण 1: एक इंस्टेंस बनाएं

सबसे पहले, आपको एक इंस्टेंस बनाना होगा। अपने AWS अकाउंट पर जाएं और इंस्टेंस लॉन्च करें। आप स्टोरेज को 15g तक बढ़ा सकते हैं और TensorFlow ट्यूटोरियल में बताए गए समान सुरक्षा समूह का उपयोग कर सकते हैं।

चरण 2: कनेक्शन खोलें

कनेक्शन खोलें और डॉकर कंटेनर इंस्टॉल करें। अधिक जानकारी के लिए, TensorFlow के साथ ट्यूटोरियल देखें डाक में काम करनेवाला मज़दूरध्यान रखें कि, आपको सही कार्यशील निर्देशिका में होना चाहिए।

Docker को स्थापित करने के लिए बस इन कोडों को चलाएँ:

sudo yum update -y
sudo yum install -y docker
sudo service docker start
sudo user-mod -a -G docker ec2-user
exit

चरण 3: कनेक्शन को पुनः खोलें और इंस्टॉल करें Spark

कनेक्शन को पुनः खोलने के बाद, आप Py युक्त छवि को स्थापित कर सकते हैंSpark.

## Spark
docker run -v ~/work:/home/jovyan/work -d -p 8888:8888 jupyter/pyspark-notebook

## Allow preserving Jupyter notebook
sudo chown 1000 ~/work

## Install tree to see our working directory next
sudo yum install -y tree

चरण 4: ओपन Jupyter

कंटेनर और उसका नाम जांचें

docker ps

डॉकर लॉग के साथ डॉकर को लॉन्च करें और उसके बाद डॉकर का नाम लिखें। उदाहरण के लिए, डॉकर लॉग zealous_goldwasser

अपने ब्राउज़र पर जाएं और लॉन्च करें Jupyter. पता है http://localhost:8888/. टर्मिनल द्वारा दिया गया पासवर्ड पेस्ट करें.

नोटयदि आप अपनी AWS मशीन पर कोई फ़ाइल अपलोड/डाउनलोड करना चाहते हैं, तो आप साइबरडक सॉफ़्टवेयर का उपयोग कर सकते हैं, https://cyberduck.io/.

Py कैसे स्थापित करेंSpark on Windows/मैक विद कोंडा

Py को स्थापित करने की विस्तृत प्रक्रिया निम्नलिखित हैSpark on Windows/मैक एनाकोंडा का उपयोग कर रहा है:

स्थापित करने के लिए Spark आपकी स्थानीय मशीन पर, एक नया conda वातावरण बनाना एक अनुशंसित अभ्यास है। यह नया वातावरण इंस्टॉल हो जाएगा Python 3.6, Spark और सभी निर्भरताएँ.

मैक उपयोगकर्ता

cd anaconda3
touch hello-spark.yml
vi hello-spark.yml

Windows उपयोगकर्ता

cd C:\Users\Admin\Anaconda3
echo.>hello-spark.yml
notepad hello-spark.yml

आप .yml फ़ाइल को संपादित कर सकते हैं। इंडेंट के साथ सावधान रहें। – से पहले दो स्पेस की आवश्यकता है

name: hello-spark 
    dependencies:
    
    - python=3.6
    - jupyter
    - ipython
    - numpy
    - numpy-base
    - pandas
    - py4j
    - pyspark
    - pytz

इसे बचाएँ और माहौल बनाएँ। इसमें कुछ समय लगता है

conda env create -f hello-spark.yml

स्थान के बारे में अधिक जानकारी के लिए, कृपया ट्यूटोरियल देखें TensorFlow स्थापित करें

आप अपनी मशीन में स्थापित सभी वातावरण की जांच कर सकते हैं

conda env list
Activate hello-spark

मैक उपयोगकर्ता

source activate hello-spark

Windows उपयोगकर्ता

activate hello-spark

नोट: आपने TensorFlow पर ट्यूटोरियल चलाने के लिए पहले से ही एक विशिष्ट TensorFlow वातावरण बनाया है। hello-tf से अलग एक नया वातावरण बनाना अधिक सुविधाजनक है। hello-tf को ओवरलोड करने का कोई मतलब नहीं है Spark या कोई अन्य मशीन लर्निंग लाइब्रेरी।

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

Jupyter

प्रारंभिक Jupyter नोटबुक और कोशिश करें कि PySpark काम करता है। एक नई नोटबुक में निम्नलिखित Py चिपकाएँSpark नमूना कोड:

import pyspark
from pyspark import SparkContext
sc =SparkContext()

यदि कोई त्रुटि दिखाई देती है, तो सम्भावना है कि Java आपकी मशीन पर इंस्टॉल नहीं है। मैक में, टर्मिनल खोलें और java -version लिखें, अगर कोई java संस्करण है, तो सुनिश्चित करें कि यह 1.8 है। Windows, एप्लीकेशन पर जाएं और जांचें कि क्या कोई है Java फ़ोल्डर. अगर वहाँ एक है Java फ़ोल्डर, जाँच करें कि Java 1.8 स्थापित है. इस लेखन के समय, PySpark के साथ संगत नहीं है Java9 और ऊपर।

यदि आपको स्थापित करने की आवश्यकता है Java, आपको सोचना होगा संपर्क और jdk-8u181-windows-x64.exe डाउनलोड करें

Jupyter

मैक उपयोगकर्ता के लिए, `brew` का उपयोग करने की अनुशंसा की जाती है।

brew tap caskroom/versions
brew cask install java8

इस चरण दर चरण ट्यूटोरियल का संदर्भ लें कैसे स्थापित करने के लिए Java

नोट: किसी परिवेश को पूरी तरह मिटाने के लिए remove का उपयोग करें।

 conda env remove -n hello-spark -y

Spark संदर्भ

Sparkसंदर्भ आंतरिक इंजन है जो क्लस्टर के साथ कनेक्शन की अनुमति देता है। यदि आप कोई ऑपरेशन चलाना चाहते हैं, तो आपको एक की आवश्यकता है Sparkप्रसंग।

बनाओ Sparkसंदर्भ

सबसे पहले, आपको एक पहल करनी होगी Sparkप्रसंग।

import pyspark
from pyspark import SparkContext
sc =SparkContext()

अब जब कि Sparkसंदर्भ तैयार है, आप RDD, रेसिलिएंट डिस्ट्रिब्यूटेड डेटासेट नामक डेटा का संग्रह बना सकते हैं। RDD में गणना स्वचालित रूप से क्लस्टर में समानांतर होती है।

nums= sc.parallelize([1,2,3,4])

आप take बटन से पहली पंक्ति तक पहुंच सकते हैं

nums.take(1)
[1]

आप लैम्ब्डा फ़ंक्शन के साथ डेटा पर परिवर्तन लागू कर सकते हैं। Py मेंSpark नीचे दिए गए उदाहरण में, आप संख्याओं का वर्ग लौटाते हैं। यह एक मानचित्र परिवर्तन है

squared = nums.map(lambda x: x*x).collect()
for num in squared:
    print('%i ' % (num))

1 
4 
9 
16

एसक्यूएल संदर्भ

डेटाफ्रेम का उपयोग करना अधिक सुविधाजनक तरीका है। Sparkयदि संदर्भ पहले से ही सेट है, तो आप इसका उपयोग डेटाफ़्रेम बनाने के लिए कर सकते हैं। आपको SQLContext भी घोषित करना होगा

SQLContext इंजन को विभिन्न डेटा स्रोतों से जोड़ने की अनुमति देता है। इसका उपयोग इंजन की कार्यक्षमताओं को आरंभ करने के लिए किया जाता है। Spark एसक्यूएल।

from pyspark.sql import Row
from pyspark.sql import SQLContext

sqlContext = SQLContext(sc)

अब इसमें Spark ट्यूटोरियल Python, चलिए टपल की एक सूची बनाते हैं। प्रत्येक टपल में लोगों का नाम और उनकी आयु होगी। चार चरण आवश्यक हैं:

चरण 1) जानकारी के साथ ट्यूपल की सूची बनाएं

[('John',19),('Smith',29),('Adam',35),('Henry',50)]

चरण 2) RDD बनाएं

rdd = sc.parallelize(list_p)

चरण 3) ट्यूपल्स को परिवर्तित करें

rdd.map(lambda x: Row(name=x[0], age=int(x[1])))

चरण 4) डेटाफ़्रेम संदर्भ बनाएँ

sqlContext.createDataFrame(ppl)
list_p = [('John',19),('Smith',29),('Adam',35),('Henry',50)]
rdd = sc.parallelize(list_p)
ppl = rdd.map(lambda x: Row(name=x[0], age=int(x[1])))
DF_ppl = sqlContext.createDataFrame(ppl)

यदि आप प्रत्येक सुविधा के प्रकार तक पहुँचना चाहते हैं, तो आप printSchema() का उपयोग कर सकते हैं

DF_ppl.printSchema()
root
 |-- age: long (nullable = true)
 |-- name: string (nullable = true)

Py के साथ मशीन लर्निंग उदाहरणSpark

अब आपको इसका संक्षिप्त विचार मिल गया है Spark और SQLContext, आप अपना पहला मशीन लर्निंग प्रोग्राम बनाने के लिए तैयार हैं।

Py के साथ मशीन लर्निंग प्रोग्राम बनाने के चरण निम्नलिखित हैंSpark:

  • चरण 1) Py के साथ बुनियादी संचालनSpark
  • चरण 2) डेटा प्रीप्रोसेसिंग
  • चरण 3) डेटा प्रोसेसिंग पाइपलाइन बनाएं
  • चरण 4) क्लासिफायर बनाएं: लॉजिस्टिक
  • चरण 5) मॉडल को प्रशिक्षित और मूल्यांकन करें
  • चरण 6) हाइपरपैरामीटर को ट्यून करें

इस पाय मेंSpark मशीन लर्निंग ट्यूटोरियल में, हम वयस्क डेटासेट का उपयोग करेंगे। इस ट्यूटोरियल का उद्देश्य Pyspark का उपयोग करना सीखना है। डेटासेट के बारे में अधिक जानकारी के लिए, इस ट्यूटोरियल को देखें।

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

चरण १) Py के साथ मूल ऑपरेशनSpark

सबसे पहले, आपको SQLContext को इनिशिएलाइज़ करना होगा जो अभी तक इनिशिएल नहीं हुआ है।

#from pyspark.sql import SQLContext
url = "https://raw.githubusercontent.com/guru99-edu/R-Programming/master/adult_data.csv"
from pyspark import SparkFiles
sc.addFile(url)
sqlContext = SQLContext(sc)

फिर, आप sqlContext.read.csv के साथ cvs फ़ाइल पढ़ सकते हैं। आप यह बताने के लिए inferSchema को True पर सेट करके उपयोग करते हैं Spark डेटा के प्रकार का अनुमान लगाने के लिए स्वचालित रूप से। डिफ़ॉल्ट रूप से, यह False पर होता है।

df = sqlContext.read.csv(SparkFiles.get("adult_data.csv"), header=True, inferSchema= True)

आइये डेटा प्रकार पर एक नज़र डालें

df.printSchema()
root
 |-- age: integer (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: integer (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: integer (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: integer (nullable = true)
 |-- capital_loss: integer (nullable = true)
 |-- hours_week: integer (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)

आप शो के साथ डेटा देख सकते हैं।

df.show(5, truncate = False)
+---+----------------+------+---------+-------------+------------------+-----------------+-------------+-----+------+------------+------------+----------+--------------+-----+
|age|workclass       |fnlwgt|education|education_num|marital           |occupation       |relationship |race |sex   |capital_gain|capital_loss|hours_week|native_country|label|
+---+----------------+------+---------+-------------+------------------+-----------------+-------------+-----+------+------------+------------+----------+--------------+-----+
|39 |State-gov       |77516 |Bachelors|13           |Never-married     |Adm-clerical     |Not-in-family|White|Male  |2174        |0           |40        |United-States |<=50K|
|50 |Self-emp-not-inc|83311 |Bachelors|13           |Married-civ-spouse|Exec-managerial  |Husband      |White|Male  |0           |0           |13        |United-States |<=50K|
|38 |Private         |215646|HS-grad  |9            |Divorced          |Handlers-cleaners|Not-in-family|White|Male  |0           |0           |40        |United-States |<=50K|
|53 |Private         |234721|11th     |7            |Married-civ-spouse|Handlers-cleaners|Husband      |Black|Male  |0           |0           |40        |United-States |<=50K|
|28 |Private         |338409|Bachelors|13           |Married-civ-spouse|Prof-specialty   |Wife         |Black|Female|0           |0           |40        |Cuba          |<=50K|
+---+----------------+------+---------+-------------+------------------+-----------------+-------------+-----+------+------------+------------+----------+--------------+-----+
only showing top 5 rows

यदि आपने inderShema को True पर सेट नहीं किया है, तो टाइप के साथ क्या हो रहा है, यह यहाँ देखें। ये सभी स्ट्रिंग में हैं।

df_string = sqlContext.read.csv(SparkFiles.get("adult.csv"), header=True, inferSchema=  False)
df_string.printSchema()
root
 |-- age: string (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: string (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: string (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: string (nullable = true)
 |-- capital_loss: string (nullable = true)
 |-- hours_week: string (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)

निरंतर चर को सही प्रारूप में बदलने के लिए, आप कॉलम को फिर से व्यवस्थित कर सकते हैं। आप यह बताने के लिए withColumn का उपयोग कर सकते हैं Spark परिवर्तन को किस स्तंभ पर संचालित करना है।

# Import all from `sql.types`
from pyspark.sql.types import *

# Write a custom function to convert the data type of DataFrame columns
def convertColumn(df, names, newType):
    for name in names: 
        df = df.withColumn(name, df[name].cast(newType))
    return df 
# List of continuous features
CONTI_FEATURES  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
# Convert the type
df_string = convertColumn(df_string, CONTI_FEATURES, FloatType())
# Check the dataset
df_string.printSchema()
root
 |-- age: float (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: float (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: float (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: float (nullable = true)
 |-- capital_loss: float (nullable = true)
 |-- hours_week: float (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)

from pyspark.ml.feature import StringIndexer
#stringIndexer = StringIndexer(inputCol="label", outputCol="newlabel")
#model = stringIndexer.fit(df)
#df = model.transform(df)
df.printSchema()

कॉलम चुनें

आप पंक्तियों को select और विशेषताओं के नाम के साथ चुनकर दिखा सकते हैं। नीचे, age और fnlwgt चयनित हैं।

df.select('age','fnlwgt').show(5)
+---+------+
|age|fnlwgt|
+---+------+
| 39| 77516|
| 50| 83311|
| 38|215646|
| 53|234721|
| 28|338409|
+---+------+
only showing top 5 rows

समूह के अनुसार गणना करें

यदि आप समूह के अनुसार घटनाओं की संख्या गिनना चाहते हैं, तो आप श्रृंखला बना सकते हैं:

  • द्वारा समूह बनाएं()
  • गिनती ()

एक साथ।Spark नीचे दिए गए उदाहरण में, आप शिक्षा स्तर के अनुसार पंक्तियों की संख्या गिनते हैं।

df.groupBy("education").count().sort("count",ascending=True).show()
+------------+-----+
|   education|count|
+------------+-----+
|   Preschool|   51|
|     1st-4th|  168|
|     5th-6th|  333|
|   Doctorate|  413|
|        12th|  433|
|         9th|  514|
| Prof-school|  576|
|     7th-8th|  646|
|        10th|  933|
|  Assoc-acdm| 1067|
|        11th| 1175|
|   Assoc-voc| 1382|
|     Masters| 1723|
|   Bachelors| 5355|
|Some-college| 7291|
|     HS-grad|10501|
+------------+-----+

डेटा का वर्णन करें

डेटा के सारांश आँकड़े प्राप्त करने के लिए, आप डिस्क्राइब() का उपयोग कर सकते हैं। यह निम्न की गणना करेगा:

  • गणना
  • मतलब
  • मानक विचलन
  • मिनट
  • मैक्स
df.describe().show()
+-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+
|summary|               age|  workclass|            fnlwgt|   education|    education_num| marital|      occupation|relationship|              race|   sex|      capital_gain|    capital_loss|        hours_week|native_country|label|
+-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+
|  count|             32561|      32561|             32561|       32561|            32561|   32561|           32561|       32561|             32561| 32561|             32561|           32561|             32561|         32561|32561|
|   mean| 38.58164675532078|       null|189778.36651208502|        null| 10.0806793403151|    null|            null|        null|              null|  null|1077.6488437087312| 87.303829734959|40.437455852092995|          null| null|
| stddev|13.640432553581356|       null|105549.97769702227|        null|2.572720332067397|    null|            null|        null|              null|  null| 7385.292084840354|402.960218649002|12.347428681731838|          null| null|
|    min|                17|          ?|             12285|        10th|                1|Divorced|               ?|     Husband|Amer-Indian-Eskimo|Female|                 0|               0|                 1|             ?|<=50K|
|    max|                90|Without-pay|           1484705|Some-college|               16| Widowed|Transport-moving|        Wife|             White|  Male|             99999|            4356|                99|    Yugoslavia| >50K|
+-------+------------------+-----------+------------------+------------+-----------------+--------+----------------+------------+------------------+------+------------------+----------------+------------------+--------------+-----+

यदि आप केवल एक कॉलम का सारांश सांख्यिकी चाहते हैं, तो डिस्क्राइब() के अंदर कॉलम का नाम जोड़ें

df.describe('capital_gain').show()
+-------+------------------+
|summary|      capital_gain|
+-------+------------------+
|  count|             32561|
|   mean|1077.6488437087312|
| stddev| 7385.292084840354|
|    min|                 0|
|    max|             99999|
+-------+------------------+

क्रॉसटैब संगणना

कुछ अवसरों पर, दो युग्मित स्तंभों के बीच वर्णनात्मक सांख्यिकी देखना दिलचस्प हो सकता है। उदाहरण के लिए, आप शिक्षा के स्तर के आधार पर 50k से कम या उससे अधिक आय वाले लोगों की संख्या गिन सकते हैं। इस ऑपरेशन को क्रॉसटैब कहा जाता है।

df.crosstab('age', 'label').sort("age_label").show()
+---------+-----+----+
|age_label|<=50K|>50K|
+---------+-----+----+
|       17|  395|   0|
|       18|  550|   0|
|       19|  710|   2|
|       20|  753|   0|
|       21|  717|   3|
|       22|  752|  13|
|       23|  865|  12|
|       24|  767|  31|
|       25|  788|  53|
|       26|  722|  63|
|       27|  754|  81|
|       28|  748| 119|
|       29|  679| 134|
|       30|  690| 171|
|       31|  705| 183|
|       32|  639| 189|
|       33|  684| 191|
|       34|  643| 243|
|       35|  659| 217|
|       36|  635| 263|
+---------+-----+----+
only showing top 20 rows

आप देख सकते हैं कि युवा अवस्था में किसी भी व्यक्ति की आय 50 हजार से अधिक नहीं होती।

स्तंभ छोड़ें

कॉलम हटाने के लिए दो सहज API हैं:

  • ड्रॉप(): एक कॉलम हटाएँ
  • dropna(): NA को हटाएँ

नीचे आप education_num कॉलम डालें

df.drop('education_num').columns

['age',
 'workclass',
 'fnlwgt',
 'education',
 'marital',
 'occupation',
 'relationship',
 'race',
 'sex',
 'capital_gain',
 'capital_loss',
 'hours_week',
 'native_country',
 'label']

डेटा फ़िल्टर करें

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

df.filter(df.age > 40).count()

13443

Descriptसमूह के अनुसार ive आँकड़े

अंततः, आप डेटा को समूहवार वर्गीकृत कर सकते हैं और माध्य जैसे सांख्यिकीय संक्रियाओं की गणना कर सकते हैं।

df.groupby('marital').agg({'capital_gain': 'mean'}).show()
+--------------------+------------------+
|             marital| avg(capital_gain)|
+--------------------+------------------+
|           Separated| 535.5687804878049|
|       Never-married|376.58831788823363|
|Married-spouse-ab...| 653.9832535885167|
|            Divorced| 728.4148098131893|
|             Widowed| 571.0715005035247|
|   Married-AF-spouse| 432.6521739130435|
|  Married-civ-spouse|1764.8595085470085|
+--------------------+------------------+

चरण 2) डेटा प्रीप्रोसेसिंग

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

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

आयु वर्ग जोड़ें

कोई नई सुविधा जोड़ने के लिए आपको यह करना होगा:

  1. कॉलम का चयन करें
  2. परिवर्तन लागू करें और इसे डेटाफ़्रेम में जोड़ें
from pyspark.sql.functions import *

# 1 Select the column
age_square = df.select(col("age")**2)

# 2 Apply the transformation and add it to the DataFrame
df = df.withColumn("age_square", col("age")**2)

df.printSchema()
root
 |-- age: integer (nullable = true)
 |-- workclass: string (nullable = true)
 |-- fnlwgt: integer (nullable = true)
 |-- education: string (nullable = true)
 |-- education_num: integer (nullable = true)
 |-- marital: string (nullable = true)
 |-- occupation: string (nullable = true)
 |-- relationship: string (nullable = true)
 |-- race: string (nullable = true)
 |-- sex: string (nullable = true)
 |-- capital_gain: integer (nullable = true)
 |-- capital_loss: integer (nullable = true)
 |-- hours_week: integer (nullable = true)
 |-- native_country: string (nullable = true)
 |-- label: string (nullable = true)
 |-- age_square: double (nullable = true)

आप देख सकते हैं कि age_square को डेटा फ़्रेम में सफलतापूर्वक जोड़ दिया गया है। आप select के साथ वेरिएबल्स का क्रम बदल सकते हैं। नीचे, आप age_square को उम्र के ठीक बाद लाते हैं।

COLUMNS = ['age', 'age_square', 'workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country', 'label']
df = df.select(COLUMNS)
df.first()

Row(age=39, age_square=1521.0, workclass='State-gov', fnlwgt=77516, education='Bachelors', education_num=13, marital='Never-married', occupation='Adm-clerical', relationship='Not-in-family', race='White', sex='Male', capital_gain=2174, capital_loss=0, hours_week=40, native_country='United-States', label='<=50K')

हॉलैंड-नीदरलैंड को छोड़ दें

जब किसी फीचर के भीतर किसी समूह में केवल एक ही अवलोकन होता है, तो यह मॉडल में कोई जानकारी नहीं लाता है। इसके विपरीत, यह क्रॉस-वैलिडेशन के दौरान त्रुटि का कारण बन सकता है।

आइये घराने की उत्पत्ति की जाँच करें

df.filter(df.native_country == 'Holand-Netherlands').count()
df.groupby('native_country').agg({'native_country': 'count'}).sort(asc("count(native_country)")).show()

+--------------------+---------------------+
|      native_country|count(native_country)|
+--------------------+---------------------+
|  Holand-Netherlands|                    1|
|            Scotland|                   12|
|             Hungary|                   13|
|            Honduras|                   13|
|Outlying-US(Guam-...|                   14|
|          Yugoslavia|                   16|
|            Thailand|                   18|
|                Laos|                   18|
|            Cambodia|                   19|
|     Trinadad&Tobago|                   19|
|                Hong|                   20|
|             Ireland|                   24|
|             Ecuador|                   28|
|              Greece|                   29|
|              France|                   29|
|                Peru|                   31|
|           Nicaragua|                   34|
|            Portugal|                   37|
|                Iran|                   43|
|               Haiti|                   44|
+--------------------+---------------------+
only showing top 20 rows

Native_country फीचर में नीदरलैंड से आने वाला केवल एक ही घर है। आप इसे बाहर कर दें।

df_remove = df.filter(df.native_country !=	'Holand-Netherlands')

चरण 3) डेटा प्रोसेसिंग पाइपलाइन बनाएं

स्किकिट-लर्न के समान, पाइस्पार्क में भी एक पाइपलाइन एपीआई है।

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

उदाहरण के लिए, मशीन लर्निंग में एक सार्वभौमिक परिवर्तन में एक स्ट्रिंग को एक हॉट एनकोडर में बदलना शामिल है, यानी, एक कॉलम द्वारा एक समूह। एक हॉट एनकोडर आमतौर पर शून्य से भरा एक मैट्रिक्स होता है।

डेटा को रूपांतरित करने के चरण scikit-learn के बहुत समान हैं। आपको यह करना होगा:

  • स्ट्रिंग को संख्यात्मक रूप से अनुक्रमित करें
  • वन हॉट एनकोडर बनाएं
  • डेटा ट्रांसफ़ॉर्म करें

दो API यह काम करते हैं: स्ट्रिंगइंडेक्सर, वनहॉटएनकोडर

  1. सबसे पहले, आप इंडेक्स करने के लिए स्ट्रिंग कॉलम का चयन करते हैं। इनपुटकॉल डेटासेट में कॉलम का नाम है। आउटपुटकॉल परिवर्तित कॉलम को दिया गया नया नाम है।
StringIndexer(inputCol="workclass", outputCol="workclass_encoded")
  1. डेटा को फिट करें और उसे रूपांतरित करें
model = stringIndexer.fit(df)		
`indexed = model.transform(df)``
  1. समूह के आधार पर समाचार कॉलम बनाएँ। उदाहरण के लिए, यदि फ़ीचर में 10 समूह हैं, तो नए मैट्रिक्स में 10 कॉलम होंगे, प्रत्येक समूह के लिए एक।
OneHotEncoder(dropLast=False, inputCol="workclassencoded", outputCol="workclassvec")
### Example encoder
from pyspark.ml.feature import StringIndexer, OneHotEncoder, VectorAssembler

stringIndexer = StringIndexer(inputCol="workclass", outputCol="workclass_encoded")
model = stringIndexer.fit(df)
indexed = model.transform(df)
encoder = OneHotEncoder(dropLast=False, inputCol="workclass_encoded", outputCol="workclass_vec")
encoded = encoder.transform(indexed)
encoded.show(2)

+---+----------+----------------+------+---------+-------------+------------------+---------------+-------------+-----+----+------------+------------+----------+--------------+-----+-----------------+-------------+
|age|age_square|       workclass|fnlwgt|education|education_num|           marital|     occupation| relationship| race| sex|capital_gain|capital_loss|hours_week|native_country|label|workclass_encoded|workclass_vec|
+---+----------+----------------+------+---------+-------------+------------------+---------------+-------------+-----+----+------------+------------+----------+--------------+-----+-----------------+-------------+
| 39|    1521.0|       State-gov| 77516|Bachelors|           13|     Never-married|   Adm-clerical|Not-in-family|White|Male|        2174|           0|        40| United-States|<=50K|              4.0|(9,[4],[1.0])|
| 50|    2500.0|Self-emp-not-inc| 83311|Bachelors|           13|Married-civ-spouse|Exec-managerial|      Husband|White|Male|           0|           0|        13| United-States|<=50K|              1.0|(9,[1],[1.0])|
+---+----------+----------------+------+---------+-------------+------------------+---------------+-------------+-----+----+------------+------------+----------+--------------+-----+-----------------+-------------+
only showing top 2 rows

पाइपलाइन का निर्माण करें

आप सभी सटीक विशेषताओं को परिवर्तित करने और उन्हें अंतिम डेटासेट में जोड़ने के लिए एक पाइपलाइन बनाएंगे। पाइपलाइन में चार ऑपरेशन होंगे, लेकिन आप जितने चाहें उतने ऑपरेशन जोड़ सकते हैं।

  1. श्रेणीबद्ध डेटा को एनकोड करें
  2. लेबल सुविधा को अनुक्रमित करें
  3. सतत चर जोड़ें
  4. सीढ़ियाँ एकत्रित करें।

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

1. श्रेणीबद्ध डेटा को एनकोड करें

यह चरण बिल्कुल उपरोक्त उदाहरण के समान ही है, सिवाय इसके कि आप सभी श्रेणीबद्ध विशेषताओं पर लूप करते हैं।

from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoderEstimator
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']
stages = [] # stages in our Pipeline
for categoricalCol in CATE_FEATURES:
    stringIndexer = StringIndexer(inputCol=categoricalCol, outputCol=categoricalCol + "Index")
    encoder = OneHotEncoderEstimator(inputCols=[stringIndexer.getOutputCol()],
                                     outputCols=[categoricalCol + "classVec"])
    stages += [stringIndexer, encoder]

2. लेबल सुविधा को अनुक्रमित करें

Sparkकई अन्य लाइब्रेरी की तरह, लेबल के लिए स्ट्रिंग मान स्वीकार नहीं करता है। आप लेबल सुविधा को स्ट्रिंगइंडेक्सर के साथ परिवर्तित करते हैं और इसे सूची चरणों में जोड़ते हैं

# Convert label into label indices using the StringIndexer
label_stringIdx =  StringIndexer(inputCol="label", outputCol="newlabel")
stages += [label_stringIdx]

3. सतत चर जोड़ें

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

assemblerInputs = [c + "classVec" for c in CATE_FEATURES] + CONTI_FEATURES

4. सीढ़ियाँ जोड़ें।

अंत में, आप VectorAssembler में सभी चरणों को पास करते हैं

assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="features")stages += [assembler]

अब जब सभी चरण तैयार हो गए हैं, तो आप डेटा को पाइपलाइन में डाल देते हैं।

# Create a Pipeline.
pipeline = Pipeline(stages=stages)
pipelineModel = pipeline.fit(df_remove)
model = pipelineModel.transform(df_remove)

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

model.take(1)

[Row(age=39, age_square=1521.0, workclass='State-gov', fnlwgt=77516, education='Bachelors', education_num=13, marital='Never-married', occupation='Adm-clerical', relationship='Not-in-family', race='White', sex='Male', capital_gain=2174, capital_loss=0, hours_week=40, native_country='United-States', label='<=50K', workclassIndex=4.0, workclassclassVec=SparseVector(8, {4: 1.0}), educationIndex=2.0, educationclassVec=SparseVector(15, {2: 1.0}), maritalIndex=1.0, maritalclassVec=SparseVector(6, {1: 1.0}), occupationIndex=3.0, occupationclassVec=SparseVector(14, {3: 1.0}), relationshipIndex=1.0, relationshipclassVec=SparseVector(5, {1: 1.0}), raceIndex=0.0, raceclassVec=SparseVector(4, {0: 1.0}), sexIndex=0.0, sexclassVec=SparseVector(1, {0: 1.0}), native_countryIndex=0.0, native_countryclassVec=SparseVector(40, {0: 1.0}), newlabel=0.0, features=SparseVector(99, {4: 1.0, 10: 1.0, 24: 1.0, 32: 1.0, 44: 1.0, 48: 1.0, 52: 1.0, 53: 1.0, 93: 39.0, 94: 77516.0, 95: 2174.0, 96: 13.0, 98: 40.0}))]

चरण 4) क्लासिफायर बनाएं: लॉजिस्टिक

गणना को तेज़ बनाने के लिए, आप मॉडल को डेटाफ़्रेम में परिवर्तित करते हैं।

आपको मानचित्र का उपयोग करके मॉडल से नया लेबल और सुविधाएँ चुनने की आवश्यकता है।

from pyspark.ml.linalg import DenseVector
input_data = model.rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"])))

आप ट्रेन डेटा को DataFrame के रूप में बनाने के लिए तैयार हैं। आप sqlContext का उपयोग करें

df_train = sqlContext.createDataFrame(input_data, ["label", "features"])

दूसरी पंक्ति की जाँच करें

df_train.show(2)
+-----+--------------------+
|label|            features|
+-----+--------------------+
|  0.0|[0.0,0.0,0.0,0.0,...|
|  0.0|[0.0,1.0,0.0,0.0,...|
+-----+--------------------+
only showing top 2 rows

ट्रेन/टेस्ट सेट बनाएं

आप randomSplit के साथ डेटासेट को 80/20 में विभाजित करते हैं।

# Split the data into train and test sets
train_data, test_data = df_train.randomSplit([.8,.2],seed=1234)

आइए गिनती करें कि प्रशिक्षण और परीक्षण दोनों में 50 हजार से कम/अधिक आय वाले कितने लोग हैं

train_data.groupby('label').agg({'label': 'count'}).show()
+-----+------------+
|label|count(label)|
+-----+------------+
|  0.0|       19698|
|  1.0|        6263|
+-----+------------+

test_data.groupby('label').agg({'label': 'count'}).show()
+-----+------------+
|label|count(label)|
+-----+------------+
|  0.0|        5021|
|  1.0|        1578|
+-----+------------+

लॉजिस्टिक रिग्रॉसर का निर्माण करें

अंतिम लेकिन महत्वपूर्ण बात यह है कि आप क्लासिफायर बना सकते हैं। Pyspark में लॉजिस्टिक रिग्रेशन करने के लिए LogisticRegression नामक एक API है।

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

# Import `LinearRegression`
from pyspark.ml.classification import LogisticRegression

# Initialize `lr`
lr = LogisticRegression(labelCol="label",
                        featuresCol="features",
                        maxIter=10,
                        regParam=0.3)

# Fit the data to the model
linearModel = lr.fit(train_data)

#आप प्रतिगमन से गुणांक देख सकते हैं

# Print the coefficients and intercept for logistic regression
print("Coefficients: " + str(linearModel.coefficients))
print("Intercept: " + str(linearModel.intercept))

Coefficients: [-0.0678914665262,-0.153425526813,-0.0706009536407,-0.164057586562,-0.120655298528,0.162922330862,0.149176870438,-0.626836362611,-0.193483661541,-0.0782269980838,0.222667203836,0.399571096381,-0.0222024341804,-0.311925857859,-0.0434497788688,-0.306007744328,-0.41318209688,0.547937504247,-0.395837350854,-0.23166535958,0.618743906733,-0.344088614546,-0.385266881369,0.317324463006,-0.350518889186,-0.201335923138,-0.232878560088,-0.13349278865,-0.119760542498,0.17500602491,-0.0480968101118,0.288484253943,-0.116314616745,0.0524163478063,-0.300952624551,-0.22046421474,-0.16557996579,-0.114676231939,-0.311966431453,-0.344226119233,0.105530129507,0.152243047814,-0.292774545497,0.263628334433,-0.199951374076,-0.30329422583,-0.231087515178,0.418918551,-0.0565930184279,-0.177818073048,-0.0733236680663,-0.267972912252,0.168491215697,-0.12181255723,-0.385648075442,-0.202101794517,0.0469791640782,-0.00842850210625,-0.00373211448629,-0.259296141281,-0.309896554133,-0.168434409756,-0.11048086026,0.0280647963877,-0.204187030092,-0.414392623536,-0.252806580669,0.143366465705,-0.516359222663,-0.435627370849,-0.301949286524,0.0878249035894,-0.210951740965,-0.621417928742,-0.099445190784,-0.232671473401,-0.1077745606,-0.360429419703,-0.420362959052,-0.379729467809,-0.395186242741,0.0826401853838,-0.280251589972,0.187313505214,-0.20295228799,-0.431177064626,0.149759018379,-0.107114299614,-0.319314858424,0.0028450133235,-0.651220387649,-0.327918792207,-0.143659581445,0.00691075160413,8.38517628783e-08,2.18856717378e-05,0.0266701216268,0.000231075966823,0.00893832698698]
Intercept: -1.9884177974805692

चरण 5) मॉडल को प्रशिक्षित और मूल्यांकन करें

अपने परीक्षण सेट के लिए पूर्वानुमान उत्पन्न करने के लिए,

आप test_data पर transform() के साथ linearModel का उपयोग कर सकते हैं

# Make predictions on test data using the transform() method.
predictions = linearModel.transform(test_data)

आप पूर्वानुमानों में तत्वों को प्रिंट कर सकते हैं

predictions.printSchema()
root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)
 |-- rawPrediction: vector (nullable = true)
 |-- probability: vector (nullable = true)
 |-- prediction: double (nullable = false)

आप लेबल, भविष्यवाणी और संभावना में रुचि रखते हैं

selected = predictions.select("label", "prediction", "probability")
selected.show(20)
+-----+----------+--------------------+
|label|prediction|         probability|
+-----+----------+--------------------+
|  0.0|       0.0|[0.91560704124179...|
|  0.0|       0.0|[0.92812140213994...|
|  0.0|       0.0|[0.92161406774159...|
|  0.0|       0.0|[0.96222760777142...|
|  0.0|       0.0|[0.66363283056957...|
|  0.0|       0.0|[0.65571324475477...|
|  0.0|       0.0|[0.73053376932829...|
|  0.0|       1.0|[0.31265053873570...|
|  0.0|       0.0|[0.80005907577390...|
|  0.0|       0.0|[0.76482251301640...|
|  0.0|       0.0|[0.84447301189069...|
|  0.0|       0.0|[0.75691912026619...|
|  0.0|       0.0|[0.60902504096722...|
|  0.0|       0.0|[0.80799228385509...|
|  0.0|       0.0|[0.87704364852567...|
|  0.0|       0.0|[0.83817652582377...|
|  0.0|       0.0|[0.79655423248500...|
|  0.0|       0.0|[0.82712311232246...|
|  0.0|       0.0|[0.81372823882016...|
|  0.0|       0.0|[0.59687710752201...|
+-----+----------+--------------------+
only showing top 20 rows

मॉडल का मूल्यांकन करें

आपको यह देखने के लिए सटीकता मीट्रिक को देखना होगा कि मॉडल कितना अच्छा (या बुरा) प्रदर्शन करता है। वर्तमान में, सटीकता माप की गणना करने के लिए कोई API नहीं है Sparkडिफ़ॉल्ट मान ROC, रिसीवर ऑपरेटिंग विशेषता वक्र है। यह एक अलग मीट्रिक है जो झूठी सकारात्मक दर को ध्यान में रखता है।

आरओसी को देखने से पहले, आइए सटीकता माप का निर्माण करें। आप इस मीट्रिक से अधिक परिचित हैं। सटीकता माप कुल प्रेक्षणों की संख्या पर सही पूर्वानुमान का योग है।

आप लेबल और `पूर्वानुमान' के साथ एक डेटाफ़्रेम बनाते हैं।

cm = predictions.select("label", "prediction")

आप लेबल में वर्ग की संख्या और भविष्यवाणी की जांच कर सकते हैं

cm.groupby('label').agg({'label': 'count'}).show()
+-----+------------+
|label|count(label)|
+-----+------------+
|  0.0|        5021|
|  1.0|        1578|
+-----+------------+

cm.groupby('prediction').agg({'prediction': 'count'}).show()
+----------+-----------------+
|prediction|count(prediction)|
+----------+-----------------+
|       0.0|             5982|
|       1.0|              617|
+----------+-----------------+

उदाहरण के लिए, परीक्षण सेट में 1578 परिवार ऐसे हैं जिनकी आय 50 हजार से अधिक है और 5021 परिवार इससे कम हैं। हालांकि, वर्गीकरणकर्ता ने 617 हजार से अधिक आय वाले 50 परिवारों की भविष्यवाणी की।

जब लेबल को पंक्तियों की कुल संख्या पर सही ढंग से वर्गीकृत किया जाता है, तो आप गणना की गणना करके सटीकता की गणना कर सकते हैं।

cm.filter(cm.label == cm.prediction).count() / cm.count()

0.8237611759357478

आप सब कुछ एक साथ जोड़ सकते हैं और सटीकता की गणना करने के लिए एक फ़ंक्शन लिख सकते हैं।

def accuracy_m(model): 
    predictions = model.transform(test_data)
    cm = predictions.select("label", "prediction")
    acc = cm.filter(cm.label == cm.prediction).count() / cm.count()
    print("Model accuracy: %.3f%%" % (acc * 100)) 
accuracy_m(model = linearModel)
Model accuracy: 82.376%

आरओसी मेट्रिक्स

मॉड्यूल बाइनरीक्लासिफिकेशनइवैल्यूएटर में आरओसी माप शामिल हैं। रिसीवर Operaबाइनरी वर्गीकरण के साथ इस्तेमाल किया जाने वाला एक और आम उपकरण विशेषता वक्र है। यह सटीकता/रिकॉल वक्र के समान ही है, लेकिन सटीकता बनाम रिकॉल को प्लॉट करने के बजाय, ROC वक्र गलत सकारात्मक दर के विरुद्ध सच्ची सकारात्मक दर (यानी रिकॉल) दिखाता है। झूठी सकारात्मक दर नकारात्मक उदाहरणों का अनुपात है जिन्हें गलत तरीके से सकारात्मक के रूप में वर्गीकृत किया गया है। यह एक माइनस सच्ची नकारात्मक दर के बराबर है। सच्ची नकारात्मक दर को विशिष्टता भी कहा जाता है। इसलिए ROC वक्र संवेदनशीलता (रिकॉल) बनाम 1 - विशिष्टता को प्लॉट करता है

### Use ROC 
from pyspark.ml.evaluation import BinaryClassificationEvaluator

# Evaluate model
evaluator = BinaryClassificationEvaluator(rawPredictionCol="rawPrediction")
print(evaluator.evaluate(predictions))
print(evaluator.getMetricName())

0.8940481662695192क्षेत्रअंडरआरओसी

print(evaluator.evaluate(predictions))

0.8940481662695192

चरण 6) हाइपरपैरामीटर को ट्यून करें

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

गणना के समय को कम करने के लिए, आप नियमितीकरण पैरामीटर को केवल दो मानों के साथ ट्यून करते हैं।

from pyspark.ml.tuning import ParamGridBuilder, CrossValidator

# Create ParamGrid for Cross Validation
paramGrid = (ParamGridBuilder()
             .addGrid(lr.regParam, [0.01, 0.5])
             .build())

अंत में, आप 5 गुना के साथ क्रॉस वैलिएशन विधि का उपयोग करके मॉडल का मूल्यांकन करते हैं। इसे प्रशिक्षित करने में लगभग 16 मिनट लगते हैं।

from time import *
start_time = time()

# Create 5-fold CrossValidator
cv = CrossValidator(estimator=lr,
                    estimatorParamMaps=paramGrid,
                    evaluator=evaluator, numFolds=5)

# Run cross validations
cvModel = cv.fit(train_data)
# likely take a fair amount of time
end_time = time()
elapsed_time = end_time - start_time
print("Time to train model: %.3f seconds" % elapsed_time)

मॉडल को प्रशिक्षित करने में लगा समय: 978.807 सेकंड

सर्वोत्तम नियमितीकरण हाइपरपैरामीटर 0.01 है, जिसकी सटीकता 85.316 प्रतिशत है।

accuracy_m(model = cvModel)
Model accuracy: 85.316%

आप cvModel.bestModel को extractParamMap() के साथ श्रृंखलाबद्ध करके अनुशंसित पैरामीटर निकाल सकते हैं

bestModel = cvModel.bestModel
bestModel.extractParamMap()

{Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='aggregationDepth', doc='suggested depth for treeAggregate (>= 2)'): 2,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='elasticNetParam', doc='the ElasticNet mixing parameter, in range [0, 1]. For alpha = 0, the penalty is an L2 penalty. For alpha = 1, it is an L1 penalty'): 0.0,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='family', doc='The name of family which is a description of the label distribution to be used in the model. Supported options: auto, binomial, multinomial.'): 'auto',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='featuresCol', doc='features column name'): 'features',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='fitIntercept', doc='whether to fit an intercept term'): True,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='labelCol', doc='label column name'): 'label',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='maxIter', doc='maximum number of iterations (>= 0)'): 10,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='predictionCol', doc='prediction column name'): 'prediction',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='probabilityCol', doc='Column name for predicted class conditional probabilities. Note: Not all models output well-calibrated probability estimates! These probabilities should be treated as confidences, not precise probabilities'): 'probability',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='rawPredictionCol', doc='raw prediction (a.k.a. confidence) column name'): 'rawPrediction',
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='regParam', doc='regularization parameter (>= 0)'): 0.01,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='standardization', doc='whether to standardize the training features before fitting the model'): True,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='threshold', doc='threshold in binary classification prediction, in range [0, 1]'): 0.5,
 Param(parent='LogisticRegression_4d8f8ce4d6a02d8c29a0', name='tol', doc='the convergence tolerance for iterative algorithms (>= 0)'): 1e-06}

सारांश

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

शुरुआत के लिए Spark, आपको एक पहल करने की आवश्यकता है Spark संदर्भ:

'Sparkप्रसंग()'

और और एसक्यूएल डेटा स्रोत से कनेक्ट करने के लिए संदर्भ:

'एसक्यूएलकॉन्टेक्स्ट()'

ट्यूटोरियल में, आप सीखेंगे कि लॉजिस्टिक रिग्रेशन को कैसे प्रशिक्षित किया जाए:

  1. डेटासेट को डेटाफ़्रेम में बदलें:
rdd.map(lambda x: (x["newlabel"], DenseVector(x["features"])))
sqlContext.createDataFrame(input_data, ["label", "features"])

ध्यान दें कि लेबल का कॉलम नाम newlabel है और सभी सुविधाएँ सुविधाओं में एकत्रित हैं। यदि आपके डेटासेट में ये मान अलग हैं तो इन्हें बदलें।

  1. ट्रेन/टेस्ट सेट बनाएं
randomSplit([.8,.2],seed=1234)
  1. मॉडल को प्रशिक्षित करें
LogisticRegression(labelCol="label",featuresCol="features",maxIter=10, regParam=0.3)
lr.fit()
  1. भविष्यवाणी करना
linearModel.transform()