def test_1D_single(self): session = None ary = np.array([3.0, 2.1, 1.3, 1.8, 5.7]) sources = make_data_sources(session, "none", ary) assert_almost_equal(sources[0][0].get_data(), np.arange(len(ary))) assert_almost_equal(sources[0][1].get_data(), ary) return
def test_CYP_p2s(self): wcslibout = self.wazp.wcs.p2s([[-10, 30]], 1) wcs_phi = wcslibout['phi'] wcs_theta = wcslibout['theta'] phi, theta = self.azp(-10, 30) utils.assert_almost_equal(np.asarray(phi), wcs_phi) utils.assert_almost_equal(np.asarray(theta), wcs_theta)
def test_default_pars(self): self.cheb2.parameters = np.arange(9) p = np.array([1344., 1772., 400., 1860., 2448., 552., 432., 568., 128.]) z = self.cheb2(self.x, self.y) self.fitter(self.x, self.y, z) utils.assert_almost_equal(self.cheb2.parameters, p)
def test_gross_pnl_calculation(self): tick = self.goog[0] self.backtest.trades.append(Trade('buy', tick)) self.assertEqual(-100.34, self.backtest.gross) tick = self.goog[10] self.backtest.trades.append(Trade('sell', tick)) assert_almost_equal(1.17, self.backtest.gross)
def test_single_array_input(self): model = SummedCompositeModel([self.p1, self.p11]) result = model(self.x) delta11 = self.p11(self.x) delta1 = self.p1(self.x) xx = delta1 + delta11 utils.assert_almost_equal(xx, result)
def test_labeledinput_1(self): # Note: No actual use of LabeledInput in this test; this just uses the # same name for symmetry with the old tests p1 = Polynomial1D(3, c0=1, c1=2, c2=3, c3=4) p2 = Polynomial2D(3, c0_0=1, c2_0=2, c0_1=3, c2_1=4) m = p2 | p1 assert_almost_equal(p1(p2(self.x, self.y)), m(self.x, self.y))
def test_multiple_input(self): rot = models.Rotation2D(angle=-60) model = SerialCompositeModel([rot, rot]) xx, yy = model(self.x, self.y) x1, y1 = model.inverse(xx, yy) utils.assert_almost_equal(x1, self.x) utils.assert_almost_equal(y1, self.y)
def test_chunk_unchunk_grad2(): n_time = 101 n_batch = 3 n_dim = 5 numpy.random.seed(1234) _x = numpy.random.randn(n_time, n_batch, n_dim).astype(f32) _Dx2 = numpy.random.randn(n_time, n_batch, n_dim).astype(f32) _index = numpy.ones((n_time, n_batch), dtype="int8") x = T.as_tensor(_x) Dx2 = T.as_tensor(_Dx2) index = T.as_tensor(_index) chunk_size = 11 chunk_step = 7 out, oindex = chunk(x, index=index, chunk_size=chunk_size, chunk_step=chunk_step) chunk_op = NativeOp.Chunking().make_op() assert type(out.owner.op) is type(chunk_op) x2, index2, factors = unchunk(out, index=oindex, chunk_size=chunk_size, chunk_step=chunk_step, n_time=x.shape[0], n_batch=x.shape[1]) unchunk_op = NativeOp.UnChunking().make_op() assert type(x2.owner.op) is type(unchunk_op) Dout, _, _, _, _, _ = unchunk_op.grad(x2.owner.inputs, (Dx2, None, None)) Dx, _, _, _, _ = chunk_op.grad(out.owner.inputs, (Dout, None)) _Dx = Dx.eval() assert_almost_equal(_Dx, _Dx2)
def test_Updater_add_check_numerics_ops(): class _Layer(DummyLayer): def _get_loss_value(self): return tf.log(self.x) from TFNetwork import TFNetwork, ExternData from Config import Config with make_scope() as session: config = Config() config.set("debug_add_check_numerics_ops", True) network = TFNetwork(extern_data=ExternData(), train_flag=True) network.add_layer(name="output", layer_class=_Layer, initial_value=1.0) network.initialize_params(session=session) updater = Updater(config=config, network=network) updater.set_learning_rate(1.0, session=session) updater.set_trainable_vars(network.get_trainable_params()) updater.init_optimizer_vars(session=session) # Should succeed. session.run(updater.get_optim_op()) # One gradient descent step from ln(x), x = 1.0: gradient is 1.0 / x, thus x - 1.0 = 0.0. assert_almost_equal(session.run(network.get_default_output_layer().output.placeholder), 0.0) try: # Now, should fail. session.run(updater.get_optim_op()) except tf.errors.InvalidArgumentError as exc: print("Expected exception: %r" % exc) else: assert False, "should have raised an exception"
def test_Stats(): rnd = numpy.random.RandomState(42) m = rnd.uniform(-2., 10., (1000, 3)) mean_ref = numpy.mean(m, axis=0) var_ref = numpy.var(m, axis=0) std_dev_ref = numpy.std(m, axis=0) print("ref mean/var/stddev:", mean_ref, var_ref, std_dev_ref) assert_almost_equal(numpy.sqrt(var_ref), std_dev_ref) stats = Stats() t = 0 while t < len(m): s = int(rnd.uniform(10, 100)) m_sub = m[t:t + s] print("sub seq from t=%i, len=%i" % (t, len(m_sub))) stats.collect(m_sub) t += s mean = stats.get_mean() std_dev = stats.get_std_dev() print("mean/stddev:", mean, std_dev) assert_almost_equal(mean, mean_ref) assert_almost_equal(std_dev, std_dev_ref) m -= mean[None, :] m /= std_dev[None, :] stats2 = Stats() t = 0 while t < len(m): s = int(rnd.uniform(10, 100)) m_sub = m[t:t + s] stats2.collect(m_sub) t += s mean0 = stats2.get_mean() stddev1 = stats2.get_std_dev() print("normalized mean/stddev:", mean0, stddev1) assert_almost_equal(mean0, 0.) assert_almost_equal(stddev1, 1.)
def test_derived(self): """ Derived parameters should have expected values """ domain = Domain(2, 32, 200.0, 193.2) self.assertEqual(domain.total_samples, 64) self.assertEqual(domain.window_t, 400.0) assert_almost_equal(domain.centre_omega, 1213.911401347, 9) assert_almost_equal(domain.centre_lambda, 1551.720797, 6)
def test_labeledinput(self): ado = LabeledInput([self.x, self.y], ['x', 'y']) scomptr = SCompositeModel([self.p2, self.p1], [['x', 'y'], ['z']], [['z'], ['z']]) sresult = scomptr(ado) z = self.p2(self.x, self.y) z1 = self.p1(z) utils.assert_almost_equal(z1, sresult.z)
def test_ss_agrawal(self): """ Test splitstep Agrawal method. """ self.parameters["method"] = "SS_AGRAWAL" stepper = Stepper(**self.parameters) A_out = stepper(self.A_in) assert_almost_equal(max(np.abs(A_out) ** 2), self.P_analytical, 4)
def test_Pix2Sky(code): """Check astropy model eval against wcslib eval""" wcs_map = os.path.join(os.pardir, os.pardir, "wcs", "tests", "maps", "1904-66_{0}.hdr".format(code)) test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) params = [] for i in range(3): key = 'PV2_{0}'.format(i + 1) if key in header: params.append(header[key]) w = wcs.WCS(header) w.wcs.crval = [0., 0.] w.wcs.crpix = [0, 0] w.wcs.cdelt = [1, 1] wcslibout = w.wcs.p2s([PIX_COORDINATES], 1) wcs_phi = wcslibout['phi'] wcs_theta = wcslibout['theta'] model = getattr(projections, 'Pix2Sky_' + code) tanprj = model(*params) phi, theta = tanprj(*PIX_COORDINATES) utils.assert_almost_equal(np.asarray(phi), wcs_phi) utils.assert_almost_equal(np.asarray(theta), wcs_theta)
def test_update(): data = ex4() X = add_bias(data['x']) theta = array([[.01, 0.01, 0.01]]) y = vstack([data['y'], 1 - data['y']]).T assert_almost_equal(update(X, y, theta, rho=.05, l=1.), [[-0.5585, 0.0146, 0.0150]], decimal=3)
def test_p_bin(): X = array([[1, 0, 1], [0, 0, 1], [1, 0, 1], [1, 0, 0], [1, 1, 1], [1, 0, 0]]) theta = array([[1, 2, 3]]) assert_almost_equal(prob(X, theta), [[0.9820, 0.01799], [0.9526, 0.04743], [0.9820, 0.01799], [0.7311, 0.2689], [0.9975, 0.002473], [0.7311, 0.2689]], decimal=3)
def test_change_par(self): """ Test that a change to one parameter as a set propagates to param_sets. """ self.gmodel.amplitude = [1, 10] utils.assert_almost_equal(self.gmodel.param_sets, np.array([[1.0, 10], [3.5, 5.2], [0.4, 0.7]])) np.all(self.gmodel.parameters == [1.0, 10.0, 3.5, 5.2, 0.4, 0.7])
def test_p_mult(): X = array([[1, 0, 1], [0, 0, 1], [1, 0, 1], [1, 0, 0], [1, 1, 1], [1, 0, 0]]) theta = array([[1, 0, 3], [0, 2, 1], [2, 3, 1]]) assert_almost_equal(prob(X, theta), [[0.696, 0.0347, 0.256, 0.0128], [0.757, 0.1025, 0.1025, 0.0377], [0.696, 0.0347, 0.256, 0.0128], [0.225, 0.0826, 0.610, 0.0826], [0.114, 0.0419, 0.842, 0.00209], [0.225, 0.0826, 0.610, 0.0826]], decimal=3) data = ex4() X = add_bias(data['x']) theta = array([[.01, 0.01, 0.01]]) assert_almost_equal(prob(X, theta)[:, 0], [0.7790, 0.7747, 0.8030, 0.7875, 0.7604, 0.7712, 0.7586, 0.7649, 0.7982, 0.7850, 0.7613, 0.7721, 0.7841, 0.7455, 0.7799, 0.7649, 0.7721, 0.7941, 0.7613, 0.7521, 0.7512, 0.7558, 0.7398, 0.7604, 0.7359, 0.7211, 0.7446, 0.7841, 0.7150, 0.7436, 0.7799, 0.7408, 0.7512, 0.7658, 0.7577, 0.7738, 0.7221, 0.7558, 0.7586, 0.7455, 0.7120, 0.7130, 0.7016, 0.6846, 0.7221, 0.7369, 0.7058, 0.7079, 0.6559, 0.7211, 0.7231, 0.6964, 0.7037, 0.7465, 0.7408, 0.7530, 0.7301, 0.6835, 0.7301, 0.7058, 0.7604, 0.7613, 0.7340, 0.6974, 0.7271, 0.7110, 0.7658, 0.7291, 0.7568, 0.7465, 0.7359, 0.7503, 0.6932, 0.7417, 0.6963, 0.7037, 0.7389, 0.7191, 0.7099, 0.7359], decimal=3)
def test_add_check_numerics_ops(): with make_scope() as session: x = tf.constant(3.0, name="x") y = tf.log(x * 3, name="y") assert isinstance(y, tf.Tensor) assert_almost_equal(session.run(y), numpy.log(9.)) check = add_check_numerics_ops([y]) session.run(check) z1 = tf.log(x - 3, name="z1") assert_equal(str(session.run(z1)), "-inf") z2 = tf.log(x - 4, name="z2") assert_equal(str(session.run(z2)), "nan") check1 = add_check_numerics_ops([z1]) try: session.run(check1) except tf.errors.InvalidArgumentError as exc: print("Expected exception: %r" % exc) else: assert False, "should have raised an exception" check2 = add_check_numerics_ops([z2]) try: session.run(check2) except tf.errors.InvalidArgumentError as exc: print("Expected exception: %r" % exc) else: assert False, "should have raised an exception"
def test_iris_benchmark(): data = iris() x = add_bias(data['x']) y = binarize(data['y']) train_split = [12, 39, 23, 5, 3, 29, 49, 47, 21, 30, 34, 48, 20, 45, 31, 27, 17, 22, 41, 6, 40, 38, 42, 19, 26, 15, 35, 10, 46, 25, 0, 32, 1, 16, 4, 13, 24, 33, 43, 18, 81, 65, 62, 50, 93, 92, 53, 58, 87, 55, 70, 72, 83, 56, 52, 73, 78, 64, 68, 59, 74, 89, 67, 51, 66, 98, 90, 69, 95, 63, 82, 54, 86, 85, 96, 97, 79, 71, 94, 80, 142, 147, 125, 145, 119, 101, 141, 105, 129, 138, 122, 120, 139, 124, 134, 111, 148, 117, 132, 133, 104, 130, 128, 115, 127, 131, 136, 112, 107, 143, 149, 106, 109, 108, 102, 100, 126, 103, 146, 113] test_split = [2, 7, 8, 9, 11, 14, 28, 36, 37, 44, 57, 60, 61, 75, 76, 77, 84, 88, 91, 99, 110, 114, 116, 118, 121, 123, 135, 137, 140, 144] xTrain = x[train_split, :] yTrain = y[train_split, :] xTest = x[test_split, :] yTest = y[test_split, :] model = OVRClassifier(LogisticModel(rho=1.)).train(xTrain, yTrain, verbose=False) pred = binarize(model.predict(xTest)) assert_almost_equal(accuracy_score(yTest, pred), 0.96667, decimal=3)
def test_rk4ip(self): """ Test Runge-kutta in the interaction picture. """ self.parameters["method"] = "RK4IP" stepper = Stepper(**self.parameters) A_out = stepper(self.A_in) assert_almost_equal(max(np.abs(A_out) ** 2), self.P_analytical, 5)
def test_Sky2Pix(code): """Check astropy model eval against wcslib eval""" wcs_map = os.path.join(os.pardir, os.pardir, "wcs", "tests", "maps", "1904-66_{0}.hdr".format(code)) test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) params = [] for i in range(3): key = 'PV2_{0}'.format(i + 1) if key in header: params.append(header[key]) w = wcs.WCS(header) w.wcs.crval = [0., 0.] w.wcs.crpix = [0, 0] w.wcs.cdelt = [1, 1] wcslibout = w.wcs.p2s([PIX_COORDINATES], 1) wcs_pix = w.wcs.s2p(wcslibout['world'], 1)['pixcrd'] model = getattr(projections, 'Sky2Pix_' + code) tinv = model(*params) x, y = tinv(wcslibout['phi'], wcslibout['theta']) utils.assert_almost_equal(np.asarray(x), wcs_pix[:, 0]) utils.assert_almost_equal(np.asarray(y), wcs_pix[:, 1])
def test_ss_sym_midpoint(self): """ Test symmetric splitstep with midpoint method. """ self.parameters["method"] = "SS_SYM_MIDPOINT" stepper = Stepper(**self.parameters) A_out = stepper(self.A_in) assert_almost_equal(max(np.abs(A_out) ** 2), self.P_analytical, 2)
def test_ss_symmetric(self): """ Test symmetric splitstep method. """ self.parameters["method"] = "SS_SYMMETRIC" stepper = Stepper(**self.parameters) A_out = stepper(self.A_in) assert_almost_equal(max(np.abs(A_out) ** 2), self.P_analytical, 0)
def test_ss_reduced(self): """ Test reduced splitstep method. """ self.parameters["method"] = "SS_REDUCED" stepper = Stepper(**self.parameters) A_out = stepper(self.A_in) assert_almost_equal(max(np.abs(A_out) ** 2), self.P_analytical, 3)
def test_ss_simple(self): """ Test simple splitstep method. """ self.parameters["method"] = "SS_SIMPLE" stepper = Stepper(**self.parameters) A_out = stepper(self.A_in) assert_almost_equal(max(np.abs(A_out) ** 2), self.P_analytical, 3)
def test_single_array_input(self): pcomptr = PCompositeModel([self.p1, self.p11]) presult = pcomptr(self.x) delta11 = self.p11(self.x) delta1 = self.p1(self.x) xx = self.x + delta1 + delta11 utils.assert_almost_equal(xx, presult)
def test_AZP_s2p(self): wcslibout = self.wazp.wcs.p2s([[-10, 30]],1) wcs_pix = self.wazp.wcs.s2p(wcslibout['world'], 1)['pixcrd'] azpinv = projections.Sky2Pix_AZP(mu=2, gamma=30) x, y = azpinv(wcslibout['phi'], wcslibout['theta']) utils.assert_almost_equal(np.asarray(x), wcs_pix[:,0]) utils.assert_almost_equal(np.asarray(y), wcs_pix[:,1])
def test_a_bin(): X = array([[1, 0, 1], [0, 0, 1], [1, 0, 1], [1, 0, 0], [1, 1, 1], [1, 0, 0]]) theta = array([[1, 2, 3]]) assert_almost_equal(act(X, theta), [[54.598, 1.], [20.0855, 1.], [54.598, 1.], [2.7183, 1.], [403.429, 1.], [2.71828, 1.]], decimal=3)
def test_ss_sym_rk4(self): """ Test symmetric splitstep with Runge-Kutta method. """ self.parameters["method"] = "SS_SYM_RK4" stepper = Stepper(**self.parameters) A_out = stepper(self.A_in) assert_almost_equal(max(np.abs(A_out) ** 2), self.P_analytical, 3)
def test_labledinput_2(self): rot = Rotation2D(angle=23.4) offx = Shift(-2) offy = Shift(1.2) m = rot | (offx & Identity(1)) | (Identity(1) & offy) x, y = rot(self.x, self.y) x = offx(x) y = offy(y) assert_almost_equal(x, m(self.x, self.y)[0]) assert_almost_equal(y, m(self.x, self.y)[1]) a = np.deg2rad(23.4) # For kicks matrix = [[np.cos(a), -np.sin(a)], [np.sin(a), np.cos(a)]] x, y = AffineTransformation2D(matrix, [-2, 1.2])(self.x, self.y) assert_almost_equal(x, m(self.x, self.y)[0]) assert_almost_equal(y, m(self.x, self.y)[1])
def test_max_and_argmax_sparse(): n_time = 3 n_batch = 2 n_dim = 5 s0 = np.array([[0, 0], [0, 1], [1, 1], [1, 2], [1, 2], [2, 2], [2, 2]], dtype=f32) s1 = np.array([[1, 2], [2, 3], [1, 1], [2, 0], [4, 1], [3, 3], [4, 4]], dtype=f32) w = np.array([[1, 2], [2, 1], [1, 2], [3, 4], [5, 6], [7, 8], [9, 13]], dtype=f32) m = np.array([[1, 1], [1, 1], [1, 1], [1, 1], [1, 1], [1, 1], [1, 0]], dtype=f32) print("W:\n%r" % NativeOp.sparse_to_dense(s0, s1, w, m, n_time, n_dim).eval()) init_out_max = T.zeros((n_time, n_batch), dtype=f32) init_out_arg = T.zeros((n_time, n_batch), dtype=f32) max1, arg1 = NativeOp.max_and_argmax_sparse(s0, s1, w, m, init_out_max, init_out_arg) W = NativeOp.sparse_to_dense(s0, s1, w, m, n_time, n_dim) assert W.ndim == 3 max2, arg2 = T.max_and_argmax(W, axis=2) arg0 = np.array([[2, 2], [4, 1], [4, 3]]) max0 = np.array([[2, 2], [5, 2], [9, 8]]) arg1 = arg1.eval() arg2 = arg2.eval() max1 = max1.eval() max2 = max2.eval() print("arg0:\n%r" % arg0) print("arg1:\n%r" % arg1) print("arg2:\n%r" % arg2) print("max0:\n%r" % max0) print("max1:\n%r" % max1) print("max2:\n%r" % max2) assert_almost_equal(arg0, arg1) assert_almost_equal(arg0, arg2) assert_almost_equal(max0, max1) assert_almost_equal(max0, max2)
def test_multiclass_merge_estimators(): coef1 = np.array([[1., 2, 3], [4, 5, 6], [7., 8, 9]]) coef2 = np.array([[10., 11, 12]]) coef3 = np.array([[13., 14, 15], [16, 17, 18], [19, 20, 21]]) intercept1 = np.array([[1.], [2], [3]]) intercept2 = np.array([[4.]]) intercept3 = np.array([[5.], [6], [7]]) classes1 = np.array([0, 1, 2]) classes2 = np.array([1, 2]) classes3 = np.array([1, 2, 3]) def f(coef, intercept, classes): s = SGDClassifier() s.coef_ = coef s.intercept_ = intercept s.classes_ = classes return s ests = [ f(coef1, intercept1, classes1), f(coef2, intercept2, classes2), f(coef3, intercept3, classes3) ] coef = np.zeros((4, 3), dtype='f8') coef[classes1] += coef1 coef[[classes2[1]]] += coef2 coef[classes3] += coef3 coef /= 3 intercept = np.zeros((4, 1), dtype='f8') intercept[classes1] += intercept1 intercept[[classes2[1]]] += intercept2 intercept[classes3] += intercept3 intercept /= 3 res = merge_estimators(ests) tm.assert_almost_equal(res.coef_, coef) tm.assert_almost_equal(res.intercept_, intercept) tm.assert_almost_equal(res.classes_, np.arange(4))
def test_recorder_a(self): """ test some statistical operations """ p_1 = {(1, ) : 0.1, (2, ) : 0.2, (3, ) : 0.3, (4, ) : 0.4,} rec = cmepy.recorder.create((('foo',),)) rec.write(1.0, p_1) ev = rec['foo'].expected_value assert_almost_equal(ev, numpy.array([[3.0]])) var = rec['foo'].variance assert_almost_equal(var, numpy.array([1.0])) std_dev = rec['foo'].standard_deviation assert_almost_equal(std_dev, numpy.array([1.0]))
def test_strided_slice_grad_and_back_grad(): shape = (3, 2, 2) from tensorflow.python.ops.gen_array_ops import strided_slice_grad x = tf.reshape(tf.range(0, numpy.prod(shape), dtype=tf.float32), shape) x_ = x[0::1] y = strided_slice_grad(shape=tf.convert_to_tensor(shape), begin=tf.constant([0]), end=tf.constant([0], dtype=tf.int32), end_mask=1, strides=tf.constant([1]), dy=x_) y.set_shape(x.get_shape()) vx, vx_, vy = session.run([x, x_, y]) print("vx, vx_, vy:", vx, vx_, vy) assert_almost_equal(vx, vx_) assert_almost_equal(vx, vy) dy = tf.reshape( tf.range(0, numpy.prod(shape), dtype=tf.float32) * 0.1 - 5.135, shape) dx, = tf.gradients(ys=[y], xs=[x], grad_ys=[dy]) vdx, vdy = session.run([dx, dy]) print("vdx, vdy:", vdx, vdy) assert_almost_equal(vdx, vdy)
def test_recorder_b(self): """ test out some more statistical operations """ p_1 = {(1, ) : 0.1, (2, ) : 0.2, (3, ) : 0.3, (4, ) : 0.4,} # map states via pairwise aggregation even = lambda *x : x[0]/2 odd = lambda *x : x[0]/2 + 1 rec = cmepy.recorder.create((('even', 'odd'), (even, odd))) rec.write(1.0, p_1) even_ev = rec['even'].expected_value assert_almost_equal(even_ev, numpy.array([[1.3]])) odd_ev = rec['odd'].expected_value assert_almost_equal(odd_ev, numpy.array([[2.3]])) cov = rec[('even', 'odd')].covariance assert_almost_equal(cov, numpy.array([0.41]))
def assert_almost_equal(actual, desired, decimal=7, err_msg='', verbose=True): """ Alternative naming for assertArrayAlmostEqual. """ return nptu.assert_almost_equal(actual, desired, decimal, err_msg, verbose)
def test_single_array_input(self): scomptr = SCompositeModel([self.p1, self.p11]) sresult = scomptr(self.x) xx = self.p11(self.p1(self.x)) utils.assert_almost_equal(xx, sresult)
def test_single_array_input(self): model = SerialCompositeModel([self.p1, self.p11]) result = model(self.x) xx = self.p11(self.p1(self.x)) utils.assert_almost_equal(xx, result)
def test_poly2D_cheb2D(self): model = self.fitter(self.cheb2, self.x, self.y, self.z) z1 = model(self.x, self.y) assert_almost_equal(self.z, z1)
def test_CYP_s2p(self): wcslibout = self.wazp.wcs.p2s([[-10, 30]], 1) wcs_pix = self.wazp.wcs.s2p(wcslibout['world'], 1)['pixcrd'] x, y = self.azp.inverse(wcslibout['phi'], wcslibout['theta']) utils.assert_almost_equal(np.asarray(x), wcs_pix[:, 0]) utils.assert_almost_equal(np.asarray(y), wcs_pix[:, 1])
def test_repeate(self): # make sure repeated runs of updatewcs do not change the WCS. updatewcs.updatewcs(self.acs_file) w1 = HSTWCS(self.acs_file, ext=('SCI', 1)) w4 = HSTWCS(self.acs_file, ext=('SCI', 2)) w1r = HSTWCS(self.ref_file, ext=('SCI', 1)) w4r = HSTWCS(self.ref_file, ext=('SCI', 2)) utils.assert_almost_equal(w1.wcs.crval, w1r.wcs.crval) utils.assert_almost_equal(w1.wcs.crpix, w1r.wcs.crpix) utils.assert_almost_equal(w1.wcs.cd, w1r.wcs.cd) assert ((np.array(w1.wcs.ctype) == np.array(w1r.wcs.ctype)).all()) utils.assert_almost_equal(w1.sip.a, w1r.sip.a) utils.assert_almost_equal(w1.sip.b, w1r.sip.b) utils.assert_almost_equal(w4.wcs.crval, w4r.wcs.crval) utils.assert_almost_equal(w4.wcs.crpix, w4r.wcs.crpix) utils.assert_almost_equal(w4.wcs.cd, w4r.wcs.cd) assert ((np.array(self.w4.wcs.ctype) == np.array(w4r.wcs.ctype)).all()) utils.assert_almost_equal(w4.sip.a, w4r.sip.a) utils.assert_almost_equal(w4.sip.b, w4r.sip.b)
def coordinates(): easy_algo_db = get_easy_algo_db() localization_template = easy_algo_db.create_instance( FAMILY_LOC_TEMPLATES, template) localization_template._init_metrics() center = localization_template.center offset = localization_template.offset pose = dtu.geo.SE2_from_translation_angle([center[0], center[1] - offset], np.deg2rad(0)) location = localization_template.coords_from_pose(pose) assert_almost_equal(location['phi'], 0) assert_almost_equal(location['d'], 0) DX = 0.01 pose = dtu.geo.SE2_from_translation_angle( [center[0], center[1] - offset + DX], np.deg2rad(0)) location = localization_template.coords_from_pose(pose) assert_almost_equal(location['phi'], 0) assert_almost_equal(location['d'], DX) pose = dtu.geo.SE2_from_translation_angle( [center[0], center[1] - offset + DX], np.deg2rad(10)) location = localization_template.coords_from_pose(pose) assert_almost_equal(location['phi'], np.deg2rad(10)) assert_almost_equal(location['d'], DX) pose = dtu.geo.SE2_from_translation_angle([center[0] + offset, center[1]], np.deg2rad(90)) location = localization_template.coords_from_pose(pose) assert_almost_equal(location['phi'], np.deg2rad(0)) assert_almost_equal(location['d'], 0) a = 0 pose = dtu.geo.SE2_from_translation_angle( [center[0] + offset * np.cos(a), center[1] + offset * np.sin(a)], np.deg2rad(45)) location = localization_template.coords_from_pose(pose) assert_almost_equal(location['phi'], np.deg2rad(-45)) assert_almost_equal(location['d'], 0) a = np.deg2rad(-40) pose = dtu.geo.SE2_from_translation_angle( [center[0] + offset * np.cos(a), center[1] + offset * np.sin(a)], np.deg2rad(50)) location = localization_template.coords_from_pose(pose) # print('offset: %s' % offset) # print('pose: %s' % SE2.friendly(pose)) # print('location: %s' % phi_d_friendly(location)) # assert_almost_equal(location['phi'], np.deg2rad(0)) assert_almost_equal(location['d'], 0) a = np.deg2rad(-40) D = 0.01 pose = dtu.geo.SE2_from_translation_angle([ center[0] + (offset + D) * np.cos(a), center[1] + (offset + D) * np.sin(a) ], np.deg2rad(50)) location = localization_template.coords_from_pose(pose) # print('offset: %s' % offset) # print('pose: %s' % SE2.friendly(pose)) # print('location: %s' % phi_d_friendly(location)) # assert_almost_equal(location['phi'], np.deg2rad(0)) assert_almost_equal(location['d'], -D) pose = dtu.geo.SE2_from_translation_angle([+0.1095, 0], np.deg2rad(0)) check_coords(localization_template, pose) pose = dtu.geo.SE2_from_translation_angle([+0.1095, 0], np.deg2rad(15)) check_coords(localization_template, pose) # pose = dtu.geo.SE2_from_translation_angle([0.15, -0.1], np.deg2rad(5)) check_coords(localization_template, pose)
def compare_faster(): variables = collections.OrderedDict() variables['alpha'] = dict(min=-180, max=180, description="angle", resolution=5, units='deg', units_display='deg') variables['r'] = dict(min=3, max=5, description="distance", resolution=0.1, units='m', units_display='cm') # this will fail if precision is float32 gh = GridHelper(variables, precision='float64') val_fast = gh.create_new() val_fast.fill(0) val_slow = gh.create_new() val_slow.fill(0) od = dtu.get_output_dir_for_test() F = 1 alpha0 = 7 # r0 = 4 r0 = 4.1 w0 = 1. value = dict(alpha=alpha0, r=r0) gh.add_vote(val_slow, value, w0, F) assert_equal(np.sum(val_slow > 0), 9) values = np.zeros((2, 1)) values[0, 0] = alpha0 values[1, 0] = r0 weights = np.zeros(1) weights[0] = w0 gh.add_vote_faster(val_fast, values, weights, F) assert_equal(np.sum(val_fast > 0), 9) d = grid_helper_plot(gh, val_slow) fn = os.path.join(od, 'compare_faster_slow.jpg') dtu.write_data_to_file(d.get_png(), fn) d = grid_helper_plot(gh, val_fast) fn = os.path.join(od, 'compare_faster_fast.jpg') dtu.write_data_to_file(d.get_png(), fn) D = val_fast - val_slow diff = np.max(np.abs(D)) print('diff: %r' % diff) if diff > 1e-8: print(dtu.indent(array_as_string_sign(val_fast), 'val_fast ')) print(dtu.indent(array_as_string_sign(val_slow), 'val_slow ')) print(dtu.indent(array_as_string_sign(D), 'Diff ')) print('non zero val_fast: %s' % val_fast[val_fast > 0]) print('non zero val_slow: %s' % val_slow[val_slow > 0]) assert_almost_equal(val_fast, val_slow)
def get_map_straight_lane( tile_size: float, width_yellow: float, width_white: float, tile_spacing: float, gap_len: float, dash_len: float, width_red: float, ) -> SegmentsMap: # from inner yellow to inner white constants = {} constants["tile_size"] = tile_size constants["width_yellow"] = width_yellow constants["width_white"] = width_white constants["dash_len"] = dash_len constants["gap_len"] = gap_len constants["tile_spacing"] = gap_len lane_width = L = (tile_size - 2 * width_white - width_yellow) / 2 constants["lane_width"] = lane_width y1 = +width_yellow / 2 + L + width_white y2 = +width_yellow / 2 + L y3 = +width_yellow / 2 y4 = -width_yellow / 2 y5 = -width_yellow / 2 - L y6 = -width_yellow / 2 - L - width_white assert_almost_equal(width_white + L + width_yellow + L + width_white, tile_size) extra = (tile_spacing - tile_size) / 2 FRAME = FRAME_TILE S = -tile_size / 2 - extra D = tile_size / 2 + extra points: Dict[PointName, SegMapPoint] = {} segments: List[SegMapSegment] = [] faces: List[SegMapFace] = [] points["p1"] = SegMapPoint(id_frame=FRAME, coords=np.array([S, y1, 0])) points["q1"] = SegMapPoint(id_frame=FRAME, coords=np.array([D, y1, 0])) points["p2"] = SegMapPoint(id_frame=FRAME, coords=np.array([S, y2, 0])) points["q2"] = SegMapPoint(id_frame=FRAME, coords=np.array([D, y2, 0])) points["p3"] = SegMapPoint(id_frame=FRAME, coords=np.array([S, y3, 0])) points["q3"] = SegMapPoint(id_frame=FRAME, coords=np.array([D, y3, 0])) points["p4"] = SegMapPoint(id_frame=FRAME, coords=np.array([S, y4, 0])) points["q4"] = SegMapPoint(id_frame=FRAME, coords=np.array([D, y4, 0])) points["p5"] = SegMapPoint(id_frame=FRAME, coords=np.array([S, y5, 0])) points["q5"] = SegMapPoint(id_frame=FRAME, coords=np.array([D, y5, 0])) points["p6"] = SegMapPoint(id_frame=FRAME, coords=np.array([S, y6, 0])) points["q6"] = SegMapPoint(id_frame=FRAME, coords=np.array([D, y6, 0])) add_tile(points, faces, segments, tile_size, tile_spacing) def add_dash(x, length): s = len(points) pre = f"dash{s}_" points[pre + "t0"] = SegMapPoint(id_frame=FRAME, coords=np.array([x, y3, 0])) points[pre + "t1"] = SegMapPoint(id_frame=FRAME, coords=np.array([x, y4, 0])) points[pre + "t2"] = SegMapPoint(id_frame=FRAME, coords=np.array([x + length, y4, 0])) points[pre + "t3"] = SegMapPoint(id_frame=FRAME, coords=np.array([x + length, y3, 0])) faces.append( SegMapFace( color=YELLOW, points=[ PointName(pre + "t0"), PointName(pre + "t1"), PointName(pre + "t2"), PointName(pre + "t3"), ], )) ngaps: int = int(tile_size / (gap_len + dash_len)) + 1 if width_red is not None: do_not_go_over = tile_size / 2 else: do_not_go_over = tile_size / 2 + extra for i in range(int(ngaps)): x = i * (gap_len + dash_len) - tile_size / 2 x1 = min(x + dash_len, do_not_go_over) length = x1 - x if length > 0: add_dash(x, length) segments.append( SegMapSegment(color=Segment.WHITE, points=[PointName("q1"), PointName("p1")])) segments.append( SegMapSegment(color=Segment.WHITE, points=[PointName("p2"), PointName("q2")])) segments.append( SegMapSegment(color=Segment.YELLOW, points=[PointName("q3"), PointName("p3")])) segments.append( SegMapSegment(color=Segment.YELLOW, points=[PointName("p4"), PointName("q4")])) segments.append( SegMapSegment(color=Segment.WHITE, points=[PointName("q5"), PointName("p5")])) segments.append( SegMapSegment(color=Segment.WHITE, points=[PointName("p6"), PointName("q6")])) faces.append( SegMapFace(color=WHITE, points=[ PointName("p1"), PointName("q1"), PointName("q2"), PointName("p2") ])) faces.append( SegMapFace(color=WHITE, points=[ PointName("p5"), PointName("q5"), PointName("q6"), PointName("p6") ])) if width_red is not None: x1 = tile_size / 2 - width_red y2 = -width_yellow / 2 y1 = -tile_size / 2 + width_white x2 = tile_size / 2 _add_rect( points, faces, segments, x1, y1, x2, y2, FRAME, RED, use_sides_for_loc=[Segment.RED, None, Segment.RED, None], ) constants["width_red"] = width_red return SegmentsMap(points=points, segments=segments, faces=faces, constants=constants)
def test_fast_bw_uniform(): print("Make op...") from NativeOp import FastBaumWelchOp op = FastBaumWelchOp().make_op() # (am_scores, edges, weights, start_end_states, float_idx, state_buffer) print("Op:", op) n_batch = 3 seq_len = 7 n_classes = 5 from Fsa import FastBwFsaShared fsa = FastBwFsaShared() for i in range(n_classes): fsa.add_edge(i, i + 1, emission_idx=i) # fwd fsa.add_edge(i + 1, i + 1, emission_idx=i) # loop assert n_classes <= seq_len fast_bw_fsa = fsa.get_fast_bw_fsa(n_batch=n_batch) print("edges:") print(fast_bw_fsa.edges) edges = fast_bw_fsa.edges.view("float32") edges_placeholder = T.fmatrix(name="edges") weights = fast_bw_fsa.weights weights_placeholder = T.fvector(name="weights") print("start_end_states:") print(fast_bw_fsa.start_end_states) start_end_states = fast_bw_fsa.start_end_states.view("float32") start_end_states_placeholder = T.fmatrix(name="start_end_states") am_scores = numpy.ones((seq_len, n_batch, n_classes), dtype="float32") * numpy.float32(1.0 / n_classes) am_scores = -numpy.log(am_scores) # in -log space am_scores_placeholder = T.ftensor3(name="am_scores") float_idx = numpy.ones((seq_len, n_batch), dtype="float32") float_idx_placeholder = T.fmatrix(name="float_idx") last_state_idx = numpy.max(fast_bw_fsa.start_end_states[1]) # see get_automata_for_batch state_buffer = numpy.zeros((2, last_state_idx + 1), dtype="float32") state_buffer_placeholder = T.fmatrix(name="state_buffer") print("Construct call...") fwdbwd, obs_scores = op( am_scores_placeholder, edges_placeholder, weights_placeholder, start_end_states_placeholder, float_idx_placeholder, state_buffer_placeholder) f = theano.function(inputs=[am_scores_placeholder, edges_placeholder, weights_placeholder, start_end_states_placeholder, float_idx_placeholder, state_buffer_placeholder], outputs=[fwdbwd, obs_scores]) print("Done.") print("Eval:") fwdbwd, score = f(am_scores, edges, weights, start_end_states, float_idx, state_buffer) print("score:") print(repr(score)) assert_equal(score.shape, (seq_len, n_batch)) bw = numpy.exp(-fwdbwd) print("Baum-Welch soft alignment:") print(repr(bw)) assert_equal(bw.shape, (seq_len, n_batch, n_classes)) from numpy import array, float32 if seq_len == n_classes: print("Extra check identity...") for i in range(n_batch): assert_almost_equal(numpy.identity(n_classes), bw[:, i]) if seq_len == 7 and n_classes == 5: print("Extra check ref_align (7,5)...") assert_allclose(score, 8.55801582, rtol=1e-5) # should be the same everywhere ref_align = \ array([[[1., 0., 0., 0., 0.]], [[0.33333316, 0.66666663, 0., 0., 0.]], [[0.06666669, 0.53333354, 0.40000018, 0., 0.]], [[0., 0.20000014, 0.60000014, 0.19999999, 0.]], [[0., 0., 0.39999962, 0.53333312, 0.06666663]], [[0., 0., 0., 0.66666633, 0.33333316]], [[0., 0., 0., 0., 0.99999982]]], dtype=float32) assert_equal(ref_align.shape, (seq_len, 1, n_classes)) ref_align = numpy.tile(ref_align, (1, n_batch, 1)) assert_equal(ref_align.shape, bw.shape) # print("Reference alignment:") # print(repr(ref_align)) print("mean square diff:", numpy.mean(numpy.square(ref_align - bw))) print("max square diff:", numpy.max(numpy.square(ref_align - bw))) assert_allclose(ref_align, bw, rtol=1e-5) print("Done.")
c0 = np.array([d[1], -d[0], 0]) if False: z = np.array([0, 0, 1]) c = np.cross(d, z) assert_almost_equal(np.linalg.norm(c), 1.0) assert_almost_equal(np.linalg.norm(c0), 1.0) assert_almost_equal(c0, c[:2]) return c0 # TODO: move away assert_almost_equal( np.array([0, -1, 0]), get_normal_outward_for_segment(np.array([0, 0]), np.array([2, 0]))) def add_prefix(sm, prefix): points = {} faces = [] segments = [] for k, v in sm.points.items(): points[prefix + k] = v for face in sm.faces: points2 = tuple(prefix + _ for _ in face.points) faces.append(face._replace(points=points2)) for segment in sm.segments: points2 = tuple(prefix + _ for _ in segment.points) segments.append(segment._replace(points=points2))
def compare_faster(): variables = {} variables["alpha"] = dict(min=-180, max=180, description="angle", resolution=5, units="deg", units_display="deg") variables["r"] = dict(min=3, max=5, description="distance", resolution=0.1, units="m", units_display="cm") # this will fail if precision is float32 gh = GridHelper(variables, precision="float64") val_fast = gh.create_new() val_fast.fill(0) val_slow = gh.create_new() val_slow.fill(0) od = dtu.get_output_dir_for_test() F = 1 alpha0 = 7 # r0 = 4 r0 = 4.1 w0 = 1.0 value = dict(alpha=alpha0, r=r0) gh.add_vote(val_slow, value, w0, F) assert_equal(np.sum(val_slow > 0), 9) values = np.zeros((2, 1)) values[0, 0] = alpha0 values[1, 0] = r0 weights = np.zeros(1) weights[0] = w0 gh.add_vote_faster(val_fast, values, weights, F) assert_equal(np.sum(val_fast > 0), 9) d = grid_helper_plot(gh, val_slow) fn = os.path.join(od, "compare_faster_slow.jpg") dtu.write_data_to_file(d.get_png(), fn) d = grid_helper_plot(gh, val_fast) fn = os.path.join(od, "compare_faster_fast.jpg") dtu.write_data_to_file(d.get_png(), fn) D = val_fast - val_slow diff = np.max(np.abs(D)) print(f"diff: {diff!r}") if diff > 1e-8: print(dtu.indent(array_as_string_sign(val_fast), "val_fast ")) print(dtu.indent(array_as_string_sign(val_slow), "val_slow ")) print(dtu.indent(array_as_string_sign(D), "Diff ")) print(f"non zero val_fast: {val_fast[val_fast > 0]}") print(f"non zero val_slow: {val_slow[val_slow > 0]}") assert_almost_equal(val_fast, val_slow)
def test_outcome_dependent_data(): np.random.seed(10) m = 1000 max_terms = 100 y = np.random.normal(size=m) w = np.random.normal(size=m) ** 2 weight = SingleWeightDependentData.alloc(w, m, max_terms, 1e-16) data = SingleOutcomeDependentData.alloc(y, weight, m, max_terms) # Test updating B = np.empty(shape=(m, max_terms)) for k in range(max_terms): b = np.random.normal(size=m) B[:, k] = b code = weight.update_from_array(b) if k >= 99: 1 + 1 data.update() assert_equal(code, 0) assert_almost_equal( np.dot(weight.Q_t[:k + 1, :], np.transpose(weight.Q_t[:k + 1, :])), np.eye(k + 1)) assert_equal(weight.update_from_array(b), -1) # data.update(1e-16) # Test downdating q = np.array(weight.Q_t).copy() theta = np.array(data.theta[:max_terms]).copy() weight.downdate() data.downdate() weight.update_from_array(b) data.update() assert_almost_equal(q, np.array(weight.Q_t)) assert_almost_equal(theta, np.array(data.theta[:max_terms])) assert_almost_equal( np.array(data.theta[:max_terms]), np.dot(weight.Q_t, w * y)) wB = B * w[:, None] Q, _ = qr(wB, pivoting=False, mode='economic') assert_almost_equal(np.abs(np.dot(weight.Q_t, Q)), np.eye(max_terms)) # Test that reweighting works assert_equal(data.k, max_terms) w2 = np.random.normal(size=m) ** 2 weight.reweight(w2, B, max_terms) data.synchronize() assert_equal(data.k, max_terms) w2B = B * w2[:, None] Q2, _ = qr(w2B, pivoting=False, mode='economic') assert_almost_equal(np.abs(np.dot(weight.Q_t, Q2)), np.eye(max_terms)) assert_almost_equal( np.array(data.theta[:max_terms]), np.dot(weight.Q_t, w2 * y))
def test_fast_bw_uniform(): print("Make op...") op = make_fast_baum_welch_op(compiler_opts=dict( verbose=True)) # will be cached, used inside :func:`fast_baum_welch` # args: (am_scores, edges, weights, start_end_states, float_idx, state_buffer) print("Op:", op) n_batch = 3 seq_len = 7 n_classes = 5 from Fsa import FastBwFsaShared fsa = FastBwFsaShared() for i in range(n_classes): fsa.add_edge(i, i + 1, emission_idx=i) # fwd fsa.add_edge(i + 1, i + 1, emission_idx=i) # loop assert n_classes <= seq_len fast_bw_fsa = fsa.get_fast_bw_fsa(n_batch=n_batch) edges = tf.constant(fast_bw_fsa.edges, dtype=tf.int32) weights = tf.constant(fast_bw_fsa.weights, dtype=tf.float32) start_end_states = tf.constant(fast_bw_fsa.start_end_states, dtype=tf.int32) am_scores = numpy.ones((seq_len, n_batch, n_classes), dtype="float32") * numpy.float32(1.0 / n_classes) am_scores = -numpy.log(am_scores) # in -log space am_scores = tf.constant(am_scores, dtype=tf.float32) float_idx = tf.ones((seq_len, n_batch), dtype=tf.float32) # from TFUtil import sequence_mask_time_major # float_idx = tf.cast(sequence_mask_time_major(tf.convert_to_tensor(list(range(seq_len - n_batch + 1, seq_len + 1)))), dtype=tf.float32) print("Construct call...") fwdbwd, obs_scores = fast_baum_welch(am_scores=am_scores, float_idx=float_idx, edges=edges, weights=weights, start_end_states=start_end_states) print("Done.") print("Eval:") fwdbwd, score = session.run([fwdbwd, obs_scores]) print("score:") print(repr(score)) assert_equal(score.shape, (seq_len, n_batch)) bw = numpy.exp(-fwdbwd) print("Baum-Welch soft alignment:") print(repr(bw)) assert_equal(bw.shape, (seq_len, n_batch, n_classes)) from numpy import array, float32 if seq_len == n_classes: print("Extra check identity...") for i in range(n_batch): assert_almost_equal(numpy.identity(n_classes), bw[:, i]) if seq_len == 7 and n_classes == 5: print("Extra check ref_align (7,5)...") assert_allclose(score, 8.55801582, rtol=1e-5) # should be the same everywhere ref_align = \ array([[[1., 0., 0., 0., 0.]], [[0.33333316, 0.66666663, 0., 0., 0.]], [[0.06666669, 0.53333354, 0.40000018, 0., 0.]], [[0., 0.20000014, 0.60000014, 0.19999999, 0.]], [[0., 0., 0.39999962, 0.53333312, 0.06666663]], [[0., 0., 0., 0.66666633, 0.33333316]], [[0., 0., 0., 0., 0.99999982]]], dtype=float32) assert_equal(ref_align.shape, (seq_len, 1, n_classes)) ref_align = numpy.tile(ref_align, (1, n_batch, 1)) assert_equal(ref_align.shape, bw.shape) # print("Reference alignment:") # print(repr(ref_align)) print("mean square diff:", numpy.mean(numpy.square(ref_align - bw))) print("max square diff:", numpy.max(numpy.square(ref_align - bw))) assert_allclose(ref_align, bw, rtol=1e-5) print("Done.")
def test_object_pars(self): l2 = TestParModel(coeff=[[1, 2], [3, 4]], e=(2, 3), param_dim=2) utils.assert_almost_equal(l2.parameters, [1.0, 2.0, 3.0, 4.0, 2.0, 3.0])
def get_map_curve(tile_size, tile_spacing, width_yellow, width_white, gap_len, dash_len, direction): constants = {} constants["tile_size"] = tile_size constants["width_yellow"] = width_yellow constants["width_white"] = width_white constants["dash_len"] = dash_len constants["gap_len"] = gap_len constants["tile_spacing"] = gap_len lane_width = L = (tile_size - 2 * width_white - width_yellow) / 2 constants["lane_width"] = lane_width assert_almost_equal(width_white + L + width_yellow + L + width_white, tile_size) extra = (tile_spacing - tile_size) / 2 id_frame = FRAME_TILE points = {} segments = [] faces = [] add_tile(points, faces, segments, tile_size, tile_spacing) radius = tile_size - width_white / 2 width = width_white if direction == "right": center = [-tile_size / 2, -tile_size / 2] alpha1 = -np.deg2rad(3) alpha2 = np.pi / 2 + np.deg2rad(3) else: center = [-tile_size / 2, +tile_size / 2] alpha1 = -np.pi / 2 - np.deg2rad(3) alpha2 = +np.deg2rad(3) colors = [WHITE] lengths = [width_white * 2] detect_color = Segment.WHITE add_curved( points, faces, segments, id_frame, center, radius, alpha1, alpha2, width, colors, lengths, detect_color, ) radius = tile_size / 2 width = width_yellow colors = [YELLOW, None] lengths = [dash_len, gap_len] detect_color = Segment.YELLOW add_curved( points, faces, segments, id_frame, center, radius, alpha1, alpha2, width, colors, lengths, detect_color, ) if direction == "right": angle = 0 else: angle = 3 * np.pi / 2 add_corner(points, faces, segments, tile_size, extra, width_white, id_frame, angle) return SegmentsMap(points=points, segments=segments, faces=faces, constants=constants)
def test_single_array_input(self): p1 = Polynomial1D(3, c0=1, c1=2, c2=3, c3=4) p2 = Polynomial1D(3, c0=2, c1=3, c2=4, c3=5) m = p1 | p2 assert_almost_equal(p2(p1(self.x)), m(self.x))
def test_firing_rate(): assert_equal(firing_rate([1, 2, 3]), 1) assert_equal(firing_rate([1, 1.2, 1.4, 1.6, 1.8]), 5) assert_almost_equal(firing_rate([1.1, 1.2, 1.3, 1.4, 1.5]), 10)
def test_change_parameters(self): self.gmodel.parameters = [13, 10, 9, 5.2, 0.4, 0.7] utils.assert_almost_equal(self.gmodel.amplitude.value, [13., 10.]) utils.assert_almost_equal(self.gmodel.mean.value, [9., 5.2])
def test_get_features_feature_metric(): # "voltage traces" that are constant at -70*mV, -60mV, -50mV, -40mV for # 50ms each. voltage_target = np.ones( (2, 200)) * np.repeat([-70, -60, -50, -40], 50) * mV dt = 1 * ms # The results for the first and last "parameter set" are too high/low, the # middle one is perfect voltage_model = np.ones( (3, 2, 200)) * np.repeat([-70, -60, -50, -40], 50) * mV voltage_model[0, 0, :] += 2.5 * mV voltage_model[0, 1, :] += 5 * mV voltage_model[2, 0, :] -= 2.5 * mV voltage_model[2, 1, :] -= 5 * mV inp_times = [[99 * ms, 150 * ms], [49 * ms, 150 * ms]] # Default comparison: absolute difference # Check that FeatureMetric rejects the normalization argument with pytest.raises(ValueError): feature_metric = FeatureMetric(inp_times, ['voltage_base'], normalization=2) feature_metric = FeatureMetric(inp_times, ['voltage_base']) results = feature_metric.get_features(voltage_model, voltage_target, dt=dt) assert len(results) == 3 assert all(isinstance(r, dict) for r in results) assert all(r.keys() == {'voltage_base'} for r in results) assert_almost_equal(results[0]['voltage_base'], np.array([2.5 * mV, 5 * mV])) assert_almost_equal(results[1]['voltage_base'], [0, 0]) assert_almost_equal(results[2]['voltage_base'], np.array([2.5 * mV, 5 * mV])) # Custom comparison: squared difference feature_metric = FeatureMetric(inp_times, ['voltage_base'], combine=lambda x, y: (x - y)**2) results = feature_metric.get_features(voltage_model, voltage_target, dt=dt) assert len(results) == 3 assert all(isinstance(r, dict) for r in results) assert all(r.keys() == {'voltage_base'} for r in results) assert_almost_equal(results[0]['voltage_base'], np.array([(2.5 * mV)**2, (5 * mV)**2])) assert_almost_equal(results[1]['voltage_base'], [0, 0]) assert_almost_equal(results[2]['voltage_base'], np.array([(2.5 * mV)**2, (5 * mV)**2]))
def test_get_initializer_const_formula(): shape = (2, 3) initializer = get_initializer("log(1.0 / 4.0)") v = initializer(shape) assert_almost_equal(session.run(v), numpy.zeros(shape) + numpy.log(1.0 / 4.0))
def test_get_initializer_constant(): shape = (2, 3) initializer = get_initializer("constant") v = initializer(shape) assert_almost_equal(session.run(v), numpy.zeros(shape))
def test_poly2D_cheb2D(self): self.fitter(self.x, self.y, self.z) z1 = self.cheb2(self.x, self.y) utils.assert_almost_equal(self.z, z1)
def test_get_initializer_zero(): shape = (2, 3) initializer = get_initializer(0.0) v = initializer(shape) assert_almost_equal(session.run(v), numpy.zeros(shape))