基于 Apache Mahout 构建社会化推荐引擎

时间 2019-11-08

标签基于 apache mahout 构建社会化推荐引擎栏目 Apache 繁體版

原文原文链接

Apache Mahout 简介

Apache Mahout 是 Apache Software Foundation（ASF）旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地建立智能应用程序。经典算法包括聚类、分类、协同过滤、进化编程等等，而且，在 Mahout 的最近版本中还加入了对 Apache Hadoop 的支持，使这些算法能够更高效的运行在云计算环境中。

回页首

Taste 简介

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

Taste 工做原理

图 1. Taste 的主要组件图

Taste 由如下五个主要的组件组成：

DataModel：DataModel 是用户喜爱信息的抽象接口，它的具体实现支持从任意类型的数据源抽取用户喜爱信息。Taste 默认提供 JDBCDataModel 和 FileDataModel，分别支持从数据库和文件中读取用户的喜爱信息。
UserSimilarity 和 ItemSimilarity：UserSimilarity 用于定义两个用户间的类似度，它是基于协同过滤的推荐引擎的核心部分，能够用来计算用户的“邻居”，这里咱们将与当前用户口味类似的用户称为他的邻居。ItemSimilarity 相似的，计算内容之间的类似度。
UserNeighborhood：用于基于用户类似度的推荐方法中，推荐的内容是基于找到与当前用户喜爱类似的“邻居用户”的方式产生的。UserNeighborhood 定义了肯定邻居用户的方法，具体实现通常是基于 UserSimilarity 计算获得的。
Recommender：Recommender 是推荐引擎的抽象接口，Taste 中的核心组件。程序中，为它提供一个 DataModel，它能够计算出对不一样用户的推荐内容。实际应用中，主要使用它的实现类 GenericUserBasedRecommender 或者 GenericItemBasedRecommender，分别实现基于用户类似度的推荐引擎或者基于内容的推荐引擎。

Taste 的安装与简单的 Demo 实现

安装 Taste 的软件需求：

若是须要 build 源代码或者例子，须要 Apache Ant 1.5+ 或 Apache Maven 2.0.10+。
Taste 应用程序须要 Servlet 2.3+容器，例如 Jakarta Tomcat。
Taste 中的 MySQLJDBCDataModel 实现须要 MySQL 4.x+数据库。

安装 Taste 并运行 Demo：

从 SVN 或是下载压缩包获得 Apache Mahout 的发布版本：

从 SVN得到；
下载压缩包；

从 Grouplens 下载数据源："1 Million MovieLens Dataset"。
解压数据源压缩包，将 movie.dat 和 ratings.dat 拷贝到 Mahout 安装目录下的 taste-web/src/ main/resources/org/apache/mahout/cf/taste/example/grouplens 目录下。
回到在 core 目录下，运行"mvn install"，将 Mahout core 安装在本地库中。
进入 taste-web, 拷贝 ../examples/target/grouplens.jar 到 taste-web/lib 目录
编辑 taste-web/recommender.properties，将 recommender.class 设置为 org.apache.mahout. cf.taste.example.grouplens.GroupLensRecommender。
在 Mahout 的安装目录下，运行"mvn package"。
运行“mvn jetty:run-war”。这里须要将 Maven 的最大内存设置为 1024M，MAVEN_OPTS=-Xmx1024M。若是须要在 Tomcat 下运行，能够在执行"mvn package"后，将 taste-web/target 目录下生成的 war 包拷贝到 Tomcat 的 webapp 下，同时也须要将 Java 的最大内存设置为 1024M，JAVA_OPTS=-Xmx1024M，而后启动 Tomcat。
访问“http://localhost:8080/[your_app]/RecommenderServlet?userID=1”，获得系统为编号为 1 的用户的推荐内容。参看图 2，Taste demo 运行结果界面，每一行第一项是推荐引擎预测的评分，第二项是电影的编号。
同时，Taste 还提供 Web 服务访问接口，经过如下 URL 访问：
http://localhost:8080/[your_app]/RecommenderService.jws
WSDL 文件：http://localhost:8080/[your_app]/RecommenderService.jws?wsdl
也能够经过简单的 HTTP 请求调用这个 Web 服务：
http://localhost:8080/[your_app]/RecommenderService.jws? method=recommend&userID=1&howMany=10

图 2. Taste Demo 运行结果界面

回页首

