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; }