hadoopmapreduce演算法

⑴ hadoop和maprece是一種什麼關系

hadoop是google的雲計算系統的開源實現，谷歌集群系統主要包括三個部分：分布式文件系統GFS，分布式並行計算模型map/rece，以及分布式資料庫Bigtable，hadoop也實現了這三個，GFS對應HDFS，hadoop的map/rece對應谷歌的map/rece模型，Hbase對應Bigtable。
也就是map/rece是谷歌提出的一種雲計算模型，hadoop用java開源實現了

⑵ Hadoop和MapRece究竟分別是做什麼用的

Hadoop是用來開發分布式程序的架構，是一個由Apache基金會所開發的分布式系統基礎架構。用戶可以在不了解分布式底層細節的情況下，開發分布式程序。

MapRece是用來做大規模並行數據處理的數據模型。方便了編程人員在不會分布式並行編程的情況下，將自己的程序運行在分布式系統上。

(2)hadoopmaprece演算法擴展閱讀

Hadoop是一個能夠讓用戶輕松架構和使用的分布式計算平台。用戶可以輕松地在Hadoop上開發和運行處理海量數據的應用程序。主要有以下幾個優點 ：

1、高可靠性。Hadoop按位存儲和處理數據的能力值得人們信賴 。

2、高擴展性。Hadoop是在可用的計算機集簇間分配數據並完成計算任務的，這些集簇可以方便地擴展到數以千計的節點中 。

3、高效性。Hadoop能夠在節點之間動態地移動數據，並保證各個節點的動態平衡，因此處理速度非常快 。

4、高容錯性。Hadoop能夠自動保存數據的多個副本，並且能夠自動將失敗的任務重新分配。

5、低成本。與一體機、商用數據倉庫以及QlikView、Yonghong Z-Suite等數據集市相比，hadoop是開源的，項目的軟體成本因此會大大降低。

⑶ 請簡要描述Hadoop計算框架MapRece的工作原理

分為2個步驟，map和rece，map專門負責對每個數據獨立地同時地打標簽，框架會對相同標簽的數據分成一組，rece對分好的那些組數據做累計計算。我們只要分別實現map和rece就可以了

⑷ hadoop maprece可以完成下圖功能嗎需要怎麼實現

把A作為map輸出的key，value為自己實現的類似vectorwritable的類存 a c
rece時候有sum1，sum2……sumN分別為vectorwritable相同index的和，最後各除values.size
rece的輸出value也為v e c to r w ri ta b le

⑸ hadoop maprece 進程有哪些

首先hadoop框架要求程序員將函數分成兩部分，即map和rece函數。map階段：就是將輸入通過map函數處理得出中間結果並通過hadoop框架分配到不同的rece。rece階段：就是將中間結果通過rece函數處理得到最後的結果。 以wordcount為例，在map階段，map函數在每個單詞後面加上一個1；在rece階段，rece函數將相同單詞後面的1都加起來。其中hadoop框架實現過程中的排序，分配等，當然這些也可以通過自定義的函數來控制。

⑹ Hadoop，MapRece，YARN和Spark的區別與聯系

（1） Hadoop 1.0

第一代Hadoop，由分布式存儲系統HDFS和分布式計算框架MapRece組成，其中，HDFS由一個NameNode和多個DataNode組成，MapRece由一個JobTracker和多個TaskTracker組成，對應Hadoop版本為Hadoop 1.x和0.21.X，0.22.x。

（2） Hadoop 2.0

第二代Hadoop，為克服Hadoop 1.0中HDFS和MapRece存在的各種問題而提出的。針對Hadoop 1.0中的單NameNode制約HDFS的擴展性問題，提出了HDFS Federation，它讓多個NameNode分管不同的目錄進而實現訪問隔離和橫向擴展；針對Hadoop 1.0中的MapRece在擴展性和多框架支持方面的不足，提出了全新的資源管理框架YARN(Yet Another Resource Negotiator)，它將JobTracker中的資源管理和作業控制功能分開，分別由組件ResourceManager和ApplicationMaster實現，其中，ResourceManager負責所有應用程序的資源分配，而ApplicationMaster僅負責管理一個應用程序。對應Hadoop版本為Hadoop 0.23.x和2.x。

