Merge pull request #45 from wfus/decode

Decode

Author: raylin1000

benchmark/decode.py

@@ -0,0 +1,12 @@
+from subprocess import call
+
+CWD = "../"
+DEGREE = [8, 12, 16, 32, 48, 63]
+DELTA = [0.1, 0.2, 0.3, 0.4, 0.5]
+call(['make'], cwd=CWD)
+call(['./bin/decode_client', '-s'], cwd=CWD)
+for degree in DEGREE:
+    for delta in DELTA:
+        print(degree, delta)
+        call(['./bin/decode_server', '--degree', str(degree), '--delta', str(delta)], cwd=CWD)
+        call(['./bin/decode_client', '-r', '-o', 'decode_out/out_{}_{}.png'.format(degree, delta)], cwd=CWD)                    

homo/client_decode.cpp

@@ -222,15 +222,12 @@ int main(int argc, const char** argv) {
             int pixel = encoder.decode(p);
             CLAMP(pixel, 0, 255)
             decrypted_image.push_back((uint8_t) pixel);
-            std::cout << (int) pixel << std::endl;
         }
         instream.close();
-        std::cout << std::endl;
 
         // Calculate RMS Error
         // compare_resize_opencv(test_filename.c_str(), resized_width, resized_height, bicubic, decrypted_image);
 
-        std::cout << width << '\t' << height << '\t' << decrypted_image.size() << std::endl;
         #ifdef linux
             save_image_rgb(width, height, decrypted_image, test_output);
         #else

homo/client_resize.cpp

@@ -228,9 +228,9 @@ int main(int argc, const char** argv) {
             diff = std::chrono::steady_clock::now() - start; 
             std::cout << chrono::duration<double, milli>(diff).count() << ',';
             // std::cout << i << '\t' << encoder.decode(p) << std::endl;
-            uint8_t pixel = (uint8_t) encoder.decode(p);
+            int pixel = encoder.decode(p);
             CLAMP(pixel, 0, 255)
-            decrypted_image.push_back(pixel);
+            decrypted_image.push_back((uint8_t) pixel);
         }
         instream.close();
         std::cout << std::endl;

homo/fhe_decode.h

