phe/paillier/main_define_classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialize the environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "import random\n",
    "import sys, os\n",
    "from joblib import Parallel, delayed\n",
    "from Bio import SeqIO\n",
    "from p_bloom_filter import encode\n",
    "from p_database import dotproduct, magnitude\n",
    "import time\n",
    "from phe import paillier\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from seal import ChooserEvaluator,     \\\n",
    "                 Ciphertext,           \\\n",
    "                 Decryptor,            \\\n",
    "                 Encryptor,            \\\n",
    "                 EncryptionParameters, \\\n",
    "                 Evaluator,            \\\n",
    "                 IntegerEncoder,       \\\n",
    "                 KeyGenerator,         \\\n",
    "                 MemoryPoolHandle,     \\\n",
    "                 Plaintext"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected \"addgenePartial982.fasta\" from file number 3\n",
      "/SEAL/local_data/atitus/data/bacterial_genomes/bacteria/GCF_000446565.2_ASM44656v2_genomic.fasta\n"
     ]
    }
   ],
   "source": [
    "## This is a reference to data stored on the Lab41 system\n",
    "\n",
    "#d = '/local_data/atitus/data/bacterial_genomes/bacteria'\n",
    "d = '/SEAL/local_data/atitus/data/bacterial_genomes/bacteria'\n",
    "\n",
    "random.seed(3)\n",
    "\n",
    "files = os.listdir(d)\n",
    "query_file_ind = randint(0, 8)\n",
    "\n",
    "f = files[query_file_ind]\n",
    "\n",
    "print('Selected \"' + f + '\" from file number %s' % str(query_file_ind))\n",
    "\n",
    "f = os.path.join(d, 'GCF_000446565.2_ASM44656v2_genomic.fasta')#f)\n",
    "print(f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PHE\n",
    "Paillier Homomorphic Encryption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "\n",
    "############\n",
    "# Set up environment\n",
    "############\n",
    "## Parameters\n",
    "# seq_len: Length of query sequence - this is also the length of the database entries\n",
    "# LSH_size: the size of the LSH to has the sequences into - in the current implementation, must be 5:1 ratio to seq_len\n",
    "# num_cores: number of cores for parallelization\n",
    "# kmer_size: size of k-mer to hash sequece into LSH\n",
    "# H: hash function being used\n",
    "# hash_max: parameter to make sure our hashes are withing the bounds of the LSH\n",
    "# data_dir: directory that holds all of the FASTA files for the data\n",
    "# search_n_entries: limit the number of DB entries to compare against query - mostly for testing purposes\n",
    "# comparison: 'pe' == plain-to-encrypted; 'pp' == plain-to-plain - at the moment, only 'pe' is functional\n",
    "# scheme: encryption scheme - 'paillier' or 'FHE'\n",
    "\n",
    "parameters = Parameters(seq_len = 20000, \n",
    "                        LSH_size = 100000, \n",
    "                        num_cores = 48, \n",
    "                        kmer_size = 8, \n",
    "                        H = hash, \n",
    "                        hash_max = sys.maxsize + 1,\n",
    "                        data_dir = d, \n",
    "                        search_n_entries = 70,\n",
    "                        comparison = 'pe',\n",
    "                        scheme = 'paillier')\n",
    "\n",
    "\n",
    "############\n",
    "# Initialize query to be passed\n",
    "############\n",
    "investigator = Querier(parameters)\n",
    "investigator.load_query_from_fasta(f)\n",
    "investigator.encode_query(investigator.query)\n",
    "\n",
    "enc_start = time.time()\n",
    "investigator.generate_keys()\n",
    "investigator.encrypt_LSH(investigator.LSH)\n",
    "enc_end = time.time()\n",
    "\n",
    "## Pass query from Querier to DB holder\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "############\n",
    "# Search database\n",
    "############\n",
    "query = investigator.pass_query()\n",
    "participant = Database(query = query, Parameters = parameters)\n",
    "\n",
    "query_start = time.time()\n",
    "participant.gen_database_scores()\n",
    "query_end = time.time()\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "## Pass results from DB holder to Querier\n",
    "\n",
    "############\n",
    "# Calculated scores\n",
    "############\n",
    "enc_results = participant.pass_results()\n",
    "\n",
    "score_start = time.time()\n",
    "investigator.calc_scores(enc_results)\n",
    "score_end = time.time()\n",
    "\n",
    "end_time = time.time() - start\n",
    "enc_time = enc_end - enc_start\n",
    "query_time = query_end - query_start\n",
    "score_time = score_end - score_start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('Algorithm took %s minutes' % str(round(end_time/60, 2)))\n",
    "print('Encryption took %s minutes' % str(round(enc_time/60, 2)))\n",
    "print('Query took %s minutes' % str(round(query_time/60, 2)))\n",
    "print('Calculating scores took %s minutes\\n' % str(round(score_time/60, 2)))\n",
    "\n",
    "print(investigator.max_iou, investigator.max_ioLquery, investigator.max_ioLresult)\n",
    "print(investigator.best_seq == investigator.query)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FHE\n",
    "Fully Homomorphic Encryption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "\n",
    "############\n",
    "# Set up environment\n",
    "############\n",
    "parameters = Parameters(seq_len = 100, \n",
    "                        LSH_size = 500, \n",
    "                        num_cores = 48, \n",
    "                        kmer_size = 8, \n",
    "                        H = hash, \n",
    "                        hash_max = sys.maxsize + 1,\n",
    "                        data_dir = d, \n",
    "                        search_n_entries = 700,\n",
    "                        comparison = 'pe',\n",
    "                        scheme = 'FHE')\n",
    "\n",
    "\n",
    "############\n",
    "# Initialize query to be passed\n",
    "############\n",
    "investigator = Querier(parameters)\n",
    "investigator.load_query_from_fasta(f)\n",
    "investigator.encode_query(investigator.query)\n",
    "\n",
    "enc_start = time.time()\n",
    "investigator.generate_keys()\n",
    "investigator.encrypt_LSH(investigator.LSH)\n",
    "enc_end = time.time()\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "############\n",
    "# Search database\n",
    "############\n",
    "query = investigator.pass_query()\n",
    "participant = Database(query = query, Parameters = parameters)\n",
    "\n",
    "query_start = time.time()\n",
    "participant.gen_database_scores()\n",
    "query_end = time.time()\n",
    "\n",
    "\n",
    "############\n",
    "# Calculated scores\n",
    "############\n",
    "enc_results = participant.pass_results()\n",
    "\n",
    "score_start = time.time()\n",
    "investigator.calc_scores(enc_results)\n",
    "score_end = time.time()\n",
    "\n",
    "end_time = time.time() - start\n",
    "enc_time = enc_end - enc_start\n",
    "query_time = query_end - query_start\n",
    "score_time = score_end - score_start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('Algorithm took %s minutes' % str(round(end_time/60, 2)))\n",
    "print('Encryption took %s minutes' % str(round(enc_time/60, 2)))\n",
    "print('Query took %s minutes' % str(round(query_time/60, 2)))\n",
    "print('Calculating scores took %s minutes\\n' % str(round(score_time/60, 2)))\n",
    "\n",
    "print(investigator.max_iou, investigator.max_ioLquery, investigator.max_ioLresult)\n",
    "print(investigator.best_seq == investigator.query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "len(investigator.enc_LSH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Parameters(object):\n",
    "    \"\"\"\n",
    "    Comments about this class\n",
    "    \n",
    "    Attributes:\n",
    "        \n",
    "    \"\"\"\n",
    "    def __init__(self, seq_len, LSH_size, num_cores, \n",
    "                 kmer_size, H, hash_max, search_n_entries, \n",
    "                 data_dir, comparison, scheme):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self.seq_len = seq_len\n",
    "        self.LSH_size = LSH_size\n",
    "        self.num_cores = num_cores\n",
    "        self.kmer_size = kmer_size\n",
    "        self.H = H\n",
    "        self.H_max = hash_max\n",
    "        self.search_n_entries = search_n_entries\n",
    "        self.data_dir = data_dir\n",
    "        self.comparison = comparison\n",
    "        self.scheme = scheme\n",
    "        \n",
    "        if self.scheme == 'FHE':\n",
    "            self.fhe_params = EncryptionParameters()\n",
    "            self.fhe_params.set_poly_modulus('1x^2048 + 1')\n",
    "            self.fhe_params.set_coeff_modulus(ChooserEvaluator.default_parameter_options()[2048]);\n",
    "            self.fhe_params.set_plain_modulus(1 << 8)\n",
    "            self.fhe_params.validate()\n",
    "            self.memorypool = MemoryPoolHandle.acquire_global()\n",
    "            self.encoder = IntegerEncoder(self.fhe_params.plain_modulus(), 2, self.memorypool)\n",
    "            \n",
    "        \n",
    "    def get_num_cores(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.num_cores)\n",
    "        \n",
    "    \n",
    "    def get_seq_len(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.seq_len)\n",
    "    \n",
    "    \n",
    "    def get_LSH_size(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.LSH_size)\n",
    "    \n",
    "    \n",
    "    def get_kmer_size(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.kmer_size)\n",
    "    \n",
    "    \n",
    "    def get_hash_func(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.H)\n",
    "    \n",
    "    \n",
    "    def get_hash_max(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.H_max)\n",
    "    \n",
    "    \n",
    "    def get_search_size(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.search_n_entries)\n",
    "    \n",
    "    \n",
    "    def get_data_dir(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.data_dir)\n",
    "    \n",
    "    \n",
    "    def get_comparison(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.comparison)\n",
    "    \n",
    "    \n",
    "    def get_enc_scheme(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.scheme)\n",
    "    \n",
    "    \n",
    "    def get_fhe_params(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.fhe_params)\n",
    "    \n",
    "    \n",
    "    def get_mempool(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.memorypool)\n",
    "    \n",
    "    \n",
    "    def get_fhe_encoder(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Querier(object):\n",
    "    \"\"\"\n",
    "    Comments about this class\n",
    "    \n",
    "    Attributes:\n",
    "        seq_len: length of query sequence\n",
    "    \"\"\"\n",
    "    def __init__(self, Parameters):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self.seq_len = Parameters.get_seq_len()\n",
    "        self.LSH_size = Parameters.get_LSH_size()\n",
    "        self.num_cores = Parameters.get_num_cores()\n",
    "        self.kmer_size = Parameters.get_kmer_size()\n",
    "        self.H = Parameters.get_hash_func()\n",
    "        self.H_max = Parameters.get_hash_max()\n",
    "        self.comparison = Parameters.get_comparison()\n",
    "        self.scheme = Parameters.get_enc_scheme()\n",
    "        self.enc_LSH = None\n",
    "        \n",
    "        if self.scheme == 'FHE':\n",
    "            self.fhe_params = Parameters.get_fhe_params()\n",
    "            self.memorypool = Parameters.get_mempool()\n",
    "            self.encoder = Parameters.get_fhe_encoder()\n",
    "        \n",
    "        \n",
    "    def get_num_cores(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.num_cores)\n",
    "        \n",
    "    \n",
    "    def get_seq_len(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.seq_len)\n",
    "    \n",
    "        \n",
    "    def load_query_from_fasta(self, file_loc):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        \n",
    "        seq = ''\n",
    "        with open(f, \"r\") as handle:\n",
    "            for record in SeqIO.parse(handle, \"fasta\"):\n",
    "                seq += str(record.seq)\n",
    "        \n",
    "        self.query = seq[:self.seq_len]\n",
    "        return(0)\n",
    "    \n",
    "    \n",
    "    def load_query_from_database(self, database):\n",
    "        \"\"\"\n",
    "        In progress\n",
    "        \"\"\"\n",
    "        return(1)\n",
    "    \n",
    "    def print_query_seq(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.query)\n",
    "    \n",
    "    \n",
    "    def encode_query(self, query_seq):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "\n",
    "        self.LSH = encode(query_seq, \n",
    "                          size=self.LSH_size, \n",
    "                          k=self.kmer_size, \n",
    "                          h=self.H,\n",
    "                          HASH_MAX=self.H_max)\n",
    "        \n",
    "        self.query_mag = magnitude(self.LSH)\n",
    "        \n",
    "    \n",
    "    def get_LSH(self):\n",
    "        return(self.LSH)\n",
    "    \n",
    "    \n",
    "    def generate_keys(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        if self.scheme == 'paillier':\n",
    "            self.public_key, self.private_key = paillier.generate_paillier_keypair()\n",
    "            \n",
    "        elif self.scheme == 'FHE':\n",
    "            # For detailed information, see PySEAL example script\n",
    "            generator = KeyGenerator(self.fhe_params, self.memorypool)\n",
    "            generator.generate(0)\n",
    "            \n",
    "            self.public_key = generator.public_key()\n",
    "            self.private_key = generator.secret_key()\n",
    "            \n",
    "            \n",
    "            \n",
    "            self.encryptor = Encryptor(self.fhe_params, self.public_key, self.memorypool)\n",
    "            \n",
    "        else:\n",
    "            return('Wrong encryption scheme call...')\n",
    "        \n",
    "    \n",
    "    def get_pub_key(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.public_key)\n",
    "    \n",
    "    \n",
    "    def get_priv_key(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.private_key)\n",
    "    \n",
    "    \n",
    "    def _FHE_encode_int(self, integer):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        encoded = self.encoder.encode(integer)\n",
    "        encrypted = self.encryptor.encrypt(encoded)\n",
    "        \n",
    "        return(encrypted)\n",
    "    \n",
    "    \n",
    "    def encrypt_LSH(self, LSH):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        num_cores = self.num_cores\n",
    "        \n",
    "        if self.scheme == 'paillier':\n",
    "            self.enc_LSH = Parallel(n_jobs=num_cores)(delayed(self.public_key.encrypt)(x) for x in LSH)\n",
    "        \n",
    "        elif self.scheme == 'FHE':\n",
    "            self.enc_LSH = []\n",
    "            for i,x in enumerate(LSH):\n",
    "                self.enc_LSH.append(self._FHE_encode_int(LSH[i]))\n",
    "    \n",
    "        else:\n",
    "            return('Wrong encryption scheme call...')\n",
    "        \n",
    "        \n",
    "    def get_enc_query(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.enc_LSH)\n",
    "    \n",
    "    \n",
    "    def pass_query(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        if self.comparison == 'pe':\n",
    "            return(self.enc_LSH)\n",
    "        elif self.comparison == 'pp':\n",
    "            return(self.LSH)\n",
    "        else:\n",
    "            print('Wrong comparison parameter')\n",
    "            return(1)\n",
    "    \n",
    "    \n",
    "    ####################\n",
    "    # Calculate the Intersection over X\n",
    "    ####################\n",
    "    def ioX(self, intersection, data_mag):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        union = (data_mag + self.query_mag) - intersection\n",
    "\n",
    "        iou = intersection/union\n",
    "        max_ioLquery = intersection/self.query_mag\n",
    "        max_ioLresult = intersection/data_mag\n",
    "\n",
    "        return iou, max_ioLquery, max_ioLresult\n",
    "    \n",
    "    \n",
    "    ####################\n",
    "    # Calculate all IoXs\n",
    "    ####################\n",
    "    def calc_ioX(self, id_):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        if self.comparison == 'pe':\n",
    "            if self.scheme == 'paillier':\n",
    "                intersection = self.private_key.decrypt(id_[0])\n",
    "            else:\n",
    "                self.decryptor = Decryptor(self.fhe_params, self.private_key, self.memorypool)\n",
    "                poly_intersection = self.decryptor.decrypt(id_[0])\n",
    "                intersection = self.encoder.decode_int32(poly_intersection)\n",
    "        else:\n",
    "            intersection = id_[0]\n",
    "            \n",
    "        Iou, IoLquery, IoLresult = self.ioX(intersection, id_[1])\n",
    "\n",
    "        return Iou, IoLquery, IoLresult, id_[2], id_[1]\n",
    "    \n",
    "    \n",
    "    ####################\n",
    "    # Generate all scores and find max based on IoU\n",
    "    ####################\n",
    "    def calc_scores(self, enc_results):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self.max_iou = 0\n",
    "        self.best_id = 0\n",
    "        best_seq = ''\n",
    "        \n",
    "        if self.scheme == 'paillier':\n",
    "            self.result_scores = Parallel(n_jobs=self.num_cores)(delayed(self.calc_ioX)(id_) for id_ in enc_results)\n",
    "        else:\n",
    "            self.result_scores = []\n",
    "            for i,id_ in enumerate(enc_results):\n",
    "                self.result_scores.append(self.calc_ioX(id_))\n",
    "                \n",
    "        for score_set in self.result_scores:\n",
    "            if score_set[0] >= self.max_iou: \n",
    "                self.max_iou = score_set[0]\n",
    "                self.max_ioLquery = score_set[1]\n",
    "                self.max_ioLresult = score_set[2]  \n",
    "                self.best_seq = score_set[3]\n",
    "                self.result_mag = score_set[4]\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Database(object):\n",
    "    \"\"\"\n",
    "    Comments about this class\n",
    "    \n",
    "    Attributes:\n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, query, Parameters):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self.comparison = Parameters.get_comparison()\n",
    "        self.data_dir = Parameters.get_data_dir()\n",
    "        self.search_size = Parameters.get_search_size()    \n",
    "        self.seq_len = Parameters.get_seq_len()\n",
    "        self.LSH_size = Parameters.get_LSH_size()\n",
    "        self.num_cores = Parameters.get_num_cores()\n",
    "        self.kmer_size = Parameters.get_kmer_size()\n",
    "        self.H = Parameters.get_hash_func()\n",
    "        self.H_max = Parameters.get_hash_max()\n",
    "        self.enc_LSH = query\n",
    "        \n",
    "        self.scheme = Parameters.get_enc_scheme()\n",
    "        \n",
    "        if self.scheme == 'FHE':\n",
    "            self.fhe_params = Parameters.get_fhe_params()\n",
    "            self.memorypool = Parameters.get_mempool()\n",
    "            self.encoder = Parameters.get_fhe_encoder()\n",
    "    \n",
    "    \n",
    "    def get_data_dir(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.data_dir)\n",
    "    \n",
    "    \n",
    "    def gen_scores(self, id_, LSH):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        seq_file = os.path.join(self.data_dir, id_)\n",
    "\n",
    "        entry_seq = ''\n",
    "        \n",
    "        with open(seq_file, \"r\") as handle:\n",
    "            for record in SeqIO.parse(handle, \"fasta\"):\n",
    "                entry_seq += str(record.seq)\n",
    "\n",
    "        entry_seq = entry_seq[ :self.seq_len]\n",
    "\n",
    "        if seq_file == f:\n",
    "            return(LSH[0]*0,0.0001, entry_seq)\n",
    "        \n",
    "        entry_LSH = encode(entry_seq, \n",
    "                           size=self.LSH_size, \n",
    "                           k=self.kmer_size, \n",
    "                           h=self.H,\n",
    "                           HASH_MAX=self.H_max)\n",
    "        \n",
    "        if self.scheme == 'paillier':\n",
    "            return(self.phe_dotproduct(entry_LSH, LSH), magnitude(entry_LSH), entry_seq)\n",
    "        \n",
    "        else:\n",
    "            return(self.fhe_dotproduct(entry_LSH, LSH), magnitude(entry_LSH), entry_seq)\n",
    "    \n",
    "    \n",
    "    def gen_database_scores(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        \n",
    "        data = os.listdir(self.data_dir)\n",
    "        data = data[:self.search_size]\n",
    "        \n",
    "        if self.scheme == 'paillier':\n",
    "            self.result_scores = Parallel(n_jobs=self.num_cores)(delayed(self.gen_scores)(id_, self.enc_LSH) for id_ in data)\n",
    "        \n",
    "        elif self.scheme == 'FHE':\n",
    "            self.result_scores = []\n",
    "            for i,id_ in enumerate(data):\n",
    "                self.result_scores.append(self.gen_scores(id_, self.enc_LSH))\n",
    "    \n",
    "    \n",
    "    def pass_results(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        return(self.result_scores)\n",
    "    \n",
    "    \n",
    "    ####################\n",
    "    # Calculate the dot product between a binary vector and an encrypted vector\n",
    "    ####################\n",
    "    def phe_dotproduct(self, v1, v2):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        v1_array = np.asarray(v1)\n",
    "        v2_array = np.asarray(v2)\n",
    "        dot = np.dot(v1_array, v2_array)\n",
    "\n",
    "        return dot\n",
    "\n",
    "    \n",
    "    ####################\n",
    "    # Calculate the dot product between a binary vector and an encrypted vector\n",
    "    ####################\n",
    "    def fhe_dotproduct(self, entry_LSH, enc_LSH):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self.evaluator = Evaluator(self.fhe_params, self.memorypool)\n",
    "        \n",
    "        dot = -1\n",
    "        for i,_ in enumerate(enc_LSH):\n",
    "            if entry_LSH[i] == 1:\n",
    "                if dot == -1:\n",
    "                    dot = enc_LSH[i]\n",
    "                else:\n",
    "                    dot = self.evaluator.add(dot, enc_LSH[i])\n",
    "\n",
    "        return dot\n",
    "    \n",
    "\n",
    "    ####################\n",
    "    # Calculate the magnitude of a binary vector\n",
    "    ####################\n",
    "    def magnitude(v):\n",
    "        \"\"\"Finds the magnitude of a binary vector (array).\n",
    "\n",
    "        Args:\n",
    "            v: A binary vector (array).\n",
    "\n",
    "        Returns:\n",
    "            The magnitude of the vector.\n",
    "        \"\"\"\n",
    "\n",
    "        return sum(v)             "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}