MapReduce实现矩阵的预处理和矩阵的乘法

最新推荐文章于 2024-07-10 23:15:15 发布
最新推荐文章于 2024-07-10 23:15:15 发布
阅读量757 收藏 7
点赞数 1
文章标签： mapreduce 矩阵 大数据 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WJY2003IBDM/article/details/133244524
版权

1.环境配置

1. VMware虚拟机安装Ubuntu 20.04.6操作系统

2. 在ubuntu中安装jdk

3. 在ubuntu中安装hadoop，并搭建伪分布式环境

4. 在ubuntu中安装eclipse，并安装hadoop插件

2.问题说明

2.1.矩阵的预处理

x1

x2

x3

x4

x5

x6

x1

x2

x3

x4

x5

x6

x1

x2

x3

x4

x5

x6

x1

x2

x3

x4

x5

x6

x1

x2

x3

x4

x5

x6

x1

x2

x3

x4

x5

x6

任意一个值，与它周边一圈的值的均值，差异不能过大。否则，则用均值代替这个值。

2.2.矩阵的乘法

  其中矩阵乘法有两个版本算法，包括普通矩阵以及稀疏矩阵的算法

3.理论说明

3.1.矩阵的预处理

3.1.1.思路：

矩阵的预处理形象化来说，就是以一个3乘3的窗口以当前值为中心，将框住的值进行一个平均值的运算，然后进行当前值和均值的插值运算后决定是否进行替换

由于被窗口框到的值需要多次整合起来一起运算，即矩阵中的每一个值均需要多次的调用，因此可以在map阶段就将每个值能够参与哪个位置的值的更新给输出，即每次获取的周围一圈的值的键是自身的位置<I,j>,但是value却是窗口中心的值，最后在reduce阶段即可将相同键值的键值对的value整合起来运算

3.1.2.数据的输入结构

采用每一行的形式为<行，列，值>的形式输入矩阵

如图所示：

3.1.3.具体实现

Map阶段

对来自矩阵的每一行信息进行处理，把<I,j,value>的信息输出为两种键值对，其中一种键值对为<I,j,M,value>来表示窗口中的中心值，另一种键值对为<a,b,V,value>(（a，b）表示所有可以取的位置)来表示此中心值能够参与到哪些位置的预处理中

Reduce阶段

对Map阶段发送的键值对进行分类统计，在键值相同的键值对中，类型为M的则将其value赋值给originalValue表示原始值，类型为V的则将其所有的value相加后除以count求出average，最后比较差值是否大于2再决定替补替换原始值，最后输出键值对<key, originalValue/average>

下面是一个简单的3*3矩阵的预处理演示：

3.2.矩阵的乘法

  3.2.1.思路

矩阵乘法：

矩阵乘法要求左矩阵的列数与右矩阵的行数相等，m×n的矩阵A，与n×p的矩阵B相乘，结果为m×p的矩阵C。

为了方便描述,先进行假设：

矩阵A的行数为m，列数为n，aij为矩阵A第i行j列的元素。

矩阵B的行数为n，列数为p，bij为矩阵B第i行j列的元素

3.2.2.数据的输入结构

普通矩阵的表示方式：使用最原始的表示方式，相同行内不同列数据通过","分割，不同行通过换行分割，如下形式：

稀疏矩阵的表示方式：通过行列表示法，即文件中的每行数据有三个元素通过分隔符分割，第一个元素表示行，第二个元素表示列，第三个元素表示数据。这种方式对于可以不列出为0的元素，即可以减少稀疏矩阵的数据量，如下形式：

 3.2.3.具体实现

map阶段

我们需要对数据进行准备。从矩阵A中的元素aij开始，我们将其转化为p个<key, value>对的形式，其中key=“i,k”（其中k=1,2,…,p），value=“a:j,aij”。类似地，从矩阵B中的元素bij开始，我们将其转化为m个<key, value>对的形式，其中key=“k,j”（其中k=1,2,…,m），value=“b:i,bij”。

通过这样的处理，我们就能够得到具有相同key（“i,j”）的数据对，同时通过value中的"a:"和"b:"来区分元素是来自矩阵A还是矩阵B，以及它们在矩阵A的哪一列或矩阵B的哪一行。

