public TOutput GetOutput <TOutput>(Var <TOutput> var)
where TOutput : class
{
_env.CheckValue(var, nameof(var));
_env.CheckNonEmpty(var.VarName, nameof(var.VarName));
var varBinding = VariableBinding.Create(_env, $"${var.VarName}");
EntryPointVariable variable = _graph.GetVariableOrNull(varBinding.VariableName);
if (variable == null)
{
throw _env.Except("Port '{0}' not found", var.VarName);
}
var value = varBinding.GetVariableValueOrNull(variable);
if (value == null)
{
return(null);
}
var result = value as TOutput;
if (result == null)
{
throw _env.Except("Incorrect type for output '{0}'", var.VarName);
}
return(result);
}
public void RemoveVariable(VariableBinding variable)
{
var index = this.customVariables.IndexOf(variable);
this.customVariables.Remove(variable);
this.randomizations.RemoveAt(index);
}
public void AddCustomVariable(string name, Object target, string viewName)
{
var variable = new VariableBinding()
{
name = name,
target = target,
viewName = viewName
};
this.customVariables.Add(variable);
var index = this.customVariables.IndexOf(variable);
try {
var rand = RandomizationFactory.CreateFromBinding(variable);
this.randomizations.Insert(index, rand);
}
catch (UnityException e) {
var msg = new StringBuilder()
.Append("No randomization implementation found for type ")
.Append(variable.target.GetType())
.Append(". Skipping generation of randomization for ")
.Append(variable.viewName)
.Append(" (")
.Append(variable.name)
.Append(").")
.ToString()
;
Debug.LogWarning(msg);
}
}
private void InvokeEvent(System.Action <VariableBinding> action, VariableBinding variable)
{
if (null != action)
{
action(variable);
}
}
private void OnEditBinding(VariableBinding variable)
{
var head = (ChainHead)this.target;
var window = EditVariableBindingEditor.CreateWindow(new EditVariableBindingModel(head, variable));
window.OnToggleRandomizeVariable += this.OnToggleRandomizeVariable;
window.Show();
}
public bool TryGetVariable(string name, out VariableBinding binding)
{
if (!_moduleCtx.TryGetVariable(name, out binding))
{
return(_outerCtx.TryGetVariable(name, out binding));
}
ShiftIndex(ref binding.binding);
return(true);
}
private void OnToggleRandomization(VariableBinding v, bool s)
{
if (null != this.OnToggleRandomizeVariable)
{
this.OnToggleRandomizeVariable(v, s);
}
else
{
Debug.LogWarning("No OnToggleRandomizeVariable registered in EditVariableBindingEditor!");
}
}
private void EnsureValidBinding(Environment env)
{
if (Binding == null)
{
if (!env.Scopes.Values.HasBinding(Name))
{
throw new TranspilationException($"Tried to invoke non-initialized invokable '{Name}'", Location);
}
Binding = env.Scopes.Values.GetBinding(Name);
}
}
protected override void Given()
{
_variable = new Variable("Grasp", "Test", typeof(int));
_schema = new GraspSchema(new[] { _variable }, Enumerable.Empty<Calculation>());
_binding = new VariableBinding(_variable, 1);
_runtime = new GraspRuntime(_schema, A.Fake<ICalculator>(), new[] { _binding });
_newValue = 2;
}
public VariableBindingView(VariableBinding variable)
{
this.variable = variable;
var hint = new StringBuilder()
.Append("Alias for ")
.Append(this.variable.name)
.Append(" from object ")
.Append(this.variable.target)
.ToString()
;
this.label = new GUIContent(this.variable.viewName, hint);
}
//internal void OnClear(int tech, int pass)
//{
// if (Clearded != null)
// Clearded(tech, pass);
// //foreach (var v in variables)
// //{
// // v.Variable.Deferred = true;
// //}
//}
internal void AddVariable(string name, ShaderVariable v)
{
VariableBinding binding = new VariableBinding
{
Variable = v,
Setter = program.CreateUniformSetter(name)
};
if (binding.Setter == null)
{
throw new NullReferenceException("The IUniformSetter is null");
}
_variables.Add(binding);
}
private bool GetDataVariableName(IExceptionContext ectx, string nameOfData, JToken firstNodeInputs, out string variableName)
{
variableName = null;
if (firstNodeInputs[nameOfData] == null)
{
return(false);
}
string dataVar = firstNodeInputs.Value <String>(nameOfData);
ectx.Check(VariableBinding.IsValidVariableName(ectx, dataVar), $"Invalid variable name {dataVar}.");
variableName = dataVar.Substring(1);
return(true);
}
/// <summary>
/// We obtain the binding, if it exists.
/// </summary>
/// <param name="name">Name of variable.</param>
/// <returns>Asociated binding.</returns>
public void GetBinding([NotNull] string name, out VariableBinding binding)
{
object obj = values[name];
if (obj == null)
{
throw new ArgumentException("The binding with that name does not exist.");
}
if (obj.GetType() != typeof(VariableBinding))
{
throw new ArgumentException("The binding with that name does not exist, this variable " +
"is used as parameter.");
}
binding = (VariableBinding)obj;
}
public bool TryGetVariable(string name, out VariableBinding vb)
{
var hasSymbol = TryGetSymbol(name, x => ExtractVariableIndex(name, x), out var sb);
if (!hasSymbol)
{
vb = default(VariableBinding);
return(false);
}
vb = new VariableBinding()
{
type = _scopeStack[sb.ContextIndex].GetVariable(sb.CodeIndex).Type,
binding = sb
};
return(true);
}
public static IVariableRandomization CreateFromBinding(VariableBinding variable)
{
var field = variable.GetField();
var value = field.GetValue(variable.target);
var types = FindRandomizationTypes();
foreach (var type in types)
{
var attr = (CustomRandomizerAttribute)type.GetCustomAttributes(typeof(CustomRandomizerAttribute), true)[0];
if (attr.type == field.FieldType)
{
return((IVariableRandomization)System.Activator.CreateInstance(type));
}
}
throw new UnityException("Type not supported! " + field.FieldType.ToString());
}
public static VariableBindingView CreateFromVariable(VariableBinding variable)
{
var field = variable.GetField();
var types = FindViewTypes();
foreach (var type in types)
{
var attr = (CustomVariableBindingViewAttribute)type.GetCustomAttributes(
typeof(CustomVariableBindingViewAttribute), true)[0];
if (attr.type.IsAssignableFrom(field.FieldType))
{
return((VariableBindingView)System.Activator.CreateInstance(type, variable));
}
}
throw new UnityException("Unkown field type: " + field.FieldType);
}
void InOrReadParam(out Expression exp)
{
exp = null;
if (la.kind == 1)
{
Get();
exp = new PLRString(t.val); SetPos(exp, t);
}
else if (la.kind == 3)
{
Get();
exp = new VariableBinding(t.val.Replace("!", "")); SetPos(exp, t);
}
else if (StartOf(2))
{
Expression(out exp);
}
else
{
SynErr(33);
}
}
/// <summary>
/// Sets variable.
/// </summary>
/// <param name="name">The name of variable.</param>
/// <param name="index">Index parameter by
/// <see cref="Expression.Variable(uint index)"/>.</param>
public void SetBinding([NotNull] string name, VariableBinding index)
{
// Checks.
if (index.Parent != this.expression)
{
throw new ArgumentException("The index used to set variable was not created by the same expression" +
"this params are used with.");
}
// We now add variable.
int inx = sortedKeys.BinarySearch(name);
if (inx >= 0)
{
// May overwrite.
values[name] = (object)index;
}
else
{
throw new ArgumentException("Could not locate the variable "
+ name + " in named arguments of function.");
}
}
public void RefreshInformation()
{
if (Metadata == null)
{
return;
}
cmbRegion.Items.Clear();
cmbPlatform.Items.Clear();
cmbRegion.DataBindings.Clear();
cmbPlatform.DataBindings.Clear();
tbxRules.Clear();
foreach (var control in dynamicControls)
{
tableLayoutPanel1.Controls.Remove(control);
}
dynamicControls.Clear();
variableBindings.Clear();
if (Metadata.Game != null)
{
cmbRegion.Items.Add(string.Empty);
cmbPlatform.Items.Add(string.Empty);
cmbRegion.Items.AddRange(Metadata.Game.Regions.Select(x => x.Name).ToArray());
cmbPlatform.Items.AddRange(Metadata.Game.Platforms.Select(x => x.Name).ToArray());
cmbRegion.DataBindings.Add("SelectedItem", Metadata, "RegionName", false, DataSourceUpdateMode.OnPropertyChanged);
cmbPlatform.DataBindings.Add("SelectedItem", Metadata, "PlatformName", false, DataSourceUpdateMode.OnPropertyChanged);
refreshRules();
var controlIndex = 0;
if (Metadata.Game != null && Metadata.Game.Ruleset.EmulatorsAllowed)
{
var emulatedRow = getDynamicControlRowIndex(controlIndex);
var emulatedColumn = getDynamicControlColumnIndex(controlIndex);
var emulatedCheckBox = new CheckBox
{
Text = "Uses Emulator",
Anchor = AnchorLeftRight,
Margin = new Padding(7, 3, 3, 3),
Height = 21,
Visible = false
};
tableLayoutPanel1.Controls.Add(emulatedCheckBox, emulatedColumn, emulatedRow);
tableLayoutPanel1.SetColumnSpan(emulatedCheckBox, 2);
emulatedCheckBox.DataBindings.Add("Checked", Metadata, "UsesEmulator", false, DataSourceUpdateMode.OnPropertyChanged);
dynamicControls.Add(emulatedCheckBox);
controlIndex++;
}
foreach (var variable in Metadata.VariableValues.Keys)
{
var variableLabel = new Label()
{
Text = variable.Name + ":",
AutoSize = true,
Anchor = AnchorLeftRight,
Visible = false
};
var variableComboBox = new ComboBox()
{
DropDownStyle = variable.IsUserDefined ? ComboBoxStyle.DropDown : ComboBoxStyle.DropDownList,
FormattingEnabled = true,
Anchor = AnchorLeftRight,
Visible = false
};
variableComboBox.Items.Add(string.Empty);
variableComboBox.Items.AddRange(variable.Values.Select(x => x.Value).ToArray());
var variableRow = getDynamicControlRowIndex(controlIndex);
var variableLabelColumn = getDynamicControlColumnIndex(controlIndex);
var variableComboBoxColumn = variableLabelColumn + 1;
tableLayoutPanel1.Controls.Add(variableLabel, variableLabelColumn, variableRow);
tableLayoutPanel1.Controls.Add(variableComboBox, variableComboBoxColumn, variableRow);
var variableBinding = new VariableBinding()
{
Metadata = Metadata,
Variable = variable
};
variableBinding.VariableChanged += Metadata_Changed;
variableComboBox.DataBindings.Add("Text", variableBinding, "Value", false, DataSourceUpdateMode.OnPropertyChanged);
dynamicControls.Add(variableLabel);
dynamicControls.Add(variableComboBox);
variableBindings.Add(variableBinding);
controlIndex++;
}
}
foreach (var control in dynamicControls)
{
control.Visible = true;
}
cmbRegion.Enabled = cmbRegion.Items.Count > 1;
cmbPlatform.Enabled = cmbPlatform.Items.Count > 1;
RefreshAssociateButton();
}
private static object ParseJsonValue(IExceptionContext ectx, Type type, Attributes attributes, JToken value, ComponentCatalog catalog)
{
Contracts.AssertValue(ectx);
ectx.AssertValue(type);
ectx.AssertValueOrNull(value);
ectx.AssertValue(catalog);
if (value == null)
{
return(null);
}
if (value is JValue val && val.Value == null)
{
return(null);
}
if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(Optional <>) || type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
if (type.GetGenericTypeDefinition() == typeof(Optional <>) && value.HasValues)
{
value = value.Values().FirstOrDefault();
}
type = type.GetGenericArguments()[0];
}
if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(Var <>)))
{
string varName = value.Value <string>();
ectx.Check(VariableBinding.IsBindingToken(value), "Variable name expected.");
var variable = Activator.CreateInstance(type) as IVarSerializationHelper;
var varBinding = VariableBinding.Create(ectx, varName);
variable.VarName = varBinding.VariableName;
return(variable);
}
if (type == typeof(JArray) && value is JArray)
{
return(value);
}
TlcModule.DataKind dt = TlcModule.GetDataType(type);
try
{
switch (dt)
{
case TlcModule.DataKind.Bool:
return(value.Value <bool>());
case TlcModule.DataKind.String:
return(value.Value <string>());
case TlcModule.DataKind.Char:
return(value.Value <char>());
case TlcModule.DataKind.Enum:
if (!Enum.IsDefined(type, value.Value <string>()))
{
throw ectx.Except($"Requested value '{value.Value<string>()}' is not a member of the Enum type '{type.Name}'");
}
return(Enum.Parse(type, value.Value <string>()));
case TlcModule.DataKind.Float:
if (type == typeof(double))
{
return(value.Value <double>());
}
else if (type == typeof(float))
{
return(value.Value <float>());
}
else
{
ectx.Assert(false);
throw ectx.ExceptNotSupp();
}
case TlcModule.DataKind.Array:
var ja = value as JArray;
ectx.Check(ja != null, "Expected array value");
Func <IExceptionContext, JArray, Attributes, ComponentCatalog, object> makeArray = MakeArray <int>;
return(Utils.MarshalInvoke(makeArray, type.GetElementType(), ectx, ja, attributes, catalog));
case TlcModule.DataKind.Int:
if (type == typeof(long))
{
return(value.Value <long>());
}
if (type == typeof(int))
{
return(value.Value <int>());
}
ectx.Assert(false);
throw ectx.ExceptNotSupp();
case TlcModule.DataKind.UInt:
if (type == typeof(ulong))
{
return(value.Value <ulong>());
}
if (type == typeof(uint))
{
return(value.Value <uint>());
}
ectx.Assert(false);
throw ectx.ExceptNotSupp();
case TlcModule.DataKind.Dictionary:
ectx.Check(value is JObject, "Expected object value");
Func <IExceptionContext, JObject, Attributes, ComponentCatalog, object> makeDict = MakeDictionary <int>;
return(Utils.MarshalInvoke(makeDict, type.GetGenericArguments()[1], ectx, (JObject)value, attributes, catalog));
case TlcModule.DataKind.Component:
var jo = value as JObject;
ectx.Check(jo != null, "Expected object value");
// REVIEW: consider accepting strings alone.
var jName = jo[FieldNames.Name];
ectx.Check(jName != null, "Field '" + FieldNames.Name + "' is required for component.");
ectx.Check(jName is JValue, "Expected '" + FieldNames.Name + "' field to be a string.");
var name = jName.Value <string>();
ectx.Check(jo[FieldNames.Settings] == null || jo[FieldNames.Settings] is JObject,
"Expected '" + FieldNames.Settings + "' field to be an object");
return(GetComponentJson(ectx, type, name, jo[FieldNames.Settings] as JObject, catalog));
default:
var settings = value as JObject;
ectx.Check(settings != null, "Expected object value");
var inputBuilder = new InputBuilder(ectx, type, catalog);
if (inputBuilder._fields.Length == 0)
{
throw ectx.Except($"Unsupported input type: {dt}");
}
if (settings != null)
{
foreach (var pair in settings)
{
if (!inputBuilder.TrySetValueJson(pair.Key, pair.Value))
{
throw ectx.Except($"Unexpected value for component '{type}', field '{pair.Key}': '{pair.Value}'");
}
}
}
var missing = inputBuilder.GetMissingValues().ToArray();
if (missing.Length > 0)
{
throw ectx.Except($"The following required inputs were not provided for component '{type}': {string.Join(", ", missing)}");
}
return(inputBuilder.GetInstance());
}
}
catch (FormatException ex)
{
if (ex.IsMarked())
{
throw;
}
throw ectx.Except(ex, $"Failed to parse JSON value '{value}' as {type}");
}
}
public static CommonOutputs.MacroOutput <Output> TrainTest(
IHostEnvironment env,
Arguments input,
EntryPointNode node)
{
// Create default pipeline ID if one not given.
input.PipelineId = input.PipelineId ?? Guid.NewGuid().ToString("N");
// Parse the subgraph.
var subGraphRunContext = new RunContext(env);
var subGraphNodes = EntryPointNode.ValidateNodes(env, subGraphRunContext, input.Nodes, label: input.LabelColumn,
input.GroupColumn.IsExplicit ? input.GroupColumn.Value : null,
input.WeightColumn.IsExplicit ? input.WeightColumn.Value : null,
input.NameColumn.IsExplicit ? input.NameColumn.Value : null);
// Change the subgraph to use the training data as input.
var varName = input.Inputs.Data.VarName;
VariableBinding transformModelVarName = null;
if (input.TransformModel != null)
{
transformModelVarName = node.GetInputVariable(nameof(input.TransformModel));
}
if (!subGraphRunContext.TryGetVariable(varName, out var dataVariable))
{
throw env.Except($"Invalid variable name '{varName}'.");
}
var trainingVar = node.GetInputVariable(nameof(input.TrainingData));
foreach (var subGraphNode in subGraphNodes)
{
subGraphNode.RenameInputVariable(dataVariable.Name, trainingVar);
}
subGraphRunContext.RemoveVariable(dataVariable);
// Change the subgraph to use the model variable as output.
varName = input.Outputs.PredictorModel.VarName;
if (!subGraphRunContext.TryGetVariable(varName, out dataVariable))
{
throw env.Except($"Invalid variable name '{varName}'.");
}
string predictorModelVarName = node.GetOutputVariableName(nameof(Output.PredictorModel));
foreach (var subGraphNode in subGraphNodes)
{
subGraphNode.RenameOutputVariable(dataVariable.Name, predictorModelVarName);
}
subGraphRunContext.RemoveVariable(dataVariable);
// Move the variables from the subcontext to the main context.
node.Context.AddContextVariables(subGraphRunContext);
// Change all the subgraph nodes to use the main context.
foreach (var subGraphNode in subGraphNodes)
{
subGraphNode.SetContext(node.Context);
}
// Testing using test data set
var testingVar = node.GetInputVariable(nameof(input.TestingData));
//var exp = new Experiment(env);
Dictionary <string, List <ParameterBinding> > inputBindingMap;
Dictionary <ParameterBinding, VariableBinding> inputMap;
ParameterBinding paramBinding;
Dictionary <string, string> outputMap;
//combine the predictor model with any potential transfrom model passed from the outer graph
if (transformModelVarName != null && transformModelVarName.VariableName != null)
{
var combineArgs = new ModelOperations.SimplePredictorModelInput();
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var inputTransformModel = new SimpleVariableBinding(transformModelVarName.VariableName);
var inputPredictorModel = new SimpleVariableBinding(predictorModelVarName);
paramBinding = new SimpleParameterBinding(nameof(combineArgs.TransformModel));
inputBindingMap.Add(nameof(combineArgs.TransformModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputTransformModel);
paramBinding = new SimpleParameterBinding(nameof(combineArgs.PredictorModel));
inputBindingMap.Add(nameof(combineArgs.PredictorModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputPredictorModel);
outputMap = new Dictionary <string, string>();
var combineNodeOutputPredictorModel = new Var <PredictorModel>();
predictorModelVarName = combineNodeOutputPredictorModel.VarName;
outputMap.Add(nameof(ModelOperations.PredictorModelOutput.PredictorModel), combineNodeOutputPredictorModel.VarName);
EntryPointNode combineNode = EntryPointNode.Create(env, "Transforms.TwoHeterogeneousModelCombiner", combineArgs,
node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(combineNode);
}
// Add the scoring node for testing.
var args = new ScoreModel.Input();
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
paramBinding = new SimpleParameterBinding(nameof(args.Data));
inputBindingMap.Add(nameof(args.Data), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, testingVar);
var scoreNodeInputPredictorModel = new SimpleVariableBinding(predictorModelVarName);
paramBinding = new SimpleParameterBinding(nameof(args.PredictorModel));
inputBindingMap.Add(nameof(args.PredictorModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, scoreNodeInputPredictorModel);
var scoreNodeOutputScoredData = new Var <IDataView>();
var scoreNodeOutputScoringTransform = new Var <TransformModel>();
outputMap = new Dictionary <string, string>();
outputMap.Add(nameof(ScoreModel.Output.ScoredData), scoreNodeOutputScoredData.VarName);
outputMap.Add(nameof(ScoreModel.Output.ScoringTransform), scoreNodeOutputScoringTransform.VarName);
EntryPointNode scoreNode = EntryPointNode.Create(env, "Transforms.DatasetScorer", args,
node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(scoreNode);
var evalDataVarName = scoreNodeOutputScoredData.VarName;
// REVIEW: add similar support for FeatureColumn.
var settings = new MacroUtils.EvaluatorSettings
{
LabelColumn = input.LabelColumn,
WeightColumn = input.WeightColumn.IsExplicit ? input.WeightColumn.Value : null,
GroupColumn = input.GroupColumn.IsExplicit ? input.GroupColumn.Value : null,
NameColumn = input.NameColumn.IsExplicit ? input.NameColumn.Value : null
};
if (input.IncludeTrainingMetrics)
{
string evalTrainingDataVarName;
args = new ScoreModel.Input();
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
paramBinding = new SimpleParameterBinding(nameof(args.Data));
inputBindingMap.Add(nameof(args.Data), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, trainingVar);
scoreNodeInputPredictorModel = new SimpleVariableBinding(predictorModelVarName);
paramBinding = new SimpleParameterBinding(nameof(args.PredictorModel));
inputBindingMap.Add(nameof(args.PredictorModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, scoreNodeInputPredictorModel);
scoreNodeOutputScoredData = new Var <IDataView>();
scoreNodeOutputScoringTransform = new Var <TransformModel>();
outputMap = new Dictionary <string, string>();
outputMap.Add(nameof(ScoreModel.Output.ScoredData), scoreNodeOutputScoredData.VarName);
outputMap.Add(nameof(ScoreModel.Output.ScoringTransform), scoreNodeOutputScoringTransform.VarName);
scoreNode = EntryPointNode.Create(env, "Transforms.DatasetScorer", args,
node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(scoreNode);
evalTrainingDataVarName = scoreNodeOutputScoredData.VarName;
// Add the evaluator node for training.
var evalTrainingArgs = MacroUtils.GetEvaluatorArgs(input.Kind, out var evalTrainingEntryPointName, settings);
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var evalTrainingNodeInputData = new SimpleVariableBinding(evalTrainingDataVarName);
paramBinding = new SimpleParameterBinding(nameof(evalTrainingArgs.Data));
inputBindingMap.Add(nameof(evalTrainingArgs.Data), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, evalTrainingNodeInputData);
outputMap = new Dictionary <string, string>();
if (node.OutputMap.TryGetValue(nameof(Output.TrainingWarnings), out var outTrainingVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.Warnings), outTrainingVariableName);
}
if (node.OutputMap.TryGetValue(nameof(Output.TrainingOverallMetrics), out outTrainingVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.OverallMetrics), outTrainingVariableName);
}
if (node.OutputMap.TryGetValue(nameof(Output.TrainingPerInstanceMetrics), out outTrainingVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.PerInstanceMetrics), outTrainingVariableName);
}
if (node.OutputMap.TryGetValue(nameof(Output.TrainingConfusionMatrix), out outTrainingVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.ConfusionMatrix), outTrainingVariableName);
}
EntryPointNode evalTrainingNode = EntryPointNode.Create(env, evalTrainingEntryPointName, evalTrainingArgs, node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(evalTrainingNode);
}
// Add the evaluator node for testing.
var evalArgs = MacroUtils.GetEvaluatorArgs(input.Kind, out var evalEntryPointName, settings);
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var evalNodeInputData = new SimpleVariableBinding(evalDataVarName);
paramBinding = new SimpleParameterBinding(nameof(evalArgs.Data));
inputBindingMap.Add(nameof(evalArgs.Data), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, evalNodeInputData);
outputMap = new Dictionary <string, string>();
if (node.OutputMap.TryGetValue(nameof(Output.Warnings), out var outVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.Warnings), outVariableName);
}
if (node.OutputMap.TryGetValue(nameof(Output.OverallMetrics), out outVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.OverallMetrics), outVariableName);
}
if (node.OutputMap.TryGetValue(nameof(Output.PerInstanceMetrics), out outVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.PerInstanceMetrics), outVariableName);
}
if (node.OutputMap.TryGetValue(nameof(Output.ConfusionMatrix), out outVariableName))
{
outputMap.Add(nameof(CommonOutputs.ClassificationEvaluateOutput.ConfusionMatrix), outVariableName);
}
EntryPointNode evalNode = EntryPointNode.Create(env, evalEntryPointName, evalArgs, node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(evalNode);
// Marks as an atomic unit that can be run in
// a distributed fashion.
foreach (var subGraphNode in subGraphNodes)
{
subGraphNode.StageId = input.PipelineId;
}
return(new CommonOutputs.MacroOutput <Output>()
{
Nodes = subGraphNodes
});
}
public EditVariableBindingModel(ChainHead head, VariableBinding variable)
{
this.head = head;
this.variable = variable;
}
public ColorBindingView(VariableBinding variable)
: base(variable)
{
}
public IVariableRandomization GetRandomizationFor(VariableBinding variable)
{
var varindex = this.customVariables.IndexOf(variable);
return(this.randomizations[varindex]);
}
private void OnToggleRandomizeVariable(VariableBinding variable, bool state)
{
variable.randomize = state;
}
private void OnRemoveBinding(VariableBinding variable)
{
this.removeList.Add(variable);
}
public EnumBindingView(VariableBinding variable)
: base(variable)
{
}
public VariableBindingSubscriber(VariableBinding <T> binding)
{
this.binding = binding;
}
public GameObjectBindingView(VariableBinding variable)
: base(variable)
{
}
public void RefreshInformation()
{
if (Metadata == null)
return;
cmbRegion.Items.Clear();
cmbPlatform.Items.Clear();
cmbRegion.DataBindings.Clear();
cmbPlatform.DataBindings.Clear();
tbxRules.Clear();
foreach (var control in dynamicControls)
{
tableLayoutPanel1.Controls.Remove(control);
}
dynamicControls.Clear();
variableBindings.Clear();
if (Metadata.Game != null)
{
cmbRegion.Items.Add(string.Empty);
cmbPlatform.Items.Add(string.Empty);
cmbRegion.Items.AddRange(Metadata.Game.Regions.Select(x => x.Name).ToArray());
cmbPlatform.Items.AddRange(Metadata.Game.Platforms.Select(x => x.Name).ToArray());
cmbRegion.DataBindings.Add("SelectedItem", Metadata, "RegionName", false, DataSourceUpdateMode.OnPropertyChanged);
cmbPlatform.DataBindings.Add("SelectedItem", Metadata, "PlatformName", false, DataSourceUpdateMode.OnPropertyChanged);
refreshRules();
var controlIndex = 0;
if (Metadata.Game != null && Metadata.Game.Ruleset.EmulatorsAllowed)
{
var emulatedRow = getDynamicControlRowIndex(controlIndex);
var emulatedColumn = getDynamicControlColumnIndex(controlIndex);
var emulatedCheckBox = new CheckBox
{
Text = "Uses Emulator",
Anchor = AnchorLeftRight,
Margin = new Padding(7, 3, 3, 3),
Height = 21,
Visible = false
};
tableLayoutPanel1.Controls.Add(emulatedCheckBox, emulatedColumn, emulatedRow);
tableLayoutPanel1.SetColumnSpan(emulatedCheckBox, 2);
emulatedCheckBox.DataBindings.Add("Checked", Metadata, "UsesEmulator", false, DataSourceUpdateMode.OnPropertyChanged);
dynamicControls.Add(emulatedCheckBox);
controlIndex++;
}
foreach (var variable in Metadata.VariableValues.Keys)
{
var variableLabel = new Label()
{
Text = variable.Name + ":",
AutoSize = true,
Anchor = AnchorLeftRight,
Visible = false
};
var variableComboBox = new ComboBox()
{
DropDownStyle = variable.IsUserDefined ? ComboBoxStyle.DropDown : ComboBoxStyle.DropDownList,
FormattingEnabled = true,
Anchor = AnchorLeftRight,
Visible = false
};
variableComboBox.Items.Add(string.Empty);
variableComboBox.Items.AddRange(variable.Values.Select(x => x.Value).ToArray());
var variableRow = getDynamicControlRowIndex(controlIndex);
var variableLabelColumn = getDynamicControlColumnIndex(controlIndex);
var variableComboBoxColumn = variableLabelColumn + 1;
tableLayoutPanel1.Controls.Add(variableLabel, variableLabelColumn, variableRow);
tableLayoutPanel1.Controls.Add(variableComboBox, variableComboBoxColumn, variableRow);
var variableBinding = new VariableBinding()
{
Metadata = Metadata,
Variable = variable
};
variableBinding.VariableChanged += Metadata_Changed;
variableComboBox.DataBindings.Add("Text", variableBinding, "Value", false, DataSourceUpdateMode.OnPropertyChanged);
dynamicControls.Add(variableLabel);
dynamicControls.Add(variableComboBox);
variableBindings.Add(variableBinding);
controlIndex++;
}
}
foreach (var control in dynamicControls)
{
control.Visible = true;
}
cmbRegion.Enabled = cmbRegion.Items.Count > 1;
cmbPlatform.Enabled = cmbPlatform.Items.Count > 1;
RefreshAssociateButton();
}
public static CommonOutputs.MacroOutput <Output> CrossValidate(
IHostEnvironment env,
Arguments input,
EntryPointNode node)
{
env.CheckValue(input, nameof(input));
// This will be the final resulting list of nodes that is returned from the macro.
var subGraphNodes = new List <EntryPointNode>();
//the input transform model
VariableBinding transformModelVarName = null;
if (input.TransformModel != null)
{
transformModelVarName = node.GetInputVariable(nameof(input.TransformModel));
}
// Split the input data into folds.
var splitArgs = new CVSplit.Input();
splitArgs.NumFolds = input.NumFolds;
splitArgs.StratificationColumn = input.StratificationColumn;
var inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
var inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var inputData = node.GetInputVariable(nameof(splitArgs.Data));
ParameterBinding paramBinding = new SimpleParameterBinding(nameof(splitArgs.Data));
inputBindingMap.Add(nameof(splitArgs.Data), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputData);
var outputMap = new Dictionary <string, string>();
var splitOutputTrainData = new ArrayVar <IDataView>();
var splitOutputTestData = new ArrayVar <IDataView>();
outputMap.Add(nameof(CVSplit.Output.TrainData), splitOutputTrainData.VarName);
outputMap.Add(nameof(CVSplit.Output.TestData), splitOutputTestData.VarName);
var splitNode = EntryPointNode.Create(env, "Models.CrossValidatorDatasetSplitter", splitArgs,
node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(splitNode);
var predModelVars = new Var <PredictorModel> [input.NumFolds];
var inputTransformModelVars = new Var <PredictorModel> [input.NumFolds];
var warningsVars = new Var <IDataView> [input.NumFolds];
var overallMetricsVars = new Var <IDataView> [input.NumFolds];
var instanceMetricsVars = new Var <IDataView> [input.NumFolds];
var confusionMatrixVars = new Var <IDataView> [input.NumFolds];
// Instantiate the subgraph for each fold.
for (int k = 0; k < input.NumFolds; k++)
{
// Parse the nodes in input.Nodes into a temporary run context.
var context = new RunContext(env);
var graph = EntryPointNode.ValidateNodes(env, context, input.Nodes);
// Rename all the variables such that they don't conflict with the ones in the outer run context.
var mapping = new Dictionary <string, string>();
foreach (var entryPointNode in graph)
{
entryPointNode.RenameAllVariables(mapping);
}
// Instantiate a TrainTest entry point for this fold.
var args = new TrainTestMacro.Arguments
{
Nodes = new JArray(graph.Select(n => n.ToJson()).ToArray()),
TransformModel = null,
LabelColumn = input.LabelColumn,
GroupColumn = input.GroupColumn,
WeightColumn = input.WeightColumn,
NameColumn = input.NameColumn
};
if (transformModelVarName != null)
{
args.TransformModel = new Var <TransformModel> {
VarName = transformModelVarName.VariableName
}
}
;
args.Inputs.Data = new Var <IDataView>
{
VarName = mapping[input.Inputs.Data.VarName]
};
args.Outputs.PredictorModel = new Var <PredictorModel>
{
VarName = mapping[input.Outputs.PredictorModel.VarName]
};
// Set train/test trainer kind to match.
args.Kind = input.Kind;
// Set the input bindings for the TrainTest entry point.
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var trainingData = new SimpleParameterBinding(nameof(args.TrainingData));
inputBindingMap.Add(nameof(args.TrainingData), new List <ParameterBinding> {
trainingData
});
inputMap.Add(trainingData, new ArrayIndexVariableBinding(splitOutputTrainData.VarName, k));
var testingData = new SimpleParameterBinding(nameof(args.TestingData));
inputBindingMap.Add(nameof(args.TestingData), new List <ParameterBinding> {
testingData
});
inputMap.Add(testingData, new ArrayIndexVariableBinding(splitOutputTestData.VarName, k));
outputMap = new Dictionary <string, string>();
var transformModelVar = new Var <TransformModel>();
var predModelVar = new Var <PredictorModel>();
outputMap.Add(nameof(TrainTestMacro.Output.PredictorModel), predModelVar.VarName);
predModelVars[k] = predModelVar;
if (transformModelVarName != null && transformModelVarName.VariableName != null)
{
var combineModelsArgs = new ModelOperations.SimplePredictorModelInput();
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var inputTransformModel = new SimpleVariableBinding(transformModelVarName.VariableName);
var inputPredictorModel = new SimpleVariableBinding(predModelVar.VarName);
paramBinding = new SimpleParameterBinding(nameof(combineModelsArgs.TransformModel));
inputBindingMap.Add(nameof(combineModelsArgs.TransformModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputTransformModel);
paramBinding = new SimpleParameterBinding(nameof(combineModelsArgs.PredictorModel));
inputBindingMap.Add(nameof(combineModelsArgs.PredictorModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputPredictorModel);
outputMap = new Dictionary <string, string>();
var combineNodeOutputPredictorModel = new Var <PredictorModel>();
predModelVars[k] = combineNodeOutputPredictorModel;
outputMap.Add(nameof(ModelOperations.PredictorModelOutput.PredictorModel), combineNodeOutputPredictorModel.VarName);
EntryPointNode combineNode = EntryPointNode.Create(env, "Transforms.TwoHeterogeneousModelCombiner", combineModelsArgs,
node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(combineNode);
}
var warningVar = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.Warnings), warningVar.VarName);
warningsVars[k] = warningVar;
var overallMetric = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.OverallMetrics), overallMetric.VarName);
overallMetricsVars[k] = overallMetric;
var instanceMetric = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.PerInstanceMetrics), instanceMetric.VarName);
instanceMetricsVars[k] = instanceMetric;
var confusionMatrix = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.ConfusionMatrix), confusionMatrix.VarName);
confusionMatrixVars[k] = confusionMatrix;
const string trainTestEvaluatorMacroEntryPoint = "Models.TrainTestEvaluator";
subGraphNodes.Add(EntryPointNode.Create(env, trainTestEvaluatorMacroEntryPoint, args, node.Context, inputBindingMap, inputMap, outputMap));
}
// Convert the predictor models to an array of predictor models.
MacroUtils.ConvertIPredictorModelsToArray(env, node.Context, subGraphNodes, predModelVars, node.GetOutputVariableName(nameof(Output.PredictorModel)));
// Convert the warnings, overall, per instance and confusion matrix data views into an array.
var warningsArrayVar = new ArrayVar <IDataView>();
var overallArrayVar = new ArrayVar <IDataView>();
var instanceArrayVar = new ArrayVar <IDataView>();
ArrayVar <IDataView> confusionMatrixArrayVar = null;
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, warningsVars, warningsArrayVar.VarName);
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, overallMetricsVars, overallArrayVar.VarName);
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, instanceMetricsVars, instanceArrayVar.VarName);
if (input.Kind == MacroUtils.TrainerKinds.SignatureBinaryClassifierTrainer ||
input.Kind == MacroUtils.TrainerKinds.SignatureMultiClassClassifierTrainer)
{
confusionMatrixArrayVar = new ArrayVar <IDataView>();
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, confusionMatrixVars, confusionMatrixArrayVar.VarName);
}
var combineArgs = new CombineMetricsInput();
combineArgs.Kind = input.Kind;
combineArgs.LabelColumn = input.LabelColumn;
combineArgs.WeightColumn = input.WeightColumn;
combineArgs.GroupColumn = input.GroupColumn;
combineArgs.NameColumn = input.NameColumn;
// Set the input bindings for the CombineMetrics entry point.
var combineInputBindingMap = new Dictionary <string, List <ParameterBinding> >();
var combineInputMap = new Dictionary <ParameterBinding, VariableBinding>();
var warningsArray = new SimpleParameterBinding(nameof(combineArgs.Warnings));
combineInputBindingMap.Add(nameof(combineArgs.Warnings), new List <ParameterBinding> {
warningsArray
});
combineInputMap.Add(warningsArray, new SimpleVariableBinding(warningsArrayVar.VarName));
var overallArray = new SimpleParameterBinding(nameof(combineArgs.OverallMetrics));
combineInputBindingMap.Add(nameof(combineArgs.OverallMetrics), new List <ParameterBinding> {
overallArray
});
combineInputMap.Add(overallArray, new SimpleVariableBinding(overallArrayVar.VarName));
var combinePerInstArray = new SimpleParameterBinding(nameof(combineArgs.PerInstanceMetrics));
combineInputBindingMap.Add(nameof(combineArgs.PerInstanceMetrics), new List <ParameterBinding> {
combinePerInstArray
});
combineInputMap.Add(combinePerInstArray, new SimpleVariableBinding(instanceArrayVar.VarName));
if (confusionMatrixArrayVar != null)
{
var combineConfArray = new SimpleParameterBinding(nameof(combineArgs.ConfusionMatrix));
combineInputBindingMap.Add(nameof(combineArgs.ConfusionMatrix), new List <ParameterBinding> {
combineConfArray
});
combineInputMap.Add(combineConfArray, new SimpleVariableBinding(confusionMatrixArrayVar.VarName));
}
var combineOutputMap = new Dictionary <string, string>();
var combineWarningVar = new Var <IDataView>();
combineWarningVar.VarName = node.GetOutputVariableName(nameof(Output.Warnings));
combineOutputMap.Add(nameof(Output.Warnings), combineWarningVar.VarName);
var combineOverallMetric = new Var <IDataView>();
combineOverallMetric.VarName = node.GetOutputVariableName(nameof(Output.OverallMetrics));
combineOutputMap.Add(nameof(Output.OverallMetrics), combineOverallMetric.VarName);
var combineInstanceMetric = new Var <IDataView>();
combineInstanceMetric.VarName = node.GetOutputVariableName(nameof(Output.PerInstanceMetrics));
combineOutputMap.Add(nameof(Output.PerInstanceMetrics), combineInstanceMetric.VarName);
if (confusionMatrixArrayVar != null)
{
var combineConfusionMatrix = new Var <IDataView>();
combineConfusionMatrix.VarName = node.GetOutputVariableName(nameof(Output.ConfusionMatrix));
combineOutputMap.Add(nameof(TrainTestMacro.Output.ConfusionMatrix), combineConfusionMatrix.VarName);
}
var combineMetricsNode = EntryPointNode.Create(env, "Models.CrossValidationResultsCombiner",
combineArgs, node.Context, combineInputBindingMap, combineInputMap, combineOutputMap);
subGraphNodes.Add(combineMetricsNode);
return(new CommonOutputs.MacroOutput <Output>()
{
Nodes = subGraphNodes
});
}
public Vector3BindingView(VariableBinding variable)
: base(variable)
{
}
