} // конструктор для инициализации объекта DenseStructure по полям объекта ConvolutionalNetwork
public void MutateLayersNumb(DenseRandomParams drp, int mutateRate)
{
if (random.Next(100) < mutateRate)
{
denseLayersNumb = random.Next(1, drp.denseLayersNumbRange);
}
if (denseLayersNumb >= denseLayers.Count)
{
denseLayers.Capacity = denseLayersNumb;
int powIndex = Support.GetPow2(denseLayers[denseLayers.Count - 1].neurons);
while (denseLayers.Count != denseLayers.Capacity)
{
powIndex += random.Next(0, 2);
int neurons = (int)Math.Pow(2, powIndex);
denseLayers.Insert(0, new DenseLayer(drp, random, neurons));
if (sameActivations)
{
denseLayers[0].activationIndex = denseLayers[1].activationIndex;
}
}
}
else
{
denseLayers.RemoveRange(0, denseLayers.Capacity - denseLayersNumb); // перепроверить!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
denseLayers.Capacity = denseLayersNumb;
}
}
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 DenseStructure(NetworkRandomParams nrp, DenseRandomParams drp, Random random)
{
this.nrp = nrp;
this.drp = drp;
this.random = random;
sameActivations = random.Next(100) < 10 ? true : false;
int absorber = 0;
if (sameActivations)
{
absorber = random.Next(drp.denseActIndexesRange);
}
denseLayersNumb = random.Next(1, drp.denseLayersNumbRange);
denseLayers = new List <DenseLayer>(denseLayersNumb);
int powIndex = 0;
for (int i = 0; i < denseLayers.Capacity; i++)
{
int neurons = 0;
if (i == 0)
{
powIndex = random.Next(Support.GetPow2(nrp.networkOutputNumb), drp.firstDenseNeuronsRange);
}
else
{
powIndex += random.Next(0, 2);
}
neurons = (int)Math.Pow(2, powIndex);
denseLayers.Insert(0, new DenseLayer(drp, random, neurons));
if (sameActivations)
{
denseLayers[0].activationIndex = absorber;
}
}
}
public void MutateNeurons(DenseRandomParams drp, int mutateRate) // проверить
{
if (random.Next(100) < mutateRate)
{
int mutateIndex = random.Next(0, denseLayers.Count);
int powIndex = 0;
while (mutateIndex != -1)
{
if (mutateIndex != (denseLayers.Count - 1))
{
powIndex = Support.GetPow2(denseLayers[mutateIndex + 1].neurons);
}
else
{
powIndex = drp.firstDenseNeuronsRange;
}
powIndex += random.Next(0, 2);
denseLayers[mutateIndex].neurons = (int)Math.Pow(2, powIndex);
mutateIndex--;
}
}
}
} // создание объекта по 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++;
}
}
}