在shuffle阶段

Hadoop会自动将具有相同key的value分组到同一个Iterable中，形成<key, Iterable(value)>的对，并将其传递给reduce阶段进行处理。

reduce阶段

通过map阶段的处理，<key, Iterable(value)>中的key（i,j）就对应了矩阵C中的第i行第j列的元素。

Iterable中的每个value在矩阵A和矩阵B的位置也在map阶段进行了标记。对于value（x:y,z），我们只需要找到y相同的来自不同矩阵（即x分别为a和b）的两个元素，将它们相乘后求和即可得到结果。

下面是普通矩阵和稀疏矩阵的简单案例演示：

4.算法实现及分析

4.1.矩阵的预处理

4.1.1.算法流程

  1. 创建一个Mapper类MatrixMapper，其中map方法用于处理输入数据。首先将输入的一行数据分割成三个部分，分别是行、列和矩阵元素的值。然后将行和列作为输出的键（outKey），矩阵值作为输出的值（outValue），并写入上下文（context）中。接下来，针对该矩阵元素的邻居进行遍历，如果邻居的位置合法并且不与当前元素相同，就将邻居的位置作为输出的键，矩阵值作为输出的值，并写入上下文中。
  2. 创建一个Reducer类MatrixReducer，其中reduce方法用于对Mapper输出的键值对进行处理。首先初始化求和变量sum和计数变量count为0，同时定义一个变量originalValue用于保存当前元素的原始值。然后遍历Mapper输出的值集合，解析每个值的类型和数值。如果值的类型为"M"，表示这是一个矩阵元素的原始值，将其保存到originalValue中；如果值的类型为"V"，表示这是一个邻居元素的值，将其累加到sum中，并增加计数。最后，计算平均值average为sum/count。如果当前元素的原始值与平均值的绝对差大于2，将原始值更新为平均值。最后，将更新后的值转化为文本形式，并将键值对写入上下文中。
  3. 在main方法中，首先创建一个配置对象conf和一个作业对象job。然后设置作业的类和各个阶段的类，包括Mapper类、Reducer类、输出键和输出值的类。接着设置输入和输出路径。最后，调用job.waitForCompletion方法提交作业并等待作业完成，根据作业的执行结果返回相应的退出码。

4.1.2.实现代码

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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;

public class MatrixPreprocessing {
  
	// Mapper class
	public static class MatrixMapper extends Mapper<LongWritable, Text, Text, Text> {

	  private Text outKey = new Text();
	  private Text outValue = new Text();

	  // Map方法用于处理输入数据
	  public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
	    String[] parts = value.toString().split(",");
	    int row = Integer.parseInt(parts[0]);
	    int col = Integer.parseInt(parts[1]);
	    double matrixValue = Double.parseDouble(parts[2]);

	    // 设置输出键和输出值，并写入上下文
	    outKey.set(row + "," + col);
	    outValue.set("M," + matrixValue);
	    context.write(outKey, outValue);

