ஸ்பார்க்கைப் பயன்படுத்தி ஆர்.டி.டி: அப்பாச்சி தீப்பொறியின் கட்டிடத் தொகுதி

, ஒவ்வொரு ஹடூப் பொறியியலாளரின் மனதிலும் ஒரு தீப்பொறியை உருவாக்க இந்த வார்த்தை போதுமானது. TO n நினைவகத்தில் செயலாக்க கருவி இது கிளஸ்டர் கம்ப்யூட்டிங்கில் மின்னல் வேகமானது. MapReduce உடன் ஒப்பிடும்போது, ​​இன்-மெமரி தரவு பகிர்வு RDD களை உருவாக்குகிறது 10-100 எக்ஸ் வேகமாக நெட்வொர்க் மற்றும் வட்டு பகிர்வுகளை விடவும், ஆர்.டி.டி கள் (மீள் விநியோகிக்கப்பட்ட தரவு தொகுப்புகள்) காரணமாக இவை அனைத்தும் சாத்தியமாகும். ஸ்பார்க் கட்டுரையைப் பயன்படுத்தி இந்த RDD இல் இன்று நாம் கவனம் செலுத்துகின்ற முக்கிய புள்ளிகள்:

• RDD களின் தேவை
• RDD கள் என்றால் என்ன?
• RDD களின் அம்சங்கள்
• தீப்பொறியைப் பயன்படுத்தி RDD களை உருவாக்குதல்
• RDD களில் செய்யப்படும் செயல்பாடுகள்
• தீப்பொறியைப் பயன்படுத்தும் RDD கள்: போகிமொன் பயன்பாட்டு வழக்கு

RDD கள் தேவையா?

உலகம் உருவாகி வருகிறது மற்றும் தரவு அறிவியல் இன் முன்னேற்றம் காரணமாக . வழிமுறைகள் அடிப்படையில் பின்னடைவு , , மற்றும் இது இயங்கும் விநியோகிக்கப்பட்டது மறுபயன்பாட்டு கணினி ation பல கணினி அலகுகளில் தரவை மறுபயன்பாடு செய்தல் மற்றும் பகிர்வது ஆகியவை அடங்கும்.

பாரம்பரியமானது நுட்பங்களுக்கு ஒரு நிலையான இடைநிலை மற்றும் விநியோகிக்கப்பட்ட சேமிப்பு தேவை HDFS தரவு பிரதிகள் மற்றும் தரவு வரிசைப்படுத்துதலுடன் மீண்டும் மீண்டும் கணக்கீடுகளை உள்ளடக்கியது, இது செயல்முறையை மிகவும் மெதுவாக்கியது. ஒரு தீர்வைக் கண்டுபிடிப்பது ஒருபோதும் எளிதானது அல்ல.

இந்த இடத்தில் தான் ஆர்.டி.டிக்கள் (நெகிழ்திறன் விநியோகிக்கப்பட்ட தரவுத்தொகுப்புகள்) பெரிய படத்திற்கு வருகிறது.

ஆர்.டி.டி. தரவு மூலங்களிலிருந்து தரவு இறக்குமதி செய்யப்பட்டு RDD களில் கைவிடப்படுவதால் கள் பயன்படுத்த எளிதானது மற்றும் உருவாக்க எளிதானது. மேலும், அவற்றை செயலாக்க செயல்பாடுகள் பயன்படுத்தப்படுகின்றன. அவை அ நினைவகம் விநியோகிக்கப்பட்டது அனுமதியுடன் படிக்க மட்டும் மற்றும் மிக முக்கியமாக, அவை தவறு-சகிப்புத்தன்மை .

ஏதாவது தரவு பகிர்வு of RDD உள்ளது இழந்தது , அதைப் பயன்படுத்துவதன் மூலம் அதை மீண்டும் உருவாக்க முடியும் மாற்றம் அந்த இழந்த பகிர்வில் செயல்பாடு பரம்பரை , புதிதாக எல்லா தரவையும் செயலாக்குவதை விட. நிகழ்நேர காட்சிகளில் இந்த வகையான அணுகுமுறை தரவு இழப்பு சூழ்நிலைகளில் அல்லது ஒரு கணினி செயலிழந்திருக்கும் போது அற்புதங்களை நிகழ்த்தும்.

