1

我想使用 Mahout 作为推荐系统。

在我的项目中，有内容、标签、反应。用户在标记后分享内容，其他用户可以阅读内容并做出反应。

我想在任何用户阅读内容时推荐内容。

在这种情况下，如果我只使用读者信息，我将没有偏好​​值，这就是为什么我想使用具有默认 mahout 项目相似性的内容反应和内容标签。

我不能确定在推荐系统中使用反应和标签信息是正确的方法。是不是推荐人的问题。

如果这是我上面解释的正确方法，我正在考虑使用复合对象作为 ItemSimilarity，它包装了 Mahout 相似性实现（例如 TanimotoCoefficientSimilarity），然后将相似性计算结果与标签和反应相似性结果相加。

模型 ：

user_id    viewed_content_id
---------  -----------------
1             102
1             1032
2             105

content_id    reaction_id   reaction_count
----------    -----------   -------------
102             5              10000       
105             3              500
206             5              2000


content_id    tag_id
----------    ------
1              3
1              4   
1              3
2              3
2              1
3              3  
3              3

（任何内容都会有大约 5 个反应选项和大约 5 个标签。）

物品相似度等级：

public class ContentSimilarity implements ItemSimilarity {

    private ItemSimilarity similarity;
    private FastByIDMap<ContentItem> map = new FastByIDMap<>();

    private ContentSimilarity() {
    }

    /**
     * 
     * @param dataModel
     * @param similarity
     *            ---> let assume that TanimotoCoefficientSimilarity
     * @return
     * @throws TasteException
     */
    public static ContentSimilarity createWith(DataModel dataModel, ItemSimilarity similarity) throws TasteException {
    ContentSimilarity customSimilarity = new ContentSimilarity();
    customSimilarity.setSimilarity(similarity);
    return customSimilarity;
    }

    @Override
    public void refresh(Collection<Refreshable> alreadyRefreshed) {
    similarity.refresh(alreadyRefreshed);

    }

    @Override
    public double itemSimilarity(long itemID1, long itemID2) throws TasteException {
    double similarityResult = similarity.itemSimilarity(itemID1, itemID2) + customSimilarity(itemID1, itemID2);
    return similarityResult;
    }

    int threshold = 10;

    public double customSimilarity(long itemID1, long itemID2) throws TasteException {
    ContentItem item1 = map.get(itemID1);
    ContentItem item2 = map.get(itemID2);
    double score = 0.0;
    try {
        // tag similarity
        int tagIntersection = item1.getTagsAsFastIDSet().intersectionSize(item2.getTagsAsFastIDSet());

        // reactionSimilarity
        FastByIDMap<Long> item1Map = item1.getReactionsAsFastByIDMap();
        FastByIDMap<Long> item2Map = item2.getReactionsAsFastByIDMap();
        LongPrimitiveIterator item1Itr = item1Map.keySetIterator();

        int reactionScore = 0;

        while (item1Itr.hasNext()) {
        long item1Key = item1Itr.next();
        long item1Val = item1Map.get(item1Key);
        Long item2ValO = item2Map.get(item1Key);
        if (item1Val > threshold && item2ValO > threshold) {
            reactionScore += item2ValO == null ? 0 : 1;
        }
        }
        score = tagIntersection + reactionScore; // max score is 10
    } catch (IOException e) {
        e.printStackTrace();
    }

    return score / 10;
    }

    @Override
    public double[] itemSimilarities(long itemID1, long[] itemID2s) throws TasteException {
    return similarity.itemSimilarities(itemID1, itemID2s);
    }

    @Override
    public long[] allSimilarItemIDs(long itemID) throws TasteException {
    return similarity.allSimilarItemIDs(itemID);
    }

    public ItemSimilarity getSimilarity() {
    return similarity;
    }

    public void setSimilarity(ItemSimilarity similarity) {
    this.similarity = similarity;
    }

}
4

0 回答 0