Upload 18 files

README.md

@@ -1,13 +1,12 @@
 ---
-title: CipherClause
-emoji: 📚
-colorFrom: gray
-colorTo: purple
+title: Test
+emoji: 🏆
+colorFrom: red
+colorTo: gray
 sdk: gradio
 sdk_version: 4.44.0
 app_file: app.py
 pinned: false
-short_description: The privacy preserving AI develop by the CypherClause team !
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,362 @@
+import gradio as gr
+from requests import head
+from transformer_vectorizer import TransformerVectorizer
+from sklearn.feature_extraction.text import TfidfVectorizer
+import numpy as np 
+from concrete.ml.deployment import FHEModelClient
+import numpy
+import os
+from pathlib import Path
+import requests
+import json
+import base64
+import subprocess
+import shutil
+import time
+
+# This repository's directory
+REPO_DIR = Path(__file__).parent
+
+subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
+
+# Wait 5 sec for the server to start
+time.sleep(5)
+
+# Encrypted data limit for the browser to display
+# (encrypted data is too large to display in the browser)
+ENCRYPTED_DATA_BROWSER_LIMIT = 500
+N_USER_KEY_STORED = 20
+model_names=['financial_rating','legal_rating']
+
+
+FHE_MODEL_PATH = "deployment/financial_rating"
+FHE_LEGAL_PATH = "deployment/legal_rating"
+#FHE_LEGAL_PATH="deployment/legal_rating"
+
+print("Loading the transformer model...")
+
+# Initialize the transformer vectorizer
+transformer_vectorizer = TransformerVectorizer()
+vectorizer = TfidfVectorizer()
+
+def clean_tmp_directory():
+    # Allow 20 user keys to be stored.
+    # Once that limitation is reached, deleted the oldest.
+    path_sub_directories = sorted([f for f in Path(".fhe_keys/").iterdir() if f.is_dir()], key=os.path.getmtime)
+
+    user_ids = []
+    if len(path_sub_directories) > N_USER_KEY_STORED:
+        n_files_to_delete = len(path_sub_directories) - N_USER_KEY_STORED
+        for p in path_sub_directories[:n_files_to_delete]:
+            user_ids.append(p.name)
+            shutil.rmtree(p)
+
+    list_files_tmp = Path("tmp/").iterdir()
+    # Delete all files related to user_id
+    for file in list_files_tmp:
+        for user_id in user_ids:
+            if file.name.endswith(f"{user_id}.npy"):
+                file.unlink()
+mes=[]
+
+def keygen(selected_tasks):
+    # Clean tmp directory if needed
+    clean_tmp_directory()
+
+    print("Initializing FHEModelClient...")
+
+
+    
+    if not selected_tasks:
+        return "choose a task first"  # 修改提示信息为英文
+    user_id = numpy.random.randint(0, 2**32)
+    if "legal_rating" in selected_tasks:
+        model_names.append('legal_rating')
+                # Let's create a user_id
+
+        fhe_api= FHEModelClient(FHE_LEGAL_PATH, f".fhe_keys/{user_id}")
+
+
+    if "financial_rating" in selected_tasks:
+        model_names.append('financial_rating')
+
+        fhe_api = FHEModelClient(FHE_MODEL_PATH, f".fhe_keys/{user_id}")
+        
+        # Let's create a user_id
+    
+        
+    fhe_api.load()
+    
+        
+        # Generate a fresh key
+    fhe_api.generate_private_and_evaluation_keys(force=True)
+    evaluation_key = fhe_api.get_serialized_evaluation_keys()
+    
+        # Save evaluation_key in a file, since too large to pass through regular Gradio
+        # buttons, https://github.com/gradio-app/gradio/issues/1877
+    numpy.save(f"tmp/tmp_evaluation_key_{user_id}.npy", evaluation_key)
+
+    return [list(evaluation_key)[:ENCRYPTED_DATA_BROWSER_LIMIT], user_id]
+
+
+
+
+    
+def encode_quantize_encrypt(text, user_id):
+    if not user_id:
+        raise gr.Error("You need to generate FHE keys first.")
+    if "legal_rating" in model_names:
+        fhe_api = FHEModelClient(FHE_LEGAL_PATH, f".fhe_keys/{user_id}")
+        encodings =vectorizer.fit_transform([text]).toarray()
+        if encodings.shape[1] < 1736:
+            # 在后面填充零
+            padding = np.zeros((1, 1736 - encodings.shape[1]))
+            encodings = np.hstack((encodings, padding))
+        elif encodings.shape[1] > 1736:
+            # 截取前1736列
+            encodings = encodings[:, :1736]
+    else:
+        fhe_api = FHEModelClient(FHE_MODEL_PATH, f".fhe_keys/{user_id}")
+        encodings = transformer_vectorizer.transform([text])
+    
+    fhe_api.load()
+    quantized_encodings = fhe_api.model.quantize_input(encodings).astype(numpy.uint8)
+    encrypted_quantized_encoding = fhe_api.quantize_encrypt_serialize(encodings)
+
+    # Save encrypted_quantized_encoding in a file, since too large to pass through regular Gradio
+    # buttons, https://github.com/gradio-app/gradio/issues/1877
+    numpy.save(f"tmp/tmp_encrypted_quantized_encoding_{user_id}.npy", encrypted_quantized_encoding)
+
+    # Compute size
+    encrypted_quantized_encoding_shorten = list(encrypted_quantized_encoding)[:ENCRYPTED_DATA_BROWSER_LIMIT]
+    encrypted_quantized_encoding_shorten_hex = ''.join(f'{i:02x}' for i in encrypted_quantized_encoding_shorten)
+    return (
+        encodings[0],
+        quantized_encodings[0],
+        encrypted_quantized_encoding_shorten_hex,
+    )
+
+
+
+def run_fhe(user_id):
+    encoded_data_path = Path(f"tmp/tmp_encrypted_quantized_encoding_{user_id}.npy")
+    if not user_id:
+        raise gr.Error("You need to generate FHE keys first.")
+    if not encoded_data_path.is_file():
+        raise gr.Error("No encrypted data was found. Encrypt the data before trying to predict.")
+
+    # Read encrypted_quantized_encoding from the file
+    encrypted_quantized_encoding = numpy.load(encoded_data_path)
+
+    # Read evaluation_key from the file
+    evaluation_key = numpy.load(f"tmp/tmp_evaluation_key_{user_id}.npy")
+
+    # Use base64 to encode the encodings and evaluation key
+    encrypted_quantized_encoding = base64.b64encode(encrypted_quantized_encoding).decode()
+    encoded_evaluation_key = base64.b64encode(evaluation_key).decode()
+
+    query = {}
+    query["evaluation_key"] = encoded_evaluation_key
+    query["encrypted_encoding"] = encrypted_quantized_encoding
+    headers = {"Content-type": "application/json"}
+    if "legal_rating" in model_names:
+            response = requests.post(
+            "http://localhost:8000/predict_legal", data=json.dumps(query), headers=headers
+        )
+    else:
+        response = requests.post(
+                "http://localhost:8000/predict_sentiment", data=json.dumps(query), headers=headers
+            )
+    encrypted_prediction = base64.b64decode(response.json()["encrypted_prediction"])
+
+    # Save encrypted_prediction in a file, since too large to pass through regular Gradio
+    # buttons, https://github.com/gradio-app/gradio/issues/1877
+    numpy.save(f"tmp/tmp_encrypted_prediction_{user_id}.npy", encrypted_prediction)
+    encrypted_prediction_shorten = list(encrypted_prediction)[:ENCRYPTED_DATA_BROWSER_LIMIT]
+    encrypted_prediction_shorten_hex = ''.join(f'{i:02x}' for i in encrypted_prediction_shorten)
+    return encrypted_prediction_shorten_hex
+
+
+def decrypt_prediction(user_id):
+    encoded_data_path = Path(f"tmp/tmp_encrypted_prediction_{user_id}.npy")
+    if not user_id:
+        raise gr.Error("You need to generate FHE keys first.")
+    if not encoded_data_path.is_file():
+        raise gr.Error("No encrypted prediction was found. Run the prediction over the encrypted data first.")
+
+    # Read encrypted_prediction from the file
+    encrypted_prediction = numpy.load(encoded_data_path).tobytes()
+
+    if "legal_rating" in model_names:
+        fhe_api = FHEModelClient(FHE_LEGAL_PATH, f".fhe_keys/{user_id}")
+
+    fhe_api = FHEModelClient(FHE_MODEL_PATH, f".fhe_keys/{user_id}")
+    fhe_api.load()
+
+    # We need to retrieve the private key that matches the client specs (see issue #18)
+    fhe_api.generate_private_and_evaluation_keys(force=False)
+
+    predictions = fhe_api.deserialize_decrypt_dequantize(encrypted_prediction)
+    print(predictions)
+    
+    return {
+        "low_relative": predictions[0][0],
+        "medium_relative": predictions[0][1],
+        "high_relative": predictions[0][2],
+    }
+
+
+demo = gr.Blocks()
+
+
+print("Starting the demo...")
+with demo:
+
+    gr.Markdown(
+        """
+
+<h2 align="center">📄Cipher Clause</h2>
+        <p align="center">
+            <img width=200 src="https://www.helloimg.com/i/2024/09/28/66f7f6701bcfb.jpeg">
+        </p>
+
+"""
+    )
+
+
+    gr.Markdown(
+        """
+        <p align="center">
+        </p>
+        <p align="center">
+        </p>
+        """
+    )
+
+    gr.Markdown("## Notes")
+    gr.Markdown(
+    """
+- The private key is used to encrypt and decrypt the data and shall never be shared.
+- The evaluation key is a public key that the server needs to process encrypted data.
+"""
+    )
+    gr.Markdown(
+        """
+    <hr/>
+        """
+    )
+    gr.Markdown("# Step 0: Select Task")    
+    task_checkbox = gr.CheckboxGroup(
+                choices=["legal_rating", "financial_rating"],
+                label="select_tasks"
+            )
+    gr.Markdown(
+        """
+    <hr/>
+        """
+    )
+    gr.Markdown("# Step 1: Generate the keys")
+
+    b_gen_key_and_install = gr.Button("Generate all the keys and send public part to server")
+
+    evaluation_key = gr.Textbox(
+        label="Evaluation key (truncated):",
+        max_lines=4,
+        interactive=False,
+    )
+
+    user_id = gr.Textbox(
+        label="",
+        max_lines=4,
+        interactive=False,
+        visible=False
+    )
+    gr.Markdown(
+        """
+<hr/>
+        """
+    )
+    gr.Markdown("# Step 2: Provide a contract or clause")
+    gr.Markdown("## Client side")
+    gr.Markdown(
+        "Enter a contract or clause you want to analysis)."
+    )
+    text = gr.Textbox(label="Enter some words:", value="The Employee is entitled to two weeks of paid vacation annually, to be scheduled at the mutual convenience of the Employee and Employer.")
+    gr.Markdown(
+        """
+<hr/>
+        """
+    )
+    gr.Markdown("# Step 3: Encode the message with the private key")
+    b_encode_quantize_text = gr.Button(
+        "Encode, quantize and encrypt the text with vectorizer, and send to server"
+    )
+
+    with gr.Row():
+        encoding = gr.Textbox(
+            label="Representation:",
+            max_lines=4,
+            interactive=False,
+        )
+        quantized_encoding = gr.Textbox(
+            label="Quantized  representation:", max_lines=4, interactive=False
+        )
+        encrypted_quantized_encoding = gr.Textbox(
+            label="Encrypted quantized representation (truncated):",
+            max_lines=4,
+            interactive=False,
+        )
+    gr.Markdown(
+        """
+<hr/>
+        """
+    )
+    gr.Markdown("# Step 4: Run the FHE evaluation")
+    gr.Markdown("## Server side")
+    gr.Markdown(
+        "The encrypted value is received by the server. Thanks to the evaluation key and to FHE, the server can compute the (encrypted) prediction directly over encrypted values. Once the computation is finished, the server returns the encrypted prediction to the client."
+    )
+
+    b_run_fhe = gr.Button("Run FHE execution there")
+    encrypted_prediction = gr.Textbox(
+        label="Encrypted prediction (truncated):",
+        max_lines=4,
+        interactive=False,
+    )
+    gr.Markdown(
+        """
+<hr/>
+        """
+    )
+    gr.Markdown("# Step 5: Decrypt the class")
+    gr.Markdown("## Client side")
+    gr.Markdown(
+        "The encrypted sentiment is sent back to client, who can finally decrypt it with its private key. Only the client is aware of the original tweet and the prediction."
+    )
+    b_decrypt_prediction = gr.Button("Decrypt prediction")
+
+    labels_sentiment = gr.Label(label="level:")
+
+    # Button for key generation
+    b_gen_key_and_install.click(keygen, inputs=[task_checkbox], outputs=[evaluation_key, user_id])
+
+    # Button to quantize and encrypt
+    b_encode_quantize_text.click(
+        encode_quantize_encrypt,
+        inputs=[text, user_id],
+        outputs=[
+            encoding,
+            quantized_encoding,
+            encrypted_quantized_encoding,
+        ],
+    )
+
+    # Button to send the encodings to the server using post at (localhost:8000/predict_sentiment)
+    b_run_fhe.click(run_fhe, inputs=[user_id], outputs=[encrypted_prediction])
+
+    # Button to decrypt the prediction on the client
+    b_decrypt_prediction.click(decrypt_prediction, inputs=[user_id], outputs=[labels_sentiment])
+    gr.Markdown(
+        "The app was built with [Concrete-ML](https://github.com/zama-ai/concrete-ml), a Privacy-Preserving Machine Learning (PPML) open-source set of tools by [Zama](https://zama.ai/). Try it yourself and don't forget to star on Github &#11088;."
+    )
+demo.launch(share=False)

