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) { }