private void ComputeFilteredImage()
{
FilteredImage image = (FilteredImage)PreviousLayer.GetData();
FilteredImageChannel[] newChannels = new FilteredImageChannel[image.NumberOfChannels];
int size = image.Size;
for (int i = 0; i < image.NumberOfChannels; i++)
{
double[,] newValues = new double[size, size];
for (int valuesI = 0; valuesI < size; valuesI++)
{
for (int valuesJ = 0; valuesJ < size; valuesJ++)
{
if (GlobalRandom.GetRandomDouble() < Rate)
{
newValues[valuesI, valuesJ] = 0;
}
else
{
newValues[valuesI, valuesJ] = image.Channels[i].Values[valuesI, valuesJ];
}
}
}
newChannels[i] = new FilteredImageChannel(size, newValues);
}
Output = new FilteredImage(image.NumberOfChannels, newChannels);
}
public override void ComputeOutput()
{
FilteredImageChannel[] channels = new FilteredImageChannel[FilterNumber];
FilteredImage img = (FilteredImage)PreviousLayer.GetData();
bool samePadding = (Padding == "same") ? true : false;
Task[] tasks = new Task[FilterNumber];
for (int i = 0; i < FilterNumber; i++)
{
int taski = 0 + i;
tasks[taski] = Task.Run(() =>
{
channels[taski] = Filters[taski].Convolve(img, samePadding);
});
}
Task.WaitAll(tasks);
//for (int i = 0; i < FilterNumber; i++)
//{
// channels[i] = Filters[i].Convolve(img, samePadding);
//}
OutputBeforeActivation = new FilteredImage(FilterNumber, channels);
OutputImage = ActivationFunction.Activate(OutputBeforeActivation);
}
public override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate)
{
FilteredImage image = (FilteredImage)PreviousLayer.GetData();
int outputIndex = 0;
FilteredImageChannel[] channels = new FilteredImageChannel[image.NumberOfChannels];
for (int channel = 0; channel < image.NumberOfChannels; channel++)
{
double[,] values = new double[image.Size, image.Size];
for (int valuesI = 0; valuesI < image.Size; valuesI++)
{
for (int valuesJ = 0; valuesJ < image.Size; valuesJ++)
{
values[valuesI, valuesJ] = nextOutput[outputIndex].Sum();
outputIndex++;
}
}
channels[channel] = new FilteredImageChannel(image.Size, values);
}
return(new FilteredImage[1] {
new FilteredImage(image.NumberOfChannels, channels)
});
}
public override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate)
{
FilteredImage input = (FilteredImage)PreviousLayer.GetData();
FilteredImageChannel[] outputChannels = new FilteredImageChannel[input.NumberOfChannels];
FilteredImage nextErrors = (FilteredImage)nextOutput[0];
int errorSize = nextErrors.Size;
int outputSize = input.Size;
for (int i = 0; i < input.NumberOfChannels; i++)
{
outputChannels[i] = new FilteredImageChannel(outputSize);
}
Task[] tasks = new Task[input.NumberOfChannels];
for (int channel = 0; channel < input.NumberOfChannels; channel++)
{
int taskc = 0 + channel;
tasks[taskc] = Task.Run(() =>
{
for (int channelI = 0; channelI + Pool <= outputSize; channelI += Pool)
{
for (int channelJ = 0; channelJ + Pool <= outputSize; channelJ += Pool)
{
int maxi = 0, maxj = 0;
double maxx = input.Channels[taskc].Values[channelI, channelJ];
for (int poolI = 0; poolI < Pool; poolI++)
{
for (int poolJ = 0; poolJ < Pool; poolJ++)
{
int i = channelI + poolI, j = channelJ + poolJ;
if (input.Channels[taskc].Values[i, j] > maxx)
{
maxx = input.Channels[taskc].Values[i, j];
maxi = i;
maxj = j;
}
}
}
outputChannels[taskc].Values[maxi, maxj] =
nextErrors.Channels[taskc].Values[channelI / Pool, channelJ / Pool];
}
}
});
}
Task.WaitAll(tasks);
return(new FilteredImage[1] {
new FilteredImage(input.NumberOfChannels, outputChannels)
});
}
public FilteredImage Backpropagate(FilteredImage previous, FilteredImageChannel nextErrors, double learningRate, bool samePadding)
{
FilteredImageChannel[] newChannels = new FilteredImageChannel[KernelNumber];
for (int k = 0; k < KernelNumber; k++)
{
newChannels[k] = Kernels[k].Backpropagate(previous.Channels[k], nextErrors, KernelNumber, learningRate, samePadding);
}
return(new FilteredImage(KernelNumber, newChannels));
}
public override void ComputeOutput()
{
FilteredImage input = (FilteredImage)PreviousLayer.GetData();
FilteredImageChannel[] outputChannels = new FilteredImageChannel[input.NumberOfChannels];
int inputSize = input.Size;
int outputSize = inputSize / Pool;
Task[] tasks = new Task[input.NumberOfChannels];
for (int channel = 0; channel < input.NumberOfChannels; channel++)
{
int taskc = 0 + channel;
tasks[taskc] = Task.Run(() =>
{
FilteredImageChannel auxInput = input.Channels[taskc];
double[,] outputValues = new double[outputSize, outputSize];
for (int channelI = 0; channelI + Pool <= inputSize; channelI += Pool)
{
for (int channelJ = 0; channelJ + Pool <= inputSize; channelJ += Pool)
{
double maxx = auxInput.Values[channelI, channelJ];
for (int poolI = 0; poolI < Pool; poolI++)
{
for (int poolJ = 0; poolJ < Pool; poolJ++)
{
if (maxx < auxInput.Values[channelI + poolI, channelJ + poolJ])
{
maxx = auxInput.Values[channelI + poolI, channelJ + poolJ];
}
}
}
outputValues[channelI / Pool, channelJ / Pool] = maxx;
}
}
outputChannels[taskc] = new FilteredImageChannel(outputSize, outputValues);
});
}
Task.WaitAll(tasks);
Output = new FilteredImage(input.NumberOfChannels, outputChannels);
}
public double[,] Convolve(FilteredImageChannel input, bool samePadding)
{
//double[,] flippedKernel = MatrixUtils.Rotate180(Values);
//int fullSize = Size * Size;
if (samePadding)
{
return(MatrixUtils.ConvolveSame(input.Values, Values));
}
return(MatrixUtils.Convolve(input.Values, Values));
//for (int i = 0; i < Size; i++)
//{
// for (int j = 0; j < Size; j++)
// {
// convResult[i, j] /= fullSize;
// }
//}
}
public override FilteredImage GetDerivative(FilteredImage output)
{
FilteredImageChannel[] resultChannels = new FilteredImageChannel[output.NumberOfChannels];
double[,] resultValues;
for (int c = 0; c < output.NumberOfChannels; c++)
{
resultValues = new double[output.Size, output.Size];
for (int i = 0; i < output.Size; i++)
{
for (int j = 0; j < output.Size; j++)
{
resultValues[i, j] = GetValueDerivative(output.Channels[c].Values[i, j]);
}
}
resultChannels[c] = new FilteredImageChannel(output.Size, resultValues);
}
return(new FilteredImage(output.NumberOfChannels, resultChannels));
}
public override FilteredImage Activate(FilteredImage img)
{
FilteredImageChannel[] resultChannels = new FilteredImageChannel[img.NumberOfChannels];
double[,] resultValues;
for (int c = 0; c < img.NumberOfChannels; c++)
{
resultValues = new double[img.Size, img.Size];
for (int i = 0; i < img.Size; i++)
{
for (int j = 0; j < img.Size; j++)
{
resultValues[i, j] = ActivateValue(img.Channels[c].Values[i, j]);
}
}
resultChannels[c] = new FilteredImageChannel(img.Size, resultValues);
}
return(new FilteredImage(img.NumberOfChannels, resultChannels));
}
public FilteredImageChannel Backpropagate(FilteredImageChannel previous, FilteredImageChannel nextErrors, int totalKernels, double learningRate, bool samePadding)
{
//double[,] kernelDerivatives = new double[1,1];
//Task t = Task.Run(() =>
//{
// if (samePadding)
// {
// kernelDerivatives = MatrixUtils.ConvolveSame(previous.Values, nextErrors.Values);
// }
// else
// {
// kernelDerivatives = MatrixUtils.Convolve(previous.Values, nextErrors.Values);
// }
//});
//double[,] flippedKernel = MatrixUtils.Rotate180(Values);
////double[,] newErrors = MatrixUtils.Convolve(flippedKernel, nextErrors.Values);
//double[,] newErrors;
//if (samePadding)
//{
// newErrors = MatrixUtils.FullConvolutionSame(flippedKernel, nextErrors.Values);
//}
//else
//{
// newErrors = MatrixUtils.FullConvolution(flippedKernel, nextErrors.Values);
//}
//t.Wait();
//for (int i = 0; i < Size; i++)
//{
// for(int j = 0; j < Size; j++)
// {
// Values[i, j] -= learningRate * kernelDerivatives[i, j];
// }
//}
//ComputeElementSum();
//return new FilteredImageChannel(Size, newErrors);
//double[,] flippedErrors = MatrixUtils.Rotate180(nextErrors.Values);
double[,] deltaWeights = new double[1, 1];
Task t1 = Task.Run(() =>
{
if (samePadding)
{
deltaWeights = MatrixUtils.ConvolveSame(previous.Values, nextErrors.Values);
}
else
{
deltaWeights = MatrixUtils.Convolve(previous.Values, nextErrors.Values);
}
});
//double[,] flippedKernel = MatrixUtils.Rotate180(Values);
double[,] newErrors;
if (samePadding)
{
newErrors = MatrixUtils.Convolve(Values, nextErrors.Values);
}
else
{
newErrors = MatrixUtils.FullConvolution(Values, nextErrors.Values);
}
t1.Wait();
double[,] newWeights = new double[Size, Size];
for (int i = 0; i < Size; i++)
{
for (int j = 0; j < Size; j++)
{
newWeights[i, j] = Values[i, j] - learningRate * deltaWeights[i, j];
}
}
//Values = MatrixUtils.Rotate180(newWeights);
Values = newWeights;
return(new FilteredImageChannel(newErrors.GetLength(0), newErrors));
}
public FilteredImage(int numberOfChannels, int channelSize)
{
NumberOfChannels = numberOfChannels;
Channels = new FilteredImageChannel[numberOfChannels];
Size = channelSize;
}
