private FilterDefinition <Request> RequestFilter(string age, string size, string specie, string filter) { var query = Builders <Request> .Filter.Empty; if (!string.IsNullOrEmpty(age)) { Age enumAge = (Age)Enum.Parse(typeof(Age), age); query = query & Builders <Request> .Filter.ElemMatch(r => r.Pets, p => p.Age == enumAge); } if (!string.IsNullOrEmpty(size)) { Size enumSize = (Size)Enum.Parse(typeof(Size), size); query = query & Builders <Request> .Filter.ElemMatch(r => r.Pets, p => p.Size == enumSize); } if (!string.IsNullOrEmpty(specie)) { Specie enumSpecie = (Specie)Enum.Parse(typeof(Specie), specie); query = query & Builders <Request> .Filter.ElemMatch(r => r.Pets, p => p.Specie == enumSpecie); } if (!string.IsNullOrEmpty(filter)) { query = query & Builders <Request> .Filter.Regex(r => r.Location.City, new BsonRegularExpression(filter, "i")) | Builders <Request> .Filter.Regex(x => x.Location.Street, new BsonRegularExpression(filter, "i")) | Builders <Request> .Filter.Regex(x => x.Location.PostCode, new BsonRegularExpression(filter, "i")) | Builders <Request> .Filter.ElemMatch(r => r.Pets, Builders <Pet> .Filter.Regex(p => p.Name, new BsonRegularExpression(filter, "i"))); } return(query); }
public void CreateInitialGeneration() { var s = new Specie(2, 10, 0u, new IntegerChromosome(0, 1)); s.CreateInitialGeneration(); Assert.AreEqual(10, s.CurrentGeneration.Chromosomes.Count); }
public async Task <IActionResult> addPhotos(int id, List <string> descripciones, List <IFormFile> archivos) { string filePath; Task result = null; Specie especie = _SpecieRepository.Get(id); for (int i = 1; i < (archivos.Count + 1); i++) { Photo photo = new Photo(); photo.Description = descripciones[i - 1]; result = _PhotoRepository.Add(photo); _SpecieRepository.AddPhoto(especie.Id, photo); string[] extension = (archivos[i - 1].FileName).Split('.'); filePath = Path.Combine(Core.SpecieFolderPath(especie.Id.ToString()), photo.Id.ToString() + "." + extension[1]); if (archivos[i - 1].Length > 0) { using (var stream = new FileStream(filePath, FileMode.Create)) { await archivos[i - 1].CopyToAsync(stream); } } } if (result.Status == TaskStatus.RanToCompletion || result.Status == TaskStatus.Running || result.Status == TaskStatus.Created || result.Status == TaskStatus.WaitingToRun) { TempData["edicion"] = 1; } else { TempData["edicion"] = -1; } return(Redirect("/api/bpv/specie/index/")); }
/// <summary> /// Cheque si la Especie devuelta no es un null /// </summary> /// <param name="especie"></param> private void ChekIfIsNull(Specie especie) { if (especie == null) { throw new HttpException((int)System.Net.HttpStatusCode.NotFound, "Error al traer la especie"); } }
public bool AddPhoto(int specieId, Photo photo) { Specie specie = getSpecie(specieId); specie.Gallery.Add(photo); return(Update(specie.Id, specie)); }
/// <summary> /// Speciates the genomes in genomeList into the provided species. It is assumed that /// the genomeList represents all of the required genomes and that the species are currently empty. /// /// This method can be used for initialization or completely respeciating an existing genome population. /// </summary> public void SpeciateGenomes(IList <TGenome> genomeList, IList <Specie <TGenome> > specieList) { Debug.Assert(SpeciationUtils.TestEmptySpecies(specieList), "SpeciateGenomes(IList<TGenome>,IList<Species<TGenome>>) called with non-empty species"); Debug.Assert(genomeList.Count >= specieList.Count, string.Format("SpeciateGenomes(IList<TGenome>,IList<Species<TGenome>>). Specie count [{0}] is greater than genome count [{1}].", specieList.Count, genomeList.Count)); // Make a copy of genomeList and shuffle the items. List <TGenome> gList = new List <TGenome>(genomeList); Utilities.Shuffle(gList, _rng); // We evenly distribute genomes between species. // Calc how many genomes per specie. Baseline number given by integer division rounding down (by truncating fractional part). // This is guaranteed to be at least 1 because genomeCount >= specieCount. int genomeCount = genomeList.Count; int specieCount = specieList.Count; int genomesPerSpecie = genomeCount / specieCount; // Allocate genomes to species. int genomeIdx = 0; for (int i = 0; i < specieCount; i++) { Specie <TGenome> specie = specieList[i]; for (int j = 0; j < genomesPerSpecie; j++, genomeIdx++) { specie.GenomeList.Add(gList[genomeIdx]); } } // Evenly allocate any remaining genomes. for (int i = 0; i < specieCount && genomeIdx < genomeCount; i++, genomeIdx++) { specieList[i].GenomeList.Add(gList[genomeIdx]); } }
public async Task <IActionResult> Edit(int id, [Bind("Id,Description")] Specie specie) { if (id != specie.Id) { return(new NotFoundViewResult("SpecieNotFound")); } if (ModelState.IsValid) { try { await _specieRepository.UpdateAsync(specie); } catch (DbUpdateConcurrencyException) { if (!await _specieRepository.ExistAsync(specie.Id)) { return(new NotFoundViewResult("SpecieNotFound")); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(specie)); }
public Seed(string name, Specie specie) { this.name = name; this.specie = specie; daysGrown = 0; image = specie.image; }
public Models.Species.CreateBreedViewModel ToCreateBreedViewModel(Specie specie) { return(new Models.Species.CreateBreedViewModel { SpecieId = specie.Id }); }
IEnumerator createSeeds(Specie spliceToClone, float dropTime = 0.5f) { //sc.attemptSound(cloneSound); seedPacket = Instantiate(seedPrefab, transform); specieInPacket = spliceToClone; seedPacket.transform.GetChild(0).GetComponent <SpriteRenderer>().sprite = spliceToClone.image; Vector3 startPos = new Vector3(6.7f, -0.8f, 0); float goalY = -3.06f; float dropdist = goalY + 0.8f; seedPacket.transform.localPosition = startPos; yield return(new WaitForSeconds(1.0f)); for (float f = 0; f < dropTime; f += Time.deltaTime) { float pd = f / dropTime; pd *= pd; if (seedPacket != null) { seedPacket.transform.localPosition = startPos + Vector3.up * dropdist * pd; yield return(null); } } if (seedPacket != null) { seedPacket.transform.localPosition = new Vector3(6.7f, goalY, 0); } }
public Specie Recombination(Specie tata, Specie mama) { int[] potomek = new int[tata.indexes.Length]; potomek[0] = tata.indexes[0]; //search for sme val in mama arr, get index of it var val = mama.indexes[0]; int index = Array.IndexOf(tata.indexes, val); while (!Array.Exists(potomek, x => x == val)) { potomek[index] = val; val = mama.indexes[index]; index = Array.IndexOf(tata.indexes, val); } for (int i = 0; i < mama.indexes.Length; i++) { if (!Array.Exists(potomek, x => x == mama.indexes[i])) { potomek[i] = mama.indexes[i]; } } var Spec = new Specie() { indexes = potomek }; return(new Specie() { indexes = potomek }); }
public async Task <IActionResult> Create(Specie specie) { if (ModelState.IsValid) { try { await _specieRepository.CreateAsync(specie); return(RedirectToAction(nameof(Index))); } catch (DbUpdateException dbUpdateException) { if (dbUpdateException.InnerException.Message.Contains("duplicate")) { ModelState.AddModelError(string.Empty, "There are a Specie with the same name."); } else { ModelState.AddModelError(string.Empty, dbUpdateException.InnerException.Message); } } catch (Exception exception) { ModelState.AddModelError(string.Empty, exception.Message); } } return(View(specie)); }
public override void Evaluate(TrainingDatas td) { // I just realized I need the BP error function here // TODO: use proper cost function Parallel.ForEach(Species, new ParallelOptions() { MaxDegreeOfParallelism = Rng.Cores }, (Specie) => { // Loop through species Specie.Fitness = 0; for (int iTd = 0; iTd < td.Count; iTd++) { // Loop through training datas float[] pred = Specie.GetPrediction(td[iTd].Input); for (int i = 0; i < pred.Length; i++) { // Loop througo output neurons //float _cost = pred[i] && td[iTd].Target[i]; float _cost = Rng.FloatingAnd(pred[i], td[iTd].Target[i]); Specie.Fitness += _cost; } } }); }
public Population GenStartPopulation() { int[] defspecie = new int[SpecieLength]; for (int i = 0; i < defspecie.Length; i++) { defspecie[i] = i; } Specie defSpecie = new Specie() { indexes = defspecie }; _defSpecie = defSpecie; Population population = new Population(); Specie[] species = new Specie[0]; for (int i = 0; i < _popVolume; i++) //wypelniamy populacje startową { int[] locForSpecie = ShuffleSpecie(r, defSpecie); Specie specie = new Specie() { indexes = locForSpecie }; Array.Resize(ref species, species.Length + 1); // korzystamy tylko z System; species[species.Length - 1] = specie; } population.species = species; return(population); }
public async Task <IActionResult> PutSpecie(string id, Specie specie) { if (string.IsNullOrEmpty(specie.SpecieName) ) { return(BadRequest("SpecieName IS required.")); } if (id != specie.SpecieName) { return(BadRequest()); } specie.SpecieName = System.Net.WebUtility.HtmlEncode(specie.SpecieName); _context.Entry(specie).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!SpecieExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public static string[] Statistics(int bestListLenght, int bestSpecieLenght) { SortMembers(); Specie.Sort(); List <string> stats = new List <string>(); stats.Add("NeuroEvolution version no 1, Edited at 07.08.20201"); stats.Add("----------------------------------------------------------------------------------"); stats.Add("Notes"); stats.AddRange(notes); stats.Add("----------------------------------------------------------------------------------"); stats.Add("Member count :" + members.Count); stats.Add("Active specie count :" + Specie.species.Count); stats.Add("----------------------------------------------------------------------------------"); stats.Add("Best " + bestListLenght + " agents :"); for (int i = 0; i < bestListLenght && i < members.Count; i++) { stats.Add(members[i].specie.inovation + " specie's " + members[i].ID + " fitness :" + members[i].fitness); } stats.Add("----------------------------------------------------------------------------------"); stats.Add("Biggest " + bestSpecieLenght + " species :"); for (int i = 0; i < bestSpecieLenght && i < Specie.species.Count; i++) { stats.Add("Specie " + Specie.species[i].inovation + " with member size of :" + Specie.species[i].members.Count); } return(stats.ToArray()); }
// GET: Species/Edit/5 public ActionResult Edit(long?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Specie s = db.Species.Find(id); if (s == null) { return(HttpNotFound()); } SpecieViewModel vm = new SpecieViewModel(); vm.SpecieId = s.SpecieId; vm.ShortName = s.ShortName; vm.BaseTemperature = s.BaseTemperature; vm.StressTemperature = s.StressTemperature; vm.SpecieType = s.SpecieType; vm.RegionId = s.RegionId; vm.SpecieCycleId = s.SpecieCycleId; vm.Regions = this.LoadRegion(s.RegionId, s); vm.SpecieCycles = this.LoadSpecieCycles(s.SpecieCycleId, s); return(View("~/Views/Agriculture/Species/Edit.cshtml", vm)); }
public void TestCreatePetCase2_Fail_exits() {// Arrange var pet = new Pet { id = 2, memberId = 1, name = "oneDog", specieId = 1, }; var specie = new Specie { id = 1, name = "dog" }; // mockPetRepo.Setup(e => e.GetById(1)).Returns(pet); mockPetRepo.Setup(e => e.GetByMemberIDAndNameAndSpecie(1, "oneDog", 1)).Returns(pet); mockSpecieRepo.Setup(e => e.GetById(1)).Returns(specie); var controllerUnderTest = new MemberController(mockAppRepo.Object, mockMemRepo.Object, mockPetRepo.Object, mockSpecieRepo.Object, mockVCRepo.Object, mockTimeSlotRepo.Object, mockAppTimeRepo.Object, mockServiceRepo.Object); // Act var message = controllerUnderTest.CreatePet(1, 1, "oneDog") as JsonResult; var result = message.Data.ToString(); // Assert Assert.AreEqual("{ Result = Fail, The member already have dog name oneDog }", result); }
public async Task <Result> DeleteSpecie(int id) { try { Specie entity = await _specieRepository.GetById(id); if (entity == null) { return(new Result { Success = false, ErrorCode = ErrorCode.NotFound, }); } return(await _specieRepository.Delete(entity)); } catch (Exception ex) { _logger.LogError(ex, $"Problems with deleting Specie by id : {id}"); return(new Result { Success = false, ErrorCode = ErrorCode.InternalError, }); } }
public void PostAlert(string name, Specie specie, Role role) { try { var data = new SkywalkerAlert() { Timestamp = DateTime.Now, Name = name, Specie = specie, Role = role, ClientIP = HttpContext.Current.Request.UserHostName + " (" + HttpContext.Current.Request.UserHostAddress + ")", BrowserInfo = HttpContext.Current.Request.UserAgent }; var client = new HttpClient(); client.BaseAddress = new Uri(ConfigurationManager.AppSettings["DeathstarServoceBaseUrl"]); client.DefaultRequestHeaders.Accept.Add( new MediaTypeWithQualityHeaderValue("application/json")); var response = client.PostAsJsonAsync(API_POST_SKYWALKERALERT, data).Result; if (!response.IsSuccessStatusCode) { throw new Exception("Couldn't connect with the Deathstar service!"); } } catch (Exception ex) { BaseException.HandleException(ex); } }
/// <summary> /// Return the Specie added to the list. /// If already exists, it return the one of the list. /// </summary> /// <param name="pName"></param> /// <param name="pShortName"></param> /// <param name="pSpecieCycleName"></param> /// <param name="pBaseTemperature"></param> /// <param name="pStressTemperarute"></param> /// <param name="pSpecieType"></param> /// <returns></returns> public Specie AddSpecie(String pName, String pShortName, String pSpecieCycleName, Double pBaseTemperature, Double pStressTemperarute, Utils.SpecieType pSpecieType) { Specie lReturn = null; long lSpecieId = this.GetNewSpecieListId(); SpecieCycle lSpecieCycle = null; Specie lSpecie = null; lSpecieCycle = this.FindSpecieCycle(pSpecieCycleName); if (lSpecieCycle == null) { lSpecieCycle = this.AddSpecieCycle(pSpecieCycleName); } lSpecie = new Specie(lSpecieId, pName, pShortName, lSpecieCycle.SpecieCycleId, pBaseTemperature, pStressTemperarute, pSpecieType); lSpecie.SpecieCycle = lSpecieCycle; lReturn = this.ExistSpecie(lSpecie); if (lReturn == null) { this.SpecieList.Add(lSpecie); lReturn = lSpecie; } return(lReturn); }
/// <summary> /// Find the specie that a genome is closest to as determined by the distance metric. /// </summary> private Specie <TGenome> FindClosestSpecie(TGenome genome, IList <Specie <TGenome> > specieList) { // Measure distance to first specie's centroid. Specie <TGenome> closestSpecie = specieList[0]; double closestDistance = _distanceMetric.MeasureDistance(genome.Position, closestSpecie.Centroid); // Measure distance to all remaining species. int speciesCount = specieList.Count; for (int i = 1; i < speciesCount; i++) { double distance = _distanceMetric.MeasureDistance(genome.Position, specieList[i].Centroid); if (distance < closestDistance) { closestDistance = distance; closestSpecie = specieList[i]; } } return(closestSpecie); }
/// <summary> /// Return the Specie updated in the list. /// If not exists, it return null. /// </summary> /// <param name="pName"></param> /// <param name="pSpecieCycleName"></param> /// <param name="pBaseTemperature"></param> /// <returns></returns> public Specie UpdateSpecie(String pName, String pShortName, String pSpecieCycleName, Double pBaseTemperature, Double pStressTemperature, Utils.SpecieType pSpecieType) { Specie lReturn = null; SpecieCycle lSpecieCycle = null; long lSpecieCycleId = this.SpecieCycleList.Count; Specie lSpecie = null; long lSpecieId = this.SpecieList.Count; lSpecieCycle = this.FindSpecieCycle(pSpecieCycleName); if (lSpecieCycle == null) { lSpecieCycle = this.AddSpecieCycle(pSpecieCycleName); } //If not exists SpecieCycle, its create a new SpecieCycle. //In both cases, lSpecieCycle isnt null lSpecieCycleId = lSpecieCycle.SpecieCycleId; lSpecie = new Specie(lSpecieId, pName, pShortName, lSpecieCycleId, pBaseTemperature, pStressTemperature, pSpecieType); lReturn = ExistSpecie(lSpecie); if (lReturn != null) { lReturn.Name = pName; lReturn.ShortName = pShortName; lReturn.SpecieCycleId = lSpecieCycleId; lReturn.BaseTemperature = pBaseTemperature; lReturn.StressTemperature = pStressTemperature; lReturn.SpecieType = pSpecieType; } return(lReturn); }
public IActionResult Index() { if (TempData["creacion"] == null) { TempData["creacion"] = 0; } if (TempData["eliminacion"] == null) { TempData["eliminacion"] = 0; } if (TempData["edicion"] == null) { TempData["edicion"] = 0; } IDictionary <Question, Specie> diccionario = new Dictionary <Question, Specie>(); List <Question> preguntas = _QuestionRepository.Get(); foreach (Question pregunta in preguntas) { Specie especie = _SpecieRepository.Get(pregunta.SpecieId); diccionario.Add(pregunta, especie); } ViewBag.diccionario = diccionario; return(View()); }
/// <summary> /// Update an existing Crop, if not exists return null /// </summary> /// <param name="pName"></param> /// <param name="pSpecieCycle"></param> /// <param name="pRegion"></param> /// <param name="pCropCoefficient"></param> /// <param name="pStageList"></param> /// <param name="pPhenologicalStageList"></param> /// <param name="pDensity"></param> /// <param name="pMaxEvapotranspirationToIrrigate"></param> /// <param name="pMinEvapotranspirationToIrrigate"></param> /// <returns></returns> public Crop UpdateCrop(String pName, Specie pSpecie, Region pRegion, CropCoefficient pCropCoefficient, List <PhenologicalStage> pPhenologicalStageList, Double pDensity, Double pMaxEvapotranspirationToIrrigate, Double pMinEvapotranspirationToIrrigate) { Crop lReturn = null; Crop lCrop = new Crop(0, pName, pRegion.RegionId, pSpecie.SpecieId, pCropCoefficient.CropCoefficientId, pPhenologicalStageList, pDensity, pMaxEvapotranspirationToIrrigate, pMinEvapotranspirationToIrrigate); lReturn = this.ExistCrop(lCrop); if (lReturn != null) { lReturn.Name = pName; lReturn.RegionId = pRegion.RegionId; lReturn.SpecieId = pSpecie.SpecieId; lReturn.CropCoefficientId = pCropCoefficient.CropCoefficientId; lReturn.UpdatePhenologicalStageList(pPhenologicalStageList); lReturn.Density = pDensity; lReturn.MaxEvapotranspirationToIrrigate = pMaxEvapotranspirationToIrrigate; lReturn.MinEvapotranspirationToIrrigate = pMinEvapotranspirationToIrrigate; } return(lReturn); }
public Genotype[] Select(Specie[] species, int offspringCount) { var sumMeanAdjustedFitness = GetSumMeanAdjustedFitness(species); var orderedSpecies = species.OrderByDescending(sp => sp.MeanAdjustedFitness) .ToList(); var offspring = orderedSpecies .SelectMany(sp => GetOffspring(sp, offspringCount, sumMeanAdjustedFitness)) .Take(offspringCount) .ToList(); // Fill gap by producing additional offspring from top performers var diff = offspringCount - offspring.Count; if (diff > 0) { var additionalOffspring = orderedSpecies .Take(diff) .Select(sp => sp.ProduceOffspring(crossover)) .ToList(); Debug.LogFormat("Producing {0} additional offspring", additionalOffspring.Count); offspring.AddRange(additionalOffspring); } var selectedOffspring = offspring.ToArray(); Assert.AreEqual(offspringCount, selectedOffspring.Length, "Must select the correct number of offspring"); return selectedOffspring; }
public bool Remove(int id) { try { var filtro_especie = Builders <Specie> .Filter.Eq("Id", id); Specie specie = _context.Species.Find(filtro_especie).FirstOrDefault(); foreach (Photo photo in specie.Gallery) { var filtro_foto = Builders <Photo> .Filter.Eq("Id", photo.Id); _context.Photos.DeleteOne(filtro_foto); } DeleteResult actionResult = _context.Species.DeleteOne(filtro_especie); var filtro_pregunta = Builders <Question> .Filter.Eq("SpecieId", id); _context.Questions.DeleteMany(filtro_pregunta); string specieDeletedPath = Core.SpecieFolderPath(id.ToString()); Directory.Delete(specieDeletedPath, true); return(actionResult.IsAcknowledged && actionResult.DeletedCount > 0); } catch (Exception ex) { Console.Write("error: " + ex.StackTrace + "\n"); Console.Write("error: " + ex.Message + "\n"); throw ex; } }
public void AddAnimal(Specie specie, int calorias) { var animal = new Animal(this.main, specie, this.grid, calorias); this.animals.Add(animal); animal.Start(); }
private void displayStats(Specie specie) { textToUpdate.text = "Specie: " + specie.name + "\nFood: " + specie.foodPoint + "\nDurability: " + specie.durability + "\nGrow time: " + specie.growTime; if (specie.resistantProperties.Count != 0) { textToUpdate.text += "\nResistances:"; foreach (DisasterProperty property in specie.resistantProperties) { switch (property) { case DisasterProperty.EARTHQUAKE: textToUpdate.text += "\nTremor resistance"; break; case DisasterProperty.WATER: textToUpdate.text += "\nWater resistance"; break; case DisasterProperty.WIND: textToUpdate.text += "\nWind resistance"; break; } } } }
public async Task Watch() { await Receive(this.websocket, async (result, buffer) => { if (result.MessageType == WebSocketMessageType.Text) { string message = Encoding.UTF8.GetString(buffer, 0, result.Count); var request = JsonSerializer.Deserialize <RequestModel>(message); Specie specie = Specie.Seaweed; switch (request.animal) { case "SHARK": specie = Specie.Shark; break; case "SEAL": specie = Specie.Seal; break; case "FISH": specie = Specie.Fish; break; case "SEAWEED": specie = Specie.Seaweed; break; } this.environment.AddAnimal(specie, request.calorias); return; } else if (result.MessageType == WebSocketMessageType.Close) { this.environment.Destroy(); this.timer.Enabled = false; } }); }
private Specie getSpecie(string treeName) { Specie sp = new Specie(treeName); string[] indices = sp.getIndicesDeSitio();//Todo: verificar utilidad de esta variable. return(sp); }
private IEnumerable<Genotype> GetOffspring(Specie specie, int offspringCount, float sumMeanAdjustedFitness) { var specieProportion = (specie.MeanAdjustedFitness / sumMeanAdjustedFitness) * (float)offspringCount; var specieOffspringCount = Mathf.RoundToInt(specieProportion); if (specieOffspringCount > 0) { return Enumerable.Range(0, specieOffspringCount) .Select(_ => specie.ProduceOffspring(crossover)); } else { return new List<Genotype>(0); } }
public List<Phenotype> Select(Specie[] species, int eliteCount) { var orderedSpecies = species.OrderByDescending(sp => sp.BestFitness); var elites = orderedSpecies.Select(sp => { var orderedSpecie = sp.OrderByDescending(pt => pt.Fitness); return orderedSpecie.First(); }).Take(eliteCount).ToList(); Assert.AreEqual(eliteCount, elites.Count, "Must return the expected number of elites"); return elites; }
public void TestSpecie() { var specie = new Specie(13, protoGenotype, 0, 0, 0.0f); for (int i = 0; i < 100; i++) { var gt = Genotype.FromPrototype(protoGenotype); var pt = new Phenotype(gt); specie.Add(pt); } foreach (var pt in specie) { pt.AdjustedFitness = 1.0f / (float)specie.Count; } Assert.AreEqual(0.0f, specie.MeanFitness, 0.001f); Assert.AreEqual(0.01f, specie.MeanAdjustedFitness, 0.001f); Assert.AreEqual(100, specie.Count); }
IEnumerator Start() { var logPath = string.Format("logs_{0}", DateTime.Now.Ticks); Debug.LogFormat("Logging to {0}", logPath); if (!Directory.Exists(logPath)) { Directory.CreateDirectory(logPath); } elitesLog = File.CreateText(Path.Combine(logPath, "elites.csv")); populationLog = File.CreateText(Path.Combine(logPath, "populations.csv")); generationLog = File.CreateText(Path.Combine(logPath, "generations.csv")); speciesLog = File.CreateText(Path.Combine(logPath, "species.csv")); var populationSize = 100; var innovations = new InnovationCollection(); var mutations = new MutationCollection(); mutations.Add(0.01f, new AddNeuronMutator(innovations)); // 0.1% mutations.Add(0.05f, new AddSynapseMutator(innovations)); // 1% mutations.Add(0.05f, new ToggleSynapseMutator(0.125f)); mutations.Add(0.20f, new PerturbNeuronMutator(0.5f, 0.25f)); // 98% vvv mutations.Add(0.20f, new PerturbSynapseMutator(0.5f, 0.25f)); mutations.Add(0.20f, new ReplaceNeuronMutator(0.5f)); mutations.Add(0.20f, new ReplaceSynapseMutator(0.5f)); var eliteSelector = new EliteSelector(); var crossover = new MultipointCrossover(); var offspringSelector = new OffspringSelector(crossover); var distanceMetric = new DistanceMetric(2.0f, 2.0f, 1.0f); var speciation = new Speciation(10, 6.0f, 0.3f, distanceMetric); var neuronGenes = new []{ new NeuronGene(innovations.GetInitialNeuronInnovationId(0), NeuronType.UpperNeuron), new NeuronGene(innovations.GetInitialNeuronInnovationId(1), NeuronType.LowerNeuron), new NeuronGene(innovations.GetInitialNeuronInnovationId(2), NeuronType.PositionNeuron), new NeuronGene(innovations.GetInitialNeuronInnovationId(3), NeuronType.SpeedNeuron), }.ToGeneList(); var synapseGenes = new GeneList<SynapseGene>(); var protoGenotype = new Genotype(neuronGenes, synapseGenes); var genotypes = new GenotypeStream(protoGenotype) .Take(populationSize).ToArray(); var species = new Specie[0]; var generation = 0; var elitePhenotypes = new List<Phenotype>(); var offspringPhenotypes = genotypes.Select(gt => new Phenotype(gt)).ToList(); while (true) { yield return StartCoroutine(EvaluatePopulation(offspringPhenotypes)); var phenotypes = new List<Phenotype>(elitePhenotypes.Count + offspringPhenotypes.Count); phenotypes.AddRange(elitePhenotypes); phenotypes.AddRange(offspringPhenotypes); Assert.AreEqual(phenotypes.Count, populationSize, "Population size must remain constant"); var longest = phenotypes.OrderByDescending(pt => pt.BestDuration).First(); Debug.LogFormat("[{0}] Fitness: {1}, Duration: {2}s ({3}, {4}) (Longest)", generation, longest.MeanFitness, longest.MeanDuration, longest.Genotype.NeuronCount, longest.Genotype.SynapseCount); var best = phenotypes.OrderByDescending(pt => pt.Fitness).First(); Debug.LogFormat("[{0}] Fitness: {1}, Duration: {2}s ({3}, {4}) (Best)", generation, best.MeanFitness, best.MeanDuration, best.Genotype.NeuronCount, best.Genotype.SynapseCount); elitesLog.WriteLine(string.Join(",", new string[]{ generation.ToString(), best.Fitness.ToString(), best.BestDuration.ToString(), JSON.Serialize(best.Genotype.ToJSON()), })); var meanComplexity = phenotypes.Aggregate(0.0f, (sum, pt) => sum + (float)pt.Genotype.Complexity, (sum) => sum / (float)phenotypes.Count); var meanNeuronCount = phenotypes.Aggregate(0.0f, (sum, pt) => sum + (float)pt.Genotype.NeuronCount, (sum) => sum / (float)phenotypes.Count); var meanSynapseCount = phenotypes.Aggregate(0.0f, (sum, pt) => sum + (float)pt.Genotype.SynapseCount, (sum) => sum / (float)phenotypes.Count); var meanFitness = phenotypes.Aggregate(0.0f, (sum, pt) => sum + (float)pt.Fitness, (sum) => sum / (float)phenotypes.Count); var stdevFitness = phenotypes.Aggregate(0.0f, (sum, pt) => sum + Mathf.Pow(pt.Fitness - meanFitness, 2.0f), (sum) => Mathf.Sqrt(sum / (float)phenotypes.Count)); var stdevComplexity = phenotypes.Aggregate(0.0f, (sum, pt) => sum + Mathf.Pow((float)pt.Genotype.Complexity - meanComplexity, 2.0f), (sum) => Mathf.Sqrt(sum / (float)phenotypes.Count)); var stdevNeuronCount = phenotypes.Aggregate(0.0f, (sum, pt) => sum + Mathf.Pow((float)pt.Genotype.NeuronCount - meanNeuronCount, 2.0f), (sum) => Mathf.Sqrt(sum / (float)phenotypes.Count)); var stdevSynapseCount = phenotypes.Aggregate(0.0f, (sum, pt) => sum + Mathf.Pow((float)pt.Genotype.SynapseCount - meanSynapseCount, 2.0f), (sum) => Mathf.Sqrt(sum / (float)phenotypes.Count)); species = speciation.Speciate(species, phenotypes.ToArray()); Debug.LogFormat("[{0}] Species Count: {1} (Threshold: {2})", generation, species.Length, speciation.DistanceThreshold); var meanAdjustedFitness = phenotypes.Aggregate(0.0f, (sum, pt) => sum + (float)pt.AdjustedFitness, (sum) => sum / (float)phenotypes.Count); // standard deviation: // take the square root of the average of the squared deviations of the values from their average value var stdevAdjustedFitness = phenotypes.Aggregate(0.0f, (sum, pt) => sum + Mathf.Pow(pt.AdjustedFitness - meanAdjustedFitness, 2.0f), (sum) => Mathf.Sqrt(sum / (float)phenotypes.Count)); generationLog.WriteLine(new []{ generation, best.Fitness, best.MeanDuration, meanAdjustedFitness, stdevAdjustedFitness, meanFitness, stdevFitness, meanComplexity, stdevComplexity, meanNeuronCount, stdevNeuronCount, meanSynapseCount, stdevSynapseCount }.Stringify()); foreach (var sp in species) { speciesLog.WriteLine(new []{ generation, sp.SpeciesId, sp.Count, sp.BestFitness, sp.MeanFitness, sp.MeanAdjustedFitness, sp.MeanComplexity, }.Stringify()); foreach (var pt in sp) { populationLog.WriteLine(new []{ generation, sp.SpeciesId, pt.Fitness, pt.AdjustedFitness, pt.BestDuration, pt.Genotype.Complexity, pt.Genotype.NeuronCount, pt.Genotype.SynapseCount, }.Stringify()); } } var eliteCount = species.Length; elitePhenotypes = eliteSelector.Select(species, eliteCount); var offspringCount = populationSize - elitePhenotypes.Count; var offspringGenotypes = offspringSelector.Select(species, offspringCount); var mutationResults = mutations.Mutate(offspringGenotypes); Debug.LogFormat("[{0}] Mutations: Added Neurons: {1}, Added Synapses: {2}, Perturbed Neurons: {3}, Perturbed Synapses: {4}, Replaced Neurons: {5}, Replaced Synapses: {6}, Toggled Synapses: {7}, Pruned Synapses: {8}, Orphaned Neurons: {9}", generation, mutationResults.addedNeurons, mutationResults.addedSynapses, mutationResults.perturbedNeurons, mutationResults.perturbedSynapses, mutationResults.replacedNeurons, mutationResults.replacedSynapses, mutationResults.toggledSynapses, mutationResults.prunedSynapses, mutationResults.orphanedNeurons); offspringPhenotypes = offspringGenotypes.Select(gt => new Phenotype(gt)).ToList(); generation++; // Flush these so we can preview results while it runs generationLog.Flush(); populationLog.Flush(); speciesLog.Flush(); } }
public void Update(Specie specie) { this.species.Update(specie); this.species.Save(); }
public void Add(Specie specie) { this.species.Add(specie); this.species.Save(); }
private static float GetSumMeanAdjustedFitness(Specie[] species) { return species.Aggregate(0.0f, (sum, sp) => sum + sp.MeanAdjustedFitness); }