asd

app.py

@@ -1,175 +1,9 @@
-# import os
-# import json
-# import gradio as gr
-# import spaces
-# import torch
-# from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
-# from sentence_splitter import SentenceSplitter
-# from itertools import product
-
-# # Get the Hugging Face token from environment variable
-# hf_token = os.getenv('HF_TOKEN')
-
-# cuda_available = torch.cuda.is_available()
-# device = torch.device("cuda" if cuda_available else "cpu")
-# print(f"Using device: {device}")
-
-# # Initialize paraphraser model and tokenizer
-# paraphraser_model_name = "SamSJackson/paraphrase-dipper-no-ctx"
-# paraphraser_tokenizer = AutoTokenizer.from_pretrained("google/t5-efficient-large-nl32")
-# paraphraser_model = AutoModelForSeq2SeqLM.from_pretrained(paraphraser_model_name).to(device)
-
-# # Initialize classifier model and tokenizer
-# classifier_model_name = "andreas122001/roberta-mixed-detector"
-# classifier_tokenizer = AutoTokenizer.from_pretrained(classifier_model_name)
-# classifier_model = AutoModelForSequenceClassification.from_pretrained(classifier_model_name).to(device)
-
-# # Initialize sentence splitter
-# splitter = SentenceSplitter(language='en')
-
-# def classify_text(text):
-#     inputs = classifier_tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(device)
-#     with torch.no_grad():
-#         outputs = classifier_model(**inputs)
-#     probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
-#     predicted_class = torch.argmax(probabilities, dim=-1).item()
-#     main_label = classifier_model.config.id2label[predicted_class]
-#     main_score = probabilities[0][predicted_class].item()
-#     return main_label, main_score
-
-# @spaces.GPU
-# def generate_paraphrases(text, setting, output_format):
-#     sentences = splitter.split(text)
-#     all_sentence_paraphrases = []
-    
-#     if setting == 1:
-#         lexical = 20
-#         order = 20
-#     elif setting == 2:
-#         lexical = 40
-#         order = 40  
-#     elif setting == 3:
-#         lexical = 60
-#         order = 60
-#     elif setting == 4:
-#         lexical = 80
-#         order = 80
-#     else:
-#         lexical = 100
-#         order = 100
-    
-#     num_return_sequences = 5
-#     max_length = 384
-    
-#     formatted_output = "Original text:\n" + text + "\n\n"
-#     formatted_output += "Paraphrased versions:\n"
-    
-#     json_output = {
-#         "original_text": text,
-#         "paraphrased_versions": [],
-#         "combined_versions": [],
-#         "human_like_versions": []
-#     }
-    
-#     for i, sentence in enumerate(sentences):
-#         prompt = f"lexical = {lexical}, order = {order} {sentence}"
-#         inputs = paraphraser_tokenizer(
-#             prompt,
-#             return_tensors='pt',
-#             padding="longest",
-#             max_length=max_length,
-#             truncation=True,
-#         ).to(device)
-        
-#         # Generate paraphrases 
-#         outputs = paraphraser_model.generate(
-#             **inputs,
-#             top_p=0.95,
-#             do_sample=True,
-#             max_new_tokens=max_length,
-#             num_return_sequences=num_return_sequences
-#         )
-        
-#         paraphrases = paraphraser_tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        
-#         formatted_output += f"Original sentence {i+1}: {sentence}\n"
-#         for j, paraphrase in enumerate(paraphrases, 1):
-#             formatted_output += f"  Paraphrase {j}: {paraphrase}\n"
-        
-#         json_output["paraphrased_versions"].append({
-#             f"original_sentence_{i+1}": sentence,
-#             "paraphrases": paraphrases
-#         })
-        
-#         all_sentence_paraphrases.append(paraphrases)
-#         formatted_output += "\n"
-    
-#     all_combinations = list(product(*all_sentence_paraphrases))
-    
-#     formatted_output += "\nCombined paraphrased versions:\n"
-#     combined_versions = []
-#     for i, combination in enumerate(all_combinations[:50], 1):  # Limit to 50 combinations
-#         combined_paraphrase = " ".join(combination)
-#         combined_versions.append(combined_paraphrase)
-    
-#     json_output["combined_versions"] = combined_versions
-    
-#     # Classify combined versions
-#     human_versions = []
-#     for i, version in enumerate(combined_versions, 1):
-#         label, score = classify_text(version)
-#         formatted_output += f"Version {i}:\n{version}\n"
-#         formatted_output += f"Classification: {label} (confidence: {score:.2%})\n\n"
-#         if label == "human-produced" or (label == "machine-generated" and score < 0.98):
-#             human_versions.append((version, label, score))
-    
-#     formatted_output += "\nHuman-like or Less Confident Machine-generated versions:\n"
-#     for i, (version, label, score) in enumerate(human_versions, 1):
-#         formatted_output += f"Version {i}:\n{version}\n"
-#         formatted_output += f"Classification: {label} (confidence: {score:.2%})\n\n"
-    
-#     json_output["human_like_versions"] = [
-#         {"version": version, "label": label, "confidence_score": score}
-#         for version, label, score in human_versions
-#     ]
-    
-#     # If no human-like versions, include the top 5 least confident machine-generated versions
-#     if not human_versions:
-#         human_versions = sorted([(v, l, s) for v, l, s in zip(combined_versions, [classify_text(v)[0] for v in combined_versions], [classify_text(v)[1] for v in combined_versions])], key=lambda x: x[2])[:5]
-#         formatted_output += "\nNo human-like versions found. Showing top 5 least confident machine-generated versions:\n"
-#         for i, (version, label, score) in enumerate(human_versions, 1):
-#             formatted_output += f"Version {i}:\n{version}\n"
-#             formatted_output += f"Classification: {label} (confidence: {score:.2%})\n\n"
-    
-#     if output_format == "text":
-#         return formatted_output, "\n\n".join([v[0] for v in human_versions])
-#     else:
-#         return json.dumps(json_output, indent=2), "\n\n".join([v[0] for v in human_versions])
-
-# # Define the Gradio interface
-# iface = gr.Interface(
-#     fn=generate_paraphrases,
-#     inputs=[
-#         gr.Textbox(lines=5, label="Input Text"),
-#         gr.Slider(minimum=1, maximum=5, step=1, label="Readability to Human-like Setting"),
-#         gr.Radio(["text", "json"], label="Output Format")
-#     ],
-#     outputs=[
-#         gr.Textbox(lines=20, label="Detailed Paraphrases and Classifications"),
-#         gr.Textbox(lines=10, label="Human-like or Less Confident Machine-generated Paraphrases")
-#     ],
-#     title="Advanced Diverse Paraphraser with Human-like Filter",
-#     description="Enter a text, select a setting from readable to human-like, and choose the output format to generate diverse paraphrased versions. Combined versions are classified, and those detected as human-produced or less confidently machine-generated are presented in the final output."
-# )
-
-# # Launch the interface
-# iface.launch()
 import os
 import json
 import gradio as gr
 import spaces
 import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, T5ForConditionalGeneration
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
 from sentence_splitter import SentenceSplitter
 from itertools import product
 
