协同过滤算法（下）

最新推荐文章于 2021-10-13 16:30:56 发布
最新推荐文章于 2021-10-13 16:30:56 发布
阅读量365 收藏 1
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Thomas__li/article/details/79228926
版权

接《上》

一、MR步骤：

第一个MR 就是把输入数据的每个用户的信息整合下：

userid:1,vector:{103:2.5,102:3.0,101:5.0} 

userid:2,vector:{104:2.0,103:5.0,102:2.5,101:2.0} 

userid:3,vector:{107:5.0,105:4.5,104:4.0,101:2.5} 

userid:4,vector:{106:4.0,104:4.5,103:3.0,101:5.0} 

userid:5,vector:{106:4.0,105:3.5,104:4.0,103:2.0,102:3.0,101:4.0} 

 

public void map(LongWritable key,Textvalue,Context context) throws IOException, InterruptedException{ 

        

VarLongWritable userID=newVarLongWritable(); 

LongWritable itemID=new LongWritable(); 

FloatWritable itemValue=newFloatWritable(); 

String line=value.toString(); 

String[]info=line.split(","); 

if(info.length!=3){ return; }    //uid,itemid,preference

userID.set(Long.parseLong(info[0])); 

itemID.set(Long.parseLong(info[1])); 

itemValue.set(Float.parseFloat(info[2])); 

context.write(userID, newLongAndFloat(itemID,itemValue)); 

} 

 

public class WiKiReducer1 extends Reducer<VarLongWritable,LongAndFloat,VarLongWritable,VectorWritable> {  

      

        public void reduce(VarLongWritable userID,Iterable<LongAndFloat> itemPrefs,Context context) throws IOException, InterruptedException{  

            // RandomAccessSparseVector(int cardinality, int initialCapacity)   

            Vector userVector=new RandomAccessSparseVector(Integer.MAX_VALUE,10);  

            for(LongAndFloat itemPref:itemPrefs){  

                userVector.set(Integer.parseInt(itemPref.getFirst().toString()),Float.parseFloat(itemPref.getSecond().toString()) );  

            }  

            context.write(userID, new VectorWritable(userVector));  

    //      System.out.println("userid:"+userID+",vector:"+userVector);  

        }  

 

类 LongAndFloat 用于存储数据并实现Writable的数据类型

------------------------------------------------------------------------------------------------------------

public class LongAndFloat implements WritableComparable<LongAndFloat> {  

    private LongWritable first;  

    private FloatWritable second;  

    public LongAndFloat(){  

        set(new LongWritable(),new FloatWritable());  

    }  

    public LongAndFloat(LongWritable l,FloatWritable f){  

        set(l,f);  

    }  

    public  void set(LongWritable longWritable, FloatWritable intWritable) {  

        // TODO Auto-generated method stub  

        this.first=longWritable;  

        this.second=intWritable;  

    }  

    public LongWritable getFirst(){  

        return first;  

    }  

    public FloatWritable getSecond(){  

        return second;  

    }  

    @Override  

    public void readFields(DataInput arg0) throws IOException {  

        // TODO Auto-generated method stub  

        first.readFields(arg0);  

        second.readFields(arg0);  

    }  

    @Override  

    public void write(DataOutput arg0) throws IOException {  

        // TODO Auto-generated method stub  

        first.write(arg0);  

        second.write(arg0);  

    }  

    @Override  

    public int compareTo(LongAndFloat o) {  

        // TODO Auto-generated method stub  

        int cmp=first.compareTo(o.first);  

        if(cmp!=0){  

            return cmp;  

        }  

        return second.compareTo(o.second);  

    }     

}  

 

 

二、第二个MR：

输入数据为MR(1) 的输出，只是项目item的相似度，先不管用户ID，直接对后面的所有项目进行拆分。

输出应该类似下面：

Item_id1:Item_id2        次数

101,{107:1.0,106:2.0,105:2.0,104:4.0,103:4.0,102:3.0,101:5.0} 

102,{106:1.0,105:1.0,104:2.0,103:3.0,102:3.0,101:3.0} 

 

1.main