RDD கள் என்றால் என்ன?

ஆர்.டி.டி. அல்லது ( மீள் விநியோகிக்கப்பட்ட தரவு தொகுப்பு ) ஒரு அடிப்படை தரவு அமைப்பு தீப்பொறியில். கால நெகிழ்திறன் தரவை தானாக அல்லது தரவை உருவாக்கும் திறனை வரையறுக்கிறது மீண்டும் உருளும் க்கு அசல் நிலை தரவு இழப்பின் நிகழ்தகவுடன் எதிர்பாராத பேரழிவு ஏற்படும் போது.

ஜாவாவில் அதிகாரங்களைப் பயன்படுத்துவது எப்படி

RDD களில் எழுதப்பட்ட தரவு பகிர்வு செய்யப்பட்டது மற்றும் சேமிக்கப்படுகிறது பல இயங்கக்கூடிய முனைகள் . இயக்கும் முனை என்றால் தோல்வியுற்றது ரன் நேரத்தில், அது உடனடியாக பின்வாங்குகிறது அடுத்த இயங்கக்கூடிய முனை . இதனால்தான் மற்ற பாரம்பரிய தரவு கட்டமைப்புகளுடன் ஒப்பிடும்போது RDD கள் ஒரு மேம்பட்ட வகை தரவு கட்டமைப்புகளாக கருதப்படுகின்றன. RDD க்கள் கட்டமைக்கப்பட்ட, கட்டமைக்கப்படாத மற்றும் அரை கட்டமைக்கப்பட்ட தரவை சேமிக்க முடியும்.

ஸ்பார்க் வலைப்பதிவைப் பயன்படுத்தி எங்கள் RDD உடன் முன்னேறி, RDD களின் தனித்துவமான அம்சங்களைப் பற்றி அறிந்து கொள்வோம், இது மற்ற வகை தரவு கட்டமைப்புகளை விட ஒரு விளிம்பைக் கொடுக்கும்.

RDD இன் அம்சங்கள்

• இன்-மெமரி (ரேம்) கணக்கீடுகள் : இன்-மெமரி கணக்கீடு என்ற கருத்து தரவு செயலாக்கத்தை ஒட்டுமொத்தமாக விரைவான மற்றும் திறமையான கட்டத்திற்கு கொண்டு செல்கிறது செயல்திறன் அமைப்பின் மேம்படுத்தப்பட்டது.
• எல் அவரது மதிப்பீடு : சோம்பேறி மதிப்பீடு என்ற சொல் கூறுகிறது மாற்றங்கள் RDD இல் உள்ள தரவுகளுக்குப் பயன்படுத்தப்படும், ஆனால் வெளியீடு உருவாக்கப்படவில்லை. அதற்கு பதிலாக, பயன்படுத்தப்பட்ட மாற்றங்கள் உள்நுழைந்தது.
• விடாமுயற்சி : இதன் விளைவாக RDD கள் எப்போதும் இருக்கும் மீண்டும் பயன்படுத்தக்கூடியது.
• கரடுமுரடான செயல்பாடுகள் : தரவுத் தொகுப்புகளில் உள்ள அனைத்து உறுப்புகளுக்கும் பயனர் உருமாற்றங்களைப் பயன்படுத்தலாம் வரைபடம், வடிகட்டி அல்லது மூலம் குழு செயல்பாடுகள்.
• தவறு சகிப்புத்தன்மை : தரவு இழப்பு இருந்தால், கணினி முடியும் மீண்டும் உருட்டவும் அதன் அசல் நிலை உள்நுழைந்ததைப் பயன்படுத்துவதன் மூலம் மாற்றங்கள் .
• மாறாத தன்மை : வரையறுக்கப்பட்ட தரவு, மீட்டெடுக்கப்பட்ட அல்லது உருவாக்கப்பட்டதாக இருக்க முடியாது மாற்றப்பட்டது இது கணினியில் உள்நுழைந்ததும். நீங்கள் ஏற்கனவே இருக்கும் RDD ஐ அணுகவும் மாற்றவும் விரும்பினால், ஒரு தொகுப்பைப் பயன்படுத்துவதன் மூலம் புதிய RDD ஐ உருவாக்க வேண்டும் மாற்றம் தற்போதைய அல்லது அதற்கு முந்தைய RDD இல் செயல்படுகிறது.
• பகிர்வு : இது முக்கியமான அலகு ஸ்பார்க்கில் இணையான தன்மை ஆர்.டி.டி. இயல்பாக, உருவாக்கப்பட்ட பகிர்வுகளின் எண்ணிக்கை உங்கள் தரவு மூலத்தை அடிப்படையாகக் கொண்டது. நீங்கள் பயன்படுத்த விரும்பும் பகிர்வுகளின் எண்ணிக்கையை கூட நீங்கள் தீர்மானிக்கலாம் தனிப்பயன் பகிர்வு செயல்பாடுகள்.

