SEAL库 例4之ckks_basics解析
SEAL/native/examples/4_ckks_basics.cpp
print_example_banner("Example: CKKS Basics");
在这个例子中，我们演示了一个多项式函数的求值
PI * x^3 + 0.4*x + 1
在加密的浮点输入数据x为一组4096等距点在区间[0,1]。这个例子演示了CKKS方案的许多主要特性，但也说明了使用它的挑战。
我们首先建立CKKS方案。
EncryptionParameters parms(scheme_type::CKKS);
我们在’
2_encoders.cpp中看到CKKS中的乘法导致了规模在密文中成长。任何密文的尺度都不能太接近coeff_modulus的总大小，否则密文就会耗尽空间来存储放大的明文。CKKS方案提供了一个“rescale”功能，可以减少scale，并稳定scale扩展。Rescaling是一种模转换操作(回忆一下3_levels.cpp’)。在转换模量时，它会从coeff_modulo中移除最后一个素数，但作为副作用，它会通过移除的素数缩小了密文。通常，我们想要对尺度如何变化有完美的控制，这就是为什么在CKKS方案中，为coeff_moduls使用精心挑选的素数更为常见。
更精确地说，假设CKKS密文中的scale为S，则当前coeff_modulus(密文)中的最后一个素数是P. Rescaling下一层将scale更改为S/P，并从coeff_modulo中删除素数P,和模量切换中通常的做法一样。质数的数量限制了重新计算的次数，从而限制了计算的乘法深度。
自由选择初始规模是有可能的。一个好的策略是在coeff_modul_be中设置初始标度S和素数P_i彼此非常接近。如果密文在乘法之前有scale S，乘法之后是S^2，rescaling之后是 S^2 / P_i。如果所有P_i接近S，然后S^2/P_i又接近S。通过这种方法，我们可以在整个计算过程中使scale稳定在接近S。一般来说，对于深度D的电路，我们需要缩放D倍，即我们需要把D 素数从系数模数中去掉。一旦在coeff_modules中只剩下一个素数，剩下的素数必须比S大几个位，以保留明文的小数点前值。
因此，一般好的策略是选择CKKS方案的参数如下:
(1)选择一个60位素数作为coeff_modules中的第一个素数。这将在解密时提供最高的精度;
(2)选择另一个60位素数作为coeff_modules的最后一个元素，因为它将被用作特殊素数，并且应该与其他素数中最大的素数一样大;
(3)选择中间素数，彼此之间相近。
我们使用CoefModulusf::Create来生成适当大小的素数。注意，我们的coeff_modules是200位，这低于我们的多项式模数: coeff_modulus_degree::MaxBitCount(8192)返回218`。
size_t poly_modulus_degree = 8192;
parms.set_poly_modulus_degree(poly_modulus_degree);
parms.set_coeff_modulus(CoeffModulus::Create(
poly_modulus_degree, { 60, 40, 40, 60 }));
我们选择初始规模为2^40。在最后一层，小数点前留下60-40=20位精度，小数点后留下足够(大约10-20位)的精度。因为我们的中间质数是40位(事实上，它们非常接近2的40)，所以我们可以像上面描述的那样实现规模稳定。
double scale = pow(2.0, 40);
auto context = SEALContext::Create(parms);
print_parameters(context);
cout << endl;
KeyGenerator keygen(context);
auto public_key = keygen.public_key();
auto secret_key = keygen.secret_key();
auto relin_keys = keygen.relin_keys();
Encryptor encryptor(context, public_key);
Evaluator evaluator(context);
Decryptor decryptor(context, secret_key);
CKKSEncoder encoder(context);
size_t slot_count = encoder.slot_count();
cout << "Number of slots: " << slot_count << endl;
vector<double> input;
input.reserve(slot_count);
double curr_point = 0;
double step_size = 1.0 / (static_cast<double>(slot_count) - 1);
for (size_t i = 0; i < slot_count; i++, curr_point += step_size)
{
input.push_back(curr_point);
}
cout << "Input vector: " << endl;
print_vector(input, 3, 7);
cout << "Evaluating polynomial PI*x^3 + 0.4x + 1 ..." << endl;
/*
We create plaintexts for PI, 0.4, and 1 using an overload of CKKSEncoder::encode
that encodes the given floating-point value to every slot in the vector.
*/
Plaintext plain_coeff3, plain_coeff1, plain_coeff0;
encoder.encode(3.14159265, scale, plain_coeff3);
encoder.encode(0.4, scale, plain_coeff1);
encoder.encode(1.0, scale, plain_coeff0);
Plaintext x_plain;
print_line(__LINE__);
cout << "Encode input vectors." << endl;
encoder.encode(input, scale, x_plain);
Ciphertext x1_encrypted;
encryptor.encrypt(x_plain, x1_encrypted);
/*
To compute x^3 we first compute x^2 and relinearize. However, the scale has
now grown to 2^80.
*/
Ciphertext x3_encrypted;
print_line(__LINE__);
cout << "Compute x^2 and relinearize:" << endl;
evaluator.square(x1_encrypted, x3_encrypted);
evaluator.relinearize_inplace(x3_encrypted, relin_keys);
cout << " + Scale of x^2 before rescale: " << log2(x3_encrypted.scale())
<< " bits" << endl;
现在rescale;除了模数切换之外，规模还减少了一个因子，该因子等于被切换掉的素数(40位素数)。因此，新的scale应该接近2的40次方。但是注意，scale不等于2^40:这是因为40位素数只接近2的40次方。
print_line(__LINE__);
cout << "Rescale x^2." << endl;
evaluator.rescale_to_next_inplace(x3_encrypted);
cout << " + Scale of x^2 after rescale: " << log2(x3_encrypted.scale())
<< " bits" << endl;
问题：
现在x3_encryption与x1_encryption处于不同的级别，这阻止我们将它们相乘来计算x^3。 我们可以简单地将
x1_encrypted切换到模数转换链中的下一个参数。然而，由于我们仍然需要将x^3 项 乘以PI(plain_coeff3)，
所以我们先计算PI*x，然后将它与x^2相乘，得到PI *x^3。最后，我们计算PI *x 并将其从2^80缩放到接近
2^40的值。
print_line(__LINE__);
cout << "Compute and rescale PI*x." << endl;
Ciphertext x1_encrypted_coeff3;
evaluator.multiply_plain(x1_encrypted, plain_coeff3, x1_encrypted_coeff3);
cout << " + Scale of PI*x before rescale: " << log2(x1_encrypted_coeff3.scale())
<< " bits" << endl;
evaluator.rescale_to_next_inplace(x1_encrypted_coeff3);
cout << " + Scale of PI*x after rescale: " << log2(x1_encrypted_coeff3.scale())
<< " bits" << endl;
因为x3_encrypted和x1_encrypted_coeff3具有相同的scale和使用相同的加密参数，所以我们可以将它们相乘。我们将结果写入x3_encrypted，relinearize和rescale。再次注意scale是接近2^40，但不完全是2的40次方due to yet another scaling by a prime。我们已经到了模切换链的最后一个level。
print_line(__LINE__);
cout << "Compute, relinearize, and rescale (PI*x)*x^2." << endl;
evaluator.multiply_inplace(x3_encrypted, x1_encrypted_coeff3);
evaluator.relinearize_inplace(x3_encrypted, relin_keys);
cout << " + Scale of PI*x^3 before rescale: " << log2(x3_encrypted.scale())
<< " bits" << endl;
evaluator.rescale_to_next_inplace(x3_encrypted);
cout << " + Scale of PI*x^3 after rescale: " << log2(x3_encrypted.scale())
<< " bits" << endl;
接下来计算1次项。所有这些都需要一个带有plain_coeff1的multiply_plain。我们使用结果覆盖x1_encryption。
print_line(__LINE__);
cout << "Compute and rescale 0.4*x." << endl;
evaluator.multiply_plain_inplace(x1_encrypted, plain_coeff1);
cout << " + Scale of 0.4*x before rescale: " << log2(x1_encrypted.scale())
<< " bits" << endl;
evaluator.rescale_to_next_inplace(x1_encrypted);
cout << " + Scale of 0.4*x after rescale: " << log2(x1_encrypted.scale())
<< " bits" << endl;
问题
现在我们希望计算所有三项的和。但是，有一个严重的问题:这三个术语所使用的加密参数是不同的，这是由于模量从rescaling而来的。
加密的加法和减法要求输入的level相同，并且加密参数(parms_id)匹配。如果不匹配，Evaluate将抛出异常。
cout << endl;
print_line(__LINE__);
cout << "Parameters used by all three terms are different." << endl;
cout << " + Modulus chain index for x3_encrypted: "
<< context->get_context_data(x3_encrypted.parms_id())->chain_index() << endl;
cout << " + Modulus chain index for x1_encrypted: "
<< context->get_context_data(x1_encrypted.parms_id())->chain_index() << endl;
cout << " + Modulus chain index for plain_coeff0: "
<< context->get_context_data(plain_coeff0.parms_id())->chain_index() << endl;
cout << endl;
让我们仔细考虑一下在这一点上的scales是多少。我们把系数中的质数表示为P_0, P_1, P_2, P_3，按这个顺序。P_3作为特殊的模量，不涉及重调scaling。经过以上规模的计算，密文的scale为:
- Product x^2 has scale 2^80 and is at level 2; - Product PI*x has scale 2^80 and is at level 2; - We rescaled both down to scale 2^80/P_2 and level 1; - Product PI*x^3 has scale (2^80/P_2)^2; - We rescaled it down to scale (2^80/P_2)^2/P_1 and level 0; - Product 0.4*x has scale 2^80; - We rescaled it down to scale 2^80/P_2 and level 1; - The contant term 1 has scale 2^40 and is at level 2.
虽然这三项的比例大约是2^40，但它们的确切值是不同的，因此不能相加。
print_line(__LINE__);
cout << "The exact scales of all three terms are different:" << endl;
ios old_fmt(nullptr);
old_fmt.copyfmt(cout);
cout << fixed << setprecision(10);
cout << " + Exact scale in PI*x^3: " << x3_encrypted.scale() << endl;
cout << " + Exact scale in 0.4*x: " << x1_encrypted.scale() << endl;
cout << " + Exact scale in 1: " << plain_coeff0.scale() << endl;
cout << endl;
cout.copyfmt(old_fmt);
> 有很多方法可以解决这个问题。因为P_2和P_1非常接近2的40次方，我们可以简单地“撒谎”到Microsoft SEAL，
并设置相同的比例。例如，将*x^3的比例改为2^40就意味着将*x^3的值乘以2^120/(P_2^2*P_1)，这非常接近于1。
>
> 这应该不会导致任何明显的错误。
>
> 另一个选项是用scale 2^80/P_2对1进行编码，用0.4*x进行乘法运算，最后进行缩放。在这种情况下，我们还需要
确保使用适当的加密参数(parms_id)对1进行编码。
>
> 在本例中，我们将使用第一***种(最简单的)方法***，简单地将PI*x^3和0.4*x的范围更改为2^40。
修改：
print_line(__LINE__);
cout << "Normalize scales to 2^40." << endl;
x3_encrypted.scale() = pow(2.0, 40);
x1_encrypted.scale() = pow(2.0, 40);
我们还有一个加密参数不匹配的问题。这是很容易修复，使用传统的模切换(没有重新缩放)。CKKS支持模切换，就像BFV方案一样，允许我们在根本不需要时切换部分系数模量。
print_line(__LINE__);
cout << "Normalize encryption parameters to the lowest level." << endl;
parms_id_type last_parms_id = x3_encrypted.parms_id();
evaluator.mod_switch_to_inplace(x1_encrypted, last_parms_id);
evaluator.mod_switch_to_inplace(plain_coeff0, last_parms_id);
/*三个密文兼容，可加了
All three ciphertexts are now compatible and can be added.
*/
print_line(__LINE__);
cout << "Compute PI*x^3 + 0.4*x + 1." << endl;
Ciphertext encrypted_result;
evaluator.add(x3_encrypted, x1_encrypted, encrypted_result);
//计算结果存入 encrypted_result
evaluator.add_plain_inplace(encrypted_result, plain_coeff0);
/*
First print the true result.
*/
Plaintext plain_result; //明文结果
print_line(__LINE__);
cout << "Decrypt and decode PI*x^3 + 0.4x + 1." << endl;
cout << " + Expected result 希望打印出:" << endl;
vector<double> true_result;
for (size_t i = 0; i < input.size(); i++)
{
double x = input[i];
true_result.push_back((3.14159265 * x * x + 0.4)* x + 1);
}
print_vector(true_result, 3, 7);
/* 真正解密、解码、打印 看看如何
Decrypt, decode, and print the result.
*/
decryptor.decrypt(encrypted_result, plain_result); //解密
vector<double> result;
encoder.decode(plain_result, result); //解码
cout << " + Computed result ...... Correct." << endl;
print_vector(result, 3, 7);
虽然我们没有在这些例子中显示任何复数的计算，但是CKKSEncoder可以让我们很容易地做到这一点。复数的加法和乘法就像人们所期望的那样。
运行结果