（3） MapRece 1.0或者MRv1（MapReceversion 1）

第一代MapRece計算框架，它由兩部分組成：編程模型（programming model）和運行時環境（runtime environment）。它的基本編程模型是將問題抽象成Map和Rece兩個階段，其中Map階段將輸入數據解析成key/value，迭代調用map()函數處理後，再以key/value的形式輸出到本地目錄，而Rece階段則將key相同的value進行規約處理，並將最終結果寫到HDFS上。它的運行時環境由兩類服務組成：JobTracker和TaskTracker，其中，JobTracker負責資源管理和所有作業的控制，而TaskTracker負責接收來自JobTracker的命令並執行它。

（4）MapRece 2.0或者MRv2（MapRece version 2）或者NextGen MapRec

MapRece 2.0或者MRv2具有與MRv1相同的編程模型，唯一不同的是運行時環境。MRv2是在MRv1基礎上經加工之後，運行於資源管理框架YARN之上的MRv1，它不再由JobTracker和TaskTracker組成，而是變為一個作業控制進程ApplicationMaster，且ApplicationMaster僅負責一個作業的管理，至於資源的管理，則由YARN完成。

簡而言之，MRv1是一個獨立的離線計算框架，而MRv2則是運行於YARN之上的MRv1。

（5）Hadoop-MapRece（一個離線計算框架）

Hadoop是google分布式計算框架MapRece與分布式存儲系統GFS的開源實現，由分布式計算框架MapRece和分布式存儲系統HDFS（Hadoop Distributed File System）組成，具有高容錯性，高擴展性和編程介面簡單等特點，現已被大部分互聯網公司採用。

（6）Hadoop-YARN(Hadoop 2.0的一個分支，實際上是一個資源管理系統)

YARN是Hadoop的一個子項目（與MapRece並列），它實際上是一個資源統一管理系統，可以在上面運行各種計算框架（包括MapRece、Spark、Storm、MPI等）。當前Hadoop版本比較混亂，讓很多用戶不知所措。實際上，當前Hadoop只有兩個版本：Hadoop 1.0和Hadoop 2.0，其中，Hadoop 1.0由一個分布式文件系統HDFS和一個離線計算框架MapRece組成，而Hadoop 2.0則包含一個支持NameNode橫向擴展的HDFS，一個資源管理系統YARN和一個運行在YARN上的離線計算框架MapRece。相比於Hadoop 1.0，Hadoop 2.0功能更加強大，且具有更好的擴展性、性能，並支持多種計算框架。Borg/YARN/Mesos/Torca/Corona一類系統可以為公司構建一個內部的生態系統，所有應用程序和服務可以「和平而友好」地運行在該生態系統上。有了這類系統之後，你不必憂愁使用Hadoop的哪個版本，是Hadoop 0.20.2還是 Hadoop 1.0，你也不必為選擇何種計算模型而苦惱，因此各種軟體版本，各種計算模型可以一起運行在一台「超級計算機」上了。

從開源角度看，YARN的提出，從一定程度上弱化了多計算框架的優劣之爭。YARN是在Hadoop MapRece基礎上演化而來的，在MapRece時代，很多人批評MapRece不適合迭代計算和流失計算，於是出現了Spark和Storm等計算框架，而這些系統的開發者則在自己的網站上或者論文里與MapRece對比，鼓吹自己的系統多麼先進高效，而出現了YARN之後，則形勢變得明朗：MapRece只是運行在YARN之上的一類應用程序抽象，Spark和Storm本質上也是，他們只是針對不同類型的應用開發的，沒有優劣之別，各有所長，合並共處，而且，今後所有計算框架的開發，不出意外的話，也應是在YARN之上。這樣，一個以YARN為底層資源管理平台，多種計算框架運行於其上的生態系統誕生了。目前spark是一個非常流行的內存計算（或者迭代式計算，DAG計算）框架，在MapRece因效率低下而被廣為詬病的今天，spark的出現不禁讓大家眼前一亮。

