sad

app.py

@@ -1,9 +1,192 @@
+# # # 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("cpu" if cuda_available else "cpu")
+# # # print(f"Using device: {device}")
+
+# # # # Initialize paraphraser model and tokenizer
+# # # paraphraser_model_name = "NoaiGPT/777"
+# # # paraphraser_tokenizer = AutoTokenizer.from_pretrained(paraphraser_model_name, use_auth_token=hf_token)
+# # # paraphraser_model = AutoModelForSeq2SeqLM.from_pretrained(paraphraser_model_name, use_auth_token=hf_token).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:
+# # #         num_return_sequences = 5
+# # #         repetition_penalty = 1.1
+# # #         no_repeat_ngram_size = 2
+# # #         temperature = 1.0
+# # #         max_length = 128
+# # #     elif setting == 2:
+# # #         num_return_sequences = 10
+# # #         repetition_penalty = 1.2
+# # #         no_repeat_ngram_size = 3
+# # #         temperature = 1.2
+# # #         max_length = 192
+# # #     elif setting == 3:
+# # #         num_return_sequences = 15
+# # #         repetition_penalty = 1.3
+# # #         no_repeat_ngram_size = 4
+# # #         temperature = 1.4
+# # #         max_length = 256
+# # #     elif setting == 4:
+# # #         num_return_sequences = 20
+# # #         repetition_penalty = 1.4
+# # #         no_repeat_ngram_size = 5
+# # #         temperature = 1.6
+# # #         max_length = 320
+# # #     else:
+# # #         num_return_sequences = 25
+# # #         repetition_penalty = 1.5
+# # #         no_repeat_ngram_size = 6
+# # #         temperature = 1.8
+# # #         max_length = 384
+    
+# # #     top_k = 50
+# # #     top_p = 0.95
+# # #     length_penalty = 1.0
+    
+# # #     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):
+# # #         inputs = paraphraser_tokenizer(f'paraphraser: {sentence}', return_tensors="pt", padding="longest", truncation=True, max_length=max_length).to(device)
+        
+# # #         # Generate paraphrases using the specified parameters
+# # #         outputs = paraphraser_model.generate(
+# # #             inputs.input_ids,
+# # #             attention_mask=inputs.attention_mask,
+# # #             num_return_sequences=num_return_sequences,
+# # #             repetition_penalty=repetition_penalty,
+# # #             no_repeat_ngram_size=no_repeat_ngram_size,
+# # #             temperature=temperature,
+# # #             max_length=max_length,
+# # #             top_k=top_k,
+# # #             top_p=top_p,
+# # #             do_sample=True,
+# # #             early_stopping=False,
+# # #             length_penalty=length_penalty
+# # #         )
+        
+# # #         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, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
+# # from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
 # # from sentence_splitter import SentenceSplitter
 # # from itertools import product
 
@@ -11,13 +194,14 @@
 # # hf_token = os.getenv('HF_TOKEN')
 
 # # cuda_available = torch.cuda.is_available()
-# # device = torch.device("cpu" if cuda_available else "cpu")
+# # device = torch.device("cuda" if cuda_available else "cpu")
 # # print(f"Using device: {device}")
 
 # # # Initialize paraphraser model and tokenizer
-# # paraphraser_model_name = "NoaiGPT/777"
-# # paraphraser_tokenizer = AutoTokenizer.from_pretrained(paraphraser_model_name, use_auth_token=hf_token)
-# # paraphraser_model = AutoModelForSeq2SeqLM.from_pretrained(paraphraser_model_name, use_auth_token=hf_token).to(device)
+# # paraphraser_model_name = "sharad/ParaphraseGPT"
+# # paraphraser_tokenizer = AutoTokenizer.from_pretrained("humarin/chatgpt_paraphraser_on_T5_base")
+# # paraphraser_model = AutoModelForSeq2SeqLM.from_pretrained(paraphraser_model_name).to(device)
+# # paraphrase_pipeline = pipeline("text2text-generation", model=paraphraser_model, tokenizer=paraphraser_tokenizer, device=0 if cuda_available else -1)
 
 # # # Initialize classifier model and tokenizer
 # # classifier_model_name = "andreas122001/roberta-mixed-detector"
@@ -37,7 +221,7 @@
 # #     main_score = probabilities[0][predicted_class].item()
 # #     return main_label, main_score
 
-# # # @spaces.GPU
+# # @spaces.GPU
 # # def generate_paraphrases(text, setting, output_format):
 # #     sentences = splitter.split(text)
 # #     all_sentence_paraphrases = []
@@ -46,31 +230,31 @@
 # #         num_return_sequences = 5
 # #         repetition_penalty = 1.1
 # #         no_repeat_ngram_size = 2
-# #         temperature = 1.0
+# #         temperature = 0.9
 # #         max_length = 128
 # #     elif setting == 2:
