asd

app.py

@@ -328,6 +328,188 @@ def generate_paraphrases(text, setting, output_format):
     
     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, T5ForConditionalGeneration
+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 = "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 grammar correction model and tokenizer
+grammar_model_name = "grammarly/coedit-large"
+grammar_tokenizer = AutoTokenizer.from_pretrained(grammar_model_name)
+grammar_model = T5ForConditionalGeneration.from_pretrained(grammar_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 correct_grammar(text):
+    inputs = grammar_tokenizer(f'Fix grammatical errors in this sentence: {text}', return_tensors="pt").input_ids.to(device)
+    outputs = grammar_model.generate(inputs, max_length=256)
+    corrected_text = grammar_tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return corrected_text
+
+@spaces.GPU
+def generate_paraphrases(text, setting, output_format):
+    sentences = splitter.split(text)
+    all_sentence_paraphrases = []
+
+    # Define settings
+    settings = {
+        1: {"num_return_sequences": 2, "repetition_penalty": 1.1, "no_repeat_ngram_size": 2, "temperature": 1.0, "max_length": 128},
+        2: {"num_return_sequences": 2, "repetition_penalty": 1.2, "no_repeat_ngram_size": 3, "temperature": 1.2, "max_length": 192},
+        3: {"num_return_sequences": 2, "repetition_penalty": 1.3, "no_repeat_ngram_size": 4, "temperature": 1.4, "max_length": 256},
+        4: {"num_return_sequences": 2, "repetition_penalty": 1.4, "no_repeat_ngram_size": 5, "temperature": 1.6, "max_length": 320},
+        5: {"num_return_sequences": 2, "repetition_penalty": 1.5, "no_repeat_ngram_size": 6, "temperature": 1.8, "max_length": 384}
+    }
+    config = settings.get(setting, settings[5])
+
+    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": []
+    }
+
+    # Process sentences in batches
+    batch_size = 4
+    for i in range(0, len(sentences), batch_size):
+        batch_sentences = sentences[i:i + batch_size]
+        inputs = paraphraser_tokenizer([f'paraphraser: {sentence}' for sentence in batch_sentences], return_tensors="pt", padding="longest", truncation=True, max_length=config["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=config["num_return_sequences"],
+            repetition_penalty=config["repetition_penalty"],
+            no_repeat_ngram_size=config["no_repeat_ngram_size"],
+            temperature=config["temperature"],
+            max_length=config["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)
+
+        corrected_paraphrases = [correct_grammar(paraphrase) for paraphrase in paraphrases]
+
+        for j, sentence in enumerate(batch_sentences):
+            formatted_output += f"Original sentence {i + j + 1}: {sentence}\n"
+            sentence_paraphrases = corrected_paraphrases[j * config["num_return_sequences"]:(j + 1) * config["num_return_sequences"]]
+            for k, paraphrase in enumerate(sentence_paraphrases, 1):
+                formatted_output += f"  Paraphrase {k}: {paraphrase}\n"
+
+            json_output["paraphrased_versions"].append({
+                f"original_sentence_{i + j + 1}": sentence,
+                "paraphrases": sentence_paraphrases
+            })
+
+            all_sentence_paraphrases.append(sentence_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):
@@ -336,17 +518,17 @@ def generate_paraphrases(text, setting, output_format):
         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]
@@ -354,7 +536,7 @@ def generate_paraphrases(text, setting, output_format):
         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: