def test_double_backward_gpu(self):
self.check_double_backward(
cuda.to_gpu(self.x1),
cuda.to_gpu(self.x2),
cuda.to_gpu(self.gy),
cuda.to_gpu(self.ggx1),
cuda.to_gpu(self.ggx2))
def forward(self, state, action, Reward, state_dash, episode_end):
num_of_batch = state.shape[0]
s = Variable(state)
s_dash = Variable(state_dash)
Q = self.Q_func(s) # Get Q-value
# Generate Target Signals
tmp2 = self.Q_func(s_dash)
tmp2 = list(map(np.argmax, tmp2.data.get())) # argmaxQ(s',a)
tmp = self.Q_func_target(s_dash) # Q'(s',*)
tmp = list(tmp.data.get())
# select Q'(s',*) due to argmaxQ(s',a)
res1 = []
for i in range(num_of_batch):
res1.append(tmp[i][tmp2[i]])
#max_Q_dash = np.asanyarray(tmp, dtype=np.float32)
max_Q_dash = np.asanyarray(res1, dtype=np.float32)
target = np.asanyarray(Q.data.get(), dtype=np.float32)
for i in xrange(num_of_batch):
if not episode_end[i][0]:
tmp_ = np.sign(Reward[i]) + self.gamma * max_Q_dash[i]
else:
tmp_ = np.sign(Reward[i])
action_index = self.action_to_index(action[i])
target[i, action_index] = tmp_
# TD-error clipping
td = Variable(cuda.to_gpu(target)) - Q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td/abs(td_tmp) * (abs(td.data) > 1)
zero_val = Variable(cuda.to_gpu(np.zeros((self.replay_size, self.num_of_actions), dtype=np.float32)))
loss = F.mean_squared_error(td_clip, zero_val)
return loss, Q
def test_sqnorm_array_multi_gpu(self):
x0 = cuda.to_gpu(self.x, device=0)
x1 = cuda.to_gpu(self.x, device=1)
a0 = cuda.to_gpu(self.a, device=0)
a1 = cuda.to_gpu(self.a, device=1)
self.assertAlmostEqual(optimizer._sum_sqnorm(
[self.x, self.a, x0, a0, x1, a1]), 8.75 * 3)
def test_double_backward_gpu(self):
x1 = cuda.to_gpu(self.x1)
x2 = cuda.to_gpu(self.x2)
gy = cuda.to_gpu(self.gy)
ggx1 = cuda.to_gpu(self.ggx1)
ggx2 = cuda.to_gpu(self.ggx2)
self.check_double_backward(x1, x2, gy, ggx1, ggx2)
def experienceReplay(self, time):
if self.initial_exploration < time:
# Pick up replay_size number of samples from the Data
if time < self.data_size: # during the first sweep of the History Data
replay_index = np.random.randint(0, time, (self.replay_size, 1))
else:
replay_index = np.random.randint(0, self.data_size, (self.replay_size, 1))
s_replay = np.ndarray(shape=(self.replay_size, 4, 84, 84), dtype=np.float32)
a_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.uint8)
r_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.float32)
s_dash_replay = np.ndarray(shape=(self.replay_size, 4, 84, 84), dtype=np.float32)
episode_end_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.bool)
for i in xrange(self.replay_size):
s_replay[i] = np.asarray(self.D[0][replay_index[i]], dtype=np.float32)
a_replay[i] = self.D[1][replay_index[i]]
r_replay[i] = self.D[2][replay_index[i]]
s_dash_replay[i] = np.array(self.D[3][replay_index[i]], dtype=np.float32)
episode_end_replay[i] = self.D[4][replay_index[i]]
s_replay = cuda.to_gpu(s_replay)
s_dash_replay = cuda.to_gpu(s_dash_replay)
# Gradient-based update
self.optimizer.zero_grads()
loss, _ = self.forward(s_replay, a_replay, r_replay, s_dash_replay, episode_end_replay)
loss.backward()
self.optimizer.update()
def test_forward_gpu(self):
self.check_forward(
cuda.to_gpu(self.x),
cuda.to_gpu(self.offset),
cuda.to_gpu(self.W),
cuda.to_gpu(self.b),
self.stride, self.pad)
def generate_sample(state, primetext):
prev_char = np.array([0], dtype=np.int32)
if args.gpu >= 0:
prev_char = cuda.to_gpu(prev_char)
if len(primetext) > 0:
for i in primetext:
sys.stdout.write(i)
prev_char = np.ones((1,)).astype(np.int32) * vocab[i]
if args.gpu >= 0:
prev_char = cuda.to_gpu(prev_char)
state, prob = model.predict(prev_char, state)
for i in xrange(args.length):
state, prob = model.predict(prev_char, state)
if args.sample > 0:
probability = cuda.to_cpu(prob.data)[0].astype(np.float64)
probability /= np.sum(probability)
index = np.random.choice(range(len(probability)), p=probability)
else:
index = np.argmax(cuda.to_cpu(prob.data))
sys.stdout.write(ivocab[index].encode("utf-8"))
prev_char = np.array([index], dtype=np.int32)
if args.gpu >= 0:
prev_char = cuda.to_gpu(prev_char)
return state
def train_epoch(train_data, train_labels, model, optimizer, batchsize, transformations, silent, gpu=0, finetune=False):
N = train_data.shape[0]
pbar = ProgressBar(0, N)
perm = np.random.permutation(N)
sum_accuracy = 0
sum_loss = 0
for i in range(0, N, batchsize):
x_batch = train_data[perm[i : i + batchsize]]
y_batch = train_labels[perm[i : i + batchsize]]
if transformations is not None:
if "rotation" == transformations:
x_batch = rotate_transform_batch(x_batch, rotation=2 * np.pi)
if gpu >= 0:
x_batch = cuda.to_gpu(x_batch.astype(np.float32))
y_batch = cuda.to_gpu(y_batch.astype(np.int32))
optimizer.zero_grads()
x = Variable(x_batch)
t = Variable(y_batch)
loss, acc = model(x, t, train=True, finetune=finetune)
if not finetune:
loss.backward()
optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * y_batch.size
sum_accuracy += float(cuda.to_cpu(acc.data)) * y_batch.size
if not silent:
pbar.update(i + y_batch.size)
return sum_loss, sum_accuracy
def train(train_dl, N, model, optimizer, trans, args, input_q, data_q):
pbar = ProgressBar(N)
perm = np.random.permutation(N)
sum_loss = 0
# putting all data
for i in range(0, N, args.batchsize):
x_batch = train_dl[perm[i:i + args.batchsize]]
input_q.put(x_batch)
# training
for i in range(0, N, args.batchsize):
input_data, label = data_q.get()
if args.gpu >= 0:
input_data = cuda.to_gpu(input_data.astype(np.float32))
label = cuda.to_gpu(label.astype(np.float32))
optimizer.zero_grads()
loss, pred = model.forward(input_data, label, train=True)
loss.backward()
optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
pbar.update(i + args.batchsize if (i + args.batchsize) < N else N)
return sum_loss
def forward(x_data, y_data, train=True):
x_0 = chainer.Variable(cuda.to_gpu(x_data, 0), volatile=not train)
x_1 = chainer.Variable(cuda.to_gpu(x_data, 1), volatile=not train)
t = chainer.Variable(cuda.to_gpu(y_data, 0), volatile=not train)
h1_0 = F.dropout(F.relu(model.gpu0.l1(x_0)), train=train)
h1_1 = F.dropout(F.relu(model.gpu1.l1(x_1)), train=train)
h2_0 = F.dropout(F.relu(model.gpu0.l2(h1_0)), train=train)
h2_1 = F.dropout(F.relu(model.gpu1.l2(h1_1)), train=train)
h3_0 = F.dropout(F.relu(model.gpu0.l3(h2_0)), train=train)
h3_1 = F.dropout(F.relu(model.gpu1.l3(h2_1)), train=train)
# Synchronize
h3_0 += F.copy(h3_1, 0)
h3_1 = F.copy(h3_0, 1)
h4_0 = F.dropout(F.relu(model.gpu0.l4(h3_0)), train=train)
h4_1 = F.dropout(F.relu(model.gpu1.l4(h3_1)), train=train)
h5_0 = F.dropout(F.relu(model.gpu0.l5(h4_0)), train=train)
h5_1 = F.dropout(F.relu(model.gpu1.l5(h4_1)), train=train)
h6_0 = F.relu(model.gpu0.l6(h5_0))
h6_1 = F.relu(model.gpu1.l6(h5_1))
# Synchronize
y = h6_0 + F.copy(h6_1, 0)
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def get_loss(self, state, action, reward, state_prime, episode_end):
s = Variable(cuda.to_gpu(state))
s_dash = Variable(cuda.to_gpu(state_prime))
q = self.model.q_function(s) # Get Q-value
# Generate Target Signals
tmp = self.model_target.q_function(s_dash) # Q(s',*)
tmp = list(map(np.max, tmp.data)) # max_a Q(s',a)
max_q_prime = np.asanyarray(tmp, dtype=np.float32)
target = np.asanyarray(copy.deepcopy(q.data.get()), dtype=np.float32)
for i in range(self.replay_size):
if episode_end[i][0] is True:
tmp_ = np.sign(reward[i])
else:
# The sign of reward is used as the reward of DQN!
tmp_ = np.sign(reward[i]) + self.gamma * max_q_prime[i]
target[i, action[i]] = tmp_
# TD-error clipping
td = Variable(cuda.to_gpu(target)) - q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td/abs(td_tmp) * (abs(td.data) > 1)
zero_val = Variable(cuda.to_gpu(np.zeros((self.replay_size, self.n_act), dtype=np.float32)))
loss = F.mean_squared_error(td_clip, zero_val)
return loss, q
def test_forward_gpu_volatile(self):
self.check_forward(cuda.to_gpu(self.hx),
cuda.to_gpu(self.cx),
[cuda.to_gpu(x) for x in self.xs],
[[cuda.to_gpu(w) for w in ws] for ws in self.ws],
[[cuda.to_gpu(b) for b in bs] for bs in self.bs],
True)
def fit(self, train_x, train_y, transpose=True):
self.create_model(len(train_x[0]), 10)
optimizer = optimizers.Adam()
optimizer.setup(self.model.collect_parameters())
N = len(train_x)
for epoch in xrange(self.epochs):
if self.varbose:
print epoch + 1
sum_loss = 0.0
perm = np.random.permutation(N)
for i in xrange(0, N, self.batch_size):
x_batch = train_x[perm[i : i + self.batch_size]]
y_batch = train_y[perm[i : i + self.batch_size]]
if self.cuda:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
optimizer.zero_grads()
y, loss = self.forward(x_batch, y_batch)
loss.backward()
optimizer.update()
if self.varbose:
sum_loss += float(cuda.to_cpu(loss.data)) * self.batch_size
if self.varbose:
print sum_loss / N
def _gather(link, target):
size, num = size_num_grads(link)
ptrs = numpy.empty(num, dtype=numpy.uint64)
dtypes = numpy.empty(num, dtype=numpy.int8)
info = numpy.empty(num + 1, dtype=numpy.int32)
info[0] = 0
i = 0
for _, param in sorted(link.namedparams()):
if param.size == 0:
continue
ptrs[i] = 0 # NULL pointer
d = getattr(param, target)
if d is not None:
ptrs[i] = d.data.ptr
dtypes[i] = 0 # fp32
if param.dtype == numpy.float16:
dtypes[i] = 1 # fp16
info[i + 1] = info[i] + param.size
i += 1
info[0] = num
ptrs = cuda.to_gpu(ptrs)
dtypes = cuda.to_gpu(dtypes)
info = cuda.to_gpu(info)
return _memcpy_gather()(ptrs, dtypes, info, size=size)
def _scatter(link, array, target):
size, num = size_num_grads(link)
ptrs = numpy.zeros(num, dtype=numpy.uint64)
dtypes = numpy.zeros(num, dtype=numpy.int8)
info = numpy.zeros(num + 1, dtype=numpy.int32)
info[0] = 0
i = 0
for _, param in sorted(link.namedparams()):
if param.size == 0:
continue
ptrs[i] = 0 # NULL pointer
d = getattr(param, target)
if d is None:
d = cuda.cupy.zeros(param.shape, dtype=param.dtype)
setattr(param, target, d)
ptrs[i] = d.data.ptr
dtypes[i] = 0 # fp32
if param.dtype == numpy.float16:
dtypes[i] = 1 # fp16
info[i + 1] = info[i] + param.size
i += 1
if i != num:
raise()
info[0] = num
ptrs = cuda.to_gpu(ptrs)
dtypes = cuda.to_gpu(dtypes)
info = cuda.to_gpu(info)
return _memcpy_scatter()(ptrs, dtypes, info, array, size=size)
def test_proposal_creator_gpu(self):
self.check_proposal_creator(
self.proposal_creator,
cuda.to_gpu(self.bbox_d),
cuda.to_gpu(self.score),
cuda.to_gpu(self.anchor), self.img_size,
scale=1.)
def predict(self, x_data, y_data, gpu=-1):
if gpu >= 0:
x_data = cuda.to_gpu(x_data)
y_data = cuda.to_gpu(y_data)
x, t = Variable(x_data), Variable(y_data)
y = self.__forward(x)
return F.softmax(y) #, F.accuracy(y, t)
def train_loop():
while True:
while data_q.empty():
time.sleep(0.1)
inp = data_q.get()
if inp == 'end': # quit
res_q.put('end')
break
elif inp == 'train': # restart training
res_q.put('train')
train = True
continue
elif inp == 'val': # start validation
res_q.put('val')
pickle.dump(model, open('model', 'wb'), -1)
train = False
continue
x, y = inp
if args.gpu >= 0:
x = cuda.to_gpu(x)
y = cuda.to_gpu(y)
if train:
optimizer.zero_grads()
loss, accuracy = model.forward(x, y)
loss.backward()
optimizer.update()
else:
loss, accuracy = model.forward(x, y, train=False)
res_q.put((float(cuda.to_cpu(loss.data)),
float(cuda.to_cpu(accuracy.data))))
del loss, accuracy, x, y
def forward(self, state, action, Reward, state_dash, episode_end):
num_of_batch = state.shape[0]
s = Variable(state)
s_dash = Variable(state_dash)
Q = self.model.Q_func(s,train=True) # Get Q-value
# Generate Target Signals
tmp = self.model_target.Q_func(s_dash,train=self.targetFlag) # Q(s',*)
tmp = list(map(np.max, tmp.data.get())) # max_a Q(s',a)
max_Q_dash = np.asanyarray(tmp, dtype=np.float32)
target = np.asanyarray(Q.data.get(), dtype=np.float32)
for i in xrange(num_of_batch):
if not episode_end[i][0]:
tmp_ = np.sign(Reward[i]) + self.gamma * max_Q_dash[i]
else:
tmp_ = np.sign(Reward[i])
#print action
action_index = self.action_to_index(action[i])
target[i, action_index] = tmp_
# TD-error clipping
td = Variable(cuda.to_gpu(target,self.gpu_id)) - Q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td/abs(td_tmp) * (abs(td.data) > 1)
zero_val = Variable(cuda.to_gpu(np.zeros((self.replay_size, self.num_of_actions), dtype=np.float32),self.gpu_id))
loss = F.mean_squared_error(td_clip, zero_val)
return loss, Q
def check_forward_gpu(self, use_cudnn):
with chainer.using_config('use_cudnn', use_cudnn):
self.check_forward(
cuda.to_gpu(self.hx),
[cuda.to_gpu(x) for x in self.xs],
[[cuda.to_gpu(w) for w in ws] for ws in self.ws],
[[cuda.to_gpu(b) for b in bs] for bs in self.bs])
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:
gamma_ = self.xp.ones(self.avg_mean.shape, dtype=x.dtype)
if self.device is None:
gamma = variable.Variable(gamma_, volatile='auto')
else:
gamma = \
variable.Variable(cuda.to_gpu(gamma_, self.device), volatile='auto')
if hasattr(self, 'beta'):
beta = self.beta
else:
beta_ = self.xp.zeros(self.avg_mean.shape, dtype=x.dtype)
if self.device is None:
beta = variable.Variable(beta_, volatile='auto')
else:
beta = variable.Variable(cuda.to_gpu(beta_, self.device), volatile='auto')
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')
ret = batch_normalization.fixed_batch_normalization(
x, gamma, beta, mean, var, self.eps, self.use_cudnn)
return ret
def check_backward(self, inputs, grad_outputs, backend_config):
xp = backend_config.xp
if backend_config.use_cuda:
inputs = cuda.to_gpu(inputs)
grad_outputs = cuda.to_gpu(grad_outputs)
x_data, W_data, b_data = inputs
y_grad, = grad_outputs
if not self.c_contiguous:
x_data = xp.asfortranarray(x_data)
W_data = xp.asfortranarray(W_data)
y_grad = xp.asfortranarray(y_grad)
assert not x_data.flags.c_contiguous
assert not W_data.flags.c_contiguous
assert not y_grad.flags.c_contiguous
if b_data is not None:
b = xp.empty((len(b_data) * 2,), dtype=b_data.dtype)
b[::2] = b_data
b_data = b[::2]
assert not b_data.flags.c_contiguous
args = (x_data, W_data)
if b_data is not None:
args = args + (b_data,)
def f(*args):
return F.deconvolution_2d(
*args, stride=self.stride, pad=self.pad, outsize=self.outsize,
dilate=self.dilate, group=self.group)
with backend_config:
gradient_check.check_backward(
f, args, y_grad, **self.check_backward_options)
def test_forward_gpu_train(self):
self.rnn.to_gpu()
with chainer.using_config('use_cudnn', 'always'), \
chainer.using_config('train', True):
self.check_forward(
cuda.to_gpu(self.h),
[cuda.to_gpu(x) for x in self.xs])
def train(train_dl, N, model, optimizer, args, input_q, data_q):
widgets = ["Training : ", Percentage(), Bar()]
pbar = ProgressBar(maxval = N, widgets = widgets).start()
sum_loss = 0
# putting all data
for i in range(0, N, 2):
x_batch = train_dl[perm[i:i + 2]]
input_q.put(x_batch)
# training
for i in range(0, N, args.batchsize):
input_data, label = data_q.get()
print (input_data.shape, label.shape)
if args.gpu >= 0:
input_data = cuda.to_gpu(input_data.astype(np.float32))
label = cuda.to_gpu(label.astype(np.float32))
optimizer.zero_grads()
loss, pred = model.forward(input_data, label, train=True)
loss.backward()
optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
pbar.update(i + args.batchsize if (i + args.batchsize) < N else N)
return sum_loss
def check_equivariance(im, layers, input_array, output_array, point_group):
# Transform the image
f = input_array(im)
g = point_group.rand()
gf = g * f
im1 = gf.v
# Apply layers to both images
im = Variable(cuda.to_gpu(im))
im1 = Variable(cuda.to_gpu(im1))
fmap = im
fmap1 = im1
for layer in layers:
layer.to_gpu()
fmap = layer(fmap)
fmap1 = layer(fmap1)
# Transform the computed feature maps
fmap1_garray = output_array(cuda.to_cpu(fmap1.data))
r_fmap1_data = (g.inv() * fmap1_garray).v
fmap_data = cuda.to_cpu(fmap.data)
assert np.allclose(fmap_data, r_fmap1_data, rtol=1e-5, atol=1e-3)
def test_DNSP_sparse_matmul_forward_gpu(self):
a = cuda.to_gpu(self.a)
b = cuda.to_gpu(self.b)
if self.a_dtype == numpy.float16 or self.b_dtype == numpy.float16:
self.check_DNSP_forward(a, b, atol=1e-3, rtol=1e-3)
else:
self.check_DNSP_forward(a, b)
def train(self, x, y, actions=None):
actions = actions.astype(np.int32)
batch_size = len(actions)
if self._gpu_device:
x = cuda.to_gpu(x, self._gpu_device)
y = cuda.to_gpu(y, self._gpu_device)
actions = cuda.to_gpu(actions, self._gpu_device)
q = self._model(x)
q_subset = F.reshape(F.select_item(q, actions), (batch_size, 1))
y = y.reshape(batch_size, 1)
loss = F.sum(F.huber_loss(q_subset, y, 1.0))
self._model.cleargrads()
loss.backward()
self._optimizer.update()
self._loss_val = np.asscalar(cuda.to_cpu(loss.data))
# Keeps track of the number of train() calls
self._steps += 1
if self._steps % self._target_update_interval == 0:
# copy weights
self._target.copyparams(self._model)
def get(self, n, balance=True):
ind = np.random.permutation(self.data.shape[0])
if not balance:
d = self.data[ind[:n], :].astype(np.float32)
l = self.label[ind[:n]].astype(np.int32)
if gpu > -1:
d = cuda.to_gpu(d)
l = cuda.to_gpu(l)
return d, l
else:
cnt = [0]*10
m = 0
ret_data = np.zeros((n, self.data.shape[1])).astype(np.float32)
ret_label = np.zeros(n).astype(np.int32)
for i in range(self.data.shape[0]):
if cnt[self.label[ind[i]]] < n/10:
ret_data[m, :] = self.data[ind[i]]
ret_label[m] = self.label[ind[i]]
cnt[self.label[ind[i]]] += 1
m += 1
if m == n:
break
if gpu > -1:
ret_data = cuda.to_gpu(ret_data)
ret_label = cuda.to_gpu(ret_label)
return ret_data, ret_label
def convert_data(before_data, gpu): d = [] # story: 15 → [[3通常文(mem), 1質問文, 1答え],[6通常文(mem), 1質問文, 1答え],...] # 文の最長単語数を求める sentence_maxlen = max(max(len(s.sentence) for s in story) for story in before_data) for story in before_data: mem = np.ones((50, sentence_maxlen), dtype=np.int32) # mem: 50×sentence_maxlenのint32のゼロ行列 mem = -1 * mem i = 0 for sent in story: # # isinstance(object, class): objectがclassのインスタンスかどうか if isinstance(sent, data.Sentence): if i == 50: # The capacity of memory is restricted to the most 50 sentence(1ストーリーあたり50文まで記憶する) mem[0:i-1, :] = mem[1:i, :] # 一番古い情報をシフトする(1〜49→0〜48にシフト) # print mem[0,0:3] # 0行目の0〜2列を取得 # mem_length[0:i-1] = mem_length[1:i] i -= 1 mem[i, 0:len(sent.sentence)] = sent.sentence # mem_length[i] = len(sent.sentence) i += 1 elif isinstance(sent, data.Query): # question sentence query = np.ones(sentence_maxlen, dtype=np.int32) # 質問文ベクトル query = -1 * query query[0:len(sent.sentence)] = sent.sentence query = query[np.newaxis, :] # 1次元→2次元配列に変換 answer = np.array([sent.answer], dtype=np.int32) if gpu >= 0: # gpu d.append((cuda.to_gpu(mem),cuda.to_gpu(query),cuda.to_gpu(answer))) else: d.append((copy.deepcopy(mem),(query),answer)) return d
def test_backward_gpu(self):
self.rnn.to_gpu()
self.check_backward(
cuda.to_gpu(self.h),
[cuda.to_gpu(x) for x in self.xs],
cuda.to_gpu(self.gh),
[cuda.to_gpu(gy) for gy in self.gys])
def test_forward_gpu_nobias(self):
self.check_forward(cuda.to_gpu(self.x), cuda.to_gpu(self.W), None,
cuda.to_gpu(self.x.dot(self.W.T)))
def test_forward_gpu_no_cudnn(self):
self.check_forward(cuda.to_gpu(self.x), cuda.to_gpu(self.t), False)
def test_forward_no_reduction_gpu(self):
self.check_forward_no_reduction(cuda.to_gpu(self.x),
cuda.to_gpu(self.t))
def test_forward_gpu(self):
self.check_forward(cuda.to_gpu(self.x), cuda.to_gpu(self.t))
def test_backward_gpu(self):
x1 = cuda.to_gpu(self.x1)
x2 = cuda.to_gpu(self.x2)
g = cuda.to_gpu(self.g)
self.check_backward(x1, x2, g)
def test_backward_gpu(self):
print 'test_backward_gpu'
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.ksizes),
cuda.to_gpu(self.gy))
def test_forward_gpu(self):
print 'test_forward_gpu'
self.check_forward(cuda.to_gpu(self.x), cuda.to_gpu(self.ksizes))
def test_double_backward_gpu_nobias(self):
self.check_double_backward(cuda.to_gpu(self.x),
cuda.to_gpu(self.W), None,
cuda.to_gpu(self.gy), cuda.to_gpu(self.ggx),
cuda.to_gpu(self.ggW), None)
def test_backward_gpu_nobias(self):
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.W), None,
cuda.to_gpu(self.gy))
def test_forward_gpu(self):
self.check_forward(cuda.to_gpu(self.x), cuda.to_gpu(self.W),
cuda.to_gpu(self.b),
cuda.to_gpu(self.x.dot(self.W.T) + self.b))
def test_backward_gpu(self):
self.check_backward(cuda.to_gpu(self.x0), cuda.to_gpu(self.x1))
def test_double_backward_gpu(self):
self.check_double_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.W),
cuda.to_gpu(self.b), cuda.to_gpu(self.gy),
cuda.to_gpu(self.ggx),
cuda.to_gpu(self.ggW),
cuda.to_gpu(self.ggb))
def test_backward_gpu_im2col_nobias(self):
self.use_cudnn = 'never'
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.W), None,
cuda.to_gpu(self.gy))
def test_backward_gpu(self):
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.W),
cuda.to_gpu(self.b), cuda.to_gpu(self.gy))
def test_forward_gpu_non_contiguous(self):
self.check_forward(cuda.cupy.asfortranarray(cuda.to_gpu(self.x)))
def train_dcgan_labeled(gen, dis, epoch0=0):
o_gen = optimizers.Adam(alpha=0.0002, beta1=0.5)
o_dis = optimizers.Adam(alpha=0.0002, beta1=0.5)
o_gen.setup(gen)
o_dis.setup(dis)
o_gen.add_hook(chainer.optimizer.WeightDecay(0.00001))
o_dis.add_hook(chainer.optimizer.WeightDecay(0.00001))
zvis = (xp.random.uniform(-1, 1, (100, nz), dtype=np.float32))
for epoch in xrange(epoch0,n_epoch):
perm = np.random.permutation(n_train)
sum_l_dis = np.float32(0)
sum_l_gen = np.float32(0)
for i in xrange(0, n_train, batchsize):
print("{}/{}".format(i, n_train))
# discriminator
# 0: from dataset
# 1: from noise
#print "load image start ", i
x2 = np.zeros((batchsize, 3, 96, 96), dtype=np.float32)
for j in range(batchsize):
try:
rnd = np.random.randint(len(dataset))
rnd2 = np.random.randint(2)
img = np.asarray(Image.open(StringIO(dataset[rnd])).convert('RGB')).astype(np.float32).transpose(2, 0, 1)
if rnd2==0:
x2[j,:,:,:] = (img[:,:,::-1]-128.0)/128.0
else:
x2[j,:,:,:] = (img[:,:,:]-128.0)/128.0
except:
print 'read image error occured', fs[rnd]
#print "load image done"
# train generator
z = Variable(xp.random.uniform(-1, 1, (batchsize, nz), dtype=np.float32))
x = gen(z)
yl = dis(x)
L_gen = F.softmax_cross_entropy(yl, Variable(xp.zeros(batchsize, dtype=np.int32)))
L_dis = F.softmax_cross_entropy(yl, Variable(xp.ones(batchsize, dtype=np.int32)))
# train discriminator
x2 = Variable(cuda.to_gpu(x2))
yl2 = dis(x2)
L_dis += F.softmax_cross_entropy(yl2, Variable(xp.zeros(batchsize, dtype=np.int32)))
#print "forward done"
o_gen.zero_grads()
L_gen.backward()
o_gen.update()
o_dis.zero_grads()
L_dis.backward()
o_dis.update()
sum_l_gen += L_gen.data.get()
sum_l_dis += L_dis.data.get()
#print "backward done"
if i%image_save_interval==0:
pylab.rcParams['figure.figsize'] = (16.0,16.0)
pylab.clf()
vissize = 100
z = zvis
z[50:,:] = (xp.random.uniform(-1, 1, (50, nz), dtype=np.float32))
z = Variable(z)
x = gen(z, test=True)
x = x.data.get()
for i_ in range(100):
tmp = ((np.vectorize(clip_img)(x[i_,:,:,:])+1)/2).transpose(1,2,0)
pylab.subplot(10,10,i_+1)
pylab.imshow(tmp)
pylab.axis('off')
pylab.savefig('%s/vis_%d_%d.png'%(out_image_dir, epoch,i))
serializers.save_hdf5("%s/dcgan_model_dis_%d.h5"%(out_model_dir, epoch),dis)
serializers.save_hdf5("%s/dcgan_model_gen_%d.h5"%(out_model_dir, epoch),gen)
serializers.save_hdf5("%s/dcgan_state_dis_%d.h5"%(out_model_dir, epoch),o_dis)
serializers.save_hdf5("%s/dcgan_state_gen_%d.h5"%(out_model_dir, epoch),o_gen)
print 'epoch end', epoch, sum_l_gen/n_train, sum_l_dis/n_train
def test_backward_gpu(self):
self.check_backward(cuda.to_gpu(self.data), cuda.to_gpu(self.grad))
def test_forward_gpu_no_cudnn(self):
self.check_forward(cuda.to_gpu(self.x), 'never')
def test_backward_gpu(self):
self.check_backward([cuda.to_gpu(x) for x in self.data],
[cuda.to_gpu(x) for x in self.grads])
def test_backward_gpu_no_cudnn(self):
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy), 'never')
optimizer = optimizers.RMSprop(lr=args.learning_rate,
alpha=args.decay_rate,
eps=1e-8)
optimizer.setup(model)
whole_len = train_data.shape[0]
jump = whole_len / batchsize
epoch = 0
start_at = time.time()
cur_at = start_at
state = make_initial_state(n_units, batchsize=batchsize)
if args.gpu >= 0:
accum_loss = Variable(cuda.zeros(()))
for key, value in state.items():
value.data = cuda.to_gpu(value.data)
else:
accum_loss = Variable(np.zeros((), dtype=np.float32))
print 'going to train {} iterations'.format(jump * n_epochs)
for i in xrange(jump * n_epochs):
x_batch = np.array(
[train_data[(jump * j + i) % whole_len] for j in xrange(batchsize)])
y_batch = np.array([
train_data[(jump * j + i + 1) % whole_len] for j in xrange(batchsize)
])
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
def test_forward_gpu(self):
self.check_forward(cuda.to_gpu(self.data))
def test_backward_gpu(self):
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.indices),
cuda.to_gpu(self.g))
def test_forward_gpu(self):
self.check_forward([cuda.to_gpu(x) for x in self.data])
def test_sqnorm_array(self):
x = cuda.to_gpu(self.x)
a = cuda.to_gpu(self.a)
self.assertAlmostEqual(optimizer._sum_sqnorm(
[self.x, self.a, x, a]), 8.75 * 2)
def test_forward_gpu(self):
x1 = cuda.to_gpu(self.x1)
x2 = cuda.to_gpu(self.x2)
self.check_forward(x1, x2, self.y_expected)
def test_sqnorm_gpu(self):
x = cuda.to_gpu(self.x)
self.assertAlmostEqual(optimizer._sum_sqnorm([x]), 4.75)
def test_invlaid_gpu(self):
self.check_invalid(cuda.to_gpu(self.x), cuda.to_gpu(self.ind))
def test_backward_gpu(self):
self.link.to_gpu()
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy))
def test_sqnorm_scalar_gpu(self):
a = cuda.to_gpu(self.a)
self.assertAlmostEqual(optimizer._sum_sqnorm([a]), 4)