從架構和應用角度上看，spark是一個僅包含計算邏輯的開發庫（盡管它提供個獨立運行的master/slave服務，但考慮到穩定後以及與其他類型作業的繼承性，通常不會被採用），而不包含任何資源管理和調度相關的實現，這使得spark可以靈活運行在目前比較主流的資源管理系統上，典型的代表是mesos和yarn，我們稱之為「spark on mesos」和「spark on yarn」。將spark運行在資源管理系統上將帶來非常多的收益，包括：與其他計算框架共享集群資源；資源按需分配，進而提高集群資源利用率等。

FrameWork On YARN

運行在YARN上的框架，包括MapRece-On-YARN, Spark-On-YARN, Storm-On-YARN和Tez-On-YARN。

（1）MapRece-On-YARN：YARN上的離線計算；

（2）Spark-On-YARN：YARN上的內存計算；

（3）Storm-On-YARN：YARN上的實時/流式計算；

（4）Tez-On-YARN：YARN上的DAG計算

⑺ 如何在hadoop環境下執行maprece任務

之前學習了一段時間的hadoop的相關知識 ，學習理論基礎的時候要同時實際操作才能對它更熟練，廢話不多說來說說在hadoop上運行一個最簡單的wordscount的程序

首先我先貼上這個程序的源代碼 供大家參考 代碼分為三個部分寫的Run、 map階段、 rece階段

Map：

[java]view plain

• <spanstyle="font-family:KaiTi_GB2312;font-size:18px;">packagewordsCount;

• importjava.io.IOException;

• importjava.util.StringTokenizer;

• importorg.apache.hadoop.io.IntWritable;

• importorg.apache.hadoop.io.LongWritable;

• importorg.apache.hadoop.io.Text;

• importorg.apache.hadoop.maprece.Mapper;

• <LongWritable,Text,Text,IntWritable>{

• @Override

• protectedvoidmap(LongWritablekey,Textvalue,Mapper<LongWritable,Text,Text,IntWritable>.Contextcontext)

• throwsIOException,InterruptedException{

• Stringline=value.toString();

• StringTokenizerst=newStringTokenizer(line);

• while(st.hasMoreTokens()){

• Stringword=st.nextToken();

• context.write(newText(word),newIntWritable(1));

• }

• }

• }</span>


Rece：

[java]view plain

• <spanstyle="font-family:KaiTi_GB2312;font-size:18px;">packagewordsCount;

• importjava.io.IOException;

• importorg.apache.hadoop.io.IntWritable;

• importorg.apache.hadoop.io.Text;

• importorg.apache.hadoop.maprece.Recer;

• <Text,IntWritable,Text,IntWritable>{

• @Override

• protectedvoidrece(Textkey,Iterable<IntWritable>iterator,

• Recer<Text,IntWritable,Text,IntWritable>.Contextcontext)throwsIOException,InterruptedException{

• //TODO自動生成的方法存根

• intsum=0;

• for(IntWritablei:iterator){

• sum=sum+i.get();

• }

• context.write(key,newIntWritable(sum));

• }

• }</span>

Run：

[java]view plain

• <spanstyle="font-family:KaiTi_GB2312;font-size:18px;">packagewordsCount;

• importorg.apache.hadoop.conf.Configuration;

• importorg.apache.hadoop.fs.Path;

• importorg.apache.hadoop.io.IntWritable;

• importorg.apache.hadoop.io.Text;

• importorg.apache.hadoop.maprece.Job;

• importorg.apache.hadoop.maprece.lib.input.FileInputFormat;

• importorg.apache.hadoop.maprece.lib.input.TextInputFormat;

• importorg.apache.hadoop.maprece.lib.output.FileOutputFormat;

• importorg.apache.hadoop.maprece.lib.output.TextOutputFormat;

