`
wbj0110
  • 浏览: 1599229 次
  • 性别: Icon_minigender_1
  • 来自: 上海
文章分类
社区版块
存档分类
最新评论

Mahout

阅读更多

12.1 简介

Mahout为推荐引擎提供了一些可扩展的机器学习领域的经典算法实现,

可以使开发人员更为快捷的创建智能应用程序。

12.2 安装

12.2.1 要求

Hadoop集群已经正常启动

12.2.2 配置

这里选用0.7版本
 
tar -zxvf mahout-distribution-0.7.tar.gz -C /usr/local/cloud/src/
cd /usr/local/cloud/
ln -s -f /usr/local/cloud/src/mahout-distribution-0.7 mahout

12.3 测试

12.3.1 获取测试数据

包含600行60列的一个测试数据
 
wget http://archive.ics.uci.edu/ml/databases/synthetic_control/synthetic_control.data

12.3.2 上传到Hadoop集群

 
hadoop fs -mkdir testdata
hadoop fs -put synthetic_control.data testdata

12.3.3 测试各种算法

 
cd /usr/local/cloud/mahout/
# canopy
hadoop jar mahout-examples-0.7-job.jar org.apache.mahout.clustering.syntheticcontrol.canopy.Job
# kmeans
hadoop jar mahout-examples-0.7-job.jar org.apache.mahout.clustering.syntheticcontrol.kmeans.Job

12.4 推荐

12.4.1 协同过滤

  • Taste简介

    Taste 是 Apache Mahout

    提供的一个协同过滤算法的高效实现,它是一个基于 Java 实现的可扩展的,高效的推荐引擎。Taste 既实现了最基本的基于用户的和基于内容的推荐算法,同时也提供了扩展接口,使用户可以方便的定义和实现自己的推荐算法。同时,Taste 不仅仅只适用于 Java 应用程序,它可以作为内部服务器的一个组件以 HTTP 和 Web Service 的形式向外界提供推荐的逻辑。Taste 的设计使它能满足企业对推荐引擎在性能、灵活性和可扩展性等方面的要求。

  • Taste原理

    • 系统架构

      image0

    • 接口设计

      • DataModel

        DataModel

        是用户喜好信息的抽象接口,它的具体实现可能来自任意类型的数据源以抽取用户喜好信息。Taste提供了MySQLDataModel,方便用户通过JDBC和MySQL访问数据, 此外还通过FileDataModel提供了对文件数据源的支持。

    • UserSimilarity 和 ItemSimilarity

      UserSimilarity

      用于定义两个用户间的相似度,它是基于协同过滤的推荐引擎的核心部分,可以用来计算用户的“邻居”,这里我们将与当前用户口味相似的用户称为他的邻居。ItemSimilarity 类似的,定义内容之间的相似度。

    • UserNeighborhood

      用于基于用户相似度的推荐方法中,推荐的内容是基于找到与当前用户喜好相似的“邻居用户”的方式产生的。UserNeighborhood 定义了确定邻居用户的方法,具体实现一般是基于 UserSimilarity 计算得到的。

    • Recommender

      Recommender 是推荐引擎的抽象接口,Taste

      中的核心组件。程序中,为它提供一个DataModel,它可以计算出对不同用户的推荐内容。实际应用中,主要使用它的实现类 GenericUserBasedRecommender 或者 GenericItemBasedRecommender,分别实现基于用户相似度的推荐引擎或者基于内容的推荐引擎。

  • Taste演示

    • 下载测试数据

      http://www.grouplens.org/node/73

    • 拷贝到指定目录
       
      cp ml-1m.zip /usr/local/cloud/mahout/
      cd /usr/local/cloud/mahout/
      unzip ml-1m.zip
      # 电影信息文件 格式为MovieID::MovieName::MovieTags
      cp movies.dat integration/src/main/resources/org/apache/mahout/cf/taste/example/grouplens/
      # 打分信息文件 格式为UserID::MovieID::Rating::Timestamp
      cp ratings.dat integration/src/main/resources/org/apache/mahout/cf/taste/example/grouplens/
      mvn install -DskipTests
    • 修改pom文件
      添加对mahout-examples的依赖
       
      <dependency>
          <groupId>${project.groupId}</groupId>
          <artifactId>mahout-examples</artifactId>
          <version>0.7</version>
      </dependency>
      
    • 使用jetty进行测试
       
      cd integration
      mvn jetty:run
      
      访问如下地址查看效果
       

      http://hadooptest:8080/mahout-integration/RecommenderServlet?userID=1

    • 命令行方式测试
       
      mvn -q exec:java -Dexec.mainClass="org.apache.mahout.cf.taste.example.grouplens.GroupLensRecommenderEvaluatorRunner" -Dexec.args="-i /home/hadoop/cloud/ml-1m/ratings.dat"
      
  • Taste示例
     
    // 1. 选择数据源
    // 数据源格式为UserID,MovieID,Ratings
    // 使用文件型数据接口
    DataModel model = new FileDataModel(new File("/Users/matrix/Documents/plan/test/ratings.txt"));
    
    // 2. 实现相似度算法
    // 使用PearsonCorrelationSimilarity实现UserSimilarity接口, 计算用户的相似度
    // 其中PearsonCorrelationSimilarity是基于皮尔逊相关系数计算相似度的实现类
    // 其它的还包括
    // EuclideanDistanceSimilarity:基于欧几里德距离计算相似度
    // TanimotoCoefficientSimilarity:基于 Tanimoto 系数计算相似度
    // UncerteredCosineSimilarity:计算 Cosine 相似度
    UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
    // 可选项
    similarity.setPreferenceInferrer(new AveragingPreferenceInferrer(model));
    
    // 3. 选择邻居用户
    // 使用NearestNUserNeighborhood实现UserNeighborhood接口, 选择最相似的三个用户
    // 选择邻居用户可以基于'对每个用户取固定数量N个最近邻居'和'对每个用户基于一定的限制,取落在相似度限制以内的所有用户为邻居'
    // 其中NearestNUserNeighborhood即基于固定数量求最近邻居的实现类
    // 基于相似度限制的实现是ThresholdUserNeighborhood
    UserNeighborhood neighborhood = new NearestNUserNeighborhood(3, similarity, model);
    
    // 4. 实现推荐引擎
    // 使用GenericUserBasedRecommender实现Recommender接口, 基于用户相似度进行推荐
    Recommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
    Recommender cachingRecommender = new CachingRecommender(recommender);
    List<RecommendedItem> recommendations = cachingRecommender.recommend(1234, 10);
    
    // 输出推荐结果
    for (RecommendedItem item : recommendations) {
        System.out.println(item.getItemID() + "\t" + item.getValue());
    }
    

12.4.2 聚类分析

  • 框架设计

    针对分组需求,Mahout的聚类算法将对象表示成一种简单的数据模型:向量,然后通过计算各向量间的相似度进行分组。

  • 数据模型

    在Mahout中向量(Vector)有多种实现.

    • DenseVector

      它的实现就是一个浮点数数组, 对向量里所有维度进行存储,

      适合用于存储密集向量。

    • RandomAccessSparseVector

      基于浮点数的HashMap实现, key是整数类型, value是浮点数类型,

      只存储向量中不为空的值, 并提供随机访问。

    • SequentialAccessVector

      实现为整数类型和浮点数类型的并行数组, 同样只存储不为空的值,

      但只提供顺序访问

  • 数据建模

    Mahout为实现将数据建模成向量, 提供了对数据进行向量化的各种方法。

    • 简单的整数类型或浮点型数据
      这种数据因为本身就被描述成一个向量, 因此可以直接存为向量。
       
      // 创建一个二维点集的向量组
      public static final double[][] points = { { 1, 1 }, { 2, 1 }, { 1, 2 },
       { 2, 2 }, { 3, 3 },  { 8, 8 }, { 9, 8 }, { 8, 9 }, { 9, 9 }, { 5, 5 },
       { 5, 6 }, { 6, 6 }};
      public static List<Vector> getPointVectors(double[][] raw) {
          List<Vector> points = new ArrayList<Vector>();
          for (int i = 0; i < raw.length; i++) {
              double[] fr = raw[i];
              // 这里选择创建 RandomAccessSparseVector
              Vector vec = new RandomAccessSparseVector(fr.length);
          // 将数据存放在创建的 Vector 中
              vec.assign(fr);
              points.add(vec);
          }
          return points;
      }
      
    • 枚举类型数据
      这类数据是对物体的描述, 只是取值范围有限,

      比如苹果的颜色数据包括: 红色、黄色和绿色, 则在数据建模时可以用数字表示颜色。 | 红色=1, 黄色=2, 绿色=3

       
      // 创建苹果信息数据的向量组
      public static List<Vector> generateAppleData() {
          List<Vector> apples = new ArrayList<Vector>();
          // 这里创建的是 NamedVector,其实就是在上面几种 Vector 的基础上,
          // 为每个 Vector 提供一个可读的名字
          NamedVector apple = new NamedVector(new DenseVector(new double[] {0.11, 510, 1}), "Small round green apple");
          apples.add(apple);
      
          apple = new NamedVector(new DenseVector(new double[] {0.2, 650, 3}), "Large oval red apple");
          apples.add(apple);
      
          apple = new NamedVector(new DenseVector(new double[] {0.09, 630, 1}), "Small elongated red apple");
          apples.add(apple);
      
          apple = new NamedVector(new DenseVector(new double[] {0.18, 520, 2}), "Medium oval green apple");
          apples.add(apple);
      
          return apples;
      }
      
    • 文本信息

      在信息检索领域中最常用的是向量空间模型,

      文本的向量空间模型就是将文本信息建模成一个向量, 其中每个维度是文本中出现的一个词的权重。

  • 常用算法

    • K均值聚类算法

      • 原理

        给定一个N个对象的数据集, 构建数据的K个划分,

        每个划分就是一个聚类, K<=N, 需要满足两个要求:1.每个划分至少包含一个对象; 2. 每个对象必须属于且仅属于一个组。

      • 过程

        首先创建一个初始划分, 随机的选择K个对象,

        每个对象初始的代表了一个划分的中心, 对于其它的对象, 根据其与各个划分的中心的距离, 把它们分给最近的划分。

        然后使用迭代进行重定位,

        尝试通过对象在划分间移动以改进划分。所谓重定位, 就是当有新的对象被分配到了某个划分或者有对象离开了某个划分时, 重新计算这个划分的中心。这个过程不断重复, 直到各个划分中的对象不再变化。

      • 优缺点

        当划分结果比较密集, 且划分之间的区别比较明显时,

        K均值的效果比较好。K均值算法复杂度为O(NKt), 其中t为迭代次数。

        但其要求用户必须事先给出K值,

        而K值的选择一般都基于一些经验值或多次实验的结果。而且, K均值对孤立点数据比较敏感, 少量这类的数据就能对评价值造成极大的影响。

      • 示例

        • 基于内存的单机应用(0.5版)
           
          /**
           * 基于内存的K均值聚类算法实现
           */
          public static void kMeansClusterInMemoryKMeans(){
              // 指定需要聚类的个数
              int k = 2;
          
              // 指定K均值聚类算法的最大迭代次数
              int maxIter = 3;
          
              // 指定K均值聚类算法的最大距离阈值
              double distanceThreshold = 0.01;
          
              // 声明一个计算距离的方法,这里选择了欧几里德距离
              DistanceMeasure measure = new EuclideanDistanceMeasure();
          
              // 构建向量集,使用的是二维点集
              List<Vector> pointVectors = getPointVectors(points);
          
              // 从点集向量中随机的选择k个向量作为初始分组的中心
              List<Vector> randomPoints = chooseRandomPoints(pointVectors, k);
          
              // 基于前面选中的中心构建分组
              List<Cluster> clusters = new ArrayList<Cluster>();
              int clusterId = 0;
              for(Vector v : randomPoints){
              clusters.add(new Cluster(v, clusterId ++, measure));
              }
              // 调用 KMeansClusterer.clusterPoints 方法执行K均值聚类
              List<List<Cluster>> finalClusters = KMeansClusterer.clusterPoints(pointVectors, clusters, measure, maxIter, distanceThreshold);
          
              // 打印最终的聚类结果
              for(Cluster cluster : finalClusters.get(finalClusters.size() -1)) {
              System.out.println("Cluster id: " + cluster.getId() + " center: " + cluster.getCenter().asFormatString());
              System.out.println("\tPoints: " + cluster.getNumPoints());
              }
          }
          
      • 基于Hadoop的集群应用(0.5版)
        注意:
        首先需要在MVN工程中添加如下依赖
         
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-core</artifactId>
            <version>1.0.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.mahout</groupId>
            <artifactId>mahout-core</artifactId>
            <version>0.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.mahout</groupId>
            <artifactId>mahout-utils</artifactId>
            <version>0.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.mahout</groupId>
            <artifactId>mahout-math</artifactId>
            <version>0.5</version>
        </dependency>
        
        其次在集群上运行前需要进行相关配置
         
        # 需要在$HADOOP_HOME/conf/hadoop-env.sh中设置CLASSPATH
        export MAHOUT_HOME=/usr/local/cloud/mahout
        for f in $MAHOUT_HOME/lib/*.jar; do
            HADOOP_CLASSPATH=${HADOOP_CLASSPATH}:$f;
        done
        for f in $MAHOUT_HOME/*.jar; do
           HADOOP_CLASSPATH=$(HADOOP_CLASSPATH):$f;
        done
        然后即可测试如下代码
         
        /**
         * 基于 Hadoop 的K均值聚类算法实现
         * @throws Exception
         */
        public static void kMeansClusterUsingMapReduce () throws Exception{
            Configuration conf = new Configuration();
        
            // 声明一个计算距离的方法,这里选择了欧几里德距离
            DistanceMeasure measure = new EuclideanDistanceMeasure();
        
            // 指定输入路径,基于 Hadoop 的实现是通过指定输入输出的文件路径来指定数据源的。
            Path testpoints = new Path("testpoints");
            Path output = new Path("output");
        
            // 清空输入输出路径下的数据
            HadoopUtil.delete(conf, testpoints);
            HadoopUtil.delete(conf, output);
        
            RandomUtils.useTestSeed();
        
            // 在输入路径下生成点集,与内存的方法不同,这里需要把所有的向量写进文件
            writePointsToFile(testpoints);
        
            // 指定需要聚类的个数,这里选择 2 类
            int k = 2;
        
            // 指定 K 均值聚类算法的最大迭代次数
            int maxIter = 3;
        
            // 指定 K 均值聚类算法的最大距离阈值
            double distanceThreshold = 0.01;
        
            // 随机的选择k个作为簇的中心
            Path clusters = RandomSeedGenerator.buildRandom(conf, testpoints, new Path(output, "clusters-0"), k, measure);
        
            // 调用 KMeansDriver.runJob 方法执行 K 均值聚类算法
            KMeansDriver.run(testpoints, clusters, output, measure, distanceThreshold, maxIter, true, true);
        
            // 调用 ClusterDumper 的 printClusters 方法将聚类结果打印出来。
            ClusterDumper clusterDumper = new ClusterDumper(new Path(output, "clusters-" + (maxIter - 1)), new Path(output, "clusteredPoints"));
            clusterDumper.printClusters(null);
        }
        
      • 基于Hadoop的集群应用(0.7版)
         
        public static void kMeansClusterUsingMapReduce() throws IOException, InterruptedException,
                    ClassNotFoundException {
            Configuration conf = new Configuration();
        
            // 声明一个计算距离的方法,这里选择了欧几里德距离
            DistanceMeasure measure = new EuclideanDistanceMeasure();
            File testData = new File("input");
            if (!testData.exists()) {
            testData.mkdir();
            }
        
            // 指定输入路径,基于 Hadoop 的实现是通过指定输入输出的文件路径来指定数据源的。
            Path samples = new Path("input/file1");
        
            // 在输入路径下生成点集,这里需要把所有的向量写进文件
            List<Vector> sampleData = new ArrayList<Vector>();
        
            RandomPointsUtil.generateSamples(sampleData, 400, 1, 1, 3);
            RandomPointsUtil.generateSamples(sampleData, 300, 1, 0, 0.5);
            RandomPointsUtil.generateSamples(sampleData, 300, 0, 2, 0.1);
            ClusterHelper.writePointsToFile(sampleData, conf, samples);
        
            // 指定输出路径
            Path output = new Path("output");
            HadoopUtil.delete(conf, output);
        
            // 指定需要聚类的个数,这里选择3
            int k = 3;
        
            // 指定 K 均值聚类算法的最大迭代次数
            int maxIter = 10;
        
            // 指定 K 均值聚类算法的最大距离阈值
            double distanceThreshold = 0.01;
        
            // 随机的选择k个作为簇的中心
            Path clustersIn = new Path(output, "random-seeds");
            RandomSeedGenerator.buildRandom(conf, samples, clustersIn, k, measure);
        
            // 调用 KMeansDriver.run 方法执行 K 均值聚类算法
            KMeansDriver.run(samples, clustersIn, output, measure, distanceThreshold, maxIter, true, 0.0, true);
        
            // 输出结果
            List<List<Cluster>> Clusters = ClusterHelper.readClusters(conf, output);
            for (Cluster cluster : Clusters.get(Clusters.size() - 1)) {
            System.out.println("Cluster id: " + cluster.getId() + " center: " + cluster.getCenter().asFormatString());
            }
        }
        
        输出结果为:
         
        Cluster id: 997 center: {1:3.6810451340150467,0:3.8594229542914538}
        Cluster id: 998 center: {1:2.068611196044424,0:-0.5471173292759096}
        Cluster id: 999 center: {1:-0.6392433868275759,0:1.2972649625289365}
        

12.4.3 分类分析

分享到:
评论

相关推荐

    mahout-core-0.9.jar+mahout-core-0.8.jar+mahout-core-0.1.jar

    这个压缩包包含的是Mahout项目不同版本的核心库,分别是mahout-core-0.9.jar、mahout-core-0.8.jar和mahout-core-0.1.jar。这些版本的差异在于功能的完善、性能的优化以及对新特性的支持。 1. **Mahout核心功能**:...

    mahout所需jar包

    **马哈多(Mahout)库的概述** 马哈多(Mahout)是Apache软件基金会的一个开源项目,专注于提供可扩展的机器学习库。它基于Hadoop,这意味着它能够利用分布式计算来处理大规模数据集。 Mahout的目标是帮助开发人员...

    mahout-distribution-0.9.tar.gz

    Apache Mahout是一个基于Java的开源机器学习库,它提供了丰富的算法和工具,用于构建智能应用程序,特别是关注推荐系统、分类和聚类分析。"mahout-distribution-0.9.tar.gz"是Apache Mahout的0.9版本的发行包,包含...

    人工智能-推荐系统-新闻推荐-基于Mahout的新闻推荐系统

    Mahout:整体框架,实现了协同过滤 Deeplearning4j,构建VSM Jieba:分词,关键词提取 HanLP:分词,关键词提取 Spring Boot:提供API、ORM 关键实现 基于用户的协同过滤 直接调用Mahout相关接口即可 选择不同...

    apache-mahout-distribution-0.11.0-src.zip

    Apache Mahout是一个开源项目,专注于开发可扩展的机器学习库,它主要由Java语言编写,并且依赖于Maven构建系统。在"apache-mahout-distribution-0.11.0-src.zip"这个压缩包中,您将找到Mahout 0.11.0版本的源代码,...

    maven_mahout_template-mahout-0.8

    《Apache Maven与Mahout实战:基于maven_mahout_template-mahout-0.8的探索》 Apache Maven是一款强大的项目管理和依赖管理工具,广泛应用于Java开发领域。它通过一个项目对象模型(Project Object Model,POM)来...

    Mahout in Action 2012

    Apache Mahout是一个Apache开源数据挖掘和机器学习项目,它提供了一系列基于Java的工具和库,用于构建可扩展的推荐系统、聚类算法以及其他机器学习应用。Mahout的目标是简化数据挖掘任务的实现,使其不仅仅局限于...

    测试mahout推荐算法的数据集

    Apache Mahout是一个基于Hadoop的数据挖掘库,它提供了多种推荐算法的实现,如协同过滤、基于内容的推荐以及混合推荐方法。 Mahout的协同过滤算法是其核心功能之一,它通过分析用户的历史行为来预测他们可能感兴趣...

    如何成功运行Apache Mahout的Taste Webapp-Mahout推荐教程-Maven3.0.5-JDK1.6-Mahout0.5

    根据给定的文件信息,我们可以提炼出以下几个与Apache Mahout及其Taste Webapp相关的知识点: 1. Apache Mahout简介 Apache Mahout是一个开源项目,隶属于Apache软件基金会(ASF),专门提供可扩展的机器学习算法...

    Mahout最新基础依赖包.rar

    **Apache Mahout简介** Apache Mahout 是一个开源项目,它为大数据分析提供了机器学习库。这个库主要关注三个核心领域:推荐系统、分类和聚类。Mahout 的目标是使开发人员能够轻松构建智能应用程序,利用分布式计算...

    mahout 简介,中文

    Mahout提供了这些相似度度量的实现,使得开发人员能够灵活选择最适合其应用场景的方法。 ### 集群 集群是无监督学习的一种形式,其目的是将一组对象分为几个类别或“集群”,使得同一集群内的对象彼此相似,而不同...

    MAHOUT实战(中文版)

    《MAHOUT实战》这本书是关于Apache Mahout机器学习库的中文版指南,旨在帮助读者理解和应用Mahout进行大数据分析和构建智能应用。Apache Mahout是一个开源项目,它提供了可扩展的机器学习算法,用于分类、聚类和推荐...

    大数据Mahout实践指南

    《大数据Mahout实践指南》是一本深入探讨大数据分析与机器学习技术的专业书籍,尤其侧重于Apache Mahout框架的应用。Mahout是Apache软件基金会的一个开源项目,致力于提供可扩展的、易于使用的机器学习库,用于构建...

    Mahout In Action英文完整版

    ### Mahout in Action:全面解析 #### 一、概述 《Mahout in Action》是一本由Sean Owen、Robin Anil、Ted Dunning和Ellen Friedman合著的专业书籍,旨在深入介绍Apache Mahout这一强大的机器学习库。该书的网上...

    [Mahout] Windows下Mahout单机安装

    【标题】:“Mahout在Windows下的单机安装教程” 【内容详解】 Apache Mahout是一个开源机器学习库,它提供了一系列的可扩展、分布式算法,涵盖了推荐系统、分类、聚类等多个机器学习领域。在Windows环境下安装...

    Mahout-0.9-jar包

    Apache Mahout是一个开源机器学习库,它为大数据分析提供了丰富的算法和工具,旨在帮助开发者构建智能应用程序。在标题“Mahout-0.9-jar包”中,提及的是该库的一个特定版本——0.9,这通常意味着包含了该版本的所有...

    mahout Algorithms源码分析

    Mahout是一个Apache Software Foundation(ASF)旗下的开源项目,主要用途是提供可扩展的机器学习算法的实现,帮助开发人员更方便快捷地创建智能应用程序。Mahout包含了很多算法的实现,包括聚类(Clustering)、...

    mahout1.0编译包

    “mahout1.0编译包”是指Apache Mahout机器学习库的一个特定版本,已经针对Hadoop 2进行了优化和编译。Mahout是一个流行的数据挖掘工具,它提供了各种算法来实现推荐系统、分类和聚类。这里的“1.0”可能指的是在...

Global site tag (gtag.js) - Google Analytics