def test_erf() -> None: try: from scipy.special import erf as scipy_erf except: pytest.skip("scipy not installed skipping test for erf") x = np.array([-1000, -100, -10] + np.linspace(-5, 5, 1001).tolist() + [10, 100, 1000]) y_scipy = scipy_erf(x) # Test mx.nd y_mxnet = util.erf(mx.nd, mx.nd.array(x)).asnumpy() assert np.allclose(y_mxnet, y_scipy, rtol=1e-3) # Test mx.sym X = mx.symbol.Variable("x") func = util.erf(mx.sym, X) func_exec = func.bind(ctx=mx.cpu(), args={"x": mx.nd.array(x)}) func_exec.forward() y_mxnet_sym = func_exec.outputs[0].asnumpy() assert np.allclose(y_mxnet_sym, y_scipy, rtol=1e-3) # Text np y_np = util.erf(np, x) assert np.allclose(y_np, y_scipy, atol=1e-7)
def test_erf() -> None: try: from scipy.special import erf as scipy_erf except: pytest.skip("scipy not installed skipping test for erf") x = np.array([-1000, -100, -10] + np.linspace(-5, 5, 1001).tolist() + [10, 100, 1000]) y_mxnet = util.erf(mx.nd, mx.nd.array(x)).asnumpy() y_scipy = scipy_erf(x) assert np.allclose(y_mxnet, y_scipy)
def test_erf() -> None: pytest.importorskip("scipy") from scipy.special import erf as scipy_erf x = np.array([-1000, -100, -10] + np.linspace(-5, 5, 1001).tolist() + [10, 100, 1000]) y_scipy = scipy_erf(x) # Text np y_np = erf(x) assert np.allclose(y_np, y_scipy, atol=1e-7)
def test_erf() -> None: try: from scipy.special import erf as scipy_erf except: pytest.skip("scipy not installed skipping test for erf") x = np.array([-1000, -100, -10] + np.linspace(-5, 5, 1001).tolist() + [10, 100, 1000]) y_scipy = scipy_erf(x) # Text np y_np = erf(x) assert np.allclose(y_np, y_scipy, atol=1e-7)
def testErfExecution(self): raw = np.random.rand(10, 8, 6) a = tensor(raw, chunk_size=3) r = erf(a) result = self.executor.execute_tensor(r, concat=True)[0] expected = scipy_erf(raw) np.testing.assert_array_equal(result, expected) # test sparse raw = sps.csr_matrix(np.array([0, 1.0, 1.01, np.nan])) a = tensor(raw, chunk_size=3) r = erf(a) result = self.executor.execute_tensor(r, concat=True)[0] data = scipy_erf(raw.data) expected = sps.csr_matrix((data, raw.indices, raw.indptr), raw.shape) np.testing.assert_array_equal(result.toarray(), expected.toarray())
def test_elf(): raw = np.random.rand(10, 8, 5) t = tensor(raw, chunk_size=3) r = erf(t) expect = scipy_erf(raw) assert r.shape == raw.shape assert r.dtype == expect.dtype t, r = tile(t, r) assert r.nsplits == t.nsplits for c in r.chunks: assert isinstance(c.op, TensorErf) assert c.index == c.inputs[0].index assert c.shape == c.inputs[0].shape
def testElf(self): raw = np.random.rand(10, 8, 5) t = tensor(raw, chunk_size=3) r = erf(t) expect = scipy_erf(raw) self.assertEqual(r.shape, raw.shape) self.assertEqual(r.dtype, expect.dtype) r.tiles() self.assertEqual(r.nsplits, t.nsplits) for c in r.chunks: self.assertIsInstance(c.op, TensorErf) self.assertEqual(c.index, c.inputs[0].index) self.assertEqual(c.shape, c.inputs[0].shape)
def chirp_region(x_in, nhalfcycles=6.5, warpexp=0.65, symmetric=False, noise=None): """Determine which region of the chirp the x_in vectors are in by assigning a probability of 0 to 1. If the noise is non-zero the erf() is used to approximate the probability, otherwise it is binary 0 or 1. This is very close to the "best" classifier possible for the noisy chirp. Parameters: x_in -- usual set of ML X vectors with shape of (m, 2) others as in make_chirp(). """ # confirm some of the x_in dimension properties assert((len(x_in.shape) == 2) and (x_in.shape[1] == 2)) # convert the input xs (similar to the x1rot,x2rot above) # to the diagonal coordinate system: the x1, x2 above. x1r = x_in[:, 0] x2r = x_in[:, 1] x1 = (x1r + x2r) / 2.0 x2 = (x2r - x1r) / 2.0 y_out = np.zeros(len(x1)) # go from x1 to the x2boundary x1warp = (abs(x1))**warpexp * x1 / abs(x1) # Symmetry determines if we use sin or cos if symmetric: trigfunc = np.cos else: trigfunc = np.sin # determine the boundary (in x2) between the two classes (at x1) x2boundary = trigfunc(x1warp * nhalfcycles * np.pi) * (1.0 - abs(x1warp)) if noise > 0: # Use erf() to assign a 0 to 1 probability zboundary = (x2 - x2boundary)/noise y_class = 0.5 * scipy_erf(zboundary / np.sqrt(2)) + 0.5 else: # assign binary values y_class = 1 * (x2 > x2boundary) # show the assignment in the input coord.s: ##plt.scatter(x1r, x2r, s=10, c=y_class, cmap=plt.cm.Spectral); return y_class
def __init__(self, a): self.a, self.b = a, None self.value = scipy_erf(a.value)