Hugging Face's logo

Spaces:
sashtech
/
aihumanifierandgrmoform
Runtime error

App Files Community
aihumanifierandgrmoform
File size: 4,495 Bytes 
d90e4dc
84669bc
d90e4dc
 
 
 
 
 
 
 
 
 
23b0057
 
12244e9
d90e4dc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
12244e9
 
d90e4dc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
import os
import gradio as gr
from transformers import pipeline
import spacy
import subprocess
import nltk
from nltk.corpus import wordnet
import torch
from gramformer import Gramformer

# Initialize the English text classification pipeline for AI detection
pipeline_en = pipeline(task="text-classification", model="Hello-SimpleAI/chatgpt-detector-roberta")

# Initialize Gramformer
gf = Gramformer(models=1, use_gpu=False)  # 1 = corrector

# 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)

# 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 -> Capitalization -> Grammar Correction (Humanifier)
def paraphrase_correct_and_grammar(text):
    # Step 1: Paraphrase the text
    paraphrased_text = paraphrase_with_spacy_nltk(text)
    
    # Step 2: Capitalize sentences and proper nouns
    capitalized_text = capitalize_sentences_and_nouns(paraphrased_text)
    
    # Step 3: Grammar correction using Gramformer
    corrected_sentences = gf.correct(capitalized_text, max_candidates=1)
    final_text = next(iter(corrected_sentences)) if corrected_sentences else 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 & Grammar Check")
        output_text = gr.Textbox(label="Processed Text")

        # Connect the paraphrasing and grammar correction function to the button
        paraphrase_button.click(paraphrase_correct_and_grammar, inputs=text_input, outputs=output_text)

# Launch the app with both functionalities
demo.launch()