def test_check_output(self):
fluid.enable_imperative()
linear = paddle.nn.Conv2d(2, 3, 3)
before_weight = linear.weight.numpy()
if self.dim == None:
self.dim = -1
if self.dim != -1:
self.dim = (self.dim + len(before_weight)) % len(before_weight)
wn = weight_norm(linear, dim=self.dim)
outputs = []
for name, data in self.data.items():
output = linear(fluid.dygraph.to_variable(data))
outputs.append(output.numpy())
after_weight = linear.weight
self.actual_outputs = [
linear.weight_g.numpy(),
linear.weight_v.numpy()
]
expect_output = self.weight_normalize(before_weight, self.dim)
for expect, actual in zip(expect_output, self.actual_outputs):
self.assertTrue(
numpy.allclose(numpy.array(actual), expect, atol=0.001))
def main(cfgs):
fluid.enable_imperative()
if 'resnet' in cfgs.netG:
from configs.resnet_configs import get_configs
else:
raise NotImplementedError
configs = get_configs(config_name=cfgs.config_set)
configs = list(configs.all_configs())
data_loader, id2name = create_eval_data(cfgs, direction=cfgs.direction)
model = TestModel(cfgs)
model.setup() ### load_network
### this input used in compute model flops and params
for data in data_loader:
model.set_input(data)
break
npz = np.load(cfgs.real_stat_path)
results = []
for config in configs:
fakes, names = [], []
flops, _ = model.profile(config=config)
s_time = time.time()
for i, data in enumerate(data_loader()):
model.set_input(data)
model.test(config)
generated = model.fake_B
fakes.append(generated.detach().numpy())
name = id2name[i]
save_path = os.path.join(cfgs.save_dir, 'test' + str(config))
if not os.path.exists(save_path):
os.makedirs(save_path)
save_path = os.path.join(save_path, name)
names.append(name)
if i < cfgs.num_test:
image = util.tensor2img(generated)
util.save_image(image, save_path)
result = {'config_str': encode_config(config), 'flops': flops} ### compute FLOPs
fluid.disable_imperative()
if not cfgs.no_fid:
block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[2048]
inception_model = InceptionV3([block_idx])
fid = get_fid(fakes, inception_model, npz, cfgs.inception_model_path, batch_size=cfgs.batch_size, use_gpu=cfgs.use_gpu)
result['fid'] = fid
fluid.enable_imperative()
e_time = (time.time() - s_time) / 60
result['time'] = e_time
print(result)
results.append(result)
if not os.path.exists(cfgs.save_dir):
os.makedirs(os.path.dirname(cfgs.save_dir))
save_file = os.path.join(cfgs.save_dir, 'search_result.pkl')
with open(save_file, 'wb') as f:
pickle.dump(results, f)
print('Successfully finish searching!!!')
def __init__(
self,
use_cuda=False,
tree=True,
prob=False,
use_pos=False,
model_files_path=None,
buckets=False,
batch_size=None,
encoding_model="ernie-lstm",
):
if model_files_path is None:
if encoding_model in ["lstm", "transformer", "ernie-1.0", "ernie-tiny", "ernie-lstm"]:
model_files_path = self._get_abs_path(os.path.join("./model_files/", encoding_model))
else:
raise KeyError("Unknown encoding model.")
if not os.path.exists(model_files_path):
try:
utils.download_model_from_url(model_files_path, encoding_model)
except Exception as e:
logging.error("Failed to download model, please try again")
logging.error("error: {}".format(e))
raise e
args = [
"--model_files={}".format(model_files_path), "--config_path={}".format(self._get_abs_path('config.ini')),
"--encoding_model={}".format(encoding_model)
]
if use_cuda:
args.append("--use_cuda")
if tree:
args.append("--tree")
if prob:
args.append("--prob")
if batch_size:
args.append("--batch_size={}".format(batch_size))
args = ArgConfig(args)
# Don't instantiate the log handle
args.log_path = None
self.env = Environment(args)
self.args = self.env.args
fluid.enable_imperative(self.env.place)
self.model = load(self.args.model_path)
self.model.eval()
self.lac = None
self.use_pos = use_pos
# buckets=None if not buckets else defaults
if not buckets:
self.args.buckets = None
if args.prob:
self.env.fields = self.env.fields._replace(PHEAD=Field("prob"))
if self.use_pos:
self.env.fields = self.env.fields._replace(CPOS=Field("postag"))
# set default batch size if batch_size is None and not buckets
if batch_size is None and not buckets:
self.args.batch_size = 50
def test_check_output(self):
fluid.enable_imperative()
linear = paddle.nn.Conv2d(2, 3, 3)
before_weight = linear.weight
wn = weight_norm(linear, dim=self.dim)
rwn = remove_weight_norm(linear)
after_weight = linear.weight
self.assertTrue(
numpy.allclose(before_weight.numpy(),
after_weight.numpy(),
atol=0.001))
def __init__(self,
use_cuda=False,
tree=True,
prob=False,
use_pos=False,
model_files_path=None,
buckets=False,
batch_size=None):
if model_files_path is None:
model_files_path = self._get_abs_path('./model_files/baidu')
if not os.path.exists(model_files_path):
try:
utils.download_model_from_url(model_files_path)
except Exception as e:
logging.error("Failed to download model, please try again")
logging.error(f"error: {e}")
return
args = [
f"--model_files={model_files_path}",
f"--config_path={self._get_abs_path('config.ini')}"
]
if use_cuda:
args.append("--use_cuda")
if tree:
args.append("--tree")
if prob:
args.append("--prob")
if batch_size:
args.append(f"--batch_size={batch_size}")
args = ArgConfig(args)
# Don't instantiate the log handle
args.log_path = None
self.env = Environment(args)
self.args = self.env.args
fluid.enable_imperative(self.env.place)
self.model = load(self.args.model_path)
self.lac = None
self.use_pos = use_pos
# buckets=None if not buckets else defaults
if not buckets:
self.args.buckets = None
if args.prob:
self.env.fields = self.env.fields._replace(PHEAD=Field('prob'))
if self.use_pos:
self.env.fields = self.env.fields._replace(CPOS=Field('postag'))
# set default batch size if batch_size is None and not buckets
if batch_size is None and not buckets:
self.args.batch_size = 50
def evaluate_model(self, step):
ret = {}
self.is_best = False
save_dir = os.path.join(self.cfgs.save_dir, 'mobile', 'eval',
str(step))
if not os.path.exists(save_dir):
os.makedirs(save_dir)
self.netG_A.eval()
self.netG_B.eval()
for direction in ['AtoB', 'BtoA']:
eval_dataloader = getattr(self, 'eval_dataloader_' + direction)
id2name = getattr(self, 'name_' + direction)
fakes = []
cnt = 0
for i, data_i in enumerate(eval_dataloader):
self.set_single_input(data_i)
self.test_single_side(direction)
fakes.append(self.fake_B.detach().numpy())
for j in range(len(self.fake_B)):
if cnt < 10:
name = 'fake_' + direction + str(i + j) + '.png'
save_path = os.path.join(save_dir, name)
fake_im = util.tensor2img(self.fake_B[j])
util.save_image(fake_im, save_path)
cnt += 1
suffix = direction[-1]
fluid.disable_imperative()
fid = get_fid(fakes, self.inception_model,
getattr(self, 'npz_%s' % direction[-1]),
self.cfgs.inception_model)
fluid.enable_imperative(place=self.cfgs.place)
if fid < getattr(self, 'best_fid_%s' % suffix):
self.is_best = True
setattr(self, 'best_fid_%s' % suffix, fid)
print("direction: %s, fid score is: %f, best fid score is %f" %
(direction, fid, getattr(self, 'best_fid_%s' % suffix)))
fids = getattr(self, 'fids_%s' % suffix)
fids.append(fid)
if len(fids) > 3:
fids.pop(0)
ret['metric/fid_%s' % suffix] = fid
ret['metric/fid_%s-mean' %
suffix] = sum(getattr(self, 'fids_%s' % suffix)) / len(
getattr(self, 'fids_%s' % suffix))
ret['metric/fid_%s-best' % suffix] = getattr(
self, 'best_fid_%s' % suffix)
self.netG_A.train()
self.netG_B.train()
return ret
def main(cfgs):
fluid.enable_imperative()
if cfgs.config_str is not None:
assert 'super' in cfgs.netG or 'sub' in cfgs.netG
config = decode_config(cfgs.config_str)
else:
assert 'super' not in cfgs.model
config = None
data_loader, id2name = create_eval_data(cfgs, direction=cfgs.direction)
model = TestModel(cfgs)
model.setup() ### load_network
fakes, names = [], []
for i, data in enumerate(data_loader()):
model.set_input(data)
if i == 0 and cfgs.need_profile:
flops, params = model.profile(config)
print('FLOPs: %.3fG, params: %.3fM' % (flops / 1e9, params / 1e6))
sys.exit(0)
model.test(config)
generated = model.fake_B
fakes.append(generated.detach().numpy())
name = id2name[i]
print(name)
save_path = os.path.join(cfgs.save_dir, 'test')
if not os.path.exists(save_path):
os.makedirs(save_path)
save_path = os.path.join(save_path, name)
names.append(name)
if i < cfgs.num_test:
image = util.tensor2img(generated)
util.save_image(image, save_path)
fluid.disable_imperative()
if not cfgs.no_fid:
print('Calculating FID...')
block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[2048]
inception_model = InceptionV3([block_idx])
npz = np.load(cfgs.real_stat_path)
fid = get_fid(fakes, inception_model, npz, cfgs.inception_model_path)
print('fid score: %#.2f' % fid)
def evaluate_model(self, step):
ret = {}
self.is_best = False
save_dir = os.path.join(self.cfgs.save_dir, 'distiller', 'eval',
str(step))
if not os.path.exists(save_dir):
os.makedirs(save_dir)
self.netG_student.eval()
fakes = []
cnt = 0
for i, data_i in enumerate(self.eval_dataloader):
id2name = self.name
self.set_single_input(data_i)
self.test()
fakes.append(self.Sfake_B.detach().numpy())
for j in range(len(self.Sfake_B)):
if cnt < 10:
Sname = 'Sfake_' + str(i + j) + '.png'
Tname = 'Tfake_' + str(i + j) + '.png'
Sfake_im = util.tensor2img(self.Sfake_B[j])
Tfake_im = util.tensor2img(self.Tfake_B[j])
util.save_image(Sfake_im, os.path.join(save_dir, Sname))
util.save_image(Tfake_im, os.path.join(save_dir, Tname))
cnt += 1
suffix = self.cfgs.direction
fluid.disable_imperative()
fid = get_fid(fakes, self.inception_model, self.npz,
self.cfgs.inception_model)
fluid.enable_imperative(place=self.cfgs.place)
if fid < self.best_fid:
self.is_best = True
self.best_fid = fid
print("fid score is: %f, best fid score is %f" % (fid, self.best_fid))
self.fids.append(fid)
if len(self.fids) > 3:
self.fids.pop(0)
ret['metric/fid'] = fid
ret['metric/fid-mean'] = sum(self.fids) / len(self.fids)
ret['metric/fid-best'] = self.best_fid
self.netG_student.train()
return ret
def main(cfgs):
fluid.enable_imperative()
config = decode_config(args.config_str)
if args.model == 'mobile_resnet':
from model.mobile_generator import MobileResnetGenerator as SuperModel
from model.sub_mobile_generator import SubMobileResnetGenerator as SubModel
input_nc, output_nc = args.input_nc, args.output_nc
super_model = SuperModel(input_nc, output_nc, ngf=args.ngf, norm_layer=InstanceNorm, n_blocks=9)
sub_model = SubModel(input_nc, output_nc, config=config, norm_layer=InstanceNorm, n_blocks=9)
else:
raise NotImplementedError
load_network(super_model, args.input_path)
transfer_weight(super_model, sub_model)
if not os.path.exists(args.output_path):
os.makedirs(args.output_path)
save_path = os.path.join(args.output_path, 'final_net')
fluid.save_dygraph(sub_model.state_dict(), save_path)
print('Successfully export the subnet at [%s].' % save_path)
def _get_abs_path(self, path):
return os.path.normpath(
os.path.join(os.path.dirname(os.path.abspath(__file__)), path))
if __name__ == '__main__':
logging.info("init arguments.")
args = ArgConfig()
logging.info("init environment.")
env = Environment(args)
logging.info(f"Override the default configs\n{env.args}")
logging.info(f"{env.WORD}\n{env.FEAT}\n{env.ARC}\n{env.REL}")
logging.info(f"Set the max num of threads to {env.args.threads}")
logging.info(
f"Set the seed for generating random numbers to {env.args.seed}")
logging.info(f"Run the subcommand in mode {env.args.mode}")
fluid.enable_imperative(env.place)
mode = env.args.mode
if mode == "train":
train(env)
elif mode == "evaluate":
evaluate(env)
elif mode == "predict":
predict(env)
elif mode == "predict_q":
predict_query(env)
else:
logging.error(f"Unknown task mode: {mode}.")
# 每次生成一个Batch，使用set_batch_generator配置数据源
def batch_generator_creator():
def __reader__():
for _ in range(BATCH_NUM):
batch_image, batch_label = get_random_images_and_labels(
[BATCH_SIZE, MNIST_IMAGE_SIZE], [BATCH_SIZE, MNIST_LABLE_SIZE])
yield batch_image, batch_label
return __reader__
BATCH_SIZE = 10
place = fluid.CPUPlace() # 或者 fluid.CUDAPlace(0)
fluid.enable_imperative(place)
#
# # 使用sample数据生成器作为DataLoader的数据源
# data_loader1 = fluid.io.DataLoader.from_generator(capacity=10)
# data_loader1.set_sample_generator(sample_generator_creator(), batch_size=BATCH_SIZE, places=place)
#
# # 使用sample list数据生成器作为DataLoader的数据源
# data_loader2 = fluid.io.DataLoader.from_generator(capacity=10)
# data_loader2.set_sample_list_generator(sample_list_generator_creator(), places=place)
# 使用batch数据生成器作为DataLoader的数据源
data_loader3 = fluid.io.DataLoader.from_generator(capacity=10)
data_loader3.set_batch_generator(batch_generator_creator(), places=place)
for data in data_loader3():
image, label = data