தீப்பொறியைப் பயன்படுத்தி RDD ஐ உருவாக்குதல்

RDD களை உருவாக்கலாம் மூன்று வழிகள்:

1. இருந்து தரவைப் படித்தல் இணையான வசூல்

val PCRDD = spark.sparkContext.parallelize (வரிசை ('திங்கள்', 'செவ்வாய்', 'புதன்', 'Thu', 'வெள்ளி', 'சனி'), 2) val resultRDD = PCRDD.collect () resultRDD.collect ( ) .முழுத்து (println)

2. விண்ணப்பிக்கிறது மாற்றம் முந்தைய RDD களில்

val words = spark.sparkContext.parallelize (Seq ('Spark', 'is', 'a', 'very', 'powerful', 'language')) val wordpair = words.map (w = (w.charAt ( 0), w)) wordpair.collect (). முன்னறிவிப்பு (println)

3. இருந்து தரவைப் படித்தல் வெளிப்புற சேமிப்பு அல்லது கோப்பு பாதைகள் போன்றவை HDFS அல்லது HBase

val Sparkfile = spark.read.textFile ('/ user / edureka_566977 / spark / spark.txt.') Sparkfile.collect ()

RDD களில் செய்யப்படும் செயல்பாடுகள்:

RDD களில் செய்யப்படும் முக்கியமாக இரண்டு வகையான செயல்பாடுகள் உள்ளன, அதாவது:

• மாற்றங்கள்
• செயல்கள்

மாற்றங்கள் : தி செயல்பாடுகள் நாங்கள் RDD களில் விண்ணப்பிக்கிறோம் வடிகட்டி, அணுகல் மற்றும் மாற்றவும் உருவாக்க பெற்றோர் RDD இல் உள்ள தரவு a அடுத்தடுத்த RDD என்று அழைக்கப்படுகிறது மாற்றம் . புதிய RDD முந்தைய RDD க்கு ஒரு சுட்டிக்காட்டி அளிக்கிறது, அவற்றுக்கிடையேயான சார்புநிலையை உறுதி செய்கிறது.

உருமாற்றங்கள் சோம்பேறி மதிப்பீடுகள், வேறு வார்த்தைகளில் கூறுவதானால், நீங்கள் பணிபுரியும் RDD இல் பயன்படுத்தப்படும் செயல்பாடுகள் உள்நுழைந்திருக்கும், ஆனால் இல்லை செயல்படுத்தப்பட்டது. தூண்டப்பட்ட பிறகு கணினி ஒரு முடிவு அல்லது விதிவிலக்கை வீசுகிறது செயல் .

மாற்றங்களை நாம் கீழே இரண்டு வகைகளாகப் பிரிக்கலாம்:

• குறுகிய மாற்றங்கள்
• பரந்த மாற்றங்கள்

குறுகிய மாற்றங்கள் குறுகிய மாற்றங்களை நாங்கள் பயன்படுத்துகிறோம் ஒற்றை பகிர்வு RDD ஐ செயலாக்க தேவையான தரவு ஒரு புதிய RDD ஐ உருவாக்க பெற்றோர் RDD இன் ஒரு பகிர்வில் கிடைக்கிறது பெற்றோர் ஏ.எஸ்.டி. . குறுகிய மாற்றங்களுக்கான எடுத்துக்காட்டுகள்:

