Beispiel #1
0
 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();
        }
Beispiel #3
0
        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());
        }
Beispiel #4
0
        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();
        }
Beispiel #5
0
        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);
        }
Beispiel #9
0
 public Evaluator(ExperimentParameters experimentParameters, Point[] positivePoints)
 {
     ExperimentParameters           = experimentParameters;
     PositivePoints                 = positivePoints;
     NumberOfConstraints            = experimentParameters.NumberOfConstraints;
     NumberOfConstraintCoefficients = experimentParameters.NumberOfDimensions + 1;
 }
Beispiel #10
0
        public bool HasTables(ExperimentParameters experimentParameters)
        {
            var controlQuery = $"SELECT name FROM sqlite_master WHERE name = '{VersionsTableName}'";
            var result       = _databaseEngine.PrepareStatement(controlQuery).ExecuteReader();

            return(result.HasRows);
        }
Beispiel #11
0
        /// <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);
        }
Beispiel #13
0
        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();
     }
 }
Beispiel #16
0
        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);
        }
Beispiel #17
0
        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"));
            }
        }
Beispiel #18
0
        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" : "   ");
        }
Beispiel #20
0
        protected override void runIncluded(ExperimentParameters parameters)
        {
            if (parameters.IsFirstRun)
            {
                parameters.TutorialManager.ActivateScreen <Experiment99Screen>();
                ExperimentHacks.RemoveEmptyStateFirstLine(this, parameters);
            }

            Toggl.OnUserTimeEntryStart += this.sendStartAction;
        }
Beispiel #21
0
 public void Run(ExperimentParameters parameters)
 {
     if (parameters.Included)
     {
         this.runIncluded(parameters);
     }
     else
     {
         this.runExcluded(parameters);
     }
 }
Beispiel #22
0
        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 void Run(ExperimentParameters parameters)
 {
     if (parameters.Included)
     {
         this.runIncluded(parameters);
     }
     else
     {
         this.runExcluded(parameters);
     }
 }
        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));
        }
Beispiel #25
0
        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());
        }
Beispiel #27
0
        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>();
 }
Beispiel #34
0
 protected virtual void runExcluded(ExperimentParameters parameters) { }