一、數(shù)據(jù)排序案例的設計與實現(xiàn)

1.1設計思路

圖1：MaxCompute MapReduce各個階段思路設計

設計思路分析分為六個模塊：input輸入數(shù)據(jù)、splitting拆分、Mapping映射、Shuffing派發(fā)、Reducing縮減、Final result輸出。
輸入數(shù)據(jù)：直接讀入文本不進行分片，數(shù)據(jù)項本身作為單個Map Worker的輸入。
Map階段：Map處理輸入，每獲取一個數(shù)字，將數(shù)字的Count設置為1，并將此<Word, Count>對輸出，此時以Word作為輸出數(shù)據(jù)的Key。
Shuffle>合并排序：在Shuffle階段前期，首先對每個Map Worker的輸出，按照Key值（即Word值）進行排序。排序后進行Combiner操作，即將Key值（Word值）相同的Count累加，構成新的<Word, Count>對。此過程被稱為合并排序。
Shuffle>分配Reduce：在Shuffle階段后期，數(shù)據(jù)被發(fā)送到Reduce端。Reduce Worker收到數(shù)據(jù)后依賴Key值再次對數(shù)據(jù)排序。此時進行數(shù)據(jù)項目復制，將key復制一份賦值給value，設計新的排序模式。
Reduce階段：每個Reduce Worker對數(shù)據(jù)進行處理時，采用value的值作為新的排序規(guī)則(從小到大)，每一個key值都會自動綁定一個全局的index，用于記錄輸出的排序序列號，得到輸出結果。
輸出結果：數(shù)據(jù)在hadoop服務器上展示。

1.2實踐過程

圖2：代碼設計
代碼：

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
public class spark {
    public static class Map extends Mapper<Object, Text, IntWritable, IntWritable> {
        private static IntWritable data = new IntWritable();
        @Override
        public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            String line = value.toString();
            data.set(Integer.parseInt(line));
            context.write(data, new IntWritable(1));
        }
    }
    public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable> {
        private static IntWritable lineNum = new IntWritable(1);
        @Override
        public void reduce(IntWritable key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            for (IntWritable val : values) {
                context.write(lineNum, key);
                lineNum = new IntWritable(lineNum.get() + 1);}}}
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        // 這句話很關鍵
        // conf.set("mapred.job.tracker", "192.168.1.2:9001");
        String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
        if (otherArgs.length != 2) {
            System.err.println("Usage: Data Sort <in> <out>");
            System.exit(2);
        }
        Job job = Job.getInstance(conf, "spark");
        job.setJarByClass(spark.class);
        // 設置 Map 和 Reduce 處理類
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        // 設置輸出類型
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(IntWritable.class);
        // 設置輸入和輸出目錄
        FileInputFormat.setInputPaths(job, new Path("hdfs://localhost:9000/spark/dataFile6.txt"));
        FileOutputFormat.setOutputPath(job, new Path("hdfs://localhost:9000/spark/output1"));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

圖3：將項目打包方便后續(xù)在hadoop服務器上運行

圖4：執(zhí)行相關指令（文件上傳分布式+運行jar包）

1.3成果展示+數(shù)據(jù)可視化分析

圖5：排序輸出各個國家世界杯累計勝場

圖6：2022卡塔爾世界杯累計勝場數(shù)目柱狀圖

圖7：2022卡塔爾世界杯累計勝場數(shù)-FIFA官方數(shù)據(jù)

分析：根據(jù)數(shù)據(jù)可視化的結果不難發(fā)現(xiàn)，巴西、德國、意大利、阿根廷四個國家的總勝場數(shù)超過其他國家，位列世界杯第一屆至第二十二屆勝場數(shù)top3，因此我們大膽預測在2026年舉行的第二十三屆世界杯上最有可能取得冠亞軍的隊伍就是巴西和德國隊。按照截止到二十一屆俄羅斯世界杯勝場數(shù)來看，阿根廷、德國、巴西三個國家最有可能登頂冠軍，二十二屆世界杯的冠軍就是阿根廷，因此數(shù)據(jù)分析是有說服力的。同時我們仍然可以對輸入的數(shù)據(jù)進行改造，譬如按照勝場數(shù)/比賽場數(shù)來計算勝率，并按照勝率的結果估算出最有可能成為冠亞軍的隊伍，將IntWritable類換成FloatWritable類作為輸入數(shù)據(jù)的類型。