• publicclassRun{

• publicstaticvoidmain(String[]args)throwsException{

• //TODO自動生成的方法存根

• Configurationconfiguration=newConfiguration();

• Jobjob=newJob(configuration);

• job.setJarByClass(Run.class);

• job.setJobName("wordscount!");

• job.setOutputKeyClass(Text.class);

• job.setOutputValueClass(IntWritable.class);

• job.setInputFormatClass(TextInputFormat.class);

• job.setOutputFormatClass(TextOutputFormat.class);

• job.setMapperClass(WordsMapper.class);

• job.setRecerClass(WordsRece.class);

• FileInputFormat.addInputPath(job,newPath("hdfs://192.168.1.111:9000/user/input/wc/"));

• FileOutputFormat.setOutputPath(job,newPath("hdfs://192.168.1.111:9000/user/result/"));

• job.waitForCompletion(true);

• }

• }</span>


Run裡面的輸入和輸出路徑根據自己的來修改

這個程序就不用去講解了吧 到處都能找到

首先在hadoop上運行這個程序用兩個方法

方法一：將自己的編譯軟體與hadoop相連（我用的是MyEclipse去鏈接hadoop），直接運行程序。MyEclipse連接hadoop的教程待會我會在文章結尾處給出一個鏈接供大家參考。




查看結果你可通過在你的Eclipse連接好hadoop查看，還可以通過在hdfs文件系統的網頁去查看（localhost：50070）。

還有一個很重要的一步就是，運行之前保證你的hadoop已經啟動了，可以通過jps來查看你的進程中是否已經啟動hadoop集群

⑻ hadoop的maprece常見演算法案例有幾種

基本MapRece模式

計數與求和
問題陳述:
有許多文檔，每個文檔都有一些欄位組成。需要計算出每個欄位在所有文檔中的出現次數或者這些欄位的其他什麼統計值。例如，給定一個log文件，其中的每條記錄都包含一個響應時間，需要計算出平均響應時間。
解決方案:
讓我們先從簡單的例子入手。在下面的代碼片段里，Mapper每遇到指定詞就把頻次記1，Recer一個個遍歷這些詞的集合然後把他們的頻次加和。

1 class Mapper
2 method Map(docid id, doc d)
3 for all term t in doc d do
4 Emit(term t, count 1)
5
6 class Recer
7 method Rece(term t, counts [c1, c2,...])
8 sum = 0
9 for all count c in [c1, c2,...] do
10 sum = sum + c
11 Emit(term t, count sum)

這種方法的缺點顯而易見，Mapper提交了太多無意義的計數。它完全可以通過先對每個文檔中的詞進行計數從而減少傳遞給Recer的數據量:

1 class Mapper
2 method Map(docid id, doc d)
3 H = new AssociativeArray
4 for all term t in doc d do
5 H{t} = H{t} + 1
6 for all term t in H do
7 Emit(term t, count H{t})

如果要累計計數的的不只是單個文檔中的內容，還包括了一個Mapper節點處理的所有文檔，那就要用到Combiner了:

1 class Mapper
2 method Map(docid id, doc d)
3 for all term t in doc d do
4 Emit(term t, count 1)
5
6 class Combiner
7 method Combine(term t, [c1, c2,...])
8 sum = 0
9 for all count c in [c1, c2,...] do
10 sum = sum + c
11 Emit(term t, count sum)
12
13 class Recer
14 method Rece(term t, counts [c1, c2,...])
15 sum = 0
16 for all count c in [c1, c2,...] do
17 sum = sum + c
18 Emit(term t, count sum)

應用：Log 分析, 數據查詢

整理歸類