使用 Taste 构建推荐引擎实例 – 电影推荐引擎

根据上面的步骤，咱们能够获得一个简单的推荐引擎 demo 环境，下面介绍如何使用 Taste 方便地构建自定义的推荐引擎。

抽取 Taste 工具包

直接使用 Mahout 的项目环境进行编码，须要使用 Ant 或者 Maven 进行编译，整个过程比较复杂，这里咱们将构建推荐引擎所须要的工具包从 Mahout 工程中抽取出来，从而方便的构建自定义的推荐引擎。

在 Eclipse 中建立 Web 应用的工程 MovieSite，将 demo 时生成的推荐引擎 Web 应用的 war 包解压缩，将 lib 下的 jar 文件拷贝到 MovieSite 的 lib 目录下。这样咱们就能够方便的编写本身的推荐引擎。

图 3. MovieSite 工程中引用的 jar 文件

数据建模

这里咱们想要编写一个电影推荐引擎，第一步须要对数据进行建模，分析应用中涉及的主要实体以及实体间的关系，从而设计数据库存储，程序中的类，以及推荐引擎的 DataModel。

图 4 电影和用户信息数据模型

数据模型中存在如下实体：

Movie：表示电影，包含电影的基本信息：编号、名称、发布时间、类型等等。
User：表示用户，包含用户的基本信息：编号、姓名、邮件等等。
Movie Reference：表示某个用户对某个电影的喜爱程度，包含用户编号、电影编号、用户的评分以及评分的时间。
Movie Similarity：表示两个电影的类似度（这里的类似度是双向的），包括两个电影编号、电影的类似度。两个电影的类似度能够经过电影的基本信息计算获得。

下面咱们就基于这个数据模型设计数据库的存储以及推荐引擎的 DataModel。

1 ．建立 MySQL 数据库存储电影和用户的信息，用户的喜爱信息以及电影的类似度。

清单 1. 建立数据库 SQL

 CREATE DATABASE movie; 
 USE movie; 
 CREATE TABLE movies (  // 保存电影相关的信息。
    id INTEGER NOT NULL AUTO_INCREMENT, 
    name varchar(100) NOT NULL, 
    published_year varchar(4) default NULL, 
    type varchar(100) default NULL, 
 --    ...more movie information... 
    PRIMARY KEY (id) 
 ); 

 CREATE TABLE users (  // 保存用户信息
    id INTEGER NOT NULL AUTO_INCREMENT, 
    name varchar(50) NOT NULL, 
    email varchar(100) default NULL, 
 --    ...more user information... 
    PRIMARY KEY (id) 
 ); 

 CREATE TABLE movie_preferences (  // 保存用户对电影的评分，即喜爱程度
    userID INTEGER NOT NULL, 
    movieID INTEGER NOT NULL, 
    preference INTEGER NOT NULL DEFAULT 0, 
    timestamp INTEGER not null default 0, 
    FOREIGN KEY (userID) REFERENCES users(id) ON DELETE CASCADE, 
    FOREIGN KEY (movieID) REFERENCES movies(id) ON DELETE CASCADE 
 ); 

 CREATE TABLE movie_similarity (   // 保存电影和电影的类似程度
    movieID1 INTEGER NOT NULL, 
    movieID2 INTEGER NOT NULL, 
    similarity DOUBLE NOT NULL DEFAULT 0, 
    FOREIGN KEY (movieID1) REFERENCES movies(id) ON DELETE CASCADE, 
    FOREIGN KEY (movieID2) REFERENCES movies(id) ON DELETE CASCADE 
 ); 

 CREATE INDEX movie_preferences_index1 ON movie_preferences ( userID , movieID ); 
 CREATE INDEX movie_preferences_index2 ON movie_preferences ( userID ); 
 CREATE INDEX movie_preferences_index3 ON movie_preferences ( movieID );

在实际应用中，咱们须要将应用中的实例数据写入到数据库中。做为例子，这里将从 GroupLen 下载的数据源写入数据库。

设计实现推荐引擎的 DataModel。

因为上面采用数据库存储用户的喜爱信息，这里须要基于数据库的推荐引擎实现。这里扩展 MySQLJDBCDataModel 实现电影推荐引擎的 DataModel 实例。