-# #         num_return_sequences = 10
+# #         num_return_sequences = 5
 # #         repetition_penalty = 1.2
 # #         no_repeat_ngram_size = 3
-# #         temperature = 1.2
+# #         temperature = 0.95
 # #         max_length = 192
 # #     elif setting == 3:
-# #         num_return_sequences = 15
+# #         num_return_sequences = 5
 # #         repetition_penalty = 1.3
 # #         no_repeat_ngram_size = 4
-# #         temperature = 1.4
+# #         temperature = 1.0
 # #         max_length = 256
 # #     elif setting == 4:
-# #         num_return_sequences = 20
+# #         num_return_sequences = 5
 # #         repetition_penalty = 1.4
 # #         no_repeat_ngram_size = 5
-# #         temperature = 1.6
+# #         temperature = 1.05
 # #         max_length = 320
 # #     else:
-# #         num_return_sequences = 25
+# #         num_return_sequences = 5
 # #         repetition_penalty = 1.5
 # #         no_repeat_ngram_size = 6
-# #         temperature = 1.8
+# #         temperature = 1.1
 # #         max_length = 384
     
 # #     top_k = 50
@@ -88,36 +272,30 @@
 # #     }
     
 # #     for i, sentence in enumerate(sentences):
-# #         inputs = paraphraser_tokenizer(f'paraphraser: {sentence}', return_tensors="pt", padding="longest", truncation=True, max_length=max_length).to(device)
-        
-# #         # Generate paraphrases using the specified parameters
-# #         outputs = paraphraser_model.generate(
-# #             inputs.input_ids,
-# #             attention_mask=inputs.attention_mask,
+# #         paraphrases = paraphrase_pipeline(
+# #             sentence,
 # #             num_return_sequences=num_return_sequences,
-# #             repetition_penalty=repetition_penalty,
-# #             no_repeat_ngram_size=no_repeat_ngram_size,
-# #             temperature=temperature,
-# #             max_length=max_length,
+# #             do_sample=True,
 # #             top_k=top_k,
 # #             top_p=top_p,
-# #             do_sample=True,
-# #             early_stopping=False,
-# #             length_penalty=length_penalty
+# #             temperature=temperature,
+# #             no_repeat_ngram_size=no_repeat_ngram_size,
+# #             repetition_penalty=repetition_penalty,
+# #             max_length=max_length
 # #         )
         
-# #         paraphrases = paraphraser_tokenizer.batch_decode(outputs, skip_special_tokens=True)
+# #         paraphrases_texts = [p['generated_text'] for p in paraphrases]
         
 # #         formatted_output += f"Original sentence {i+1}: {sentence}\n"
-# #         for j, paraphrase in enumerate(paraphrases, 1):
+# #         for j, paraphrase in enumerate(paraphrases_texts, 1):
 # #             formatted_output += f"  Paraphrase {j}: {paraphrase}\n"
         
 # #         json_output["paraphrased_versions"].append({
 # #             f"original_sentence_{i+1}": sentence,
-# #             "paraphrases": paraphrases
+# #             "paraphrases": paraphrases_texts
 # #         })
         
-# #         all_sentence_paraphrases.append(paraphrases)
+# #         all_sentence_paraphrases.append(paraphrases_texts)
 # #         formatted_output += "\n"
     
 # #     all_combinations = list(product(*all_sentence_paraphrases))
@@ -186,10 +364,18 @@
 # import gradio as gr
 # import spaces
 # import torch
-# from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
+# import sys
+# import subprocess
+# from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
 # from sentence_splitter import SentenceSplitter
 # from itertools import product
 
+# # Ensure sentencepiece is installed
+# try:
+#     import sentencepiece
+# except ImportError:
+#     subprocess.check_call([sys.executable, "-m", "pip", "install", "sentencepiece"])
+
 # # Get the Hugging Face token from environment variable
 # hf_token = os.getenv('HF_TOKEN')
 
@@ -198,10 +384,9 @@
 # print(f"Using device: {device}")
 
 # # Initialize paraphraser model and tokenizer
-# paraphraser_model_name = "sharad/ParaphraseGPT"
-# paraphraser_tokenizer = AutoTokenizer.from_pretrained("humarin/chatgpt_paraphraser_on_T5_base")
+# paraphraser_model_name = "ramsrigouthamg/t5-large-paraphraser-diverse-high-quality"
+# paraphraser_tokenizer = AutoTokenizer.from_pretrained(paraphraser_model_name, use_fast=False)
 # paraphraser_model = AutoModelForSeq2SeqLM.from_pretrained(paraphraser_model_name).to(device)
