/// <summary>
/// Save this transform model.
/// </summary>
internal override void Save(IHostEnvironment env, Stream stream)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(stream, nameof(stream));
using (var ch = env.Start("Saving transform model"))
{
using (var rep = RepositoryWriter.CreateNew(stream, ch))
{
ch.Trace("Saving root schema and transformations");
TrainUtils.SaveDataPipe(env, rep, _chain, blankLoader: true);
rep.Commit();
}
}
}
/// <summary>
/// Save a <see cref="ICanForecast{T}"/> model to a file specified by <paramref name="filePath"/>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="catalog"><see cref="ModelOperationsCatalog"/></param>
/// <param name="model"><see cref="ICanForecast{T}"/> model to save.</param>
/// <param name="filePath">File path to save the model to.</param>
public static void SaveForecastingModel <T>(this ModelOperationsCatalog catalog, ICanForecast <T> model, string filePath)
{
var env = CatalogUtils.GetEnvironment(catalog);
using (var file = File.Create(filePath))
{
using (var ch = env.Start("Saving forecasting model."))
{
using (var rep = RepositoryWriter.CreateNew(file, ch))
{
ModelSaveContext.SaveModel(rep, model, LoaderSignature);
rep.Commit();
}
}
}
}
/// <summary>
/// Save the model to the stream.
/// The method saves the loader and the transformations of dataPipe and saves optionally predictor
/// and command. It also uses featureColumn, if provided, to extract feature names.
/// </summary>
/// <param name="env">The host environment to use.</param>
/// <param name="ch">The communication channel to use.</param>
/// <param name="outputStream">The output model stream.</param>
/// <param name="predictor">The predictor.</param>
/// <param name="data">The training examples.</param>
/// <param name="command">The command string.</param>
public static void SaveModel(IHostEnvironment env, IChannel ch, Stream outputStream, IPredictor predictor, RoleMappedData data, string command = null)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(ch, nameof(ch));
ch.CheckValue(outputStream, nameof(outputStream));
ch.CheckValueOrNull(predictor);
ch.CheckValue(data, nameof(data));
ch.CheckValueOrNull(command);
using (var ch2 = env.Start("SaveModel"))
using (var pch = env.StartProgressChannel("Saving model"))
{
using (var rep = RepositoryWriter.CreateNew(outputStream, ch2))
{
if (predictor != null)
{
ch2.Trace("Saving predictor");
ModelSaveContext.SaveModel(rep, predictor, ModelFileUtils.DirPredictor);
}
ch2.Trace("Saving loader and transformations");
var dataPipe = data.Data;
if (dataPipe is IDataLoader)
{
ModelSaveContext.SaveModel(rep, dataPipe, ModelFileUtils.DirDataLoaderModel);
}
else
{
SaveDataPipe(env, rep, dataPipe);
}
// REVIEW: Handle statistics.
// ModelSaveContext.SaveModel(rep, dataStats, DirDataStats);
if (!string.IsNullOrWhiteSpace(command))
{
using (var ent = rep.CreateEntry(ModelFileUtils.DirTrainingInfo, "Command.txt"))
using (var writer = Utils.OpenWriter(ent.Stream))
writer.WriteLine(command);
}
ModelFileUtils.SaveRoleMappings(env, ch, data.Schema, rep);
rep.Commit();
}
ch2.Done();
}
}
private void AddNewPortfolio(object parameter)
{
Portfolio NewPortfolio = new Portfolio();
NewPortfolioViewModel NPVM = new NewPortfolioViewModel();
NewPortfolioWindow NPW = new NewPortfolioWindow();
NPW.DataContext = NPVM;
NPW.ShowDialog();
if (NPW.DialogResult.HasValue && NPW.DialogResult.Value)
{
NewPortfolio.PortfolioName = NPW.PortfolioNameTextBox.Text;
}
NewPortfolio.BenchmarkInstrument = NPW.BenchmarkInstrumentTextBox.Text;
NewPortfolio.InceptionDate = DateTime.Today;
Portfolios.Add(NewPortfolio);
RepositoryWriter.WritePortfolio(NewPortfolio.PortfolioName, NewPortfolio.BenchmarkInstrument, NewPortfolio.InceptionDate);
}
/// <summary>
/// Save the contents to a stream, as a "model file".
/// </summary>
public void SaveTo(IHostEnvironment env, Stream outputStream)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(outputStream, nameof(outputStream));
env.Check(outputStream.CanWrite && outputStream.CanSeek, "Need a writable and seekable stream to save");
using (var ch = env.Start("Saving pipeline"))
{
using (var rep = RepositoryWriter.CreateNew(outputStream, ch))
{
ch.Trace("Saving data reader");
ModelSaveContext.SaveModel(rep, Reader, "Reader");
ch.Trace("Saving transformer chain");
ModelSaveContext.SaveModel(rep, Transformer, TransformerChain.LoaderSignature);
rep.Commit();
}
}
}
public LoaderWrapper(IHostEnvironment env, ModelLoadContext ctx)
{
ctx.CheckAtModel(GetVersionInfo());
ctx.LoadModel <IDataLoader, SignatureLoadDataLoader>(env, out var loader, "Loader", new MultiFileSource(null));
var loaderStream = new MemoryStream();
using (var rep = RepositoryWriter.CreateNew(loaderStream))
{
ModelSaveContext.SaveModel(rep, loader, "Loader");
rep.Commit();
}
_env = env;
_loaderFactory = (IMultiStreamSource source) =>
{
using (var rep = RepositoryReader.Open(loaderStream))
{
ModelLoadContext.LoadModel <IDataLoader, SignatureLoadDataLoader>(env, out var ldr, rep, "Loader", source);
return(ldr);
}
};
}
public void SetUp()
{
mocker = new AutoMoqer();
classUnderTest = mocker.Create <RepositoryWriter>();
}
private void DeletePortfolio(object obj)
{
RepositoryWriter.RemovePortfolio(SelectedPortfolio);
Portfolios.Remove(SelectedPortfolio);
}
