def load_model(self):
# model_file = osp.join(self.data_dir, 'max_miou.npz')
model_file = osp.join(self.data_dir, 'max_depth_acc.npz')
with open(osp.join(self.data_dir, 'model.txt'), 'r') as f:
model_name = f.readline().rstrip()
with open(osp.join(self.data_dir, 'n_class.txt'), 'r') as f:
n_class = int(f.readline().rstrip())
self.n_class = n_class
with open(osp.join(self.data_dir, 'num_view.txt'), 'r') as f:
num_view = int(f.readline().rstrip())
self.num_view = num_view
if model_name == 'FCN8sAtOnceInputRGBD':
self.model = FCN8sAtOnceInputRGBD(n_class=n_class,
masking=True,
concat=True,
no_bp_before_rgb_pool5=False)
elif model_name == 'FCN8sAtOnceConcatAtOnce':
self.model = FCN8sAtOnceConcatAtOnce(n_class=n_class,
masking=True,
no_bp_before_rgb_pool5=False)
print('\nLoading trained model: {0}'.format(model_file))
S.load_npz(model_file, self.model)
print('Finished loading trained model: {0}\n'.format(model_file))
if self.gpu >= 0:
cuda.get_device_from_id(self.gpu).use()
self.model.to_gpu()
if LooseVersion(chainer.__version__) < LooseVersion('2.0.0'):
self.model.train = False
def __init__(self):
super().__init__()
self.title = 'PyQt5 image - pythonspot.com'
self.left = 300
self.top = 300
self.width = 900
self.height = 600
self.gen = network.Generator(depth=depth)
serializers.load_npz(gen_path, self.gen)
# file
self.csv_file = [[random.random() for j in range(csv_len)]]
self.vec2rand_model = load_model(vec2rand_model_path)
# gpu using
if gpu >= 0:
cuda.get_device_from_id(0).use()
self.gen.to_gpu()
self.xp = self.gen.xp
self.initUI()
#generating image.
z = self.xp.random.randn(1, 512, 1, 1).astype('f')
x = self.gen(z, alpha=1.0)
x = chainer.cuda.to_cpu(x.data)
img = x[0].copy()
utils.save_image(img, 'temp.jpg')
_img = Image.open('temp.jpg')
self.img = np.asarray(_img)
self.initFigure()
self.show()
def dump_bilm_embeddings(vocab_file,
dataset_file,
options_file,
weight_file,
outfile,
gpu=-1,
batchsize=32):
with open(options_file, 'r') as fin:
options = json.load(fin)
max_word_length = options['char_cnn']['max_characters_per_token']
vocab = UnicodeCharsVocabulary(vocab_file, max_word_length)
batcher = Batcher(vocab_file, max_word_length)
model = Elmo(options_file,
weight_file,
num_output_representations=1,
requires_grad=False,
do_layer_norm=False,
dropout=0.)
if gpu >= 0:
cuda.get_device_from_id(gpu).use()
model.to_gpu()
# (batch_size, timesteps, 50)
# TODO(sosk): preencoding token embedding for acceleration
with chainer.using_config("train", False), \
chainer.no_backprop_mode():
sentence_id = 0
n_lines = sum([1 for _ in open(dataset_file, 'r')])
with open(dataset_file, 'r') as fin, h5py.File(outfile, 'w') as fout:
for minibatch in minibatch_iterator(tqdm.tqdm(fin, total=n_lines),
batchsize):
sentences = [line.strip().split() for line in minibatch]
char_ids = batcher.batch_sentences(sentences,
add_bos_eos=False)
char_ids = model.xp.asarray(char_ids)
mb_outs = model.forward(char_ids)
mb_embedding_layers = mb_outs['elmo_layers']
# [(batch_size, max_sequence_length, embedding_dim), ..., x n_layers]
# Note that embedding layers have already trushed bos & eos
# But they contains padding
mb_mask = mb_outs['mask']
mb_concat_embedding_layers = cuda.to_cpu(
model.xp.stack(
[mb_emb.array for mb_emb in mb_embedding_layers],
axis=1))
# (batch_size, n_layers=3, max_sequence_length, embedding_dim)
for mask, concat_embedding_layers in zip(
mb_mask, mb_concat_embedding_layers):
# remove pads
length = int(mask.sum())
concat_embedding_layers = concat_embedding_layers[:, :
length]
# (n_layers=3, sequence_length, embedding_dim)
ds = fout.create_dataset('{}'.format(sentence_id),
concat_embedding_layers.shape,
dtype='float32',
data=concat_embedding_layers)
sentence_id += 1
def __call__(self, x, test=False, finetune=False):
"""Invokes the forward propagation of BatchNormalization.
BatchNormalization accepts additional arguments, which controls three
different running mode.
Args:
x (Variable): Input variable.
test (bool): If ``True``, BatchNormalization runs in testing mode;
it normalizes the input using pre-computed statistics.
finetune (bool): If ``finetune`` is ``True`` and ``test`` is
``False``, BatchNormalization runs in fine-tuning mode; it
accumulates the input array to compute population statistics
for normalization, and normalizes the input using batch
statistics.
If ``test`` is ``False``, then BatchNormalization runs in training
mode; it computes moving averages of mean and variance for evaluation
during training, and normalizes the input using batch statistics.
"""
if hasattr(self, 'gamma'):
gamma = self.gamma
else:
with cuda.get_device_from_id(self._device_id):
gamma = variable.Variable(self.xp.ones(
self.avg_mean.shape, dtype=x.dtype), volatile='auto')
if hasattr(self, 'beta'):
beta = self.beta
else:
with cuda.get_device_from_id(self._device_id):
beta = variable.Variable(self.xp.zeros(
self.avg_mean.shape, dtype=x.dtype), volatile='auto')
# Var is always ones
with cuda.get_device_from_id(self._device_id):
self.one_var = self.xp.ones(self.avg_mean.shape, dtype=x.dtype)
if not test:
if finetune:
self.N += 1
decay = 1. - 1. / self.N
else:
decay = self.decay
func = batch_normalization.BatchNormalizationFunction(
self.eps, self.avg_mean, self.avg_var, True, decay,
self.use_cudnn)
ret = func(x, gamma, beta)
self.avg_mean[:] = func.running_mean
self.avg_var[:] = func.running_var
else:
# Use running average statistics or fine-tuned statistics.
mean = variable.Variable(self.avg_mean, volatile='auto')
#var = variable.Variable(self.avg_var, volatile='auto')
var = variable.Variable(self.one_var, volatile='auto')
ret = batch_normalization.fixed_batch_normalization(
x, gamma, beta, mean, var, self.eps, self.use_cudnn)
return ret
def load_model(self):
n_class = len(self.train_dataset.class_names)
if self.model_name == 'fcn32s':
self.model = fcn.models.FCN32s(n_class=n_class)
vgg = fcn.models.VGG16()
vgg_path = vgg.download()
S.load_npz(vgg_path, vgg)
self.model.init_from_vgg16(vgg)
elif self.model_name == 'fcn16s':
self.model = fcn.models.FCN16s(n_class=n_class)
fcn32s = fcn.models.FCN32s()
fcn32s_path = fcn32s.download()
S.load_npz(fcn32s_path, fcn32s)
self.model.init_from_fcn32s(fcn32s_path, fcn32s)
elif self.model_name == 'fcn8s':
self.model = fcn.models.FCN8s(n_class=n_class)
fcn16s = fcn.models.FCN16s()
fcn16s_path = fcn16s.download()
S.load_npz(fcn16s_path, fcn16s)
self.model.init_from_fcn16s(fcn16s_path, fcn16s)
elif self.model_name == 'fcn8s_at_once':
self.model = fcn.models.FCN8sAtOnce(n_class=n_class)
vgg = fcn.models.VGG16()
vgg_path = vgg.download()
S.load_npz(vgg_path, vgg)
self.model.init_from_vgg16(vgg)
else:
raise ValueError(
'Unsupported model_name: {}'.format(self.model_name))
if self.gpu >= 0:
cuda.get_device_from_id(self.gpu).use()
self.model.to_gpu()
def generate():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--gen', type=str, default=None)
parser.add_argument('--depth', '-d', type=int, default=0)
parser.add_argument('--out', '-o', type=str, default='img/')
parser.add_argument('--num', '-n', type=int, default=10)
args = parser.parse_args()
gen = network.Generator(depth=args.depth)
print('loading generator model from ' + args.gen)
serializers.load_npz(args.gen, gen)
if args.gpu >= 0:
cuda.get_device_from_id(0).use()
gen.to_gpu()
xp = gen.xp
z1 = gen.z(1)
z2 = gen.z(1)
for i in range(args.num):
print(i)
p = i / (args.num - 1)
z = z1 * p + z2 * (1 - p)
x = gen(z, alpha=1.0)
x = chainer.cuda.to_cpu(x.data)
img = x[0].copy()
filename = os.path.join(args.out, 'gen_%04d.png' % i)
utils.save_image(img, filename)
def test():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--model', '-m', type=str, default=None)
parser.add_argument('--id', '-i', type=int, default=0)
parser.add_argument('--inf', type=int, default=10)
parser.add_argument('--outf', type=int, default=3)
args = parser.parse_args()
test = dataset.UCSDped1Dataset(0, 200, args.inf, args.outf,
"./ucsd_ped1_test.npy")
model = convlstm.Model(n_input=2, size=[128, 64, 64])
if args.model != None:
print("loading model from " + args.model)
serializers.load_npz(args.model, model)
x, t = test[args.id]
x = np.expand_dims(x, 0)
t = np.expand_dims(t, 0)
if args.gpu >= 0:
cuda.get_device_from_id(0).use()
model.to_gpu()
x = cuda.cupy.array(x)
t = cuda.cupy.array(t)
print(x.shape)
print(t.shape)
res = model(Variable(x), Variable(t))
print(res)
def __call__(self, c, h, x):
"""Returns new cell state and updated output of LSTM.
Args:
c (~chainer.Variable): Cell states of LSTM units.
h (~chainer.Variable): Output at the previous time step.
x (~chainer.Variable): A new batch from the input sequence.
Returns:
tuple of ~chainer.Variable: Returns ``(c_new, h_new)``, where
``c_new`` represents new cell state, and ``h_new`` is updated
output of LSTM units.
"""
if self.upward.W.data is None:
in_size = x.size // x.shape[0]
with cuda.get_device_from_id(self._device_id):
self.upward._initialize_params(in_size)
self._initialize_params()
lstm_in = self.upward(x)
if h is not None:
lstm_in += self.lateral(h)
if c is None:
xp = self.xp
with cuda.get_device_from_id(self._device_id):
c = variable.Variable(
xp.zeros((x.shape[0], self.state_size), dtype=x.dtype))
return lstm.lstm(c, lstm_in)
def __init__(self,
arch=None,
weights_file=None,
model=None,
device=-1,
precise=False):
self.arch = arch
self.precise = precise
if model is not None:
self.model = model
else:
print('[INFO] [DetectHuman]: LOADING POSE MODEL', flush=True)
self.model = params['archs'][arch]()
if weights_file:
serializers.load_npz(weights_file, self.model)
self.device = device
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
# create gaussian filter
self.gaussian_kernel = self.create_gaussian_kernel(
params['gaussian_sigma'], params['ksize'])[None, None]
self.gaussian_kernel = cuda.to_gpu(self.gaussian_kernel)
def set_cuda(self, gpu_id=0, deterministic=False, benchmark=True):
"""Set model to the GPU version.
Args:
gpu_id (int)
deterministic (bool, optional):
benchmark (bool, optional): not used
"""
if self.use_cuda:
chainer.config.type_check = False
if deterministic:
chainer.config.cudnn_deterministic = True
logger.info('GPU deterministic mode (no cudnn)')
else:
chainer.config.cudnn_deterministic = False
logger.info('GPU mode')
cuda.get_device_from_id(gpu_id).use()
self.to_gpu()
if not chainer.cuda.available:
raise ValueError('cuda is not available')
if not chainer.cuda.cudnn_enabled:
raise ValueError('cudnn is not available')
else:
logger.info('CPU mode')
def __call__(self, orig_img):
orig_img = orig_img.copy()
if self.precise:
return self.detect_precise(orig_img)
orig_img_h, orig_img_w, _ = orig_img.shape
input_w, input_h = self.compute_optimal_size(orig_img, params['inference_img_size'])
map_w, map_h = self.compute_optimal_size(orig_img, params['heatmap_size'])
resized_image = cv2.resize(orig_img, (input_w, input_h))
x_data = self.preprocess(resized_image)
if self.device >= 0:
x_data = cuda.to_gpu(x_data)
h1s, h2s = self.model(x_data)
pafs = F.resize_images(h1s[-1], (map_h, map_w)).data[0]
heatmaps = F.resize_images(h2s[-1], (map_h, map_w)).data[0]
if self.device >= 0:
pafs = pafs.get()
cuda.get_device_from_id(self.device).synchronize()
all_peaks = self.compute_peaks_from_heatmaps(heatmaps)
if len(all_peaks) == 0:
return np.empty((0, len(JointType), 3)), np.empty(0)
all_connections = self.compute_connections(pafs, all_peaks, map_w, params)
subsets = self.grouping_key_points(all_connections, all_peaks, params)
all_peaks[:, 1] *= orig_img_w / map_w
all_peaks[:, 2] *= orig_img_h / map_h
poses = self.subsets_to_pose_array(subsets, all_peaks)
scores = subsets[:, -2]
return poses, scores
def __call__(self, x, gamma_=None, beta_=None):
if hasattr(self, 'gamma'):
gamma = self.gamma
elif gamma_ is not None:
gamma = gamma_
else:
with cuda.get_device_from_id(self._device_id):
gamma = variable.Variable(
self.xp.ones(self.avg_mean.shape, dtype=x.dtype))
if hasattr(self, 'beta'):
beta = self.beta
elif beta_ is not None:
beta = beta_
else:
with cuda.get_device_from_id(self._device_id):
beta = variable.Variable(
self.xp.zeros(self.avg_mean.shape, dtype=x.dtype))
decay = self.decay
if (not configuration.config.train) and self.valid_test:
mean = variable.Variable(self.avg_mean)
var = variable.Variable(self.avg_var)
ret = fixed_instance_normalization(x, gamma, beta, mean, var,
self.eps)
else:
func = InstanceNormalizationFunction(self.eps, self.avg_mean,
self.avg_var, decay)
ret = func(x, gamma, beta)
self.avg_mean = func.running_mean
self.avg_var = func.running_var
return ret
def load_model(self):
# model_file = osp.join(self.data_dir, 'max_miou.npz')
model_file = osp.join(self.data_dir, 'max_depth_acc.npz')
with open(osp.join(self.data_dir, 'model.txt'), 'r') as f:
model_name = f.readline().rstrip()
with open(osp.join(self.data_dir, 'n_class.txt'), 'r') as f:
n_class = int(f.readline().rstrip())
self.n_class = n_class
with open(osp.join(self.data_dir, 'num_view.txt'), 'r') as f:
num_view = int(f.readline().rstrip())
self.num_view = num_view
if model_name == 'FCN8sMultiViewMirrorSegmentationDepthEstimation':
self.model = FCN8sMultiViewMirrorSegmentationDepthEstimation(
n_class=n_class, num_view=num_view)
print('\nLoading trained model: {0}'.format(model_file))
S.load_npz(model_file, self.model)
print('Finished loading trained model: {0}\n'.format(model_file))
if self.gpu >= 0:
cuda.get_device_from_id(self.gpu).use()
self.model.to_gpu()
if LooseVersion(chainer.__version__) < LooseVersion('2.0.0'):
self.model.train = False
def load_model(self):
n_class = len(self.train_dataset.class_names)
if self.model_name == 'fcn32s':
self.model = fcn.models.FCN32s(n_class=n_class)
vgg = fcn.models.VGG16()
vgg_path = vgg.download()
S.load_npz(vgg_path, vgg)
self.model.init_from_vgg16(vgg)
elif self.model_name == 'fcn16s':
self.model = fcn.models.FCN16s(n_class=n_class)
fcn32s = fcn.models.FCN32s()
fcn32s_path = fcn32s.download()
S.load_npz(fcn32s_path, fcn32s)
self.model.init_from_fcn32s(fcn32s_path, fcn32s)
elif self.model_name == 'fcn8s':
self.model = fcn.models.FCN8s(n_class=n_class)
fcn16s = fcn.models.FCN16s()
fcn16s_path = fcn16s.download()
S.load_npz(fcn16s_path, fcn16s)
self.model.init_from_fcn16s(fcn16s_path, fcn16s)
elif self.model_name == 'fcn8s_at_once':
self.model = fcn.models.FCN8sAtOnce(n_class=n_class)
vgg = fcn.models.VGG16()
vgg_path = vgg.download()
S.load_npz(vgg_path, vgg)
self.model.init_from_vgg16(vgg)
else:
raise ValueError(
'Unsupported model_name: {}'.format(self.model_name))
if self.gpu >= 0:
cuda.get_device_from_id(self.gpu).use()
self.model.to_gpu()
def __init__(self):
super(SoleAffordanceSegmentation, self).__init__()
affordance = rospy.get_param('~affordance')
pretrained_model, modal, out_channels = get_pretrained_model(
affordance
)
self.out_channels = out_channels
gpu = rospy.get_param('~gpu', 0)
model = grasp_fusion.models.FCN8sVGG16Sigmoid(
out_channels=out_channels,
pretrained_model=pretrained_model,
modal=modal,
)
if gpu >= 0:
cuda.get_device_from_id(gpu).use()
model.to_gpu()
self.model = model
self.pub_label = self.advertise('~output/label', Image, queue_size=1)
self.pub_prob = self.advertise('~output/prob', Image, queue_size=1)
self.pub_viz = self.advertise('~output/viz', Image, queue_size=1)
def generate():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--sgen', type=str, default=None)
parser.add_argument('--depth', '-d', type=int, default=5)
parser.add_argument('--out', '-o', type=str, default='img/')
parser.add_argument('--num', '-n', type=int, default=100)
args = parser.parse_args()
sgen = network.StyleBasedGenerator(depth=args.depth)
print('loading generator model from ' + args.sgen)
serializers.load_npz(args.sgen, sgen)
if args.gpu >= 0:
cuda.get_device_from_id(0).use()
sgen.to_gpu()
xp = sgen.xp
for i in range(args.num):
print(i)
z = sgen.make_latent(1)
x = sgen(z, alpha=1.0)
x = chainer.cuda.to_cpu(x.data)
img = x[0].copy()
filename = os.path.join(args.out, '%d.png' % (i + 1))
utils.save_image(img, filename)
def __call__(self, orig_img):
orig_img = orig_img.copy()
if self.precise:
return self.detect_precise(orig_img)
orig_img_h, orig_img_w, _ = orig_img.shape
input_w, input_h = self.compute_optimal_size(orig_img, params['inference_img_size'])
map_w, map_h = self.compute_optimal_size(orig_img, params['heatmap_size'])
resized_image = cv2.resize(orig_img, (input_w, input_h))
x_data = self.preprocess(resized_image)
if self.device >= 0:
x_data = cuda.to_gpu(x_data)
h1s, h2s = self.model(x_data)
pafs = F.resize_images(h1s[-1], (map_h, map_w)).data[0]
heatmaps = F.resize_images(h2s[-1], (map_h, map_w)).data[0]
if self.device >= 0:
pafs = pafs.get()
cuda.get_device_from_id(self.device).synchronize()
all_peaks = self.compute_peaks_from_heatmaps(heatmaps)
if len(all_peaks) == 0:
return np.empty((0, len(JointType), 3)), np.empty(0)
all_connections = self.compute_connections(pafs, all_peaks, map_w, params)
subsets = self.grouping_key_points(all_connections, all_peaks, params)
all_peaks[:, 1] *= orig_img_w / map_w
all_peaks[:, 2] *= orig_img_h / map_h
poses = self.subsets_to_pose_array(subsets, all_peaks)
scores = subsets[:, -2]
return poses, scores
def __call__(self, x, finetune=False):
if hasattr(self, 'gamma'):
gamma = self.gamma
else:
with cuda.get_device_from_id(self._device_id):
gamma = variable.Variable(
self.xp.ones(self.avg_mean.shape, dtype=x.dtype))
if hasattr(self, 'beta'):
beta = self.beta
else:
with cuda.get_device_from_id(self._device_id):
beta = variable.Variable(
self.xp.zeros(self.avg_mean.shape, dtype=x.dtype))
if chainer.configuration.config.train:
if finetune:
self.N += 1
decay = 1. - 1. / self.N
else:
decay = self.decay
func = MultiNodeBatchNormalizationFunction(self.comm, self.eps,
self.avg_mean,
self.avg_var, decay)
ret = func(x, gamma, beta)
self.avg_mean[:] = func.running_mean
self.avg_var[:] = func.running_var
else:
# Use running average statistics or fine-tuned statistics.
mean = variable.Variable(self.avg_mean)
var = variable.Variable(self.avg_var)
ret = batch_normalization.fixed_batch_normalization(
x, gamma, beta, mean, var, self.eps)
return ret
def __call__(self, x, finetune=False):
if hasattr(self, 'gamma'):
gamma = self.gamma
else:
with cuda.get_device_from_id(self._device_id):
gamma = variable.Variable(self.xp.ones(
self.avg_mean.shape, dtype=x.dtype))
if hasattr(self, 'beta'):
beta = self.beta
else:
with cuda.get_device_from_id(self._device_id):
beta = variable.Variable(self.xp.zeros(
self.avg_mean.shape, dtype=x.dtype))
if chainer.configuration.config.train:
if finetune:
self.N += 1
decay = 1. - 1. / self.N
else:
decay = self.decay
func = MultiNodeBatchNormalizationFunction(
self.comm, self.eps, self.avg_mean, self.avg_var, decay)
ret = func(x, gamma, beta)
self.avg_mean[:] = func.running_mean
self.avg_var[:] = func.running_var
else:
# Use running average statistics or fine-tuned statistics.
mean = variable.Variable(self.avg_mean)
var = variable.Variable(self.avg_var)
ret = batch_normalization.fixed_batch_normalization(
x, gamma, beta, mean, var, self.eps)
return ret
def __init__(self, arch=None, weights_file=None, model=None, device=-1):
# test
# self.model = params['archs']['nn1']()
# serializers.load_npz('result/nn1/model_iter_50000', self.model)
print('Loading PoseNet...')
self.model = params['archs']['posenet']()
serializers.load_npz('models/coco_posenet.npz', self.model)
# if model is not None:
# self.model = model
# else:
# # load model
# print('Loading PoseNet...')
# self.model = params['archs'][arch]()
# if weights_file:
# serializers.load_npz(weights_file, self.model)
self.device = device
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
# create gaussian filter
ksize = params['ksize']
kernel = cuda.to_gpu(
self.create_gaussian_kernel(sigma=params['gaussian_sigma'],
ksize=ksize))
self.gaussian_kernel = kernel
def __call__(self, c, h, x):
"""Returns new cell state and updated output of LSTM.
Args:
c (~chainer.Variable): Cell states of LSTM units.
h (~chainer.Variable): Output at the previous time step.
x (~chainer.Variable): A new batch from the input sequence.
Returns:
tuple of ~chainer.Variable: Returns ``(c_new, h_new)``, where
``c_new`` represents new cell state, and ``h_new`` is updated
output of LSTM units.
"""
if self.upward.W.data is None:
in_size = x.size // x.shape[0]
with cuda.get_device_from_id(self._device_id):
self.upward._initialize_params(in_size)
self._initialize_params()
lstm_in = self.upward(x)
if h is not None:
lstm_in += self.lateral(h)
if c is None:
xp = self.xp
with cuda.get_device_from_id(self._device_id):
c = variable.Variable(
xp.zeros((x.shape[0], self.state_size), dtype=x.dtype))
return lstm.lstm(c, lstm_in)
def main():
default_model_file = osp.join(here, 'data/G_horse2zebra_from_pytorch.npz')
default_out_file = osp.join(here, 'logs/create_horse2zebra.gif')
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('video_file', help='Video file of horse.')
parser.add_argument('-g', '--gpu', type=int, default=0, help='GPU id.')
parser.add_argument('-m',
'--model-file',
default=default_model_file,
help='Model file.')
parser.add_argument('-o',
'--out-file',
default=default_out_file,
help='Output video file.')
args = parser.parse_args()
print('GPU id: {:d}'.format(args.gpu))
print('Model file: {:s}'.format(args.model_file))
print('Video file: {:s}'.format(args.video_file))
print('Output file: {:s}'.format(args.out_file))
chainer.global_config.train = False
chainer.global_config.enable_backprop = False
model = chainer_cyclegan.models.ResnetGenerator()
chainer.serializers.load_npz(args.model_file, model)
if args.gpu >= 0:
cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
batch_size = 1
video = imageio.get_reader(args.video_file)
writer = imageio.get_writer(args.out_file)
for img in tqdm.tqdm(video):
img_org = img.copy()
img = cv2.resize(img, (256, 256))
xi = img.astype(np.float32)
xi = (xi / 255) * 2 - 1
xi = xi.transpose(2, 0, 1)
x = np.repeat(xi[None, :, :, :], batch_size, axis=0)
if args.gpu >= 0:
x = cuda.to_gpu(x)
y = model(x)
yi = y[0].array
yi = cuda.to_cpu(yi)
yi = yi.transpose(1, 2, 0)
yi = (yi + 1) / 2 * 255
out = yi.astype(np.uint8)
out = cv2.resize(out, (img_org.shape[1], img_org.shape[0]))
writer.append_data(np.hstack([img_org, out]))
print('Wrote video: {:s}'.format(args.out_file))
def update_core(self):
train_iter = self.get_iterator('main')
optimizer = self.get_optimizer('main')
batch = train_iter.next()
t_data = self.converter(batch, self.device)
B = t_data.shape[0]
y_data = self.func(B)
B, C, H, W = t_data.shape[:4]
y_data = F.broadcast_to(y_data, (B, C, H, W))
loss = compute_loss(y_data, t_data)
reporter.report({
'main/loss': loss,
'pos/light_x': self.model.data[0],
'pos/light_y': self.model.data[1],
'pos/light_z': self.model.data[2]
})
y_data = y_data.data
if self.device >= 0:
y_data = y_data.get()
cuda.get_device_from_id(self.device).synchronize()
img = y_data[0]
img = np.transpose(img, (1, 2, 0))
img = np.clip(img, 0, 1)
img = (img * 255).astype(np.uint8)
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
save_progress_image(self.odir, self.count, img)
optimizer.target.cleargrads()
loss.backward()
optimizer.update()
self.count += 1
def generate():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--model', '-m', type=str, default=None)
parser.add_argument('--id', '-i', type=int, default=0)
parser.add_argument('--inf', type=int, default=10)
parser.add_argument('--outf', type=int, default=10)
args = parser.parse_args()
test = dataset.MovingMnistDataset(0, 10000, args.inf, args.outf)
model = network.MovingMnistNetwork(sz=[128, 64, 64], n=2, directory="img/")
if args.model != None:
print( "loading model from " + args.model )
serializers.load_npz(args.model, model)
x, t = test[args.id]
x = np.expand_dims(x, 0)
t = np.expand_dims(t, 0)
if args.gpu >= 0:
cuda.get_device_from_id(0).use()
model.to_gpu()
x = cuda.cupy.array(x)
t = cuda.cupy.array(t)
res = model(Variable(x), Variable(t))
def __init__(self, arch=None, weights_file=None, model=None, device=-1):
# test
# self.model = params['archs']['nn1']()
# serializers.load_npz('result/nn1/model_iter_50000', self.model)
print('Loading PoseNet...')
self.model = params['archs']['posenet']()
serializers.load_npz('models/coco_posenet.npz', self.model)
# if model is not None:
# self.model = model
# else:
# # load model
# print('Loading PoseNet...')
# self.model = params['archs'][arch]()
# if weights_file:
# serializers.load_npz(weights_file, self.model)
self.device = device
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
# create gaussian filter
ksize = params['ksize']
kernel = cuda.to_gpu(self.create_gaussian_kernel(sigma=params['gaussian_sigma'], ksize=ksize))
self.gaussian_kernel = kernel
def __init__(self, ds_path, spec_file_name, layer_name, box_type,
window_size, model_param_file_path, plog_path, gpu_id):
""" Constructor
Args:
ds_path (str): a dataset path
spec_file_name (str): a dataset spec file name
layer_name (str): a layer name
box_type (str): a type of boxes - 'tbox' or 'ebox'
model_param_file_path (str): a model parameter file path
gpu_id (int): GPU ID (-1 for CPU)
"""
# set dataset
self.ds = TripDataset(ds_path, spec_file_name, layer_name, box_type)
# check dataset
self.ds_length = self.ds.get_length()
# window size
self.window_size = window_size
# set gpu
self.gpu_id = gpu_id
if self.gpu_id >= 0:
cuda.get_device_from_id(self.gpu_id).use()
# set model
self.set_model(model_param_file_path)
# prediction log file path
self.plog_path = plog_path
self.plogf = None
def __init__(self):
super(AffordanceSegmentation, self).__init__()
affordance = rospy.get_param('~affordance')
pretrained_model, modal, out_channels = get_pretrained_model(
affordance)
gpu = rospy.get_param('~gpu', 0)
self.lock = Lock()
# rospy.set_param('~always_subscribe', True)
model = grasp_fusion.models.FCN8sVGG16Sigmoid(
out_channels=out_channels,
pretrained_model=pretrained_model,
modal=modal,
)
if gpu >= 0:
cuda.get_device_from_id(gpu).use()
model.to_gpu()
self.model = model
self.pub_label = self.advertise('~output/label', Image, queue_size=1)
self.pub_prob = self.advertise('~output/prob', Image, queue_size=1)
self.pub_viz = self.advertise('~output/viz', Image, queue_size=1)
self._prob = None
self.srv_reset = rospy.Service('~reset', Empty, self.reset_callback)
def __init__(self, model, optimizer, obs_normalizer=None,
update_interval=3072, minibatch_size=3072, epochs=1,
entropy_coef=1e-3, loss_decay=0.99, entropy_decay=0.99,
discriminator_value_offset=1e-8, noisy_label=False,
noisy_label_range=0.3, gpu=None):
self.model = model
self.optimizer = optimizer
self.obs_normalizer = obs_normalizer
if gpu is not None and gpu >= 0:
cuda.get_device_from_id(gpu).use()
self.model.to_gpu(device=gpu)
if obs_normalizer is not None:
self.obs_normalizer.to_gpu(device=gpu)
self.xp = self.model.xp
self.epochs = epochs
self.update_interval = update_interval
self.minibatch_size = minibatch_size
self.epochs = epochs
self.entropy_coef = entropy_coef
self.loss_decay = loss_decay
self.entropy_decay = entropy_decay
self.average_loss = 0.
self.accuracy_gen = 0.
self.accuracy_exp = 0.
self.average_entropy = 0.
self.discriminator_value_offset = discriminator_value_offset
self.noisy_label = noisy_label
self.noisy_label_range = noisy_label_range
self._reset_trajectories()
def main():
args = parse_args()
model = VGG16(pretrained_model='imagenet')
image = cv2.imread(args.image_path)
image_size = (224, 224)
image = cv2.resize(image, image_size)
if args.gpu >= 0:
cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
xp = cuda.cupy
else:
xp = np
x = np.float32(image)
x = x.transpose((2, 0, 1))[np.newaxis, ::-1, :, :]
x -= model.mean
x = xp.asarray(x)
y_grad = xp.zeros((1, 1000), dtype=np.float32)
y_grad[0, args.label] = 1.0
gcam = gradcam.gradcam(model,
x, [model.conv5_3.conv, F.relu],
y_grad=y_grad)
gcam = cuda.to_cpu(gcam[0])
heatmap_image = gradcam.heatmap(gcam, image_size)
cv2.imwrite(args.heatmap_path, heatmap_image)
overlay_image = gradcam.overlay(image, gcam)
cv2.imwrite(args.overlay_path, overlay_image)
def __call__(self, x, **kwargs):
argument.check_unexpected_kwargs(
kwargs, test='test argument is not supported anymore. '
'Use chainer.using_config')
finetune, = argument.parse_kwargs(kwargs, ('finetune', False))
if hasattr(self, 'gamma'):
gamma = self.gamma
else:
with cuda.get_device_from_id(self._device_id):
gamma = variable.Variable(self.xp.ones(
self.avg_mean.shape, dtype=x.dtype))
if hasattr(self, 'beta'):
beta = self.beta
else:
with cuda.get_device_from_id(self._device_id):
beta = variable.Variable(self.xp.zeros(
self.avg_mean.shape, dtype=x.dtype))
if configuration.config.train:
if finetune:
self.N += 1
decay = 1. - 1. / self.N
else:
decay = self.decay
ret = batch_normalization(
x, gamma, beta, eps=self.eps, running_mean=self.avg_mean,
running_var=self.avg_var, decay=decay)
else:
# Use running average statistics or fine-tuned statistics.
mean = variable.Variable(self.avg_mean)
var = variable.Variable(self.avg_var)
ret = fixed_batch_normalization(
x, gamma, beta, mean, var, self.eps)
return ret
def __init__(self,
arch=None,
weights_file=None,
model=None,
device=-1,
precise=False):
self.arch = arch
self.precise = precise
if model is not None:
self.model = model
else:
print('Loading the model...')
self.model = params['archs'][arch]()
if weights_file:
serializers.load_npz(weights_file, self.model)
self.device = 0
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
self.gaussian_kernel = self.create_gaussian_kernel(
params['gaussian_sigma'], params['ksize'])[None, None]
self.gaussian_kernel = cuda.to_gpu(self.gaussian_kernel)
def __call__(self,img):
edit_img = img.copy()
img_h,img_w ,_ = edit_img.shape
#画像とheatmapの大きさの最適化(stride=8の倍数にする)
input_w,input_h = self.compute_optimal_size(edit_img,constants['img_size'])
map_w,map_h = self.compute_optimal_size(edit_img,constants['heatmap_size'])
#画像サイズの更新と学習器に入れるためにデータの編集
resized_image = cv2.resize(edit_img, (input_w, input_h))
x_data = self.preprocess(resized_image)
#GPUへの適用
if self.device >= 0:
x_data = cuda.to_gpu(x_data)
#学習器からの出力(全ステージから)
Ss,Ls = self.model(x_data)
#最終ステージの物のみ取り出す
heatmaps = F.resize_images(Ss[-1], (map_h, map_w)).data[0]
pafs = F.resize_images(Ls[-1], (map_h, map_w)).data[0]
if self.device >= 0:
pafs = pafs.get()
cuda.get_device_from_id(self.device).synchronize()
#heatmapからPeakを計算する
all_peaks = self.compute_peaks_from_heatmaps(heatmaps)
if len(all_peaks) == 0:
return np.empty((0, len(JointType), 3)), np.empty(0)
#peakとpafからConnectionを計算する
all_connections = self.compute_connections(pafs, all_peaks, map_w, constants)
#subsetの作成
subsets = self.grouping_key_points(all_connections, all_peaks, constants)
all_peaks[:, 1] *= img_w / map_w
all_peaks[:, 2] *= img_h / map_h
#poseの計算
poses = self.subsets_to_pose_array(subsets, all_peaks)
return poses
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--model', '-m', type=str, default="./results/model")
parser.add_argument('--begin', '-b', type=int, default=0)
args = parser.parse_args()
# Set up a neural network to train.
_, test_x = get_cifar10(withlabel=False, ndim=3)
test = LoadDataset(test_x)
model = network.CAE(3,3, return_out=True)
if args.model != None:
print( "loading model from " + args.model )
serializers.load_npz(args.model, model)
# Show 64 images
fig = plt.figure(figsize=(6,6))
plt.title("Original images: first rows,\n Predicted images: second rows")
plt.axis('off')
plt.tight_layout()
pbar = tqdm(total=32)
for i in range(4):
for j in range(8):
ax = fig.add_subplot(8, 8, i*16+j+1, xticks=[], yticks=[])
x, t = test[i*8+j]
xT = x.transpose(1, 2, 0)
ax.imshow(xT, cmap=plt.cm.bone, interpolation='nearest')
x = np.expand_dims(x, 0)
t = np.expand_dims(t, 0)
if args.gpu >= 0:
cuda.get_device_from_id(0).use()
model.to_gpu()
x = cuda.cupy.array(x)
t = cuda.cupy.array(t)
predicted, loss = model(Variable(x), Variable(t))
#print(predicted.shape)
#print(loss)
predicted = F.transpose(predicted[0], (1, 2, 0))
predicted = cuda.to_cpu(predicted.data) #Variable to numpy
predicted = predicted * 255
predicted = predicted.astype(np.uint8)
ax = fig.add_subplot(8, 8, i*16+j+9, xticks=[], yticks=[])
ax.imshow(predicted, cmap=plt.cm.bone, interpolation='nearest')
pbar.update(1)
pbar.close()
plt.savefig("result.png")
plt.show()
plt.close()
def __call__(self, batch, device=None, padding=None):
"""Concatenate data and transfer them to GPU asynchronously.
See also :func:`chainer.dataset.concat_examples`.
Args:
batch (list): A list of examples.
device (int): Device ID to which each array is sent.
padding: Scalar value for extra elements.
Returns:
Array, a tuple of arrays, or a dictionary of arrays.
The type depends on the type of each example in the batch.
"""
if len(batch) == 0:
raise ValueError('batch is empty')
first_elem = batch[0]
if len(self._conveyor) == 0:
self._device = device # device is set at first call
if device is not None and device >= 0 and self._stream is None:
with cuda.get_device_from_id(device):
self._stream = cuda.Stream(non_blocking=True)
if device is not self._device:
raise ValueError('device is different')
with cuda.get_device_from_id(device):
if isinstance(first_elem, tuple):
result = []
if not isinstance(padding, tuple):
padding = [padding] * len(first_elem)
for i in six.moves.range(len(first_elem)):
self._conveyor[i].put(
_concat_arrays([example[i] for example in batch],
padding[i]))
for i in six.moves.range(len(first_elem)):
result.append(self._conveyor[i].get())
return tuple(result)
elif isinstance(first_elem, dict):
result = {}
if not isinstance(padding, dict):
padding = {key: padding for key in first_elem}
for key in first_elem:
self._conveyor[key].put(
_concat_arrays([example[key] for example in batch],
padding[key]))
for key in first_elem:
result[key] = self._conveyor[key].get()
return result
else:
return to_device(device, _concat_arrays(batch, padding))
def _loss(X_, Y_, verbose=1, beta=1, weights=None, cpu=False, **kwargs):
"""CUDA ready: implementation based on NumPy/CuPy"""
if cuda.available and not cpu: # if CUDA is installed on the machine, use it.
gpu = True
if cuda.get_array_module(X_).__name__ == 'cupy': # if At_ is on GPU
# make sure it is on the same device as Bt_
assert X_.data.device.id == Y_.data.device.id
# use that Device as main device
cuda.get_device_from_id(X_.data.device.id).use()
# set pointers
X = X_
Y = Y_
print(X.device.id)
else: # At_ is a CPU array
print('Copying to GPU.')
X = cuda.to_gpu(X_, device=2)
Y = cuda.to_gpu(Y_, device=2)
cuda.get_device_from_id(2).use()
else: # CUDA is not installed, run on CPU
gpu = False
# set pointers
X = X_
Y = Y_
xp = cuda.get_array_module(X)
# Compute objective value and grad at Z.
X = X.reshape(Y.shape[:-1])
d1, d2, d3, m = X.shape
nb = Y.shape[-1]
if weights is None:
weights = np.ones(nb)
G = xp.zeros((d1, d2, d3, m))
d = 0
for i in range(nb):
if verbose > 1:
print('computing distances and gradients for shape %d' % (i + 1))
M_gpu, G_gpu = sinkhorn_dist_grad(X,
Y[:, :, :, :, i],
verbose=verbose,
**kwargs)
if gpu:
if verbose > 1:
print('_ copying to cpu')
M_cpu = cuda.to_cpu(M_gpu)
else:
M_cpu = M_gpu
d_cpu, D_cpu = soft_dtw(M_cpu, beta)
D_bar_cpu = soft_dtw_grad(D_cpu, beta)
if gpu:
if verbose > 1:
print('_ copying to gpu')
D_bar_gpu = cuda.to_gpu(D_bar_cpu, device=G_gpu.device.id)
else:
D_bar_gpu = D_bar_cpu
final_G_gpu = chain_rule(D_bar_gpu, G_gpu)
G += weights[i] * final_G_gpu
d += weights[i] * d_cpu
return d, G
def __call__(self, x, **kwargs):
"""__call__(self, x, finetune=False)
Invokes the forward propagation of BatchNormalization.
In training mode, the BatchNormalization computes moving averages of
mean and variance for evaluation during training, and normalizes the
input using batch statistics.
.. warning::
``test`` argument is not supported anymore since v2.
Instead, use ``chainer.using_config('train', False)``.
See :func:`chainer.using_config`.
Args:
x (Variable): Input variable.
finetune (bool): If it is in the training mode and ``finetune`` is
``True``, BatchNormalization runs in fine-tuning mode; it
accumulates the input array to compute population statistics
for normalization, and normalizes the input using batch
statistics.
"""
argument.check_unexpected_kwargs(
kwargs, test='test argument is not supported anymore. '
'Use chainer.using_config')
finetune, = argument.parse_kwargs(kwargs, ('finetune', False))
if hasattr(self, 'gamma'):
gamma = self.gamma
else:
with cuda.get_device_from_id(self._device_id):
gamma = variable.Variable(self.xp.ones(
self.avg_mean.shape, dtype=x.dtype))
if hasattr(self, 'beta'):
beta = self.beta
else:
with cuda.get_device_from_id(self._device_id):
beta = variable.Variable(self.xp.zeros(
self.avg_mean.shape, dtype=x.dtype))
if configuration.config.train:
if finetune:
self.N += 1
decay = 1. - 1. / self.N
else:
decay = self.decay
ret = functions.batch_normalization(
x, gamma, beta, eps=self.eps, running_mean=self.avg_mean,
running_var=self.avg_var, decay=decay)
else:
# Use running average statistics or fine-tuned statistics.
mean = variable.Variable(self.avg_mean)
var = variable.Variable(self.avg_var)
ret = functions.fixed_batch_normalization(
x, gamma, beta, mean, var, self.eps)
return ret
def test_forward_gpu_multi(self):
with cuda.get_device_from_id(0):
self.link.to_gpu()
x1 = cuda.to_gpu(self.x1)
x2 = cuda.to_gpu(self.x2)
x3 = cuda.to_gpu(self.x3)
with cuda.get_device_from_id(1):
self.check_forward(x1, x2, x3)
def test_copydata_gpu_to_another_gpu(self):
cp = cuda.cupy
with cuda.get_device_from_id(0):
data1 = cp.zeros(3, dtype=np.float32)
expect = cp.ones(3, dtype=np.float32)
with cuda.get_device_from_id(1):
data2 = cp.ones(3, dtype=np.float32)
self.check_copydata(data1, data2, expect)
def test_addgrad_gpu_to_another_gpu(self):
cp = cuda.cupy
with cuda.get_device_from_id(1):
a = cp.full(3, 10, dtype=np.float32)
with cuda.get_device_from_id(0):
b = cp.full(3, 20, dtype=np.float32)
c = cp.full(3, 30, dtype=np.float32)
self.check_addgrad(a, b, c)
def test_forward_gpu_multi(self):
with cuda.get_device_from_id(0):
self.link.to_gpu()
c = cuda.to_gpu(self.c)
h = cuda.to_gpu(self.h)
x = cuda.to_gpu(self.x)
with cuda.get_device_from_id(1):
self.check_forward(c, h, x)
def test_addgrad_gpu_to_another_gpu_none_dst_dev1(self):
cp = cuda.cupy
with cuda.get_device_from_id(1):
a = cp.full(3, 20, dtype=np.float32)
with cuda.get_device_from_id(0):
b = cp.full(3, 10, dtype=np.float32)
c = cp.full(3, 20, dtype=np.float32)
with cuda.get_device_from_id(1):
self.check_addgrad(a, b, c, clear_dst_grad=True)
def test_zerograds_fill_multi_gpu(self):
cupy = cuda.cupy
with cuda.get_device_from_id(1):
a = chainer.Variable(cupy.empty(3, dtype=np.float32))
a.grad = cupy.empty_like(a.data)
a.zerograd()
self.assertEqual(int(a.grad.device), 1)
with cuda.get_device_from_id(1):
g_expect = cupy.zeros_like(a.data)
cupy.testing.assert_array_equal(a.grad, g_expect)
def dump_bilm_embeddings(vocab_file, dataset_file, options_file,
weight_file, outfile, gpu=-1,
batchsize=32):
with open(options_file, 'r') as fin:
options = json.load(fin)
max_word_length = options['char_cnn']['max_characters_per_token']
vocab = UnicodeCharsVocabulary(vocab_file, max_word_length)
batcher = Batcher(vocab_file, max_word_length)
model = Elmo(
options_file,
weight_file,
num_output_representations=1,
requires_grad=False,
do_layer_norm=False,
dropout=0.)
if gpu >= 0:
cuda.get_device_from_id(gpu).use()
model.to_gpu()
# (batch_size, timesteps, 50)
# TODO(sosk): preencoding token embedding for acceleration
with chainer.using_config("train", False), \
chainer.no_backprop_mode():
sentence_id = 0
n_lines = sum([1 for _ in open(dataset_file, 'r')])
with open(dataset_file, 'r') as fin, h5py.File(outfile, 'w') as fout:
for minibatch in minibatch_iterator(tqdm.tqdm(fin, total=n_lines),
batchsize):
sentences = [line.strip().split() for line in minibatch]
char_ids = batcher.batch_sentences(
sentences, add_bos_eos=False)
char_ids = model.xp.asarray(char_ids)
mb_outs = model.forward(char_ids)
mb_embedding_layers = mb_outs['elmo_layers']
# [(batch_size, max_sequence_length, embedding_dim), ..., x n_layers]
# Note that embedding layers have already trushed bos & eos
# But they contains padding
mb_mask = mb_outs['mask']
mb_concat_embedding_layers = cuda.to_cpu(
model.xp.stack([mb_emb.array for mb_emb in mb_embedding_layers], axis=1))
# (batch_size, n_layers=3, max_sequence_length, embedding_dim)
for mask, concat_embedding_layers in zip(mb_mask, mb_concat_embedding_layers):
# remove pads
length = int(mask.sum())
concat_embedding_layers = concat_embedding_layers[:, :length]
# (n_layers=3, sequence_length, embedding_dim)
ds = fout.create_dataset(
'{}'.format(sentence_id),
concat_embedding_layers.shape,
dtype='float32',
data=concat_embedding_layers
)
sentence_id += 1
def test_zerograds_multi_gpu(self):
cupy = cuda.cupy
with cuda.get_device_from_id(1):
a = chainer.Variable(cupy.empty(3, dtype=np.float32))
with testing.assert_warns(DeprecationWarning):
a.zerograd()
self.assertIsNot(a.grad, None)
self.assertEqual(int(a.grad.device), 1)
with cuda.get_device_from_id(1):
g_expect = cupy.zeros_like(a.data)
cupy.testing.assert_array_equal(a.grad, g_expect)
def dump_token_embeddings(vocab_file, options_file, weight_file, outfile,
gpu=-1, batchsize=128):
'''
Given an input vocabulary file, dump all the token embeddings to the
outfile. The result can be used as the embedding_weight_file when
constructing a BidirectionalLanguageModel.
'''
with open(options_file, 'r') as fin:
options = json.load(fin)
max_word_length = options['char_cnn']['max_characters_per_token']
vocab = UnicodeCharsVocabulary(vocab_file, max_word_length)
batcher = Batcher(vocab_file, max_word_length)
model = Elmo(
options_file,
weight_file,
num_output_representations=1,
requires_grad=False,
do_layer_norm=False,
dropout=0.)
tokens = [vocab.id_to_word(i) for i in range(vocab.size)]
n_tokens = len(tokens)
# (batch_size, timesteps, 50)
if gpu >= 0:
cuda.get_device_from_id(gpu).use()
model.to_gpu()
all_embeddings = []
with chainer.using_config("train", False), \
chainer.no_backprop_mode():
for minibatch in minibatch_iterator(tqdm.tqdm(tokens, total=n_tokens),
batchsize):
char_ids = batcher.batch_sentences([minibatch], add_bos_eos=False)
char_ids = model.xp.asarray(char_ids) # to gpu
embeddings = model._elmo_lstm._token_embedder\
.forward(char_ids)['token_embedding']
# (batch_size, sequence_length + 2, embedding_dim)
embeddings = embeddings[:, 1:-1] # del bos and eos
embeddings = embeddings[0]
embeddings = cuda.to_cpu(embeddings.array)
all_embeddings.append(embeddings)
all_embeddings = numpy.concatenate(all_embeddings, axis=0)
with h5py.File(outfile, 'w') as fout:
ds = fout.create_dataset(
'embedding',
all_embeddings.shape,
dtype='float32',
data=all_embeddings)
def __init__(self, arch=None, weights_file=None, model=None, device=-1):
print('Loading FaceNet...')
self.model = params['archs'][arch]()
serializers.load_npz(weights_file, self.model)
self.device = device
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
# create gaussian filter
ksize = params['ksize']
kernel = cuda.to_gpu(self.create_gaussian_kernel(sigma=params['gaussian_sigma'], ksize=ksize))
self.gaussian_kernel = kernel
def __call__(self, x):
"""Updates the internal state and returns the LSTM outputs.
Args:
x (~chainer.Variable): A new batch from the input sequence.
Returns:
~chainer.Variable: Outputs of updated LSTM units.
"""
if self.upward.has_uninitialized_params:
with cuda.get_device_from_id(self._device_id):
in_size = x.size // x.shape[0]
self.upward._initialize_params(in_size)
self._initialize_params()
batch = x.shape[0]
lstm_in = self.upward(x)
h_rest = None
if self.h is not None:
h_size = self.h.shape[0]
if batch == 0:
h_rest = self.h
elif h_size < batch:
msg = ('The batch size of x must be equal to or less than'
'the size of the previous state h.')
raise TypeError(msg)
elif h_size > batch:
h_update, h_rest = split_axis.split_axis(
self.h, [batch], axis=0)
lstm_in += self.lateral(h_update)
else:
lstm_in += self.lateral(self.h)
if self.c is None:
xp = self.xp
with cuda.get_device_from_id(self._device_id):
self.c = variable.Variable(
xp.zeros((batch, self.state_size), dtype=x.dtype),
volatile='auto')
self.c, y = lstm.lstm(self.c, lstm_in)
if h_rest is None:
self.h = y
elif len(y.data) == 0:
self.h = h_rest
else:
self.h = concat.concat([y, h_rest], axis=0)
return y
def _train_for_auxiliary_task(self, x_l0, x_l1, y_l, x_u0, x_u1):
# Compute gradients
y_pred0 = self.model(x_u0, self.model_params)
y_pred1 = self.model(x_u1, self.model_params)
loss_rc = self.rc_loss(y_pred0, y_pred1)
self._cleargrads()
loss_rc.backward(retain_grad=True)
# Update optimizee parameters by meta-learner
model_params = self.model_params
for i, elm in enumerate(model_params.items()):
name, w = elm
meta_learner = self.meta_learners[i]
ml_optimizer = self.ml_optimizers[i]
shape = w.shape
with cuda.get_device_from_id(self.device):
xp = cuda.get_array_module(w.data)
g_old = w.grad # no nedd to deep copy
grad_data = xp.reshape(g_old, (np.prod(shape), 1))
# refine grad, update w, and replace
grad = Variable(grad_data)
g = meta_learner(grad) #TODO: use either h or c
w -= F.reshape(g, shape)
model_params[name] = w
# Forward primary taks for training meta-leaners
#TODO: use the same labeled data?
y_pred = self.model(x_l0, self.model_params)
self.loss_ml += F.softmax_cross_entropy(y_pred, y_l)
def accuracy_gpu(self, device=None):
model = self.model
optimizer = self.optimizer
model.to_gpu(device=device)
optimizer.setup(model)
with cuda.get_device_from_id(device):
return self._train_linear_classifier(model, optimizer, True)
def update_parameter_by_meta_learner(
self, model_params, loss,
x_l0, x_l1, y_l):
# Forward meta-learner
namedparams = model_params
for i, elm in enumerate(namedparams.items()): # parameter-loop
k, p = elm
with cuda.get_device_from_id(self.device):
shape = p.shape
xp = cuda.get_array_module(p.data)
x = p.grad
grad = xp.reshape(x, (np.prod(shape), ))
meta_learner = self.meta_learners[i]
g = meta_learner(Variable(grad)) # forward
w = p - F.reshape(g, shape)
self.model_params[k] = w
# Train meta-learner with main objective
y_pred = self.model(x_l0, self.model_params)
loss_ce = F.softmax_cross_entropy(y_pred, y_l)
self.cleargrads() # need to clear W'grad due to loss_rec.backward
for meta_learner in self.meta_learners:
meta_learner.cleargrads()
loss_ce.backward(retain_grad=True)
for opt in self.opt_meta_learners:
opt.update()
loss_ce.unchain_backward() #TODO: here is a proper place to unchain?
def update_parameter_by_meta_learner(
self, model_params, loss,
x_l0, x_l1, y_l):
# Forward meta-learner
namedparams = model_params
for i, elm in enumerate(namedparams.items()): # parameter-loop
k, p = elm
with cuda.get_device_from_id(self.device):
shape = p.shape
xp = cuda.get_array_module(p.data)
# normalize grad
x = p.grad
p_val = 10
grad0 = xp.where(xp.absolute(x) > xp.exp(-p_val),
xp.log(xp.absolute(x))/p_val, -1)
grad1 = xp.where(xp.absolute(x) > xp.exp(-p_val),
xp.sign(x), xp.exp(p_val)*x)
grad0 = xp.reshape(grad0, (np.prod(shape), ))
grad1 = xp.reshape(grad1, (np.prod(shape), ))
grad0 = xp.expand_dims(grad0, axis=1)
grad1 = xp.expand_dims(grad1, axis=1)
input_grad = xp.concatenate((grad0, grad1), axis=1)
# normalize loss
x = loss.data
loss0 = xp.where(xp.absolute(x) > xp.exp(-p_val),
xp.log(xp.absolute(x))/p_val, -1)
loss1 = xp.where(xp.absolute(x) > xp.exp(-p_val),
xp.sign(x), xp.exp(p_val)*x)
loss0 = xp.expand_dims(loss0, axis=0)
loss1 = xp.expand_dims(loss1, axis=0)
input_loss = xp.concatenate((loss0, loss1))
input_loss = xp.broadcast_to(input_loss,
(input_grad.shape[0], 2))
# input
input_ = xp.concatenate((input_grad, input_loss), axis=1)
meta_learner = self.meta_learners[i]
g = meta_learner(Variable(input_.astype(xp.float32))) # forward
w = p - F.reshape(g, shape) * 1e-3
namedparams[k] = w
# Train meta-learner with main objective
y_pred = self.model(x_l0, self.model_params)
loss_ce = F.softmax_cross_entropy(y_pred, y_l)
self.cleargrads() # need to clear W'grad due to loss_rec.backward
for meta_learner in self.meta_learners:
meta_learner.cleargrads()
loss_ce.backward(retain_grad=True)
for opt in self.opt_meta_learners:
opt.update()
loss_ce.unchain_backward()
def __call__(self, x):
"""Updates the internal state and returns the LSTM outputs.
Args:
x (~chainer.Variable): A new batch from the input sequence.
Returns:
~chainer.Variable: Outputs of updated LSTM units.
"""
lstm_in = self.upward(x)
if self.h is not None:
lstm_in += self.lateral(self.h)
else:
xp = self.xp
with cuda.get_device_from_id(self._device_id):
self.h = variable.Variable(
xp.zeros((len(x.data), self.state_size),
dtype=x.data.dtype),
volatile='auto')
if self.c is None:
xp = self.xp
with cuda.get_device_from_id(self._device_id):
self.c = variable.Variable(
xp.zeros((len(x.data), self.state_size),
dtype=x.data.dtype),
volatile='auto')
lstm_in = reshape.reshape(lstm_in, (len(lstm_in.data),
lstm_in.data.shape[1] // 4,
4))
a, i, f, o = split_axis.split_axis(lstm_in, 4, 2)
a = reshape.reshape(a, (len(a.data), self.state_size))
i = reshape.reshape(i, (len(i.data), self.state_size))
f = reshape.reshape(f, (len(f.data), self.state_size))
o = reshape.reshape(o, (len(o.data), self.state_size))
c_tmp = tanh.tanh(a) * sigmoid.sigmoid(i) + sigmoid.sigmoid(f) * self.c
self.c = zoneout.zoneout(self.c, c_tmp, self.c_ratio, self.train)
self.h = zoneout.zoneout(self.h,
sigmoid.sigmoid(o) * tanh.tanh(c_tmp),
self.h_ratio, self.train)
return self.h
def __init__(self, arch=None, weights_file=None, model=None, device=-1, precise=False):
self.arch = arch
self.precise = precise
if model is not None:
self.model = model
else:
print('Loading the model...')
self.model = params['archs'][arch]()
if weights_file:
serializers.load_npz(weights_file, self.model)
self.device = device
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
# create gaussian filter
self.gaussian_kernel = self.create_gaussian_kernel(params['gaussian_sigma'], params['ksize'])[None, None]
self.gaussian_kernel = cuda.to_gpu(self.gaussian_kernel)
def load_model(self):
n_fg_class = len(self.train_dataset.fg_class_names)
pooling_func = cmr.functions.roi_align_2d
anchor_scales = (4, 8, 16, 32)
roi_size = 14
min_size = 600
max_size = 1000
mask_initialW = chainer.initializers.Normal(0.01)
if self.model_name == 'vgg16':
self.mask_rcnn = cmr.models.MaskRCNNVGG16(
n_fg_class=n_fg_class,
pretrained_model='imagenet',
pooling_func=pooling_func,
anchor_scales=anchor_scales,
roi_size=roi_size,
min_size=min_size,
max_size=max_size,
mask_initialW=mask_initialW,
)
elif self.model_name in ['resnet50', 'resnet101']:
n_layers = int(self.model_name.lstrip('resnet'))
self.mask_rcnn = cmr.models.MaskRCNNResNet(
n_layers=n_layers,
n_fg_class=n_fg_class,
pooling_func=pooling_func,
anchor_scales=anchor_scales,
roi_size=roi_size,
min_size=min_size,
max_size=max_size,
mask_initialW=mask_initialW,
)
else:
raise ValueError(
'Unsupported model_name: {}'.format(self.model_name))
self.model = cmr.models.MaskRCNNTrainChain(self.mask_rcnn)
if self.gpu >= 0:
cuda.get_device_from_id(self.gpu).use()
self.model.to_gpu()
def __call__(self, x):
"""Applies the linear layer.
Args:
x (~chainer.Variable): Batch of input vectors.
Returns:
~chainer.Variable: Output of the linear layer.
"""
if self.has_uninitialized_params:
with cuda.get_device_from_id(self._device_id):
self._initialize_params(x.size // x.shape[0])
return linear.linear(x, self.W, self.b)
def forward_meta_learners(self, ):
# Forward of meta-learner, i.e., parameter update
for i, name_param in enumerate(self.model_params.items()):
k, p = name_param
with cuda.get_device_from_id(self.device):
shape = p.shape
xp = cuda.get_array_module(p.data)
w_data = p.data # meta learner is gated-reccurent unit for W not for G
w_data = xp.reshape(w_data, (1, 1, np.prod(shape)))
meta_learner = self.meta_learners[i]
w_accum = meta_learner(Variable(w_data)) # forward
w_accum = F.reshape(w_accum, shape)
self.model_params[k] = w_accum
def __call__(self, x, W=None, b=None):
if self.has_uninitialized_params:
with cuda.get_device_from_id(self._device_id):
self._initialize_params(x.shape[1])
if W is not None:
return deconvolution_2d.deconvolution_2d(
x, W, b, self.stride, self.pad,
self.outsize, self.use_cudnn,
deterministic=self.deterministic)
return deconvolution_2d.deconvolution_2d(
x, self.W, self.b, self.stride, self.pad,
self.outsize, self.use_cudnn,
deterministic=self.deterministic)
def forward_meta_learners(self, ):
# Forward of meta-learner, i.e., parameter update
for i, name_param in enumerate(self.model_params.items()):
k, p = name_param
with cuda.get_device_from_id(self.device):
shape = p.shape
xp = cuda.get_array_module(p.data)
x = p.grad
#grad = xp.reshape(x, (np.prod(shape), ))
grad = xp.reshape(x, (np.prod(shape), 1))
meta_learner = self.meta_learners[i]
g = meta_learner(Variable(grad)) # forward
w = p - F.reshape(g, shape)
self.model_params[k] = w # parameter update
def __call__(self, x):
"""Applies the convolution layer.
Args:
x (~chainer.Variable): Input image.
Returns:
~chainer.Variable: Output of the convolution.
"""
if self.has_uninitialized_params:
with cuda.get_device_from_id(self._device_id):
self._initialize_params(x.shape[1])
return dilated_convolution_2d.dilated_convolution_2d(
x, self.W, self.b, self.stride,
self.pad, self.dilate, self.use_cudnn)
