rename and re-classification for reasoning operators (#112)

* rename reasoning doc ops

Author: scuuy

docs/en/notes/dev_guide/test.md

@@ -12,14 +12,18 @@ The test code’s implementation can refer to `DataFlow/test/test_reasoning.py`.
 
 ```python
 import pytest
-from dataflow.operators.generate import (
-    QuestionCategoryClassifier,
-    QuestionDifficultyClassifier,
-    QuestionGenerator,
-    AnswerGenerator,
+from dataflow.operators.reasoning import (
+    ReasoningQuestionCategorySampleEvaluator,
+    ReasoningQuestionDifficultySampleEvaluator,
+    ReasoningQuestionGenerator,
+    ReasoningAnswerGenerator,
+    ReasoningAnswerFormatterFilter,
+    ReasoningAnswerTokenLengthFilter,
+    ReasoningAnswerNgramFilter,
+    ReasoningAnswerGroundTruthFilter,
+    ReasoningAnswerPipelineRootFilter,
 )
 
-from dataflow.operators.filter import *
 from dataflow.utils.storage import FileStorage
 from dataflow.serving import APILLMServing_request, LocalModelLLMServing
 from dataflow.core import LLMServingABC
@@ -43,41 +47,41 @@ class ReasoningPipeline():
                 model_source="local"
             )
 
-        self.question_filter_step1 = QuestionFilter(
+        self.question_filter_step1 = ReasoningQuestionFilter(
             system_prompt="You are an expert in evaluating mathematical problems. Follow the user's instructions strictly and output your final judgment in the required JSON format.",
             llm_serving=llm_serving
         )
-        self.question_gen_step2 =  QuestionGenerator(
+        self.question_gen_step2 =  ReasoningQuestionGenerator(
             num_prompts=3,
             llm_serving=llm_serving
         )
-        self.question_filter_step3 = QuestionFilter(
+        self.question_filter_step3 = ReasoningQuestionFilter(
             system_prompt="You are an expert in evaluating mathematical problems. Follow the user's instructions strictly and output your final judgment in the required JSON format.",
             llm_serving=llm_serving
         )
-        self.question_difficulty_classifier_step4 = QuestionDifficultyClassifier(
+        self.question_difficulty_classifier_step4 = ReasoningQuestionDifficultySampleEvaluator(
             llm_serving=llm_serving
         )
-        self.question_category_classifier_step5 = QuestionCategoryClassifier(
+        self.question_category_classifier_step5 = ReasoningQuestionCategorySampleEvaluator(
             llm_serving=llm_serving
         )
         ########################## branch ############################
-        self.answer_pipeline_root_step6 = AnswerPipelineRoot()
+        self.answer_pipeline_root_step6 = ReasoningAnswerPipelineRootFilter()
         ########################## answer ############################
-        self.answer_generator_step7 = AnswerGenerator(
+        self.answer_generator_step7 = ReasoningAnswerGenerator(
             llm_serving=llm_serving
         )
 
-        self.answer_format_filter_step8 = AnswerFormatterFilter()
+        self.answer_format_filter_step8 = ReasoningAnswerFormatterFilter()
 
-        self.answer_token_length_filter_step9 = AnswerTokenLengthFilter(
+        self.answer_token_length_filter_step9 = ReasoningAnswerTokenLengthFilter(
             max_answer_token_length = 8192,
             tokenizer_dir = "Qwen/Qwen2.5-0.5B-Instruct"
         )
 
-        self.answer_groundtruth_filter_step10 = AnswerGroundTruthFilter()
+        self.answer_groundtruth_filter_step10 = ReasoningAnswerGroundTruthFilter()
 
-        self.answer_ngram_filter_step11 = AnswerNgramFilter(
+        self.answer_ngram_filter_step11 = ReasoningAnswerNgramFilter(
             min_score = 0.1,
             max_score = 1.0,
             ngrams = 5

docs/en/notes/guide/agent/DataFlow-AgentPipelineOrchestration.md

@@ -58,10 +58,10 @@ python test/test_dataflow_agent.py recommend
 The generated pipeline code (results may vary depending on the chosen model type and version) looks roughly like this:
 ```python
 import pytest
-from dataflow.operators.generate.Reasoning.QuestionGenerator import QuestionGenerator
-from dataflow.operators.process.Reasoning.QuestionFilter import QuestionFilter
-from dataflow.operators.generate.Reasoning.QuestionDifficultyClassifier import QuestionDifficultyClassifier
-from dataflow.operators.generate.Reasoning.QuestionCategoryClassifier import QuestionCategoryClassifier
+from dataflow.operators.generate.Reasoning.ReasoningQuestionGenerator import ReasoningQuestionGenerator
+from dataflow.operators.process.Reasoning.ReasoningQuestionFilter import ReasoningQuestionFilter
+from dataflow.operators.generate.Reasoning.ReasoningQuestionDifficultySampleEvaluator import ReasoningQuestionDifficultySampleEvaluator
+from dataflow.operators.generate.Reasoning.ReasoningQuestionCategorySampleEvaluator import ReasoningQuestionCategorySampleEvaluator
 from dataflow.utils.storage import FileStorage
 from dataflow.serving import APILLMServing_request, LocalModelLLMServing_vllm, LocalModelLLMServing_sglang
 
@@ -86,10 +86,10 @@ class RecommendPipeline():
             hf_local_dir="local",
         )
 