圖8：排序愛奇藝輿情熱度單日榜單數(shù)據(jù)

圖9：排序愛奇藝輿情熱度單日榜單數(shù)據(jù)扇形圖（12月27日）

圖10：愛奇藝輿情熱度燈塔數(shù)據(jù)專業(yè)版

根據(jù)大數(shù)據(jù)可視化扇形圖，在12月27日當天用戶在愛奇藝平臺討論的熱播劇中：回來的女兒、月歌行、風吹半夏三部劇位列前三，說明用戶對于懸疑題材、仙俠題材、現(xiàn)實主義題材比較感興趣，對于東北插班生、危險愛人這種現(xiàn)代偶像劇接受度不高，同時我們大膽的預測，在12月28日當天，回來的女兒仍然可以以大優(yōu)勢位居輿情榜單榜首，月歌行、風吹半夏、卿卿日常等劇集差距不大仍有趕超“上位”的可能。

圖11：NBA常規(guī)球賽勝場分數(shù)排序

圖12：NBA常規(guī)球賽勝場分數(shù)柱狀圖

圖13：NBA常規(guī)球賽勝場情況統(tǒng)計（數(shù)據(jù)來自體育賽事官網）

在2022年NBA常規(guī)賽事中，猶他爵士籃球隊以大比分的優(yōu)勢取得年冠，評選年度MVP最佳籃球手的殊榮將以47.11%的概率入駐猶他爵士籃球隊，其中波士頓 凱爾特人籃球隊也有機會實現(xiàn)反超，于此同時國王球隊評分墊底，可能無緣出圈12強賽事戰(zhàn)隊。

二、求數(shù)據(jù)平均值案例的設計與實現(xiàn)

2.1設計思路

圖14：Average the data MapReduce各個階段思路設計

設計思路分析分為六個模塊：input輸入數(shù)據(jù)、splitting拆分、Mapping映射、Shuffing派發(fā)、Average求平均、Final result輸出。
input輸入數(shù)據(jù)：直接讀入自定義文本數(shù)據(jù)，不進行分片，數(shù)據(jù)項本身作為單個Map Worker的輸入。求數(shù)據(jù)平均值設計數(shù)據(jù)如下圖所示：

圖15：Average the data測試數(shù)據(jù)設計

Splitting拆分：即將input輸入的數(shù)據(jù)進行一一拆分到每個運行處理模塊中，讓系統(tǒng)進行對數(shù)據(jù)的拆分與分解分析工作。
Map階段：在MapReduce里排序默認是按照自然排序的，且只能對key進行排序，所以第一步需要包裝一個實體類做key，所以在Map處理輸入，每獲取一個蔬菜，將不同蔬菜的一個月內價格變化數(shù)目number設置為n，并將此<Vegetables, number>對輸出，此時以number作為輸出數(shù)據(jù)的Key，同時將自動或手動為index中的每月平均蔬菜價格數(shù)據(jù)變化建立的一種數(shù)據(jù)結構和相關配置。
Shuffle派發(fā)：在Shuffle階段前期，首先對每個Map Worker的輸出按照Key值（即Word值）進行相應派發(fā)與分配，將每一種蔬菜每天對應的價格派發(fā)后進行Combiner操作，即將Key值（Word值）Count累加，進行Average。
Final result輸出結果：數(shù)據(jù)進行Average求平均成功后，會將結果在hadoop服務器上展示。

2.2實踐過程

圖16：打開hdfs
在終端輸入./sbin/start-dfs.sh啟動hdfs。

圖17：確定Hadoop處于啟動狀態(tài)
通過輸入jps確定Hadoop處于啟動狀態(tài)。

圖18：上傳到hdfs的data目錄
在終端輸入命令：bin/hdfs dfs -put /home/hadoop/Downloads/cai.txt data將cai.txt文件上傳到hdfs的data目錄下。
在終端輸入命令：bin/hdfs dfs -ls data查看data目錄下的內容，可以看到我們已經成功將cai.txt文件上傳到hdfs的data目錄下。