@@ -181,9 +15,9 @@ device = torch.device("cuda" if cuda_available else "cpu")
 print(f"Using device: {device}")
 
 # Initialize paraphraser model and tokenizer
-paraphraser_model_name = "SamSJackson/paraphrase-dipper-no-ctx"
-paraphraser_tokenizer = AutoTokenizer.from_pretrained("google/t5-efficient-large-nl32")
-paraphraser_model = T5ForConditionalGeneration.from_pretrained(paraphraser_model_name).to(device)
+paraphraser_model_name = "Ateeqq/Text-Rewriter-Paraphraser"
+paraphraser_tokenizer = AutoTokenizer.from_pretrained(paraphraser_model_name, token=hf_token)
+paraphraser_model = AutoModelForSeq2SeqLM.from_pretrained(paraphraser_model_name, token=hf_token).to(device)
 
 # Initialize classifier model and tokenizer
 classifier_model_name = "andreas122001/roberta-mixed-detector"
@@ -209,23 +43,23 @@ def generate_paraphrases(text, setting, output_format):
     all_sentence_paraphrases = []
     
     if setting == 1:
-        lexical = 20
-        order = 20
+        temperature = 0.6
+        num_beams = 2
     elif setting == 2:
-        lexical = 40
-        order = 40  
+        temperature = 0.7
+        num_beams = 3
     elif setting == 3:
-        lexical = 60
-        order = 60
+        temperature = 0.8
+        num_beams = 4
     elif setting == 4:
-        lexical = 80
-        order = 80
+        temperature = 0.9
+        num_beams = 5
     else:
-        lexical = 100
-        order = 100
+        temperature = 1.0
+        num_beams = 6
     
     num_return_sequences = 5
-    max_length = 384
+    max_length = 64
     
     formatted_output = "Original text:\n" + text + "\n\n"
     formatted_output += "Paraphrased versions:\n"
@@ -238,42 +72,33 @@ def generate_paraphrases(text, setting, output_format):
     }
     
     for i, sentence in enumerate(sentences):
-        prompt = f"lexical = {lexical}, order = {order} {sentence}"
-        inputs = paraphraser_tokenizer(
-            prompt,
-            return_tensors='pt',
-            padding="longest",
-            max_length=max_length,
-            truncation=True,
-        ).to(device)
+        inputs = paraphraser_tokenizer(f'paraphraser: {sentence}', return_tensors="pt", padding="longest", truncation=True, max_length=max_length).input_ids.to(device)
         
         # Generate paraphrases 
         outputs = paraphraser_model.generate(
-            **inputs,
-            top_p=0.95,
-            do_sample=True,
-            max_new_tokens=max_length,
+            inputs,
+            num_beams=num_beams,
+            num_beam_groups=num_beams,
             num_return_sequences=num_return_sequences,
-            temperature=0.7,
+            repetition_penalty=10.0,
+            diversity_penalty=3.0,
             no_repeat_ngram_size=2,
-            length_penalty=1.0
+            temperature=temperature,
+            max_length=max_length
         )
         
         paraphrases = paraphraser_tokenizer.batch_decode(outputs, skip_special_tokens=True)
         
-        # Clean up paraphrases
-        cleaned_paraphrases = [p.replace(prompt, "").strip() for p in paraphrases]
-        
         formatted_output += f"Original sentence {i+1}: {sentence}\n"
-        for j, paraphrase in enumerate(cleaned_paraphrases, 1):
+        for j, paraphrase in enumerate(paraphrases, 1):
             formatted_output += f"  Paraphrase {j}: {paraphrase}\n"
         
         json_output["paraphrased_versions"].append({
             f"original_sentence_{i+1}": sentence,
-            "paraphrases": cleaned_paraphrases
+            "paraphrases": paraphrases
         })
         
-        all_sentence_paraphrases.append(cleaned_paraphrases)
+        all_sentence_paraphrases.append(paraphrases)
         formatted_output += "\n"
     
     all_combinations = list(product(*all_sentence_paraphrases))