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