స్పార్క్ ఉపయోగించి RDD: అపాచీ స్పార్క్ యొక్క బిల్డింగ్ బ్లాక్

, ప్రతి హడూప్ ఇంజనీర్ మనస్సులో ఒక స్పార్క్ సృష్టించడానికి ఈ పదం సరిపోతుంది. TO n మెమరీలో ప్రాసెసింగ్ సాధనం ఇది క్లస్టర్ కంప్యూటింగ్‌లో మెరుపు వేగంతో ఉంటుంది. మ్యాప్‌రెడ్యూస్‌తో పోలిస్తే, ఇన్-మెమరీ డేటా షేరింగ్ RDD లను చేస్తుంది 10-100x వేగంగా నెట్‌వర్క్ మరియు డిస్క్ షేరింగ్ కంటే మరియు RDD లు (స్థితిస్థాపక పంపిణీ డేటా సెట్లు) కారణంగా ఇవన్నీ సాధ్యమవుతాయి. స్పార్క్ కథనాన్ని ఉపయోగించి ఈ RDD లో ఈ రోజు మనం దృష్టి సారించే ముఖ్య అంశాలు:

• RDD ల అవసరం
• RDD లు అంటే ఏమిటి?
• RDD ల యొక్క లక్షణాలు
• స్పార్క్ ఉపయోగించి RDD ల సృష్టి
• ఆర్‌డిడిలపై ఆపరేషన్లు చేస్తారు
• స్పార్క్ ఉపయోగించి RDD లు: పోకీమాన్ యూజ్ కేస్

RDD ల అవసరం?

ప్రపంచం అభివృద్ధి చెందుతోంది మరియు డేటా సైన్స్ లో పురోగతి కారణంగా . అల్గోరిథంలు ఆధారంగా రిగ్రెషన్ , , మరియు ఇది నడుస్తుంది పంపిణీ ఇటరేటివ్ కంప్యూట్ ation బహుళ కంప్యూటింగ్ యూనిట్లలో డేటాను పునర్వినియోగం చేయడం మరియు భాగస్వామ్యం చేయడం.

సాంప్రదాయ పద్ధతులకు స్థిరమైన ఇంటర్మీడియట్ మరియు పంపిణీ నిల్వ అవసరం HDFS డేటా ప్రతిరూపాలు మరియు డేటా సీరియలైజేషన్‌తో పునరావృత గణనలను కలిగి ఉంటుంది, ఇది ప్రక్రియను చాలా నెమ్మదిగా చేసింది. పరిష్కారం కనుగొనడం అంత సులభం కాదు.

ఇది ఎక్కడ ఉంది ఆర్డీడీలు (స్థితిస్థాపక పంపిణీ డేటాసెట్‌లు) పెద్ద చిత్రానికి వస్తుంది.

ఆర్డీడీ డేటా మూలాల నుండి డేటా దిగుమతి చేయబడి, RDD లలో పడిపోవటం వలన వాటిని ఉపయోగించడం సులభం మరియు సృష్టించడానికి అప్రయత్నంగా ఉంటుంది. ఇంకా, వాటిని ప్రాసెస్ చేయడానికి ఆపరేషన్లు వర్తించబడతాయి. అవి a మెమరీ పంపిణీ అనుమతులతో చదవడానికి మాత్రమే మరియు ముఖ్యంగా, అవి తప్పు-సహనం .

ఏదైనా ఉంటే డేటా విభజన యొక్క RDD కోల్పోయిన , అదే వర్తించడం ద్వారా పునరుత్పత్తి చేయవచ్చు పరివర్తన లో కోల్పోయిన విభజనపై ఆపరేషన్ వంశం , మొదటి నుండి అన్ని డేటాను ప్రాసెస్ చేయడం కంటే. నిజ సమయ దృశ్యాలలో ఈ రకమైన విధానం డేటా నష్టం పరిస్థితులలో లేదా సిస్టమ్ డౌన్ అయినప్పుడు అద్భుతాలు జరిగేలా చేస్తుంది.

RDD లు అంటే ఏమిటి?

