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 void ComputeOutput() { FilteredImage image = (FilteredImage)PreviousLayer.GetData(); int outputIndex = 0; //for(int valuesI = 0; valuesI < image.Size; valuesI++) // { // for (int valuesJ = 0; valuesJ < image.Size; valuesJ++) // { // for (int channel = 0; channel < image.NumberOfChannels; channel++) // { // Output.Values[outputIndex] = image.Channels[channel].Values[valuesI, valuesJ]; // outputIndex++; // } // } // } for (int channel = 0; channel < image.NumberOfChannels; channel++) { for (int valuesI = 0; valuesI < image.Size; valuesI++) { for (int valuesJ = 0; valuesJ < image.Size; valuesJ++) { Output.Values[outputIndex] = image.Channels[channel].Values[valuesI, valuesJ]; outputIndex++; } } } }
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 override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate) { FilteredImage[] newErrors = new FilteredImage[FilterNumber]; FilteredImage previous = (FilteredImage)PreviousLayer.GetData(); FilteredImage nextErrors = (FilteredImage)nextOutput[0]; FilteredImage activationDerivatives = ActivationFunction.GetDerivative(OutputBeforeActivation); for (int i = 0; i < nextErrors.NumberOfChannels; i++) { for (int j = 0; j < nextErrors.Size; j++) { for (int k = 0; k < nextErrors.Size; k++) { nextErrors.Channels[i].Values[j, k] *= activationDerivatives.Channels[i].Values[j, k]; } } } 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(() => { newErrors[taski] = Filters[taski].Backpropagate(previous, nextErrors.Channels[taski], learningRate, samePadding); }); } Task.WaitAll(tasks); //for (int i = 0; i < FilterNumber; i++) //{ // newErrors[i] = Filters[i].Backpropagate(previous, // nextErrors.Channels[i], learningRate, samePadding); //} //for (int i = 0; i < FilterNumber; i++) //{ // newErrors[i] = Filters[i].Backpropagate(previous, // activationDerivatives.Channels[i], learningRate, samePadding); //} return(newErrors); }
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); }
private void InitializeOutput() { if (Output == null) { LayerOutput previousData = PreviousLayer.GetData(); if (previousData is FlattenedImage) { FlattenedImage previous = (FlattenedImage)previousData; Output = new FlattenedImage(previous.Size); } else { FilteredImage previous = (FilteredImage)previousData; Output = new FilteredImage(previous.NumberOfChannels, previous.Size); } } }
public override void ComputeOutput() { FlattenedImage previous = (FlattenedImage)PreviousLayer.GetData(); Task[] tasks = new Task[NumberOfUnits]; for (int i = 0; i < NumberOfUnits; i++) { int taski = 0 + i; tasks[taski] = Task.Run(() => { Output.Values[taski] = Units[taski].ComputeOutput(previous); }); } Task.WaitAll(tasks); Output = ActivationFunction.Activate(Output); }
private void ComputeFlattenedImage() { FlattenedImage previous = (FlattenedImage)PreviousLayer.GetData(); double[] newValues = new double[previous.Size]; for (int i = 0; i < previous.Size; i++) { if (GlobalRandom.GetRandomDouble() < Rate) { newValues[i] = 0; } else { newValues[i] = previous.Values[i]; } } Output = new FlattenedImage(previous.Size, newValues); }
public override LayerOutput[] Backpropagate(LayerOutput[] nextOutput, double learningRate) { int weightsPerUnit = Units[0].NumberOfWeights; FlattenedImage[] result = new FlattenedImage[weightsPerUnit]; FlattenedImage previous = (FlattenedImage)PreviousLayer.GetData(); for (int i = 0; i < weightsPerUnit; i++) { result[i] = new FlattenedImage(NumberOfUnits); } FlattenedImage activationDerivative = ActivationFunction.GetDerivative(Output); Task[] tasks = new Task[NumberOfUnits]; for (int unit = 0; unit < NumberOfUnits; unit++) { int tasku = 0 + unit; tasks[tasku] = Task.Run(() => { Unit unitAux = Units[tasku]; FlattenedImage nextErrors = (FlattenedImage)nextOutput[tasku]; double unitSum = nextErrors.Values.Sum(); double unitDerivative = unitSum * activationDerivative.Values[tasku]; for (int weight = 0; weight < unitAux.NumberOfWeights; weight++) { Monitor.Enter(result); result[weight].Values[tasku] = unitDerivative * unitAux.Weights[weight]; Monitor.Exit(result); double deltaW = unitDerivative * previous.Values[weight]; unitAux.Weights[weight] -= learningRate * deltaW; } }); } Task.WaitAll(tasks); //for (int unit = 0; unit < NumberOfUnits; unit++) //{ // Unit unitAux = Units[unit]; // FlattenedImage nextErrors = (FlattenedImage)nextOutput[unit]; // double unitSum = nextErrors.Sum(); // double unitDerivative = unitSum * activationDerivative.Values[unit]; // for (int weight = 0; weight < unitAux.NumberOfWeights; weight++) // { // Monitor.Enter(result); // result[weight].Values[unit] = unitDerivative * unitAux.Weights[weight]; // Monitor.Exit(result); // double deltaW = unitDerivative * previous.Values[weight]; // unitAux.Weights[weight] -= learningRate * deltaW; // } //} return(result); }