def function_set(self): # 第一层卷积 # 卷积 h1_conv = nd.Convolution( data=self.__batch_X, weight=self.__W1, bias=self.__b1, kernel=self.__W1.shape[2:], num_filter=self.__W1.shape[0]) # 激活 h1_activation = nd.relu(h1_conv) # 池化 h1 = nd.Pooling(data=h1_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) # 第二层卷积 h2_conv = nd.Convolution( data=h1, weight=self.__W2, bias=self.__b2, kernel=self.__W2.shape[2:], num_filter=self.__W2.shape[0]) h2_activation = nd.relu(h2_conv) h2 = nd.Pooling(data=h2_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) h2 = nd.flatten(h2) # 第一层全连接 h3_linear = nd.dot(h2, self.__W3) + self.__b3 h3 = nd.relu(h3_linear) # 第二层全连接 h4_linear = nd.dot(h3, self.__W4) + self.__b4 # print("1st conv block:", h1.shape) # print("2nd conv block:", h2.shape) # print("1st dense:", h3.shape) # print("2nd dense:", h4_linear.shape) # print("output:", h4_linear) return h4_linear
def net(X, verbose=False): X = X.as_in_context(W1.context) # 第一层卷积 h1_conv = nd.Convolution(data=X, weight=W1, bias=b1, kernel=W1.shape[2:], num_filter=W1.shape[0]) h1_activation = nd.relu(h1_conv) h1 = nd.Pooling(data=h1_activation, pool_type='max', kernel=(2, 2), stride=(2, 2)) # 第二层卷积 h2_conv = nd.Convolution(data=h1, weight=W2, bias=b2, kernel=W2.shape[2:], num_filter=W2.shape[0]) h2_activation = nd.relu(h2_conv) h2 = nd.Pooling(h2_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) h2 = nd.flatten(h2) # 第一层全连接 h3_linear = nd.dot(h2, W3) + b3 h3 = nd.relu(h3_linear) # 第二层全连接 h4_linear = nd.dot(h3, W4) + b4 if verbose: print('1st conv block', h1.shape) print('2nd conv block', h2.shape) print('1st conv block', h3.shape) print('2nd conv block', h4_linear.shape) print('output:', h4_linear) return h4_linear
def function_set(self): def batch_norm(X, gamma, beta, is_training, moving_mean, moving_variance, eps=1e-5, moving_momentum=0.9): assert len(X.shape) in (2, 4) # 全连接: batch_size x feature if len(X.shape) == 2: # 每个输入维度在样本上的平均和方差 mean = X.mean(axis=0) variance = ((X - mean) ** 2).mean(axis=0) # 2D卷积: batch_size x channel x height x width else: # 对每个通道算均值和方差,需要保持 4D 形状使得可以正确的广播 mean = X.mean(axis=(0, 2, 3), keepdims=True) variance = ((X - mean) ** 2).mean(axis=(0, 2, 3), keepdims=True) # 变形使得可以正确的广播 moving_mean = moving_mean.reshape(mean.shape) moving_variance = moving_variance.reshape(mean.shape) # 均一化 if is_training: X_hat = (X - mean) / nd.sqrt(variance + eps) # !!! 更新全局的均值和方差 # 每一个 batch_X 都会使用上个 batch_X 的 0.9 与 这个 batch_X 的 0.1 moving_mean[:] = moving_momentum * moving_mean + (1.0 - moving_momentum) * mean moving_variance[:] = moving_momentum * moving_variance + (1.0 - moving_momentum) * variance else: # !!! 测试阶段使用全局的均值和方差 X_hat = (X - moving_mean) / nd.sqrt(moving_variance + eps) # 拉升和偏移 return gamma.reshape(mean.shape) * X_hat + beta.reshape(mean.shape) # 第一层卷积 h1_conv = nd.Convolution( data=self.__batch_X, weight=self.__W1, bias=self.__b1, kernel=(5, 5), num_filter=20) # 第一个 BN h1_bn = batch_norm( h1_conv, self.__gamma1, self.__beta1, self.__is_training, self.__moving_mean1, self.__moving_variance1) h1_activation = nd.relu(h1_bn) h1 = nd.Pooling( data=h1_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) # 第二层卷积 h2_conv = nd.Convolution( data=h1, weight=self.__W2, bias=self.__b2, kernel=(3, 3), num_filter=50) # 第二个 BN h2_bn = batch_norm( h2_conv, self.__gamma2, self.__beta2, self.__is_training, self.__moving_mean2, self.__moving_variance2) h2_activation = nd.relu(h2_bn) h2 = nd.Pooling(data=h2_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) h2 = nd.flatten(h2) # 第一层全连接 h3_linear = nd.dot(h2, self.__W3) + self.__b3 h3 = nd.relu(h3_linear) # 第二层全连接 h4_linear = nd.dot(h3, self.__W4) + self.__b4 return h4_linear
def sc(X, W, attr): xshp, wshp = X.shape, W.shape C, OC, IC = xshp[1], wshp[0], wshp[1] assert C >= IC and C % IC == 0 and C // IC == eval(attr['num_group']) num_group = C // IC assert num_group == eval(attr['num_group']) and \ OC >= num_group and OC % num_group == 0 xs = sym_slice(X, 1, 1) ws = kernel_slice_2d(W) OPG = OC // num_group nattr = attr.copy() nattr['num_group'] = '1' nattr['num_filter'] = '1' nodes = [] for o in range(OC): nnodes = [] j = int(o/OPG)*IC for i in range(IC): xoi, woi = xs[i+j], ws[o][i] yoi = nd.Convolution(xoi, woi, **nattr) nnodes.append(yoi) if len(nnodes) > 1: zi = nd.add_n(*nnodes) else: zi = nnodes[0] nodes.append(zi) return nd.concat(*nodes, dim=1)
def test_conv2d(): print("test conv2d") batch = np.random.randint(low=1, high=32) i_c = np.random.randint(low=1, high=32) i_h = np.random.randint(low=7, high=256) i_w = np.random.randint(low=7, high=256) xshape = (batch, i_c, i_h, i_w) print(xshape) x = np.random.randint(low=-127, high=127, size=xshape) o_c = np.random.randint(low=1, high=1024) f_h = 3 f_w = 3 wshape = (o_c, i_c, f_h, f_w) print(wshape) w = np.random.randint(low=-127, high=127, size=wshape) stride = (1, 1) padding = (0, 0) dilation = (1, 1) kernel_size = (f_h, f_w) o_h = (i_h + 2 * padding[0] - f_h) / stride[0] + 1 o_w = (i_w + 2 * padding[1] - f_w) / stride[1] + 1 oshape = (batch, o_c, o_h, o_w) params = { 'stride': stride, 'pad': padding, 'dilate': dilation, 'kernel': kernel_size, 'num_filter': o_c } y = nd.Convolution(nd.array(x), nd.array(w), None, **params)
def _compute_block_mask(self, mask): weight_mat = nd.ones(48 * self.block_size * self.block_size) weight_mat = weight_mat.reshape( [48, 1, self.block_size, self.block_size]) block_mask = nd.Convolution(data=mask, no_bias=True, weight=weight_mat, num_filter=48, kernel=(3, 3), pad=(int(np.ceil(self.block_size) / 2 + 1), int(np.ceil(self.block_size) / 2 + 1))) # compute mask area delta = self.block_size // 2 input_height = mask.shape[2] + delta * 2 input_width = mask.shape[3] + delta * 2 height_to_crop = block_mask.shape[2] - input_height width_to_crop = block_mask.shape[3] - input_width #print height_to_crop #print width_to_crop if height_to_crop != 0: block_mask = block_mask[:, :, :-height_to_crop, :] if width_to_crop != 0: block_mask = block_mask[:, :, :, :-width_to_crop] block_mask = 1 - block_mask return block_mask
def fwd_conv2d_groupwise(*data, **attrs): assert len(data) == 2 num_group = attrs['num_group'] assert num_group == 1, \ "currently only support num_group = 1, provided {}".format(num_group) X, W = data # reshape weight OC, IC = W.shape[:2] W = nd.transpose(W, axes=(1, 0, 2, 3)) rshp = ( OC * IC, 1, ) + W.shape[2:] W = W.reshape(rshp) # convert to groupwise conv attrs['num_group'] = IC attrs['num_filter'] = IC * OC out = nd.Convolution(X, W, **attrs) # sum axis YH, YW = out.shape[-2:] N = X.shape[0] rshp = (N, IC, OC, YH, YW) out = out.reshape(rshp) out = nd.sum(out, axis=1) return out
def net(X, verbose=False): X = X.as_in_context(W1.context) # 第一个卷积层 h1_conv = nd.Convolution(data=X, weight=W1, bias=b1, kernel=W1.shape[2:], num_filter=W1.shape[0]) h1_activation = nd.relu(h1_conv) h1 = nd.Pooling(data=h1_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) # h1_conv.shape: (256, 20, 24, 24) # h1.shape: (256, 20, 12, 12) #print('h1_conv.shape: ',h1_conv.shape) #print('h1.shape: ',h1.shape) # 第二个卷积层 h2_conv = nd.Convolution(data=h1, weight=W2, bias=b2, kernel=W2.shape[2:], num_filter=W2.shape[0]) h2_activation = nd.relu(h2_conv) h2 = nd.Pooling(data=h2_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) h2 = nd.flatten(h2) # 第一个全连接层 h3_linear = nd.dot(h2, W3) + b3 h3 = nd.relu(h3_linear) # 第二个全连接层 h4_linear = nd.dot(h3, W4) + b4 if verbose: print('1st conv block:', h1.shape) print('2nd conv block:', h2.shape) print('1st dense block:', h3.shape) print('2nd dense block:', h4_linear.shape) print('output:', h4_linear) return h4_linear
def forward(self, x): inp = x.shape[1] oup = self.width_opt[self.idx] x = nd.Convolution(x, weight=self.conv_weight.data()[:oup,:inp,:,:], kernel=(3, 3), stride=self.stride, pad=(1, 1), num_filter=oup, no_bias=True) x = nd.BatchNorm(x, self.gamma[self.idx].data(), self.beta[self.idx].data(), self.moving_mean[self.idx].data(), self.moving_var[self.idx].data()) x = nd.Activation(x, act_type='relu') return x
def network(self, X=None, debug=False,): filters, kernels, stride, padding, dilate = self.conv_params['num_filter'], self.conv_params['kernel'], \ self.conv_params['stride'], self.conv_params['padding'], self.conv_params['dilate'] type_pool, kernels_pool, stride_pool, padding_pool, dilate_pool = self.pool_params['pool_type'], \ self.pool_params['kernel'], self.pool_params['stride'], \ self.pool_params['padding'], self.pool_params['dilate'] act_type = self.act_params['act_type'] hidden_dim = self.fc_params['hidden_dim'] # CNN ########################################################################################################## convlayer_out = X interlayer = [] for i, (nf, k, S, P, D, t_p, k_p, S_p, P_p, D_p, a) in enumerate(zip(filters, kernels, stride, padding, dilate, type_pool, kernels_pool, stride_pool, padding_pool, dilate_pool, act_type)): W, b = self.params['W{:d}'.format(i+1,)], self.params['b{:d}'.format(i+1,)] convlayer_out = nd.Convolution(data = convlayer_out, weight=W, bias=b, kernel=k, num_filter=nf, stride=S, dilate=D) convlayer_out = activation(convlayer_out, act_type = a) convlayer_out = nd.Pooling(data=convlayer_out, pool_type=t_p, kernel=k_p, stride=S_p, pad=P_p) interlayer.append(convlayer_out) i_out = i if debug: print("layer{:d} shape: {}".format(i+1, convlayer_out.shape)) # MLP ########################################################################################################## FClayer_out = nd.flatten(convlayer_out) interlayer.append(FClayer_out) if debug: print("After Flattened, Data shape: {}".format(FClayer_out.shape)) for j, (hd, a) in enumerate(zip(hidden_dim, act_type[-len(hidden_dim):])): W, b = self.params['W{:d}'.format(j+i_out+2,)], self.params['b{:d}'.format(j+i_out+2,)] FClayer_out = nd.dot(FClayer_out, W) + b FClayer_out = activation(FClayer_out, act_type = a) if autograd.is_training(): # 对激活函数的输出使用droupout FClayer_out = dropout(FClayer_out, self.drop_prob) if debug: print("layer{:d} shape: {}".format(j+i_out+2, FClayer_out.shape)) interlayer.append(FClayer_out) j_out = j # OUTPUT ########################################################################################################## W, b = self.params['W{:d}'.format(j_out+i_out+3,)], self.params['b{:d}'.format(j_out+i_out+3,)] yhat = nd.dot(FClayer_out, W) + b if debug: print("Output shape: {}".format(yhat.shape)) print('------------') interlayer.append(yhat) return yhat, interlayer
def net(x, is_training=False, verbose=False): x = x.as_in_context(w1.context) h1_conv = nd.Convolution(data=x, weight=w1, bias=b1, kernel=w1.shape[2:], num_filter=c1) h1_bn = utils.batch_norm(h1_conv, gamma1, beta1, is_training, moving_mean1, moving_variance1) h1_activation = nd.relu(h1_conv) h1 = nd.Pooling(data=h1_activation, pool_type='max', kernel=(2, 2), stride=(2, 2)) h2_conv = nd.Convolution(data=h1, weight=w2, bias=b2, kernel=w2.shape[2:], num_filter=c2) h2_bn = utils.batch_norm(h2_conv, gamma2, beta2, is_training, moving_mean2, moving_variance2) h2_activation = nd.relu(h2_conv) h2 = nd.Pooling(data=h2_activation, pool_type='max', kernel=(2, 2), stride=(2, 2)) h2 = nd.flatten(h2) h3_linear = nd.dot(h2, w3) + b3 h3 = nd.relu(h3_linear) h4_linear = nd.dot(h3, w4) + b4 if verbose: print('h1 conv block: ', h1.shape) print('h2 conv block: ', h2.shape) print('h3 conv block: ', h3.shape) print('h4 conv block: ', h4_linear.shape) print('output: ', h4_linear) return h4_linear.as_in_context(ctx)
def sc(X, W, attr, ichannel, step): xshp = X.shape xs = sym_slice(X, ichannel, step) ws = sym_slice(W, ichannel, step) nodes = [] j = 0 for i in range(0, xshp[ichannel], step): yi = nd.Convolution(xs[j], ws[j], **attr) nodes.append(yi) j += 1 return nd.add_n(*nodes)
def match_templates(self, net_z, net_x): # B C H W Bz, Cz, Hz, Wz = net_z.shape Bx, Cx, Hx, Wx = net_x.shape net_final_ = nd.Convolution(data=net_x, weight=net_z, num_filter=1, kernel=[Hz, Wz], no_bias=True) net_final_ = self.bn_final(net_final_) net_final_ = np.transpose(net_final_, axes=(1, 2, 3, 0)) net_final = net_final_[0] return net_final
def network(X,drop_rate=0.0): # formula : output_size=((input−weights+2*Padding)/Stride)+1 #data size # MNIST,FashionMNIST = (batch size , 1 , 28 , 28) # CIFAR = (batch size , 3 , 32 , 32) C_H1=nd.Activation(data= nd.Convolution(data=X , weight = W1 , bias = B1 , kernel=(3,3) , stride=(1,1) , num_filter=60) , act_type="relu") # MNIST : result = ( batch size , 60 , 26 , 26) , CIFAR10 : : result = ( batch size , 60 , 30 , 30) P_H1=nd.Pooling(data = C_H1 , pool_type = "max" , kernel=(2,2), stride = (2,2)) # MNIST : result = (batch size , 60 , 13 , 13) , CIFAR10 : result = (batch size , 60 , 15 , 15) C_H2=nd.Activation(data= nd.Convolution(data=P_H1 , weight = W2 , bias = B2 , kernel=(6,6) , stride=(1,1) , num_filter=30), act_type="relu") # MNIST : result = ( batch size , 30 , 8 , 8), CIFAR10 : result = ( batch size , 30 , 10 , 10) P_H2=nd.Pooling(data = C_H2 , pool_type = "max" , kernel=(2,2), stride = (2,2)) # MNIST : result = (batch size , 30 , 4 , 4) , CIFAR10 : result = (batch size , 30 , 5 , 5) P_H2 = nd.flatten(data=P_H2) '''FullyConnected parameter • data: (batch_size, input_dim) • weight: (num_hidden, input_dim) • bias: (num_hidden,) • out: (batch_size, num_hidden) ''' F_H1 =nd.Activation(nd.FullyConnected(data=P_H2 , weight=W3 , bias=B3 , num_hidden=120),act_type="sigmoid") F_H1 =nd.Dropout(data=F_H1, p=drop_rate) F_H2 =nd.Activation(nd.FullyConnected(data=F_H1 , weight=W4 , bias=B4 , num_hidden=64),act_type="sigmoid") F_H2 =nd.Dropout(data=F_H2, p=drop_rate) softmax_Y = nd.softmax(nd.FullyConnected(data=F_H2 ,weight=W5 , bias=B5 , num_hidden=10)) return softmax_Y
def test_ord1(): a = nd.array(np.random.random((16, 32, 28, 28))) # a = nd.array([-1,2]).reshape((1,2,1,1)) # print("x", a) b = nd.array(np.random.random((4, 32, 1, 1))) # b = nd.array([3,5,7,9]).reshape((2,2,1,1)) # print("w", b) c = nd.Convolution(a, b, no_bias=True, num_group=1, kernel=(1, 1), num_filter=4) # print("conv", c) # import group_conv as gconv # attrs = { # 'num_group': '1', # 'kernel': '(1,1)', # 'no_bias': 'True', # 'num_filter': '2', # } # nodes = gconv.sc(a, b, attrs) # print("nodes", nodes) b1 = nd.transpose(b, axes=(1, 0, 2, 3)) b1 = b1.reshape((128, 1, 1, 1)) c1 = nd.Convolution(a, b1, no_bias=True, num_group=32, kernel=(1, 1), num_filter=128) c1 = c1.reshape((16, 32, 4, 28, 28)) # print("gconv", c1) c1 = nd.sum(c1, axis=1) # print("sum", c1) utils.check_valid(c, c1, tol=1e-5)
def net_lenet(X, verbose=False): # 第一层卷积 h1_conv = nd.Convolution(data=X, weight=lenet_W1, bias=lenet_b1, kernel=lenet_W1.shape[2:], num_filter=lenet_W1.shape[0]) h1_activation = nd.relu(h1_conv) h1 = nd.Pooling(data=h1_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) # 第二层卷积 h2_conv = nd.Convolution(data=h1, weight=lenet_W2, bias=lenet_b2, kernel=lenet_W2.shape[2:], num_filter=lenet_W2.shape[0]) h2_activation = nd.relu(h2_conv) h2 = nd.Pooling(data=h2_activation, pool_type="max", kernel=(2, 2), stride=(2, 2)) h2 = nd.flatten(h2) # 第一层全连接 h3_linear = nd.dot(h2, lenet_W3) + lenet_b3 h3 = nd.relu(h3_linear) # 第二层全连接 h4_linear = nd.dot(h3, lenet_W4) + lenet_b4 if verbose: print('1st conv block:', h1.shape) print('2nd conv block:', h2.shape) print('1st dense:', h3.shape) print('2nd dense:', h4_linear.shape) print('output:', h4_linear) return h4_linear
def new_flow(Y, nuclei=None, device=mx.cpu()): w = nd.ones((1, 1, 3, 3), ctx=device) bias = nd.zeros((32, ), ctx=device) bias0 = nd.zeros((1, ), ctx=device) #w[0,0,2,2] = 0 #w[0,0,0,0] = 0 #w[0,0,0,2] = 0 #w[0,0,2,0] = 0 w = w / nd.sum(w) Ly, Lx = Y.shape mu = np.zeros((2, Ly, Lx)) edge = np.zeros((Ly, Lx)) unq = np.unique(Y) nmask = len(unq) - 1 _, N = np.unique(Y, return_counts=True) R = np.median(N[1:]**.5) #print(R) for j in range(nmask): mask = (Y == unq[j + 1]) y, x = (Y == unq[j + 1]).nonzero() y0 = np.min(y) x0 = np.min(x) if nuclei is not None: M = nuclei[y, x] M = M - M.min() + 1e-3 M = M / M.sum() ymed = np.round(np.dot(M, (y - y0))).astype('int32') xmed = np.round(np.dot(M, (x - x0))).astype('int32') y = y - y0 x = x - x0 Ly, Lx = np.max(y) + 1, np.max(x) + 1 T0 = nd.zeros((1, 1, Ly + 2, Lx + 2), ctx=device) T0[0, 0, y + 1, x + 1] = 1 ff = T0 * (nd.Convolution( T0, w, bias0, kernel=(3, 3), pad=(1, 1), num_filter=1) < .95) ybound, xbound = np.nonzero(ff[0, 0].asnumpy()) ds = ((y[:, np.newaxis] + 1 - ybound)**2 + (x[:, np.newaxis] + 1 - xbound)**2)**.5 dmin = np.min(ds, axis=1) edge[y + y0, x + x0] = dmin #imin = np.argmin( - np.min(ds, axis=1)) if nuclei is None: if False: mask = nd.zeros((Ly + 2, Lx + 2), ctx=device) mask[y + 1, x + 1] = 1 T0 = nd.zeros((1, 1, Ly + 2, Lx + 2), ctx=device) T0[0, 0, y + 1, x + 1] = 1 for j in range(Ly + Lx): T0 = nd.Convolution(T0, w, bias0, kernel=(3, 3), pad=(1, 1), num_filter=1) T0 = T0 * mask T0 = T0 / T0.mean() xy = np.unravel_index( np.argmax((mask * T0[0, 0]).asnumpy().squeeze()), mask.shape) ymed, xmed = xy[0] - 1, xy[1] - 1 elif False: ydist = y xdist = x if len(ydist) > 200: ix = np.random.permutation(len(y))[:200] ydist = ydist[ix] xdist = xdist[ix] ds = ((ydist - y[:, np.newaxis])**2 + (xdist - x[:, np.newaxis])**2)**.5 imin = np.argmin(np.mean(ds, axis=1)) ymed = y[imin] xmed = x[imin] else: ymed = int(np.median(y)) xmed = int(np.median(x)) imin = np.argmin((x - xmed)**2 + (y - ymed)**2) xmed = x[imin] ymed = y[imin] mask = nd.zeros((1, 1, Ly + 2, Lx + 2), ctx=device) T0 = nd.zeros((1, 1, Ly + 2, Lx + 2), ctx=device) T0[0, 0, ymed + 1, xmed + 1] += 1. mask[0, 0, y + 1, x + 1] = 1 T = T0.copy() T = nd.zeros((1, 1, Ly + 2, Lx + 2), ctx=device) # T0.copy() for t in range(Ly + Lx): T = T * mask + T0 T = nd.Convolution(T, w, bias0, kernel=(3, 3), pad=(1, 1), num_filter=1) tnp = T[0, 0].asnumpy() dx = tnp[1:-1, 2:] - tnp[1:-1, :-2] dy = tnp[2:, 1:-1] - tnp[:-2, 1:-1] D = np.stack((dx, dy)) mu[:, y + y0, x + x0] = mu[:, y + y0, x + x0] + D[:, y, x] mu = mu / (1e-20 + np.sum(mu**2, axis=0)**.5) return mu[0], mu[1], edge
def std(X, W, attr): return nd.Convolution(X, W, **attr)
def test_gen(step=2, NG=1, OPG=4, IPG=8, N=16, H=28, W=28, KH=1, KW=1, PH=0, PW=0, SH=1, SW=1, DH=1, DW=1, tol=1e-6, th=2**8): # for temporory assert NG == 1 YH = (H + 2 * PH - DH * (KH - 1) - 1) // SH + 1 YW = (W + 2 * PW - DW * (KW - 1) - 1) // SW + 1 # for reference C = IPG * NG O = OPG * NG X = utils.generate_data_int((N, C, H, W), th=th) W = utils.generate_data_int((O, IPG, KH, KW), th=th) attrs = { 'no_bias': True, 'num_group': NG, 'kernel': (KH, KW), 'num_filter': O, 'stride': (SH, SW), 'pad': (PH, PW), 'layout': 'NCHW', 'dilate': (DH, DW), } Y = nd.Convolution(X, W, **attrs) # transpose and reshape W assert IPG % step == 0, "invalid step: {}".format(step) # (O,IPG,KH,KW) --transpose--> (IPG,O,KH,KW) W1 = nd.transpose(W, axes=(1, 0, 2, 3)) NIPG = IPG // step # (IPG,O,KH,KW) --reshape--> (NIPG,step,O,KH,KW) W1 = nd.reshape(W1, shape=(NIPG, step, O, KH, KW)) # (NIPG,step,O,KH,KW) --transpose--> (NIPG,O,step,KH,KW) W1 = nd.transpose(W1, axes=(0, 2, 1, 3, 4)) NO = NIPG * O # (NIPG,O,step,KH,KW) --reshape--> (NO,step,KH,KW) W1 = nd.reshape(W1, shape=(NO, step, KH, KW)) NNG = C // step nattrs = { 'no_bias': True, 'num_group': NNG, 'kernel': (KH, KW), 'num_filter': NO, 'stride': (SH, SW), 'pad': (PH, PW), 'layout': 'NCHW', 'dilate': (DH, DW), } Y1 = nd.Convolution(X, W1, **nattrs) # (N,NO,YH,YW) --reshape--> (N,NIPG,O,YH,YW) Y1 = nd.reshape(Y1, shape=(N, NIPG, O, YH, YW)) # (N,NIPG,O,YH,YW) --sum--> (N,O,YH,YW) Y1 = nd.sum(Y1, axis=1) utils.check_valid(Y, Y1, tol=tol)
def net_PLB(X, params, debug=False, pool_type='max', pool_size=4, pool_stride=4): [W1, b1, W2, b2, W3, b3, W4, b4, W5, b5, W6, b6, W7, b7] = params ######################## # Define the computation of the first convolutional layer ######################## h1_conv = nd.Convolution(data=X, weight=W1, bias=b1, kernel=(1, 16), num_filter=64, stride=(1, 1), dilate=(1, 1)) h1_pooling = nd.Pooling(data=h1_conv, pool_type=pool_type, kernel=(1, pool_size), stride=(1, pool_stride)) h1 = relu(h1_pooling) 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=(1, 16), num_filter=128, stride=(1, 1), dilate=(1, 2)) h2_pooling = nd.Pooling(data=h2_conv, pool_type=pool_type, kernel=(1, pool_size), stride=(1, pool_stride)) h2 = relu(h2_pooling) if debug: print("h2 shape: %s" % (np.array(h2.shape))) ######################## # Define the computation of the third convolutional layer ######################## h3_conv = nd.Convolution(data=h2, weight=W3, bias=b3, kernel=(1, 16), num_filter=256, stride=(1, 1), dilate=(1, 2)) h3_pooling = nd.Pooling(data=h3_conv, pool_type=pool_type, kernel=(1, pool_size), stride=(1, pool_stride)) h3 = relu(h3_pooling) if debug: print("h3 shape: %s" % (np.array(h3.shape))) ######################## # Define the computation of the 4th convolutional layer ######################## h4_conv = nd.Convolution(data=h3, weight=W4, bias=b4, kernel=(1, 32), num_filter=512, stride=(1, 1), dilate=(1, 2)) h4_pooling = nd.Pooling(data=h4_conv, pool_type=pool_type, kernel=(1, pool_size), stride=(1, pool_stride)) h4 = relu(h4_pooling) if debug: print("h4 shape: %s" % (np.array(h4.shape))) ######################## # Flattening h4 so that we can feed it into a fully-connected layer ######################## h5 = nd.flatten(h4) if debug: print("Flat h5 shape: %s" % (np.array(h5.shape))) ######################## # Define the computation of the 5th (fully-connected) layer ######################## h6_linear = nd.dot(h5, W5) + b5 h6 = relu(h6_linear) if debug: print("h6 shape: %s" % (np.array(h6.shape))) ######################## # Define the computation of the 6th (fully-connected) layer ######################## h7_linear = nd.dot(h6, W6) + b6 h7 = relu(h7_linear) if debug: print("h7 shape: %s" % (np.array(h7.shape))) ######################## # Define the computation of the output layer ######################## yhat_linear = nd.dot(h7, W7) + b7 if debug: print("yhat_linear shape: %s" % (np.array(yhat_linear.shape))) interlayer = [W1, b1, W2, b2, W3, b3, W4, b4, W5, b5, W6, b6, W7, b7] return yhat_linear, interlayer
def net_PRL(X, params, debug=False, pool_type='max', pool_size=4, pool_stride=2): [W1, b1, W2, b2, W3, b3, W4, b4, W5, b5, W6, b6, W7, b7, W8, b8, W9, b9] = params drop_prob = 0.5 ######################## # Define the computation of the first convolutional layer ######################## h1_conv = nd.Convolution(data=X, weight=W1, bias=b1, kernel=(1, 64), num_filter=8, stride=(1, 1), dilate=(1, 1)) h1 = nd.LeakyReLU(h1_conv, act_type='elu') 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=(1, 32), num_filter=8, stride=(1, 1), dilate=(1, 1)) h2_pooling = nd.Pooling(data=h2_conv, pool_type=pool_type, kernel=(1, 8), stride=(1, pool_stride)) h2 = nd.LeakyReLU(h2_pooling, act_type='elu') if debug: print("h2 shape: %s" % (np.array(h2.shape))) ######################## # Define the computation of the third convolutional layer ######################## h3_conv = nd.Convolution(data=h2, weight=W3, bias=b3, kernel=(1, 32), num_filter=16, stride=(1, 1), dilate=(1, 1)) h3 = nd.LeakyReLU(h3_conv, act_type='elu') if debug: print("h3 shape: %s" % (np.array(h3.shape))) ######################## # Define the computation of the 4th convolutional layer ######################## h4_conv = nd.Convolution(data=h3, weight=W4, bias=b4, kernel=(1, 16), num_filter=16, stride=(1, 1), dilate=(1, 1)) h4_pooling = nd.Pooling(data=h4_conv, pool_type=pool_type, kernel=(1, 6), stride=(1, pool_stride)) h4 = nd.LeakyReLU(h4_pooling, act_type='elu') if debug: print("h4 shape: %s" % (np.array(h4.shape))) ######################## # Define the computation of the 5th convolutional layer ######################## h5_conv = nd.Convolution(data=h4, weight=W5, bias=b5, kernel=(1, 16), num_filter=32, stride=(1, 1), dilate=(1, 1)) h5 = nd.LeakyReLU(h5_conv, act_type='elu') if debug: print("h5 shape: %s" % (np.array(h5.shape))) ######################## # Define the computation of the 6th convolutional layer ######################## h6_conv = nd.Convolution(data=h5, weight=W6, bias=b6, kernel=(1, 16), num_filter=32, stride=(1, 1), dilate=(1, 1)) h6_pooling = nd.Pooling(data=h6_conv, pool_type=pool_type, kernel=(1, 4), stride=(1, pool_stride)) h6 = nd.LeakyReLU(h6_pooling, act_type='elu') if debug: print("h6 shape: %s" % (np.array(h6.shape))) ######################## # Flattening h6 so that we can feed it into a fully-connected layer ######################## h7 = nd.flatten(h6) if debug: print("Flat h7 shape: %s" % (np.array(h7.shape))) ######################## # Define the computation of the 8th (fully-connected) layer ######################## h8_linear = nd.dot(h7, W7) + b7 h8 = nd.LeakyReLU(h8_linear, act_type='elu') if autograd.is_training(): # 对激活函数的输出使用droupout h8 = dropout(h8, drop_prob) if debug: print("h8 shape: %s" % (np.array(h8.shape))) ######################## # Define the computation of the 9th (fully-connected) layer ######################## h9_linear = nd.dot(h8, W8) + b8 h9 = nd.LeakyReLU(h9_linear, act_type='elu') if autograd.is_training(): # 对激活函数的输出使用droupout h9 = dropout(h9, drop_prob) if debug: print("h9 shape: %s" % (np.array(h9.shape))) ######################## # Define the computation of the output layer ######################## yhat_linear = nd.dot(h9, W9) + b9 if debug: print("yhat_linear shape: %s" % (np.array(yhat_linear.shape))) interlayer = [ W1, b1, W2, b2, W3, b3, W4, b4, W5, b5, W6, b6, W7, b7, W8, b8, W9, b9 ] return yhat_linear, interlayer
''' import mxnet as mx from mxnet.gluon import nn from mxnet import ndarray as nd # 卷积层 # 输入输出的数据格式是: batch * channel * height * width # 权重格式:output_channels * in_channels * height * width 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('input:', data) print('weight:', w) print('bias:', b) print('output:', out) # 窗口移动和边缘填充 out = nd.Convolution(data, w, b, kernel=w.shape[2:], num_filter=w.shape[1], stride=(2, 2), pad=(1, 1)) print('output:', out)
def network( X, drop_rate=0.0 ): # formula : output_size=((input−weights+2*Padding)/Stride)+1 #data size # MNIST,FashionMNIST = (batch size , 1 , 28 , 28) # CIFAR = (batch size , 3 , 32 , 32) # builtin The BatchNorm function moving_mean, moving_var does not work. C_H1 = nd.Activation( data=nd.BatchNorm(data=nd.Convolution(data=X, weight=W1, bias=B1, kernel=(3, 3), stride=(1, 1), num_filter=60), gamma=gamma1, beta=beta1, moving_mean=ma1, moving_var=mv1, momentum=0.9, fix_gamma=False, use_global_stats=True), act_type="relu" ) # MNIST : result = ( batch size , 60 , 26 , 26) , CIFAR10 : : result = ( batch size , 60 , 30 , 30) P_H1 = nd.Pooling( data=C_H1, pool_type="avg", kernel=(2, 2), stride=(2, 2) ) # MNIST : result = (batch size , 60 , 13 , 13) , CIFAR10 : result = (batch size , 60 , 15 , 15) C_H2 = nd.Activation( data=nd.BatchNorm(data=nd.Convolution(data=P_H1, weight=W2, bias=B2, kernel=(6, 6), stride=(1, 1), num_filter=30), gamma=gamma2, beta=beta2, moving_mean=ma2, moving_var=mv2, momentum=0.9, fix_gamma=False, use_global_stats=True), act_type="relu" ) # MNIST : result = ( batch size , 30 , 8 , 8), CIFAR10 : result = ( batch size , 30 , 10 , 10) P_H2 = nd.Pooling( data=C_H2, pool_type="avg", kernel=(2, 2), stride=(2, 2) ) # MNIST : result = (batch size , 30 , 4 , 4) , CIFAR10 : result = (batch size , 30 , 5 , 5) P_H2 = nd.flatten(data=P_H2) '''FullyConnected parameter • data: (batch_size, input_dim) • weight: (num_hidden, input_dim) • bias: (num_hidden,) • out: (batch_size, num_hidden) ''' F_H1 = nd.Activation(nd.BatchNorm(data=nd.FullyConnected( data=P_H2, weight=W3, bias=B3, num_hidden=120), gamma=gamma3, beta=beta3, moving_mean=ma3, moving_var=mv3, momentum=0.9, fix_gamma=False, use_global_stats=True), act_type="relu") F_H1 = nd.Dropout(data=F_H1, p=drop_rate) F_H2 = nd.Activation(nd.BatchNorm(data=nd.FullyConnected( data=F_H1, weight=W4, bias=B4, num_hidden=64), gamma=gamma4, beta=beta4, moving_mean=ma4, moving_var=mv4, momentum=0.9, fix_gamma=False, use_global_stats=True), act_type="relu") F_H2 = nd.Dropout(data=F_H2, p=drop_rate) #softmax_Y = nd.softmax(nd.FullyConnected(data=F_H2 ,weight=W5 , bias=B5 , num_hidden=10)) out = nd.FullyConnected(data=F_H2, weight=W5, bias=B5, num_hidden=10) return out
def net(X, params, debug=False, pool_type='avg', pool_size=16, pool_stride=2, act_type='relu', dilate_size=1, nf=1): [W1, b1, W2, b2, W3, b3, W4, b4, W5, b5] = params ######################## # Define the computation of the first convolutional layer ######################## h1_conv = nd.Convolution(data=X, weight=W1, bias=b1, kernel=(1, 16), num_filter=int(16 * nf), stride=(1, 1), dilate=(1, dilate_size)) h1_activation = activation(h1_conv, act_type=act_type) h1 = nd.Pooling(data=h1_activation, pool_type=pool_type, kernel=(1, pool_size), stride=(1, pool_stride)) 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=(1, 8), num_filter=int(32 * nf), stride=(1, 1), dilate=(1, dilate_size)) h2_activation = activation(h2_conv, act_type=act_type) h2 = nd.Pooling(data=h2_activation, pool_type=pool_type, kernel=(1, pool_size), stride=(1, pool_stride)) if debug: print("h2 shape: %s" % (np.array(h2.shape))) ######################## # Define the computation of the third convolutional layer ######################## h3_conv = nd.Convolution(data=h2, weight=W3, bias=b3, kernel=(1, 8), num_filter=int(64 * nf), stride=(1, 1), dilate=(1, dilate_size)) h3_activation = activation(h3_conv, act_type=act_type) h3 = nd.Pooling(data=h3_activation, pool_type=pool_type, kernel=(1, pool_size), stride=(1, pool_stride)) if debug: print("h3 shape: %s" % (np.array(h3.shape))) ######################## # Flattening h3 so that we can feed it into a fully-connected layer ######################## h4 = nd.flatten(h3) if debug: print("Flat h4 shape: %s" % (np.array(h4.shape))) ######################## # Define the computation of the 4th (fully-connected) layer ######################## h5_linear = nd.dot(h4, W4) + b4 h5 = activation(h5_linear, act_type=act_type) if autograd.is_training(): # 对激活函数的输出使用droupout h5 = dropout(h5, drop_prob) if debug: print("h5 shape: %s" % (np.array(h5.shape))) print("Dropout: ", drop_prob) ######################## # Define the computation of the output layer ######################## yhat_linear = nd.dot(h5, W5) + b5 if debug: print("yhat_linear shape: %s" % (np.array(yhat_linear.shape))) interlayer = [h1, h2, h3, h4, h5] return yhat_linear, interlayer
np.random.seed(30) # w = nd.array(np.random.rand(2, 3, 3, 3)) w = nd.load( '/home/yjr/MxNet_Codes/gluon-cv/scripts/gloun2TF/mxnet_weights/resnet50_v1b-0ecdba34.params' )['conv1.weight'] # [64, 3, 7, 7] # w = nd.arange(9*2).reshape((2, 1, 3, 3)) data = nd.array(np.random.rand(1, 3, 224, 224)) # data, _ = mxnet_process_img('../demo_img/person.jpg') # data = nd.arange(6*6).reshape((1, 1, 6, 6)) # 卷积运算 out = nd.Convolution(data, w, no_bias=True, kernel=(7, 7), stride=(2, 2), num_filter=64, pad=(3, 3)) def tf_conv(data, w): data = tf.constant(data.asnumpy()) data = tf.pad(data, paddings=[[0, 0], [0, 0], [3, 3], [3, 3]]) tf_out = slim.conv2d(data, num_outputs=64, kernel_size=[7, 7], padding='VALID', stride=2, biases_initializer=None,
def fwd_conv2d(*data, **attrs): assert len(data) == 2 out = nd.Convolution(*data, **attrs) return out
import mxnet as mx