/// <summary>Find the the parameters resulting in the minimal results for a given evaluation measure (2D)</summary>
/// <remarks>The recommender will be set to the best parameter value after calling this method.</remarks>
/// <param name="evaluation_measure">the name of the evaluation measure</param>
/// <param name="hp_name1">the name of the first hyperparameter to optimize</param>
/// <param name="hp_values1">the values of the first hyperparameter to try out</param>
/// <param name="hp_name2">the name of the second hyperparameter to optimize</param>
/// <param name="hp_values2">the values of the second hyperparameter to try out</param>
/// <param name="recommender">the recommender</param>
/// <param name="split">the dataset split to use</param>
/// <returns>the best (lowest) average value for the hyperparameter</returns>
public static double FindMinimum(string evaluation_measure,
string hp_name1, string hp_name2,
double[] hp_values1, double[] hp_values2,
RatingPredictor recommender,
ISplit <IRatings> split)
{
double min_result = double.MaxValue;
int min_i = -1;
int min_j = -1;
for (int i = 0; i < hp_values1.Length; i++)
{
for (int j = 0; j < hp_values2.Length; j++)
{
Recommender.SetProperty(recommender, hp_name1, hp_values1[i].ToString(CultureInfo.InvariantCulture));
Recommender.SetProperty(recommender, hp_name2, hp_values2[j].ToString(CultureInfo.InvariantCulture));
Console.Error.WriteLine("reg_u={0} reg_i={1}", hp_values1[i].ToString(CultureInfo.InvariantCulture), hp_values2[j].ToString(CultureInfo.InvariantCulture)); // TODO this is not generic
double result = Eval.Ratings.EvaluateOnSplit(recommender, split)[evaluation_measure];
if (result < min_result)
{
min_i = i;
min_j = j;
min_result = result;
}
}
}
// set to best hyperparameter values
Recommender.SetProperty(recommender, hp_name1, hp_values1[min_i].ToString(CultureInfo.InvariantCulture));
Recommender.SetProperty(recommender, hp_name2, hp_values2[min_j].ToString(CultureInfo.InvariantCulture));
return(min_result);
}
/// <summary>Find the the parameters resulting in the minimal results for a given evaluation measure (1D)</summary>
/// <remarks>The recommender will be set to the best parameter value after calling this method.</remarks>
/// <param name="evaluation_measure">the name of the evaluation measure</param>
/// <param name="hyperparameter_name">the name of the hyperparameter to optimize</param>
/// <param name="hyperparameter_values">the values of the hyperparameter to try out</param>
/// <param name="recommender">the recommender</param>
/// <param name="split">the dataset split to use</param>
/// <returns>the best (lowest) average value for the hyperparameter</returns>
public static double FindMinimum(string evaluation_measure,
string hyperparameter_name,
double[] hyperparameter_values,
RatingPredictor recommender,
ISplit <IRatings> split)
{
double min_result = double.MaxValue;
int min_i = -1;
for (int i = 0; i < hyperparameter_values.Length; i++)
{
Recommender.SetProperty(recommender, hyperparameter_name, hyperparameter_values[i].ToString(CultureInfo.InvariantCulture));
double result = Eval.Ratings.EvaluateOnSplit(recommender, split)[evaluation_measure];
if (result < min_result)
{
min_i = i;
min_result = result;
}
}
Recommender.SetProperty(recommender, hyperparameter_name, hyperparameter_values[min_i].ToString(CultureInfo.InvariantCulture));
return(min_result);
}
static double Run(RatingPredictor recommender, ISplit <IRatings> split, string hp_string, string evaluation_measure)
{
Recommender.Configure(recommender, hp_string);
double result = Eval.Ratings.EvaluateOnSplit(recommender, split)[evaluation_measure];
Console.Error.WriteLine("Nelder-Mead: {0}: {1}", hp_string, result.ToString(CultureInfo.InvariantCulture));
return(result);
}
/// <summary>List all recommenders in a given namespace</summary>
/// <param name="prefix">a string representing the namespace</param>
/// <returns>an array of strings containing the recommender descriptions</returns>
public static string[] List(string prefix)
{
var result = new List <string>();
foreach (Type type in Utils.GetTypesInNamespace(prefix))
{
if (!type.IsAbstract && !type.IsInterface && !type.IsEnum && !type.IsGenericType && type.GetInterface("IRecommender") != null)
{
IRecommender recommender = prefix.Equals("MyMediaLite.RatingPrediction") ? (IRecommender)Recommender.CreateRatingPredictor(type) : (IRecommender)Recommender.CreateItemRecommender(type);
string description = recommender.ToString();
string needs = Recommender.Needs(recommender);
if (needs.Length > 0)
{
description += " (needs " + needs + ")";
}
result.Add(description);
}
}
return(result.ToArray());
}
/// <summary>Find the the parameters resulting in the minimal results for a given evaluation measure</summary>
/// <remarks>The recommender will be set to the best parameter value after calling this method.</remarks>
/// <param name="evaluation_measure">the name of the evaluation measure</param>
/// <param name="hp_names">the names of the hyperparameters to optimize</param>
/// <param name="initial_hp_values">the values of the hyperparameters to try out first</param>
/// <param name="recommender">the recommender</param>
/// <param name="split">the dataset split to use</param>
/// <returns>the best (lowest) average value for the hyperparameter</returns>
public static double FindMinimum(string evaluation_measure,
IList <string> hp_names,
IList <Vector> initial_hp_values,
RatingPredictor recommender, // TODO make more general?
ISplit <IRatings> split)
{
var results = new Dictionary <string, double>();
var hp_vectors = new Dictionary <string, Vector>();
// initialize
foreach (var hp_values in initial_hp_values)
{
string hp_string = CreateConfigString(hp_names, hp_values);
results[hp_string] = Run(recommender, split, hp_string, evaluation_measure);
hp_vectors[hp_string] = hp_values;
}
List <string> keys;
for (int i = 0; i < num_it; i++)
{
if (results.Count != hp_vectors.Count)
{
throw new Exception(string.Format("{0} vs. {1}", results.Count, hp_vectors.Count));
}
keys = new List <string>(results.Keys);
keys.Sort(delegate(string k1, string k2) { return(results[k1].CompareTo(results[k2])); });
var min_key = keys.First();
var max_key = keys.Last();
Console.Error.WriteLine("Nelder-Mead: iteration {0} ({1})", i, results[min_key]);
var worst_vector = hp_vectors[max_key];
var worst_result = results[max_key];
hp_vectors.Remove(max_key);
results.Remove(max_key);
// compute center
var center = ComputeCenter(results, hp_vectors);
// reflection
//Console.Error.WriteLine("ref");
var reflection = center + alpha * (center - worst_vector);
string ref_string = CreateConfigString(hp_names, reflection);
double ref_result = Run(recommender, split, ref_string, evaluation_measure);
if (results[min_key] <= ref_result && ref_result < results.Values.Max())
{
results[ref_string] = ref_result;
hp_vectors[ref_string] = reflection;
continue;
}
// expansion
if (ref_result < results[min_key])
{
//Console.Error.WriteLine("exp");
var expansion = center + gamma * (center - worst_vector);
string exp_string = CreateConfigString(hp_names, expansion);
double exp_result = Run(recommender, split, exp_string, evaluation_measure);
if (exp_result < ref_result)
{
results[exp_string] = exp_result;
hp_vectors[exp_string] = expansion;
}
else
{
results[ref_string] = ref_result;
hp_vectors[ref_string] = reflection;
}
continue;
}
// contraction
//Console.Error.WriteLine("con");
var contraction = worst_vector + rho * (center - worst_vector);
string con_string = CreateConfigString(hp_names, contraction);
double con_result = Run(recommender, split, con_string, evaluation_measure);
if (con_result < worst_result)
{
results[con_string] = con_result;
hp_vectors[con_string] = contraction;
continue;
}
// reduction
//Console.Error.WriteLine("red");
var best_vector = hp_vectors[min_key];
var best_result = results[min_key];
hp_vectors.Remove(min_key);
results.Remove(min_key);
foreach (var key in new List <string>(results.Keys))
{
var reduction = hp_vectors[key] + sigma * (hp_vectors[key] - best_vector);
string red_string = CreateConfigString(hp_names, reduction);
double red_result = Run(recommender, split, red_string, evaluation_measure);
// replace by reduced vector
results.Remove(key);
hp_vectors.Remove(key);
results[red_string] = red_result;
hp_vectors[red_string] = reduction;
}
results[min_key] = best_result;
hp_vectors[min_key] = best_vector;
results[max_key] = worst_result;
hp_vectors[max_key] = worst_vector;
}
keys = new List <string>(results.Keys);
keys.Sort(delegate(string k1, string k2) { return(results[k1].CompareTo(results[k2])); });
// set to best hyperparameter values
Recommender.Configure(recommender, keys.First());
return(results[keys.First()]);
}
