from fastapi import FastAPI from pydantic import BaseModel import torch from transformers import AutoTokenizer, AutoModelForCausalLM import numpy as np from Watermark.WatermarkingFnFourier import WatermarkingFnFourier from Watermark.WatermarkingFnSquare import WatermarkingFnSquare from Watermark.WatermarkerBase import Watermarker from sentence_transformers import SentenceTransformer app = FastAPI() model_name_or_path = "meta-llama/Llama-2-13b-chat-hf" device = "cuda:0" k_p=1 watermarkingFnClass = WatermarkingFnFourier # Initialize tokenizer and model tokenizer = AutoTokenizer.from_pretrained(model_name_or_path) model = AutoModelForCausalLM.from_pretrained( model_name_or_path, torch_dtype=torch.bfloat16, load_in_4bit=True ).to(device) sts_model = SentenceTransformer('sentence-transformers/all-mpnet-base-v2', device=device) prompt = ( "Paraphrase the user provided text while preserving semantic similarity. " "Do not include any other sentences in the response, such as explanations of the paraphrasing. " "Do not summarize." ) pre_paraphrased = "Here is a paraphrased version of the text while preserving the semantic similarity:\n\n" # Define the request format class WatermarkRequest(BaseModel): text: str key: int strength: int # Paraphrasing endpoint @app.post("/watermark") def watermark(request: WatermarkRequest): T_o = request.text id = request.key kappa = request.strength try: id = int(id) kappa = int(kappa) except ValueError: return {'text': "Please enter valid numbers."} # init watermarker watermarker = Watermarker(model, tokenizer, id, kappa, k_p, watermarkingFnClass=watermarkingFnClass) # watermark paraphrasing_prompt = tokenizer.apply_chat_template( [ {"role":"system", "content":prompt}, {"role":"user", "content":T_o}, ], tokenize=False, add_generation_prompt = True) + f"{pre_paraphrased}\n\n" watermarked = watermarker.generate( paraphrasing_prompt, return_scores=True, max_new_tokens=int(len(paraphrasing_prompt) * 1.5), do_sample=False, temperature=None, top_p=None, num_beams=8, num_beam_groups=4, num_return_sequences=8, diversity_penalty = 0.5 ) sts_scores = sts_model.encode([T_o, *watermarked["text"]], convert_to_tensor=True) cos_sim = torch.nn.functional.cosine_similarity(sts_scores[0], sts_scores[1:], dim=1).cpu() selection_score = cos_sim + watermarked["q_score"] selection = torch.argmax(selection_score) watermarked = watermarked["text"][selection] res_o = watermarker.verify(T_o)[0] q_o = res_o[k_p-1] # Verify on watermarked text res_w = watermarker.verify(watermarked)[0] q_w = res_w[k_p-1] return {'text': watermarked, 'q_o': q_o, 'q_w': q_w}