def find_solves_of_codes(l1, l2, r1, penalty=0, it=False): solves = [] # Find all codes # codes, _ = compress_bf(l1+l2) codes = get_PISA_codes(l1 + l2, return_loads=True) if it: code, new_code = solve_with_iterations(l1, l2, r1) else: code = None if code: # Decompress the code d = decompress(new_code) # Add them to the answers, only if the found string starts with r1 if d[:len(r1)] == r1: complexity = analogy_load(code) + analogy_load(new_code) \ + penalty solves.append((d[len(r1):], round(complexity, 2), code, new_code)) for code, load in codes: # Replace the symbols in the codes new_codes = replace_left_right(code, l1, l2, r1) for new_code in new_codes: # Decompress the codes d = decompress(new_code) # Add them to the answers, only if the found string starts with r1 if d[:len(r1)] == r1: complexity = analogy_load(code) + analogy_load(new_code) \ + penalty solves.append((d[len(r1):], round(complexity, 2), code, new_code)) return solves
def test_alternation(self): self.assertEqual(decompress('<(a)>/<(b)(c)(d)>'), 'abacad') self.assertEqual(decompress('<(a)(b)(c)>/<(d)>'), 'adbdcd') self.assertEqual(decompress('<(<(a)(b)>/<(d)>)>/<(e)(f)>'), 'adbdeadbdf') self.assertEqual(decompress('<<((a))((b))>/<((d))>>/<(e)>'), 'aedebede') self.assertEqual(decompress('<(A)>/<(<(BB)(C)>/<(A)>)(B)>'), 'ABBACAAB')
def test_analogies(self): tests = { ('AAAB', 'CBBB', 'EEEEEF'): 'GFFFFF', ('ABA', 'AABBAA', 'AABBAA'): 'AAABBBAAA', ('ABBACCC', 'ADDDD', 'IJJJIKKKK'): 'ILLLLL', } for test, answer in tests.items(): l1, l2, r1 = test code, new_code = solve_with_iterations(l1, l2, r1) self.assertEqual(decompress(code), l1 + l2) self.assertEqual(decompress(new_code), r1 + answer)
def runTest(self): """Positive test case""" check = [ "CS311_Assn5_writeup.pdf", "ProcBenchmarker.sh", "ThreadBenchmarker", "makefile", "proj5_multi_proc.c", "proj5_threadstest.c", ] decompressor.decompress(FILEPATH) files = os.listdir(FILEPATH) for c in check: self.assertIn(c, files)
def test_pisa(self): for i in range(50): N = randint(2, 20) s = ''.join([choice(['A', 'B', 'C', 'D']) for _ in range(N)]) g = Graph(s) encode(g) code, _ = g.edges[g.nodes[0]][g.nodes[-1]] self.assertEqual(s, decompress(code))
def test_symmetry(self): self.assertEqual(decompress('S[(a)(b)]'), 'abba') self.assertEqual(decompress('S[(a),(b)]'), 'aba') self.assertEqual(decompress('S[((a)),((b))]'), '(a)(b)(a)') self.assertEqual(decompress('S[(a)(b),(c)]'), 'abcba') self.assertEqual(decompress('S[(d)(S[(a),(b)]),(c)]'), 'dabacabad') self.assertEqual(decompress('S[S[((a)),((b))],(c)]'), 'abacaba')
def solve_with_iterations(l1, l2, r1): # Find structures of iteration parameters for different parts of analogy iters_l1, pars_l1, sym_l1, struct_l1 = find_it_structure(l1) it_r1, pars_r1, sym_r1, struct_r1 = find_it_structure(r1) iters_l2, pars_l2, sym_l2, struct_l2 = find_it_structure(l2) iters_orig, pars_l, sym_l, struct_l = find_it_structure(l1+l2) # Check whether the structure of l1+l2 created unwanted parameters. # Eg structure of BBAA:AABB creates unwanted 4*(A) # If so, replace the structure with the structure of l1 + structure of l2 if any(p not in pars_l1 + pars_l2 for p in pars_l): iters_orig = iters_l1 + iters_l2 pars_l = pars_l1 + pars_l2 sym_l = sym_l1 + sym_l2 struct_l = struct_l1 + struct_l2 pars_l1 = get_pars(struct_l1) pars_r1 = get_pars(struct_r1) if len(pars_l1) != len(pars_r1): return None, None struct_l = add_distances_symbols(struct_l, pars_l1, False) pars_l = get_pars(struct_l) full_code = replace_it_structure(struct_l, pars_l1, pars_r1) full_code = remove_distances(full_code) full_code = decompress(full_code) rep_pars = get_pars(full_code) if '0' in rep_pars: return None, None it_r1 = add_new_iterations(sym_l, sym_r1, it_r1, rep_pars) for n in rep_pars: replaced = False for it in it_r1: if it.startswith(n): if n == '1': rep = it[3:-1] else: rep = it full_code = full_code.replace('{' + n + '}', rep, 1) replaced = True elif n == '1' and it[0].isalpha(): full_code = full_code.replace('{' + n + '}', it, 1) replaced = True full_code = remove_distances(full_code) return ''.join(iters_orig), full_code
data_X = data_X[indices, :, :] data_Y = data_Y[indices] batch_loss_sum = 0.0 batch_accuracy_sum = 0.0 log.i('******************** Epoch ' + str(epoch + 1)) for step in range(batch_count): batch_x, batch_y = data_X[step * batch_size:(step + 1) * batch_size], data_Y[step * batch_size:(step + 1) * batch_size] batch_x = decompress(batch_x, dimension_count) batch_y = get_one_hot_vector(batch_size, batch_y) batch_y = np.repeat(batch_y, input_size, axis=0) assert (batch_x.shape[0] == batch_y.shape[0] ) # raise exception if they have different sizes session.run(training_op, feed_dict={X: batch_x, Y: batch_y}) batch_loss = session.run(loss_op, feed_dict={ X: batch_x, Y: batch_y }) # calculate batch loss batch_loss_sum += batch_loss batch_result_list = session.run(tf.argmax(prediction, 1),
def decompress(data, size): try: return decompressor.decompress(data, size) except OSError: return pydecompressor.decompress(data, size)
def runTest(self): """Wrong file type""" decompressor.decompress(WRONG_TYPE) self.assertRaises(tarfile.TarError)
def runTest(self): """File not found""" decompressor.decompress(NOT_FOUND) self.assertRaises(tarfile.TarError)
def test_iteration(self): self.assertEqual(decompress('2*(a)'), 'aa') self.assertEqual(decompress('2*((a))'), '(a)(a)') self.assertEqual(decompress('2*(3*(a))'), 'aaaaaa') self.assertEqual(decompress('11*(a)'), 'aaaaaaaaaaa')
def compress_decompress_compare(self, strings): for string in strings: answers, _ = compress_bf(string) for ans in answers: self.assertEqual(decompress(ans), string)
def test_combined(self): self.assertEqual(decompress('S[(2*(ab))(c)]'), 'ababccabab') self.assertEqual(decompress('S[2*((a)(b))(c)]'), 'ababccbaba') self.assertEqual(decompress('<2*((a)(b))>/<(f)>'), 'afbfafbf') self.assertEqual(decompress('3*(S[(A),(B)])'), 'ABAABAABA') self.assertEqual(decompress('<(A)>/<S[((B)),((C))]>'), 'ABACAB')
def runTest(self): """Negative test case""" decompressor.decompress(EMPTY_FILEPATH) files = os.listdir(EMPTY_FILEPATH) self.assertEqual(files, [])
def run(folder): gf = agGetSubFolders.agGetSubFolders(folder) folders = gf.getFolders() for fold in folders: decompressor.decompress(fold)
def classify_apps(apk_folder_directory): ''' Classify apps as benign or malicious apps. Parameters ---------- apk_folder_directory : the directory of the folder containing APKs for scanning Returns ------- prediction_dictionary : a dictionary recording classification results (keys for APK names and values for corresponding results - 0 represents a benign app, while 1 represents malware) ''' data_X, data_Y, package_name_list = load_data(apk_folder_directory) learning_rate = 0.00001 batch_size = 1 display_step = 1 dimension_count = 86645 input_size = 50 class_count = 2 tf.disable_eager_execution() X = tf.placeholder(tf.float32, [None, input_size, dimension_count, 1]) Y = tf.placeholder(tf.float32, [None, class_count]) prediction = conv_net(X) # build the net init_op = tf.global_variables_initializer( ) # intialise the variables to assign their default values saver = tf.train.Saver() with tf.Session() as session: session.run(init_op) saver.restore(session, get_cnn_trainer_saver_path()) batch_count = int(data_X.shape[0] / batch_size) prediction_dictionary = {} for step in range(batch_count): batch_x = data_X[step * batch_size:(step + 1) * batch_size] batch_y = data_Y[step * batch_size:(step + 1) * batch_size] batch_package_name_list = package_name_list[step * batch_size:(step + 1) * batch_size] batch_x = decompress(batch_x, dimension_count) batch_y = get_one_hot_vector(batch_size, batch_y) batch_result_list = session.run(tf.argmax(prediction, 1), feed_dict={X: batch_x}) package_name_index = 0 for start_index in range(0, len(batch_result_list), input_size): prediction_dictionary[ batch_package_name_list[package_name_index]] = np.int16( batch_result_list[start_index:start_index + input_size].max() ).item( ) # convert the "numpy.int64" type to the native "int" type package_name_index += 1 return prediction_dictionary