def forward(self, input, use_cudnn=True, use_mkldnn=True):
main_block = self.memory.main_program.current_block()
conv_op_desc = main_block.desc.append_op()
conv_out = main_block.create_var(name="%s_out" % self.base_name,
dtype='float32')
conv_op = Operator(block=main_block,
desc=conv_op_desc,
type='conv2d',
inputs={
'Input': input,
'Filter': self.main_conv_weight
},
outputs={'Output': conv_out},
attrs={
'strides': self.stride,
'paddings': self.padding,
'dilations': self.dilation,
'groups': self.groups,
'use_cudnn': use_cudnn,
'use_mkldnn': use_mkldnn
})
main_block.ops.append(conv_op)
if self.bias:
# add bias
final_out_name = "%s_%d_out" % (self.base_name, self.call_count)
final_out_var = main_block.create_var(name=final_out_name,
shape=conv_out.shape,
dtype='float32')
add_op_desc = main_block.desc.append_op()
add_op = Operator(block=main_block,
desc=add_op_desc,
type='elementwise_add',
inputs={
'X': [conv_out],
'Y': [self.bias]
},
outputs={'Out': [final_out_var]},
attrs={'axis': 1})
main_block.ops.append(add_op)
self.memory.add_var(final_out_var)
return final_out_var
self.call_count += 1
return conv_out
def forward(self, input):
""" create op here"""
main_block = self.memory.main_program.current_block()
tmp_out_name = "%s_tmp_%d_out" % (self.base_name, self.call_count)
tmp_out_var = main_block.create_var(name=tmp_out_name,
shape=[-1, self.output_dim],
dtype='float32')
self.memory.add_var(tmp_out_var)
mul_op_desc = main_block.desc.append_op()
mul_op = Operator(block=main_block,
desc=mul_op_desc,
type='mul',
inputs={
'X': [input],
'Y': [self.main_weight]
},
outputs={'Out': [tmp_out_var]},
attrs={
'x_num_col_dims': 1,
'y_num_col_dims': 1
})
main_block.ops.append(mul_op)
if self.bias:
final_out_name = "%s_%d_out" % (self.base_name, self.call_count)
final_out_var = main_block.create_var(name=final_out_name,
shape=[-1, self.output_dim],
dtype='float32')
self.memory.add_var(final_out_var)
add_op_desc = main_block.desc.append_op()
add_op = Operator(block=main_block,
desc=add_op_desc,
type='elementwise_add',
inputs={
'X': [tmp_out_var],
'Y': [self.main_bias]
},
outputs={'Out': [final_out_var]},
attrs={'axis': 1})
main_block.ops.append(add_op)
return final_out_var
self.call_count += 1
return tmp_out_var
def forward(self, input):
main_block = self.memory.main_program.current_block()
out_name = "%s_%d_out" % (self.base_name, self.call_count)
out_var = main_block.create_var(name=out_name, dtype='float32')
self.memory.add_var(out_var)
relu_op_desc = main_block.desc.append_op()
relu_op = Operator(block=main_block,
desc=relu_op_desc,
type='relu',
inputs={'X': input},
outputs={'Out': out_var})
main_block.ops.append(relu_op)
self.call_count += 1
return out_var
def forward(self, input1, input2):
main_block = self.memory.main_program.current_block()
out_var = main_block.create_var(name="%s_out" % self.base_name,
dtype='float32')
element_add_op_desc = main_block.desc.append_op()
element_add_op = Operator(block=main_block,
desc=element_add_op_desc,
type='elementwise_add',
inputs={
'X': [input1],
'Y': [input2]
},
outputs={'Out': [out_var]})
main_block.ops.append(element_add_op)
return out_var
def forward(self, softmax, label):
loss_name = "%s_loss" % self.base_name
start_block = self.memory.startup_program.global_block()
main_block = self.memory.main_program.current_block()
loss_var = main_block.create_var(name=loss_name,
dtype='float32')
loss_desc = main_block.desc.append_op()
loss_op = Operator(block=main_block,
desc=loss_desc,
type='cross_entropy',
inputs={'X':[softmax],
'Label':[label]},
outputs={'Y':[loss_var]},
attrs={"soft_label":False})
self.memory.add_var(loss_var)
main_block.ops.append(loss_op)
return loss_var
def forward(self, input, use_cudnn=False):
out_name = "%s_%d_out" % (self.base_name, self.call_count)
start_block = self.memory.startup_program.global_block()
main_block = self.memory.main_program.current_block()
out_var = main_block.create_var(name=out_name,
dtype='float32')
softmax_desc = main_block.desc.append_op()
softmax_op = Operator(block=main_block,
desc=softmax_desc,
type='softmax',
inputs={'X':[input]},
outputs={'Out':[out_var]},
attrs={"use_cudnn":use_cudnn})
self.memory.add_var(out_var)
main_block.ops.append(softmax_op)
self.call_count += 1
return out_var
def forward(self, input):
main_block = self.memory.main_program.current_block()
batch_norm_op_desc = main_block.desc.append_op()
batch_norm_out = main_block.create_var(name="%s_bn_out" %
self.base_name,
dtype='float32')
mean_out = self.mean
variance_out = self.variance
saved_mean = main_block.create_var(name="%s_mean_out" % self.base_name,
dtype='float32')
saved_variance = main_block.create_var(name="%s_var_out" %
self.base_name,
dtype='float32')
batch_norm_op = Operator(block=main_block,
desc=batch_norm_op_desc,
type="batch_norm",
inputs={
"X": input,
"Scale": self.main_scale,
"Bias": self.main_bias,
"Mean": self.main_mean,
"Variance": self.main_variance
},
outputs={
"Y": batch_norm_out,
"MeanOut": mean_out,
"VarianceOut": variance_out,
"SavedMean": saved_mean,
"SavedVariance": saved_variance
},
attrs={
"momentum": 0.9,
"epsilon": 1e-5,
"is_test": False,
"use_mkldnn": False,
"fuse_with_relu": False
})
self.memory.add_var(batch_norm_out)
self.memory.add_var(mean_out)
self.memory.add_var(variance_out)
self.memory.add_var(saved_mean)
self.memory.add_var(saved_variance)
main_block.ops.append(batch_norm_op)
self.call_count += 1
return batch_norm_out
def forward(self,
input,
pool_type='max',
pool_size=-1,
pool_stride=1,
pool_padding=0,
use_cudnn=True,
ceil_mode=False,
use_mkldnn=False,
global_pooling=False):
if pool_type not in ["max", "avg"]:
raise ValueError(
"Unknown pool_type: '%s'. It can only be 'max' or 'avg'.",
str(pool_type))
if global_pooling is False and pool_size == -1:
raise ValueError(
"When the global_pooling is False, pool_size must be passed "
"and be a valid value. Received pool_size: " + str(pool_size))
main_block = self.memory.main_program.current_block()
out_name = "%s_%d_out" % (self.base_name, self.call_count)
pool_out = main_block.create_var(name=out_name, dtype='float32')
self.memory.add_var(pool_out)
pool2d_op_desc = main_block.desc.append_op()
pool2d_op = Operator(block=main_block,
desc=pool2d_op_desc,
type='pool2d',
inputs={'X': input},
outputs={'Out': pool_out},
attrs={
"pooling_type": pool_type,
"ksize": _pair(pool_size),
"global_pooling": global_pooling,
"strides": _pair(pool_stride),
"paddings": _pair(pool_padding),
"use_cudnn": use_cudnn,
"ceil_mode": ceil_mode,
"use_mkldnn": use_mkldnn
})
main_block.ops.append(pool2d_op)
self.call_count += 1
return pool_out
def forward(self, input, dim=None, keep_dim=False):
out_name = "%s_%d_out" % (self.base_name, self.call_count)
start_block = self.memory.startup_program.global_block()
main_block = self.memory.main_program.current_block()
out_var = main_block.create_var(name=out_name, dtype='float32')
mean_desc = main_block.desc.append_op()
mean_op = Operator(block=main_block,
desc=mean_desc,
type='reduce_mean',
inputs={'X': input},
outputs={'Out': out_var},
attrs={
'dim': dim if dim != None else [0],
'keep_dim': keep_dim,
'reduce_all': True if dim == None else False
})
self.memory.add_var(out_var)
main_block.ops.append(mean_op)
self.call_count += 1
return out_var
def forward(self, logits, label):
softmax_out_name = "%s_softmax" % self.base_name
loss_name = "%s_loss" % self.base_name
start_block = self.memory.startup_program.global_block()
main_block = self.memory.main_program.current_block()
softmax_out_var = main_block.create_var(name=softmax_out_name,
dtype='float32')
loss_var = main_block.create_var(name=loss_name,
dtype='float32')
loss_desc = main_block.desc.append_op()
loss_op = Operator(block=main_block,
desc=loss_desc,
type='softmax_with_cross_entropy',
inputs={'Logits': logits,
'Label': label},
outputs={'Softmax': softmax_out_var,
'Loss': loss_var},
attrs={'soft_label': False})
self.memory.add_var(loss_var)
self.memory.add_var(softmax_out_var)
main_block.ops.append(loss_op)
return loss_var
from paddle.fluid import Program, Operator
my_program = Program()
cur_block = my_program.current_block()
abs_input_var = cur_block.create_var(name='abs_input',
shape=[-1, 32, 32],
dtype='float32')
abs_output_var = cur_block.create_var(name='abs_output',
shape=[-1, 32, 32],
dtype='float32')
op_desc = cur_block.desc.append_op()
op = Operator(block=cur_block, desc=op_desc, type='abs',
inputs={'X': [abs_input_var]}, outputs={'Out': [abs_output_var]})
print(str(my_program))
const_init = ConstantInitializer(value=0.0)
W_var = cur_block.create_parameter(name='fc_W',
dtype='float32',
shape=[128, 64],
initializer=xavier_init)
b_var = cur_block.create_parameter(name='fc_b',
dtype='float32',
shape=[64],
initializer=const_init)
mul_op_desc = cur_block.desc.append_op()
mul_op = Operator(block=cur_block,
desc=mul_op_desc,
type='mul',
inputs={
'X': x_var,
'Y': W_var
},
outputs={'Out': Wx_var},
attrs={
"x_num_col_dims": 1,
"y_num_col_dims": 1
})
add_op_desc = cur_block.desc.append_op()
add_op = Operator(block=cur_block,
desc=add_op_desc,
type='elementwise_add',
inputs={
'X': [Wx_var],
'Y': [b_var]
},
outputs={'Out': [y_var]},