initial commit

.gitignore

@@ -0,0 +1 @@
+__pycache__/

README copy.md

@@ -0,0 +1,55 @@
+---
+title: Encrypted Anonymization Using Fully Homomorphic Encryption
+emoji: 🕵️‍♂️ 🔒
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 3.40.0
+app_file: app.py
+pinned: true
+tags:
+  - FHE
+  - PPML
+  - privacy
+  - privacy preserving machine learning
+  - data anonymization
+  - homomorphic encryption
+  - security
+python_version: 3.10.11
+---
+
+# Data Anonymization using FHE
+
+## Run the application locally
+
+### Install the dependencies
+
+First, create a virtual env and activate it:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+Then, install the required packages:
+
+```python
+pip3 install pip --upgrade
+pip3 install -U pip wheel setuptools --ignore-installed
+pip3 install -r requirements.txt --ignore-installed
+```
+
+The above steps should only be done once.
+
+## Run the app
+
+In a terminal, run:
+
+```bash
+source .venv/bin/activate
+python3 anonymize_app.py
+```
+
+## Interact with the application
+
+Open the given URL link (search for a line like `Running on local URL: http://127.0.0.1:8888/`).

app.py

@@ -0,0 +1,95 @@
+"""A Gradio app for anonymizing text data using FHE."""
+
+import gradio as gr
+import re
+from fhe_anonymizer import FHEAnonymizer
+import pandas as pd
+
+
+anonymizer = FHEAnonymizer()
+
+
+def deidentify_text(input_text):
+    anonymized_text, identified_words = anonymizer(input_text)
+    # Convert the list of identified words into a DataFrame
+    if identified_words:  # Ensure there are identified words to process
+        identified_df = pd.DataFrame(identified_words, columns=["Identified Words"])
+    else:
+        identified_df = pd.DataFrame(columns=["Identified Words"])
+    return anonymized_text, identified_df
+
+
+# Default demo text from the file
+with open("demo_text.txt", "r") as file:
+    default_demo_text = file.read()
+
+demo = gr.Blocks()
+
+with demo:
+    gr.Markdown(
+        """
+        <p align="center">
+            <img width=200 src="file/images/logos/zama.jpg">
+        </p>
+        <h1 style="text-align: center;">Encrypted Anonymization Using Fully Homomorphic Encryption</h1>
+        <p align="center">
+            <a href="https://github.com/zama-ai/concrete-ml"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="file/images/logos/github.png">Concrete-ML</a>
+            —
+            <a href="https://docs.zama.ai/concrete-ml"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="file/images/logos/documentation.png">Documentation</a>
+            —
+            <a href="https://zama.ai/community"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="file/images/logos/community.png">Community</a>
+            —
+            <a href="https://twitter.com/zama_fhe"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="file/images/logos/x.png">@zama_fhe</a>
+        </p>
+        """
+    )
+
+    with gr.Accordion("What is Encrypted Anonymization?", open=False):
+        gr.Markdown(
+            """
+            Encrypted Anonymization leverages Fully Homomorphic Encryption (FHE) to protect sensitive information during data processing. This approach allows for the anonymization of text data, such as personal identifiers, while ensuring that the data remains encrypted throughout the entire process. It enables organizations to utilize sensitive data for analytics and machine learning without compromising individual privacy or security.
+            """
+        )
+
+    with gr.Accordion("Why is privacy important in data processing?", open=False):
+        gr.Markdown(
+            """
+            Privacy in data processing is critical to protect individuals' personal information from unauthorized access and potential misuse. With the increasing amount of personal data being collected and analyzed, the risks associated with data breaches and identity theft have also risen. By implementing privacy-preserving techniques, such as encrypted anonymization, organizations can safeguard sensitive information, build trust with their customers, and comply with stringent data protection regulations.
+            """
+        )
+
+    with gr.Accordion(
+        "How does Fully Homomorphic Encryption enhance data privacy?", open=False
+    ):
+        gr.Markdown(
+            """
+            Fully Homomorphic Encryption (FHE) enhances data privacy by enabling computations on encrypted data without needing to decrypt it first. This revolutionary technology ensures that sensitive data can be processed and analyzed securely, without exposing it to potential threats. FHE is a game-changer for privacy-preserving computations, allowing for the secure analysis of encrypted data, which is particularly beneficial in sectors like finance, healthcare, and beyond.
+            """
+        )
+
+    gr.Markdown(
+        """
+        <p align="center">
+            <img src="file/images/banner.png">
+        </p>
+        """
+    )
+
+    with gr.Row():
+        input_text = gr.Textbox(value=default_demo_text, lines=13, placeholder="Input text here...", label="Input")
+
+        anonymized_text_output = gr.Textbox(label="Anonymized Text", lines=13)
+
+    identified_words_output = gr.Dataframe(label="Identified Words")
+
+    submit_button = gr.Button("Anonymize")
+
+    submit_button.click(
+        deidentify_text,
+        inputs=[input_text],
+        outputs=[anonymized_text_output, identified_words_output],
+    )
+
+
+# Launch the app
+demo.launch(share=False)

