带有复合项目相似性对象的基于内容的推荐者是否可能？

Question

我想使用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;
    }

}