private bool IsWithinBudget(ProjectComponent projectComponent, SubComponent subComponent)
{
//get the component budget
var componentBudget = projectComponent.Budget;
//get the total amount of money in each component
decimal totalsubcomponentBudget = 0;
//loop through all the subcomponents adding each components budget
foreach (var subcomponent in projectComponent.SubComponents)
{
totalsubcomponentBudget += subcomponent.Budget;
}
var newProposedTotal = totalsubcomponentBudget + subComponent.Budget;
if (newProposedTotal > componentBudget)
{
return(false);
}
else
{
return(true);
}
}
private static byte[] GetBytesOne(IHost host, string dataFile, SubComponent <IDataLoader, SignatureDataLoader> sub,
string termColumn, string valueColumn)
{
Contracts.AssertValue(host);
host.Assert(!string.IsNullOrWhiteSpace(dataFile));
host.AssertNonEmpty(termColumn);
host.AssertNonEmpty(valueColumn);
if (!sub.IsGood())
{
// REVIEW: Should there be defaults for loading from text?
var ext = Path.GetExtension(dataFile);
bool isBinary = string.Equals(ext, ".idv", StringComparison.OrdinalIgnoreCase);
bool isTranspose = string.Equals(ext, ".tdv", StringComparison.OrdinalIgnoreCase);
if (!isBinary && !isTranspose)
{
throw host.ExceptUserArg(nameof(Arguments.Loader), "must specify the loader");
}
host.Assert(isBinary != isTranspose); // One or the other must be true.
sub = new SubComponent <IDataLoader, SignatureDataLoader>(isBinary ? "BinaryLoader" : "TransposeLoader");
}
var ldr = sub.CreateInstance(host, new MultiFileSource(dataFile));
return(GetBytesFromDataView(host, ldr, termColumn, valueColumn));
}
/// <summary>
/// Given a predictor and an optional scorer SubComponent, produces a compatible ISchemaBindableMapper.
/// First, it tries to instantiate the bindable mapper using the <paramref name="scorerSettings"/>
/// (this will only succeed if there's a registered BindableMapper creation method with load name equal to the one
/// of the scorer).
/// If the above fails, it checks whether the predictor implements <see cref="ISchemaBindableMapper"/>
/// directly.
/// If this also isn't true, it will create a 'matching' standard mapper.
/// </summary>
public static ISchemaBindableMapper GetSchemaBindableMapper(IHostEnvironment env, IPredictor predictor,
SubComponent <IDataScorerTransform, SignatureDataScorer> scorerSettings)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(predictor, nameof(predictor));
env.CheckValueOrNull(scorerSettings);
// See if we can instantiate a mapper using scorer arguments.
if (scorerSettings.IsGood() && TryCreateBindableFromScorer(env, predictor, scorerSettings, out var bindable))
{
return(bindable);
}
// The easy case is that the predictor implements the interface.
bindable = predictor as ISchemaBindableMapper;
if (bindable != null)
{
return(bindable);
}
// Use one of the standard wrappers.
if (predictor is IValueMapperDist)
{
return(new SchemaBindableBinaryPredictorWrapper(predictor));
}
return(new SchemaBindablePredictorWrapper(predictor));
}
public void AddSubComponent()
{
var enc = new HL7Encoding();
Segment PID = new Segment("PID", enc);
Field f = new Field(enc);
Component c = new Component(enc);
c.IsSubComponentized = true;
SubComponent sc1 = new SubComponent("A", enc);
SubComponent sc2 = new SubComponent("B", enc);
c.AddSubComponent(sc1);
c.AddSubComponent(sc2);
f.AddNewComponent(c);
// Creates a new Field
PID.AddNewField(f, 1);
Message message = new Message();
message.AddNewSegment(PID);
var str = message.SerializeMessage(false);
Assert.AreEqual("PID|A&B\r", str);
}
public void Dispose_NullSite_Success()
{
var component = new SubComponent();
component.Dispose();
component.Dispose();
}
/// <summary>
/// Create a trainer.
/// </summary>
/// <param name="env">host</param>
/// <param name="settings">trainer description as a string such <pre>ova{p=lr}</pre></param>
/// <param name="extraArgs">additional arguments</param>
public static ITrainerExtended CreateTrainer(IHostEnvironment env, string settings, params object[] extraArgs)
{
var sc = SubComponent.Parse <ITrainer, SignatureTrainer>(settings);
var inst = sc.CreateInstance(env, extraArgs);
return(new ExtendedTrainer(inst, sc.Kind));
}
// This saves the lookup data as a byte array encoded as a binary .idv file.
private static byte[] GetBytes(IHost host, ColInfo[] infos, Arguments args)
{
Contracts.AssertValue(host);
host.AssertNonEmpty(infos);
host.AssertValue(args);
string dataFile = args.DataFile;
SubComponent <IDataLoader, SignatureDataLoader> loader = args.Loader;
string termColumn;
string valueColumn;
if (!string.IsNullOrEmpty(args.TermColumn))
{
host.Assert(!string.IsNullOrEmpty(args.ValueColumn));
termColumn = args.TermColumn;
valueColumn = args.ValueColumn;
}
else
{
var ext = Path.GetExtension(dataFile);
if (loader.IsGood() || string.Equals(ext, ".idv", StringComparison.OrdinalIgnoreCase))
{
throw host.ExceptUserArg(nameof(args.TermColumn), "Term and value columns needed.");
}
loader = GetLoaderSubComponent(args.DataFile, args.KeyValues, host);
termColumn = "Term";
valueColumn = "Value";
}
return(GetBytesOne(host, dataFile, loader, termColumn, valueColumn));
}
public static IPredictor Train(IHostEnvironment env, IChannel ch, RoleMappedData data, ITrainer trainer, string name, RoleMappedData validData,
SubComponent <ICalibratorTrainer, SignatureCalibrator> calibrator, int maxCalibrationExamples, bool?cacheData, IPredictor inputPredictor = null)
{
ICalibratorTrainer caliTrainer = !calibrator.IsGood() ? null : calibrator.CreateInstance(env);
return(TrainCore(env, ch, data, trainer, name, validData, caliTrainer, maxCalibrationExamples, cacheData, inputPredictor));
}
private void PrintRecipe(IChannel ch, RecipeInference.SuggestedRecipe[] suggestedRecipes, string settingsString, StreamWriter sw = null)
{
string prefix = "";
foreach (var recipe in suggestedRecipes)
{
var loaderSubComponent = new SubComponent("TextLoader", settingsString);
sw?.WriteLine(prefix + "loader={0}", loaderSubComponent);
foreach (var suggestion in recipe.Transforms)
{
string transform = $"xf={suggestion.Transform}";
ch.Info(transform);
sw?.WriteLine(transform);
}
if (recipe.Learners != null)
{
foreach (var suggestion in recipe.Learners)
{
string learner = $"tr={suggestion.LoadableClassInfo.LoadNames[0]}{{{suggestion.Settings}}}";
ch.Info(learner);
sw?.WriteLine(learner);
}
}
prefix = "\n\n";
}
}
/// <summary>
/// Trains a model.
/// </summary>
/// <param name="env">host</param>
/// <param name="ch">channel</param>
/// <param name="data">traing data</param>
/// <param name="validData">validation data</param>
/// <param name="calibrator">calibrator</param>
/// <param name="maxCalibrationExamples">number of examples used to calibrate</param>
/// <param name="cacheData">cache training data</param>
/// <param name="inpPredictor">for continuous training, initial state</param>
/// <returns>predictor</returns>
public IPredictor Train(IHostEnvironment env, IChannel ch, RoleMappedData data, RoleMappedData validData = null,
SubComponent <ICalibratorTrainer, SignatureCalibrator> calibrator = null, int maxCalibrationExamples = 0,
bool?cacheData = null, IPredictor inpPredictor = null)
{
return(TrainUtils.Train(env, ch, data, Trainer, LoadName, validData, calibrator, maxCalibrationExamples,
cacheData, inpPredictor));
}
public virtual NuGenHL7Exception[] testComponent(Genetibase.NuGenHL7.model.Type type, Component profile, System.String profileID)
{
System.Collections.ArrayList exList = new System.Collections.ArrayList(20);
addToList(testType(type, profile, null, profileID), exList);
//test children
if (profile.SubComponents > 0 && !profile.Usage.Equals("X") && hasContent(type))
{
if (typeof(Composite).IsAssignableFrom(type.GetType()))
{
Composite comp = (Composite)type;
for (int i = 1; i <= profile.SubComponents; i++)
{
SubComponent childProfile = profile.getSubComponent(i);
try
{
Genetibase.NuGenHL7.model.Type child = comp.getComponent(i - 1);
addToList(testType(child, childProfile, null, profileID), exList);
}
catch (DataTypeException de)
{
exList.Add(new NuGenProfileNotHL7CompliantException("More subcomponents in profile than allowed in message: " + de.Message));
}
}
addToList(checkExtraComponents(comp, profile.SubComponents), exList);
}
else
{
exList.Add(new NuGenProfileNotFollowedException("A component has primitive type " + type.GetType().FullName + " but the profile defines subcomponents"));
}
}
return(toArray(exList));
}
private IEarlyStoppingCriterion CreateEarlyStoppingCriterion(string name, string args, bool lowerIsBetter)
{
var env = new ConsoleEnvironment()
.AddStandardComponents();
var sub = new SubComponent <IEarlyStoppingCriterion, SignatureEarlyStoppingCriterion>(name, args);
return(sub.CreateInstance(env, lowerIsBetter));
}
private EarlyStoppingRuleBase CreateEarlyStoppingCriterion(string name, string args, bool lowerIsBetter)
{
var env = new MLContext()
.AddStandardComponents();
var sub = new SubComponent <EarlyStoppingRuleBase, SignatureEarlyStoppingCriterion>(name, args);
return(sub.CreateInstance(env, lowerIsBetter));
}
/// <param name="env">The environment.</param>
/// <param name="registrationName">The registration name.</param>
/// <param name="inputDataView">The input data view.</param>
/// <param name="splitColumn">The column to use for splitting data into folds.</param>
/// <param name="args">Cross validation arguments.</param>
/// <param name="createExamples">The delegate to create RoleMappedData</param>
/// <param name="applyTransformsToTestData">The delegate to apply the transforms from the train pipeline to the test data</param>
/// <param name="scorer">The scorer</param>
/// <param name="evaluator">The evaluator</param>
/// <param name="getValidationDataView">The delegate to create validation data view</param>
/// <param name="applyTransformsToValidationData">The delegate to apply the transforms from the train pipeline to the validation data</param>
/// <param name="inputPredictor">The input predictor, for the continue training option</param>
/// <param name="cmd">The command string.</param>
/// <param name="loader">Original loader so we can construct correct pipeline for model saving.</param>
/// <param name="savePerInstance">Whether to produce the per-instance data view.</param>
/// <returns></returns>
public FoldHelper(
IHostEnvironment env,
string registrationName,
IDataView inputDataView,
string splitColumn,
Arguments args,
Func <IHostEnvironment, IChannel, IDataView, ITrainer, RoleMappedData> createExamples,
Func <IHostEnvironment, IChannel, IDataView, RoleMappedData, IDataView, RoleMappedData> applyTransformsToTestData,
SubComponent <IDataScorerTransform, SignatureDataScorer> scorer,
SubComponent <IMamlEvaluator, SignatureMamlEvaluator> evaluator,
Func <IDataView> getValidationDataView = null,
Func <IHostEnvironment, IChannel, IDataView, RoleMappedData, IDataView, RoleMappedData> applyTransformsToValidationData = null,
IPredictor inputPredictor = null,
string cmd = null,
IDataLoader loader = null,
bool savePerInstance = false)
{
Contracts.CheckValue(env, nameof(env));
env.CheckNonWhiteSpace(registrationName, nameof(registrationName));
env.CheckValue(inputDataView, nameof(inputDataView));
env.CheckValue(splitColumn, nameof(splitColumn));
env.CheckParam(args.NumFolds > 1, nameof(args.NumFolds));
env.CheckValue(createExamples, nameof(createExamples));
env.CheckValue(applyTransformsToTestData, nameof(applyTransformsToTestData));
env.CheckParam(args.Trainer.IsGood(), nameof(args.Trainer));
env.CheckValueOrNull(scorer);
env.CheckValueOrNull(evaluator);
env.CheckValueOrNull(args.Calibrator);
env.CheckParam(args.MaxCalibrationExamples > 0, nameof(args.MaxCalibrationExamples));
env.CheckParam(getValidationDataView == null || applyTransformsToValidationData != null, nameof(applyTransformsToValidationData));
env.CheckValueOrNull(inputPredictor);
env.CheckValueOrNull(cmd);
env.CheckValueOrNull(args.OutputModelFile);
env.CheckValueOrNull(loader);
_env = env;
_registrationName = registrationName;
_inputDataView = inputDataView;
_splitColumn = splitColumn;
_numFolds = args.NumFolds;
_createExamples = createExamples;
_applyTransformsToTestData = applyTransformsToTestData;
_trainer = args.Trainer;
_scorer = scorer;
_evaluator = evaluator;
_calibrator = args.Calibrator;
_maxCalibrationExamples = args.MaxCalibrationExamples;
_useThreads = args.UseThreads;
_cacheData = args.CacheData;
_getValidationDataView = getValidationDataView;
_applyTransformsToValidationData = applyTransformsToValidationData;
_inputPredictor = inputPredictor;
_cmd = cmd;
_outputModelFile = args.OutputModelFile;
_loader = loader;
_savePerInstance = savePerInstance;
}
protected void SendTelemetryComponent(IPipe <TelemetryMessage> pipe, SubComponent sub)
{
Host.AssertValue(pipe);
Host.AssertValueOrNull(sub);
if (sub.IsGood())
{
pipe.Send(TelemetryMessage.CreateTrainer(sub.Kind, sub.SubComponentSettings));
}
}
public void Dispose_HasDisposedWithoutEvents_DoesNotnvokesEvent()
{
var component = new SubComponent();
component.Disposed += Component_Disposed;
component.CanRaiseEventsInternal = false;
component.Dispose();
Assert.False(InvokedDisposed);
}
public void Ctor_Default()
{
var component = new SubComponent();
Assert.True(component.CanRaiseEvents);
Assert.Null(component.Container);
Assert.False(component.DesignMode);
Assert.Same(component.Events, component.Events);
Assert.Null(component.Site);
}
private static TRes CreateInstance <TRes, TSig>(IHostEnvironment env, string settings, out string loadName, params object[] extraArgs)
where TRes : class
{
Contracts.AssertValue(env);
env.AssertValue(settings, "settings");
var sc = SubComponent.Parse <TRes, TSig>(settings);
loadName = sc.Kind;
return(sc.CreateInstance(env, extraArgs));
}
public void Site_Set_GetReturnsExpected()
{
var component = new SubComponent();
Assert.Null(component.Site);
var site = new MockSite();
component.Site = site;
Assert.Same(site, component.Site);
}
private void WeightedMetricTest(Instances noWeights, Instances weights1, Instances weightsQuarter, string predictorName, Func <Tester <Float> > tester)
{
Instances[] data = new Instances[3] {
noWeights, weights1, weightsQuarter
};
Metric[][] results = new Metric[3][];
var sub = new SubComponent <ITrainer <Instances, IPredictor <Instance, Float> >, SignatureOldTrainer>(
predictorName, "nl=5 lr=0.25 iter=20 mil=1");
for (int i = 0; i < 3; i++)
{
Instances instances = data[i];
if (instances == null)
{
continue;
}
// Create the trainer
var trainer = sub.CreateInstance(new TrainHost(new Random(1), 0));
// Train a predictor
trainer.Train(instances);
var predictor = trainer.CreatePredictor();
results[i] = tester().Test(predictor, instances);
}
//Compare metrics results with unweighted metrics
for (int i = 1; i < 3; i++)
{
if (results[i] == null)
{
continue;
}
//The nonweighted result should have half of the metrics
Assert.Equal(results[i].Length, results[0].Length * 2);
for (int m = 0; m < results[0].Length; m++)
{
Assert.Equal(results[0][m].Name, results[i][m].Name);
Double diff = Math.Abs(results[0][m].Value - results[i][m].Value);
if (diff > 1e-6)
{
Fail("{0} differ: {1} vs. {2}", results[0][m].Name, results[0][m].Value, results[i][m].Value);
}
}
}
//Compare all metrics between weight 1 (with and without explicit weight in the input)
for (int m = 0; m < results[0].Length; m++)
{
Assert.True(Math.Abs(results[0][m].Value - results[1][m].Value) < 1e-10);
Assert.True(Math.Abs(results[0][m].Value - results[1][m + results[0].Length].Value) < 1e-10);
}
}
public void ToString_HasSite_ReturnsExpected()
{
var component = new SubComponent();
Assert.Equal("System.ComponentModel.Tests.ComponentTests+SubComponent", component.ToString());
component.Site = new MockSite {
Name = "name"
};
Assert.Equal("name [System.ComponentModel.Tests.ComponentTests+SubComponent]", component.ToString());
}
public void Dispose_NullSiteContainer_Success()
{
var component = new SubComponent()
{
Site = new MockSite {
Container = null
}
};
component.Dispose();
component.Dispose();
}
public void Finalize_Invoke_DoesNotCallDisposedEvent()
{
var component = new SubComponent();
component.Disposed += Component_Disposed;
MethodInfo method = typeof(Component).GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(method);
method.Invoke(component, null);
Assert.False(InvokedDisposed);
}
/// <summary>
/// Create an instance of the indicated component with the given extra parameters.
/// </summary>
public static TRes CreateInstance <TRes, TSig>(IHostEnvironment env, SubComponent comp, params object[] extra)
where TRes : class
{
string options = CmdParser.CombineSettings(comp.Settings);
TRes result;
if (TryCreateInstance <TRes, TSig>(env, out result, comp.Kind, options, extra))
{
return(result);
}
throw Contracts.Except("Unknown loadable class: {0}", comp.Kind).MarkSensitive(MessageSensitivity.None);
}
public void Dispose_NotDisposing_DoesNotInvokeEvent()
{
var component = new SubComponent();
component.Disposed += Component_Disposed;
component.DisposeInternal(false);
Assert.False(InvokedDisposed);
component.DisposeInternal(true);
Assert.True(InvokedDisposed);
}
private static bool TryCreateBindableFromScorer(IHostEnvironment env, IPredictor predictor,
SubComponent <IDataScorerTransform, SignatureDataScorer> scorerSettings, out ISchemaBindableMapper bindable)
{
Contracts.AssertValue(env);
env.AssertValue(predictor);
env.Assert(scorerSettings.IsGood());
// Try to find a mapper factory method with the same loadname as the scorer settings.
var mapperComponent = new SubComponent <ISchemaBindableMapper, SignatureBindableMapper>(scorerSettings.Kind, scorerSettings.Settings);
return(ComponentCatalog.TryCreateInstance(env, out bindable, mapperComponent, predictor));
}
public TrainCommand(IHostEnvironment env, Arguments args)
: base(env, args, nameof(TrainCommand))
{
Host.CheckNonWhiteSpace(args.OutputModelFile, nameof(args.OutputModelFile));
_info = TrainUtils.CheckTrainer(Host, args.Trainer, args.DataFile);
_trainer = args.Trainer;
_labelColumn = args.LabelColumn;
_featureColumn = args.FeatureColumn;
_groupColumn = args.GroupColumn;
_weightColumn = args.WeightColumn;
_nameColumn = args.NameColumn;
}
public void DesignMode_GetWithSite_ReturnsExpected(bool result)
{
var site = new MockSite
{
DesignMode = result
};
var component = new SubComponent
{
Site = site
};
Assert.Equal(result, component.DesignMode);
}
public void GetService_InvokeWithSite_ReturnsExpected(Type serviceType, Type result)
{
var site = new MockSite
{
ServiceType = result
};
var component = new SubComponent
{
Site = site
};
Assert.Same(result, component.GetService(serviceType));
}
public void Finalize_Invoke_DoesNotCallDisposedEvent()
{
var component = new SubComponent();
int callCount = 0;
component.Disposed += (sender, e) => callCount++;
MethodInfo method = typeof(Component).GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(method);
method.Invoke(component, null);
Assert.Equal(0, callCount);
}