• வரைபடம் ()
• வடிகட்டி()
• பிளாட்மேப் ()
• பகிர்வு ()
• mapPartitions ()

பரந்த மாற்றங்கள்: பரந்த மாற்றத்தை நாங்கள் பயன்படுத்துகிறோம் பல பகிர்வுகள் புதிய RDD ஐ உருவாக்க. RDD ஐ செயலாக்க தேவையான தரவு பல பகிர்வுகளில் கிடைக்கிறது பெற்றோர் ஏ.எஸ்.டி. . பரந்த மாற்றங்களுக்கான எடுத்துக்காட்டுகள்:

• குறைத்தல் ()
• தொழிற்சங்கம் ()

செயல்கள் : செயல்கள் அப்பாச்சி தீப்பொறிக்கு விண்ணப்பிக்க அறிவுறுத்துகின்றன கணக்கீடு முடிவு அல்லது விதிவிலக்கை இயக்கி RDD க்கு அனுப்பவும். செயல்களில் சில பின்வருமாறு:

• திரட்டுதல்()
• எண்ணிக்கை ()
• எடுத்து ()
• முதல் ()

RDD களில் செயல்பாடுகளை நடைமுறையில் பயன்படுத்துவோம்:

ஐ.பி.எல் (இந்தியன் பிரீமியர் லீக்) ஒரு கிரிக்கெட் போட்டியாகும், இது உச்ச மட்டத்தில் உள்ளது. எனவே, இன்று ஐபிஎல் தரவுத் தொகுப்பில் கைகோர்த்து, ஸ்பார்க்கைப் பயன்படுத்தி எங்கள் ஆர்.டி.டியை இயக்கலாம்.

• முதலில், ஐபிஎல்லின் CSV பொருந்தக்கூடிய தரவைப் பதிவிறக்குவோம். அதைப் பதிவிறக்கிய பிறகு, இது வரிசைகள் மற்றும் நெடுவரிசைகளுடன் ஒரு எக்செல் கோப்பாகத் தெரிகிறது.

அடுத்த கட்டத்தில், நாங்கள் தீப்பொறியை எரித்தோம் மற்றும் match.csv கோப்பை அதன் இருப்பிடத்திலிருந்து ஏற்றுவோம், என் விஷயத்தில் என்csvகோப்பு இடம் “/User/edureka_566977/test/matches.csv”

இப்போது தொடங்குவோம் மாற்றம் முதல் பகுதி:

• வரைபடம் ():

நாம் பயன்படுத்த வரைபட மாற்றம் ஒரு RDD இன் ஒவ்வொரு உறுப்புக்கும் ஒரு குறிப்பிட்ட உருமாற்ற செயல்பாட்டைப் பயன்படுத்துவதற்கு. இங்கே நாம் CKfile என்ற பெயரில் ஒரு RDD ஐ உருவாக்குகிறோம்csvகோப்பு. மாநிலங்கள் என்று அழைக்கப்படும் மற்றொரு RDD ஐ உருவாக்குவோம் நகர விவரங்களை சேமிக்கவும் .

spark2-shell val CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') CKfile.collect.foreach (println) val states = CKfile.map (_. split (',') (2)) states.collect (). foreach (println)

• வடிகட்டி():

வடிகட்டி உருமாற்றம், பெயர் அதன் பயன்பாட்டை விவரிக்கிறது. கொடுக்கப்பட்ட தரவுகளின் தொகுப்பிலிருந்து தேர்ந்தெடுக்கப்பட்ட தரவை வடிகட்ட இந்த உருமாற்ற செயல்பாட்டைப் பயன்படுத்துகிறோம். நாங்கள் விண்ணப்பிக்கிறோம் வடிகட்டி செயல்பாடு ஆண்டின் ஐபிஎல் போட்டிகளின் பதிவுகளைப் பெற இங்கே 2017 அதை நிரப்பு RDD இல் சேமிக்கவும்.

val fil = CKfile.filter (line => line.contains ('2017')) fil.collect (). foreach (println)

• பிளாட்மேப் ():

