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 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 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);
}
static void Main(string[] args)
{
SquareCalculator calc = new SquareCalculator();
InputCoordinates prog = new InputCoordinates();
string path = @"C:\Users\guzhvad\Downloads\Guzhva\C Sharp\Log.txt";
List <IStorage> storages = new List <IStorage>()
{
new ConsoleStorage(),
new FileStorage(path)
};
Logger logger = new Logger(storages);
logger.LogLevel = Models.LogLevel.Info;
prog.InputCoordinate(logger);
calc.CalculateLandSquare(prog.GetPoints(), logger);
Console.ReadLine();
}
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);
}