 public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {  

        // TODO Auto-generated method stub  

        Configuration conf1 = new Configuration();  

        String[] otherArgs = new GenericOptionsParser(conf1, args).getRemainingArgs();        

        if (otherArgs.length != 2) {  

          System.err.println("Usage: WiKiDriver2 <in> <out>");  

          System.exit(2);  

        }  

        Job job1 = new Job(conf1, "wiki  job two");  

        job1.setNumReduceTasks(1);  

        job1.setJarByClass(WiKiDriver2.class);  

        job1.setInputFormatClass(SequenceFileInputFormat.class);  

        job1.setMapperClass(WikiMapper2.class);  

        job1.setMapOutputKeyClass(IntWritable.class);  

        job1.setMapOutputValueClass(IntWritable.class);  

        job1.setReducerClass(WiKiReducer2.class);  

        job1.setOutputKeyClass(IntWritable.class);  

        job1.setOutputValueClass(VectorWritable.class);  

        job1.setOutputFormatClass(SequenceFileOutputFormat.class);  

        SequenceFileInputFormat.addInputPath(job1, new Path(PATH+otherArgs[0]));  

        SequenceFileOutputFormat.setOutputPath(job1, new Path(PATH+otherArgs[1]));     

        if(!job1.waitForCompletion(true)){  

            System.exit(1); // run error then exit  

        }  

    }  

 

2.Mapper

publicclass WikiMapper2 extends Mapper<VarLongWritable,VectorWritable,IntWritable,IntWritable>{ 

     

    public void map(VarLongWritableuserID,VectorWritable userVector,Context context) throws IOException,InterruptedException{ 

        Iterator<Vector.Element>it=userVector.get().iterateNonZero(); 

        while(it.hasNext()){ 

            int index1=it.next().index(); 

    //     System.out.println("index1:"+index1); 

            Iterator<Vector.Element>it2=userVector.get().iterateNonZero(); 

            while(it2.hasNext()){ 

                intindex2=it2.next().index();                   

                //  test 

                /*if(index1==101){

                    System.out.println("index1:"+index1+",index2:"+index2);

                }*/ 

                context.write(newIntWritable(index1), new IntWritable(index2)); 

            } 

        } 

    } 

} 

3.reduce

public class WiKiReducer2 extendsReducer<IntWritable,IntWritable,IntWritable,VectorWritable> {       

       public void reduce(IntWritable itemIndex1,Iterable<IntWritable>itemPrefs,Context context) throws IOException, InterruptedException{ 

           // RandomAccessSparseVector(intcardinality, int initialCapacity)  

           Vector itemVector=newRandomAccessSparseVector(Integer.MAX_VALUE,10); 

           for(IntWritable itemPref:itemPrefs){ 

                intitemIndex2=itemPref.get(); 

                itemVector.set(itemIndex2,itemVector.get(itemIndex2)+1.0); 

           } 

           context.write(itemIndex1, new VectorWritable(itemVector)); 

                     // System.out.println(itemIndex1+","+itemVector); 

       } 

} 

 

三、第三个MR：

含有两个Mapper，第一个MR(31)把MR(2)的输出的格式转为VectorOrPrefWritable;

 

MR2为用户评分矩阵

Item_id   user_id:preference

101,{107:1.0,106:2.0,105:2.0,104:4.0,103:4.0,102:3.0,101:5.0} 

 

MR(32)针对MR(1)的输出把每一个项目ID和用户ID作为一对进行输出，输出格式也为VectorOrPrefWritable;

 

MR1生成物品同现矩阵

Item_id1:Item_id2        次数

userid:5,vector:{106:4.0,105:3.5,104:4.0,103:2.0,102:3.0,101:4.0}

 

VectorOrPrefWritable

input: MR2的输出userVectors

map: 输出：(itemId,VectorOrPrefWritable<userId, pref>)

1.main

public static void main(String[] args)throws IOException, ClassNotFoundException, InterruptedException { 

       // TODO Auto-generated method stub 

       Configuration conf1 = new Configuration(); 

         

       String[] otherArgs = new GenericOptionsParser(conf1,args).getRemainingArgs();       

       if (otherArgs.length != 2) { 

         System.err.println("Usage: WiKiDriver31 <in><out>"); 

         System.exit(2); 

       } 

       Job job1 = new Job(conf1, "wiki job three1");  

       job1.setOutputFormatClass(SequenceFileOutputFormat.class); 

       job1.setInputFormatClass(SequenceFileInputFormat.class); 

       job1.setNumReduceTasks(1); 

       job1.setJarByClass(WiKiDriver31.class); 

       job1.setMapperClass(WikiMapper31.class); 

       job1.setMapOutputKeyClass(IntWritable.class); 

       job1.setMapOutputValueClass(VectorOrPrefWritable.class); 

         

       // set a reducer only to use SequenceFileOutputFormat 

       job1.setReducerClass(WiKiReducer31.class); 

       job1.setOutputKeyClass(IntWritable.class); 

       job1.setOutputValueClass(VectorOrPrefWritable.class); 

         

       // this MR's input is the MR2's output 

       SequenceFileInputFormat.addInputPath(job1, newPath(PATH+otherArgs[0])); 

       SequenceFileOutputFormat.setOutputPath(job1, newPath(PATH+otherArgs[1]));    

       if(!job1.waitForCompletion(true)){ 

           System.exit(1); // run error then exit 

       } 

   }   

} 

 

