public ValidationForm(MainForm mainForm) { InitializeComponent(); Validator = new MyValidator(); m_mainForm = mainForm; }
public override void Validate(MyValidator validator) { base.Validate(validator); validator.AssertError(Controls != null, this, "Controls must not be null"); if (Controls != null) validator.AssertError(Controls.Count >= 3, this, "Size of Control input must be 3 or more"); }
public ValidationForm(MainForm mainForm, MyValidator validator) { InitializeComponent(); Validator = validator; m_mainForm = mainForm; }
public MyLocalSimulation(MyValidator validator, IMyExecutionPlanner executionPlanner) : base(validator) { m_threadPool = new MyThreadPool(MyKernelFactory.Instance.DevCount, InitCore, ExecutePlan); m_threadPool.StartThreads(); try { ExecutionPlanner = executionPlanner; } catch (Exception e) { m_threadPool.Finish(); throw e; } }
public override void Validate(MyValidator validator) { base.Validate(validator); if (PupilControl != null) { validator.AssertError(PupilControl.Count > 2, this, "Not enough control values (at least 3 values needed)"); validator.AssertError((PupilControl.Count % 3) == 0, this, "Wrong pupil control input size, it has to be [x,y,s] or [x,y,s;x,y,s...]"); validator.AssertError((float)PupilControl.Count / (float)PupilControl.ColumnHint != 0, this, "If input is matrix, it has to be 3 columns and N rows, each row x,y,s"); } }
public override void Validate(MyValidator validator) { ScriptCheckMethod = null; ScriptShouldStopMethod = null; CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CompilerParameters parameters = new CompilerParameters() { GenerateInMemory = false, GenerateExecutable = false, }; parameters.ReferencedAssemblies.Add("GoodAI.Platform.Core.dll"); parameters.ReferencedAssemblies.Add("System.Core.dll"); //for LINQ support parameters.ReferencedAssemblies.Add("System.Runtime.dll"); //for LINQ support // TODO: load the xunit dll in Brain Simulator UI from the module directory. parameters.ReferencedAssemblies.Add("xunit.assert.dll"); parameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location); //Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); //IEnumerable<Assembly> openTKAssemblies = loadedAssemblies.Where(x => x.ManifestModule.Name == "xunit.assert.dll"); //if (openTKAssemblies.Count() > 0) // parameters.ReferencedAssemblies.Add(openTKAssemblies.First().Location); CompilerResults results = codeProvider.CompileAssemblyFromSource(parameters, Script); if (results.Errors.HasErrors) { string message = ""; foreach (CompilerError error in results.Errors) { message += "Line " + error.Line + ": " + error.ErrorText + "\n"; } validator.AddError(this, "Errors in compiled script:\n" + message); return; } else if (results.CompiledAssembly == null) { validator.AddError(this, "Compiled assembly is null."); return; } try { Type enclosingType = results.CompiledAssembly.GetType("Runtime.Script"); ScriptCheckMethod = enclosingType.GetMethod("Check"); validator.AssertError(ScriptCheckMethod != null, this, "Check() method not found in compiled script"); ScriptShouldStopMethod = enclosingType.GetMethod("ShouldStop"); // optional, don't check for null } catch (Exception e) { validator.AddError(this, "Script analysis failed: " + e.GetType().Name + ": " + e.Message); } }
public override void Validate(MyValidator validator) { base.Validate(validator); if (ControlsB != null) { validator.AssertError(ControlsB.Count >= 3, this, "Not enough controls (3 expected)"); } }
public override void Validate(MyValidator validator) { //MyLog.INFO.WriteLine("In.c = " + Input.Count + " "+ (Input.Count != 9)); //MyLog.INFO.WriteLine("Out.c = " + Action.Count + " " + (+Action.Count != 9)); base.Validate(validator); // validator.AssertWarning(XInput.Count == 1 && YInput.Count == 1, this, "Both inputs should have size 1. Only first value will be considered."); validator.AssertError(EnvironmentData==null || EnvironmentData.Count == 10 ,this, "EnvironmentData input has to have size 10."); var explore_rate = this.InitialExploration; var exploration_decay = this.ExplorationDecay; validator.AssertError(!(explore_rate < 0.0 || explore_rate > 1.0 || exploration_decay < 0.0 || exploration_decay > 1.0), this, "exploration parameters have to be in [0,1]"); }
//Validation rules public override void Validate(MyValidator validator) { validator.AssertError((InputHeight - FilterHeight + 2 * ZeroPadding) % VerticalStride == 0, this, "Filter doesn't fit vertically when striding."); validator.AssertError((InputWidth - FilterWidth + 2 * ZeroPadding) % HorizontalStride == 0, this, "Filter doesn't fit horizontally when striding."); validator.AssertInfo(ZeroPadding == (FilterWidth - 1) / 2 && ZeroPadding == (FilterHeight - 1) / 2, this, "Input and output might not have the same dimension. Set stride to 1 and zero padding to ((FilterSize - 1) / 2) to fix this."); }
public override void Validate(MyValidator validator) { validator.AssertError(Controls != null, this, "No controls available"); validator.AssertError(File.Exists(SaveFile), this, "Please specify a correct SaveFile path in world properties."); validator.AssertError(File.Exists(TilesetTable), this, "Please specify a correct TilesetTable path in world properties."); validator.AssertError(FoFSize > 0, this, "FoF size has to be positive."); validator.AssertError(FoFResWidth > 0, this, "FoF resolution width has to be positive."); validator.AssertError(FoFResHeight > 0, this, "FoF resolution height has to be positive."); validator.AssertError(FoVSize > 0, this, "FoV size has to be positive."); validator.AssertError(FoVResWidth > 0, this, "FoV resolution width has to be positive."); validator.AssertError(FoVResHeight > 0, this, "FoV resolution height has to be positive."); validator.AssertError(Width > 0, this, "Free view width has to be positive."); validator.AssertError(Height > 0, this, "Free view height has to be positive."); validator.AssertError(ResolutionWidth > 0, this, "Free view resolution width has to be positive."); validator.AssertError(ResolutionHeight > 0, this, "Free view resolution height has to be positive."); validator.AssertError(ToolSize > 0, this, "Tool size has to be positive."); validator.AssertError(ToolResWidth > 0, this, "Tool resolution width has to be positive."); validator.AssertError(ToolResHeight > 0, this, "Tool resolution height has to be positive."); ControlMapper.CheckControlSize(validator, Controls, this); TryToyWorld(); foreach (TWLogMessage message in TWLog.GetAllLogMessages()) switch (message.Severity) { case TWSeverity.Error: { validator.AssertError(false, this, message.ToString()); break; } case TWSeverity.Warn: { validator.AssertWarning(false, this, message.ToString()); break; } } }
public override void Validate(MyValidator validator) { base.Validate(validator); if (PreviousLayer != null) { MyLog.WARNING.WriteLine("Deltas are not propagated backwards from LSTM layer!"); } }
public override void Validate(MyValidator validator) { base.Validate(validator); if (!ParamsChanged) { validator.AssertError(Layers.Count > 0, this, "The network has no layers."); validator.AssertError(DataInput != null, this, "No input available."); if (DataInput != null) { validator.AssertError(DataInput.Count > 0, this, "Input connected but empty."); validator.AssertWarning(DataInput.ColumnHint > 1, this, "The Data input columnHint is 1."); uint total = InputWidth * InputHeight * InputsCount * ForwardSamplesPerStep; validator.AssertError(DataInput.Count == total, this, "DataInput Count is " + DataInput.Count + ". Expected " + InputLayer.Output.ToString() + " = " + total + "."); } validator.AssertError(TrainingData != null, this, "No TrainingData available."); if (TrainingData != null) { validator.AssertError(TrainingData.Count > 0, this, "TrainingData connected but empty."); validator.AssertWarning(TrainingData.ColumnHint > 1, this, "TrainingData columnHint is 1."); uint total = InputWidth * InputHeight * InputsCount * TrainingSamplesPerStep; validator.AssertError(TrainingData.Count == total, this, "TrainingData Count is " + TrainingData.Count + ". Expected " + InputLayer.Output.ToString() + " = " + total + "."); } validator.AssertError(TrainingLabel != null, this, "No TrainingLabel available."); validator.AssertError(LastLayer != null, this, "Last layer is null."); if (TrainingLabel != null && LastLayer != null) validator.AssertError(TrainingLabel.Count == LastLayer.Output.Count * TrainingSamplesPerStep, this, "Current label dimension is " + TrainingLabel.Count + ". Expected " + TrainingSamplesPerStep + "x" + LastLayer.Output.Count + "."); } }
public override void Validate(MyValidator validator) { //base.Validate(validator); validator.AssertError(Neurons > 0, this, "Number of neurons should be > 0"); validator.AssertError(Input != null, this, "Neural network node \"" + this.Name + "\" has no input."); validator.AssertWarning(Connection != ConnectionType.NOT_SET, this, "ConnectionType not set for " + this); }
public override void Validate(MyValidator validator) { base.Validate(validator); if (!ParamsChanged) { validator.AssertError(Layers.Count > 0, this, "The network has no layers."); if (AutoencoderTask.NetworkMode != MyAutoencoderMode.FEATURE_DECODING) { validator.AssertError(DataInput != null, this, "No input available."); if (DataInput != null) { validator.AssertError(DataInput.Count > 0, this, "Input connected but empty."); validator.AssertWarning(DataInput.ColumnHint > 1, this, "The Data input columnHint is 1."); uint total = InputWidth * InputHeight * InputsCount * ForwardSamplesPerStep; validator.AssertError(DataInput.Count == total, this, "DataInput Count is " + DataInput.Count + ". Expected " + InputLayer.Output.ToString() + " = " + total + "."); } } if (AutoencoderTask.NetworkMode == MyAutoencoderMode.TRAINING) { validator.AssertError(LastLayer != null, this, "Last layer is null."); } if (AutoencoderTask.NetworkMode == MyAutoencoderMode.FEATURE_ENCODING || AutoencoderTask.NetworkMode == MyAutoencoderMode.FEATURE_DECODING) { validator.AssertError(FeatureLayer != null, this, "In FEATURE_ENCODING or FEATURE_DECODING mode, a featureLayer must be present in the network architecture"); } if (AutoencoderTask.NetworkMode == MyAutoencoderMode.FEATURE_ENCODING) { if (FeatureOutput != null && FeatureLayer != null) validator.AssertError(FeatureOutput.Count == FeatureLayer.Output.Count * ForwardSamplesPerStep, this, "In FEATURE_DECODING mode, the Feature output must have the same size (currently " + FeatureOutput.Count + ") as the featureLayer output (" + FeatureLayer.Output.Count + " x " + ForwardSamplesPerStep + ")"); } if (AutoencoderTask.NetworkMode == MyAutoencoderMode.FEATURE_DECODING) { validator.AssertError(FeatureInput != null, this, "In FEATURE_DECODING mode, the Feature input must be connected"); if (FeatureInput != null && FeatureLayer != null) validator.AssertError(FeatureInput.Count == FeatureLayer.Output.Count * ForwardSamplesPerStep, this, "In FEATURE_DECODING mode, the Feature input must have the same size (currently " + FeatureInput.Count + ") as the featureLayer output (" + FeatureLayer.Output.Count + " x " + ForwardSamplesPerStep + ")"); } } }
public override void Validate(MyValidator validator) { base.Validate(validator); validator.AssertError(Target != null, this, "Target not defiend"); }
public override void Validate(MyValidator validator) { base.Validate(validator); validator.AssertError(Input.Count != 0, this, "Zero input size is not allowed."); base.Validate(validator); validator.AssertError(Reward.Count != 0, this, "Zero reward size is not allowed."); }
public MyCsvFileWriterNodeTests() { m_validator = TypeMap.GetInstance<MyValidator>(); }
public static void CheckControlSize(MyValidator validator, MyAbstractMemoryBlock controls, MyWorkingNode sender) { validator.AssertError(controls != null, sender, "Controls are not connected"); if (controls != null) { int neededControls = NrOfControls; int providedControls = controls.Count; validator.AssertError(providedControls >= neededControls, sender, String.Format("Wrong number of actions. With current control mode ({0}) you have to provide at least {1} controls. Provide the correct number of controls or change the control mode.", Mode, neededControls)); validator.AssertWarning(providedControls != neededControls, sender, String.Format("With current control mode ({0}) you should provide {1} controls but you provided {2} controls. Make sure that this is what you want and you have correct control mode chosen.", Mode, neededControls, providedControls)); } }
public override void Validate(MyValidator validator) { base.Validate(validator); if (ParentNetwork == null) { validator.AddError(this, "LSTM layer needs to be in a neural network group"); } }
public override void Validate(MyValidator validator) { validator.AssertError(Input.Count % 2 == 0, this, "Number of neurons in previous layer has to be even (two params mu, sigma)."); }
public override void Validate(MyValidator validator) { base.Validate(validator); // commented out, so we don't explicitly need a target input validator.AssertError(Input != null, this, "No input available"); validator.AssertError(Input.Count == Output.Count, this, "Input size must be equal to output size."); }
//Validation rules public override void Validate(MyValidator validator) { base.Validate(validator); if (QLearning.Enabled) { validator.AssertError(Action.Count == Neurons, this, "Number of neurons need to correspond with number of actions (action size)"); validator.AssertError(Reward.Count == 1, this, "Reward needs to be a single floating point number (cannot be an array)"); } else if (QLearningBatch.Enabled) { validator.AssertError(ParentNetwork.BatchSize >= 3, this, "BatchSize needs to be >= 3"); validator.AssertError(Reward.Count == (ParentNetwork.BatchSize - 1) / 2, this, "Reward size must be equal to (BatchSize - 1) / 2"); validator.AssertError(Action.Count == (ParentNetwork.BatchSize - 1) / 2 * Actions, this, "Action size must be equal to (BatchSize - 1) / 2 * Actions"); } }
//Validation rules public override void Validate(MyValidator validator) { base.Validate(validator); validator.AssertError(Action.Count == Neurons, this, "Number of neurons need to correspond with number of actions (action size)"); validator.AssertError(Reward.Count == 1, this, "Reward needs to be a single floating point number (cannot be an array)"); }
public MySimulation(MyValidator validator) { AutoSaveInterval = 0; GlobalDataFolder = String.Empty; Validator = validator; validator.Simulation = this; }
public override void Validate(MyValidator validator) { base.Validate(validator); }
public override void Validate(MyValidator validator) { base.Validate(validator); List<IMyExecutable> tasks = GetTasks(this); validator.AssertError(tasks.Find(task => task is IMyForwardTask) != null, this, "You need to have at least one forward task"); if (BatchSize > 1) { foreach (MyNode n in Children) { var layer = n as MyAbstractLayer; if (layer != null && !layer.SupportsBatchLearning) { validator.AssertError(false, layer, layer.Name + " does not support batch learning! Remove the layer or set BatchSize to 1."); } } } }
public override void Validate(MyValidator validator) { // base.Validate(validator); validator.AssertError(Neurons > 0, this, "Number of neurons should be > 0"); validator.AssertWarning(Connection != ConnectionType.NOT_SET, this, "ConnectionType not set for " + this); }
public override void Validate(MyValidator validator) { base.Validate(validator); if (validator.ValidationSucessfull) { // all inputs have equal size (so take first and check others) for (int i = 1, size = GetInputSize(0); i < InputBranches; i++) { validator.AssertError(size == GetInputSize(i), this, "All inputs must be the same size"); } validator.AssertError(InputBranches >= 2, this, "At least one target and one input have to be set"); } }
public override void Validate(MyValidator validator) { validator.AssertError(Fitness != null, this, "Requires fitness input."); validator.AssertError(SwitchMember != null, this, "There must be a signal to change tested members. Otherwise infinite loops will occur."); }
//Validation rules public override void Validate(MyValidator validator) { base.Validate(validator); if (PreviousLayer != null) validator.AssertError(InputWidth * InputHeight * Depth == PreviousLayer.Neurons, this, "'Input width * input height * depth' must be equal to output size of the previous layer."); validator.AssertError((InputWidth - FilterWidth) % HorizontalStride == 0, this, "Filter does not fit the input image horizontally when striding."); // horizontal input check: validator.AssertError((InputHeight - FilterHeight) % VerticalStride == 0, this, "Filter does not fit the input image vertically when striding."); // vertical input check: validator.AssertError(InputHeight > FilterHeight && InputWidth > FilterWidth, this, "Filter dimensions must be smaller than input dimensions."); }