def _allclose_dense_sparse(x, y, rtol=1e-7, atol=1e-9): """Check allclose for sparse and dense data. Both x and y need to be either sparse or dense, they can't be mixed. Parameters ---------- x : array-like or sparse matrix First array to compare. y : array-like or sparse matrix Second array to compare. rtol : float, optional relative tolerance; see numpy.allclose atol : float, optional absolute tolerance; see numpy.allclose. Note that the default here is more tolerant than the default for numpy.testing.assert_allclose, where atol=0. """ if sp.issparse(x) and sp.issparse(y): x = x.tocsr() y = y.tocsr() x.sum_duplicates() y.sum_duplicates() return (cp.array_equal(x.indices, y.indices) and cp.array_equal(x.indptr, y.indptr) and cp.allclose(x.data, y.data, rtol=rtol, atol=atol)) elif not sp.issparse(x) and not sp.issparse(y): return cp.allclose(x, y, rtol=rtol, atol=atol) raise ValueError("Can only compare two sparse matrices, not a sparse " "matrix and an array")
def __eq__(self, other): other = xp.asarray(other) if self.__class__ != other.__class__: return False if xp.array_equal(self.xx, other.xx) and xp.array_equal( self.yy, other.yy): return True else: return False
def check_valid_y(data: np.ndarray) -> bool: """ Check if any key has been pressed in the datased. Some files may not have any key recorded due to windows permission errors on some computers, people not using WASD or other problems, we want to discard these files. Input: - data: ndarray [num_examples x 6] Output: - Bool: True if the file is valid, False is there no key recorded """ seen_keys: Set[int] = set() for i in range(0, data.shape[0]): if np.array_equal(data[i][5], [0, 0, 0, 0]): seen_keys.add(0) elif np.array_equal(data[i][5], [1, 0, 0, 0]): seen_keys.add(1) elif np.array_equal(data[i][5], [0, 1, 0, 0]): seen_keys.add(2) elif np.array_equal(data[i][5], [0, 0, 1, 0]): seen_keys.add(3) elif np.array_equal(data[i][5], [0, 0, 0, 1]): seen_keys.add(4) elif np.array_equal(data[i][5], [1, 0, 1, 0]): seen_keys.add(5) elif np.array_equal(data[i][5], [1, 0, 0, 1]): seen_keys.add(6) elif np.array_equal(data[i][5], [0, 1, 1, 0]): seen_keys.add(7) elif np.array_equal(data[i][5], [0, 1, 0, 1]): seen_keys.add(8) if len(seen_keys) >= 3: return True else: return False
def check_seed(self, seed): bg1 = self.bg(seed) bg2 = self.bg(seed) bg3 = self.bg(None) xs1 = bg1.random_raw(10) xs2 = bg2.random_raw(10) xs3 = bg3.random_raw(10) # Random state must be reproducible assert cupy.array_equal(xs1, xs2) # Random state must be initialized randomly with seed=None assert not cupy.array_equal(xs1, xs3)
def test_memory_reference_for_gpu_cuda(): if Test_Mem_Ref.is_cuda_available() == True: algo = AlgoGPU() algo.whoami() algo.initialize_array(10) input = algo.get_input_memory() output = algo.get_output_memory() print(input) print(type(input)) for i in range(10): input[i] = i / 5 algo.compute(input, output) print(output) print(type(output)) assert (cp.array_equal(input, output)) assert (isinstance(input, cp._core.core.ndarray)) assert (isinstance(output, cp._core.core.ndarray)) else: print("CUDA is not available")
def test_prior_in_posteriors(self): for frame in self.data: frame["prior"] = 1 like = HyperparameterLikelihood(posteriors=self.data, hyper_prior=self.model) self.assertTrue( xp.array_equal(like.sampling_prior, xp.ones_like(like.data["a"])))
def testFilterLikelihoods(self): """ Tests _filterLikelihoods function for several cases: i. Likelihood goes straight to redzone, skipping over yellowzone, repeats ii. Case (i) with different values, and cupy array instead of float list iii. A scenario where changing the redzone from four to five 9s should filter differently """ redThreshold = 0.9999 yellowThreshold = 0.999 # Case (i): values at indices 1 and 7 should be filtered to yellowzone l = [1.0, 1.0, 0.9, 0.8, 0.5, 0.4, 1.0, 1.0, 0.6, 0.0] l = [1 - x for x in l] l2 = copy.copy(l) l2[1] = 1 - yellowThreshold l2[7] = 1 - yellowThreshold l3 = an._filterLikelihoods(l, redThreshold=redThreshold) for i in range(len(l2)): self.assertAlmostEqual(l2[i], l3[i], msg="Failure in case (i)") # Case (ii): values at indices 1-10 should be filtered to yellowzone l = cupy.array([ 0.999978229, 0.999978229, 0.999999897, 1, 1, 1, 1, 0.999999994, 0.999999966, 0.999999966, 0.999994331, 0.999516576, 0.99744487 ]) l = 1.0 - l l2 = copy.copy(l) l2[1:11] = 1 - yellowThreshold l3 = an._filterLikelihoods(l, redThreshold=redThreshold) for i in range(len(l2)): self.assertAlmostEqual(l2[i], l3[i], msg="Failure in case (ii)") # Case (iii): redThreshold difference should be at index 2 l = cupy.array([ 0.999968329, 0.999999897, 1, 1, 1, 1, 0.999999994, 0.999999966, 0.999999966, 0.999994331, 0.999516576, 0.99744487 ]) l = 1.0 - l l2a = copy.copy(l) l2b = copy.copy(l) l2a[1:10] = 1 - yellowThreshold l2b[2:10] = 1 - yellowThreshold l3a = an._filterLikelihoods(l, redThreshold=redThreshold) l3b = an._filterLikelihoods(l, redThreshold=0.99999) for i in range(len(l2a)): self.assertAlmostEqual(l2a[i], l3a[i], msg="Failure in case (iii), list a") for i in range(len(l2b)): self.assertAlmostEqual(l2b[i], l3b[i], msg="Failure in case (iii), list b") self.assertFalse(cupy.array_equal(l3a, l3b), msg="Failure in case (iii), list 3")
def crossover_chromosomes(x_probability, x_method, selection_method, population, optim, encoding): parent_pairs = select_chromosomes(selection_method, population, optim) population_hat = None if x_method == 'single point': population_hat = single_point_crossover(parent_pairs, x_probability) elif x_method == 'multiple point': population_hat = multiple_point_crossover(parent_pairs, x_probability) elif x_method == 'uniform point': population_hat = uniform_crossover(parent_pairs, x_probability) # elif x_method == 'OX': # population_hat = order_crossover(parent_pairs, x_probability, encoding) # elif x_method == 'PMX': # population_hat = partially_mapped_crossover(parent_pairs, x_probability, encoding) else: print( '\nError [4]: Invalid crossover method [at crossover chromosomes]\nExiting...' ) exit() # check crossover effect over current generation if cupy.array_equal(population, population_hat): print( '\nWarning [1]: No crossover change in population [at crossover chromosomes]' ) return population else: return population_hat
def test_return_as_cupy_copy(): a = cp.array([1.1, 3.14, 42.69]) b = cupy_ref.Cupy_Ref(ptr = a.data.ptr, shape = a.shape, dtype = a.dtype, typestr = a.dtype.str) c = cp.array(b, dtype=b.dtype, copy=True) # we use copy to create a new cupy object with the same value of "a" assert(cp.array_equal(a,c)) assert(a.data.ptr != c.data.ptr) # make sure it is copied
def test_return_as_cupy_using_cupy_ref_class(): a = cp.array([1.1, 3.14, 42.69]) b = cupy_ref.Cupy_Ref(ptr = a.data.ptr, shape = a.shape, dtype = a.dtype, typestr = a.dtype.str) c = b.get_cupy_array() assert(cp.array_equal(a,c)) assert(a.data.ptr == c.data.ptr) # make sure it is not copied
def test_create_real_cupy_from_c(): a = cp.array([3.14, 4.25, 5.36], dtype=cp.float64) b = Test_Custom_Cupy.test_create_real_cupy_from_c() assert (cp.array_equal(a, b)) assert ( cp.asnumpy(b).sum() == b.sum() ) #see if the normal cupy from c++ can be converted to numpy like a normal cupy
def test_send_cupy_complex_to_c_and_send_it_back(): a = cp.array([[3.14, 4.25, 5.36], [4, 5, 6], [1.23, 4.56, 7.89]], dtype=cp.complex128) b = Test_Cupy.test_send_cupy_complex_to_c_and_send_it_back( a.data.ptr, a.size, a.shape[0], a.shape[1]) #is there any way to receive shape a single variable? assert (cp.array_equal(a, b))
def test_return_as_cupy_not_copy(): a = cp.array([1.1, 3.14, 42.69]) b = cupy_ref.Cupy_Ref(ptr = a.data.ptr, shape = a.shape, dtype = a.dtype, typestr = a.dtype.str) c = cp.array(b, dtype=b.dtype, copy=False) # we dont use copy to get the original "a" assert(cp.array_equal(a,c)) assert(a.data.ptr == c.data.ptr) # make sure it is not copied
def testFilterLikelihoods(self): """ Tests _filterLikelihoods function for several cases: i. Likelihood goes straight to redzone, skipping over yellowzone, repeats ii. Case (i) with different values, and cupy array instead of float list iii. A scenario where changing the redzone from four to five 9s should filter differently """ redThreshold = 0.9999 yellowThreshold = 0.999 # Case (i): values at indices 1 and 7 should be filtered to yellowzone l = [1.0, 1.0, 0.9, 0.8, 0.5, 0.4, 1.0, 1.0, 0.6, 0.0] l = [1 - x for x in l] l2 = copy.copy(l) l2[1] = 1 - yellowThreshold l2[7] = 1 - yellowThreshold l3 = an._filterLikelihoods(l, redThreshold=redThreshold) for i in range(len(l2)): self.assertAlmostEqual(l2[i], l3[i], msg="Failure in case (i)") # Case (ii): values at indices 1-10 should be filtered to yellowzone l = cupy.array([0.999978229, 0.999978229, 0.999999897, 1, 1, 1, 1, 0.999999994, 0.999999966, 0.999999966, 0.999994331, 0.999516576, 0.99744487]) l = 1.0 - l l2 = copy.copy(l) l2[1:11] = 1 - yellowThreshold l3 = an._filterLikelihoods(l, redThreshold=redThreshold) for i in range(len(l2)): self.assertAlmostEqual(l2[i], l3[i], msg="Failure in case (ii)") # Case (iii): redThreshold difference should be at index 2 l = cupy.array([0.999968329, 0.999999897, 1, 1, 1, 1, 0.999999994, 0.999999966, 0.999999966, 0.999994331, 0.999516576, 0.99744487]) l = 1.0 - l l2a = copy.copy(l) l2b = copy.copy(l) l2a[1:10] = 1 - yellowThreshold l2b[2:10] = 1 - yellowThreshold l3a = an._filterLikelihoods(l, redThreshold=redThreshold) l3b = an._filterLikelihoods(l, redThreshold=0.99999) for i in range(len(l2a)): self.assertAlmostEqual(l2a[i], l3a[i], msg="Failure in case (iii), list a") for i in range(len(l2b)): self.assertAlmostEqual(l2b[i], l3b[i], msg="Failure in case (iii), list b") self.assertFalse(cupy.array_equal(l3a, l3b), msg="Failure in case (iii), list 3")
def test_memory_holder(): a = Test_Interface.GPU_memory_holder([3]) b = a.get_memory_reference() c = cp.array(b, dtype=b.dtype, copy=False) a_2 = cp.array([0.0, 0.0, 0.0]) assert(c.shape == a_2.shape) assert(cp.array_equal(c, a_2))
def test_memory(): assert (cp.get_default_memory_pool().used_bytes() == 0) a = Test_Custom_Cupy.test_create_real_cupy_from_c() b = a * 2 assert (cp.array_equal(b.sum(), a.sum() * 2)) a = None b = None assert (cp.get_default_memory_pool().used_bytes() == 0)
def testBucketIndexSupport(self): """Check bucket index support""" bucketIndices = self._e.getBucketIndices(self._d) topDown = self._e.getBucketInfo(bucketIndices) topDownValues = cupy.array([elem.value for elem in topDown]) errs = topDownValues - cupy.array([320.25, 3.5, .167, 14.8]) self.assertAlmostEqual(errs.max(), 0, 4) encodings = [] for x in topDown: encodings.extend(x.encoding) self.assertTrue(cupy.array_equal(encodings, self._expected))
def test_add_cupy_and_numpy(): a = Test_Interface.GPU_memory_holder([3]) b = a.get_memory_reference() c = cp.array(b, dtype=b.dtype, copy=False) data = np.array([1.0, 1.0, 1.0]) c_inc = cp.array([1.0, 1.0, 1.0]) for i in range(3): c[i] = data[i] assert cp.array_equal(c, c_inc)
def mutate_chromosomes(probability, m_method, population, optim): population_hat = None if m_method[0] == 'random': population_hat = random_mutation(population, probability, m_method) elif m_method[0] == 'elitism': population_hat = elitism(population, probability, m_method, optim) else: print( '\nError [9]: Invalid mutation method [at mutate chromosomes]\nExiting...' ) exit() # check mutation effect over current generation if cupy.array_equal(population, population_hat): # print('\nWarning [3]: No mutation change in population [at mutate chromosomes]') return population else: return population_hat
def roots(p): """Computes the roots of a polynomial with given coefficients. Args: p (cupy.ndarray or cupy.poly1d): polynomial coefficients. Returns: cupy.ndarray: polynomial roots. .. warning:: This function doesn't support currently polynomial coefficients whose companion matrices are general 2d square arrays. Only those with complex Hermitian or real symmetric 2d arrays are allowed. The current `cupy.roots` doesn't guarantee the order of results. .. seealso:: :func:`numpy.roots` """ if isinstance(p, cupy.poly1d): p = p.coeffs if p.dtype.kind == 'b': raise NotImplementedError('boolean inputs are not supported') if p.ndim == 0: raise TypeError('0-dimensional input is not allowed') if p.size < 2: return cupy.array([]) [p] = cupy.polynomial.polyutils.as_series([p[::-1]]) if p.size < 2: return cupy.array([]) if p.size == 2: out = (-p[0] / p[1])[None] if p[0] == 0: out = out.real.astype(numpy.float64) return out cmatrix = cupy.polynomial.polynomial.polycompanion(p) # TODO(Dahlia-Chehata): Support after cupy.linalg.eigvals is supported if cupy.array_equal(cmatrix, cmatrix.conj().T): out = cupy.linalg.eigvalsh(cmatrix) else: raise NotImplementedError('Only complex Hermitian and real ' 'symmetric 2d arrays are supported ' 'currently') return out.astype(p.dtype)
def test_memory_sychronization(): """ Check if automatic copy to host and copy to device are correct done, if c++ cuda kernel is called via python binding """ size = 30 mem_holder = Test_Interface.GPU_memory_holder([size]) mem_holder_ref = mem_holder.get_memory_reference() mem_holder_array = mem_holder_ref.get_cupy_array() data = np.arange(1, size + 1, 1, np.float64) expected_result = cp.array(data + 1) for i in range(size): mem_holder_array[i] = data[i] Test_Interface.incOne(mem_holder_ref, size) assert cp.array_equal(expected_result, mem_holder_array)
def poly(seq_of_zeros): """Computes the coefficients of a polynomial with the given roots sequence. Args: seq_of_zeros (cupy.ndarray): a sequence of polynomial roots. Returns: cupy.ndarray: polynomial coefficients from highest to lowest degree. .. warning:: This function doesn't support general 2d square arrays currently. Only complex Hermitian and real symmetric 2d arrays are allowed. .. seealso:: :func:`numpy.poly` """ x = seq_of_zeros if x.ndim == 2 and x.shape[0] == x.shape[1] and x.shape[0] != 0: if cupy.array_equal(x, x.conj().T): x = cupy.linalg.eigvalsh(x) else: raise NotImplementedError('Only complex Hermitian and real ' 'symmetric 2d arrays are supported ' 'currently') elif x.ndim == 1: x = x.astype(cupy.mintypecode(x.dtype.char), copy=False) else: raise ValueError('Input must be 1d or non-empty square 2d array.') if x.size == 0: return 1.0 size = 2 ** (x.size - 1).bit_length() a = cupy.zeros((size, 2), x.dtype) a[:, 0].fill(1) cupy.negative(x, out=a[:x.size, 1]) while size > 1: size = size // 2 a = cupy._math.misc._fft_convolve(a[:size], a[size:], 'full') return a[0, :x.size + 1]
def test_generating_cupy_of_complex_double_from_c(): a = cp.array([3.14, 4.25, 5.36], dtype=cp.complex128) b = Test_Cupy.test_generating_cupy_of_complex_double_from_c() assert (cp.array_equal(a, b))