public double GetPhysicalMetricValue(IList <double> sequence, EMetric metric, double coefficient)
{
double metricValue;
switch (metric)
{
case EMetric.CpuFpsPerWatt:
if (coefficient > 0)
{
metricValue = ((sequence.Count * 1000 / sequence.Sum()) / coefficient) * 10;
}
else
{
metricValue = 0;
}
break;
case EMetric.GpuFpsPerWatt:
if (coefficient > 0)
{
metricValue = ((sequence.Count * 1000 / sequence.Sum()) / coefficient) * 10;
}
else
{
metricValue = 0;
}
break;
default:
metricValue = 0;
break;
}
return(Math.Round(metricValue, 2));
}
public double GetPhysicalMetricValue(IList <double> sequence, EMetric metric, double coefficient)
{
double metricValue;
switch (metric)
{
case EMetric.CpuFpsPerWatt:
if (coefficient > 0)
{
metricValue = (sequence.Count * 1000 / sequence.Sum()) / coefficient;
}
else
{
metricValue = 0;
}
break;
//case EMetric.GpuFpsPerWatt:
//if (coefficient > 0)
// metricValue = (sequence.Count * 1000 / sequence.Sum()) / coefficient;
//else
// metricValue = double.NaN;
//break;
default:
metricValue = 0;
break;
}
return(Math.Round(metricValue, _options.FpsValuesRoundingDigits));
}
public double GetOnlineFpsMetricValue(EMetric metric)
{
lock (_lock)
{
return(_frametimeStatisticProvider
.GetFpsMetricValue(_frametimes, metric));
}
}
public static TrustMatrixBuilder GetMatrixBuilder(EMetric metric, Matrix <float> trustMatrix, int topN)
{
TrustMatrixBuilder matrixBuilder = null;
switch (metric)
{
case EMetric.LinearTrustPropagation:
matrixBuilder = new LinearTrustPropagation(trustMatrix);
break;
case EMetric.ResourceAllocation:
matrixBuilder = new ResourceAllocation(trustMatrix, topN);
break;
}
return(matrixBuilder);
}
private static string GetMatrixFile(EMetric metric, int propagationDistance, int topN)
{
string matrixFile = string.Empty;
switch (metric)
{
case EMetric.LinearTrustPropagation:
matrixFile = String.Format(Resources.linear_trust_matrix, propagationDistance);
break;
case EMetric.ResourceAllocation:
matrixFile = String.Format(Resources.resource_allocation, propagationDistance, topN);
break;
}
return(matrixFile);
}
/// <summary>
/// Calculate FPS metric values.
/// frametimes.
/// </summary>
/// <param name="sequence"></param>
/// <param name="metric"></param>
/// <returns>metric value</returns>
public double GetFpsMetricValue(IList <double> sequence, EMetric metric)
{
double metricValue;
IList <double> fps;
switch (metric)
{
case EMetric.Max:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = fps.Max();
break;
case EMetric.P99:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetPQuantileSequence(fps, 0.99);
break;
case EMetric.P95:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetPQuantileSequence(fps, 0.95);
break;
case EMetric.Average:
metricValue = sequence.Count * 1000 / sequence.Sum();
break;
case EMetric.Median:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetPQuantileSequence(fps, 0.5);
break;
case EMetric.P5:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetPQuantileSequence(fps, 0.05);
break;
case EMetric.P1:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetPQuantileSequence(fps, 0.01);
break;
case EMetric.P0dot2:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetPQuantileSequence(fps, 0.002);
break;
case EMetric.P0dot1:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetPQuantileSequence(fps, 0.001);
break;
case EMetric.OnePercentLow:
metricValue = 1000 / GetPAverageHighSequence(sequence, 1 - 0.01);
break;
case EMetric.ZerodotOnePercentLow:
metricValue = 1000 / GetPAverageHighSequence(sequence, 1 - 0.001);
break;
case EMetric.Min:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = fps.Min();
break;
case EMetric.AdaptiveStd:
fps = sequence.Select(ft => 1000 / ft).ToList();
metricValue = GetAdaptiveStandardDeviation(fps, _options.MovingAverageWindowSize);
break;
default:
metricValue = double.NaN;
break;
}
return(Math.Round(metricValue, _options.FpsValuesRoundingDigits));
}
private static Matrix <float> GetEstimatedTrustMatrix(Matrix <float> originalTrustMatrix, EMetric metric, int propagationDistance, int topN)
{
Matrix <float> estimatedTrustMatrix;
string matrixFile = GetMatrixFile(metric, propagationDistance, topN);
if (File.Exists(matrixFile))
{
estimatedTrustMatrix = new Matrix <float>(matrixFile);
}
else
{
estimatedTrustMatrix = TrustMatrixBuilderFactory.GetMatrixBuilder(metric, originalTrustMatrix, topN).BuildMatrix(propagationDistance);
estimatedTrustMatrix.WriteToFile(matrixFile);
}
return(estimatedTrustMatrix);
}
static void Main(string[] args)
{
//while (true)
//{
//Console.WriteLine("Choose your trust propagation metric");
//Console.WriteLine("1 - Linear Trust Propagation");
//Console.WriteLine("2 - Resource Allocation");
//int metricInput = Convert.ToInt32(Console.ReadLine());
//Console.WriteLine("Choose the propagation distance");
//int propagationDistance = Convert.ToInt32(Console.ReadLine());
//Console.WriteLine("Choose top N for trust propagation");
//int topN = Convert.ToInt32(Console.ReadLine());
//Console.WriteLine("Choose top K ecommendations");
//int topK = Convert.ToInt32(Console.ReadLine());
//EMetric metric = (EMetric)metricInput;
//Console.WriteLine("New Execution!");
//Console.WriteLine($"Metric: {metric.ToString()}");
//Console.WriteLine($"TopN: { topN }");
//Console.WriteLine($"TopK: {topK}");
//Console.WriteLine($"Propagation Distance: {propagationDistance}");
//Matrix<float> originalTrustMatrix = new Matrix<float>(Resources.trust_data_file);
//Console.WriteLine("Building estimated trust matrix...");
//Matrix<float> estimatedTrustMatrix = GetEstimatedTrustMatrix(originalTrustMatrix, metric, propagationDistance, topN);
//Console.WriteLine("Estimated trust matrix built");
//Matrix<int> ratingsMatrix = new Matrix<int>(Resources.rating_data_file);
//Matrix<int> maxRatings = GetMaxRatings(ratingsMatrix);
//maxRatings.WriteToFile("maxRatings");
//RatingPredictor ratingPredictor = new RatingPredictor();
//Dictionary<int, double> usersAverageRatings = GetUsersAverageRatings(ratingsMatrix, ratingPredictor);
//ratingPredictor.setUsersAverageRatings(usersAverageRatings);
//Stopwatch timer = new Stopwatch();
//timer.Start();
//Console.WriteLine("Running top k recommendation experiment...");
//TopKRecommendation evaluator = new TopKRecommendation(topK);
//evaluator.Evaluate(ratingsMatrix, estimatedTrustMatrix, maxRatings, ratingPredictor);
//timer.Stop();
//Console.WriteLine(timer.Elapsed);
//Console.WriteLine();
//Console.WriteLine($"Recall: {evaluator.Recall}");
//Console.WriteLine($"Precision: {evaluator.Precision}");
//Console.WriteLine();
for (int propagationDistance = 3; propagationDistance <= 3; propagationDistance++)
{
for (int metricInput = 2; metricInput <= 2; metricInput++)
{
for (int n = 1; n < topNValues.Length; n++)
{
for (int k = 0; k < topKValues.Length; k++)
{
int topN = topNValues[n];
int topK = topKValues[k];
//topN = 20;
//topK = 20;
//propagationDistance = 2;
//metricInput = 2;
EMetric metric = (EMetric)metricInput;
Console.WriteLine("New Execution!");
Console.WriteLine($"Metric: {metric.ToString()}");
Console.WriteLine($"TopN: { topN }");
Console.WriteLine($"TopK: {topK}");
Console.WriteLine($"Propagation Distance: {propagationDistance}");
Matrix <float> originalTrustMatrix = new Matrix <float>(Resources.trust_data_file);
Console.WriteLine("Building estimated trust matrix...");
Matrix <float> estimatedTrustMatrix = GetEstimatedTrustMatrix(originalTrustMatrix, metric, propagationDistance, topN);
Console.WriteLine("Estimated trust matrix built");
Matrix <int> originalRatingsMatrix = new Matrix <int>(Resources.rating_data_file);
Matrix <int> ratingsMatrix = new Matrix <int>(Resources.rating_data_file);
Matrix <int> maxRatings = GetMaxRatings(ratingsMatrix, estimatedTrustMatrix);
maxRatings.WriteToFile("maxRatings");
RatingPredictor ratingPredictor = new RatingPredictor();
Dictionary <int, double> usersAverageRatings = GetUsersAverageRatings(ratingsMatrix, ratingPredictor);
ratingPredictor.setUsersAverageRatings(usersAverageRatings);
Stopwatch timer = new Stopwatch();
timer.Start();
Console.WriteLine("Running top k recommendation experiment...");
TopKRecommendation evaluator = new TopKRecommendation(topK);
evaluator.Evaluate(ratingsMatrix, estimatedTrustMatrix, maxRatings, ratingPredictor);
timer.Stop();
Console.WriteLine(timer.Elapsed);
Console.WriteLine();
Console.WriteLine($"Recall: {evaluator.Recall}");
Console.WriteLine($"Precision: {evaluator.Precision}");
Console.WriteLine($"Predicted Ratings: { evaluator.RatingsPredicted}");
Console.WriteLine($"Rated items predicted: { evaluator.ItemsPredicted }");
Console.WriteLine($"Coverage: {evaluator.Coverage}");
//Console.WriteLine($"Mean Average Error: {Experiment.MeanAverageError(originalRatingsMatrix, estimatedTrustMatrix, ratingPredictor)}");
Console.WriteLine();
using (StreamWriter writer = new StreamWriter(Resources.results, true))
{
writer.WriteLine("-------------------------------------");
writer.WriteLine($"Metric: {metric.ToString()}");
writer.WriteLine($"TopN: { topN }");
writer.WriteLine($"TopK: {topK}");
writer.WriteLine($"Propagation Distance: {propagationDistance}");
writer.WriteLine();
writer.WriteLine($"Recall: {evaluator.Recall}");
writer.WriteLine($"Precision: {evaluator.Precision}");
writer.WriteLine($"Predicted Ratings: { evaluator.RatingsPredicted}");
writer.WriteLine($"Rated items predicted: { evaluator.ItemsPredicted }");
writer.WriteLine($"Coverage: {evaluator.Coverage}");
writer.WriteLine($"Execution time: {timer.Elapsed}");
writer.WriteLine("----------------------------------------");
writer.WriteLine();
}
}
}
}
}
//}
}
