internal static InternalArray bin_conv2d(InternalArray input, InternalArray weight, InternalArray bias, InternalArray alpha, int[] kernel_size, int[] stride, int[] padding)
{
var col_tensor = THWrapper.THFloatTensor_new();
var output = THWrapper.THFloatTensor_new();
var _alpha = alpha.ToTHTensor();
var _input = input.ToTHTensor();
var _weight = weight.ToTHTensor();
IntPtr _bias;
if (bias == null)
{
_bias = THWrapper.THFloatTensor_new();
}
else
{
_bias = bias.ToTHTensor();
}
binop.THNN_Bin_SpatialConvolutionMM_updateOutput(_input, output, _weight, _bias, col_tensor, _alpha,
kernel_size[0], kernel_size[1], stride[0], stride[1], padding[0], padding[1]);
THWrapper.THFloatTensor_free(col_tensor);
var ret = InternalArray.FromTHFloatTensor(output);
THWrapper.THFloatTensor_free(output);
THWrapper.THFloatTensor_free(_bias);
THWrapper.THFloatTensor_free(_input);
THWrapper.THFloatTensor_free(_alpha);
return(ret);
}
internal static InternalArray fpbin_conv2d(InternalArray input, InternalArray weight, InternalArray bias, InternalArray alpha, int[] kernel_size, int[] stride, int[] padding)
{
var col_tensor = THWrapper.THFloatTensor_new();
var output = THWrapper.THFloatTensor_new();
var _alpha = alpha.ToTHTensor();
var cln = new InternalArray(input.Shape);
for (int i = 0; i < cln.Data.Length; i++)
{
cln.Data[i] = input.QIntData[i];
}
var _input = cln.ToTHTensor();
var _weight = weight.ToTHTensor();
IntPtr _bias;
if (bias == null)
{
_bias = THWrapper.THFloatTensor_new();
}
else
{
_bias = bias.ToTHTensor();
}
binop.THNN_Bin_SpatialConvolutionMM_updateOutput(_input, output, _weight, _bias, col_tensor, _alpha,
kernel_size[0], kernel_size[1], stride[0], stride[1], padding[0], padding[1], true);
THWrapper.THFloatTensor_free(col_tensor);
var ret = InternalArray.FromTHFloatTensor(output);
ret.QIntData = new short[ret.Data.Length];
for (int i = 0; i < ret.Data.Length; i++)
{
ret.QIntData[i] = (short)ret.Data[i];
}
ret.Data = null;
THWrapper.THFloatTensor_free(output);
THWrapper.THFloatTensor_free(_bias);
THWrapper.THFloatTensor_free(_input);
THWrapper.THFloatTensor_free(_alpha);
return(ret);
}
public IntPtr ToTHTensor()
{
IntPtr ret = (IntPtr)0;
if (IntData != null)
{
ret = THWrapper.THIntTensor_new();
CreatedTensors.Add(ret);
if (Shape.Length == 2)
{
THWrapper.THIntTensor_resize2d(ret, Shape[0], Shape[1]);
for (int i = 0; i < Shape[0]; i++)
{
for (int j = 0; j < Shape[1]; j++)
{
THWrapper.THIntTensor_set2d(ret, i, j, Get2DInt(i, j));
}
}
}
if (Shape.Length == 3)
{
THWrapper.THIntTensor_resize3d(ret, Shape[0], Shape[1], Shape[2]);
for (int k = 0; k < Shape[0]; k++)
{
for (int i = 0; i < Shape[1]; i++)
{
for (int j = 0; j < Shape[2]; j++)
{
THWrapper.THIntTensor_set3d(ret, k, i, j, Get3DInt(k, i, j));
}
}
}
}
if (Shape.Length == 4)
{
THWrapper.THIntTensor_resize4d(ret, Shape[0], Shape[1], Shape[2], Shape[3]);
for (int k1 = 0; k1 < Shape[0]; k1++)
{
for (int k = 0; k < Shape[1]; k++)
{
for (int i = 0; i < Shape[2]; i++)
{
for (int j = 0; j < Shape[3]; j++)
{
THWrapper.THIntTensor_set4d(ret, k1, k, i, j, Get4DInt(k1, k, i, j));
}
}
}
}
}
return(ret);
}
if (Data != null)
{
ret = THWrapper.THFloatTensor_new();
CreatedTensors.Add(ret);
if (Shape.Length == 2)
{
THWrapper.THFloatTensor_resize2d(ret, Shape[0], Shape[1]);
for (int i = 0; i < Shape[0]; i++)
{
for (int j = 0; j < Shape[1]; j++)
{
THWrapper.THFloatTensor_set2d(ret, i, j, Get2D(i, j));
}
}
}
if (Shape.Length == 3)
{
THWrapper.THFloatTensor_resize3d(ret, Shape[0], Shape[1], Shape[2]);
for (int k = 0; k < Shape[0]; k++)
{
for (int i = 0; i < Shape[1]; i++)
{
for (int j = 0; j < Shape[2]; j++)
{
THWrapper.THFloatTensor_set3d(ret, k, i, j, Get3D(k, i, j));
}
}
}
}
if (Shape.Length == 4)
{
THWrapper.THFloatTensor_resize4d(ret, Shape[0], Shape[1], Shape[2], Shape[3]);
for (int k1 = 0; k1 < Shape[0]; k1++)
{
for (int k = 0; k < Shape[1]; k++)
{
for (int i = 0; i < Shape[2]; i++)
{
for (int j = 0; j < Shape[3]; j++)
{
THWrapper.THFloatTensor_set4d(ret, k1, k, i, j, Get4D(k1, k, i, j));
}
}
}
}
}
}
return(ret);
}
internal static InternalArray fpbin_linear(InternalArray input, InternalArray weight, InternalArray bias, InternalArray alpha)
{
var m = input.Shape[0];
var n = input.Shape[1];
var k = weight.Shape[0];
/**
*
* m = input.data.shape[0]
* n = input.data.shape[1]
* k = weight.data.shape[0]
* out_tensor = torch.FloatTensor()
* bin_input = torch.IntTensor()
* use_cuda = input.is_cuda
* binop.encode_rows_cpu(input.data, bin_input)
* binop.binary_gemm_cpu(bin_input, weight.data, output.data, m, n, k, 1, 0, 0, alpha.data)
* output.data.mul_(alpha.data.t().expand(output.shape))
* if bias is not None:
* output.data.add_(bias.data.expand(output.shape))
* return output
*
*/
//InternalArray output = new InternalArray(new int[] { });
var cln = new InternalArray(input.Shape);
for (int i = 0; i < cln.Data.Length; i++)
{
cln.Data[i] = input.QIntData[i];
}
var _input = cln.ToTHTensor();
var bin_input = THWrapper.THIntTensor_new();
encode_rows_cpu(_input, bin_input);
//var temp = InternalArray.FromTHIntTensor(bin_input);
var _alpha = alpha.ToTHTensor();
//var _bin_input = bin_input.ToTHTensor();
var _weight = weight.ToTHTensor();
var _output = THWrapper.THFloatTensor_new();
binop.fpbinary_gemm_cpu(bin_input, _weight, _output, m, n, k, 1, 0, 0, _alpha);
var temp2 = InternalArray.FromTHFloatTensor(_output);
THWrapper.THFloatTensor_free(_input);
THWrapper.THIntTensor_free(bin_input);
//var tt = alpha.ToTHTensor();
var ttt = alpha.Transpose2D();
ttt.QIntData = new short[ttt.Data.Length];
for (int i = 0; i < ttt.Data.Length; i++)
{
ttt.QIntData[i] = (short)(ttt.Data[i] * 256);
}
ttt.Data = null;
//var newt=THWrapper.THFloatTensor_newTranspose(tt, 0, 1);
/*output.data.mul_(alpha.data.t().expand(output.shape))
*/
if (bias != null)
{
throw new NotImplementedException();
/*
* if bias is not None:
* output.data.add_(bias.data.expand(output.shape))*/
}
var output = InternalArray.FromTHFloatTensor(_output);
output.QIntData = new short[output.Data.Length];
for (int i = 0; i < output.QIntData.Length; i++)
{
output.QIntData[i] = (short)(output.Data[i] * 256);
}
output.Data = null;
for (int i = 0; i < ttt.QIntData.Length; i++)
{
var val4 = (short)((int)(output.QIntData[i] * ttt.QIntData[i]) >> 8);
//output.QIntData[i] = output.Data[i] * ttt.Data[i];
output.QIntData[i] = val4;
}
THWrapper.THFloatTensor_free(_output);
return(output);
}
internal static InternalArray bin_linear(InternalArray input, InternalArray weight, InternalArray bias, InternalArray alpha)
{
var m = input.Shape[0];
var n = input.Shape[1];
var k = weight.Shape[0];
/**
*
* m = input.data.shape[0]
* n = input.data.shape[1]
* k = weight.data.shape[0]
* out_tensor = torch.FloatTensor()
* bin_input = torch.IntTensor()
* use_cuda = input.is_cuda
* binop.encode_rows_cpu(input.data, bin_input)
* binop.binary_gemm_cpu(bin_input, weight.data, output.data, m, n, k, 1, 0, 0, alpha.data)
* output.data.mul_(alpha.data.t().expand(output.shape))
* if bias is not None:
* output.data.add_(bias.data.expand(output.shape))
* return output
*
*/
//InternalArray output = new InternalArray(new int[] { });
var _input = input.ToTHTensor();
var bin_input = THWrapper.THIntTensor_new();
encode_rows_cpu(_input, bin_input);
var temp = InternalArray.FromTHIntTensor(bin_input);
var _alpha = alpha.ToTHTensor();
//var _bin_input = bin_input.ToTHTensor();
var _weight = weight.ToTHTensor();
var _output = THWrapper.THFloatTensor_new();
binop.binary_gemm_cpu(bin_input, _weight, _output, m, n, k, 1, 0, 0, _alpha);
var temp2 = InternalArray.FromTHFloatTensor(_output);
THWrapper.THFloatTensor_free(_input);
THWrapper.THIntTensor_free(bin_input);
//var tt = alpha.ToTHTensor();
var ttt = alpha.Transpose2D();
//var newt=THWrapper.THFloatTensor_newTranspose(tt, 0, 1);
/*output.data.mul_(alpha.data.t().expand(output.shape))
*/
if (bias != null)
{/*
* if bias is not None:
* output.data.add_(bias.data.expand(output.shape))*/
}
var output = InternalArray.FromTHFloatTensor(_output);
for (int i = 0; i < ttt.Data.Length; i++)
{
output.Data[i] *= ttt.Data[i];
}
THWrapper.THFloatTensor_free(_output);
return(output);
}
/*public static void memcpy(float[] a1, long dst, float[] a2, long dst2, long size)
* {
* for (int i = 0; i < size / 4; i++)
* {
* a1[i + dst] = a2[i + dst2];
* }
* }*/
/*
* THFloatTensor *input,
* THFloatTensor *output,
* THIntTensor *weight,
* THFloatTensor *bias,
* THFloatTensor *columns,
* THFloatTensor *alphas,
* int kH, int kW,
* int dH, int dW,
* int padH, int padW)*/
public static void THNN_Bin_SpatialConvolutionMM_updateOutput(
IntPtr input,
IntPtr output,
IntPtr weight,
IntPtr bias,
IntPtr columns,
IntPtr alphas,
int kH, int kW,
int dH, int dW,
int padH, int padW
, bool quantOutput = false)
{
int ndim = THWrapper.THFloatTensor_nDimension(input);
int dimf = 0;
int dimh = 1;
int dimw = 2;
if (ndim == 4)
{
dimf++;
dimh++;
dimw++;
}
var nInputPlane = THWrapper.THFloatTensor_size(input, dimf);
var inputHeight = THWrapper.THFloatTensor_size(input, dimh);
var inputWidth = THWrapper.THFloatTensor_size(input, dimw);
var nOutputPlane = THWrapper.THFloatTensor_size(weight, 0);
var outputHeight = (inputHeight + 2 * padH - kH) / dH + 1;
var outputWidth = (inputWidth + 2 * padW - kW) / dW + 1;
//InternalArray ones = new InternalArray(new int[] { 1 });
IntPtr ones = THWrapper.THFloatTensor_new();
if (bias != null && THWrapper.THFloatTensor_nDimension(bias) == 1)
{
THWrapper.THFloatTensor_resize2d(bias, THWrapper.THFloatTensor_size(bias, 0), 1);
//THFloatTensor_resize2d(bias, bias.Shape[0], 1);
}
THWrapper.THFloatTensor_resize2d(ones, 1, outputHeight * outputWidth);
//THFloatTensor_resize2d(ones, 1, outputHeight * outputWidth);
THWrapper.THFloatTensor_fill(ones, 1);
//THFloatTensor_fill(ones, 1);
var T = THWrapper.THFloatTensor_size(input, 0);
//InternalArray bin_col = new InternalArray(new int[] { 1 });
var bin_col = THWrapper.THIntTensor_new();
THWrapper.THFloatTensor_resize4d(output, T, (int)nOutputPlane, outputHeight, outputWidth);
//THFloatTensor_resize4d(output, T, (int)nOutputPlane, outputHeight, outputWidth);
THWrapper.THFloatTensor_resize3d(columns, T, kW * kH * nInputPlane, outputHeight * outputWidth);
//THFloatTensor_resize3d(columns, T, kW * kH * nInputPlane, outputHeight * outputWidth);
THWrapper.THIntTensor_resize3d(bin_col, T, (int)nOutputPlane, outputHeight * outputWidth);
//THIntTensor_resize3d(bin_col, T, (int)nOutputPlane, outputHeight * outputWidth);
for (int t = 0; t < T; t++)
{
/*var input_t = input.Get2DImageFrom4DArray(0, t);
* var columns_t = columns.Get2DImageFrom4DArray(0, t);
* var bin_col_t = bin_col.Get2DImageFrom4DArray(0, t);*/
//var _bin_col = bin_col.ToTHTensor();
var input_t = THWrapper.THFloatTensor_newSelect(input, 0, t);
var columns_t = THWrapper.THFloatTensor_newSelect(columns, 0, t);
var bin_col_t = THWrapper.THIntTensor_newSelect(bin_col, 0, t);
/* var bbb = InternalArray.FromTHFloatTensor(columns_t);
* for (int i = 0; i < bbb.Data.Length; i++)
* {
* var res = bbb.Data[i];
* if (res != 0)
* {
*
* }
*
* }*/
THNN_unfolded_copy(
columns_t, input_t, kW, kH, dW, dH, padW, padH,
(int)nInputPlane, (int)inputWidth, (int)inputHeight, (int)outputWidth, (int)outputHeight
);
// bbb = InternalArray.FromTHFloatTensor(columns_t);
//Debug.Assert(bbb.Data[1800] == -0.053401);
//Debug.Assert(bbb.Data[4200] == -0.852360);
/* for (int i = 0; i < bbb.Data.Length; i++)
* {
* var res = bbb.Data[i];
* if (res != 0)
* {
*
* }
* }*/
encode_cols_cpu(columns_t, bin_col_t);
// var bb = InternalArray.FromTHIntTensor(bin_col_t);
/* for (int i = 0; i < bb.IntData.Length; i++)
* {
* var res = bb.IntData[i];
* if (res != 0)
* {
*
* }
* }*/
}
for (int t = 0; t < T; t++)
{
/* THFloatTensor* output_t = THFloatTensor_newSelect(output, 0, t);
* THIntTensor* bin_col_t = THIntTensor_newSelect(bin_col, 0, t);
*/
/*var output_t = output.Get2DImageFrom4DArray(0, t);
* var bin_col_t = bin_col.Get2DImageFrom4DArray(0, t);*/
//var _output = output.ToTHTensor();
//var _bin_col = bin_col.ToTHTensor();
var output_t = THWrapper.THFloatTensor_newSelect(output, 0, t);
var bin_col_t = THWrapper.THIntTensor_newSelect(bin_col, 0, t);
THNN_Bin_SpatialConvolutionMM_updateOutput_frame(
output_t, weight, bias, ones, bin_col_t, alphas, kW, kH, dW, dH, padW, padH,
nInputPlane, inputWidth, inputHeight, nOutputPlane, outputWidth, outputHeight, quantOutput
);
}
}