清单 2. Taste DataModel 的实现

 public class MovieDataModel extends MySQLJDBCDataModel { 

    // 保存用户对电影的评分的数据库表名
    public final static String PERFERENCETABLE = "movie_preferences";  
    public final static String USERID_COLUMN = "userID";   // 表中用户标识的列名
    public final static String ITEMID_COLUMN = "movieID";  // 表中电影标识的列名
    public final static String PERFERENCE_COLUMN = "preference";  // 表中评分的列名

    public MovieDataModel(String dataSourceName) throws TasteException { 		
        super(lookupDataSource(dataSourceName), PERFERENCETABLE, USERID_COLUMN, 
            ITEMID_COLUMN, PERFERENCE_COLUMN); 
    } 

    public MovieDataModel() { 
        //DBUtil.getDataSource() 将返回应用的数据源
        // 此应用是 J2EE 应用，因此这里会采用 JDNI 的方式建立数据库连接。
        super(DBUtil.getDataSource(), PERFERENCETABLE, USERID_COLUMN, 
            ITEMID_COLUMN, PERFERENCE_COLUMN); 
    } 
 }

推荐引擎实现

前面介绍了数据建模和 DataModel 的实现，下面来详细介绍推荐引擎的实现。如前面介绍的，Taste 既实现了最基本的基于用户的和基于内容的推荐算法，同时也提供了扩展接口，使用户能够方便的定义和实现本身的推荐算法。下面详细介绍如何扩展 Taste 的推荐引擎接口，实现基于用户类似度的推荐引擎，基于内容类似度的推荐引擎，以及 Slope One 的推荐引擎。Slope One 是一种很是快速简单的基于项目的推荐方法，须要使用用户的评分信息。

清单 3. 基于用户类似度的推荐实现

 public class UserBasedRecommender implements Recommender { 

    private final Recommender recommender; 

    public UserBasedRecommender() throws IOException, TasteException { 
        this(new MovieDataModel()); 
    } 

    public UserBasedRecommender(DataModel model) throws TasteException { 

        UserSimilarity userSimilarity = new PearsonCorrelationSimilarity(model);  
        userSimilarity.setPreferenceInferrer(new AveragingPreferenceInferrer(model)); 

        UserNeighborhood neighborhood = 
            new NearestNUserNeighborhood(3, userSimilarity, model); 
        recommender = new CachingRecommender( 
            new GenericUserBasedRecommender(model, neighborhood, userSimilarity)); 
    } 

    // 对外提供的推荐的接口，参数为用户标识和推荐项的个数
    public List<RecommendedItem> recommend(long userID, int howMany) 
        throws TasteException { 
        return recommender.recommend(userID, howMany); 
    } 
        
    public List<RecommendedItem> recommend(long userID, int howMany, 
        Rescorer<Long> rescorer) throws TasteException { 
        return recommender.recommend(userID, howMany, rescorer); 
    } 

    // 如下方法都是实现 Recommender 的接口
    public float estimatePreference(long userID, long itemID) throws TasteException { 
        return recommender.estimatePreference(userID, itemID); 
    } 
 
    public void setPreference(long userID, long itemID, float value) 
        throws TasteException { 
        recommender.setPreference(userID, itemID, value); 
    } 

    public void removePreference(long userID, long itemID) throws TasteException { 
        recommender.removePreference(userID, itemID); 
    } 
 
    public DataModel getDataModel() { 
        return recommender.getDataModel(); 
    } 

    public void refresh(Collection<Refreshable> alreadyRefreshed) { 
        recommender.refresh(alreadyRefreshed); 
    } 

    public String toString() { 
        return "UserBasedRecommender[recommender:" + recommender + ']'; 
    } 
 }

从上面的代码示例清单 3 能够看出，实现一个推荐引擎须要实现 Recommender 接口，它通常是对于某种 Taste 提供的推荐引擎的扩展，这是对 GenericUserBasedRecommender 进行的扩展，其中最重要的方法就是实例化推荐引擎的构造方法，通常其中涉及如下步骤：

基于 DataModel，计算用户的类似度，这里采用 PearsonCorrelation 算法。
为用户类似度设置类似度推理方法，这里采用了 AveragingPreferenceInferrer。
基于用户类似度计算用户的“邻居”，这里将与该用户最近距离为 3 的用户设置为该用户的“邻居”。
使用以上获得的用户类似度对象和邻居用户的计算方法对象建立一个 GenericUserBasedRecommender 的实例。通常状况下，这时都采用 CachingRecommender 为 RecommendationItem 进行缓存，从而提升访问速度。

