bool Reforce(TablePredictor original, TablePredictor factoryTester, Random rdm, int breath)
{
int variationCount = ((int)short.MaxValue) * 2 * 256; //All entries, times 2 (prediction,state) , times 256 possible states
int startVariation = rdm.Next(variationCount);
int count = 0;
for (int i = startVariation; i < variationCount; i = (i + 1) % variationCount)
{
count++;
if (count > breath)
{
return(false);
}
TablePredictor.variationOverride(factoryTester, i);
factoryTester.ResetState();
factoryTester.ResetMetrics();
factoryTester.testPredict(test);
if (original.accuracy < factoryTester.accuracy)
{
TablePredictor.variationOverride(original, i);
original.predictionCount = factoryTester.predictionCount;
original.errorCount = factoryTester.errorCount;
return(true); //return both the original and the factory tester with the same variation
}
TablePredictor.variationUndo(factoryTester, i, original);
}
return(false);
}
public static TablePredictor LoadFromFile(string file)
{
byte[] saveArray = System.IO.File.ReadAllBytes(file);
TablePredictor load = null;
//version check
if (saveArray[0] == 0)
{
int symbolSize = BitConverter.ToInt32(saveArray, 1);
int stateSize = BitConverter.ToInt32(saveArray, 5);
load = new TablePredictor(symbolSize, stateSize);
load.speciesDepth = BitConverter.ToInt32(saveArray, 9);
for (int i = 0; i < load.table.Length; i++)
{
load.table[i] = saveArray[13 + i];
}
}
else
{
throw new Exception("Invalid file version.");
}
return(load);
}
public static TablePredictor mutate(TablePredictor original, Random rdm, double intensity)
{
TablePredictor mutated = new TablePredictor(original.symbolSize, original.stateSize);
mutateOverride(mutated, original, rdm, intensity);
return(mutated);
}
public static TablePredictor cross(TablePredictor parent1, TablePredictor parent2, Random rdm)
{
TablePredictor mutated = new TablePredictor(parent1.symbolSize, parent1.stateSize);
crossOverride(mutated, parent1, parent2, rdm);
return(mutated);
}
public static void variationUndo(TablePredictor destination, int variation, TablePredictor original)
{
throw new Exception();
int index = variation / (256 * 2);
int field = (variation / 256) % 2;
int mutation = variation % 256;
destination.table[index * 2 + field] = original.table[index * 2 + field];
}
public static void variationOverride(TablePredictor destination, int variation)
{
throw new Exception();
int index = variation / (256 * 2);
int field = (variation / 256) % 2;
int mutation = variation % 256;
destination.table[index * 2 + field] = (byte)mutation;
}
public TablePredictor(TablePredictor copy)
{
this.symbolSize = copy.symbolSize;
this.stateSize = copy.stateSize;
Initialize();
copy.table.CopyTo(table, 0);
state = copy.state;
species = copy.species;
speciesDepth = copy.speciesDepth;
birthTime = copy.birthTime;
}
public static void mutateOverride(TablePredictor destination, TablePredictor original, Random rdm, double intensity)
{
original.table.CopyTo(destination.table, 0);
destination.FactoryReset();
destination.species = original.species;
destination.speciesDepth = original.speciesDepth + 1;
//not very optimal
int mutationCount = rdm.Next(2 + (int)(original.table.Length * intensity));
destination.mutationLeap = mutationCount;
//int mutationCount = rdm.Next((int)(1 + original.table.Length * 0.3f));
int index;
for (int i = 0; i < mutationCount; i++)
{
index = rdm.Next(destination.table.Length);
if (index % 2 == 0)
{
destination.table[index] = (byte)rdm.Next(destination.symbolSize);
}
else
{
destination.table[index] = (byte)rdm.Next(destination.stateSize);
}
//inputIndex = rdm.Next(original.symbolSize);
//stateIndex = rdm.Next(original.stateSize);
//outputChange = (rdm.NextDouble() < 0.5f) ? 1 : 0;
//Optimize this, for %2 check
//if(outputChange == 0)
// destination.table[inputIndex * original.tableStride + stateIndex * 2 + outputChange] = (byte)rdm.Next(destination.symbolSize);
//else
// destination.table[inputIndex * original.tableStride + stateIndex * 2 + outputChange] = (byte)rdm.Next(destination.stateSize);
}
destination.origin = OriginType.Mutation;
}
void Reforcer(TablePredictor table)
{
Random rdm = new Random();
TablePredictor tester = new TablePredictor(table);
int breath = 256;
for (int i = 0; i < 2; i++)
{
if (Reforce(table, tester, rdm, breath))
{
Console.WriteLine(i + " Reforce result: " + table.accuracy);
}
else
{
Console.WriteLine(i + " Reforce failed. ");
}
}
}
void Learner()
{
//Start Genetic Algorithms
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < 100000; i++)
{
Iterate();
if (i % 100 == 0)
{
printPopulation(1);
}
}
Console.WriteLine("Learner over, best result at: ");
printPopulation(int.MaxValue);
stopwatch.Stop();
long elapsedTime = stopwatch.ElapsedMilliseconds;
Console.WriteLine("Genetic Algorithms runtime at: \nMiliseconds: " + elapsedTime + "\nSeconds: " + elapsedTime / 1000f + "\nMinutes" + (elapsedTime / 1000f) / 60f);
TablePredictor best = population[0];
Console.WriteLine("Rank : 0 " + best.getStats());
population.Clear();
Console.WriteLine("Reforcer Start: ");
stopwatch = new Stopwatch();
stopwatch.Start();
Reforcer(best);
stopwatch.Stop();
elapsedTime = stopwatch.ElapsedMilliseconds;
Console.WriteLine("Reforcer runtime at: \nMiliseconds: " + elapsedTime + "\nSeconds: " + elapsedTime / 1000f + "\nMinutes" + (elapsedTime / 1000f) / 60f);
Console.WriteLine("Best \n" + best.getStats());
}
public static void crossOverride(TablePredictor destination, TablePredictor parent1, TablePredictor parent2, Random rdm)
{
parent1.table.CopyTo(destination.table, 0);
destination.FactoryReset();
//not very optimal
int parent2Count = rdm.Next(destination.table.Length);
destination.species = (parent2Count > destination.table.Length / 2) ? parent2.species : parent1.species;
destination.speciesDepth = (parent1.speciesDepth > parent2.speciesDepth) ? parent1.speciesDepth : parent2.speciesDepth;
int index;
for (int i = 0; i < parent2Count; i++)
{
index = rdm.Next(destination.table.Length);
destination.table[index] = parent2.table[index];
}
destination.origin = OriginType.Cross;
}
public static void randomOverride(TablePredictor destination, Random rdm)
{
destination.FactoryReset();
speciesCounter++;
destination.species = speciesCounter;
destination.speciesDepth = 0;
for (int i = 0; i < destination.table.Length; i++)
{
//Check if slot is prediction output, or new state output
if (i % 2 == 0)
{
destination.table[i] = (byte)rdm.Next(destination.symbolSize);
}
else
{
destination.table[i] = (byte)rdm.Next(destination.stateSize);
}
}
destination.origin = OriginType.Random;
}
void Iterate()
{
Random rdm = new Random();
//List<float> crossPerformance = new List<float>();
//List<float> mutationPerformance = new List<float>(); ;
//List<float> randomPerformance = new List<float>(); ;
//Create mutated children
double crossRatio = 0.5;
for (int i = permanence; i < permanence + children; i++)
{
if (rdm.NextDouble() < crossRatio)
{
//Cross
int parent1 = rdm.Next(permanence);
int parent2 = rdm.Next(permanence);
TablePredictor.crossOverride(population[i], population[parent1], population[parent2], rdm);
population[i].birthTime = cycle;
population[i].testPredict(test);
//crossPerformance.Add(population[i].accuracy);
}
else
{
//Mutation
int parent = rdm.Next(permanence);
TablePredictor.mutateOverride(population[i], population[parent], rdm, 0.3);
population[i].birthTime = cycle;
population[i].testPredict(test);
//mutationPerformance.Add(population[i].accuracy);
}
}
//Add randoms
for (int i = permanence + children; i < population.Count; i++)
{
TablePredictor.randomOverride(population[i], rdm);
population[i].testPredict(test);
//randomPerformance.Add(population[i].accuracy);
}
//sort to find weaker individuals
sortPopulation();
//Convert weaker same species individuals to randoms
for (int i = 0; i < population.Count; i++)
{
for (int j = population.Count - 1; j > i; j--)
{
if (population[j].species == population[i].species)
{
TablePredictor.randomOverride(population[j], rdm);
population[j].testPredict(test);
//randomPerformance.Add(population[j].accuracy);
}
}
}
//sort again
sortPopulation();
//mutation measures
//float waterlineAccuracy = population[permanence-1].accuracy;
//int pCount = 0;
//for (int i = 0; i < mutationPerformance.Count; i++)
// if (mutationPerformance[i] > waterlineAccuracy)
// pCount++;
//if(mutationPerformance.Count > 0)
// Console.WriteLine("Mutation Performance: " + pCount / (float)mutationPerformance.Count);
//pCount = 0;
//for (int i = 0; i < crossPerformance.Count; i++)
// if (crossPerformance[i] > waterlineAccuracy)
// pCount++;
//if (crossPerformance.Count > 0)
// Console.WriteLine("Cross Performance: " + pCount / (float)crossPerformance.Count);
//pCount = 0;
//for (int i = 0; i < randomPerformance.Count; i++)
// if (randomPerformance[i] > waterlineAccuracy)
// pCount++;
//if (randomPerformance.Count > 0)
// Console.WriteLine("Random Performance: " + pCount / (float)randomPerformance.Count);
cycle++;
}
public Qaib(MainWindow window)
{
//Load test bytes
test = load();
//truncate test bytes
byte[] truncatedTest = new byte[256];
for (int i = 0; i < truncatedTest.Length; i++)
{
truncatedTest[i] = test[i];
}
test = truncatedTest;
test = CharToSymbol(test);
basicPredictTablePrint(test);
//print Test bytes metrics
Console.WriteLine("Test text loaded with: " + test.Length + " Bytes.");
Console.WriteLine("Test text loaded with: " + test.Length / 1024f + " KBytes.");
Console.WriteLine("Test text loaded with: " + (test.Length / 1024f) / 1014f + " MBytes.");
//Set char alphabet as test for translation display
//test = new byte[256];
//for (int i = 0; i < 256; i++)
// test[i] = (byte)i;
bool printTestStrings = false;
if (printTestStrings)
{
string inputText = "";
for (int i = 0; i < test.Length; i++)
{
inputText += (char)test[i];
}
Console.WriteLine("\nTest string:");
Console.WriteLine(inputText);
test = CharToSymbol(test);
string symbolBytes = "";
for (int i = 0; i < test.Length; i++)
{
symbolBytes += ("" + (int)test[i]).PadLeft(4);
}
Console.WriteLine("\nTest symbol bytes:");
Console.WriteLine(symbolBytes);
test = SymbolToChar(test);
string symbolText = "";
for (int i = 0; i < test.Length; i++)
{
symbolText += (char)test[i];
}
Console.WriteLine("\nTest symbol texted:");
Console.WriteLine(symbolText);
}
//test = load();
//test = CharToSymbol(test);
TablePredictor f0 = TablePredictor.LoadFromFile("AAABakef0.tp");
byte[] g0 = f0.predictStates(test);
Console.WriteLine(f0.getStats());
test = g0;
symbolCount = 64;
//more layers
TablePredictor f1 = TablePredictor.LoadFromFile("aaap.tp");
byte[] g1 = f1.predictStates(g0);
Console.WriteLine(f1.getStats());
//TablePredictor f2 = TablePredictor.LoadFromFile("Bakef2.tp");
//byte[] g2 = f2.predictStates(g1);
//Console.WriteLine(f2.getStats());
//TablePredictor f3 = TablePredictor.LoadFromFile("Bakef3.tp");
//byte[] g3 = f3.predictStates(g2);
//Console.WriteLine(f3.getStats());
byte[] display;
//display = f3.project(g3);
//display = f2.project(g2);
display = f1.project(g1);
display = f0.project(display);
display = SymbolToChar(display);
string os = "";
for (int i = 0; i < display.Length; i++)
{
os += (char)display[i];
}
Console.WriteLine("\nTest symbol texted:");
Console.WriteLine(os);
//Setup2();
}
void VFLearner()
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Random rdm = new Random(0);
TablePredictor testTable = new TablePredictor(symbolCount, population[0].stateSize);
TablePredictor temp;
int printRun = 100000;
double crossRatio = 0.0;
double randomRatio = 0.1;
double mutatedRatio = 1 - (crossRatio + randomRatio);
double mutationIntensity = 0.5;
int runs = int.MaxValue;
double decision;
int parent;
for (int i = 0; i < runs; i++)
{
cycle++;
if (i % printRun == 0)
{
population[0].SaveToFile("Run0-" + (i / printRun) + "v0.tp");
Console.WriteLine("m.i.: " + ("" + mutationIntensity).PadRight(10).Substring(0, 6));
printPopulation(1);
}
decision = rdm.NextDouble();
if (decision < mutatedRatio)
{
//Mutation
parent = rdm.Next(populationCount);
TablePredictor.mutateOverride(testTable, population[parent], rdm, mutationIntensity);
testTable.birthTime = cycle;
}
else if (decision < mutatedRatio + crossRatio)
{
throw new Exception("NO CROSS ALLOWED");
//Cross
int parent1 = rdm.Next(populationCount);
int parent2 = rdm.Next(populationCount);
TablePredictor.crossOverride(testTable, population[parent1], population[parent2], rdm);
testTable.birthTime = cycle;
if (testTable.species == population[parent1].species)
{
parent = parent1;
}
else
{
parent = parent2;
}
}
else
{
TablePredictor.randomOverride(testTable, rdm);
parent = -1;
}
testTable.testPredict(test);
if (testTable.accuracy > population[populationCount - 1].accuracy)
{
if (parent != -1)
{
//Children analysis
if (population[parent].accuracy < testTable.accuracy)
{
//Parent beat
//Soft change for sucessful mutation intensity (x2 because of random average behaviour)
mutationIntensity = 0.8 * mutationIntensity + 0.2 * (2 * testTable.mutationIntensity);
if (mutationIntensity > 0.9)
{
mutationIntensity = 0.9; //maximum allowed mutation intensity
}
temp = population[parent];
population[parent] = testTable;
testTable = temp;
//Reorder
for (int j = parent; j > 0; j--)
{
if (population[j - 1].accuracy < population[j].accuracy)
{
temp = population[j - 1];
population[j - 1] = population[j];
population[j] = temp;
}
}
}
}
else
{
//Random win, order
for (int j = 0; j < populationCount; j++)
{
if (testTable.accuracy > population[j].accuracy)
{
temp = population[j];
population[j] = testTable;
testTable = temp;
}
}
}
}
}
stopwatch.Stop();
long elapsedTime = stopwatch.ElapsedMilliseconds;
Console.WriteLine("Genetic Algorithms runtime at: \nMiliseconds: " + elapsedTime + "\nSeconds: " + elapsedTime / 1000f + "\nMinutes" + (elapsedTime / 1000f) / 60f);
printPopulation(populationCount);
TablePredictor best = population[0];
Console.WriteLine("Rank : 0 " + best.getStats());
best.SaveToFile("Potato.tp");
TablePredictor lel = TablePredictor.LoadFromFile("Potato.tp");
lel.testPredict(test);
Console.WriteLine("Loaded: " + lel.getStats());
}