Create app.py

app.py

@@ -0,0 +1,134 @@
+import nltk
+import re
+import random
+from nltk.tokenize import sent_tokenize
+from nltk.tag import pos_tag
+from nltk.chunk import ne_chunk
+from nltk.tree import Tree
+import gradio as gr
+
+# Download necessary NLTK data
+nltk.download('punkt')
+nltk.download('averaged_perceptron_tagger')
+nltk.download('maxent_ne_chunker')
+nltk.download('words')
+
+def get_named_entities(text):
+    """Extract named entities from text."""
+    chunked = ne_chunk(pos_tag(nltk.word_tokenize(text)))
+    named_entities = []
+    
+    for chunk in chunked:
+        if isinstance(chunk, Tree):
+            entity = ' '.join([word for word, tag in chunk.leaves()])
+            named_entities.append((entity, chunk.label()))
+    
+    return named_entities
+
+def generate_question_from_sentence(sentence):
+    """Generate a question from a sentence."""
+    # Remove punctuation at the end
+    sentence = re.sub(r'[.!?]$', '', sentence)
+    
+    # Check for common patterns that can be turned into questions
+    if re.search(r'\bis\s|\bwas\s|\bwere\s|\bare\s', sentence):
+        # Convert statements with "is", "was", "were", "are" into yes/no questions
+        match = re.search(r'^(.*?)\s(is|was|were|are)\s(.*?)$', sentence, re.IGNORECASE)
+        if match:
+            return f"{match.group(2).capitalize()} {match.group(1)} {match.group(3)}?"
+    
+    # Check for sentences with dates or years
+    if re.search(r'\b(in|on|during)\s\d{4}\b|\b(January|February|March|April|May|June|July|August|September|October|November|December)\b', sentence, re.IGNORECASE):
+        return f"When did {sentence.lower()}?"
+    
+    # Get named entities
+    entities = get_named_entities(sentence)
+    
+    # If there are named entities, ask about them
+    if entities:
+        entity, entity_type = entities[0]
+        if entity_type == 'PERSON':
+            return f"Who is {entity}?"
+        elif entity_type in ['GPE', 'LOCATION']:
+            return f"Where is {entity}?"
+        elif entity_type == 'ORGANIZATION':
+            return f"What is {entity}?"
+    
+    # Check for sentences with "because", "due to", "as a result"
+    if re.search(r'\bbecause\b|\bdue to\b|\bas a result\b', sentence, re.IGNORECASE):
+        return f"Why {sentence.lower()}?"
+    
+    # Default questions based on sentence structure
+    words = nltk.word_tokenize(sentence)
+    pos_tags = pos_tag(words)
+    
+    # Check if sentence has a verb
+    has_verb = any(tag.startswith('VB') for _, tag in pos_tags)
+    
+    if has_verb:
+        # Extract subject (simplistic approach)
+        subject = ""
+        for word, tag in pos_tags:
+            if tag.startswith('NN') or tag.startswith('PRP'):
+                subject = word
+                break
+        
+        if subject:
+            if subject.lower() in ['i', 'you', 'we', 'they']:
+                return f"What did {subject.lower()} do?"
+            else:
+                return f"What did {subject} do?"
+        else:
+            # Fallback to "what" question
+            return f"What {sentence.lower()}?"
+    
+    # Very generic fallback
+    question_starters = [
+        "What is described in",
+        "What is mentioned about",
+        "Can you explain",
+        "Could you elaborate on"
+    ]
+    
+    return f"{random.choice(question_starters)} the statement: '{sentence}'?"
+
+def paragraph_to_questions(paragraph):
+    """Generate questions from a paragraph."""
+    sentences = sent_tokenize(paragraph)
+    questions = []
+    
+    for sentence in sentences:
+        # Skip very short sentences
+        if len(sentence.split()) < 4:
+            continue
+        
+        question = generate_question_from_sentence(sentence)
+        questions.append(question)
+    
+    return questions
+
+# Function to format the output for Gradio
+def generate_questions(paragraph):
+    questions = paragraph_to_questions(paragraph)
+    return "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)])
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=generate_questions,
+    inputs=gr.Textbox(lines=10, placeholder="Enter a paragraph to generate questions..."),
+    outputs=gr.Textbox(label="Generated Questions"),
+    title="Paragraph to Questions Generator",
+    description="Enter a paragraph and the model will generate relevant questions based on the content.",
+    examples=[
+        ["Artificial intelligence has revolutionized many industries. Companies like Google and OpenAI are investing billions in research. The field continues to grow rapidly, with new breakthroughs announced every month. Concerns about ethics and regulation remain important topics of discussion."],
+        ["The Great Barrier Reef is the world's largest coral reef system. It is located off the coast of Queensland, Australia. The reef is home to thousands of species of marine life. Climate change poses a significant threat to its survival."]
+    ]
+)
+
+# For use as a module in other Hugging Face applications
+def generate_questions_from_text(text):
+    return paragraph_to_questions(text)
+
+# Launch the app if running directly
+if __name__ == "__main__":
+    demo.launch()