'''卷积层 & 池化层
每次我们采样一个跟权重一样大小的窗口，让它跟权重做按元素的乘法然后相加。通常我们也是用卷积的术语把这个窗口叫kernel或者filter。
stride移动窗口步伐大小
pad在边缘填充窗口大小
当输入数据有多个通道的时候，每个通道会有对应的权重，然后会对每个通道做卷积之后在通道之间求和
当输入需要多通道时，每个输出通道有对应权重，然后每个通道上做卷积。
池化层能够很好的缓解卷积层位置敏感问题。它跟卷积类似每次看一个小窗口，然后选出窗口里面最大的元素，或者平均元素作为输出
'''
#卷积层
# 输入输出数据格式是 batch x channel x height x width，这里batch和channel都是1
# 权重格式是 output_channels x in_channels x height x width，这里input_filter和output_filter都是1。
w = nd.arange(4).reshape((1,1,2,2))
b = nd.array([1])
data = nd.arange(9).reshape((1,1,3,3))
out = nd.Convolution(data, w, b, kernel=w.shape[2:], num_filter=w.shape[0])
#移动窗口
out = nd.Convolution(data, w, b, kernel=w.shape[2:], num_filter=w.shape[0],
stride=(2,2), pad=(1,1))
#输入多通道（注意weight，data大小变了）
w = nd.arange(8).reshape((1,2,2,2))
data = nd.arange(18).reshape((1,2,3,3))
out = nd.Convolution(data, w, b, kernel=w.shape[2:], num_filter=w.shape[0])
#输出多通道（注意weight，bias，data，out大小都变了）
w = nd.arange(16).reshape((2,2,2,2))
data = nd.arange(18).reshape((1,2,3,3))
def net(X, is_training=True, debug=False):
########################
# Define the computation of the first convolutional layer
########################
h1_conv = nd.Convolution(data=X,
weight=W1,
bias=b1,
kernel=(3, 3),
num_filter=20)
h1_normed = batch_norm(h1_conv,
gamma1,
beta1,
scope_name='bn1',
is_training=is_training)
h1_activation = relu(h1_normed)
h1 = nd.Pooling(data=h1_activation,
pool_type="avg",
kernel=(2, 2),
stride=(2, 2))
if debug:
print("h1 shape: %s" % (np.array(h1.shape)))
########################
# Define the computation of the second convolutional layer
########################
h2_conv = nd.Convolution(data=h1,
weight=W2,
bias=b2,
kernel=(5, 5),
num_filter=50)
h2_normed = batch_norm(h2_conv,
gamma2,
beta2,
scope_name='bn2',
is_training=is_training)
h2_activation = relu(h2_normed)
h2 = nd.Pooling(data=h2_activation,
pool_type="avg",
kernel=(2, 2),
stride=(2, 2))
if debug:
print("h2 shape: %s" % (np.array(h2.shape)))
########################
# Flattening h2 so that we can feed it into a fully-connected layer
########################
h2 = nd.flatten(h2)
if debug:
print("Flat h2 shape: %s" % (np.array(h2.shape)))
########################
# Define the computation of the third (fully-connected) layer
########################
h3_linear = nd.dot(h2, W3) + b3
h3_normed = batch_norm(h3_linear,
gamma3,
beta3,
scope_name='bn3',
is_training=is_training)
h3 = relu(h3_normed)
if debug:
print("h3 shape: %s" % (np.array(h3.shape)))
########################
# Define the computation of the output layer
########################
yhat_linear = nd.dot(h3, W4) + b4
if debug:
print("yhat_linear shape: %s" % (np.array(yhat_linear.shape)))
return yhat_linear
#!/usr/bin/env python #coding:utf-8 #author: chengfu.wcy from mxnet import nd w = nd.arange(4).reshape((1, 1, 2, 2)) b = nd.array([1]) data = nd.arange(9).reshape((1, 1, 3, 3)) out = nd.Convolution(data, w, b, kernel=w.shape[2:], num_filter=w.shape[1]) print data print w print b print out
def flowdr(dem_fill,NoData,rows,cols,ctx,switch):
ingrid = np.indices((rows, cols))
ingrid[0] # row indices
ingrid[1] # column indices
ingridxmx=nd.array(ingrid[1],ctx[0]).reshape((1,1,rows, cols))
ingridymx=nd.array(ingrid[0],ctx[0]).reshape((1,1,rows, cols))
dem_fillmx=nd.array(dem_fill,ctx[0])
demmx=dem_fillmx.reshape((1,1,rows, cols))
res=1
l=[0,1,2,3,4,5,6,7,0]
direct=[1,2,4,8,16,32,64,128]
direct_d=[[1,3],[2,6],[4,12],[8,24],[16,48],[32,96],[64,192],[128,129]]
weight=[None]*8
weight1=[None]*8
convx=[None]*8
convy=[None]*8
convz=[None]*8
runlen=[1,ma.pow(2,0.5),1,ma.pow(2,0.5),1,ma.pow(2,0.5),1,ma.pow(2,0.5)]*res
n = [[[] for x in range(3)] for x in range(8)]#create list to store normal vectors for each facet
s = [None]*8
d = [None]*8
weight[0] = nd.array([[0, 0, 0], [0, 1, -1], [0, 0, 0]], gpu(0))
weight[1] = nd.array([[0, 0, -1], [0, 1, 0], [0, 0, 0]], gpu(0))
weight[2] = nd.array([[0, -1, 0], [0, 1, 0], [0, 0, 0]], gpu(0))
weight[3] = nd.array([[-1, 0, 0], [0, 1, 0], [0, 0, 0]], gpu(0))
weight[4] = nd.array([[0, 0, 0], [-1, 1, 0], [0, 0, 0]], gpu(0))
weight[5] = nd.array([[0, 0, 0], [0, 1, 0], [-1, 0, 0]], gpu(0))
weight[6] = nd.array([[0, 0, 0], [0, 1, 0], [0, -1, 0]], gpu(0))
weight[7] = nd.array([[0, 0, 0], [0, 1, 0], [0, 0, -1]], gpu(0))
weight1[0] = nd.array([[0, 0, 0], [0, 1, -10], [0, 0, 0]], gpu(0))
weight1[1] = nd.array([[0, 0, -10], [0, 1, 0], [0, 0, 0]], gpu(0))
weight1[2] = nd.array([[0, -10, 0], [0, 1, 0], [0, 0, 0]], gpu(0))
weight1[3] = nd.array([[-10, 0, 0], [0, 1, 0], [0, 0, 0]], gpu(0))
weight1[4] = nd.array([[0, 0, 0], [-10, 1, 0], [0, 0, 0]], gpu(0))
weight1[5] = nd.array([[0, 0, 0], [0, 1, 0], [-10, 0, 0]], gpu(0))
weight1[6] = nd.array([[0, 0, 0], [0, 1, 0], [0, -10, 0]], gpu(0))
weight1[7] = nd.array([[0, 0, 0], [0, 1, 0], [0, 0, -10]], gpu(0))
d0=nd.zeros((rows, cols),ctx[0],dtype='float32')
dd=nd.zeros((rows, cols),ctx[0],dtype='float32')
d_flat=nd.zeros((rows, cols),ctx[0],dtype='float32')
flat=nd.zeros((rows, cols),ctx[0],dtype='float32')
dep=nd.zeros((rows, cols),ctx[0],dtype='float32')
high=nd.zeros((rows, cols),ctx[0],dtype='float32')
fd=nd.zeros((rows, cols),ctx[0],dtype='float32')-999
d_compact=nd.zeros((rows, cols),ctx[0],dtype='float32')-1
for i in range(0,8):
w=weight[i].reshape((1, 1, 3, 3))
convz[i] = nd.Convolution(data=demmx, weight=w, kernel=(3,3), no_bias=True, num_filter=1,pad=(1,1),cudnn_tune='off')
convz[i]=convz[i][0,0,:,:]
if switch==1 or 3:
convx[i] = nd.Convolution(data=ingridxmx, weight=w, kernel=(3,3), no_bias=True, num_filter=1,pad=(1,1),cudnn_tune='off')
convy[i] = nd.Convolution(data=ingridymx, weight=w, kernel=(3,3), no_bias=True, num_filter=1,pad=(1,1),cudnn_tune='off')
convx[i]=convx[i][0,0,:,:]
convy[i]=convy[i][0,0,:,:]
if switch==1 or 3:
for p in range(0,8):#8 facets from N-NE clockwise
l0=l[p]
l1=l[p+1]
d[l0]=d0-999#Nodata value
dmax=d0-999
smax=d0-999
n[l0][0]= convz[l0]*convy[l1]-convz[l1]*convy[l0]#nx
n[l0][1]= convz[l0]*convx[l1]-convz[l1]*convx[l0]#ny
n[l0][2]= convy[l0]*convx[l1]-convy[l1]*convx[l0]#nz
#make boolean mask to determine direction d and slope s
d[l0]=nd.where(condition=((n[l0][0]==0)*(n[l0][1]>=0)),x=d0,y=d[l0])
d[l0]=nd.where(condition=((n[l0][0]==0)*(n[l0][1])<0),x=d0+ma.pi,y=d[l0])
d[l0]=nd.where(condition=(n[l0][0]>0),x=ma.pi/2-nd.arctan(n[l0][1]/n[l0][0]),y=d[l0])
d[l0]=nd.where(condition=(n[l0][0]<0),x=3*ma.pi/2-nd.arctan(n[l0][1]/n[l0][0]),y=d[l0])
d[l0]=nd.where(condition=((convz[l0]<=0)*(convz[l1]<=0)),x=dmax,y=d[l0])
s[l0]=-nd.tan(nd.arccos(n[l0][2]/(nd.sqrt(nd.square(n[l0][0])+nd.square(n[l0][1])+nd.square(n[l0][2])))))#slope of the triangular facet
s[l0]=nd.where(condition=((convz[l0]<=0)*(convz[l1]<=0)),x=smax,y=s[l0])
#Modify the scenario when the steepest slope is outside the 45 range of each facet
dmax=nd.where(condition=((convz[l0]/runlen[l0]>=convz[l1]/runlen[l0])*(convz[l0]>0)),x=d0+ma.pi*l0/4,y=dmax)
dmax=nd.where(condition=((convz[l0]/runlen[l0]<convz[l1]/runlen[l0])*(convz[l1]>0)),x=d0+ma.pi*(l0+1)/4,y=dmax)
smax=nd.where(condition=((convz[l0]>=convz[l1])*(convz[l0]>0)),x=convz[l0]/runlen[l0],y=smax)
smax=nd.where(condition=((convz[l0]<convz[l1])*(convz[l1]>0)),x=convz[l1]/runlen[l1],y=smax)
d[l0]=nd.where(condition=((d[l0]<ma.pi*l0/4)+(d[l0]>ma.pi*l1/4)),x=dmax,y=d[l0])
s[l0]=nd.where(condition=((d[l0]<ma.pi*l0/4)+(d[l0]>ma.pi*l1/4)),x=smax,y=s[l0])
if switch==1:
#flat and depressions indicator grid
flat=(convz[l0]==0)+flat
dep=(convz[l0]<0)+dep
high=(convz[l0]>0)+high
for q in range(0,8):#check if the 45 degree range angles need to be maintaied, otherwise delete (set to NoData)
l0=l[q]
l1=l[q+1]
l2=l[q-1]
dmax=d0-999
if q==0:
dmax=nd.where(condition=(d[0]==d[1]),x=d[0],y=dmax)
dmax=nd.where(condition=(d[0]==d[7]),x=d[0],y=dmax)
d[0]=nd.where(condition=((d[0]==ma.pi*l0/4)+(d[0]==ma.pi*l1/4)),x=dmax,y=d[0])
else:
dmax=nd.where(condition=(d[l0]==d[l1]),x=d[l0],y=dmax)
dmax=nd.where(condition=(d[l0]==d[l2]),x=d[l0],y=dmax)
d[l0]=nd.where(condition=((d[l0]==ma.pi*l0/4)+(d[l0]==ma.pi*l1/4)),x=dmax,y=d[l0])
#Check if flat or surface depression area. then lable with -1 or -10 respectively
if switch==1:
fd=nd.where(condition=(flat==8),x=d0-2,y=fd)#flats
fd=nd.where(condition=(dep>=1)*(high==0),x=d0-3,y=fd)#high edge
high_zero=nd.where(condition=(high==0),x=d0+1,y=d0)
for j in range (0,8):
if switch==1 or switch==2:
d_flat=nd.where(condition=(convz[j]==0),x=d0+direct[j],y=d0)+d_flat
if switch==1:
flat_near=nd.where(condition=(convz[j]==0),x=d0+5,y=d0)
dd1=high_zero+flat_near
w=weight1[j].reshape((1, 1, 3, 3))
dd1=dd1.reshape((1,1,rows, cols))
conv_near= nd.Convolution(data=dd1, weight=w, kernel=(3,3), no_bias=True, num_filter=1,pad=(1,1),cudnn_tune='off')
conv_near= conv_near[0,0,:,:]
dd=nd.where(condition=(conv_near==-5)+(conv_near==-59)+(conv_near==-54)+(conv_near==-4),x=d0+1,y=d0)+dd
if switch==1 or switch==3:
d_compact=nd.where(condition=(d[j]==ma.pi*j/4),x=d0+direct_d[j][0],y=d_compact)
d_compact=nd.where(condition=(d[j]>j*ma.pi/4)*(d[j]<(j+1)*ma.pi/4),x=d0+direct_d[j][1],y=d_compact)
if switch==1 or switch==3:
d_compact=nd.where(condition=(dem_fillmx==d0+NoData),x=d0-999,y=d_compact)#NoData
if switch==1:
fd=nd.where(condition=(dd>=1)*(high>=1),x=d0-1,y=fd)#low edge
fd=nd.where(condition=(dep==8),x=d0-10,y=fd)#lowest points in depressions
return (fd.asnumpy(),d_compact.asnumpy(),d_flat.asnumpy())
if switch==2:
return (d_flat.asnumpy())
if switch==3:
return (d_compact.asnumpy())
def forward(self, is_train, req, in_data, out_data, aux):
if is_train:
x = in_data[0]
w = in_data[1]
int_w = in_data[3]
y = out_data[0]
# print(self.no_bias)
quan_x, x_shift_bit = self.int_quantize(x)
quan_w, w_shift_bit = self.int_quantize(w)
self.assign(in_data[3], req[0], quan_w)
# print(quan_x.sum(), quan_w)
if self.no_bias:
y[:] = nd.Convolution(data=quan_x,
weight=quan_w,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
else:
b = in_data[2]
int_b = in_data[4]
quan_b, b_shift_bit = self.int_quantize(b)
y = nd.Convolution(data=quan_x,
weight=quan_w,
bias=quan_b,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
self.assign(in_data[4], req[0], quan_b)
self.assign(out_data[0], req[0], mx.nd.array(y))
else:
x = in_data[0]
int_w = in_data[3]
y = out_data[0]
quan_x, x_shift_bit = self.int_quantize(x)
if self.no_bias:
y[:] = nd.Convolution(data=quan_x,
weight=int_w,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
else:
int_b = in_data[4]
y = nd.Convolution(data=quan_x,
weight=int_w,
bias=int_b,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
self.assign(out_data[0], req[0], mx.nd.array(y))
def nms_attention_nd(roi_feat,
position_mat,
nms_pair_pos_fc1_1_weight,
nms_pair_pos_fc1_1_bias,
nms_query_1_weight,
nms_query_1_bias,
nms_key_1_weight,
nms_key_1_bias,
nms_linear_out_1_weight,
nms_linear_out_1_bias,
num_rois,
dim=(1024, 1024, 1024),
fc_dim=(64, 16),
feat_dim=1024,
group=16,
index=1):
""" Attetion module with vectorized version
Args:
roi_feat: [num_rois, num_fg_classes, feat_dim]
position_mat: [num_fg_classes, num_rois, num_rois, 4]
num_rois: number of rois
dim: key, query and linear_out dim
fc_dim:
feat_dim:
group:
index:
Returns:
output: [num_rois, num_fg_classes, fc_dim]
"""
dim_group = (dim[0] / group, dim[1] / group, dim[2] / group)
roi_feat = nd.transpose(roi_feat, axes=(1, 0, 2))
# roi_feat_reshape, [num_fg_classes*num_rois, feat_dim]
roi_feat_reshape = nd.Reshape(roi_feat, shape=(-3, -2))
# position_embedding, [num_fg_classes, num_rois, num_rois, fc_dim[0]]
position_embedding = extract_pairwise_multi_position_embedding_nd(
position_mat, fc_dim[0])
# [num_fg_classes * num_rois * num_rois, fc_dim[0]]
position_embedding_reshape = nd.Reshape(position_embedding,
shape=(-1, fc_dim[0]))
# position_feat_1, [num_fg_classes * num_rois * num_rois, fc_dim[1]]
position_feat_1 = nd.FullyConnected(name='nms_pair_pos_fc1_' + str(index),
data=position_embedding_reshape,
weight=nms_pair_pos_fc1_1_weight,
bias=nms_pair_pos_fc1_1_bias,
num_hidden=fc_dim[1])
# position_feat_1, [num_fg_classes, num_rois, num_rois, fc_dim[1]]
position_feat_1 = nd.Reshape(position_feat_1,
shape=(-1, num_rois, num_rois, fc_dim[1]))
aff_weight = nd.Activation(data=position_feat_1, act_type='relu')
# aff_weight, [num_fg_classes, fc_dim[1], num_rois, num_rois]
aff_weight = nd.transpose(aff_weight, axes=(0, 3, 1, 2))
####################### multi head in batch###########################
assert dim[0] == dim[1], 'Matrix multi requires the same dims!'
# q_data, [num_fg_classes * num_rois, dim[0]]
q_data = nd.FullyConnected(name='nms_query_' + str(index),
data=roi_feat_reshape,
weight=nms_query_1_weight,
bias=nms_query_1_bias,
num_hidden=dim[0])
# q_data, [num_fg_classes, num_rois, group, dim_group[0]]
q_data_batch = nd.Reshape(q_data,
shape=(-1, num_rois, group, dim_group[0]))
q_data_batch = nd.transpose(q_data_batch, axes=(0, 2, 1, 3))
# q_data_batch, [num_fg_classes * group, num_rois, dim_group[0]]
q_data_batch = nd.Reshape(q_data_batch, shape=(-3, -2))
k_data = nd.FullyConnected(name='nms_key_' + str(index),
data=roi_feat_reshape,
weight=nms_key_1_weight,
bias=nms_key_1_bias,
num_hidden=dim[1])
# k_data, [num_fg_classes, num_rois, group, dim_group[1]]
k_data_batch = nd.Reshape(k_data,
shape=(-1, num_rois, group, dim_group[1]))
k_data_batch = nd.transpose(k_data_batch, axes=(0, 2, 1, 3))
# k_data_batch, [num_fg_classes * group, num_rois, dim_group[1]]
k_data_batch = nd.Reshape(k_data_batch, shape=(-3, -2))
v_data = roi_feat
aff = nd.batch_dot(lhs=q_data_batch,
rhs=k_data_batch,
transpose_a=False,
transpose_b=True)
# aff_scale, [num_fg_classes * group, num_rois, num_rois]
aff_scale = (1.0 / math.sqrt(float(dim_group[1]))) * aff
assert fc_dim[1] == group, 'Check the dimensions in attention!'
# [num_fg_classes * fc_dim[1], num_rois, num_rois]
aff_weight_reshape = nd.Reshape(aff_weight, shape=(-3, -2))
# weighted_aff, [num_fg_classes * fc_dim[1], num_rois, num_rois]
weighted_aff = nd.log(nd.maximum(aff_weight_reshape, 1e-6)) + aff_scale
# aff_softmax, [num_fg_classes * fc_dim[1], num_rois, num_rois]
aff_softmax = nd.softmax(data=weighted_aff,
axis=2,
name='nms_softmax_' + str(index))
aff_softmax_reshape = nd.Reshape(aff_softmax,
shape=(-1, fc_dim[1] * num_rois, 0))
# output_t, [num_fg_classes, fc_dim[1] * num_rois, feat_dim]
output_t = nd.batch_dot(lhs=aff_softmax_reshape, rhs=v_data)
# output_t_reshape, [num_fg_classes, fc_dim[1], num_rois, feat_dim]
output_t_reshape = nd.Reshape(output_t,
shape=(-1, fc_dim[1], num_rois, feat_dim))
# output_t_reshape, [fc_dim[1], feat_dim, num_rois, num_fg_classes]
output_t_reshape = nd.transpose(output_t_reshape, axes=(1, 3, 2, 0))
# output_t_reshape, [1, fc_dim[1] * feat_dim, num_rois, num_fg_classes]
output_t_reshape = nd.Reshape(output_t_reshape,
shape=(1, fc_dim[1] * feat_dim, num_rois,
-1))
linear_out = nd.Convolution(name='nms_linear_out_' + str(index),
data=output_t_reshape,
weight=nms_linear_out_1_weight,
bias=nms_linear_out_1_bias,
kernel=(1, 1),
num_filter=dim[2],
num_group=fc_dim[1])
# [dim[2], num_rois, num_fg_classes]
linear_out_reshape = nd.Reshape(linear_out, shape=(dim[2], num_rois, -1))
# [num_rois, num_fg_classes, dim[2]]
output = nd.transpose(linear_out_reshape, axes=(1, 2, 0))
return output
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
dx = in_grad[0]
dw = in_grad[1]
x = in_data[0]
w = in_data[1]
# b = in_data[2]
# w = in_data[3]
# quan_b = in_data[4]
x_shift_bit = in_data[5]
dy = out_grad[0]
# x, x_shift_bit = self.int_quantize(x)
quan_w, w_shift_bit = self.int_quantize(w)
y = out_data[0]
if self.no_bias:
x.attach_grad(), quan_w.attach_grad()
with autograd.record():
y[:] = nd.Convolution(data=x,
weight=quan_w,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
dx, dw = autograd.grad(y, [x, quan_w], dy, retain_graph=True)
y, y_shift_bit = self.int_quantize(y)
# print(y_shift_bit)
# y_shift_bit = (x_shift_bit * 0.3 + y_shift_bit * 0.7).floor()
self.assign(in_grad[0], req[0], dx / (2**y_shift_bit))
self.assign(in_grad[1], req[0], dw / (2**w_shift_bit))
self.assign(in_data[3], req[0], quan_w)
# self.assign(in_data[3], req[0], quan_b)
self.assign(in_data[5], req[0], y_shift_bit)
else:
b = in_data[2]
b, b_shift_bit = self.int_quantize(b)
x.attach_grad(), w.attach_grad(), b.attach_grad()
with autograd.record():
y[:] = nd.Convolution(data=x,
weight=w,
bias=b,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
dx, dw, db = autograd.grad(y, [x, w, b], dy, retain_graph=True)
self.assign(in_grad[0], req[0], dx / (2**x_shift_bit))
self.assign(in_grad[1], req[0], dw / (2**w_shift_bit))
self.assign(in_grad[2], req[0], db / (2**b_shift_bit))
self.assign(in_data[2], req[0], quan_w)
self.assign(in_data[3], req[0], quan_b)
self.assign(in_data[4], req[0], x_shift_bit)
self.assign(in_data[5], req[0], y_shift_bit)
def forward(self, is_train, req, in_data, out_data, aux):
if is_train:
x = in_data[0]
w = in_data[1]
quan_w = in_data[3]
quan_b = in_data[4]
x_shift_bit = in_data[5]
#if x.max() > 127 or x.min() < -128:
# print('False')
y = out_data[0]
last_shift_bit = out_data[1]
if self.no_bias:
quan_w, w_shift_bit = self.int_quantize(w)
y[:] = nd.Convolution(data=x,
weight=quan_w,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
else:
b = in_data[2]
quan_w, quan_b, w_shift_bit = self.int_quantize_double(w, b)
y = nd.Convolution(data=quan_x,
weight=quan_w,
bias=quan_b,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
y, y_shift_bit = self.int_quantize(y)
self.assign(out_data[0], req[0], mx.nd.array(y))
self.assign(out_data[1], req[0], mx.nd.array(y_shift_bit))
else:
quan_x = in_data[0]
w = in_data[1]
quan_w = in_data[3]
y_shift_bit = in_data[5]
y = out_data[0]
# quan_x, x_shift_bit = self.int_quantize(x)
if self.no_bias:
quan_w_2, w_shift_bit = self.int_quantize(w)
# print('sum', (quan_w_2 != quan_w).sum())
# self.assign(in_data[1], req[0], quan_w)
y[:] = nd.Convolution(data=quan_x,
weight=quan_w_2,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
# y, y_shift_bit = self.int_quantize(y)
# print('----------------int conv------------------')
# print(y)
else:
b = in_data[2]
quan_w, quan_b, w_shift_bit = self.int_quantize_double(w, b)
y = nd.Convolution(data=quan_x,
weight=quan_w,
bias=quan_b,
kernel=self.kernel,
num_filter=self.num_filter,
stride=self.stride,
pad=self.pad,
no_bias=self.no_bias,
workspace=self.workspace,
name=self.name)
y = (y * (2**y_shift_bit)).floor()
self.assign(out_data[0], req[0], mx.nd.array(y))
self.assign(out_data[1], req[0], y_shift_bit)
def _forward(self, data, weight, bias=None):
kwargs = self._kwargs.copy()
kwargs['no_bias'] = bias is None
return nd.Convolution(data, weight, bias, name='fwd', **kwargs)
