def test_ixor_invalid_dtypes(device, dtypes): (in_dtype1, in_dtype2), _ = dtypes shape = (2, 3) a = chainerx.array(array_utils.uniform(shape, in_dtype1)) b = chainerx.array(array_utils.uniform(shape, in_dtype2)) with pytest.raises(chainerx.DtypeError): a ^= b
def generate_inputs(self): h_shape = (self.n_layers, self.batches[0], self.hidden_size) dtype = self.in_dtypes[0] h = array_utils.uniform(h_shape, dtype) c = array_utils.uniform(h_shape, dtype) in_size = self.input_size out_size = self.hidden_size xs = [ array_utils.uniform((self.batches[b], in_size), dtype) for b in range(len(self.batches)) ] def w_in(i, j): return in_size if i == 0 and j < 4 else out_size inputs = [] inputs.append(h) inputs.append(c) for i in range(len(self.batches)): inputs.append(xs[i]) for n in range(self.n_layers): for i in range(8): inputs.append( array_utils.uniform((out_size, w_in(n, i)), dtype)) for i in range(8): inputs.append(array_utils.uniform((out_size, ), dtype)) return tuple(inputs)
def generate_inputs(self): (x_dtype, y_dtype) = self.in_dtypes x = array_utils.uniform(self.x_shape, x_dtype) y = array_utils.uniform(self.y_shape, y_dtype) condition = numpy.random.uniform(0, 1, size=self.cond_shape) self.condition = (condition > 0.5).astype(self.condition_dtype) return (x, y)
def test_minimum_invalid_dtypes(device, dtype): shape = (3, 2) bool_array = chainerx.array(array_utils.uniform(shape, 'bool_')) numeric_array = chainerx.array(array_utils.uniform(shape, dtype)) with pytest.raises(chainerx.DtypeError): chainerx.minimum(bool_array, numeric_array) with pytest.raises(chainerx.DtypeError): chainerx.minimum(numeric_array, bool_array)
def generate_inputs(self): c_shape = self.c_shape x_shape = self.x_shape c_dtype, x_dtype = self.in_dtypes c = array_utils.uniform(c_shape, c_dtype) x = array_utils.uniform(x_shape, x_dtype) return c, x
def test_floordiv_invalid_dtypes(device, dtypes, is_module): (in_dtype1, in_dtype2), _ = dtypes shape = (2, 3) a = chainerx.array(array_utils.uniform(shape, in_dtype1)) b = chainerx.array(array_utils.uniform(shape, in_dtype2)) with pytest.raises(chainerx.DtypeError): if is_module: a // b else: chainerx.floor_divide(a, b)
def test_sub_invalid_dtypes(device, dtypes, is_module): (in_dtype1, in_dtype2), _ = dtypes shape = (2, 3) a = chainerx.array(array_utils.uniform(shape, in_dtype1)) b = chainerx.array(array_utils.uniform(shape, in_dtype2)) with pytest.raises(chainerx.DtypeError): if is_module: a - b else: chainerx.subtract(a, b)
def generate_inputs(self): dst_dtype, src_dtype = self.in_dtypes dst = array_utils.uniform(self.dst_shape, dst_dtype) src = array_utils.uniform(self.src_shape, src_dtype) where = array_utils.uniform( self.where_shape if self.where_shape is not None else (1,), 'float32', 0, 1) > 0.5 return dst, src, where
def generate_inputs(self): x_shape = self.x_shape w_shape = self.w_shape b_shape = self.b_shape dtype = self.dtype x = array_utils.uniform(x_shape, dtype) w = array_utils.uniform(w_shape, dtype) if b_shape in (None, Unspecified): return x, w else: b = array_utils.uniform(b_shape, dtype) return x, w, b
def generate_inputs(self): x_shape = self.x_shape w_shape = self.w_shape b_shape = self.b_shape if len(self.in_dtypes) == 3: x_dtype, w_dtype, b_dtype = self.in_dtypes else: (x_dtype, w_dtype), b_dtype = self.in_dtypes, None x = array_utils.uniform(x_shape, x_dtype) w = array_utils.uniform(w_shape, w_dtype) if b_shape is None: return x, w else: b = array_utils.uniform(b_shape, b_dtype) return x, w, b
def generate_inputs(self): dtype = self.dtype if self.input_lhs == 'random': a = array_utils.uniform(self.shape, dtype) elif isinstance(self.input_lhs, (bool, int, float)): a = numpy.full(self.shape, self.input_lhs, dtype=dtype) else: assert False if self.input_rhs == 'random': b = array_utils.uniform(self.shape, dtype) elif isinstance(self.input_rhs, (bool, int, float)): b = numpy.full(self.shape, self.input_rhs, dtype=dtype) else: assert False return a, b
def generate_inputs(self): in_dtype1, in_dtype2 = self.in_dtypes in_shape1, in_shape2 = self.in_shapes if self.input_lhs == 'random': a = array_utils.uniform(in_shape1, in_dtype1) elif isinstance(self.input_lhs, (bool, int, float)): a = numpy.full(in_shape1, self.input_lhs, dtype=in_dtype1) else: assert False if self.input_rhs == 'random': b = array_utils.uniform(in_shape2, in_dtype2) elif isinstance(self.input_rhs, (bool, int, float)): b = numpy.full(in_shape2, self.input_rhs, dtype=in_dtype2) else: assert False return a, b
def generate_inputs(self): h_shape = (self.n_layers * 2, self.batches[0], self.hidden_size) dtype = self.in_dtypes[0] low = -1.0 high = 1.0 if dtype == 'float16': low = -0.5 high = 0.5 h = array_utils.uniform(h_shape, dtype) in_size = self.input_size out_size = self.hidden_size xs = [ array_utils.uniform((self.batches[b], in_size), dtype, low=low, high=high) for b in range(len(self.batches)) ] def w_in(i, j): if i == 0 and j < 1: return in_size elif i > 0 and j < 1: return out_size * 2 else: return out_size inputs = [] inputs.append(h) for i in range(len(self.batches)): inputs.append(xs[i]) for n in range(self.n_layers): for direction in (0, 1): for i in range(2): inputs.append( array_utils.uniform((out_size, w_in(n, i)), dtype, low=low, high=high)) for i in range(2): inputs.append( array_utils.uniform((out_size, ), dtype, low=low, high=high)) return tuple(inputs)
def generate_inputs(self): in_dtype, = self.in_dtypes if isinstance(self.input, numpy.ndarray): return self.input.astype(in_dtype), if self.input == 'random': return array_utils.uniform(self.shape, in_dtype), if isinstance(self.input, (bool, int, float)): return numpy.full(self.shape, self.input, dtype=in_dtype), assert False
def generate_inputs(self): in_dtype, = self.in_dtypes if isinstance(self.input, numpy.ndarray): return self.input.astype(in_dtype), if self.input == 'random': return array_utils.uniform(self.shape, in_dtype), if isinstance(self.input, (bool, int, float)): return numpy.full(self.shape, self.input, dtype=in_dtype), assert False
def _random_condition(shape, dtype, *, random_state=None): if random_state is None: random_state = numpy.random.RandomState() neg_mask = random_state.randint(0, 2, size=shape).astype('bool') cond = array_utils.uniform(shape, dtype, random_state=random_state) # Replace zeros with nonzero, making the average number of zero elements # in cond independent of the dtype. cond[cond == 0] = 1 cond[neg_mask] = 0 return cond
def generate_inputs(self): # Do not divide by small number to avoid ridiculously large outputs. if not self.is_scalar_rhs and self.input == 'random': in_dtype, = self.in_dtypes low = -5 if numpy.dtype(in_dtype).kind != 'u' else 2 high = 5 x = array_utils.uniform(self.shape, in_dtype, low=low, high=high) x[(-1 < x) & (x < 0)] = -2 x[(0 <= x) & (x < 1)] = 2 return x, return super().generate_inputs()
def test_power_invalid_bool_dtype(device, dtype, is_bool_rhs, is_bool_primitive, is_module): shape = (3, 2) a = chainerx.array(array_utils.uniform(shape, dtype)) if is_bool_primitive: b = True else: b = chainerx.array(array_utils.uniform(shape, 'bool')) with pytest.raises(chainerx.DtypeError): if is_module: if is_bool_rhs: chainerx.power(a, b) else: chainerx.power(b, a) else: if is_bool_rhs: a**b else: b**a
def generate_inputs(self): in_dtype, = self.in_dtypes a = array_utils.uniform(self.shape, in_dtype) return a,
def generate_inputs(self): in_dtype, = self.in_dtypes if hasattr(self, 'array'): return self.array.astype(in_dtype), return array_utils.uniform(self.shape, in_dtype),
def test_moveaxis_invalid(xp, shape, source, dst): a = array_utils.uniform(shape, 'float') a = xp.array(a) return xp.moveaxis(a, source, dst)
def generate_inputs(self): a = array_utils.uniform(self.shape, self.dtype) return a,
def test_square_invalid_dtypes(device): shape = (3, 2) bool_array = chainerx.array(array_utils.uniform(shape, 'bool_')) with pytest.raises(chainerx.DtypeError): chainerx.square(bool_array)
def _random_condition(shape, dtype): size = int(numpy.prod(shape)) mask = numpy.random.randint(0, 1, size).astype('bool_').reshape(shape) pos = array_utils.uniform(shape, dtype) pos[numpy.logical_not(pos)] = True # All elements are True return pos * mask
def generate_inputs(self): shape = self.shape x1_dtype, x2_dtype = self.in_dtypes x1 = array_utils.uniform(shape, x1_dtype) x2 = array_utils.uniform(shape, x2_dtype) return x1, x2
def generate_inputs(self): dst = array_utils.uniform((2, 3), 'float32') src = array_utils.uniform((2, 3), 'float32') return dst, src