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 decompress(data, size):
try:
return decompressor.decompress(data, size)
except OSError:
return pydecompressor.decompress(data, size)
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