@@ -202,32 +202,27 @@ Ciphertext homomorphic_cos(Ciphertext &x,
 void approximated_step(Ciphertext &amplitude, 
                         Ciphertext &index, 
                         Ciphertext &count, 
+                        int order, 
                         int degree,
                         double delta,
+                        int width, 
+                        int height,
                         std::vector<Ciphertext> &run,
                         Evaluator &evaluator, 
                         FractionalEncoder &encoder, 
-                        Encryptor &encryptor,
-                        Decryptor &decryptor) {
-    Plaintext p1, p2, p3, p4, p5;
+                        Encryptor &encryptor) {
     Ciphertext b(count);
     evaluator.multiply_plain(b, encoder.encode(0.5));
     Ciphertext offset(index);
     evaluator.add(offset, b);
     evaluator.add_plain(offset, encoder.encode(-0.5));
     evaluator.negate(offset);
     evaluator.add_plain(b, encoder.encode(delta - 0.5));
-    decryptor.decrypt(amplitude, p1);
-    decryptor.decrypt(index, p2);
-    decryptor.decrypt(count, p3);
-    decryptor.decrypt(offset, p4);
-    decryptor.decrypt(b, p5);
-    std::cout << encoder.decode(p1) << '\t' << encoder.decode(p2) << '\t' << encoder.decode(p3) << '\t' << encoder.decode(p4) << '\t' << encoder.decode(p5) << std::endl;
-    for (int i = 0; i < 16; i++) {
+    for (int i = 0; i < width * height; i++) {
         Ciphertext c(b);
-        evaluator.multiply_plain(c, encoder.encode(1.0 / 64.0));
+        evaluator.multiply_plain(c, encoder.encode(1.0 / ((double) order)));
         for (int j = 1; j <= degree; j++) {
-            double arg_factor = ((float) j) * M_PI / 64.0;
+            double arg_factor = ((float) j) * M_PI / ((double) order);
             Ciphertext sin_arg(b);
             evaluator.multiply_plain(sin_arg, encoder.encode(arg_factor));
             Ciphertext cos_arg(offset);
@@ -246,11 +241,14 @@ void approximated_step(Ciphertext &amplitude,
     }
 } 
 
-void debug_approximated_step(Ciphertext &amplitude, 
+void approximated_step(Ciphertext &amplitude, 
                         Ciphertext &index, 
                         Ciphertext &count, 
+                        int order,
                         int degree,
                         double delta,
+                        int width,
+                        int height,
                         std::vector<Ciphertext> &run,
                         Evaluator &evaluator, 
                         FractionalEncoder &encoder, 
@@ -266,11 +264,10 @@ void debug_approximated_step(Ciphertext &amplitude,
     double b = cnt / 2.0;
     double offset = -(ind + b - 0.5);
     b += delta - 0.5;
-    std::cout << amp << '\t' << ind << '\t' << cnt << '\t' << b << '\t' << offset << std::endl;
-    for (int i = 0; i < 16; i++) {
-        double res = b / 64.0;
+    for (int i = 0; i < width * height; i++) {
+        double res = b / ((double) order);
         for (int j = 1; j <= degree; j++) {
-            double arg_factor = ((float) j) * M_PI / 64.0;
+            double arg_factor = ((float) j) * M_PI / ((double) order);
             double sin_factor = sin(arg_factor * b);
             double cos_factor = cos(arg_factor * (i + offset));
             double term = 2.0 / (M_PI * ((float) j)) * cos_factor * sin_factor;

homo/server_decode.cpp

@@ -34,6 +34,9 @@ int main(int argc, const char** argv) {
     int coeff_modulus = COEFF_MODULUS;
     int resized_width = 0;
     int resized_height = 0;
+    int degree = 12;
+    double delta = 0.5;
+    int order = 64;
 
 
     try {
@@ -44,6 +47,9 @@ int main(int argc, const char** argv) {
             ("f,file", "Filename for input file to be resized", cxxopts::value<std::string>())
             ("v,verbose", "Verbose logging output", cxxopts::value<bool>(verbose))
             ("o,outfile", "Filename for homomorphic ciphertext to be saved to", cxxopts::value<std::string>())
+            ("delta", "Delta for step function size", cxxopts::value<double>())
+            ("order", "Order of approximation for step function approximation Fourier series", cxxopts::value<int>())
+            ("degree", "Terms for step function approximation", cxxopts::value<int>())
             ("ncoeff", "Number of coefficients for integer portion of encoding", cxxopts::value<int>())
             ("fcoeff", "Number of coefficients for fractional portion of encoding", cxxopts::value<int>())
             ("cmod", "Coefficient Modulus for polynomial encoding", cxxopts::value<int>())
@@ -64,6 +70,9 @@ int main(int argc, const char** argv) {
         if (result.count("fcoeff")) n_fractional_coeffs = result["fcoeff"].as<int>(); 
         if (result.count("pmod")) plain_modulus = result["pmod"].as<int>(); 
         if (result.count("cmod")) coeff_modulus = result["cmod"].as<int>(); 
+        if (result.count("degree")) degree = result["degree"].as<int>();  
+        if (result.count("order")) order = result["order"].as<int>(); 
+        if (result.count("delta")) delta = result["delta"].as<double>(); 
         if (result.count("n_poly_base")) n_poly_base = result["base"].as<int>(); 
     } 
     catch (const cxxopts::OptionException& e) {
@@ -116,35 +125,26 @@ int main(int argc, const char** argv) {
     Ciphertext c, index, elem, count;
     std::vector<std::vector<Ciphertext>> res;
     for (int i = 0; i < 3; i++) {
-        std::cout << "Color " << i << std::endl;
         encryptor.encrypt(encoder.encode(0), index);
         std::vector<Ciphertext> channel;
         for (int j = 0; j < width * height; j++) {
             encryptor.encrypt(encoder.encode(0), c);
             channel.push_back(c);
         }
         for (int j = 0; j < pairs[i]; j++) {
-            std::cout << "Run " << j << std::endl;
             std::vector<Ciphertext> run;
             elem.load(myfile);
             count.load(myfile);
-            debug_approximated_step(elem, index, count, 63, 0.5, run, evaluator, encoder, encryptor, decryptor);
+            approximated_step(elem, index, count, order, degree, delta, width, height, run, evaluator, encoder, encryptor, decryptor);
             for (int k = 0; k < width * height; k++) {
                 // Plaintext p;
                 // decryptor.decrypt(run[k], p);
                 // std::cout << encoder.decode(p) << '\t';
                 evaluator.add(channel[k], run[k]);
             }
-            std::cout << std::endl;
             evaluator.add(index, count);
         }
         res.push_back(channel);
-        for (int j = 0; j < width * height; j++) {
-            Plaintext p;
-            decryptor.decrypt(res[i][j], p);
-            std::cout << encoder.decode(p) << '\t';
-        }
-        std::cout << std::endl;
     }
     for (int i = 0; i < width * height; i++) {
         for (int j = 0; j < 3; j++) {