-# paraphrase_pipeline = pipeline("text2text-generation", model=paraphraser_model, tokenizer=paraphraser_tokenizer, device=0 if cuda_available else -1)
 
 # # Initialize classifier model and tokenizer
 # classifier_model_name = "andreas122001/roberta-mixed-detector"
@@ -227,40 +412,26 @@
 #     all_sentence_paraphrases = []
     
 #     if setting == 1:
-#         num_return_sequences = 5
-#         repetition_penalty = 1.1
-#         no_repeat_ngram_size = 2
-#         temperature = 0.9
+#         num_return_sequences = 3
+#         num_beams = 5
 #         max_length = 128
 #     elif setting == 2:
-#         num_return_sequences = 5
-#         repetition_penalty = 1.2
-#         no_repeat_ngram_size = 3
-#         temperature = 0.95
+#         num_return_sequences = 3
+#         num_beams = 7
 #         max_length = 192
 #     elif setting == 3:
-#         num_return_sequences = 5
-#         repetition_penalty = 1.3
-#         no_repeat_ngram_size = 4
-#         temperature = 1.0
+#         num_return_sequences = 3
+#         num_beams = 9
 #         max_length = 256
 #     elif setting == 4:
-#         num_return_sequences = 5
-#         repetition_penalty = 1.4
-#         no_repeat_ngram_size = 5
-#         temperature = 1.05
+#         num_return_sequences = 3
+#         num_beams = 11
 #         max_length = 320
 #     else:
-#         num_return_sequences = 5
-#         repetition_penalty = 1.5
-#         no_repeat_ngram_size = 6
-#         temperature = 1.1
+#         num_return_sequences = 3
+#         num_beams = 15
 #         max_length = 384
     
-#     top_k = 50
-#     top_p = 0.95
-#     length_penalty = 1.0
-    
 #     formatted_output = "Original text:\n" + text + "\n\n"
 #     formatted_output += "Paraphrased versions:\n"
     
@@ -272,19 +443,21 @@
 #     }
     
 #     for i, sentence in enumerate(sentences):
-#         paraphrases = paraphrase_pipeline(
-#             sentence,
-#             num_return_sequences=num_return_sequences,
-#             do_sample=True,
-#             top_k=top_k,
-#             top_p=top_p,
-#             temperature=temperature,
-#             no_repeat_ngram_size=no_repeat_ngram_size,
-#             repetition_penalty=repetition_penalty,
-#             max_length=max_length
+#         text = "paraphrase: " + sentence + " </s>"
+#         encoding = paraphraser_tokenizer.encode_plus(text, max_length=max_length, padding=True, return_tensors="pt")
+#         input_ids, attention_mask = encoding["input_ids"].to(device), encoding["attention_mask"].to(device)
+        
+#         paraphraser_model.eval()
+#         beam_outputs = paraphraser_model.generate(
+#             input_ids=input_ids,
+#             attention_mask=attention_mask,
+#             max_length=max_length,
+#             early_stopping=True,
+#             num_beams=num_beams,
+#             num_return_sequences=num_return_sequences
 #         )
         
-#         paraphrases_texts = [p['generated_text'] for p in paraphrases]
+#         paraphrases_texts = [paraphraser_tokenizer.decode(beam_output, skip_special_tokens=True, clean_up_tokenization_spaces=True) for beam_output in beam_outputs]
         
 #         formatted_output += f"Original sentence {i+1}: {sentence}\n"
 #         for j, paraphrase in enumerate(paraphrases_texts, 1):
@@ -314,7 +487,7 @@
 #         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):
+#         if label == "human-produced" or (label == "machine-generated" and score < 0.90):  # Adjusted threshold
 #             human_versions.append((version, label, score))
     
 #     formatted_output += "\nHuman-like or Less Confident Machine-generated versions:\n"
@@ -358,24 +531,15 @@
 
 # # Launch the interface
 # iface.launch()
-
 import os
 import json
 import gradio as gr
 import spaces
 import torch
-import sys
-import subprocess
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
 from sentence_splitter import SentenceSplitter
 from itertools import product
 
-# Ensure sentencepiece is installed
-try:
-    import sentencepiece
-except ImportError:
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "sentencepiece"])
-
 # Get the Hugging Face token from environment variable
 hf_token = os.getenv('HF_TOKEN')
 
@@ -385,7 +549,7 @@ print(f"Using device: {device}")
 
 # Initialize paraphraser model and tokenizer
 paraphraser_model_name = "ramsrigouthamg/t5-large-paraphraser-diverse-high-quality"
-paraphraser_tokenizer = AutoTokenizer.from_pretrained(paraphraser_model_name, use_fast=False)
+paraphraser_tokenizer = AutoTokenizer.from_pretrained(paraphraser_model_name)
 paraphraser_model = AutoModelForSeq2SeqLM.from_pretrained(paraphraser_model_name).to(device)
 
 # Initialize classifier model and tokenizer