static void Init_b(long long * gradIn, long long * gradOut, long long * primitives)
{
dnnError_t err;
//gradOut, layout is user or mkl
dnnLayout_t lt_out_b = (dnnLayout_t)primitives[POOL_L_B_O];
dnnLayout_t lt_out = (dnnLayout_t)gradOut[MKLLayout];
if (lt_out==NULL) lt_out = (dnnLayout_t)primitives[POOL_L_O];
//create conversion and buff if necessary
dnnPrimitive_t cv_out_b = NULL; float * buf_out_b = NULL;
CHECK_ERR( try_convert(&cv_out_b, &buf_out_b, lt_out, lt_out_b) , err );
//save
primitives[CV_POOLING_BACKWARD_OUTPUT] = (long long)cv_out_b;
primitives[BUFFER_POOLING_BACKWARD_OUTPUT] = (long long)buf_out_b;
//gradIn, layout
gradIn[CPULayout] = primitives[POOL_L_I];
dnnLayout_t lt_in_b = (dnnLayout_t)primitives[POOL_L_B_I];
float* buf_in_b = NULL;
CHECK_ERR( dnnAllocateBuffer_F32((void**)(&buf_in_b), lt_in_b), err );
primitives[BUFFER_POOLING_BACKWARD_INPUT] = (long long)buf_in_b;
ERR_RETURN:
return;
}
//gradOut: output gradient of CONV layer, known parameters
//gradIn: input gradient, to be calculated
static void Conv_bdata_init(
long long * gradIn,
long long * gradOut,
int N, int oC, int oH, int oW,
long long * weight,
long long * primitives)
{
dnnError_t err;
//get gradOut layout, create conversion if necessary
dnnLayout_t lt_out = (dnnLayout_t)gradOut[MKLLayout];
if(lt_out==NULL)
{
lt_out = (dnnLayout_t)primitives[L_O];
}
dnnPrimitive_t cv_out_bdata = NULL; float * buf_out_bdata = NULL;
CHECK_ERR( try_convert(&cv_out_bdata, &buf_out_bdata, lt_out, (dnnLayout_t)primitives[L_BD_O]) , err );
primitives[CONVERT_BWDDATA_OUTPUT] = (long long)cv_out_bdata;
primitives[BUFFER_BWDDATA_OUTPUT] = (long long)buf_out_bdata;
//for filter
dnnLayout_t lt_filter = (dnnLayout_t)primitives[L_W];
dnnLayout_t lt_filter_bdata = (dnnLayout_t)primitives[L_BD_W];
dnnPrimitive_t cv_filter_bdata = NULL; float * buf_filter_bdata = NULL;
CHECK_ERR( try_convert(&cv_filter_bdata, &buf_filter_bdata, lt_filter, lt_filter_bdata), err );
primitives[BUFFER_BWDDATA_FILTER] = (long long)buf_filter_bdata;
primitives[CONVERT_BWDDATA_FILTER] = (long long)cv_filter_bdata;
//create gradInput layout and memory
dnnLayout_t lt_in_bdata = (dnnLayout_t)primitives[L_BD_I];
float * buf_in_bdata = (float*)(gradIn[CPUPtr]);
CHECK_ERR( dnnAllocateBuffer_F32((void**)(&buf_in_bdata), lt_in_bdata), err );
primitives[BUFFER_BWDDATA_INPUT] = (long long)buf_in_bdata;
gradIn[CPULayout] = (long long)(dnnLayout_t)primitives[L_I_CHWN];
float* gradOutTransPtr = NULL;
if (gradOut[MKLLayout] == 0)
{
gradOutTransPtr = (float*)malloc(N*oC*oH*oW*sizeof(float));
}
primitives[BUFFER_TRANS_OUTPUT] = (long long)gradOutTransPtr;
ERR_RETURN:
return;
}
static GCharsetConverter *
guess_encoding (GeditDocumentOutputStream *stream,
const void *inbuf,
gsize inbuf_size)
{
GCharsetConverter *conv = NULL;
if (inbuf == NULL || inbuf_size == 0)
{
stream->priv->is_utf8 = TRUE;
return NULL;
}
if (stream->priv->encodings != NULL &&
stream->priv->encodings->next == NULL)
{
stream->priv->use_first = TRUE;
}
/* We just check the first block */
while (TRUE)
{
const GeditEncoding *enc;
if (conv != NULL)
{
g_object_unref (conv);
conv = NULL;
}
/* We get an encoding from the list */
enc = get_encoding (stream);
/* if it is NULL we didn't guess anything */
if (enc == NULL)
{
break;
}
gedit_debug_message (DEBUG_UTILS, "trying charset: %s",
gedit_encoding_get_charset (stream->priv->current_encoding->data));
if (enc == gedit_encoding_get_utf8 ())
{
gsize remainder;
const gchar *end;
if (g_utf8_validate (inbuf, inbuf_size, &end) ||
stream->priv->use_first)
{
stream->priv->is_utf8 = TRUE;
break;
}
/* Check if the end is less than one char */
remainder = inbuf_size - (end - (gchar *)inbuf);
if (remainder < 6)
{
stream->priv->is_utf8 = TRUE;
break;
}
continue;
}
conv = g_charset_converter_new ("UTF-8",
gedit_encoding_get_charset (enc),
NULL);
/* If we tried all encodings we use the first one */
if (stream->priv->use_first)
{
break;
}
/* Try to convert */
if (try_convert (conv, inbuf, inbuf_size))
{
break;
}
}
if (conv != NULL)
{
g_converter_reset (G_CONVERTER (conv));
}
return conv;
}
static void Conv_bfilter_init(
long long * input,
long long * gradOutput,
long long * gradWeight,
long long * primitives,
int N, int oC, int oH, int oW)
{
dnnError_t err;
//for gradOut
dnnLayout_t lt_out = (dnnLayout_t)(gradOutput[MKLLayout]);
if(lt_out==NULL) lt_out = (dnnLayout_t)primitives[L_O];
dnnPrimitive_t cv_out_bfilter = NULL; float* buf_out_bfilter = NULL;
CHECK_ERR( try_convert(&cv_out_bfilter, &buf_out_bfilter, lt_out, (dnnLayout_t)primitives[L_BF_O]) , err );
primitives[CONVERT_BWDFILTER_OUTPUT] = (long long)cv_out_bfilter;
primitives[BUFFER_BWDFILTER_OUTPUT] = (long long)buf_out_bfilter;
//for the first layer without delta, input gradOut should first be transposed
float* gradOutTransPtr = NULL;
if ( gradOutput[MKLLayout] == 0 && primitives[BUFFER_TRANS_OUTPUT] == 0)
{
gradOutTransPtr = (float*)malloc(N*oC*oH*oW*sizeof(float));
primitives[BUFFER_TRANS_OUTPUT] = (long long)gradOutTransPtr;
}
//for filter
dnnLayout_t lt_filter = (dnnLayout_t)primitives[L_W];
dnnLayout_t lt_filter_bfilter = (dnnLayout_t)primitives[L_BF_W];
dnnPrimitive_t cv_filter_bfilter = NULL; float * buf_filter_bfilter = NULL;
if(!dnnLayoutCompare_F32(lt_filter_bfilter, lt_filter))
{
CHECK_ERR( dnnConversionCreate_F32(&cv_filter_bfilter, lt_filter_bfilter, lt_filter), err);
CHECK_ERR( dnnAllocateBuffer_F32((void**)&buf_filter_bfilter, lt_filter_bfilter), err);
}
primitives[BUFFER_BWDFILTER_FILTER] = (long long)buf_filter_bfilter;
primitives[CONVERT_BWDFILTER_FILTER] = (long long)cv_filter_bfilter;
//for input
dnnLayout_t lt_in_real = (dnnLayout_t)input[MKLLayout];
if(lt_in_real==NULL)
{
lt_in_real = (dnnLayout_t)primitives[L_I];
}
dnnLayout_t lt_in_bfilter = (dnnLayout_t)primitives[L_BF_I];
dnnPrimitive_t cv_in_bfilter = NULL; float* buf_in_bfilter = (float*)(input[CPUPtr]);
CHECK_ERR( try_convert(&cv_in_bfilter, &buf_in_bfilter, lt_in_real, lt_in_bfilter), err );
primitives[BUFFER_BWDFILTER_INPUT] = (long long)buf_in_bfilter;
primitives[CONVERT_BWDFILTER_INPUT] = (long long)cv_in_bfilter;
//if has bias
if (primitives[BDW_BIAS_INDEX] != 0)
{
//convert for grad_bias if necessary
dnnLayout_t lt_bias_bias = (dnnLayout_t)primitives[L_B_B];
dnnLayout_t lt_bias = (dnnLayout_t)primitives[L_B];
dnnPrimitive_t cv_bias_bias = NULL; float * buf_bias_bias = NULL;
CHECK_ERR( dnnConversionCreate_F32(&cv_bias_bias, lt_bias_bias, lt_bias), err);
CHECK_ERR( dnnAllocateBuffer_F32((void**)&buf_bias_bias, lt_bias_bias), err);
primitives[BUFFER_BIAS_BIAS] = (long long)buf_bias_bias;
primitives[CV_BIAS_BIAS] = (long long)cv_bias_bias;
//convert for grad_out if necessary
dnnLayout_t lt_bias_out = (dnnLayout_t)primitives[L_B_O];
dnnPrimitive_t cv_out_bias = NULL; float* buf_out_bias = (float*)(input[CPUPtr]);
CHECK_ERR( try_convert(&cv_out_bias, &buf_out_bias, lt_out, lt_bias_out), err );
primitives[BUFFER_BIAS_OUT] = (long long)buf_out_bias;
primitives[CV_BIAS_OUT] = (long long)cv_out_bias;
}
ERR_RETURN:
return;
}
static int Conv_f_init(
long long * input,
long long * output,
long long * weight,
long long * primitives,
int N, int inC, int inH, int inW,
int kH, int kW,
int dH, int dW,
int padH, int padW,
int outC, int outH, int outW,
int hasBias)
{
dnnError_t err;
//init dimensions
size_t inputSize[DIM4] = { inW, inH, inC, N};
size_t outputSize[DIM4] = {outW, outH, outC, N};
size_t filterSize[DIM4] = { kW, kH, inC, outC};
size_t stride[DIM2] = { dW, dH};
int pad[DIM2] = {-padW, -padH};
size_t biasSize[1] = {outC};
size_t biasStrides[1] = { 1 };
//using NCHW layout
size_t filterStridesNCHW[DIM4] = {1, kW, kW*kH, kW*kH*inC};
size_t inputStridesNCHW[DIM4] = {1, inW, inW*inH, inW*inH*inC};
size_t outputStridesNCHW[DIM4] = {1, outW, outW*outH, outW*outH*outC};
//CHWN
size_t filterStridesCHWN[DIM4] = {outC, outC*kW, outC*kW*kH, 1};
size_t inputStridesCHWN[DIM4] = {N, N*inW, N*inW*inH, 1};
size_t outputStridesCHWN[DIM4] = {N, N*outW, N*outW*outH, 1};
//create execute and save into primitives
dnnPrimitiveAttributes_t attributes = NULL;
CHECK_ERR( dnnPrimitiveAttributesCreate_F32(&attributes), err );
dnnPrimitive_t conv_f = NULL; //forward operation
dnnPrimitive_t conv_bdata = NULL; //backward calculate gradient input
dnnPrimitive_t conv_bfilter = NULL; //backward calculate gradient filter(weight)
dnnPrimitive_t conv_b_bias = NULL; //backward bias
//create layout and save
//lt_in, layout of input in NCHW form
//lt_filter_f, required layout (MKL layout) for forward for weight
//lt_out_bfilter, required layout for backward weight update for output
dnnLayout_t lt_in_NCHW, lt_filter, lt_out_NCHW, lt_in_CHWN, lt_out_CHWN, lt_bias_CHWN=NULL;
dnnLayout_t lt_in_f, lt_filter_f, lt_out_f, lt_bias_f;
dnnLayout_t lt_in_bdata, lt_filter_bdata, lt_out_bdata, lt_bias_bdata;
dnnLayout_t lt_in_bfilter, lt_filter_bfilter, lt_out_bfilter,lt_bias_bias, lt_out_bias;
if (hasBias)
{
CHECK_ERR(dnnConvolutionCreateForwardBias_F32( &conv_f, attributes, dnnAlgorithmConvolutionDirect, DIM4, inputSize, outputSize, filterSize, stride, pad, dnnBorderZeros),err);
CHECK_ERR(dnnConvolutionCreateForwardBias_F32( &conv_f, attributes, dnnAlgorithmConvolutionDirect, DIM4, inputSize, outputSize, filterSize, stride, pad, dnnBorderZeros),err);
CHECK_ERR( dnnLayoutCreate_F32(<_bias_CHWN, 1, biasSize, biasStrides), err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_bias_f, conv_f, dnnResourceBias ) , err );
CHECK_ERR(dnnConvolutionCreateBackwardBias_F32( &conv_b_bias, attributes, dnnAlgorithmConvolutionDirect, DIM4, outputSize),err);
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_bias_bias, conv_b_bias, dnnResourceDiffBias) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_out_bias, conv_b_bias, dnnResourceDiffDst) , err );
}
else
CHECK_ERR(dnnConvolutionCreateForward_F32( &conv_f, attributes, dnnAlgorithmConvolutionDirect, DIM4, inputSize, outputSize, filterSize, stride, pad, dnnBorderZeros),err);
CHECK_ERR(dnnConvolutionCreateBackwardData_F32( &conv_bdata, attributes, dnnAlgorithmConvolutionDirect, DIM4, inputSize, outputSize, filterSize, stride, pad, dnnBorderZeros),err);
CHECK_ERR(dnnConvolutionCreateBackwardFilter_F32(&conv_bfilter, attributes, dnnAlgorithmConvolutionDirect, DIM4, inputSize, outputSize, filterSize, stride, pad, dnnBorderZeros),err);
primitives[FORWARD_INDEX] = (long long)conv_f;
primitives[BWD_DATA_INDEX] = (long long)conv_bdata;
primitives[BWD_FILTER_INDEX] = (long long)conv_bfilter;
primitives[BDW_BIAS_INDEX] = (long long)conv_b_bias;
CHECK_ERR( dnnLayoutCreate_F32(<_in_NCHW, DIM4, inputSize, inputStridesNCHW), err );
CHECK_ERR( dnnLayoutCreate_F32(<_in_CHWN, DIM4, inputSize, inputStridesCHWN), err );
CHECK_ERR( dnnLayoutCreate_F32(<_filter, DIM4, filterSize, filterStridesCHWN), err );
CHECK_ERR( dnnLayoutCreate_F32(<_out_NCHW, DIM4, outputSize, outputStridesNCHW), err );
CHECK_ERR( dnnLayoutCreate_F32(<_out_CHWN, DIM4, outputSize, outputStridesCHWN), err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_in_f, conv_f, dnnResourceSrc ) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_filter_f, conv_f, dnnResourceFilter), err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_out_f, conv_f, dnnResourceDst ) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_in_bdata, conv_bdata, dnnResourceDiffSrc) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_filter_bdata, conv_bdata, dnnResourceFilter) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_out_bdata, conv_bdata, dnnResourceDiffDst) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_in_bfilter, conv_bfilter, dnnResourceSrc) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_filter_bfilter, conv_bfilter, dnnResourceDiffFilter) , err );
CHECK_ERR( dnnLayoutCreateFromPrimitive_F32(<_out_bfilter, conv_bfilter, dnnResourceDiffDst) , err );
//here assume NCHW (CHWN will be transposed)
primitives[L_I] = (long long)lt_in_NCHW;
primitives[L_O] = (long long)lt_out_NCHW;
primitives[L_W] = (long long)lt_filter;
primitives[L_B] = (long long)lt_bias_CHWN;
primitives[L_F_I] = (long long)lt_in_f;
primitives[L_F_O] = (long long)lt_out_f;
primitives[L_F_W] = (long long)lt_filter_f;
primitives[L_F_B] = (long long)lt_bias_f;
primitives[L_BD_I] = (long long)lt_in_bdata;
primitives[L_BD_O] = (long long)lt_out_bdata;
primitives[L_BD_W] = (long long)lt_filter_bdata;
primitives[L_BF_I] = (long long)lt_in_bfilter;
primitives[L_BF_O] = (long long)lt_out_bfilter;
primitives[L_BF_W] = (long long)lt_filter_bfilter;
primitives[L_I_CHWN] = (long long)lt_in_CHWN;
primitives[L_O_CHWN] = (long long)lt_out_CHWN;
primitives[L_B_B] = (long long)lt_bias_bias;
primitives[L_B_O] = (long long)lt_out_bias;
//input may have user layout (from raw image data,continuous NCHW )
// or maybe mkl layout (is previous mkl-based layer's output)
dnnLayout_t lt_in_real = (dnnLayout_t)input[MKLLayout];
if(lt_in_real==NULL) lt_in_real = lt_in_NCHW;
//create conversion and buff if necessary
dnnPrimitive_t cv_in_f = NULL; float * buf_in_f = NULL;
CHECK_ERR( try_convert(&cv_in_f, &buf_in_f, lt_in_real, lt_in_f) , err );
//create transpose if necessary
float* newPtr = NULL;
if (input[MKLLayout] == 0)
{
newPtr = (float*)malloc(inC*inH*inW*N*sizeof(float));
}
primitives[BUFFER_TRANS_INPUT] = (long long)newPtr;
//save conversion and buff
primitives[BUFFER_FORWARD_INPUT] = (long long)buf_in_f;
primitives[CONVERT_FORWARD_INPUT] = (long long)cv_in_f;
//filter layout
dnnPrimitive_t cv_filter_f = NULL; float * buf_filter_f = NULL;
CHECK_ERR( try_convert(&cv_filter_f, &buf_filter_f, lt_filter, lt_filter_f), err );
primitives[CONVERT_FORWARD_FILTER] = (long long)cv_filter_f;
primitives[BUFFER_FORWARD_FILTER] = (long long)buf_filter_f;
//save user layout for output, and create mkl buffer
//output always has mkl buffer and recorded in layer's primitive
output[CPULayout] = (long long)lt_out_CHWN;
float* buf_out_f = NULL;
CHECK_ERR( dnnAllocateBuffer_F32((void**)(&buf_out_f), lt_out_f), err );
primitives[BUFFER_FORWARD_OUTPUT] = (long long)buf_out_f;
//for bias
dnnPrimitive_t cv_bias_f = NULL; float * buf_bias_f = NULL;
dnnPrimitive_t cv_bias_b = NULL; float * buf_bias_b = NULL;
if (hasBias)
{
CHECK_ERR( try_convert(&cv_bias_f, &buf_bias_f, lt_bias_CHWN, lt_bias_f), err );
}
primitives[CONVERT_FORWARD_BIAS] = (long long)cv_bias_f;
primitives[BUFFER_FORWARD_BIAS] = (long long)buf_bias_f;
return 0;
ERR_RETURN:
return 1;
}
