public SaveOnnxCommand(IHostEnvironment env, Arguments args)
: base(env, args, LoadName)
{
Host.CheckValue(args, nameof(args));
Host.CheckNonWhiteSpace(args.Onnx, nameof(args.Onnx));
Utils.CheckOptionalUserDirectory(args.Onnx, nameof(args.Onnx));
_outputModelPath = args.Onnx;
_outputJsonModelPath = string.IsNullOrWhiteSpace(args.Json) ? null : args.Json;
if (args.Name == null)
{
_name = Path.GetFileNameWithoutExtension(_outputModelPath);
}
else
{
Host.CheckNonWhiteSpace(args.Name, nameof(args.Name));
_name = args.Name;
}
_loadPredictor = args.LoadPredictor;
_inputsToDrop = CreateDropMap(args.InputsToDropArray ?? args.InputsToDrop?.Split(','));
_outputsToDrop = CreateDropMap(args.OutputsToDropArray ?? args.OutputsToDrop?.Split(','));
_domain = args.Domain;
_model = args.Model;
}
public static void WriteKcHousePriceModel(string dataPath, Stream stream)
{
if (s_housePriceModel == null)
{
s_housePriceModel = CreateKcHousePricePredictorModel(dataPath);
}
s_housePriceModel.Save(s_environment, stream);
}
public IPredictorModel Apply(IHostEnvironment env, ITransformModel transformModel)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(transformModel, nameof(transformModel));
ITransformModel newTransformModel = _transformModel.Apply(env, transformModel);
Contracts.AssertValue(newTransformModel);
return(new PredictorModel(newTransformModel, _predictor, _roleMappings));
}
private PredictorModel(ITransformModel transformModel, IPredictor predictor, KeyValuePair <RoleMappedSchema.ColumnRole, string>[] roleMappings)
{
Contracts.AssertValue(transformModel);
Contracts.AssertValue(predictor);
Contracts.AssertValue(roleMappings);
_transformModel = transformModel;
_predictor = predictor;
_roleMappings = roleMappings;
}
public PredictorModel(IHostEnvironment env, RoleMappedData trainingData, IDataView startingData, IPredictor predictor)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(trainingData, nameof(trainingData));
env.CheckValue(predictor, nameof(predictor));
_transformModel = new TransformModel(env, trainingData.Data, startingData);
_roleMappings = trainingData.Schema.GetColumnRoleNames().ToArray();
_predictor = predictor;
}
public PredictorModel(IHostEnvironment env, Stream stream)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(stream, nameof(stream));
using (var ch = env.Start("Loading predictor model"))
{
// REVIEW: address the asymmetry in the way we're loading and saving the model.
_transformModel = new TransformModel(env, stream);
var roles = ModelFileUtils.LoadRoleMappingsOrNull(env, stream);
env.CheckDecode(roles != null, "Predictor model must contain role mappings");
_roleMappings = roles.ToArray();
_predictor = ModelFileUtils.LoadPredictorOrNull(env, stream);
env.CheckDecode(_predictor != null, "Predictor model must contain a predictor");
}
}
public static CombineTransformModelsOutput CombineTransformModels(IHostEnvironment env, CombineTransformModelsInput input)
{
Contracts.CheckValue(env, nameof(env));
var host = env.Register("CombineTransformModels");
host.CheckValue(input, nameof(input));
EntryPointUtils.CheckInputArgs(host, input);
host.CheckNonEmpty(input.Models, nameof(input.Models));
ITransformModel model = input.Models[input.Models.Length - 1];
for (int i = input.Models.Length - 2; i >= 0; i--)
{
model = model.Apply(env, input.Models[i]);
}
return(new CombineTransformModelsOutput {
OutputModel = model
});
}
/// <summary>
/// Apply this transform model to the given input transform model to produce a composite transform model.
/// </summary>
public ITransformModel Apply(IHostEnvironment env, ITransformModel input)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(input, nameof(input));
IDataView view;
Schema schemaRoot = input.InputSchema;
var mod = input as TransformModel;
if (mod != null)
{
view = ApplyTransformUtils.ApplyAllTransformsToData(env, _chain, mod._chain);
}
else
{
view = new EmptyDataView(env, schemaRoot);
view = input.Apply(env, view);
view = Apply(env, view);
}
return(new TransformModel(env, schemaRoot, view));
}
public SkeletalTransform(ITransformModel transform)
{
this.myTransform = transform;
}
public ISkeletalTransform CreateProduct(ITransformModel rootModel)
{
return new SkeletalTransform(rootModel);
}