	    // 遍历邻居元素
	    for(int i=row-1; i<=row+1; i++){
	      for(int j=col-1; j<=col+1; j++){
	        // 判断邻居元素位置的合法性，并且不是当前元素
	        if(i>0 && i <=3 && j>0 && j <=11 && (i != row || j != col)){
	          outKey.set(i + "," + j);
	          outValue.set("V," + matrixValue);
	          context.write(outKey, outValue);
	        }
	      }
	    }
	  }
	}

	// Reducer class
	public static class MatrixReducer extends Reducer<Text, Text, Text, Text> {

	  private Text outValue = new Text();

	  // Reduce方法用于对Mapper输出的键值对进行处理
	  public void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
	    double sum = 0.0;
	    int count = 0;
	    double originalValue = 0.0;

	    // 遍历值集合
	    for (Text value : values) {
	      String[] parts = value.toString().split(",");
	      String valueType = parts[0];
	      double doubleValue = 0.0;
	      doubleValue = Double.parseDouble(parts[1]);

	      // 根据值的类型进行处理
	      if (valueType.equals("M")) {
	        originalValue = doubleValue;
	      } else if (valueType.equals("V")) {
	        sum += doubleValue;
	        count++;
	      }
	    }

	    // 计算平均值
	    double average = sum / count;

	    // 如果当前元素的原始值与平均值的绝对差大于2，则更新原始值为平均值
	    if (Math.abs(originalValue - average) > 2) {
	      originalValue = average;
	    }

	    // 将更新后的值转化为文本形式，并将键值对写入上下文
	    outValue.set(Double.toString(originalValue));
	    context.write(key, outValue);
	  }
	}

	public static void main(String[] args) throws Exception {
	  Configuration conf = new Configuration();
	  Job job = Job.getInstance(conf, "Matrix Preprocessing");

	  job.setJarByClass(MatrixPreprocessing.class);
	  job.setMapperClass(MatrixMapper.class);
	  job.setReducerClass(MatrixReducer.class);

	  job.setOutputKeyClass(Text.class);
	  job.setOutputValueClass(Text.class);

	  // 设置输入和输出路径
	  FileInputFormat.addInputPath(job, new Path("hdfs://localhost:9000/user/hadoop/input/test.txt"));
	  FileOutputFormat.setOutputPath(job, new Path("hdfs://localhost:9000/user/hadoop/output"));

	  // 提交作业并等待作业完成
	  System.exit(job.waitForCompletion(true) ? 0 : 1);
	}

4.2.普通矩阵的乘法

4.2.1.算法流程

  1. 定义了一个静态内部类 MatrixMapper，继承自 Mapper 类。这个类用于将输入的数据切分成键值对，并将它们发送给 Reducer 进行处理。
  2. 在 Mapper 类中定义了一些变量，包括数据集名称(flag)、矩阵A的行数(rowNum)、矩阵B的列数(colNum)、矩阵A当前所在行(rowIndexA)和矩阵B当前所在行(rowIndexB)。
  3. 重写了 Mapper 类的 setup 方法，用于获取输入文件的名称。
  4. 重写了 Mapper 类的 map 方法，在每个 map 方法中首先将输入的文本按空格分隔成一个字符串数组（tokens）。
  5. 根据输入文件的名称(flag)，如果是"ma.txt"，则进入矩阵A的处理逻辑。对于可能的每一列，创建键(Text对象，表示矩阵A的行和列)和值(Text对象，表示矩阵A的元素)对，并将它们写入上下文(context)。
  6. 如果输入文件的名称是"mb.txt"，则进入矩阵B的处理逻辑。对于可能的每一行和每一列，创建键(Text对象，表示矩阵B的行和列)和值(Text对象，表示矩阵B的元素)对，并将它们写入上下文(context)。
  7. 定义了一个静态内部类 MatrixReducer，继承自 Reducer 类。这个类将 Mapper 输出的键值对进行聚合处理，并将结果写入输出。
  8. 重写了 Reducer 类的 reduce 方法。在 reduce 方法中，首先创建了两个空的 HashMap 对象(mapA和mapB)，用于存储矩阵A和矩阵B的元素。
  9. 遍历输入的 values，根据键值的不同将元素分别存储到 mapA 或 mapB 中。
  10. 接着，对于每一个矩阵A中的元素，查找对应的矩阵B中的元素，并进行乘法运算，累加结果到 result 变量中。
  11. 最后，将结果写入上下文(context)，输出键(Text对象，表示矩阵乘法的结果)和值(IntWritable对象，表示计算结果)对。

4.2.2.实现代码

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
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.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
 
