private double SignTest(PredictionMethod A, PredictionMethod B)
{
double winA; double winB;
Contest(A, B, out winA, out winB);
return(1 - pAnotBetterThanB((int)Math.Round(winA), (int)Math.Round(winB)));
}
//predict a rating for a user item pair using the specified method
public double PredictRating(PredictionMethod m, string sUID, string sIID)
{
User user = users.getUserById(sUID);
Item item = items.GetItemById(sIID);
return(predictionEngine.Predict(m, user, item));
}
private double ComputeRMSE(PredictionMethod m, RecommenderSystemEngine engineTrain, IEnumerable <RankingDB.RankData> allTest)
{
double sum = 0;
foreach (var rankData in allTest)
{
double pretictedRating = Math.Round(engineTrain.PredictRating(m, rankData.ranker, rankData.item));
sum += Math.Pow((rankData.rank - pretictedRating), 2);
}
return(Math.Sqrt(sum / allTest.Count()));
}
public Dictionary <double, double> PredictAllRatings(PredictionMethod m, string sUID, string sIID)
{
SimilartyData <string> similarityData = null;
switch (m)
{
case PredictionMethod.Pearson:
similarityData = usr2usr[m];
break;
case PredictionMethod.Cosine:
similarityData = usr2usr[m];
break;
case PredictionMethod.Random:
break;
case PredictionMethod.SVD:
break;
case PredictionMethod.Stereotypes:
break;
default:
break;
}
if (similarityData == null)
{
throw new NotImplementedException();
}
IEnumerable <string> users = getUsers(sUID, sIID, similarityData).ToList();
Dictionary <double, double> rankToSumSimilarity = new Dictionary <double, double>();
foreach (var usr in users)
{
var rank = _db.GetRank(usr, sIID);
if (!rankToSumSimilarity.ContainsKey(rank.Value))
{
rankToSumSimilarity[rank.Value] = 0;
}
double sim = similarityData.GetSimilarity(sUID, usr);
if (sim > 0)
{
rankToSumSimilarity[rank.Value] += sim;
}
}
return(rankToSumSimilarity);
}
public Dictionary <PredictionMethod, double> ComputeRMSE(List <PredictionMethod> lMethods, out Dictionary <PredictionMethod, Dictionary <PredictionMethod, double> > dConfidence)
{
// compute RMSE
Dictionary <PredictionMethod, double> results = new Dictionary <PredictionMethod, double>();
foreach (var method in lMethods)
{
IPredictionModel model = predictionEngine.getModel(method);
if (model != null)
{
var rmse = evaluationEngine.computeRMSE(testUsers, testItems, model);
results.Add(method, rmse);
}
}
// compute dConfidence
dConfidence = new Dictionary <PredictionMethod, Dictionary <PredictionMethod, double> >();
foreach (var method in lMethods)
{
dConfidence.Add(method, new Dictionary <PredictionMethod, double>());
}
List <Tuple <PredictionMethod, PredictionMethod> > methodPairs = DataUtils.getAllPairedCombinations(lMethods);
foreach (var methodPair in methodPairs)
{
PredictionMethod method1 = methodPair.Item1;
PredictionMethod method2 = methodPair.Item2;
Tuple <double, double> pApB = evaluationEngine.computeConfidence(testUsers, testItems, predictionEngine.getModel(method1), predictionEngine.getModel(method2));
dConfidence[method1].Add(method2, pApB.Item1);
dConfidence[method2].Add(method1, pApB.Item2);
}
return(results);
}
private void Contest(PredictionMethod A, PredictionMethod B, out double winA, out double winB)
{
winA = 0; winB = 0;
foreach (var rankData in _allTest)
{
double eA = Math.Abs(rankData.rank - PredictRating(A, rankData.ranker, rankData.item));
double eB = Math.Abs(rankData.rank - PredictRating(B, rankData.ranker, rankData.item));
if (eA < eB)
{
++winA;
}
if (eA > eB)
{
++winB;
}
if (eA == eB)
{
winA += 0.5;
winB += 0.5;
}
}
}
public List <string> Recommend(RecommendationMethod sAlgorithm, string sUserId, int cRecommendations)
{
if (sAlgorithm == RecommendationMethod.Popularity)
{
return(recommendPopularity(sUserId, cRecommendations));
}
else if (sAlgorithm.ToString().StartsWith("NN"))
{
return(recommendNN(sAlgorithm, sUserId, cRecommendations));
}
else if (sAlgorithm == RecommendationMethod.Jaccard)
{
return(recommendCP(sUserId, cRecommendations, true));
}
else if (sAlgorithm == RecommendationMethod.CP)
{
return(recommendCP(sUserId, cRecommendations, false));
}
else //prediction
{
PredictionMethod predictionMethod = PredictionMethod.Pearson;
if (sAlgorithm == RecommendationMethod.BaseModel)
{
predictionMethod = PredictionMethod.BaseModel;
}
else if (sAlgorithm == RecommendationMethod.Cosine)
{
predictionMethod = PredictionMethod.Cosine;
}
else if (sAlgorithm == RecommendationMethod.Stereotypes)
{
predictionMethod = PredictionMethod.Stereotypes;
}
return(recommendPredictions(sUserId, cRecommendations, predictionMethod));
}
}
private List <string> recommendPredictions(string sUserId, int cRecommendations, PredictionMethod predictionMethod)
{
//List<string> ans = new List<string>();
//SortedDictionary<double, List<string>> moviesPredictedRatings = new SortedDictionary<double, List<string>>();
Dictionary <string, double> moviesPredictedRatings = new Dictionary <string, double>();
foreach (string movie in m_trainMovieToUser.Keys)
{
if (m_trainMovieToUser[movie].Contains(sUserId))
{
continue;
}
double predictedRating = PredictRating(predictionMethod, sUserId, movie);
moviesPredictedRatings.Add(movie, predictedRating);
/* if (!moviesPredictedRatings.ContainsKey(predictedRating))
* moviesPredictedRatings.Add(predictedRating, new List<string>());
* moviesPredictedRatings[predictedRating].Add(movie);*/
}
List <string> moviesSorted = moviesPredictedRatings.Keys.ToList();
moviesSorted.Sort((a, b) => moviesPredictedRatings[a].CompareTo(moviesPredictedRatings[b]));
return(moviesSorted.Take(cRecommendations).ToList());
}
public List <KeyValuePair <string, double> > getProbability(List <string> givenItems, PredictionMethod method)
{
if (method == PredictionMethod.Cp)
{
return(getConditionalProbability(givenItems));
}
return(getSequenceProbability(new List <string> {
givenItems.Last()
}));
}
//predict a rating for a user item pair using the specified method
public double PredictRating(PredictionMethod m, string sUID, string sIID)
{
if (m_ratings.Count == 0)
{
Console.WriteLine("No ratings in memory");
return(-1);
}
if (!m_ratings.ContainsKey(sUID))
{
Console.WriteLine("invalid user ID");
return(-1);
}
if (!m_trainMovieToUser.ContainsKey(sIID))
{
Console.WriteLine("invalid Item ID");
return(-1);
}
//if the user rated only one movie and the movie is sIID ?
if (m_ratings[sUID].Keys.Count == 1 && m_ratings[sUID].ContainsKey(sIID))
{
return(-1);
}
if (m == PredictionMethod.Cosine || m == PredictionMethod.Pearson)
{
double numerator = 0;
double denominator = 0;
foreach (string uID in m_trainMovieToUser[sIID])
{
if (uID.Equals(sUID))
{
continue;
}
double wau = 0;
double right = (m_ratings[uID][sIID] - m_trainUserAvgs[uID]); //does it need to be Abs value??
if (m == PredictionMethod.Pearson)
{
wau = calcWPearson(sUID, uID, sIID);
if (wau >= 0.1)
{
numerator += (wau * right);
denominator += wau;
}
}
else if (m == PredictionMethod.Cosine)
{
wau = calcWCosine(sUID, uID, sIID);
numerator += (wau * right);
denominator += wau;
}
}
double maxRating = m_ratings[sUID].Values.Max();
double ans = m_trainUserAvgs[sUID];
if (numerator == 0 && denominator == 0)
{
return(ans);
}
ans += (numerator / denominator);
if (ans > maxRating) //!!
{
return(maxRating);
}
return(ans); //should be Ra + num/dem
}
if (m == PredictionMethod.BaseModel)
{
if (!m_trainedBaseModel)
{
TrainBaseModel(10); //we need to save bu bi qu pi as fields in order to get the rating
m_trainedBaseModel = true;
}
return(predictRatingBaseModel(sUID, sIID));
}
if (m == PredictionMethod.Stereotypes)
{
if (!m_trainedStereoType)
{
TrainStereotypes(10);
m_trainedStereoType = true;
}
return(predictRatingStereoType(sUID, sIID));
}
else//else random
{
return(randomPredictRating(sUID, sIID));
}
}
public double PredictRating(PredictionMethod m, string sUID, string sIID)
{
SimilartyData similarityData = null;
switch (m)
{
case PredictionMethod.Pearson:
similarityData = usr2usr[m];
break;
case PredictionMethod.Cosine:
similarityData = usr2usr[m];
break;
case PredictionMethod.Random:
return(GetRandomRank(sUID));
case PredictionMethod.SVD:
return(_svd.Predict(sUID, sIID));
case PredictionMethod.Stereotypes:
break;
default:
break;
}
if (similarityData == null)
{
throw new NotImplementedException();
}
IEnumerable <string> users = getUsers(sUID, sIID, similarityData).ToList();
double mone = 0;
foreach (var usr in users)
{
if (usr == sUID)
{
continue;
}
double avg = _db.GetRanks(usr).Average();
var sim = similarityData.GetSimilarity(sUID, usr);
if (sim > 0)
{
mone += sim * (_db.GetRank(usr, sIID).Value - avg);
}
}
double avgCurrent = 0;
var ranks = _db.GetRanks(sUID).ToList();
if (ranks.Count > 0)
{
avgCurrent = ranks.Average();
}
if (mone == 0)
{
return(avgCurrent);
}
double mechane = 0;
foreach (var usr in users)
{
if (usr == sUID)
{
continue;
}
var sim = similarityData.GetSimilarity(sUID, usr);
if (sim > 0)
{
mechane += sim;
}
}
//mechne will be zero only if mone will be zero, and if move is zero
//we already exit
return(avgCurrent + mone / mechane);
}
public double PredictRating(PredictionMethod m, string sUID, string sIID)
{
throw new NotImplementedException();
}
private double ComputeRMSE(PredictionMethod m, RankingDB db)
{
return(ComputeRMSE(m, new RecommenderSystemEngine(db), db.GetAllData()));
}
//return the predicted weights of all ratings that a user may give an item using one of the methods "Pearson", "Cosine", "Random"
public Dictionary <double, double> PredictAllRatings(PredictionMethod m, string sUID, string sIID)
{
return(_trainEngine.PredictAllRatings(m, sUID, sIID));
}
//return an histogram of all ratings that the user has used
/*public Dictionary<double, int> GetRatingsHistogram(string sUID)
* {
* Dictionary<double, int> res = new Dictionary<double, int>();
*
* IEnumerable<double> AllRanks = _ratings.GetRanks(sUID);
* foreach (var rank in AllRanks)
* {
* if (!res.ContainsKey(rank))
* res[rank] = 0;
++res[rank];
* }
* return res;
* }*/
//predict the rating that a user will give to an item using one of the methods "Pearson", "Cosine", "Random"
public double PredictRating(PredictionMethod m, string sUID, string sIID)
{
return(_trainEngine.PredictRating(m, sUID, sIID));
}
public EvaluationResult(PredictionMethod method, int len, double score)
{
this.method = method;
this.len = len;
this.score = score;
}
