public static void encode_cols_cpu(IntPtr input, IntPtr output)//input float, output int
{
/* int n = input->size[0];
* int k = input->size[1];
* int l = 1 + (n - 1) / ENCODE_BIT;
*
* THIntTensor_resize2d(output, l, k);
* float* a = THFloatTensor_data(input);
* uint32_t* b = (uint32_t*)THIntTensor_data(output);
*
* encode_cols_cpu_kernel(a, b, n, k);*/
var n = (int)THWrapper.THFloatTensor_size(input, 0);
var k = (int)THWrapper.THFloatTensor_size(input, 1);
int l = 1 + (n - 1) / matmul.ENCODE_BIT;
THWrapper.THIntTensor_resize2d(output, l, k);
var a = THWrapper.THFloatTensor_data(input);
var b = THWrapper.THIntTensor_data(output);
encode_cols_cpu_kernel(a, b, n, k);
//var res1 = BitConverter.ToUInt32(BitConverter.GetBytes(THWrapper.THIntTensor_get2d(output, 0, 7)), 0);
//var res2 = THWrapper.THIntTensor_get2d(output, 7, 0);
}
public static void encode_rows_cpu(IntPtr input, IntPtr output)//input float, output int
{
var m = (int)THWrapper.THFloatTensor_size(input, 0);
var n = (int)THWrapper.THFloatTensor_size(input, 1);
int l = 1 + (n - 1) / matmul.ENCODE_BIT;
THWrapper.THIntTensor_resize2d(output, m, l);
var test1 = THWrapper.THIntTensor_nDimension(output);
var dim0 = THWrapper.THIntTensor_size(output, 0);
var dim1 = THWrapper.THIntTensor_size(output, 1);
//THIntTensor_resize2d(output, m, l);
/*int m = input->size[0];
* int n = input->size[1];
* int l = 1 + (n - 1) / ENCODE_BIT;
*
* THIntTensor_resize2d(output, m, l);
* float* a = THFloatTensor_data(input);
* uint32_t* b = (uint32_t*)THIntTensor_data(output);
*/
var a = THWrapper.THFloatTensor_data(input);
var b = THWrapper.THIntTensor_data(output);
encode_rows_cpu_kernel(a, b, m, n);
//var temp = InternalArray.FromTHIntTensor(output);
}
public static void fpbinary_gemm_cpu(IntPtr a, IntPtr b, IntPtr c, int m, int nn, int k, int transb, int beta, int alpha, IntPtr alphas)
{
if (THWrapper.THFloatTensor_nDimension(c) != 2 || THWrapper.THFloatTensor_size(c, 0) * THWrapper.THFloatTensor_size(c, 1) < m * k)
{
THWrapper.THFloatTensor_resize2d(c, m, k);
//THFloatTensor_resize2d(c, m, k);
}
/*
* uint32_t* A = (uint32_t*)THIntTensor_data(a);
* uint32_t* B = (uint32_t*)THIntTensor_data(b);
* float* C = THFloatTensor_data(c);
* float* D = THFloatTensor_data(alphas);
*/
var A = THWrapper.THIntTensor_data(a);
var B = THWrapper.THIntTensor_data(b);
var C = THWrapper.THFloatTensor_data(c);
var D = THWrapper.THFloatTensor_data(alphas);
var aa = InternalArray.FromTHIntTensor(a);
var bb = InternalArray.FromTHIntTensor(b);
var cc = InternalArray.FromTHFloatTensor(c);
var dd = InternalArray.FromTHFloatTensor(alphas);
int n = 1 + (nn - 1) / matmul.ENCODE_BIT;
int brow = transb != 0 ? 1 : k;
int bcol = transb != 0 ? n : 1;
//matmul.dgemm_nn(m, k, nn, A, n, 1, B, brow, bcol, C, k, 1, beta, alpha, D);
//matmul.dgemm_nn(m, k, nn, A, n, 1, B, brow, bcol, C, k, 1, beta, alpha, D);
matmul.fpdgemm_nn(m, k, nn, A, n, 1, B, brow, bcol, C, k, 1, beta);
if (alpha != 0)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < k; j++)
{
//C[i * n + j] *= alphas[i];
var aa1 = matmul.GetFloat(C, i * k + j);
short aq1 = (short)(aa1 * 256);
var aa2 = matmul.GetFloat(D, i);
var aq2 = (short)(aa2 * 256);
var val4 = (short)((int)(aq1 * aq2) >> 8);
var quant_res = val4 / 256f;
var orig = aa1 * aa2;
//matmul.SetFloat(C, i * k + j, aa1 * aa2);
matmul.SetFloat(C, i * k + j, val4);
//C[i * n + j] = (float)(C[i * n + j] * alphas[i]);
}
}
}
}
public static InternalArray FromTHFloatTensor(IntPtr tensor)
{
var dims = THWrapper.THFloatTensor_nDimension(tensor);
int[] d = new int[dims];
for (int i = 0; i < dims; i++)
{
d[i] = (int)THWrapper.THFloatTensor_size(tensor, i);
}
InternalArray ret = new InternalArray(d);
if (dims == 2)
{
for (int i = 0; i < d[0]; i++)
{
for (int j = 0; j < d[1]; j++)
{
ret.Set2D(i, j, THWrapper.THFloatTensor_get2d(tensor, i, j));
}
}
}
if (dims == 3)
{
for (int k = 0; k < d[0]; k++)
{
for (int i = 0; i < d[1]; i++)
{
for (int j = 0; j < d[2]; j++)
{
ret.Set3D(k, i, j, THWrapper.THFloatTensor_get3d(tensor, k, i, j));
}
}
}
}
if (dims == 4)
{
for (int k1 = 0; k1 < d[0]; k1++)
{
for (int k = 0; k < d[1]; k++)
{
for (int i = 0; i < d[2]; i++)
{
for (int j = 0; j < d[3]; j++)
{
ret.Set4D(k1, k, i, j, THWrapper.THFloatTensor_get4d(tensor, k1, k, i, j));
}
}
}
}
}
ret.UpdateOffsets();
return(ret);
}
/*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
);
}
}
