def calculation_helper(self, p, q, r, tsize): m1 = np.random.rand(p, q) m2 = np.random.rand(q, r) m3 = np.matmul(m1, m2) _m1 = _matrix.Matrix(m1) _m2 = _matrix.Matrix(m2) tstart = time.clock() ret_naive = _matrix.multiply_naive(_m1, _m2) tnaive = time.clock() - tstart tstart = time.clock() ret_tile = _matrix.multiply_tile(_m1, _m2, tsize) ttile = time.clock() - tstart tstart = time.clock() ret_mkl = _matrix.multiply_mkl(_m1, _m2) tmkl = time.clock() - tstart assert m3.shape[0] == ret_naive.nrow and m3.shape[1] == ret_naive.ncol assert m3.shape[0] == ret_tile.nrow and m3.shape[1] == ret_tile.ncol assert m3.shape[0] == ret_mkl.nrow and m3.shape[1] == ret_mkl.ncol assert (self.is_close_to_equal(m3, ret_naive, p, r)) assert (self.is_close_to_equal(m3, ret_tile, p, r)) assert (self.is_close_to_equal(m3, ret_mkl, p, r)) with open('performance.txt', 'w') as f: f.write('multiply_naive: {}\n'.format(tnaive)) f.write('multiply_tile: {}\n'.format(ttile)) f.write('multiply_mkl: {}\n'.format(tmkl)) f.write('tile speed-up over naive: {}\n'.format(tnaive / ttile)) f.write('MKL speed-up over naive: {}\n'.format(tnaive / tmkl))
def test_speed(): mat1 = m.Matrix(largesize, largesize) mat2 = m.Matrix(largesize, largesize) fp = open("performance.txt", "a") for x in range( largesize ): for y in range( largesize ): mat1[x,y] = random.random() mat2[x,y] = random.random() t_naive = time.time() naive = m.multiply_naive(mat1, mat2) t_naive = time.time() - t_naive fp.write('multiply_naive use ' + str(t_naive) + 's\n' ) tilesize = 1 t_tilemin = t_naive * 2 while tilesize * tilesize <= largesize : tilesize *= 2 t_tile = time.time() tile = m.multiply_tile(mat1, mat2, tilesize) t_tile = time.time() - t_tile fp.write('multiply_tile use ' + str(t_tile) +'s with tile size ' + str(tilesize) + '\n' ) if t_tilemin > t_tile : t_tilemin = t_tile t_mkl = time.time() mkl = m.multiply_mkl(mat1, mat2) t_mkl = time.time() - t_mkl fp.write('multiply_mkl use ' + str(t_mkl) + 's\n' ) fp.close() assert t_naive * 0.8 > t_tilemin
def calculation_helper(self, p, q, r, tsize): m1 = np.random.rand(p, q) m2 = np.random.rand(q, r) m3 = np.matmul(m1, m2) _m1 = _matrix.Matrix(m1) _m2 = _matrix.Matrix(m2) start = self.time_report(-1) naive = _matrix.multiply_naive(_m1, _m2) tnaive = self.time_report(start) start = self.time_report(-1) tile = _matrix.multiply_tile(_m1, _m2, tsize) ttile = self.time_report(start) start = self.time_report(-1) mkl = _matrix.multiply_mkl(_m1, _m2) tmkl = self.time_report(start) assert m3.shape[0] == naive.nrow and m3.shape[1] == naive.ncol assert m3.shape[0] == tile.nrow and m3.shape[1] == tile.ncol assert m3.shape[0] == mkl.nrow and m3.shape[1] == mkl.ncol assert(self.is_close_to_equal(m3, naive, p, r)) assert(self.is_close_to_equal(m3, tile, p, r)) assert(self.is_close_to_equal(m3, mkl, p, r)) f = open("performance.txt", "w") f.write('multiply_naive costs: {} seconds\n'.format(tnaive)) f.write('multiply_tile costs: {} seconds\n'.format(ttile)) f.write('multiply_mkl costs: {} seconds\n'.format(tmkl)) f.write('tile speed-up over naive: {}\n'.format(tnaive / ttile)) f.write('MKL speed-up over naive: {}\n'.format(tnaive / tmkl)) f.close()
def odd_tile_size(): matrix_size = 3 A_content = np.eye(matrix_size) A = _matrix.Matrix(A_content) # print(A) B_content = np.arange(1, matrix_size**2 + 1).reshape(matrix_size, matrix_size) B = _matrix.Matrix(B_content) print(_matrix.multiply_tile(A, B, 2))
def make_matrices(self, size): mat1 = _matrix.Matrix(size, size) mat2 = _matrix.Matrix(size, size) mat3 = _matrix.Matrix(size, size) for it in range(size): for jt in range(size): mat1[it, jt] = it * size + jt + 1 mat2[it, jt] = it * size + jt + 1 mat3[it, jt] = 0 return mat1, mat2, mat3
def test_multiply_naive(): np.random.seed(5555) a = np.random.random((1000, 1000)) b = np.random.random((1000, 1000)) mat_a = _matrix.Matrix(a) mat_b = _matrix.Matrix(b) mat_ret = _matrix.multiply_naive(mat_a, mat_b) assert mat_ret.nrow == mat_a.nrow assert mat_ret.ncol == mat_b.ncol assert np.array(mat_ret) == pytest.approx(np.matmul(a, b))
def test_tile(): mat1 = m.Matrix(size, size) mat2 = m.Matrix(size, size) np_mat = np_matrix(size, size) copy_matrix(mat1, np_mat, size, size) copy_matrix(mat2, np_mat, size, size) mat_tile = m.multiply_tile(mat1, mat2, 8) mat_mkl = m.multiply_mkl(mat1, mat2) for i in range(size): for j in range(size): npt.assert_equal(mat_tile[i, j], mat_mkl[i, j])
def test_generate_cipher(self): origin = Image.open('testing/message.png') origin = origin.convert('1') width=origin.size[0]*2 height=origin.size[1]*2 pix = numpy.array(origin) _m1 = _matrix.Matrix(pix) out_image_B = Image.new('1', (width, height)) b = numpy.array(out_image_B) _m2 = _matrix.Matrix(numpy.array(Image.open('testing/secret.png').convert('1'))) _m3 = _matrix.Matrix(b) res = _matrix.generate_cipher(_m1,_m2,_m3,int(width/2),int(height/2)) res = numpy.asarray(_matrix.to_matrix(res)) target = numpy.array(Image.open('testing/ciphered.png').convert('1')) assert self.compare_helper(res,target) == 1
def create_matrix(self, m, n): # setup matrix A = _matrix.Matrix(m, n) for i in range(m): for j in range(n): A[i, j] = random.randint(0, 1000) return A
def test_caculation(self): size = 1000 np_mat1 = np.random.random(size * size) np_mat2 = np.random.random(size * size) mat1 = _matrix.Matrix(size, size, np_mat1.tolist()) mat2 = _matrix.Matrix(size, size, np_mat2.tolist()) start = time.time() ret_naive = _matrix.multiply_naive(mat1, mat2) end = time.time() navie_time = end - start print('multiply_naive runtime = {0:2.4f} seconds'.format(end - start)) start = time.time() ret_tile = _matrix.multiply_tile(mat1, mat2, 100) end = time.time() tile_time = end - start print(end - start) start = time.time() ret_mkl = _matrix.multiply_mkl(mat1, mat2) end = time.time() mkl_time = end - start print(end - start) self.assertEqual(size, ret_naive.nrow) self.assertEqual(size, ret_naive.ncol) self.assertEqual(size, ret_mkl.nrow) self.assertEqual(size, ret_mkl.ncol) for i in range(ret_naive.nrow): for j in range(ret_naive.ncol): self.assertNotEqual(mat1[i, j], ret_mkl[i, j]) self.assertEqual(ret_naive[i, j], pytest.approx(ret_mkl[i, j], abs=1e-05)) self.assertEqual(ret_tile[i, j], pytest.approx(ret_mkl[i, j], abs=1e-05)) fp = open("performance.txt", "w") fp.write( 'multiply_naive runtime = {0:2.4f} seconds\n'.format(navie_time)) fp.write( 'multiply_tile runtime = {0:2.4f} seconds\n'.format(tile_time)) fp.write('multiply_mkl runtime = {0:2.4f} seconds\n'.format(mkl_time)) fp.close
def make_matrices(self, row, col): matrix = _matrix.Matrix(row, col) darray = np.zeros((row, col)) for i in range(row): for j in range(col): v = random.randint(0, 10000) matrix[i, j] = v darray[i, j] = v return matrix, darray
def test_copy(): mat1 = m.Matrix(smallsize, smallsize) for x in range( smallsize ): for y in range( smallsize ): mat1[x,y] = x*y mat2 = mat1 assert mat2[ smallsize - 1 , smallsize - 1 ] == ( smallsize - 1 )*( smallsize - 1 )
def test_compare(): mat1 = m.Matrix(smallsize, smallsize) for x in range( smallsize ): for y in range( smallsize ): mat1[x,y] = x*y mat2 = mat1 assert mat1 == mat2
def different_tile_size(): matrix_size = 512 A_content = np.eye(matrix_size) A = _matrix.Matrix(A_content) # print(A) B_content = np.arange(1, matrix_size**2 + 1).reshape(matrix_size, matrix_size) B = _matrix.Matrix(B_content) # print(B) MKL_MM = _matrix.multiply_mkl(A, B) for p in range(1, 9): tiled_MM = _matrix.multiply_tile(A, B, 2**p) assert tiled_MM == MKL_MM for p in [14, 22, 56]: tiled_MM = _matrix.multiply_tile(A, B, p) assert tiled_MM == MKL_MM
def test_matrix(self): size = 1000 tile_width = random.randint(10, 100) mat1 = _matrix.Matrix(size, size) mat2 = _matrix.Matrix(size, size) for i in range(size): for j in range(size): mat1[i, j] = random.randint(1, 100) mat2[i, j] = random.randint(1, 100) starttime = time.time() ret_naive = _matrix.multiply_naive(mat1, mat2) endtime = time.time() naive_time = endtime - starttime starttime = time.time() ret_tile = _matrix.multiply_tile(mat1, mat2, tile_width) endtime = time.time() tile_time = endtime - starttime starttime = time.time() ret_mkl = _matrix.multiply_naive(mat1, mat2) endtime = time.time() mkl_time = endtime - starttime f = open('performance.txt', 'w') f.writelines([ 'tile_width = ', repr(tile_width), '\nnaive costs ', repr(naive_time), ' seconds.\ntile costs ', repr(tile_time), ' seconds.\nmkl costs ', repr(mkl_time), ' seconds.\ntile/naive = ', repr(tile_time / naive_time) ]) f.close() for a in range(ret_naive.nrow): for b in range(ret_naive.ncol): self.assertEqual(ret_naive[a, b], ret_tile[a, b]) self.assertEqual(ret_tile[a, b], ret_mkl[a, b]) self.assertEqual(ret_naive[a, b], ret_mkl[a, b]) self.assertLess(tile_time / naive_time, 0.8)
def performance(): matrix_size = 512 A_content = np.eye(matrix_size) A = _matrix.Matrix(A_content) # print(A) B_content = np.arange(1, matrix_size**2 + 1).reshape(matrix_size, matrix_size) B = _matrix.Matrix(B_content) for p in range(4, 8): tsize = 2**p ns = dict(_matrix=_matrix, mat1=A, mat2=B, tsize=tsize) t_tile = timeit.Timer('_matrix.multiply_tile(mat1, mat2, tsize)', globals=ns) t_naive = timeit.Timer('_matrix.multiply_naive(mat1, mat2)', globals=ns) time_tile = min(t_tile.repeat(10, 1)) time_naive = min(t_naive.repeat(10, 1)) ratio = time_tile / time_naive print(tsize, ratio)
def test_correct(): mat1 = m.Matrix(smallsize, smallsize) mat2 = m.Matrix(smallsize, smallsize) for x in range( smallsize ): for y in range( smallsize ): mat1[x,y] = x* y mat2[x,y] = x * y naive = m.multiply_naive(mat1, mat2) tile = m.multiply_tile(mat1, mat2, 32) mkl = m.multiply_mkl(mat1, mat2) for x in range( smallsize ): for y in range( smallsize ): print( tile[x,y] ) assert tile == naive assert naive == mkl assert tile == mkl
def nd_array_test(): size = 100 mat = _matrix.Matrix(size, size) for it in range(size): for jt in range(size): mat[it, jt] = it * size + jt + 1 np_array = np.array(mat, copy=False) np_array[0, 0] = 10 print(np_array[0, 0], mat[0, 0]) np_array[1, 0] = 200 print(np_array[1, 0], mat[1, 0]) np_array.fill(0) print(np_array[0, 0], mat[0, 0]) mat.array.fill(-1) print(mat.array[0, 0], mat[0, 0])
def test_ndarray(self): size = 100 mat = _matrix.Matrix(size, size) for it in range(size): for jt in range(size): mat[it, jt] = it * size + jt + 1 for i in range(size): for j in range(size): self.assertNotEqual(0, mat[i, j]) self.assertTrue(isinstance(mat.array, np.ndarray)) self.assertEqual((size, size), mat.array.shape) self.assertEqual(np.dtype('float64'), mat.array.dtype) mat.array.fill(0) for i in range(size): for j in range(size): self.assertEqual(0, mat[i, j])
def test_attributes(): mat = m.Matrix(2, 3) npt.assert_equal(2, mat.nrow) npt.assert_equal(3, mat.ncol) flag = True try: mat.nrow == 2 except AttributeError: pass except: flag = False try: mat.ncol == 3 except AttributeError: pass except: flag = False return npt.assert_equal(flag, True)
BOLD = '\033[1m' UNDERLINE = '\033[4m' if __name__ == "__main__": # benchmark configuration # n: the matrix with n * n # tsize: the tiling size of tile version # repeat: number of testing, take the `min` executation time n = 1000 tsize = 64 repeat = 5 # setup matrix print("setup random matrix with {} * {}...".format(n, n)) A = _matrix.Matrix(n, n) B = _matrix.Matrix(n, n) for i in range(n): for j in range(n): A[i, j] = random.randint(0, 1000) B[i, j] = random.randint(0, 1000) # doing benchmark print("doing benchmark ... repeat {} times".format(repeat)) min_naive_time = float("inf") min_dgemm_time = float("inf") min_tile_time = float("inf") for i in range(repeat): # naive (C1, naive_time) = benchmark(_matrix.multiply_naive, A, B)
try: img = Image.open(infile) except IOError as e: logging.fatal( "Fatal error: I/O error while loading message image '%s' (%s)" % (args.message, str(e))) sys.exit(1) #f, e = os.path.splitext(infile) uuid = uuid.uuid1() logging.info('UUID: %s' % (uuid)) if args.resize: img = img.resize(args.resize, Image.ANTIALIAS) img = img.convert('1') #convert image to 1 bit pix = numpy.array(img) _m1 = _matrix.Matrix(pix) # prepare two empty matrix width = img.size[0] * 2 height = img.size[1] * 2 out_image_A = Image.new('1', (width, height)) out_image_B = Image.new('1', (width, height)) a = numpy.array(out_image_A) b = numpy.array(out_image_B) _m2 = _matrix.Matrix(a) _m3 = _matrix.Matrix(b) f = args.format.lower() if not f == 'jpeg' and not f == 'png': logging.fatal("Not support format type: '%s' , only supprt jpeg or png" % (f))
def test_setitem(): mat = m.Matrix(2, 3) for i in range(2): for j in range(2): mat[i, j] = 2.3
def test_getitem(): mat = m.Matrix(2, 3) for i in range(2): for j in range(3): tmp = mat[i, j]
def test_no_match_size(): npt.assert_raises(IndexError, m.multiply_naive, m.Matrix(2, 3), m.Matrix(2, 3)) npt.assert_raises(IndexError, m.multiply_tile, m.Matrix(2, 3), m.Matrix(2, 3), 2)
SIZE = 1000 REPEAT = 5 FILE_NAME = "performance.txt" def benchmark(func, A, B, *args): start = time.time() C = func(A, B, *args) end = time.time() return end - start if __name__ == "__main__": # set up matrix mat1 = _matrix.Matrix(SIZE, SIZE) mat2 = _matrix.Matrix(SIZE, SIZE) for i in range(SIZE): for j in range(SIZE): mat1[i, j] = random.uniform(0, 1000) mat2[i, j] = random.uniform(0, 1000) # start bench min_mkl_time = float('inf') min_tile_time = float('inf') for i in range(REPEAT): temp = benchmark(_matrix.multiply_mkl, mat1, mat2) if min_mkl_time > temp: min_mkl_time = temp temp = benchmark(_matrix.multiply_tile, mat1, mat2, 17) if min_tile_time > temp: min_tile_time = temp # output to file with open(FILE_NAME, "w") as f:
log( f'test case {idx+1:2}/{len(test_cases):2}: , dim= {m:4} x {n:4} x {k:4} (repeat={times})', f) total_size = m * k population_size = 100 random_population = [ int(random.randrange(-500, 1000)) for _ in range(int(population_size)) ] naive_list = [0 for _ in range(times)] MKL_list = [0 for _ in range(times)] for i in range(times): A = _matrix.Matrix(m, n) A_content = random.choices(random_population, k=m * n) copy_to_mat(A, m, n, A_content) B = _matrix.Matrix(n, k) B_content = random.choices(random_population, k=n * k) copy_to_mat(B, n, k, B_content) naive_result, naive_time = naive_MM(A, B) MKL_result, MKL_time = MKL_MM(A, B) assert naive_result == MKL_result naive_list[i] = naive_time MKL_list[i] = MKL_time naive_runtime[idx] = sum(naive_list) / len(naive_list)
def test_insert(): mat1 = m.Matrix(smallsize, smallsize) mat1[ 0,0 ] = 100 assert mat1[ 0,0 ] == 100