|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.ML.Internal.Utilities;
namespace Microsoft.ML.AutoML
{
/// <summary>
/// The main interface of the sweeper
/// </summary>
internal interface ISweeper
{
/// <summary>
/// Returns between 0 and maxSweeps configurations to run.
/// It expects a list of previous runs such that it can generate configurations that were not already tried.
/// The list of runs can be null if there were no previous runs.
/// Some smart sweepers can take advantage of the metric(s) that the caller computes for previous runs.
/// </summary>
ParameterSet[] ProposeSweeps(int maxSweeps, IEnumerable<IRunResult> previousRuns = null);
}
/// <summary>
/// This is the interface that each type of parameter sweep needs to implement
/// </summary>
internal interface IValueGenerator
{
/// <summary>
/// Given a value in the [0,1] range, return a value for this parameter.
/// </summary>
IParameterValue CreateFromNormalized(Double normalizedValue);
/// <summary>
/// Used mainly in grid sweepers, return the i-th distinct value for this parameter
/// </summary>
IParameterValue this[int i] { get; }
/// <summary>
/// Used mainly in grid sweepers, return the count of distinct values for this parameter
/// </summary>
int Count { get; }
/// <summary>
/// Returns the name of the generated parameter
/// </summary>
string Name { get; }
}
/// <summary>
/// Parameter value generated from the sweeping.
/// The parameter values must be immutable.
/// Value is converted to string because the runner will usually want to construct a command line for TL.
/// Implementations of this interface must also override object.GetHashCode() and object.Equals(object) so they are consistent
/// with IEquatable.Equals(IParameterValue).
/// </summary>
internal interface IParameterValue : IEquatable<IParameterValue>
{
string Name { get; }
string ValueText { get; }
}
/// <summary>
/// Type safe version of the IParameterValue interface.
/// </summary>
internal interface IParameterValue<out TValue> : IParameterValue
{
TValue Value { get; }
}
/// <summary>
/// A set of parameter values.
/// The parameter set must be immutable.
/// </summary>
internal sealed class ParameterSet : IEquatable<ParameterSet>, IEnumerable<IParameterValue>
{
private readonly Dictionary<string, IParameterValue> _parameterValues;
private readonly int _hash;
public ParameterSet(IEnumerable<IParameterValue> parameters)
{
_parameterValues = new Dictionary<string, IParameterValue>();
foreach (var parameter in parameters)
{
_parameterValues.Add(parameter.Name, parameter);
}
var parameterNames = _parameterValues.Keys.ToList();
parameterNames.Sort();
_hash = 0;
foreach (var parameterName in parameterNames)
{
_hash = Hashing.CombineHash(_hash, _parameterValues[parameterName].GetHashCode());
}
}
public ParameterSet(Dictionary<string, IParameterValue> paramValues, int hash)
{
_parameterValues = paramValues;
_hash = hash;
}
public IEnumerator<IParameterValue> GetEnumerator()
{
return _parameterValues.Values.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public int Count
{
get { return _parameterValues.Count; }
}
public IParameterValue this[string name]
{
get { return _parameterValues[name]; }
}
private bool ContainsParamValue(IParameterValue parameterValue)
{
IParameterValue value;
return _parameterValues.TryGetValue(parameterValue.Name, out value) &&
parameterValue.Equals(value);
}
public bool Equals(ParameterSet other)
{
if (other == null || other._hash != _hash || other._parameterValues.Count != _parameterValues.Count)
return false;
return other._parameterValues.Values.All(pv => ContainsParamValue(pv));
}
public ParameterSet Clone() =>
new ParameterSet(new Dictionary<string, IParameterValue>(_parameterValues), _hash);
public override string ToString()
{
return string.Join(" ", _parameterValues.Select(kvp => string.Format("{0}={1}", kvp.Value.Name, kvp.Value.ValueText)).ToArray());
}
public override int GetHashCode()
{
return _hash;
}
}
/// <summary>
/// The result of a run.
/// Contains the parameter set used, useful for the sweeper to not generate the same configuration multiple times.
/// Also contains the result of a run and the metric value that is used by smart sweepers to generate new configurations
/// that try to maximize this metric.
/// </summary>
internal interface IRunResult : IComparable<IRunResult>
{
ParameterSet ParameterSet { get; }
IComparable MetricValue { get; }
bool IsMetricMaximizing { get; }
}
internal interface IRunResult<T> : IRunResult
where T : IComparable<T>
{
new T MetricValue { get; }
}
/// <summary>
/// Simple implementation of IRunResult
/// </summary>
internal sealed class RunResult : IRunResult<Double>
{
private readonly ParameterSet _parameterSet;
private readonly Double? _metricValue;
private readonly bool _isMetricMaximizing;
/// <summary>
/// This switch changes the behavior of the CompareTo function, switching the greater than / less than
/// behavior, depending on if it is set to True.
/// </summary>
public bool IsMetricMaximizing { get { return _isMetricMaximizing; } }
public ParameterSet ParameterSet
{
get { return _parameterSet; }
}
public RunResult(ParameterSet parameterSet, Double metricValue, bool isMetricMaximizing)
{
_parameterSet = parameterSet;
_metricValue = metricValue;
_isMetricMaximizing = isMetricMaximizing;
}
public Double MetricValue
{
get
{
return _metricValue.Value;
}
}
public int CompareTo(IRunResult other)
{
var otherTyped = other as RunResult;
//Contracts.Check(otherTyped != null);
if (_metricValue == otherTyped._metricValue)
return 0;
return _isMetricMaximizing ^ (_metricValue < otherTyped._metricValue) ? 1 : -1;
}
public bool HasMetricValue
{
get
{
return _metricValue != null;
}
}
IComparable IRunResult.MetricValue
{
get { return MetricValue; }
}
}
/// <summary>
/// The metric class, used by smart sweeping algorithms.
/// Ideally we would like to move towards a IDataView, this is
/// just a simple view instead, and it is decoupled from RunResult so we can move
/// in that direction in the future.
/// </summary>
internal sealed class RunMetric
{
private readonly float _primaryMetric;
private readonly float[] _metricDistribution;
public RunMetric(float primaryMetric, IEnumerable<float> metricDistribution = null)
{
_primaryMetric = primaryMetric;
if (metricDistribution != null)
_metricDistribution = metricDistribution.ToArray();
}
/// <summary>
/// The primary metric to optimize.
/// This metric is usually an aggregate value for the run, for example, AUC, accuracy etc.
/// By default, smart sweeping algorithms will maximize this metric.
/// If you want to minimize, either negate this value or change the option in the arguments of the sweeper constructor.
/// </summary>
public float PrimaryMetric
{
get { return _primaryMetric; }
}
/// <summary>
/// The (optional) distribution of the metric.
/// This distribution can be a secondary measure of how good a run was, e.g per-fold AUC, per-fold accuracy, (sampled) per-instance log loss etc.
/// </summary>
public float[] GetMetricDistribution()
{
if (_metricDistribution == null)
return null;
var result = new float[_metricDistribution.Length];
Array.Copy(_metricDistribution, result, _metricDistribution.Length);
return result;
}
}
}
|