基于物品的协同过滤推荐算法（矩阵相乘）

最新推荐文章于 2024-04-16 17:55:52 发布
最新推荐文章于 2024-04-16 17:55:52 发布
阅读量977 收藏
点赞数
分类专栏： 大数据应用 文章标签： hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010790770/article/details/43053501
版权

推荐系统一般都要用到矩阵相乘，其中涉及的算法比较复杂，经过几天几夜的冥思若想，终于独立的把这套算法用代码实现了。

所用技术：hadoop 1.1.2,

测试数据：(用户    电影名    评分)

待改进：对每个用户的推荐列表按评分进行排序

u0    冰0    1.0
u1    冰18    2.0
u1    冰4    4.5
u1    冰8    2.0
u2    冰7    4.5
u2    冰2    1.0
u2    冰11    2.5
u2    冰1    1.0
u2    冰19    2.5
u3    冰15    1.5
u3    冰16    1.5
u3    冰8    1.5
u4    冰17    1.5
u4    冰18    4.5

......

期望数据

u0    冰10:4.0
u0    冰7:5.0
u0    冰17:4.0
u0    冰6:2.0
u0    冰18:6.0
u0    冰5:5.0
u0    冰15:5.0
u0    冰4:6.0
u0    冰16:2.0
u0    冰3:2.0
u0    冰13:2.0
u0    冰2:3.0
u0    冰14:2.0
u0    冰1:3.0
u0    冰11:4.0
u0    冰12:4.0
u0    冰9:4.0
u0    冰19:4.0
u0    冰8:3.0
u1    冰10:47.0
u1    冰7:44.5
u1    冰17:52.5
u1    冰6:45.0
u1    冰5:42.5
u1    冰15:53.0
u1    冰16:30.0
u1    冰3:53.5
u1    冰13:31.5
u1    冰2:28.0
u1    冰14:47.0
u1    冰1:53.5
u1    冰11:18.5
u1    冰0:45.0
u1    冰12:51.0
u1    冰9:47.0
u1    冰19:49.0
u10    冰10:121.5
u10    冰7:111.0
u10    冰17:109.0
u10    冰6:72.0
u10    冰18:113.5

......

一、Main函数入口

package recom;

import java.util.regex.Pattern;

public class Recommonend {
    public static final Pattern DELIMITER = Pattern.compile("[\t,]");
    static final String RECOM_URL = "hdfs://hadoop0:9000/yu/recom";
    static final String input_Path0 = RECOM_URL+"/input";
    static final String output_Path0 = RECOM_URL+"/output";

    public static void main(String[] args)  throws Exception{
        String output_Path1 = output_Path0+"/step1";
        String output_Path2 = output_Path0+"/step2";
        String output_Path3 = output_Path0+"/step3";
        
        String output_Path3_1 = output_Path0+"/step3_1";
        String output_Path4 = output_Path0+"/step4";
        String[] paths1 = {input_Path0,output_Path1};
        String[] paths2 = {output_Path1,output_Path2};
        String[] paths3 = {output_Path2,output_Path3};
        String[] paths3_1 = {input_Path0,output_Path3_1};
        String[] paths4 = {output_Path3,output_Path3_1,output_Path4};
        Step1.run(paths1);
        Step2.run(paths2);
        Step3.run(paths3);
        Step3_1.run(paths3_1);
        Step4.run(paths4);
    }
}

二、读取原始测试数据(step1)

package recom;

import java.io.IOException;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;
import org.apache.hadoop.util.Tool;