清单 4. 基于内容类似度的推荐实现

 public class ItemBasedRecommender implements Recommender { 

    private final Recommender recommender; 

    public ItemBasedRecommender() throws IOException, TasteException { 
        this(new MovieDataModel()); 
    } 
	  
    public ItemBasedRecommender(DataModel dataModel) throws TasteException { 

        Collection<GenericItemSimilarity.ItemItemSimilarity> correlations = 
            MovieSimilarityTable.getAllMovieSimilarities(); 
        ItemSimilarity itemSimilarity = new GenericItemSimilarity(correlations); 
        recommender = new CachingRecommender(new EmbededItemBasedRecommender( 
            new GenericItemBasedRecommender(dataModel, itemSimilarity))); 
    } 
		  
    public List<RecommendedItem> recommend(long userID, int howMany) 
        throws TasteException { 
        return recommender.recommend(userID, howMany); 
    } 
    
	 ......... 

    //EmbededItemBasedRecommender 类的定义		  
    private static final class EmbededItemBasedRecommender implements Recommender { 

        // 包含一个 GenericItemBasedRecommender 实例；
        private final GenericItemBasedRecommender recommender; 

        private EmbededItemBasedRecommender(GenericItemBasedRecommender recommender) { 
            this.recommender = recommender; 
        } 

        public List<RecommendedItem> recommend(long userID,  int howMany, 
            Rescorer<Long> rescorer) 
            throws TasteException { 
            FastIDSet itemIDs = recommender.getDataModel().getItemIDsFromUser(userID); 
            return recommender.mostSimilarItems(itemIDs.toArray(), howMany, null); 
        } 

    ........ 

 }

从上面的代码示例清单 4 能够看出，与上一个实现相似它是对 GenericItemBasedRecommender 的扩展，它的构造方法涉及如下步骤：

为了提升推荐引擎的实时响应速度，这里须要对电影信息的预处理，将电影的类似度提早计算好存储在数据库中的 movie_similarity 表中，而后从数据库中读取全部的电影的类似度，用于建立 ItemItemSimilarity 的集合。
基于 ItemItemSimilarity 的集合生成一个内容类似度 ItemSimilarity。
建立一个 EmbededItemBasedRecommender 实例，它是一个内部类，包含一个 GenericItemBasedRecommender 实例，它的 recommend 方法中，先从 DataModel 中获得该用户评分的电影列表，而后调用 GenericItemBasedRecommender 中的 mostSimilarItems 方法计算出最类似的电影推荐给用户。

清单 5. SlopeOne Recommeder 的实现

 public final class MovieRecommender implements Recommender { 

    private final Recommender recommender; 

    public MovieRecommender() throws IOException, TasteException { 
        this(new MovieDataModel()); 
    } 

    public MovieRecommender(DataModel dataModel) throws TasteException { 
        // 建立一个 SlopeOneRecommender 的实例
        recommender = new CachingRecommender(new SlopeOneRecommender(dataModel)); 
    } 

    // 对外提供的推荐的接口，参数为用户标识和推荐项的个数
    public List<RecommendedItem> recommend(long userID, int howMany) 
        throws TasteException { 
        return recommender.recommend(userID, howMany); 
    } 
    
	 ........ 

 }

Slope One 是一种很是快速简单的基于项目的推荐方法，它只须要使用用户的评分信息。具体的实现，只须要在咱们的推荐引擎中包含一个 SlopeOneRecommender 的实例。

用户界面展现

实现一个推荐引擎的最后一步就是编写客户端代码，为电影推荐引擎提供一个友好的用户界面。下面展现一下咱们为电影推荐引擎写的一个简单的用户界面：右边红色框中的是该用户已经打分的电影列表，左边蓝色框中是推荐引擎为用户推荐的电影列表。

首先，展现一下基于用户的推荐引擎的推荐结果，推荐引擎会根据用户已打分的电影找到用户的“邻居”，将“邻居”们比较喜欢的电影推荐给当前用户。

图 5. 基于用户的推荐结果（查看大图）

其次，图 6 展现了基于内容的推荐引擎的推荐结果，推荐引擎会根据用户已打分的电影找到类似的电影，推荐给当前用户。

图 6. 基于内容的推荐结果（查看大图）

最后，展现 SlopeOne 推荐引擎的推荐结果，这种推荐引擎计算速度较快，效果很好，是一种很是快速简单的基于项目的推荐方法。