பிக்டேட்டா: மேப்ரீட்யூஸ் பயன்பாடுகளை உருவாக்குவதற்கான நுட்பங்கள் மற்றும் உத்திகள்

5.1 வரைபடம் மட்டும் வேலை

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

நாம் நினைவில் வைத்துள்ளபடி, MapReduce ஆனது வரைபடம், ஷஃபிள் மற்றும் குறைப்பு நிலைகளைக் கொண்டுள்ளது. இந்த கட்டத்தில் தரவு வரிசைப்படுத்தப்படுவதால், ஒரு விதியாக, ஷஃபிள் நிலை நடைமுறைப் பணிகளில் மிகவும் கடினமானதாக மாறும். உண்மையில், வரைபட நிலை மட்டும் வழங்கக்கூடிய பல பணிகள் உள்ளன. அத்தகைய பணிகளின் எடுத்துக்காட்டுகள் இங்கே:

• தரவு வடிகட்டுதல் (உதாரணமாக, இணைய சேவையகப் பதிவுகளில் உள்ள "IP முகவரி 123.123.123.123 இலிருந்து அனைத்து பதிவுகளையும் கண்டுபிடி");
• தரவு மாற்றம் (“csv-logs இல் நெடுவரிசையை நீக்கு”);
• வெளிப்புற மூலத்திலிருந்து தரவை ஏற்றுதல் மற்றும் இறக்குதல் ("பதிவிலிருந்து எல்லா பதிவுகளையும் தரவுத்தளத்தில் செருகவும்").

அத்தகைய பணிகள் வரைபடத்தை மட்டும் பயன்படுத்தி தீர்க்கப்படுகின்றன. ஹடூப்பில் வரைபடம் மட்டும் பணியை உருவாக்கும் போது, ​​குறைப்பவர்களின் பூஜ்ஜிய எண்ணிக்கையைக் குறிப்பிட வேண்டும்:

ஹடூப்பில் வரைபடம்-மட்டும் பணி உள்ளமைவின் எடுத்துக்காட்டு:

job.setNumReduceTasks(0); 

hadoop jar hadoop-streaming.jar \ 
 -D mapred.reduce.tasks=0\ 
-input input_dir\ 
-output output_dir\ 
-mapper "python mapper.py"\ 
-file "mapper.py"

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

5.2 இணைக்கவும்

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

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

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

ஹடூப்பில் இணைப்பியைப் பயன்படுத்துதல்:

job.setMapperClass(TokenizerMapper.class); 
job.setCombinerClass(IntSumReducer.class); 
job.setReducerClass(IntSumReducer.class); 

hadoop jar hadoop-streaming.jar \ 
-input input_dir\ 
-output output_dir\ 
-mapper "python mapper.py"\ 
-reducer "python reducer.py"\ 
-combiner "python reducer.py"\ 
-file "mapper.py"\ 
-file "reducer.py"\

5.3 MapReduce பணி சங்கிலிகள்

ஒரு சிக்கலைத் தீர்க்க ஒரு MapReduce போதுமானதாக இல்லாத சூழ்நிலைகள் உள்ளன. எடுத்துக்காட்டாக, சற்று மாற்றியமைக்கப்பட்ட வேர்ட்கவுண்ட் பணியைக் கவனியுங்கள்: உரை ஆவணங்களின் தொகுப்பு உள்ளது, தொகுப்பில் 1 முதல் 1000 முறை வரை எத்தனை சொற்கள் நிகழ்ந்தன, 1001 முதல் 2000 வரை எத்தனை சொற்கள், 2001 முதல் 3000 வரை எத்தனை சொற்கள், மற்றும் பல. தீர்வுக்கு, எங்களுக்கு 2 MapReduce வேலைகள் தேவை:

• மாற்றியமைக்கப்பட்ட வார்த்தைகளின் எண்ணிக்கை, ஒவ்வொரு வார்த்தைக்கும் அது எந்த இடைவெளியில் விழுந்தது என்பதைக் கணக்கிடும்;
• முதல் MapReduce வெளியீட்டில் ஒவ்வொரு இடைவெளியும் எத்தனை முறை சந்தித்தன என்பதைக் கணக்கிடும் MapReduce.

போலி குறியீடு தீர்வு:

#map1 
def map(doc): 
for word in doc: 
yield word, 1

#reduce1 
def reduce(word, values): 
yield int(sum(values)/1000), 1 

#map2 
def map(doc): 
interval, cnt = doc.split() 
yield interval, cnt 

