def forward(ctx,
input,
rois,
offset,
spatial_scale,
pooled_size,
output_dim,
no_trans,
group_size=1,
part_size=None,
sample_per_part=4,
trans_std=.0):
ctx.spatial_scale = spatial_scale
ctx.no_trans = int(no_trans)
ctx.output_dim = output_dim
ctx.group_size = group_size
ctx.pooled_size = pooled_size
ctx.part_size = pooled_size if part_size is None else part_size
ctx.sample_per_part = sample_per_part
ctx.trans_std = trans_std
output, output_count = \
DCN.deform_psroi_pooling_forward(input, rois, offset,
ctx.no_trans, ctx.spatial_scale,
ctx.output_dim, ctx.group_size,
ctx.pooled_size, ctx.part_size,
ctx.sample_per_part, ctx.trans_std)
ctx.save_for_backward(input, rois, offset, output_count)
return output
def __init__(self, chi, cho):
super(DeformConv, self).__init__()
self.actf = nn.Sequential(nn.BatchNorm2d(cho, momentum=BN_MOMENTUM),
nn.ReLU(inplace=True))
self.conv = DCN(chi,
cho,
kernel_size=(3, 3),
stride=1,
padding=1,
dilation=1,
deformable_groups=1)
def backward(ctx, grad_output):
input, depth, weight, bias = ctx.saved_tensors
grad_input, grad_weight, grad_bias = \
DCN.depthaware_conv_backward(input, depth, weight,
bias,
grad_output,
ctx.kernel_size[0], ctx.kernel_size[1],
ctx.stride[0], ctx.stride[1],
ctx.padding[0], ctx.padding[1],
ctx.dilation[0], ctx.dilation[1],
ctx.group,
ctx.im2col_step)
return grad_input, None, grad_weight, grad_bias,\
None, None, None, None, None
def forward(ctx, input, offset, weight, bias, stride, padding, dilation,
group, deformable_groups, im2col_step):
ctx.stride = _pair(stride)
ctx.padding = _pair(padding)
ctx.dilation = _pair(dilation)
ctx.kernel_size = _pair(weight.shape[2:4])
ctx.group = group
ctx.deformable_groups = deformable_groups
ctx.im2col_step = im2col_step
output = DCN.deform_conv2d_forward(
input, weight, bias, offset, ctx.kernel_size[0],
ctx.kernel_size[1], ctx.stride[0], ctx.stride[1], ctx.padding[0],
ctx.padding[1], ctx.dilation[0], ctx.dilation[1], ctx.group,
ctx.deformable_groups, ctx.im2col_step)
ctx.save_for_backward(input, offset, weight, bias)
return output
def backward(ctx, grad_output):
input, depth, depth_offset, offset, mask, weight, bias = ctx.saved_tensors
grad_input, grad_offset, grad_mask, grad_weight, grad_bias = \
DCN.sample_conv_backward(input, depth, depth_offset, weight,
bias,
offset, mask,
grad_output,
ctx.kernel_size[0], ctx.kernel_size[1],
ctx.stride[0], ctx.stride[1],
ctx.padding[0], ctx.padding[1],
ctx.dilation[0], ctx.dilation[1],
ctx.groups,
ctx.deformable_groups,
ctx.im2col_step)
return grad_input, None, None, grad_offset, grad_mask, grad_weight, grad_bias,\
None, None, None, None, None, None
def backward(ctx, grad_output):
input, offset, weight, bias = ctx.saved_tensors
grad_input, grad_offset, grad_weight, grad_bias = \
DCN.sparse_conv3d_backward(input, weight,
bias,
offset,
grad_output,
ctx.kernel_size[0], ctx.kernel_size[1], ctx.kernel_size[2],
ctx.stride[0], ctx.stride[1], ctx.stride[2],
ctx.padding[0], ctx.padding[1], ctx.padding[2],
ctx.dilation[0], ctx.dilation[1], ctx.dilation[2],
ctx.group,
ctx.deformable_groups,
ctx.num_pts,
ctx.im2col_step)
return grad_input, grad_offset, grad_weight, grad_bias,\
None, None, None, None, None, None, None, None
def forward(ctx, input, offset, weight, bias, kernel_size, stride, padding,
dilation, group, deformable_groups, num_pts, im2col_step):
ctx.stride = _triple(stride)
ctx.padding = _triple(padding)
ctx.dilation = _triple(dilation)
ctx.kernel_size = _triple(kernel_size)
ctx.group = group
ctx.deformable_groups = deformable_groups
ctx.num_pts = num_pts
ctx.im2col_step = im2col_step
output = DCN.sparse_conv3d_forward(
input, weight, bias, offset, ctx.kernel_size[0],
ctx.kernel_size[1], ctx.kernel_size[2], ctx.stride[0],
ctx.stride[1], ctx.stride[2], ctx.padding[0], ctx.padding[1],
ctx.padding[2], ctx.dilation[0], ctx.dilation[1], ctx.dilation[2],
ctx.group, ctx.deformable_groups, ctx.num_pts, ctx.im2col_step)
ctx.save_for_backward(input, offset, weight, bias)
return output
def backward(ctx, grad_output):
input, offset = ctx.saved_tensors
# print('===grad_output', grad_output.shape, grad_output)
# print('===input', input.shape, input)
# print('===offset', offset.shape, offset)
grad_input, grad_offset = \
DCN.deform_im2col_backward(input.contiguous(),
offset.contiguous(),
grad_output.contiguous(),
ctx.kernel_size[0], ctx.kernel_size[1],
ctx.stride[0], ctx.stride[1],
ctx.padding[0], ctx.padding[1],
ctx.dilation[0], ctx.dilation[1],
ctx.group,
ctx.deformable_groups,
ctx.im2col_step)
return grad_input, grad_offset, \
None, None, None, None, None, None
def backward(ctx, grad_output):
input, rois, offset, output_count = ctx.saved_tensors
grad_input, grad_offset = \
DCN.deform_psroi_pooling_backward(grad_output,
input,
rois,
offset,
output_count,
ctx.no_trans,
ctx.spatial_scale,
ctx.output_dim,
ctx.group_size,
ctx.pooled_size,
ctx.part_size,
ctx.sample_per_part,
ctx.trans_std)
return grad_input, None, grad_offset, \
None, None, None, None, None, None, None, None
def forward(ctx, input, offset,
kernel_size, stride, padding, dilation, group=1, deformable_groups=1, im2col_step=1):
ctx.stride = _pair(stride)
ctx.padding = _pair(padding)
ctx.dilation = _pair(dilation)
# ctx.kernel_size = _pair(weight.shape[2:4])
ctx.kernel_size = _pair(kernel_size)
ctx.group = group
ctx.deformable_groups = deformable_groups
ctx.im2col_step = im2col_step
output = DCN.deform_im2col_forward(input.contiguous(),
offset.contiguous(),
ctx.kernel_size[0], ctx.kernel_size[1],
ctx.stride[0], ctx.stride[1],
ctx.padding[0], ctx.padding[1],
ctx.dilation[0], ctx.dilation[1],
ctx.group,
ctx.deformable_groups,
ctx.im2col_step)
ctx.save_for_backward(input, offset)
return output
"epoch": config.epoches,
"batch_size": config.batch_size,
"init_learning_rate": config.init_learning_rate,
"decay_rate": config.decay_rate,
"optimizer_type": "adam",
"batch_norm": 0,
"batch_norm_decay": 0.995,
"verbose": False,
"random_seed": 2016,
"loss_type": "logloss",
"eval_metric": roc_auc_score,
"l2_reg": 0.0,
"greater_is_better": True,
"cross_layers_num": config.cross_layers_num
}
dcn = DCN.DCN(**dcn_params)
dataParser = DataParser(base_params, featureDict)
trainSample_Xi, trainSample_Xv, trainSample_numeric_Xv, trainSample_y_label = dataParser.data_parser(
df_trainSample, has_label=True)
valSample_Xi, valSample_Xv, valSample_numeric_Xv, valSample_y_label = dataParser.data_parser(
df_valSample, has_label=True)
fileNames = clientHdfs.list(base_params['sparkDirName_trainData'])
# fileNames = os.listdir(base_params['sparkDirName_trainData'])
fileNames.remove('_SUCCESS')
fileNames_num = len(fileNames)
train_scores = []
val_scores = []
train_losses = []
val_losses = []
counter = 0
for epoch in range(base_params['epoches']):
train_file = './data/adult.data.txt'
test_file = './data/adult.test.txt'
train_x, train_y, train_di, train_dv, train_numeric_xv, test_di, test_dv, test_y, test_numeric_xv = load_data(
train_file, test_file)
fold = list(
StratifiedKFold(n_splits=3, shuffle=True,
random_state=2018).split(train_x, train_y))
_get = lambda x, y: [x[i] for i in y]
for i, (train_idx, valid_idx) in enumerate(fold):
print "the %dth fold start" % (i + 1)
train_xi, train_xv, train_nx, train_y_ = _get(train_di, train_idx), _get(
train_dv, train_idx), _get(train_numeric_xv,
train_idx), _get(train_y, train_idx)
valid_xi, valid_xv, valid_nx, valid_y_ = _get(train_di, valid_idx), _get(
train_dv, valid_idx), _get(train_numeric_xv,
valid_idx), _get(train_y, valid_idx)
dcn = DCN(**param)
dcn.fit(train_xi, train_xv, train_nx, train_y_, valid_xi, valid_xv,
valid_nx, valid_y_)
print 'Fit all train data......'
dcn = DCN(**param)
dcn.fit(train_di, train_dv, train_numeric_xv, train_y)
dcn.predict(test_di, test_dv, test_numeric_xv, test_y)