圖19：查看cai.txt文件內容
在終端輸入命令：bin/hdfs dfs -text data/cai.txt查看cai.txt文件內容。

2.3編寫java程序并運行文件

圖20：java程序代碼
代碼：

package Mapreduce;

import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;

public class scoreSort {
    public static class scoreSortMapper extends Mapper<LongWritable, Text, Text, DoubleWritable> {
        private final Text k2 = new Text();
        private final DoubleWritable v2 = new DoubleWritable();
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            // 通過空格進行分割
            StringTokenizer tokenizer = new StringTokenizer(value.toString());
            // 迭代拿出
            while (tokenizer.hasMoreTokens()) {
                k2.set(tokenizer.nextToken());
                v2.set(Double.parseDouble(tokenizer.nextToken()));
                context.write(k2, v2);
            }
        }
    }

    public static class scoreSortReduce extends Reducer<Text, DoubleWritable, Text, DoubleWritable> {
        @Override
        protected void reduce(Text key, Iterable<DoubleWritable> values, Context context) throws IOException, InterruptedException {
            double sum = 0;
            int count = 0;
            for (DoubleWritable val : values) {
                sum += val.get();
                count++;
            }
            context.write(key, new DoubleWritable(sum / count));
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        /* 配置文件 */
        Configuration config = new Configuration();
        Job job = Job.getInstance(config, "App");
        /* mapper操作 */
        job.setMapperClass(scoreSortMapper.class);
        /* 設置map后輸出數(shù)據(jù)類型，如果不設置會默認輸出<IntWritable,Text>類型，會報錯 */
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(DoubleWritable.class);
        /* 設置輸出文件類型 */
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(DoubleWritable.class);
        /* combiner操作 */
        job.setCombinerClass(scoreSortReduce.class);
        /* reduce操作 */
        job.setReducerClass(scoreSortReduce.class);
        /* 設置輸入、輸出目錄，輸出目錄不能存在 */
        /* 設置輸入輸出的目錄 */
        Path inputpath = new Path("hdfs://localhost:9000/user/hadoop/data/cai.txt");
        Path outpath = new Path("hdfs://localhost:9000/out4");
        /* 設置需要計算的文件 */
        FileInputFormat.addInputPath(job, inputpath);
        /* 刪除多余的目錄 */
        //MpUtil.delOutPut(config, outpath);
        FileOutputFormat.setOutputPath(job, outpath);
        /* 0表示正常退出，1表示錯誤退出 */
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

圖21：scoreSort工程打包生成Sort.jar

圖22：查看是否打包成功
在進入myapp目錄下終端輸入命令：ls，可以看到，“/usr/local/hadoop/myapp”目錄下已經存在一個Sort.jar文件。

圖23：使用hadoop jar命令運行程序
在終端輸入命令：./bin/hadoop jar ./myapp/Sort.jar.jar運行打包的程序。

圖24：運行結果
結果已經被寫入了HDFS的“/user/hadoop/out4”目錄中。

2.4成果展示+數(shù)據(jù)可視化分析

圖25：查看輸出文件內容
在終端輸入命令：bin/hdfs dfs -cat /out4/*查看輸出文件內容.

圖26：2022年12月份大白菜價格變化圖
表格數(shù)據(jù)中可分析出，大白菜的最高價格為1.26元/公斤，最低價格為1.15元/公斤，平均價格為1.22元/公斤，中位數(shù)價格為1.19元/公斤，當前價格處于中間。

圖27：2022年12月份洋白菜價格變化圖
洋白菜的最高價格為1.66元/公斤，最低價格為1.41元/公斤，平均價格為1.49元/公斤，中位數(shù)價格為1.50元/公斤，當前價格處于高位。

圖28：2022年12月份油菜價格變化圖
油菜的最高價格為4.48元/公斤，最低價格為2.93元/公斤，平均價格為3.32元/公斤，中位數(shù)價格為3.64元/公斤，當前價格處于高位。

圖29：2022年12月份菠菜價格變化圖
菠菜的最高價格為6.40元/公斤，最低價格為4.42元/公斤，平均價格為4.77元/公斤，中位數(shù)價格為5.17元/公斤，當前價格處于高位。

圖30：2022年12月份韭菜價格變化圖
韭菜的最高價格為6.80元/公斤，最低價格為5.06元/公斤，平均價格為5.44元/公斤，中位數(shù)價格為6.17元/公斤，當前價格處于高位。

圖31：2022年12月份白蘿卜價格變化圖
白蘿卜的最高價格為1.55元/公斤，最低價格為1.39元/公斤，平均價格為1.50元/公斤，中位數(shù)價格為1.48元/公斤，當前價格處于高位。

圖32：2022年12月份蔬菜價格變化雷達圖

分析：蔬菜價格整體隨時間增長逐漸增高，“前低后高”，呈斜“N”分布態(tài)勢，變化圖來看，2022年12月份全國主要蔬菜批發(fā)均價在中旬起逐漸走高，價格在1.26～5.97元/kg之間波動，此后在波動中上升較明顯，總體來看整個月份菜價“前低后高”，上半個月的平均菜價明顯低于下半個月，呈現(xiàn)出斜“N”分布態(tài)勢。
價格整體波動幅度縮小，價格的波動幅度指某個產品一年中的高低價差與一年中最低價的比值。從圖表顯示數(shù)據(jù)和linux系統(tǒng)運行得出的Average data可得，2022年我國大白菜平均價格為1.25元/公斤，油菜平均價格為3.32元/公斤，洋白菜平均價格為1.50元/公斤，白蘿卜平均價格為1.50元/公斤，菠菜平均價格為4.77元/公斤，韭菜平均價格為5.44元/公斤，蔬菜平均最高值5.97元/kg，最低值為1.10元/kg，高低價差為4.87元/kg，波動幅度為27.6%，為近6年來最小波幅，也是近年來波幅低于30%的唯一月份。波幅縮小表明蔬菜供應淡旺季區(qū)別不明顯，蔬菜均衡供應能力進一步增強。

圖33：2022年12月份蔬菜價格變化柱狀圖

三、基于hadoop的PageRank算法實現(xiàn)

3.1設計思路

1、首先MapReduce的元語是不能被破壞的：即 “相同”的key為一組，調用一次reduce方法，方法內迭代這組數(shù)據(jù)。
2、通過觀察，我們可以看到這樣的現(xiàn)象，頁面包含超鏈接，每次迭代將pr值除以鏈接數(shù)后得到的值傳遞給所鏈接的頁面，每次迭代都要包含頁面鏈接關系和該頁面的pr值。
3、MapReduce設計思路： 其中：
map階段：主要做兩件事情。
第一，讀懂數(shù)據(jù)，第一次附加初始pr值。
第二，映射k:v。傳遞頁面鏈接關系，key為該頁面，value為頁面鏈接關系，計算鏈接的pr值，key為所鏈接的頁面，value為pr值。
reduce階段：按頁分組。
第一： 兩類value分別處理。
第二： 最終合并為一條數(shù)據(jù)輸出：key為頁面&新的pr值，value為鏈接關系。

3.2實踐過程

圖34：java程序設計

代碼：

package cbcPR;

import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Counter;
import org.apache.hadoop.mapreduce.Counters;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class PageRank {

	public static enum PageCouter{  
		TotalPage,  
		ConvergePage  
		};
    /*map過程*/
	public static class TokenizerMapper extends Mapper<Object, Text, Text, Text>{
	    public void map(Object key, Text value, Context context
	                   ) throws IOException, InterruptedException {
	        StringTokenizer itr = new StringTokenizer(value.toString());
	        String id = itr.nextToken(); //當前網頁
	        float weight = Float.parseFloat(itr.nextToken()); //當前網頁的權值
	        float out_weight = weight / itr.countTokens(); //為每個網頁投票的權值
	        String outs = "";
	        while (itr.hasMoreTokens()) {
	            String out_id = itr.nextToken();
	            outs += out_id + " ";
	            context.write(new Text(out_id), new Text("&" + out_weight));
	        }
	        context.write(new Text(id), new Text(outs)); 
	        context.write(new Text(id), new Text("#" + weight)); 
	        //'#'表示當前的權值，用于reduce階段判斷是否收斂
	        //枚舉計數(shù)器，計算有幾個Page
	        context.getCounter(PageCouter.TotalPage).increment(1);
	    }
	}

    /*reduce過程*/
	public static class WeightReducer extends Reducer<Text,Text,Text,Text> {
	    public void reduce(Text key, Iterable<Text> values, Context context
	                      ) throws IOException, InterruptedException {
	        float sum_weight = 0; //新的權值
	        float pre_weight = 0; //上一輪的權值，比較是否收斂
	        String outs = "";
	        for (Text val : values) {
	            String tmp = val.toString();
	            if (tmp.startsWith("&")) 
	                sum_weight+=Float.parseFloat(tmp.substring(1));
	            else if (tmp.startsWith("#"))
	                pre_weight =Float.parseFloat(tmp.substring(1)); 
	            else outs = tmp;
	        }
	        sum_weight = 0.8f * sum_weight + 0.2f * 0.125f; //平滑處理，處理終止點和陷阱 
	        context.write(key, new Text(sum_weight + " " + outs));
	        if (sum_weight == pre_weight)        //枚舉計數(shù)器，計算有幾個已收斂
	            context.getCounter(PageCouter.ConvergePage).increment(1);
	    }
	}

	public static void main(String[] args) throws Exception {
	    Configuration conf = new Configuration();
	    String in_path = args[0];
	    String out_path = args[1] + "/iter";
	    for (int i = 0; i < 50; i++) { //設置最多只迭代50次，也可用while
	        Job job = Job.getInstance(conf, "page rank");
	        job.setJarByClass(PageRank.class);
	        job.setMapperClass(TokenizerMapper.class);
	        job.setReducerClass(WeightReducer.class);
	        job.setOutputKeyClass(Text.class);
	        job.setOutputValueClass(Text.class);
	        FileInputFormat.addInputPath(job, new Path(in_path));
	        FileOutputFormat.setOutputPath(job, new Path(out_path + i));
	        job.setNumReduceTasks(2); //設置reduce數(shù)量為2，模擬大文件
	        in_path = out_path + i;   //設置下一輪的輸入
	        job.waitForCompletion(true);

	        Counters counters = job.getCounters(); 
	        Counter counter = counters.findCounter(PageCouter.TotalPage);
	        long totalpage=counter.getValue();// 獲取計數(shù)值
	        counter = counters.findCounter(PageCouter.ConvergePage);
	        long convergepage = counter.getValue(); //收斂計數(shù)值
	        System.out.println("total page: " + totalpage);
	        System.out.println("converge page: " + convergepage);
	        if (totalpage == convergepage) {
	            System.out.print("converge at iteration: " + i);
	            break;
	        }
	    }
	}
}

圖35： 打包生成PageRank2.jar

圖36：查看是否打包成功

圖37：準備數(shù)據(jù)

圖38：啟動hadoop并確認狀態(tài)

圖39：確保運行程序不出錯，新建input

圖40：上傳數(shù)據(jù)

圖41：運行jar包

圖42：運行結果

圖43：查看數(shù)據(jù)

3.3成果展示

圖44：實驗結果

3.4 數(shù)據(jù)的可視化分析

有4個網頁，鏈接關系如下，A網頁有到B和C網頁的鏈接，B有到D網頁的鏈接，其余類似。

圖45：網頁鏈接狀態(tài)

初始化每個網頁的PageRank為1/N = 1/4
每個網頁根據(jù)出鏈數(shù)均分自己的權值，更新所有網頁的PageRank，即
? A的PageRank為0.25，則分給B和C各0.125，而A得到D分得的0.125，所以A的PageRank更新為0.125
? 同理，B更新為0.375，C更新為0.125，D更新為0.375，四個網頁和仍為1
重復第二步直到收斂

通常我們使用一種合適的數(shù)據(jù)結構來表示頁面間的鏈接關系。設一共有N個頁面，則要生成一個N維矩陣，其中第i行表示的是其他頁面對 第i個頁面鏈接的概率，第j列表示的是第j個頁面對其他頁面鏈接的概率。這樣的矩陣叫做轉移矩陣。對應到上圖，轉移矩陣為：

在上圖中，第一列為頁面A對各個頁面轉移的概率，第一行為各個頁面對頁面A轉移的概率。初始時，每一個頁面的PageRank值都是均等的，為1/N，這里也即是1/4。然后對于頁面A來說，根據(jù)每一個頁面的PageRank值和每個頁面對頁面A的轉移概率，可以算出新一輪頁面A的PageRank值。這里，只有頁面B和頁面C轉移了自己的1/2給A。所以新一輪A的PageRank值為1/41/2+1/41/2=9/24。為了計算方便，我們設置各頁面初始的PageRank值為一個列向量V0。然后再基于轉移矩陣，我們可以直接求出新一輪各個頁面的PageRank值。即 V1 = MV0

現(xiàn)在得到了各頁面新的PageRank值V1, 繼續(xù)用M 去乘以V1 ,就會得到更新的PageRank值。一直迭代這個過程，可以證明出V最終會收斂。此時停止迭代。這時的V就是各個頁面的PageRank值。在上圖中，一直迭代的中間V如下：

按照這種方式計算下去我們就可以得到了，迭代到i= 45時，兩個計數(shù)器都為8，即在i = 45時收斂，查看輸出文件，如代碼中設置的，每一輪有兩份輸出。

分析：PageRank的Page可是認為是網頁，表示網頁排名，也可以認為是Larry Page(google 產品經理)，因為他是這個算法的發(fā)明者之一，還是google CEO。PageRank算法計算每一個網頁的PageRank值，然后根據(jù)這個值的大小對網頁的重要性進行排序。它的思想是模擬一個悠閑的上網者，上網者首先隨機選擇一個網頁打開，然后在這個網頁上呆了幾分鐘后，跳轉到該網頁所指向的鏈接，這樣無所事事、漫無目的地在網頁上跳來跳去，PageRank就是估計這個悠閑的上網者分布在各個網頁上的概率。首先分為ABCDEFGH，8組網址數(shù)據(jù)初始的總分配權值是0.125，首先進行的是平均分配權值的操作。圖是強連通的，即從任意網頁可以到達其他任意網頁：互聯(lián)網上的網頁不滿足強連通的特性，因為有一些網頁不指向任何網頁，如果按照上面的計算，上網者到達這樣的網頁后便走投無路、四顧茫然，導致前面累計得到的轉移概率被清零，這樣下去，最終的得到的概率分布向量所有元素幾乎都為0。然后通過處理終止點問題和陷阱問題。上網者是一個悠閑的上網者，而不是一個愚蠢的上網者，我們的上網者是聰明而悠閑，他悠閑，漫無目的，總是隨機的選擇網頁，他聰明，在走到一個終結網頁或者一個陷阱網頁，不會傻傻的干著急，他會在瀏覽器的地址隨機輸入一個地址，當然這個地址可能又是原來的網頁，但這里給了他一個逃離的機會，讓他離開這萬丈深淵。模擬聰明而又悠閑的上網者，對算法進行改進，每一步，上網者可能都不想看當前網頁了，不看當前網頁也就不會點擊上面的連接，而上悄悄地在地址欄輸入另外一個地址，而在地址欄輸入而跳轉到各個網頁的概率是1/n。假設上網者每一步查看當前網頁的概率為a，那么他從瀏覽器地址欄跳轉的概率為(1-a)。采用矩陣相乘，不斷迭代，直到迭代前后概率分布向量的值變化不大，一般迭代到30次以上就收斂了。真的的web結構的轉移矩陣非常大，目前的網頁數(shù)量已經超過100億，轉移矩陣是100億*100億的矩陣，直接按矩陣乘法的計算方法不可行，需要借助Map-Reduce的計算方式來解決文章來源地址http://www.zghlxwxcb.cn/news/detail-754153.html

到了這里，關于大數(shù)據(jù)實戰(zhàn)——基于Hadoop的Mapreduce編程實踐案例的設計與實現(xiàn)的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！