deployment/financial_rating/client.zip

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

deployment/financial_rating/server.zip

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

deployment/financial_rating/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5", "concrete-ml": "1.4.0", "python": "3.10.12"}

deployment/legal_rating/client.zip

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

deployment/legal_rating/server.zip

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

deployment/legal_rating/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5", "concrete-ml": "1.4.0", "python": "3.10.12"}

deployment/sentiment_fhe_model/client.zip

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

deployment/sentiment_fhe_model/server.zip

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

deployment/sentiment_fhe_model/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5", "concrete-ml": "1.4.0", "python": "3.10.11"}

requirements.txt

@@ -0,0 +1,6 @@
+concrete-ml==1.4.0
+gradio
+pandas==1.4.3
+transformers==4.36.0 
+
+

server.py

@@ -0,0 +1,48 @@
+"""Server that will listen for GET requests from the client."""
+from fastapi import FastAPI
+from joblib import load
+from concrete.ml.deployment import FHEModelServer
+from pydantic import BaseModel
+import base64
+from pathlib import Path
+
+current_dir = Path(__file__).parent
+
+# Load the model
+fhe_model = FHEModelServer("deployment/financial_rating")
+fhe_legal_model = FHEModelServer("deployment/legal_rating")
+class PredictRequest(BaseModel):
+    evaluation_key: str
+    encrypted_encoding: str
+
+# Initialize an instance of FastAPI
+app = FastAPI()
+
+# Define the default route 
+@app.get("/")
+def root():
+    return {"message": "Welcome to Your Sentiment Classification FHE Model Server!"}
+
+@app.post("/predict_sentiment")
+def predict_sentiment(query: PredictRequest):
+    fhe_model = FHEModelServer("deployment/financial_rating")
+
+    encrypted_encoding = base64.b64decode(query.encrypted_encoding)
+    evaluation_key = base64.b64decode(query.evaluation_key)
+    prediction = fhe_model.run(encrypted_encoding, evaluation_key)
+
+    # Encode base64 the prediction
+    encoded_prediction = base64.b64encode(prediction).decode()
+    return {"encrypted_prediction": encoded_prediction}
+    
+@app.post("/predict_legal")
+def predict_legal(query: PredictRequest):
+    fhe_legal_model = FHEModelServer("deployment/legal_rating")
+    
+    encrypted_encoding = base64.b64decode(query.encrypted_encoding)
+    evaluation_key = base64.b64decode(query.evaluation_key)
+    prediction = fhe_legal_model.run(encrypted_encoding, evaluation_key)
+
+    # Encode base64 the prediction
+    encoded_prediction = base64.b64encode(prediction).decode()
+    return {"encrypted_prediction": encoded_prediction}

