NoaiGPT-777 / app.py
NoaiGPT's picture
asd
b26218c
raw
history blame
30.8 kB
# # # 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 pipeline, 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 = "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"
# # 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 = 0.9
# # max_length = 128
# # elif setting == 2:
# # num_return_sequences = 5
# # repetition_penalty = 1.2
# # no_repeat_ngram_size = 3
# # temperature = 0.95
# # max_length = 192
# # elif setting == 3:
# # num_return_sequences = 5
# # repetition_penalty = 1.3
# # no_repeat_ngram_size = 4
# # temperature = 1.0
# # max_length = 256
# # elif setting == 4:
# # num_return_sequences = 5
# # repetition_penalty = 1.4
# # no_repeat_ngram_size = 5
# # temperature = 1.05
# # max_length = 320
# # else:
# # num_return_sequences = 5
# # repetition_penalty = 1.5
# # no_repeat_ngram_size = 6
# # temperature = 1.1
# # 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):
# # 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
# # )
# # paraphrases_texts = [p['generated_text'] for p in paraphrases]
# # formatted_output += f"Original sentence {i+1}: {sentence}\n"
# # 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_texts
# # })
# # all_sentence_paraphrases.append(paraphrases_texts)
# # 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
# 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')
# 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 = "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)
# # 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 = 3
# num_beams = 5
# max_length = 128
# elif setting == 2:
# num_return_sequences = 3
# num_beams = 7
# max_length = 192
# elif setting == 3:
# num_return_sequences = 3
# num_beams = 9
# max_length = 256
# elif setting == 4:
# num_return_sequences = 3
# num_beams = 11
# max_length = 320
# else:
# num_return_sequences = 3
# num_beams = 15
# 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):
# 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 = [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):
# formatted_output += f" Paraphrase {j}: {paraphrase}\n"
# json_output["paraphrased_versions"].append({
# f"original_sentence_{i+1}": sentence,
# "paraphrases": paraphrases_texts
# })
# all_sentence_paraphrases.append(paraphrases_texts)
# 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.90): # Adjusted threshold
# 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 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 = "ramsrigouthamg/t5-large-paraphraser-diverse-high-quality"
paraphraser_tokenizer = AutoTokenizer.from_pretrained(paraphraser_model_name)
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
def clean_text(text):
return text.replace("paraphrasedoutput: ", "")
@spaces.GPU
def generate_paraphrases(text, setting, output_format):
sentences = splitter.split(text)
all_sentence_paraphrases = []
if setting == 1:
num_return_sequences = 5
temperature = 1.0
top_k = 50
top_p = 0.95
max_length = 128
elif setting == 2:
num_return_sequences = 7
temperature = 1.2
top_k = 50
top_p = 0.95
max_length = 192
elif setting == 3:
num_return_sequences = 10
temperature = 1.4
top_k = 50
top_p = 0.95
max_length = 256
elif setting == 4:
num_return_sequences = 15
temperature = 1.6
top_k = 50
top_p = 0.95
max_length = 320
else:
num_return_sequences = 20
temperature = 1.8
top_k = 50
top_p = 0.95
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):
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()
outputs = paraphraser_model.generate(
input_ids=input_ids,
attention_mask=attention_mask,
max_length=max_length,
num_return_sequences=num_return_sequences,
do_sample=True,
top_k=top_k,
top_p=top_p,
temperature=temperature
)
paraphrases_texts = [paraphraser_tokenizer.decode(output, skip_special_tokens=True, clean_up_tokenization_spaces=True) for output in outputs]
formatted_output += f"Original sentence {i+1}: {sentence}\n"
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_texts
})
all_sentence_paraphrases.append(paraphrases_texts)
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.90): # Adjusted threshold
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])
def clean_paraphrased_output(text):
cleaned_text = clean_text(text)
return cleaned_text
# Define the Gradio interface
iface = gr.Interface(
fn=clean_paraphrased_output,
inputs=[
gr.Textbox(lines=5, label="Input Text")
],
outputs=[
gr.Textbox(lines=20, label="Cleaned Text")
],
title="Clean Paraphrased Output",
description="Enter a text with 'paraphrasedoutput:' prefix and get the cleaned text."
)
# Launch the interface
iface.launch()