புதிய RDD ஐ உருவாக்க RDD இன் ஒவ்வொரு கூறுகளுக்கும் ஒரு மாற்றும் செயல்பாடாக பிளாட்மேப் பயன்படுத்துகிறோம். இது வரைபட மாற்றத்திற்கு ஒத்ததாகும். இங்கே நாங்கள் விண்ணப்பிக்கிறோம்பிளாட்மேப்க்கு ஹைதராபாத் நகரத்தின் போட்டிகளைத் துப்பவும் தரவை சேமிக்கவும்filRDDஆர்.டி.டி.

val filRDD = fil.flatMap (line => line.split ('ஹைதராபாத்')). சேகரிக்க ()

• பகிர்வு ():

நாம் ஒரு RDD இல் எழுதும் ஒவ்வொரு தரவும் ஒரு குறிப்பிட்ட எண்ணிக்கையிலான பகிர்வுகளாக பிரிக்கப்படுகிறது. கண்டுபிடிக்க இந்த உருமாற்றத்தைப் பயன்படுத்துகிறோம் பகிர்வுகளின் எண்ணிக்கை தரவு உண்மையில் பிரிக்கப்பட்டுள்ளது.

val fil = CKfile.filter (line => line.contains ('2017')) fil.partitions.size

• mapPartitions ():

வரைபடத்தின் () மற்றும் மாற்றாக MapPatitions ஐ நாங்கள் கருதுகிறோம்ஒவ்வொரு() ஒன்றாக. கண்டுபிடிக்க இங்கே வரைபடப் பகிர்வுகளைப் பயன்படுத்துகிறோம் வரிசைகளின் எண்ணிக்கை எங்கள் ஃபில் ஆர்.டி.டி.

val fil = CKfile.filter (line => line.contains ('2016')) fil.mapPartitions (idx => வரிசை (idx.size) .iterator) .செய்தல்

• குறைத்தல் ():

நாம் பயன்படுத்தகுறைத்தல்() ஆன் முக்கிய மதிப்பு ஜோடிகள் . இந்த மாற்றத்தை எங்கள் மீது பயன்படுத்தினோம்csvஉடன் பிளேயரைக் கண்டுபிடிக்க கோப்பு போட்டிகளில் மிக உயர்ந்த நாயகன் .

