Upload 2 files

app.py

@@ -1,49 +1,325 @@
 import gradio as gr
-import easyocr
-
-# 创建一个 EasyOCR 阅读器实例
-reader = easyocr.Reader(['en'])  # 选择语言，这里选择英文
-
-def toggle_visibility(input_type):
-    """根据输入类型控制文本框和文件上传控件的可见性"""
-    user_input_visible = input_type == "Text Input"
-    file_upload_visible = input_type == "File Upload"
-    return gr.update(visible=user_input_visible), gr.update(visible=file_upload_visible)
-
-def process_input(input_type, user_input, uploaded_file):
-    print('ooooocr')
-    if input_type == "File Upload" and uploaded_file is not None:
-        # 读取上传的文件
-        with open(uploaded_file.name, "rb") as f:
-            image = f.read()
-        results = reader.readtext(image)
-        # 提取识别的文本
-        extracted_text = ' '.join([text[1] for text in results])
-        print("提取的文本:")
-        print(extracted_text)
-        return extracted_text
-    elif input_type == "Text Input":
-        return user_input
+from requests import head
+from transformer_vectorizer import TransformerVectorizer
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+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()
+model_nams=[]
+
+def keygen(selected_tasks):
+    # Clean tmp directory if needed
+    clean_tmp_directory()
+
+    print("Initializing FHEModelClient...")
+
+    
+    if not selected_tasks:
+        return "choose task first"  # 修改提示信息为英文
+
+    if "legal_rating" in selected_tasks:
+        model_names.append('legal_rating')
+    if "financial_rating" in selected_tasks:
+        model_names.append('financial_rating')
+
+    # Let's create a user_id
+
+
+    user_id = numpy.random.randint(0, 2**32)
+    fhe_api = FHEModelClient(FHE_MODEL_PATH, f".fhe_keys/{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
+    eval_key_path = Path(f"tmp/tmp_evaluation_key__{user_id}.npy")
+    numpy.save(eval_key_path, evaluation_key)
+    
+    user_id_leagl = numpy.random.randint(0, 2**32)
+    fhe_api_legal= FHEModelClient(FHE_LEGAL_PATH, f".fhe_keys/{user_id_leagl}")
+    fhe_api_legal.load()
+
+
+        
+    evaluation_keys = []
+    evaluation_keys.append(list(evaluation_key)[:ENCRYPTED_DATA_BROWSER_LIMIT])
+    #evaluation_keys.append(list(evaluation_key_legal)[:ENCRYPTED_DATA_BROWSER_LIMIT])
+
+    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.")
+
+    fhe_api = FHEModelClient(FHE_MODEL_PATH, f".fhe_keys/{user_id}")
+    fhe_api.load()
+    encodings = transformer_vectorizer.transform([text])
+    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"}
+    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()
+
+    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(
+        """
+<p align="center">
+    <img width=200 src="https://user-images.githubusercontent.com/5758427/197816413-d9cddad3-ba38-4793-847d-120975e1da11.png">
+</p>
+<h2 align="center">Sentiment Analysis On Encrypted Data Using Homomorphic Encryption</h2>
+<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="https://user-images.githubusercontent.com/5758427/197972109-faaaff3e-10e2-4ab6-80f5-7531f7cfb08f.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="https://user-images.githubusercontent.com/5758427/197976802-fddd34c5-f59a-48d0-9bff-7ad1b00cb1fb.png">Documentation</a>
+    —
+    <a href="https://zama.ai/community"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="https://user-images.githubusercontent.com/5758427/197977153-8c9c01a7-451a-4993-8e10-5a6ed5343d02.png">Community</a>
+    —
+    <a href="https://twitter.com/zama_fhe"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="https://user-images.githubusercontent.com/5758427/197975044-bab9d199-e120-433b-b3be-abd73b211a54.png">@zama_fhe</a>
+</p>
+<p align="center">
+  <img src="https://user-images.githubusercontent.com/56846628/219329304-6868be9e-5ce8-4279-9123-4cb1bc0c2fb5.png" width="60%" height="60%">
+</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("# Step 0: Select Tasks")    
+    task_checkbox = gr.CheckboxGroup(
+                choices=["legal_rating", "financial_rating"],
+                label="select_tasks"
+            )
+
     gr.Markdown("# Step 1: Generate the keys")
-    b_gen_key_and_install = gr.Button("Generate 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("# Step 2: Choose Input Method")
-    input_type = gr.Radio(choices=["Text Input", "File Upload"], label="Select Input Method")
-    user_input = gr.Textbox(label="Enter Text", placeholder="Type here...", visible=False)  # Initially hidden
-    file_upload = gr.File(label="Upload File", file_types=[".jpg", ".png"], visible=False)  # Initially hidden
+    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("# Step 2: Provide a message")
+    gr.Markdown("## Client side")
+    gr.Markdown(
+        "Enter a sensitive text message you received and would like to do sentiment analysis on (ideas: the last text message of your boss.... or lover)."
+    )
+    text = gr.Textbox(label="Enter a message:", value="I really like your work recently")
+
+    gr.Markdown("# Step 3: Encode the message with the private key")
+    b_encode_quantize_text = gr.Button(
+        "Encode, quantize and encrypt the text with transformer vectorizer, and send to server"
+    )
+
+    with gr.Row():
+        encoding = gr.Textbox(
+            label="Transformer representation:",
+            max_lines=4,
+            interactive=False,
+        )
+        quantized_encoding = gr.Textbox(
+            label="Quantized transformer representation:", max_lines=4, interactive=False
+        )
+        encrypted_quantized_encoding = gr.Textbox(
+            label="Encrypted quantized transformer representation (truncated):",
+            max_lines=4,
+            interactive=False,
+        )
+
+    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("# Step 5: Decrypt the sentiment")
+    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="Sentiment:")
 
-    # 使用change事件来调用toggle_visibility函数
-    input_type.change(toggle_visibility, inputs=input_type, outputs=[user_input, file_upload])
+    # Button for key generation
+    b_gen_key_and_install.click(keygen, inputs=[task_checkbox], outputs=[evaluation_key, user_id])
 
-    submit_button = gr.Button("Submit")
-    output_text = gr.Textbox(label="Extracted Text")
+    # Button to quantize and encrypt
+    b_encode_quantize_text.click(
+        encode_quantize_encrypt,
+        inputs=[text, user_id],
+        outputs=[
+            encoding,
+            quantized_encoding,
+            encrypted_quantized_encoding,
+        ],
+    )
 
-    submit_button.click(process_input, inputs=[input_type, user_input, file_upload], outputs=output_text)
+    # 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])
 
-demo.launch()
+    # 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)

server.py

@@ -0,0 +1,45 @@
+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):
+    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("/legal_rating")
+def predict_sentiment(query: PredictRequest):
+    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}