హాయ్.
  ఈ రోజు మనం MapReduce పై గురించి చర్చిస్తాము.
  ఇప్పటికే మేము MapReduce పై చర్చించాము.
  సో, నేడు మేము ఒకటి లేదా రెండు సమస్యలను పరిష్కరించడానికి ప్రయత్నించండి లేదా కాకుండా ఎలా ఒకటి లేదా రెండు చూడటానికి ప్రయత్నించండి; మాప్ రిడస్ సమస్యలో సమస్యను విచ్ఛిన్నం చేయగలము మరియు దానిపై ఎలా పనిచేయాలి. 
  కాబట్టి, మీరు MapReduce నమూనాను పార్లేలైజేషన్ సాధ్యమైనంత భారీ డేటాను ప్రాసెస్ చేయడానికి ఉపయోగించబడుతుందని మీరు గుర్తుంచుకుంటే, పార్టీషన్ సాధ్యమవుతుంది.
  మరియు ప్రధానంగా కాకుండా Google ద్వారా అభివృద్ధి మరియు తరువాత వివిధ రంగాలలో ఉపయోగిస్తారు.
  కాబట్టి, మేము ఏమి చేస్తాము; మేము ప్రారంభంలో రెండు స్లయిడ్లను ఈ MapReduce ఫ్రేమ్ వర్క్ సంబంధించిన ఒకటి లేదా రెండు సమస్యలు చేపట్టడానికి ముందు మేము శీఘ్ర రీక్యాప్ ఉంటుంది.
  కాబట్టి, మేము ఇప్పటికే చర్చించారు; కాబట్టి, ఇది Google లో అభివృద్ధి చేయబడిన ప్రోగ్రామింగ్ మోడల్. ప్రాథమిక లక్ష్యం పెద్ద స్థాయి శోధనను అమలు చేయడం.
  బిగ్ టేబుల్ మరియు GFS పంపిణీ చేయబడిన ఫైల్ సిస్టమ్ను ఉపయోగించి నిల్వ చేయబడిన డేటాను ఉపయోగించి భారీగా స్కేలబుల్ వెబ్ డేటాపై టెక్స్ట్ ప్రాసెసింగ్; Google ఫైల్ సిస్టమ్ మరియు పెద్ద డేటా; బిగ్ టేబుల్.
  కాబట్టి, ఇది ప్రారంభమైన గూగుల్ యొక్క లక్ష్యంగా ఉంది; కాబట్టి, భారీగా సమాంతర గణన ద్వారా డేటా యొక్క పెద్ద పరిమాణాన్ని ప్రాసెస్ చేయడం మరియు రూపొందించడం; ఒక సమయంలో పదుల మరియు వేలాది ప్రాసెసర్లను ఉపయోగించడం.
  సో, పదుల మరియు వేల ట్యూన్ ప్రాసెసర్ల భారీ సంఖ్యలో ఉన్నాయి. కాబట్టి, నేను లోపలికి దోపిడీ చేయగలదా అన్న విషయాలలో అంతర్లీన సమాంతరత  ఉన్నట్లయితే, అది దోషపూరితమైనదిగా రూపొందించబడింది; అర్థం, గణన పురోగతిని నిర్ధారించడానికి; ప్రాసెసర్ లేదా నెట్వర్క్ విఫలమైతే కూడా.
  కాబట్టి, ఇది ప్రాథమిక మూలాధారం. 
  కాబట్టి, ఇది ప్రాథమిక భావన లేదా ప్రాథమికమైనది; ఈ పనుల యొక్క పూర్వస్థితి లేదా ఈ ప్రాథమికంగా చెప్పాము. కాబట్టి, హడూప్ వంటి అనేక విషయాలు ఉన్నాయి, ఓపెన్ సోర్స్ అమలు MapReduce; యాదృచ్ఛికంగా దీనిని యాహూఅభివృద్ధి చేసింది; అమెజాన్  EC2 లో ప్రీ ప్యాక్డ్  AMI లలో లభిస్తుంది మరియు మొదలగునవి.
  కాబట్టి, మేము దాని చరిత్రనుండి దూరంగా చూస్తే; కాబట్టి, ఇది అనేక సమాంతర అనువర్తనాలచేఉపయోగించే సమాంతర ప్రోగ్రామింగ్ సంగ్రహణం.   
  ఇది వేలాది ప్రాసెసర్లనుకలిగి ఉన్న భారీ స్థాయి గణనను నిర్వహిస్తుంది.
  మేము సరిగ్గా సహించని అమలును అమలు చేస్తున్నందున ఇది మళ్లీ ఉంది; డేటా వైపు మరియు ప్రాసెసర్  మరియు నెట్వర్క్ వైపు రెండు.
  కాబట్టి, ప్రతిదీ తప్పు తట్టుకుంటుంది; రెండు దశలుగా విభజించబడింది; ఒక మాప్ దశ .
  కాబట్టి, మ్యాపింగ్ కాబట్టి, నేను రెండు దశలుగా విభజించాను.
  కాబట్టి, ఇది ఒక ఇంటర్మీడియట్ ఫలితంగా మ్యాప్ చెయ్యబడింది మరియు ఒక కుదించబడుతుంది; మళ్ళీ, తగ్గించడానికి ఫంక్షన్ లేదా దశ తగ్గించడానికి; ఆ ఇంటర్మీడియట్ ఫలితం అసలు ఫలితాలు తగ్గించు.
  కాబట్టి, ఇలా చేయడం; మనం మా పూర్వ ఉపన్యాసంలో లేదా MapReduce ముందున్న చర్చలో చూసినప్పుడు మనము సమాంతర సామర్థ్యాన్న కలిగి ఉన్నాము; మేము గణనీయమైన సమాంతర సామర్థ్యాన్ని సాధించగలము, మనము పెద్ద మొత్తంలో సమాచారముతో వ్యవహరిస్తున్నప్పుడు మరియు ప్రక్రియలో స్వాభావిక సమాంతరత ది.
  కాబట్టి, మనం చూస్తున్నది మాప్ ప్రాసెసర్ సంఖ్య మరియు రీడర్ ప్రాసెసర్ల సంఖ్య.
  ఇది సమస్య మీద ఆధారపడి పని చేస్తారు.
  సో, ఒక మాస్టర్ నియంత్రిక ఉంది, M mapper ప్రాసెసర్ మరియు పని ఆ reducer సెల్ ప్రాసెసర్ R సంఖ్య చెప్పారు.
  మరియు కొన్ని సందర్భాల్లో ఈ మ్యాపర్ మరియు తగ్గించేది; ప్రాసెసర్ అదే భౌతిక అవస్థాపన వద్ద భాగస్వామ్యం చేయవచ్చు.
  కాబట్టి; అనగా, కొన్నిసార్లు మేము ఒక మ్యాపర్గా వ్యవహరిస్తాము మరియు తదుపరి దశలో ఒక రీడ్యూసర్ రకాలుగా వ్యవహరిస్తాము.
  కాబట్టి, ఇది డెవలపర్ యొక్క మా సామర్ధ్యం లేదా మీరు ఈ మ్యాపింగ్  మరియు మ్యాప్ను  ఎలా రూపొందించాలో మరియు విధులు తగ్గించడమే.
  ఆ భాషను ఏదేని ఆధారంగా అమలు చేయడం; డెవలపర్ పని, బహుశా చాలా ఉన్నాయి; అనగా ప్రజలు పైథాన్మీద పని చేస్తుంటే, అది c ప్లస్ ప్లస్ మరియు ఇతర కోడింగ్ విషయాలపై ఉంటుంది.
  కాబట్టి, ఆ కోడింగ్ భాగంగా ఆ ఏ విధమైన సమస్య మరియు మీరు పని వాతావరణం ఏమిటి ఆధారంగా.
  కానీ ప్రధానంగా ఒక తత్వశాస్త్రంMAP యొక్క సంఖ్య M మరియు తగ్గింపు సమితి  ఉన్నాయి; మీరు విషయం లోకి ఇంటర్మీడియట్ ఫలితాలు కలిగి.
  కాబట్టి, ప్రతి మాప్ ప్రతి మాప్టర్ ప్రపంచ ఫైలు వ్యవస్థ(నుండి ఇన్పుట్ యొక్క 1 M వ  చదివినట్లు ముందుగా మేము చర్చించినట్లుగా, మాస్టర్ ఇచ్చిన ప్రదేశాలను ఉపయోగించి.
  సో, మాస్టర్ కంట్రోలర్ ; మాస్టర్ నోడ్  నియంత్రిక ఈ మీరు చదవడానికి అవసరం రాళ్లను అని చెప్పారు.
  కాబట్టి, మ్యాప్ ఫంక్షన్  ఒక కీ విలువ జత నుండి మరొక కీ విలువ జతకు రూపాంతరం ఉంటుంది.
  ఇక్కడ నేను k1, v1 కు k2, v2; ప్రతి మ్యాపర్ ప్రతి తగ్గింపుకు ఒక ఫైల్ యొక్క గణన ఫలితాలను వ్రాస్తుంది.
  కాబట్టి, R తగ్గింపుదారులు ఉంటే సాధారణంగా తయారు చేస్తారు.
  కాబట్టి, ఒక తగ్గింపుదారుడు ఉంటే, అది ఒక ఫైల్ తగ్గింపుకు కోసం ఫలితం సిద్ధం చేస్తుంది; కాబట్టి అది యూజర్ కోసం ఫైల్ను సృష్టించే ఒక ఫైల్.
  ఫైళ్ళు ఒక కీలో నిల్వ చేయబడి ఒక కీ ద్వారా క్రమబద్ధీకరించబడతాయి మరియు స్థానిక ఫైల్ సిస్టమ్లో నిల్వ చేయబడతాయి.
  కాబట్టి, మాపర్ యొక్క అవుట్పుట్ నిల్వ చేయబడిన స్థానిక ఫైల్ వ్యవస్థలు
  యజమాని ఈ ఫైల్ యొక్క స్థానాన్ని ట్రాక్ చేస్తాడు, యజమాని విషయాలను ట్రాక్ చేస్తాడు.
  తగ్గించే దశ లేదా తగ్గింపు దశలో; మాపెర్ మొత్తం ప్రక్రియ యొక్క పాక్షిక గణన చేసింది. 
  పాక్షిక గణనను ఒక తగ్గింపుదారుకి తెలియచేస్తాడు; సంబంధిత మ్యాపర్లకు స్థానిక ఫైల్ సిస్టమ్లో నిల్వ చేయబడ్డాయి.
  కాబట్టి, నిర్దిష్ట మాపెర్స్ కోసం M మాపర్లు ఉన్నట్లయితే, ఫైల్స్  ప్రత్యేకమైన తగ్గింపు కోసం నిల్వ చేయబడతాయి.
  Reducer రిమోట్ ప్రక్రియ కాల్ చేయండి; ఫైళ్ళను ఎదుర్కొనేందుకు మ్యాపర్ని అభ్యర్థించండి.
  ప్రతి తగ్గింపు సమూహాలు ఒకే కీని ఉపయోగించి పటాలు టేప్ యొక్క ఫలితాలు మరియు ఒక ఫంక్షన్ చేస్తాయి; ఈ విలువకు సంబంధించిన కొన్ని ఫంక్షన్ f మరియు విలువలు జాబితా.
  అంటే మీకు k 2 గా ఉంటే, v 2 తరువాత నేను కొన్ని k2 మరియు ఆ v2 యొక్క ఫంక్షన్కు మ్యాప్ చేస్తాను.
  కాబట్టి, ఫంక్షన్ సగటు వంటి సాధారణ కావచ్చు; కాబట్టి, బహుశా మరింత పౌనఃపున్యం లేదా గణన లేదా మరికొన్ని కార్యకలాపాలను చేసే కొన్ని క్లిష్టమైన పనులు.
  కాబట్టి, ఫలితాలు Google ఫైల్ సిస్టమ్కు తిరిగి వ్రాయబడతాయి, అందువల్ల Google ఫైల్ సిస్టమ్ వాటిని జాగ్రత్తగా చూస్తుంది.
  కాబట్టి, MapReduce ఉదాహరణ; కాబట్టి, 3 మ్యాప్లు ఉన్నాయి; 2 తగ్గింపుదారులు , మ్యాప్ ఫంక్షన్  ఈ విషయంలో ఉంది; మీరు జ్ఞాపకం ఉంటే లేదా మీరు మా మునుపటి ఉపన్యాసం మరియు చర్చ చూస్తే.
  సో, అక్కడ పదం యొక్క భారీ వాల్యూమ్ మరియు మేము ఒక పదం లెక్కింపు చేయాలనుకుంటున్నారా.
  కాబట్టి, ప్రతి మాపెర్ ఈ మ్యాపర్ వంటి డేటా విషయాలను కలిగి ఉంది D 1, D 2, D 3 మరియు ఈ D 4, D 7, D 8 etcetera.
  కాబట్టి, ప్రతి మాపెర్ పదం యొక్క పాక్షిక సంఖ్యను మరియు w 1, w 2, w 3 మరియు అందువలన మరియు మొదలగునవి చేస్తుంది.
  మరియు రెండు తగ్గింపుదారులు ఉంటారు, కాబట్టి ఇది రెండు తగ్గింపుదారుల కొరకు ఫైల్ను సృష్టిస్తుంది మరియు తద్వారా W1 మరియు W లకు బాధ్యత వహిస్తుంది; యూజర్లు రెండు w3 మరియు w4 కోసం లేదో.
  మరియు మేము విషయం మీద పద గణన చేస్తాను, కాబట్టి ఇక్కడ ఒక మ్యాపింగ్ ఫంక్షన్  ఉంది, ఇక్కడ ఇది జరుగుతుంది మరియు ఒక తగ్గించడం ఫంక్షన్ ఉంది, ఇక్కడ ప్రధానంగా ప్రతి ఫంక్షన్ కోసం ఈ ఫంక్షన్ యొక్క సమ్మషన్ కోసం ఫంక్షన్ ఉంది; W1.
  కాబట్టి, ఇది మాప్ రిడస్ సమస్య మరియు గత చర్చ లేదా గత ఉపన్యాసంలో లెక్కింపు సమస్య ఏమిటంటే ఇది వ్యవస్థలో సమాంతర సామర్థ్యాన్ని అందించగలదని మేము చూపించాము.
  కాబట్టి, మేము ఇప్పుడు కొన్ని సమస్యలను చూస్తాము. 
  కాబట్టి, ఇది సరిగ్గా MapReduce సమస్య కాదు, కేవలం హడూప్ ఫైల్ సిస్టమ్ లేదా GFS కోసం వెళ్ళడం; Google ఫైల్ వ్యవస్థ
  కాబట్టి, మీరు ఈ ఫైల్ వ్యవస్థలు సహజ ఫైల్ సిస్టమ్ కంటే ఎన్నటికీ పెద్ద భాగం బ్లాక్ పరిమాణంగా ఉన్నట్లు గుర్తుంటే బ్లాక్ పరిమాణం 64 MB అయితే.
  మరియు మరొక విషయం ఏమిటంటే డేటా యొక్క ప్రతి ఉదాహరణకు మూడు ప్రతిరూపంఉంది.
  కాబట్టి, ఒక మూడు ప్రతిరూపం ఉంది, అక్కడ మీరు తప్పు తట్టుకోగల మోడ్ను కలిగి ఉండటానికి అనుమతిస్తుంది; అందుచేత వ్రాయబడిన వ్రాతపూర్వక కార్యకలాపములు ఉన్నాయి.
  కాబట్టి, ఈ ప్రత్యేక విషయం లో; మేము ఉంటే మేము చెప్పే ఉంటే; HDFS బ్లాక్ పరిమాణం 64 MB అయితే, అప్పుడు మేము తెలుసుకోవాలనుకుంటున్నాము; 64 K, 65 MB, Kb యొక్క మూడు ఫైల్స్ ఉంటే; MB మరియు 127 MB.
  కాబట్టి, HDFS ముసాయిదాచే ఎన్ని బ్లాక్లు సృష్టించబడతాయి.
  కాబట్టి, 64 kb ఉంటే; ఎన్ని బ్లాక్ ఒకటి సృష్టించబడిందో మరియు 65 MB, మనకు 2; ఎందుకంటే 64 MB వరకు; 1 మరియు 127 MB కూడా 2. సో, మొత్తం 5, కానీ వాస్తవ ప్రతిరూపాలు ఉన్నాయి ప్రతిరూపాలు ఉన్నాయి; కాబట్టి, సాధారణంగా 3 ప్రతిరూపం ఉంటుంది, కనుక సమర్థవంతమైన బ్లాక్ పరిమాణం 5 కు సమానంగా ఉంటుంది; ఈ బ్లాక్స్.
  కాబట్టి, చాలా సూటిగా; ఏదీ, సంక్లిష్టత ఉండదు, కాబట్టి నేను విభిన్న రకం విషయం కలిగి ఉంటే. కాబట్టి, మేము ఈ సూటిగా లెక్కించవచ్చు; కాబట్టి, మళ్ళీ ఏమీ చేయకూడదు; MapReduce తో వెంటనే ఏమీ లేదు, అయితే; డేటా HDFS లో నిల్వ చేయబడుతుంది లేదా ఇది ఓపెన్ సోర్స్ లేదా GFS లో ఉంటే, అది Google ఫైల్ సిస్టమ్ అయితే మరియు ఈ డేటా పరిమాణాన్ని కలిగి ఉండాలి లేదా మీరు బడ్జెట్లో నిల్వ చేయవలసిన అవసరం ఉంది, మీరు పెద్ద డేటా సమితిలో పని చేస్తున్నప్పుడు మీకు ఎంత నిల్ ఉంది, ఈ రకమైన డేటా సమితులపై మీకు ఎంత నిల్వ అవసరం? 
  ఇప్పుడు, MapReduce ఫ్రేమ్ పై చాలా సరళమైన సమస్యతో మళ్ళీ ఒక సమస్యను చూద్దాం. కాబట్టి, మేము ఈ MapReduce ఫ్రేమ్ను కలిగి ఉన్నాం. 
  అయితే సమస్య యొక్క ఈ సరళత కారణంగా మనం మళ్ళీ మమ్మల్ని చాలా అభినందించలేము.
  కానీ MapReduce ఫ్రేమ్ అర్థం చేసుకోవడానికి, అది మంచి కావచ్చు.
  కాబట్టి మీరు ఏదైనా భాషలో నకిలీ సంకేతాలు లేదా కోడ్లను రాయాలనుకుంటున్నారా; అక్కడ ఎక్కడ; మనం చేయాలనుకుంటున్నారా? MapReduce లో పూర్ణాంకాల సమితి యొక్క సగటును లెక్కించండి.
  కాబట్టి, పూర్ణాంకాల సమితి వ్యవస్థలోకి పంప్ చేయబడి ఉంటుంది, ఇది కీబోర్డ్ నుండి లేదా ఏదో ఒక ప్రత్యక్ష ఇన్పుట్ కావచ్చు మరియు మనము పూర్ణాంక యొక్క సమితి యొక్క సగటును కనుగొనాలనుకుంటున్నాము.
  ఇతర అర్థంలో, ఈ విలక్షణ కేసు లో నేను పూర్ణాంకA గా సెట్ చేశాను; 10, 20, 30, 40, 50. కాబట్టి, పూర్ణాంకాల సమితి ఉన్నందున నేను సగటున చేయాలనుకుంటున్నాను.
  కాబట్టి, ఇతర అర్థంలో మనం ప్రాథమికంగా దానిని మొత్తాన్ని మరియు కార్డినిటీ ద్వారా విభజించాలనుకుంటున్నాము.
  కాబట్టి, పూర్తిగా 5 గా విభజించబడింది.
  కాబట్టి ఈ విషయంలో మనం ఏమి చేస్తాము? మాస్టర్ నోడ్  మూడు మ్యాపులర్ ఉన్నట్లు మేము భావిస్తున్నాము.
  కాబట్టి, మాప్పర్ నోడ్స్ 3 సంఖ్యలుగా పరిగణించబడుతున్నాయి మరియు ఒక సంఖ్య తగ్గింపు సంఖ్య 1 సంఖ్య.
  కాబట్టి, ఈ మాపెర్( కోసం ఏమి చేయాలో మాస్టర్ నోడ్ లో ఏమి చేస్తుంది; ఇది M1, M2, M 3 అని చెప్పుతుంది; 3 మ్యాపర్ నోడ్
  కాబట్టి, ఈ డేటాలో ఒక భాగాన్ని మొదటిదానికి 10, 20 ఇస్తుంది.
  30, 40 మరియు 50. కాబట్టి, ప్రతి మాపెర్ విషయాలు పాక్షిక లెక్కింపు చేస్తుంది; అది ఈ రెండు విషయాల సగటును చేస్తుంది.
  కాబట్టి, అది ఏది వస్తే వస్తుంది; నేను సగటు మరియు కౌంట్ చెప్పగలను.
  కాబట్టి, మొదటిది 15, 2; అప్పుడు ఇది 35 కార్డినల్లు 2 మరియు ఇది 50; 1.
  ఇతర అర్థంలో; తాత్కాలిక స్థానిక ఫైల్ సిస్టమ్లో స్టోర్ 15; 2, 35; 2.
  ప్రాథమికంగా మ్యాపర్ యొక్క అవుట్పుట్; ఇది కలయిక ద్వారా చేస్తుంది.
  కాబట్టి, ఈ పటం పనులు సాధించాలనుకుంటోంది.
  తగ్గింపు; తగ్గింపు ప్రధానంగా అన్ని విషయాలను తీసుకుంటుంది ఒక తగ్గింపు ఉంది మరియు అది మొత్తం విషయం యొక్క సగటు లేదా మరింత సగటు ఒక సగటు చేస్తుంది.
  కాబట్టి, ఇతర అర్ధంలో ఇది 15 నక్షత్రం 2 అని చెపుతుంది; ఇక్కడ 35 స్టార్ 2 మరియు 50 స్టార్ 1. ఇతర అర్థంలో సిగ్మా మొత్తం 150; సిగ్మా గణన 5.
  కాబట్టి, అది 150 (బై / బై) 5 30 అని మరియు ఇది ప్రాథమికంగా 15 స్టార్2 ప్లస్ 35 స్టార్2; 
  సో, సమస్య సూటిగా లేదా సాధారణ మీ రు కనుగొనలేరు ఇక్కడ పెద్ద ఒప్పందం ఏమిటి? విషయాలు సంఖ్య అధిక ప్రవాహం లా వస్తున్న ఉంటే, ఆపై నేను ప్రధానంగా ఒక సమాంతర విషయాలు చేయవచ్చు; ఇవి సమాంతరంగా ప్రాసెస్  చేయబడతాయి మరియు ఇది ఒక ప్రత్యేక తగ్గింపు ద్వారా తగ్గిపోతుంది.
  కాబట్టి, మేము దానికోసం కోడ్ వ్రాస్తే; కాబట్టి, మీరు దీనిని ఏ భాషైనా ఉపయోగించవచ్చు.
  ఇక్కడ మేము పైథాన్ లేదా పైథాన్ రకం భాష(ని వాడుతున్నాము, అది భాష ముఖ్యం కాదు; మీరు ఏ సూడో కోడ్ మరియు విషయాల రకాన్ని ఉపయోగించగల ప్రాతినిధ్యం ముఖ్యం.
  కాబట్టి, మీరు ఆ మాపెర్ ఫంక్షన్ లేదా మాపెర్ డాట్ పి; కాబట్టి, ఇది పైథాన్ రకం.
  కాబట్టి, మనము సింటాక్స్కు ప్రాముఖ్యత ఇవ్వము. కాకుండా మేము భావన మరింత ప్రాధాన్యత ఇస్తున్నారు.
  సో, డెఫ్ మ్యాప్; కాబట్టి l తక్కువ ఉంది; కాబట్టి, మేము ఏమి చేస్తాము? మేము 0 కు i కు సమానం అయ్యే మొత్తానికి, 0 కన్నా ఎక్కువ l పొడవు, మొత్తం మొత్తానికి సమానం.
  కాబట్టి, ప్రతి మ్యాపర్ ఈలా చేస్తుంది; ప్రతి మ్యాపర్ ఏమి చేస్తుంది; అది దానికి కేటాయించిన డేటా యొక్క భాగం master నోడ్ ద్వారా మరియు తరువాత మన సందర్భాలలో ఎన్ని డేటా ఉంది? మ్యాపర్ 1 కు 2 డేటా ఉంది; మ్యాప 2 కు 2 డేటా మ్యాపర్ 3 ఉంది; M 3 కు 1 డేటా ఉంది; 
  కాబట్టి, ఇది 2; 2 ప్రతి.
  కాబట్టి, ప్రతి mapper కోసం మేము ఈ పూర్తి; కాబట్టి, ఈ కేసులో l యొక్క పొడవు ద్వారా సగటు మొత్తం 2; అది ఈ మొత్తాన్ని పొడవు 2 గా ఉండవలెను.
  లేదా మరికొందరు ఖచ్చితంగా చెప్పాలంటే, ఒక ఫ్లోటింగ్ పాయింట్ వ్యత్యాసం కలిగి, ఫ్లోటింగ్ పాయింట్ విభజన ఎందుకంటే ఇది ఒక; లేకపోతే పూర్ణాంక విభాగాలు ఉండవచ్చు.
  కాబట్టి, మనం ఆదర్శంగా కొన్ని నక్షత్రం 1.0 పొడవు 1 ద్వారా విభజించవచ్చు.
  కాబట్టి, l పొడవు; ఈ సందర్భంలో 2 మరియు అప్పుడు మేము ఈ అవుట్పుట్. 
  మనం ప్రింట్ ఫంక్షన్ వాడతాము, దీనిని స్థానిక ఫైల్ సిస్టమ్కు అవుట్పుట్ చేయండి.
  కాబట్టి, ఈ ఆజ్ఞ జ్ఞానవంతుడు కావచ్చు; మీరు వేర్వేరు ప్రోగ్రామింగ్ పారామితి  పొడవులను ఉపయోగిస్తుంటే అది భిన్నంగా ఉండవచ్చు. 
  కాబట్టి, mapper ప్రాథమికంగా ఈ డేటాను విడుదల చేస్తాయి.
  కాబట్టి, అది స్థానిక ఫైల్ సిస్టమ్లో నిల్వ చేయబడుతుంది; కాబట్టి, మనం ఏమి చేస్తున్నామో, ప్రతి మాపెర్ కోసం మేము దాని యొక్క జాబితాను చదివే డేటా యొక్క జాబితాను చదువుతున్నాము, దీనితో విలువను మొత్తాన్ని ప్రారంభించడం కొన్ని చేస్తే, మనం ఏమి చేస్తున్నామో మనం చేస్తున్న దాన్ని జోడించాము; లూప్ కోసం.
  అందువల్ల, సరాసరిని దాని నుండి బయటకు తీసుకొనే మొత్తాన్ని లెక్కించడం వల్ల ఇది ఏదీ కాదు, కానీ అది విభజనను విభజించటానికి చేస్తుంది.
  మరియు అది స్థానిక ఫైల్ సిస్టమ్స్లో ఆ విలువను వెలికి లేదా డంపింగ్ చేస్తుంది; ఇది రీడ్యూసర్ చదువుతాను.
  కాబట్టి, ఇది విషయం యొక్క మాప్పర్ భాగం; కాబట్టి, మేము తగ్గింపు భాగాన్ని చూస్తే మనకు డెఫ్ తగ్గింపు
  కాబట్టి, అది ఏమి చదువుతుంది; కాబట్టి, మ్యాపర్ ఎక్కడున్నారని సంసారంగా ఉంది.
  కాబట్టి, మీరు చూస్తే అది ఈ సగటు విలువ మరియు విషయం యొక్క పొడవు ఇవ్వడం.
  ఇక్కడ కూడా మేము ఆ ప్రత్యేక విషయం మొత్తం సమానంగా చదవండి; 
  కాబట్టి, ఇక్కడ i నేను 0 పరిధిలో ఉన్నాను; l యొక్క పొడవు కాబట్టి, మేము మా మునుపటి విషయం చూస్తే అది ఏమి ఉంది; కాబట్టి, అది ఏమి చేస్తుందో, అది ప్రాథమికంగా విలువలను ఈ విధమైన లెక్కించేందుకు ప్రయత్నిస్తుంది.
  కాబట్టి, i యొక్క ప్లస్ పొడవును లెక్కించడానికి సమానంగా లెక్కించండి; కాబట్టి, చివరకు మేము సగటుని పొందుతున్నాము.
  మళ్ళీ ఫ్లోట్ మొత్తం చేయడానికి; అవును ఈ గుణిస్తారు లేదా మీరు basically typecast కూడా కౌంట్ మరియు అప్పుడు సగటు ముద్రించవచ్చు.
  కాబట్టి, రీడ్యూసర్ ఏమిటంటే ఈ స్థానిక ఫైల్ వ్యవస్థను తీసుకెళ్లడం వల్ల ఒకే ఒక తగ్గింపుదారుడు ఉంటారు.
  కాబట్టి, ఇది అన్ని విలువలు మరియు అన్ని డేటా కోసం పడుతుంది; ఇది ప్రతి మ్యాపర్ నుండి ఆ అవుట్పుట్ను సంక్షిప్తం చేస్తూ ఉంటుంది, ఈ సందర్భంలో 3 ఉన్నాయి.
  కాబట్టి, ఇది 15 కు 2 గా ఉంటుంది; ప్లస్ 35 లోకి 2 ప్లస్ 50 లోకి; ఇక్కడ 2 ప్లస్ 2 ప్లస్ 1 5.5 గా విభజించబడి ఉంటుంది. కాబట్టి, అది సగటు విలువను లెక్కిస్తుంది మరియు అది తిరిగి అవసరమయ్యేదానిపై ఆధారపడి Google ఫైల్ సిస్టమ్ లేదా హడూప్ ఫైల్ వ్యవస్థకు సగటు విలువను రాస్తుంది.
  కాబట్టి, ఇక్కడ ఇది ఇదే అవుతుంది, అయితే ఇది ఒక సరళమైన సాధారణ విషయం కావచ్చు, కానీ నేను సమస్యను విభజించగలము. అక్కడ ఉన్న స్వాభావిక సమాంతరత ఉన్నాయి; నేను డేటా యొక్క భాగం తీసుకున్నాను మరియు మా MapReduce ఫ్రేమ్ వర్క్ లో దీనిని పరిష్కరించడానికి ప్రయత్నిస్తాను.
  కాబట్టి, డేటా భారీ సంఖ్యలోఉంటే అప్పుడు mapper; మాస్టర్ నోడ్ తదనుగుణంగా విభజిస్తుంది మరియు పాక్షిక గణన( మరియు తగ్గింపుదారుడు దానిని చదివే మరియు తుది గణనను చేయండి.
  కాబట్టి, ఇది మళ్ళీ MapReduce ఫ్రేమ్ యొక్క ఒక సాధారణ ఉదాహరణ; కాబట్టి, తదుపరి మేము మరొక సమస్య చూస్తాము.
  కాబట్టి, XYZ సంస్థ యొక్క మొత్తం మరియు సగటు జీతంను లెక్కించాలని నేను కోరుతున్నాను; MapReduce ఉపయోగించి లింగం సమూహం చేయబడిన కొన్ని సంస్థ.
  కాబట్టి, ఇన్పుట్ పేరు లింగం మరియు విషయం యొక్క జీతం; ఈ సందర్భంలో పేరు జాన్ అని, లింగంM లేదా మగ మరియు జీతం ఏదో ఉంది 10000 యూనిట్ లేదా బహుశా 10000 డాలర్ లేదా ఏదో.
  మరియు తదుపరి మార్థా ఉంది, లింగం F మరియు జీతం 15000 ఏదో ఉంది.
  కాబట్టి, మేము ఏమి చేయాలనుకుంటున్నారా? మగ జ్ఞానం వంటివాటిని మనం తెలుసుకోవాలనుకుంటున్నాము. ఈ విషయంలో మీ మొత్తం మరియు సగటు జీతం ఏమిటి అని పురుషుడు మరియు స్త్రీ; ఏమైనప్పటికీ కార్డినిటీ ద్వారా విభజించబడిన మొత్తం విషయాలు సగటు జీతం ఉంటుంది; కాబట్టి, అవుట్పుట్ ఆ రూపంలో ఉంటుంది.
  కాబట్టి, మనము ఈ ప్రత్యేక సమస్యను పరిశీలించటానికి MapReduce సమస్యను అమలు చేయవచ్చో చూద్దాం.
  కాబట్టి, దీనిని చూద్దాము.
  కాబట్టి, మనం ఏమి చేస్తున్నాం? మేము ఈ Tuple ఈ వంటి కలిగి; పేరు లింగం మరియు జీతం.
  సో, ఈ tuple ఉంది; కాబట్టి, మేము మాప్ దశలో ఏమి చేయాలనుకుంటున్నారా? కాబట్టి, ఇన్పుట్ డేటా ఇన్పుట్ డేటా ఉన్నట్లయితే ఇన్పుట్ డేటా కావాలనుకుంటే; ఇన్పుట్ డేటా సమితి యొక్క వివిధ సెట్లు ఉన్నాయి.
  కాబట్టి, మనం చేయాలనుకుంటున్నారా? మేము లింగ ఎం గురించి బాధపడటం లేదు ఎందుకంటే మేము సేకరించేందుకు కావలసిన; వ్యక్తి యొక్క పేరు గురించి బాధపడటం లేదా ఆ అవసరం లేదు; కాబట్టి, జీతం.
  కాబట్టి, మనం ఈ రెండు విషయాలను మనం జీతం అని చెప్పుకోవాలి. కాబట్టి, సంబంధిత మరియు అందువలన, వారు ఈ రకం రకాన్ని రకం చేయాలనుకుంటున్నారా లేదా నేను కీ విలువ జత చేయవచ్చు.
  కీ ఇది; పురుషుడు లేదా స్త్రీ మరియు విలువ విషయాలు యొక్క జీతం లేదా మేము ఒక రెండు రకాల నిఘంటువు కలిగి ఉన్నాము చెప్పగలదు, ఇది కీ విలువ జంట కలిగి మరియు తరువాత చెప్పటానికి; నేను దీనిని డిక్ట్ 1, డిక్ట్ 2 మరియు ఈ రెండు రకాలైన కీ విలువ జత మరియు ప్రతి 1 కోసం చెప్తాను, నేను డిక్ట్ 1 ను కలిగి ఉండవచ్చు, అప్పుడు ఇతర ఒకటి కూడా డిక్ట్ 2 కొరకు ఉంటుంది; ఐ ఉండవచ్చు. సో, కాబట్టి ఈ సందర్భంలో id ఈ ప్రత్యేక పురుషుడు లేదా పురుషుడు మరియు అప్పుడు మొత్తం లేదా సగటు జీతం కలిగి.
  కాబట్టి, రెండు వేర్వేరు గణనల కోసం మొత్తం సగటును గణించడం ఒక నిఘంటువులో నిర్మాణం ఉందని మరియు రీడ్యూసర్ ప్రాథమికంగా ఈ విషయాన్ని చేస్తాడని మేము భావిస్తున్నాము.
  కాబట్టి, దీన్ని ఎలా గుర్తించాలో చూడాలనుకుంటున్నారా, అందువల్ల మాకు సమస్యను చూద్దాం.
  కాబట్టి, నాకు పేరు, లింగం మరియు జీతం అనే సమితి ఉంది; ప్రతి లింకు నుండి లింగ మరియు జీతం సేకరించేందుకు కావలసిన.
  నేను బహుళ మ్యాపర్కలిగి ఉంటే; కాబట్టి, నేను ఆ పదాన్ని తీసివేస్తాను మరియు ఒక ప్రత్యేక రెండు రకాలైన నిఘంటువు రకం వలె డంప్ చేస్తాను.
  ఒకటి రెండు రకాలైన విషయం; ఒకటి మనకు M మరియు f తో మరియు తగ్గింపు భాగంలో ఉన్న దానితో మనము మొత్తం మరియు average జీతం యొక్క మొత్తము మరియు జీతంను లెక్కించవచ్చు.
  కాబట్టి, మనం ఒక mapper dot py లేదా mapper గా చూస్తాము, కొన్ని python type code ను డాట్ చేస్తాము.
  కాబట్టి, మళ్ళీ నేను మళ్ళీ మళ్ళీ మళ్ళీ చేయాలనుకుంటున్నాను; ఈ కోడింగ్ భాషతో మీరు చేయగలగటం మరియు మనం చేయబోయేది ఏది కాదు; వాస్తవమైన పైథాన్  విషయంతో కొన్ని వాక్యనిర్మాణ సమస్య ఉండవచ్చు, కానీ సంభాషణ విషయంలో పట్టింపు లేదు, మీరు నిజంగానే దీన్ని అమలు చేయాలనుకుంటే వాస్తవిక వాక్యనిర్మాణ వాక్యనిర్మాణం అనుసరించాల్సి ఉంటుంది.
  కాబట్టి, ఇది సిజ్ డాట్ స్టాండ్ లో ఒక లైన్ కోసం విషయం; మనం ఏమి చేస్తున్నామో.
  కాబట్టి, ఇది కామాతో వేరు చేయబడుతుందని మేము పరిశీలిస్తున్నాము.
  కాబట్టి, నేను ఇప్పుడు వేరొక 0 కు సమానమైన పేరు, జీతం సాల్ కు ప్రాతినిధ్యం వహిస్తుంది; లైన్ 2 సృష్టిస్తున్నప్పుడు; లేదా మాపెర్ ఫేజ్ను ఉద్భవించడం, స్థానిక ఫైల్ వ్యవస్థలో డేటా.
  కాబట్టి, మనము ప్రింట్ కామా శాతం d.
  అప్పుడు, మేము ఏమి చేస్తాము? లింగం మరియు జీతం; ఇతర అర్థంలో ఈ వాక్యనిర్మాణం మీరు తనిఖీ చెయ్యాలి.
  ఇతర అర్ధంలో, మనం జీతం లేదా విషయం మరియు వేతన జీతం లోకి జీతం లో ప్రాథమికంగా లింగం డంప్ చేయండి; మీరు ఈ M ను మరియు వేతన భాగాన్ని ఉత్పత్తి చేయాలనుకుంటున్నట్లు మీరు చూస్తున్నట్లు మరియు మరొక విషయం ఏమిటంటే M లేదా F మరియు జీతం భాగం.
  కాబట్టి, తగ్గింపు దశలో; మనం దిగుమతి చేస్తాం. కాబట్టి, దీనిని నిర్వచించండి లేదా ఈ dict org అని పిలిచే sys లో లైన్ కోసం మేము తరగతి అని పిలుస్తాము.
  కాబట్టి, ఇది చదువుతున్నది ఏమిటి? ఇది ప్రాథమికంగా లింగ లేదా కీ విలువ మరియు విషయాలు విలువ లేదా ఇతర అర్ధంలో లింగం మరియు జీతం విలువలు  తో కీ విలువ భయం.
  కాబట్టి, మనకు ఆ పేరు లేదు, ఎందుకంటే ఈ ప్రత్యేక ప్రశ్నకు విషయం యొక్క పేరు అవసరం లేదు; లైన్ 1.
  కాబట్టి, ఇది ఇప్పటికే ఉన్నట్లయితే; అది అర్థం, అప్పుడు మీరు చదివాను ఒకసారి ఆర్గ్ ఆర్క్; కాబట్టి, మా లక్ష్యం ఏమిటి? కాబట్టి ప్రాథమికంగా లింగ విలువను, జీతం విలువకు జోడించడం ద్వారా జీతాలు పెంచాలి.
  కాబట్టి, ఇప్పటికే అక్కడ ఉంటే; అది ఏంటి అంటే; కాబట్టి, ఇప్పుడు నా నామమాత్రంగా తగ్గించేది నిఘంటువు లెక్కింపు, కీ విలువ జత. కాబట్టి, ఇప్పటికే ఉన్న లింగం ఉంటే మగ లేదా మహిళా, నేను ఎప్పుడైనా ఆ అంశాలను జోడించాను.
  ఇది లేకపోతే అది లేకపోతే; అంటే, ఈ ప్రాథమికంగా ప్రారంభంలో విషయం dict org ఉంది.
  సో, ఒక ఖాళీ విషయం తో ప్రారంభించడం; కాబట్టి ఇది వస్తున్నప్పుడు మొదటిసారి.
  కాబట్టి, మొదటిసారి అది వస్తోంది; అంటే, ఒక ఖాళీ విషయం.
  కాబట్టి, అది ఖాళీగా ఉంటే అది ప్రాథమికంగా ప్రారంభించడం; అప్పుడు జీతం చేర్చండి; అంటే, అది dict org dot కీల జీతంతో ప్రారంభించబడుతుంది; dict org మొత్తం మొత్తానికి సమానం జీతం సగటు; లింగం యొక్క లింగం ద్వారా లింగం విభజించబడింది.
  కాబట్టి, అది డిగ్క్ ఆర్గ్ లింగ మొత్తానికి సమానంగా సమానంగా మరియు మొత్తం జీతంతో సమానంగా ఉంటుంది.
  మరియు మనం ప్రాథమికంగా ఇతర విషయాలను Google లేదా GFA లేదా HDFS ఫైల్ సిస్టమ్కు తిరిగి వ్రాస్తాము.
  కేసు మాదిరిగా కామా లేదా టాబ్ ద్వారా వేరుచేయాలనుకుంటే; అది బహుశా పూర్ణాంకం అయితే లేదా అది ఒక ఫ్లోట్ మరియు అన్ని విషయాలు ఉంటే ఆ ఆధారంగా కావచ్చు.
  కాబట్టి, మేము ఈ లింగం మొత్తం సల్మరియు జీతం సగట వంటి కలిగి.
  కాబట్టి, చివరి ఉపరితల ఉపరితలంపై మేము ఏమి చేస్తాము.
  కాబట్టి, మేము త్వరగా పరిశీలించడానికి ప్రయత్నించినట్లయితే, మాపింగ్ ఫంక్షన్లో మనం ఏమి చేస్తున్నామో; మనము పేరు, లింగం మరియు జీతం వంటి మూడు విషయాలను కలిగి ఉన్నాయి.
  మా లక్ష్యం మ్యాపింగ్ విధులు; కాబట్టి, ఇది అన్ని మ్యాప్ను చూడడమే మనం చూద్దాం.
  ఇది లింగం M మరియు జీ జీ ఎఫ్ లేదా ఫెమ్ మరియు జీతం మరియు తగ్గింపుదారులతో కలిసి ఈ వేతనాలను ఉంచడం. 
  కాబట్టి, లింగం మరియు జీతం మరియు తగ్గింపుదారుని ప్రాథమికంగా మధ్యంతర ఫలితం గ్రహించి సగటు మరియు మొత్తాన్ని లెక్కించడం.
  కాబట్టి, ఇక్కడ ఆ ఆపరేషన్ ఉంది; కాబట్టి, ఇది ఒక ప్రత్యేకమైన పైథాన్ రకం, కొందరు వాక్యనిర్మాణ సమస్య ఉన్నందున నేను ఖచ్చితంగా కఠినమైన పైథాన్ను చెప్పలేదు.
  కానీ మీరు ఏదైనా అమలు చేయగలరు. 
  ఆలోచన నేను సమస్యను చిన్న సమాంతరంగా మ్యాపర్చే విభజించి ఆపై రెండవ దశలో విభజించాలి; తగ్గింపుదారు మరొక కీ విలువ జతకు ఉంచాడు.
  కాబట్టి, ఇన్పుట్ సెట్ నుండి కీ విలువ; కీ విలువ జత సమితికి, తగ్గించేవాడు ఆ కీ విలువ జత మరియు ఒక ఫంక్షన్ చాలు.
  ఈ సందర్భంలో సరాసరి లేదా మొత్తము మొత్తము, కీ విలువ జత యొక్క మరొక సమితికి మరియు చివరికి, అది HDFS జత లేదా GFS ఫైల్ సిస్టమ్ సరేకి వెళుతుంది.
  సో, మేము ఏమి ప్రయత్నించారు నేటి విషయం లో చూడండి; ఈ MapReduce విధులు సాధారణ సమస్యలు చెప్పటానికి; మనం మాప్ లో ఉంచవచ్చు మరియు విషయాలు తగ్గించవచ్చు ఎలా.
  మ్యాపర్లు ఈ సంఖ్య అందుబాటులో ఉన్నాయి; అనుమతించు వనరు యొక్క ప్రధానంగా లభ్యత మరియు మాస్టర్ నోడ్స్ దానిని ఎలా విభజించాలో మరియు తగ్గింపుదారుల సంఖ్య కూడా పదం ఆధారంగా ఉంటుంది.
  ఏ విధమైన ఫంక్షనల్ విషయాలు మీరు చేయాలనుకుంటున్నారో మరియు వారు మాస్టర్ నోడ్  ఉన్నట్లయితే, ఇది mappers యొక్క m సంఖ్యను మరియు రీడ్యూసర్ యొక్క సంఖ్యను విభజిస్తుంది.
  సమస్య, సమస్య యొక్క కార్యాచరణను విభజించటం అనేది రెండు దశల్లో అమలు చేయబడటం మరియు విభజన యొక్క ఈ విధమైన సమాంతర అమలును కలిగి ఉంటుంది.
  ధన్యవాదాలు.