public class MatrixMultiply {
    public static class MatrixMapper extends
            Mapper<LongWritable, Text, Text, Text> {
        private String flag = null;// 数据集名称
        private int rowNum = 3;// 矩阵A的行数
        private int colNum = 3;// 矩阵B的列数
        private int rowIndexA = 1; // 矩阵A，当前在第几行
        private int rowIndexB = 1; // 矩阵B，当前在第几行

        protected void setup(Context context) throws IOException,
                InterruptedException {
            flag = ((FileSplit) context.getInputSplit()).getPath().getName();// 获取文件名称
        }

        protected void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            String[] tokens = value.toString().split(" ");
            if ("ma.txt".equals(flag)) {
                for (int i = 1; i <= colNum; i++) {
                    Text k = new Text(rowIndexA + " " + i);
                    for (int j = 0; j < tokens.length; j++) {
                        Text v = new Text("a " + (j + 1) + " " + tokens[j]);
                        context.write(k, v);
                    }
                }
                rowIndexA++;// 每执行一次map方法，矩阵向下移动一行
            } else if ("mb.txt".equals(flag)) {
                for (int i = 1; i <= rowNum; i++) {
                    for (int j = 0; j < tokens.length; j++) {
                        Text k = new Text(i + " " + (j + 1));
                        Text v = new Text("b " + rowIndexB + " " + tokens[j]);
                        context.write(k, v);
                    }
                }
                rowIndexB++;// 每执行一次map方法，矩阵向下移动一行
            }
        }
    }
 
    public static class MatrixReducer extends
            Reducer<Text, Text, Text, IntWritable> {
        protected void reduce(Text key, Iterable<Text> values, Context context)
                throws IOException, InterruptedException {
            Map<String, String> mapA = new HashMap<String, String>();
            Map<String, String> mapB = new HashMap<String, String>();
 
            for (Text value : values) {
                String[] val = value.toString().split(" ");
                if ("a".equals(val[0])) {
                    mapA.put(val[1], val[2]);
                } else if ("b".equals(val[0])) {
                    mapB.put(val[1], val[2]);
                }
            }
 
            int result = 0;
            Iterator<String> mKeys = mapA.keySet().iterator();
            while (mKeys.hasNext()) {
                String mkey = mKeys.next();
                if (mapB.get(mkey) == null) {
                    continue;
                }
                result += Integer.parseInt(mapA.get(mkey))
                        * Integer.parseInt(mapB.get(mkey));
            }
            context.write(key, new IntWritable(result));
        }
    }
 
    public static void main(String[] args) throws IOException,
            ClassNotFoundException, InterruptedException {
        String input1 = "hdfs://localhost:9000/user/hadoop/input/ma.txt";
        String input2 = "hdfs://localhost:9000/user/hadoop/input/mb.txt";
        String output = "hdfs://localhost:9000/user/hadoop/output";
 
        Configuration conf = new Configuration();
        conf.addResource("classpath:/hadoop/core-site.xml");
        conf.addResource("classpath:/hadoop/hdfs-site.xml");
        conf.addResource("classpath:/hadoop/mapred-site.xml");
        conf.addResource("classpath:/hadoop/yarn-site.xml");
 
        Job job = Job.getInstance(conf, "MatrixMultiply");
        job.setJarByClass(MatrixMultiply.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
 
        job.setMapperClass(MatrixMapper.class);
        job.setReducerClass(MatrixReducer.class);
 
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
 
        FileInputFormat.setInputPaths(job, new Path(input1), new Path(input2));// 加载2个输入数据集
        Path outputPath = new Path(output);
        outputPath.getFileSystem(conf).delete(outputPath, true);
        FileOutputFormat.setOutputPath(job, outputPath);
 
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

4.3.稀疏矩阵的乘法

4.3.1.算法流程

  1. 定义了一个静态内部类 SMMapper 继承自 Mapper 类，并指定了输入键的类型为 LongWritable，输入值的类型为 Text，输出键的类型为 Text，输出值的类型为 Text。
  2. 在 setup 方法中获取输入文件的名称，并赋值给变量 flag。
  3. 在 map 方法中，根据输入文件的名称判断当前正在处理的是矩阵A的文件还是矩阵B的文件。
  4. 如果是矩阵A的文件（test1.txt），则对于每个输入的行，将该行的元素与矩阵B的列数进行遍历，生成键值对 <行号,列号> -> <'a',行号,元素值>，并通过上下文对象 context 进行输出。
  5. 如果是矩阵B的文件（test2.txt），则对于每个输入的行，将该行的元素与矩阵A的行数进行遍历，生成键值对 <行号,列号> -> <'b',元素值,列号>，并通过上下文对象 context 进行输出。
  6. 定义了一个静态内部类 SMReducer 继承自 Reducer 类，并指定了输入键的类型为 Text，输入值的类型为 Text，输出键的类型为 Text，输出值的类型为 IntWritable。
  7. 在 reduce 方法中，创建了两个空的 HashMap，用于存储矩阵A和矩阵B中的元素。
  8. 遍历 values 集合，对每个值进行解析，并根据其类型（'a'或'b'）将其放入相应的 HashMap 中。
  9. 初始化变量 result 为0，用于存储最终的乘积结果。
  10. 遍历矩阵A的所有键，如果对应的键在矩阵B中也存在，则将矩阵A和矩阵B中对应键的元素值相乘，并累加到 result 中。
  11. 最后，通过上下文对象 context 将键值对 <行号,列号> -> 乘积结果 输出。

整个算法的流程是：

  1. 输入是两个矩阵A和B，分别存储在两个输入文件 test1.txt 和 test2.txt 中。
  2. SMMapper 类根据输入文件的名称判断当前处理的是矩阵A还是矩阵B，并根据规则生成键值对。
  3. MapReduce 框架将生成的键值对按照键进行分组，并将每组键值对传递给 SMReducer 类的 reduce 方法。
  4. SMReducer 类将相同的键对应的值按照其类型分别放入两个 HashMap 中。
  5. 遍历矩阵A的所有键，如果对应的键在矩阵B中也存在，则将两个矩阵中该键对应的元素值相乘，并累加到结果变量 result 中。
  6. 最后，将乘积结果通过上下文对象 context 输出。

4.3.2.实现代码

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
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.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

public class SparseMatrixMultiply {
    public static class SMMapper extends Mapper<LongWritable, Text, Text, Text> {
        private String flag = null;
        private int m = 100;// 矩阵A的行数
        private int p = 100;// 矩阵B的列数
 
        protected void setup(Context context) throws IOException,
                InterruptedException {
            FileSplit split = (FileSplit) context.getInputSplit();
            flag = split.getPath().getName();
        }
 
        protected void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            String[] val = value.toString().split(" ");
            if ("test1.txt".equals(flag)) {
                for (int i = 1; i <= p; i++) {
                    context.write(new Text(val[0] + "," + i), new Text("a,"
                            + val[1] + "," + val[2]));
                }
            } else if ("test2.txt".equals(flag)) {
                for (int i = 1; i <= m; i++) {
                    context.write(new Text(i + "," + val[1]), new Text("b,"
                            + val[0] + "," + val[2]));
                }
            }
        }
    }
 
    public static class SMReducer extends
            Reducer<Text, Text, Text, IntWritable> {
        protected void reduce(Text key, Iterable<Text> values, Context context)
                throws IOException, InterruptedException {
            Map<String, String> mapA = new HashMap<String, String>();
            Map<String, String> mapB = new HashMap<String, String>();
 
            for (Text value : values) {
                String[] val = value.toString().split(",");
                if ("a".equals(val[0])) {
                    mapA.put(val[1], val[2]);
                } else if ("b".equals(val[0])) {
                    mapB.put(val[1], val[2]);
                }
            }
 
            int result = 0;
            // 可能在mapA中存在在mapB中不存在的key，或相反情况
            // 因为，数据定义的时候使用的是稀疏矩阵的定义
            // 所以，这种只存在于一个map中的key，说明其对应元素为0，不影响结果
            Iterator<String> mKeys = mapA.keySet().iterator();
            while (mKeys.hasNext()) {
                String mkey = mKeys.next();
                if (mapB.get(mkey) == null) {
                    continue;
                }
                result += Integer.parseInt(mapA.get(mkey))
                        * Integer.parseInt(mapB.get(mkey));
            }
            context.write(key, new IntWritable(result));
        }
    }
 
    public static void main(String[] args) throws IOException,
            ClassNotFoundException, InterruptedException {
    	String input1 = "hdfs://localhost:9000/user/hadoop/input/test1.txt";
        String input2 = "hdfs://localhost:9000/user/hadoop/input/test2.txt";
        String output = "hdfs://localhost:9000/user/hadoop/output";
 
        Configuration conf = new Configuration();
        conf.addResource("classpath:/hadoop/core-site.xml");
        conf.addResource("classpath:/hadoop/hdfs-site.xml");
        conf.addResource("classpath:/hadoop/mapred-site.xml");
        conf.addResource("classpath:/hadoop/yarn-site.xml");
 
        Job job = Job.getInstance(conf, "SparseMatrixMultiply");
        job.setJarByClass(SparseMatrixMultiply.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
 
        job.setMapperClass(SMMapper.class);
        job.setReducerClass(SMReducer.class);
 
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
 
        FileInputFormat.setInputPaths(job, new Path(input1), new Path(input2));// 加载2个输入数据集
        Path outputPath = new Path(output);
        outputPath.getFileSystem(conf).delete(outputPath, true);
        FileOutputFormat.setOutputPath(job, outputPath);
 
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

5.运行范例

5.1.矩阵预处理

5.1.1输入矩阵

5.1.2.输出矩阵

5.2.普通矩阵乘法

5.2.1输入矩阵

A矩阵

B矩阵

5.2.2.输出矩阵

5.3.稀疏矩阵乘法

5.2.1输入矩阵

A矩阵

（100*100，值的范围在1-50，稀疏度为0.3）

B矩阵

（100*100，值的范围在1-50，稀疏度为0.4）

5.2.2.输出矩阵

（由于是一位一位排序的，行大概按照1，10，100，11，12….，列则顺序）

引用借鉴：MapReduce实现矩阵乘法_看山的博客-CSDN博客

WJYM
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
用MapReduce实现矩阵乘法
fens的博客
01-15 1053
Hadoop家族系列文章，主要介绍Hadoop家族产品，常用的项目包括Hadoop, Hive, Pig, HBase, Sqoop, Mahout, Zookeeper, Avro, Ambari, Chukwa，新增加的项目包括，YARN, Hcatalog, Oozie, Cassandra, Hama, Whirr, Flume, ...
MapReduce 基础算法【矩阵乘法】
To-nemy
08-15 2879
1. 矩阵乘法原理和实现思路 对于任意矩阵MMM和NNN,若矩阵MMM的列数等于矩阵NNN的行数，则记MMM和NNN的乘积P=M⋅NP=M⋅NP=M \cdot N。其中mijmijm_{ij}记作矩阵MMM的第iii行第jjj列的元素，njknjkn_{jk}记作矩阵NNN的第jjj行第kkk列的元素，则其乘积矩阵PPP的元素可由下式求得： pik=(M⋅N)ik=∑jmijnjkpik=(...
MapReduce实现矩阵乘法
庐州小白的博客
10-19 1905
矩阵运算是程序运行过程中非常耗时的部分，因而也出现了许多针矩阵计算的优化方法，尤其是矩阵乘法，对于MitM_{it}Mit​和NtkN_{tk}Ntk​，其相乘的复杂度是O(i×k)O(i \times k)O(i×k)。熟悉矩阵运算的人都应知道，结果矩阵PPP中的任意元素pikp_{ik}pik​和M、NM、NM、N中的第iii行、kkk列均有关。 pik=(M×N)ik=∑jmijnjk p_...
大数据Mapreduce编程——矩阵乘法
qq_46138648的博客
02-28 4074
大数据基础编程mapreduce之矩阵乘法
算法系列：矩阵相乘算法的MapReduce实现
as123588的专栏
11-28 470
看到一篇文章，列出了几个使用MapReduce完成的算法（附有实现案例），但是还是想自己实现下，所以自己写了一个，后来看了下案例，不是太一样，但是我实现了，不管效果如何，或者好不好看，总之我实现了。这里就跟大家分享下，同时也希望能得到一个建议。 首先介绍下我的实现思想： 1.两个矩阵相乘，我们假设为a[i][j]，b[x][y]，若a*b则i==y，即c[n][n]=a[i]...
MapReduce编程： 2. 矩阵乘法
叶小东的博客
03-17 3399
MapReduce编程： 2. 矩阵乘法
java 矩阵乘法的mapreduce程序实现
08-30
java 矩阵乘法的mapreduce程序实现是使用Hadoop的MapReduce框架来实现矩阵乘法的操作。矩阵乘法是一种基本的线性代数操作，用于计算两个矩阵的乘积。在大规模数据处理中，矩阵乘法是非常常见的操作，但是传统的矩阵...
基于Hadoop MapReduce的矩阵乘法
12-28
1、资源内容：基于Hadoop MapReduce的矩阵乘法 2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok的情况下才上传的。 3、适用对象...
MapReduce实现矩阵相乘算法
11-29
总之，使用Hadoop MapReduce实现矩阵相乘是一个涉及并行计算、分布式存储和高效数据处理的综合问题，它展示了MapReduce在处理大规模数值计算时的强大能力。通过理解并实践这一算法，开发者可以更好地掌握大数据处理...
MapReduce实现大矩阵乘法
11-15
在“MapReduce实现大矩阵乘法”这个主题中，我们将深入探讨如何利用MapReduce模型解决大矩阵乘法的问题，这是一种高效处理大数据存储的有效方法。 **Map阶段** 在Map阶段，输入数据被分割成多个块（通常为HDFS中的...
1-MapReduce矩阵乘法 600.rar
06-19
描述中提到，“采用python基于MapReduce架构实现矩阵相乘”，这表明代码是用Python语言编写的，并且利用了MapReduce的特性来处理矩阵乘法的计算任务。大数据离线运算意味着这不是实时或流式计算，而是处理预先存储的...
MapReduce:出租车数据案例
01-06 4314
计算出10月1日这天每小时的载客量 CarMapper: package com.hadoop.map; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Mapper; import java.io.IOException...
MapReduce编程——矩阵乘法（Python版本）
huhubbdd的博客
11-11 532
无
MapReduce实现矩阵相乘
小江专栏
03-31 8493
前言 MapReduce打开了并行计算的大门，让我们个人开发者有了处理大数据的能力。但想用好MapReduce，把原来单机算法并行化，也不是一件容易事情。很多的时候，我们需要从单机算法能否矩阵化去思考，所以矩阵操作就变成了算法并行化的基础。 矩阵介绍 为了方便说明，举两个矩阵作为示例： ， 容易看出，是一个矩阵，是一个矩阵，我们能够算出： 这三个矩阵当然不大，但
矩阵补全（Matrix Completion）和缺失值预处理
qq_44015059的博客
07-16 8640
前言 文章转载自：https://www.cnblogs.com/wuliytTaotao/p/10814770.html 1. 矩阵补全 矩阵补全（Matrix Completion），就是补上一个含缺失值矩阵的缺失部分。 矩阵补全可以通过矩阵分解（matrix factorization）将一个含缺失值的矩阵 XXX 分解为两个（或多个）矩阵，然后这些分解后的矩阵相乘就可以得到原矩阵的近似 X′X^{\prime}X′，我们用这个近似矩阵 X′X^{\prime}X′ 的值来填补原矩阵 X 的缺失部分。
MapReduce 矩阵乘法
weixin_30549175的博客
11-30 336
一、对朴素简单直接方法 把m*n 和n*l的矩阵A和B相乘，这估计是最容易想到的方法了： 把A（m*n）的元素，每个发送l次，把B（n*l）的元素每个发送m次。将发送到一起的数据相乘求和，得到最后的结果。 优点：在知道坐标的情况下，这个过程就一轮mapreduce。 缺点：每个值要被发送多次。m*n 和n*l的矩阵，发送的元素有m*l*2次，比如100万的方...
大数据基础：Hadoop之MapReduce重点架构原理
最新发布
Lansonli（蓝深李）的博客
07-10 1551
Reduce端每个Reduce task会从每个map task所在的节点上拉取落地的磁盘文件对应的分区数据，对于每个Reduce task来说，从各个节点上拉取到多个分区数据后，每个分区内的数据按照key分组有序，但是总体来看这些分区文件中key数据不是全局有序状态（分区数据内部有序，外部无序）。第一次排序发生在Map阶段的磁盘溢写时：当MapReduce的环形缓冲区达到溢写阈值时，在数据刷写到磁盘之前，会对数据按照key的字典序进行快速排序，以确保每个分区内的数据有序。
mapreduce实现矩阵乘法
07-28
在实现矩阵乘法时，可以使用MapReduce来进行并行计算。具体实现步骤如下： 1. Map阶段：将输入的矩阵A和矩阵B进行预处理，生成键值对。键表示矩阵C中的元素位置，值表示来自矩阵A和矩阵B的元素。 2. Shuffle阶段：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值