def test_save_load_parameters():
v = nn.Variable([64, 1, 28, 28], need_grad=False)
with nn.parameter_scope("param1"):
with nn.parameter_scope("conv1"):
h = PF.convolution(v, 32, (3, 3))
b = PF.batch_normalization(h, batch_stat=True)
with nn.parameter_scope("conv2"):
h1 = PF.convolution(v, 32, (3, 3))
b2 = PF.batch_normalization(h1, batch_stat=True)
for k, v in nn.get_parameters(grad_only=False).iteritems():
v.data.cast(np.float32)[...] = np.random.randn(*v.shape)
with nn.parameter_scope("param1"):
param1 = nn.get_parameters(grad_only=False)
nn.save_parameters("tmp.h5")
nn.save_parameters("tmp.protobuf")
with nn.parameter_scope("param2"):
nn.load_parameters('tmp.h5')
param2 = nn.get_parameters(grad_only=False)
with nn.parameter_scope("param3"):
nn.load_parameters('tmp.protobuf')
param3 = nn.get_parameters(grad_only=False)
for par2 in [param2, param3]:
assert param1.keys() == par2.keys() # Check order
for (n1, p1), (n2, p2) in zip(sorted(param1.items()),
sorted(par2.items())):
assert n1 == n2
assert np.all(p1.d == p2.d)
assert p1.data.dtype == p2.data.dtype
assert p1.need_grad == p2.need_grad
def test():
print("Evaluate the trained model with full MNIST test set")
args = get_args()
# Create CNN network for both training and testing.
mnist_cnn_prediction = mnist_lenet_prediction
if args.net == 'resnet':
mnist_cnn_prediction = mnist_resnet_prediction
args.batch_size = 100
tdata = data_iterator_mnist(args.batch_size, False)
timage = nn.Variable([args.batch_size, 1, 28, 28])
tlabel = nn.Variable([args.batch_size, 1])
parameter_file = os.path.join(
args.model_save_path,
'{}_params_{:06}.h5'.format(args.net, args.max_iter))
nn.load_parameters(parameter_file)
# Create inference graph
tpred = mnist_cnn_prediction(timage, test=True)
num_test_iter = int((tdata.size + args.batch_size - 1) / args.batch_size)
te = 0.0
for j in range(num_test_iter):
timage.d, tlabel.d = tdata.next()
tpred.forward(clear_buffer=True)
te += categorical_error(tpred.d, tlabel.d)
te_avg = te / num_test_iter
print("MNIST test accuracy", 1 - te_avg)
def load_checkpoint(self, args):
"""Load pretrained parameters and solver states
Args:
args (ArgumentParser): To check if tensorflow trained weights are to be used for testing and to get the path of the folder
from where the parameter and solver states are to be loaded
"""
if args.use_tf_weights:
if not os.path.isfile(
os.path.join(args.weights_path, 'gen_params.h5')):
os.makedirs(args.weights_path, exist_ok=True)
print(
"Downloading the pretrained tf-converted weights. Please wait..."
)
url = "https://nnabla.org/pretrained-models/nnabla-examples/GANs/stylegan2/styleGAN2_G_params.h5"
from nnabla.utils.data_source_loader import download
download(url, os.path.join(args.weights_path, 'gen_params.h5'),
False)
nn.load_parameters(os.path.join(args.weights_path,
'gen_params.h5'))
print('Loaded pretrained weights from tensorflow!')
else:
try:
nn.load_parameters(os.path.join(args.weights_path,
'params.h5'))
except:
if args.test:
warnings.warn(
"Testing Model without pretrained weights!!!")
else:
print('No Pretrained weights loaded.')
def main(args):
if args.gpu:
ctx = get_extension_context('cudnn', device_id=str(args.device))
nn.set_default_context(ctx)
# atari environment
env = AtariWrapper(gym.make(args.env), args.seed, episodic=True)
eval_env = AtariWrapper(gym.make(args.env), args.seed, episodic=False)
num_actions = env.action_space.n
# action-value function built with neural network
model = NoisyNetDQN(q_function, num_actions, args.batch_size, args.gamma,
args.lr)
if args.load is not None:
nn.load_parameters(args.load)
model.update_target()
buffer = ReplayBuffer(args.buffer_size, args.batch_size)
exploration = ConstantEpsilonGreedy(num_actions, 0.0)
monitor = prepare_monitor(args.logdir)
update_fn = update(model, buffer, args.target_update_interval)
eval_fn = evaluate(eval_env, model, render=args.render)
train(env, model, buffer, exploration, monitor, update_fn, eval_fn,
args.final_step, args.update_start, args.update_interval,
args.save_interval, args.evaluate_interval, ['loss'])
def load_models(epoch_num, gen=True, dis=True):
# load generator parameter
with nn.parameter_scope('Wave-U-Net'):
nn.load_parameters(
os.path.join(args.model_save_path,
'param_{:04}.h5'.format(args.epoch_from)))
def test(args):
## Load data & Create batch
clean_data, noisy_data = dt.data_loader(test=True, need_length=True)
# Batch
# - Proccessing speech interval can be adjusted by "start_frame" and "start_frame".
# - "None" -> All speech in test dataset.
baches_test = dt.create_batch_test(clean_data, noisy_data, start_frame=None, stop_frame=None)
del clean_data, noisy_data
## Create network
# Variables
noisy_t = nn.Variable(baches_test.noisy.shape) # Input
z = nn.Variable([baches_test.noisy.shape[0], 1024, 8]) # Random Latent Variable
# Network (Only Generator)
output_t = Generator(noisy_t, z)
## Load parameter
# load generator
with nn.parameter_scope("gen"):
print(args.epoch)
nn.load_parameters(os.path.join(args.model_save_path, "generator_param_{:04}.h5".format(args.epoch)))
## Validation
noisy_t.d = baches_test.noisy
#z.d = np.random.randn(*z.shape)
z.d = np.zeros(z.shape) # zero latent valiables
output_t.forward()
## Create wav files
dt.wav_write('clean.wav', baches_test.clean.flatten(), fs=16000)
dt.wav_write('input_segan.wav', baches_test.noisy.flatten(), fs=16000)
dt.wav_write('output_segan.wav', output_t.d.flatten(), fs=16000)
print('finish!')
def show():
args = get_args()
# Load model
nn.load_parameters(args.model_load_path)
params = nn.get_parameters()
# Show heatmap
for name, param in params.items():
# SSL only on convolution weights
if "conv/W" not in name:
continue
print(name)
n, m, k0, k1 = param.d.shape
w_matrix = param.d.reshape((n, m * k0 * k1))
# Filter x Channel heatmap
fig, ax = plt.subplots()
ax.set_title(
"{} with shape {} \n Filter x (Channel x Heigh x Width)".format(
name, (n, m, k0, k1)))
heatmap = ax.pcolor(w_matrix)
fig.colorbar(heatmap)
plt.pause(0.5)
raw_input("Press Key")
plt.close()
def load_parameters(params_path):
if not os.path.isfile(params_path):
from nnabla.utils.download import download
url = os.path.join("https://nnabla.org/pretrained-models/nnabla-examples/eval_metrics/lpips",
params_path.split("/")[-1])
download(url, params_path, False)
nn.load_parameters(params_path)
def main(args):
# Setting
device_id = args.device_id
conf = args.conf
path = conf.data_path
B = conf.batch_size
R = conf.n_rays
L = conf.layers
D = conf.depth
feature_size = conf.feature_size
ctx = get_extension_context('cudnn', device_id=device_id)
nn.set_default_context(ctx)
# Dataset
ds = DTUMVSDataSource(path, R, shuffle=True)
# Monitor
monitor_path = "/".join(args.model_load_path.split("/")[0:-1])
monitor = Monitor(monitor_path)
monitor_psnrs = MonitorSeries(f"PSNRs", monitor, interval=1)
monitor_psnr = MonitorSeries(f"PSNR", monitor, interval=1)
# Load model
nn.load_parameters(args.model_load_path)
# Evaluate
image_list = []
for pose, intrinsic, mask_obj in zip(ds.poses, ds.intrinsics, ds.masks):
image = render(pose[np.newaxis, ...], intrinsic[np.newaxis, ...],
mask_obj[np.newaxis, ...], conf)
image_list.append(image)
metric = psnr(image_list, ds.images, ds.masks, monitor_psnrs)
monitor_psnr.add(0, metric)
def test_transformer(config, netG, train_iterators, monitor, param_file):
netG_A2B = netG['netG_A2B']
train_iterator_src, train_iterator_trg = train_iterators
# Load boundary image to get Variable shapes
bod_map_A = train_iterator_src.next()[0]
bod_map_B = train_iterator_trg.next()[0]
real_bod_map_A = nn.Variable(bod_map_A.shape)
real_bod_map_B = nn.Variable(bod_map_B.shape)
real_bod_map_A.persistent, real_bod_map_B.persistent = True, True
################### Graph Construction ####################
# Generator
with nn.parameter_scope('netG_transformer'):
with nn.parameter_scope('netG_A2B'):
fake_bod_map_B = netG_A2B(
real_bod_map_A, test=True,
norm_type=config["norm_type"]) # (1, 15, 64, 64)
fake_bod_map_B.persistent = True
# load parameters of networks
with nn.parameter_scope('netG_transformer'):
with nn.parameter_scope('netG_A2B'):
nn.load_parameters(param_file)
monitor_vis = nm.MonitorImage('result',
monitor,
interval=config["test"]["vis_interval"],
num_images=1,
normalize_method=lambda x: x)
# Test
i = 0
iter_per_epoch = train_iterator_src.size // config["test"]["batch_size"] + 1
if config["num_test"]:
num_test = config["num_test"]
else:
num_test = train_iterator_src.size
for _ in range(iter_per_epoch):
bod_map_A = train_iterator_src.next()[0]
bod_map_B = train_iterator_trg.next()[0]
real_bod_map_A.d, real_bod_map_B.d = bod_map_A, bod_map_B
# Generate fake images
fake_bod_map_B.forward(clear_buffer=True)
i += 1
images_to_visualize = [
real_bod_map_A.d, fake_bod_map_B.d, real_bod_map_B.d
]
visuals = combine_images(images_to_visualize)
monitor_vis.add(i, visuals)
if i > num_test:
break
def evaluate(path):
nn.load_parameters(os.path.join(path, "params.h5"))
# Create embedded network
batch_size = 500
image = nn.Variable([batch_size, 1, 28, 28])
feature = I.mnist_lenet_feature(image, test=True)
# Process all images
features = []
labels = []
# Prepare MNIST data iterator
rng = np.random.RandomState(313)
data = I.data_iterator_mnist(batch_size, train=False, shuffle=True, rng=rng)
for i in range(10000 // batch_size):
image_data, label_data = data.next()
image.d = image_data / 255.0
feature.forward(clear_buffer=True)
features.append(feature.d.copy())
labels.append(label_data.copy())
features = np.vstack(features)
labels = np.vstack(labels)
df = pd.DataFrame(features, columns=["x", "y"])
df["label"] = labels
return df
def test_save_load_parameters():
v = nn.Variable([64, 1, 28, 28], need_grad=False)
with nn.parameter_scope("param1"):
with nn.parameter_scope("conv1"):
h = PF.convolution(v, 32, (3, 3))
b = PF.batch_normalization(h, batch_stat=True)
with nn.parameter_scope("conv2"):
h1 = PF.convolution(v, 32, (3, 3))
b2 = PF.batch_normalization(h1, batch_stat=True)
for k, v in iteritems(nn.get_parameters(grad_only=False)):
v.data.cast(np.float32)[...] = np.random.randn(*v.shape)
with nn.parameter_scope("param1"):
param1 = nn.get_parameters(grad_only=False)
nn.save_parameters("tmp.h5")
nn.save_parameters("tmp.protobuf")
with nn.parameter_scope("param2"):
nn.load_parameters('tmp.h5')
param2 = nn.get_parameters(grad_only=False)
with nn.parameter_scope("param3"):
nn.load_parameters('tmp.protobuf')
param3 = nn.get_parameters(grad_only=False)
for par2 in [param2, param3]:
assert param1.keys() == par2.keys() # Check order
for (n1, p1), (n2, p2) in zip(sorted(param1.items()), sorted(par2.items())):
assert n1 == n2
assert np.all(p1.d == p2.d)
assert p1.data.dtype == p2.data.dtype
assert p1.need_grad == p2.need_grad
def main(args):
if args.gpu:
ctx = get_extension_context('cudnn', device_id=str(args.device))
nn.set_default_context(ctx)
# atari environment
num_envs = args.num_envs
envs = [gym.make(args.env) for _ in range(num_envs)]
batch_env = BatchEnv([AtariWrapper(env, args.seed) for env in envs])
eval_env = AtariWrapper(gym.make(args.env), 50, episodic=False)
num_actions = envs[0].action_space.n
# action-value function built with neural network
lr_scheduler = learning_rate_scheduler(args.lr, 10**7)
model = A2C(num_actions, num_envs, num_envs * args.time_horizon,
args.v_coeff, args.ent_coeff, lr_scheduler)
if args.load is not None:
nn.load_parameters(args.load)
logdir = prepare_directory(args.logdir)
eval_fn = evaluate(eval_env, model, args.render)
# start training loop
return_fn = compute_returns(args.gamma)
train_loop(batch_env, model, num_actions, return_fn, logdir, eval_fn, args)
def main(args):
# Setting
device_id = args.device_id
conf = args.conf
path = conf.data_path
B = conf.batch_size
R = conf.n_rays
L = conf.layers
D = conf.depth
feature_size = conf.feature_size
ctx = get_extension_context('cudnn', device_id=device_id)
nn.set_default_context(ctx)
# Dataset
ds = DTUMVSDataSource(path, R, shuffle=True)
# Monitor
monitor_path = "/".join(args.model_load_path.split("/")[0:-1])
monitor = Monitor(monitor_path)
monitor_image = MonitorImage(
f"Rendered image synthesis", monitor, interval=1)
# Load model
nn.load_parameters(args.model_load_path)
# Render
pose = ds.poses[conf.valid_index:conf.valid_index+1, ...]
intrinsic = ds.intrinsics[conf.valid_index:conf.valid_index+1, ...]
mask_obj = ds.masks[conf.valid_index:conf.valid_index+1, ...]
image = render(pose, intrinsic, mask_obj, conf)
monitor_image.add(conf.valid_index, image)
def meta_test(args, shape_x, test_data):
# Build episode generators
test_episode_generator = EpisodeGenerator(
test_data[0], test_data[1], args.n_class, args.n_shot, args.n_query)
# Build prototypical network
xs_v = nn.Variable((args.n_class * args.n_shot, ) + shape_x)
xq_v = nn.Variable((args.n_class * args.n_query, ) + shape_x)
hq_v = net(args.n_class, xs_v, xq_v, args.embedding,
args.net_type, args.metric, True)
yq_v = nn.Variable((args.n_class * args.n_query, 1))
err_v = F.mean(F.top_n_error(hq_v, yq_v, n=1))
# Load parameters
nn.load_parameters(args.work_dir + "/params.h5")
# Evaluate error rate
v_errs = []
for k in range(args.n_episode_for_test):
xs_v.d, xq_v.d, yq_v.d = test_episode_generator.next()
err_v.forward(clear_no_need_grad=True, clear_buffer=True)
v_errs.append(np.float(err_v.d.copy()))
v_err_mean = np.mean(v_errs)
v_err_std = np.std(v_errs)
v_err_conf = 1.96 * v_err_std / np.sqrt(args.n_episode_for_test)
# Monitor error rate
monitor = Monitor(args.work_dir)
monitor_test_err = MonitorSeries("Test error", monitor)
monitor_test_conf = MonitorSeries("Test error confidence", monitor)
monitor_test_err.add(0, v_err_mean * 100)
monitor_test_conf.add(0, v_err_conf * 100)
return v_err_mean, v_err_conf
def generate(args):
# Context
ctx = get_extension_context(args.context,
device_id=args.device_id,
type_config=args.type_config)
nn.set_default_context(ctx)
# Args
latent = args.latent
maps = args.maps
batch_size = args.batch_size
# Generator
nn.load_parameters(args.model_load_path)
z_test = nn.Variable([batch_size, latent])
x_test = generator(z_test, maps=maps, test=True, up=args.up)
# Monitor
monitor = Monitor(args.monitor_path)
monitor_image_tile_test = MonitorImageTile("Image Tile Generated",
monitor,
num_images=batch_size,
interval=1,
normalize_method=denormalize)
# Generation iteration
for i in range(args.num_generation):
z_test.d = np.random.randn(batch_size, latent)
x_test.forward(clear_buffer=True)
monitor_image_tile_test.add(i, x_test)
def _load_nnp_to_proto(nnp_path):
import google.protobuf.text_format as text_format
import tempfile
import zipfile
import shutil
proto = nnabla_pb2.NNablaProtoBuf()
tmpdir = tempfile.mkdtemp()
try:
with zipfile.ZipFile(nnp_path, "r") as nnp:
for name in nnp.namelist():
_, ext = os.path.splitext(name)
if name == "nnp_version.txt":
pass # Currently nnp_version.txt is ignored
elif ext in [".nntxt", ".prototxt"]:
nnp.extract(name, tmpdir)
with open(os.path.join(tmpdir, name), "rt") as f:
text_format.Merge(f.read(), proto)
elif ext in [".protobuf", ".h5"]:
nnp.extract(name, tmpdir)
nn.load_parameters(os.path.join(tmpdir, name))
finally:
shutil.rmtree(tmpdir)
return proto
def __init__(self, config):
self._cols_size = config.columns_size
self._x_length = config.x_length
self._model_params_path = config.mlp_model_params_path
self._x = nn.Variable([1, self._x_length, self._cols_size])
self._pred = self.network(self._x)
nn.load_parameters(self._model_params_path)
def main(args):
env = gym.make(args.env)
env.seed(args.seed)
eval_env = gym.make(args.env)
eval_env.seed(50)
action_shape = env.action_space.shape
# GPU
if args.gpu:
ctx = get_extension_context('cudnn', device_id=str(args.device))
nn.set_default_context(ctx)
if args.load:
nn.load_parameters(args.load)
model = SAC(env.observation_space.shape, action_shape[0], args.batch_size,
args.critic_lr, args.actor_lr, args.temp_lr, args.tau,
args.gamma)
model.sync_target()
buffer = ReplayBuffer(args.buffer_size, args.batch_size)
monitor = prepare_monitor(args.logdir)
update_fn = update(model, buffer)
eval_fn = evaluate(eval_env, model, render=args.render)
train(env, model, buffer, EmptyNoise(), monitor, update_fn, eval_fn,
args.final_step, args.batch_size, 1, args.save_interval,
args.evaluate_interval, ['critic_loss', 'actor_loss', 'temp_loss'])
def __init__(self, param_path=None):
assert os.path.isfile(
param_path), "pretrained VGG19 weights not found."
self.h5_file = param_path
if not os.path.exists(self.h5_file):
print(
"Pretrained VGG19 parameters not found. Downloading. Please wait..."
)
url = "https://nnabla.org/pretrained-models/nnabla-examples/GANs/first-order-model/vgg19.h5"
from nnabla.utils.data_source_loader import download
download(url, url.split('/')[-1], False)
with nn.parameter_scope("VGG19"):
logger.info('loading vgg19 parameters...')
nn.load_parameters(self.h5_file)
# drop all the affine layers.
drop_layers = [
'classifier/0/affine', 'classifier/3/affine',
'classifier/6/affine'
]
for layers in drop_layers:
nn.parameter.pop_parameter((layers + '/W'))
nn.parameter.pop_parameter((layers + '/b'))
self.mean = nn.Variable.from_numpy_array(
np.asarray([0.485, 0.456, 0.406]).reshape(1, 3, 1, 1))
self.std = nn.Variable.from_numpy_array(
np.asarray([0.229, 0.224, 0.225]).reshape(1, 3, 1, 1))
def test_parameter_file_load_save():
module_creator = ModuleCreator(TSTNetNormal(), [(4, 3, 32, 32),
(4, 3, 32, 32)])
proto_variable_inputs = module_creator.get_proto_variable_inputs()
outputs = module_creator.module(*proto_variable_inputs)
g = nn.graph_def.get_default_graph_by_variable(outputs)
with create_temp_with_dir(nnp_file) as tmp_file:
g.save(tmp_file)
another = TSTNetNormal()
variable_inputs = module_creator.get_variable_inputs()
outputs = g(*variable_inputs)
ref_outputs = another(*variable_inputs)
# Should not equal
with pytest.raises(AssertionError) as excinfo:
forward_variable_and_check_equal(outputs, ref_outputs)
# load to local scope
with nn.parameter_scope('', another.parameter_scope):
nn.load_parameters(tmp_file)
another.update_parameter()
ref_outputs = another(*variable_inputs)
forward_variable_and_check_equal(outputs, ref_outputs)
def main():
ctx = get_extension_context('cudnn', device_id=args.gpus)
nn.set_default_context(ctx)
image_left = imread(args.left_image)
image_right = imread(args.right_image)
if args.dataset == 'Kitti':
var_left = nn.Variable((1, 3, args.im_height_kt, args.im_width_kt))
var_right = nn.Variable((1, 3, args.im_height_kt, args.im_width_kt))
img_left, img_right = preprocess_kitti(image_left, image_right)
elif args.dataset == 'SceneFlow':
var_left = nn.Variable((1, 3, args.im_height_sf, args.im_width_sf))
var_right = nn.Variable((1, 3, args.im_height_sf, args.im_width_sf))
img_left, img_right = preprocess_sceneflow(image_left, image_right)
var_left.d, var_right.d = img_left, img_right
if args.loadmodel is not None:
# Loading CNN pretrained parameters.
nn.load_parameters(args.loadmodel)
pred_test = psm_net(var_left, var_right, args.maxdisp, False)
pred_test.forward(clear_buffer=True)
pred = pred_test.d
pred = np.squeeze(pred, axis=1)
pred = pred[0]
pred = 2*(pred - np.min(pred))/np.ptp(pred)-1
scipy.misc.imsave('stereo_depth.png', pred)
print("Done")
def test_parameter_file_load_save_for_file_object(memory_buffer_format):
module_creator = ModuleCreator(TSTNetNormal(), [(4, 3, 32, 32),
(4, 3, 32, 32)])
variable_inputs = module_creator.get_variable_inputs()
a_module = module_creator.module
outputs = a_module(*variable_inputs)
another = TSTNetNormal()
ref_outputs = another(*variable_inputs)
extension = memory_buffer_format
# Should not equal
with pytest.raises(AssertionError) as excinfo:
forward_variable_and_check_equal(outputs, ref_outputs)
with io.BytesIO() as param_file:
nn.save_parameters(param_file,
a_module.get_parameters(),
extension=extension)
# load from file
with nn.parameter_scope('', another.parameter_scope):
nn.load_parameters(param_file, extension=extension)
another.update_parameter()
ref_outputs = another(*variable_inputs)
# should equal
forward_variable_and_check_equal(outputs, ref_outputs)
def test_parameter_file_load_save_for_files(parameter_file):
module_creator = ModuleCreator(TSTNetNormal(), [(4, 3, 32, 32),
(4, 3, 32, 32)])
variable_inputs = module_creator.get_variable_inputs()
a_module = module_creator.module
outputs = a_module(*variable_inputs)
another = TSTNetNormal()
ref_outputs = another(*variable_inputs)
# Should not equal
with pytest.raises(AssertionError) as excinfo:
forward_variable_and_check_equal(outputs, ref_outputs)
with create_temp_with_dir(parameter_file) as tmp_file:
# save to file
nn.save_parameters(tmp_file, a_module.get_parameters())
# load from file
with nn.parameter_scope('', another.parameter_scope):
nn.load_parameters(tmp_file)
another.update_parameter()
ref_outputs = another(*variable_inputs)
# should equal
forward_variable_and_check_equal(outputs, ref_outputs)
def main(args):
env = gym.make(args.env)
env.seed(args.seed)
eval_env = gym.make(args.env)
eval_env.seed(50)
action_shape = env.action_space.shape
# GPU
if args.gpu:
ctx = get_extension_context('cudnn', device_id=str(args.device))
nn.set_default_context(ctx)
if args.load:
nn.load_parameters(args.load)
model = TD3(env.observation_space.shape, action_shape[0], args.batch_size,
args.critic_lr, args.actor_lr, args.tau, args.gamma,
args.target_reg_sigma, args.target_reg_clip)
model.sync_target()
noise = NormalNoise(np.zeros(action_shape),
args.exploration_sigma + np.zeros(action_shape))
buffer = ReplayBuffer(args.buffer_size, args.batch_size)
monitor = prepare_monitor(args.logdir)
update_fn = update(model, buffer, args.update_actor_freq)
eval_fn = evaluate(eval_env, model, render=args.render)
train(env, model, buffer, noise, monitor, update_fn, eval_fn,
args.final_step, args.batch_size, 1, args.save_interval,
args.evaluate_interval, ['critic_loss', 'actor_loss'])
def load_parameters_and_config(path):
'''
Load paramters and deduce the configuration
of memory layout and input channels
Returns: (channel_last, input_channels)
'''
nn.load_parameters(path)
try:
conv1 = nn.parameter.get_parameter('conv1/conv/W')
except:
raise ValueError(
'conv1/conv/W is not found. This parameter configuration deduction works for resnet only.'
)
shape = conv1.shape
assert shape[1] == 7 or shape[
3] == 7, 'This deduction process assumes that the first convolution has 7x7 filter.'
channel_last = False
channels = shape[1]
if shape[1] == 7:
channel_last = True
channels = shape[3]
assert channels in (3, 4), f'channels must be either 3 or 4: {channels}.'
return channel_last, channels
def main():
args = get_args()
nn.load_parameters(args.input)
params = nn.get_parameters(grad_only=False)
processed = False
# Convert memory layout
layout = get_memory_layout(params)
if args.memory_layout is None:
pass
elif args.memory_layout != layout:
logger.info(f'Converting memory layout to {args.memory_layout}.')
convert_memory_layout(params, args.memory_layout)
processed |= True
else:
logger.info('No need to convert memory layout.')
if args.force_3_channels:
ret = force_3_channels(params, args.memory_layout)
if ret:
logger.info('Converted first conv to 3-channel input.')
processed |= ret
if not processed:
logger.info(
'No change has been made for the input. Not saving a new parameter file.'
)
return
logger.info(f'Save a new parameter file at {args.output}')
for key, param in params.items():
nn.parameter.set_parameter(key, param)
nn.save_parameters(args.output)
def get_estimates(self,
input_path: str,
parts,
fft_size=4096,
hop_size=1024,
n_channels=2,
apply_mwf_flag=True,
ch_flip_average=True):
# Set NNabla extention
ctx = get_extension_context(self.context)
nn.set_default_context(ctx)
# Load the model weights
nn.load_parameters(str(self.model_file_path))
# Read file locally
if settings.DEFAULT_FILE_STORAGE == 'api.storage.FileSystemStorage':
_, inp_stft = generate_data(input_path, fft_size,
hop_size, n_channels, self.sample_rate)
else:
# If remote, download to temp file and load audio
fd, tmp_path = tempfile.mkstemp()
try:
r_get = requests.get(input_path)
with os.fdopen(fd, 'wb') as tmp:
tmp.write(r_get.content)
_, inp_stft = generate_data(tmp_path, fft_size, hop_size,
n_channels, self.sample_rate)
finally:
# Remove temp file
os.remove(tmp_path)
out_stfts = {}
estimates = {}
inp_stft_contiguous = np.abs(np.ascontiguousarray(inp_stft))
# Need to compute all parts even for static mix, for mwf?
for part in parts:
print(f'Processing {part}...')
with open('./config/d3net/{}.yaml'.format(part)) as file:
# Load part specific Hyper parameters
hparams = yaml.load(file, Loader=yaml.FullLoader)
with nn.parameter_scope(part):
out_sep = model_separate(
inp_stft_contiguous, hparams, ch_flip_average=ch_flip_average)
out_stfts[part] = out_sep * np.exp(1j * np.angle(inp_stft))
if apply_mwf_flag:
out_stfts = apply_mwf(out_stfts, inp_stft)
for part, output in out_stfts.items():
if not parts[part]:
continue
estimates[part] = stft2time_domain(output, hop_size, True)
return estimates
def main():
"""
Inference function to generate SR images.
"""
nn.load_parameters(args.model)
# Inference data loader
inference_data = inference_data_loader(args.input_dir_lr)
input_shape = [
1,
] + list(inference_data.inputs[0].shape)
output_shape = [1, input_shape[1] * 4, input_shape[2] * 4, 3]
oh = input_shape[1] - input_shape[1] // 8 * 8
ow = input_shape[2] - input_shape[2] // 8 * 8
# Build the computation graph
inputs_raw = nn.Variable(input_shape)
pre_inputs = nn.Variable(input_shape)
pre_gen = nn.Variable(output_shape)
pre_warp = nn.Variable(output_shape)
transposed_pre_warp = space_to_depth(pre_warp)
inputs_all = F.concatenate(inputs_raw, transposed_pre_warp)
with nn.parameter_scope("generator"):
gen_output = generator(inputs_all, 3, args.num_resblock)
outputs = (gen_output + 1) / 2
inputs_frames = F.concatenate(pre_inputs, inputs_raw)
with nn.parameter_scope("fnet"):
flow_lr = flow_estimator(inputs_frames)
flow_lr = F.pad(flow_lr, (0, 0, 0, oh, 0, ow, 0, 0), "reflect")
flow_hr = upscale_four(flow_lr * 4.0)
pre_gen_warp = warp_by_flow(pre_gen, flow_hr)
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
max_iter = len(inference_data.inputs)
print('Frame evaluation starts!!')
pre_inputs.d, pre_gen.d, pre_warp.d = 0, 0, 0
for i in range(max_iter):
inputs_raw.d = np.array([inference_data.inputs[i]]).astype(np.float32)
if i != 0:
pre_gen_warp.forward()
pre_warp.data.copy_from(pre_gen_warp.data)
outputs.forward()
output_frame = outputs.d
if i >= 5:
name, _ = os.path.splitext(
os.path.basename(str(inference_data.paths_lr[i])))
filename = args.output_name + '_' + name
print('saving image %s' % filename)
out_path = os.path.join(args.output_dir,
"%s.%s" % (filename, args.output_ext))
save_img(out_path, output_frame[0])
else: # First 5 is a hard-coded symmetric frame padding, ignored but time added!
print("Warming up %d" % (5 - i))
pre_inputs.data.copy_from(inputs_raw.data)
pre_gen.data.copy_from(outputs.data)
def importNetwork(self, fname):
print("Import Q-network from {}".format(fname))
nn.load_parameters(fname + '.h5')
print "Updating target Q-network"
self.update_Q_target()
print '--------------------------------------------------'
print nn.get_parameters()
print '--------------------------------------------------'
def evaluate(args):
# Context
ctx = get_extension_context(args.context,
device_id=args.device_id,
type_config=args.type_config)
nn.set_default_context(ctx)
# Args
latent = args.latent
maps = args.maps
batch_size = args.batch_size
image_size = args.image_size
n_classes = args.n_classes
not_sn = args.not_sn
# Model (Inception model) from nnp file
nnp = NnpLoader(args.nnp_inception_model_load_path)
x, y = get_input_and_output(nnp, args.batch_size, name=args.variable_name)
if args.evaluation_metric == "IS":
is_model = None
compute_metric = compute_inception_score
if args.evaluation_metric == "FID":
di = data_iterator_imagenet(args.valid_dir,
args.dirname_to_label_path,
batch_size=args.batch_size,
ih=args.image_size,
iw=args.image_size,
shuffle=True,
train=False,
noise=False)
compute_metric = functools.partial(compute_frechet_inception_distance,
di=di)
# Monitor
monitor = Monitor(args.monitor_path)
monitor_metric = MonitorSeries("{}".format(args.evaluation_metric),
monitor,
interval=1)
# Compute the evaluation metric for all models
def cmp_func(path):
return int(path.split("/")[-1].strip("params_").rstrip(".h5"))
model_load_path = sorted(glob.glob("{}/*.h5".format(args.model_load_path)), key=cmp_func) \
if os.path.isdir(args.model_load_path) else \
[args.model_load_path]
for path in model_load_path:
# Model (SAGAN)
nn.load_parameters(path)
z = nn.Variable([batch_size, latent])
y_fake = nn.Variable([batch_size])
x_fake = generator(z, y_fake, maps=maps, n_classes=n_classes, test=True, sn=not_sn)\
.apply(persistent=True)
# Compute the evaluation metric
score = compute_metric(z, y_fake, x_fake, x, y, args)
itr = cmp_func(path)
monitor_metric.add(itr, score)
def visualize(args):
"""
Visualizing embedded digits onto 2D space.
"""
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
batch_size = 500
# Create default context.
ctx = nn.Context(backend="cpu|cuda",
compute_backend="default|cudnn",
array_class="CudaArray",
device_id="{}".format(args.device_id))
# Load parameters
nn.load_parameters(os.path.join(args.model_save_path,
'params_%06d.h5' % args.max_iter))
# Create embedder network
image = nn.Variable([batch_size, 1, 28, 28])
feature = mnist_lenet_feature(image, test=False)
# Process all images
features = []
labels = []
# Prepare MNIST data iterator
rng = np.random.RandomState(313)
data = data_iterator_mnist(batch_size, train=False, shuffle=True, rng=rng)
for i in range(10000 // batch_size):
image_data, label_data = data.next()
image.d = image_data / 255.
feature.forward(clear_buffer=True)
features.append(feature.d.copy())
labels.append(label_data.copy())
features = np.vstack(features)
labels = np.vstack(labels)
# Visualize
f = plt.figure(figsize=(16, 9))
for i in range(10):
c = plt.cm.Set1(i / 10.)
plt.plot(features[labels.flat == i, 0].flatten(), features[
labels.flat == i, 1].flatten(), '.', c=c)
plt.legend(map(str, range(10)))
plt.grid()
plt.savefig(os.path.join(args.monitor_path, "embed.png"))
def main():
HERE = os.path.dirname(__file__)
# Import MNIST data
sys.path.append(
os.path.realpath(os.path.join(HERE, '..', '..', 'vision', 'mnist')))
from mnist_data import data_iterator_mnist
from args import get_args
from classification import mnist_lenet_prediction, mnist_resnet_prediction
args = get_args(description=__doc__)
mnist_cnn_prediction = mnist_lenet_prediction
if args.net == 'resnet':
mnist_cnn_prediction = mnist_resnet_prediction
# Infer parameter file name and read it.
model_save_path = os.path.join('../../vision/mnist',
args.model_save_path)
parameter_file = os.path.join(
model_save_path,
'{}_params_{:06}.h5'.format(args.net, args.max_iter))
try:
nn.load_parameters(parameter_file)
except IOError:
logger.error("Run classification.py before runnning this script.")
exit(1)
# Create a computation graph to be saved.
image = nn.Variable([args.batch_size, 1, 28, 28])
pred = mnist_cnn_prediction(image, test=True)
# Save NNP file (used in C++ inference later.).
nnp_file = '{}_{:06}.nnp'.format(args.net, args.max_iter)
runtime_contents = {
'networks': [
{'name': 'runtime',
'batch_size': args.batch_size,
'outputs': {'y': pred},
'names': {'x': image}}],
'executors': [
{'name': 'runtime',
'network': 'runtime',
'data': ['x'],
'output': ['y']}]}
nn.utils.save.save(nnp_file, runtime_contents)
def test_graph_clear_buffer(seed):
np.random.seed(313)
rng = np.random.RandomState(seed)
x = nn.Variable([2, 3, 4, 4])
t = nn.Variable([2, 1])
x.d = rng.randn(*x.shape)
t.d = rng.randint(0, 5, size=t.shape)
# Network definition
nn.set_default_context(nn.Context())
nn.clear_parameters()
x1 = x + 1
x2 = x1 - 1
with nn.parameter_scope('conv1'):
z = PF.convolution(x2, 3, (2, 2))
z2 = F.relu(z, inplace=True)
with nn.parameter_scope('fc2'):
z3 = PF.affine(z2, 5)
l = F.softmax_cross_entropy(z3, t, 1)
L = F.mean(l)
# Forwardprop
import tempfile
import os
tmpd = tempfile.mkdtemp()
nn.save_parameters(os.path.join(tmpd, 'parameter.h5'))
first = False
for cnng in [False, True]:
for cb in [False, True]:
_ = nn.load_parameters(os.path.join(tmpd, 'parameter.h5'))
for v in nn.get_parameters().values():
v.grad.zero()
L.forward(clear_no_need_grad=cnng)
L.backward(clear_buffer=cb)
if not first:
first = True
g = list(nn.get_parameters().values())[0].g.copy()
else:
g2 = list(nn.get_parameters().values())[0].g.copy()
assert np.all(g == g2)
def load(filenames, prepare_data_iterator=True):
'''load
Load network information from files.
Args:
filenames (list): List of filenames.
Returns:
dict: Network infomation.
'''
class Info:
pass
info = Info()
proto = nnabla_pb2.NNablaProtoBuf()
for filename in filenames:
_, ext = os.path.splitext(filename)
if 'txt' in ext:
with open(filename, 'rt') as f:
text_format.Merge(f.read(), proto)
elif ext in ['.protobuf', '.h5']:
nn.load_parameters(filename, proto)
elif ext == '.nnp':
tmpdir = tempfile.mkdtemp()
with zipfile.ZipFile(filename, 'r') as nnp:
for name in nnp.namelist():
nnp.extract(name, tmpdir)
_, ext = os.path.splitext(name)
if 'txt' in ext:
with open(os.path.join(tmpdir, name), 'rt') as f:
text_format.Merge(f.read(), proto)
elif ext in ['.protobuf', '.h5']:
nn.load_parameters(os.path.join(tmpdir, name), proto)
shutil.rmtree(tmpdir)
default_context = None
if proto.HasField('global_config'):
info.global_config = _global_config(proto)
default_context = info.global_config.default_context
else:
default_context = nn.context()
if proto.HasField('training_config'):
info.training_config = _training_config(proto)
if len(proto.dataset) > 0:
info.datasets = _datasets(proto, prepare_data_iterator)
if len(proto.network) > 0:
info.networks = _networks(proto, default_context)
if len(proto.optimizer) > 0:
info.optimizers = _optimizers(
proto, default_context, info.networks, info.datasets)
if len(proto.monitor) > 0:
info.monitors = _monitors(
proto, default_context, info.networks, info.datasets)
if len(proto.executor) > 0:
info.executors = _executors(proto, info.networks)
return info
def main(args):
# Settings
device_id = args.device_id
batch_size = 100
batch_size_eval = 100
n_l_train_data = 4000
n_train_data = 50000
n_cls = 10
learning_rate = 1. * 1e-3
n_epoch = 300
act = F.relu
iter_epoch = n_train_data / batch_size
n_iter = n_epoch * iter_epoch
extension_module = args.context
# Model
## supervised
batch_size, m, h, w = batch_size, 3, 32, 32
ctx = extension_context(extension_module, device_id=device_id)
x_l = nn.Variable((batch_size, m, h, w))
y_l = nn.Variable((batch_size, 1))
pred = cnn_model_003(ctx, x_l)
loss_ce = ce_loss(ctx, pred, y_l)
loss_er = er_loss(ctx, pred)
loss_supervised = loss_ce + loss_er
## stochastic regularization
x_u0 = nn.Variable((batch_size, m, h, w), need_grad=False)
x_u1 = nn.Variable((batch_size, m, h, w), need_grad=False)
pred_x_u0 = cnn_model_003(ctx, x_u0)
pred_x_u1 = cnn_model_003(ctx, x_u1)
loss_sr = sr_loss(ctx, pred_x_u0, pred_x_u1)
loss_er0 = er_loss(ctx, pred_x_u0)
loss_er1 = er_loss(ctx, pred_x_u1)
loss_unsupervised = loss_sr + loss_er0 + loss_er1
## autoencoder
path = args.model_path
nn.load_parameters(path)
x_u0_rc = cnn_ae_model_000(ctx, x_u0, act=F.relu, test=True)
x_u1_rc = cnn_ae_model_000(ctx, x_u1, act=F.relu, test=True)
x_u0_rc.need_grad = False
x_u1_rc.need_grad = False
pred_x_u0_rc = cnn_model_003(ctx, x_u0_rc, test=False)
pred_x_u1_rc = cnn_model_003(ctx, x_u1_rc, test=False)
loss_sr_rc = sr_loss(ctx, pred_x_u0_rc, pred_x_u1_rc)
loss_er0_rc = er_loss(ctx, pred_x_u0_rc)
loss_er1_rc = er_loss(ctx, pred_x_u1_rc)
loss_unsupervised_rc = loss_sr_rc + loss_er0_rc + loss_er1_rc
loss_unsupervised += loss_unsupervised_rc
## evaluate
batch_size_eval, m, h, w = batch_size, 3, 32, 32
x_eval = nn.Variable((batch_size_eval, m, h, w))
pred_eval = cnn_model_003(ctx, x_eval, test=True)
# Solver
with nn.context_scope(ctx):
solver = S.Adam(alpha=learning_rate)
solver.set_parameters(nn.get_parameters())
# Dataset
## separate dataset
home = os.environ.get("HOME")
fpath = os.path.join(home, "datasets/cifar10/cifar-10.npz")
separator = Separator(n_l_train_data)
separator.separate_then_save(fpath)
l_train_path = os.path.join(home, "datasets/cifar10/l_cifar-10.npz")
u_train_path = os.path.join(home, "datasets/cifar10/cifar-10.npz")
test_path = os.path.join(home, "datasets/cifar10/cifar-10.npz")
# data reader
data_reader = Cifar10DataReader(l_train_path, u_train_path, test_path,
batch_size=batch_size,
n_cls=n_cls,
da=True,
shape=True)
# Training loop
print("# Training loop")
epoch = 1
st = time.time()
acc_prev = 0.
for i in range(n_iter):
# Get data and set it to the varaibles
x_l0_data, x_l1_data, y_l_data = data_reader.get_l_train_batch()
x_u0_data, x_u1_data, y_u_data = data_reader.get_u_train_batch()
x_l.d, _ , y_l.d= x_l0_data, x_l1_data, y_l_data
x_u0.d, x_u1.d= x_u0_data, x_u1_data
# Train
loss_supervised.forward(clear_no_need_grad=True)
solver.zero_grad()
loss_supervised.backward(clear_buffer=True)
solver.update()
loss_unsupervised.forward(clear_no_need_grad=True)
solver.zero_grad()
loss_unsupervised.backward(clear_buffer=True)
solver.update()
# Evaluate
if (i+1) % iter_epoch == 0:
# Get data and set it to the varaibles
x_data, y_data = data_reader.get_test_batch()
# Evaluation loop
ve = 0.
iter_val = 0
for k in range(0, len(x_data), batch_size_eval):
x_eval.d = x_data[k:k+batch_size_eval, :]
label = y_data[k:k+batch_size_eval, :]
pred_eval.forward(clear_buffer=True)
ve += categorical_error(pred_eval.d, label)
iter_val += 1
msg = "Epoch:{},ElapsedTime:{},Acc:{:02f}".format(
epoch,
time.time() - st,
(1. - ve / iter_val) * 100)
print(msg)
st = time.time()
epoch +=1
def main(args):
# Settings
device_id = args.device_id
batch_size = args.batch_size
batch_size_eval = args.batch_size_eval
n_l_train_data = 4000
n_train_data = 50000
n_cls = 10
learning_rate = 1. * 1e-3
n_epoch = 300
act = F.relu
iter_epoch = int(n_train_data / batch_size)
n_iter = n_epoch * iter_epoch
extension_module = args.context
# Model
## supervised resnet
batch_size, m, h, w = batch_size, 3, 32, 32
ctx = extension_context(extension_module, device_id=device_id)
x_l = nn.Variable((batch_size, m, h, w))
y_l = nn.Variable((batch_size, 1))
pred_res = cifar10_resnet23_prediction(ctx, "resnet", x_l)
loss_res_ce = ce_loss(ctx, pred_res, y_l)
loss_res_supervised = loss_res_ce
## stochastic regularization
nn.load_parameters(args.model_load_path)
x_u0 = nn.Variable((batch_size, m, h, w))
x_u0.persistent = True
pred_x_u0, log_var0 = cnn_model_003(ctx, x_u0)
pred_x_u0.need_grad, log_var0.need_grad = False, False
## knowledge transfer for resnet
pred_res_x_u0 = cifar10_resnet23_prediction(ctx, "resnet", x_u0)
loss_res_unsupervised = kl_divergence(ctx, pred_res_x_u0, pred_x_u0, log_var0)
## evaluate
batch_size_eval, m, h, w = batch_size, 3, 32, 32
x_eval = nn.Variable((batch_size_eval, m, h, w))
pred_res_eval = cifar10_resnet23_prediction(ctx, "resnet", x_eval, test=True)
# Solver
with nn.context_scope(ctx):
with nn.parameter_scope("resnet"):
solver_res = S.Adam(alpha=learning_rate)
solver_res.set_parameters(nn.get_parameters())
# Dataset
## separate dataset
home = os.environ.get("HOME")
fpath = os.path.join(home, "datasets/cifar10/cifar-10.npz")
separator = Separator(n_l_train_data)
separator.separate_then_save(fpath)
l_train_path = os.path.join(home, "datasets/cifar10/l_cifar-10.npz")
u_train_path = os.path.join(home, "datasets/cifar10/cifar-10.npz")
test_path = os.path.join(home, "datasets/cifar10/cifar-10.npz")
# data reader
data_reader = Cifar10DataReader(l_train_path, u_train_path, test_path,
batch_size=batch_size,
n_cls=n_cls,
da=True,
shape=True)
# Training loop
print("# Training loop")
epoch = 1
st = time.time()
acc_prev = 0.
for i in range(n_iter):
# Get data and set it to the varaibles
x_l0_data, x_l1_data, y_l_data = data_reader.get_l_train_batch()
x_u0_data, x_u1_data, y_u_data = data_reader.get_u_train_batch()
x_l.d, _ , y_l.d= x_l0_data, x_l1_data, y_l_data
x_u0.d, _ = x_u0_data, x_u1_data
# Train resnet
loss_res_supervised.forward(clear_no_need_grad=True)
loss_res_unsupervised.forward(clear_no_need_grad=True)
solver_res.zero_grad()
loss_res_supervised.backward(clear_buffer=True)
loss_res_unsupervised.backward(clear_buffer=True)
solver_res.update()
# Evaluate
if int((i+1) % iter_epoch) == 0:
# Get data and set it to the varaibles
x_data, y_data = data_reader.get_test_batch()
# Evaluation loop for resnet
ve = 0.
iter_val = 0
for k in range(0, len(x_data), batch_size_eval):
x_eval.d = get_test_data(x_data, k, batch_size_eval)
label = get_test_data(y_data, k, batch_size_eval)
pred_res_eval.forward(clear_buffer=True)
ve += categorical_error(pred_res_eval.d, label)
iter_val += 1
msg = "Model:resnet,Epoch:{},ElapsedTime:{},Acc:{:02f}".format(
epoch,
time.time() - st,
(1. - ve / iter_val) * 100)
print(msg)
st = time.time()
epoch +=1
