public AdjustedNeuralNetworkPopulation Create(NeuralNetwork network, NeuralNetworkTest test, out AdjustedNeuralNetworkBodyFactory bodyFactory)
{
Contract.Requires(network != null);
Contract.Requires(test != null);
return DoCreate(network, test, out bodyFactory);
}
protected AdjusterLearningEpoch(NeuralNetwork network, NeuralNetworkTest test = null)
: base(test)
{
Contract.Requires(network != null);
Network = network;
}
public BackPropagationLearningEpoch(BackPropagationRule rule, NeuralNetwork network, NeuralNetworkTest test = null)
: base(network, test)
{
Contract.Requires(network != null);
Contract.Requires(rule != null);
Rule = rule;
}
public LearningTestResult(NeuralNetworkTest test, NeuralNetworkTestResult result)
{
Contract.Requires(test != null);
Contract.Requires(result != null);
Contract.Requires(test.TestValueUnits.Length == result.Count);
Test = test;
Result = result;
}
public AdjustedNeuralNetworkPopulation Create(NeuralNetwork network, NeuralNetworkTest test)
{
Contract.Requires(network != null);
Contract.Requires(test != null);
AdjustedNeuralNetworkBodyFactory temp;
var pop = DoCreate(network, test, out temp);
return pop;
}
NeuralNetworkTestResult IParallelLearningStrategy.DoIteration(NeuralNetworkTest test)
{
CurrentTest = test;
bool improved = process.Step();
if (last == null || improved)
{
last = process.LastResult;
}
return last;
}
public void InitInitialNetworks()
{
if (populationSize % 5 != 0)
{
populationSize = number_of_players_per_generation;
}
nets = new List <NeuralNetworkTest>();
for (int i = 0; i < populationSize; i++)
{
NeuralNetworkTest net = new NeuralNetworkTest(layers);
net.Mutate();
nets.Add(net);
}
}
private NeuralNetworkTestResult Step(NeuralNetworkTest test)
{
Debug.Assert(population != null);
Debug.Assert(bodyFactory != null);
bodyFactory.Parameters.Test = test;
if (populationInitialized)
{
population.Step();
}
else
{
population.Initialize();
populationInitialized = true;
}
Debug.Assert(bestBody != null);
return bestBody.TestResult;
}
protected internal override void InitializeNewRun()
{
if (process == null) process = new Process(this); else process.Reset();
CurrentTest = null;
last = null;
}
protected abstract NeuralNetworkTestResult Step(NeuralNetworkTest test);
protected StochasticAdjusterLearningEpoch(NeuralNetwork network, NeuralNetworkTest test = null)
: base(network, test)
{
Contract.Requires(network != null);
}
private AdjustedNeuralNetworkPopulation DoCreate(NeuralNetwork network, NeuralNetworkTest test, out AdjustedNeuralNetworkBodyFactory bodyFactory)
{
var parameters = new AdjustedTestableNetworkParameters
{
Test = test,
Network = network,
MutationStrength = MutationStrength
};
bodyFactory = new AdjustedNeuralNetworkBodyFactory(parameters);
if (CrossoverChunkSize.HasValue)
{
bodyFactory.CrossoverChunkSize = CrossoverChunkSize.Value;
}
else
{
bodyFactory.CrossoverChunkSize = IntRange.CreateFixed(parameters.AdjustableItems.Length / 2 - 1);
}
bodyFactory.PointMutationChance = PointMutationChance;
var newPop = new AdjustedNeuralNetworkPopulation();
newPop.ChanceOfMigration = ChanceOfMigration;
for (int gIdx = 0; gIdx < groupCount; gIdx++)
{
var group = new AdjustedNeuralNetworkGroup(bodyFactory, groupSize);
if (SelectionStrategy != null) group.SelectionStrategy = SelectionStrategy;
newPop.Groups.Add(group);
}
return newPop;
}
public void StartGame()
{
if (gameRunning)
{
remainingAliveBirds = 0;
foreach (Player p in players)
{
if (p.alive)
{
remainingAliveBirds++;
remainingBirdsText.text = "Rem: " + remainingAliveBirds;
}
}
if (remainingAliveBirds > 0)
{
return;
}
gameRunning = false;
}
else
{
startGameButton.enabled = false;
startGameButton.gameObject.SetActive(false);
timer = 5.1f;
gameRunning = true;
if (generationNumber == 0)
{
InitInitialNetworks();
}
else
{
foreach (Player p in players)
{
if (p.Score >= maxScore)
{
maxScore = p.Score;
maxScoreGeneration = generationNumber;
maxScoreText.text = "Max Score: " + maxScore + " in Generation: " + maxScoreGeneration;
}
}
nets.Sort();
for (int i = 0; i < populationSize / 5; i++)
{
stupidNets.Add(nets[i]);
}
for (int i = 0; i < 4 * populationSize / 5; i++)
{
nets[i] = new NeuralNetworkTest(nets[i % (int)(populationSize / 5) + (4 * populationSize / 5)]);
nets[i].Mutate();
while (stupidNets.Contains(nets[i]))
{
nets[i].Mutate();
}
}
for (int i = 4 * populationSize / 5; i < populationSize; i++)
{
nets[i] = new NeuralNetworkTest(nets[i]);
}
//// Randomize to add variations
//for ( int i = 0; i < 10; i++)
//{
// nets[i] = new NeuralNetworkTest(layers);
// //nets[i].Mutate();
//}
for (int i = 0; i < populationSize; i++)
{
nets[i].SetFitness(0f);
}
}
generationNumber++;
ClearPipes();
generationText.text = "Generation: " + generationNumber;
CreatePlayerBodies();
// ResetGame();
}
}
NeuralNetworkTestResult IParallelLearningStrategy.DoIteration(NeuralNetworkTest test)
{
return Step(test);
}
protected override NeuralNetworkTestResult Step(NeuralNetworkTest test)
{
Contract.Ensures(Contract.Result<NeuralNetworkTestResult>() != null);
return null;
}
protected override NeuralNetworkTestResult Step(NeuralNetworkTest test)
{
return onlineTest.RunTest(Network,
(result) =>
{
BackPropagate(result.GetErrors().First());
},
false);
}
public MAQLearningEpoch(NeuralNetwork network, NeuralNetworkTest test = null)
: base(network, test)
{
Contract.Requires(network != null);
}
NeuralNetworkTestResult IParallelLearningStrategy.DoIteration(NeuralNetworkTest test)
{
CurrentTest = test;
compo.Step();
return compo.BestProcess.LastResult;
}
protected override NeuralNetworkTestResult Step(NeuralNetworkTest test)
{
process.Step();
return process.LastResult;
}
public void Init(NeuralNetworkTest _net)
{
this.net = _net;
initialized = true;
}
protected LearningEpoch(NeuralNetworkTest test = null)
{
if ((this.currentTest = test) != null) TestChanged();
}
