Add math

src/deepeval/base_task.py

@@ -71,6 +71,52 @@ class BaseTask(ABC):
         answer = self.tokenizer.decode(output[0][-1])
 
         return answer
+
+    def generate_response_oeqa_multi_token(self, msg, max_new_tokens=-1, choices: list = []):
+        """
+        Handles multiple-choice questions where answers might have multiple tokens.
+        """
+        # Ensure tokenizer has proper special tokens set
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        if self.model.config.pad_token_id is None:
+            self.model.config.pad_token_id = self.tokenizer.pad_token_id
+
+        chat = [
+                {"role": "user", "content": "You are a question-answering chatbot."},
+                {"role": "assistant", "content": "I am ready to answer your questions. Feel free to ask anything.\n"},
+                {"role": "user", "content": f"{msg}"},
+            ]
+        formatted_chat = self.tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
+        print(formatted_chat)
+        inputs = self.tokenizer(formatted_chat, return_tensors="pt", padding=True, truncation=True)
+        input_ids = inputs.input_ids.to(self.model.device)
+        attention_mask = inputs.attention_mask.to(self.model.device)
+
+        # Custom LogitsProcessor to restrict generation
+        class RestrictToABCDLogitsProcessor(LogitsProcessor):
+            def __call__(self, input_ids, scores):
+                mask = torch.full_like(scores, float("-inf"))  # Block all tokens
+                return mask
+        logits_processor = LogitsProcessorList([RestrictToABCDLogitsProcessor()])
+
+        # Generate response
+        output = self.model.generate(
+            input_ids,
+            do_sample=True,
+            attention_mask=attention_mask,
+            #max_new_tokens=max_new_tokens,
+            eos_token_id=self.tokenizer.eos_token_id,
+            pad_token_id=self.tokenizer.pad_token_id,
+            temperature=0.4,
+            #logits_processor=logits_processor,
+        )
+        generated_ids = output[0]  # The generated sequence including the prompt
+        generated_tokens = generated_ids[len(input_ids[0]):]  # Exclude the input_ids part
+        generated_text = self.tokenizer.decode(generated_tokens, skip_special_tokens=True)
+        return generated_text
+
     
     def generate_response_mcqa_multi_token(self, msg, max_new_tokens=5, choices: list = []):
         """

src/deepeval/deepeval_task_manager.py

@@ -13,6 +13,7 @@ from src.deepeval.reading_comprehension_task import ReadingComprehensionTask
 from src.deepeval.reading_comp_mc import ReadingComprehensionMCTask
 from src.deepeval.complex_reasoning import ComplexReasoningTask
 from src.deepeval.nli import NLITask
+from src.deepeval.math import MathTask
 from typing import List
 load_dotenv()
 
@@ -37,6 +38,7 @@ class Task(Enum):
     READING_COMPREHENSION_MC = "reading_comprehension_mc"
     COMPLEX_REASONING = "complex_reasoning"
     NLI = "nli"
+    MATH = "math"
 
 
 class DeepEvalTaskManager:
@@ -121,7 +123,12 @@ class DeepEvalTaskManager:
         res = nli_task.evaluate()
         return res
 
+    def math(self):
+        math_task = MathTask(self.model_name)
+        res = math_task.evaluate()
+        return res
+
 if __name__ == "__main__":
-    des = DeepEvalTaskManager("meta-llama/Llama-3.2-1B-Instruct", ["COMPLEX_REASONING","NLI"])
+    des = DeepEvalTaskManager("google/gemma", ["MATH"])
     res = des.run_tasks()
     print(res)

src/deepeval/math.py

@@ -0,0 +1,82 @@
+from src.deepeval.base_task import BaseTask
+from collections import defaultdict
+from src.deepeval.utils import accuracy, accuracy_standard_error
+from typing import Any
+import re
+
+class MathTask(BaseTask):
+    def __init__(self, model_name):
+        super().__init__("metunlp/math_tr", model_name=model_name)
+
+    def load_dataset_from_hf(self):
+        dataset = super().load_dataset_from_hf()
+        return dataset.select(range(min(10, len(dataset))))
+
+
+    def evaluate(self) -> dict[str, Any]:
+        responses = []
+        difficulty_results = defaultdict(lambda: {'correct': 0, 'total': 0})
+        total_count = 0
+        true = 0
+
+        for row in self.dataset:
+            total_count += 1
+
+            # Get values from row
+            category = str(row["difficulty"])
+            answer = row["final_answer"]
+
+            # Prints for debugging
+            print(f"Answer: {answer}")
+            print("Type of answer:", type(answer))
+
+            # Construct the prompt/message
+            instruction = f"""Aşağıdaki matematik problemini verilen nihai cevap formatına uygun olacak şekilde çözün. Tüm adımları gösterdikten sonra, nihai cevabınızı sadece bir kez ve aşağıdaki kurallara uygun şekilde kutu içinde verin.
+
+Nihai Cevap için Uyulması Gereken Format Kuralları:
+
+1. Nihai cevap, tek seferde \\boxed{{...}} içinde verilmeli. Örnek: Cevap 1 ise, "\\boxed{{1}}".
+2. Kesirleri her zaman en sade halde verilmeli.
+    - Matris içi kesirler: x/y biçiminde.
+    - Diğer tüm kesirler: \\frac{{x}}{{y}} biçiminde.
+3. Çarpma işareti (*) kullanmayın. Örnek: 2x yazın, 2**x* değil.
+4. Birden çok değişken varsa alfabetik sıraya uyulmalı ve (x, y, z...), polinomları azalan derece sırasına göre yazılmalı.
+5. Her zaman aynı gösterim biçimi kullanılmalı. Ondalık yerine kesir kullanılmalı (ör. 0.5 yerine \\frac{{1}}{{2}} ).
+6. Faktörize polinomlar daima aynı faktör sırası ile verilsin; her sorguda aynı cevabı verecek şekilde tutarlılığı koruyun.
+7. Nihai cevabı kutu dışında tekrar etmeyin, biçimi değiştirmeyin. Aynı soru tekrarlandığında aynı formatı ve cevabı verin.
+
+Görev: Problemi çözün, son adımda yukarıdaki kurallara tam uyan tek bir kutu içinde nihai cevabı verin.
+
+            """
+            prompt = f"{instruction}\n\nSoru:\n{row["question"]}\n"
+            message = prompt
+
+            # Get/format answer of the model
+            model_answer = self.generate_response_oeqa_multi_token(message)
+            responses.append(model_answer)
+            model_answer_cleaned = re.search(r"\\boxed{([^}]*)}", model_answer)
+
+            # Print answers
+            print(f"Correct Answer: {answer}")
+            print(f"Model Answer: {model_answer}")
+            print(f"Model Answer Cleaned: {model_answer_cleaned}")
+            print(f"Result: {answer == model_answer_cleaned}")
+
+            # Check if correct based on metric
+            if answer == model_answer_cleaned:
+                true += 1
+                difficulty_results[category]['correct'] += 1
+
+            difficulty_results[category]['total'] += 1
+
+        # Print results categorized by difficulty
+        for category, stats in difficulty_results.items():
+            calculatedAccuracy = stats['correct'] / stats['total'] if stats['total'] > 0 else 0
+            print(f"{category.capitalize()} Accuracy: {calculatedAccuracy:.2%} ({stats['correct']}/{stats['total']})")
+
+        print("Results:", responses)
+        print("Overall Accuracy:", true / total_count)
+        acc = accuracy(true, total_count)
+        acc_stderr = accuracy_standard_error(acc, total_count)
+        return {"acc": acc, "acc_stderr": acc_stderr}
+

src/deepeval/nli.py

@@ -41,11 +41,11 @@ class NLITask(BaseTask):
             instruction = ""
             question = "Yukarıdaki cümleler arasındaki ilişki “entailment” (bir cümle diğerini ima eder), “neutral (cümleler birbirini ima etmez ve çelişmez) veya “contradiction (cümleler birbirleriyle çelişir) olarak karakterize edilebilir. Bu ilişkilerden hangisi olduğunu söyleyin."
             context = f"Bağlam:\n{row["text"]}\n" # can add to prompt if needed
-            prompt = f"Cümle1:\n{row["premise"]}\nCümle2:{row["hypothesis"]}\nSoru:\n{question}\nSeçenekler:\n{formatted_choices}\n{instruction}\n"
+            prompt = f"Cümle1: {row["premise"]}\nCümle2: {row["hypothesis"]}\nSoru:\n{question}\nSeçenekler:\n{formatted_choices}\n{instruction}\n"
             message = prompt
 
             # Get/format answer of the model
-            model_answer = self.generate_response_mcqa_multi_token(message, choices=choices, max_new_tokens=10)
+            model_answer = self.generate_response_mcqa_multi_token(message, choices=choices, max_new_tokens=2)
             responses.append(model_answer)
             model_answer_cleaned = model_answer.strip().replace('\n', '').replace(' ', '').upper()
 

src/deepeval/reading_comp_mc.py

@@ -56,6 +56,7 @@ class ReadingComprehensionMCTask(BaseTask):
             print(f"Correct Answer: {correct_answer_letter}")
             print(f"Model Answer: {model_answer}")
             print(f"Model Answer Cleaned: {model_answer_cleaned}")
+            print(f"Result: {correct_answer_letter == model_answer_cleaned}")
 
             # Check if correct based on metric
             if correct_answer_letter == model_answer_cleaned:

src/deepeval/turkish_general_knowledge_task.py

@@ -9,7 +9,7 @@ class TurkishGeneralKnowledgeTask(BaseTask):
 
     def load_dataset_from_hf(self):
         dataset = super().load_dataset_from_hf()
-        return dataset.select(range(min(1, len(dataset))))
+        return dataset.select(range(min(10, len(dataset))))
 
     def evaluate(self):
         responses = []