public static NdArray <Real> SingleInputForward(NdArray <Real> x, NdArray <Real> weight, NdArray <Real> bias, ICompressibleActivation <Real> activation, IFunction <Real> linear)
{
int outputCount = weight.Shape[0];
int inputCount = weight.Shape[1];
Real[] y = bias == null ? new Real[outputCount * x.BatchCount] : GetBiasedValue(x.BatchCount, outputCount, bias.Data);
for (int batchCount = 0; batchCount < x.BatchCount; batchCount++)
{
for (int i = 0; i < outputCount; i++)
{
for (int j = 0; j < inputCount; j++)
{
y[batchCount * outputCount + i] += x.Data[batchCount * inputCount + j] * weight.Data[i * inputCount + j];
}
}
}
if (activation != null)
{
for (int i = 0; i < y.Length; i++)
{
y[i] = activation.ForwardActivate(y[i]);
}
}
return(NdArray.Convert(y, new[] { outputCount }, x.BatchCount, linear));
}
public static NdArray NeedPreviousForwardCpu(this ICompressibleActivation compressibleActivation, NdArray x)
{
Real[] y = new Real[x.Data.Length];
for (int i = 0; i < y.Length; i++)
{
y[i] = compressibleActivation.ForwardActivate(x.Data[i]);
}
return(NdArray.Convert(y, x.Shape, x.BatchCount, compressibleActivation));
}
public static NdArray <Real> SingleInputForward(NdArray <Real> x, NdArray <Real> weight, NdArray <Real> bias, int strideX, int strideY, int padX, int padY, ICompressibleActivation <Real> activation, IFunction <Real> conv2d)
{
int outputCount = weight.Shape[0];
int inputCount = weight.Shape[1];
int kernelHeight = weight.Shape[2];
int kernelWidth = weight.Shape[3];
int outputHeight = (int)Math.Floor((x.Shape[1] - kernelHeight + padY * 2.0f) / strideY) + 1;
int outputWidth = (int)Math.Floor((x.Shape[2] - kernelWidth + padX * 2.0f) / strideX) + 1;
Real[] y = new Real[x.BatchCount * outputCount * outputHeight * outputWidth];
for (int batchCounter = 0; batchCounter < x.BatchCount; batchCounter++)
{
int yBatchOffset = batchCounter * outputCount * outputHeight * outputWidth;
int xBatchOffset = batchCounter * x.Length;
for (int och = 0; och < outputCount; och++)
{
int kOchOffset = och * inputCount * kernelHeight * kernelWidth;
int yChOffset = yBatchOffset + och * outputHeight * outputWidth;
for (int oy = 0; oy < outputHeight * strideY; oy += strideY)
{
int iyStart = oy - padY < 0 ? 0 : oy - padY;
int iyLimit = kernelHeight + oy - padY < x.Shape[1] ? kernelHeight + oy - padY : x.Shape[1];
for (int ox = 0; ox < outputWidth * strideX; ox += strideX)
{
int ixStart = ox - padX < 0 ? 0 : ox - padX;
int ixLimit = kernelWidth + ox - padX < x.Shape[2] ? kernelWidth + ox - padX : x.Shape[2];
int yIndex = yChOffset + oy / strideY * outputWidth + ox / strideX;
for (int ich = 0; ich < inputCount; ich++)
{
int kIchOffset = kOchOffset + ich * kernelHeight * kernelWidth;
int xChOffset = xBatchOffset + ich * x.Shape[1] * x.Shape[2];
for (int iy = iyStart; iy < iyLimit; iy++)
{
for (int ix = ixStart; ix < ixLimit; ix++)
{
int wIndex = kIchOffset + (iy - oy + padY) * kernelWidth + ix - ox + padX;
int xIndex = xChOffset + iy * x.Shape[2] + ix;
y[yIndex] += x.Data[xIndex] * weight.Data[wIndex];
}
}
}
}
}
}
}
if (activation != null && bias != null)
{
for (int batchCounter = 0; batchCounter < x.BatchCount; batchCounter++)
{
int resultIndex = batchCounter * outputCount * outputHeight * outputWidth;
for (int och = 0; och < outputCount; och++)
{
for (int location = 0; location < outputHeight * outputWidth; location++)
{
y[resultIndex] += bias.Data[och];
y[resultIndex] = activation.ForwardActivate(y[resultIndex]);
resultIndex++;
}
}
}
}
else if (bias != null)
{
for (int batchCounter = 0; batchCounter < x.BatchCount; batchCounter++)
{
int resultIndex = batchCounter * outputCount * outputHeight * outputWidth;
for (int och = 0; och < outputCount; och++)
{
for (int location = 0; location < outputHeight * outputWidth; location++)
{
y[resultIndex] += bias.Data[och];
resultIndex++;
}
}
}
}
else if (activation != null)
{
for (int i = 0; i < y.Length; i++)
{
y[i] = activation.ForwardActivate(y[i]);
}
}
return(NdArray.Convert(y, new[] { outputCount, outputHeight, outputWidth }, x.BatchCount, conv2d));
}
public static NdArray <Real> SingleInputForward(NdArray <Real> input, NdArray <Real> weight, NdArray <Real> bias, int strideX, int strideY, int padX, int padY, ICompressibleActivation <Real> activation, IFunction <Real> deconv2d)
{
int inputCount = weight.Shape[0];
int outputCount = weight.Shape[1];
int kernelHeight = weight.Shape[2];
int kernelWidth = weight.Shape[3];
int outputHeight = (input.Shape[1] - 1) * strideY + kernelHeight - padY * 2;
int outputWidth = (input.Shape[2] - 1) * strideX + kernelWidth - padX * 2;
Real[] result = new Real[input.BatchCount * outputCount * outputWidth * outputHeight];
int outSizeOffset = outputWidth * outputHeight;
int inputSizeOffset = input.Shape[1] * input.Shape[2];
int kSizeOffset = weight.Shape[2] * weight.Shape[3];
for (int batchCount = 0; batchCount < input.BatchCount; batchCount++)
{
for (int och = 0; och < outputCount; och++)
{
for (int oy = padY; oy < outputHeight + padY; oy++)
{
int iyLimit = oy / strideY + 1 < input.Shape[1] ? oy / strideY + 1 : input.Shape[1];
int iyStart = oy - weight.Shape[2] < 0 ? 0 : (oy - weight.Shape[2]) / strideY + 1;
for (int ox = padX; ox < outputWidth + padX; ox++)
{
int ixLimit = ox / strideX + 1 < input.Shape[2] ? ox / strideX + 1 : input.Shape[2];
int ixStart = ox - weight.Shape[3] < 0 ? 0 : (ox - weight.Shape[3]) / strideX + 1;
int outputIndex = batchCount * outputCount * outSizeOffset + och * outSizeOffset + (oy - padY) * outputWidth + ox - padX;
for (int ich = 0; ich < input.Shape[0]; ich++)
{
int inputIndexOffset = batchCount * input.Length + ich * inputSizeOffset;
int kernelIndexOffset = ich * weight.Shape[1] * kSizeOffset + och * kSizeOffset;
for (int iy = iyStart; iy < iyLimit; iy++)
{
for (int ix = ixStart; ix < ixLimit; ix++)
{
int inputIndex = inputIndexOffset + iy * input.Shape[2] + ix;
int kernelIndex = kernelIndexOffset + (oy - iy * strideY) * weight.Shape[3] + (ox - ix * strideX);
result[outputIndex] += input.Data[inputIndex] * weight.Data[kernelIndex];
}
}
}
}
}
}
}
if (activation != null && bias != null)
{
for (int batchCount = 0; batchCount < input.BatchCount; batchCount++)
{
for (int och = 0; och < outputCount; och++)
{
for (int oy = padY; oy < outputHeight + padY; oy++)
{
for (int ox = padX; ox < outputWidth + padX; ox++)
{
int outputIndex = batchCount * outputCount * outSizeOffset + och * outSizeOffset + (oy - padY) * outputWidth + ox - padX;
result[outputIndex] += bias.Data[och];
result[outputIndex] = activation.ForwardActivate(result[outputIndex]);
}
}
}
}
}
else if (bias != null)
{
for (int batchCount = 0; batchCount < input.BatchCount; batchCount++)
{
for (int och = 0; och < outputCount; och++)
{
for (int oy = padY; oy < outputHeight + padY; oy++)
{
for (int ox = padX; ox < outputWidth + padX; ox++)
{
int outputIndex = batchCount * outputCount * outSizeOffset + och * outSizeOffset + (oy - padY) * outputWidth + ox - padX;
result[outputIndex] += bias.Data[och];
}
}
}
}
}
else if (activation != null)
{
for (int batchCount = 0; batchCount < input.BatchCount; batchCount++)
{
for (int och = 0; och < outputCount; och++)
{
for (int oy = padY; oy < outputHeight + padY; oy++)
{
for (int ox = padX; ox < outputWidth + padX; ox++)
{
int outputIndex = batchCount * outputCount * outSizeOffset + och * outSizeOffset + (oy - padY) * outputWidth + ox - padX;
result[outputIndex] = activation.ForwardActivate(result[outputIndex]);
}
}
}
}
}
return(NdArray.Convert(result, new[] { outputCount, outputHeight, outputWidth }, input.BatchCount, deconv2d));
}