public override Vector <double> EvaluateConcrete(Vector <double> input) { // If we have a meanImage ... if (meanImage_ != null) { return((input - DenseVector.OfArray(meanImage_)) * scale_); } // If we have a meanChannel ... if (meanChannel_ != null && meanChannel_.Count() > 0) { Vector <double> cur = input; for (int channel = 0; channel < InputCoordinates.ChannelCount; channel++) { for (int r = 0; r < InputCoordinates.RowCount; r++) { for (int c = 0; c < InputCoordinates.ColumnCount; c++) { int index = InputCoordinates.GetIndex(channel, r, c); cur[index] = (input[index] - meanChannel_[channel]) * scale_; } } } return(cur); } // If we are only doing scaling ... return(input * (float)scale_); }
public void ApplyKernel <NumT, T, V>(ref T output, V input, int padding, int kernel, int row, int column) where NumT : struct, Num <T, V> where V : IList <T> { for (int i = 0; i < InputCoordinates.ChannelCount; i++) { for (int j = 0; j < KernelDimension; j++) { for (int k = 0; k < KernelDimension; k++) { int x = row - padding + j; int y = column - padding + k; if (x < 0 || y < 0 || x >= InputCoordinates.RowCount || y >= InputCoordinates.ColumnCount) { continue; } int index = InputCoordinates.GetIndex(i, x, y); if (index >= 0 && index < input.Count) { default(NumT).AddMul(ref output, input[index], Kernels[kernel, KernelCoordinates.GetIndex(i, j, k)]); } } } } default(NumT).Add(ref output, Intercepts[kernel]); return; }
public T ApplyKernel <NumT, T, V>(V input, int channel, int row, int column) where NumT : struct, Num <T, V> where V : IList <T> { T sum = default(NumT).Const(0.0); int count = 1; for (int i = 0; i < KernelDimension; i++) { for (int j = 0; j < KernelDimension; j++) { int x = row - Padding + i; int y = column - Padding + j; if (x >= InputCoordinates.RowCount || y >= InputCoordinates.ColumnCount) { continue; } int index = InputCoordinates.GetIndex(channel, x, y); if (index < 0 || index >= input.Count) { continue; } default(NumT).Add(ref sum, input[index]); count++; } } default(NumT).Mul(ref sum, 1.0 / (double)count); return(sum); }
public override LPSTerm[] EvaluateSymbolic(LPSState state, LPSTerm[] input) { LPSTerm[] cur = default(NumInstLPSTermArr).CreateVector(input.Length); // If we have a meanImage ... if (meanImage_ != null) { for (int i = 0; i < input.Length; i++) { cur[i].Sub(LPSTerm.Const(meanImage_[i])); // - mean cur[i].Add(input[i]); // + input cur[i].Mul(scale_); } return(cur); } // If we have a meanChannel ... if (meanChannel_ != null && meanChannel_.Count() > 0) { for (int channel = 0; channel < InputCoordinates.ChannelCount; channel++) { for (int r = 0; r < InputCoordinates.RowCount; r++) { for (int c = 0; c < InputCoordinates.ColumnCount; c++) { int index = InputCoordinates.GetIndex(channel, r, c); cur[index].Sub(LPSTerm.Const(meanChannel_[channel])); cur[index].Add(input[index]); cur[index].Mul(scale_); } } } return(cur); } // Finally, if we are only doing scaling ... for (int i = 0; i < input.Length; i++) { cur[i].Add(input[i]); cur[i].Mul(scale_); } return(cur); }
public void InputToScratch(Vector <double> input) { // Must populate _input_scratch :: kernelMatrix.ColumnCount x kernel-positions var jBound = Utils.UImageCoordinate.ComputeOutputCounts(KernelDimension, InputCoordinates.RowCount, 1, Padding, false); var kBound = Utils.UImageCoordinate.ComputeOutputCounts(KernelDimension, InputCoordinates.ColumnCount, 1, Padding, false); for (int row = 0; row < jBound; row++) { for (int col = 0; col < kBound; col++) { for (int c = 0; c < InputCoordinates.ChannelCount; c++) { for (int i = 0; i < KernelDimension; i++) { for (int j = 0; j < KernelDimension; j++) { int x = row - padding_ + i; int y = col - padding_ + j; int output_x = c * KernelDimension * KernelDimension + i * KernelDimension + j; int output_y = row * kBound + col; if (x < 0 || y < 0 || x >= InputCoordinates.RowCount || y >= InputCoordinates.ColumnCount) { _input_scratch.Value[output_x, output_y] = 0; continue; } int index = InputCoordinates.GetIndex(c, x, y); if (index < 0 || index >= input.Count) { _input_scratch.Value[output_x, output_y] = 0; continue; } _input_scratch.Value[output_x, output_y] = input[index]; } } } } } }
public override double ApplyKernelConcrete(NNInstrumentation instr, Vector <double> input, int outIndex, int channel, int row, int column) { int argMax = InputCoordinates.GetIndex(channel, row, column); double max = input[argMax]; for (int i = 0; i < KernelDimension; i++) { for (int j = 0; j < KernelDimension; j++) { if (i == 0 && j == 0) { continue; } int x = row - Padding + i; int y = column - Padding + j; if (x >= InputCoordinates.RowCount || y >= InputCoordinates.ColumnCount) { continue; } int index = InputCoordinates.GetIndex(channel, x, y); if (index < 0 || index >= input.Count) { continue; } if (max < input[index]) { argMax = index; max = input[index]; } } } if (instr != null) { instr[Index].Selections[outIndex] = argMax; } return(max); }
public override LPSTerm ApplyKernelSymbolic(LPSState state, LPSTerm[] input, int outIndex, int channel, int row, int column) { int[] selections = state.Instrumentation[Index].Selections; int maxIndex = selections[outIndex]; LPSTerm maxInput = input[maxIndex]; for (int i = 0; i < KernelDimension; i++) { for (int j = 0; j < KernelDimension; j++) { int x = row - Padding + i; int y = column - Padding + j; if (x >= InputCoordinates.RowCount || y >= InputCoordinates.ColumnCount) { continue; } int curIndex = InputCoordinates.GetIndex(channel, x, y); if (curIndex == maxIndex) { continue; } if (curIndex < 0 || curIndex >= input.Length) { continue; } // maxInput - input[curIndex] >= 0 LPSTerm t = LPSTerm.Const(0.0); t.Add(maxInput); t.AddMul(input[curIndex], -1.0); state.DeferredCts.And(t, InequalityType.GE); } } return(maxInput); }