def sumDiagProducts(diagMatrix, ct_vector):
template = [0] * len(diagMatrix[0])
plain_matrix = Plaintext()
crtbuilder.compose(template, plain_matrix)
accumulated = Ciphertext()
encryptor.encrypt(plain_matrix, accumulated)
for i, row in enumerate(diagMatrix):
print("_____________________________")
print(i, row)
temp = copy.deepcopy(ct_vector)
# the last number needs to wrap around!
evaluator.rotate_rows(temp, i, gal_keys)
decryptor.decrypt(temp, plain_matrix)
crtbuilder.decompose(plain_matrix)
print_matrix([plain_matrix.coeff_at(i) for i in range(plain_matrix.coeff_count())])
encodedRow = Plaintext()
crtbuilder.compose(row, encodedRow)
evaluator.multiply_plain(temp, encodedRow)
evaluator.add(accumulated, temp)
decryptor.decrypt(accumulated, plain_matrix)
crtbuilder.decompose(plain_matrix)
print([plain_matrix.coeff_at(i) for i in range(4)])
return accumulated
def dec_recompose(
enc_wts
): # function to decrypt the aggregated weight vector received from parameter server
dec_wts = []
global_aggregate = {}
chunks = len(enc_wts)
for h in range(chunks):
plain_agg = Plaintext()
decryptor.decrypt(enc_wts[h], plain_agg)
crtbuilder.decompose(plain_agg)
dec_wts += [
plain_agg.coeff_at(h) for h in range(plain_agg.coeff_count())
]
for h in range(len(dec_wts)):
if dec_wts[h] > int(parms.plain_modulus().value() - 1) / 2:
dec_wts[h] = dec_wts[h] - parms.plain_modulus().value()
for h in range(len(dec_wts)):
dec_wts[h] = float(dec_wts[h]) / (1000 * m)
pos_start = 0
for param_tensor in flattened_lengths:
pos_end = pos_start + flattened_lengths[param_tensor]
global_aggregate.update({
param_tensor:
torch.tensor(dec_wts[pos_start:pos_end]).reshape(
shapes[param_tensor])
})
pos_start = pos_end
return global_aggregate
def rotateAdd(ct, length, lowerbound=1):
res = Plaintext()
while length > lowerbound:
length //= 2
oldCt = copy.deepcopy(ct)
evaluator.rotate_rows(ct, length, gal_keys)
evaluator.add(ct, oldCt)
print(length)
decryptor.decrypt(ct, res)
crtbuilder.decompose(res)
#print_matrix([res.coeff_at(i) for i in range(res.coeff_count())])
return [res.coeff_at(i) for i in range(lowerbound)]
def example_batching():
print_example_banner("Example: Batching with PolyCRTBuilder");
parms = EncryptionParameters()
parms.set_poly_modulus("1x^4096 + 1")
parms.set_coeff_modulus(seal.coeff_modulus_128(4096))
parms.set_plain_modulus(40961)
context = SEALContext(parms)
print_parameters(context)
qualifiers = context.qualifiers()
keygen = KeyGenerator(context)
public_key = keygen.public_key()
secret_key = keygen.secret_key()
gal_keys = GaloisKeys()
keygen.generate_galois_keys(30, gal_keys)
#ev_keys = EvaluationKeys()
#keygen.generate_evaluation_keys(30, ev_keys)
encryptor = Encryptor(context, public_key)
evaluator = Evaluator(context)
decryptor = Decryptor(context, secret_key)
crtbuilder = PolyCRTBuilder(context)
slot_count = (int)(crtbuilder.slot_count())
row_size = (int)(slot_count / 2)
print("Plaintext matrix row size: " + (str)(row_size))
def print_matrix(matrix):
print("")
print_size = 5
current_line = " ["
for i in range(print_size):
current_line += ((str)(matrix[i]) + ", ")
current_line += ("..., ")
for i in range(row_size - print_size, row_size):
current_line += ((str)(matrix[i]))
if i != row_size-1: current_line += ", "
else: current_line += "]"
print(current_line)
current_line = " ["
for i in range(row_size, row_size + print_size):
current_line += ((str)(matrix[i]) + ", ")
current_line += ("..., ")
for i in range(2*row_size - print_size, 2*row_size):
current_line += ((str)(matrix[i]))
if i != 2*row_size-1: current_line += ", "
else: current_line += "]"
print(current_line)
print("")
# [ 0, 1, 2, 3, 0, 0, ..., 0 ]
# [ 4, 5, 6, 7, 0, 0, ..., 0 ]
pod_matrix = [0]*slot_count
pod_matrix[0] = 0
pod_matrix[1] = 1
pod_matrix[2] = 2
pod_matrix[3] = 3
pod_matrix[row_size] = 4
pod_matrix[row_size + 1] = 5
pod_matrix[row_size + 2] = 6
pod_matrix[row_size + 3] = 7
print("Input plaintext matrix:")
print_matrix(pod_matrix)
plain_matrix = Plaintext()
crtbuilder.compose(pod_matrix, plain_matrix)
encrypted_matrix = Ciphertext()
print("Encrypting: ")
encryptor.encrypt(plain_matrix, encrypted_matrix)
print("Done")
print("Noise budget in fresh encryption: " +
(str)(decryptor.invariant_noise_budget(encrypted_matrix)) + " bits")
pod_matrix2 = []
for i in range(slot_count): pod_matrix2.append((i % 2) + 1)
plain_matrix2 = Plaintext()
crtbuilder.compose(pod_matrix2, plain_matrix2)
print("Second input plaintext matrix:")
print_matrix(pod_matrix2)
print("Adding and squaring: ")
evaluator.add_plain(encrypted_matrix, plain_matrix2)
evaluator.square(encrypted_matrix)
evaluator.relinearize(encrypted_matrix, ev_keys)
print("Done")
print("Noise budget in result: " + (str)(decryptor.invariant_noise_budget(encrypted_matrix)) + " bits")
plain_result = Plaintext()
print("Decrypting result: ")
decryptor.decrypt(encrypted_matrix, plain_result)
print("Done")
crtbuilder.decompose(plain_result)
pod_result = [plain_result.coeff_at(i) for i in range(plain_result.coeff_count())]
print("Result plaintext matrix:")
print_matrix(pod_result)
encryptor.encrypt(plain_matrix, encrypted_matrix)
print("Unrotated matrix: ")
print_matrix(pod_matrix)
print("Noise budget in fresh encryption: " +
(str)(decryptor.invariant_noise_budget(encrypted_matrix)) + " bits")
# Now rotate the rows to the left 3 steps, decrypt, decompose, and print.
evaluator.rotate_rows(encrypted_matrix, 3, gal_keys)
print("Rotated rows 3 steps left: ")
decryptor.decrypt(encrypted_matrix, plain_result)
crtbuilder.decompose(plain_result)
pod_result = [plain_result.coeff_at(i) for i in range(plain_result.coeff_count())]
print_matrix(pod_result)
print("Noise budget after rotation" +
(str)(decryptor.invariant_noise_budget(encrypted_matrix)) + " bits")
# Rotate columns (swap rows), decrypt, decompose, and print.
evaluator.rotate_columns(encrypted_matrix, gal_keys)
print("Rotated columns: ")
decryptor.decrypt(encrypted_matrix, plain_result)
crtbuilder.decompose(plain_result)
pod_result = [plain_result.coeff_at(i) for i in range(plain_result.coeff_count())]
print_matrix(pod_result)
print("Noise budget after rotation: " +
(str)(decryptor.invariant_noise_budget(encrypted_matrix)) + " bits")
# Rotate rows to the right 4 steps, decrypt, decompose, and print.
evaluator.rotate_rows(encrypted_matrix, -4, gal_keys)
print("Rotated rows 4 steps right: ")
decryptor.decrypt(encrypted_matrix, plain_result)
crtbuilder.decompose(plain_result)
pod_result = [plain_result.coeff_at(i) for i in range(plain_result.coeff_count())]
print_matrix(pod_result)
print("Noise budget after rotation: " +
(str)(decryptor.invariant_noise_budget(encrypted_matrix)) + " bits")
