public async Task <bool> CreatePredictionCoursesForParticipants()
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
Log.Information("Inicio CreatePredictionCoursesForParticipants");
try
{
var ratingCursos = await ratingCursoRepository.GetAllAsync();
var ratingCursosToTrain = ratingCursos.Select(x => new CourseEntry {
IdCurso = Convert.ToUInt32(x.IdCurso), IdParticipante = Convert.ToUInt32(x.IdParticipante), Rating = (float)x.Rating
}).ToList();
MLContext mlContext = new MLContext();
var traindata = mlContext.Data.LoadFromEnumerable(ratingCursosToTrain);
MatrixFactorizationTrainer.Options options = new MatrixFactorizationTrainer.Options();
options.MatrixColumnIndexColumnName = nameof(CourseEntry.IdCurso);
options.MatrixRowIndexColumnName = nameof(CourseEntry.IdParticipante);
options.LabelColumnName = "Rating";
options.LossFunction = MatrixFactorizationTrainer.LossFunctionType.SquareLossRegression;
options.Alpha = 0.01;
options.Lambda = 0.025;
options.NumberOfIterations = 1000;
var trainingPipeLine = mlContext.Recommendation().Trainers.MatrixFactorization(options);
ITransformer model = trainingPipeLine.Fit(traindata);
var predictionengine = mlContext.Model.CreatePredictionEngine <CourseEntry, CursoRatingPrediction>(model);
int?allItemsInteger = default;
var cursos = await cursoRepository.GetCursosAsync(allItemsInteger, allItemsInteger, allItemsInteger, default);
var participantes = await participanteRepository.GetParticipantesAsync(allItemsInteger, allItemsInteger);
await predictionTrainerRepository.ClearPredictionsAsync();
Log.Information("All predictions has deleted until {date}", DateTime.Now);
foreach (var participante in participantes)
{
var topCursos = cursos.Select(x => new
{
Curso = x.Nombre,
x.IdCurso,
Score = (predictionengine.Predict(
new CourseEntry()
{
IdCurso = Convert.ToUInt16(x.IdCurso),
IdParticipante = Convert.ToUInt16(participante.IdParticipante)
}).Score)
}).OrderByDescending(x => x.Score).Take(5);
foreach (var item in topCursos)
{
Console.WriteLine($" Participante: {participante.IdParticipante} {participante.Nombre} Curso: {item.Curso} prediction.Rating: {Math.Round(item.Score)} {item.Score} ");
RatingCursoEntity ratingCursoEntity = new RatingCursoEntity();
var rating = (int)Math.Round(item.Score);
ratingCursoEntity.Rating = rating >= (int)decimal.Zero ? rating : (int)decimal.Zero;
ratingCursoEntity.IdParticipante = participante.IdParticipante;
ratingCursoEntity.IdCurso = item.IdCurso;
await predictionTrainerRepository.CreatePredictionCourseForParticipantAsync(ratingCursoEntity);
}
}
stopWatch.Stop();
Log.Information("Finalizado CreatePredictionCoursesForParticipants in {elapsedTime}", stopWatch.Elapsed);
return(true);
}
catch (Exception ex)
{
stopWatch.Stop();
Log.Error("Un error a ocurrido en la Predicción de Cursos con la siguiente excepción: {errormessage}", ex.Message);
return(false);
}
}
/// <summary>
/// The program entry point.
/// </summary>
/// <param name="args">The command line arguments</param>
static void Main(string[] args)
{
// set up a new machine learning context
var context = new MLContext();
// load training and test data
var trainingDataView = context.Data.LoadFromTextFile <MovieRating>(trainingDataPath, hasHeader: true, separatorChar: ',');
var testDataView = context.Data.LoadFromTextFile <MovieRating>(testDataPath, hasHeader: true, separatorChar: ',');
// prepare matrix factorization options
var options = new MatrixFactorizationTrainer.Options
{
MatrixColumnIndexColumnName = "UserIDEncoded",
MatrixRowIndexColumnName = "MovieIDEncoded",
LabelColumnName = "Label",
NumberOfIterations = 20,
ApproximationRank = 100
};
// set up a training pipeline
// step 1: map userId and movieId to keys
var pipeline = context.Transforms.Conversion.MapValueToKey(
inputColumnName: "UserID",
outputColumnName: "UserIDEncoded")
.Append(context.Transforms.Conversion.MapValueToKey(
inputColumnName: "MovieID",
outputColumnName: "MovieIDEncoded")
// step 2: find recommendations using matrix factorization
.Append(context.Recommendation().Trainers.MatrixFactorization(options)));
// train the model
Console.WriteLine("Training the model...");
var model = pipeline.Fit(trainingDataView);
Console.WriteLine();
// evaluate the model performance
Console.WriteLine("Evaluating the model...");
var predictions = model.Transform(testDataView);
var metrics = context.Regression.Evaluate(predictions, labelColumnName: "Label", scoreColumnName: "Score");
Console.WriteLine($" RMSE: {metrics.RootMeanSquaredError:#.##}");
Console.WriteLine($" MAE: {metrics.MeanAbsoluteError:#.##}");
Console.WriteLine($" MSE: {metrics.MeanSquaredError:#.##}");
Console.WriteLine();
// check if Mark likes 'GoldenEye'
Console.WriteLine("Calculating the score for Mark liking the movie 'GoldenEye'...");
var predictionEngine = context.Model.CreatePredictionEngine <MovieRating, MovieRatingPrediction>(model);
var prediction = predictionEngine.Predict(
new MovieRating()
{
UserID = 999,
MovieID = 10 // GoldenEye
}
);
Console.WriteLine($" Score: {prediction.Score}");
Console.WriteLine();
// find Mark's top 5 movies
Console.WriteLine("Calculating Mark's top 5 movies...");
var top5 = (from m in Movies.All
let p = predictionEngine.Predict(
new MovieRating()
{
UserID = 999,
MovieID = m.ID
})
orderby p.Score descending
select(MovieId: m.ID, Score: p.Score)).Take(5);
foreach (var t in top5)
{
Console.WriteLine($" Score:{t.Score}\tMovie: {Movies.Get(t.MovieId)?.Title}");
}
Console.ReadLine();
}
public async Task <List <int> > Get(string id)
{
string path = AppDomain.CurrentDomain.BaseDirectory + @"pauseproject.json";
Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", path);
database = FirestoreDb.Create("pauseproject-349dd");
var res = await GetCollection(id);
string filepath = AppDomain.CurrentDomain.BaseDirectory;
using (StreamWriter file = new System.IO.StreamWriter(filepath + @"\..\..\..\Data\users.json"))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(file, res);
}
using (var r = new ChoJSONReader(filepath + @"\..\..\..\Data\users.json"))
{
using (var w = new ChoCSVWriter(filepath + @"\..\..\..\Data\" + "users.csv").WithFirstLineHeader())
{
w.Write(r);
}
}
//start machine learning algorithm
var mlContext = new MLContext();
var trainingDataView = mlContext.Data.LoadFromTextFile <GameStarFSDTO>(filepath + @"..\..\..\Data\users.csv", hasHeader: true, separatorChar: ',');
var testDataView = mlContext.Data.LoadFromTextFile <GameStarFSDTO>(filepath + @"..\..\..\Data\usersTest.csv", hasHeader: true, separatorChar: ',');
var options = new MatrixFactorizationTrainer.Options
{
MatrixColumnIndexColumnName = "userIDEncoded",
MatrixRowIndexColumnName = "collectionIDEncoded",
LabelColumnName = "value",
NumberOfIterations = 20,
ApproximationRank = 100
};
var pipeline = mlContext.Transforms.Conversion.MapValueToKey(
inputColumnName: "userID",
outputColumnName: "userIDEncoded")
.Append(mlContext.Transforms.Conversion.MapValueToKey(
inputColumnName: "collectionID",
outputColumnName: "collectionIDEncoded")
.Append(mlContext.Recommendation().Trainers.MatrixFactorization(options)));
var model = pipeline.Fit(trainingDataView);
var predictions = model.Transform(testDataView);
var metrics = mlContext.Regression.Evaluate(predictions, labelColumnName: "value", scoreColumnName: "Score");
var predictionEngine = mlContext.Model.CreatePredictionEngine <GameStarFSDTO, GameRatingPrediction>(model);
//predict specific game for a user
/*
* var prediction = predictionEngine.Predict(
* new GameStarFSDTO()
* {
* userID = "Xa5hyfP8HjaX9kbsLTnckuQfuaI3",
* collectionID = 4200
* }
* );
* Console.WriteLine($" Score: {prediction.Score}");
* Console.WriteLine();
*/
Games.LoadGameData(filepath + @"..\..\..\Data\recommendation-games.csv");
//Console.WriteLine(Games._games.Value.Count);
var top5 = (from m in Games._games.Value
let p = predictionEngine.Predict(
new GameStarFSDTO()
{
userID = id,
collectionID = m.ID
})
orderby p.Score descending
select(collectionID: m.ID, p.Score)).Take(10);
List <int> gamesRecommended = new List <int>();
foreach (var t in top5)
{
gamesRecommended.Add((int)Games.Get(t.collectionID)?.ID);
}
//Console.WriteLine($" Score:{t.Score}\tMovie: {Games.Get(t.collectionID)?.ID}");
return(gamesRecommended);
}
/// <summary>
/// Point d'entrée du programme.
/// </summary>
/// <param name="args">Arguments du programme.</param>
static void Main(string[] args)
{
// Création d'un contexte de machine learning.
var mlContext = new MLContext();
// Chargement des données d'entrainement et de tests.
var trainingDataView = mlContext.Data.LoadFromTextFile <MovieRating>(trainingDataPath, hasHeader: true, separatorChar: ',');
var testDataView = mlContext.Data.LoadFromTextFile <MovieRating>(testDataPath, hasHeader: true, separatorChar: ',');
// Options de factorisation de la matrice.
var options = new MatrixFactorizationTrainer.Options
{
MatrixColumnIndexColumnName = "UserIdEncoded",
MatrixRowIndexColumnName = "MovieIdEncoded",
LabelColumnName = "Label",
NumberOfIterations = 20,
ApproximationRank = 100
};
/**
* Pipeline d'entrainement.
* Step 1 : Map des identifiants(user et movie) à des clés.
*/
var pipeline = mlContext.Transforms.Conversion.MapValueToKey(
inputColumnName: "UserId",
outputColumnName: "UserIdEncoded")
.Append(mlContext.Transforms.Conversion.MapValueToKey(
inputColumnName: "MovieId",
outputColumnName: "MovieIdEncoded"))
// Step 2 : Recherche des recommendations avec de la factorisation de matrice.
.Append(mlContext.Recommendation().Trainers.MatrixFactorization(options));
// Entrainement du modèle.
Console.WriteLine("Entrainement du modèle...");
var model = pipeline.Fit(trainingDataView);
Console.WriteLine();
// Evaluation du modèle.
Console.WriteLine("Evaluation du modèle...");
var predictions = model.Transform(testDataView);
var metrics = mlContext.Regression.Evaluate(
predictions,
labelColumnName: nameof(MovieRatingPrediction.Label),
scoreColumnName: nameof(MovieRatingPrediction.Score));
Console.WriteLine($" R2: {metrics.RSquared:#.##} | Doit s'approcher de 1.00");
Console.WriteLine($" MAE: {metrics.MeanAbsoluteError:#.##} | Doit s'approcher de 0.00");
Console.WriteLine($" MSE: {metrics.MeanSquaredError:#.##} | Doit s'approcher de 0.00");
Console.WriteLine($" RMSE: {metrics.RootMeanSquaredError:#.##} | Doit s'approcher de 0.00");
Console.WriteLine();
// Test d'un utilisateur pour le film GoldenEye.
Console.WriteLine("Calcul du score pour l'utilisateur 6 pour le film GoldenEye");
var predictionEngine = mlContext.Model.CreatePredictionEngine <MovieRating, MovieRatingPrediction>(model);
var prediction = predictionEngine.Predict(new MovieRating
{
UserId = 6,
MovieId = 10 // GoldenEye
});
Console.WriteLine($" Score: {prediction.Score}");
Console.WriteLine();
// find the top 5 movies for a given user
Console.WriteLine("Calculating the top 5 movies for user 6...");
var top5 = (from m in MovieRepository.All
let p = predictionEngine.Predict(
new MovieRating()
{
UserId = 6,
MovieId = m.Id
})
orderby p.Score descending
select(MovieId: m.Id, Label: p.Score)).Take(5);
foreach (var(MovieId, Label) in top5)
{
Console.WriteLine($" Score:{Label}\tMovie: {MovieRepository.Get(MovieId)?.Title}");
}
Console.ReadKey();
}
static void Main(string[] args)
{
BCCConsole.Write(BCCConsoleColor.DarkBlue, false, "Restaurant Recommender Is Started . . .");
MLContext mlContext = new MLContext(0);
var trainingDataFile = Environment.CurrentDirectory + @"\Data\TrainingFile.tsv";
DataPreparer.PreprocessData(trainingDataFile);
IDataView trainingDataView = mlContext.Data
.LoadFromTextFile <ModelInput>(trainingDataFile, hasHeader: true);
var dataPreProcessingPipeLine = mlContext.Transforms.Conversion
.MapValueToKey("UserIdEncoded", nameof(ModelInput.UserId))
.Append(mlContext.Transforms.Conversion
.MapValueToKey("RestaurantNameEncoded", nameof(ModelInput.RestaurantName)));
var options = new MatrixFactorizationTrainer.Options
{
MatrixColumnIndexColumnName = "UserIdEncoded",
MatrixRowIndexColumnName = "RestaurantNameEncoded",
LabelColumnName = "TotalRating",
NumberOfIterations = 10,
ApproximationRank = 200,
Quiet = true
};
var trainer = mlContext.Recommendation().Trainers.MatrixFactorization(options);
var trainerPipeLine = dataPreProcessingPipeLine.Append(trainer);
#region Not Using CV
BCCConsole.Write(BCCConsoleColor.DarkBlue, false, "\n", "Training Model");
var model = trainerPipeLine.Fit(trainingDataView);
////Test
//var testUserId = "U1134";
var predictionEngine = mlContext.Model
.CreatePredictionEngine <ModelInput, ModelOutput>(model);
//var alreadyRatedRestaurant = mlContext.Data
// .CreateEnumerable<ModelInput>(trainingDataView, false)
// .Where(r => r.UserId == testUserId)
// .Select(r => r.RestaurantName)
// .Distinct();
//var allRestaurantNames = trainingDataView
// .GetColumn<string>("RestaurantName")
// .Distinct().Where(r => !alreadyRatedRestaurant.Contains(r));
//var scoredRestaurant = allRestaurantNames
// .Select(rn =>
// {
// var prediction = predictionEngine.Predict(
// new ModelInput()
// {
// UserId = testUserId,
// RestaurantName = rn
// });
// return (RestaurantName: rn, PredictedScore: prediction.Score);
// });
//var top10Restaurant = scoredRestaurant
// .OrderByDescending(r => r.PredictedScore)
// .Take(10);
//BCCConsole.Write(BCCConsoleColor.DarkGreen,false,
// "\n",
// $"Top 10 Restaurant Name & Rate For User {testUserId}",
// "----------------------------------------------------");
//foreach (var top in top10Restaurant)
//{
// BCCConsole.Write(BCCConsoleColor.DarkGreen,false,$"Prediction Score [{top.PredictedScore:#.0}] | Restaurant Name [{top.RestaurantName}] ");
//}
//BCCConsole.Write(BCCConsoleColor.DarkGreen,false, "----------------------------------------------------");
#endregion
#region Using CV
//var cvMetrics = mlContext.Recommendation()
// .CrossValidate(trainingDataView, trainerPipeLine, labelColumnName: "TotalRating");
//var averageRMSE = cvMetrics.Average(cv => cv.Metrics.RootMeanSquaredError);
//var averageRSquared = cvMetrics.Average(cv => cv.Metrics.RSquared);
//BCCConsole.Write(BCCConsoleColor.DarkGreen, false,
// "\n",
// "Training Result Before Cross Validation (Metrics) ",
// "--------------------------------------------------",
// $"RMSE => Root Error : {averageRMSE:#.000}",
// $"RSQ => RSquared : {averageRSquared:#.000}",
// "--------------------------------------------------");
#endregion
Console.WriteLine("Enter Restaurant Name");
string rn = Console.ReadLine();
if (string.IsNullOrEmpty(rn))
{
"Error".Red();
Environment.Exit(-1);
}
var prediction = predictionEngine.Predict(new ModelInput()
{
UserId = "CLONED",
RestaurantName = rn
});
BCCConsole.Write(BCCConsoleColor.Green, false, "\n", $"Prediction Result Score : {prediction.Score:#.0} For Rincon Huasteco");
//HyperParameterExploration(mlContext, dataPreProcessingPipeLine, trainingDataView);
}
