def testSameDim(self): A = CuMatrix() B = CuMatrix() self.assertTrue(same_dim_cu_matrix(A, B)) A = CuMatrix.from_size(10, 10) B = CuMatrix.from_size(10, 9) self.assertFalse(same_dim_cu_matrix(A, B))
def testcopy_from_mat(self): for i in range(1, 10): rows, cols = 10 * i, 5 * i A = Matrix(rows, cols) A.set_randn_() B = CuMatrix.from_size(*A.shape) B.copy_from_mat(A) self.assertAlmostEqual(A.sum(), B.sum(), places=4) A = CuMatrix.from_size(rows, cols) A.set_randn() B = CuMatrix.from_size(rows, cols) B.copy_from_cu_mat(A) self.assertAlmostEqual(A.sum(), B.sum(), places=4)
def testSwap(self): for i in range(10): dim = (10 * i, 4 * i) M = Matrix(np.random.random(dim)) A = CuMatrix.from_matrix(M) B = CuMatrix.from_size(A.num_rows(), A.num_cols()) B.Swap(A) self.assertAlmostEqual(A.sum(), B.sum(), places=4) #Kaldi's precision is aweful self.assertAlmostEqual(M.sum(), B.sum(), places=4) #Kaldi's precision is aweful C = CuMatrix.from_size(M.shape[0], M.shape[1]) C.SwapWithMatrix(M) self.assertAlmostEqual(B.sum(), C.sum(), places=4) #Kaldi's precision is aweful
def testNew(self): A = CuMatrix() self.assertIsNotNone(A) self.assertEqual(0, A.num_rows()) self.assertEqual(0, A.num_cols()) dim = A.dim() self.assertEqual(0, dim.rows) self.assertEqual(0, dim.cols) A = CuMatrix.from_size(10, 10) self.assertIsNotNone(A) self.assertEqual(10, A.num_rows()) self.assertEqual(10, A.num_cols()) dim = A.dim() self.assertEqual(10, dim.rows) self.assertEqual(10, dim.cols) A = CuMatrix.from_matrix(Matrix([[2, 3], [5, 7]])) self.assertIsNotNone(A) self.assertEqual(2, A.num_rows()) self.assertEqual(2, A.num_cols()) B = CuMatrix.from_other(A) self.assertIsNotNone(B) self.assertEqual(2, B.num_rows()) self.assertEqual(2, B.num_cols())
def test_nnet_compute(self): gen_config = NnetGenerationOptions() test_collapse_model = random.choice([True, False]) configs = generate_config_sequence(gen_config) nnet = Nnet() for j, config in enumerate(configs): # print("Input config[{}]:".format(j)) # print(config) istrm = istringstream.from_str(config) nnet.read_config(istrm) request = ComputationRequest() inputs = compute_example_computation_request_simple(nnet, request) if test_collapse_model: set_batchnorm_test_mode(True, nnet) set_dropout_test_mode(True, nnet) compiler = Compiler(request, nnet) opts = CompilerOptions() computation = compiler.create_computation(opts) nnet_collapsed = Nnet.from_other(nnet) if test_collapse_model: collapse_config = CollapseModelConfig() collapse_model(collapse_config, nnet_collapsed) compiler_collapsed = Compiler(request, nnet_collapsed) computation_collapsed = compiler_collapsed.create_computation(opts) computation_collapsed.compute_cuda_indexes() ostrm = ostringstream() computation.print_computation(ostrm, nnet) # print("Generated computation:") # print(ostrm.to_str()) check_config = CheckComputationOptions() check_config.check_rewrite = True checker = ComputationChecker(check_config, nnet, computation) checker.check() if random.choice([True, False]): opt_config = NnetOptimizeOptions() optimize(opt_config, nnet, max_output_time_in_request(request), computation) ostrm = ostringstream() computation.print_computation(ostrm, nnet) # print("Optimized computation:") # print(ostrm.to_str()) compute_opts = NnetComputeOptions() compute_opts.debug = random.choice([True, False]) computation.compute_cuda_indexes() computer = NnetComputer(compute_opts, computation, nnet, nnet) for i, ispec in enumerate(request.inputs): temp = CuMatrix.from_matrix(inputs[i]) print("Input sum:", temp.sum()) computer.accept_input(ispec.name, temp) computer.run() output = computer.get_output_destructive("output") print("Output sum:", output.sum()) if test_collapse_model: computer_collapsed = NnetComputer(compute_opts, computation_collapsed, nnet_collapsed, nnet_collapsed) for i, ispec in enumerate(request.inputs): temp = CuMatrix.from_matrix(inputs[i]) computer_collapsed.accept_input(ispec.name, temp) computer_collapsed.run() output_collapsed = computer_collapsed.get_output_destructive( "output") print("Output sum [collapsed]:", output_collapsed.sum()) self.assertTrue( approx_equal_cu_matrix(output, output_collapsed), "Regular and collapsed computation outputs differ.") output_deriv = CuMatrix.from_size(output.num_rows(), output.num_cols()) output_deriv.set_randn() if request.outputs[0].has_deriv: computer.accept_input("output", output_deriv) computer.run() for i, ispec in enumerate(request.inputs): if ispec.has_deriv: in_deriv = computer.get_output_destructive(ispec.name) print( "Input-deriv sum for input {} is:".format(ispec.name), in_deriv.sum())