2map

publicclass WikiMapper31 extends Mapper<IntWritable,VectorWritable,IntWritable,VectorOrPrefWritable>{ 

     

    public void map(IntWritablekey,VectorWritable value,Context context) throws IOException, InterruptedException{ 

         

                context.write(key, newVectorOrPrefWritable(value.get())); 

        //     System.out.println("key"+key.toString()+",vlaue"+value.get()); 

            } 

    } 

 

3.reduce

public class WiKiReducer31 extends Reducer<IntWritable ,VectorOrPrefWritable,IntWritable,VectorOrPrefWritable> {  

    public void reduce(IntWritable key,Iterable<VectorOrPrefWritable> values ,Context context ) throws IOException, InterruptedException{            

        for(VectorOrPrefWritable va:values){  

            context.write(key, va);          }  

    }  

}  

四、第四个MR：

MR4的map不做任何事情；MR4的reduce输出就是把MR(31)和MR(32)的相同的itemID整合一下而已(注意此处的输入为两个路径)：如下：

101 {107:1.0,106:2.0,105:2.0,104:4.0,103:4.0,102:3.0,101:5.0} [5 1 4 23] [4.0 5.0 5.0 2.0 2.5] 

 

101共现矩阵

101{107:1.0,106:2.0,105:2.0,104:4.0,103:4.0,102:3.0,101:5.0}

101用户评分矩阵

[5 1 4 2 3] [4.0 5.0 5.0 2.0 2.5]

Item_id   user_id:preference

101      2:2.0

101      5:4.0

101      4:5.0

101      3:2.0

101      1:5.0

1.main

public static void main(String[] args)throws IOException, ClassNotFoundException, InterruptedException { 

       // TODO Auto-generated method stub 

       Configuration conf1 = new Configuration(); 

       String[] otherArgs = new GenericOptionsParser(conf1,args).getRemainingArgs();       

       if (otherArgs.length != 3) { 

         System.err.println("Usage: WiKiDriver4 <in1><in2><out>"); 

         System.exit(2); 

       } 

       Job job1 = new Job(conf1, "wiki job four"); 

       job1.setNumReduceTasks(1); 

       job1.setJarByClass(WiKiDriver4.class); 

       job1.setInputFormatClass(SequenceFileInputFormat.class); 

       job1.setMapperClass(WikiMapper4.class);  

       job1.setMapOutputKeyClass(IntWritable.class); 

       job1.setMapOutputValueClass(VectorOrPrefWritable.class);     

       job1.setReducerClass(WiKiReducer4.class); 

       job1.setOutputKeyClass(IntWritable.class); 

      job1.setOutputValueClass(VectorAndPrefsWritable.class); 

       job1.setOutputFormatClass(SequenceFileOutputFormat.class); 

       SequenceFileInputFormat.addInputPath(job1, newPath(PATH+otherArgs[0])); 

       SequenceFileInputFormat.addInputPath(job1, new Path(PATH+otherArgs[1])); 

       SequenceFileOutputFormat.setOutputPath(job1, newPath(PATH+otherArgs[2]));    

       if(!job1.waitForCompletion(true)){ 

           System.exit(1); // run error then exit 

       } 

   } 

} 

 

2.map

public class WikiMapper4 extends Mapper<IntWritable ,VectorOrPrefWritable,IntWritable,VectorOrPrefWritable> {    

    public void map(IntWritable key,VectorOrPrefWritable value,Context context) throws IOException, InterruptedException{  

        context.write(key, value);  

    }  

}  

 

3.reduce

public class WiKiReducer4 extendsReducer<IntWritable,VectorOrPrefWritable,IntWritable,VectorAndPrefsWritable>{ 