cml_xgboost.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:431175c3c2bd7591ebfffa3ea45b1096dda5ba7588291252994f9be31db35534
+size 6625266

demo_text.txt

@@ -0,0 +1,10 @@
+Hello, my name is David Johnson and I live in Maine.
+My credit card number is 4095-2609-9393-4932 and my crypto wallet id is 16Yeky6GMjeNkAiNcBY7ZhrLoMSgg1BoyZ.
+
+On September 18 I visited microsoft.com and sent an email to test@presidio.site,  from the IP 192.168.0.1.
+
+My passport: 191280342 and my phone number: (212) 555-1234.
+
+This is a valid International Bank Account Number: IL150120690000003111111 . Can you please check the status on bank account 954567876544?
+
+Kate's social security number is 078-05-1126.  Her driver license? it is 1234567A.

embedded_model.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28fcf483356bf2bef29b8220b84803acf9518f19fbc9342e76cac06b30803f28
+size 73056

embedded_model.model.wv.vectors_ngrams.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:faf08ed9c3bc29cf71c16f5d2b311f3bfb730a92f12c2e52d742bc6b59bf9e5f
+size 800000128

fhe_anonymizer.py

@@ -0,0 +1,74 @@
+import gensim
+import re
+from concrete.ml.deployment import FHEModelClient, FHEModelServer
+from pathlib import Path
+from concrete.ml.common.serialization.loaders import load
+
+base_dir = Path(__file__).parent
+
+class FHEAnonymizer:
+    def __init__(self, punctuation_list=".,!?:;"):
+
+        self.embeddings_model = gensim.models.FastText.load(str(base_dir / "embedded_model.model"))
+        self.punctuation_list = punctuation_list
+        with open(base_dir / "cml_xgboost.model", "r") as model_file:
+            self.fhe_ner_detection = load(file=model_file)
+
+        path_to_model = (base_dir / "deployment").resolve()
+        self.client = FHEModelClient(path_to_model)
+        self.server = FHEModelServer(path_to_model)
+        self.client.generate_private_and_evaluation_keys()
+        self.evaluation_key = self.client.get_serialized_evaluation_keys()
+
+    def fhe_inference(self, x):
+        enc_x = self.client.quantize_encrypt_serialize(x)
+        enc_y = self.server.run(enc_x, self.evaluation_key)
+        y = self.client.deserialize_decrypt_dequantize(enc_y)
+        return y
+
+    def __call__(self, text: str):
+        text = self.preprocess_sentences(text)
+        identified_words = []
+        new_text = []
+
+        for word in text.split():
+            # Prediction for each word
+            x = self.embeddings_model.wv[word][None]
+            prediction = self.fhe_ner_detection.predict(x)
+            # prediction = self.fhe_inference(x).argmax(1)[0]
+
+            if prediction == 1:
+                identified_words.append(word)
+                new_text.append("<REMOVED>")
+            else:
+                new_text.append(word)
+
+        # Joining the modified text
+        modified_text = " ".join(new_text)
+
+        return modified_text, identified_words
+
+    def preprocess_sentences(self, sentence, verbose=False):
+        """Preprocess the sentence."""
+
+        sentence = re.sub(r'\n+', ' ', sentence)
+        if verbose: print(sentence)
+
+        sentence = re.sub(' +', ' ', sentence)
+        if verbose: print(sentence)
+
+        sentence = re.sub(r"'s\b", " s", sentence)
+        if verbose: print(sentence)
+
+        sentence = re.sub(r'\s([,.!?;:])', r'\1', sentence)
+        if verbose: print(sentence)
+
+        pattern = r'(?<!\w)[{}]|[{}](?!\w)'.format(re.escape(self.punctuation_list), re.escape(self.punctuation_list))
+        sentence = re.sub(pattern, '', sentence)
+        if verbose: print(sentence)
+
+        sentence = re.sub(r'\s([,.!?;:])', r'\1', sentence)
+        if verbose: print(sentence)
+
+
+        return sentence