ఆర్డీడీ లేదా ( స్థితిస్థాపక పంపిణీ డేటా సెట్ ) ఒక ప్రాథమిక డేటా నిర్మాణం స్పార్క్లో. పదం స్థితిస్థాపకంగా డేటాను స్వయంచాలకంగా లేదా డేటాను ఉత్పత్తి చేసే సామర్థ్యాన్ని నిర్వచిస్తుంది తిరిగి రోలింగ్ కు అసలు స్థితి డేటా నష్టం సంభావ్యతతో unexpected హించని విపత్తు సంభవించినప్పుడు.

RDD లలో వ్రాసిన డేటా విభజించబడింది మరియు నిల్వ బహుళ ఎక్జిక్యూటబుల్ నోడ్స్ . ఒక అమలు నోడ్ ఉంటే విఫలమవుతుంది రన్ టైమ్‌లో, అది తక్షణమే బ్యాక్ అప్ పొందుతుంది తదుపరి ఎక్జిక్యూటబుల్ నోడ్ . ఇతర సాంప్రదాయ డేటా నిర్మాణాలతో పోల్చినప్పుడు RDD లను అధునాతన డేటా నిర్మాణాలుగా పరిగణిస్తారు. RDD లు నిర్మాణాత్మక, నిర్మాణాత్మక మరియు సెమీ స్ట్రక్చర్డ్ డేటాను నిల్వ చేయగలవు.

స్పార్క్ బ్లాగును ఉపయోగించి మా RDD తో ముందుకు వెళ్దాం మరియు RDD ల యొక్క ప్రత్యేక లక్షణాల గురించి తెలుసుకుందాం, ఇది ఇతర రకాల డేటా నిర్మాణాలపై అంచుని ఇస్తుంది.

RDD యొక్క లక్షణాలు

• ఇన్-మెమరీ (ర్యామ్) గణనలు : ఇన్-మెమరీ గణన యొక్క భావన డేటా ప్రాసెసింగ్ మొత్తంగా వేగంగా మరియు సమర్థవంతమైన దశకు తీసుకువెళుతుంది పనితీరు వ్యవస్థ యొక్క అప్‌గ్రేడ్ చేయబడింది.
• ఎల్ అతని మూల్యాంకనం : లేజీ మూల్యాంకనం అనే పదం చెప్పారు పరివర్తనాలు RDD లోని డేటాకు వర్తించబడతాయి, కాని అవుట్పుట్ ఉత్పత్తి చేయబడదు. బదులుగా, అనువర్తిత పరివర్తనాలు లాగిన్ చేయబడింది.
• పట్టుదల : ఫలిత RDD లు ఎల్లప్పుడూ ఉంటాయి పునర్వినియోగపరచదగినది.
• ముతక-కణిత ఆపరేషన్లు : వినియోగదారు డేటా సెట్లలోని అన్ని అంశాలకు పరివర్తనలను వర్తింపజేయవచ్చు మ్యాప్, ఫిల్టర్ లేదా ద్వారా సమూహం కార్యకలాపాలు.
• తప్పు సహనం : డేటా కోల్పోతే, సిస్టమ్ చేయగలదు తిరిగి వెళ్లండి దాని అసలు స్థితి లాగిన్ ఉపయోగించడం ద్వారా పరివర్తనాలు .
• మార్పులేనిది : డేటా నిర్వచించబడింది, తిరిగి పొందబడింది లేదా సృష్టించబడదు మార్చబడింది అది సిస్టమ్‌లోకి లాగిన్ అయిన తర్వాత. ఒకవేళ మీరు ఇప్పటికే ఉన్న RDD ని యాక్సెస్ చేసి, సవరించాల్సిన అవసరం ఉంటే, మీరు తప్పనిసరిగా సమితిని వర్తింపజేయడం ద్వారా కొత్త RDD ని సృష్టించాలి పరివర్తన ప్రస్తుత లేదా మునుపటి RDD కి పనిచేస్తుంది.
• విభజన : ఇది కీలకమైన యూనిట్ స్పార్క్లో సమాంతరత ఆర్డీడీ. అప్రమేయంగా, సృష్టించబడిన విభజనల సంఖ్య మీ డేటా మూలం మీద ఆధారపడి ఉంటుంది. మీరు ఉపయోగించాలనుకుంటున్న విభజనల సంఖ్యను కూడా మీరు నిర్ణయించవచ్చు అనుకూల విభజన విధులు.

