@auther by sizaif

SEAL 学习第四天： ckks_basics

@[toc]

简介说明

通常一个好的策略是为CKKS选择参数方案如下:

    (1) 选择一个60位素数作为coeff_modulus中的第一个素数.这将解密时给出最高的精度; 
    (2) 选择另一个60位素数作为coeff_modulus的最后一个元素，,同时这将被用作特殊的素数，应该与其他质数中最大的一样打；
    (3) 选择中间素数彼此接近

我们使用CoeffModulus::Create来生成适当大小的素数。请注意我们的coeff_modulus是200位的总和，这低于

poly_modulus_degree: CoeffModulus::MaxBitCount(8192)返回218。

scale

比例增大输入的浮点系数数据

即使在纯文本元素的CKKS方案基本上是多项式的整数系数 x^n

编码的位精度;自然会影响精度结果。

所以设置一个放大比例系数是很有必要的。

有了scale 必然有rescale

rescale

通常在乘法后执行

目的: 乘法后： scale = scale + scale = 2*scale 即 $ \Delta^{2}\to \Delta $

函数调用	参数类型	解释说明
evaluator.rescale_to_next_inplace(Ciphertext)	Ciphertext	重新调整scale比例系数接近于初始设置的值，接近但不是等于
double scale = pow(2.0, 40);	int	定义一个2^40 的scale 比例系数

Encoding & Decoding

计算

对于多项式不同的计算顺序消耗的噪声预算以及性能不同

在这个样例中:

求 $F(x) = \pi * x^{3} + 0.4 * x +1$

Plaintext plain_coeff3, plain_coeff1, plain_coeff0;
// 编码
encoder.encode(3.14159265, scale, plain_coeff3);// PI
encoder.encode(0.4, scale, plain_coeff1); // 0.4
encoder.encode(1.0, scale, plain_coeff0); // 1


// x^2
evaluator.square(x1_encrypted, x3_encrypted); // x3_encrypted = x1_encrypted * x1_encrypted
evaluator.relinearize_inplace(x3_encrypted, relin_keys);
evaluator.rescale_to_next_inplace(x3_encrypted); // 重新调整scale 规模

// PI * x
evaluator.multiply_plain(x1_encrypted, plain_coeff3, x1_encrypted_coeff3);// x1_encrypted_coeff3 = x1_encrypted * plain_coeff3
evaluator.rescale_to_next_inplace(x1_encrypted_coeff3);

// 0.4*x
evaluator.multiply_plain_inplace(x1_encrypted, plain_coeff1);
evaluator.rescale_to_next_inplace(x1_encrypted);

然后就可以三项之和；然而,有一个严重的问题是:

这三个术语使用的加密参数都是不同是由于模数从缩放转换而来。

而加密的加法和减法要求输入的level为相同并且加密参数(parms_id)匹配。

如果有不匹配时，求值器将抛出异常。

我们验证可以发现三者的level是不一样的

在这个样例中 level的变化过程

- 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.

三者的scale 虽然接近，但也是不一样的

这里有几种方法来解决这个scale问题

既然P_2和P_1非常接近2 ^ 40,我们可以简单欺骗 Microsoft SEAL，把scale 设置成一样的，因为以及非常接近2^40
```
// 重新设置两者的scale
x3_encrypted.scale() = pow(2.0, 40);    
x1_encrypted.scale() = pow(2.0, 40);
```
另一种方法就是将1 编码成 2^80/P_2 在做一个 multiply_plain 将level降到与0.4*x 保持一致

解决掉上面的问题后我们还有加密参数不匹配的问题。这是很容易的通过使用modulus switching (no rescaling) 来解决

CKKS支持modulus switching就像BFV格式一样、

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);

到现在这三种密文现在都是兼容的，可以进行add运算了

cout << "Compute PI*x^3 + 0.4*x + 1." << endl;
Ciphertext encrypted_result;
evaluator.add(x3_encrypted, x1_encrypted, encrypted_result);
evaluator.add_plain_inplace(encrypted_result, plain_coeff0);

结果验证:

输出一个真的，然后将加密的解密解码，做对比验证

code

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);

源代码