initial commit

README.md

@@ -1,14 +1,59 @@
 ---
-title: Lang Learn App
-emoji: 👀
-colorFrom: green
-colorTo: blue
+title: Language Learning App - Grammar Checker
+emoji: 🎓
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.31.0
+sdk_version: 4.15.0
 app_file: app.py
 pinned: false
-license: cc-by-4.0
-short_description: An application prototype
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Language Learning Application - Grammar Checker
+
+An AI-powered language learning application that provides:
+
+## Features
+
+- **📝 Writing Analysis**: Submit your writing for automated grammar checking and error correction
+- **🏋️ Exercise Creation**: Generate grammar exercises from text containing errors
+- **✏️ Exercise Practice**: Practice with generated exercises and get scored feedback
+- **📊 Progress Tracking**: Track student progress across submissions and exercises
+
+## How to Use
+
+### For Students:
+1. **Writing Analysis**: Enter your name and paste your writing in the "Writing Analysis" tab
+2. **Exercise Practice**: Use exercise IDs to practice grammar exercises
+3. **View Progress**: Check your improvement over time
+
+### For Teachers:
+1. **Create Exercises**: Use the "Exercise Creation" tab to generate exercises from error-containing text
+2. **Monitor Progress**: Track student submissions and exercise performance
+3. **Assign Practice**: Share exercise IDs with students for targeted practice
+
+## Technology
+
+- **Neural Networks**: Uses advanced T5 and ELECTRA models for grammar error detection and correction
+- **Models**: 
+  - `Zlovoblachko/Realec-2step-ft-realec` for grammar correction
+  - `Zlovoblachko/4tag-electra-grammar-error-detection` for error detection
+- **Database**: SQLite for storing submissions, exercises, and progress
+- **Interface**: Gradio for easy-to-use web interface
+
+## Example Usage
+
+1. **Submit Writing**: "I have went to the store yesterday" → "I went to the store yesterday"
+2. **Create Exercise**: Input text with errors → Get numbered sentences for practice
+3. **Practice**: Correct the sentences → Get immediate feedback and scoring
+
+## Educational Value
+
+This application helps language learners by:
+- Providing immediate feedback on grammar errors
+- Creating personalized practice exercises
+- Tracking learning progress over time
+- Offering detailed error analysis and corrections
+
+Perfect for ESL students, writing practice, and grammar skill development!

app.py