問題陳述:
有一系列條目，每個條目都有幾個屬性，要把具有同一屬性值的條目都保存在一個文件里，或者把條目按照屬性值分組。 最典型的應用是倒排索引。
解決方案：
解決方案很簡單。 在 Mapper 中以每個條目的所需屬性值作為 key，其本身作為值傳遞給 Recer。 Recer 取得按照屬性值分組的條目，然後可以處理或者保存。如果是在構建倒排索引，那麼 每個條目相當於一個詞而屬性值就是詞所在的文檔ID。
應用：倒排索引， ETL
過濾 (文本查找)，解析和校驗
問題陳述:
假設有很多條記錄，需要從其中找出滿足某個條件的所有記錄，或者將每條記錄傳換成另外一種形式（轉換操作相對於各條記錄獨立，即對一條記錄的操作與其他記錄無關）。像文本解析、特定值抽取、格式轉換等都屬於後一種用例。
解決方案:
非常簡單，在Mapper 里逐條進行操作，輸出需要的值或轉換後的形式。
應用：日誌分析，數據查詢，ETL，數據校驗

分布式任務執行

問題陳述:
大型計算可以分解為多個部分分別進行然後合並各個計算的結果以獲得最終結果。
解決方案: 將數據切分成多份作為每個 Mapper 的輸入，每個Mapper處理一份數據，執行同樣的運算，產生結果，Recer把多個Mapper的結果組合成一個。
案例研究： 數字通信系統模擬
像 WiMAX 這樣的數字通信模擬軟體通過系統模型來傳輸大量的隨機數據，然後計算傳輸中的錯誤幾率。 每個 Mapper 處理樣本 1/N 的數據，計算出這部分數據的錯誤率，然後在 Recer 里計算平均錯誤率。
應用：工程模擬，數字分析，性能測試
排序
問題陳述:
有許多條記錄，需要按照某種規則將所有記錄排序或是按照順序來處理記錄。
解決方案: 簡單排序很好辦 – Mappers 將待排序的屬性值為鍵，整條記錄為值輸出。 不過實際應用中的排序要更加巧妙一點， 這就是它之所以被稱為MapRece 核心的原因（「核心」是說排序？因為證明Hadoop計算能力的實驗是大數據排序？還是說Hadoop的處理過程中對key排序的環節？）。在實踐中，常用組合鍵來實現二次排序和分組。
MapRece 最初只能夠對鍵排序， 但是也有技術利用可以利用Hadoop 的特性來實現按值排序。想了解的話可以看這篇博客。
按照BigTable的概念，使用 MapRece來對最初數據而非中間數據排序，也即保持數據的有序狀態更有好處，必須注意這一點。換句話說，在數據插入時排序一次要比在每次查詢數據的時候排序更高效。
應用：ETL，數據分析

非基本 MapRece 模式

迭代消息傳遞 (圖處理)

問題陳述：
假設一個實體網路，實體之間存在著關系。 需要按照與它比鄰的其他實體的屬性計算出一個狀態。這個狀態可以表現為它和其它節點之間的距離， 存在特定屬性的鄰接點的跡象， 鄰域密度特徵等等。
解決方案：
網路存儲為系列節點的結合，每個節點包含有其所有鄰接點ID的列表。按照這個概念，MapRece 迭代進行，每次迭代中每個節點都發消息給它的鄰接點。鄰接點根據接收到的信息更新自己的狀態。當滿足了某些條件的時候迭代停止，如達到了最大迭代次數（網路半徑）或兩次連續的迭代幾乎沒有狀態改變。從技術上來看，Mapper 以每個鄰接點的ID為鍵發出信息，所有的信息都會按照接受節點分組，recer 就能夠重算各節點的狀態然後更新那些狀態改變了的節點。下面展示了這個演算法：

1 class Mapper
2 method Map(id n, object N)
3 Emit(id n, object N)
4 for all id m in N.OutgoingRelations do
5 Emit(id m, message getMessage(N))
6
7 class Recer
8 method Rece(id m, [s1, s2,...])
9 M = null
10 messages = []
11 for all s in [s1, s2,...] do
12 if IsObject(s) then
13 M = s
14 else // s is a message
15 messages.add(s)
16 M.State = calculateState(messages)
17 Emit(id m, item M)

一個節點的狀態可以迅速的沿著網路傳全網，那些被感染了的節點又去感染它們的鄰居，整個過程就像下面的圖示一樣：