       public void reduce(IntWritable key, Iterable<VectorOrPrefWritable>values,Context context) throws IOException, InterruptedException{ 

           List<Long> userfs=new ArrayList<Long>();  //userID

           List<Float> prefs=new ArrayList<Float>();  // pref

           Vector v=null; 

           for(VectorOrPrefWritable value:values){ 

               if(value.getVector()!=null){ 

                    v=value.getVector(); 

                }else{ 

                   userfs.add(value.getUserID()); 

                   prefs.add(value.getValue()); 

                 } 

           } 

           context.write(key, new VectorAndPrefsWritable(v,userfs,prefs)); 

   //System.out.println("key ,itemid:"+key.toString()+",information:"+v+","+userfs+","+prefs); 

       }  

} 

 

 

五、第五个MR：

map:针对MR4的输出的每一行中的每一个用户，用这个用户的评分值(value)去乘以项目之间的相似度向量，比如针对第一条记录中的用户3，则有 Vectorforuser3=[1.0 2.0 2.0 4.0 4.0 3.0 5.0]* 2.5  则map的输出为 key :3    value :  Vectorforuser3;

map的输出应该如下所示：

alluserids:[5, 1, 4, 2, 3]  

,userid:5,vector:{107:4.0,106:8.0,105:8.0,104:16.0,103:16.0,102:12.0,101:20.0}  

,userid:1,vector:{107:5.0,106:10.0,105:10.0,104:20.0,103:20.0,102:15.0,101:25.0}  

,userid:4,vector:{107:5.0,106:10.0,105:10.0,104:20.0,103:20.0,102:15.0,101:25.0}  

,userid:2,vector:{107:2.0,106:4.0,105:4.0,104:8.0,103:8.0,102:6.0,101:10.0}  

,userid:3,vector:{107:2.5,106:5.0,105:5.0,104:10.0,103:10.0,102:7.5,101:12.5}  

 

Combine : 针对map的输出，把相同 key(即userID)的向量对应相加，得到的向量和即为该userID的对各个项目的评分；

combine的输出应该如下所示：

userid:1,vecotr:{107:5.0,106:18.0,105:15.5,104:33.5,103:39.0,102:31.5,101:44.0} 

userid:2,vecotr:{107:4.0,106:20.5,105:15.5,104:36.0,103:41.5,102:32.5,101:45.5} 

Reduce:针对combine的输出，把用户已经评价过分的项目筛选掉，然后按照评分值的大小有大到小排序输出，即为用户推荐项目；

最后的输出为：

1  [104:33.5,106:18.0,105:15.5,107:5.0] 

2  [106:20.5,105:15.5,107:4.0] 

3  [103:26.5,102:20.0,106:17.5] 

4  [102:37.0,105:26.0,107:9.5] 

5  [107:11.5] 

 

1.main

public static void main(String[] args)throws IOException, ClassNotFoundException, InterruptedException {

       Configuration conf1 = new Configuration(); 

       String[] otherArgs = new GenericOptionsParser(conf1,args).getRemainingArgs();       

       if (otherArgs.length != 2) { 

         System.err.println("Usage: WiKiDriver5 <in><out>"); 

         System.exit(2); 

       } 

       Job job1 = new Job(conf1, "wiki job five"); 

       job1.setNumReduceTasks(1); 

       job1.setJarByClass(WiKiDriver5.class); 

       job1.setInputFormatClass(SequenceFileInputFormat.class); 

       job1.setMapperClass(WikiMapper5.class);  

       job1.setMapOutputKeyClass(VarLongWritable.class); 

       job1.setMapOutputValueClass(VectorWritable.class); 

         

       job1.setCombinerClass(WiKiCombiner5.class); 

       job1.setReducerClass(WiKiReducer5.class); 

       job1.setOutputKeyClass(VarLongWritable.class); 

       job1.setOutputValueClass(RecommendedItemsWritable.class); 

   //  job1.setOutputFormatClass(SequenceFileOutputFormat.class); 

       SequenceFileInputFormat.addInputPath(job1, new Path(PATH+otherArgs[0])); 

 

       FileOutputFormat.setOutputPath(job1, new Path(PATH+otherArgs[1]));    

       if(!job1.waitForCompletion(true)){ 

           System.exit(1); // run error then exit 

       } 

   } 

} 

 

2.Map

