We will use the Concrete library to perform homomorphic inference using the trained model on encrypted data. The Concrete library significantly simplifies implementing this kind of thing. In the next sections we will focus primarily on practical use of the library, leaving out some low-level implementation details for brevity.

Loading Data

First we will load our data and model weights into vectors in Rust:

// imports for file reading
use std::fs::File;
use std::io::{BufRead, BufReader, Error, ErrorKind, Read};

// helper function to print elements of a vector
fn print_f64_vector(v: &Vec::<f64>){
    for &element in v { print!("{}, ", element); }
    println!("");
}

// function to read the csv files 
fn read<R: Read>(io: R) -> Result<Vec<f64>, Error> {
    let br = BufReader::new(io);
    br.lines()
        .map(|line| line.and_then(|v| v.parse().map_err(|e| Error::new(ErrorKind::InvalidData, e))))
        .collect()
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // read the data: you will have to change the path!
    let plaintext_data = read(File::open("/home/ed/py/linreg/weights.csv")?)?;
    let cipher_data_input = read(File::open("/home/ed/py/linreg/data.csv")?)?;
  
    // make sure we have read the values correctly
    print_f64_vector(&plaintext_data);
    print_f64_vector(&cipher_data_input);

    Ok(())
}

Concrete implementation of Logistic Regression

The next step is to implement the FHE-powered logistic regression model in Rust with Concrete. We’ll do this using the following stages:

1. Create an encoder using Concrete that will be used to when encrypting and decrypting the patient’s medical data.
2. Create two secret keys using Concrete, used to encrypt and decypt the data.
3. Create a bootstrap key using the secret keys. This is what allows the encrypted data to be operated on. The bootstrap key is shared with the medical company in our example use case. This remains secure because the bootstrap key does not allow data to be decrypted into plaintext (see our previous article for a more detailed description of what bootstrapping is and why it works).
4. Create some custom error types, useful if there are problems when we run novel operations.
5. Create two structs for matrices containing plaintext and encrypted ciphertext data. We will use these to store the model weights and patient data respectively.
6. Write a matrix multiply function that can operate on plaintext and encrypted matrices.
7. Combine the above elements to make the encrypted logistic regression model.

With all the above pieces, we will be able to: encrypt patient data; store it in matrix form; store plaintext model data in matrix form; and multiply the two matrices homomorphically to obtain encrypted predictions. We will then use the patient’s secret key to decrypt the model predictions and assess if the homomorphic model works as expected.

1–3. Defining the encoding and the encryption keys

First we need some extra imports from the Concrete library:

# concrete imports
pub use concrete::{ Encoder, LWESecretKey, RLWESecretKey, LWEBSK, LWEKSK, LWE, LWE128_1024, RLWE128_1024_1,CryptoAPIError };

Now we can define the input encoder, secret keys and the bootstrap key in the main function:

// define an encoder for the input with parameters:
//    range of inputs (-2, 2)
//    bits of precision = 6
//    bits of padding = 7
let encoder_input = Encoder::new(-2., 2., 6, 7)?;

// secret keys with parameters:
//    bits of security = 128
//    polynomial size = 1024
let sk_rlwe = RLWESecretKey::new(&RLWE128_1024_1);
let sk_in = LWESecretKey::new(&LWE128_1024);

// bootstrap key with parameters:
//    log base = 6
//    levels = 8
let bsk = LWEBSK::new(&sk_in, &sk_rlwe, 6, 8);

The parameters used above took a bit of fine tuning, for more information on how these parameters work please look at the Concrete documentation.

4–5. Defining the matrix structs (and custom errors)

As we are creating new operations and operands, we first define some error types that we will use later:

/// A custom error for FHE operations
#[derive(Debug, Clone)]
pub struct FHEError { message: String }
impl FHEError {
    pub fn new(message: String) -> FHEError { FHEError { message } }
}

impl std::fmt::Display for FHEError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "FHEError: {}", self.message)
    }
}

impl std::error::Error for FHEError {}
impl std::convert::From<CryptoAPIError> for FHEError {
    fn from (err: CryptoAPIError) -> Self {
        FHEError::new(format!("CryptoAPIError: {:}", err))
    }
}

/// a matrix operation error
#[derive(Debug, Clone)]
struct MatOpError { message: String }
impl std::fmt::Display for MatOpError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.message)
    }
}

impl std::error::Error for MatOpError {}
impl MatOpError {
    fn new(message: String) -> MatOpError { MatOpError { message } }
}

Now we must define the ciphertext matrix struct, then implement a new method which will allow us to create matrices of ciphertexts. The data containing the elements of the ciphertext matrix is stored in a vector of type LWE:

/// a matrix of LWE ciphers
pub struct CipherMatrix {
    pub dimensions: (usize, usize),
    pub data: Vec<LWE>
}
      
impl CipherMatrix {
      
    pub fn new(data: Vec<LWE>, dimensions: (usize, usize)) 
        -> Result<CipherMatrix, FHEError>
    {
        // check that the data has the right number of elements
        if data.len() != dimensions.0 * dimensions.1 {
            return Err(FHEError::new(format!(
                "The dimensions are ({}, {}), so the data must have {} elements, but has {}",
                dimensions.0, dimensions.1, dimensions.0 * dimensions.1, data.len()
            )))
        }
        Ok(CipherMatrix { dimensions, data })
    }  
}

We similarly define a plaintext matrix containing 64-bit floats:

/// a matrix of plaintext values
pub struct PlaintextMatrix {
    pub dimensions: (usize, usize),
    pub data: Vec<f64>
}
    