#reduce2 
def reduce(interval, values): 
yield interval*1000, sum(values) 

ஹடூப்பில் MapReduce பணிகளின் வரிசையை இயக்க, இரண்டாவது பணிக்கான உள்ளீடாக முதல் ஒன்றின் வெளியீட்டாகக் குறிப்பிடப்பட்ட கோப்புறையைக் குறிப்பிட்டு அவற்றை இயக்கினால் போதும்.

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

5.4 விநியோகிக்கப்பட்ட தற்காலிக சேமிப்பு

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

HDFS இல் சேமிக்கப்பட்ட கோப்புகள், உள்ளூர் கோப்புகள் (பணி தொடங்கப்பட்ட இயந்திரத்திற்கு உள்ளூர்) நீங்கள் சேர்க்கலாம். -file விருப்பத்தின் மூலம் mapper.py மற்றும் reducer.py கோப்புகளைச் சேர்ப்பதன் மூலம் ஹடூப் ஸ்ட்ரீமிங்கில் விநியோகிக்கப்பட்ட தற்காலிக சேமிப்பை எவ்வாறு பயன்படுத்துவது என்பதை நான் ஏற்கனவே மறைமுகமாகக் காட்டியுள்ளேன். உண்மையில், நீங்கள் mapper.py மற்றும் reducer.py ஆகியவற்றை மட்டும் சேர்க்க முடியாது, ஆனால் பொதுவாக தன்னிச்சையான கோப்புகளை சேர்க்கலாம், பின்னர் அவை உள்ளூர் கோப்புறையில் இருப்பதைப் போல பயன்படுத்தலாம்.

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

