feat: more scoring model

.gitignore

@@ -0,0 +1,2 @@
+
+*.pyc

README.md

@@ -10,6 +10,8 @@ pinned: false
 license: mit
 preload_from_hub:
     - JacobLinCool/IELTS_essay_scoring_safetensors
+    - KevSun/Engessay_grading_ML
+    - chillies/mistral-7b-ielts-evaluator-q4
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,34 +1,24 @@
 from typing import *
 import gradio as gr
-import numpy as np
-import spaces
-import torch
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from model.IELTS_essay_scoring import grade_IELTS_essay_scoring
+from model.Engessay_grading_ML import grade_Engessay_grading_ML
 
-model_name = "JacobLinCool/IELTS_essay_scoring_safetensors"
-model = AutoModelForSequenceClassification.from_pretrained(model_name)
-tokenizer = AutoTokenizer.from_pretrained(model_name)
+models = {
+    "IELTS_essay_scoring": grade_IELTS_essay_scoring,
+    "Engessay_grading_ML": grade_Engessay_grading_ML,
+}
 
 
-@spaces.GPU
-def grade(question: str, answer: str) -> Tuple[float, float, float, float, float]:
+# we don't apply @spaces.GPU to here because some models work fast on CPU
+def grade(question: str, answer: str, model: str) -> Tuple[float, str]:
     if len(question) < 30 or len(answer) < 30:
         raise gr.Error("Please enter more than 30 characters")
 
-    text = f"{question} {answer}"
+    if model not in models:
+        raise gr.Error(f"Model {model} not found")
 
-    inputs = tokenizer(
-        text, return_tensors="pt", padding=True, truncation=True, max_length=512
-    )
-    with torch.no_grad():
-        outputs = model(**inputs)
-        predictions = outputs.logits.squeeze()
-
-    predicted_scores = predictions.numpy()
-    normalized_scores = (predicted_scores / predicted_scores.max()) * 9
-    rounded_scores = np.round(normalized_scores * 2) / 2
-
-    return tuple(rounded_scores)
+    grader = models[model]
+    return grader(question, answer)
 
 
 with gr.Blocks() as app:
@@ -46,18 +36,20 @@ with gr.Blocks() as app:
                 placeholder="Write your essay here",
                 lines=10,
             )
+            model = gr.Radio(
+                label="Select the grading model",
+                choices=list(models.keys()),
+                value=list(models.keys())[0],
+            )
             btn = gr.Button("Grade Essay", variant="primary")
         with gr.Column():
-            task_achievement = gr.Number(label="Task Achievement")
-            coherence_cohesion = gr.Number(label="Coherence and Cohesion")
-            vocabulary = gr.Number(label="Vocabulary")
-            grammar = gr.Number(label="Grammar")
-            overall = gr.Number(label="Overall")
+            overall = gr.Number(label="Overall Score")
+            comment = gr.Textbox(label="Comment", lines=10)
 
     btn.click(
         fn=grade,
-        inputs=[question, essay],
-        outputs=[task_achievement, coherence_cohesion, vocabulary, grammar, overall],
+        inputs=[question, essay, model],
+        outputs=[overall, comment],
     )
 
     gr.Examples(

model/Engessay_grading_ML.py

@@ -0,0 +1,37 @@
+from typing import *
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+model_name = "KevSun/Engessay_grading_ML"
+model = AutoModelForSequenceClassification.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+
+@torch.no_grad()
+def grade_Engessay_grading_ML(question: str, answer: str) -> Tuple[float, str]:
+    text = f"{question} {answer}"
+
+    inputs = tokenizer(text, return_tensors="pt")
+
+    outputs = model(**inputs)
+    predictions = outputs.logits.squeeze()
+
+    predicted_scores = predictions.numpy()
+    scaled_scores = 2.25 * predicted_scores - 1.25
+    rounded_scores = [round(score * 2) / 2 for score in scaled_scores]
+
+    labels = [
+        "cohesion",
+        "syntax",
+        "vocabulary",
+        "phraseology",
+        "grammar",
+        "conventions",
+    ]
+    overall_score = round(sum(rounded_scores) / len(rounded_scores) * 2) / 2
+
+    comment = ""
+    for label, score in zip(labels, rounded_scores):
+        comment += f"{label}: {score}\n"
+
+    return overall_score, comment

model/IELTS_essay_scoring.py

@@ -0,0 +1,39 @@
+from typing import *
+import torch
+import numpy as np
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+model_name = "JacobLinCool/IELTS_essay_scoring_safetensors"
+model = AutoModelForSequenceClassification.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+
+@torch.no_grad()
+def grade_IELTS_essay_scoring(question: str, answer: str) -> Tuple[float, str]:
+    text = f"{question} {answer}"
+
+    inputs = tokenizer(
+        text, return_tensors="pt", padding=True, truncation=True, max_length=512
+    )
+
+    outputs = model(**inputs)
+    predictions = outputs.logits.squeeze()
+
+    predicted_scores = predictions.numpy()
+    normalized_scores = (predicted_scores / predicted_scores.max()) * 9
+    rounded_scores = np.round(normalized_scores * 2) / 2
+
+    labels = [
+        "Task Achievement",
+        "Coherence and Cohesion",
+        "Vocabulary",
+        "Grammar",
+        "Overall",
+    ]
+    overall_score = float(rounded_scores[-1])
+
+    comment = ""
+    for label, score in zip(labels, rounded_scores):
+        comment += f"{label}: {score}\n"
+
+    return overall_score, comment