案例研究： 沿分類樹的有效性傳遞
問題陳述：
這個問題來自於真實的電子商務應用。將各種貨物分類，這些類別可以組成一個樹形結構，比較大的分類（像男人、女人、兒童）可以再分出小分類（像男褲或女裝），直到不能再分為止（像男式藍色牛仔褲）。這些不能再分的基層類別可以是有效（這個類別包含有貨品）或者已無效的（沒有屬於這個分類的貨品）。如果一個分類至少含有一個有效的子分類那麼認為這個分類也是有效的。我們需要在已知一些基層分類有效的情況下找出分類樹上所有有效的分類。
解決方案：
這個問題可以用上一節提到的框架來解決。我們咋下面定義了名為 getMessage和 calculateState 的方法：

1 class N
2 State in {True = 2, False = 1, null = 0},
3 initialized 1 or 2 for end-of-line categories, 0 otherwise
4 method getMessage(object N)
5 return N.State
6 method calculateState(state s, data [d1, d2,...])
7 return max( [d1, d2,...] )

案例研究：廣度優先搜索
問題陳述：需要計算出一個圖結構中某一個節點到其它所有節點的距離。
解決方案： Source源節點給所有鄰接點發出值為0的信號，鄰接點把收到的信號再轉發給自己的鄰接點，每轉發一次就對信號值加1：

1 class N
2 State is distance,
3 initialized 0 for source node, INFINITY for all other nodes
4 method getMessage(N)
5 return N.State + 1
6 method calculateState(state s, data [d1, d2,...])
7 min( [d1, d2,...] )

案例研究：網頁排名和 Mapper 端數據聚合
這個演算法由Google提出，使用權威的PageRank演算法，通過連接到一個網頁的其他網頁來計算網頁的相關性。真實演算法是相當復雜的，但是核心思想是權重可以傳播，也即通過一個節點的各聯接節點的權重的均值來計算節點自身的權重。

1 class N
2 State is PageRank
3 method getMessage(object N)
4 return N.State / N.OutgoingRelations.size()
5 method calculateState(state s, data [d1, d2,...])
6 return ( sum([d1, d2,...]) )

要指出的是上面用一個數值來作為評分實際上是一種簡化，在實際情況下，我們需要在Mapper端來進行聚合計算得出這個值。下面的代碼片段展示了這個改變後的邏輯 （針對於 PageRank 演算法）：

1 class Mapper
2 method Initialize
3 H = new AssociativeArray
4 method Map(id n, object N)
5 p = N.PageRank / N.OutgoingRelations.size()
6 Emit(id n, object N)
7 for all id m in N.OutgoingRelations do
8 H{m} = H{m} + p
9 method Close
10 for all id n in H do
11 Emit(id n, value H{n})
12
13 class Recer
14 method Rece(id m, [s1, s2,...])
15 M = null
16 p = 0
17 for all s in [s1, s2,...] do
18 if IsObject(s) then
19 M = s
20 else
21 p = p + s
22 M.PageRank = p
23 Emit(id m, item M)

應用：圖分析，網頁索引

值去重 （對唯一項計數）
問題陳述: 記錄包含值域F和值域 G，要分別統計相同G值的記錄中不同的F值的數目 (相當於按照 G分組).
這個問題可以推而廣之應用於分面搜索（某些電子商務網站稱之為Narrow Search）
Record 1: F=1, G={a, b}
Record 2: F=2, G={a, d, e}
Record 3: F=1, G={b}
Record 4: F=3, G={a, b}

Result:
a -> 3 // F=1, F=2, F=3
b -> 2 // F=1, F=3
d -> 1 // F=2
e -> 1 // F=2

解決方案 I:
第一種方法是分兩個階段來解決這個問題。第一階段在Mapper中使用F和G組成一個復合值對，然後在Recer中輸出每個值對，目的是為了保證F值的唯一性。在第二階段，再將值對按照G值來分組計算每組中的條目數。
第一階段：