transformer_vectorizer.py

@@ -0,0 +1,58 @@
+# Let's import a few requirements
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import numpy
+
+class TransformerVectorizer:
+    def __init__(self):
+        # Load the tokenizer (converts text to tokens)
+        self.tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment-latest")
+
+        # Load the pre-trained model
+        self.transformer_model = AutoModelForSequenceClassification.from_pretrained(
+            "cardiffnlp/twitter-roberta-base-sentiment-latest"
+        )
+        self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+    def text_to_tensor(
+        self,
+        texts: list,
+    ) -> numpy.ndarray:
+        """Function that transforms a list of texts to their learned representation.
+        
+        Args:
+            list_text_X (list): List of texts to be transformed.
+
+        Returns:
+            numpy.ndarray: Transformed list of texts.
+        """
+        # First, tokenize all the input text
+        tokenized_text_X_train = self.tokenizer.batch_encode_plus(
+            texts, return_tensors="pt"
+        )["input_ids"]
+
+        # Depending on the hardware used, the number of examples to be processed can be reduced
+        # Here we split the data into 100 examples per batch
+        tokenized_text_X_train_split = torch.split(tokenized_text_X_train, split_size_or_sections=50)
+
+        # Send the model to the device
+        transformer_model = self.transformer_model.to(self.device)
+        output_hidden_states_list = []
+
+        for tokenized_x in tokenized_text_X_train_split:
+            # Pass the tokens through the transformer model and get the hidden states
+            # Only keep the last hidden layer state for now
+            output_hidden_states = transformer_model(tokenized_x.to(self.device), output_hidden_states=True)[
+                1
+            ][-1]
+            # Average over the tokens axis to get a representation at the text level.
+            output_hidden_states = output_hidden_states.mean(dim=1)
+            output_hidden_states = output_hidden_states.detach().cpu().numpy()
+            output_hidden_states_list.append(output_hidden_states)
+
+        self.encodings = numpy.concatenate(output_hidden_states_list, axis=0)
+        return self.encodings
+
+    def transform(self, texts: list):
+        return self.text_to_tensor(texts)
+