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; }