Spaces:
Running
Running
| import os | |
| import gradio as gr | |
| from transformers import pipeline | |
| import spacy | |
| import subprocess | |
| import nltk | |
| from nltk.corpus import wordnet | |
| from grammarChecker.util import check_becauseError, check_butError, check_TenseError, check_articleError | |
| from pattern.en import conjugate, tenses | |
| # Initialize the English text classification pipeline for AI detection | |
| pipeline_en = pipeline(task="text-classification", model="Hello-SimpleAI/chatgpt-detector-roberta") | |
| # Function to predict the label and score for English text (AI Detection) | |
| def predict_en(text): | |
| res = pipeline_en(text)[0] | |
| return res['label'], res['score'] | |
| # Ensure necessary NLTK data is downloaded for Humanifier | |
| nltk.download('wordnet') | |
| nltk.download('omw-1.4') | |
| # Ensure the SpaCy model is installed for Humanifier | |
| try: | |
| nlp = spacy.load("en_core_web_sm") | |
| except OSError: | |
| subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"]) | |
| nlp = spacy.load("en_core_web_sm") | |
| # Function to get synonyms using NLTK WordNet (Humanifier) | |
| def get_synonyms_nltk(word, pos): | |
| synsets = wordnet.synsets(word, pos=pos) | |
| if synsets: | |
| lemmas = synsets[0].lemmas() | |
| return [lemma.name() for lemma in lemmas] | |
| return [] | |
| # Function to capitalize the first letter of sentences and proper nouns (Humanifier) | |
| def capitalize_sentences_and_nouns(text): | |
| doc = nlp(text) | |
| corrected_text = [] | |
| for sent in doc.sents: | |
| sentence = [] | |
| for token in sent: | |
| if token.i == sent.start: # First word of the sentence | |
| sentence.append(token.text.capitalize()) | |
| elif token.pos_ == "PROPN": # Proper noun | |
| sentence.append(token.text.capitalize()) | |
| else: | |
| sentence.append(token.text) | |
| corrected_text.append(' '.join(sentence)) | |
| return ' '.join(corrected_text) | |
| # Function to check and correct tense consistency in sentences using Pattern.en | |
| def check_tense_consistency(text): | |
| doc = nlp(text) | |
| corrected_sentences = [] | |
| for sent in doc.sents: | |
| verbs = [token for token in sent if token.pos_ == 'VERB'] | |
| if verbs: | |
| # Find the most common tense in the sentence | |
| common_tense = None | |
| for verb in verbs: | |
| verb_tense = tenses(verb.text) | |
| if verb_tense: | |
| common_tense = verb_tense[0][0] | |
| break | |
| # Conjugate all verbs to the common tense if there's inconsistency | |
| corrected_sentence = [] | |
| for token in sent: | |
| if token.pos_ == 'VERB' and common_tense: | |
| corrected_verb = conjugate(token.text, tense=common_tense) | |
| corrected_sentence.append(corrected_verb) | |
| else: | |
| corrected_sentence.append(token.text) | |
| corrected_sentences.append(' '.join(corrected_sentence)) | |
| else: | |
| corrected_sentences.append(sent.text) | |
| return ' '.join(corrected_sentences) | |
| # Function to perform grammar and structure corrections using external grammar functions | |
| def grammar_correction(text): | |
| error_count_because, corrected_text_because = check_becauseError(text) | |
| error_count_but, corrected_text_but = check_butError(corrected_text_because) | |
| error_count_tense, corrected_text_tense = check_TenseError(corrected_text_but) | |
| error_count_article, final_corrected_text = check_articleError(corrected_text_tense) | |
| return final_corrected_text | |
| # Paraphrasing function using SpaCy and NLTK (Humanifier) | |
| def paraphrase_with_spacy_nltk(text): | |
| doc = nlp(text) | |
| paraphrased_words = [] | |
| for token in doc: | |
| # Map SpaCy POS tags to WordNet POS tags | |
| pos = None | |
| if token.pos_ in {"NOUN"}: | |
| pos = wordnet.NOUN | |
| elif token.pos_ in {"VERB"}: | |
| pos = wordnet.VERB | |
| elif token.pos_ in {"ADJ"}: | |
| pos = wordnet.ADJ | |
| elif token.pos_ in {"ADV"}: | |
| pos = wordnet.ADV | |
| synonyms = get_synonyms_nltk(token.text.lower(), pos) if pos else [] | |
| # Replace with a synonym only if it makes sense | |
| if synonyms and token.pos_ in {"NOUN", "VERB", "ADJ", "ADV"} and synonyms[0] != token.text.lower(): | |
| paraphrased_words.append(synonyms[0]) | |
| else: | |
| paraphrased_words.append(token.text) | |
| # Join the words back into a sentence | |
| paraphrased_sentence = ' '.join(paraphrased_words) | |
| # Capitalize sentences and proper nouns | |
| corrected_text = capitalize_sentences_and_nouns(paraphrased_sentence) | |
| return corrected_text | |
| # Combined function: Paraphrase -> Grammar Correction -> Capitalization -> Tense Consistency (Humanifier) | |
| def paraphrase_and_correct(text): | |
| # Step 1: Paraphrase the text | |
| paraphrased_text = paraphrase_with_spacy_nltk(text) | |
| # Step 2: Grammar and structure corrections | |
| grammatically_corrected_text = grammar_correction(paraphrased_text) | |
| # Step 3: Capitalize sentences and proper nouns | |
| capitalized_text = capitalize_sentences_and_nouns(grammatically_corrected_text) | |
| # Step 4: Check and correct tense consistency | |
| final_text = check_tense_consistency(capitalized_text) | |
| return final_text | |
| # Gradio app setup with two tabs | |
| with gr.Blocks() as demo: | |
| with gr.Tab("AI Detection"): | |
| t1 = gr.Textbox(lines=5, label='Text') | |
| button1 = gr.Button("🤖 Predict!") | |
| label1 = gr.Textbox(lines=1, label='Predicted Label 🎃') | |
| score1 = gr.Textbox(lines=1, label='Prob') | |
| # Connect the prediction function to the button | |
| button1.click(predict_en, inputs=[t1], outputs=[label1, score1], api_name='predict_en') | |
| with gr.Tab("Humanifier"): | |
| text_input = gr.Textbox(lines=5, label="Input Text") | |
| paraphrase_button = gr.Button("Paraphrase & Correct") | |
| output_text = gr.Textbox(label="Paraphrased Text") | |
| # Connect the paraphrasing and correction function to the button | |
| paraphrase_button.click(paraphrase_and_correct, inputs=text_input, outputs=output_text) | |
| # Launch the app with the remaining functionalities | |
| demo.launch() | |