private static ICommandLineComponentFactory ParseScorerSettings(string settings)
{
return(CmdParser.CreateComponentFactory(
typeof(IComponentFactory <IDataView, ISchemaBoundMapper, RoleMappedSchema, IDataScorerTransform>),
typeof(SignatureDataScorer),
settings));
}
private static IDataView MakeScorer(IHostEnvironment env, ISchema schema, string featureColumn, TModel model, BinaryClassifierScorer.Arguments args)
{
var settings = $"Binary{{{CmdParser.GetSettings(env, args, new BinaryClassifierScorer.Arguments())}}}";
var scorerFactorySettings = CmdParser.CreateComponentFactory(
typeof(IComponentFactory <IDataView, ISchemaBoundMapper, RoleMappedSchema, IDataScorerTransform>),
typeof(SignatureDataScorer),
settings);
var bindable = ScoreUtils.GetSchemaBindableMapper(env, model, scorerFactorySettings: scorerFactorySettings);
var edv = new EmptyDataView(env, schema);
var data = new RoleMappedData(edv, "Label", featureColumn, opt: true);
return(new BinaryClassifierScorer(env, args, data.Data, bindable.Bind(env, data.Schema), data.Schema));
}
private static TRes CreateCore <TRes>(
IHostEnvironment env,
Type factoryType,
Type signatureType,
string settings,
out string loadName,
params object[] extraArgs)
where TRes : class
{
Contracts.AssertValue(env);
env.AssertValue(factoryType);
env.AssertValue(signatureType);
env.AssertValue(settings, "settings");
var factory = CmdParser.CreateComponentFactory(factoryType, signatureType, settings);
loadName = factory.Name;
return(ComponentCatalog.CreateInstance <TRes>(env, factory.SignatureType, factory.Name, factory.GetSettingsString(), extraArgs));
}
public void NewTest()
{
var ml = new MLContext();
ml.AddStandardComponents();
var classes = Utils.MarshalInvoke(ml.ComponentCatalog.FindLoadableClasses <int>, typeof(SignatureCalibrator));
foreach (var cls in classes)
{
var factory = CmdParser.CreateComponentFactory(typeof(IComponentFactory <ICalibratorTrainer>), typeof(SignatureCalibrator), cls.LoadNames[0]);
var calibrator = ((IComponentFactory <ICalibratorTrainer>)factory).CreateComponent(ml);
}
var components = ml.ComponentCatalog.GetAllComponents(typeof(ICalibratorTrainerFactory));
foreach (var component in components)
{
var factory = CmdParser.CreateComponentFactory(typeof(IComponentFactory <ICalibratorTrainer>), typeof(SignatureCalibrator), component.Aliases[0]);
var calibrator = ((IComponentFactory <ICalibratorTrainer>)factory).CreateComponent(ml);
}
}
/// <summary>
/// Creates a data scorer from the 'LoadName{settings}' string.
/// </summary>
/// <param name="env">The host environment to use.</param>
/// <param name="settings">The settings string.</param>
/// <param name="data">The data to score.</param>
/// <param name="predictor">The predictor to score.</param>
/// <param name="trainSchema">The training data schema from which the scorer can optionally extract
/// additional information, for example, label names. If this is <c>null</c>, no information will be
/// extracted.</param>
/// <returns>The scored data.</returns>
internal static IDataScorerTransform CreateScorer(this IHostEnvironment env, string settings,
RoleMappedData data, IPredictor predictor, RoleMappedSchema trainSchema = null)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(data, nameof(data));
env.CheckValue(predictor, nameof(predictor));
env.CheckValueOrNull(trainSchema);
Type factoryType = typeof(IComponentFactory <IDataView, ISchemaBoundMapper, RoleMappedSchema, IDataScorerTransform>);
Type signatureType = typeof(SignatureDataScorer);
ICommandLineComponentFactory scorerFactorySettings = CmdParser.CreateComponentFactory(
factoryType,
signatureType,
settings);
var bindable = ScoreUtils.GetSchemaBindableMapper(env, predictor, scorerFactorySettings: scorerFactorySettings);
var mapper = bindable.Bind(env, data.Schema);
return(CreateCore <IDataScorerTransform>(env, factoryType, signatureType, settings, data.Data, mapper, trainSchema));
}
