public UserMovieRatingsTable GetUserMovieRatingsTable()
{
var users = _mapper.Map <IEnumerable <UserViewModel> >(_userRepository.GetAll());
var usersIdList = new List <string>();
foreach (var user in users)
{
usersIdList.Add(user.Id);
}
UserMovieRatingsTable table = new UserMovieRatingsTable();
table.UserIndexToId = usersIdList;
var movies = _mapper.Map <IEnumerable <MovieViewModel> >(_movieRepository.GetAll());
var moviesIdList = new List <int>();
foreach (var movie in movies)
{
moviesIdList.Add(movie.Id);
}
table.MovieIndexToId = moviesIdList;
foreach (var userId in table.UserIndexToId)
{
table.Users.Add(new UserMoviesRatings(userId, table.MovieIndexToId.Count));
}
foreach (var user in _userRepository.GetAll())
{
var userActions = _userActionRepo.GetAll().Where(x => x.UserId == user.Id);
foreach (var movie in _movieRepository.GetAll())
{
List <UserActionsViewModel> actionsForMovie = new List <UserActionsViewModel>();
foreach (var userAction in userActions)
{
var userActionsMovie = _userActionMovieRepo.GetAll().Where(x => x.MovieId == movie.Id && x.UserActionId == userAction.Id);
foreach (var userActionMovie in userActionsMovie)
{
UserActionsViewModel userActionsViewModel = new UserActionsViewModel
{
Action = (ActionsViewModel)userActionMovie.UserActions.Action,
};
actionsForMovie.Add(userActionsViewModel);
}
}
int userIndex = table.UserIndexToId.IndexOf(user.Id);
int movieIndex = table.MovieIndexToId.IndexOf(movie.Id);
table.Users[userIndex].MovieRatings[movieIndex] = Rating(actionsForMovie);
}
}
return(table);
}
private List <int> GetHighestRatedArticlesForUser(int userIndex, UserMovieRatingsTable table)
{
List <Tuple <int, double> > items = new List <Tuple <int, double> >();
for (int articleIndex = 0; articleIndex < table.MovieIndexToId.Count; articleIndex++)
{
if (table.Users[userIndex].MovieRatings[articleIndex] != 0)
{
items.Add(new Tuple <int, double>(articleIndex, table.Users[userIndex].MovieRatings[articleIndex]));
}
}
items.Sort((c, n) => n.Item2.CompareTo(c.Item2));
return(items.Select(x => x.Item1).ToList());
}
private void FillTransposedRatings(UserMovieRatingsTable table)
{
int features = table.Users.Count;
transposedRatings = new double[table.MovieIndexToId.Count][];
for (int a = 0; a < table.MovieIndexToId.Count; a++)
{
transposedRatings[a] = new double[features];
for (int f = 0; f < features; f++)
{
transposedRatings[a][f] = table.Users[f].MovieRatings[a];
}
}
}
private List <MovieRating> GetNearestNeighbors(int movieId, int nummovies, UserMovieRatingsTable table)
{
FillTransposedRatings(table);
List <MovieRating> neighbors = new List <MovieRating>();
var mainMovieIndex = table.MovieIndexToId.IndexOf(movieId);
Methods pearsoneCorrelation = new Methods {
};
for (int movieIndex = 0; movieIndex < table.MovieIndexToId.Count - 1; movieIndex++)
{
int searchMovieIndex = table.MovieIndexToId[movieIndex];
double score = pearsoneCorrelation.PearsoneCorrelation(transposedRatings[mainMovieIndex], transposedRatings[searchMovieIndex]);
neighbors.Add(new MovieRating(searchMovieIndex, score));
}
neighbors.Sort((c, n) => n.Rating.CompareTo(c.Rating));
return(neighbors.Take(nummovies).ToList());
}
public List <MovieViewModel> GetSuggestions(string userId, int numSuggestions, UserMovieRatingsTable table)
{
int userIndex = table.UserIndexToId.IndexOf(userId);
List <int> movies = GetHighestRatedArticlesForUser(userIndex, table).Take(5).ToList();
List <Suggestion> suggestions = new List <Suggestion>();
foreach (int movieIndex in movies)
{
int movieId = table.MovieIndexToId[movieIndex];
List <MovieRating> neighboringMovies = GetNearestNeighbors(movieId, 5, table);
foreach (MovieRating neighbor in neighboringMovies)
{
int neighborArticleIndex = table.MovieIndexToId.IndexOf(neighbor.MovieId);
double averageMovieRating = 0.0;
int count = 0;
for (int userRatingIndex = 0; userRatingIndex < table.UserIndexToId.Count; userRatingIndex++)
{
if (transposedRatings[neighborArticleIndex][userRatingIndex] != 0)
{
averageMovieRating += transposedRatings[neighborArticleIndex][userRatingIndex];
count++;
}
}
if (count > 0)
{
averageMovieRating /= count;
}
suggestions.Add(new Suggestion(userId, neighbor.MovieId, averageMovieRating));
}
}
suggestions.Sort((c, n) => n.Rating.CompareTo(c.Rating));
var suggestionsList = suggestions.Take(numSuggestions).ToList();
List <MovieViewModel> movieViewModels = new List <MovieViewModel>();
foreach (var suggestion in suggestionsList)
{
var movieViewModel = _mapper.Map <MovieViewModel>(_movieRepository.GetAll().FirstOrDefault(x => x.Id == suggestion.MovieId));
movieViewModels.Add(movieViewModel);
}
return(movieViewModels);
}
private List <UserMoviesRatings> GetNearestNeighbors(string userId, UserMoviesRatings user, int numUsers, UserMovieRatingsTable table)
{
List <UserMoviesRatings> neighbors = new List <UserMoviesRatings>();
Methods pearsoneCorrelation = new Methods {
};
for (var i = 0; i < table.Users.Count(); i++)
{
if (table.Users[i].UserId == user.UserId)
{
table.Users[i].Score = double.NegativeInfinity;
}
else
{
table.Users[i].Score = pearsoneCorrelation.PearsoneCorrelation(table.Users[i].MovieRatings, user.MovieRatings);
}
}
var similarUsers = table.Users.OrderByDescending(x => x.Score);
return(similarUsers.Take(numUsers).ToList());
}
public List <MovieViewModel> GetSuggestions(string userId, int numSuggestions, UserMovieRatingsTable table)
{
int userIndex = table.UserIndexToId.IndexOf(userId);
UserMoviesRatings user = table.Users[userIndex];
List <Suggestion> suggestions = new List <Suggestion>();
List <UserMoviesRatings> neighbors = GetNearestNeighbors(userId, user, 5, table);
if (neighbors.ToList()[0].Score <= 0.5)
{
ItemBasedRecommender itemBasedRecommender = new ItemBasedRecommender(_mapper, _movieRepository);
return(itemBasedRecommender.GetSuggestions(userId, 10, table));
}
for (int movieIndex = 0; movieIndex < table.MovieIndexToId.Count; movieIndex++)
{
if (user.MovieRatings[movieIndex] != 0)
{
double score = 0.0;
int count = 0;
for (var u = 0; u < neighbors.Count; u++)
{
if (neighbors[u].MovieRatings[movieIndex] != 0)
{
score += neighbors[u].MovieRatings[movieIndex] - ((u + 1.0) / 100.0);
count++;
}
}
if (count > 0)
{
score /= count;
}
suggestions.Add(new Suggestion(userId, table.MovieIndexToId[movieIndex], score));
}
}
suggestions.Sort((c, n) => n.Rating.CompareTo(c.Rating));
List <Suggestion> suggestionsList = suggestions.Take(numSuggestions).ToList();
List <MovieViewModel> movieViewModels = new List <MovieViewModel>();
foreach (var suggestion in suggestionsList)
{
Movie movie = _movieRepository.GetById(suggestion.MovieId);
movieViewModels.Add(_mapper.Map <MovieViewModel>(movie));
}
return(movieViewModels);
}
