def test_case(self):
np.random.seed(200)
x_data = np.random.random((2, 3, 6, 6)).astype("float32")
dim_data = np.array([12]).astype("int32")
shape_data = np.array([12, 12]).astype("int32")
actual_size_data = np.array([12, 12]).astype("int32")
scale_data = np.array([2.0]).astype("float32")
prog = fluid.Program()
startup_prog = fluid.Program()
place = fluid.CUDAPlace(
0) if fluid.core.is_compiled_with_cuda() else fluid.CPUPlace()
with fluid.program_guard(prog, startup_prog):
x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32")
dim = fluid.data(name="dim", shape=[1], dtype="int32")
shape_tensor = fluid.data(name="shape_tensor",
shape=[2],
dtype="int32")
actual_size = fluid.data(name="actual_size",
shape=[2],
dtype="int32")
scale_tensor = fluid.data(name="scale_tensor",
shape=[1],
dtype="float32")
out1 = interpolate(x,
out_shape=[12, 12],
resample='BICUBIC',
align_corners=False)
out2 = interpolate(x,
out_shape=[12, dim],
resample='BICUBIC',
align_corners=False)
out3 = interpolate(x,
out_shape=shape_tensor,
resample='BICUBIC',
align_corners=False)
out4 = interpolate(x,
out_shape=[4, 4],
actual_shape=actual_size,
resample='BICUBIC',
align_corners=False)
out5 = interpolate(x,
scale=scale_tensor,
resample='BICUBIC',
align_corners=False)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
results = exe.run(fluid.default_main_program(),
feed={
"x": x_data,
"dim": dim_data,
"shape_tensor": shape_data,
"actual_size": actual_size_data,
"scale_tensor": scale_data
},
fetch_list=[out1, out2, out3, out4, out5],
return_numpy=True)
expect_res = bicubic_interp_np(x_data,
out_h=12,
out_w=12,
align_corners=False)
for res in results:
self.assertTrue(np.allclose(res, expect_res))
with fluid.dygraph.guard():
x = fluid.dygraph.to_variable(x_data)
interp = interpolate(x,
out_shape=[12, 12],
resample='BICUBIC',
align_corners=False)
dy_result = interp.numpy()
expect = bicubic_interp_np(x_data,
out_h=12,
out_w=12,
align_corners=False)
self.assertTrue(np.allclose(dy_result, expect))
def test_axis_max():
# maximum of axis should less than dimensions of x
x2 = fluid.data(name='x2', shape=[3, 4, 5, 6], dtype="float32")
paddle.nn.functional.dropout(x2, axis=[0, 5])
def test_axis_len():
# length of axis should not greater than dimensions of x
x2 = fluid.data(name='x2', shape=[3, 4, 5, 6], dtype="float32")
paddle.nn.functional.dropout(x2, axis=[0, 1, 2, 3, 4])
def test_pdtype():
# p should be int or float
x2 = fluid.data(name='x2', shape=[3, 4, 5, 6], dtype="float32")
paddle.nn.functional.dropout(x2, p='0.5')
def test_mode():
# mode should be 'downscale_in_infer' or 'upscale_in_train'
x2 = fluid.data(name='x2', shape=[3, 4, 5, 6], dtype="float32")
paddle.nn.functional.dropout(x2, mode='abc')
def context(self,
input_image=None,
trainable=True,
pretrained=True,
param_prefix='',
get_prediction=False,
variant='d',
norm_type='bn',
feature_maps=[3, 4, 5],
return_c5=False):
"""Distill the Head Features, so as to perform transfer learning.
:param input_image: image tensor.
:type input_image: <class 'paddle.fluid.framework.Variable'>
:param trainable: whether to set parameters trainable.
:type trainable: bool
:param pretrained: whether to load default pretrained model.
:type pretrained: bool
:param param_prefix: the prefix of parameters in yolo_head and backbone
:type param_prefix: str
:param get_prediction: whether to get prediction,
if True, outputs is {'bbox_out': bbox_out},
if False, outputs is {'head_features': head_features}.
:type get_prediction: bool
:param depth: depth of network
:type depth: int
:param variant: type of resnet
:type variant: str
:param norm_type: type of normlization
:type norm_type: str
:param feature_maps: stage of output
:type feature_maps: list
"""
context_prog = input_image.block.program if input_image else fluid.Program(
)
startup_program = fluid.Program()
with fluid.program_guard(context_prog, startup_program):
if return_c5:
return ResNetC5(
depth=50,
norm_type=norm_type,
variant=variant,
feature_maps=feature_maps)
image = input_image if input_image else fluid.data(
name='image',
shape=[-1, 3, 224, 224],
dtype='float32',
lod_level=0)
backbone = ResNet(depth=50, variant=variant, norm_type=norm_type,\
feature_maps=feature_maps, get_prediction=get_prediction)
out = backbone(image)
inputs = {'image': image}
if get_prediction:
outputs = {'pred_out': out}
else:
outputs = {'body_feats': out}
place = fluid.CPUPlace()
exe = fluid.Executor(place)
if pretrained:
def _if_exist(var):
return os.path.exists(
os.path.join(self.default_pretrained_model_path,
var.name))
if not param_prefix:
fluid.io.load_vars(
exe,
self.default_pretrained_model_path,
main_program=context_prog,
predicate=_if_exist)
else:
exe.run(startup_program)
return inputs, outputs, context_prog
def check_static_result(self, place):
with fluid.program_guard(fluid.Program(), fluid.Program()):
input = fluid.data(name="input", shape=[-1, -1], dtype="float32")
res1 = paddle.nn.functional.dropout(x=input, p=0., training=False)
res2 = paddle.nn.functional.dropout(
x=input, p=0., axis=0, training=True, mode='upscale_in_train')
res3 = paddle.nn.functional.dropout(
x=input, p=0., axis=0, training=True, mode='downscale_in_infer')
res4 = paddle.nn.functional.dropout(
x=input, p=0., axis=0, training=False, mode='upscale_in_train')
res5 = paddle.nn.functional.dropout(
x=input,
p=0.,
axis=0,
training=False,
mode='downscale_in_infer')
res6 = paddle.nn.functional.dropout(
x=input,
p=0.,
axis=[0, 1],
training=True,
mode='upscale_in_train')
res7 = paddle.nn.functional.dropout(
x=input,
p=0.,
axis=[0, 1],
training=True,
mode='downscale_in_infer')
res8 = paddle.nn.functional.dropout(
x=input,
p=0.,
axis=[0, 1],
training=False,
mode='upscale_in_train')
res9 = paddle.nn.functional.dropout(
x=input,
p=0.,
axis=[0, 1],
training=False,
mode='downscale_in_infer')
res10 = paddle.nn.functional.dropout(x=input, p=1., training=True)
res11 = paddle.fluid.layers.dropout(x=input, dropout_prob=0.)
res12 = paddle.nn.functional.dropout(
x=input,
p=0.,
axis=(0, 1),
training=False,
mode='upscale_in_train')
res13 = paddle.nn.functional.dropout(
x=input, p=0.7, axis=1, training=True, mode='upscale_in_train')
in_np = np.ones([40, 40]).astype("float32")
res_np = in_np
res_np2 = np.zeros_like(in_np)
exe = fluid.Executor(place)
res_list = [
res1, res2, res3, res4, res5, res6, res7, res8, res9, res11,
res12
]
for res in res_list:
fetches = exe.run(fluid.default_main_program(),
feed={"input": in_np},
fetch_list=[res])
self.assertTrue(np.allclose(fetches[0], res_np))
fetches2 = exe.run(fluid.default_main_program(),
feed={"input": in_np},
fetch_list=[res10])
self.assertTrue(np.allclose(fetches2[0], res_np2))
fetches3 = exe.run(fluid.default_main_program(),
feed={"input": in_np},
fetch_list=[res13])
from opts import parser
from model import ECOfull
from config import parse_config, print_configs
from reader import KineticsReader
args = parser.parse_args()
cfg = parse_config('config.txt')
# print_configs(cfg, 'TRAIN')
main_program = fluid.default_main_program()
start_program = fluid.default_startup_program()
place = fluid.CUDAPlace(0) if args.use_cuda else fluid.CPUPlace()
with fluid.program_guard(main_program, start_program):
# data placeholder
input = fluid.data(name='data', shape=[-1, 3, 224, 224], dtype='float32')
label = fluid.data(name='label', shape=[-1, 1], dtype='int64')
print(f'label shape:{label.shape}')
model = ECOfull(input, num_segments=args.num_segments)
net_out = model()
cost = fluid.layers.softmax_with_cross_entropy(net_out, label)
avg_cost = fluid.layers.mean(cost)
acc = fluid.layers.accuracy(net_out, label)
# test program
eval_program = main_program.clone(for_test=True)
# optimizer
fluid.optimizer.SGD(args.lr).minimize(avg_cost)
# 验证集
val_reader = KineticsReader('eco', 'valid', cfg).create_reader()
param_initializer=self.param_initializer)
self.model['blocks'][i]['feedforward']['out'] = enc_output
enc_input = enc_output
enc_output = self.pre_process_layer(
enc_output,
self.preprocess_cmd,
self.prepostprocess_dropout,
scale_name=self.param_names['post_encoder']['scale'],
bias_name=self.param_names['post_encoder']['bias'])
self.model['out'] = enc_output
return enc_output
if __name__ == "__main__":
bert = TransformerEncoder('bert_base')
embedding_input = fluid.data(shape=[-1, 128, 764],
dtype='float32',
name='embedding')
input_mask = fluid.data(shape=[-1, 128, 1], dtype='float32', name='mask')
att_mask = fluid.layers.matmul(x=input_mask,
y=input_mask,
transpose_y=True)
bert.build(embedding_input, att_mask)
print(bert.model)
def test_run(self):
inputs_basic_lstm = fluid.data(
name='inputs_basic_lstm',
shape=[None, None, self.input_size],
dtype='float32')
sequence_length = fluid.data(
name="sequence_length", shape=[None], dtype='int64')
inputs_dynamic_rnn = layers.transpose(inputs_basic_lstm, perm=[1, 0, 2])
cell = LSTMCell(self.hidden_size, name="LSTMCell_for_rnn")
output, final_state = dynamic_rnn(
cell=cell,
inputs=inputs_dynamic_rnn,
sequence_length=sequence_length,
is_reverse=False)
output_new = layers.transpose(output, perm=[1, 0, 2])
rnn_out, last_hidden, last_cell = basic_lstm(inputs_basic_lstm, None, None, self.hidden_size, num_layers=1, \
batch_first = False, bidirectional=False, sequence_length=sequence_length, forget_bias = 1.0)
if core.is_compiled_with_cuda():
place = core.CUDAPlace(0)
else:
place = core.CPUPlace()
exe = Executor(place)
exe.run(framework.default_startup_program())
inputs_basic_lstm_np = np.random.uniform(
-0.1, 0.1,
(self.seq_len, self.batch_size, self.input_size)).astype('float32')
sequence_length_np = np.ones(
self.batch_size, dtype='int64') * self.seq_len
inputs_np = np.random.uniform(
-0.1, 0.1, (self.batch_size, self.input_size)).astype('float32')
pre_hidden_np = np.random.uniform(
-0.1, 0.1, (self.batch_size, self.hidden_size)).astype('float32')
pre_cell_np = np.random.uniform(
-0.1, 0.1, (self.batch_size, self.hidden_size)).astype('float32')
param_names = [[
"LSTMCell_for_rnn/BasicLSTMUnit_0.w_0",
"basic_lstm_layers_0/BasicLSTMUnit_0.w_0"
], [
"LSTMCell_for_rnn/BasicLSTMUnit_0.b_0",
"basic_lstm_layers_0/BasicLSTMUnit_0.b_0"
]]
for names in param_names:
param = np.array(fluid.global_scope().find_var(names[0]).get_tensor(
))
param = np.random.uniform(
-0.1, 0.1, size=param.shape).astype('float32')
fluid.global_scope().find_var(names[0]).get_tensor().set(param,
place)
fluid.global_scope().find_var(names[1]).get_tensor().set(param,
place)
out = exe.run(feed={
'inputs_basic_lstm': inputs_basic_lstm_np,
'sequence_length': sequence_length_np,
'inputs': inputs_np,
'pre_hidden': pre_hidden_np,
'pre_cell': pre_cell_np
},
fetch_list=[output_new, rnn_out])
self.assertTrue(np.allclose(out[0], out[1], rtol=1e-4))
import paddle.fluid as fluid
#define operation
w = fluid.data(name='w', shape=[None, 1], dtype='float32')
w.stop_gradient = False
loss = w * w
grad = fluid.gradients([loss], w)
print(grad)
#Define Exector
cpu = fluid.core.CPUPlace()
exe = fluid.Executor(cpu)
exe.run(fluid.default_startup_program())
#Prepare data
import numpy
x = numpy.ones((1, 1))
x = x.astype('float32')
#Run computing
outs = exe.run(feed={'w': x}, fetch_list=[loss, grad])
print('loss: {}, grad: {}'.format(outs[0][0], outs[1][0]))
def build_model(main_prog, start_prog, phase=ModelPhase.TRAIN):
width = train_shape[0]
height = train_shape[1]
image_shape = [-1, 3, height, width]
grt_shape = [-1, 1, height, width]
class_num = 20
with fluid.program_guard(main_prog, start_prog):
with fluid.unique_name.guard():
image = fluid.data(name='image',
shape=image_shape,
dtype='float32')
label = fluid.data(name='label', shape=grt_shape, dtype='int32')
mask = fluid.data(name='mask', shape=grt_shape, dtype='int32')
if ModelPhase.is_train(phase) or ModelPhase.is_eval(phase):
data_loader = fluid.io.DataLoader.from_generator(
feed_list=[image, label, mask],
capacity=256,
iterable=False,
use_double_buffer=True)
net_name = cfg["model"]
if net_name == "deeplab":
net = deeplabv3p
elif net_name == "hrnet":
net = hrnet
elif net_name == "ocrnet":
net = ocrnet
#logit = hrnet(image,class_num)
logits = net(image, class_num)
if ModelPhase.is_train(phase) or ModelPhase.is_eval(phase):
weight_softmax = [0.5] + ([5.0] * 19)
softmax_loss = multi_softmax_with_loss(logits, label, mask,
class_num,
weight_softmax)
if cfg["lovasz_loss"]:
lovasz_loss = multi_lovasz_softmax_loss(
logits, label, mask)
lovasz_weight = cfg["lovasz_weight"]
softmax_weight = 1 - lovasz_weight
avg_loss = (lovasz_weight *
lovasz_loss) + (softmax_weight * softmax_loss)
else:
avg_loss = softmax_loss
if isinstance(logits, tuple):
logit = logits[0]
else:
logit = logits
if logit.shape[2:] != label.shape[2:]:
logit = fluid.layers.resize_bilinear(logit, label.shape[2:])
if ModelPhase.is_predict(phase):
logit = softmax(logit)
out = fluid.layers.transpose(logit, [0, 2, 3, 1])
pred = fluid.layers.argmax(out, axis=3)
pred = fluid.layers.unsqueeze(pred, axes=[3])
if ModelPhase.is_eval(phase):
return data_loader, avg_loss, pred, label, mask
if ModelPhase.is_train(phase):
decay_step = all_step
power = 0.9
#decay_lr = fluid.layers.piecewise_decay(cfg["decay_step"],values=cfg["decay_values"])
#optimizer = fluid.optimizer.Momentum(learning_rate=decay_lr,momentum=0.9,
# regularization=fluid.regularizer.L2Decay(regularization_coeff=4e-05))
poly_lr = fluid.layers.polynomial_decay(cfg["lr"],
decay_step,
end_learning_rate=0,
power=power)
optimizer = fluid.optimizer.Adam(
learning_rate=poly_lr,
beta1=0.9,
beta2=0.99,
regularization=fluid.regularizer.L2Decay(
regularization_coeff=4e-05))
optimizer.minimize(avg_loss)
return data_loader, avg_loss, poly_lr, pred, label, mask
def test_out_shape():
x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32")
out = interpolate(x,
out_shape=[12],
resample='BICUBIC',
align_corners=False)
def test_align_corcers():
x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32")
interpolate(x,
out_shape=[12, 12],
resample='BICUBIC',
align_corners=3)
# define a random dataset
class RandomDataset(paddle.io.Dataset):
def __init__(self, num_samples):
self.num_samples = num_samples
def __getitem__(self, idx):
image = np.random.random([IMAGE_SIZE]).astype('float32')
label = np.random.randint(0, CLASS_NUM - 1, (1, )).astype('int64')
return image, label
def __len__(self):
return self.num_samples
image = fluid.data(name='image', shape=[None, 784], dtype='float32')
label = fluid.data(name='label', shape=[None, 1], dtype='int64')
pred = fluid.layers.fc(input=image, size=10, act='softmax')
loss = fluid.layers.cross_entropy(input=pred, label=label)
avg_loss = fluid.layers.mean(loss)
optimizer = fluid.optimizer.SGD(learning_rate=0.001)
optimizer.minimize(avg_loss)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
# create data loader
dataset = RandomDataset(BATCH_NUM * BATCH_SIZE)
loader = paddle.io.DataLoader(dataset,
padding=0,
act=None,
param_attr=ParamAttr(initializer=MSRA(), name='conv-12_weights'),
bias_attr=False)
out4 = fluid.layers.concat([out2, out3], axis=1)
out4 = fluid.layers.conv2d(
input=out4,
num_filters=num_classes,
filter_size=1,
stride=1,
padding=0,
act=None,
param_attr=ParamAttr(initializer=MSRA(), name='conv-13_weights'),
bias_attr=False)
out4 = fluid.layers.resize_bilinear(out4, input.shape[2:])
return out4
def post_hrnet(input, num_classes):
logit = high_resolution_net(input, num_classes)
return logit
if __name__ == '__main__':
image_shape = [-1, 3, 769, 769]
image = fluid.data(name='image', shape=image_shape, dtype='float32')
logit = post_hrnet(image, 4)
print("logit:", logit.shape)
yield train_data, label_data
return reader
train_reader = fluid.io.batch(paddle.reader.shuffle(my_reader(), buf_size=8),
4)
#DEV_COUNT = fluid.core.get_cuda_device_count()
use_cuda = False
place = fluid.cuda_places() if use_cuda else fluid.cpu_places()
if not use_cuda:
os.environ['CPU_NUM'] = str(2)
data = fluid.data(name="char", shape=[None, 50], dtype="int64", lod_level=0)
#data = fluid.data(name="char", shape=[None, 50], dtype="float32", lod_level=0)
label = fluid.data(name="label", shape=[None, 1], dtype="int64", lod_level=0)
reader = fluid.io.PyReader(feed_list=[data, label],
capacity=40,
iterable=True,
return_list=False)
reader.decorate_sample_list_generator(train_reader, place)
emb = fluid.embedding(data, size=[10, 64])
prob = fluid.layers.fc(emb, size=2, act='softmax')
#prob = fluid.layers.fc(data, size=2, act='softmax')
ce = fluid.layers.cross_entropy(prob, label)
loss = fluid.layers.mean(ce)
import shutil
import paddle
import paddle.fluid as fluid
import create_data
import text_reader
import bilstm_net
try:
# 兼容PaddlePaddle2.0
paddle.enable_static()
except:
pass
# 定义输入数据， lod_level不为0指定输入数据为序列数据
words = fluid.data(name='words', shape=[None, 1], dtype='int64', lod_level=1)
label = fluid.data(name='label', shape=[None, 1], dtype='int64')
# 获取数据字典长度
dict_dim = create_data.get_dict_len('datasets/dict_txt.txt')
# 获取长短期记忆网络
model = bilstm_net.bilstm_net(words, dict_dim, 15)
# 获取损失函数和准确率
cost = fluid.layers.cross_entropy(input=model, label=label)
avg_cost = fluid.layers.mean(cost)
acc = fluid.layers.accuracy(input=model, label=label)
# 获取预测程序
test_program = fluid.default_main_program().clone(for_test=True)
def loss_scaling_check_inf(self, use_npu=True, scope=fluid.Scope()):
a = fluid.data(name="a", shape=[1024, 1024], dtype='float32')
b = fluid.data(name="b", shape=[512, 128], dtype='float32')
x = [a, b]
found_inf = fluid.data(name="found_inf", shape=[1], dtype='bool')
prev_loss_scaling = fluid.data(name="prev_loss_scaling",
shape=[1],
dtype='float32')
num_good_steps = fluid.data(name="num_good_steps",
shape=[1],
dtype='int32')
num_bad_steps = fluid.data(name="num_bad_steps",
shape=[1],
dtype='int32')
a_v = np.random.random([1024, 1024]).astype('float32')
b_v = np.random.random([512, 128]).astype('float32')
i = np.random.randint(0, 1024, 1)
j = np.random.randint(0, 1024, 1)
a_v[i[0]][j[0]] = np.inf
found_inf_v = np.array([True]).astype('bool')
prev_loss_scaling_v = np.array([2048]).astype('float32')
num_good_steps_v = np.array([999], dtype=np.int32)
num_bad_steps_v = np.array([1], dtype=np.int32)
incr_every_n_steps = 1000
decr_every_n_nan_or_inf = 2
incr_ratio = 2
decr_ratio = 0.8
result = amp_nn.update_loss_scaling(x,
found_inf,
prev_loss_scaling,
num_good_steps,
num_bad_steps,
incr_every_n_steps,
decr_every_n_nan_or_inf,
incr_ratio,
decr_ratio,
name="update_loss_scaling")
place = paddle.NPUPlace(0) if use_npu else fluid.CPUPlace()
exe = fluid.Executor(place)
with fluid.scope_guard(scope):
exe.run(fluid.default_startup_program())
result_v = exe.run(feed={
'a': a_v,
'b': b_v,
'found_inf': found_inf_v,
'prev_loss_scaling': prev_loss_scaling_v,
'num_good_steps': num_good_steps_v,
'num_bad_steps': num_bad_steps_v
},
fetch_list=[
result, x, found_inf, prev_loss_scaling,
num_good_steps, num_bad_steps
])
assert np.array_equal(result_v[0], np.zeros_like(a_v))
assert np.array_equal(result_v[1], np.zeros_like(b_v))
assert np.array_equal(result_v[2], np.zeros_like(a_v))
assert np.array_equal(result_v[3], np.zeros_like(b_v))
assert np.array_equal(result_v[4], found_inf_v)
assert np.array_equal(result_v[5], prev_loss_scaling_v * decr_ratio)
assert np.array_equal(result_v[6], np.zeros_like(num_good_steps_v))
assert np.array_equal(result_v[7], np.zeros_like(num_bad_steps_v))
os.makedirs(frame_path_interpolated)
if not os.path.exists(frame_path_combined):
os.makedirs(frame_path_combined)
if not os.path.exists(video_path_input):
os.makedirs(video_path_input)
if not os.path.exists(video_path_output):
os.makedirs(video_path_output)
args.KEY_FRAME_THREAD = 0.
saved_model = args.saved_model
timestep = args.time_step
num_frames = int(1.0 / timestep) - 1
image = fluid.data(name='image',
shape=[2, 1, args.channels, -1, -1],
dtype='float32')
DAIN = networks.__dict__["DAIN_slowmotion"](channel=args.channels,
filter_size=args.filter_size,
timestep=args.time_step,
training=False)
out = DAIN(image)
out = out[0][1]
place = fluid.CUDAPlace(0)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
fetch_list = [out.name]
inference_program = fluid.default_main_program().clone(for_test=True)
def test_dtype():
# the input dtype of dropout must be float32 or float64
# float16 only can be set on GPU place
xr = fluid.data(name='xr', shape=[3, 4, 5, 6], dtype="int32")
paddle.nn.functional.dropout(xr, p=0.5)
def create_network(self, is_infer=False):
"""Create data layers and model network.
:param is_training: Whether to create a network for training.
:type is_training: bool
:return reader: Reader for input.
:rtype reader: read generater
:return log_probs: An output unnormalized log probability layer.
:rtype lig_probs: Varable
:return loss: A ctc loss layer.
:rtype loss: Variable
"""
if not is_infer:
input_fields = {
'names': ['audio_data', 'text_data', 'seq_len_data', 'masks'],
'shapes': [[None, 161, None], [None, 1], [None, 1],
[None, 32, 81, None]],
'dtypes': ['float32', 'int32', 'int64', 'float32'],
'lod_levels': [0, 1, 0, 0]
}
inputs = [
fluid.data(name=input_fields['names'][i],
shape=input_fields['shapes'][i],
dtype=input_fields['dtypes'][i],
lod_level=input_fields['lod_levels'][i])
for i in range(len(input_fields['names']))
]
reader = fluid.io.DataLoader.from_generator(feed_list=inputs,
capacity=64,
iterable=False,
use_double_buffer=True)
(audio_data, text_data, seq_len_data, masks) = inputs
else:
audio_data = fluid.data(name='audio_data',
shape=[None, 161, None],
dtype='float32',
lod_level=0)
seq_len_data = fluid.data(name='seq_len_data',
shape=[None, 1],
dtype='int64',
lod_level=0)
masks = fluid.data(name='masks',
shape=[None, 32, 81, None],
dtype='float32',
lod_level=0)
text_data = None
reader = fluid.DataFeeder([audio_data, seq_len_data, masks],
self._place)
log_probs, loss = deep_speech_v2_network(
audio_data=audio_data,
text_data=text_data,
seq_len_data=seq_len_data,
masks=masks,
dict_size=self._vocab_size,
num_conv_layers=self._num_conv_layers,
num_rnn_layers=self._num_rnn_layers,
rnn_size=self._rnn_layer_size,
use_gru=self._use_gru,
share_rnn_weights=self._share_rnn_weights)
return reader, log_probs, loss
def test_pvalue():
# p should be 0.<=p<=1.
x2 = fluid.data(name='x2', shape=[3, 4, 5, 6], dtype="float32")
paddle.nn.functional.dropout(x2, p=1.2)
def test_dtype():
data = fluid.data(shape=[10], dtype="float16", name="input")
fluid.layers.unique(data)
def test_axis():
# axis should be int or list
x2 = fluid.data(name='x2', shape=[3, 4, 5, 6], dtype="float32")
paddle.nn.functional.dropout(x2, axis=1.2)
def build_model(main_prog=None,
start_prog=None,
phase=ModelPhase.TRAIN,
**kwargs):
if not ModelPhase.is_valid_phase(phase):
raise ValueError("ModelPhase {} is not valid!".format(phase))
if ModelPhase.is_train(phase):
width = cfg.TRAIN_CROP_SIZE[0]
height = cfg.TRAIN_CROP_SIZE[1]
else:
width = cfg.EVAL_CROP_SIZE[0]
height = cfg.EVAL_CROP_SIZE[1]
image_shape = [-1, cfg.DATASET.DATA_DIM, height, width]
grt_shape = [-1, 1, height, width]
class_num = cfg.DATASET.NUM_CLASSES
#with fluid.program_guard(main_prog, start_prog):
# with fluid.unique_name.guard():
# 在导出模型的时候，增加图像标准化预处理,减小预测部署时图像的处理流程
# 预测部署时只须对输入图像增加batch_size维度即可
if cfg.SLIM.KNOWLEDGE_DISTILL_IS_TEACHER:
image = main_prog.global_block()._clone_variable(
kwargs['image'], force_persistable=False)
label = main_prog.global_block()._clone_variable(
kwargs['label'], force_persistable=False)
mask = main_prog.global_block()._clone_variable(
kwargs['mask'], force_persistable=False)
else:
if ModelPhase.is_predict(phase):
origin_image = fluid.data(name='image',
shape=[-1, -1, -1, cfg.DATASET.DATA_DIM],
dtype='float32')
image, valid_shape, origin_shape = export_preprocess(origin_image)
else:
image = fluid.data(name='image',
shape=image_shape,
dtype='float32')
label = fluid.data(name='label', shape=grt_shape, dtype='int32')
mask = fluid.data(name='mask', shape=grt_shape, dtype='int32')
# use DataLoader.from_generator when doing traning and evaluation
if ModelPhase.is_train(phase) or ModelPhase.is_eval(phase):
data_loader = None
if not cfg.SLIM.KNOWLEDGE_DISTILL_IS_TEACHER:
data_loader = fluid.io.DataLoader.from_generator(
feed_list=[image, label, mask],
capacity=cfg.DATALOADER.BUF_SIZE,
iterable=False,
use_double_buffer=True)
loss_type = cfg.SOLVER.LOSS
if not isinstance(loss_type, list):
loss_type = list(loss_type)
# dice_loss或bce_loss只适用两类分割中
if class_num > 2 and (("dice_loss" in loss_type) or
("bce_loss" in loss_type)):
raise Exception(
"dice loss and bce loss is only applicable to binary classfication"
)
# 在两类分割情况下，当loss函数选择dice_loss或bce_loss的时候，最后logit输出通道数设置为1
if ("dice_loss" in loss_type) or ("bce_loss" in loss_type):
class_num = 1
if "softmax_loss" in loss_type:
raise Exception(
"softmax loss can not combine with dice loss or bce loss")
logits = seg_model(image, class_num)
# 根据选择的loss函数计算相应的损失函数
if ModelPhase.is_train(phase) or ModelPhase.is_eval(phase):
loss_valid = False
avg_loss_list = []
valid_loss = []
if "softmax_loss" in loss_type:
weight = cfg.SOLVER.CROSS_ENTROPY_WEIGHT
avg_loss_list.append(
multi_softmax_with_loss(logits, label, mask, class_num,
weight))
loss_valid = True
valid_loss.append("softmax_loss")
if "dice_loss" in loss_type:
avg_loss_list.append(multi_dice_loss(logits, label, mask))
loss_valid = True
valid_loss.append("dice_loss")
if "bce_loss" in loss_type:
avg_loss_list.append(multi_bce_loss(logits, label, mask))
loss_valid = True
valid_loss.append("bce_loss")
if not loss_valid:
raise Exception(
"SOLVER.LOSS: {} is set wrong. it should "
"include one of (softmax_loss, bce_loss, dice_loss) at least"
" example: ['softmax_loss'], ['dice_loss'], ['bce_loss', 'dice_loss']"
.format(cfg.SOLVER.LOSS))
invalid_loss = [x for x in loss_type if x not in valid_loss]
if len(invalid_loss) > 0:
print(
"Warning: the loss {} you set is invalid. it will not be included in loss computed."
.format(invalid_loss))
avg_loss = 0
for i in range(0, len(avg_loss_list)):
avg_loss += avg_loss_list[i]
#get pred result in original size
if isinstance(logits, tuple):
logit = logits[0]
else:
logit = logits
if logit.shape[2:] != label.shape[2:]:
logit = fluid.layers.resize_bilinear(logit, label.shape[2:])
# return image input and logit output for inference graph prune
if ModelPhase.is_predict(phase):
# 两类分割中，使用dice_loss或bce_loss返回的logit为单通道，进行到两通道的变换
if class_num == 1:
logit = sigmoid_to_softmax(logit)
else:
logit = softmax(logit)
# 获取有效部分
logit = fluid.layers.slice(logit,
axes=[2, 3],
starts=[0, 0],
ends=valid_shape)
logit = fluid.layers.resize_bilinear(logit,
out_shape=origin_shape,
align_corners=False,
align_mode=0)
logit = fluid.layers.argmax(logit, axis=1)
return origin_image, logit
if class_num == 1:
out = sigmoid_to_softmax(logit)
out = fluid.layers.transpose(out, [0, 2, 3, 1])
else:
out = fluid.layers.transpose(logit, [0, 2, 3, 1])
pred = fluid.layers.argmax(out, axis=3)
pred = fluid.layers.unsqueeze(pred, axes=[3])
if ModelPhase.is_visual(phase):
if class_num == 1:
logit = sigmoid_to_softmax(logit)
else:
logit = softmax(logit)
return pred, logit
if ModelPhase.is_eval(phase):
return data_loader, avg_loss, pred, label, mask
if ModelPhase.is_train(phase):
decayed_lr = None
if not cfg.SLIM.KNOWLEDGE_DISTILL:
optimizer = solver.Solver(main_prog, start_prog)
decayed_lr = optimizer.optimise(avg_loss)
# optimizer = solver.Solver(main_prog, start_prog)
# decayed_lr = optimizer.optimise(avg_loss)
return data_loader, avg_loss, decayed_lr, pred, label, mask, image
def test_axis_min():
# minimum of axis should greater equal than 0
x2 = fluid.data(name='x2', shape=[3, 4, 5, 6], dtype="float32")
paddle.nn.functional.dropout(x2, axis=[0, -1])
def infer(args):
data_shape = [None, 3, args.image_size, args.image_size]
input = fluid.data(name='input', shape=data_shape, dtype='float32')
label_org_ = fluid.data(name='label_org_',
shape=[None, args.c_dim],
dtype='float32')
label_trg_ = fluid.data(name='label_trg_',
shape=[None, args.c_dim],
dtype='float32')
image_name = fluid.data(name='image_name',
shape=[None, args.n_samples],
dtype='int32')
model_name = 'net_G'
if args.model_net == 'CycleGAN':
loader = fluid.io.DataLoader.from_generator(
feed_list=[input, image_name],
capacity=4, ## batch_size * 4
iterable=True,
use_double_buffer=True)
from network.CycleGAN_network import CycleGAN_model
model = CycleGAN_model()
if args.input_style == "A":
fake = model.network_G(input, name="GA", cfg=args)
elif args.input_style == "B":
fake = model.network_G(input, name="GB", cfg=args)
else:
raise "Input with style [%s] is not supported." % args.input_style
elif args.model_net == 'Pix2pix':
loader = fluid.io.DataLoader.from_generator(
feed_list=[input, image_name],
capacity=4, ## batch_size * 4
iterable=True,
use_double_buffer=True)
from network.Pix2pix_network import Pix2pix_model
model = Pix2pix_model()
fake = model.network_G(input, "generator", cfg=args)
elif args.model_net == 'StarGAN':
loader = fluid.io.DataLoader.from_generator(
feed_list=[input, label_org_, label_trg_, image_name],
capacity=32,
iterable=True,
use_double_buffer=True)
from network.StarGAN_network import StarGAN_model
model = StarGAN_model()
fake = model.network_G(input, label_trg_, name="g_main", cfg=args)
elif args.model_net == 'STGAN':
from network.STGAN_network import STGAN_model
loader = fluid.io.DataLoader.from_generator(
feed_list=[input, label_org_, label_trg_, image_name],
capacity=32,
iterable=True,
use_double_buffer=True)
model = STGAN_model()
fake, _ = model.network_G(input,
label_org_,
label_trg_,
cfg=args,
name='generator',
is_test=True)
elif args.model_net == 'AttGAN':
from network.AttGAN_network import AttGAN_model
loader = fluid.io.DataLoader.from_generator(
feed_list=[input, label_org_, label_trg_, image_name],
capacity=32,
iterable=True,
use_double_buffer=True)
model = AttGAN_model()
fake, _ = model.network_G(input,
label_org_,
label_trg_,
cfg=args,
name='generator',
is_test=True)
elif args.model_net == 'CGAN':
noise = fluid.data(name='noise',
shape=[None, args.noise_size],
dtype='float32')
conditions = fluid.data(name='conditions',
shape=[None, 1],
dtype='float32')
from network.CGAN_network import CGAN_model
model = CGAN_model(args.n_samples)
fake = model.network_G(noise, conditions, name="G")
elif args.model_net == 'DCGAN':
noise = fluid.data(name='noise',
shape=[None, args.noise_size],
dtype='float32')
from network.DCGAN_network import DCGAN_model
model = DCGAN_model(args.n_samples)
fake = model.network_G(noise, name="G")
elif args.model_net == 'SPADE':
label_shape = [None, args.label_nc, args.crop_height, args.crop_width]
spade_data_shape = [None, 1, args.crop_height, args.crop_width]
from network.SPADE_network import SPADE_model
model = SPADE_model()
input_label = fluid.data(name='input_label',
shape=label_shape,
dtype='float32')
input_ins = fluid.data(name='input_ins',
shape=spade_data_shape,
dtype='float32')
input_ = fluid.layers.concat([input_label, input_ins], 1)
fake = model.network_G(input_, "generator", cfg=args, is_test=True)
else:
raise NotImplementedError("model_net {} is not support".format(
args.model_net))
def _compute_start_end(image_name):
image_name_start = np.array(image_name)[0].astype('int32')
image_name_end = image_name_start + args.n_samples - 1
image_name_save = str(np.array(image_name)[0].astype('int32')) + '.jpg'
print("read {}.jpg ~ {}.jpg".format(image_name_start, image_name_end))
return image_name_save
# prepare environment
place = fluid.CPUPlace()
if args.use_gpu:
place = fluid.CUDAPlace(0)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for var in fluid.default_main_program().all_parameters():
print(var.name)
print(args.init_model + '/' + model_name)
fluid.load(fluid.default_main_program(),
os.path.join(args.init_model, model_name))
print('load params done')
if not os.path.exists(args.output):
os.makedirs(args.output)
attr_names = args.selected_attrs.split(',')
if args.model_net == 'AttGAN' or args.model_net == 'STGAN':
test_reader = celeba_reader_creator(image_dir=args.dataset_dir,
list_filename=args.test_list,
args=args,
mode="VAL")
reader_test = test_reader.make_reader(return_name=True)
loader.set_batch_generator(
reader_test,
places=fluid.cuda_places() if args.use_gpu else fluid.cpu_places())
for data in loader():
real_img, label_org, label_trg, image_name = data[0][
'input'], data[0]['label_org_'], data[0]['label_trg_'], data[
0]['image_name']
image_name_save = _compute_start_end(image_name)
real_img_temp = save_batch_image(np.array(real_img))
images = [real_img_temp]
for i in range(args.c_dim):
label_trg_tmp = copy.deepcopy(np.array(label_trg))
for j in range(len(label_trg_tmp)):
label_trg_tmp[j][i] = 1.0 - label_trg_tmp[j][i]
label_trg_tmp = check_attribute_conflict(
label_trg_tmp, attr_names[i], attr_names)
label_org_tmp = list(
map(lambda x: ((x * 2) - 1) * 0.5, np.array(label_org)))
label_trg_tmp = list(
map(lambda x: ((x * 2) - 1) * 0.5, label_trg_tmp))
if args.model_net == 'AttGAN':
for k in range(len(label_trg_tmp)):
label_trg_tmp[k][i] = label_trg_tmp[k][i] * 2.0
tensor_label_org_ = fluid.LoDTensor()
tensor_label_trg_ = fluid.LoDTensor()
tensor_label_org_.set(label_org_tmp, place)
tensor_label_trg_.set(label_trg_tmp, place)
out = exe.run(feed={
"input": real_img,
"label_org_": tensor_label_org_,
"label_trg_": tensor_label_trg_
},
fetch_list=[fake.name])
fake_temp = save_batch_image(out[0])
images.append(fake_temp)
images_concat = np.concatenate(images, 1)
if len(np.array(label_org)) > 1:
images_concat = np.concatenate(images_concat, 1)
fake_image = Image.fromarray(
((images_concat + 1) * 127.5).astype(np.uint8))
fake_image.save(
os.path.join(args.output, "fake_image_" + image_name_save))
elif args.model_net == 'StarGAN':
test_reader = celeba_reader_creator(image_dir=args.dataset_dir,
list_filename=args.test_list,
args=args,
mode="VAL")
reader_test = test_reader.make_reader(return_name=True)
loader.set_batch_generator(
reader_test,
places=fluid.cuda_places() if args.use_gpu else fluid.cpu_places())
for data in loader():
real_img, label_org, label_trg, image_name = data[0][
'input'], data[0]['label_org_'], data[0]['label_trg_'], data[
0]['image_name']
image_name_save = _compute_start_end(image_name)
real_img_temp = save_batch_image(np.array(real_img))
images = [real_img_temp]
for i in range(args.c_dim):
label_trg_tmp = copy.deepcopy(np.array(label_org))
for j in range(len(np.array(label_org))):
label_trg_tmp[j][i] = 1.0 - label_trg_tmp[j][i]
label_trg_tmp = check_attribute_conflict(
label_trg_tmp, attr_names[i], attr_names)
tensor_label_trg_ = fluid.LoDTensor()
tensor_label_trg_.set(label_trg_tmp, place)
out = exe.run(feed={
"input": real_img,
"label_trg_": tensor_label_trg_
},
fetch_list=[fake.name])
fake_temp = save_batch_image(out[0])
images.append(fake_temp)
images_concat = np.concatenate(images, 1)
if len(np.array(label_org)) > 1:
images_concat = np.concatenate(images_concat, 1)
fake_image = Image.fromarray(
((images_concat + 1) * 127.5).astype(np.uint8))
fake_image.save(
os.path.join(args.output, "fake_image_" + image_name_save))
elif args.model_net == 'Pix2pix' or args.model_net == 'CycleGAN':
test_reader = reader_creator(image_dir=args.dataset_dir,
list_filename=args.test_list,
shuffle=False,
batch_size=args.n_samples,
mode="VAL")
reader_test = test_reader.make_reader(args, return_name=True)
loader.set_batch_generator(
reader_test,
places=fluid.cuda_places() if args.use_gpu else fluid.cpu_places())
id2name = test_reader.id2name
for data in loader():
real_img, image_name = data[0]['input'], data[0]['image_name']
image_names = []
for name in image_name:
image_names.append(id2name[np.array(name).astype('int32')[0]])
print("read: ", image_names)
fake_temp = exe.run(fetch_list=[fake.name],
feed={"input": real_img})
fake_temp = save_batch_image(fake_temp[0])
input_temp = save_batch_image(np.array(real_img))
if len(image_names) == 1:
fake_temp = np.expand_dims(fake_temp, axis=0)
input_temp = np.expand_dims(input_temp, axis=0)
for i, name in enumerate(image_names):
fake_image = Image.fromarray(
((fake_temp[i] + 1) * 127.5).astype(np.uint8))
fake_image.save(os.path.join(args.output, "fake_" + name))
input_image = Image.fromarray(
((input_temp[i] + 1) * 127.5).astype(np.uint8))
input_image.save(os.path.join(args.output, "input_" + name))
elif args.model_net == 'SPADE':
test_reader = triplex_reader_creator(image_dir=args.dataset_dir,
list_filename=args.test_list,
shuffle=False,
batch_size=1,
mode="TEST")
id2name = test_reader.id2name
reader_test = test_reader.make_reader(args, return_name=True)
for data in zip(reader_test()):
data_A, data_B, data_C, name = data[0]
name = id2name[np.array(name).astype('int32')[0]]
print("read: ", name)
tensor_A = fluid.LoDTensor()
tensor_C = fluid.LoDTensor()
tensor_A.set(data_A, place)
tensor_C.set(data_C, place)
fake_B_temp = exe.run(fetch_list=[fake.name],
feed={
"input_label": tensor_A,
"input_ins": tensor_C
})
fake_B_temp = np.squeeze(fake_B_temp[0]).transpose([1, 2, 0])
input_B_temp = np.squeeze(data_B[0]).transpose([1, 2, 0])
fakeB_image = Image.fromarray(
((fake_B_temp + 1) * 127.5).astype(np.uint8))
fakeB_image.save(os.path.join(args.output, "fakeB_" + name))
real_image = Image.fromarray(
((input_B_temp + 1) * 127.5).astype(np.uint8))
real_image.save(os.path.join(args.output, "real_" + name))
elif args.model_net == 'CGAN':
noise_data = np.random.uniform(low=-1.0,
high=1.0,
size=[args.n_samples, args.noise_size
]).astype('float32')
label = np.random.randint(0, 9, size=[args.n_samples,
1]).astype('float32')
noise_tensor = fluid.LoDTensor()
conditions_tensor = fluid.LoDTensor()
noise_tensor.set(noise_data, place)
conditions_tensor.set(label, place)
fake_temp = exe.run(fetch_list=[fake.name],
feed={
"noise": noise_tensor,
"conditions": conditions_tensor
})[0]
fake_image = np.reshape(fake_temp, (args.n_samples, -1))
fig = utility.plot(fake_image)
plt.savefig(os.path.join(args.output, 'fake_cgan.png'),
bbox_inches='tight')
plt.close(fig)
elif args.model_net == 'DCGAN':
noise_data = np.random.uniform(low=-1.0,
high=1.0,
size=[args.n_samples, args.noise_size
]).astype('float32')
noise_tensor = fluid.LoDTensor()
noise_tensor.set(noise_data, place)
fake_temp = exe.run(fetch_list=[fake.name],
feed={"noise": noise_tensor})[0]
fake_image = np.reshape(fake_temp, (args.n_samples, -1))
fig = utility.plot(fake_image)
plt.savefig(os.path.join(args.output, 'fake_dcgan.png'),
bbox_inches='tight')
plt.close(fig)
else:
raise NotImplementedError("model_net {} is not support".format(
args.model_net))
def test_xdim():
# dimentions of x should be 4
x = fluid.data(name='x1', shape=[2, 3, 4, 5, 6], dtype="int32")
paddle.nn.functional.dropout2d(x)
output = fluid.layers.elementwise_mul(
mask, x) + fluid.layers.elementwise_mul((1.0 - mask), y)
return output
def SlimFaceNet_A_x0_60(class_dim=None, scale=0.6, arch=None):
scale = 0.6
arch = [0, 1, 5, 1, 0, 2, 1, 2, 0, 1, 2, 1, 1, 0, 1]
return SlimFaceNet(class_dim=class_dim, scale=scale, arch=arch)
def SlimFaceNet_B_x0_75(class_dim=None, scale=0.6, arch=None):
scale = 0.75
arch = [1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 3, 2, 2, 3]
return SlimFaceNet(class_dim=class_dim, scale=scale, arch=arch)
def SlimFaceNet_C_x0_75(class_dim=None, scale=0.6, arch=None):
scale = 0.75
arch = [1, 1, 2, 1, 0, 2, 1, 0, 1, 0, 1, 1, 2, 2, 3]
return SlimFaceNet(class_dim=class_dim, scale=scale, arch=arch)
if __name__ == "__main__":
paddle.enable_static()
x = fluid.data(name='x', shape=[-1, 3, 112, 112], dtype='float32')
print(x.shape)
model = SlimFaceNet(10000,
arch=[1, 3, 3, 1, 1, 0, 0, 1, 0, 1, 1, 0, 5, 5, 3])
y = model.net(x)
