def full_like(array, fill_value, stream=None):
"""Creates a constant-filled cupy.ndarray object like the given array.
Args:
array (cupy.ndarray or numpy.ndarray): Base array.
fill_value: Constant value to fill the array by.
stream (cupy.cuda.Stream): CUDA stream.
Returns:
cupy.ndarray: Constant-filled array.
"""
warnings.warn("chainer.cuda.full_like is deprecated. Use cupy.full_like instead.", DeprecationWarning)
check_cuda_available()
assert stream is None
if isinstance(array, cupy.ndarray):
return cupy.full_like(array, fill_value)
return cupy.full(array.shape, fill_value, dtype=array.dtype)
def full_like(array, fill_value, stream=None):
"""Creates a constant-filled cupy.ndarray object like the given array.
Args:
array (cupy.ndarray or numpy.ndarray): Base array.
fill_value: Constant value to fill the array by.
stream (cupy.cuda.Stream): CUDA stream.
Returns:
cupy.ndarray: Constant-filled array.
"""
warnings.warn(
'chainer.cuda.full_like is deprecated. Use cupy.full_like instead.',
DeprecationWarning)
check_cuda_available()
assert stream is None
if isinstance(array, cupy.ndarray):
return cupy.full_like(array, fill_value)
return cupy.full(array.shape, fill_value, dtype=array.dtype)
def gradient_norm(model, X, y, K, sw=None):
if sw is None:
sw = cp.ones(X.shape[0])
else:
sw = cp.atleast_1d(cp.array(sw, dtype=np.float64))
X = cp.array(X, dtype=np.float64)
y = cp.array(y, dtype=np.float64)
K = cp.array(K, dtype=np.float64)
betas = cp.array(as_type('cupy', model.dual_coef_),
dtype=np.float64).reshape(y.shape)
# initialise to NaN in case below loop has 0 iterations
grads = cp.full_like(y, np.NAN)
for i, (beta, target, current_alpha) in (
enumerate(zip(betas.T, y.T, model.alpha))):
grads[:, i] = 0.0
grads[:, i] = -cp.dot(K * sw, target)
grads[:, i] += cp.dot(cp.dot(K * sw, K), beta)
grads[:, i] += cp.dot(K * current_alpha, beta)
return linalg.norm(grads)
def test_full_like_reshape_cupy_only(self, dtype):
a = testing.shaped_arange((2, 3, 4), cupy, dtype)
b = cupy.full_like(a, 1, shape=self.shape)
c = cupy.full(self.shape, 1, dtype=dtype)
testing.assert_array_equal(b, c)
def test_full_like_subok(self):
a = cupy.ndarray((2, 3, 4))
with pytest.raises(TypeError):
cupy.full_like(a, 1, subok=True)
def constant(self, data, dx, dy):
return cp.full_like(data, self.const, dtype=self.dtype)
See its docstring for more information.
"""
from ._array_object import Array
_check_valid_dtype(dtype)
if device is not None and not isinstance(device, _Device):
raise ValueError(f"Unsupported device {device!r}")
if device is None:
device = _Device() # current device
if isinstance(fill_value, Array) and fill_value.ndim == 0:
fill_value = fill_value._array
prev_device = runtime.getDevice()
try:
runtime.setDevice(device.id)
res = np.full_like(x._array, fill_value, dtype=dtype)
finally:
runtime.setDevice(prev_device)
if res.dtype not in _all_dtypes:
# This will happen if the fill value is not something that NumPy
# coerces to one of the acceptable dtypes.
raise TypeError("Invalid input to full_like")
return Array._new(res)
def linspace(
start: Union[int, float],
stop: Union[int, float],
/,
num: int,
*,
def main():
try:
os.mkdir(args.snapshot_path)
except:
pass
dataset = gqn.data.Dataset(args.dataset_path)
sampler = gqn.data.Sampler(dataset)
iterator = gqn.data.Iterator(sampler, batch_size=args.batch_size)
hyperparams = HyperParameters()
model = Model(hyperparams)
model.to_gpu()
optimizer = Optimizer(model.parameters)
for iteration in range(args.training_steps):
for batch_index, data_indices in enumerate(iterator):
# shape: (batch, views, height, width, channels)
# range: [-1, 1]
images, viewpoints = dataset[data_indices]
image_size = images.shape[2:4]
total_views = images.shape[1]
# sample number of views
num_views = random.choice(range(total_views))
query_index = random.choice(range(total_views))
if num_views > 0:
observed_images = images[:, :num_views]
observed_viewpoints = viewpoints[:, :num_views]
# (batch, views, height, width, channels) -> (batch * views, height, width, channels)
observed_images = observed_images.reshape((
args.batch_size * num_views, ) + observed_images.shape[2:])
observed_viewpoints = observed_viewpoints.reshape(
(args.batch_size * num_views, ) +
observed_viewpoints.shape[2:])
# (batch * views, height, width, channels) -> (batch * views, channels, height, width)
observed_images = observed_images.transpose((0, 3, 1, 2))
# transfer to gpu
observed_images = chainer.cuda.to_gpu(observed_images)
observed_viewpoints = chainer.cuda.to_gpu(observed_viewpoints)
r = model.representation_network.compute_r(
observed_images, observed_viewpoints)
# (batch * views, channels, height, width) -> (batch, views, channels, height, width)
r = r.reshape((args.batch_size, num_views) + r.shape[1:])
# sum element-wise across views
r = cf.sum(r, axis=1)
else:
r = np.zeros((args.batch_size, hyperparams.channels_r) +
hyperparams.chrz_size,
dtype="float32")
r = chainer.cuda.to_gpu(r)
query_images = images[:, query_index]
query_viewpoints = viewpoints[:, query_index]
# (batch * views, height, width, channels) -> (batch * views, channels, height, width)
query_images = query_images.transpose((0, 3, 1, 2))
# transfer to gpu
query_images = chainer.cuda.to_gpu(query_images)
query_viewpoints = chainer.cuda.to_gpu(query_viewpoints)
hg_0 = xp.zeros((
args.batch_size,
hyperparams.channels_chz,
) + hyperparams.chrz_size,
dtype="float32")
cg_0 = xp.zeros((
args.batch_size,
hyperparams.channels_chz,
) + hyperparams.chrz_size,
dtype="float32")
u_0 = xp.zeros((
args.batch_size,
hyperparams.generator_u_channels,
) + image_size,
dtype="float32")
he_0 = xp.zeros((
args.batch_size,
hyperparams.channels_chz,
) + hyperparams.chrz_size,
dtype="float32")
ce_0 = xp.zeros((
args.batch_size,
hyperparams.channels_chz,
) + hyperparams.chrz_size,
dtype="float32")
sigma_t = 1.0
loss_kld = 0
he_l = he_0
ce_l = ce_0
hg_l = hg_0
cg_l = cg_0
u_l = u_0
for l in range(hyperparams.generator_total_timestep):
# zg_l = model.generation_network.sample_z(hg_l)
# hg_l, cg_l, u_l = model.generation_network.forward_onestep(
# hg_0, cg_0, u_0, zg_l, query_viewpoints, r)
# x = model.generation_network.sample_x(u_l)
he_next, ce_next = model.inference_network.forward_onestep(
hg_l, he_l, ce_l, query_images, query_viewpoints, r)
mu_z_q = model.inference_network.compute_mu_z(he_l)
ze_l = cf.gaussian(mu_z_q, xp.zeros_like(mu_z_q))
hg_next, cg_next, u_next = model.generation_network.forward_onestep(
hg_l, cg_l, u_l, ze_l, query_viewpoints, r)
mu_z_p = model.generation_network.compute_mu_z(hg_l)
kld = gqn.nn.chainer.functions.gaussian_kl_divergence(
mu_z_q, mu_z_p)
loss_kld += cf.mean(kld)
hg_l = hg_next
cg_l = cg_next
u_l = u_next
he_l = he_next
ce_l = ce_next
mu_x = model.generation_network.compute_mu_x(u_l)
negative_log_likelihood = gqn.nn.chainer.functions.gaussian_negative_log_likelihood(
query_images, mu_x, xp.full_like(mu_x, math.log(sigma_t)))
loss_nll = cf.mean(negative_log_likelihood)
loss = loss_nll + loss_kld
model.cleargrads()
loss.backward()
optimizer.step()
print("Iteration {}: {} / {} - loss: {}".format(
iteration + 1, batch_index + 1, len(iterator),
float(loss.data)))
chainer.serializers.save_hdf5(
os.path.join(args.snapshot_path, "model.hdf5"), model.parameters)
def test_full_like_subok(self):
a = cupy.ndarray((2, 3, 4))
return cupy.full_like(a, 1)