@@ -0,0 +1,498 @@
+import gradio as gr
+import sqlite3
+import json
+import os
+from datetime import datetime
+import torch
+import nltk
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, ElectraTokenizer, ElectraForTokenClassification
+import torch.nn as nn
+
+# Download NLTK data
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+
+# Initialize SQLite database for storing submissions and exercises
+def init_database():
+    conn = sqlite3.connect('language_app.db')
+    c = conn.cursor()
+    
+    # Users table
+    c.execute('''CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        username TEXT UNIQUE NOT NULL,
+        email TEXT UNIQUE NOT NULL,
+        role TEXT NOT NULL,
+        password_hash TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )''')
+    
+    # Tasks table
+    c.execute('''CREATE TABLE IF NOT EXISTS tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        title TEXT NOT NULL,
+        description TEXT NOT NULL,
+        image_url TEXT,
+        creator_id INTEGER,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )''')
+    
+    # Submissions table
+    c.execute('''CREATE TABLE IF NOT EXISTS submissions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id INTEGER,
+        student_name TEXT NOT NULL,
+        content TEXT NOT NULL,
+        analysis_result TEXT,
+        analysis_html TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )''')
+    
+    # Exercises table
+    c.execute('''CREATE TABLE IF NOT EXISTS exercises (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        title TEXT NOT NULL,
+        instructions TEXT NOT NULL,
+        sentences TEXT NOT NULL,
+        image_url TEXT,
+        submission_id INTEGER,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )''')
+    
+    # Exercise attempts table
+    c.execute('''CREATE TABLE IF NOT EXISTS exercise_attempts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        exercise_id INTEGER,
+        student_name TEXT NOT NULL,
+        responses TEXT NOT NULL,
+        score REAL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )''')
+    
+    conn.commit()
+    conn.close()
+
+# Neural Network Model (simplified version of your existing model)
+class SimpleGrammarChecker:
+    def __init__(self):
+        self.model_name = "Zlovoblachko/Realec-2step-ft-realec"
+        self.ged_model_name = "Zlovoblachko/4tag-electra-grammar-error-detection"
+        self.load_models()
+    
+    def load_models(self):
+        try:
+            # Load T5 model
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
+            
+            # Load GED model
+            self.ged_tokenizer = ElectraTokenizer.from_pretrained(self.ged_model_name)
+            self.ged_model = ElectraForTokenClassification.from_pretrained(self.ged_model_name)
+            
+            print("Models loaded successfully!")
+        except Exception as e:
+            print(f"Error loading models: {e}")
+            self.model = None
+            self.ged_model = None
+    
+    def analyze_text(self, text):
+        if not self.model or not text.strip():
+            return "Model not available or empty text", ""
+        
+        try:
+            # Tokenize and generate correction
+            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    input_ids=inputs.input_ids,
+                    attention_mask=inputs.attention_mask,
+                    max_length=512,
+                    num_beams=4,
+                    early_stopping=True
+                )
+            
+            corrected_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Get GED predictions if available
+            error_spans = []
+            if self.ged_model:
+                error_spans = self.get_error_spans(text)
+            
+            # Generate HTML output
+            html_output = self.generate_html_analysis(text, corrected_text, error_spans)
+            
+            return corrected_text, html_output
+            
+        except Exception as e:
+            return f"Error during analysis: {str(e)}", ""
+    
+    def get_error_spans(self, text):
+        try:
+            inputs = self.ged_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+            
+            with torch.no_grad():
+                outputs = self.ged_model(**inputs)
+                predictions = torch.argmax(outputs.logits, dim=2)
+            
+            tokens = self.ged_tokenizer.convert_ids_to_tokens(inputs.input_ids[0])
+            token_predictions = predictions[0].cpu().numpy().tolist()
+            
+            error_spans = []
+            for i, (token, pred) in enumerate(zip(tokens, token_predictions)):
+                if token.startswith("##") or token in ["[CLS]", "[SEP]", "[PAD]"]:
+                    continue
+                if pred != 0:  # 0 is correct, 1=R, 2=M, 3=U
+                    error_type = ["C", "R", "M", "U"][pred]
+                    error_spans.append({"token": token, "type": error_type, "position": i})
+            
+            return error_spans
+        except:
+            return []
+    
+    def generate_html_analysis(self, original, corrected, error_spans):
+        html = f"""
+        <div style='font-family: Arial, sans-serif; line-height: 1.6; padding: 20px; border: 1px solid #ddd; border-radius: 8px; background-color: #f9f9f9;'>
+            <h3 style='color: #333; margin-top: 0;'>Grammar Analysis Results</h3>
+            
+            <div style='margin: 15px 0;'>
+                <h4 style='color: #555;'>Original Text:</h4>
+                <p style='padding: 10px; background-color: #fff; border: 1px solid #ddd; border-radius: 4px;'>{original}</p>
+            </div>
+            
+            <div style='margin: 15px 0;'>
+                <h4 style='color: #28a745;'>Corrected Text:</h4>
+                <p style='padding: 10px; background-color: #d4edda; border: 1px solid #c3e6cb; border-radius: 4px;'>{corrected}</p>
+            </div>
+            
+            <div style='margin: 15px 0;'>
+                <h4 style='color: #333;'>Error Analysis:</h4>
+                <p style='color: #666;'>Found {len(error_spans)} potential errors</p>
+            </div>
+        </div>
+        """
+        return html
+
+# Initialize components
+init_database()
+grammar_checker = SimpleGrammarChecker()
+
+# Gradio Interface Functions
+def analyze_student_writing(text, student_name, task_title="General Writing Task"):
+    """Analyze student writing and store in database"""
+    if not text.strip():
+        return "Please enter some text to analyze.", ""
+    
+    if not student_name.strip():
+        return "Please enter your name.", ""
+    
+    # Analyze text
+    corrected_text, html_analysis = grammar_checker.analyze_text(text)
+    
+    # Store in database
+    conn = sqlite3.connect('language_app.db')
+    c = conn.cursor()
+    
+    # Insert task if not exists
+    c.execute("INSERT OR IGNORE INTO tasks (title, description) VALUES (?, ?)", 
+              (task_title, f"Writing task: {task_title}"))
+    
+    c.execute("SELECT id FROM tasks WHERE title = ?", (task_title,))
+    task_id = c.fetchone()[0]
+    
+    # Insert submission
+    analysis_data = {
+        "corrected_text": corrected_text,
+        "original_text": text,
+        "html_output": html_analysis
+    }
+    
+    c.execute("""INSERT INTO submissions (task_id, student_name, content, analysis_result, analysis_html) 
+                 VALUES (?, ?, ?, ?, ?)""",
+              (task_id, student_name, text, json.dumps(analysis_data), html_analysis))
+    
+    submission_id = c.lastrowid
+    conn.commit()
+    conn.close()
+    
+    return corrected_text, html_analysis
+
+def create_exercise_from_text(text, exercise_title="Grammar Exercise"):
+    """Create an exercise from text with errors"""
+    if not text.strip():
+        return "Please enter text to create an exercise.", ""
+    
+    # Analyze text to find sentences with errors
+    sentences = nltk.sent_tokenize(text)
+    exercise_sentences = []
+    
+    for sentence in sentences:
+        corrected, _ = grammar_checker.analyze_text(sentence)
+        if sentence.strip() != corrected.strip():  # Has errors
+            exercise_sentences.append({
+                "original": sentence.strip(),
+                "corrected": corrected.strip()
+            })
+    
+    if not exercise_sentences:
+        return "No errors found in the text. Cannot create exercise.", ""
+    
+    # Store exercise in database
+    conn = sqlite3.connect('language_app.db')
+    c = conn.cursor()
+    
+    c.execute("""INSERT INTO exercises (title, instructions, sentences) 
+                 VALUES (?, ?, ?)""",
+              (exercise_title, 
+               "Correct the grammatical errors in the following sentences:",
+               json.dumps(exercise_sentences)))
+    
+    exercise_id = c.lastrowid
+    conn.commit()
+    conn.close()
+    
+    # Generate exercise HTML
+    exercise_html = f"""
+    <div style='font-family: Arial, sans-serif; padding: 20px; border: 1px solid #ddd; border-radius: 8px;'>
+        <h3>{exercise_title}</h3>
+        <p><strong>Instructions:</strong> Correct the grammatical errors in the following sentences:</p>
+        <ol>
+    """
+    
+    for i, sentence_data in enumerate(exercise_sentences, 1):
+        exercise_html += f"<li style='margin: 10px 0; padding: 10px; background-color: #f8f9fa; border-radius: 4px;'>{sentence_data['original']}</li>"
+    
+    exercise_html += "</ol></div>"
+    
+    return f"Exercise created with {len(exercise_sentences)} sentences!", exercise_html
+
+def attempt_exercise(exercise_id, student_responses, student_name):
+    """Submit exercise attempt and get score"""
+    if not student_name.strip():
+        return "Please enter your name.", ""
+    
+    try:
+        exercise_id = int(exercise_id)
+    except:
+        return "Please enter a valid exercise ID.", ""
+    
+    # Get exercise from database
+    conn = sqlite3.connect('language_app.db')
+    c = conn.cursor()
+    
+    c.execute("SELECT sentences FROM exercises WHERE id = ?", (exercise_id,))
+    result = c.fetchone()
+    
+    if not result:
+        return "Exercise not found.", ""
+    
+    exercise_sentences = json.loads(result[0])
+    
+    # Parse student responses
+    responses = [r.strip() for r in student_responses.split('\n') if r.strip()]
+    
+    if len(responses) != len(exercise_sentences):
+        return f"Please provide exactly {len(exercise_sentences)} responses (one per line).", ""
+    
+    # Calculate score
+    correct_count = 0
+    feedback = []
+    
+    for i, (sentence_data, response) in enumerate(zip(exercise_sentences, responses), 1):
+        correct_answer = sentence_data['corrected']
+        is_correct = response.lower().strip() == correct_answer.lower().strip()
+        
+        if is_correct:
+            correct_count += 1
+            feedback.append(f"✅ Sentence {i}: Correct!")
+        else:
+            feedback.append(f"❌ Sentence {i}: Your answer: '{response}' | Correct answer: '{correct_answer}'")
+    
+    score = (correct_count / len(exercise_sentences)) * 100
+    
+    # Store attempt
+    attempt_data = {
+        "responses": responses,
+        "score": score,
+        "feedback": feedback
+    }
+    
+    c.execute("""INSERT INTO exercise_attempts (exercise_id, student_name, responses, score) 
+                 VALUES (?, ?, ?, ?)""",
+              (exercise_id, student_name, json.dumps(attempt_data), score))
+    
+    conn.commit()
+    conn.close()
+    
+    feedback_html = f"""
+    <div style='font-family: Arial, sans-serif; padding: 20px; border: 1px solid #ddd; border-radius: 8px;'>
+        <h3>Exercise Results</h3>
+        <p><strong>Score: {score:.1f}%</strong> ({correct_count}/{len(exercise_sentences)} correct)</p>
+        <div style='margin-top: 15px;'>
+            {'<br>'.join(feedback)}
+        </div>
+    </div>
+    """
+    
+    return f"Score: {score:.1f}%", feedback_html
+
+def get_student_progress(student_name):
+    """Get student's submission and exercise history"""
+    if not student_name.strip():
+        return "Please enter a student name."
+    
+    conn = sqlite3.connect('language_app.db')
+    c = conn.cursor()
+    
+    # Get submissions
+    c.execute("""SELECT s.id, s.content, s.created_at, t.title 
+                 FROM submissions s JOIN tasks t ON s.task_id = t.id 
+                 WHERE s.student_name = ? ORDER BY s.created_at DESC""", (student_name,))
+    submissions = c.fetchall()
+    
+    # Get exercise attempts
+    c.execute("""SELECT ea.score, ea.created_at, e.title 
+                 FROM exercise_attempts ea JOIN exercises e ON ea.exercise_id = e.id 
+                 WHERE ea.student_name = ? ORDER BY ea.created_at DESC""", (student_name,))
+    attempts = c.fetchall()
+    
+    conn.close()
+    
+    progress_html = f"""
+    <div style='font-family: Arial, sans-serif; padding: 20px;'>
+        <h3>Progress for {student_name}</h3>
+        
+        <h4>Writing Submissions ({len(submissions)})</h4>
+        <ul>
+    """
+    
+    for sub in submissions:
+        progress_html += f"<li><strong>{sub[3]}</strong> - {sub[2][:16]} - {len(sub[1])} characters</li>"
+    
+    progress_html += f"""
+        </ul>
+        
+        <h4>Exercise Attempts ({len(attempts)})</h4>
+        <ul>
+    """
+    
+    for att in attempts:
+        progress_html += f"<li><strong>{att[2]}</strong> - Score: {att[0]:.1f}% - {att[1][:16]}</li>"
+    
+    progress_html += "</ul></div>"
+    
+    return progress_html
+
+# Create Gradio Interface
+with gr.Blocks(title="Language Learning App - Grammar Checker", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🎓 Language Learning Application")
+    gr.Markdown("### AI-Powered Grammar Checking and Exercise Generation")
+    
+    with gr.Tabs():
+        # Student Writing Analysis Tab
+        with gr.TabItem("📝 Writing Analysis"):
+            gr.Markdown("## Submit Your Writing for Analysis")
+            
+            with gr.Row():
+                with gr.Column():
+                    student_name_input = gr.Textbox(label="Your Name", placeholder="Enter your name")
+                    task_title_input = gr.Textbox(label="Assignment Title", value="General Writing Task")
+                    writing_input = gr.Textbox(
+                        label="Your Writing", 
+                        lines=8, 
+                        placeholder="Paste your writing here for grammar analysis..."
+                    )
+                    analyze_btn = gr.Button("Analyze Writing", variant="primary")
+                
+                with gr.Column():
+                    corrected_output = gr.Textbox(label="Corrected Text", lines=6)
+                    analysis_output = gr.HTML(label="Detailed Analysis")
+            
+            analyze_btn.click(
+                analyze_student_writing,
+                inputs=[writing_input, student_name_input, task_title_input],
+                outputs=[corrected_output, analysis_output]
+            )
+        
+        # Exercise Creation Tab
+        with gr.TabItem("🏋️ Exercise Creation"):
+            gr.Markdown("## Create Grammar Exercises")
+            
+            with gr.Row():
+                with gr.Column():
+                    exercise_title_input = gr.Textbox(label="Exercise Title", value="Grammar Exercise")
+                    exercise_text_input = gr.Textbox(
+                        label="Text with Errors", 
+                        lines=6,
+                        placeholder="Enter text containing grammatical errors to create an exercise..."
+                    )
+                    create_exercise_btn = gr.Button("Create Exercise", variant="primary")
+                
+                with gr.Column():
+                    exercise_result = gr.Textbox(label="Result")
+                    exercise_display = gr.HTML(label="Generated Exercise")
+            
+            create_exercise_btn.click(
+                create_exercise_from_text,
+                inputs=[exercise_text_input, exercise_title_input],
+                outputs=[exercise_result, exercise_display]
+            )
+        
+        # Exercise Attempt Tab
+        with gr.TabItem("✏️ Exercise Practice"):
+            gr.Markdown("## Practice Grammar Exercises")
+            
+            with gr.Row():
+                with gr.Column():
+                    exercise_id_input = gr.Textbox(label="Exercise ID", placeholder="Enter exercise ID")
+                    student_name_exercise = gr.Textbox(label="Your Name", placeholder="Enter your name")
+                    responses_input = gr.Textbox(
+                        label="Your Answers", 
+                        lines=6,
+                        placeholder="Enter your corrected sentences (one per line)..."
+                    )
+                    submit_exercise_btn = gr.Button("Submit Answers", variant="primary")
+                
+                with gr.Column():
+                    score_output = gr.Textbox(label="Your Score")
+                    feedback_output = gr.HTML(label="Detailed Feedback")
+            
+            submit_exercise_btn.click(
+                attempt_exercise,
+                inputs=[exercise_id_input, responses_input, student_name_exercise],
+                outputs=[score_output, feedback_output]
+            )
+        
+        # Progress Tracking Tab
+        with gr.TabItem("📊 Student Progress"):
+            gr.Markdown("## View Student Progress")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    progress_student_name = gr.Textbox(label="Student Name", placeholder="Enter student name")
+                    get_progress_btn = gr.Button("Get Progress", variant="primary")
+                
+                with gr.Column(scale=2):
+                    progress_output = gr.HTML(label="Student Progress")
+            
+            get_progress_btn.click(
+                get_student_progress,
+                inputs=[progress_student_name],
+                outputs=[progress_output]
+            )
+    
+    gr.Markdown("""
+    ---
+    ### How to Use:
+    1. **Writing Analysis**: Submit your writing to get grammar corrections and detailed error analysis
+    2. **Exercise Creation**: Teachers can create exercises from text containing errors
+    3. **Exercise Practice**: Students can practice with generated exercises and get scored feedback
+    4. **Progress Tracking**: View student progress across submissions and exercises
+    
+    *Powered by advanced neural networks for grammar error detection and correction*
+    """)
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.15.0
+torch==2.1.0
+transformers==4.36.0
+nltk==3.8.1
+numpy==1.24.3
+sqlite3