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)