def _masked_column_median(arr, masked_value): """Compute the median of each column in the 2D array arr, ignoring any instances of masked_value""" mask = _get_mask(arr, masked_value) if arr.size == 0: return cp.full(arr.shape[1], cp.nan) arr_sorted = arr.copy() if not cp.isnan(masked_value): # If nan is not the missing value, any column with nans should # have a median of nan nan_cols = cp.any(cp.isnan(arr), axis=0) arr_sorted[mask] = cp.nan else: nan_cols = cp.full(arr.shape[1], False) # nans are always sorted to end of array arr_sorted = cp.sort(arr_sorted, axis=0) count_missing_values = mask.sum(axis=0) # Ignore missing values in determining "halfway" index of sorted # array n_elems = arr.shape[0] - count_missing_values # If no elements remain after removing missing value, median for # that colum is nan nan_cols = cp.logical_or(nan_cols, n_elems <= 0) col_index = cp.arange(arr_sorted.shape[1]) median = (arr_sorted[cp.floor_divide(n_elems - 1, 2), col_index] + arr_sorted[cp.floor_divide(n_elems, 2), col_index]) / 2 median[nan_cols] = cp.nan return median
def my_sum(S1, sig, varargin=None): # returns a running sum applied sequentially across a choice of dimensions and bin sizes # S1 is the matrix to be filtered # sig is either a scalar or a sequence of scalars, one for each axis to be filtered. # it's the plus/minus bin length for the summing filter # varargin can be the dimensions to do filtering, if len(sig) != x.shape # if sig is scalar and no axes are provided, the default axis is 2 idims = 1 if varargin is not None: idims = varargin idims = _make_vect(idims) if _is_vect(idims) and _is_vect(sig): sigall = sig else: sigall = np.tile(sig, len(idims)) for sig, idim in zip(sigall, idims): Nd = S1.ndim S1 = cp.transpose(S1, [idim] + list(range(0, idim)) + list(range(idim + 1, Nd))) dsnew = S1.shape S1 = cp.reshape(S1, (S1.shape[0], -1), order='F') dsnew2 = S1.shape S1 = cp.concatenate((cp.full( (sig, dsnew2[1]), 0), S1, cp.full((sig, dsnew2[1]), 0)), axis=0) Smax = S1[:dsnew2[0], :] for j in range(1, 2 * sig + 1): Smax = Smax + S1[j:j + dsnew2[0], :] S1 = cp.reshape(Smax, dsnew, order='F') S1 = cp.transpose( S1, list(range(1, idim + 1)) + [0] + list(range(idim + 1, Nd))) return S1
def _compute_bispectrum(kind, kn, kcoords, nsamples, sample_thresh, ndim, dim, shape, double, progress, exclude, blocksize, compute_point, *ffts): knyq = max(shape) // 2 shape = [cp.int16(Ni) for Ni in shape] if double: float, complex = cp.float64, cp.complex128 else: float, complex = cp.float32, cp.complex64 mempool = cp.get_default_memory_pool() pinned_mempool = cp.get_default_pinned_memory_pool() bispec = cp.full((dim, dim), cp.nan + 1.j * cp.nan, dtype=complex) binorm = cp.full((dim, dim), cp.nan, dtype=float) omega = np.zeros((dim, dim), dtype=np.int64) counts = cp.zeros((dim, dim), dtype=cp.int64) for i in range(dim): k1 = kn[i] k1ind = kind[i] nk1 = k1ind.size for j in range(i + 1): k2 = kn[j] if exclude and k1 + k2 > knyq: continue k2ind = kind[j] nk2 = k2ind.size nsamp = nsamples[i, j] nsamp = int(nsamp) if type(nsamp) is np.int64 \ else max(int(nsamp*nk1*nk2), 1) if nsamp < nk1 * nk2 or nsamp > sample_thresh: samp = cp.random.randint(0, nk1 * nk2, size=nsamp, dtype=cp.int64) count = nsamp else: samp = cp.arange(nk1 * nk2, dtype=cp.int64) count = nk1 * nk2 tpb = blocksize bpg = (count + (tpb - 1)) // tpb bispecbuf = cp.zeros(count, dtype=complex) binormbuf = cp.zeros(count, dtype=float) countbuf = cp.zeros(count, dtype=cp.int16) compute_point( (bpg, ), (tpb, ), (k1ind, k2ind, *kcoords, cp.int64(nk1), cp.int64(nk2), *shape, samp, cp.int64(count), bispecbuf, binormbuf, countbuf, *ffts)) N = countbuf.sum() value = bispecbuf.sum() norm = binormbuf.sum() bispec[i, j], bispec[j, i] = value, value binorm[i, j], binorm[j, i] = norm, norm omega[i, j], omega[j, i] = nk1 * nk2, nk1 * nk2 counts[i, j], counts[j, i] = N, N del bispecbuf, binormbuf, countbuf, samp mempool.free_all_blocks() pinned_mempool.free_all_blocks() if progress: _printProgressBar(i, dim - 1) return bispec.get(), binorm.get(), omega, counts.get()
def ts_rank(x, window): if window > len(x): return cp.full(len(x), cp.nan) # 只排名了,没有除总数形成分位 def _rank(x): x = cp.where(cp.isinf(x) | cp.isnan(x), cp.inf, x) # 此方式,只一次排序,对于长数组更有优势 temp = x.argsort() ranks = cp.empty_like(temp) ranks[temp] = cp.arange(len(x)) ranks = ranks.astype(float) # 将nan和inf的位置恢复为nan,不参与rank ranks = cp.where(cp.isinf(x), cp.nan, ranks) #ranks[cp.isinf(x)] = cp.nan # 返回x的最后一个元素的排名 return (ranks + 1)[-1] x_rolling_array = cp_rolling_window(x, window) pre_fix = cp.full(window - 1, cp.nan) result = cp.zeros(x_rolling_array.shape[0]) for i in range(x_rolling_array.shape[0]): result[i] = _rank(x_rolling_array[i]) return cp.concatenate((pre_fix, result))
def hit(self, r: RayList, t_min: float, t_max: Union[float, cp.ndarray]) \ -> HitRecordList: if isinstance(t_max, (int, float, cp.floating)): t_max_list = cp.full(len(r), t_max, cp.float32) else: t_max_list = t_max oc: Vec3List = r.origin() - self.center a: cp.ndarray = r.direction().length_squared() half_b: cp.ndarray = oc @ r.direction() c: cp.ndarray = oc.length_squared() - self.radius**2 discriminant_list: cp.ndarray = half_b**2 - a*c discriminant_condition = discriminant_list > 0 if not discriminant_condition.any(): return HitRecordList.new(len(r)).set_compress_info(None) # Calculate t positive_discriminant_list = ( discriminant_list * discriminant_condition ) root = cp.sqrt(positive_discriminant_list) non_zero_a = a - (a == 0) t_0 = (-half_b - root) / non_zero_a t_1 = (-half_b + root) / non_zero_a # Choose t t_0_condition = ( (t_min < t_0) & (t_0 < t_max_list) & discriminant_condition ) t_1_condition = ( (t_min < t_1) & (t_1 < t_max_list) & (~t_0_condition) & discriminant_condition ) t = cp.where(t_0_condition, t_0, 0) t = cp.where(t_1_condition, t_1, t) # Compression condition = t > 0 full_rate = condition.sum() / len(t) if full_rate > 0.5: idx = None else: idx = cp.where(condition)[0] t = t[idx] r = RayList( Vec3List(r.orig.get_ndarray(idx)), Vec3List(r.dir.get_ndarray(idx)) ) # Wrap up result point = r.at(t) outward_normal = (point - self.center) / self.radius result = HitRecordList( point, t, cp.full(len(r), self.material.idx, dtype=cp.int32) ).set_face_normal(r, outward_normal).set_compress_info(idx) return result
def __make_velocity_density_field(self, wall_area, sound_speed, density): density_arr = cp.full((self.width, self.height), density["air"], dtype=cp.float32) density_arr[wall_area] = density["acrylic"] velocity_arr = cp.full((self.width, self.height), sound_speed["air"], dtype=cp.float32) velocity_arr[wall_area] = sound_speed["acrylic"] return velocity_arr, density_arr
def make_labels(self, D): if self.device >= 0: for d in D: self.label_true.append(cp.full(d.shape, 1, dtype=cp.float32)) self.label_false.append(cp.full(d.shape, 0, dtype=cp.float32)) else: for d in D: self.label_true = np.full(d.shape, 1, dtype=np.float32) self.label_false = np.full(d.shape, 0, dtype=np.float32)
def ts_sma(x, window): if window > len(x): return cp.full(len(x), cp.nan) pre_fix = cp.full(window - 1, cp.nan) x = cp.where(cp.isinf(x), cp.nan, x) rolling_array = cp_rolling_window(x, window) result = cp.mean(rolling_array, axis=1) return cp.concatenate((pre_fix, result))
def test_triangular_for_invalid_params(self, param_dtype): left = cupy.full(self.left_shape, 1, dtype=param_dtype) mode = cupy.full(self.mode_shape, 0, dtype=param_dtype) right = cupy.full(self.right_shape, 2, dtype=param_dtype) with self.assertRaises(ValueError): _distributions.triangular(left, mode, right, size=self.shape, dtype=self.dtype) left = cupy.full(self.left_shape, -2, dtype=param_dtype) mode = cupy.full(self.mode_shape, 0, dtype=param_dtype) right = cupy.full(self.right_shape, -1, dtype=param_dtype) with self.assertRaises(ValueError): _distributions.triangular(left, mode, right, size=self.shape, dtype=self.dtype) left = cupy.full(self.left_shape, 0, dtype=param_dtype) mode = cupy.full(self.mode_shape, 0, dtype=param_dtype) right = cupy.full(self.right_shape, 0, dtype=param_dtype) with self.assertRaises(ValueError): _distributions.triangular(left, mode, right, size=self.shape, dtype=self.dtype)
def test_noncentral_chisquare_for_invalid_params(self, param_dtype): df = cupy.full(self.df_shape, -1, dtype=param_dtype) nonc = cupy.full(self.nonc_shape, 1, dtype=param_dtype) with pytest.raises(ValueError): _distributions.noncentral_chisquare( df, nonc, size=self.shape, dtype=self.dtype) df = cupy.full(self.df_shape, 1, dtype=param_dtype) nonc = cupy.full(self.nonc_shape, -1, dtype=param_dtype) with pytest.raises(ValueError): _distributions.noncentral_chisquare( df, nonc, size=self.shape, dtype=self.dtype)
def ts_max(x, window): if window > len(x): return cp.full(len(x), cp.nan) # 把空值填充为-inf x = cp.where(cp.isinf(x) | cp.isnan(x), -cp.inf, x) prefix = cp.full(window - 1, cp.nan) x_rolling_array = cp_rolling_window(x, window) result = cp.max(x_rolling_array, axis=1) # 结果中如果存在-inf,说明此window均为空,返回nan result = result.astype(float) result = cp.where(cp.isinf(result), cp.nan, result) return cp.concatenate((prefix, result))
def delay(x, period): # window是> if abs(period) >= len(x): return cp.full(len(x), cp.nan) #period 和 window的区别,这里不再减1 prefix = cp.full(abs(period), cp.nan) # 只有float才能加cp.nan, 否则int就会变成-2147483648 result = cp.roll(x, period).astype(float) if period >= 0: result[:period] = prefix else: result[period:] = prefix return result
def ts_covariance(x, y, window): if x.shape[0] != y.shape[0]: raise ValueError("The length of x and y must be the same") if window > len(x): return cp.full(len(x), cp.nan) pre_fix = cp.full(window - 1, cp.nan) x_rolling_array = cp_rolling_window(x, window) y_rolling_array = cp_rolling_window(y, window) result = cp.zeros(x_rolling_array.shape[0]) for i in range(x_rolling_array.shape[0]): result[i] = covariance(x_rolling_array[i], y_rolling_array[i]) return cp.concatenate((pre_fix, result))
def __setitem__(self, key, value): if len(self) == 0: self._hashtable_keys = cp.full(key.shape[0] + 1, _EMPTY_KEY, dtype=cp.int32) self._hashtable_values = cp.full(key.shape[0] + 1, self.default, dtype=value.dtype) else: raise NotImplementedError( 'Trying to update CudaDict, not yet supported') cuda_hashtable_insert[self.tpb, self.bpg](key, value, self._hashtable_keys, self._hashtable_values)
def initialize_sparse_weights(self, density, init_method='Xavier', bias_constant=None): """ This initializes all weights, I might add a module to initialize based on a list of values(normal SDs), one for each layer, but for now I am using Xavier initialization for everything.""" print('Initalizing sparse weights') for i in range(len(self._layers)): if i == 0: shape = (self._layers[i]._size, self._input_size) else: shape = (self._layers[i]._size, self._layers[i - 1]._size) if init_method == 'Xavier': self._layers[i]._weights = csr_matrix( scipy.sparse.random(shape[0], shape[1], density=density, format='csr', dtype=np.float32, data_rvs=np.random.randn) * np.sqrt(3. / sum(shape))) self._layers[i]._biases = cp.full(self._layers[i]._size, bias_constant) # This is just rescaling the initialization by the density. if init_method == 'Xavier_2': self._layers[i]._weights = csr_matrix( scipy.sparse.random(shape[0], shape[1], density=density, format='csr', dtype=np.float32, data_rvs=np.random.randn) * np.sqrt(3. / sum(shape)) / density) self._layers[i]._biases = cp.full(self._layers[i]._size, bias_constant) if type(init_method) == float: self._layers[i]._weights = csr_matrix( scipy.sparse.random(shape[0], shape[1], density=density, format='csr', dtype=np.float32, data_rvs=np.random.randn) * init_method) self._layers[i]._biases = cp.full(self._layers[i]._size, bias_constant) for layer in self.layers: layer.get_coordinates() return
def ts_argmin(x, window): if window > len(x): return cp.full(len(x), cp.nan) # 将nan及-inf填充为inf x = cp.where(cp.isinf(x) | cp.isnan(x), cp.inf, x) prefix = cp.full(window - 1, cp.nan) x_rolling_array = cp_rolling_window(x, window) result = cp.argmin(x_rolling_array, axis=1) # 找到window中全为-inf的情况,填充为nan result = result.astype(float) result = cp.where(cp.isinf(x_rolling_array).all(axis=1), cp.nan, result) result += 1 return cp.concatenate((prefix, result))
def test_normalization(): """Test that `match_template` gives the correct normalization. Normalization gives 1 for a perfect match and -1 for an inverted-match. This test adds positive and negative squares to a zero-array and matches the array with a positive template. """ n = 5 N = 20 ipos, jpos = (2, 3) ineg, jneg = (12, 11) image = cp.full((N, N), 0.5) image[ipos:ipos + n, jpos:jpos + n] = 1 image[ineg:ineg + n, jneg:jneg + n] = 0 # white square with a black border template = cp.zeros((n + 2, n + 2)) template[1:1 + n, 1:1 + n] = 1 result = match_template(image, template) # get the max and min results. sorted_result = cp.argsort(result.ravel()) iflat_min = cp.asnumpy(sorted_result[0]) iflat_max = cp.asnumpy(sorted_result[-1]) min_result = np.unravel_index(iflat_min, result.shape) max_result = np.unravel_index(iflat_max, result.shape) # shift result by 1 because of template border assert np.all((np.array(min_result) + 1) == (ineg, jneg)) assert np.all((np.array(max_result) + 1) == (ipos, jpos)) assert cp.allclose(result.ravel()[iflat_min], -1) assert cp.allclose(result.ravel()[iflat_max], 1)
def _prepend_const(narray, pad_amount, value, axis=-1): if pad_amount == 0: return narray padshape = tuple([x if i != axis else pad_amount for i, x in enumerate(narray.shape)]) return cupy.concatenate((cupy.full(padshape, value, narray.dtype), narray), axis=axis)
def _append_reflect(narray, pad_amount, value, axis=-1): if pad_amount == 0: return narray padshape = tuple(x if i != axis else pad_amount for i, x in enumerate(narray.shape)) return cupy.concatenate((narray, cupy.full(padshape, value, narray.dtype)), axis=axis)
def _validate_n_bins(self, n_features): """Returns n_bins_, the number of bins per feature. """ orig_bins = self.n_bins if isinstance(orig_bins, numbers.Number): if not isinstance(orig_bins, numbers.Integral): raise ValueError("{} received an invalid n_bins type. " "Received {}, expected int." .format(KBinsDiscretizer.__name__, type(orig_bins).__name__)) if orig_bins < 2: raise ValueError("{} received an invalid number " "of bins. Received {}, expected at least 2." .format(KBinsDiscretizer.__name__, orig_bins)) return np.full(n_features, orig_bins, dtype=int) n_bins = check_array(orig_bins, dtype=np.int, copy=True, ensure_2d=False) if n_bins.ndim > 1 or n_bins.shape[0] != n_features: raise ValueError("n_bins must be a scalar or array " "of shape (n_features,).") bad_nbins_value = (n_bins < 2) | (n_bins != orig_bins) violating_indices = np.where(bad_nbins_value)[0] if violating_indices.shape[0] > 0: indices = ", ".join(str(i) for i in violating_indices) raise ValueError("{} received an invalid number " "of bins at indices {}. Number of bins " "must be at least 2, and must be an int." .format(KBinsDiscretizer.__name__, indices)) return n_bins
def __init__(self, w, s): self.s = s self.w = w self.W = cp.random.normal(0, 0.1, w * s).astype(DT).reshape(s, w) self.b = cp.full((s, 1), 0.5, dtype=DT) self.dW = cp.zeros((self.s, self.w), dtype=DT) self.db = cp.zeros((self.s, 1), dtype=DT)
def __init__(self, state_size, state_transfer, measurement_size, measurement_transfer, time_step, sigma_spread, difference=lambda x, y: x - y): self.x_hat = np.zeros(state_size) self.Nx = state_size self.P = np.eye(state_size) self.F = state_transfer self.Nz = measurement_size self.R = np.eye(measurement_size) self.H = measurement_transfer self.Q = np.eye(state_size) self.kappa = sigma_spread self.weights = np.full(2 * state_size + 1, .5 / (state_size + sigma_spread)) self.weights[0] = sigma_spread / (state_size + sigma_spread) self.difference = difference self.num_sp = 2 * state_size + 1 self.sp = np.zeros((self.num_sp, self.Nx)) self.sp_f = np.zeros((self.num_sp, self.Nx)) self.sp_h = np.zeros((self.num_sp, self.Nz)) self.dt = time_step
def decay_linear(x, window): if window > len(x): return cp.full(len(x), cp.nan) prefix = cp.full(window - 1, cp.nan) x = cp.where(cp.isinf(x), cp.nan, x) x_rolling_array = cp_rolling_window(x, window) # 等差数列求和公式 denominator = (window + 1) * window / 2 # window各元素权重 weight = (cp.arange(window) + 1) * 1.0 / denominator result = cp.zeros(x_rolling_array.shape[0]) for i in range(x_rolling_array.shape[0]): result[i] = x_rolling_array[i].dot(weight) return cp.concatenate((prefix, result))
def get_W_matrix(self): bias = self.w[0] W = cp.full(self.filter_shape, cp.nan) for row_number, i in enumerate( range(1, len(self.w), self.filter_shape[1])): W[row_number, :] = self.w[i:i + self.filter_shape[1]] return W, bias
def _assign_uniform_weight(input_graph: cugraph.Graph, default_value: Any) -> cugraph.Graph: g = cugraph.DiGraph() if input_graph.is_directed() else cugraph.Graph() if input_graph.edgelist is not None: # TODO avoid copying the 'src' and 'dst' columns twice gdf = input_graph.view_edge_list().copy() gdf["weight"] = cupy.full(len(gdf), default_value) g.from_cudf_edgelist(gdf, source="src", destination="dst", edge_attr="weight") else: offset_col, index_col, _ = g.view_adj_list() value_col = cudf.Series(cupy.full(len(offset_col), default_value)) g.from_cudf_adjlist(offset_col, index_col, value_col) return g
def inject_error(weight, mask0, mask1, num_bits=32): if num_bits == 32: dtype = cp.uint32 ftype = cp.float32 shape = weight.shape weight_flatten = cp.ravel(weight).view(dtype) mask0, mask0_bit = mask0 mask1, mask1_bit = mask1 zero = cp.zeros(1, dtype=dtype) if (mask0.__len__() is not 0) or (mask1.__len__() is not 0): for b in range(num_bits): fault = cp.full(weight_flatten.size, 2**b, dtype=dtype) bit_loc0 = cp.where(mask0_bit == b, mask0, zero).nonzero()[0] bit_loc1 = cp.where(mask1_bit == b, mask1, zero).nonzero()[0] uniform0 = cp.zeros(weight_flatten.size, dtype=dtype) uniform1 = cp.zeros(weight_flatten.size, dtype=dtype) # Inject bit error if bit_loc0.__len__() > 0: cp.put(uniform0, mask0[bit_loc0], fault) cp.put(uniform1, mask1[bit_loc1], fault) # Stuck at 0 not_mask0 = cp.invert(uniform0) weight_flatten = cp.bitwise_and(weight_flatten, not_mask0) # Stuck at 1 weight_flatten = cp.bitwise_or(weight_flatten, uniform1) weight_float = weight_flatten.view(ftype) return cp.reshape(weight_float, shape) else: return weight
def _prepend_const(narray, pad_amount, value, axis=-1): if pad_amount == 0: return narray padshape = tuple(x if i != axis else pad_amount for i, x in enumerate(narray.shape)) return cupy.concatenate((cupy.full(padshape, value, narray.dtype), narray), axis=axis)
def ts_correlation(x, y, window): if x.shape[0] != y.shape[0]: raise ValueError("The length of x and y must be the same") # window是> if window > len(x): return cp.full(len(x), cp.nan) pre_fix = cp.full(window - 1, cp.nan) x_array = cp_rolling_window(x, window) y_array = cp_rolling_window(y, window) # 这里没有使用reuslt = [], 考虑并行计算append可能会导致结果乱序 result = cp.zeros(x_array.shape[0]) for i in range(x_array.shape[0]): result[i] = correlation(x_array[i], y_array[i]) return cp.concatenate((pre_fix, result))
def test(self): # Elementwise a = cupy.full((1, self.size), 7, dtype=cupy.int8) # Reduction result = a.sum(axis=0, dtype=cupy.int8) # Explicitly specify the dtype to absorb Linux/Windows difference. assert result.sum(dtype=cupy.int64) == self.size * 7
def full( shape: Union[int, Tuple[int, ...]], fill_value: Union[int, float], *, dtype: Optional[Dtype] = None, device: Optional[Device] = None, ) -> Array: """ Array API compatible wrapper for :py:func:`np.full <numpy.full>`. 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(shape, 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") return Array._new(res)
def resize(a, new_shape): """Return a new array with the specified shape. If the new array is larger than the original array, then the new array is filled with repeated copies of ``a``. Note that this behavior is different from a.resize(new_shape) which fills with zeros instead of repeated copies of ``a``. Args: a (array_like): Array to be resized. new_shape (int or tuple of int): Shape of resized array. Returns: cupy.ndarray: The new array is formed from the data in the old array, repeated if necessary to fill out the required number of elements. The data are repeated in the order that they are stored in memory. .. seealso:: :func:`numpy.resize` """ if numpy.isscalar(a): return cupy.full(new_shape, a) a = cupy.asarray(a) if a.size == 0: return cupy.zeros(new_shape, dtype=a.dtype) out = cupy.empty(new_shape, a.dtype) _resize_kernel(a, a.size, out) return out
def full(shape, fill_value, dtype=numpy.float32, stream=None): """Creates a constant-filled cupy.ndarray object. Args: shape (tuple of ints): The shape of array. fill_value: Constant to fill the array by. dtype (numpy.dtype): Element type. stream (cupy.cuda.Stream): CUDA stream. Returns: cupy.ndarray: Constant-filled GPU array allocated by the memory pool. """ warnings.warn("chainer.cuda.full is deprecated. Use cupy.full instead.", DeprecationWarning) check_cuda_available() assert stream is None return cupy.full(shape, fill_value, dtype=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)