//Job configuration
JobConf job = new JobConf();
DistributedCache.addCacheFile(new URI("/myapp/lookup.dat#lookup.dat"),  job);
DistributedCache.addCacheArchive(new URI("/myapp/map.zip", job);
DistributedCache.addFileToClassPath(new Path("/myapp/mylib.jar"), job);
DistributedCache.addCacheArchive(new URI("/myapp/mytar.tar", job);
DistributedCache.addCacheArchive(new URI("/myapp/mytgz.tgz", job);

//example of usage in mapper-e:
public static class MapClass extends MapReduceBase
implements Mapper<K, V, K, V> {

 private Path[] localArchives;
 private Path[] localFiles;

 public void configure(JobConf job) {
   // get cached data from archives
   File f = new File("./map.zip/some/file/in/zip.txt");
 }

 public void map(K key, V value,
             	OutputCollector<K, V> output, Reporter reporter)
 throws IOException {
   // use data here
   // ...
   // ...
   output.collect(k, v);
 }
}

yarn  hadoop-streaming.jar\ 
-files mapper.py,reducer.py,some_cached_data.txt\ 
-input '/some/input/path' \ 
-output '/some/output/path' \  
-mapper 'python mapper.py' \ 
-reducer 'python reducer.py' \

import sys 
#just read file from local folder 
data = open('some_cached_data.txt').read() 
 
for line in sys.stdin() 
#processing input 
#use data here

5.5 சேர்வதைக் குறைக்கவும்

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

இரண்டு வலை சேவையகங்களின் பதிவுகள் உள்ளன, ஒவ்வொரு பதிவும் இப்படி இருக்கும்:

t\t

பதிவு துணுக்கு உதாரணம்:

1446792139	
178.78.82.1	
/sphingosine/unhurrying.css 
1446792139	
126.31.163.222	
/accentually.js 
1446792139	
154.164.149.83	
/pyroacid/unkemptly.jpg 
1446792139	
202.27.13.181	
/Chawia.js 
1446792139	
67.123.248.174	
/morphographical/dismain.css 
1446792139	
226.74.123.135	
/phanerite.php 
1446792139	
157.109.106.104	
/bisonant.css

ஒவ்வொரு IP முகவரிக்கும் 2 சேவையகங்களில் எந்தெந்த சேவையகம் அடிக்கடி சென்றது என்பதைக் கணக்கிடுவது அவசியம். முடிவு வடிவத்தில் இருக்க வேண்டும்:

\t

முடிவின் ஒரு பகுதியின் எடுத்துக்காட்டு:

178.78.82.1	
first 
126.31.163.222	
second 
154.164.149.83	
second 
226.74.123.135	
first

துரதிர்ஷ்டவசமாக, தொடர்புடைய தரவுத்தளங்களைப் போலல்லாமல், பொதுவாக, இரண்டு பதிவுகளை விசை மூலம் இணைப்பது (இந்த விஷயத்தில், ஐபி முகவரி மூலம்) மிகவும் கடினமான செயல் மற்றும் 3 MapReduce மற்றும் Reduce Join முறையைப் பயன்படுத்தி தீர்க்கப்படுகிறது:

ReduceJoin இது போன்ற வேலை செய்கிறது:

1) ஒவ்வொரு உள்ளீட்டுப் பதிவுகளுக்கும், ஒரு தனி MapReduce (வரைபடம் மட்டும்) தொடங்கப்பட்டு, உள்ளீட்டுத் தரவை பின்வரும் படிவத்திற்கு மாற்றுகிறது:

key -> (type, value

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

2) இரண்டு MapReduces இன் வெளியீடுகளும் 3வது MapReduce இன் உள்ளீட்டிற்கு வழங்கப்படுகின்றன, இது உண்மையில் தொழிற்சங்கத்தை செய்கிறது. இந்த MapReduce ஆனது உள்ளீட்டை வெறுமனே நகலெடுக்கும் வெற்று மேப்பரைக் கொண்டுள்ளது. அடுத்து, ஷஃபிள் தரவை விசைகளாக சிதைத்து, அதை உள்ளீடாக குறைப்பவருக்கு ஊட்டுகிறது:

key -> [(type, value)]

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

5.6 MapJoins

ReduceJoin முறையானது விசை மூலம் இரண்டு பதிவுகளை இணைக்கும் பொதுவான வழக்கை விவரிக்கிறது. இருப்பினும், ஒரு சிறப்பு வழக்கு உள்ளது, இதில் பணியை கணிசமாக எளிதாக்கலாம் மற்றும் துரிதப்படுத்தலாம். பதிவுகளில் ஒன்று மற்றதை விட கணிசமாக சிறியதாக இருக்கும் சந்தர்ப்பம் இதுவாகும். பின்வரும் சிக்கலைக் கவனியுங்கள்:

2 பதிவுகள் உள்ளன. முதல் பதிவில் இணைய சேவையகப் பதிவு உள்ளது (முந்தைய பணியைப் போலவே), இரண்டாவது கோப்பில் (100kb அளவு) URL-> தீம் பொருத்தம் உள்ளது. உதாரணம் 2வது கோப்பு:

/toyota.php 	
auto 
/football/spartak.html 	
sport 
/cars 	
auto 
/finances/money 	
business

ஒவ்வொரு ஐபி முகவரிக்கும், இந்த ஐபி முகவரியிலிருந்து எந்த வகையின் பக்கங்கள் அடிக்கடி ஏற்றப்பட்டன என்பதைக் கணக்கிடுவது அவசியம்.

இந்த வழக்கில், நாமும் URL மூலம் 2 பதிவுகளை இணைக்க வேண்டும். இருப்பினும், இந்த விஷயத்தில், நாம் 3 MapReduce ஐ இயக்க வேண்டியதில்லை, ஏனெனில் இரண்டாவது பதிவு நினைவகத்தில் முழுமையாக பொருந்தும். 1வது MapReduce ஐப் பயன்படுத்தி சிக்கலைத் தீர்க்க, நாம் இரண்டாவது பதிவை விநியோகிக்கப்பட்ட தற்காலிக சேமிப்பில் ஏற்றலாம், மேலும் மேப்பர் துவக்கப்படும்போது, ​​அதை நினைவகத்தில் படிக்கவும், அதை -> தலைப்பு அகராதியில் வைக்கவும்.

மேலும், சிக்கல் பின்வருமாறு தீர்க்கப்படுகிறது:

வரைபடம்:

# find the subject of each of the pages of the first log 
input_line -> [ip,  topic] 

குறைக்க:

Ip -> [topics] -> [ip, most_popular_topic]

குறைப்பு ஒரு ஐபி மற்றும் அனைத்து தலைப்புகளின் பட்டியலை உள்ளீடாகப் பெறுகிறது, இது எந்த தலைப்புகளில் அடிக்கடி சந்தித்தது என்பதைக் கணக்கிடுகிறது. எனவே, 1வது MapReduce ஐப் பயன்படுத்தி பணி தீர்க்கப்படுகிறது, மேலும் உண்மையான இணைப்பானது பொதுவாக வரைபடத்தில் நடைபெறுகிறது (எனவே, விசையின் மூலம் கூடுதல் ஒருங்கிணைப்பு தேவையில்லை என்றால், MapOnly வேலை வழங்கப்படலாம்):