def nondiagonal_block_mp(self, workers, labEnc_Xi, enc_mask_A):
new_block = None
# Matrix multiplication(labEnc_Xj, labEnc_Xi)
t_labEnc_Xi = transpose(labEnc_Xi)
num_dimension = len(t_labEnc_Xi)
for labEnc_Xj in self.list_labEnc_Xj:
t_labEnc_Xj = transpose(labEnc_Xj)
splitedmatrice = []
for vector1 in t_labEnc_Xj:
for vector2 in t_labEnc_Xi:
#splitedmatrice.append([vector1, vector2])
interval = len(vector1)//10
for i in range(0, len(vector1), interval):
splitedmatrice.append([vector1[i:i + interval], vector2[i:i + interval]])
temp = workers.map(self.dotproduct, splitedmatrice)
subnew_block = []
for i in range(0, len(temp), 10):
subnew_block.append(sum(temp[i:i + 10]))
subnew_block = list(zip(*[iter(subnew_block)]*num_dimension)) # reshape
if new_block is None:
new_block = subnew_block
else:
new_block += subnew_block
# remove mask(sum(Enc(b*b')))
#assert len(new_block) == len(enc_mask_A) and len(new_block[-1]) == len(enc_mask_A[-1])
new_block = [list(map(add, enc_value, enc_mask)) for enc_value, enc_mask in zip(new_block, enc_mask_A)]
return new_block
def invMixColumns(state: bytearray, rotate=False) -> bytearray:
if rotate:
state = transpose(state)
for col in range(Nb):
m0 = matrix_element(state, col, 0)
m1 = matrix_element(state, col, 1)
m2 = matrix_element(state, col, 2)
m3 = matrix_element(state, col, 3)
s0 = ffMultiply(0x0e, m0) ^ ffMultiply(0x0b, m1) ^ \
ffMultiply(0x0d, m2) ^ ffMultiply(0x09, m3)
s1 = ffMultiply(0x09, m0) ^ ffMultiply(0x0e, m1) ^ \
ffMultiply(0x0b, m2) ^ ffMultiply(0x0d, m3)
s2 = ffMultiply(0x0d, m0) ^ ffMultiply(0x09, m1) ^ \
ffMultiply(0x0e, m2) ^ ffMultiply(0x0b, m3)
s3 = ffMultiply(0x0b, m0) ^ ffMultiply(0x0d, m1) ^ \
ffMultiply(0x09, m2) ^ ffMultiply(0x0e, m3)
# set the new byte values in the state
state[matrix_index(col, 0)] = s0
state[matrix_index(col, 1)] = s1
state[matrix_index(col, 2)] = s2
state[matrix_index(col, 3)] = s3
if rotate:
state = transpose(state)
return state
def shiftRows(state: bytearray, rotate=False) -> bytearray:
if rotate:
state = transpose(state)
for row in range(Nb):
r = state[row * Nb:row * Nb + Nb]
for i in range(row):
r_temp = r[0]
r = r[1:Nb]
r.append(r_temp)
state[row * Nb: row * Nb + Nb] = r
if rotate:
state = transpose(state)
return state
def invShiftRows(state: bytearray, rotate=False) -> bytearray:
if rotate:
state = transpose(state)
for row in range(Nb):
r = state[row * Nb:row * Nb + Nb]
for i in range(row):
r_temp = r[Nb - 1]
r = r[0:Nb - 1]
r.insert(0, r_temp)
state[row * Nb:row * Nb + Nb] = r
if rotate:
state = transpose(state)
return state
def main():
"""
main function to prepare data for Tiramisu algorithm
"""
parser = argparse.ArgumentParser(
description='reads image sets and augments the data for Tiramisu',
prog='data_gen.py <args>')
# Required arguments
parser.add_argument("-i",
"--input",
required=True,
help="Path to image sets")
parser.add_argument("-o",
"--output",
required=True,
help="Path to save test and train files")
# Optional arguments
parser.add_argument("-r",
"--ratio",
type=float,
default=0.2,
help="validation set ratio")
# Creating required directories
args = vars(parser.parse_args())
if not os.path.exists(args['output'] + '/train/data/'):
os.makedirs(args['output'] + '/train/data/')
if not os.path.exists(args['output'] + '/validate/data/'):
os.makedirs(args['output'] + '/validate/data/')
if not os.path.exists(args['output'] + '/train/masks/'):
os.makedirs(args['output'] + '/train/masks/')
if not os.path.exists(args['output'] + '/validate/masks/'):
os.makedirs(args['output'] + '/validate/masks/')
if not os.path.exists(args['output'] + '/test/data/'):
os.makedirs(args['output'] + '/test/data/')
print("Creating an image per video...")
combine(args['input'], args['output'])
print("Generating a mask per video...")
json_to_mask(args['input'], args['output'])
print("augmenting the dataset...")
slicer(args['output'])
rotate(args['output'])
transpose(args['output'])
# Splitting the dataset into training and validation set
split(args['output'], args['ratio'])
def compute_merged_mask(self, enc_seed_i, num_instances, num_features):
"""
Protocol-Vertical Step1(set up)
- receive upk_i[Enc(seed_i)], label information[num_instances, num_features] from DataOweners
- compute B'=Enc(sum(b_i*b_j), c'=Enc(sum(bi*b_0))
:param enc_seed_i : upk_i
:param num_instances, num_features : label information
:return enc_mask_A, enc_mask_b: B', c' denoted in the paper
"""
seed_i = self.msk.decrypt(enc_seed_i)
mask_X_i = [[
PRF(seed_i, h_index + w_index * num_instances, self.mpk.n)
for w_index in range(num_features)
] for h_index in range(num_instances)]
# compute B'[i,j]
enc_mask_A = None
t_mask_X_i = transpose(mask_X_i)
if len(self.list_mask_X) != 0:
for mask_X_j in self.list_mask_X:
submask = [[
self.mpk.encrypt(
space_mapping(sum(map(operator.mul, vector1, vector2)),
self.mpk.n)) for vector1 in t_mask_X_i
] for vector2 in transpose(mask_X_j)]
if enc_mask_A is None:
enc_mask_A = submask
else:
enc_mask_A += submask
self.list_mask_X.append(mask_X_i)
# compute c'[i]
enc_mask_b = None
if self.mask_Y is None:
#self.mask_Y = [PRF(seed_i, index, self.mpk.n) for index in range(num_instances)]
self.mask_Y = t_mask_X_i[0]
else:
enc_mask_b = [
self.mpk.encrypt(
space_mapping(sum(map(operator.mul, vector1, self.mask_Y)),
self.mpk.n)) for vector1 in t_mask_X_i
]
return enc_mask_A, enc_mask_b
def c19():
b64_cipher_texts = [
b'SSBoYXZlIG1ldCB0aGVtIGF0IGNsb3NlIG9mIGRheQ==',
b'Q29taW5nIHdpdGggdml2aWQgZmFjZXM=',
b'RnJvbSBjb3VudGVyIG9yIGRlc2sgYW1vbmcgZ3JleQ==',
b'RWlnaHRlZW50aC1jZW50dXJ5IGhvdXNlcy4=',
b'SSBoYXZlIHBhc3NlZCB3aXRoIGEgbm9kIG9mIHRoZSBoZWFk',
b'T3IgcG9saXRlIG1lYW5pbmdsZXNzIHdvcmRzLA==',
b'T3IgaGF2ZSBsaW5nZXJlZCBhd2hpbGUgYW5kIHNhaWQ=',
b'UG9saXRlIG1lYW5pbmdsZXNzIHdvcmRzLA==',
b'QW5kIHRob3VnaHQgYmVmb3JlIEkgaGFkIGRvbmU=',
b'T2YgYSBtb2NraW5nIHRhbGUgb3IgYSBnaWJl',
b'VG8gcGxlYXNlIGEgY29tcGFuaW9u',
b'QXJvdW5kIHRoZSBmaXJlIGF0IHRoZSBjbHViLA==',
b'QmVpbmcgY2VydGFpbiB0aGF0IHRoZXkgYW5kIEk=',
b'QnV0IGxpdmVkIHdoZXJlIG1vdGxleSBpcyB3b3JuOg==',
b'QWxsIGNoYW5nZWQsIGNoYW5nZWQgdXR0ZXJseTo=',
b'QSB0ZXJyaWJsZSBiZWF1dHkgaXMgYm9ybi4=',
b'VGhhdCB3b21hbidzIGRheXMgd2VyZSBzcGVudA==',
b'SW4gaWdub3JhbnQgZ29vZCB3aWxsLA==',
b'SGVyIG5pZ2h0cyBpbiBhcmd1bWVudA==',
b'VW50aWwgaGVyIHZvaWNlIGdyZXcgc2hyaWxsLg==',
b'V2hhdCB2b2ljZSBtb3JlIHN3ZWV0IHRoYW4gaGVycw==',
b'V2hlbiB5b3VuZyBhbmQgYmVhdXRpZnVsLA==',
b'U2hlIHJvZGUgdG8gaGFycmllcnM/',
b'VGhpcyBtYW4gaGFkIGtlcHQgYSBzY2hvb2w=',
b'QW5kIHJvZGUgb3VyIHdpbmdlZCBob3JzZS4=',
b'VGhpcyBvdGhlciBoaXMgaGVscGVyIGFuZCBmcmllbmQ=',
b'V2FzIGNvbWluZyBpbnRvIGhpcyBmb3JjZTs=',
b'SGUgbWlnaHQgaGF2ZSB3b24gZmFtZSBpbiB0aGUgZW5kLA==',
b'U28gc2Vuc2l0aXZlIGhpcyBuYXR1cmUgc2VlbWVkLA==',
b'U28gZGFyaW5nIGFuZCBzd2VldCBoaXMgdGhvdWdodC4=',
b'VGhpcyBvdGhlciBtYW4gSSBoYWQgZHJlYW1lZA==',
b'QSBkcnVua2VuLCB2YWluLWdsb3Jpb3VzIGxvdXQu',
b'SGUgaGFkIGRvbmUgbW9zdCBiaXR0ZXIgd3Jvbmc=',
b'VG8gc29tZSB3aG8gYXJlIG5lYXIgbXkgaGVhcnQs',
b'WWV0IEkgbnVtYmVyIGhpbSBpbiB0aGUgc29uZzs=',
b'SGUsIHRvbywgaGFzIHJlc2lnbmVkIGhpcyBwYXJ0',
b'SW4gdGhlIGNhc3VhbCBjb21lZHk7',
b'SGUsIHRvbywgaGFzIGJlZW4gY2hhbmdlZCBpbiBoaXMgdHVybiw=',
b'VHJhbnNmb3JtZWQgdXR0ZXJseTo=',
b'QSB0ZXJyaWJsZSBiZWF1dHkgaXMgYm9ybi4=',
]
block_size = 16
random_key = get_random_bytes(block_size)
reused_nonce = 0
def c19_cryptor(plain_text):
return aes128_ctr_encode(random_key, reused_nonce, plain_text)
cipher_texts = [b64decode(s) for s in b64_cipher_texts]
repeat_length = min(map(len, cipher_texts))
chunks = [ct[0:repeat_length] for ct in cipher_texts]
chunks = transpose(chunks)
keystream = bytes(map(lambda t: t[1], map(c4_best_single_byte_xor,
chunks)))
for ct in cipher_texts:
ctt = ct[0:repeat_length]
print(xor_buf(ctt, keystream))
def get_public_key(pub_key):
if not os.path.isfile(pub_key):
print("There are no public key available")
return None
with open(pub_key, 'r') as f:
lines = f.readlines()
n = int(lines[1])
k = int(lines[2])
q = int(lines[3])
lines = lines[4::]
rows = []
for i in range(len(lines)):
row = get_vector(lines[i])
rows.append(row)
A = u.transpose(rows)
f.close()
return A, n, k, q
def encrypt(m, A, q, n, k):
r = u.random_bit_vector(n)
tA = u.transpose(A)
coeff = (q - 1) / 2
alpha = (u.matrix_vector(tA, r, q))
beta = [0 for i in range(n)]
for i in range(k):
mi = coeff * m[i]
beta.append(mi)
c = []
for i in range(len(alpha)):
ti = alpha[i] + beta[i]
ti %= q
if ti > ((q - 1) / 2):
ti -= q
#print("Correction")
if ti < -((q - 1) / 2):
ti += q
#print("Correction")
c.append(ti)
#print("Encryption completed")
return c
def group(self, grouping, array=None):
array = array if array is not None else self.board
# group into nested list of lists, 4 items each
nested_array = grouper(array, 4)
if grouping == 'columns':
nested_array = transpose(*nested_array)
return nested_array
def ungroup(self, grouping, array=None):
array = array if array is not None else self.board
nested_array = array[:]
if grouping == 'columns':
nested_array = transpose(*nested_array)
# flatten - credit: https://stackoverflow.com/a/952952/3991555
flat_array = flatten(nested_array)
return flat_array
def train(args, builder, params):
trainer = dynet.RMSPropTrainer(params, args.learning_rate)
trainer.set_clip_threshold(args.clip_threshold)
for group_no in range(args.iterations):
print('batch group #%d...' % (group_no + 1))
batch_group_loss = 0.0
for batch_no in range(args.batch_group_size):
# Sample a new batch of training data
length = random.randint(*args.training_length_range)
batch = [
random_sequence(length, args.source_alphabet_size)
for i in range(args.batch_size)
]
# Arrange the input and output halves of the sequences into batches
# of individual symbols
input_sequence_batch = transpose(s.input_sequence() for s in batch)
output_sequence_batch = transpose(s.output_sequence()
for s in batch)
# Start building the computation graph for this batch
dynet.renew_cg()
state = builder.initial_state(args.batch_size)
# Feed everything up to the separator symbol into the model; ignore
# outputs
for symbol_batch in input_sequence_batch:
index_batch = [input_symbol_to_index(s) for s in symbol_batch]
state = state.next(index_batch, StackLSTMBuilder.INPUT_MODE)
# Feed the rest of the sequence into the model and sum up the loss
# over the predicted symbols
symbol_losses = []
for symbol_batch in output_sequence_batch:
index_batch = [output_symbol_to_index(s) for s in symbol_batch]
symbol_loss = dynet.pickneglogsoftmax_batch(
state.output(), index_batch)
symbol_losses.append(symbol_loss)
state = state.next(index_batch, StackLSTMBuilder.OUTPUT_MODE)
loss = dynet.sum_batches(dynet.esum(symbol_losses))
# Forward pass
loss_value = loss.value()
batch_group_loss += loss_value
# Backprop
loss.backward()
# Update parameters
trainer.update()
avg_loss = batch_group_loss / (args.batch_size * args.batch_group_size)
print(' average loss: %0.2f' % avg_loss)
def shift(text, amount):
alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
assert (len(alpha) == 26)
shifted = ""
for n in range(len(alpha)):
shifted += alpha[(n + amount) % len(alpha)]
tbl = dict((a, b) for (a, b) in zip(alpha, shifted))
return transpose(text.upper(), tbl)
def move(self, direction):
def move_row_left(row):
def tighten(row):
new_row = [i for i in row if i != 0]
new_row += [0 for i in range(len(row) - len(new_row))]
return new_row
def merge(row):
pair = False
new_row = []
for i in range(len(row)):
if pair:
new_row.append(2*row[i])
self.score += 2*row[i]
pair = False
else:
if i + 1 < len(row) and row[i] == row[i + 1]:
pair = True
new_row.append(0)
else:
new_row.append(row[i])
assert len(new_row) == len(row)
return new_row
return tighten(merge(tighten(row)))
moves = {}
moves['Left'] = lambda field: \
[move_row_left(row) for row in field]
moves['Right'] = lambda field: \
invert(moves['Left'](invert(field)))
moves['Up'] = lambda field: \
transpose(moves['Left'](transpose(field)))
moves['Down'] = lambda field: \
transpose(moves['Right'](transpose(field)))
if direction in moves:
if self.move_is_possible(direction):
self.field = moves[direction](self.field)
self.spawn()
return True
else:
return False
def plot_stats(stats, save_to):
# normalise ranks
all_ranks = [rank for (_, _, _, rank) in stats]
all_ranks = util.transpose(all_ranks)
all_ranks = [[x / float(sum(row)) for x in row] for row in all_ranks]
all_ranks = util.transpose(all_ranks)
# objectify stats
player_stats = collections.defaultdict(lambda: util.MutableNamedTuple())
for (i, (name, mean, sdev, _)) in enumerate(stats):
player_stats[name].mean = mean
player_stats[name].sdev = sdev
player_stats[name].ranks = all_ranks[i]
# setup plot and maximize
colormap = create_colormap(player_stats.keys())
create_figure()
# plot ranks
width = 1.0
ax1 = plt.subplot2grid((5, 1), (0, 0), rowspan=4)
xs = xrange(1, len(all_ranks[0]) + 1)
bottom = [0] * len(xs)
for name, player_info in player_stats.items():
ys = player_info.ranks
ax1.bar(xs, ys, bottom=bottom, color=colormap[name], width=width)
bottom = util.vector_sum(ys, bottom)
plt.xticks([x + width / 2.0 for x in xs], map(str, xs))
plt.xlim(min(xs), max(xs))
plt.ylim(0, 1)
plt.xlabel('Rank')
plt.ylabel('Probability')
# create legend
ax2 = plt.subplot2grid((5, 1), (4, 0))
label_fun = (lambda player_type, player_info:
u'%s (μ=%.2f, σ=%.2f)'
% (player_type, player_info.mean, player_info.sdev))
create_legend(ax2, player_stats, colormap, label_fun)
# save graph
save_figure(save_to)
def kd_to_pt_score(kd):
key_size = kd[0]
chunks = chunk(cipher_text, key_size)
chunks = transpose(chunks)
key = bytes(map(lambda t: t[1], map(c4_best_single_byte_xor, chunks)))
plain_text = decrypt_xor(key, cipher_text)
score = english_score(plain_text)
return (score, plain_text)
def reset():
global level, cur_screen_pos, bird_pos_x, bird_pos_y, bird_vel,\
score, game_over, bird_anim_frame, show_readme, lead_in
cur_screen_pos = 0
bird_pos_x = BIRD_X_POS
bird_pos_y = round(PIPE_HEIGHT / 2)
bird_vel = 0
score = 0
game_over = False
bird_anim_frame = 0
lead_in = START_SPACE
# make first pipe have a gap in the middle
middle = (PIPE_HEIGHT - PIPE_GAP) / 2
first_pipe_top = random.randint(middle - 3, middle + 3)
level = ([empty] * START_SPACE +
pipe_and_space(first_pipe_top) +
[el for _ in range(NUM_PIPES) for el in pipe_and_space()])
level = transpose(transpose(level) + art.ground(len(level)))
if first_run:
# have to add empty space to the bottom of readme
fillup = len(level[0]) - len(art.readme)
whitespace = [' ' * len(art.readme[0])]
readme = art.readme + whitespace * fillup
whitespace = [' ' * len(art.logo[0])]
logo = (whitespace * 20 +
art.logo +
whitespace * (SCREEN_HEIGHT - 20 - len(art.logo)))
level = (transpose(readme) +
[' ' * SCREEN_HEIGHT] * 5 +
transpose(logo) +
level)
bird_pos_x += SCREEN_WIDTH + len(logo[0]) + 7
lead_in += len(logo[0]) + len(readme[0]) + 5
def mixColumns(state: bytearray, rotate=False) -> bytearray:
out = state.copy()
if rotate:
out = transpose(out)
for col in range(Nb):
m0 = matrix_element(out, col, 0)
m1 = matrix_element(out, col, 1)
m2 = matrix_element(out, col, 2)
m3 = matrix_element(out, col, 3)
s0 = ffMultiply(0x02, m0) ^ ffMultiply(0x03, m1) ^ m2 ^ m3
s1 = m0 ^ ffMultiply(0x02, m1) ^ ffMultiply(0x03, m2) ^ m3
s2 = m0 ^ m1 ^ ffMultiply(0x02, m2) ^ ffMultiply(0x03, m3)
s3 = ffMultiply(0x03, m0) ^ m1 ^ m2 ^ ffMultiply(0x02, m3)
# set the new byte values in the state
out[matrix_index(col, 0)] = s0
out[matrix_index(col, 1)] = s1
out[matrix_index(col, 2)] = s2
out[matrix_index(col, 3)] = s3
if rotate:
out = transpose(out)
return out
def protocol_ridge_step1(self):
"""
Protocol-ridge_version1 Step1(data masking)
- sample a random matrix(R) and a random vector(r)
- mask a merged dataset(A, b) with R, r
:return enc_C: Enc(C) = Enc(A*R)
:return enc_d: Enc(d) = Enc(b + Ar)
"""
num_dimension = len(self.merged_enc_A)
# sample a random matrix(R) and a random vector(r)
Range = self.mpk.n-1
MaxInt = self.mpk.max_int
R = [[( random.randrange(Range) - MaxInt ) for _ in range(num_dimension)] for _ in range(num_dimension)]
# check that R is invertible. ([det(A)] is non-zero <=> A is invertible)
# if R is not invertible, random-sample again until R is invertible.
det_R = compute_det(R, self.mpk.n)
while(det_R == 0.0):
R = [[( random.randrange(Range) - MaxInt ) for _ in range(num_dimension)] for _ in range(num_dimension)]
det_R = compute_det(R, self.mpk.n)
r = [(int)( random.randrange(Range) - MaxInt ) for _ in range(num_dimension)]
# store R, r in the Object for step3
self.R = R
self.r = r
self.det_R = det_R
# masking C = A*R with multi-processing
splitedAR = []
R_trans = transpose(self.R)
for i in range(num_dimension):
for j in range(num_dimension):
splitedAR.append([self.merged_enc_A[i], R_trans[j]])
splitedbA = list(zip(self.merged_enc_b, self.merged_enc_A))
with multi.Pool(processes = multi.cpu_count()) as workers:#multi processing
# masking C = A*R with multi-processing
enc_C = workers.map(self.dotproduct, splitedAR)
# masking d = b + A*r
enc_d = workers.map(self.compute_enc_d, splitedbA)
workers.close()
workers.terminate()
enc_C = list(zip(*[iter(enc_C)]*num_dimension)) # reshape
return enc_C, enc_d
def move_is_possible(self, direction):
def row_is_left_movable(row):
def change(i):
if 0 == row[i] and 0 != row[i + 1]:
return True
if 0 != row[i] and row[i + 1] == row[i]:
return True
return False
return any(change(i) for i in range(len(row) - 1))
check = {}
check['Left'] = lambda field: \
any(row_is_left_movable(row) for row in field)
check['Right'] = lambda field: \
check['Left'](invert(field))
check['Up'] = lambda field: \
check['Left'](transpose(field))
check['Down'] = lambda field: \
check['Right'](transpose(field))
if direction in check:
return check[direction](self.field)
else:
return False
def nondiagonal_block(self, labEnc_Xi, enc_mask_A):
new_block = None
# Matrix multiplication(labEnc_Xj, labEnc_Xi)
t_labEnc_Xi = transpose(labEnc_Xi)
for labEnc_Xj in self.list_labEnc_Xj:
subnew_block = [[sum(map(mul, vector1, vector2)) for vector1 in t_labEnc_Xi] for vector2 in transpose(labEnc_Xj)]
if new_block is None:
new_block = subnew_block
else:
new_block += subnew_block
# remove mask(sum(Enc(b*b')))
assert len(new_block) == len(enc_mask_A)
assert len(new_block[-1]) == len(enc_mask_A[-1])
new_block = [list(map(add, enc_value, enc_mask)) for enc_value, enc_mask in zip(new_block, enc_mask_A)]
return new_block
def merge_data(self, enc_Ai, enc_bi, labEnc_Xi, labEnc_Y, enc_mask_A, enc_mask_b, lamda, magnitude):
encoded_lamda = (int)(lamda * (magnitude**2))
# merged Enc(A)
if len(self.merged_enc_A) == 0: # if a MLE gets data from the first DOwner
assert enc_mask_A is None and enc_mask_b is None
assert enc_bi is not None
self.merged_enc_A = self.diagonal_block(enc_Ai, encoded_lamda)
self.merged_enc_b = enc_bi
else:
'''
# single process
new_diagonal_block = self.diagonal_block(enc_Ai, encoded_lamda)
new_nondiagonal_block = self.nondiagonal_block(labEnc_Xi, enc_mask_A)
'''
# multi processing
# parallization with multi-processing to improve the performance
new_diagonal_block = self.diagonal_block(enc_Ai, encoded_lamda)
with multi.Pool(processes = multi.cpu_count()) as workers:#multi processing
new_nondiagonal_block = self.nondiagonal_block_mp(workers, labEnc_Xi, enc_mask_A)
new_enc_bi = workers.map(self.compute_new_enc_bi, list(zip(enc_mask_b, transpose(labEnc_Xi))))
workers.close()
workers.terminate()
# add blocks to right side
for index, new_subline in enumerate(new_nondiagonal_block):
self.merged_enc_A[index] += new_subline
# add blocks to bottom side
t_newNonDiagonalBlock = transpose(new_nondiagonal_block)
for h_index in range(len(enc_Ai)):
self.merged_enc_A.append(t_newNonDiagonalBlock[h_index] + new_diagonal_block[h_index])
self.merged_enc_b += new_enc_bi
# add Enc(Xi), Enc(Yi) on the list
self.list_labEnc_Xj.append(labEnc_Xi)
if labEnc_Y is not None:
self.labEnc_Y = labEnc_Y
whitespace * (SCREEN_HEIGHT - 20 - len(art.logo)))
level = (transpose(readme) +
[' ' * SCREEN_HEIGHT] * 5 +
transpose(logo) +
level)
bird_pos_x += SCREEN_WIDTH + len(logo[0]) + 7
lead_in += len(logo[0]) + len(readme[0]) + 5
reset()
# show first frame and wait for keypress
screen_slice = level[cur_screen_pos:cur_screen_pos + SCREEN_WIDTH]
screen = transpose(screen_slice)
data = '\r\n'.join(''.join(row) for row in screen)
set_text(text_area, data)
while not keycheck():
print 'waiting'
pass
while True: # game loop
key_pressed = keycheck()
if key_pressed:
if game_over:
first_run = False
reset()
else:
def pipe_and_space(top_height=None):
return transpose(art.pipes(PIPE_GAP, PIPE_HEIGHT, top_height)) \
+ [empty] * PIPE_SPACING
wm_mask_list = []
text_mask_list = []
for i in range(len(input_img)):
text_img = show(input_img[i])
text_mask = get_text_mask(np.array(text_img)) # 得到 text 的 mask (bool)
rgb_img = Image.new(mode="RGB", size=text_img.size, color=(255, 255, 255))
p = -int(wm_img.size[0] * np.tan(10 * np.pi / 180))
right_shift = 10
xp = pos[i][0][0] + right_shift if len(pos[i]) != 0 else right_shift
# xp = 0
rgb_img.paste(wm_img, box=(xp, p)) # 先贴 wm
wm_mask = (np.array(rgb_img.convert('L')) != 255) # 得到 wm 的 mask(bool)
rgb_img.paste(text_img, mask=cvt2Image(text_mask)) # 再贴 text
wm0_img_list.append(rgb_img)
wm_mask_list.append(transpose(wm_mask))
text_mask_list.append(transpose(text_mask))
wm_mask = np.asarray(wm_mask_list)
text_mask = np.asarray(text_mask_list)
batch_size = 100
clip_min, clip_max = 0.0, 1.0
# 大数据集查看
record_text = []
wm0_img = pred_img = np.asarray(
[cvt2raw(np.array(img.convert('L'))) / 255 for img in wm0_img_list])
batch_iter = len(input_img) // batch_size
batch_iter = batch_iter if len(input_img) % batch_size == 0 else batch_iter + 1
for batch_i in range(batch_iter):
start = batch_size * batch_i
def score(num):
digs = [transpose(digits[int(d)]) for d in str(num)]
return transpose([col for dig in digs for col in dig])
def ground(length):
one = transpose(ground_segment)
many = one * (length / len(one) + 1)
assert len(many) >= length
return transpose(many[:length])
def protocol_ridge_step1(self):
"""
Protocol-ridge Step1(data masking)
- sample a random matrix(R) and a random vector(r)
- mask a merged dataset(A, b) with R, r
:return enc_C: Enc(C) = Enc(A*R)
:return enc_d: Enc(d) = Enc(b + Ar)
"""
num_dimension = len(self.merged_enc_A)
# sample a random matrix(R) and a random vector(r)
Range = self.pk.n - 1
MaxInt = self.pk.max_int
R = [[(random.randrange(Range) - MaxInt) for _ in range(num_dimension)]
for _ in range(num_dimension)]
# check that R is invertible. ([det(A)] is non-zero <=> A is invertible)
# if R is not invertible, random-sample again until R is invertible.
det_R = compute_det(R, self.pk.n)
while (det_R == 0.0):
R = [[(random.randrange(Range) - MaxInt)
for _ in range(num_dimension)] for _ in range(num_dimension)]
det_R = compute_det(R, self.pk.n)
r = [(int)(random.randrange(Range) - MaxInt)
for _ in range(num_dimension)]
self.R = R
self.r = r
self.det_R = det_R
# Matrix multiplication with multi proccessing.
splitedAR = []
R_trans = transpose(self.R)
for i in range(num_dimension):
for j in range(num_dimension):
splitedAR.append([self.merged_enc_A[i], R_trans[j]])
splitedbA = list(zip(self.merged_enc_b, self.merged_enc_A))
with multi.Pool(
processes=multi.cpu_count()) as pool: #multi processing
# masking C = A*R with multi-processing
enc_C = pool.map(self.compute_enc_C, splitedAR)
# masking d = b + A*r
enc_d = pool.map(self.compute_enc_d, splitedbA)
pool.close()
pool.terminate()
enc_C = list(zip(*[iter(enc_C)] * num_dimension)) # reshape
'''
# Matrix multiplication with multi proccessing.
interval = num_dimension//5
self.interval = interval
A_splited = [self.merged_enc_A[i:i + interval] for i in range(0, num_dimension, interval)]
R_trans = transpose(R)
R_t_splited = [R_trans[i:i + interval] for i in range(0, num_dimension, interval)]
splitedAR = []
for A_i in A_splited:
for R_t_i in R_t_splited:
splitedAR.append([A_i, transpose(R_t_i)])
splitedbA = list(zip(self.merged_enc_b, self.merged_enc_A))
with multi.Pool(processes = multi.cpu_count()) as pool: #multi processing
# masking C = A*R with multi-processing
temp_enc_C = pool.map(self.compute_enc_C, splitedAR)
enc_C = []
for i in range(5): #reshape
enc_C += [list(chain.from_iterable(items)) for items in zip(*temp_enc_C[i:i+5])]
# masking d = b + A*r
enc_d = pool.map(self.compute_enc_d, splitedbA)
pool.close()
pool.terminate()
'''
return enc_C, enc_d
def test_transpose():
chunks = [b'123', b'456']
assert (transpose(chunks) == [b'14', b'25', b'36'])
chunks = [b'123', b'456', b'7']
assert (transpose(chunks) == [b'147', b'25', b'36'])