val ManOfTheMatch = CKfile.map (_. split (',') (13%) val MOTMcount = ManOfTheMatch.map (WINcount => (WINcount, 1)) val ManOTH = MOTMcount.reduceByKey ((x, y) => x + y) .மாப் (tup => (tup._2, tup._1)) sortByKey (false) ManOTH.take (10) .முழுத்து (println)

• தொழிற்சங்கம் ():

பெயர் அதையெல்லாம் விளக்குகிறது, நாங்கள் தொழிற்சங்க உருமாற்றத்தைப் பயன்படுத்துகிறோம் இரண்டு RDD களை ஒன்றாக இணைக்கவும் . இங்கே நாம் இரண்டு RDD களை உருவாக்குகிறோம், அதாவது fil மற்றும் fil2. fil RDD இல் 2017 ஐபிஎல் போட்டிகளின் பதிவுகளும், fil2 RDD இல் 2016 ஐபிஎல் போட்டி பதிவுகளும் உள்ளன.

val fil = CKfile.filter (line => line.contains ('2017')) val fil2 = CKfile.filter (line => line.contains ('2016')) val uninRDD = fil.union (fil2)

உடன் தொடங்குவோம் செயல் உண்மையான வெளியீட்டைக் காண்பிக்கும் பகுதி:

• திரட்டுதல்():

சேகரிப்பு என்பது நாம் பயன்படுத்தும் செயலாகும் உள்ளடக்கங்களைக் காண்பி RDD இல்.

val CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') CKfile.collect.foreach (println)

• எண்ணிக்கை ():

எண்ணிக்கைஎண்ணுவதற்கு நாம் பயன்படுத்தும் ஒரு செயல் பதிவுகளின் எண்ணிக்கை RDD இல் உள்ளது.இங்கேஎங்கள் match.csv கோப்பில் உள்ள மொத்த பதிவுகளின் எண்ணிக்கையை கணக்கிட இந்த செயல்பாட்டைப் பயன்படுத்துகிறோம்.

val CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') CKfile.count ()

• எடுத்து ():

எடுப்பது என்பது சேகரிக்கும் ஒரு அதிரடி நடவடிக்கையாகும், ஆனால் ஒரே வித்தியாசம் என்னவென்றால் அதை எதையும் அச்சிட முடியும் தேர்ந்தெடுக்கப்பட்ட வரிசைகளின் எண்ணிக்கை பயனர் கோரிக்கையின் படி. இங்கே அச்சிட பின்வரும் குறியீட்டைப் பயன்படுத்துகிறோம் முதல் பத்து முன்னணி அறிக்கைகள்.

val statecountm = Scount.reduceByKey ((x, y) => x + y) .மாப் (tup => (tup._2, tup._1)) sortByKey (false) statecountm.collect (). foreach (println) statecountm. எடுத்துக்கொள்ளுங்கள் (10) .முழுத்து (println)

• முதல் ():

முதல் () என்பது சேகரிக்கும் () மற்றும் () ஐ ஒத்த ஒரு செயல் செயல்பாடுஅதுவெளியீட்டை முதன்மையான அறிக்கையை அச்சிடப் பயன்படுகிறது இங்கே நாம் கண்டுபிடிக்க முதல் () செயல்பாட்டைப் பயன்படுத்துகிறோம் ஒரு குறிப்பிட்ட நகரத்தில் அதிகபட்ச போட்டிகளில் விளையாடியது மும்பையை வெளியீடாகப் பெறுகிறோம்.

val CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') val states = CKfile.map (_. split (',') (2)) val Scount = states.map (Scount => ( Scount, 1)) scala & gt val statecount = Scount.reduceByKey ((x, y) => x + y) .collect.foreach (println) Scount.reduceByKey ((x, y) => x + y) .collect.foreach (println) val statecountm = Scount.reduceByKey ((x, y) => x + y) .மாப் (tup => (tup._2, tup._1)) sortByKey (false) statecountm.first ()

எங்கள் செயல்முறையை ஸ்பார்க்கைப் பயன்படுத்தி எங்கள் கற்றல் ஆர்.டி.டி.யாக மாற்ற, இன்னும் சுவாரஸ்யமானது, நான் ஒரு சுவாரஸ்யமான பயன்பாட்டு வழக்கைக் கொண்டு வந்துள்ளேன்.

தீப்பொறியைப் பயன்படுத்தி ஆர்.டி.டி: போகிமொன் பயன்பாட்டு வழக்கு

• முதலில், நாம் ஒரு போகிமொன்.சி.எஸ்.வி கோப்பைப் பதிவிறக்கி, மேட்ச்ஸ்.சி.எஸ்.வி கோப்பில் செய்ததைப் போல தீப்பொறி-ஷெல்லில் ஏற்றுவோம்.

val PokemonDataRDD1 = sc.textFile ('/ user / edureka_566977 / PokemonFile / PokemonData.csv') PokemonDataRDD1.collect (). foreach (println)

போகிமொன்கள் உண்மையில் ஒரு பெரிய வகைகளில் கிடைக்கின்றன, சில வகைகளைக் கண்டுபிடிப்போம்.

• Pokemon.csv கோப்பிலிருந்து ஸ்கீமாவை நீக்குகிறது

எங்களுக்கு தேவையில்லை ஸ்கீமா Pokemon.csv கோப்பின். எனவே, நாங்கள் அதை அகற்றுகிறோம்.

val Head = PokemonDataRDD1.first () val NoHeader = PokemonDataRDD1.filter (line =>! line.equals (Head))

• எண்ணைக் கண்டறிதல் பகிர்வுகள் எங்கள் pokemon.csv இல் விநியோகிக்கப்படுகிறது.

println ('No.ofpartitions =' + NoHeader.partitions.size)

• நீர் போகிமொன்

கண்டுபிடிப்பது நீர் போகிமொனின் எண்ணிக்கை

val WaterRDD = PokemonDataRDD1.filter (line => line.contains ('Water')) WaterRDD.collect (). foreach (println)

• தீ போகிமொன்

கண்டுபிடிப்பது தீ போகிமொனின் எண்ணிக்கை

val FireRDD = PokemonDataRDD1.filter (line => line.contains ('Fire')) FireRDD.collect (). foreach (println)

• நாம் கண்டறிய முடியும் மக்கள் தொகை எண்ணிக்கை செயல்பாட்டைப் பயன்படுத்தி வேறு வகையான போகிமொனின்

WaterRDD.count () FireRDD.count ()

• நான் விளையாட்டை விரும்புகிறேன் என்பதால் தற்காப்பு உத்தி போகிமொனைக் கண்டுபிடிப்போம் அதிகபட்ச பாதுகாப்பு.

val defenceList = NoHeader.map {x => x.split (',') map. வரைபடம் {x => (x (6) .டூபிள்)} println ('அதிகபட்ச_விவரம்:' + defenceList.max ())

• அதிகபட்சம் எங்களுக்குத் தெரியும் பாதுகாப்பு வலிமை மதிப்பு ஆனால் இது எந்த போகிமொன் என்று எங்களுக்குத் தெரியாது. எனவே, அது எது என்பதைக் கண்டுபிடிப்போம் போகிமொன்.

val defWithPokemonName = NoHeader.map {x => x.split (',') map. வரைபடம் {x => (x (6) .டூபிள், x (1))} val MaxDefencePokemon = defWithPokemonName.groupByKey.takeOrded (1) (ஆர்டர் [இரட்டை] .reverse.on (_._ 1)) MaxDefencePokemon.foreach (println)

• இப்போது போகிமொனை வரிசைப்படுத்துவோம் குறைந்தது பாதுகாப்பு

val minDefencePokemon = defenceList.distinct.sortBy (x => x.toDouble, true, 1) minDefencePokemon.take (5) .முழுத்து (println)

• இப்போது ஒரு போகிமொனைப் பார்ப்போம் குறைந்த தற்காப்பு உத்தி.

val PokemonDataRDD2 = sc.textFile ('/ user / edureka_566977 / PokemonFile / PokemonData.csv') val Head2 = PokemonDataRDD2.first () val NoHeader2 = PokemonDataRDD2.filter (line =>! lineHeader2) .map {x => x.split (',') map. வரைபடம் {x => (x (6) .டூபிள், x (1))} val MinDefencePokemon2 = defWithPokemonName2.groupByKey.takeOrded (1) (வரிசைப்படுத்துதல் [இரட்டை ] .on (_._ 1)) MinDefencePokemon2.foreach (println)

எனவே, இதன் மூலம், ஸ்பார்க் கட்டுரையைப் பயன்படுத்தி இந்த RDD இன் முடிவுக்கு வருகிறோம். ஆர்.டி.டிக்கள், அவற்றின் அம்சங்கள் மற்றும் அவற்றில் செய்யக்கூடிய பல்வேறு வகையான செயல்பாடுகள் பற்றிய உங்கள் அறிவின் மீது நாங்கள் கொஞ்சம் வெளிச்சம் போட்டோம் என்று நம்புகிறேன்.

இந்த கட்டுரை அடிப்படையாகக் கொண்டது கிளவுட்ரா ஹடூப் மற்றும் ஸ்பார்க் டெவலப்பர் சான்றிதழ் தேர்வுக்கு (சி.சி.ஏ .175) உங்களை தயார்படுத்த வடிவமைக்கப்பட்டுள்ளது. அப்பாச்சி ஸ்பார்க் மற்றும் ஸ்பார்க் சுற்றுச்சூழல் அமைப்பு பற்றிய ஆழமான அறிவைப் பெறுவீர்கள், இதில் ஸ்பார்க் ஆர்.டி.டி, ஸ்பார்க் எஸ்.கியூ.எல், ஸ்பார்க் எம்.எல்லிப் மற்றும் ஸ்பார்க் ஸ்ட்ரீமிங் ஆகியவை அடங்கும். ஸ்கலா புரோகிராமிங் மொழி, எச்டிஎஃப்எஸ், ஸ்கூப், ஃப்ளூம், ஸ்பார்க் கிராஃப்எக்ஸ் மற்றும் காஃப்கா போன்ற மெசேஜிங் சிஸ்டம் குறித்த விரிவான அறிவைப் பெறுவீர்கள்.