1 class Mapper
2 method Map(null, record [value f, categories [g1, g2,...]])
3 for all category g in [g1, g2,...]
4 Emit(record [g, f], count 1)
5
6 class Recer
7 method Rece(record [g, f], counts [n1, n2, ...])
8 Emit(record [g, f], null )

第二階段：

1 class Mapper
2 method Map(record [f, g], null)
3 Emit(value g, count 1)
4
5 class Recer
6 method Rece(value g, counts [n1, n2,...])
7 Emit(value g, sum( [n1, n2,...] ) )

解決方案 II:
第二種方法只需要一次MapRece 即可實現，但擴展性不強。演算法很簡單-Mapper 輸出值和分類，在Recer里為每個值對應的分類去重然後給每個所屬的分類計數加1，最後再在Recer結束後將所有計數加和。這種方法適用於只有有限個分類，而且擁有相同F值的記錄不是很多的情況。例如網路日誌處理和用戶分類，用戶的總數很多，但是每個用戶的事件是有限的，以此分類得到的類別也是有限的。值得一提的是在這種模式下可以在數據傳輸到Recer之前使用Combiner來去除分類的重復值。

1 class Mapper
2 method Map(null, record [value f, categories [g1, g2,...] )
3 for all category g in [g1, g2,...]
4 Emit(value f, category g)
5
6 class Recer
7 method Initialize
8 H = new AssociativeArray : category -> count
9 method Rece(value f, categories [g1, g2,...])
10 [g1', g2',..] = ExcludeDuplicates( [g1, g2,..] )
11 for all category g in [g1', g2',...]
12 H{g} = H{g} + 1
13 method Close
14 for all category g in H do
15 Emit(category g, count H{g})

應用：日誌分析，用戶計數
互相關
問題陳述：有多個各由若干項構成的組，計算項兩兩共同出現於一個組中的次數。假如項數是N，那麼應該計算N*N。
這種情況常見於文本分析（條目是單詞而元組是句子），市場分析（購買了此物的客戶還可能購買什麼）。如果N*N小到可以容納於一台機器的內存，實現起來就比較簡單了。
配對法
第一種方法是在Mapper中給所有條目配對，然後在Recer中將同一條目對的計數加和。但這種做法也有缺點：
使用 combiners 帶來的的好處有限，因為很可能所有項對都是唯一的
不能有效利用內存

1 class Mapper
2 method Map(null, items [i1, i2,...] )
3 for all item i in [i1, i2,...]
4 for all item j in [i1, i2,...]
5 Emit(pair [i j], count 1)
6
7 class Recer
8 method Rece(pair [i j], counts [c1, c2,...])
9 s = sum([c1, c2,...])
10 Emit(pair[i j], count s)

Stripes Approach（條方法？不知道這個名字怎麼理解）
第二種方法是將數據按照pair中的第一項來分組，並維護一個關聯數組，數組中存儲的是所有關聯項的計數。The second approach is to group data by the first item in pair and maintain an associative array (「stripe」) where counters for all adjacent items are accumulated. Recer receives all stripes for leading item i, merges them, and emits the same result as in the Pairs approach.
中間結果的鍵數量相對較少，因此減少了排序消耗。
可以有效利用 combiners。
可在內存中執行，不過如果沒有正確執行的話也會帶來問題。
實現起來比較復雜。
一般來說， 「stripes」 比 「pairs」 更快

1 class Mapper
2 method Map(null, items [i1, i2,...] )
3 for all item i in [i1, i2,...]
4 H = new AssociativeArray : item -> counter
5 for all item j in [i1, i2,...]
6 H{j} = H{j} + 1
7 Emit(item i, stripe H)
8
9 class Recer
10 method Rece(item i, stripes [H1, H2,...])
11 H = new AssociativeArray : item -> counter
12 H = merge-sum( [H1, H2,...] )
13 for all item j in H.keys()
14 Emit(pair [i j], H{j})

應用：文本分析，市場分析
參考資料：Lin J. Dyer C. Hirst G. Data Intensive Processing MapRece
用MapRece 表達關系模式
在這部分我們會討論一下怎麼使用MapRece來進行主要的關系操作。
篩選（Selection）

1 class Mapper
2 method Map(rowkey key, tuple t)
3 if t satisfies the predicate
4 Emit(tuple t, null)

投影（Projection）
投影只比篩選稍微復雜一點，在這種情況下我們可以用Recer來消除可能的重復值。

1 class Mapper
2 method Map(rowkey key, tuple t)
3 tuple g = project(t) // extract required fields to tuple g
4 Emit(tuple g, null)
5
6 class Recer

⑼ hadoop和maprece是一種什麼關系

hadoop是依據maprece的原理，用Java語言實現的分布式處理機制。

Hadoop是一個能夠對大量數據進行分布式處理的軟體框架，實現了Google的MapRece編程模型和框架，能夠把應用程序分割成許多的小的工作單元，並把這些單元放到任何集群節點上執行。

MapRece是Hadoop中的一個數據運算核心模塊，MapRece通過JobClient生成任務運行文件，並在JobTracker進行調度指派TaskTracker完成任務。

(9)hadoopmaprece演算法擴展閱讀

1、MapRece分布式計算框架原型：

MapRece分布式計算模型是由Google提出，主要用於搜索領域，解決海量數據的計算問題Apache對其做了開源實現，整合在hadoop中實現通用分布式數據計算。

MR由兩個階段組成：Map和Rece，用戶只需要實現map()和rece()兩個函數，即可實現分布式計算，非常簡單。大大簡化了分布式並發處理程序的開發。

Map階段就是進行分段處理。

Rece階段就是進行匯總處理。匯總之後還可以進行數據的一系列美化操作，然後再輸出。

2、MapRece組件介紹：

JobClient：用於把用戶的作業任務生成Job的運行包，並存放到HDFS中。

JobinProgress：把Job運行包分解成MapTask和ReceTask並存放於TaskTracker中。

JobTracker(Master)：進行調度管理TaskTracker執行任務。

TaskTracker(Slave)：執行分配下來的Map計算或Rece計算任務。

⑽ Hadoop MapRee是如何實現計算向數據靠攏

大規模數據處理時，MapRece在三個層面上的基本構思：如何對付大數據處理：分而治之。對相互間不具有計算依賴關系的大數據，實現並行最自然的辦法就是採取分而治之的策略。上升到抽象模型：Mapper與Recer。MPI等並行計算方法缺少高層並行編程模型，為了克服這一缺陷，MapRece借鑒了Lisp函數式語言中的思想，用Map和Rece兩個函數提供了高層的並行編程抽象模型。上升到構架：統一構架，為程序員隱藏系統層細節。MPI等並行計算方法缺少統一的計算框架支持，程序員需要考慮數據存儲、劃分、分發、結果收集、錯誤恢復等諸多細節；為此，MapRece設計並提供了統一的計算框架，為程序員隱藏了絕大多數系統層面的處理細節。MapRece借鑒了函數式程序設計語言Lisp中的思想，定義了如下的Map和Rece兩個抽象的編程介面，由用戶去編程實現：map：(k1;v1)[(k2;v2)]輸入：鍵值對(k1;v1)表示的數據。處理：文檔數據記錄[(k2;v2)](如文本文件中的行，或數據表格中的行)將以「鍵值對」形式傳入map函數；map函數將處理這些鍵值對，並以另一種鍵。值對形式輸出處理的一組鍵值對中間結果。輸出：鍵值對[(k2;v2)]表示的一組中間數據。rece:(k2;[v2])[(k3;v3)]輸入：由map輸出的一組鍵值對[(k2;v2)]將被進行合並處理將同樣主鍵下的不同數值合並到一個列表[v2]中，故rece的輸入為(k2;[v2])處理：對傳入的中間結果列表數據進行某種整理或進一步的處理,並產生最終的某種形式的結果輸出[(k3;v3)]。輸出：最終輸出結果[(k3;v3)]。Map和Rece為程序員提供了一個清晰的操作介面抽象描述。