publicclass WikiMapper5 extends Mapper<IntWritable,VectorAndPrefsWritable,VarLongWritable,VectorWritable>{       

    public void map(IntWritablekey,VectorAndPrefsWritable vectorAndPref,Context context) throws IOException,InterruptedException{ 

        Vector coo=vectorAndPref.getVector(); 

        List<Long>userIds=vectorAndPref.getUserIDs(); 

        List<Float>prefValues=vectorAndPref.getValues(); 

       //System.out.println("alluserids:"+userIds); 

        for(inti=0;i<userIds.size();i++){ 

            long userID=userIds.get(i); 

            floatprefValue=prefValues.get(i); 

            Vectorpar=coo.times(prefValue); 

            context.write(newVarLongWritable(userID), new VectorWritable(par)); 

            //System.out.println(",userid:"+userID+",vector:"+par);  //  ifthe user id = 3 is the same as my paper then is right 

        }    

    } 

} 

3.combine

publicclass WiKiCombiner5 extendsReducer<VarLongWritable,VectorWritable,VarLongWritable,VectorWritable>{ 

        public void reduce(VarLongWritable key,Iterable<VectorWritable> values,Context context) throws IOException,InterruptedException{ 

            Vector partial=null; 

            for(VectorWritable v:values){ 

               partial=partial==null?v.get():partial.plus(v.get()); 

            } 

            context.write(key, newVectorWritable(partial)); 

           System.out.println("userid:"+key.toString()+",vecotr:"+partial);//   here also should be the same as my paper'sresult 

        } 

} 

4.reduce

publicclass WiKiReducer5 extendsReducer<VarLongWritable,VectorWritable,VarLongWritable,RecommendedItemsWritable>{       

    private intrecommendationsPerUser=RECOMMENDATIONSPERUSER; 

    private String path=JOB1OUTPATH;       

    private staticFastMap<Integer,String> map=new FastMap<Integer,String>(); 

    public void setup(Context context) throwsIOException{ 

        Configuration conf=newConfiguration(); 

        FileSystemfs=FileSystem.get(URI.create(path), conf); 

       Path tempPath=new Path(path); 

        SequenceFile.Reader reader=null; 

        try { 

            reader=new SequenceFile.Reader(fs,tempPath, conf); 

            Writablekey=(Writable)ReflectionUtils.newInstance(reader.getKeyClass(),conf); 

            Writable value = (Writable)ReflectionUtils.newInstance(reader.getValueClass(), conf);  

        // long position = reader.getPosition();   

            while (reader.next(key, value)){   

               map.put(Integer.parseInt(key.toString()), value.toString()); 

        //     System.out.println(key.toString()+","+value.toString()); 

            //    position = reader.getPosition(); //beginning of next record   

            } 

        } catch (Exception e) { 

            // TODO Auto-generated catchblock 

            e.printStackTrace(); 

        }   

    } 

 

public void reduce(VarLongWritable key,Iterable<VectorWritable> values,Context context) throws IOException,InterruptedException{ 

         

           int userID=(int)key.get(); 

           Vector rev=null; 

           for(VectorWritable vec:values){ 

                rev=rev==null?vec.get():rev.plus(vec.get()); 

           } 

           Queue<RecommendedItem>topItems=new PriorityQueue<RecommendedItem>( 

                   recommendationsPerUser+1, 

                   Collections.reverseOrder(ByValueRecommendedItemComparator.getInstance()) 

                    ); 

           Iterator<Vector.Element>recommendationVectorIterator= 

                    rev.iterateNonZero(); 

           while(recommendationVectorIterator.hasNext()){ 

                Vector.Elemente=recommendationVectorIterator.next(); 

                int index=e.index(); 

                System.out.println("Vecotr.element.indxe:"+index);  // test here  find the index is itemid or not  ** test result : index isitem 

               if(!hasItem(userID,String.valueOf(index))){ 

                    float value=(float)e.get(); 

                    if(topItems.size()<recommendationsPerUser){ 

                        //  here only set index 

                        topItems.add(newGenericRecommendedItem(index,value)); 

                    }elseif(value>topItems.peek().getValue()){ 

                        topItems.add(newGenericRecommendedItem(index,value)); 

                        topItems.poll(); 

                    } 

                } 

           } 

           List<RecommendedItem>recom=newArrayList<RecommendedItem>(topItems.size()); 

            recom.addAll(topItems); 

           Collections.sort(recom,ByValueRecommendedItemComparator.getInstance()); 

           context.write(key, new RecommendedItemsWritable(recom));         

       } 

     

   public static boolean hasItem(int user,String item){  // to check whether the user has rate theitem 

       boolean flag=false; 

       String items=map.get(user); 

       if(items.contains(item)){ 

           flag=true; 

       } 

       return flag; 

   } 

} 

 