public class Step1{
    public static void run(String[] args) throws Exception {
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(new URI(args[1]), conf);
        Path outPath = new Path(args[1]);
        if(fs.exists(outPath))
        {
            fs.delete(outPath, true);
        }
        Job job = new Job(conf,Step1.class.getSimpleName());
        FileInputFormat.setInputPaths(job, args[0]);
        job.setInputFormatClass(TextInputFormat.class);
        job.setMapperClass(MyMapper.class);
        job.setPartitionerClass(HashPartitioner.class);
        job.setNumReduceTasks(1);//设定运算分支个数
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileOutputFormat.setOutputPath(job, outPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        job.waitForCompletion(true);
        System.exit(0);
    }
    static class MyMapper extends Mapper<Object, Text, Text, Text>
    {
        Text outKey = new Text();
        Text outValue = new Text();
        @Override
        protected void map(Object key, Text value,
                Mapper<Object, Text, Text, Text>.Context ctx)
                throws IOException, InterruptedException {
            String[] vals = Recommonend.DELIMITER.split(value.toString());
            outKey.set(vals[0]);
            outValue.set(vals[1]+":"+vals[2]);
            ctx.write(outKey,outValue);
        }
    }
    
    static class MyReducer extends Reducer<Text, Text, Text, Text>
    {
        Text outValue = new Text();
        @Override
        protected void reduce(Text key, Iterable<Text> vals,
                Reducer<Text, Text, Text, Text>.Context ctx)
                throws IOException, InterruptedException {
            StringBuilder sb = new StringBuilder();
            for(Text val:vals)
            {
                sb.append(","+val);
            }
            outValue.set(sb.toString().replaceFirst(",", ""));
            ctx.write(key, outValue);
        }
    }
        
}
生成的数据如下：

u0    冰0:1.0
u1    冰18:2.0,冰4:4.5,冰8:2.0
u10    冰4:1.5,冰15:5.0,冰19:5.0,冰0:1.0,冰12:1.5,冰11:1.5,冰14:4.5
u11    冰5:2.0,冰18:3.0,冰6:3.0,冰7:3.0,冰19:2.0,冰0:4.5,冰4:0.0
u12    冰15:2.5,冰9:3.5,冰10:0.0,冰11:5.0,冰3:3.5,冰5:0.5
u13    冰18:2.5,冰6:5.0,冰19:4.0,冰12:1.5,冰14:1.0,冰16:0.0,冰5:2.0
u14    冰4:0.0,冰12:3.5
u15    冰4:0.0,冰3:4.5,冰12:0.5,冰18:0.5
u18    冰7:4.0,冰8:2.5,冰19:3.0,冰10:4.0,冰11:4.0,冰14:0.0,冰13:2.0,冰15:2.0
u19    冰16:1.5,冰9:4.5,冰5:3.5,冰10:4.0,冰3:2.0
u2    冰2:1.0,冰11:2.5,冰1:1.0,冰19:2.5,冰7:4.5
u20    冰6:3.5,冰13:1.0,冰3:3.0,冰19:3.5,冰8:0.5,冰4:0.5,冰15:0.0
u21    冰1:3.5,冰7:4.0,冰16:0.5,冰19:0.0,冰4:3.0,冰14:2.0,冰10:2.0
u22    冰6:4.0,冰18:4.5,冰4:2.0,冰1:3.0,冰10:1.5,冰8:4.0
u23    冰2:2.5,冰6:2.5,冰17:4.0
u24    冰14:4.0,冰17:4.0,冰3:5.0

......

三、生成电影推荐列表(step2)

package recom;

import java.io.IOException;
import java.net.URI;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

import recom.Step1.MyMapper;
import recom.Step1.MyReducer;


public class Step2 {
    public static void run(String[] args) throws Exception
    {
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(new URI(args[1]), conf);
        Path outPath = new Path(args[1]);
        if(fs.exists(outPath))
        {
            fs.delete(outPath, true);
        }
        Job job = new Job(conf,Step1.class.getSimpleName());
        FileInputFormat.setInputPaths(job, args[0]);
        job.setInputFormatClass(TextInputFormat.class);
        job.setMapperClass(MyMapper.class);
        job.setPartitionerClass(HashPartitioner.class);
        job.setNumReduceTasks(1);//设定运算分支个数
        job.setReducerClass(MyReducer.class);
        
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(LongWritable.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(LongWritable.class);
        FileOutputFormat.setOutputPath(job, outPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        job.waitForCompletion(true);
        System.exit(0);
    }
    static class MyMapper extends Mapper<Object, Text, Text, LongWritable>
    {
        Text outKey = new Text();
        LongWritable one = new LongWritable(1);
        @Override
        protected void map(Object key, Text vals,
                Mapper<Object, Text, Text, LongWritable>.Context ctx)
                throws IOException, InterruptedException {
            String[] ary = Recommonend.DELIMITER.split(vals.toString());
            for(int i=1;i<ary.length;i++)
            {
                String itemId1=ary[i].split(":")[0];
                for(int j=1;j<ary.length;j++)
                {
                    outKey.set(itemId1+":"+ary[j].split(":")[0]);
                    ctx.write(outKey, one);
                }
            }
        }
    }
    
    static class MyReducer extends Reducer<Text, LongWritable, Text, LongWritable>
    {
        LongWritable outValue = new LongWritable();
        @Override
        protected void reduce(Text key, Iterable<LongWritable> vals,
                Reducer<Text, LongWritable, Text, LongWritable>.Context ctx)
                throws IOException, InterruptedException {
            long sum = 0l;
            for(LongWritable val:vals)
            {
                sum+=val.get();
            }
            outValue.set(sum);
            ctx.write(key, outValue);
        }
    }

}

生成的数据结构如下：

冰0:冰0    17
冰0:冰1    3
冰0:冰10    4
冰0:冰11    4
冰0:冰12    4
冰0:冰13    2
冰0:冰14    2
冰0:冰15    5
冰0:冰16    2
冰0:冰17    4
冰0:冰18    6
冰0:冰19    4

......

四、对生成的电影列表作进一步处理（step3）

package recom;

import java.io.IOException;
import java.net.URI;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

import recom.Step2.MyMapper;
import recom.Step2.MyReducer;

public class Step3 {    
    static class MyMapper extends Mapper<Object, Text, Text, Text>
    {
        Text outKey =  new Text();
        Text outValue = new Text();
        
        @Override
        protected void setup(Context ctx)
                throws IOException, InterruptedException {
            System.out.println(ctx.getConfiguration().get("date"));
        }
        @Override
        protected void map(Object key, Text value,
                Mapper<Object, Text, Text, Text>.Context ctx)
                throws IOException, InterruptedException {
            //冰与火之歌0:冰与火之歌0    1172
            String[] vals = Recommonend.DELIMITER.split(value.toString());
            outKey.set("film&"+vals[0].split(":")[0]);//reduce阶段，结果集是按字符排序，为控制顺序，将key加上字符"film&"
            outValue.set(vals[0].split(":")[1]+":"+vals[1]);        
            ctx.write(outKey, outValue);
        }
    }
    
    static class MyReducer extends Reducer<Text, Text, Text, Text>
    {
        Text outValue = new Text();
        @Override
        protected void reduce(Text key, Iterable<Text> vals,
                Reducer<Text, Text, Text, Text>.Context ctx)
                throws IOException, InterruptedException {
            StringBuilder sb = new StringBuilder();
            for(Text val:vals)
            {
                sb.append(","+val);
            }
            outValue.set(sb.toString().replaceFirst(",", ""));
            ctx.write(key, outValue);
        }
    }
    
    public static void run(String[] args) throws Exception
    {
        Configuration conf = new Configuration();
        conf.set("date", "好大一棵树");
        FileSystem fs = FileSystem.get(new URI(args[1]), conf);
        Path outPath = new Path(args[1]);
        if(fs.exists(outPath))
        {
            fs.delete(outPath, true);
        }
        Job job = new Job(conf,Step3.class.getSimpleName());
        FileInputFormat.setInputPaths(job, args[0]);
        job.setInputFormatClass(TextInputFormat.class);
        job.setMapperClass(MyMapper.class);
        job.setPartitionerClass(HashPartitioner.class);
        job.setNumReduceTasks(1);//设定运算分支个数
        job.setReducerClass(MyReducer.class);
        
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileOutputFormat.setOutputPath(job, outPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        job.waitForCompletion(true);
        System.exit(0);
    }
}
生成的数据如下：

film&冰0    冰8:3,冰7:5,冰6:2,冰5:5,冰4:6,冰3:2,冰2:3,冰19:4,冰18:6,冰17:4,冰16:2,冰15:5,冰14:2,冰13:2,冰12:4,冰11:4,冰10:4,冰1:3,冰0:17,冰9:4
film&冰1    冰0:3,冰1:20,冰10:7,冰11:6,冰12:6,冰13:2,冰14:8,冰15:9,冰16:4,冰17:7,冰18:6,冰19:5,冰2:6,冰3:5,冰4:7,冰5:7,冰6:3,冰7:6,冰8:5,冰9:10
film&冰10    冰9:5,冰0:4,冰10:22,冰11:8,冰12:6,冰13:7,冰14:5,冰15:7,冰16:6,冰17:6,冰1:7,冰18:4,冰19:6,冰2:3,冰3:8,冰4:6,冰5:7,冰6:2,冰7:8,冰8:6
film&冰11    冰9:7,冰0:4,冰1:6,冰10:8,冰11:17,冰12:4,冰13:4,冰14:4,冰15:8,冰16:3,冰17:7,冰18:1,冰19:4,冰2:3,冰3:5,冰4:1,冰5:4,冰6:2,冰7:6,冰8:6
film&冰12    冰1:6,冰0:4,冰10:6,冰11:4,冰12:23,冰13:5,冰14:6,冰15:7,冰16:5,冰17:7,冰18:7,冰19:7,冰2:8,冰3:6,冰4:6,冰5:7,冰6:3,冰7:4,冰8:5,冰9:6
film&冰13    冰0:2,冰1:2,冰10:7,冰11:4,冰12:5,冰13:16,冰14:6,冰15:8,冰16:2,冰17:5,冰18:5,冰19:8,冰2:4,冰3:5,冰4:3,冰5:5,冰6:3,冰7:4,冰8:4,冰9:4
film&冰14    冰18:6,冰0:2,冰1:8,冰10:5,冰11:4,冰12:6,冰13:6,冰14:25,冰15:8,冰16:4,冰17:7,冰19:8,冰2:4,冰3:8,冰4:6,冰5:7,冰6:3,冰7:3,冰8:4,冰9:5
film&冰15    冰0:5,冰1:9,冰10:7,冰11:8,冰12:7,冰13:8,冰14:8,冰15:26,冰16:4,冰17:5,冰19:9,冰2:4,冰3:7,冰4:6,冰5:6,冰6:3,冰7:6,冰8:8,冰9:7,冰18:5
film&冰16    冰0:2,冰1:4,冰10:6,冰11:3,冰12:5,冰13:2,冰14:4,冰15:4,冰16:16,冰17:4,冰18:3,冰19:4,冰2:3,冰3:6,冰4:4,冰5:8,冰6:4,冰7:2,冰8:3,冰9:7
film&冰17    冰9:10,冰8:10,冰7:2,冰6:6,冰5:7,冰4:5,冰3:8,冰2:11,冰19:4,冰18:5,冰17:26,冰16:4,冰15:5,冰14:7,冰13:5,冰12:7,冰11:7,冰10:6,冰1:7,冰0:4
film&冰18    冰0:6,冰1:6,冰10:4,冰11:1,冰12:7,冰13:5,冰14:6,冰15:5,冰16:3,冰17:5,冰18:21,冰19:6,冰2:3,冰3:7,冰4:9,冰5:6,冰6:5,冰7:6,冰8:7,冰9:4
film&冰19    冰0:4,冰1:5,冰10:6,冰11:4,冰12:7,冰13:8,冰14:8,冰15:9,冰16:4,冰17:4,冰18:6,冰19:21,冰2:2,冰3:6,冰4:6,冰5:3,冰6:5,冰7:8,冰8:5,冰9:6
film&冰2    冰0:3,冰1:6,冰10:3,冰11:3,冰12:8,冰13:4,冰14:4,冰15:4,冰16:3,冰17:11,冰18:3,冰19:2,冰2:17,冰3:6,冰4:4,冰5:5,冰6:2,冰7:1,冰8:2,冰9:7
film&冰3    冰0:2,冰1:5,冰10:8,冰11:5,冰12:6,冰13:5,冰14:8,冰15:7,冰16:6,冰17:8,冰18:7,冰19:6,冰2:6,冰3:23,冰4:7,冰5:8,冰6:3,冰7:2,冰8:4,冰9:9
film&冰4    冰0:6,冰1:7,冰10:6,冰11:1,冰12:6,冰13:3,冰14:6,冰15:6,冰16:4,冰17:5,冰18:9,冰19:6,冰2:4,冰3:7,冰4:24,冰5:5,冰6:6,冰7:5,冰8:7,冰9:6
film&冰5    冰0:5,冰1:7,冰10:7,冰11:4,冰12:7,冰13:5,冰14:7,冰15:6,冰16:8,冰17:7,冰18:6,冰19:3,冰2:5,冰3:8,冰4:5,冰5:20,冰6:2,冰7:2,冰8:4,冰9:9
film&冰6    冰0:2,冰1:3,冰10:2,冰11:2,冰12:3,冰13:3,冰14:3,冰15:3,冰16:4,冰17:6,冰18:5,冰19:5,冰2:2,冰3:3,冰4:6,冰5:2,冰6:14,冰7:1,冰8:4,冰9:3
film&冰7    冰1:6,冰10:8,冰11:6,冰12:4,冰13:4,冰14:3,冰15:6,冰16:2,冰17:2,冰18:6,冰0:5,冰19:8,冰2:1,冰3:2,冰4:5,冰5:2,冰6:1,冰7:15,冰8:5,冰9:5
film&冰8    冰18:7,冰0:3,冰1:5,冰10:6,冰11:6,冰12:5,冰13:4,冰14:4,冰15:8,冰16:3,冰17:10,冰19:5,冰2:2,冰3:4,冰4:7,冰5:4,冰6:4,冰7:5,冰8:23,冰9:6
film&冰9    冰0:4,冰1:10,冰10:5,冰11:7,冰12:6,冰13:4,冰14:5,冰15:7,冰16:7,冰17:10,冰18:4,冰19:6,冰2:7,冰3:9,冰4:6,冰5:9,冰6:3,冰7:5,冰8:6,冰9:24

五、生成每个用户所看电影的评分表(step3_1)

package recom;

import java.io.IOException;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.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;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

import recom.Step3.MyMapper;
import recom.Step3.MyReducer;

public class Step3_1 {
    static class MyMapper extends Mapper<Object, Text, Text, Text>
    {
        Text outKey =  new Text();
        Text outValue = new Text();
        @Override
        protected void map(Object key, Text value,
                Mapper<Object, Text, Text, Text>.Context context)
                throws IOException, InterruptedException {
            //林志玲0    冰与火之歌25    1.5
            String[] vals = Recommonend.DELIMITER.split(value.toString());
            outKey.set("user&"+vals[0]); //reduce阶段，结果集是按字符排序，为控制顺序，将key加上字符"user&"。
            outValue.set(vals[1]+":"+vals[2]);
            context.write(outKey, outValue);
        }
    }
    
    static class MyReducer extends Reducer<Text, Text, Text, Text>
    {        
        Text outValue = new Text();
        @Override
        protected void reduce(Text key, Iterable<Text> vals,
                Reducer<Text, Text, Text, Text>.Context ctx)
                throws IOException, InterruptedException {
            StringBuilder sb = new StringBuilder();
            for(Text val:vals)
            {
                sb.append(","+val.toString());
            }
            outValue.set(sb.toString().replaceFirst(",", ""));
            ctx.write(key, outValue);
        }
    }
    
    public static void run(String[] args) throws Exception
    {
        Configuration conf = new Configuration();
        FileSystem fs = FileSystem.get(new URI(args[1]), conf);
        Path outPath = new Path(args[1]);
        if(fs.exists(outPath))
        {
            fs.delete(outPath, true);
        }
        Job job = new Job(conf,Step3_1.class.getSimpleName());
        FileInputFormat.setInputPaths(job, args[0]);
        job.setInputFormatClass(TextInputFormat.class);
        job.setMapperClass(MyMapper.class);
        job.setPartitionerClass(HashPartitioner.class);
        job.setNumReduceTasks(1);//设定运算分支个数
        job.setReducerClass(MyReducer.class);
        
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileOutputFormat.setOutputPath(job, outPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        job.waitForCompletion(true);
        System.exit(0);
    }

}
生成的数据如下：

user&u0    冰0:1.0
user&u1    冰18:2.0,冰4:4.5,冰8:2.0
user&u10    冰4:1.5,冰15:5.0,冰19:5.0,冰0:1.0,冰12:1.5,冰11:1.5,冰14:4.5
user&u11    冰5:2.0,冰18:3.0,冰6:3.0,冰7:3.0,冰19:2.0,冰0:4.5,冰4:0.0
user&u12    冰15:2.5,冰9:3.5,冰10:0.0,冰11:5.0,冰3:3.5,冰5:0.5
user&u13    冰18:2.5,冰6:5.0,冰19:4.0,冰12:1.5,冰14:1.0,冰16:0.0,冰5:2.0
user&u14    冰4:0.0,冰12:3.5
user&u15    冰4:0.0,冰3:4.5,冰12:0.5,冰18:0.5
user&u18    冰7:4.0,冰8:2.5,冰19:3.0,冰10:4.0,冰11:4.0,冰14:0.0,冰13:2.0,冰15:2.0
user&u19    冰16:1.5,冰9:4.5,冰5:3.5,冰10:4.0,冰3:2.0
user&u2    冰2:1.0,冰11:2.5,冰1:1.0,冰19:2.5,冰7:4.5
user&u20    冰6:3.5,冰13:1.0,冰3:3.0,冰19:3.5,冰8:0.5,冰4:0.5,冰15:0.0
user&u21    冰1:3.5,冰7:4.0,冰16:0.5,冰19:0.0,冰4:3.0,冰14:2.0,冰10:2.0
user&u22    冰6:4.0,冰18:4.5,冰4:2.0,冰1:3.0,冰10:1.5,冰8:4.0
user&u23    冰2:2.5,冰6:2.5,冰17:4.0
user&u24    冰14:4.0,冰17:4.0,冰3:5.0

......

六、生成最终的结果集(step4)

package recom;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.net.URI;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.FileSystem;
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.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;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

public class Step4 {
    public static void run(String[] args) throws Exception
    {
        Configuration conf = new Configuration();        
        FileSystem fs = FileSystem.get(new URI(args[2]), conf);
        Path outPath = new Path(args[2]);
        if(fs.exists(outPath))
        {
            fs.delete(outPath, true);
        }
        Job job = new Job(conf,Step4.class.getSimpleName());
//        FileInputFormat.setInputPaths(job, args[0]);
//        FileInputFormat.setInputPaths(job, args[1]);
        FileInputFormat.setInputPaths(job, new Path(args[1]),new Path(args[0]));
        job.setInputFormatClass(TextInputFormat.class);
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);
        job.setPartitionerClass(HashPartitioner.class);
        job.setNumReduceTasks(1);//设定运算分支个数        
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileOutputFormat.setOutputPath(job, outPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        job.waitForCompletion(true);
        System.exit(0);
    }
    
    static class MyMapper extends Mapper<Object, Text, Text, Text>
    {
        Text outKey = new Text();
        Text outValue = new Text();    
    
        @Override
        protected void map(Object key, Text value,
                Mapper<Object, Text, Text, Text>.Context ctx)                
                throws IOException, InterruptedException {
            String[] vals = value.toString().split("\t");
            outKey.set(vals[0]);
            outValue.set(vals[1]);
            ctx.write(outKey, outValue);            
        }
    }
    
    static class MyReducer extends Reducer<Text, Text, Text, Text>
    {        
        Text outKey = new Text();
        Text outValue = new Text();
        Map<String,Map<String,Long>> fileMap = new HashMap<String,Map<String,Long>>();
        
        @Override
        protected void reduce(Text key, Iterable<Text> vals,
                Reducer<Text, Text, Text, Text>.Context ctx)
                throws IOException, InterruptedException {
            for(Text val:vals)
            {        
                if(key.toString().startsWith("film&"))
                {
                    HashMap<String,Long> map = new HashMap<String, Long>();
                    String[] cts = val.toString().split(",");
                    for(String str:cts)
                    {
                        String[] ctr = str.split(":");
                        map.put(ctr[0], Long.parseLong(ctr[1]));
                    }
                    fileMap.put(key.toString().replaceFirst("film&", ""), map);
                }    
                
                
                else if(key.toString().startsWith("user&"))
                {        
                    for(Entry<String,Map<String,Long>> entry:fileMap.entrySet())
                    {
                        String fkey = entry.getKey();                        
                        String[] cts = val.toString().split(",");                        
                        boolean flag =  isContainKey(fkey, cts);
                        if(flag)
                        {
                            Map<String,Long> map = entry.getValue();
                            double sum = 0;
                            for(String scs:cts)
                            {
                                double score = Double.parseDouble(scs.split(":")[1]);
                                String dom = scs.split(":")[0];
                                Long times = map.get(dom);                            
                                sum+=score*times;
                            }
                            outKey.set(key.toString().replaceFirst("user&", ""));
                            outValue.set(fkey+":"+sum);
                            ctx.write(outKey, outValue);
                        }                
                    }    
                }
            }            
        }

        private boolean isContainKey(String fkey, String[] cts) {
            for(String skey:cts)
            {
                String tkey = skey.split(":")[0];
                if(fkey.equals(tkey))
                {
                    return false;
                }
            }
            return true;
        }        
    }
}






于枫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于矩阵分解的协同过滤推荐算法
m0_49956978的博客
11-30 888
针对于推荐算法的小白踩坑推荐
协同过滤算法之基于物品的推荐算法
weixin_44087528的博客
04-28 863
目前有关个性化推荐算法主要分为三大类：1.基于协同过滤的推荐；2.基于内容过滤的推荐和3.社会化推荐。 本文主要讨论基于协同过滤的推荐，而该算法也可以划分为两类： 1.基于用户的协同过滤算法（UserCF） 该算法利用用户之间的相似性来推荐用户感兴趣的信息，个人通过合作的机制给予信息相当程度的回应（如评分）并记录下来以达到过滤的目的进而帮助别人筛选信息，回应不一定局限于特别感兴趣的，特别不感兴趣信...
Hadoop案例之基于物品的协同过滤算法ItemCF
liushahe2012的博客
01-06 8939
Hadoop案例之基于物品的协同过滤算法ItemCF
大数据毕设 推荐系统设计与实现 协同过滤推荐算法
m0_76217654的博客
07-24 653
🔥 这两年开始毕业设计和毕业答辩的要求和难度不断提升，传统的毕设题目缺少创新和亮点，往往达不到毕业答辩的要求，这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的是🚩推荐系统设计与实现🥇学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：4分🧿推荐系统，是当今互联网背后的无名英雄。
38 | 矩阵（下）：如何使用矩阵操作进行协同过滤推荐？
qq_37756660的博客
04-16 1118
今天首先简要地介绍了推荐系统的概念和主要思想。为了给用户提供可靠的结果，推荐系统需要充分挖掘历史数据中，用户和物品之间的关系。协同过滤的推荐算法就很好地体现了这一点。一旦涉及用户和物品的这种二元关系，矩阵就有用武之地了。我通过矩阵来表示用户和物品的关系，并通过矩阵计算来获得协同过滤的结果。协同过滤分为基于用户的过滤和基于物品的过滤两种，它们的核心思想都是相同的，因此矩阵操作也是类似的。在这两个应用场景下，矩阵点乘体现了多个用户或者物品之间的相似程度，以及聚集后的相似程度所导致的最终推荐结果。
使用hadoop完成推荐算法
shuangyueliao的专栏
03-03 2227
基于物品的推荐算法 算法步骤 已知以上用户对物品的行为，假设点击行为得1分，搜索行为得3分，收藏5分，付款10分。请为用户推荐合适的物品。 1、从以上信息构建用户、物品的评分矩阵，如下图 2、由以上矩阵构建物品的相似度矩阵 如1号物品和2号物品，算出其第一行和第二行的余弦相似度，即可得出其第1号物品和第2号物品的相似度，最终得出6*6相似度矩阵 3、相似度矩阵*评分矩阵=推荐列表 左边是第...
物品推荐（基于物品的协同过滤算法）
weixin_34220963的博客
01-02 377
  用户对物品的评分矩阵 × 物品相似矩阵 = 推荐列表 构建物品相似度矩阵的时候可以通过计算两个物品的余弦相似度得出，于是需要构建每个物品在所有用户中的评分矩阵   本例中，不采用余弦相似度的方式计算物品与物品相似度 在MapReduce作业中，输入数据的格式是：用户，物品，评分 第一步、构建用于评分矩阵，表示如下： 第二步、构建物品相似度矩阵。这里采用的方法是...
基于矩阵分解的推荐算法
zhu_xian_gang的博客
04-25 1464
一、什么是推荐算法 二、学习矩阵分解之前，先了解一下协同过滤 2.1 什么是协同过滤 2.2 协同过滤存在的问题 三、矩阵分解 3.1什么是矩阵分解 3.2这里主要介绍BasicSVD算法 3.3实际应用 3.4代码实现 四、总结分析矩阵分解的优缺点
基于物品的协同过滤算法 （mapreduce）
02-21
协同过滤（Collaborative Filtering，简称CF）是推荐系统中最常用的一种算法，它基于用户的行为数据来预测他们可能感兴趣但尚未接触过的物品。而基于物品的协同过滤（Item-based Collaborative Filtering，简称IBCF...
python基于物品协同过滤算法实现代码
01-20
本次测试基于MovieLens数据集实现的基于物品的协同过滤，目前只是在小样本上实现，主要问题是计算太耗内存，后期代码继续优化与完善。 数据集说明：movies.dat中数据是用户对电影的评分。数据格式：UserID::...
基于物品的协同过滤推荐算法Python源码
01-24
基于物品的协同过滤推荐算法Demo An recommend algorithm based on ItemCF, use Python. the ininial data format like this ,for some reason,the original data file is not supported. 一个基于物品的协同过滤...
基于物品的协同过滤推荐算法(Python).zip
最新发布
05-19
基于物品的协同过滤算法：给用户推荐与他之前喜欢的物品相似的物品。 基于用户的协同过滤算法：给用户推荐与他兴趣相似的用户喜欢的物品。 协同过滤算法的优点包括： 无需事先对商品或用户进行分类或标注，适用于...
python基于协同过滤推荐算法的电影推荐系统源码.zip
06-08
python基于协同过滤推荐算法的电影推荐系统源码 python基于协同过滤推荐算法的电影推荐系统源码 python基于协同过滤推荐算法的电影推荐系统源码 python基于协同过滤推荐算法的电影推荐系统源码 python基于协同过滤...
推荐系统算法--ItemCF--MF(ALS)--FF
凝眸伏笔的博客
02-15 5562
1.ItemCF： 协同过滤是什么？ 协同过滤 (Collaborative filtering)，指的是，通过收集群体用户的偏好信息，自动化预测（过滤）个体用户可能感兴趣的内容。协（collaborating）是群体行为，过滤（filtering）则是针对个人的行为。 ItemCF：Item Collaboration Filter，基于物品的协同过滤。 核心......
MapReduce实现推荐算法（同现矩阵*评分矩阵=推荐结果）
asdfzjs的专栏
08-29 4322
该讲主要是基于ItemCF的物品推荐。 1，常用的两大协同过滤算法。 a,基于物品的协同过滤算法 基于item的协同过滤，通过用户对不同item的评分来评测item之间的相似性，基于item之间的相似性做出推荐。简单来讲就是：给用户推荐和他之前喜欢的物品相似的物品。 b,基于用户的协同过滤算法UserCF 基于用户的协同过滤，通过不同用户对物品的评分来评测用户之间的相似性，基于用
物品推荐算法分析
weixin_40738426的博客
09-12 1721
因为老师给的代码和网上看到的一些都不是很满意，所以这里记录一下自己的一些关于物品相似度的算法分析。 这里介绍的是简单的物品推荐算法分析： 先介绍一些关于物品推荐算法的一些基本的概念： 物品相似度用一个用户的喜欢的物品决定。 这里物品相似度的定义就是说有用户评分的几个物品， 只要他们有分数（不为0），就说这两个物品有关联（相似）。 例如下面这个用户3，显然物品101，104，105，107有评分，那么就可以说101，104有关联，101，105有关联，104，105有关联，类似的，这几个有评分的两两组合。 注
大数据Hadoop学习之————基于物品的协同过滤算法实现物品推荐
xdkb159的博客
08-19 2879
一、实现基础 1、用户对物品的推荐列表（用户为列，物品为行） = 用户对物品的评分矩阵 × 物品同现矩阵 2、用户对物品的评分矩阵：用户对物品的点击、收藏、加购物车和购买等行为都是对物品的不同评分，矩阵如下： 并且，矩阵可以进行行列转换 3、物品同现矩阵：两个物品出现在同一个用户的次数，即item1和item2都出现在user1和user3，所以item1:item2的同现值为2，当然item2:item1的同现值也为2，所以物...
基于MapReduce的ItemBase推荐算法的共现矩阵实现（一）
weixin_33836874的博客
09-22 314
一、概述    这2个月研究根据用户标签情况对用户的相似度进行评估，其中涉及一些推荐算法知识，在这段时间研究了一遍《推荐算法实践》和《Mahout in action》，在这里主要是根据这两本书的一些思想和自己的一些理解对分布式基于ItemBase的推荐算法进行实现。其中分两部分，第一部分是根据共现矩阵的方式来简单的推算出用户的推荐项，第二部分则是通过传统的相似度矩阵的方法来实践ItemBase推...
推荐算法
慧有未来
05-08 288
相似度种类：    余弦相似度  切比雪夫距离   皮尔森系数   杰卡德距离   欧式相似度  曼哈顿距离 基于物品的协同过滤推荐算法（ItemCF）    用户行为与权重        1.点击---1分        2.搜索---3.0分        3.收藏---5分        4.付款---10分   算法思想：给他们推荐那些和他们之前喜欢的物品相似的物品      相似度矩阵X...
基于物品协同过滤推荐算法python
05-26
物品协同过滤推荐算法是一种基于物品相似度的推荐算法，它通过计算物品之间的相似度来为用户提供个性化推荐。下面是一个基于Python的物品协同过滤推荐算法的示例代码： ```python import numpy as np # 创建数据集...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值