def test_summary_nlp(self):
def _get_param_from_state_dict(state_dict):
params = 0
for k, v in state_dict.items():
params += np.prod(v.numpy().shape)
return params
nlp_net = paddle.nn.GRU(input_size=2,
hidden_size=3,
num_layers=3,
direction="bidirectional")
paddle.summary(nlp_net, (1, 1, 2))
rnn = paddle.nn.LSTM(16, 32, 2)
params_info = paddle.summary(
rnn, [(-1, 23, 16), ((2, None, 32), (2, -1, 32))])
gt_params = _get_param_from_state_dict(rnn.state_dict())
np.testing.assert_allclose(params_info['total_params'], gt_params / 2.0)
rnn = paddle.nn.GRU(16, 32, 2, direction='bidirectional')
params_info = paddle.summary(rnn, (4, 23, 16))
gt_params = _get_param_from_state_dict(rnn.state_dict())
np.testing.assert_allclose(params_info['total_params'], gt_params / 2.0)
rnn = paddle.nn.SimpleRNN(16, 32, 2, direction='bidirectional')
params_info = paddle.summary(rnn, (4, 23, 16))
gt_params = _get_param_from_state_dict(rnn.state_dict())
np.testing.assert_allclose(params_info['total_params'], gt_params / 2.0)
def quantize_model(config, model):
if config.get("Slim", False) and config["Slim"].get("quant", False):
from paddleslim.dygraph.quant import QAT
assert config["Slim"]["quant"]["name"].lower(
) == 'pact', 'Only PACT quantization method is supported now'
QUANT_CONFIG["activation_preprocess_type"] = "PACT"
model.quanter = QAT(config=QUANT_CONFIG)
model.quanter.quantize(model)
logger.info("QAT model summary:")
paddle.summary(model, (1, 3, 224, 224))
else:
model.quanter = None
return
def main():
#x = paddle.tensor.rand((2, 3, 520, 520),dtype='float32')
#print(x.shape)
x = (2, 3, 520, 520)
model = GIoNet(num_classes=59, IMG_SIZE=x[2::])
params_info = paddle.summary(model, x)
print(params_info)
def main():
args = parse_args()
cfg, model_name = _trim(get_config(args.config, show=False))
print(f"Building model({model_name})...")
model = build_model(cfg)
params_info = paddle.summary(model, (1, 8, 3, 224, 224))
print(params_info)
def train():
paddle.set_device('gpu')
model = resnet50()
paddle.summary(model, (1, 3, 32, 32))
transform = Compose([
paddle.vision.transforms.Transpose(),
paddle.vision.transforms.Normalize(0, 255.),
])
cifar10 = Cifar10(mode='train', transform=transform)
loader = paddle.io.DataLoader(cifar10,
shuffle=True,
batch_size=BATCH_SIZE,
num_workers=10)
for epoch in range(EPOCH_NUM):
for batch_id, data in enumerate(loader()):
out = model(data[0])
out = paddle.mean(out)
if batch_id % 10 == 0:
print("Epoch {}: batch {}, out {}".format(
epoch, batch_id, out.numpy()))
def main():
args = parse_args()
cfg, model_name = _trim(get_config(args.config, show=False), args)
print(f"Building model({model_name})...")
model = build_model(cfg)
img_size = args.img_size
num_seg = args.num_seg
#NOTE: only support tsm now, will refine soon
params_info = paddle.summary(model, (1, num_seg, 3, img_size, img_size))
print(params_info)
if args.FLOPs:
flops_info = paddle.flops(model, [1, num_seg, 3, img_size, img_size],
print_detail=True)
print(flops_info)
def test_summary_error(self):
with self.assertRaises(TypeError):
nlp_net = paddle.nn.GRU(input_size=2, hidden_size=3, num_layers=3)
paddle.summary(nlp_net, (1, 1, '2'))
with self.assertRaises(ValueError):
nlp_net = paddle.nn.GRU(input_size=2, hidden_size=3, num_layers=3)
paddle.summary(nlp_net, (-1, -1))
paddle.disable_static()
nlp_net = paddle.nn.GRU(input_size=2, hidden_size=3, num_layers=3)
paddle.summary(nlp_net, (1, 1, 2))
def test_summary_input(self):
paddle.enable_static()
mymodel = MyModel()
input_data = paddle.rand([1, 20])
paddle.summary(mymodel, input=input_data)
paddle.disable_static()
rnn = paddle.nn.SimpleRNN(16, 32, 2, direction='bidirectional')
input_data = paddle.rand([4, 23, 16])
paddle.summary(rnn, input=input_data)
lenet_List_input = LeNetListInput()
input_data = [paddle.rand([1, 1, 28, 28]), paddle.rand([1, 400])]
paddle.summary(lenet_List_input, input=input_data)
lenet_dict_input = LeNetDictInput()
input_data = {
'x1': paddle.rand([1, 1, 28, 28]),
'x2': paddle.rand([1, 400])
}
paddle.summary(lenet_dict_input, input=input_data)
nn.BatchNorm(128),
nn.ReLU(),
nn.Conv1D(128, max_points, 1),
nn.BatchNorm(max_points),
nn.ReLU(),
)
self.fc = self.fc = nn.Sequential(nn.Linear(1024, 512), nn.ReLU(),
nn.Linear(512, 256), nn.ReLU(),
nn.Dropout(p=0.7),
nn.Linear(256, num_classes))
def forward(self, inputs):
"""
Input:
inputs: input points data, [B, 3, N]
Return:
x: predicts, [B, num_classes]
"""
x = paddle.to_tensor(inputs)
x = self.mlp_1(x)
x = self.mlp_2(x)
x = paddle.max(x, axis=2)
x = self.fc(x)
return x
if __name__ == '__main__':
model = PointNet_Basic_Clas()
paddle.summary(model, (64, 3, 1024))
# 设置损失值的比例
radio_cls_loss = 1.0
radio_bbox_loss = 0.5
radio_landmark_loss = 1.0
# 训练参数值
data_path = '../dataset/48/all_data'
batch_size = 384
learning_rate = 1e-3
epoch_num = 22
model_path = '../infer_models'
# 获取P模型
model = ONet()
paddle.summary(model, input_size=(batch_size, 3, 48, 48))
# 获取数据
train_dataset = CustomDataset(data_path)
train_loader = DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
# 设置优化方法
scheduler = paddle.optimizer.lr.PiecewiseDecay(
boundaries=[6, 14, 20],
values=[0.001, 0.0001, 0.00001, 0.000001],
verbose=True)
optimizer = paddle.optimizer.Adam(
parameters=model.parameters(),
learning_rate=scheduler,
def train(args):
if dist.get_rank() == 0:
# 日志记录器
writer = LogWriter(logdir='log')
# 设置支持多卡训练
dist.init_parallel_env()
# 获取训练数据
train_dataset = PPASRDataset(args.train_manifest,
args.dataset_vocab,
mean=args.data_mean,
std=args.data_std,
min_duration=args.min_duration,
max_duration=args.max_duration)
train_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
collate_fn=collate_fn,
num_workers=args.num_workers,
use_shared_memory=False)
train_loader_shuffle = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
collate_fn=collate_fn,
num_workers=args.num_workers,
shuffle=True,
use_shared_memory=False)
# 获取测试数据
test_dataset = PPASRDataset(args.test_manifest,
args.dataset_vocab,
mean=args.data_mean,
std=args.data_std)
test_loader = DataLoader(dataset=test_dataset,
batch_size=args.batch_size,
collate_fn=collate_fn,
num_workers=args.num_workers,
use_shared_memory=False)
# 获取解码器，用于评估
greedy_decoder = GreedyDecoder(train_dataset.vocabulary)
# 获取模型，同时数据均值和标准值到模型中，方便以后推理使用
model = PPASR(train_dataset.vocabulary,
data_mean=paddle.to_tensor(args.data_mean),
data_std=paddle.to_tensor(args.data_std))
if dist.get_rank() == 0:
print('input_size的第三个参数是变长的，这里为了能查看输出的大小变化，指定了一个值！')
paddle.summary(model, input_size=(args.batch_size, 128, 500))
# 设置支持多卡训练
model = paddle.DataParallel(model)
# 设置优化方法
clip = paddle.nn.ClipGradByNorm(clip_norm=1.0)
# 分段学习率
boundaries = [10, 20, 50, 100]
lr = [0.1**l * args.learning_rate for l in range(len(boundaries) + 1)]
# 获取预训练的epoch数
last_epoch = int(re.findall(r'\d+', args.pretrained_model)
[-1]) if args.pretrained_model is not None else -1
scheduler = paddle.optimizer.lr.PiecewiseDecay(boundaries=boundaries,
values=lr,
last_epoch=last_epoch,
verbose=True)
optimizer = paddle.optimizer.Adam(parameters=model.parameters(),
learning_rate=scheduler,
grad_clip=clip)
# 获取损失函数
ctc_loss = paddle.nn.CTCLoss()
# 加载预训练模型
if args.pretrained_model is not None:
model.set_state_dict(
paddle.load(os.path.join(args.pretrained_model, 'model.pdparams')))
optimizer.set_state_dict(
paddle.load(os.path.join(args.pretrained_model,
'optimizer.pdopt')))
train_step = 0
test_step = 0
# 开始训练
for epoch in range(last_epoch, args.num_epoch):
# 第一个epoch不打乱数据
if epoch == 1:
train_loader = train_loader_shuffle
for batch_id, (inputs, labels, input_lens,
label_lens) in enumerate(train_loader()):
out, out_lens = model(inputs, input_lens)
out = paddle.transpose(out, perm=[2, 0, 1])
# 计算损失
loss = ctc_loss(out, labels, out_lens, label_lens)
loss.backward()
optimizer.step()
optimizer.clear_grad()
# 多卡训练只使用一个进程打印
if batch_id % 100 == 0 and dist.get_rank() == 0:
print('[%s] Train epoch %d, batch %d, loss: %f' %
(datetime.now(), epoch, batch_id, loss))
writer.add_scalar('Train loss', loss, train_step)
train_step += 1
# 固定步数也要保存一次模型
if batch_id % 2000 == 0 and batch_id != 0 and dist.get_rank() == 0:
# 保存模型
save_model(args=args,
epoch=epoch,
model=model,
optimizer=optimizer)
# 多卡训练只使用一个进程执行评估和保存模型
if dist.get_rank() == 0:
# 执行评估
model.eval()
cer = evaluate(model, test_loader, greedy_decoder)
print('[%s] Test epoch %d, cer: %f' % (datetime.now(), epoch, cer))
writer.add_scalar('Test cer', cer, test_step)
test_step += 1
model.train()
# 记录学习率
writer.add_scalar('Learning rate', scheduler.last_lr, epoch)
# 保存模型
save_model(args=args,
epoch=epoch,
model=model,
optimizer=optimizer)
scheduler.step()
def compress(args):
if args.data == "cifar10":
transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])])
train_dataset = paddle.vision.datasets.Cifar10(mode="train",
backend="cv2",
transform=transform)
val_dataset = paddle.vision.datasets.Cifar10(mode="test",
backend="cv2",
transform=transform)
class_dim = 10
image_shape = [3, 32, 32]
pretrain = False
args.total_images = 50000
elif args.data == "imagenet":
import imagenet_reader as reader
train_dataset = reader.ImageNetDataset(mode='train')
val_dataset = reader.ImageNetDataset(mode='val')
class_dim = 1000
image_shape = "3,224,224"
else:
raise ValueError("{} is not supported.".format(args.data))
trainer_num = paddle.distributed.get_world_size()
use_data_parallel = trainer_num != 1
place = paddle.set_device('gpu' if args.use_gpu else 'cpu')
# model definition
if use_data_parallel:
paddle.distributed.init_parallel_env()
pretrain = True if args.data == "imagenet" else False
if args.model == "mobilenet_v1":
net = mobilenet_v1(pretrained=pretrain, num_classes=class_dim)
elif args.model == "mobilenet_v3":
net = MobileNetV3_large_x1_0(class_dim=class_dim)
if pretrain:
load_dygraph_pretrain(net, args.pretrained_model, True)
else:
raise ValueError("{} is not supported.".format(args.model))
_logger.info("Origin model summary:")
paddle.summary(net, (1, 3, 224, 224))
############################################################################################################
# 1. quantization configs
############################################################################################################
quant_config = {
# weight preprocess type, default is None and no preprocessing is performed.
'weight_preprocess_type': None,
# activation preprocess type, default is None and no preprocessing is performed.
'activation_preprocess_type': None,
# weight quantize type, default is 'channel_wise_abs_max'
'weight_quantize_type': 'channel_wise_abs_max',
# activation quantize type, default is 'moving_average_abs_max'
'activation_quantize_type': 'moving_average_abs_max',
# weight quantize bit num, default is 8
'weight_bits': 8,
# activation quantize bit num, default is 8
'activation_bits': 8,
# data type after quantization, such as 'uint8', 'int8', etc. default is 'int8'
'dtype': 'int8',
# window size for 'range_abs_max' quantization. default is 10000
'window_size': 10000,
# The decay coefficient of moving average, default is 0.9
'moving_rate': 0.9,
# for dygraph quantization, layers of type in quantizable_layer_type will be quantized
'quantizable_layer_type': ['Conv2D', 'Linear'],
}
if args.use_pact:
quant_config['activation_preprocess_type'] = 'PACT'
############################################################################################################
# 2. Quantize the model with QAT (quant aware training)
############################################################################################################
quanter = QAT(config=quant_config)
quanter.quantize(net)
_logger.info("QAT model summary:")
paddle.summary(net, (1, 3, 224, 224))
opt, lr = create_optimizer(net, trainer_num, args)
if use_data_parallel:
net = paddle.DataParallel(net)
train_batch_sampler = paddle.io.DistributedBatchSampler(
train_dataset,
batch_size=args.batch_size,
shuffle=True,
drop_last=True)
train_loader = paddle.io.DataLoader(train_dataset,
batch_sampler=train_batch_sampler,
places=place,
return_list=True,
num_workers=4)
valid_loader = paddle.io.DataLoader(val_dataset,
places=place,
batch_size=args.batch_size,
shuffle=False,
drop_last=False,
return_list=True,
num_workers=4)
@paddle.no_grad()
def test(epoch, net):
net.eval()
batch_id = 0
acc_top1_ns = []
acc_top5_ns = []
eval_reader_cost = 0.0
eval_run_cost = 0.0
total_samples = 0
reader_start = time.time()
for data in valid_loader():
eval_reader_cost += time.time() - reader_start
image = data[0]
label = data[1]
if args.data == "cifar10":
label = paddle.reshape(label, [-1, 1])
eval_start = time.time()
out = net(image)
acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1)
acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5)
eval_run_cost += time.time() - eval_start
batch_size = image.shape[0]
total_samples += batch_size
if batch_id % args.log_period == 0:
log_period = 1 if batch_id == 0 else args.log_period
_logger.info(
"Eval epoch[{}] batch[{}] - top1: {:.6f}; top5: {:.6f}; avg_reader_cost: {:.6f} s, avg_batch_cost: {:.6f} s, avg_samples: {}, avg_ips: {:.3f} images/s"
.format(epoch, batch_id, np.mean(acc_top1.numpy()),
np.mean(acc_top5.numpy()),
eval_reader_cost / log_period,
(eval_reader_cost + eval_run_cost) / log_period,
total_samples / log_period, total_samples /
(eval_reader_cost + eval_run_cost)))
eval_reader_cost = 0.0
eval_run_cost = 0.0
total_samples = 0
acc_top1_ns.append(np.mean(acc_top1.numpy()))
acc_top5_ns.append(np.mean(acc_top5.numpy()))
batch_id += 1
reader_start = time.time()
_logger.info(
"Final eval epoch[{}] - acc_top1: {:.6f}; acc_top5: {:.6f}".format(
epoch, np.mean(np.array(acc_top1_ns)),
np.mean(np.array(acc_top5_ns))))
return np.mean(np.array(acc_top1_ns))
def cross_entropy(input, target, ls_epsilon):
if ls_epsilon > 0:
if target.shape[-1] != class_dim:
target = paddle.nn.functional.one_hot(target, class_dim)
target = paddle.nn.functional.label_smooth(target,
epsilon=ls_epsilon)
target = paddle.reshape(target, shape=[-1, class_dim])
input = -paddle.nn.functional.log_softmax(input, axis=-1)
cost = paddle.sum(target * input, axis=-1)
else:
cost = paddle.nn.functional.cross_entropy(input=input,
label=target)
avg_cost = paddle.mean(cost)
return avg_cost
def train(epoch, net):
net.train()
batch_id = 0
train_reader_cost = 0.0
train_run_cost = 0.0
total_samples = 0
reader_start = time.time()
for data in train_loader():
train_reader_cost += time.time() - reader_start
image = data[0]
label = data[1]
if args.data == "cifar10":
label = paddle.reshape(label, [-1, 1])
train_start = time.time()
out = net(image)
avg_cost = cross_entropy(out, label, args.ls_epsilon)
acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1)
acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5)
avg_cost.backward()
opt.step()
opt.clear_grad()
lr.step()
loss_n = np.mean(avg_cost.numpy())
acc_top1_n = np.mean(acc_top1.numpy())
acc_top5_n = np.mean(acc_top5.numpy())
train_run_cost += time.time() - train_start
batch_size = image.shape[0]
total_samples += batch_size
if batch_id % args.log_period == 0:
log_period = 1 if batch_id == 0 else args.log_period
_logger.info(
"epoch[{}]-batch[{}] lr: {:.6f} - loss: {:.6f}; top1: {:.6f}; top5: {:.6f}; avg_reader_cost: {:.6f} s, avg_batch_cost: {:.6f} s, avg_samples: {}, avg_ips: {:.3f} images/s"
.format(
epoch, batch_id, lr.get_lr(), loss_n, acc_top1_n,
acc_top5_n, train_reader_cost / log_period,
(train_reader_cost + train_run_cost) / log_period,
total_samples / log_period,
total_samples / (train_reader_cost + train_run_cost)))
train_reader_cost = 0.0
train_run_cost = 0.0
total_samples = 0
batch_id += 1
reader_start = time.time()
############################################################################################################
# train loop
############################################################################################################
best_acc1 = 0.0
best_epoch = 0
for i in range(args.num_epochs):
train(i, net)
acc1 = test(i, net)
if paddle.distributed.get_rank() == 0:
model_prefix = os.path.join(args.model_save_dir, "epoch_" + str(i))
paddle.save(net.state_dict(), model_prefix + ".pdparams")
paddle.save(opt.state_dict(), model_prefix + ".pdopt")
if acc1 > best_acc1:
best_acc1 = acc1
best_epoch = i
if paddle.distributed.get_rank() == 0:
model_prefix = os.path.join(args.model_save_dir, "best_model")
paddle.save(net.state_dict(), model_prefix + ".pdparams")
paddle.save(opt.state_dict(), model_prefix + ".pdopt")
############################################################################################################
# 3. Save quant aware model
############################################################################################################
if paddle.distributed.get_rank() == 0:
# load best model
load_dygraph_pretrain(net,
os.path.join(args.model_save_dir, "best_model"))
path = os.path.join(args.model_save_dir, "inference_model",
'qat_model')
quanter.save_quantized_model(net,
path,
input_spec=[
paddle.static.InputSpec(
shape=[None, 3, 224, 224],
dtype='float32')
])
box_loss, landmarks_loss, acc))
scheduler.step()
# 保存模型
if not os.path.exists(model_path):
os.makedirs(model_path)
paddle.jit.save(layer=model,
path=os.path.join(model_path, name),
input_spec=[InputSpec(shape=shape, dtype='float32')])
# 获取O模型
modelO = ONet()
shapeO = [None, 3, 48, 48]
pathO = '../dataset/28/all_data'
paddle.summary(modelO, input_size=(batch_size, 3, 48, 48))
train(modelO, 0.5, 22, pathO, 'ONet', shapeO)
# 获取P模型
modelP = PNet()
shapeP = [None, 3, None, None]
pathP = '../dataset/12/all_data'
paddle.summary(modelP, input_size=(batch_size, 3, 12, 12))
train(modelP, 0.5, 30, pathP, 'PNet', shapeP)
# 获取R模型
modelR = RNet()
shapeR = [None, 3, 24, 24]
pathR = '../dataset/32/all_data'
paddle.summary(modelR, input_size=(batch_size, 3, 24, 24))
train(modelR, 0.5, 22, pathR, 'RNet', shapeR)
def test_summary_non_tensor(self):
paddle.summary(ModelOutter(), input_size=(-1, 3))
def train(args):
if dist.get_rank() == 0:
shutil.rmtree('log', ignore_errors=True)
# 日志记录器
writer = LogWriter(logdir='log')
# 设置支持多卡训练
if len(args.gpus.split(',')) > 1:
dist.init_parallel_env()
# 获取训练数据
train_dataset = PPASRDataset(args.train_manifest,
args.dataset_vocab,
mean_std_filepath=args.mean_std_path,
min_duration=args.min_duration,
max_duration=args.max_duration)
batch_sampler = paddle.io.DistributedBatchSampler(
train_dataset, batch_size=args.batch_size, shuffle=True)
train_loader = DataLoader(dataset=train_dataset,
collate_fn=collate_fn,
batch_sampler=batch_sampler,
num_workers=args.num_workers)
# 获取测试数据
test_dataset = PPASRDataset(args.test_manifest,
args.dataset_vocab,
mean_std_filepath=args.mean_std_path)
batch_sampler = paddle.io.BatchSampler(test_dataset,
batch_size=args.batch_size)
test_loader = DataLoader(dataset=test_dataset,
collate_fn=collate_fn,
batch_sampler=batch_sampler,
num_workers=args.num_workers)
# 获取模型
model = DeepSpeech2Model(feat_size=train_dataset.feature_dim,
dict_size=len(train_dataset.vocabulary),
num_conv_layers=args.num_conv_layers,
num_rnn_layers=args.num_rnn_layers,
rnn_size=args.rnn_layer_size)
if dist.get_rank() == 0:
print('input_size的第三个参数是变长的，这里为了能查看输出的大小变化，指定了一个值！')
paddle.summary(model,
input_size=[(None, train_dataset.feature_dim, 970),
(None, )],
dtypes=[paddle.float32, paddle.int64])
# 设置支持多卡训练
if len(args.gpus.split(',')) > 1:
model = paddle.DataParallel(model)
# 设置优化方法
clip = paddle.nn.ClipGradByNorm(clip_norm=3.0)
# 获取预训练的epoch数
last_epoch = int(re.findall(
r'\d+', args.resume)[-1]) if args.resume is not None else 0
scheduler = paddle.optimizer.lr.ExponentialDecay(
learning_rate=args.learning_rate,
gamma=0.83,
last_epoch=last_epoch,
verbose=True)
optimizer = paddle.optimizer.Adam(
parameters=model.parameters(),
learning_rate=scheduler,
weight_decay=paddle.regularizer.L2Decay(1e-06),
grad_clip=clip)
# 获取损失函数
ctc_loss = paddle.nn.CTCLoss()
# 加载预训练模型
if args.pretrained_model is not None:
model_dict = model.state_dict()
model_state_dict = paddle.load(
os.path.join(args.pretrained_model, 'model.pdparams'))
# 特征层
for name, weight in model_dict.items():
if name in model_state_dict.keys():
if weight.shape != list(model_state_dict[name].shape):
print('{} not used, shape {} unmatched with {} in model.'.
format(name, list(model_state_dict[name].shape),
weight.shape))
model_state_dict.pop(name, None)
else:
print('Lack weight: {}'.format(name))
model.set_dict(model_state_dict)
print('成功加载预训练模型')
# 加载预训练模型
if args.resume is not None:
model.set_state_dict(
paddle.load(os.path.join(args.resume, 'model.pdparams')))
optimizer.set_state_dict(
paddle.load(os.path.join(args.resume, 'optimizer.pdopt')))
print('成功恢复模型参数和优化方法参数')
train_step = 0
test_step = 0
# 开始训练
for epoch in range(last_epoch, args.num_epoch):
for batch_id, (inputs, labels, input_lens,
label_lens) in enumerate(train_loader()):
out, out_lens = model(inputs, input_lens)
out = paddle.transpose(out, perm=[1, 0, 2])
# 计算损失
loss = ctc_loss(out, labels, out_lens, label_lens)
loss.backward()
optimizer.step()
optimizer.clear_grad()
# 多卡训练只使用一个进程打印
if batch_id % 100 == 0 and dist.get_rank() == 0:
print('[%s] Train epoch %d, batch %d, loss: %f' %
(datetime.now(), epoch, batch_id, loss))
writer.add_scalar('Train loss', loss, train_step)
train_step += 1
# 固定步数也要保存一次模型
if batch_id % 2000 == 0 and batch_id != 0 and dist.get_rank() == 0:
# 保存模型
save_model(args=args,
epoch=epoch,
model=model,
optimizer=optimizer)
# 多卡训练只使用一个进程执行评估和保存模型
if dist.get_rank() == 0:
# 执行评估
model.eval()
c = evaluate(model, test_loader, test_dataset.vocabulary)
print('\n', '=' * 70)
print('[%s] Test epoch %d, cer: %f' % (datetime.now(), epoch, c))
print('=' * 70)
writer.add_scalar('Test cer', c, test_step)
test_step += 1
model.train()
# 记录学习率
writer.add_scalar('Learning rate', scheduler.last_lr, epoch)
# 保存模型
save_model(args=args,
epoch=epoch,
model=model,
optimizer=optimizer)
scheduler.step()
con = self.gru_con(con)[0]
# 合成GRU特征
own = self.sub_own(own)
con = self.sub_con(con)
# 降维
own = paddle.tensor.flatten(own, start_axis=1)
con = paddle.tensor.flatten(con, start_axis=1)
own = self.features_own(own)
con = self.features_con(con)
# 合成正方与反方特征
features = paddle.tensor.concat([own, con], axis=1)
role_features = self.sub_role(features)
flag_features = self.sub_flag(features)
money_features = self.sub_money(features)
# 输出层
role = self.role(role_features)
flag = self.flag(flag_eatures)
money = self.money(money_features)
if not self.is_infer:
return role, flag, money
else:
role_prob = paddle.nn.functional.softmax(role)
role_sort = paddle.tensor.argsort(role_prob, descending=True)
return role_prob, role_sort, flag, money
if __name__ == '__main__':
net = CWNet()
paddle.summary(net, input_size=[(8, 4), (8, 5)], dtypes="int64")
result = 0
for grasp_pre in grasps_pre:
if max_iou(grasp_pre, grasps_true) > 0.25:
result = 1
break
if result:
val_result['correct'] += 1
else:
val_result['failed'] += 1
acc = val_result['correct'] / (val_result['correct'] +
val_result['failed'])
val_result['acc'] = acc
print(time.ctime())
print('Correct: {}/{}, val_loss: {:0.4f}, acc: {:0.4f}'.format(
val_result['correct'], val_result['correct'] + val_result['failed'],
val_result['loss'].numpy()[0], acc))
return val_result
if __name__ == '__main__':
use_gpu = True
paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu')
net = GGCNN(include_depth + include_rgb * 3)
paddle.summary(net, (1, 4, 300, 300))
for epoch_num in range(epoch_nums):
train_result = train(net, epoch_num, train_batches)
print('validating...')
val_result = eval_net(net, val_batches)
fluid.dygraph.save_dygraph(net.state_dict(), "save_dir/params")
import paddle
import paddle.nn as nn
class VoxNet(nn.Layer):
def __init__(self, name_scope='VoxNet_', num_classes=10):
super(VoxNet, self).__init__()
self.backbone = nn.Sequential(nn.Conv3D(1, 32, 5, 2), nn.BatchNorm(32),
nn.LeakyReLU(), nn.Conv3D(32, 32, 3, 1),
nn.MaxPool3D(2, 2, 0))
self.head = nn.Sequential(nn.Linear(32 * 6 * 6 * 6, 128),
nn.LeakyReLU(), nn.Dropout(0.2),
nn.Linear(128, num_classes))
def forward(self, inputs):
x = paddle.to_tensor(inputs)
x = self.backbone(x)
x = paddle.reshape(x, (-1, 32 * 6 * 6 * 6))
x = self.head(x)
return x
if __name__ == '__main__':
model = VoxNet()
paddle.summary(model, (64, 1, 32, 32, 32))
# 设置损失值的比例
radio_cls_loss = 1.0
radio_bbox_loss = 0.5
radio_landmark_loss = 0.5
# 训练参数值
data_path = '../dataset/24/all_data'
batch_size = 384
learning_rate = 1e-3
epoch_num = 22
model_path = '../infer_models'
# 获取P模型
model = RNet()
paddle.summary(model, input_size=(batch_size, 3, 24, 24))
# 获取数据
train_dataset = CustomDataset(data_path)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
# 设置优化方法
scheduler = paddle.optimizer.lr.PiecewiseDecay(boundaries=[6, 14, 20], values=[0.001, 0.0001, 0.00001, 0.000001],
verbose=True)
optimizer = paddle.optimizer.Adam(parameters=model.parameters(),
learning_rate=scheduler,
weight_decay=paddle.regularizer.L2Decay(1e-4))
# 获取损失函数
class_loss = ClassLoss()
bbox_loss = BBoxLoss()
def test_summary_gpu(self):
paddle.disable_static(self.device)
rnn = paddle.nn.LSTM(16, 32, 2)
params_info = paddle.summary(
rnn, [(-1, 23, 16), ((2, None, 32), (2, -1, 32))])
# 设置损失值的比例
radio_cls_loss = 1.0
radio_bbox_loss = 0.5
radio_landmark_loss = 0.5
# 训练参数值
data_path = '../dataset/12/all_data'
batch_size = 384
learning_rate = 1e-3
epoch_num = 30
model_path = '../infer_models'
# 获取P模型
model = PNet()
paddle.summary(model, input_size=(batch_size, 3, 12, 12))
# 获取数据
train_dataset = CustomDataset(data_path)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
# 设置优化方法
scheduler = paddle.optimizer.lr.PiecewiseDecay(boundaries=[6, 14, 20], values=[0.001, 0.0001, 0.00001, 0.000001],
verbose=True)
optimizer = paddle.optimizer.Adam(parameters=model.parameters(),
learning_rate=scheduler,
weight_decay=paddle.regularizer.L2Decay(1e-4))
# 获取损失函数
class_loss = ClassLoss()
bbox_loss = BBoxLoss()
def train(args):
# 设置支持多卡训练
if len(args.gpus.split(',')) > 1:
dist.init_parallel_env()
if dist.get_rank() == 0:
shutil.rmtree('log', ignore_errors=True)
# 日志记录器
writer = LogWriter(logdir='log')
# 获取数据
train_dataset = CustomDataset(args.train_root_path, is_train=False)
# 设置支持多卡训练
if len(args.gpus.split(',')) > 1:
batch_sampler = paddle.io.DistributedBatchSampler(train_dataset, batch_size=args.batch_size, shuffle=True)
else:
batch_sampler = paddle.io.BatchSampler(train_dataset, batch_size=args.batch_size, shuffle=True)
train_loader = DataLoader(dataset=train_dataset, batch_sampler=batch_sampler, num_workers=args.num_workers)
print("[%s] 总数据类别为：%d" % (datetime.now(), train_dataset.num_classes))
# 获取模型，贴心的作者同时提供了resnet的模型，以满足不同情况的使用
if args.use_model == 'resnet_face34':
model = resnet_face34()
else:
model = MobileFaceNet()
metric_fc = ArcNet(feature_dim=512, class_dim=train_dataset.num_classes)
if dist.get_rank() == 0:
paddle.summary(model, input_size=(None, 3, 112, 112))
# 设置支持多卡训练
if len(args.gpus.split(',')) > 1:
model = paddle.DataParallel(model)
metric_fc = paddle.DataParallel(metric_fc)
# 获取预训练的epoch数
last_epoch = int(re.findall(r'\d+', args.resume)[-1]) + 1 if args.resume is not None else 0
# 学习率衰减
scheduler = paddle.optimizer.lr.StepDecay(learning_rate=args.learning_rate, step_size=10, gamma=0.1, last_epoch=last_epoch, verbose=True)
# 设置优化方法
optimizer = paddle.optimizer.Momentum(parameters=model.parameters() + metric_fc.parameters(),
learning_rate=scheduler,
momentum=0.9,
weight_decay=paddle.regularizer.L2Decay(5e-4))
# 加载预训练模型
if args.pretrained_model is not None:
model_dict = model.state_dict()
model_state_dict = paddle.load(os.path.join(args.pretrained_model, 'model.pdparams'))
# 特征层
for name, weight in model_dict.items():
if name in model_state_dict.keys():
if weight.shape != list(model_state_dict[name].shape):
print('{} not used, shape {} unmatched with {} in model.'.
format(name, list(model_state_dict[name].shape), weight.shape))
model_state_dict.pop(name, None)
else:
print('Lack weight: {}'.format(name))
model.set_dict(model_state_dict)
print('[%s] Rank %d 成功加载 model 参数' % (datetime.now(), dist.get_rank()))
# 恢复训练
if args.resume is not None:
model.set_state_dict(paddle.load(os.path.join(args.resume, 'model.pdparams')))
metric_fc.set_state_dict(paddle.load(os.path.join(args.resume, 'metric_fc.pdparams')))
optimizer.set_state_dict(paddle.load(os.path.join(args.resume, 'optimizer.pdopt')))
print('[%s] Rank %d 成功加载模型参数和优化方法参数' % (datetime.now(), dist.get_rank()))
# 获取损失函数
loss = paddle.nn.CrossEntropyLoss()
train_step = 0
test_step = 0
sum_batch = len(train_loader) * (args.num_epoch - last_epoch)
# 开始训练
for epoch in range(last_epoch, args.num_epoch):
loss_sum = []
accuracies = []
for batch_id, (img, label) in enumerate(train_loader()):
start = time.time()
feature = model(img)
output = metric_fc(feature, label)
# 计算损失值
los = loss(output, label)
los.backward()
optimizer.step()
optimizer.clear_grad()
# 计算准确率
label = paddle.reshape(label, shape=(-1, 1))
acc = accuracy(input=paddle.nn.functional.softmax(output), label=label)
accuracies.append(acc.numpy()[0])
loss_sum.append(los.numpy()[0])
# 多卡训练只使用一个进程打印
if batch_id % 100 == 0 and dist.get_rank() == 0:
eta_sec = ((time.time() - start) * 1000) * (sum_batch - (epoch - last_epoch) * len(train_loader) - batch_id)
eta_str = str(timedelta(seconds=int(eta_sec / 1000)))
print('[%s] Train epoch %d, batch: %d/%d, loss: %f, accuracy: %f, eta: %s' % (
datetime.now(), epoch, batch_id, len(train_loader), sum(loss_sum) / len(loss_sum), sum(accuracies) / len(accuracies), eta_str))
writer.add_scalar('Train loss', los, train_step)
train_step += 1
loss_sum = []
# 多卡训练只使用一个进程执行评估和保存模型
if dist.get_rank() == 0:
print('='*70)
acc = test(model)
print('[%s] Test %d, accuracy: %f' % (datetime.now(), epoch, acc))
print('='*70)
writer.add_scalar('Test acc', acc, test_step)
# 记录学习率
writer.add_scalar('Learning rate', scheduler.last_lr, epoch)
test_step += 1
save_model(args, epoch, model, metric_fc, optimizer)
scheduler.step()
save_model(args, args.num_epoch, model, metric_fc, optimizer)
def test_summary_nlp(self):
paddle.enable_static()
nlp_net = paddle.nn.GRU(input_size=2, hidden_size=3, num_layers=3)
paddle.summary(nlp_net, (1, 2))
def test_summary_dtype(self):
input_shape = (3, 1)
net = paddle.nn.Embedding(10, 3, sparse=True)
paddle.summary(net, input_shape, dtypes='int64')
def forward(self, x):
fc = self._linear(x)
return fc + self._offset
batch_size = 3
feature_size = 5
output_dim = 1
shape = (batch_size, feature_size, output_dim)
fc_layer = SimpleFcLayer(*shape)
# 查验模型结构
paddle.summary(fc_layer, shape[0:2]) # 输出简单的线性结构
# ---------------------------------------------------------------------------
# Layer (type) Input Shape Output Shape Param #
# ===========================================================================
# Linear-5 [[3, 5]] [3, 1] 6
# ===========================================================================
# Total params: 6
# Trainable params: 6
# Non-trainable params: 0
# ---------------------------------------------------------------------------
# Input size (MB): 0.00
# Forward/backward pass size (MB): 0.00
# Params size (MB): 0.00
# Estimated Total Size (MB): 0.00
# ---------------------------------------------------------------------------
def main():
print("\n Paddlepaddle version: {}\n".format(paddle.__version__))
args = parse_args()
# 初始化并行环境
# dist.init_parallel_env()
# 加载数据集
train_dataset = paddle.vision.datasets.MNIST(mode='train',
transform=ToTensor())
val_dataset = paddle.vision.datasets.MNIST(mode='test',
transform=ToTensor())
train_loader = paddle.io.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True)
test_loader = paddle.io.DataLoader(val_dataset, batch_size=args.batch_size)
# 模型搭建
mnist = Mnist()
paddle.summary(net=mnist, input_size=(-1, 1, 28, 28))
# 增加paddle.DataParallel封装
# mnist = paddle.DataParallel(mnist)
optim = paddle.optimizer.Adam(parameters=mnist.parameters())
loss_fn = paddle.nn.CrossEntropyLoss()
start_epoch = 0
epochs = args.epochs
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
info = np.load('./weights/info.npy', allow_pickle=True).item()
start_epoch = info['epoch'] + 1
val_loss = info['loss']
val_acc = info['acc']
print('Epoch {}, validation loss is: {loss:.4f}, validation accuracy is {acc:.4f}\n'\
.format(start_epoch,loss=val_loss,acc=val_acc))
mnist_state_dict = paddle.load('./weights/mnist.pdparams')
mnist.set_state_dict(mnist_state_dict)
optim_state_dict = paddle.load('./weights/optim.pdopt')
optim.set_state_dict(optim_state_dict)
best_acc = 0.0
for epoch in range(start_epoch, epochs):
# 训练
mnist.train()
loader = tqdm.tqdm(train_loader)
for batch_id, (image, label) in enumerate(loader):
predicts = mnist(image)
loss = loss_fn(predicts, label)
acc = paddle.metric.accuracy(predicts, label)
loss.backward()
optim.step()
optim.clear_grad()
description = (
'Epoch {} (loss: {loss:.4f}, acc: {acc:.4f})'.format(
epoch, loss=loss.numpy().item(), acc=acc.numpy().item()))
loader.set_description(description)
# 测试
mnist.eval()
losses = 0.0
accuracy = 0.0
count = 0
for batch_id, (image, label) in enumerate(test_loader):
predicts = mnist(image)
loss = loss_fn(predicts, label)
acc = paddle.metric.accuracy(predicts, label)
count += 1
losses += loss.numpy().item()
accuracy += acc.numpy().item()
val_loss = losses / count
val_acc = accuracy / count
print("Testing: loss:{loss:.4f}, acc: {acc:.4f}".format(loss=val_loss,
acc=val_acc))
# 保存测试过程结果
result = OrderedDict()
result['timestamp'] = datetime.now()
result['epoch'] = epoch
result['loss'] = val_loss
result['accuracy'] = val_acc
result_dir = './result/'
if not os.path.exists(result_dir) and result_dir != '':
os.makedirs(result_dir)
result_file = os.path.join(result_dir, 'valid_results.csv')
write_heading = not os.path.exists(result_file)
with open(result_file, mode='a') as out:
if write_heading:
out.write(",".join([str(k) for k, v in result.items()]) + '\n')
out.write(",".join([str(v) for k, v in result.items()]) + '\n')
# 保存参数
print('Saving checkpoint..')
state = {'epoch': epoch, 'loss': val_loss, 'acc': val_acc}
# 目前仅支持存储 Layer 或者 Optimizer 的 state_dict 。
np.save('./weights/info.npy', state, allow_pickle=True) # 保存相关参数
paddle.save(mnist.state_dict(), './weights/mnist.pdparams')
paddle.save(optim.state_dict(), './weights/optim.pdopt')
# 保存用于部署的模型和参数
if val_acc > best_acc:
best_acc = val_acc
paddle.jit.save(
mnist,
'./deploy/mnist',
input_spec=[InputSpec(shape=[1, 1, 28, 28], dtype='float32')])
def train(args):
# 设置支持多卡训练
dist.init_parallel_env()
if dist.get_rank() == 0:
shutil.rmtree('log', ignore_errors=True)
# 日志记录器
writer = LogWriter(logdir='log')
# 数据输入的形状
input_shape = eval(args.input_shape)
# 获取数据
train_dataset = CustomDataset(args.train_list_path, model='train', spec_len=input_shape[3])
train_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers)
test_dataset = CustomDataset(args.test_list_path, model='test', spec_len=input_shape[3])
test_loader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers)
# 获取模型
model = resnet34()
metric_fc = ArcMarginProduct(feature_dim=512, class_dim=args.num_classes, easy_margin=args.easy_margin)
if dist.get_rank() == 0:
paddle.summary(model, input_size=input_shape)
# 设置支持多卡训练
model = paddle.DataParallel(model)
metric_fc = paddle.DataParallel(metric_fc)
# 分段学习率
boundaries = [10, 30, 70, 100]
lr = [0.1 ** l * args.learning_rate for l in range(len(boundaries) + 1)]
scheduler = paddle.optimizer.lr.PiecewiseDecay(boundaries=boundaries, values=lr, verbose=True)
# 设置优化方法
optimizer = paddle.optimizer.Adam(parameters=model.parameters() + metric_fc.parameters(),
learning_rate=scheduler,
weight_decay=paddle.regularizer.L2Decay(1e-4))
# 加载预训练模型
if args.pretrained_model is not None:
model_dict = model.state_dict()
param_state_dict = paddle.load(os.path.join(args.pretrained_model, 'model.pdparams'))
for name, weight in model_dict.items():
if name in param_state_dict.keys():
if weight.shape != list(param_state_dict[name].shape):
print('{} not used, shape {} unmatched with {} in model.'.
format(name, list(param_state_dict[name].shape), weight.shape))
param_state_dict.pop(name, None)
else:
print('Lack weight: {}'.format(name))
model.set_dict(param_state_dict)
print('成功加载预训练模型参数')
# 恢复训练
if args.resume is not None:
model.set_state_dict(paddle.load(os.path.join(args.resume, 'model.pdparams')))
optimizer.set_state_dict(paddle.load(os.path.join(args.resume, 'optimizer.pdopt')))
print('成功加载模型参数和优化方法参数')
# 获取损失函数
loss = FocalLoss(gamma=args.gamma)
train_step = 0
test_step = 0
# 开始训练
for epoch in range(args.num_epoch):
loss_sum = []
for batch_id, (spec_mag, label) in enumerate(train_loader()):
feature = model(spec_mag)
output = metric_fc(feature, label)
# 计算损失值
los = loss(output, label)
loss_sum.append(los)
los.backward()
optimizer.step()
optimizer.clear_grad()
# 多卡训练只使用一个进程打印
if batch_id % 100 == 0 and dist.get_rank() == 0:
print('[%s] Train epoch %d, batch_id: %d, loss: %f' % (
datetime.now(), epoch, batch_id, sum(loss_sum) / len(loss_sum)))
writer.add_scalar('Train loss', los, train_step)
train_step += 1
loss_sum = []
# 多卡训练只使用一个进程执行评估和保存模型
if dist.get_rank() == 0:
acc = test(model, metric_fc, test_loader)
print('[%s] Train epoch %d, accuracy: %f' % (datetime.now(), epoch, acc))
writer.add_scalar('Test acc', acc, test_step)
# 记录学习率
writer.add_scalar('Learning rate', scheduler.last_lr, epoch)
test_step += 1
save_model(args, model, optimizer)
scheduler.step()
