public static void SpatialMaxPoolingBackward(Tensor input, Tensor gradOutput, Tensor gradInput, Tensor indices, ConvolutionDesc2d cd, bool ceilMode)
{
int dimw = 3;
int dimh = 2;
int dimc = 1;
long nbatch = input.Sizes[0];
long nslices = input.Sizes[dimc];
long iheight = input.Sizes[dimh];
long iwidth = input.Sizes[dimw];
long owidth = gradOutput.Sizes[dimw];
long oheight = gradOutput.Sizes[dimh];
Ops.Fill(gradInput, 0);
using Tensor gradOutputContig = Ops.AsContiguous(gradOutput);
for (int i = 0; i < nbatch; ++i)
{
using Tensor gradInput_i = gradInput.Select(0, i);
using Tensor gradOutput_i = gradOutputContig.Select(0, i);
using Tensor indices_i = indices.Select(0, i);
using (NativeWrapper.BuildTensorRefPtr(gradInput_i, out IntPtr gradInput_iPtr))
using (NativeWrapper.BuildTensorRefPtr(gradOutput_i, out IntPtr gradOutput_iPtr))
using (NativeWrapper.BuildTensorRefPtr(indices_i, out IntPtr indices_iPtr))
{
CpuOpsNative.TS_SpatialMaxPooling_updateGradInput_frame(gradInput_iPtr, gradOutput_iPtr, indices_iPtr,
nslices, iwidth, iheight,
owidth, oheight,
cd.dW, cd.dH);
}
}
}
// allArgs should start with a null placeholder for the RNG object
/// <summary>
/// Invokes the with RNG.
/// </summary>
/// <param name="seed">The seed.</param>
/// <param name="method">The method.</param>
/// <param name="allArgs">All arguments.</param>
private static void InvokeWithRng(int? seed, MethodInfo method, params object[] allArgs)
{
if (!seed.HasValue)
seed = seedGen.Next();
IntPtr rng;
NativeWrapper.CheckResult(CpuOpsNative.TS_NewRNG(out rng));
NativeWrapper.CheckResult(CpuOpsNative.TS_SetRNGSeed(rng, seed.Value));
allArgs[0] = rng;
NativeWrapper.InvokeTypeMatch(method, allArgs);
NativeWrapper.CheckResult(CpuOpsNative.TS_DeleteRNG(rng));
}
private static void Conv2ForwardFrame(Tensor input, Tensor output, Tensor weight, Tensor bias, Tensor finput,
int kW,
int kH,
int dW,
int dH,
int padW,
int padH,
long nInputPlane,
long inputWidth,
long inputHeight,
long nOutputPlane,
long outputWidth,
long outputHeight)
{
var inputRef = NativeWrapper.AllocTensorRef(input);
var finputRef = NativeWrapper.AllocTensorRef(finput);
var inputPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TensorRef64)));
Marshal.StructureToPtr(inputRef, inputPtr, false);
var finputPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TensorRef64)));
Marshal.StructureToPtr(finputRef, finputPtr, false);
try
{
CpuOpsNative.TS_Unfolded_Copy(finputPtr, inputPtr, kW, kH, dW, dH, padW, padH, (int)nInputPlane, (int)inputWidth, (int)inputHeight, (int)outputWidth, (int)outputHeight);
using (var output2d = output.View(nOutputPlane, outputHeight * outputWidth))
{
if (bias != null)
{
using (var biasExp = bias.Expand(nOutputPlane, output2d.Sizes[1]))
{
Ops.Copy(output2d, biasExp);
}
}
else
{
Ops.Fill(output, 0);
}
Ops.Addmm(output2d, 1, output2d, 1, weight, finput);
}
}
finally
{
Marshal.FreeHGlobal(inputPtr);
Marshal.FreeHGlobal(finputPtr);
NativeWrapper.FreeTensorRef(inputRef);
NativeWrapper.FreeTensorRef(finputRef);
}
}
private static void Conv2BackwardInputFrame(Tensor gradOutput, Tensor gradInput, Tensor weight, Tensor fgradInput, ConvolutionDesc2d cd)
{
using (Tensor gradOutput2d = gradOutput.View(gradOutput.Sizes[0], gradOutput.Sizes[1] * gradOutput.Sizes[2]))
{
Ops.Addmm(fgradInput, 0, fgradInput, 1, weight, gradOutput2d);
}
Ops.Fill(gradInput, 0);
using (NativeWrapper.BuildTensorRefPtr(fgradInput, out IntPtr fgradInputPtr))
using (NativeWrapper.BuildTensorRefPtr(gradInput, out IntPtr gradInputPtr))
{
CpuOpsNative.TS_Unfolded_Acc(fgradInputPtr, gradInputPtr, cd.kW, cd.kH, cd.dW, cd.dH, cd.padW, cd.padH,
(int)gradInput.Sizes[0], (int)gradInput.Sizes[2], (int)gradInput.Sizes[1],
(int)gradOutput.Sizes[2], (int)gradOutput.Sizes[1]);
}
}
/// <summary>
/// Spatials the maximum pooling backward.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="gradOutput">The grad output.</param>
/// <param name="gradInput">The grad input.</param>
/// <param name="indices">The indices.</param>
/// <param name="cd">The cd.</param>
/// <param name="ceilMode">if set to <c>true</c> [ceil mode].</param>
public static void SpatialMaxPoolingBackward(NDArray input, NDArray gradOutput, NDArray gradInput, NDArray indices, ConvolutionDesc2d cd, bool ceilMode)
{
var dimw = 3;
var dimh = 2;
var dimc = 1;
var nbatch = input.Shape[0];
var nslices = input.Shape[dimc];
var iheight = input.Shape[dimh];
var iwidth = input.Shape[dimw];
var owidth = gradOutput.Shape[dimw];
var oheight = gradOutput.Shape[dimh];
Ops.Fill(gradInput, 0);
using (var gradOutputContig = Ops.AsContiguous(gradOutput))
{
for (int i = 0; i < nbatch; ++i)
{
using (var gradInput_i = gradInput.Select(0, i))
using (var gradOutput_i = gradOutputContig.Select(0, i))
using (var indices_i = indices.Select(0, i))
{
IntPtr gradInput_iPtr, gradOutput_iPtr, indices_iPtr;
using (NativeWrapper.BuildTensorRefPtr(gradInput_i, out gradInput_iPtr))
using (NativeWrapper.BuildTensorRefPtr(gradOutput_i, out gradOutput_iPtr))
using (NativeWrapper.BuildTensorRefPtr(indices_i, out indices_iPtr))
{
CpuOpsNative.TS_SpatialMaxPooling_updateGradInput_frame(gradInput_iPtr, gradOutput_iPtr, indices_iPtr,
nslices, iwidth, iheight,
owidth, oheight,
cd.dW, cd.dH);
}
}
}
}
}
public static void SpatialMaxPoolingForward(Tensor input, Tensor output, Tensor indices, ConvolutionDesc2d cd, bool ceilMode)
{
if (input.DimensionCount != 4)
{
throw new ArgumentException("input must be a 4D tensor");
}
var dimw = 3;
var dimh = 2;
var dimc = 1;
if (input.Sizes[dimw] < cd.kW - cd.padW || input.Sizes[dimh] < cd.kH - cd.padH)
{
throw new InvalidOperationException("input image is smaller than kernel size");
}
if (cd.padW > cd.kW / 2 || cd.padH > cd.kH / 2)
{
throw new InvalidOperationException("pad should be smaller than half of the kernel size");
}
var nbatch = input.Sizes[0];
var nslices = input.Sizes[dimc];
var iheight = input.Sizes[dimh];
var iwidth = input.Sizes[dimw];
long owidth;
long oheight;
if (ceilMode)
{
// ReSharper disable once ArrangeRedundantParentheses
oheight = (long)(Math.Ceiling((float)(iheight - cd.kH + 2 * cd.padH) / cd.dH)) + 1;
// ReSharper disable once ArrangeRedundantParentheses
owidth = (long)(Math.Ceiling((float)(iwidth - cd.kW + 2 * cd.padW) / cd.dW)) + 1;
}
else
{
// ReSharper disable once ArrangeRedundantParentheses
oheight = (long)(Math.Floor((float)(iheight - cd.kH + 2 * cd.padH) / cd.dH)) + 1;
// ReSharper disable once ArrangeRedundantParentheses
owidth = (long)(Math.Floor((float)(iwidth - cd.kW + 2 * cd.padW) / cd.dW)) + 1;
}
if (cd.padW != 0 || cd.padH != 0)
{
// ensure that the last pooling starts inside the image
if ((oheight - 1) * cd.dH >= iheight + cd.padH)
{
--oheight;
}
if ((owidth - 1) * cd.dW >= iwidth + cd.padW)
{
--owidth;
}
}
using var inputContig = Ops.AsContiguous(input);
for (var i = 0; i < nbatch; ++i)
{
using var input_i = inputContig.Select(0, i);
using var output_i = output.Select(0, i);
using var indices_i = indices.Select(0, i);
using (NativeWrapper.BuildTensorRefPtr(input_i, out var input_iPtr))
{
using (NativeWrapper.BuildTensorRefPtr(output_i, out var output_iPtr))
{
using (NativeWrapper.BuildTensorRefPtr(indices_i, out var indices_iPtr))
{
CpuOpsNative.TS_SpatialMaxPooling_updateOutput_frame(input_iPtr, output_iPtr, indices_iPtr,
nslices, iwidth, iheight,
owidth, oheight,
cd.kW, cd.kH, cd.dW, cd.dH, cd.padW, cd.padH);
}
}
}
}
}
private static string GetLastError()
{
IntPtr strPtr = CpuOpsNative.TS_GetLastError();
return(Marshal.PtrToStringAnsi(strPtr));
}
