[轉] 基於 Apache Mahout 構建社會化推薦引擎

時間 2020-06-20

標籤基於 apache mahout 構建社會化推薦引擎欄目 Apache 简体版

原文原文鏈接

來源：http://www.ibm.com/developerworks/cn/java/j-lo-mahout/index.htmlhtml

Apache Mahout 簡介

Apache Mahout 是 Apache Software Foundation（ASF）旗下的一個開源項目，提供一些可擴展的機器學習領域經典算法的實現，旨在幫助開發人員更加方便快捷地建立智能應用程序。經典算法包括聚類、分類、協同過濾、進化編程等等，而且，在 Mahout 的最近版本中還加入了對 Apache Hadoop 的支持，使這些算法能夠更高效的運行在雲計算環境中。數據庫

Taste 簡介

Taste 是 Apache Mahout 提供的一個協同過濾算法的高效實現，它是一個基於 Java 實現的可擴展的，高效的推薦引擎。Taste 既實現了最基本的基於用戶的和基於內容的推薦算法，同時也提供了擴展接口，使用戶能夠方便的定義和實現本身的推薦算法。同時，Taste 不只僅只適用於 Java 應用程序，它能夠做爲內部服務器的一個組件以 HTTP 和 Web Service 的形式向外界提供推薦的邏輯。Taste 的設計使它能知足企業對推薦引擎在性能、靈活性和可擴展性等方面的要求。apache

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 的軟件需求：json

若是須要 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 推薦引擎的推薦結果，這種推薦引擎計算速度較快，效果很好，是一種很是快速簡單的基於項目的推薦方法。

圖 7. SlopeOne 實現的推薦結果（查看大圖）

總結

目前幾乎全部大型的電子商務系統，都不一樣程度地使用了各類形式的推薦引擎。推薦技術的使用，不只大大的提升了用戶購物的體驗，增長了用戶的粘着度，並且電子商務公司也因爲推薦系統的應用而大大的提升了交叉銷售的可能，從而大大的提升了營業額。今天，你有本身的商品推薦系統麼？

借鑑於電子商務的成功經驗，咱們能夠把推薦技術應用到其餘的領域。像咱們在文章中所演示的那樣，你能夠建立一個電影的推薦引擎。若是你是一個 blogger，那麼你能夠建立一個博客的推薦引擎，若是你是一個新聞提供商，你可使用推薦技術爲不一樣的用戶推薦它可能關心的新聞，等等。

今天，你推薦了麼？

相關標籤/搜索