public NsmStdDevsMutator(ExperimentParameters experimentParameters) { GlobalLearningRate = experimentParameters.GlobalLearningRate; IndividualLearningRate = experimentParameters.IndividualLearningRate; StepThreshold = experimentParameters.StepThreshold; _randomGenerator = MersenneTwister.Instance; }
public Engine(ExperimentParameters experimentParameters, IBenchmark benchmark, ConstraintsBuilderBase constraintsBuilder, IProcessor <Point[]> pointsNormalizer, IProcessor <Constraint[]> redundantConstraintsRemover, IAngleCalculator meanAngleCalculator, Stopwatch stoper) { Parameters = experimentParameters; Benchmark = benchmark; _constraintsBuilder = constraintsBuilder; _redundantConstraintsRemover = redundantConstraintsRemover; _stoper = stoper; _meanAngleCalculator = meanAngleCalculator; _pointsNormalizer = pointsNormalizer; Statistics = new Statistics(); EvolutionSteps = new List <IList <Constraint> >(); NormalizedEvolutionSteps = new List <IList <Constraint> >(); MersenneTwister.Initialize(experimentParameters.Seed); //var normalDis = new NormalDistribution(); //const int count = int.MaxValue / 1000; //var values = new double[count]; //////var sum = 0.0; //for (int i = 0; i < count; i++) //{ // values[i] = MersenneTwister.Instance.NextGaussian(); //} ////values = normalDis.Generate(count); //var mean = values.Mean(); //var stdDev = values.StandardDeviation(); }
public static string GetFileName(this ExperimentParameters experimentParameters, string prefix = null, string extension = null) { var sb = new StringBuilder(); if (prefix != null) { sb.Append(prefix).Append("_"); } sb.Append(experimentParameters.TypeOfBenchmark).Append("_"); sb.Append(experimentParameters.Seed).Append("_"); sb.Append(experimentParameters.NumberOfDimensions).Append("_"); sb.Append(experimentParameters.EvolutionParameters.NumberOfGenerations).Append("_"); sb.Append(experimentParameters.EvolutionParameters.OffspringPopulationSize).Append("_"); sb.Append(experimentParameters.NumberOfPositivePoints).Append("_"); sb.Append(experimentParameters.NumberOfNegativePoints).Append("_"); sb.Append(experimentParameters.AllowQuadraticTerms).Append("_"); sb.Append(experimentParameters.UseDataNormalization).Append("_"); sb.Append(experimentParameters.UseSeeding); if (extension != null) { sb.Append(extension); } return(sb.ToString()); }
public CubenBenchmark(ExperimentParameters experimentParameters, ITermsFactory termsFactory) { var numberOfDimensions = experimentParameters.NumberOfDimensions; var cubenBoundaryValue = experimentParameters.CubenBoundaryValue; var constraints = new List <Constraint>(numberOfDimensions * 2); Domains = new Domain[numberOfDimensions]; for (var i = 0; i < numberOfDimensions; i++) { var value = i + 1; var terms1 = new Term[numberOfDimensions]; var terms2 = new Term[numberOfDimensions]; for (var j = 0; j < numberOfDimensions; j++) { terms1[j] = termsFactory.Create((int)TermType.Linear, 0); terms2[j] = termsFactory.Create((int)TermType.Linear, 0); } terms1[i].Coefficient = -1; terms2[i].Coefficient = 1; constraints.Add(new LinearConstraint(terms1, -value)); constraints.Add(new LinearConstraint(terms2, value + value * cubenBoundaryValue)); Domains[i] = new Domain(value - value * cubenBoundaryValue, value + 2 * value * cubenBoundaryValue); } Constraints = constraints.ToArray(); }
public static string ToConsoleArgumentsString(this ExperimentParameters experimentParameters) { var sb = new StringBuilder(); var propertyInfos = GetDbSerializableProperties(experimentParameters).ToList(); foreach (var pi in propertyInfos) { var valueToPrint = pi.GetValue(experimentParameters, null); if (pi.PropertyType.IsEnum) { valueToPrint = Enum.GetName(pi.PropertyType, valueToPrint); } sb.Append($"{pi.Name}={valueToPrint} "); } propertyInfos = GetDbSerializableProperties(experimentParameters.EvolutionParameters).ToList(); foreach (var pi in propertyInfos) { var valueToPrint = pi.GetValue(experimentParameters.EvolutionParameters, null); if (pi.PropertyType.IsEnum) { valueToPrint = Enum.GetName(pi.PropertyType, valueToPrint); } sb.Append($"{pi.Name}={valueToPrint} "); } return(sb.ToString()); }
public Solution[] GeneratePopulation(ExperimentParameters experimentParameters) { var basePopulationSize = experimentParameters.BasePopulationSize; var population = new Solution[basePopulationSize]; for (var i = 0; i < basePopulationSize; i++) { population[i] = new Solution(experimentParameters); var lenght = population[i].ObjectCoefficients.Length; for (var j = 0; j < lenght; j++) { population[i].ObjectCoefficients[j] = _randomGenerator.NextDouble(); population[i].StdDeviationsCoefficients[j] = _randomGenerator.NextDoublePositive(); } lenght = population[i].RotationsCoefficients.Length; for (var j = 0; j < lenght; j++) { population[i].RotationsCoefficients[j] = _randomGenerator.NextDoublePositive(); } } return(population); }
public async Task <IActionResult> Edit(int id, [Bind("Id,ShowTitle,ShowTimer, AddComment")] ExperimentParameters experimentParameters) { if (id != experimentParameters.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(experimentParameters); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ExperimentParametersExists(experimentParameters.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(experimentParameters)); }
public BallnBenchmark(ExperimentParameters experimentParameters, ITermsFactory termsFactory) { var numberOfDimensions = experimentParameters.NumberOfDimensions; var ballnBoundaryValue = experimentParameters.BallnBoundaryValue; var numberOfTerms = numberOfDimensions * 2; var terms = new Term[numberOfTerms]; var limitingValue = ballnBoundaryValue * ballnBoundaryValue; Constraints = new Constraint[1]; Domains = new Domain[numberOfDimensions]; for (var i = 0; i < numberOfDimensions; i++) { var value = i + 1; terms[i] = termsFactory.Create((int)TermType.Quadratic, 1); Domains[i] = new Domain(value - 2 * ballnBoundaryValue, value + 2 * ballnBoundaryValue); //HACK TODO //Domains[i] = new Domain(value - 2 * ballnBoundaryValue + 100, value + 2 * ballnBoundaryValue + 100); // limitingValue -= value * value; } for (var i = numberOfDimensions; i < numberOfTerms; i++) { var value = i + 1 - numberOfDimensions; terms[i] = termsFactory.Create((int)TermType.Linear, -2 * value); } Constraints[0] = new QuadraticConstraint(terms, limitingValue); }
public Evaluator(ExperimentParameters experimentParameters, Point[] positivePoints) { ExperimentParameters = experimentParameters; PositivePoints = positivePoints; NumberOfConstraints = experimentParameters.NumberOfConstraints; NumberOfConstraintCoefficients = experimentParameters.NumberOfDimensions + 1; }
public bool HasTables(ExperimentParameters experimentParameters) { var controlQuery = $"SELECT name FROM sqlite_master WHERE name = '{VersionsTableName}'"; var result = _databaseEngine.PrepareStatement(controlQuery).ExecuteReader(); return(result.HasRows); }
/// <summary> /// The map evaluator constructor. /// </summary> /// <param name="experimentParameters">The experiment definition and control parameters.</param> /// <param name="agentInputNeuronCount">The number of input neurons in the agent neural controller.</param> /// <param name="agentOutputNeuronCount">The number of output neurons in the agent neural controller.</param> public MapEvaluator(ExperimentParameters experimentParameters, int agentInputNeuronCount, int agentOutputNeuronCount) { // Create the NEAT genome (agent) decoder - acyclic activation is always used _agentDecoder = new NeatGenomeDecoder(CreateActivationScheme(experimentParameters.ActivationScheme, experimentParameters.ActivationIters, experimentParameters.ActivationDeltaThreshold)); // Create the maze decoder _mazeDecoder = new MazeDecoder(experimentParameters.MazeScaleMultiplier); // Initialize evaluation units EvaluationUnits = new List <MazeNavigatorEvaluationUnit>(); // Create maze factory with default dimensions (NEAT factory will be set later based on structure of first // genome encountered) _mazeGenomeFactory = new MazeGenomeFactory(experimentParameters.MazeHeight, experimentParameters.MazeWidth, experimentParameters.MazeQuadrantHeight, experimentParameters.MazeQuadrantWidth); _neatGenomeFactory = new NeatGenomeFactory(agentInputNeuronCount, agentOutputNeuronCount); // Set experiment parameters _experimentParameters = experimentParameters; // Create new agent ID list and maze ID/structure map _agentGenomeIds = new List <int>(); _mazeIdStructureMap = new Dictionary <int, MazeStructure>(); }
public static string GetCSVString(ExperimentParameters parameters, List <DataSet> dataArchive) { string csv = ""; for (int i = 0; i < dataArchive.Count; i++) { foreach (KeyValuePair <string, double> kv in dataArchive[i].Points[0].kvPairs) { csv += kv.Key + ","; } csv = csv.Substring(0, csv.Length - 1); csv += "\n"; foreach (DataPoint p in dataArchive[i].Points) { foreach (KeyValuePair <string, double> kv in p.kvPairs) { csv += kv.Value + ","; } csv = csv.Substring(0, csv.Length - 1); csv += "\n"; } csv += "\n"; } //string csv = "{ \"params\" : " + JsonConvert.SerializeObject(parameters, Formatting.Indented); return(csv); }
static string convertData(DataSet d, ExperimentParameters parameters, int index) { string result = ""; double[] scanParameterValues = d.GetAllValuesOfKey(parameters.ScanParams.ScanParameterName); result += "data[" + (index + 1).ToString() + ", \"" + parameters.ScanParams.ScanParameterName + "\"] = {"; foreach (double val in scanParameterValues) { result += val.ToString() + ","; } result = result.Remove(result.Length - 1); //Cheezy way of removing the last comma result += "};\n"; foreach (string AIName in parameters.DAQmx.AINames) { double[] values = d.GetAllValuesOfKey(AIName); result += "data[" + (index + 1).ToString() + ", \"" + AIName + "\"] = {"; foreach (double val in values) { result += val.ToString() + ","; } result = result.Remove(result.Length - 1); //Cheezy way of removing the last comma result += "};\n"; } return(result); }
public SimplexnBenchmark(ExperimentParameters experimentParameters) { var numberOfDimensions = experimentParameters.NumberOfDimensions; var simplexnBoundaryValue = experimentParameters.SimplexnBoundaryValue; var tanPi12 = Math.Tan(Math.PI / 12); var cotPi12 = 1 / tanPi12; var constraints = new List <Constraint>(numberOfDimensions * 2 - 1); var termsCoefficients = new double[numberOfDimensions]; Domains = new Domain[numberOfDimensions]; for (var i = 0; i < numberOfDimensions - 1; i++) { Domains[i] = new Domain(-1, 2 + simplexnBoundaryValue); var termsCoefficients1 = new double[numberOfDimensions]; var termsCoefficients2 = new double[numberOfDimensions]; termsCoefficients1[i] = -cotPi12; termsCoefficients1[i + 1] = tanPi12; termsCoefficients2[i + 1] = -cotPi12; termsCoefficients2[i] = tanPi12; constraints.Add(new LinearConstraint(termsCoefficients1, 0)); constraints.Add(new LinearConstraint(termsCoefficients2, 0)); termsCoefficients[i] = 1; } termsCoefficients[numberOfDimensions - 1] = 1; Domains[numberOfDimensions - 1] = new Domain(-1, 2 + simplexnBoundaryValue); constraints.Add(new LinearConstraint(termsCoefficients, simplexnBoundaryValue)); Constraints = constraints.ToArray(); }
public async Task CreateParams([FromBody][Bind("Id,Description,ShowTitle,ShowTimer,AddComment,Timer")] ExperimentParameters experimentParameters) { if (ModelState.IsValid) { _context.Add(experimentParameters); await _context.SaveChangesAsync(); } }
public bool IsSameVersion(ExperimentParameters experimentParameters) { var implementationQuery = $"SELECT * FROM {VersionsTableName} " + $"WHERE {nameof(Version.ImplementationVersion)} = '{Version.ImplementationVersion}'"; var result = _databaseEngine.PrepareStatement(implementationQuery).ExecuteReader(); return(result.HasRows); }
public bool ExperimentShouldBePrepared(ExperimentParameters experimentParameters) { if (HasTables(experimentParameters) == false) { return(true); } if (IsSameVersion(experimentParameters) == false) { return(true); } //var experimentParametersPredicates = GetPredicates(experimentParameters, ExperimentParametersTableName); //var evolutionParametersPredicates = GetPredicates(experimentParameters.EvolutionParameters, EvolutionParametersTableName); //var getIdQuery = $"SELECT {ExperimentParametersTableName}.parent FROM {ExperimentParametersTableName} INNER JOIN {EvolutionParametersTableName} " + // $"ON {ExperimentParametersTableName}.parent = {EvolutionParametersTableName}.parent " + // $"WHERE {experimentParametersPredicates} AND {evolutionParametersPredicates}"; var experimentParametersPredicates = GetPredicates(experimentParameters, ExperimentsTableName); var evolutionParametersPredicates = GetPredicates(experimentParameters.EvolutionParameters, ExperimentsTableName); var getIdQuery = $"SELECT {ExperimentsTableName}.id FROM {ExperimentsTableName} " + $"WHERE {experimentParametersPredicates} AND {evolutionParametersPredicates}"; var id = _databaseEngine.PrepareStatement(getIdQuery).ExecuteScalar(); if (id == null) { return(true); } //var reader = _databaseEngine.PrepareStatement(getIdQuery).ExecuteReader(); //if (!reader.HasRows) // return true; try { //var errorQuery = $"SELECT {ErrorsTableName}.{nameof(Exception.HResult)} FROM {ErrorsTableName} WHERE {ErrorsTableName}.parent = '{id}'"; var errorQuery = $"SELECT {ExperimentsTableName}.{nameof(Exception.HResult)} FROM {ExperimentsTableName}"; var result = _databaseEngine.PrepareStatement(errorQuery).ExecuteScalar(); if (result == null) { return(false); } var hasError = string.IsNullOrEmpty(result.ToString()) == false; return(hasError); } catch (Exception exception) { return(!exception.Message.Contains("no such column")); } }
private static void SaveSingleScript(ExperimentParameters experimentParameters) { var arguments = experimentParameters.ToConsoleArgumentsString(); var filename = experimentParameters.GetFileName(extension: ".sh"); var singleScriptPath = Path.GetFullPath(ScriptsDirPath + filename); ScriptsFullPaths.Add(singleScriptPath); File.WriteAllText(singleScriptPath, ExperimentScriptContent(arguments)); }
private static IEnumerable <string> GetParametersCellsContent(ExperimentParameters experimentParameters) { yield return($"{experimentParameters.EvolutionParameters.OffspringPopulationSize,4}"); yield return($"{experimentParameters.EvolutionParameters.NumberOfGenerations,4}"); yield return(experimentParameters.UseSeeding ? @"\cm" : " "); yield return(experimentParameters.UseDataNormalization ? @"\cm" : " "); }
protected override void runIncluded(ExperimentParameters parameters) { if (parameters.IsFirstRun) { parameters.TutorialManager.ActivateScreen <Experiment99Screen>(); ExperimentHacks.RemoveEmptyStateFirstLine(this, parameters); } Toggl.OnUserTimeEntryStart += this.sendStartAction; }
public void Run(ExperimentParameters parameters) { if (parameters.Included) { this.runIncluded(parameters); } else { this.runExcluded(parameters); } }
public static string GetJSONString(ExperimentParameters parameters, List <DataSet> dataArchive) { string jsontext = "{ \"params\" : " + JsonConvert.SerializeObject(parameters, Formatting.Indented); for (int i = 0; i < dataArchive.Count; i++) { jsontext += ", \"data_" + i.ToString() + "\": " + dataArchive[i].ToJson(Formatting.Indented); } jsontext += "}"; return(jsontext); }
public async Task <IActionResult> Create([Bind("Id,Description,ShowTitle,ShowTimer, AddComment")] ExperimentParameters experimentParameters) { if (ModelState.IsValid) { _context.Add(experimentParameters); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(experimentParameters)); }
public void Log(ExperimentParameters experimentParameters, bool withEvolutionParameters = true) { if (withEvolutionParameters) { Log(experimentParameters.EvolutionParameters); } _logBuilder.AppendLine("============== EXPERIMENT PARAMETERS ==============="); _logBuilder.AppendPrintable(experimentParameters); _logBuilder.AppendLine("===================================================="); }
private static string GetParamCell(ExperimentParameters experimentParameters) { var sb = new StringBuilder(); sb.Append($"{experimentParameters.EvolutionParameters.OffspringPopulationSize,4}"); sb.Append(" "); sb.Append($"{experimentParameters.EvolutionParameters.NumberOfGenerations,4}"); sb.Append(" "); sb.Append(experimentParameters.UseSeeding ? "S" : " "); sb.Append(experimentParameters.UseDataNormalization ? "N" : " "); return(sb.ToString()); }
public static string GetHashString(this ExperimentParameters experimentParameters) { var hashStringBuilder = new StringBuilder(); var propertyInfos = experimentParameters.GetDbSerializableProperties().OrderBy(pi => pi.Name); foreach (var propertyInfo in propertyInfos) { hashStringBuilder.Append(propertyInfo.GetValue(experimentParameters, null)); } return(hashStringBuilder.ToString()); }
public void Initialise(ExperimentParameters p) { parameters = p; if (p.ScanParams.AcquireDataDuringScan) { daq = new DAQmxTriggeredMultiAIHardware(); daq.ConfigureAI(parameters.DAQmx); } dds = new USBVisaDDS(parameters.DDS.DDSAddress); dds.Connect(); }
void initialiseExperimentalParameters(string jsonParams) { try { parameters = JsonConvert.DeserializeObject <ExperimentParameters>(jsonParams); } catch (JsonException e) { Clients.All.toConsole(e.Message); Clients.All.toConsole("Could not initialise hardware. Stopping."); throw new ExperimentalParametersException(); } }
public static IParentsSelector GetParentsSelector(ExperimentParameters experimentParameters) { return(new ParentsRandomSelector(experimentParameters)); //switch (experimentParameters.TypeOfSurvivorsSelection) //{ // case ExperimentParameters.SelectionType.Distinct: // return new ParentsRandomSelector(experimentParameters); ; // case ExperimentParameters.SelectionType.Union: // return new ParentsRandomUnionSelector(experimentParameters); // default: // throw new ArgumentOutOfRangeException(); //} }
public IEngine Create(ExperimentParameters experimentParameters) { var benchmarksFactory = new BenchmarksFactory(); var pointsGenerator = new PointsGenerator(); var benchmark = benchmarksFactory.Create(experimentParameters); var constraintsBuilder = new ConstraintsBuilder(benchmark.Constraints, experimentParameters); var pointsNormalizer = new StandardScorePointsNormalizer(); var redundantConstraintsRemover = new RedundantConstraintsRemover(pointsGenerator, benchmark.Domains, experimentParameters); var meanAngleCalculator = new MeanAngleCalculator(); var stoper = new Stopwatch(); return(new Core.Engine(experimentParameters, benchmark, constraintsBuilder, pointsNormalizer, redundantConstraintsRemover, meanAngleCalculator, stoper)); }
protected override void runIncluded(ExperimentParameters parameters) { parameters.TutorialManager.ActivateScreen<SimpleWelcomeScreen>(); }
protected override void runIncluded(ExperimentParameters parameters) { parameters.TutorialManager.ActivateScreen<BasicOverviewScreen>(); }
protected virtual void runExcluded(ExperimentParameters parameters) { }