最后一个reducer的编写基本思路：在Reducer的setup函数中读取SequenceFile的数据，这个数据是MR1的输出数据，用来排除用户已经评价过的项目。

在最后一个Reducer中我也用了一个FastMap,这个类是Mahout的，应该用他提供的一些类会运行的更加快吧。


Thomas__li
关注
专栏目录
协同过滤算法 java源码 毕设demo
03-02
协同过滤算法 java源码 协同过滤常常被用于分辨某位特定顾客可能感兴趣的东西，这些结论来自于对其他相似顾客对哪些产品感兴趣的分析。协同过滤以其出色的速度和健壮性，在全球互联网领域炙手可热。
Hadoop笔记之三:WordCount实验续
luchi007的专栏
11-11 1258
## 引言 ## 在上一篇的文章中，基本了解了Hadoop的Map-Reduce大致框架，根据官方教程，对WordCount实验有了新的补充，补充基本是在Map-Reduce中加入作业Job的一些控制信息，这就来看下。 ## 实验 ## 先上文档的代码package com.luchi.wordcount;import java.io.BufferedReader; import jav
MapReduce进阶
Antg的博客
10-13 215
一.HDFS数据格式 1.文件格式 2.压缩格式 3.设置mr的输出格式 例子:设置输出格式为gzip shell命令启动时要携带对应的参数: # 命令太长时 可以用 \ 新开一行 yarn jar aaa.jar com.aaa.main.Wordcount \ -Dmapred.output.compress=true \ -Dmapred.output.compression.codec=org.apache.hadoop.io.compressGzipCodec \ 输入路径 输出路径 启动类
数据挖掘——商品推荐和大数据处理
zkinglin's blog
04-16 3655
亲和性分析——商品推荐一、Hadoop云计算基础第1关：WordCount词频统计第2关：HDFS文件读写第3关：倒排索引第4关： 网页排序——PageRank算法二、亲和性分析——商品推荐第1关：使用 Numpy 加载文件中的数据（一）相关知识1>Numpy 是什么2>使用 Numpy 加载文件中的数据（二）编程要求（三）参考代码第2关：处理 Numpy 加载到的数据（一）相关知识1>将文字规则用数值表示2>处理从 Data 中获取的数据（二）编程要求（三）参考代码第3关：商品推荐
从零开始学习Hadoop--第2章 第一个MapReduce程序
uhgrft4645的博客
05-02 1172
1.Hadoop从头说 1.1 Google是一家做搜索的公司 做搜索是技术难度很高的活。首先要存储很多的数据，要把全球的大部分网页都抓下来，可想而知存储量有多大。然后，要能快速检索网页，用户输入几个关键词找资料，越快越好，最好在一秒之内出结果。如果全球每秒有上亿个用户在检索，只有一两秒的检索时间，要在全球的网页里找到最合适的检索结果，难度很大。如果你准备了解大数据开发或是正在学习大数据开发,...
HDFS和MapReduce综合实训
AtlantisChina
12-16 4033
EduCoder上的大数据技术原理与应用的实训项目，实训项目地址：https://www.educoder.net/shixuns/aekgf6pz/challenges
基于MovieLens-1M数据集实现的协同过滤算法demo.zip
最新发布
05-19
协同过滤算法（Collaborative Filtering）是一种经典的推荐算法，其基本原理是“协同大家的反馈、评价和意见，一起对海量的信息进行过滤，从中筛选出用户可能感兴趣的信息”。它主要依赖于用户和物品之间的行为关系...
基于模型的协同过滤算法.zip
05-19
协同过滤算法（Collaborative Filtering）是一种经典的推荐算法，其基本原理是“协同大家的反馈、评价和意见，一起对海量的信息进行过滤，从中筛选出用户可能感兴趣的信息”。它主要依赖于用户和物品之间的行为关系...
基于协同过滤算法商品推荐系统论文-java-文档-基于协同过滤算法商品推荐系统文档
02-22
### 基于协同过滤算法的商品推荐系统设计与实现 #### 一、绪论 - **选题动因**：随着互联网技术的发展和电子商务平台的兴起，如何在海量的商品信息中帮助用户找到他们真正感兴趣的商品成为了商家面临的一个重大...
python基于物品协同过滤算法实现代码
01-20
本次测试基于MovieLens数据集实现的基于物品的协同过滤，目前只是在小样本上实现，主要问题是计算太耗内存，后期代码继续优化与完善。 数据集说明：movies.dat中数据是用户对电影的评分。数据格式：UserID::...
hadoop 第一个 mapreduce 程序（对MapReduce的几种固定代码的理解）
weixin_38166905的博客
09-04 456
1.2MapReduce 和 HDFS 是如何工作的 MapReduce 其实是两部分，先是 Map 过程，然后是 Reduce 过程。从词频计算来说，假设某个文件块里的一行文字是”Thisis a small cat. That is a smalldog.”，那么，Map 过程会对这一行进行处理，将每个单词从句子解析出来，依次生成形如<“this”,1>, <”i...
关于Hadoop的GenericOptionsParser…
leexurui的专栏
08-29 5882
由于集群为hadoop配置了执行队列，所以如果我们程序写成下面这样的话：           Configuration conf = new Configuration();      String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();       ...........      File
hadoop fs命令无法使用_关于hadoop的GenericOptionsParser类
weixin_39781599的博客
11-29 670
原文链接琐碎-关于hadoop的GenericOptionsParser类 - Daem0n - 博客园​www.cnblogs.comhadoop源代码分析（4）-org.apache.hadoop.util包-GenericOptionsParser类【原创】 - 草原战狼 - 博客园​www.cnblogs.comGenericOptionsParser 命令行解析器是hadoop框架中解析...
琐碎-关于hadoop的GenericOptionsParser类
weixin_33800593的博客
10-29 234
GenericOptionsParser 命令行解析器 是hadoop框架中解析命令行参数的基本类。它能够辨别一些标准的命令行参数，能够使应用程序轻易地指定namenode，jobtracker，以及其他额外的配置资源 有篇日志写的很好，自己就不赘述了：http://www.cnblogs.com/caoyuanzhanlang/archive/2013/02/21/2920934.htm...
MapReduce 编程实战
zhiwenganyong的博客
06-17 1797
MapReduce 采用了「分而治之」的思想。在分布式计算中，MapReduce 框架负责处理并行编程中分布式存储、工作调度、负载均衡、容错均衡、容错处理以及网络通信等复杂问题，把处理过程高度抽象为两个函数：map，把一个任务分解成多个任务；reduce，将任务的处理结果汇总。MapReduce 处理的数据集（或任务）必须具备这样的特点：待处理的数据集可以分解成许多小的数据集，而且每一个小数据集都可以完全并行地进行处理。 在 Hadoop 中，每个 MapReduce 任务都被初始化为一个 Job，每个
Hadoop如何实现关联计算
u012388497的专栏
11-06 763
转贴存档，原帖地址：http://datamachine.iteye.com/admin/blogs/1963256。     选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。      以关联计算为例。      假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单
mapreduce程序编写（大数据学习跟进）
myhirra的专栏
03-06 7097
折腾了半天。终于编写成功了第一个自己的mapreduce程序，并通过打jar包的方式运行起来了。 运行环境：windows 64bit      eclipse 64bit     jdk6.0 64bit 一、工程准备 1、新建java project 2、导入jar包 新建一个user library 把hadoop文件夹里的hadoop-core和lib包里的所有包都导
跟我一起学【Hadoop开发】之—— hadoop的GenericOptionsParser类
SunWuKong_Hadoop的博客
07-12 1090
GenericOptionsParser 命令行解析器 是hadoop框架中解析命令行参数的基本类。它能够辨别一些标准的命令行参数，能够使应用程序轻易地指定namenode，jobtracker，以及其他额外的配置资源 有篇日志写的很好，自己就不赘述了：传送门 例子： 最简单的在WordCount中用到了： Configuration conf = new Configuration(...
协同过滤算法原理及应用解析
该算法主要分为基于用户的协同过滤算法和基于物品的协同过滤算法两种。 基于用户的协同过滤算法是根据目标用户与其他用户的相似性来进行推荐的。系统首先找出与目标用户有相似喜好的用户群体，然后根据这部分用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值