public void MutateMaxPooling(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
maxPullingExist = !maxPullingExist;
}
}
public void MutateActivation(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) <= mutateRate ? true : false)
{
activationIndex = random.Next(0, crp.convActIndexesRange);
}
}
public void MutateWindows(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
for (int i = 0; i < convLayers.Count; i++)
{
if (random.Next(100) < 20)
{
convLayers[i].slidingWindow[0] = random.Next(1, crp.slidingWindowsRange[0]);
if (convLayers[i].slidingWindow[0] > 1)
{
convLayers[i].slidingWindow[1] = random.Next(1, crp.slidingWindowsRange[1]);
}
else
{
convLayers[i].slidingWindow[1] = random.Next(2, crp.slidingWindowsRange[1]);
}
}
else
{
convLayers[i].MutateWindow(crp, mutateRate);
}
}
}
}
public ConvStructure(ConvRandomParams crp, Random random)
{
this.random = random;
sameSlidingWindowsSize = random.Next(100) < 10 ? true : false; //подредачить шанс
sameActivations = random.Next(100) < 10 ? true : false; //подредачить шанс
allSquareSlidingWindows = random.Next(100) < 10 ? true : false; //подредачить шанс
convLayersNumb = random.Next(1, crp.convLayersNumbRange);
convLayers = new List <ConvLayer>(convLayersNumb);
int powRandomValue = 0;
for (int i = 0; i < convLayers.Capacity; i++)
{
if (i == 0)
{
powRandomValue = random.Next(1, crp.firstConvPowFilters);
}
else
{
powRandomValue += random.Next(0, 2);
}
int filters = (int)Math.Pow(2, powRandomValue);
convLayers.Add(new ConvLayer(crp, random, filters));
}
if (sameSlidingWindowsSize) // тут уже одинаковые
{
int abserber = random.Next(convLayers.Count);
for (int i = 0; i < convLayers.Count; i++)
{
convLayers[i].slidingWindow = convLayers[abserber].slidingWindow;
}
}
if (allSquareSlidingWindows)
{
for (int i = 0; i < convLayers.Count; i++)
{
if (convLayers[i].slidingWindow[0] > 1)
{
convLayers[i].slidingWindow[1] = convLayers[i].slidingWindow[0];
}
else
{
convLayers[i].slidingWindow[0] = convLayers[i].slidingWindow[1];
}
}
}
if (sameActivations)
{
int sameActivationIndex = random.Next(crp.convActIndexesRange);
for (int i = 0; i < convLayers.Count; i++)
{
convLayers[i].activationIndex = sameActivationIndex;
}
}
}
public void MutateActivation(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
if (random.Next(100) < 10)
{
sameActivations = !sameActivations;
if (sameActivations)
{
int abserberIndex = random.Next(convLayers.Count);
for (int i = 0; i < convLayers.Count; i++)
{
convLayers[i].activationIndex = convLayers[abserberIndex].activationIndex;
}
}
}
else
{
for (int i = 0; i < convLayers.Count; i++)
{
convLayers[i].MutateActivation(crp, mutateRate);
}
}
}
}
public ConvolutionalChromosome(ConvolutionalNetwork cNet, ConvRandomParams crp, DenseRandomParams drp)
{
this.crp = crp;
this.drp = drp;
//добавить рандомные параметры
convPart = new ConvStructure(cNet.slidingWindows, cNet.convActivationIndexes, cNet.filters, cNet.convDropoutIndexes, cNet.convDropoutRates);
densePart = new DenseStructure(cNet.denseActivationIndexes, cNet.neurons, cNet.denseDropoutIndexes, cNet.denseDropoutRates);
} // конструктор для создания хромосомы из полей описательного класса ConvolutionalNetwork для последующего использования в генетических алгоритмах (например, для поиска лучшего варианта чем текущий)
} // для создания объекта по описательному
public void MutateWindow(ConvRandomParams crp, int mutateRate)
{
int mutateWay = random.Next(100);
if (mutateWay < 10)
{
squareSlidingWindow = !squareSlidingWindow;
if (squareSlidingWindow)
{
if (slidingWindow[0] > 1)
{
slidingWindow[1] = slidingWindow[0];
}
else
{
slidingWindow[0] = slidingWindow[1];
}
}
else
{
int index = random.Next(2);
if (random.Next(100) < mutateRate)
{
slidingWindow[index] = random.Next(2, crp.slidingWindowsRange[index]);
}
}
}
else
{
if (random.Next(100) <= mutateRate)
{
slidingWindow[0] = random.Next(1, crp.slidingWindowsRange[0]);
}
if (random.Next(100) <= mutateRate || slidingWindow[0] == 1)
{
if (slidingWindow[0] > 1)
{
slidingWindow[1] = random.Next(1, crp.slidingWindowsRange[1]);
}
else
{
slidingWindow[1] = random.Next(2, crp.slidingWindowsRange[1]);
}
}
this.squareSlidingWindow = slidingWindow[0] == slidingWindow[1];
}
if (slidingWindow[0] == slidingWindow[1])
{
squareSlidingWindow = true;
}
else
{
squareSlidingWindow = false;
}
}
public void MutateDropout(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
int mutationWay = random.Next(100);
if (mutationWay < 10)
{
dropoutExist = !dropoutExist;
}
else
{
dropoutRate = random.Next(10, crp.convDropRange);
}
}
}
public GeneticProgramm(NetworkRandomParams nrp, ConvRandomParams crp, DenseRandomParams drp,
int genEpochs, int[] selection, int populationSize, int mutateRate,
float accPriority, float paramPriority, int assessmentIndex, int percent)
{
_nrp = nrp;
_crp = crp;
_drp = drp;
_genEpochs = genEpochs;
_selection = selection;
_populationSize = populationSize;
_mutateRate = mutateRate;
_accPriority = accPriority;
_paramPriority = paramPriority;
_assessmentIndex = assessmentIndex;
_percent = percent;
}
} // конструктор для создания хромосомы из полей описательного класса ConvolutionalNetwork для последующего использования в генетических алгоритмах (например, для поиска лучшего варианта чем текущий)
public void MutateConvolutional(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
if (random.Next(100) < 5)
{
convPart = new ConvStructure(crp, random);
}
else
{
convPart.MutateLayersNumb(crp, mutateRate);
convPart.MutateActivation(crp, mutateRate);
convPart.MutateWindows(crp, mutateRate);
}
}
}
public void MutateLayersNumb(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
convLayersNumb = random.Next(1, crp.convLayersNumbRange);
if (convLayersNumb >= convLayers.Count)
{
convLayers.Capacity = convLayersNumb;
int powIndex = Support.GetPow2(convLayers[convLayers.Count - 1].filters);
while (convLayers.Count != convLayers.Capacity) // проверить условие!!
{
powIndex += random.Next(0, 2);
//int filters = random.Next(crp.firstConvPowFilters, crp.firstConvPowFilters + crp.firstConvPowFilters * convLayers.Count); //переделать!?
int filters = (int)Math.Pow(2, powIndex);
convLayers.Add(new ConvLayer(crp, random, filters));
if (sameSlidingWindowsSize)
{
convLayers[convLayers.Count - 1].slidingWindow = convLayers[0].slidingWindow;
}
if (sameActivations)
{
convLayers[convLayers.Count - 1].activationIndex = convLayers[0].activationIndex;
}
if (allSquareSlidingWindows)
{
if (convLayers[convLayers.Count - 1].slidingWindow[0] > 1)
{
convLayers[convLayers.Count - 1].slidingWindow[1] = convLayers[convLayers.Count - 1].slidingWindow[0];
}
else
{
convLayers[convLayers.Count - 1].slidingWindow[0] = convLayers[convLayers.Count - 1].slidingWindow[1];
}
}
}
}
else
{
convLayers.RemoveRange(convLayersNumb, convLayers.Capacity - convLayersNumb);
convLayers.Capacity = convLayersNumb;
}
}
}
public ConvolutionalChromosome(GeneticProgramm gp, Random random)
{
_gp = gp;
this.random = random;
nrp = gp._nrp;
crp = gp._crp;
drp = gp._drp;
convPart = new ConvStructure(crp, random);
densePart = new DenseStructure(nrp, drp, random);
if (nrp.notRandomSpeed)
{
trainConstSpeed = nrp.trainConstSpeedRange[0];
}
else
{
trainConstSpeed = Convert.ToSingle(random.Next((int)(nrp.trainConstSpeedRange[0] * 1000), (int)(nrp.trainConstSpeedRange[1] * 1000))) / 1000;
}
optimizer = nrp.optimizers[random.Next(nrp.optimizers.Count)];
loss_function = nrp.loss_functions[random.Next(nrp.loss_functions.Count)];
}
public ConvLayer(ConvRandomParams crp, Random random, int filters)
{
this.random = random;
this.filters = filters;
slidingWindow = new int[2];
dropoutExist = random.Next(100) < 10 ? true : false;
maxPullingExist = random.Next(100) < 10 ? true : false;
if (dropoutExist)
{
dropoutRate = random.Next(10, crp.convDropRange);
}
else
{
dropoutRate = 0;
}
activationIndex = random.Next(crp.convActIndexesRange);
squareSlidingWindow = random.Next(100) <= 20 ? true : false;
if (squareSlidingWindow)
{
slidingWindow[0] = random.Next(2, crp.slidingWindowsRange[0]);
slidingWindow[1] = slidingWindow[0];
}
else
{
slidingWindow[0] = random.Next(1, crp.slidingWindowsRange[0]);
if (slidingWindow[0] > 1)
{
slidingWindow[1] = random.Next(1, crp.slidingWindowsRange[1]);
}
else
{
slidingWindow[1] = random.Next(2, crp.slidingWindowsRange[1]);
}
}
//Thread.Sleep(1);
}
} // создание объекта по ConvolutionalNetwork
public void MutateFilters(ConvRandomParams crp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
int mutateIndex = random.Next(0, convLayers.Count);
int powIndex = 0;
while (mutateIndex != convLayers.Count)
{
if (mutateIndex != 0)
{
powIndex = Support.GetPow2(convLayers[mutateIndex - 1].filters);
}
else
{
powIndex = crp.firstConvPowFilters;
}
powIndex += random.Next(0, 2);
convLayers[mutateIndex].filters = (int)Math.Pow(2, powIndex);
mutateIndex++;
}
}
}
public GeneticProgramm CollectConv_NN_Params()
{
List <String> convActivations = new List <string>();
if (reluConvChb.Checked)
{
convActivations.Add("relu");
}
if (softmaxConvChb.Checked)
{
convActivations.Add("softmax");
}
if (lReluConvChb.Checked)
{
convActivations.Add("Leaky ReLU");
}
if (softsignConvChb.Checked)
{
convActivations.Add("softsign");
}
if (sigmoidConvChb.Checked)
{
convActivations.Add("sigmoid");
}
if (eluConvChb.Checked)
{
convActivations.Add("elu");
}
if (seluConvChb.Checked)
{
convActivations.Add("selu");
}
if (softplusConvChb.Checked)
{
convActivations.Add("softplus");
}
if (tanhConvChb.Checked)
{
convActivations.Add("tang");
}
if (PReLUConvChB.Checked)
{
convActivations.Add("PReLu");
}
if (TReLUConvChB.Checked)
{
convActivations.Add("TReLU");
}
List <String> denseActivations = new List <string>();
if (reluDenseChb.Checked)
{
denseActivations.Add("relu");
}
if (softmaxDenseChb.Checked)
{
denseActivations.Add("softmax");
}
if (lReluDenseChb.Checked)
{
denseActivations.Add("Leaky ReLU");
}
if (softsignDenseChb.Checked)
{
denseActivations.Add("softsign");
}
if (sigmoidDenseChb.Checked)
{
denseActivations.Add("sigmoid");
}
if (eluDenseChb.Checked)
{
denseActivations.Add("elu");
}
if (seluDenseChb.Checked)
{
denseActivations.Add("selu");
}
if (softplusDenseChb.Checked)
{
denseActivations.Add("softplus");
}
if (tanhDenseChb.Checked)
{
denseActivations.Add("tang");
}
if (PReLUDenseChB.Checked)
{
denseActivations.Add("PReLU");
}
if (ThReLUDenseChB.Checked)
{
denseActivations.Add("TReLU");
}
List <String> optimazers = new List <string>();
if (SGD_OptChB.Checked)
{
optimazers.Add("SGD");
}
List <String> lossFunctions = new List <string>();
if (categorical_crossentropyChB.Checked)
{
lossFunctions.Add("categorical_crossentropy");
}
List <int> callbacks_indexes = new List <int>();
if (modelCPChB.Checked)
{
callbacks_indexes.Add(0);
}
var nrp = new NetworkRandomParams(constSpeedChB.Checked,
new[] { float.Parse(minConstSpeedTB.Text, System.Globalization.CultureInfo.InvariantCulture),
float.Parse(maxConstSpeedTB.Text, System.Globalization.CultureInfo.InvariantCulture) },
datasetPathTB.Text, modelsPathTB.Text, labelsPathTB.Text, plotsPathTB.Text,
networkNameTB.Text, optimazers, lossFunctions, (int)learningEpochsNUD.Value, (int)batchSizeNUD.Value);
var crp = new ConvRandomParams((int)ConvLayersNumbNUD.Value,
(int)ConvFiltersNUD.Value,
convActivations.Count,
convActivations,
new[] { (int)slidingWindow1NUD.Value, (int)slidingWindow2NUD.Value },
convDropoutChB.Checked,
(int)convDropoutNUD.Value);
var drp = new DenseRandomParams((int)DenseLayersNumbNUD.Value,
(int)DenseNeuronsNUD.Value,
nrp.networkOutputNumb, // Support.GetOutputNumb(datasetPath);
denseActivations.Count,
denseActivations,
denseDropoutChB.Checked,
(int)denseDropoutNUD.Value);
var gp = new GeneticProgramm(nrp, crp, drp, (int)geneticEpochsNUD.Value, new[] { (int)copySelNUD.Value, (int)crossSelNUD.Value, (int)mutateRateNUD.Value },
(int)popolationCountNUD.Value, (int)mutateRateNUD.Value, (float)accPriorityNUD.Value, (float)memPriorityNUD.Value,
EstimatorCB.SelectedIndex, (int)instance.percentNUD.Value);
return(gp);
}