impl PlaintextMatrix {

    pub fn new(data: Vec<f64>, dimensions: (usize, usize)) 
        -> Result<PlaintextMatrix, FHEError>
    {
        // check that the data has the right number of elements
        if data.len() != dimensions.0 * dimensions.1 {
            return Err(FHEError::new(format!(
                "The dimensions are ({}, {}), so the data must have {} elements, but has {}",
                dimensions.0, dimensions.1, dimensions.0 * dimensions.1, data.len()
            )))
        }
        Ok(PlaintextMatrix { dimensions, data })
    }
}

fn safe_mul_constant_with_padding(cipher: &LWE, constant: f64, max_pt_val: f64, bits_to_consume: usize)
    -> Result<LWE, Box<dyn std::error::Error>>
{
    if constant != 0. {
        Ok(
            cipher.mul_constant_with_padding(
                constant, max_pt_val, bits_to_consume
            )?
        )
    }
    else{
        Ok(
            cipher.add_centered(
                &cipher.opposite()?
            )?.mul_constant_with_padding(
                1.0, max_pt_val, bits_to_consume
            )?
        )
    }
}

pub fn mat_mul_pc(m1: &PlaintextMatrix, m2: &CipherMatrix, bsk: &LWEBSK, max_pt_val: f64, bits_to_consume: usize)
    -> Result<CipherMatrix, Box<dyn std::error::Error>>
{   
    check_dims_pc(m1, m2)?;
    let mut ans_vector = Vec::<LWE>::with_capacity(m1.dimensions.0 * m2.dimensions.1);
    for ay in 0..m1.dimensions.0{
        for ax in 0..m2.dimensions.1{
            println!("{}, {}", ay, ax);
            for val in 0..m1.dimensions.1{
                if val == 0{
                    ans_vector.push(
                        safe_mul_constant_with_padding(
                            &m2.data[ax], 
                            m1.data[ay*m1.dimensions.1],
                            max_pt_val,
                            bits_to_consume
                        )?
                    );
                }
                else{
                    ans_vector[ax + (m2.dimensions.1 * ay)].add_centered_inplace(
                        &m2.data[ax + (val*m2.dimensions.1)].mul_constant_with_padding(
                            m1.data[(ay*m1.dimensions.1) + val], max_pt_val, bits_to_consume
                        )?
                    )?;
                }
                ans_vector[ax + (m2.dimensions.1 * ay)].bootstrap(bsk)?;
            }
        }
    }
    Ok(
        CipherMatrix::new(ans_vector, (m1.dimensions.0, m2.dimensions.1))?
    )
}

This function uses a couple of functions from the Concrete library, namely add_centered_inplace and mul_constant_with_padding. We wont go into the details of how these work, but at a high level they are simply addition and multiplication functions. add_centered_inplace adds two ciphertexts together, and mul_constant_with_padding multiplies a ciphertext by a plaintext constant, returning a new ciphertext.

We define a function called safe_mul_constant_with_padding that removes some issues when using mult_constant_with_padding on a constant that is zero. The technical details of this are a bit much for the scope of this article, but what the function is doing can be understood as follows:

Aim: calculate (C*0), where C is a ciphertext
Workflow: return (C+(C*-1)) * 1.0

This function ensures that the output is correct, and that it has the right format and encoding such that later operations are compatible with the cipher.

7. Putting it all together

We now have all the required elements to run the logistic regression model on some encrypted data. Here’s how we do it:

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // dimensions of the matrices
    let plaintext_matrix_dimensions: (usize, usize) = (1,10);       // model weights
    let cipher_matrix_dimensions: (usize, usize) = (10,569);        // dataset

    // read weights and data from files
    let plaintext_data = read(File::open("/home/ed/py/linreg/weights.csv")?)?;
    let cipher_data_input = read(File::open("/home/ed/py/linreg/data.csv")?)?;

    // encoders: min val, max val, bits, bits of padding
    let encoder_input = Encoder::new(-2., 2., 6, 7)?;

    // secret keys: 128 bits of security, polnomial size of 1024
    let sk_rlwe = RLWESecretKey::new(&RLWE128_1024_1);
    let sk_in = LWESecretKey::new(&LWE128_1024);

    //bootstrapping key: log base of 6, 8 levels
    let bsk = LWEBSK::new(&sk_in, &sk_rlwe, 6, 8);

    // encrypt each message
    let cipher_data: Result<Vec<LWE>, _> = cipher_data_input.into_iter().map(|m| 
        LWE::encode_encrypt(&sk_in, m, &encoder_input)).collect();

    // build a matrix with the cipher and plaintext
    let plaintext_mat = PlaintextMatrix::new(plaintext_data, plaintext_matrix_dimensions)?;
    let ciphertext_mat = CipherMatrix::new(cipher_data?, cipher_matrix_dimensions)?;

    // multiply the matrices
    let mat_mul_result_cipher = mat_mul_pc(&plaintext_mat, &ciphertext_mat, &bsk, 5., 6)?;

    // decrypt the result
    let mat_mul_result_plaintext = decrypt_vector(&mat_mul_result_cipher.data, &sk_in)?;
    
    // print the model output
    print_f64_vector(&mat_mul_result_plaintext);

    Ok(())
}

The output of the above code is a list of numbers, the sign of these numbers indicates the class of the prediction, negative sign, negative prediction and vice versa:

-1.1276431618729381, -0.26699129985757963, …0.6429439321792962