我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.array_equal()。
def gen_pruned_features(name): print name feature_dir = 'data/feature_' + args.domain + \ '_' + str(args.n_boxes) + 'boxes/' + name + '/' n_clips = len(glob.glob(feature_dir + BOX_FEATURE + '*.npy')) for clip in xrange(1, n_clips+1): pruned_boxes = np.load(feature_dir + BOX_FEATURE + '{:04d}.npy'.format(clip)) # (50, args.n_boxes, 4) roisavg = np.load(feature_dir + 'roisavg{:04d}.npy'.format(clip)) # (50, args.n_boxes, 512) pruned_roisavg = np.zeros((50, args.n_boxes, 512)) for frame in xrange(50): for box_id in xrange(args.n_boxes): if not np.array_equal(pruned_boxes[frame][box_id], np.zeros((4))): pruned_roisavg[frame][box_id] = roisavg[frame][box_id] np.save('{}pruned_roisavg{:04d}'.format(feature_dir, clip), pruned_roisavg)
def test_intersection_com_mock_2(self): ls = LineString([(1, 1, 9.48024060e+08), (2, 2, 9.49363260e+08), (3, 1, 9.51868860e+08)]) poly = Polygon([(1, 1), (1, 3), (4, 3), (4, 1), (1, 1)]) self.traj2.intersection_shapely = MagicMock(return_value=ls) response = self.traj2.intersection_shapely(poly) ls = np.array(ls) trajMock = self.traj2.to_Trajectory(response) traj = Trajectory(ls[:, 0], ls[:, 1], ls[:, 2]) assert (np.array_equal(trajMock.getX(), traj.getX())) assert (np.array_equal(trajMock.getY(), traj.getY())) assert (np.array_equal(trajMock.getTime(), traj.getTime()))
def _test_FileSink(self, format): filename = self._tempfileName('sink_%s' % format) complexData = format.startswith('C') typecode = format[1] dataFormat, dataType = self.TYPEMAP[typecode] indata = [dataType(x) for x in xrange(16)] source = sb.DataSource(dataFormat=dataFormat) sink = sb.FileSink(filename, midasFile=True) source.connect(sink) sb.start() source.push(indata, complexData=complexData, EOS=True) sink.waitForEOS() hdr, outdata = bluefile.read(filename) self.assertEqual(hdr['format'], format) if complexData: if dataFormat in ('double', 'float'): outdata = list(self._flatten(outdata)) else: outdata = outdata.flatten() self.assertTrue(numpy.array_equal(indata, outdata), msg="Format '%s' %s != %s" % (format, indata, outdata))
def _test_FileSource(self, format): filename = self._tempfileName('source_%s' % format) complexData = format.startswith('C') typecode = format[1] dataFormat, dataType = self.TYPEMAP[typecode] indata = self._generateSourceData(format, 16) hdr = bluefile.header(1000, format) bluefile.write(filename, hdr, indata) source = sb.FileSource(filename, midasFile=True, dataFormat=dataFormat) sink = sb.DataSink() source.connect(sink) sb.start() outdata = sink.getData(eos_block=True) if complexData: self.assertEqual(sink.sri().mode, 1) if dataFormat in ('float', 'double'): outdata = bulkio_helpers.bulkioComplexToPythonComplexList(outdata) else: outdata = numpy.reshape(outdata, (len(outdata)/2,2)) else: self.assertEqual(sink.sri().mode, 0) self.assertTrue(numpy.array_equal(indata, outdata), msg='%s != %s' % (indata, outdata))
def Verify(**kwargs): ''' Verification for the signature i/p: msg: the string sent by the sender (z,c): vectors in Zq, the signature A : numpy array, Verification Key dimension nxm T : the matrix AS mod q ,it is used in the Verification of the signature ''' msg, z, c, A, T, sd, eta, m, k, q = kwargs['msg'], kwargs['z'], kwargs['c'], kwargs['A'], kwargs['T'], kwargs['sd'], kwargs['eta'], kwargs['m'], kwargs['k'], kwargs['q'] norm_bound = eta * sd * np.sqrt(m) # checks for norm of z being small and that H(Az-Tc mod q,msg) hashes to c vec = util.vector_to_Zq(np.array(np.matmul(A,z) - np.matmul(T,c)), q) hashedList = util.hash_to_baseb(vec, msg, 3, k) print hashedList, c if np.sqrt(z.dot(z)) <= norm_bound and np.array_equal(c, hashedList): return True else: return False
def test_non_aligned_read(): delete_layer() cv, data = create_layer(size=(128,64,64,1), offset=(0,0,0)) # the last dimension is the number of channels assert cv[31:65,0:64,0:64].shape == (34,64,64,1) assert np.all(cv[31:65,0:64,0:64] == data[31:65,:64,:64,:]) # read a single pixel delete_layer() cv, data = create_layer(size=(64,64,64,1), offset=(0,0,0)) # the last dimension is the number of channels assert cv[22:23,22:23,22:23].shape == (1,1,1,1) assert np.all(cv[22:23,22:23,22:23] == data[22:23,22:23,22:23,:]) # Test steps (negative steps are not supported) img1 = cv[::2, ::2, ::2, :] img2 = cv[:, :, :, :][::2, ::2, ::2, :] assert np.array_equal(img1, img2)
def __setitem__(self, slices, img): imgshape = list(img.shape) if len(imgshape) == 3: imgshape = imgshape + [ self.num_channels ] maxsize = list(self.bounds.maxpt) + [ self.num_channels ] minsize = list(self.bounds.minpt) + [ 0 ] slices = generate_slices(slices, minsize, maxsize) bbox = Bbox.from_slices(slices) slice_shape = list(bbox.size3()) + [ slices[3].stop - slices[3].start ] if not np.array_equal(imgshape, slice_shape): raise ValueError("Illegal slicing, Image shape: {} != {} Slice Shape".format(imgshape, slice_shape)) if self.path.protocol == 'boss': self.upload_boss_image(img, bbox.minpt) else: self.upload_image(img, bbox.minpt)
def test_dense_to_sparse(self): """ Test if `dense_to_sparse` works properly.""" with tf.Session().as_default(): dense = tf.constant([[1., 2., 0.], [0., 0., 3.]], dtype=tf.float32) sparse = dense_to_sparse(dense) self.assertTrue(np.array_equal(sparse.indices.eval(), np.array([[0, 0], [0, 1], [1, 2]]))) self.assertTrue(np.array_equal(sparse.values.eval(), np.array([1., 2., 3.]))) mask = tf.constant([[0, 1, 0], [1, 0, 0]], dtype=tf.int32) masked = dense_to_sparse(dense, mask) self.assertTrue(np.array_equal(masked.indices.eval(), np.array([[0, 1], [1, 0]]))) self.assertTrue(np.array_equal(masked.values.eval(), np.array([2., 0.])))
def __init__(self, test_model=False, verify_model=True): model = Word2Vec.load(modelfile) if(test_model): acc = model.accuracy(questionfile) logger.info("Test model " + modelfile + " in " + questionfile) self.vector_size = model.vector_size self.vocab_size = len(model.wv.vocab) + 1 self.word2index = self.GetWord2Index(model) self.index2word = self.GetIndex2Word(model) self.wordvector = self.GetWordVector(model) if(verify_model): logger.info("Verifing imported word2vec model") random_state = check_random_state(12) check_index = random_state.randint(low=0, high=self.vocab_size-2,size=1000) for index in check_index: word_wv = model.wv.index2word[index] word_our = self.index2word[index+1] #print(index, word_wv, word_our) assert word_wv == word_our assert model.wv.vocab[word_our].index == self.word2index[word_our] - 1 assert np.array_equal(model.wv[word_our], self.wordvector[self.word2index[word_our]]) logger.info("Imported word2vec model is verified")
def test_vectorized_jaccard_sim(): # The vectorized version of jaccard similarity is 20x faster, but it is # harder to understand. Compute it the simple way and compare to the # vectorized version def jaccard_sim(X, Y): assert len(X) == len(Y) a = np.sum((X == 1) & (Y == 1)) d = np.sum((X == 0) & (Y == 0)) return a / float(len(X) - d) def binary_sim(mat): n_rows = mat.shape[0] out = np.empty((n_rows, n_rows), dtype=np.float64) for i in range(n_rows): out[i][i] = 1. for j in range(0, i): out[i][j] = jaccard_sim(mat[i], mat[j]) out[j][i] = out[i][j] return out # Simulate 200 queries with 100 shared page ids matrix = np.random.rand(200, 100) > 0.7 simple = binary_sim(matrix) vectorized = mjolnir.norm_query._binary_sim(matrix) assert np.array_equal(simple, vectorized)
def test_classify_image_in_memory(): # create mineral classifier instance with image loading enabled mc = mineral.MineralClassification(libraryFilenames[0], in_memory=True) # for each of the test images for image_file_name in test_classifyImage_testFilenames: # classify the test image classified_file_name = image_file_name[:-4] + "_class_test.hdr" mc.classify_image(image_file_name, classified_file_name) actual = spectral.open_image(classified_file_name) # classified image for comparison expected = spectral.open_image(image_file_name[:-4] + "_class.hdr") # verify that every pixel has the same classification assert numpy.array_equal(expected.asarray(), actual.asarray()) # test files for classify image threshold and subset tests
def _core_dist(point, neighbors, dist_function): """ Computes the core distance of a point. Core distance is the inverse density of an object. Args: point (np.array): array of dimensions (n_features,) point to compute core distance of neighbors (np.ndarray): array of dimensions (n_neighbors, n_features): array of all other points in object class dist_dunction (func): function to determine distance between objects func args must be [np.array, np.array] where each array is a point Returns: core_dist (float) inverse density of point """ n_features = np.shape(point)[0] n_neighbors = np.shape(neighbors)[1] numerator = 0 for row in neighbors: if not np.array_equal(point, row): numerator += (1/dist_function(point, row))**n_features core_dist = (numerator / (n_neighbors)) ** (-1/n_features) return core_dist
def test_intersection_com_mock(self): ls = LineString([(1.5, 1, 9.48024060e+08), (2, 2, 9.49363260e+08), (3, 2, 9.51868860e+08), (4, 3, 9.53208060e+08)]) poly = Polygon([(1, 1), (1, 3), (4, 3), (4, 1), (1, 1)]) self.traj.intersection_shapely = MagicMock(return_value=ls) response = self.traj.intersection_shapely(poly) ls = np.array(ls) trajMock = self.traj.to_Trajectory(response) traj = Trajectory(ls[:, 0], ls[:, 1], ls[:, 2]) assert (np.array_equal(trajMock.getX(), traj.getX())) assert (np.array_equal(trajMock.getY(), traj.getY())) assert (np.array_equal(trajMock.getTime(), traj.getTime()))
def test_array_equal(self): res = np.array_equal(np.array([1, 2]), np.array([1, 2])) assert_(res) assert_(type(res) is bool) res = np.array_equal(np.array([1, 2]), np.array([1, 2, 3])) assert_(not res) assert_(type(res) is bool) res = np.array_equal(np.array([1, 2]), np.array([3, 4])) assert_(not res) assert_(type(res) is bool) res = np.array_equal(np.array([1, 2]), np.array([1, 3])) assert_(not res) assert_(type(res) is bool) res = np.array_equal(np.array(['a'], dtype='S1'), np.array(['a'], dtype='S1')) assert_(res) assert_(type(res) is bool) res = np.array_equal(np.array([('a', 1)], dtype='S1,u4'), np.array([('a', 1)], dtype='S1,u4')) assert_(res) assert_(type(res) is bool)
def test_slice_metadata_using_already_sliced_data_df(self): data = pd.DataFrame([[2, 3], [5, 6], [11, 12]], index=["a", "b", "d"], columns=["f", "g"]) row_meta = pd.DataFrame([["rm1", "rm2"],["rm3", "rm4"], ["rm5", "rm6"],["rm7", "rm8"]], index=["a", "b", "c", "d"], columns=["row_field1", "row_field2"]) col_meta = pd.DataFrame([["cm1", "cm2"],["cm3", "cm4"],["cm5", "cm6"]], index=["e", "f", "g"], columns=["col_field1", "col_field2"]) e_row_meta = pd.DataFrame([["rm1", "rm2"],["rm3", "rm4"],["rm7", "rm8"]], index=["a", "b", "d"], columns=["row_field1", "row_field2"]) e_col_meta = pd.DataFrame([["cm3", "cm4"],["cm5", "cm6"]], index=["f", "g"], columns=["col_field1", "col_field2"]) out_gct = dry.slice_metadata_using_already_sliced_data_df(data, row_meta, col_meta) self.assertTrue(np.array_equal(out_gct.row_metadata_df, e_row_meta), "row_metadata_df is wrong: \n{}".format(out_gct.row_metadata_df)) self.assertTrue(np.array_equal(out_gct.col_metadata_df, e_col_meta), "col_metadata_df is wrong: \n{}".format(out_gct.col_metadata_df))
def test_make_norm_ndarray(self): ROW_SUBSET_FIELD = "pr_probe_normalization_group" COL_SUBSET_FIELD = "det_normalization_group_vector" row_df = pd.DataFrame(np.array([["8350", "1"], ["8350", "1"], ["8350", "2"], ["8350", "2"]]), index=["r1", "r2", "r3", "r4"], columns=["pr_gene_id", "pr_probe_normalization_group"]) col_df = pd.DataFrame(np.array([["G-0022", "1,1"], ["G-0022", "1,1"], ["G-0022", "1,2"], ["G-0022", "2,2"], ["G-0022", "2,2"]]), index=["c1", "c2", "c3", "c4", "c5"], columns=["det_plate", "det_normalization_group_vector"]) e_norm_ndarray = np.array([[1, 1, 1, 2, 2], [1, 1, 1, 2, 2], [1, 1, 2, 2, 2], [1, 1, 2, 2, 2]]) norm_ndarray = tear.make_norm_ndarray(row_df, col_df, ROW_SUBSET_FIELD, COL_SUBSET_FIELD) self.assertTrue(np.array_equal(norm_ndarray, e_norm_ndarray), ("\nExpected out:\n{} " + "\nActual out:\n{}").format(e_norm_ndarray, norm_ndarray))
def test_save_txt_and_load_txt(): # Get sample data set dataset = get_dataset() # Get in-memory string handle with StringIO() as handle: # Save text to handle dataset.save_txt(handle) handle.seek(0) # Load text from handle dataset2 = LtrDataset.load_txt(handle) # Assert that everything loaded correctly assert_true(np.array_equal(dataset.feature_vectors, dataset2.feature_vectors)) assert_true(np.array_equal(dataset.relevance_scores, dataset2.relevance_scores)) assert_true(np.array_equal(dataset.query_pointer, dataset2.query_pointer)) assert_true(np.array_equal(dataset.query_ids, dataset2.query_ids))
def test_save_and_load(): # Get sample data set dataset = get_dataset() # Get in-memory binary handle with BytesIO() as handle: # Save binary to handle dataset.save(handle) handle.seek(0) # Load binary from handle dataset2 = LtrDataset.load(handle) # Assert that everything loaded correctly assert_true(np.array_equal(dataset.feature_vectors, dataset2.feature_vectors)) assert_true(np.array_equal(dataset.relevance_scores, dataset2.relevance_scores)) assert_true(np.array_equal(dataset.query_pointer, dataset2.query_pointer)) assert_true(np.array_equal(dataset.query_ids, dataset2.query_ids))
def test_backward(): # Construct test data x = Variable(np.array([5., 3., 3., 1., 0.])) g = Variable(np.ones(5)) expected_result = np.array([0.7717692057972512, 0.562087881852882, 1.4058826163342215, 0.9213241007090265, 1.3389361953066183]) # Generate object lcse = LogCumsumExp() # Run forward and backward pass lcse.forward((x.data,)) result = lcse.backward((x.data, ), (g.data, )) # Assert that the result equals the expected result assert_true(np.array_equal(result[0], expected_result))
def d2_at_Z(self, z=15.0): def is_z(ax): for axis in np.array([[z,0,0],[0,z,0],[0,0,z]]): if np.array_equal(ax, axis): return True return False if is_z(self._lattice[0]): self.swap_axis((2,1,0)) return None elif is_z(self._lattice[1]): self.swap_axis((0,2,1)) return None else: # print("DO NOTHING...") return None
def test_prepare_fcma_data(): images = io.load_images_from_dir(data_dir, suffix=suffix) mask = io.load_boolean_mask(mask_file) conditions = io.load_labels(epoch_file) raw_data, _, labels = prepare_fcma_data(images, conditions, mask) expected_raw_data = np.load(expected_dir / 'expected_raw_data.npy') assert len(raw_data) == len(expected_raw_data), \ 'numbers of epochs do not match in test_prepare_fcma_data' for idx in range(len(raw_data)): assert np.allclose(raw_data[idx], expected_raw_data[idx]), \ 'raw data do not match in test_prepare_fcma_data' assert np.array_equal(labels, expected_labels), \ 'the labels do not match in test_prepare_fcma_data' from brainiak.fcma.preprocessing import RandomType images = io.load_images_from_dir(data_dir, suffix=suffix) random_raw_data, _, _ = prepare_fcma_data(images, conditions, mask, random=RandomType.REPRODUCIBLE) assert len(random_raw_data) == len(expected_raw_data), \ 'numbers of epochs do not match in test_prepare_fcma_data' images = io.load_images_from_dir(data_dir, suffix=suffix) random_raw_data, _, _ = prepare_fcma_data(images, conditions, mask, random=RandomType.UNREPRODUCIBLE) assert len(random_raw_data) == len(expected_raw_data), \ 'numbers of epochs do not match in test_prepare_fcma_data'
def test_weighted_var(): es = brainiak.eventseg.event.EventSegment(2) D = np.zeros((8, 4)) for t in range(4): D[t, :] = (1/np.sqrt(4/3)) * np.array([-1, -1, 1, 1]) for t in range(4, 8): D[t, :] = (1 / np.sqrt(4 / 3)) * np.array([1, 1, -1, -1]) mean_pat = D[[0, 4], :].T weights = np.zeros((8, 2)) weights[:, 0] = [1, 1, 1, 1, 0, 0, 0, 0] weights[:, 1] = [0, 0, 0, 0, 1, 1, 1, 1] assert np.array_equal( es.calc_weighted_event_var(D, weights, mean_pat), [0, 0]),\ "Failed to compute variance with 0/1 weights" weights[:, 0] = [1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5] weights[:, 1] = [0.5, 0.5, 0.5, 0.5, 1, 1, 1, 1] true_var = (4 * 0.5 * 12)/(6 - 5/6) * np.ones(2) / 4 assert np.allclose( es.calc_weighted_event_var(D, weights, mean_pat), true_var),\ "Failed to compute variance with fractional weights"
def test_sentence_to_seq(sentence_to_seq): sentence = 'this is a test sentence' vocab_to_int = {'<PAD>': 0, '<EOS>': 1, '<UNK>': 2, 'this': 3, 'is': 6, 'a': 5, 'sentence': 4} output = sentence_to_seq(sentence, vocab_to_int) assert len(output) == 5,\ 'Wrong length. Found a length of {}'.format(len(output)) assert output[3] == 2,\ 'Missing <UNK> id.' assert np.array_equal(output, [3, 6, 5, 2, 4]),\ 'Incorrect ouput. Found {}'.format(output) _print_success_message()
def test_CentreTransform_caching(make_random_data): # Generate an initial set of data x, mu, std = make_random_data # Apply the CentreTransform to the first dataset to preserve the mean x_copy = x.copy() center_transformer = CentreTransform() center_transformer(x_copy) # Now apply the center transform to a matrix that has been translated x_translated = x + 3.0 * mu x_expected = x_translated - mu x_produced = center_transformer(x_translated) # Check that the transformer used the mean mu instead of the translated # mean which was 3 * mu in this case above assert np.array_equal(x_expected, x_produced)
def test_StandardiseTransform_caching(make_random_data): # Generate an initial set of data x, mu, std = make_random_data # Apply the CentreTransform to the first dataset to preserve the mean x_copy = x.copy() center_transformer = CentreTransform() center_transformer(x_copy) # Now apply the center transform to a matrix translated by 2 * mu x_translated = x + 3.0 * mu x_expected = x_translated - mu x_produced = center_transformer(x_translated) # Check that the transformer used the mean mu instead of the translated # mean which was 4 * mu in this case above assert np.array_equal(x_expected, x_produced)
def test_atoms_to_system(self): """Tests that an ASE Atoms is succesfully converted to a System object. """ class NaClFactory(SimpleCubicFactory): "A factory for creating NaCl (B1, Rocksalt) lattices." bravais_basis = [[0, 0, 0], [0, 0, 0.5], [0, 0.5, 0], [0, 0.5, 0.5], [0.5, 0, 0], [0.5, 0, 0.5], [0.5, 0.5, 0], [0.5, 0.5, 0.5]] element_basis = (0, 1, 1, 0, 1, 0, 0, 1) nacl = NaClFactory()(symbol=["Na", "Cl"], latticeconstant=5.6402) system = System.from_atoms(nacl) self.assertTrue(np.array_equal(nacl.get_positions(), system.get_positions())) self.assertTrue(np.array_equal(nacl.get_initial_charges(), system.get_initial_charges())) self.assertTrue(np.array_equal(nacl.get_atomic_numbers(), system.get_atomic_numbers())) self.assertTrue(np.array_equal(nacl.get_chemical_symbols(), system.get_chemical_symbols())) self.assertTrue(np.array_equal(nacl.get_cell(), system.get_cell())) self.assertTrue(np.array_equal(nacl.get_pbc(), system.get_pbc())) self.assertTrue(np.array_equal(nacl.get_scaled_positions(), system.get_scaled_positions()))
def test_matrix(self): desc = CoulombMatrix(n_atoms_max=5, flatten=False) cm = desc.create(H2O) # Test against assumed values q = H2O.get_initial_charges() p = H2O.get_positions() norm = np.linalg.norm assumed = np.array( [ [0.5*q[0]**2.4, q[0]*q[1]/(norm(p[0]-p[1])), q[0]*q[2]/(norm(p[0]-p[2]))], [q[1]*q[0]/(norm(p[1]-p[0])), 0.5*q[1]**2.4, q[1]*q[2]/(norm(p[1]-p[2]))], [q[2]*q[0]/(norm(p[2]-p[0])), q[2]*q[1]/(norm(p[2]-p[1])), 0.5*q[2]**2.4], ] ) zeros = np.zeros((5, 5)) zeros[:3, :3] = assumed assumed = zeros self.assertTrue(np.array_equal(cm, assumed))
def test_cputensor_add(): """TODO.""" Y = ng.make_axis(length=2) M = ng.make_axis(length=2) N = ng.make_axis(length=2) a = ng.constant(np.array([3, 5], dtype=np.float32), [Y]) b = ng.constant(np.array([3, 5], dtype=np.float32), [Y]) c = a + b with executor(c) as ex: result = ex() assert np.array_equal(result, [6, 10]) np_a = np.array([[1, 2], [3, 4]], dtype=np.float32) np_b = np.array([[1, 2], [3, 4]], dtype=np.float32) np_c = np_a + np_b a = ng.constant(np_a, [M, N]) b = ng.constant(np_b, [M, N]) c = a + b with executor(c) as ex: result = ex() assert np.array_equal(result, np_c)
def test_cputensor_dot(): Y = ng.make_axis(length=2) M = ng.make_axis(length=1) N = ng.make_axis(length=3) np_a = np.array([[1, 2, 3]], dtype=np.float32) np_b = np.array([[1, 2], [2, 3], [3, 4]], dtype=np.float32) np_c = np.dot(np_a, np_b) a = ng.constant(np_a, [M, N]).named('a') b = ng.constant(np_b, [N, Y]).named('b') c = ng.dot(a, b) with executor(c) as ex: result = ex() assert np.array_equal(result, np_c)
def test_cputensor_multiply_constant(): """TODO.""" M = ng.make_axis(length=1) N = ng.make_axis(length=3) np_a = np.array([[1, 2, 3]], dtype=np.float32) np_c = np.multiply(np_a, 2) a = ng.constant(np_a, [M, N]) b = ng.constant(2) c = ng.multiply(a, b) with executor(c) as ex: result = ex() print(result) assert np.array_equal(result, np_c)
def test_cputensor_mlp(): """TODO.""" D = ng.make_axis(length=3) H = ng.make_axis(length=2) N = ng.make_axis(length=1) np_x = np.array([[1, 2, 3]], dtype=np.float32) np_w = np.array([[1, 1], [1, 1], [1, 1]], dtype=np.float32) np_b = np.array([1, 2], dtype=np.float32) np_c = np.dot(np_x, np_w) + np_b x = ng.constant(np_x, [N, D]) w = ng.constant(np_w, [D, H]) b = ng.constant(np_b, [H]) wx = ng.dot(x, w) c = wx + b with executor(c) as ex: result = ex() print(result) print(np_c) assert np.array_equal(result, np_c)
def test_idempotent_axes_a(): """ Test test axes transformations with autodiff, case a, reference test """ with ExecutorFactory() as ex: axes = ng.make_axes([ng.make_axis(3), ng.make_axis(1)]) w = ng.variable(axes, initial_value=np.ones((3, 1))) result = w + w result = ng.cast_axes(result, axes) cost = ng.sum(result, reduction_axes=axes) grad = ng.deriv(cost, w) grad_comp = ex.executor(grad) cost_comp = ex.executor(cost) cost_comp_val = cost_comp() grad_comp_val = grad_comp() grad_comp_np = np.ones((3, 1)) * 2. assert cost_comp_val == 6.0 assert np.array_equal(grad_comp_val, grad_comp_np)
def test_idempotent_axes_b(): """ Test test axes transformations with autodiff, case b, with broadcast applied to the same tensor """ with ExecutorFactory() as ex: axes = ng.make_axes([ng.make_axis(3), ng.make_axis(1)]) w = ng.variable(axes, initial_value=np.ones((3, 1))) l = ng.broadcast(w, axes) r = ng.broadcast(w, axes) result = ng.add(l, r) result = ng.cast_axes(result, axes) cost = ng.sum(result, reduction_axes=axes) grad = ng.deriv(cost, w) grad_comp = ex.executor(grad) cost_comp = ex.executor(cost) assert cost_comp() == 6.0 assert np.array_equal(grad_comp(), np.ones((3, 1)) * 2.)
def test_rolling_window(input_seq, batch_size, seq_len, strides): # This test checks if the rolling window works # We check if the first two samples in each batch are strided by strides # Truncate input sequence such that last section that doesn't fit in a batch # is thrown away input_seq = input_seq[:seq_len * batch_size * (len(input_seq) // seq_len // batch_size)] data_array = {'X': input_seq, 'y': np.roll(input_seq, axis=0, shift=-1)} time_steps = seq_len it_array = SequentialArrayIterator(data_arrays=data_array, time_steps=time_steps, stride=strides, batch_size=batch_size, tgt_key='y', shuffle=False) for idx, iter_val in enumerate(it_array): # Start of the array needs to be time_steps * idx assert np.array_equal(iter_val['X'][0, strides:time_steps], iter_val['X'][1, :time_steps - strides]) assert np.array_equal(iter_val['y'][0, strides:time_steps], iter_val['y'][1, :time_steps - strides])
def test_np_layout_shuffle(): # set up bsz = 8 C, H, W, N = 3, 28, 28, bsz C, R, S, K = 3, 5, 5, 32 # image dim-shuffle np_tf_image = np.random.randn(N, H, W, C) np_ng_image = np_layout_shuffle(np_tf_image, "NHWC", "CDHWN") np_tf_image_reverse = np_layout_shuffle(np_ng_image, "CDHWN", "NHWC") assert np.array_equal(np_tf_image, np_tf_image_reverse) # filter dim-shuffle np_tf_weight = np.random.randn(R, S, C, K) np_ng_weight = np_layout_shuffle(np_tf_weight, "RSCK", "CTRSK") np_tf_weight_reverse = np_layout_shuffle(np_ng_weight, "CTRSK", "RSCK") assert np.array_equal(np_tf_weight, np_tf_weight_reverse)
def test_reduce_max_keepdims(): data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ReduceMax', data), np.max(data, keepdims=True)) assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0,)), np.max(data, keepdims=True, axis=(0,))) assert np.array_equal(import_and_compute('ReduceMax', data, axes=(1,)), np.max(data, keepdims=True, axis=(1,))) assert np.array_equal(import_and_compute('ReduceMax', data, axes=(2,)), np.max(data, keepdims=True, axis=(2,))) assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0, 1)), np.max(data, keepdims=True, axis=(0, 1))) assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0, 2)), np.max(data, keepdims=True, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceMax', data, axes=(1, 2)), np.max(data, keepdims=True, axis=(1, 2))) assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0, 1, 2)), np.max(data, keepdims=True, axis=(0, 1, 2)))
def test_reduce_min(): data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ReduceMin', data), np.min(data, keepdims=True)) assert np.array_equal(import_and_compute('ReduceMin', data, keepdims=0), np.min(data, keepdims=False)) assert np.array_equal(import_and_compute('ReduceMin', data, axes=(1,)), np.min(data, keepdims=True, axis=(1,))) assert np.array_equal(import_and_compute('ReduceMin', data, axes=(1,), keepdims=0), np.min(data, keepdims=False, axis=(1,))) assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 2)), np.min(data, keepdims=True, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 2), keepdims=0), np.min(data, keepdims=False, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 1, 2)), np.min(data, keepdims=True, axis=(0, 1, 2))) assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 1, 2), keepdims=0), np.min(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_mean(): data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ReduceMean', data), np.mean(data, keepdims=True)) assert np.array_equal(import_and_compute('ReduceMean', data, keepdims=0), np.mean(data, keepdims=False)) assert np.array_equal(import_and_compute('ReduceMean', data, axes=(1,)), np.mean(data, keepdims=True, axis=(1,))) assert np.array_equal(import_and_compute('ReduceMean', data, axes=(1,), keepdims=0), np.mean(data, keepdims=False, axis=(1,))) assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 2)), np.mean(data, keepdims=True, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 2), keepdims=0), np.mean(data, keepdims=False, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 1, 2)), np.mean(data, keepdims=True, axis=(0, 1, 2))) assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 1, 2), keepdims=0), np.mean(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_sum(): data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ReduceSum', data), np.sum(data, keepdims=True)) assert np.array_equal(import_and_compute('ReduceSum', data, keepdims=0), np.sum(data, keepdims=False)) assert np.array_equal(import_and_compute('ReduceSum', data, axes=(1,)), np.sum(data, keepdims=True, axis=(1,))) assert np.array_equal(import_and_compute('ReduceSum', data, axes=(1,), keepdims=0), np.sum(data, keepdims=False, axis=(1,))) assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 2)), np.sum(data, keepdims=True, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 2), keepdims=0), np.sum(data, keepdims=False, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 1, 2)), np.sum(data, keepdims=True, axis=(0, 1, 2))) assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 1, 2), keepdims=0), np.sum(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_prod(): data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ReduceProd', data), np.prod(data, keepdims=True)) assert np.array_equal(import_and_compute('ReduceProd', data, keepdims=0), np.prod(data, keepdims=False)) assert np.array_equal(import_and_compute('ReduceProd', data, axes=(1,)), np.prod(data, keepdims=True, axis=(1,))) assert np.array_equal(import_and_compute('ReduceProd', data, axes=(1,), keepdims=0), np.prod(data, keepdims=False, axis=(1,))) assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 2)), np.prod(data, keepdims=True, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 2), keepdims=0), np.prod(data, keepdims=False, axis=(0, 2))) assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 1, 2)), np.prod(data, keepdims=True, axis=(0, 1, 2))) assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 1, 2), keepdims=0), np.prod(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_argmin(): def argmin(ndarray, axis, keepdims=False): res = np.argmin(ndarray, axis=axis) if keepdims: res = np.expand_dims(res, axis=axis) return res data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ArgMin', data, axis=0), argmin(data, keepdims=True, axis=0)) assert np.array_equal(import_and_compute('ArgMin', data, axis=0, keepdims=0), argmin(data, keepdims=False, axis=0)) assert np.array_equal(import_and_compute('ArgMin', data, axis=1), argmin(data, keepdims=True, axis=1)) assert np.array_equal(import_and_compute('ArgMin', data, axis=1, keepdims=0), argmin(data, keepdims=False, axis=1)) assert np.array_equal(import_and_compute('ArgMin', data, axis=2), argmin(data, keepdims=True, axis=2)) assert np.array_equal(import_and_compute('ArgMin', data, axis=2, keepdims=0), argmin(data, keepdims=False, axis=2))
def test_reduce_argmax(): def argmax(ndarray, axis, keepdims=False): res = np.argmax(ndarray, axis=axis) if keepdims: res = np.expand_dims(res, axis=axis) return res data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ArgMax', data, axis=0), argmax(data, keepdims=True, axis=0)) assert np.array_equal(import_and_compute('ArgMax', data, axis=0, keepdims=0), argmax(data, keepdims=False, axis=0)) assert np.array_equal(import_and_compute('ArgMax', data, axis=1), argmax(data, keepdims=True, axis=1)) assert np.array_equal(import_and_compute('ArgMax', data, axis=1, keepdims=0), argmax(data, keepdims=False, axis=1)) assert np.array_equal(import_and_compute('ArgMax', data, axis=2), argmax(data, keepdims=True, axis=2)) assert np.array_equal(import_and_compute('ArgMax', data, axis=2, keepdims=0), argmax(data, keepdims=False, axis=2))
def execute_calculation(operands, first_operand, const_executor): iterations = len(operands) != 1 for i in operands: _operands, expected_result, description = unpack_list(*i) if description: print("Description: ", description) print("Operands: ", _operands) print("Expected result: ", expected_result) flex_result = const_executor(*_operands) try: print("flex_result: {0:.30}".format(float(flex_result))) except TypeError: # exception for arrays np.set_printoptions(precision=30) print("flex_result: {}".format(flex_result)) print("difference: ", flex_result - expected_result) if iterations: assert_allclose(flex_result, expected_result) elif not isinstance(first_operand, np.ndarray): assert flex_result == expected_result else: assert np.array_equal(flex_result, expected_result)
def _kshape(x, k, initial_clustering=None): """ >>> from numpy.random import seed; seed(0) >>> _kshape(np.array([[1,2,3,4], [0,1,2,3], [-1,1,-1,1], [1,2,2,3]]), 2) (array([0, 0, 1, 0]), array([[-1.2244258 , -0.35015476, 0.52411628, 1.05046429], [-0.8660254 , 0.8660254 , -0.8660254 , 0.8660254 ]])) """ m = x.shape[0] if initial_clustering is not None: assert len(initial_clustering) == m, "Initial assigment does not match column length" idx = initial_clustering else: idx = randint(0, k, size=m) print(idx) centroids = np.zeros((k,x.shape[1])) distances = np.empty((m, k)) for _ in range(100): old_idx = idx for j in range(k): centroids[j] = _extract_shape(idx, x, j, centroids[j]) for i in range(m): for j in range(k): distances[i,j] = 1 - max(_ncc_c(x[i], centroids[j])) idx = distances.argmin(1) if np.array_equal(old_idx, idx): break print(idx) return idx, centroids
def _test_FileSourceType2000(self, format, subsize): filename = self._tempfileName('source_2000_%s' % format) complexData = format.startswith('C') typecode = format[1] dataFormat, dataType = self.TYPEMAP[typecode] frames = 4 indata = [self._generateSourceData(format, subsize) for x in xrange(frames)] hdr = bluefile.header(2000, format, subsize=subsize) bluefile.write(filename, hdr, indata) source = sb.FileSource(filename, midasFile=True, dataFormat=dataFormat) sink = sb.DataSink() source.connect(sink) sb.start() outdata = sink.getData(eos_block=True) if complexData: if format == 'CF': outdata = numpy.array(outdata, dtype=numpy.float32).view(numpy.complex64) outdata = numpy.reshape(outdata, (-1, subsize)) elif format == 'CD': outdata = numpy.array(outdata, dtype=numpy.float64).view(numpy.complex128) outdata = numpy.reshape(outdata, (-1, subsize)) else: outdata = numpy.reshape(outdata, (-1, subsize, 2)) self.assertEqual(sink.sri().mode, 1) else: self.assertEqual(sink.sri().mode, 0) self.assertTrue(numpy.array_equal(indata, outdata), msg="Format '%s' %s != %s" % (format, indata, outdata))
def merge_h5(in_filenames, out_filename): """ Merge a list of h5 files """ out_h5 = h5.File(out_filename, 'a') for filename in in_filenames: if filename is None: continue in_h5 = h5.File(filename, 'r') for name in in_h5.keys(): # If the dataset already exists, # They must be equal or one must be all-zero. if name in out_h5.keys(): src_data, dest_data = in_h5[name][()], out_h5[name][()] if src_data.dtype.kind != 'S' and dest_data.dtype.kind != 'S': # Both numeric if not np.any(src_data): # Source is all zero. Do nothing. continue elif not np.any(dest_data): # Dest is all zero. Overwrite. del out_h5[name] h5.h5o.copy(in_h5.id, name, out_h5.id, name) else: # Both non-zero. Assert equality and do nothing. assert np.array_equal(src_data, dest_data) else: # Either are non-numeric. Assert equality and do nothing. assert np.array_equal(src_data, dest_data) else: # Only exists in src. Copy to dest. h5.h5o.copy(in_h5.id, name, out_h5.id, name) out_h5.flush() out_h5.close()
def Verify(**kwargs): msg, A, m, n, sd, q, eta, z, c, kappa = kwargs['msg'], kwargs['A'], kwargs['m'], kwargs['n'], kwargs['sd'], kwargs['q'], kwargs['eta'], kwargs['z'], kwargs['c'], kwargs['kappa'] B2 = eta*sd*np.sqrt(m) reduced_prod = util.vector_to_Zq(np.matmul(A,z) + q*c, 2*q) #print np.sqrt(z.dot(z)),B2 #print LA.norm(z,np.inf),float(q)/4 if np.sqrt(z.dot(z)) > B2 or LA.norm(z,np.inf) >= float(q)/4: return False if np.array_equal(c, hash_iterative(np.array_str(reduced_prod)+msg, n, kappa)): return True return False
def test_main(self): # set up mask = np.asarray([ [0, 0, 0, 1, 1], [0, 0, 0, 1, 0], [0, 1, 1, 1, 1], [0, 0, 0, 0, 0] ]) mask2 = np.ones((4, 5)) masks = np.array([mask]) # test area assert area(encode(mask)) == 7 assert area(encode(masks)[0]) == 7 assert np.array_equal(decode(encode(mask)), mask) # test iou assert isinstance(iou(encode(masks), encode(masks), [0]), np.ndarray) assert iou(encode(mask), encode(mask), [0]) == 1 assert equal(iou(encode(np.array([mask, mask])), encode(mask2), [0]), 7.0/20).all() # test toBbox assert isinstance(toBbox(masks), np.ndarray) assert np.equal(toBbox(encode(mask)), np.array([1, 0, 4, 3])).all() assert np.equal(toBbox(encode(mask2)), np.array([0, 0, 5, 4])).all()