స్పార్క్ ఉపయోగించి RDD యొక్క సృష్టి

లో RDD లను సృష్టించవచ్చు మూడు మార్గాలు:

1. నుండి డేటాను చదవడం సమాంతర సేకరణలు

val PCRDD = spark.sparkContext.parallelize (శ్రేణి ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'), 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 (). Foreach (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 యొక్క ఒకే విభజనలో లభిస్తుంది పేరెంట్ ASD . ఇరుకైన పరివర్తనలకు ఉదాహరణలు:

• మ్యాప్ ()
• ఫిల్టర్ ()
• ఫ్లాట్ మ్యాప్ ()
• విభజన ()
• మ్యాప్ పార్టిషన్స్ ()

విస్తృత పరివర్తనాలు: మేము విస్తృత పరివర్తనను వర్తింపజేస్తాము బహుళ విభజనలు క్రొత్త RDD ని రూపొందించడానికి. RDD ని ప్రాసెస్ చేయడానికి అవసరమైన డేటా బహుళ విభజనలలో లభిస్తుంది పేరెంట్ ASD . విస్తృత పరివర్తనలకు ఉదాహరణలు:

• తగ్గించు ()
• యూనియన్ ()

చర్యలు : చర్యలు అపాచీ స్పార్క్ దరఖాస్తు చేయమని ఆదేశిస్తాయి గణన మరియు ఫలితం లేదా మినహాయింపును డ్రైవర్ RDD కి తిరిగి పంపండి. కొన్ని చర్యలు:

• సేకరించండి ()
• లెక్కించు ()
• తీసుకోవడం()
• ప్రధమ()

RDD లపై కార్యకలాపాలను ఆచరణాత్మకంగా వర్తింపజేద్దాం:

ఐపీఎల్ (ఇండియన్ ప్రీమియర్ లీగ్) ఇది క్రికెట్ టోర్నమెంట్, ఇది గరిష్ట స్థాయిలో ఉంది. కాబట్టి, ఈ రోజు మన చేతులను ఐపిఎల్ డేటా సెట్‌లోకి తీసుకువెళ్ళి, స్పార్క్ ఉపయోగించి మా ఆర్డిడిని అమలు చేద్దాం.

• మొదట, IPL యొక్క CSV మ్యాచ్ డేటాను డౌన్‌లోడ్ చేద్దాం. దీన్ని డౌన్‌లోడ్ చేసిన తర్వాత, ఇది వరుసలు మరియు నిలువు వరుసలతో ఎక్సెల్ ఫైల్‌గా కనిపించడం ప్రారంభిస్తుంది.

తరువాతి దశలో, మేము స్పార్క్ ని కాల్చివేస్తాము మరియు match.csv ఫైల్ను దాని స్థానం నుండి లోడ్ చేస్తాము, నా విషయంలో నాcsvఫైల్ స్థానం “/Uuser/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 ('Hyderabad')). సేకరించండి ()

• విభజన ():

మేము RDD లోకి వ్రాసే ప్రతి డేటా నిర్దిష్ట సంఖ్యలో విభజనలుగా విభజించబడింది. మేము ఈ పరివర్తనను కనుగొనడానికి ఉపయోగిస్తాము విభజనల సంఖ్య డేటా వాస్తవానికి విభజించబడింది.

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

• మ్యాప్ పార్టిషన్స్ ():

మ్యాప్ () మరియుప్రతి() కలిసి. మేము ఇక్కడ మ్యాప్ పార్టిషన్లను ఉపయోగిస్తాము వరుసల సంఖ్య మేము మా ఫిల్ RDD లో ఉన్నాము.

