def test_mask_rowcols(self): # Tests mask_rowcols. x = array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], [0, 0, 0], [0, 0, 0]]) assert_equal(mask_rowcols(x).mask, [[1, 1, 1], [1, 0, 0], [1, 0, 0]]) assert_equal(mask_rowcols(x, 0).mask, [[1, 1, 1], [0, 0, 0], [0, 0, 0]]) assert_equal(mask_rowcols(x, 1).mask, [[1, 0, 0], [1, 0, 0], [1, 0, 0]]) x = array(x._data, mask=[[0, 0, 0], [0, 1, 0], [0, 0, 0]]) assert_equal(mask_rowcols(x).mask, [[0, 1, 0], [1, 1, 1], [0, 1, 0]]) assert_equal(mask_rowcols(x, 0).mask, [[0, 0, 0], [1, 1, 1], [0, 0, 0]]) assert_equal(mask_rowcols(x, 1).mask, [[0, 1, 0], [0, 1, 0], [0, 1, 0]]) x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 0]]) assert_equal(mask_rowcols(x).mask, [[1, 1, 1], [1, 1, 1], [1, 1, 0]]) assert_equal(mask_rowcols(x, 0).mask, [[1, 1, 1], [1, 1, 1], [0, 0, 0]]) assert_equal(mask_rowcols(x, 1,).mask, [[1, 1, 0], [1, 1, 0], [1, 1, 0]]) x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]) self.assertTrue(mask_rowcols(x).all() is masked) self.assertTrue(mask_rowcols(x, 0).all() is masked) self.assertTrue(mask_rowcols(x, 1).all() is masked) self.assertTrue(mask_rowcols(x).mask.all()) self.assertTrue(mask_rowcols(x, 0).mask.all()) self.assertTrue(mask_rowcols(x, 1).mask.all())
def test_intersect1d(self): # Test intersect1d x = array([1, 3, 3, 3], mask=[0, 0, 0, 1]) y = array([3, 1, 1, 1], mask=[0, 0, 0, 1]) test = intersect1d(x, y) control = array([1, 3, -1], mask=[0, 0, 1]) assert_equal(test, control)
def test_masked_1d(self): "test the examples given in the docstring of ma.median" x = array(np.arange(8), mask=[0]*4 + [1]*4) assert_equal(np.ma.median(x), 1.5) assert_equal(np.ma.median(x).shape, (), "shape mismatch") x = array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4) assert_equal(np.ma.median(x), 2.5) assert_equal(np.ma.median(x).shape, (), "shape mismatch")
def test_stacking_arrays(self): a = array([[1,2,3,4],[5,6,7,8],[9,10,11,12]]) b = array([[13,14,15,16],[17,18,19,20],[21,22,23,24]]) c = vstack((a,b)) numpy.testing.assert_array_equal(c, array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16],[17,18,19,20],[21,22,23,24]])) d = hstack((a,b)) numpy.testing.assert_array_equal(d, array([[1,2,3,4,13,14,15,16], [5,6,7,8,17,18,19,20], [9,10,11,12,21,22,23,24]]))
def test_union1d(self): # Test union1d a = array([1, 2, 5, 7, 5, -1], mask=[0, 0, 0, 0, 0, 1]) b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1]) test = union1d(a, b) control = array([1, 2, 3, 4, 5, 7, -1], mask=[0, 0, 0, 0, 0, 0, 1]) assert_equal(test, control) # assert_array_equal([], union1d([], []))
def test_record_arrays(self): img = array([ [[0,1], [0,0]], [[0,0], [1,0]], [[0,0], [0,1]] ], dtype='float32') self.assertEqual(img.shape, (3,2,2)) img = array([[(0,0,0), (1,0,0)], [(0,1,0), (0,0,1)]], [('r','float32'),('g','float32'),('b','float32')]) img = array([[(0,0,0), (1,0,0)], [(0,1,0), (0,0,1)]], {'names': ('r','g','b'), 'formats': ('f4', 'f4', 'f4')}) img = zeros((2,2), [('r','float32'),('g','float32'),('b','float32')]) img.flat = [(0,0,0),(1,0,0),(0,1,0),(0,0,1)] print img.view(recarray)
def test_setdiff1d(self): # Test setdiff1d a = array([6, 5, 4, 7, 7, 1, 2, 1], mask=[0, 0, 0, 0, 0, 0, 0, 1]) b = array([2, 4, 3, 3, 2, 1, 5]) test = setdiff1d(a, b) assert_equal(test, array([6, 7, -1], mask=[0, 0, 1])) # a = arange(10) b = arange(8) assert_equal(setdiff1d(a, b), array([8, 9]))
def test_setxor1d(self): # Test setxor1d a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1]) b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1]) test = setxor1d(a, b) assert_equal(test, array([3, 4, 7])) # a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1]) b = [1, 2, 3, 4, 5] test = setxor1d(a, b) assert_equal(test, array([3, 4, 7, -1], mask=[0, 0, 0, 1])) # a = array([1, 2, 3]) b = array([6, 5, 4]) test = setxor1d(a, b) assert_(isinstance(test, MaskedArray)) assert_equal(test, [1, 2, 3, 4, 5, 6]) # a = array([1, 8, 2, 3], mask=[0, 1, 0, 0]) b = array([6, 5, 4, 8], mask=[0, 0, 0, 1]) test = setxor1d(a, b) assert_(isinstance(test, MaskedArray)) assert_equal(test, [1, 2, 3, 4, 5, 6]) # assert_array_equal([], setxor1d([], []))
def test_indexing_with_boolean_arrays(self): a = arange(12).reshape(3,4) b = a > 4 numpy.testing.assert_array_equal(b, array([[False, False, False, False], [False, True, True, True], [True, True, True, True]], dtype=bool)) a[b] = 0 numpy.testing.assert_array_equal(a, array([[0,1,2,3], [4,0,0,0], [0,0,0,0]])) numpy.testing.assert_array_equal(mandelbrot(4, 4, maxit=1), array([[1,1,1,1], [1,1,1,1], [1,1,1,1], [1,1,1,1]])) a = arange(12).reshape(3,-1) b1 = array([False,True,True]) b2 = array([True,False,True,False]) numpy.testing.assert_array_equal(a[b1,:], array([[4,5,6,7], [8,9,10,11]])) numpy.testing.assert_array_equal(a[b1], array([[4,5,6,7], [8,9,10,11]])) numpy.testing.assert_array_equal(a[:,b2], array([[0,2], [4,6], [8,10]])) numpy.testing.assert_array_equal(a[b1,b2], array([4,10]))
def test_in1d_invert(self): # Test in1d's invert parameter a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1]) b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1]) assert_equal(np.invert(in1d(a, b)), in1d(a, b, invert=True)) a = array([5, 5, 2, 1, -1], mask=[0, 0, 0, 0, 1]) b = array([1, 5, -1], mask=[0, 0, 1]) assert_equal(np.invert(in1d(a, b)), in1d(a, b, invert=True)) assert_array_equal([], in1d([], [], invert=True))
def test_in1d(self): # Test in1d a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1]) b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1]) test = in1d(a, b) assert_equal(test, [True, True, True, False, True]) # a = array([5, 5, 2, 1, -1], mask=[0, 0, 0, 0, 1]) b = array([1, 5, -1], mask=[0, 0, 1]) test = in1d(a, b) assert_equal(test, [True, True, False, True, True]) # assert_array_equal([], in1d([], []))
def test_shape(self): a = array([1,1,1]) self.assertEqual(a.shape, (3,)) a = array([[1], [1]]) self.assertEqual(a.shape, (2,1)) a = array([[[1,1],[1,1]], [[1,1],[1,1]]]) self.assertEqual(a.shape, (2,2,2)) a = array([[[[1],[1]], [[1],[1]]]]) self.assertEqual(a.shape, (1,2,2,1))
def test_ediff1d_tobegin(self): # Test ediff1d w/ to_begin x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1]) test = ediff1d(x, to_begin=masked) control = array([0, 1, 1, 1, 4], mask=[1, 1, 0, 0, 1]) assert_equal(test, control) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask) # test = ediff1d(x, to_begin=[1, 2, 3]) control = array([1, 2, 3, 1, 1, 1, 4], mask=[0, 0, 0, 1, 0, 0, 1]) assert_equal(test, control) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask)
def test_ediff1d_tobegin_toend(self): # Test ediff1d w/ to_begin and to_end x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1]) test = ediff1d(x, to_end=masked, to_begin=masked) control = array([0, 1, 1, 1, 4, 0], mask=[1, 1, 0, 0, 1, 1]) assert_equal(test, control) assert_equal(test.data, control.data) assert_equal(test.mask, control.mask) # test = ediff1d(x, to_end=[1, 2, 3], to_begin=masked) control = array([0, 1, 1, 1, 4, 1, 2, 3], mask=[1, 1, 0, 0, 1, 0, 0, 0]) assert_equal(test, control) assert_equal(test.data, control.data) assert_equal(test.mask, control.mask)
def test_ediff1d_toend(self): # Test ediff1d w/ to_end x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1]) test = ediff1d(x, to_end=masked) control = array([1, 1, 1, 4, 0], mask=[1, 0, 0, 1, 1]) assert_equal(test, control) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask) # test = ediff1d(x, to_end=[1, 2, 3]) control = array([1, 1, 1, 4, 1, 2, 3], mask=[1, 0, 0, 1, 0, 0, 0]) assert_equal(test, control) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask)
def test_docstring_examples(self): "test the examples given in the docstring of ma.median" x = array(np.arange(8), mask=[0]*4 + [1]*4) assert_equal(np.ma.median(x), 1.5) assert_equal(np.ma.median(x).shape, (), "shape mismatch") assert_(type(np.ma.median(x)) is not MaskedArray) x = array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4) assert_equal(np.ma.median(x), 2.5) assert_equal(np.ma.median(x).shape, (), "shape mismatch") assert_(type(np.ma.median(x)) is not MaskedArray) ma_x = np.ma.median(x, axis=-1, overwrite_input=True) assert_equal(ma_x, [2., 5.]) assert_equal(ma_x.shape, (2,), "shape mismatch") assert_(type(ma_x) is MaskedArray)
def test_ediff1d_ndarray(self): # Test ediff1d w/ a ndarray x = np.arange(5) test = ediff1d(x) control = array([1, 1, 1, 1], mask=[0, 0, 0, 0]) assert_equal(test, control) self.assertTrue(isinstance(test, MaskedArray)) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask) # test = ediff1d(x, to_end=masked, to_begin=masked) control = array([0, 1, 1, 1, 1, 0], mask=[1, 0, 0, 0, 0, 1]) self.assertTrue(isinstance(test, MaskedArray)) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask)
def test_get_gaussian_2d(self): X = asarray([-1, 1]) X = reshape(X, (len(X), 1)) y = asarray([+1 if x >= 0 else -1 for x in X]) covariance = SquaredExponentialCovariance(sigma=1, scale=1) likelihood = LogitLikelihood() gp = GaussianProcess(y, X, covariance, likelihood) laplace = LaplaceApproximation(gp, newton_start=asarray([3, 3])) f_mode, L, steps = laplace.find_mode_newton(return_full=True) gaussian = laplace.get_gaussian(f_mode, L) F = linspace(-10, 10, 20) D = zeros((len(F), len(F))) Q = array(D, copy=True) for i in range(len(F)): for j in range(len(F)): f = asarray([F[i], F[j]]) D[i, j] = gp.log_posterior_unnormalised(f) Q[i, j] = gaussian.log_pdf(f.reshape(1, len(f))) subplot(1, 2, 1) pcolor(F, F, D) hold(True) plot(steps[:, 0], steps[:, 1]) plot(f_mode[1], f_mode[0], 'mo', markersize=10) hold(False) colorbar() subplot(1, 2, 2) pcolor(F, F, Q) hold(True) plot(f_mode[1], f_mode[0], 'mo', markersize=10) hold(False) colorbar() # show() clf()
def get_mushroom_data(): data_dir = os.sep.join(__file__.split(os.sep)[:-3] + ["data"]) filename = data_dir + os.sep + "agaricus-lepiota.data" f = open(filename) X = asarray(["".join(x.strip(os.linesep).split(",")) for x in f.readlines()], dtype="c") f.close() # first column is labels labels=asarray([+1. if X[i,0]=="e" else -1. for i in range(len(X))]) # remove attribute eleven which contains loads of missing values remove_idx = 11 indices = hstack((arange(remove_idx), arange(remove_idx + 1, X.shape[1]))) X = X[:, indices[1:]] # generate a map of categorical to int cat2num={} U=unique(X) for num in range(len(U)): cat2num[U[num]]=num # produce an integer representation of the categorical data X_int=asarray([[cat2num[X[i,j]] for i in range(X.shape[0])] for j in range(X.shape[1])]).T return array(X_int, dtype=float64) ,labels
def get_usps_data(): data_dir = os.sep.join(__file__.split(os.sep)[:-3] + ["data"]) filename = data_dir + os.sep + "usps3vs5.mat" mat = scipy.io.loadmat(filename) data = mat['usps3vs5_data'] lab = array([float(x) for x in mat['usps3vs5_labels'][:, 0]]) return data, lab
def test_attributepropagation(self): x = array(arange(5), mask=[0]+[1]*4) my = masked_array(subarray(x)) ym = msubarray(x) # z = (my+1) self.assertTrue(isinstance(z, MaskedArray)) self.assertTrue(not isinstance(z, MSubArray)) self.assertTrue(isinstance(z._data, SubArray)) assert_equal(z._data.info, {}) # z = (ym+1) self.assertTrue(isinstance(z, MaskedArray)) self.assertTrue(isinstance(z, MSubArray)) self.assertTrue(isinstance(z._data, SubArray)) self.assertTrue(z._data.info['added'] > 0) # Test that inplace methods from data get used (gh-4617) ym += 1 self.assertTrue(isinstance(ym, MaskedArray)) self.assertTrue(isinstance(ym, MSubArray)) self.assertTrue(isinstance(ym._data, SubArray)) self.assertTrue(ym._data.info['iadded'] > 0) # ym._set_mask([1, 0, 0, 0, 1]) assert_equal(ym._mask, [1, 0, 0, 0, 1]) ym._series._set_mask([0, 0, 0, 0, 1]) assert_equal(ym._mask, [0, 0, 0, 0, 1]) # xsub = subarray(x, info={'name':'x'}) mxsub = masked_array(xsub) self.assertTrue(hasattr(mxsub, 'info')) assert_equal(mxsub.info, xsub.info)
def test_testAverage2(self): # More tests of average. w1 = [0, 1, 1, 1, 1, 0] w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]] x = arange(6, dtype=np.float_) assert_equal(average(x, axis=0), 2.5) assert_equal(average(x, axis=0, weights=w1), 2.5) y = array([arange(6, dtype=np.float_), 2.0 * arange(6)]) assert_equal(average(y, None), np.add.reduce(np.arange(6)) * 3. / 12.) assert_equal(average(y, axis=0), np.arange(6) * 3. / 2.) assert_equal(average(y, axis=1), [average(x, axis=0), average(x, axis=0) * 2.0]) assert_equal(average(y, None, weights=w2), 20. / 6.) assert_equal(average(y, axis=0, weights=w2), [0., 1., 2., 3., 4., 10.]) assert_equal(average(y, axis=1), [average(x, axis=0), average(x, axis=0) * 2.0]) m1 = zeros(6) m2 = [0, 0, 1, 1, 0, 0] m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]] m4 = ones(6) m5 = [0, 1, 1, 1, 1, 1] assert_equal(average(masked_array(x, m1), axis=0), 2.5) assert_equal(average(masked_array(x, m2), axis=0), 2.5) assert_equal(average(masked_array(x, m4), axis=0).mask, [True]) assert_equal(average(masked_array(x, m5), axis=0), 0.0) assert_equal(count(average(masked_array(x, m4), axis=0)), 0) z = masked_array(y, m3) assert_equal(average(z, None), 20. / 6.) assert_equal(average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5]) assert_equal(average(z, axis=1), [2.5, 5.0]) assert_equal(average(z, axis=0, weights=w2), [0., 1., 99., 99., 4.0, 10.0])
def test_ediff1d(self): "Tests mediff1d" x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1]) control = array([1, 1, 1, 4], mask=[1, 0, 0, 1]) test = ediff1d(x) assert_equal(test, control) assert_equal(test.data, control.data) assert_equal(test.mask, control.mask)
def test_dot_returns_maskedarray(self): # See gh-6611 a = np.eye(3) b = array(a) assert_(type(dot(a, a)) is MaskedArray) assert_(type(dot(a, b)) is MaskedArray) assert_(type(dot(b, a)) is MaskedArray) assert_(type(dot(b, b)) is MaskedArray)
def test_ediff1d(self): # Tests mediff1d x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1]) control = array([1, 1, 1, 4], mask=[1, 0, 0, 1]) test = ediff1d(x) assert_equal(test, control) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask)
def test_masked_1d(self): x = array(np.arange(5), mask=True) assert_equal(np.ma.median(x), np.ma.masked) assert_equal(np.ma.median(x).shape, (), "shape mismatch") assert_(type(np.ma.median(x)) is np.ma.core.MaskedConstant) x = array(np.arange(5), mask=False) assert_equal(np.ma.median(x), 2.) assert_equal(np.ma.median(x).shape, (), "shape mismatch") assert_(type(np.ma.median(x)) is not MaskedArray) x = array(np.arange(5), mask=[0,1,0,0,0]) assert_equal(np.ma.median(x), 2.5) assert_equal(np.ma.median(x).shape, (), "shape mismatch") assert_(type(np.ma.median(x)) is not MaskedArray) x = array(np.arange(5), mask=[0,1,1,1,1]) assert_equal(np.ma.median(x), 0.) assert_equal(np.ma.median(x).shape, (), "shape mismatch") assert_(type(np.ma.median(x)) is not MaskedArray)
def test_compress_rowcols(self): # Tests compress_rowcols x = array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], [0, 0, 0], [0, 0, 0]]) assert_equal(compress_rowcols(x), [[4, 5], [7, 8]]) assert_equal(compress_rowcols(x, 0), [[3, 4, 5], [6, 7, 8]]) assert_equal(compress_rowcols(x, 1), [[1, 2], [4, 5], [7, 8]]) x = array(x._data, mask=[[0, 0, 0], [0, 1, 0], [0, 0, 0]]) assert_equal(compress_rowcols(x), [[0, 2], [6, 8]]) assert_equal(compress_rowcols(x, 0), [[0, 1, 2], [6, 7, 8]]) assert_equal(compress_rowcols(x, 1), [[0, 2], [3, 5], [6, 8]]) x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 0]]) assert_equal(compress_rowcols(x), [[8]]) assert_equal(compress_rowcols(x, 0), [[6, 7, 8]]) assert_equal(compress_rowcols(x, 1), [[2], [5], [8]]) x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]) assert_equal(compress_rowcols(x).size, 0) assert_equal(compress_rowcols(x, 0).size, 0) assert_equal(compress_rowcols(x, 1).size, 0)
def test_masked_all_like(self): # Tests masked_all # Standard dtype base = array([1, 2], dtype=float) test = masked_all_like(base) control = array([1, 1], mask=[1, 1], dtype=float) assert_equal(test, control) # Flexible dtype dt = np.dtype({"names": ["a", "b"], "formats": ["f", "f"]}) base = array([(0, 0), (0, 0)], mask=[(1, 1), (1, 1)], dtype=dt) test = masked_all_like(base) control = array([(10, 10), (10, 10)], mask=[(1, 1), (1, 1)], dtype=dt) assert_equal(test, control) # Nested dtype dt = np.dtype([("a", "f"), ("b", [("ba", "f"), ("bb", "f")])]) control = array([(1, (1, 1)), (1, (1, 1))], mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt) test = masked_all_like(control) assert_equal(test, control)
def test_testAverage1(self): # Test of average. ott = array([0., 1., 2., 3.], mask=[True, False, False, False]) assert_equal(2.0, average(ott, axis=0)) assert_equal(2.0, average(ott, weights=[1., 1., 2., 1.])) result, wts = average(ott, weights=[1., 1., 2., 1.], returned=1) assert_equal(2.0, result) self.assertTrue(wts == 4.0) ott[:] = masked assert_equal(average(ott, axis=0).mask, [True]) ott = array([0., 1., 2., 3.], mask=[True, False, False, False]) ott = ott.reshape(2, 2) ott[:, 1] = masked assert_equal(average(ott, axis=0), [2.0, 0.0]) assert_equal(average(ott, axis=1).mask[0], [True]) assert_equal([2., 0.], average(ott, axis=0)) result, wts = average(ott, axis=0, returned=1) assert_equal(wts, [1., 0.])
def test_masked_all_like(self): # Tests masked_all # Standard dtype base = array([1, 2], dtype=float) test = masked_all_like(base) control = array([1, 1], mask=[1, 1], dtype=float) assert_equal(test, control) # Flexible dtype dt = np.dtype({'names': ['a', 'b'], 'formats': ['f', 'f']}) base = array([(0, 0), (0, 0)], mask=[(1, 1), (1, 1)], dtype=dt) test = masked_all_like(base) control = array([(10, 10), (10, 10)], mask=[(1, 1), (1, 1)], dtype=dt) assert_equal(test, control) # Nested dtype dt = np.dtype([('a', 'f'), ('b', [('ba', 'f'), ('bb', 'f')])]) control = array([(1, (1, 1)), (1, (1, 1))], mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt) test = masked_all_like(control) assert_equal(test, control)
def test_compress2d(self): # Tests compress2d x = array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], [0, 0, 0], [0, 0, 0]]) assert_equal(compress_rowcols(x), [[4, 5], [7, 8]]) assert_equal(compress_rowcols(x, 0), [[3, 4, 5], [6, 7, 8]]) assert_equal(compress_rowcols(x, 1), [[1, 2], [4, 5], [7, 8]]) x = array(x._data, mask=[[0, 0, 0], [0, 1, 0], [0, 0, 0]]) assert_equal(compress_rowcols(x), [[0, 2], [6, 8]]) assert_equal(compress_rowcols(x, 0), [[0, 1, 2], [6, 7, 8]]) assert_equal(compress_rowcols(x, 1), [[0, 2], [3, 5], [6, 8]]) x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 0]]) assert_equal(compress_rowcols(x), [[8]]) assert_equal(compress_rowcols(x, 0), [[6, 7, 8]]) assert_equal(compress_rowcols( x, 1, ), [[2], [5], [8]]) x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]) assert_equal(compress_rowcols(x).size, 0) assert_equal(compress_rowcols(x, 0).size, 0) assert_equal(compress_rowcols(x, 1).size, 0)
def get_pima_data(): data_dir = os.sep.join(__file__.split(os.sep)[:-3] + ["data"]) filename = data_dir + os.sep + "pima-indians-diabetes.data" data = loadtxt(filename, delimiter=",") # create labelling lab = data[:, -1] lab = array([1. if x == 1 else -1.0 for x in lab]) # cut off labeling data = data[:, :-1] return data, lab
def get_glass_data(): data_dir = os.sep.join(__file__.split(os.sep)[:-3] + ["data"]) filename = data_dir + os.sep + "glass.data" data = loadtxt(filename, delimiter=",") # create a binary "window glass" vs "non-window glass" labelling lab = data[:, -1] lab = array([1. if x <= 4 else -1.0 for x in lab]) # cut off ids and labeling data = data[:, 1:-1] return data, lab
def grid_score(k, grid): width, height = grid_dimensions(grid) row_penalties = list(max(0, sum(row) - k) for row in grid) col_penalties = list( max(0, sum(row[j] for row in grid) - k) for j in range(width)) grid = array(grid) flip = flipud(grid) r1 = range(-(width - 1), width) r2 = range(-(height - 1), height) dia_penalties = lambda m, dia_i: max(0, int(m.trace(dia_i)) - k) di1_penalties = list(dia_penalties(grid, d) for d in r1) di2_penalties = list(dia_penalties(flip, d) for d in r2) return sum(row_penalties) + sum(col_penalties) + sum(di1_penalties) + sum( di2_penalties)
def test_testAverage3(self): # Yet more tests of average! a = arange(6) b = arange(6) * 3 r1, w1 = average([[a, b], [b, a]], axis=1, returned=1) assert_equal(shape(r1), shape(w1)) assert_equal(r1.shape, w1.shape) r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=1) assert_equal(shape(w2), shape(r2)) r2, w2 = average(ones((2, 2, 3)), returned=1) assert_equal(shape(w2), shape(r2)) r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=1) assert_equal(shape(w2), shape(r2)) a2d = array([[1, 2], [0, 4]], float) a2dm = masked_array(a2d, [[False, False], [True, False]]) a2da = average(a2d, axis=0) assert_equal(a2da, [0.5, 3.0]) a2dma = average(a2dm, axis=0) assert_equal(a2dma, [1.0, 3.0]) a2dma = average(a2dm, axis=None) assert_equal(a2dma, 7. / 3.) a2dma = average(a2dm, axis=1) assert_equal(a2dma, [1.5, 4.0])
def test_axis_argument_errors(self): msg = "mask = %s, ndim = %s, axis = %s, overwrite_input = %s" for ndmin in range(5): for mask in [False, True]: x = array(1, ndmin=ndmin, mask=mask) # Valid axis values should not raise exception args = itertools.product(range(-ndmin, ndmin), [False, True]) for axis, over in args: try: np.ma.median(x, axis=axis, overwrite_input=over) except: raise AssertionError(msg % (mask, ndmin, axis, over)) # Invalid axis values should raise exception args = itertools.product([-(ndmin + 1), ndmin], [False, True]) for axis, over in args: try: np.ma.median(x, axis=axis, overwrite_input=over) except IndexError: pass else: raise AssertionError(msg % (mask, ndmin, axis, over))
def test_1d_shape_consistency(self): assert_equal( np.ma.median(array([1, 2, 3], mask=[0, 0, 0])).shape, np.ma.median(array([1, 2, 3], mask=[0, 1, 0])).shape)
def test_dot_out(self): a = array(np.eye(3)) out = array(np.zeros((3, 3))) res = dot(a, a, out=out) assert_(res is out) assert_equal(a, res)
def test_compress_nd(self): # Tests compress_nd x = np.array(list(range(3 * 4 * 5))).reshape(3, 4, 5) m = np.zeros((3, 4, 5)).astype(bool) m[1, 1, 1] = True x = array(x, mask=m) # axis=None a = compress_nd(x) assert_equal(a, [[[0, 2, 3, 4], [10, 12, 13, 14], [15, 17, 18, 19]], [[40, 42, 43, 44], [50, 52, 53, 54], [55, 57, 58, 59]]]) # axis=0 a = compress_nd(x, 0) assert_equal(a, [[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]], [[40, 41, 42, 43, 44], [45, 46, 47, 48, 49], [50, 51, 52, 53, 54], [55, 56, 57, 58, 59]]]) # axis=1 a = compress_nd(x, 1) assert_equal(a, [ [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]], [[20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [35, 36, 37, 38, 39]], [[40, 41, 42, 43, 44], [50, 51, 52, 53, 54], [55, 56, 57, 58, 59]] ]) a2 = compress_nd(x, (1, )) a3 = compress_nd(x, -2) a4 = compress_nd(x, (-2, )) assert_equal(a, a2) assert_equal(a, a3) assert_equal(a, a4) # axis=2 a = compress_nd(x, 2) assert_equal( a, [[[0, 2, 3, 4], [5, 7, 8, 9], [10, 12, 13, 14], [15, 17, 18, 19]], [[20, 22, 23, 24], [25, 27, 28, 29], [30, 32, 33, 34], [35, 37, 38, 39]], [[40, 42, 43, 44], [45, 47, 48, 49], [50, 52, 53, 54], [55, 57, 58, 59]]]) a2 = compress_nd(x, (2, )) a3 = compress_nd(x, -1) a4 = compress_nd(x, (-1, )) assert_equal(a, a2) assert_equal(a, a3) assert_equal(a, a4) # axis=(0, 1) a = compress_nd(x, (0, 1)) assert_equal(a, [[ [0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19] ], [[40, 41, 42, 43, 44], [50, 51, 52, 53, 54], [55, 56, 57, 58, 59]]]) a2 = compress_nd(x, (0, -2)) assert_equal(a, a2) # axis=(1, 2) a = compress_nd(x, (1, 2)) assert_equal(a, [[[0, 2, 3, 4], [10, 12, 13, 14], [15, 17, 18, 19]], [[20, 22, 23, 24], [30, 32, 33, 34], [35, 37, 38, 39]], [[40, 42, 43, 44], [50, 52, 53, 54], [55, 57, 58, 59]]]) a2 = compress_nd(x, (-2, 2)) a3 = compress_nd(x, (1, -1)) a4 = compress_nd(x, (-2, -1)) assert_equal(a, a2) assert_equal(a, a3) assert_equal(a, a4) # axis=(0, 2) a = compress_nd(x, (0, 2)) assert_equal( a, [[[0, 2, 3, 4], [5, 7, 8, 9], [10, 12, 13, 14], [15, 17, 18, 19]], [[40, 42, 43, 44], [45, 47, 48, 49], [50, 52, 53, 54], [55, 57, 58, 59]]]) a2 = compress_nd(x, (0, -1)) assert_equal(a, a2)
def test_onintegers_with_mask(self): # Test average on integers with mask a = average(array([1, 2])) assert_equal(a, 1.5) a = average(array([1, 2, 3, 4], mask=[False, False, True, True])) assert_equal(a, 1.5)
# loop over parameters here experiment_dir = experiment_dir_base + os.sep + str( os.path.abspath(sys.argv[0])).split(os.sep)[-1].split(".")[0] + os.sep print "running experiments", n, "times at base", experiment_dir for i in range(n): distribution = Ring() mcmc_samplers = [] kernel = GaussianKernel(sigma=1) # mcmc_samplers.append(KameleonWindow(distribution, kernel)) mcmc_samplers.append(KameleonWindowLearnScale(distribution, kernel)) mean_est = array([-2.0, -2.0]) cov_est = 0.05 * eye(2) # mcmc_samplers.append(AdaptiveMetropolis(distribution, mean_est=mean_est, cov_est=cov_est)) mcmc_samplers.append( AdaptiveMetropolisLearnScale(distribution, mean_est=mean_est, cov_est=cov_est)) num_eigen = 2 mcmc_samplers.append( AdaptiveMetropolisPCA(distribution, num_eigen=num_eigen, mean_est=mean_est, cov_est=cov_est)) mcmc_samplers.append(StandardMetropolis(distribution))
from numpy.lib.shape_base import tile from numpy.ma.core import sum, array, arange import operator def knn(group, labels, test, k): tests = tile(test, (group.shape[0], 1)) diff = group - tests diff_pow = diff * diff diff_sum = sum(diff_pow, axis=1) distance = diff_sum**0.5 argsort = distance.argsort() print('distance:', distance) print('argsort:', argsort) classcount = {} for i in arange(k): label = labels[argsort[i]] print('label:' + label) classcount[label] = classcount.get(label, 0) + 1 print(classcount) sortClasscount = sorted(classcount.items(), key=operator.itemgetter(1)) print(sortClasscount) print('res:', sortClasscount[0][0]) group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]]) labels = ['A', 'A', 'B', 'B'] test = [0, 0] k = 3 print(group.shape[0]) knn(group, labels, test, k)
def test_masked_0d(self): # Check values x = array(1, mask=False) assert_equal(np.ma.median(x), 1) x = array(1, mask=True) assert_equal(np.ma.median(x), np.ma.masked)
def setUp(self): self.data = array(np.random.rand(12)) self.data2 = array(np.random.rand(12))
def get_hyperparameters(self): return array([self.sigma, self.scale])
for v in xrange(len(vol)): print >> f, '%.3f,' % vol[v], for p in xrange(len(prob)): print >> f, '%.3f,' % function(statistic[p, v, :]), print >> f, '\n', #POLICIES path = 'data/varredura_0-4/statistics/' lbdMean = loadVar(path, 'lbdMean') lbdStd = loadVar(path, 'lbdStd') meanSquareError = loadVar(path, 'meanSquareError') rightEstimate = loadVar(path, 'rightEstimate') rightPrediction = loadVar(path, 'rightPrediction') rewardedTrials = loadVar(path, 'rewardedTrials') prob = array([.55, .65, .75, .85, .95]) vol = array([0, .005, .01, .05]) lbd = [0.01, 0.11, 0.21, 0.31, 0.41, 0.51, 0.61, 0.71, 0.81, 0.91] generateTableofStatistics(prob, vol, lbdMean, mean, path, 'tableLbdMean') generateTableofStatistics(prob, vol, lbdMean, std, path, 'tableLbdStdMean-consistence') generateTableofStatistics(prob, vol, lbdStd, mean, path, 'tableLbdMeanStd-convergence') #generateTableofStatistics(prob, vol, meanSquareError,mean, path, 'tableMeanSquareError') #generateTableofStatistics(prob, vol, rewardedTrials, mean,path,'tableRewardedTrials') generateTableofStatistics(prob, vol, rightEstimate, mean, path, 'tableRightEstimate') #generateTableofStatistics(prob, vol, rightPrediction,mean, path,'tableRightPrediction') ##CONSTANT LAMBDA
for i in range(m): #每次都降低alpha的大小 alpha = 4 / (1.0 + j + i) + 0.01 #随机选择样本 randIndex = int(np.random.uniform(0, len(dataIndex))) #随机选择一个样本计算h h = sigmoid(sum(dataMatrix[randIndex] * weights)) #计算误差 error = classLabels[randIndex] - h #更新回归系数 weights = weights + alpha * error * dataMatrix[randIndex] #删除已使用版本 del (dataIndex[randIndex]) return weights if __name__ == "__main__": dataArr, labelMat = loadDataSet() weights = gradAscent(dataArr, labelMat) print(weights) plotBestFit(weights.getA()) weights = stocGradAscent0(array(dataArr), labelMat) print(weights) plotBestFit(weights) weights = stocGradAscent1(array(dataArr), labelMat, 500) print(weights) plotBestFit(weights)