requirements.txt

@@ -0,0 +1,3 @@
+concrete-ml==1.5.0rc0
+gensim==4.3.2
+gradio==3.40.1

utils_demo.py

@@ -0,0 +1,274 @@
+
+import logging
+import re
+import string
+from flair.data import Sentence
+from flair.models import SequenceTagger
+from presidio_analyzer import AnalyzerEngine
+from presidio_anonymizer import AnonymizerEngine
+
+
+
+entity_label_to_code_map = {'<PERSON>': 0,
+ '<O>': 1,
+ '<MISC>-<NRP>': 2,
+ '<NUMBER>': 3,
+ '<PER>-<LOCATION>': 4,
+ '<LOC>': 5,
+ '<MISC>': 6, # Miscellaneous: doesn't fall into the more common categories of PERSON, LOCATION, ORGANIZATION,
+ '<DATE_TIME>': 7,
+ '<LOCATION>': 8,
+ '<PRONOUNS>': 9,
+ '<IN_PAN>': 10,
+ '<MISC>-<DATE_TIME>': 11,
+ '<ORG>': 12,
+ '<MISC>-<IN_PAN>': 13,
+ '<MISC>-<LOCATION>': 14,
+ '<PER>': 15,
+ '<MISC>-<PERSON>': 16,
+ '<LOC>-<PERSON>': 17,
+ '<PHONE_NUMBER>': 18,
+ '<LOC>-<DATE_TIME>': 19,
+ '<LOC>-<NRP>': 20,
+ '<NRP>': 21,
+ '<ORG>-<PERSON>': 22,
+ '<PER>-<NRP>': 23,
+ '<ORG>-<LOCATION>': 24,
+ '<PER>-<DATE_TIME>': 25,
+ '<PER>-<IN_PAN>': 26,
+ '<ORG>-<IN_PAN>': 27,
+ '<ORG>-<NRP>': 28,
+ '<US_DRIVER_LICENSE>': 29,
+ '<KEY <EMAIL_ADDRESS>': 30,
+ '<US_BANK_NUMBER>': 33,
+ '<IN_AADHAAR>': 34,
+ '<CRYPTO>': 35,
+ '<IP_ADDRESS>': 36,
+ '<EMAIL_ADDRESS>': 35,
+ '<US_PASSPORT>': 36,
+ '<US_SSN>': 37,
+ '<MISC>-<URL>': 38}
+
+
+pronoun_list = [
+    'I', 'i', 'me', 'my', 'mine', 'myself', 'you', 'your', 'yours', "I'm", "I am",\
+    'yourself', 'yourselves', 'he', 'him', 'his', 'himself', 'she', "i'm", \
+    'her', 'hers', 'herself', 'it', 'its', 'itself', 'they', 'them', \
+    'their', 'theirs', 'themselves', 'we', 'us', 'our', 'ours', 'ourselves' \
+    'Me', 'My', 'Mine', 'Myself', 'You', 'Your', 'Yours', 'Yourself', 'Yourselves', \
+    'He', 'Him', 'His', 'Himself', 'She', 'Her', 'Hers', 'Herself', 'It', 'Its', 'Itself', \
+    'They', 'Them', 'Their', 'Theirs', 'Themselves', 'We', 'Us', 'Our', 'Ours', 'Ourselves',
+    "Lady", "Madam", "Mr.", "Mister", "Sir", "Miss", "Ms.", "Mrs.", "Mr"
+]
+
+
+privacy_category_codes = {'<PRIVATE>': 1, '<NON_PRIVATE>': 2, '<OTHER>': 3}
+
+punctuation_list = list(string.punctuation)
+punctuation_list.remove('%')
+punctuation_list.remove('$')
+punctuation_list = ''.join(punctuation_list)
+
+def get_word_boundaries(sentence):
+    """ Find the start and end positions of each word in a sentence."""
+    return [(match.start(), match.end()) for match in re.finditer(r'[^\s]+', sentence)]
+
+
+def fuse_ner_labels(flair_ner, presidio_ner, text_type="<PRIVATE>"):
+    """Merges The NER labels from 'Flair' and 'Presidio' for a given text.
+
+    We add take into account custom cases and predefined rules for entity classification.
+    """
+    merged_ner = []
+
+    # Sanity check
+    assert len(flair_ner) == len(presidio_ner)
+
+    for i, ((w1, n1), (w2, n2)) in enumerate(zip(presidio_ner, flair_ner)):
+        
+        assert w1 == w2
+
+        if w1.lower() in pronoun_list:
+            common_ner = "<PRONOUNS>"  
+        # elif w1 in ['A+', 'A-', 'B+', 'B-', 'AB+', 'AB-', 'O+', 'O-']:
+        #     common_ner = "<PRIVATE>"
+        elif n1 == "<O>" and n2 == "<O>":
+            if w1.lower() in ["am", "'m"] and (i - 1) >= 0 and  presidio_ner[i - 1][0].lower() == 'i':
+                common_ner = "<PRONOUNS>"  
+                
+            elif bool(re.match(r'(?<!\S)[\$€]?(?:\d{1,3}(?:[ ,.]\d{3})*|\d+)(?:\.\d+)?%?', w1)):
+                common_ner = "<NUMBER>"
+            else: 
+                common_ner = '<O>'  
+        elif n1 in n2:
+            common_ner = n2  
+        elif n1 == '<O>' and n2 != '<O>':
+            common_ner = n2
+        elif n2 == '<O>'  and n1 != '<O>':
+            common_ner = f"<{n1}>"
+        else:
+             common_ner = f"<{n1}>-{n2}"        
+        try:
+            common_binary_label = 0 if common_ner =="<O>" else 1
+
+        except:
+            print(f"ERROR: common_binary_label = 0 if common_ner =='<O>' else 1 | {w1=}, {w2=}, {n1=}, {n2=}")
+
+        if common_ner not in entity_label_to_code_map.keys():
+            common_multi_label = len(entity_label_to_code_map)
+            if common_ner not in entity_label_to_code_map.keys():
+                print("NOT in KEY", common_ner)
+            entity_label_to_code_map[common_ner] = common_multi_label
+        else:
+            common_multi_label = entity_label_to_code_map[common_ner]
+
+        is_private = text_type if common_ner != '<O>' else '<OTHER>'
+        
+        merged_ner.append([w1, common_ner, is_private, privacy_category_codes[is_private], common_binary_label, common_multi_label])
+
+    return merged_ner
+
+analyzer = AnalyzerEngine()
+anonymizer = AnonymizerEngine()
+
+
+def apply_presidio_model(sentence, verbose=True):
+    """Get Presidio predictions."""
+
+    if verbose: print(f"{sentence=}")
+    # anonymized_text looks like: ['<PERSON>', 'went', 'to', 'Pitier', 'Hospital', ...]
+
+    anonymized_text = anonymizer.anonymize(text=sentence, analyzer_results=analyzer.analyze(text=sentence, language='en'))
+    anonymized_text = anonymized_text.__dict__['text'].split()
+    anonymized_text = ' '.join(anonymized_text)
+    next_word_to_concate = None
+    
+    if verbose: print(f"{anonymized_text=}")
+    if verbose: print(f"{anonymized_text.split('<')=}")
+    
+    start_index, label = 0, []
+    previous_label = None
+
+    for i, before_split in enumerate(anonymized_text.split('<')):
+
+        if verbose: 
+            print(f"\nSubseq_{i}: {before_split=}")
+
+        if i == 0:  
+            assert len(before_split) == len(sentence[start_index: len(before_split)])
+            start_index = len(before_split)
+            label.extend([(s, '<O>') for s in before_split.split()])
+        else:
+            after_split = before_split.split(">")
+            if verbose: 
+                print(f" -----> ", after_split)
+                print(sentence[start_index:])
+                print(sentence[start_index:].find(after_split[-1]))
+            
+            start2_index = start_index + sentence[start_index:].find(after_split[-1])
+            end2_index = start2_index + len(after_split[-1])
+            
+            if verbose:
+                print(f"Sanity check: '[{sentence[start2_index: end2_index]}]' VS '[{after_split[-1]}]'")
+                print(f"Hidden part: sentence[{start2_index}: {end2_index}] = {sentence[start2_index: end2_index]}")
+
+            assert sentence[start2_index: end2_index] == after_split[-1]
+
+            start2_index = start2_index if start2_index != start_index else len(sentence)
+
+            for j, anonimyzed_word in enumerate((sentence[start_index: start2_index]).split()):
+                if next_word_to_concate != None and j == 0:
+                    label.append((f"{next_word_to_concate}{anonimyzed_word}", f"<{after_split[0]}>"))
+                    next_word_to_concate = None
+                else:
+                    label.append((anonimyzed_word, f"<{after_split[0]}>"))
+
+                previous_label = f"<{after_split[0]}>"
+
+            if len(sentence[start2_index: end2_index]) >= 1 and after_split[-1][-1] != ' ' and i != len(anonymized_text.split('<')) - 1:
+                if verbose: print("Is there a space after?", after_split, after_split[-1][-1], i, len(anonymized_text.split('<')))
+
+                for j, anonimyzed_word in enumerate((after_split[-1]).split()[:-1]):
+                    label.append((anonimyzed_word, "<O>"))
+                
+                next_word_to_concate = (after_split[-1]).split()[-1]
+
+            elif len(sentence[start2_index: end2_index]) >= 1 and after_split[-1][0] != ' ' and i != len(anonymized_text.split('<')) - 1:
+                if verbose: print("Is there a space before?", after_split, after_split[-1][0], i, len(anonymized_text.split('<')))
+
+                label[-1] = (f"{label[-1][0]}{after_split[-1].split()[0]}", previous_label)
+
+                for j, anonimyzed_word in enumerate((after_split[-1]).split()[1:]):
+                    label.append((anonimyzed_word, "<O>"))
+
+            else:
+                for j, anonimyzed_word in enumerate((after_split[-1]).split()):
+                    label.append((anonimyzed_word, "<O>"))
+
+            start_index = end2_index
+
+    return label
+
+
+def apply_flair_model(original_sentence):
+    """Get Flair predictions."""
+
+    logging.getLogger('flair').setLevel(logging.WARNING)
+
+    tagger = SequenceTagger.load("flair/ner-english-large")
+    flair_sentence = Sentence(original_sentence)
+    tagger.predict(flair_sentence)
+
+    word_boundaries = get_word_boundaries(original_sentence)
+
+    ner = [[i_token.form, \
+            b_token.get_label().value, \
+            i_token.get_label().score, \
+            i_token.start_position, \
+            i_token.end_position] for b_token in flair_sentence.get_spans("ner") for i_token in b_token]
+
+    ner_labels, ner_index = [], 0
+
+    for start, end in word_boundaries:
+        word_from_text = original_sentence[start:end] 
+        if ner_index < len(ner):
+            form, label, _, s, e = ner[ner_index]
+            
+            if (s, e) == (start, end) and word_from_text == form:
+                ner_labels.append((word_from_text, label))
+                ner_index += 1
+            else:
+                ner_labels.append((word_from_text, "<O>"))
+        else:
+            ner_labels.append((word_from_text, "<O>"))
+
+    assert len(ner_labels) == len(word_boundaries)
+
+    return ner_labels
+
+
+def preprocess_sentences(sentence, verbose=False):
+    """Preprocess the sentence."""
+
+    # Removing Extra Newlines:
+    sentence = re.sub(r'\n+', ' ', sentence)
+    if verbose: print(sentence)
+    
+    # Collapsing Multiple Spaces:
+    sentence = re.sub(' +', ' ', sentence)
+    if verbose: print(sentence)
+
+    # Handling Apostrophes in Possessives:
+    sentence = re.sub(r"'s\b", " s", sentence)
+    if verbose: print(sentence)
+
+    # Removing Spaces Before Punctuation:
+    sentence = re.sub(r'\s([,.!?;:])', r'\1', sentence)
+    if verbose: print(sentence)
+
+    # Pattern for Matching Leading or Trailing Punctuation:
+    pattern = r'(?<!\w)[{}]|[{}](?!\w)'.format(re.escape(punctuation_list), re.escape(punctuation_list))
+    sentence = re.sub(pattern, '', sentence)
+    if verbose: print(sentence)
+
+    return sentence