val fil = CKfile.filter (line => line.contains ('2016')) fil.mapPartitions (idx => Array (idx.size) .iterator). సేకరణ

• తగ్గించు ():

మేము ఉపయోగిస్తాముతగ్గించు() పై కీ-విలువ జతలు . మేము ఈ పరివర్తనను మాపై ఉపయోగించాముcsvతో ప్లేయర్‌ను కనుగొనడానికి ఫైల్ అత్యధిక మ్యాన్ ఆఫ్ ది మ్యాచ్ .

ఐసో 9000 vs సిక్స్ సిగ్మా

val ManOfTheMatch = CKfile.map (_. స్ప్లిట్ (',') (13)) val MOTMcount = ManOfTheMatch.map (WINcount => (WINcount, 1)) val ManOTH = MOTMcount.reduceByKey ((x, y) => x + y) .మ్యాప్ (tup => (tup._2, tup._1)) sortByKey (తప్పుడు) ManOTH.take (10) .ఫారచ్ (println)

• యూనియన్ ():

పేరు ఇవన్నీ వివరిస్తుంది, మేము యూనియన్ పరివర్తనను ఉపయోగిస్తాము రెండు RDD లను కలిపి క్లబ్ చేయండి . ఇక్కడ మేము ఫిల్ మరియు ఫిల్ 2 అనే రెండు RDD లను సృష్టిస్తున్నాము. fil RDD లో 2017 IPL మ్యాచ్‌ల రికార్డులు ఉన్నాయి మరియు fil2 RDD లో 2016 IPL మ్యాచ్ రికార్డ్ ఉంది.

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 (తప్పుడు) 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 => ( స్కౌంట్, 1)) స్కేలా & జిటి వాల్ స్టేట్కౌంట్ = స్కౌంట్.రూడెస్బైకే ((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 (తప్పుడు) statecountm.first ()

మా ప్రక్రియను స్పార్క్ ఉపయోగించి మా అభ్యాస RDD గా చేయడానికి, మరింత ఆసక్తికరంగా, నేను ఆసక్తికరమైన ఉపయోగ కేసుతో ముందుకు వచ్చాను.

స్పార్క్ ఉపయోగించి RDD: పోకీమాన్ యూజ్ కేస్

• మొదట, మనం పోచ్‌మన్‌.సి.ఎస్.వి ఫైల్‌ను డౌన్‌లోడ్ చేసి, మ్యాచ్స్‌.సి.ఎస్.వి ఫైల్‌కు చేసినట్లుగా స్పార్క్ షెల్‌కు లోడ్ చేద్దాం.

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)

• ఇప్పుడు a తో పోకీమాన్ చూద్దాం తక్కువ రక్షణ వ్యూహం.

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 ముగింపుకు వస్తాము. RDD లు, వాటి లక్షణాలు మరియు వాటిపై చేయగలిగే వివిధ రకాల కార్యకలాపాల గురించి మీ పరిజ్ఞానంపై మేము కొంచెం వెలుగునిచ్చామని నేను ఆశిస్తున్నాను.

ఈ వ్యాసం ఆధారంగా క్లౌడెరా హడూప్ మరియు స్పార్క్ డెవలపర్ సర్టిఫికేషన్ పరీక్ష (CCA175) కోసం మిమ్మల్ని సిద్ధం చేయడానికి రూపొందించబడింది. మీరు అపాచీ స్పార్క్ మరియు స్పార్క్ ఎకోసిస్టమ్‌పై లోతైన జ్ఞానం పొందుతారు, ఇందులో స్పార్క్ RDD, స్పార్క్ SQL, స్పార్క్ MLlib మరియు స్పార్క్ స్ట్రీమింగ్ ఉన్నాయి. స్కాలా ప్రోగ్రామింగ్ లాంగ్వేజ్, హెచ్‌డిఎఫ్‌ఎస్, స్కూప్, ఫ్లూమ్, స్పార్క్ గ్రాఫ్ఎక్స్ మరియు కాఫ్కా వంటి మెసేజింగ్ సిస్టమ్‌పై మీకు సమగ్ర జ్ఞానం లభిస్తుంది.