mahout版本为mahout-distribution-0.9
mahout基于hadoop协同过滤（itembased）触发类为org.apache.mahout.cf.taste.hadoop.item.RecommenderJob。
执行RecommenderJob时大概需要以下参数：
--input <input>
--output <output>
--numRecommendations Number of recommendations per user
--usersFile File of users to recommend for
--itemsFileFile of items to recommend for
--filterFileFile containing comma-separated userID,itemID pairs. Used to exclude the item from the recommendations for that user (optional)
--booleanData Treat input as without pref values
--similarityClassname (-s) similarityClassname [SIMILARITY_COOCCURRENCE,SIMILARITY_LOGLIKELIHOOD,
SIMILARITY_TANIMOTO_COEFFICIENT,SIMILARITY_CITY_BLOCK,
SIMILARITY_COSINE,SIMILARITY_PEARSON_CORRELATION,
SIMILARITY_EUCLIDEAN_DISTANCE]
--maxPrefsPerUserMaximum number of preferences considered per user in final recommendation phase
--minPrefsPerUser ignore users with less preferences than this in the similarity computation
--maxSimilaritiesPerItem Maximum number of similarities considered per item
--maxPrefsInItemSimilaritymax number of preferences to consider per user or item in the item similarity computation phase, users or items withmore preferences will be sampled down
--threshold <threshold> discard item pairs with a similarity value below this
--outputPathForSimilarityMatrix write the item similarity matrix to this path (optional)
--randomSeed use this seed for sampling
--sequencefileOutput write the output into a SequenceFile instead of a text file
--help
--tempDir Intermediate output directory
--startPhase First phase to run default 0
--endPhaseLast phase to run mahout协同过滤输入格式为（userid，itemid，preference）。RecommenderJob流程主要包括以下几部分，我们会依次进行分析。
1、PreparePreferenceMatrixJob作业
所在包为org.apache.mahout.cf.taste.hadoop.preparation.PreparePreferenceMatrixJob，打开此类可以看到，此作业包含3个子作业。
1.1 itemIDIndex
此作业会执行ItemIDIndexMapper.class作为map类，执行ItemIDIndexReducer.class作为reduce类。
ItemIDIndexMapper.class作用是将long型的itemid转为int型内部索引。输入格式为（userid，itemid，preference），输出格式为（index，itemid）。
结果会保存到tempDir/preparePreferenceMatrix/itemIDIndex中。
1.2 toUserVectors
此作业执行ToItemPrefsMapper.class作为map类，ToUserVectorsReducer.class作为reduce类。
toUserVectors作用是将用户偏好写成每个用户的偏好向量。输入格式为（userid，temid，preference>），输出格式为 (userId, VectorWritable<itemId, preference>)
结果会保存到tempDir/preparePreferenceMatrix/userVectors文件中。
1.3 toItemVectors
此作业执行ToItemVectorsMapper.class作为map类，ToItemVectorsReducer.class作为reduce类。
toItemVectors作用是建立项目的评分矩阵。输入为toUserVectors作业的执行结果userVectors格式为(userId, VectorWritable<itemId,preference>)，输出为(itemId,VectorWritable<userId,preference>)。
结果会保存到tempDir/preparePreferenceMatrix/ratingMatrix文件中。
2、 RowSimilarityJob作业
所在包为package org.apache.mahout.math.hadoop.similarity.cooccurrence.RowSimilarityJob，打开此类进行分析。
2.1 countObservations
此作业执行CountObservationsMapper.class作为map类，执行SumObservationsReducer.class作为reduce类。
countObservations作用是计算出每个用户的评定物品数。输入为1.3中的结果ratingMatrix格式为(itemId,VectorWritable<userId,preference>)，输出格式为（vector<userid,count>）。
计算结果保存在tempDir/observationsPerColumn.bin文件中（此文件读取需要使用org.apache.mahout.math.hadoop.similarity.cooccurrence.Vectors中的read函数）。
2.2 normsAndTranspose
此作业map函数为VectorNormMapper.class，reduce函数为MergeVectorsReducer.class。
normsAndTranspose作用是将首先将ratingMatrix(itemId,VectorWritable<userId,preference>)数据进行normalize化，之后数据写成(userId, VectorWritable<itemId,preference>)格式。在此步骤的map阶段计算了每个项目preference的norms值，并将数值存到tempDir/norms.bin文件中，norms计算方式依相似度函数而定，具体实现见相似度函数中的norm函数。此处以EuclideanDistanceSimilarity为例，计算方式如下：
@Override
public double norm(Vector vector) {
double norm = 0;
for (Vector.Element e : vector.nonZeroes()) {
double value = e.get();
norm += value * value;
}
return norm;
}normalize的计算方式与所选的相似度就算方式有关，此处以SIMILARITY_EUCLIDEAN_DISTANCE为例，计算方式如下：
@Override
public Vector normalize(Vector vector) {
return vector;
}
@Override
public Vector normalize(Vector vector) {
if (vector.getNumNondefaultElements() == 0) {
return vector;
}
// center non-zero elements
double average = vector.norm(1) / vector.getNumNonZeroElements();
for (Vector.Element e : vector.nonZeroes()) {
e.set(e.get() - average);
}
return super.normalize(vector);
}计算结果保存在tempDir/weights文件中。
2.3 pairwiseSimilarity
此作业以 CooccurrencesMapper.class作为map类，以SimilarityReducer.class作为reduce类。
pairwiseSimilarity作用为计算item之间的相似度。数据输入为weights文件格式为(userId, VectorWritable<itemId,preference>)，输出为（itemM，VectorWritable <itemM+,similarscore>）(每条项目为key的数据中其它项目index一定比当前项目大，比如M对应M+1,M+2,....),由此可以看出此作业输出为对角阵的上半部分。
此作业计算相似度的方式为：在map阶段完成aggregate计算，计算方式依相似度函数而定，此处以SIMILARITY_EUCLIDEAN_DISTANCE为例，计算方式如下，
@Override
public double aggregate(double valueA, double nonZeroValueB) {
return valueA * nonZeroValueB;
}再reduce阶段通过使用map阶段计算出的aggregate值和2.2作业的norms值，得到item之间的相似度，相似度的计算方式依相似度函数而定，此处以EuclideanDistanceSimilarity为例，计算方式如下：
@Override
public double similarity(double dots, double normA, double normB, int numberOfColumns) {
// Arg can't be negative in theory, but can in practice due to rounding, so cap it.
// Also note that normA / normB are actually the squares of the norms.
double euclideanDistance = Math.sqrt(Math.max(0.0, normA - 2 * dots + normB));
return 1.0 / (1.0 + euclideanDistance);
}此作业的计算结果保存在 tempDir/pairwiseSimilarity中。
2.4 asMatrix
此作业的map类为UnsymmetrifyMapper.class，reduce类为MergeToTopKSimilaritiesReducer.class。
asMatrix的作用是将2.3的矩阵矩阵整理为完整的相似度矩阵。输入为2.3的pairwiseSimilarity文件，格式为（itemM，VectorWritable <itemM+,similarscore>），输出为（itemM，VectorWritable （（item1,similarscore），（item2，similarscore），....）。
asMatrix作业的工作方式为：在map阶段，计算pairwiseSimilarity中每个item的maxSimilaritiesPerRow（默认为100）个最相似的item，使用TopElementsQueue函数。在reduce阶段，首先将斜半矩阵合并成全矩阵，然后使用Vectors.topKElements（）函数，取出最相似的maxSimilaritiesPerRow个item。此处可以看出map阶段相当于reduce的预处理阶段，将对角矩阵进行预处理，减少了reduce的计算量。
asMatrix计算结果保存在tempDir/similarityMatrix文件中。
2.5 outputSimilarityMatrix
如果设置了outputPathForSimilarityMatrix参数，此作业将被执行。
outputSimilarityMatrix作用是将2.4产生的结果保存到用户通过outputPathForSimilarityMatrix参数设置的目录里。
3、partialMultiply作业
此作业也位于org.apache.mahout.cf.taste.hadoop.item.RecommenderJob包中，位于run函数中。分析此作业代码：
if (shouldRunNextPhase(parsedArgs, currentPhase)) {
Job partialMultiply = new Job(getConf(), "partialMultiply");
Configuration partialMultiplyConf = partialMultiply.getConfiguration();
MultipleInputs.addInputPath(partialMultiply, similarityMatrixPath, SequenceFileInputFormat.class,
SimilarityMatrixRowWrapperMapper.class);
MultipleInputs.addInputPath(partialMultiply, new Path(prepPath, PreparePreferenceMatrixJob.USER_VECTORS),
SequenceFileInputFormat.class, UserVectorSplitterMapper.class);
partialMultiply.setJarByClass(ToVectorAndPrefReducer.class);
partialMultiply.setMapOutputKeyClass(VarIntWritable.class);
partialMultiply.setMapOutputValueClass(VectorOrPrefWritable.class);
partialMultiply.setReducerClass(ToVectorAndPrefReducer.class);
partialMultiply.setOutputFormatClass(SequenceFileOutputFormat.class);
partialMultiply.setOutputKeyClass(VarIntWritable.class);
partialMultiply.setOutputValueClass(VectorAndPrefsWritable.class);
partialMultiplyConf.setBoolean("mapred.compress.map.output", true);
partialMultiplyConf.set("mapred.output.dir", partialMultiplyPath.toString());
if (usersFile != null) {
partialMultiplyConf.set(UserVectorSplitterMapper.USERS_FILE, usersFile);
}
partialMultiplyConf.setInt(UserVectorSplitterMapper.MAX_PREFS_PER_USER_CONSIDERED, maxPrefsPerUser);
boolean succeeded = partialMultiply.waitForCompletion(true);
if (!succeeded) {
return -1;
}
}分析上面代码可知，此作业通过MultipleInputs.addInputPath（）函数执行了SimilarityMatrixRowWrapperMapper.class和UserVectorSplitterMapper.class作为reduce的输入，reduce阶段执行了ToVectorAndPrefReducer.class类。
3.1 SimilarityMatrixRowWrapperMapper.class
此map作用是将similarity matrix每一行映射VectorOrPrefWritable格式。此map输入格式为（itemid，VectorWritable<itemid,similarscore>），输出格式为（itemid，VectorOrPrefWritable）。VectorOrPrefWritable类包含三个成员分别是：vector，long userid，float value。在此map阶段只是书写了VectorOrPrefWritable类的vector。
3.2 UserVectorSplitterMapper.class
此map作用是用户向量转化为VectorOrPrefWritable对象表示形式。此map输入为1.2作业结果即tempDir/preparePreferenceMatrix/userVectors文件，输出格式为（itemid，VectorOrPrefWritable）。此map阶段只书写了VectorOrPrefWritable类的userid和value。
3.3 ToVectorAndPrefReducer
这是partialMultiply作业的reduce阶段，此阶段的输入是3.1 map阶段和3.2 map阶段的输出结果，格式为（itemid，VectorOrPrefWritable），输出格式为（itemid，VectorAndPrefsWritable）。此阶段的工作方式为，将3.1 map和3.2 map传来的数据，分别写入VectorAndPrefsWritable中的List<Long> userIDs，List<Float> prefValues，Vector similarityMatrixColumn。
此作业的结果保存在tempDir/partialMultiply文件中
4、itemFiltering作业
当用户设置了filterFile文件时，此作业才会执行。此作业的作用是过滤掉文件中设置的item。
5、aggregateAndRecommend作业
此作业的map类为PartialMultiplyMapper，reduce类为AggregateAndRecommendReducer。
此作业的作用是提取出推荐结果。最后的推荐结果会保存到设置的output目录下。
当没有设置filterFile文件时，此作业的输入为3.3作业的输出文件tempDir/partialMultiply格式为（itemid，VectorAndPrefsWritable），输出格式为（userid，RecommendedItemsWritable）
此作业工作方式为：map阶段映射每个用户的preferences值和对应的item相似向量，即表示形式为(userIDWritable, PrefAndSimilarityColumnWritable)，PrefAndSimilarityColumnWritable类里面记录了float prefValue和Vector similarityColumn。
reduce阶段首先判断booleanData参数，如果是true，执行reduceBooleanData，如果是false，执行reduceNonBooleanData，一般默认为false。reduce阶段计算方式如下所示：
/**
* <p>computes prediction values for each user</p>
*
* <pre>
* u = a user
* i = an item not yet rated by u
* N = all items similar to i (where similarity is usually computed by pairwisely comparing the item-vectors
* of the user-item matrix)
*
* Prediction(u,i) = sum(all n from N: similarity(i,n) * rating(u,n)) / sum(all n from N: abs(similarity(i,n)))
* </pre>
*/
@Override
protected void reduce(VarLongWritable userID,
Iterable<PrefAndSimilarityColumnWritable> values,
Context context) throws IOException, InterruptedException {
if (booleanData) {
reduceBooleanData(userID, values, context);
} else {
reduceNonBooleanData(userID, values, context);
}
}
private void reduceBooleanData(VarLongWritable userID,
Iterable<PrefAndSimilarityColumnWritable> values,
Context context) throws IOException, InterruptedException {
/* having boolean data, each estimated preference can only be 1,
* however we can't use this to rank the recommended items,
* so we use the sum of similarities for that. */
Iterator<PrefAndSimilarityColumnWritable> columns = values.iterator();
Vector predictions = columns.next().getSimilarityColumn();
while (columns.hasNext()) {
predictions.assign(columns.next().getSimilarityColumn(), Functions.PLUS);
}
writeRecommendedItems(userID, predictions, context);
}
private void reduceNonBooleanData(VarLongWritable userID,
Iterable<PrefAndSimilarityColumnWritable> values,
Context context) throws IOException, InterruptedException {
/* each entry here is the sum in the numerator of the prediction formula */
Vector numerators = null;
/* each entry here is the sum in the denominator of the prediction formula */
Vector denominators = null;
/* each entry here is the number of similar items used in the prediction formula */
Vector numberOfSimilarItemsUsed = new RandomAccessSparseVector(Integer.MAX_VALUE, 100);
for (PrefAndSimilarityColumnWritable prefAndSimilarityColumn : values) {
Vector simColumn = prefAndSimilarityColumn.getSimilarityColumn();
float prefValue = prefAndSimilarityColumn.getPrefValue();
/* count the number of items used for each prediction */
for (Element e : simColumn.nonZeroes()) {
int itemIDIndex = e.index();
numberOfSimilarItemsUsed.setQuick(itemIDIndex, numberOfSimilarItemsUsed.getQuick(itemIDIndex) + 1);
}
if (denominators == null) {
denominators = simColumn.clone();
} else {
denominators.assign(simColumn, Functions.PLUS_ABS);
}
if (numerators == null) {
numerators = simColumn.clone();
if (prefValue != BOOLEAN_PREF_VALUE) {
numerators.assign(Functions.MULT, prefValue);
}
} else {
if (prefValue != BOOLEAN_PREF_VALUE) {
simColumn.assign(Functions.MULT, prefValue);
}
numerators.assign(simColumn, Functions.PLUS);
}
}
if (numerators == null) {
return;
}
Vector recommendationVector = new RandomAccessSparseVector(Integer.MAX_VALUE, 100);
for (Element element : numerators.nonZeroes()) {
int itemIDIndex = element.index();
/* preference estimations must be based on at least 2 datapoints */
if (numberOfSimilarItemsUsed.getQuick(itemIDIndex) > 1) {
/* compute normalized prediction */
double prediction = element.get() / denominators.getQuick(itemIDIndex);
recommendationVector.setQuick(itemIDIndex, prediction);
}
}
writeRecommendedItems(userID, recommendationVector, context);
}
/**
* find the top entries in recommendationVector, map them to the real itemIDs and write back the result
*/
private void writeRecommendedItems(VarLongWritable userID, Vector recommendationVector, Context context)
throws IOException, InterruptedException {
TopItemsQueue topKItems = new TopItemsQueue(recommendationsPerUser);
for (Element element : recommendationVector.nonZeroes()) {
int index = element.index();
long itemID;
if (indexItemIDMap != null && !indexItemIDMap.isEmpty()) {
itemID = indexItemIDMap.get(index);
} else { //we don't have any mappings, so just use the original
itemID = index;
}
if (itemsToRecommendFor == null || itemsToRecommendFor.contains(itemID)) {
float value = (float) element.get();
if (!Float.isNaN(value)) {
MutableRecommendedItem topItem = topKItems.top();
if (value > topItem.getValue()) {
topItem.set(itemID, value);
topKItems.updateTop();
}
}
}
}
List<RecommendedItem> topItems = topKItems.getTopItems();
if (!topItems.isEmpty()) {
recommendedItems.set(topItems);
context.write(userID, recommendedItems);
}
}
扫一扫
202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