-        self.questiongenerator = QuestionGenerator(num_prompts=1, llm_serving=llm_serving)
-        self.questionfilter = QuestionFilter(system_prompt="You are a helpful assistant.", llm_serving=llm_serving)
-        self.questiondifficultyclassifier = QuestionDifficultyClassifier(llm_serving=llm_serving)
-        self.questioncategoryclassifier = QuestionCategoryClassifier(llm_serving=llm_serving)
+        self.questiongenerator = ReasoningQuestionGenerator(num_prompts=1, llm_serving=llm_serving)
+        self.questionfilter = ReasoningQuestionFilter(system_prompt="You are a helpful assistant.", llm_serving=llm_serving)
+        self.questiondifficultyclassifier = ReasoningQuestionDifficultySampleEvaluator(llm_serving=llm_serving)
+        self.questioncategoryclassifier = ReasoningQuestionCategorySampleEvaluator(llm_serving=llm_serving)
 
     def forward(self):
         self.questiongenerator.run(

docs/en/notes/guide/basicinfo/framework.md

@@ -27,11 +27,11 @@ For the augmentation, filtering, and scoring of large volumes of data with compl
 
 DataFlow operators are the basic processing units that execute on raw data, typically implemented based on rules, deep learning models, or large language models (LLMs). Taking the `Reasoning Pipeline` schematic diagram above as an example, each rectangular unit can be considered an independent DataFlow operator, used to complete specific data processing tasks (such as cleaning, transformation, validation, etc.).
 
-The code style of each operator in DataFlow is very concise. Below is an example of calling the `QuestionDifficultyClassifier` operator, which uses the large model backend to evaluate the difficulty level of questions:
+The code style of each operator in DataFlow is very concise. Below is an example of calling the `ReasoningQuestionDifficultySampleEvaluator` operator, which uses the large model backend to evaluate the difficulty level of questions:
 
 ```python
-from dataflow.operators.generate.Reasoning import QuestionDifficultyClassifier,
-question_difficulty_classifier = QuestionDifficultyClassifier(
+from dataflow.operators.generate.Reasoning import ReasoningQuestionDifficultySampleEvaluator,
+question_difficulty_classifier = ReasoningQuestionDifficultySampleEvaluator(
     llm_serving=llm_serving             # Pass in a large model LLMServing class as the backend
 )
 question_difficulty_classifier.run(