/// <summary>
/// Read the object.
/// </summary>
/// <param name="mask0">The stream to read the object from.</param>
/// <returns>The object that was loaded.</returns>
public virtual Object Read(Stream mask0)
{
var result = new NEATPopulation();
var innovationList = new NEATInnovationList {
Population = result
};
result.Innovations = innovationList;
var ins0 = new EncogReadHelper(mask0);
IDictionary <Int32, ISpecies> speciesMap = new Dictionary <Int32, ISpecies>();
IDictionary <ISpecies, Int32> leaderMap = new Dictionary <ISpecies, Int32>();
IDictionary <Int32, IGenome> genomeMap = new Dictionary <Int32, IGenome>();
EncogFileSection section;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("NEAT-POPULATION") &&
section.SubSectionName.Equals("INNOVATIONS"))
{
foreach (String line in section.Lines)
{
IList <String> cols = EncogFileSection.SplitColumns(line);
var innovation = new NEATInnovation
{
InnovationID = Int32.Parse(cols[0]),
InnovationType = StringToInnovationType(cols[1]),
NeuronType = StringToNeuronType(cols[2]),
SplitX = CSVFormat.EgFormat.Parse(cols[3]),
SplitY = CSVFormat.EgFormat.Parse(cols[4]),
NeuronID = Int32.Parse(cols[5]),
FromNeuronID = Int32.Parse(cols[6]),
ToNeuronID = Int32.Parse(cols[7])
};
result.Innovations.Add(innovation);
}
}
else if (section.SectionName.Equals("NEAT-POPULATION") &&
section.SubSectionName.Equals("SPECIES"))
{
foreach (String line in section.Lines)
{
String[] cols = line.Split(',');
var species = new BasicSpecies
{
SpeciesID = Int32.Parse(cols[0]),
Age = Int32.Parse(cols[1]),
BestScore = CSVFormat.EgFormat.Parse(cols[2]),
GensNoImprovement = Int32.Parse(cols[3]),
SpawnsRequired = CSVFormat.EgFormat
.Parse(cols[4])
};
species.SpawnsRequired = CSVFormat.EgFormat
.Parse(cols[5]);
leaderMap[(species)] = (Int32.Parse(cols[6]));
result.Species.Add(species);
speciesMap[((int)species.SpeciesID)] = (species);
}
}
else if (section.SectionName.Equals("NEAT-POPULATION") &&
section.SubSectionName.Equals("GENOMES"))
{
NEATGenome lastGenome = null;
foreach (String line in section.Lines)
{
IList <String> cols = EncogFileSection.SplitColumns(line);
if (cols[0].Equals("g", StringComparison.InvariantCultureIgnoreCase))
{
lastGenome = new NEATGenome
{
NeuronsChromosome = new Chromosome(),
LinksChromosome = new Chromosome()
};
lastGenome.Chromosomes.Add(lastGenome.NeuronsChromosome);
lastGenome.Chromosomes.Add(lastGenome.LinksChromosome);
lastGenome.GenomeID = Int32.Parse(cols[1]);
lastGenome.SpeciesID = Int32.Parse(cols[2]);
lastGenome.AdjustedScore = CSVFormat.EgFormat
.Parse(cols[3]);
lastGenome.AmountToSpawn = CSVFormat.EgFormat
.Parse(cols[4]);
lastGenome.NetworkDepth = Int32.Parse(cols[5]);
lastGenome.Score = CSVFormat.EgFormat.Parse(cols[6]);
result.Add(lastGenome);
genomeMap[(int)lastGenome.GenomeID] = lastGenome;
}
else if (cols[0].Equals("n", StringComparison.InvariantCultureIgnoreCase))
{
var neuronGene = new NEATNeuronGene
{
Id = Int32.Parse(cols[1]),
NeuronType = StringToNeuronType(cols[2]),
Enabled = Int32.Parse(cols[3]) > 0,
InnovationId = Int32.Parse(cols[4]),
ActivationResponse = CSVFormat.EgFormat
.Parse(cols[5]),
SplitX = CSVFormat.EgFormat.Parse(cols[6]),
SplitY = CSVFormat.EgFormat.Parse(cols[7])
};
lastGenome.Neurons.Add(neuronGene);
}
else if (cols[0].Equals("l", StringComparison.InvariantCultureIgnoreCase))
{
var linkGene = new NEATLinkGene();
linkGene.Id = Int32.Parse(cols[1]);
linkGene.Enabled = Int32.Parse(cols[2]) > 0;
linkGene.Recurrent = Int32.Parse(cols[3]) > 0;
linkGene.FromNeuronID = Int32.Parse(cols[4]);
linkGene.ToNeuronID = Int32.Parse(cols[5]);
linkGene.Weight = CSVFormat.EgFormat.Parse(cols[6]);
linkGene.InnovationId = Int32.Parse(cols[7]);
lastGenome.Links.Add(linkGene);
}
}
}
else if (section.SectionName.Equals("NEAT-POPULATION") &&
section.SubSectionName.Equals("CONFIG"))
{
IDictionary <String, String> paras = section.ParseParams();
result.NeatActivationFunction = EncogFileSection
.ParseActivationFunction(paras,
NEATPopulation.PropertyNEATActivation);
result.OutputActivationFunction = EncogFileSection
.ParseActivationFunction(paras,
NEATPopulation.PropertyOutputActivation);
result.Snapshot = EncogFileSection.ParseBoolean(paras,
PersistConst.Snapshot);
result.InputCount = EncogFileSection.ParseInt(paras,
PersistConst.InputCount);
result.OutputCount = EncogFileSection.ParseInt(paras,
PersistConst.OutputCount);
result.OldAgePenalty = EncogFileSection.ParseDouble(paras,
PopulationConst.PropertyOldAgePenalty);
result.OldAgeThreshold = EncogFileSection.ParseInt(paras,
PopulationConst.PropertyOldAgeThreshold);
result.PopulationSize = EncogFileSection.ParseInt(paras,
PopulationConst.PropertyPopulationSize);
result.SurvivalRate = EncogFileSection.ParseDouble(paras,
PopulationConst.PropertySurvivalRate);
result.YoungBonusAgeThreshhold = EncogFileSection.ParseInt(
paras, PopulationConst.PropertyYoungAgeThreshold);
result.YoungScoreBonus = EncogFileSection.ParseDouble(paras,
PopulationConst.PropertyYoungAgeBonus);
result.GenomeIDGenerate.CurrentID = EncogFileSection.ParseInt(paras,
PopulationConst.
PropertyNextGenomeID);
result.InnovationIDGenerate.CurrentID = EncogFileSection.ParseInt(paras,
PopulationConst.
PropertyNextInnovationID);
result.GeneIDGenerate.CurrentID = EncogFileSection.ParseInt(paras,
PopulationConst.
PropertyNextGeneID);
result.SpeciesIDGenerate.CurrentID = EncogFileSection.ParseInt(paras,
PopulationConst.
PropertyNextSpeciesID);
}
}
// now link everything up
// first put all the genomes into correct species
foreach (IGenome genome in result.Genomes)
{
var neatGenome = (NEATGenome)genome;
var speciesId = (int)neatGenome.SpeciesID;
if (speciesMap.ContainsKey(speciesId))
{
ISpecies s = speciesMap[speciesId];
s.Members.Add(neatGenome);
}
neatGenome.InputCount = result.InputCount;
neatGenome.OutputCount = result.OutputCount;
}
// set the species leader links
foreach (ISpecies species in leaderMap.Keys)
{
int leaderID = leaderMap[species];
IGenome leader = genomeMap[leaderID];
species.Leader = leader;
((BasicSpecies)species).Population = result;
}
return(result);
}
/// <inheritdoc/>
public Object Read(Stream mask0)
{
var result = new RBFNetwork();
var flat = (FlatNetworkRBF)result.Flat;
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("RBF-NETWORK") &&
section.SubSectionName.Equals("PARAMS"))
{
IDictionary <String, String> paras = section.ParseParams();
EngineArray.PutAll(paras, result.Properties);
}
if (section.SectionName.Equals("RBF-NETWORK") &&
section.SubSectionName.Equals("NETWORK"))
{
IDictionary <String, String> p = section.ParseParams();
flat.BeginTraining = EncogFileSection.ParseInt(p,
BasicNetwork.TagBeginTraining);
flat.ConnectionLimit = EncogFileSection.ParseDouble(p,
BasicNetwork.TagConnectionLimit);
flat.ContextTargetOffset = EncogFileSection.ParseIntArray(
p, BasicNetwork.TagContextTargetOffset);
flat.ContextTargetSize = EncogFileSection.ParseIntArray(
p, BasicNetwork.TagContextTargetSize);
flat.EndTraining = EncogFileSection.ParseInt(p,
BasicNetwork.TagEndTraining);
flat.HasContext = EncogFileSection.ParseBoolean(p,
BasicNetwork.TagHasContext);
flat.InputCount = EncogFileSection.ParseInt(p,
PersistConst.InputCount);
flat.LayerCounts = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerCounts);
flat.LayerFeedCounts = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerFeedCounts);
flat.LayerContextCount = EncogFileSection.ParseIntArray(p, BasicNetwork.TagLayerContextCount);
flat.LayerIndex = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerIndex);
flat.LayerOutput = section.ParseDoubleArray(p,
PersistConst.Output);
flat.LayerSums = new double[flat.LayerOutput.Length];
flat.OutputCount = EncogFileSection.ParseInt(p, PersistConst.OutputCount);
flat.WeightIndex = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagWeightIndex);
flat.Weights = section.ParseDoubleArray(p,
PersistConst.Weights);
flat.BiasActivation = section.ParseDoubleArray(p, BasicNetwork.TagBiasActivation);
}
else if (section.SectionName.Equals("RBF-NETWORK") &&
section.SubSectionName.Equals("ACTIVATION"))
{
int index = 0;
flat.ActivationFunctions = new IActivationFunction[flat.LayerCounts.Length];
foreach (String line in section.Lines)
{
IActivationFunction af;
IList <String> cols = EncogFileSection
.SplitColumns(line);
String name = ReflectionUtil.AfPath
+ cols[0];
try
{
af = (IActivationFunction)ReflectionUtil.LoadObject(name);
}
catch (Exception e)
{
throw new PersistError(e);
}
for (int i = 0; i < af.ParamNames.Length; i++)
{
af.Params[i] = CSVFormat.EgFormat.Parse(cols[i + 1]);
}
flat.ActivationFunctions[index++] = af;
}
}
else if (section.SectionName.Equals("RBF-NETWORK") &&
section.SubSectionName.Equals("RBF"))
{
int index = 0;
int hiddenCount = flat.LayerCounts[1];
int inputCount = flat.LayerCounts[2];
flat.RBF = new IRadialBasisFunction[hiddenCount];
foreach (String line in section.Lines)
{
IRadialBasisFunction rbf;
IList <String> cols = EncogFileSection
.SplitColumns(line);
String name = ReflectionUtil.RBFPath + cols[0];
try
{
rbf = (IRadialBasisFunction)ReflectionUtil.LoadObject(name);
}
catch (TypeLoadException ex)
{
throw new PersistError(ex);
}
catch (TargetException ex)
{
throw new PersistError(ex);
}
catch (MemberAccessException ex)
{
throw new PersistError(ex);
}
rbf.Width = CSVFormat.EgFormat.Parse(cols[1]);
rbf.Peak = CSVFormat.EgFormat.Parse(cols[2]);
rbf.Centers = new double[inputCount];
for (int i = 0; i < inputCount; i++)
{
rbf.Centers[i] = CSVFormat.EgFormat.Parse(cols[i + 3]);
}
flat.RBF[index++] = rbf;
}
}
}
return(result);
}
/// <summary>
/// Read the object.
/// </summary>
/// <param name="mask0">The stream to read from.</param>
/// <returns>The loaded object.</returns>
public virtual Object Read(Stream mask0)
{
var result = new NEATNetwork();
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
IDictionary <Int32, NEATNeuron> neuronMap = new Dictionary <Int32, NEATNeuron>();
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("NEAT") &&
section.SubSectionName.Equals("PARAMS"))
{
IDictionary <String, String> paras = section.ParseParams();
foreach (String key in paras.Keys)
{
result.Properties.Add(key, paras[key]);
}
}
if (section.SectionName.Equals("NEAT") &&
section.SubSectionName.Equals("NETWORK"))
{
IDictionary <String, String> p = section.ParseParams();
result.InputCount = EncogFileSection.ParseInt(p,
PersistConst.InputCount);
result.OutputCount = EncogFileSection.ParseInt(p,
PersistConst.OutputCount);
result.ActivationFunction = EncogFileSection
.ParseActivationFunction(p,
PersistConst.ActivationFunction);
result.OutputActivationFunction = EncogFileSection
.ParseActivationFunction(p,
NEATPopulation.PropertyOutputActivation);
result.NetworkDepth = EncogFileSection.ParseInt(p,
PersistConst.Depth);
result.Snapshot = EncogFileSection.ParseBoolean(p,
PersistConst.Snapshot);
}
else if (section.SectionName.Equals("NEAT") &&
section.SubSectionName.Equals("NEURONS"))
{
foreach (String line in section.Lines)
{
IList <String> cols = EncogFileSection.SplitColumns(line);
long neuronID = Int32.Parse(cols[0]);
NEATNeuronType neuronType = PersistNEATPopulation
.StringToNeuronType(cols[1]);
double activationResponse = CSVFormat.EgFormat
.Parse(cols[2]);
double splitY = CSVFormat.EgFormat
.Parse(cols[3]);
double splitX = CSVFormat.EgFormat
.Parse(cols[4]);
var neatNeuron = new NEATNeuron(neuronType,
neuronID, splitY, splitX, activationResponse);
result.Neurons.Add(neatNeuron);
neuronMap[((int)neuronID)] = (neatNeuron);
}
}
else if (section.SectionName.Equals("NEAT") &&
section.SubSectionName.Equals("LINKS"))
{
foreach (String line in section.Lines)
{
IList <String> cols = EncogFileSection.SplitColumns(line);
int fromID = Int32.Parse(cols[0]);
int toID = Int32.Parse(cols[1]);
bool recurrent = Int32.Parse(cols[2]) > 0;
double weight = CSVFormat.EgFormat.Parse(cols[3]);
NEATNeuron fromNeuron = (neuronMap[fromID]);
NEATNeuron toNeuron = (neuronMap[toID]);
var neatLink = new NEATLink(weight, fromNeuron,
toNeuron, recurrent);
fromNeuron.OutputboundLinks.Add(neatLink);
toNeuron.InboundLinks.Add(neatLink);
}
}
}
return(result);
}