Add files using upload-large-folder tool

.gitattributes

@@ -69,3 +69,9 @@ deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_4_tagged.jso
 deep_search/data_from_zhiyuan/data_for_dpo/3k_question/17w_select_3k_for_dpo.json filter=lfs diff=lfs merge=lfs -text
 deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_6_tagged.json filter=lfs diff=lfs merge=lfs -text
 deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_7_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_for_rl/tagged_domain_keypoints/final_selected_dataset.json filter=lfs diff=lfs merge=lfs -text
+building_env/Miniforge3-Linux-x86_64.sh filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_5_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_1_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_2_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_for_rl/musique_tagged/musique_tagged_domain_keypoints_keywords_count.json filter=lfs diff=lfs merge=lfs -text

building_env/Miniforge3-Linux-x86_64.sh

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65af53dad30b3fcbd1cb1d4ad62fd3a86221464754844544558aae3a28795189
+size 90308175

deep_search/data_from_zhiyuan/data_for_rl/musique_tagged/musique_tagged_domain_keypoints_keywords_count.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98754d32877af32e04b050fafef05bda60f7dd2e7513caf607e15a4fcc833a72
+size 159283950

deep_search/data_from_zhiyuan/data_for_rl/tagged_domain_keypoints/final_selected_dataset.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23cb3c0f16fbb734d9338644898227c47d9678da154825ee3786f2349e4cf53b
+size 64168759

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_1_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0834d4f6529c8f33bcc498195fe2771b31df81b420c552bd755b8dfc06c25da5
+size 28838337

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_2_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e323cd5c9b0885883e9a09dcd3b61d334ad1f0450b2cc9706c1fdd094f9022b4
+size 21198229

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_5_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58f334da8ae27fc0168eb4a01c8a3a2c5389b9fa1896cbab76a2a85a85167ccf
+size 27511469

deep_search/search_o1/scripts/0_gen_google_plus_inst_summary_sft.py

@@ -0,0 +1,621 @@
+import os
+import argparse
+import torch.distributed as dist
+import json
+from vllm import LLM, SamplingParams
+from datasets import Dataset
+from transformers import AutoTokenizer
+import torch.multiprocessing as mp
+from openai import OpenAI
+import sys
+import os
+import re
+from datasets import load_dataset
+import http.client
+import os
+from openai import OpenAI
+import sys
+import os
+from datasets import load_dataset
+import http.client
+import json
+from tqdm import tqdm
+import multiprocessing
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import requests
+import json
+from collections import defaultdict
+import random
+import json
+import requests
+import time
+import re
+import concurrent.futures
+from bs4 import BeautifulSoup
+# import wikipediaapi
+import wikipedia
+from urllib.parse import unquote
+from urllib.parse import urlparse
+
+import json
+import requests
+import time
+from requests.exceptions import Timeout
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+import time
+import concurrent
+from concurrent.futures import ThreadPoolExecutor
+import pdfplumber
+from io import BytesIO
+import re
+import string
+from typing import Optional, Tuple
+from nltk.tokenize import sent_tokenize
+import json
+import copy
+from tqdm import tqdm
+import multiprocessing
+from time import sleep
+import requests
+from collections import defaultdict
+import random
+import requests
+import time
+# import wikipediaapi
+import wikipedia
+from urllib.parse import unquote
+from urllib.parse import urlparse
+# CUDA_VISIBLE_DEVICES=5
+import os
+import json
+import requests
+from requests.exceptions import Timeout
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+import time
+import concurrent
+from concurrent.futures import ThreadPoolExecutor
+import pdfplumber
+from io import BytesIO
+import re
+import string
+from typing import Optional, Tuple
+from nltk.tokenize import sent_tokenize
+from bs4 import BeautifulSoup
+# import wikipediaapi
+
+
+import re
+from time import sleep
+from openai import OpenAI
+import requests
+import json
+import multiprocessing
+from collections import defaultdict
+from tqdm import tqdm
+
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+                  'AppleWebKit/537.36 (KHTML, like Gecko) '
+                  'Chrome/58.0.3029.110 Safari/537.36',
+    'Referer': 'https://www.google.com/',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.5',
+    'Connection': 'keep-alive',
+    'Upgrade-Insecure-Requests': '1'
+}
+
+summary_prompt="""**Task Instruction:**
+
+You are tasked with reading and analyzing web pages based on the following inputs: **Previous Reasoning Path**, **Current Search Query**, and **Searched Web Pages**. 
+Your objective is to extract relevant and helpful information for **Current Search Query** from the **Searched Web Pages** and seamlessly integrate this information into the **Previous Reasoning Path** to continue reasoning for the original question.
+
+**Guidelines:**
+
+1. **Analyze the Searched Web Pages:**
+- Carefully review the content of each searched web page.
+- Identify factual information that is relevant to the **Current Search Query** and can aid in the reasoning process for the original question.
+
+2. **Extract Relevant Information:**
+- Select the information from the Searched Web Pages that directly contributes to advancing the **Previous Reasoning Path**.
+- Ensure that the extracted information is accurate and relevant.
+
+3. **Output Format:**
+- Present the helpful information for current search query: beginning with `**Final Information**` as shown below.
+**Final Information**
+[Helpful information]
+
+Now you should analyze the web pages and find helpful information based on the current search query and previous reasoning path.
+
+**Inputs:**
+- **Previous Reasoning Path:**  
+{prev_reasoning}
+
+- **Current Search Query:**  
+{search_query}
+
+- **Searched Web Pages:**  
+{document}
+"""
+
+summary_prompt_old='''## Task Description:
+Given the search query and the content of the searched webpage.
+Your task is to extract information from the webpage content that is relevant and helpful to the search query and return a summary paragraph.
+
+## **Guidelines**:
+(1) The extracted content should be relevant and helpful to the query.
+(2) The form of the extracted content **must be a summary paragraph** rather than a direct answer to the query.
+(3) You **must extract content according to this webpage**. If the webpage content is unrelated to the query, no extraction is required.
+
+## Output Format:
+[Exacted Content]: If the webpage content contains information related to the query, output the relevant summary paragraph (not a direct answer to the query); if not, output "None".
+
+## Inputs:
+[Search Query]
+{search_query}
+
+[Webpage Content]
+{document}
+
+## Output:
+[Exacted Content]
+'''
+proxies = {
+                "http": "http://127.0.0.1:7895",
+                "https": "http://127.0.0.1:7895",
+            }
+# Initialize session
+session = requests.Session()
+session.headers.update(headers)
+session.proxies.update(proxies)
+wikipedia.set_lang('en')  # 这里设置为你需要的语言
+wikipedia._http = session  # 替换为自定义的 session
+
+os.environ["OPENAI_API_KEY"] = "sk-3alq0hqR4hFlXMuyOY07rvQqSF52UJ09CsHHXyrW72yPcw8l"
+os.environ["OPENAI_API_BASE"] = "https://open.xiaojingai.com/v1"
+client = OpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY"),
+    base_url=os.environ.get("OPENAI_API_BASE")
+)
+
+def extract_text_from_url(url, use_jina=False, jina_api_key=None, snippet: Optional[str] = None):
+
+    try:
+        if "wikipedia.org" in url:
+            wiki_200=0
+            for u in range(5):
+                try:
+                    print(url)
+                    # print(unquote(url.split('/')[-1]))
+                    page_title = unquote(url.split('/')[-1])
+                    # print("000")
+                    page = wikipedia.page(page_title, auto_suggest=False)
+                    # print("111")
+                    text = page.content
+                    text = text.replace('\n\n', '\n')
+                    search_doc = text.split('== References ==')[0].split("== Notes ==")[0].strip()
+                    wiki_200=1
+                    # print("222")
+                    return search_doc
+                except:
+                    time.sleep(2)
+                    continue
+            if wiki_200==0:
+                search_doc = "None"
+                print("无法访问该页面，url:",url)
+                return search_doc
+        else:
+            flag_200=0
+            for t in range(3):
+                try:
+                    response = session.get(url)
+                    if response.status_code == 200:
+                        soup = BeautifulSoup(response.text,'lxml')
+                        text_before_summary = soup.get_text(separator='\n', strip=True)
+                        lines_before_summary=text_before_summary.split("\n")
+                        search_doc=" ".join(line for line in lines_before_summary if len(line.split())>=0)
+                        flag_200=1
+                        return search_doc
+                except:
+                    sleep(2)
+                    continue
+
+            if flag_200==0:
+                search_doc = "None"
+                print("无法访问该页面，：", "url:",url)
+                return search_doc
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return "None"
+        
+
+
+def bing_web_search(query, subscription_key, endpoint, market='en-US', language='en', timeout=20):
+
+    payload = json.dumps({
+        "q": query,  # 设置查询内容
+        "mkt": market,  # 设置市场
+        "setLang": language,  # 设置语言
+        "textDecorations": True,  # 启用文本装饰
+        "textFormat": "HTML"  # 设置文本格式
+    })
+
+    headers = {
+        'X-API-KEY': subscription_key,
+        'Content-Type': 'application/json'
+    }
+
+    try:
+        # 发送POST请求
+        response = requests.request("POST", endpoint, headers=headers, data=payload)
+        response.raise_for_status()  # Raise exception if the request failed 检查响应的状态码。如果返回的状态码是 4xx 或 5xx（表示客户端或服务器错误），它将引发 requests.exceptions.HTTPError 异常
+        search_results = response.json() #
+        return search_results
+    except Timeout:
+        print(f"Bing Web Search request timed out ({timeout} seconds) for query: {query}")
+        return {}  # Or you can choose to raise an exception
+    except requests.exceptions.RequestException as e:
+        print(f"Error occurred during Bing Web Search request: {e}")
+        return {}
+
+
+
+def extract_relevant_info(search_results):
+
+    useful_info = []
+    
+    if 'organic' in search_results : # value 通常是一个列表，包含了搜索结果的每个页面信息
+        for id, result in enumerate(search_results['organic']):
+            # if "wikipedia.org" not in result.get('link', ''):
+            #     continue
+            info = {
+                'title': result.get('title', ''), # 每个搜索结果中提取标题
+                'url': result.get('link', ''), # 每个搜索结果中提取 URL
+            }
+            useful_info.append(info)
+    
+    return useful_info
+
+def generate(messages, model_name):
+    response = client.chat.completions.create(
+        **{
+            "model": model_name,
+            "messages": messages,
+            "max_tokens": 2048,
+        }
+    )
+    response = response.choices[0].message.content
+    return response
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--subject", type=str, default="")
+    parser.add_argument("--start_sample", type=int, default=-1)
+    parser.add_argument("--end_sample", type=int, default=100000)
+    parser.add_argument("--max_samples", type=int, default=0)
+    parser.add_argument("--src_file", type=str, default="None")
+    parser.add_argument("--gpu_id", type=str, default="0")
+    parser.add_argument("--model_path", type=str, default="None")
+    parser.add_argument("--gpu_memory_rate", type=float, default=0.95)
+    parser.add_argument("--port", type=str, default="None")
+    parser.add_argument("--temp", type=float, default=0.0)
+    parser.add_argument("--prompt_type", type=str, default="None")
+    parser.add_argument("--tp_num", type=int, default=1)
+    parser.add_argument("--chunk_size", type=int, default=25)
+    return parser.parse_args()
+
+def process_text(examples,tokenizer,type=None):
+    question = examples["Question"]
+
+
+    if type=="v3":
+        messages_chat=[
+                {"role": "system","content": """You are a helpful assistant. 
+Given a question, you should answer it by first thinking about the reasoning process in the mind and then providing the final answer. 
+The output format of reasoning process and final answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., "<think> reasoning process here </think>\n\n<answer> final answer here </answer>". 
+During the thinking process, **you can perform searching for uncertain knowledge** if necessary with the format of "<|begin_search_query|> search query <|end_search_query|>". **A query must involve only a single triple**.
+Then, the search system will provide you with the retrieval information with the format of "<|begin_search_result|> ...search results... <|end_search_result|>"."""},
+                {"role": "user", "content":question}
+            ]
+
+    elif type=="v0":
+        messages_chat=[
+                {"role": "system","content": """You are a helpful assistant. Given a question, you should answer it by first thinking about the reasoning process in the mind and then providing the final answer. The output format of reasoning process and final answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., "<think> reasoning process here </think>\n\n<answer> final answer here </answer>". During the thinking process, **you can perform searching for uncertain knowledge** if necessary with the format of "<|begin_search_query|> search query (only keywords) here <|end_search_query|>". Then, the search system will provide you with the retrieval information with the format of "<|begin_search_result|> ...search results... <|end_search_result|>"."""},
+                {"role": "user", "content":question}
+            ]
+    elif type=="v2":
+        messages_chat=[
+                {"role": "system","content": """You are a helpful assistant. Given a **Judgement question**, you should answer it by first thinking about the reasoning process in the mind and then providing the final answer. The output format of reasoning process and final answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., "<think> reasoning process here </think>\n\n<answer> final answer here (yes or no)</answer>". During the thinking process, **you can perform searching for uncertain knowledge** if necessary with the format of "<|begin_search_query|> search query (only keywords) here <|end_search_query|>". Then, the search system will provide you with the retrieval information with the format of "<|begin_search_result|> ...search results... <|end_search_result|>". The final answer **must be yes or no**."""},
+                {"role": "user", "content":question}
+            ]
+    elif type=="sft_v2":
+        messages_chat=[
+            {"role": "system","content": """You are a reasoning assistant with the ability to perform web searches to help you answer the user's question accurately. You have special tools:
+
+- To perform a search: write <|begin_search_query|>  your query here <|end_search_query|> .
+Then, the system will search and analyze relevant web pages, then provide you with helpful information in the format <|begin_search_result|> ...search results... <|end_search_result|>.
+
+Whenever you encounter a topic, fact, or piece of information you are uncertain about or need further details on, please perform a search to gather more accurate, up-to-date, or specific information. You can repeat the search process multiple times if necessary.
+
+Once you have all the information you need, continue your reasoning.
+
+Remember:
+- Use <|begin_search_query|> to request a web search and end with <|end_search_query|>.
+- When done searching, continue your reasoning.
+- Do not generate <|begin_search_result|> and <|end_search_result|> tags yourself.
+
+Please answer the following question. You should provide your final answer in the format \\boxed{YOUR_ANSWER}.
+"""},
+            {"role": "user", "content":"Question:\n"+question}
+        ]
+    elif type=="sft_v3":
+        messages_chat=[
+            {"role": "user","content": """You are a reasoning assistant with the ability to perform web searches to help you answer the user's question accurately. You have special tools:
+
+- To perform a search: write <|begin_search_query|>  your query here <|end_search_query|> .
+Then, the system will search and analyze relevant web pages, then provide you with helpful information in the format <|begin_search_result|> ...search results... <|end_search_result|>.
+
+Whenever you encounter a topic, fact, or piece of information you are uncertain about or need further details on, please perform a search to gather more accurate, up-to-date, or specific information. You can repeat the search process multiple times if necessary.
+
+Once you have all the information you need, continue your reasoning.
+
+Remember:
+- Use <|begin_search_query|> to request a web search and end with <|end_search_query|>.
+- When done searching, continue your reasoning.
+- Do not generate <|begin_search_result|> and <|end_search_result|> tags yourself.
+
+Please answer the following question. You should provide your final answer in the format \\boxed{YOUR_ANSWER}.\n\nQuestion:"""+question},
+        ]
+    else:
+        kill
+
+
+    chat_prompt = tokenizer.apply_chat_template(
+                    messages_chat,
+                    tokenize=False,
+                    add_generation_prompt=True
+                )
+    examples["chat_prompt"] = chat_prompt + "<think>"
+    return examples
+
+def process_output(output, continued_answer, k):
+    prompt = output.prompt
+    answer = continued_answer["answer"]
+    quesiton = continued_answer["Question"]
+    gen_text_store = continued_answer["gen_text_store"]
+    stop_reason = output.outputs[0].stop_reason
+    generated_text = output.outputs[0].text
+    # print(generated_text)
+    # print("=="*30)
+
+    # Return 'finished' or 'continued' along with the corresponding data
+    if k == 9:  # 检索次数太多了，直接停掉，就是未完成
+        original_data = {
+            "Question": quesiton,
+            "answer": answer,
+            "generated_text": generated_text,
+            "stop_reason_final": "many_retrieve",
+            "pred_ans": "I don't know."
+        }
+        return original_data, "finished"
+
+    if "boxed" in generated_text:
+        lines = generated_text.split("\n")
+        proposed_ans = "I don't know."
+        for k, line in enumerate(reversed(lines)):
+            if "boxed{" in line:
+                proposed_ans_ori = line
+                pattern = r"\\boxed\{(.+?)\}"
+                match = re.search(pattern, proposed_ans_ori)
+                if match:
+                    proposed_ans = match.group(1)  # 提取括号中的内容
+                else:
+                    proposed_ans = "I don't know."
+        original_data = {
+            "Question": quesiton,
+            "answer": answer,
+            "pred_ans": proposed_ans,
+            "stop_reason_final": "finished",
+            "gen_text_store": gen_text_store + generated_text ,
+        }
+        return original_data, "finished"
+
+    elif "<|begin_search_query|>" in generated_text and stop_reason == "<|end_search_query|>":  # 这里处理retrieve
+        query = generated_text.split("<|begin_search_query|>")[-1].split("<|end_search_query|>")[0]
+        query = query.replace('"', "").replace("'", "").replace("\t", " ").replace("...", "")
+
+        if query:
+            # Reuse search and info extraction logic
+            BING_SUBSCRIPTION_KEY = "cb0d28279a826d7e5cf22d71f683c77ffd4ba27d"
+            bing_endpoint = "https://google.serper.dev/search"
+            # search_results = bing_web_search(query + " site:en.wikipedia.org", BING_SUBSCRIPTION_KEY, bing_endpoint)
+            search_results = bing_web_search(query, BING_SUBSCRIPTION_KEY, bing_endpoint)
+            
+            extracted_info_ori = extract_relevant_info(search_results)
+            # print(extracted_info_ori)
+            # print(len(extracted_info_ori))
+            # # kill
+
+            extracted_info = [
+                        e for e in extracted_info_ori 
+                        if not any(ext in e["url"].lower() for ext in [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".mp4", ".mp3", ".wav", ".avi", ".mov", ".zip", ".pdf"])
+                    ]
+            doc_content = "None"
+            combined_text = ""
+            for info in extracted_info[:10]:
+                print("Begin Get Full Page")
+                full_text = extract_text_from_url(info['url'])
+                print("End Get Full Page")
+                combined_text += full_text[:10000] + "\n\n"
+            query_summary = query
+            prev_reasoning = gen_text_store + generated_text.strip() + "<|end_search_query|>"
+            # print("=="*30)
+            # print(prev_reasoning)
+            # print("=="*30)
+            
+            summary_for_gpt = summary_prompt.replace("{search_query}", query_summary).replace("{document}", combined_text).replace("{prev_reasoning}", prev_reasoning)
+            # print("=="*30)
+            # print(summary_for_gpt)
+            messages_summary = [{'role': 'user', 'content': summary_for_gpt}]
+            for y in range(10):
+                try:
+                    model_output_summary = generate(messages_summary, 'gpt-4o-mini')
+                    break
+                except:
+                    continue
+            try:
+                summary_doc = model_output_summary.split("**Final Information**")[-1]
+            except Exception as e:
+                print(f"An error occurred: {e}")
+                summary_doc  = "None"
+
+            doc_content = summary_doc.lstrip(":").strip()
+            
+            original_data = {
+                "chat_prompt": prompt + generated_text.strip() + "<|end_search_query|>\n\n" + "<|begin_search_result|>\n" + doc_content + "\n<|end_search_result|>\n\n",
+                "answer": answer,
+                "Question": quesiton,
+                "stop_reason": stop_reason,
+                "gen_text_store": gen_text_store + generated_text.strip() + "<|end_search_query|>\n\n" + "<|begin_search_result|>\n" + doc_content + "\n<|end_search_result|>\n\n",
+            }
+            return original_data, "continued"
+        else:
+            original_data = {
+                "Question": quesiton,
+                "answer": answer,
+                "gen_text_store": gen_text_store + generated_text.strip(),
+                "generated_text": generated_text,
+                "stop_reason_final": "query_inst_error",
+                "pred_ans": "I don't know."
+            }
+            return original_data, "finished"
+
+    else:
+        original_data = {
+            "Question": quesiton,
+            "answer": answer,
+            "stop_reason_final": "shot_down",
+            "pred_ans": "I don't know.",
+            "gen_text_store": gen_text_store + generated_text.strip(),
+        }
+        return original_data, "finished"
+
+def main():
+    print("=Begin="*10)
+    args = parse_args()
+    gpu_id = args.gpu_id
+    os.environ["CUDA_VISIBLE_DEVICES"] = gpu_id
+    temp=args.temp
+    port=args.port
+    type=args.prompt_type
+    model_path=args.model_path
+    tp_num = args.tp_num
+    gpu_memory_rate=args.gpu_memory_rate
+    chunk_size_own= args.chunk_size
+
+    data_ori_all = []
+    with open(args.src_file, "r") as f:
+        data_ori_all = []
+        for i, line in enumerate(f):
+            if args.start_sample <= i < args.end_sample:
+                obj_ori=json.loads(line)
+                data_ori_all.append(obj_ori)
+            if i >= args.end_sample - 1:
+                break
+
+    print("All Data Length: ",len(data_ori_all))
+    chunk_size = chunk_size_own
+    chunk_num = len(data_ori_all) // chunk_size
+    if len(data_ori_all) % chunk_size != 0:
+        chunk_num += 1
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    llm = LLM(model=model_path, tensor_parallel_size=tp_num, gpu_memory_utilization=gpu_memory_rate, trust_remote_code=True)
+
+    for h in range(chunk_num):
+        print("=="*80)
+        print("Begin Chunk: ",h,"All: ",chunk_num)
+        data_ori = data_ori_all[h*chunk_size:(h+1)*chunk_size]
+        data=[]
+
+        for i in range(len(data_ori)):
+            for j in range(1):
+                data.append(data_ori[i])
+
+        data_keys = data[0].keys()
+        data_keys = ["Question" , "answer"]
+        ds = Dataset.from_dict({key: [d[key] for d in data] for key in data_keys})
+        print(len(ds))
+        ds = ds.map(
+            process_text,
+            num_proc=16,
+            fn_kwargs={"tokenizer": tokenizer,"type":type},
+        )
+        print(ds)
+
+        stop_tokens = ["<|im_end|>", "<|endoftext|>", "<|end_search_query|>", "</answer>"]
+        sampling_params = SamplingParams(temperature=temp, top_p=0.95, max_tokens=2048, stop=stop_tokens)
+
+        finished_all_list=[]
+
+        continued_answer = copy.deepcopy(data)
+
+        for k in range(10):
+
+            if len(ds) ==0:
+                print("请确定是不是真的ok了")
+                print(len(ds))
+                break
+
+            outputs = llm.generate(ds['chat_prompt'], sampling_params)
+
+            finished_texts = []
+            continued_texts = []
+            with ThreadPoolExecutor() as executor:
+                futures = []
+                for i, output in enumerate(outputs):
+                    futures.append(executor.submit(process_output, output, continued_answer[i], k))
+
+                for future in as_completed(futures):
+                    obj, label = future.result()
+                    if label == "finished":
+                        finished_texts.append(obj)
+                    elif label == "continued":
+                        continued_texts.append(obj)
+           
+            finished_all_list.extend(finished_texts)
+
+            if len(continued_texts)==0:
+                if len(finished_texts)>0:
+                    with open(args.src_file.replace(".jsonl","-"+model_path.split("/")[-2]+model_path.split("/")[-1]+f"_base_temp{args.temp}_type{type}_online.jsonl"), "a") as f:
+                        for text in finished_texts:
+                            f.write(json.dumps(text) + "\n")
+
+                break
+            else:
+                data_keys_again = continued_texts[0].keys()
+                ds = Dataset.from_dict({key: [d[key] for d in continued_texts] for key in data_keys_again})
+                continued_answer = copy.deepcopy(continued_texts)
+            print("=="*80)
+            print("Epoch: ",k,"New_Finished: ",len(finished_texts),"All_Finished ",len(finished_all_list),"Continued: ",len(continued_texts))
+
+            print("Begin Writing Epoch: ",k)
+
+            # print(continued_texts)
+            print("=="*80)
+            # print(finished_texts)
+            if len(finished_texts)>0:
+                with open(args.src_file.replace(".jsonl","-"+model_path.split("/")[-2]+model_path.split("/")[-1]+f"_base_temp{args.temp}_type{type}_online.jsonl"), "a") as f:
+                    for text in finished_texts:
+                        f.write(json.dumps(text) + "\n")
+
+    if dist.is_initialized():
+            dist.destroy_process_group()
+if __name__ == "__main__":
+    # mp.set_start_method("spawn", force=True)
+    main()
+
+# python /opt/aps/workdir/sht-RAG_RL/eval/gen_ckpt_solution_base.py --src_file /opt/aps/workdir/sht-RAG_RL/eval/datasets/hotpotqa.jsonl --model_path /opt/aps/workdir/sht-RAG_RL/results/ckpts/qwen2.5-7B-base-rm3-sft-data-2-grpo-dataset_hpqa-len_29000-tbs_64-rbs_16-sample_16-kl_0.0001-warmup_0.0-ep_10000-plr_2e-6-temp1.0-30k/ckpt --gpu_id 0 
+

deep_search/search_o1/scripts/SimpleDeepSearcher/README.md

@@ -0,0 +1,145 @@
+
+# SimpleDeepSearcher: Deep Information Seeking via Web-Powered Reasoning Trajectory Synthesis
+
+
+## 🚀 Data Synthesis in Real Web Environment
+
+### 1. Launch the Summary Model
+
+```bash
+export CUDA_VISIBLE_DEVICES=0,1
+vllm serve "YOUR_SUMMARY_MODEL_PATH" \
+    --tensor-parallel-size=2 \
+    --gpu-memory-utilization 0.95 \
+    --port 8001 > inference/output/vllm_serve.log 2>&1 &
+```
+
+---
+
+### 2. Generate Inference Search Trajectories
+
+```bash
+export CUDA_VISIBLE_DEVICES=0,1
+python -u inference/inference.py \
+    --dataset_name bamboogle \
+    --cache_dir_base cache \
+    --output_dir_base inference/output \
+    --max_search_limit 10 \
+    --max_turn 10 \
+    --top_k 10 \
+    --max_doc_len 5000 \
+    --model_path "REASON_MODEL_PATH" \
+    --summary_model_path "SUMMARY_MODEL_PARH" \
+    --base_url "http://localhost:8001/v1" \
+    --google_subscription_key "YOUR_KEY" \
+    --google_endpoint "https://google.serper.dev/search" > inference/output/output.log 2>&1
+```
+
+---
+
+## 🎯 Data Construction
+
+### 🔍 Query Sampling
+
+#### 1. Annotate Domains and Keywords of Labeled Data
+
+```bash
+python process_data/query_sampling/data_tag_domain_keypoints.py \
+  --input_file_path "/path/to/your/input.json" \
+  --cuda_visible_devices "0,1" \
+  --model_path "/path/to/your/tag_model"
+```
+
+#### 2. Extract Domains and Keywords
+
+
+```bash
+python process_data/query_sampling/extract_domain_keypoints.py \
+  --input_file_path "/path/to/your/input_tagged.json" \
+  --output_file_path "/path/to/your/output_extracted.json"
+```
+
+#### 3. Count Number of Units
+
+```bash
+python process_data/query_sampling/units_count.py \
+  --input_file "/path/to/your/output_extracted.json"
+```
+
+#### 4. Sample Questions
+
+```bash
+python process_data/query_sampling/query_sampling.py \
+  --input_file "/path/to/your/output_extracted.json" \
+  --total_samples 3000
+```
+
+---
+
+### 💬 Response Curation
+
+#### 1. Format Data
+
+```bash
+python process_data/repsonse_curation/format_data.py \
+  --input_file "/path/to/your/input_file.json"
+```
+
+#### 2. Filter Responses
+
+```bash
+python process_data/repsonse_curation/format_filter.py \
+  --input_file "/path/to/your/formatted_data.json"
+```
+
+---
+
+## 🧠 SFT Training
+
+> Run the following script after replacing the corresponding variables:
+
+```bash
+export OMP_NUM_THREADS=20
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+
+# Define parameters
+lr=1e-5
+base="BACKBONE"           # path to base model
+tokenizer="TOKENIZER"     # path to tokenizer
+train_data="TRAINING_DATA" # path to train data
+bsz=2                     # batch size
+acc=4                     # gradient accumulation steps
+save_path="YOUR_SAVE_PATH"
+output_dir="YOUR_OUTPUT_DIR"
+
+# Create output directory
+mkdir -p "$output_dir"
+echo ${output_dir}
+
+# Execute deepspeed command
+deepspeed \
+    --master_port=9944 \
+    sft/sft.py.py \
+    --deepspeed sft/ds_zero3_offload.json \
+    --model_name_or_path $base \
+    --tokenizer_name_or_path $tokenizer \
+    --do_train \
+    --save_safetensors true \
+    --data_path $train_data \
+    --lr_scheduler_type cosine \
+    --output_dir $output_dir \
+    --overwrite_output_dir \
+    --warmup_ratio 0.03 \
+    --gradient_checkpointing true \
+    --per_device_train_batch_size $bsz \
+    --gradient_accumulation_steps $acc \
+    --logging_steps 1 \
+    --learning_rate "$lr" \
+    --num_train_epochs 6 \
+    --save_strategy epoch \
+    --save_only_model true \
+    --model_max_length 30000 \
+    --save_total_limit 5 \
+    --bf16 || exit 1
+```
+

deep_search/search_o1/scripts/SimpleDeepSearcher/data/eval/bamboogle.json

@@ -0,0 +1,1002 @@
+[
+    {
+        "Question": "Who was president of the United States in the year that Citibank was founded?",
+        "source": "bamboogle",
+        "id": "bamboogle_1",
+        "answer": [
+            "james madison"
+        ]
+    },
+    {
+        "Question": "What rocket was the first spacecraft that ever approached Uranus launched on?",
+        "source": "bamboogle",
+        "id": "bamboogle_2",
+        "answer": [
+            "Titan IIIE"
+        ]
+    },
+    {
+        "Question": "In what year was the company that was founded as Sound of Music added to the S&P 500?",
+        "source": "bamboogle",
+        "id": "bamboogle_3",
+        "answer": [
+            "1999"
+        ]
+    },
+    {
+        "Question": "Who was the first African American mayor of the most populous city in the United States?",
+        "source": "bamboogle",
+        "id": "bamboogle_4",
+        "answer": [
+            "David Dinkins"
+        ]
+    },
+    {
+        "Question": "When did the last king from Britain's House of Hanover die?",
+        "source": "bamboogle",
+        "id": "bamboogle_5",
+        "answer": [
+            "20 June 1837"
+        ]
+    },
+    {
+        "Question": "When did the president who set the precedent of a two term limit enter office?",
+        "source": "bamboogle",
+        "id": "bamboogle_6",
+        "answer": [
+            "April 30, 1789"
+        ]
+    },
+    {
+        "Question": "When did the president who set the precedent of a two term limit leave office?",
+        "source": "bamboogle",
+        "id": "bamboogle_7",
+        "answer": [
+            "March 4, 1797"
+        ]
+    },
+    {
+        "Question": "How many people died in the second most powerful earthquake ever recorded?",
+        "source": "bamboogle",
+        "id": "bamboogle_8",
+        "answer": [
+            "131"
+        ]
+    },
+    {
+        "Question": "Can people who have celiac eat camel meat?",
+        "source": "bamboogle",
+        "id": "bamboogle_9",
+        "answer": [
+            "Yes"
+        ]
+    },
+    {
+        "Question": "What was the final book written by the author of On the Origin of Species?",
+        "source": "bamboogle",
+        "id": "bamboogle_10",
+        "answer": [
+            "The Formation of Vegetable Mould Through the Action of Worms"
+        ]
+    },
+    {
+        "Question": "When was the company that built the first steam locomotive to carry passengers on a public rail line founded?",
+        "source": "bamboogle",
+        "id": "bamboogle_11",
+        "answer": [
+            "1823"
+        ]
+    },
+    {
+        "Question": "Which Theranos whistleblower is not related to a senior American government official?",
+        "source": "bamboogle",
+        "id": "bamboogle_12",
+        "answer": [
+            "Erika Cheung"
+        ]
+    },
+    {
+        "Question": "What is the fastest air-breathing manned aircraft mostly made out of?",
+        "source": "bamboogle",
+        "id": "bamboogle_13",
+        "answer": [
+            "Titanium"
+        ]
+    },
+    {
+        "Question": "Who built the fastest air-breathing manned aircraft?",
+        "source": "bamboogle",
+        "id": "bamboogle_14",
+        "answer": [
+            "Lockheed Corporation"
+        ]
+    },
+    {
+        "Question": "When was the author of The Population Bomb born?",
+        "source": "bamboogle",
+        "id": "bamboogle_15",
+        "answer": [
+            "May 29, 1932"
+        ]
+    },
+    {
+        "Question": "When did the author of Annabel Lee enlist in the army?",
+        "source": "bamboogle",
+        "id": "bamboogle_16",
+        "answer": [
+            "1827"
+        ]
+    },
+    {
+        "Question": "What was the religion of the inventor of the Polio vaccine?",
+        "source": "bamboogle",
+        "id": "bamboogle_17",
+        "answer": [
+            "Jewish"
+        ]
+    },
+    {
+        "Question": "Who was the second wife of the founder of CNN?",
+        "source": "bamboogle",
+        "id": "bamboogle_18",
+        "answer": [
+            "Jane Shirley Smith"
+        ]
+    },
+    {
+        "Question": "When did the first prime minister of the Russian Empire come into office?",
+        "source": "bamboogle",
+        "id": "bamboogle_19",
+        "answer": [
+            "November 6, 1905"
+        ]
+    },
+    {
+        "Question": "What is the primary male hormone derived from?",
+        "source": "bamboogle",
+        "id": "bamboogle_20",
+        "answer": [
+            "cholesterol"
+        ]
+    },
+    {
+        "Question": "The Filipino statesman who established the government-in-exile during the outbreak of World War II was also the mayor of what city?",
+        "source": "bamboogle",
+        "id": "bamboogle_21",
+        "answer": [
+            "Quezon City"
+        ]
+    },
+    {
+        "Question": "Where was the person who shared the Nobel Prize in Physics in 1954 with Max Born born?",
+        "source": "bamboogle",
+        "id": "bamboogle_22",
+        "answer": [
+            "Oranienburg, Germany"
+        ]
+    },
+    {
+        "Question": "When was the person who shared the Nobel Prize in Physics in 1954 with Max Born born?",
+        "source": "bamboogle",
+        "id": "bamboogle_23",
+        "answer": [
+            "January 8, 1891"
+        ]
+    },
+    {
+        "Question": "What was the founding date of the university in which Plotonium was discovered?",
+        "source": "bamboogle",
+        "id": "bamboogle_24",
+        "answer": [
+            "March 23, 1868"
+        ]
+    },
+    {
+        "Question": "The material out of which the Great Sphinx of Giza is made of is mainly composed of what mineral?",
+        "source": "bamboogle",
+        "id": "bamboogle_25",
+        "answer": [
+            "calcite"
+        ]
+    },
+    {
+        "Question": "The husband of Lady Godiva was Earl of which Anglic kingdom?",
+        "source": "bamboogle",
+        "id": "bamboogle_26",
+        "answer": [
+            "Mercia"
+        ]
+    },
+    {
+        "Question": "The machine used to extract honey from honeycombs uses which physical force?",
+        "source": "bamboogle",
+        "id": "bamboogle_27",
+        "answer": [
+            "Centrifugal Force"
+        ]
+    },
+    {
+        "Question": "What is the third letter of the top level domain of the military?",
+        "source": "bamboogle",
+        "id": "bamboogle_28",
+        "answer": [
+            "l"
+        ]
+    },
+    {
+        "Question": "In what year was the government department where the internet originated at founded?",
+        "source": "bamboogle",
+        "id": "bamboogle_29",
+        "answer": [
+            "1947"
+        ]
+    },
+    {
+        "Question": "The main actor of Indiana Jones is a licensed what?",
+        "source": "bamboogle",
+        "id": "bamboogle_30",
+        "answer": [
+            "pilot"
+        ]
+    },
+    {
+        "Question": "When was the person after which the Hubble Space Telescope is named after born?",
+        "source": "bamboogle",
+        "id": "bamboogle_31",
+        "answer": [
+            "November 20, 1889"
+        ]
+    },
+    {
+        "Question": "When did the person who gave the Checkers speech die?",
+        "source": "bamboogle",
+        "id": "bamboogle_32",
+        "answer": [
+            "April 22, 1994"
+        ]
+    },
+    {
+        "Question": "When was the philosopher that formulated the hard problem of consciousness born?",
+        "source": "bamboogle",
+        "id": "bamboogle_33",
+        "answer": [
+            "April 20, 1966"
+        ]
+    },
+    {
+        "Question": "What is the capital of the second largest state in the US by area?",
+        "source": "bamboogle",
+        "id": "bamboogle_34",
+        "answer": [
+            "Austin"
+        ]
+    },
+    {
+        "Question": "What is the maximum airspeed (in km/h) of the third fastest bird?",
+        "source": "bamboogle",
+        "id": "bamboogle_35",
+        "answer": [
+            "320 km/h"
+        ]
+    },
+    {
+        "Question": "Who founded the city where the founder of geometry lived?",
+        "source": "bamboogle",
+        "id": "bamboogle_36",
+        "answer": [
+            "Alexander the Great"
+        ]
+    },
+    {
+        "Question": "What is the capital of the country where yoga originated?",
+        "source": "bamboogle",
+        "id": "bamboogle_37",
+        "answer": [
+            "New Delhi"
+        ]
+    },
+    {
+        "Question": "The fourth largest city in Germany was originally called what?",
+        "source": "bamboogle",
+        "id": "bamboogle_38",
+        "answer": [
+            "Colonia Claudia Ara Agrippinensium"
+        ]
+    },
+    {
+        "Question": "When did Nirvana's second most selling studio album come out?",
+        "source": "bamboogle",
+        "id": "bamboogle_39",
+        "answer": [
+            "September 13, 1993"
+        ]
+    },
+    {
+        "Question": "What was the job of the father of the founder of psychoanalysis?",
+        "source": "bamboogle",
+        "id": "bamboogle_40",
+        "answer": [
+            "wool merchant"
+        ]
+    },
+    {
+        "Question": "How much protein in four boiled egg yolks?",
+        "source": "bamboogle",
+        "id": "bamboogle_41",
+        "answer": [
+            "10.8"
+        ]
+    },
+    {
+        "Question": "What is the political party of the American president who entered into the Paris agreement?",
+        "source": "bamboogle",
+        "id": "bamboogle_42",
+        "answer": [
+            "Democratic Party"
+        ]
+    },
+    {
+        "Question": "The most populous city in Punjab is how large (area wise)?",
+        "source": "bamboogle",
+        "id": "bamboogle_43",
+        "answer": [
+            "310 square kilometers"
+        ]
+    },
+    {
+        "Question": "What was the death toll of the second largest volcanic eruption in the 20th century?",
+        "source": "bamboogle",
+        "id": "bamboogle_44",
+        "answer": [
+            "847"
+        ]
+    },
+    {
+        "Question": "What was the death toll of the most intense Atlantic hurricane?",
+        "source": "bamboogle",
+        "id": "bamboogle_45",
+        "answer": [
+            "52"
+        ]
+    },
+    {
+        "Question": "Who was the head of NASA during Apollo 11?",
+        "source": "bamboogle",
+        "id": "bamboogle_46",
+        "answer": [
+            "Thomas O. Paine"
+        ]
+    },
+    {
+        "Question": "Who is the father of the father of George Washington?",
+        "source": "bamboogle",
+        "id": "bamboogle_47",
+        "answer": [
+            "Lawrence Washington"
+        ]
+    },
+    {
+        "Question": "Who is the mother of the father of George Washington?",
+        "source": "bamboogle",
+        "id": "bamboogle_48",
+        "answer": [
+            "Mildred Warner"
+        ]
+    },
+    {
+        "Question": "Who is the father of the father of Barack Obama?",
+        "source": "bamboogle",
+        "id": "bamboogle_49",
+        "answer": [
+            "Hussein Onyango Obama"
+        ]
+    },
+    {
+        "Question": "Who is the mother of the father of Barack Obama?",
+        "source": "bamboogle",
+        "id": "bamboogle_50",
+        "answer": [
+            "Habiba Akumu Nyanjango"
+        ]
+    },
+    {
+        "Question": "Who was mayor of New York City when Fiorello H. La Guardia was born?",
+        "source": "bamboogle",
+        "id": "bamboogle_51",
+        "answer": [
+            "William Russell Grace"
+        ]
+    },
+    {
+        "Question": "Who was president of the U.S. when superconductivity was discovered?",
+        "source": "bamboogle",
+        "id": "bamboogle_52",
+        "answer": [
+            "William Howard Taft"
+        ]
+    },
+    {
+        "Question": "When was the person Russ Hanneman is based on born?",
+        "source": "bamboogle",
+        "id": "bamboogle_53",
+        "answer": [
+            "July 31, 1958"
+        ]
+    },
+    {
+        "Question": "When was the first location of the world's largest coffeehouse chain opened?",
+        "source": "bamboogle",
+        "id": "bamboogle_54",
+        "answer": [
+            "March 30, 1971"
+        ]
+    },
+    {
+        "Question": "Who directed the highest grossing film?",
+        "source": "bamboogle",
+        "id": "bamboogle_55",
+        "answer": [
+            "James Cameroon"
+        ]
+    },
+    {
+        "Question": "When was the longest bridge in the world opened?",
+        "source": "bamboogle",
+        "id": "bamboogle_56",
+        "answer": [
+            "30 June 2011"
+        ]
+    },
+    {
+        "Question": "Which company was responsible for the largest pharmaceutical settlement?",
+        "source": "bamboogle",
+        "id": "bamboogle_57",
+        "answer": [
+            "GlaxoSmithKline"
+        ]
+    },
+    {
+        "Question": "In what year was the tallest self-supporting tower completed?",
+        "source": "bamboogle",
+        "id": "bamboogle_58",
+        "answer": [
+            "2012"
+        ]
+    },
+    {
+        "Question": "In what year was the tallest fixed steel structure completed?",
+        "source": "bamboogle",
+        "id": "bamboogle_59",
+        "answer": [
+            "1988"
+        ]
+    },
+    {
+        "Question": "In what year was the tallest lattice tower completed?",
+        "source": "bamboogle",
+        "id": "bamboogle_60",
+        "answer": [
+            "2012"
+        ]
+    },
+    {
+        "Question": "In what year was the current tallest wooden lattice tower completed?",
+        "source": "bamboogle",
+        "id": "bamboogle_61",
+        "answer": [
+            "1935"
+        ]
+    },
+    {
+        "Question": "In what country is the second tallest statue in the world?",
+        "source": "bamboogle",
+        "id": "bamboogle_62",
+        "answer": [
+            "China"
+        ]
+    },
+    {
+        "Question": "When was the tallest ferris wheel in the world completed?",
+        "source": "bamboogle",
+        "id": "bamboogle_63",
+        "answer": [
+            "2021"
+        ]
+    },
+    {
+        "Question": "In what year was the tallest lighthouse completed?",
+        "source": "bamboogle",
+        "id": "bamboogle_64",
+        "answer": [
+            "1902"
+        ]
+    },
+    {
+        "Question": "In what country is the world largest desalination plant?",
+        "source": "bamboogle",
+        "id": "bamboogle_65",
+        "answer": [
+            "Saudi Arabia"
+        ]
+    },
+    {
+        "Question": "The most populous national capital city was established in what year?",
+        "source": "bamboogle",
+        "id": "bamboogle_66",
+        "answer": [
+            "1045 BC"
+        ]
+    },
+    {
+        "Question": "The third largest river (by discharge) in the world is in what countries?",
+        "source": "bamboogle",
+        "id": "bamboogle_67",
+        "answer": [
+            "India and Bangladesh"
+        ]
+    },
+    {
+        "Question": "What is the highest elevation (in meters) of the second largest island in the world?",
+        "source": "bamboogle",
+        "id": "bamboogle_68",
+        "answer": [
+            "4,884 m"
+        ]
+    },
+    {
+        "Question": "What is the length of the second deepest river in the world?",
+        "source": "bamboogle",
+        "id": "bamboogle_69",
+        "answer": [
+            "6,300 km"
+        ]
+    },
+    {
+        "Question": "In what country is the third largest stadium in the world?",
+        "source": "bamboogle",
+        "id": "bamboogle_70",
+        "answer": [
+            "United States"
+        ]
+    },
+    {
+        "Question": "Who is the largest aircraft carrier in the world is named after?",
+        "source": "bamboogle",
+        "id": "bamboogle_71",
+        "answer": [
+            "Gerald R. Ford"
+        ]
+    },
+    {
+        "Question": "In what year did the oldest cat ever recorded with the Cat of the Year award?",
+        "source": "bamboogle",
+        "id": "bamboogle_72",
+        "answer": [
+            "1999"
+        ]
+    },
+    {
+        "Question": "In what year was the country that is the third largest exporter of coffee founded?",
+        "source": "bamboogle",
+        "id": "bamboogle_73",
+        "answer": [
+            "1810"
+        ]
+    },
+    {
+        "Question": "Who was the commander for the space mission that had the first spacewalk?",
+        "source": "bamboogle",
+        "id": "bamboogle_74",
+        "answer": [
+            "Pavel Belyayev"
+        ]
+    },
+    {
+        "Question": "Who is the predecessor of the longest-reigning British monarch?",
+        "source": "bamboogle",
+        "id": "bamboogle_75",
+        "answer": [
+            "George VI\n"
+        ]
+    },
+    {
+        "Question": "In 2016, who was the host of the longest running talk show?",
+        "source": "bamboogle",
+        "id": "bamboogle_76",
+        "answer": [
+            "Jimmy Fallon"
+        ]
+    },
+    {
+        "Question": "In 2016, who was the host of the longest running American game show?",
+        "source": "bamboogle",
+        "id": "bamboogle_77",
+        "answer": [
+            "Drew Carey"
+        ]
+    },
+    {
+        "Question": "Who wrote the novel on which the longest running show in Broadway history is based on?",
+        "source": "bamboogle",
+        "id": "bamboogle_78",
+        "answer": [
+            "Gaston Leroux"
+        ]
+    },
+    {
+        "Question": "In what country was the only cruise line that flies the American flag incorporated in?",
+        "source": "bamboogle",
+        "id": "bamboogle_79",
+        "answer": [
+            "Bermuda"
+        ]
+    },
+    {
+        "Question": "In what year did work begin on the second longest road tunnel in the world?",
+        "source": "bamboogle",
+        "id": "bamboogle_80",
+        "answer": [
+            "1992"
+        ]
+    },
+    {
+        "Question": "What is the official color of the third oldest surviving university?",
+        "source": "bamboogle",
+        "id": "bamboogle_81",
+        "answer": [
+            "Cambridge Blue"
+        ]
+    },
+    {
+        "Question": "Who succeeded the longest reigning Roman emperor?",
+        "source": "bamboogle",
+        "id": "bamboogle_82",
+        "answer": [
+            "Tiberius"
+        ]
+    },
+    {
+        "Question": "Who preceded the Roman emperor that declared war on the sea?",
+        "source": "bamboogle",
+        "id": "bamboogle_83",
+        "answer": [
+            "Tiberius"
+        ]
+    },
+    {
+        "Question": "Who produced the longest running video game franchise?",
+        "source": "bamboogle",
+        "id": "bamboogle_84",
+        "answer": [
+            "MECC"
+        ]
+    },
+    {
+        "Question": "Who was the father of the father of psychoanalysis?",
+        "source": "bamboogle",
+        "id": "bamboogle_85",
+        "answer": [
+            "Jacob Freud"
+        ]
+    },
+    {
+        "Question": "Who was the father of the father of empiricism?",
+        "source": "bamboogle",
+        "id": "bamboogle_86",
+        "answer": [
+            "Sir Nicholas Bacon"
+        ]
+    },
+    {
+        "Question": "Who is the father of the father of observational astronomy?",
+        "source": "bamboogle",
+        "id": "bamboogle_87",
+        "answer": [
+            "Vincenzo Galilei"
+        ]
+    },
+    {
+        "Question": "Who is the father of the father of modern Hebrew?",
+        "source": "bamboogle",
+        "id": "bamboogle_88",
+        "answer": [
+            "Yehuda Leib"
+        ]
+    },
+    {
+        "Question": "Who is the father of the father of modern experimental psychology?",
+        "source": "bamboogle",
+        "id": "bamboogle_89",
+        "answer": [
+            "Maximilian Wundt"
+        ]
+    },
+    {
+        "Question": "Who is the father of the originator of cybernetics?",
+        "source": "bamboogle",
+        "id": "bamboogle_90",
+        "answer": [
+            "Leo Wiener"
+        ]
+    },
+    {
+        "Question": "Who is the father of the father of the hydrogen bomb?",
+        "source": "bamboogle",
+        "id": "bamboogle_91",
+        "answer": [
+            "Max Teller"
+        ]
+    },
+    {
+        "Question": "Who was the father of the father of computer science?",
+        "source": "bamboogle",
+        "id": "bamboogle_92",
+        "answer": [
+            "Julius Mathison Turing"
+        ]
+    },
+    {
+        "Question": "Who was the father of the father of behaviorism?",
+        "source": "bamboogle",
+        "id": "bamboogle_93",
+        "answer": [
+            "Pickens Butler Watson"
+        ]
+    },
+    {
+        "Question": "Who was the father of the founder of modern human anatomy?",
+        "source": "bamboogle",
+        "id": "bamboogle_94",
+        "answer": [
+            "Anders van Wesel"
+        ]
+    },
+    {
+        "Question": "What was the father of the last surviving Canadian father of Confederation?",
+        "source": "bamboogle",
+        "id": "bamboogle_95",
+        "answer": [
+            "Charles Tupper Sr."
+        ]
+    },
+    {
+        "Question": "When was the person who said “Now, I am become Death, the destroyer of worlds.” born?",
+        "source": "bamboogle",
+        "id": "bamboogle_96",
+        "answer": [
+            "April 22, 1904"
+        ]
+    },
+    {
+        "Question": "Who was the father of the father of information theory?",
+        "source": "bamboogle",
+        "id": "bamboogle_97",
+        "answer": [
+            "Claude Sr."
+        ]
+    },
+    {
+        "Question": "When was the person who delivered the \"Quit India\" speech born?",
+        "source": "bamboogle",
+        "id": "bamboogle_98",
+        "answer": [
+            "October 2, 1869"
+        ]
+    },
+    {
+        "Question": "When did the president who warned about the military industrial complex die?",
+        "source": "bamboogle",
+        "id": "bamboogle_99",
+        "answer": [
+            "March 28, 1969"
+        ]
+    },
+    {
+        "Question": "When did the president who said Tear Down This Wall die?",
+        "source": "bamboogle",
+        "id": "bamboogle_100",
+        "answer": [
+            "June 5, 2004"
+        ]
+    },
+    {
+        "Question": "What is the lowest elevation of the longest railway tunnel?",
+        "source": "bamboogle",
+        "id": "bamboogle_101",
+        "answer": [
+            "312 m"
+        ]
+    },
+    {
+        "Question": "When did the person who said \"Cogito, ergo sum.\" die?",
+        "source": "bamboogle",
+        "id": "bamboogle_102",
+        "answer": [
+            "February 11, 1650"
+        ]
+    },
+    {
+        "Question": "When did the person who delivered the Gettysburg Address die?",
+        "source": "bamboogle",
+        "id": "bamboogle_103",
+        "answer": [
+            "April 15, 1865"
+        ]
+    },
+    {
+        "Question": "Who was governor of Florida during Hurricane Irma?",
+        "source": "bamboogle",
+        "id": "bamboogle_104",
+        "answer": [
+            "Rick Scott"
+        ]
+    },
+    {
+        "Question": "For which club did the winner of the 2007 Ballon d'Or play for in 2012?",
+        "source": "bamboogle",
+        "id": "bamboogle_105",
+        "answer": [
+            "Real Madrid"
+        ]
+    },
+    {
+        "Question": "What's the capital city of the country that was the champion of the 2010 World Cup?",
+        "source": "bamboogle",
+        "id": "bamboogle_106",
+        "answer": [
+            "Madrid"
+        ]
+    },
+    {
+        "Question": "When was the anime studio that made Sword Art Online founded?",
+        "source": "bamboogle",
+        "id": "bamboogle_107",
+        "answer": [
+            "May 9, 2005"
+        ]
+    },
+    {
+        "Question": "Who was the first king of the longest Chinese dynasty?",
+        "source": "bamboogle",
+        "id": "bamboogle_108",
+        "answer": [
+            "King Wu of Zhou"
+        ]
+    },
+    {
+        "Question": "Who was the last emperor of the dynasty that succeeded the Song dynasty?",
+        "source": "bamboogle",
+        "id": "bamboogle_109",
+        "answer": [
+            "Toghon Temür"
+        ]
+    },
+    {
+        "Question": "What's the motto of the oldest California State university?",
+        "source": "bamboogle",
+        "id": "bamboogle_110",
+        "answer": [
+            "Powering Silicon Valley"
+        ]
+    },
+    {
+        "Question": "What's the capital of the state that the College of William & Mary is in?",
+        "source": "bamboogle",
+        "id": "bamboogle_111",
+        "answer": [
+            "Richmond"
+        ]
+    },
+    {
+        "Question": "What's the capital of the state that Washington University in St. Louis is in?",
+        "source": "bamboogle",
+        "id": "bamboogle_112",
+        "answer": [
+            "Jefferson City"
+        ]
+    },
+    {
+        "Question": "What's the capital of the state that Harvard University is in?",
+        "source": "bamboogle",
+        "id": "bamboogle_113",
+        "answer": [
+            "Boston"
+        ]
+    },
+    {
+        "Question": "What's the capital of the state that the Space Needle is at?",
+        "source": "bamboogle",
+        "id": "bamboogle_114",
+        "answer": [
+            "Olympia"
+        ]
+    },
+    {
+        "Question": "Which team won in women's volleyball in the most recent Summer Olympics that was held in London?",
+        "source": "bamboogle",
+        "id": "bamboogle_115",
+        "answer": [
+            "Brazil"
+        ]
+    },
+    {
+        "Question": "What is the nickname of the easternmost U.S. state?",
+        "source": "bamboogle",
+        "id": "bamboogle_116",
+        "answer": [
+            "Pine Tree State"
+        ]
+    },
+    {
+        "Question": "What is the nickname for the state that is the home to the “Avocado Capital of the World\"?",
+        "source": "bamboogle",
+        "id": "bamboogle_117",
+        "answer": [
+            "Golden State"
+        ]
+    },
+    {
+        "Question": "What rocket was used for the mission that landed the first humans on the moon?",
+        "source": "bamboogle",
+        "id": "bamboogle_118",
+        "answer": [
+            "Saturn V"
+        ]
+    },
+    {
+        "Question": "When did the war that Neil Armstrong served in end?",
+        "source": "bamboogle",
+        "id": "bamboogle_119",
+        "answer": [
+            "July 27, 1953"
+        ]
+    },
+    {
+        "Question": "What is the nickname for the state that Mount Rainier is located in?",
+        "source": "bamboogle",
+        "id": "bamboogle_120",
+        "answer": [
+            "Evergreen State"
+        ]
+    },
+    {
+        "Question": "When was the composer of Carol of the Bells born?",
+        "source": "bamboogle",
+        "id": "bamboogle_121",
+        "answer": [
+            "December 13, 1877"
+        ]
+    },
+    {
+        "Question": "Who is the father of the scientist at MIT that won the Queen Elizabeth Prize for Engineering in 2013?",
+        "source": "bamboogle",
+        "id": "bamboogle_122",
+        "answer": [
+            "Conway Berners-Lee"
+        ]
+    },
+    {
+        "Question": "Who was the mother of the emperor of Japan during World War I?",
+        "source": "bamboogle",
+        "id": "bamboogle_123",
+        "answer": [
+            "Yanagiwara Naruko"
+        ]
+    },
+    {
+        "Question": "Which element has an atomic number that is double that of hydrogen?",
+        "source": "bamboogle",
+        "id": "bamboogle_124",
+        "answer": [
+            "Helium"
+        ]
+    },
+    {
+        "Question": "What was the motto of the Olympics that had Fuwa as the mascots?",
+        "source": "bamboogle",
+        "id": "bamboogle_125",
+        "answer": [
+            "One World, One Dream"
+        ]
+    }
+]

deep_search/search_o1/scripts/SimpleDeepSearcher/eval/gpt_eval_sft.py

@@ -0,0 +1,216 @@
+from openai import OpenAI
+import sys
+import os
+from datasets import load_dataset
+import http.client
+import json
+import re
+from tqdm import tqdm
+import multiprocessing
+from time import sleep
+import requests
+import json
+from collections import defaultdict
+import random
+import json
+import requests
+import time
+# from bs4 import BeautifulSoup
+# import wikipediaapi
+from urllib.parse import unquote
+from urllib.parse import urlparse
+
+
+os.environ["OPENAI_API_KEY"]  = "YOUR_API_KEY"
+os.environ["OPENAI_API_BASE"] = "YOUR_API_BASE"
+
+client = OpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY"),
+    base_url=os.environ.get("OPENAI_API_BASE")
+)
+
+
+def generate(messages, model_name):
+    retry_cnt = 0
+    while True: # 重试机制
+        try:
+            if retry_cnt:
+                print(f"Retry: {retry_cnt}")
+            response = client.chat.completions.create(
+                **{
+                    "model": model_name,
+                    "messages": messages,
+                    "max_tokens": 1024,
+                    "temperature": 0,
+                }
+            )
+            response = response.choices[0].message.content
+            return response
+        except Exception as e:
+            retry_cnt += 1
+            print(f"Error: {e}")
+            time.sleep(0.5)
+def process_one_sample(obj):
+
+    prompt = '''Given a Question and its Golden Answer, verify whether the Predicted Answer is correct. The prediction is correct if it fully aligns with the meaning and key information of the Golden Answer. Respond with True if the prediction is correct and False otherwise.
+Golden Answer may have multiple options, and matching any one of them is considered correct.
+
+Question: {question}
+Golden Answer: {reference}
+Predicted Answer: {prediction}
+    '''
+
+    question = obj["item"]["Question"]
+    reference_ans_ori = obj["item"]["answer"]
+
+    reference_ans_ori = [a if isinstance(a, str) else str(a) for a in reference_ans_ori]
+    if isinstance(reference_ans_ori, str):
+        reference_ans = reference_ans_ori
+    elif isinstance(reference_ans_ori, list):
+        reference_ans = "; ".join(reference_ans_ori)
+        # print(reference_ans)
+    else:
+        kill
+
+    if reference_ans ==False:
+        reference_ans="no"
+    if reference_ans ==True:
+        reference_ans="yes"
+    solution = obj["output"]
+
+    pattern = r'\\boxed\{(.*)\}'
+    matches = re.findall(pattern, solution)
+    # proposed_ans = matches[-1]
+    if matches:
+        proposed_ans = matches[-1]
+    else:
+        proposed_ans = "No answer"
+
+
+    gpt4o_input = prompt.format(question=question , reference=reference_ans, prediction=proposed_ans)
+    flag_final_ans = True
+
+    if flag_final_ans:
+        messages = [{'role': 'user', 'content': gpt4o_input}]
+        model_output = generate(messages, 'gpt-4o-mini')
+        obj["gpt4o_output"] = model_output
+    else:
+        obj["gpt4o_output"] = "Fuck! No boxed"
+
+    obj_new={
+        "question":question,
+        "reference_ans":reference_ans ,
+        "predicted_ans": proposed_ans ,
+        "gpt4o_output":obj["gpt4o_output"] ,
+        "source": obj["item"]["source"]
+        # "output":solution,
+    }
+
+    return obj_new
+
+
+def cal_metrics(results):
+    metrics = {
+        "is_correct": 0,
+        "is_incorrect": 0,
+        "invalid_judge": 0,
+        "num": 0
+    }
+
+    error_cnt = 0
+    source_metrics = {}
+
+    for sample in results:
+        source = sample["source"]
+        if source not in source_metrics:
+            source_metrics[source] = {
+                "is_correct": 0,
+                "is_incorrect": 0,
+                "invalid_judge": 0,
+                "num": 0
+            }
+        
+        # 统计数目
+        metrics["num"] += 1
+        source_metrics[source]["num"] += 1
+
+        # 判断是否正确
+        if sample["gpt4o_output"] == "True":
+            metrics["is_correct"] += 1
+            source_metrics[source]["is_correct"] += 1
+        elif sample["gpt4o_output"] == "False":
+            metrics["is_incorrect"] += 1
+            source_metrics[source]["is_incorrect"] += 1
+        else:
+            metrics["invalid_judge"] += 1
+            source_metrics[source]["invalid_judge"] += 1
+            error_cnt += 1
+    
+
+    print("Total:", metrics["num"])
+    print(f"error_cnt: {error_cnt}")
+
+    # 计算汇总指标
+    for key in metrics:
+        if key == "num":
+            continue
+        metrics[key] = metrics[key] / metrics["num"] if metrics["num"] > 0 else 0
+    
+    # 计算各个source
+    for src in source_metrics:
+        for key in source_metrics[src]:
+            if key == "num":
+                continue
+            source_metrics[src][key] = source_metrics[src][key] / source_metrics[src]["num"] if source_metrics[src]["num"] > 0 else 0
+    
+
+    final_metrics = {'overall': metrics, 'per_source': source_metrics}
+
+    return final_metrics
+
+
+
+if __name__ == '__main__':
+    input_files=[
+        
+    ]   
+
+    for input_file in input_files:
+        print(f"Begin:{input_file}")
+
+        output_file = input_file.replace(".json", "_judge_temp0.json")
+        chunk_size=200
+        with open(input_file, "r") as fin:
+            all_demons = json.load(fin)  # 加载整个 JSON 文件，返回一个列表
+        
+        for item in all_demons:
+            if 'source' not in item["item"]:
+                item["item"]["source"] = 'unknown'
+        # all_demons =all_demons [:1]
+        print(f"Processed data has been written to {output_file}")
+
+        print("All Data Num:",len(all_demons))
+        chunk_num = len(all_demons) // chunk_size
+        if len(all_demons) % chunk_size != 0:
+            chunk_num += 1
+
+
+        all_results = []
+        for chunk_i in range(chunk_num):
+            print("Epoch:" ,chunk_i ,"/",chunk_num)
+            all_demons_subset = all_demons[chunk_i*chunk_size : (chunk_i+1)*chunk_size]
+            print(len(all_demons_subset))
+            with multiprocessing.Pool(processes=200) as pool:
+                results = list(tqdm(pool.imap(process_one_sample, all_demons_subset), total=len(all_demons_subset)))
+
+            all_results.extend(results)
+        
+        # 保存为json
+
+        final_metrics = cal_metrics(all_results)
+
+        with open(output_file, 'w') as fout:
+            json.dump(all_results, fout, ensure_ascii=False, indent=4)
+
+        with open(output_file.replace(".json","_metrics_temp0.json"), 'w') as fout:
+            json.dump(final_metrics, fout, ensure_ascii=False, indent=4)

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/add_eval.py

@@ -0,0 +1,705 @@
+import json
+import re
+# from utils import has_answer, EM_compute, F1_compute, AC_compute
+
+import os
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+num2alpha = {
+    'zero': '0', 'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5', 'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10', 'eleven': '11', 'twelve': '12', 'thirteen': '13', 'fourteen': '14', 'fifteen': '15', 'sixteen': '16', 'seventeen': '17', 'eighteen': '18', 'nineteen': '19', 'twenty': '20', 'thirty': '30', 'forty': '40', 'fifty': '50', 'sixty': '60', 'seventy': '70', 'eighty': '80', 'ninety': '90', 'hundred': '100',
+    '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five', '6': 'six', '7': 'seven', '8': 'eight', '9': 'nine', '10': 'ten', '11': 'eleven', '12': 'twelve', '13': 'thirteen', '14': 'fourteen', '15': 'fifteen', '16': 'sixteen', '17': 'seventeen', '18': 'eighteen', '19': 'nineteen', '20': 'twenty', '30': 'thirty', '40': 'forty', '50': 'fifty', '60': 'sixty', '70': 'seventy', '80': 'eighty', '90': 'ninety', '100': 'hundred',
+}
+import argparse
+import collections
+import json
+import copy
+import os
+import re
+import logging
+import string
+from typing import List
+import regex
+import unicodedata
+from tqdm import tqdm
+
+
+logger = logging.getLogger()
+
+
+class Tokens(object):
+    """A class to represent a list of tokenized text."""
+    TEXT = 0
+    TEXT_WS = 1
+    SPAN = 2
+    POS = 3
+    LEMMA = 4
+    NER = 5
+
+    def __init__(self, data, annotators, opts=None):
+        self.data = data
+        self.annotators = annotators
+        self.opts = opts or {}
+
+    def __len__(self):
+        """The number of tokens."""
+        return len(self.data)
+
+    def slice(self, i=None, j=None):
+        """Return a view of the list of tokens from [i, j)."""
+        new_tokens = copy.copy(self)
+        new_tokens.data = self.data[i: j]
+        return new_tokens
+
+    def untokenize(self):
+        """Returns the original text (with whitespace reinserted)."""
+        return ''.join([t[self.TEXT_WS] for t in self.data]).strip()
+
+    def words(self, uncased=False):
+        """Returns a list of the text of each token
+        Args:
+            uncased: lower cases text
+        """
+        if uncased:
+            return [t[self.TEXT].lower() for t in self.data]
+        else:
+            return [t[self.TEXT] for t in self.data]
+
+    def offsets(self):
+        """Returns a list of [start, end) character offsets of each token."""
+        return [t[self.SPAN] for t in self.data]
+
+    def pos(self):
+        """Returns a list of part-of-speech tags of each token.
+        Returns None if this annotation was not included.
+        """
+        if 'pos' not in self.annotators:
+            return None
+        return [t[self.POS] for t in self.data]
+
+    def lemmas(self):
+        """Returns a list of the lemmatized text of each token.
+        Returns None if this annotation was not included.
+        """
+        if 'lemma' not in self.annotators:
+            return None
+        return [t[self.LEMMA] for t in self.data]
+
+    def entities(self):
+        """Returns a list of named-entity-recognition tags of each token.
+        Returns None if this annotation was not included.
+        """
+        if 'ner' not in self.annotators:
+            return None
+        return [t[self.NER] for t in self.data]
+
+    def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):
+        """Returns a list of all ngrams from length 1 to n.
+        Args:
+            n: upper limit of ngram length
+            uncased: lower cases text
+            filter_fn: user function that takes in an ngram list and returns
+            True or False to keep or not keep the ngram
+            as_string: return the ngram as a string vs list
+        """
+
+        def _skip(gram):
+            if not filter_fn:
+                return False
+            return filter_fn(gram)
+
+        words = self.words(uncased)
+        ngrams = [(s, e + 1)
+                for s in range(len(words))
+                for e in range(s, min(s + n, len(words)))
+                if not _skip(words[s:e + 1])]
+
+        # Concatenate into strings
+        if as_strings:
+            ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]
+
+        return ngrams
+
+    def entity_groups(self):
+        """Group consecutive entity tokens with the same NER tag."""
+        entities = self.entities()
+        if not entities:
+            return None
+        non_ent = self.opts.get('non_ent', 'O')
+        groups = []
+        idx = 0
+        while idx < len(entities):
+            ner_tag = entities[idx]
+            # Check for entity tag
+            if ner_tag != non_ent:
+                # Chomp the sequence
+                start = idx
+                while (idx < len(entities) and entities[idx] == ner_tag):
+                    idx += 1
+                groups.append((self.slice(start, idx).untokenize(), ner_tag))
+            else:
+                idx += 1
+        return groups
+
+
+class Tokenizer(object):
+    """Base tokenizer class.
+    Tokenizers implement tokenize, which should return a Tokens class.
+    """
+
+    def tokenize(self, text):
+        raise NotImplementedError
+
+    def shutdown(self):
+        pass
+
+    def __del__(self):
+        self.shutdown()
+
+
+class SimpleTokenizer(Tokenizer):
+    ALPHA_NUM = r'[\p{L}\p{N}\p{M}]+'
+    NON_WS = r'[^\p{Z}\p{C}]'
+
+    def __init__(self, **kwargs):
+        """
+        Args:
+            annotators: None or empty set (only tokenizes).
+        """
+        self._regexp = regex.compile(
+            '(%s)|(%s)' % (self.ALPHA_NUM, self.NON_WS),
+            flags=regex.IGNORECASE + regex.UNICODE + regex.MULTILINE
+        )
+        if len(kwargs.get('annotators', {})) > 0:
+            logger.warning('%s only tokenizes! Skipping annotators: %s' %
+                        (type(self).__name__, kwargs.get('annotators')))
+        self.annotators = set()
+
+    def tokenize(self, text):
+        data = []
+        matches = [m for m in self._regexp.finditer(text)]
+        for i in range(len(matches)):
+            # Get text
+            token = matches[i].group()
+
+            # Get whitespace
+            span = matches[i].span()
+            start_ws = span[0]
+            if i + 1 < len(matches):
+                end_ws = matches[i + 1].span()[0]
+            else:
+                end_ws = span[1]
+
+            # Format data
+            data.append((
+                token,
+                text[start_ws: end_ws],
+                span,
+            ))
+        return Tokens(data, self.annotators)
+
+tokenizer = SimpleTokenizer()
+
+def normalize_span(text):
+    text = unicodedata.normalize('NFD', text)
+    text = tokenizer.tokenize(text).words(uncased=False)
+    return ' '.join(text), len(text)
+
+def has_answer(answers, text, match_type="string"):
+    # print(answers, text)
+    # input()
+
+    # 如果text为list
+    if isinstance(text, list):
+        text = ' '.join(text)
+
+    text = unicodedata.normalize('NFD', text)
+    if match_type == 'string':
+        text = tokenizer.tokenize(text).words(uncased=True)
+        for single_answer in answers:
+            single_answer = unicodedata.normalize('NFD', single_answer)
+            single_answer = tokenizer.tokenize(single_answer)
+            single_answer = single_answer.words(uncased=True)
+            for i in range(0, len(text) - len(single_answer) + 1):
+                if single_answer == text[i: i + len(single_answer)]:
+                    return 1
+    return 0
+
+import unicodedata
+
+def fake_answer(answers, text, fake_ans, match_type="string"):
+    answers = might_right_answers(answers) + expand_answers(answers)
+    # Normalize the input text
+    text = unicodedata.normalize('NFD', text)
+    if match_type == 'string':
+        otext = tokenizer.tokenize(text).words(uncased=False)
+        oo = ' '.join(otext)
+        text = tokenizer.tokenize(text).words(uncased=True)
+        for single_answer in answers:
+            single_answer = unicodedata.normalize('NFD', single_answer)
+            single_answer = tokenizer.tokenize(single_answer)
+            single_answer = single_answer.words(uncased=True)
+            for i in range(0, len(text) - len(single_answer) + 1):
+                if single_answer == text[i: i + len(single_answer)]:
+                    ss = ' '.join(otext[i: i + len(single_answer)])
+                    
+                    oo = oo.replace(ss, fake_ans)
+    return clean_text(oo)
+
+def clean_text(text):
+    # 定义一个正则表达式模式，用于去除标点符号后面的多余空格
+    # 这里定义了一些常见的英文标点符号
+    pattern_remove_trailing_spaces = r'([,.!?;:\(\)\[\]\{\}—–—])\s+'
+    
+    # 定义一个正则表达式模式，用于去除标点符号前面的多余空格
+    pattern_remove_leading_spaces = r'\s+([,.!?;:\(\)\[\]\{\}—–—])'
+    
+    # 定义一个正则表达式模式，确保标点符号前后至少保留一个空格
+    pattern_preserve_single_space = r'(\s*)([,.!?;:\(\)\[\]\{\}—–—])(\s*)'
+    
+    # 去除标点符号后面的多余空格
+    cleaned_text = re.sub(pattern_remove_trailing_spaces, r'\1 ', text)
+    
+    # 去除标点符号前面的多余空格
+    cleaned_text = re.sub(pattern_remove_leading_spaces, r' \1', cleaned_text)
+    
+    # 确保标点符号前后至少保留一个空格
+    cleaned_text = re.sub(pattern_preserve_single_space, r' \2 ', cleaned_text)
+    
+    # 去除首尾空白
+    cleaned_text = cleaned_text.strip()
+    
+    # 最终去除连续的空格
+    cleaned_text = re.sub(r'\s+', ' ', cleaned_text)
+    
+    return cleaned_text
+
+
+def expand_answers(answers: List[str]):
+    copy_answers = answers.copy()
+    res = set(answers)
+    for single_answer in answers:
+        if normalize_answer(single_answer) != "":
+            res.add(normalize_answer(single_answer))
+        original_answer = single_answer
+        single_answer = unicodedata.normalize('NFD', single_answer)
+        single_answer = tokenizer.tokenize(single_answer)
+        single_answer = single_answer.words(uncased=True)
+        for idx, word in enumerate(single_answer):
+            if word in num2alpha.keys():
+                cnt = 0
+                for word_before in single_answer[:idx]:
+                    if word in word_before:
+                        cnt += 1
+                pos = 0
+                while pos < len(original_answer) - len(word) + 1:
+                    if original_answer[pos:].startswith(word):
+                        if cnt == 0:
+                            res.add(original_answer[:pos] + num2alpha[word] + original_answer[pos+len(word):])
+                            break
+                        pos += len(word)
+                        cnt -= 1
+                    else:
+                        pos += 1
+    for i in res:
+        if i.lower() not in [c.lower() for c in copy_answers] and i != "":
+            copy_answers.append(i)
+    return copy_answers
+
+def might_right_answers(answers):
+    ans = set(answers)
+    res = set()
+    for single_answer in answers:
+        original_answer = single_answer
+        single_answer = unicodedata.normalize('NFD', single_answer)
+        single_answer = tokenizer.tokenize(single_answer)
+        single_answer = single_answer.words(uncased=True)
+        for idx, word in enumerate(single_answer):
+            for spand_len in range(1, len(single_answer)):
+                cand_fake_ans = " ".join(single_answer[:idx] + single_answer[idx + spand_len:])
+                if _remove_proj(normalize_answer(cand_fake_ans)).replace(" ","") != "":
+                    res.add(cand_fake_ans)
+    return list(res - ans)
+
+def _remove_proj(text):
+    text = re.sub(r"\b(in|on|at|by|with|for|of|to)\b", " ", text)
+    return text
+
+def normalize_answer(s):
+    def remove_articles(text):
+        return re.sub(r"\b(a|an|the)\b", " ", text)
+
+    def white_space_fix(text):
+        return " ".join(text.split())
+
+    def remove_punc(text):
+        exclude = set(string.punctuation)
+        return "".join(ch for ch in text if ch not in exclude)
+
+    def lower(text):
+        return text.lower()
+
+    return white_space_fix(remove_articles(remove_punc(lower(s))))
+
+def EM_compute(answer_list, prediction):
+    return max([int(normalize_answer(prediction) == normalize_answer(ground_truth)) for ground_truth in answer_list])
+
+def AC_compute(answer_list, prediction):
+    pred = normalize_answer(prediction)
+    for answer in answer_list:
+        if normalize_answer(answer) in pred:
+            return 1
+    return 0
+
+
+def F1_compute(answers, pred):
+    def get_tokens(s):
+        if not s: return []
+        return normalize_answer(s).split()
+
+    def compute_f1(a_gold, a_pred):
+        gold_toks = get_tokens(a_gold)
+        pred_toks = get_tokens(a_pred)
+        common = collections.Counter(gold_toks) & collections.Counter(pred_toks)
+        num_same = sum(common.values())
+        if len(gold_toks) == 0 or len(pred_toks) == 0:
+            # If either is no-answer, then F1 is 1 if they agree, 0 otherwise
+            return int(gold_toks == pred_toks)
+        if num_same == 0:
+            return 0
+        precision = 1.0 * num_same / len(pred_toks)
+        recall = 1.0 * num_same / len(gold_toks)
+        f1 = (2 * precision * recall) / (precision + recall)
+        return f1
+    return max([compute_f1(x, pred) for x in answers])
+
+
+def deal_judge(pred):
+    if pred is None:
+        return True
+    if has_answer(["unknown", "no specific answer", "not provide", "cannot answer", "no information provided", "no answer", "not contain", "no definitive answer"], pred):
+        return True
+    return False
+
+
+def deal_answer(pred, answers):
+    if pred is None:
+        return 0, 0
+    if pred.lower().startswith("answer:"):
+        pred = pred[7:]
+    return EM_compute(answers, pred), F1_compute(answers, pred)
+        
+
+def deal_post(pred):
+    giveup, istrue = True, None
+    if pred is None:
+        return giveup, istrue
+    if has_answer(["unclear", "not clear", "unknown", "partially correct", "partially incorrect", "not correct", "cannot determine", "cannot answer", "not incorrect", "incomplete"], pred):
+        giveup = True
+    elif has_answer(["correct", "true"], pred):
+        giveup, istrue = False, True
+    elif has_answer(["incorrect", "false"], pred):
+        giveup, istrue = False, False
+    else:
+        giveup = True
+    return giveup, istrue
+
+
+def str2paras(s):
+        if s is None:
+            return None
+        paras = []
+        for text in s.split('\n'):
+            if text.strip() != '':
+                paras.append(": " + text)
+        return paras
+
+
+# if __name__ == "__main__":
+#     file_list = os.listdir('d:/pycharmfiles/chat')
+
+#     for file in file_list:
+#         if not file.endswith('post'):
+#             continue
+#         print(file)
+#         indir = os.path.join('d:/pycharmfiles/chat', file)
+#         outdir = os.path.join('d:/pycharmfiles/llm_re/nq/data', file)
+#         outstr = ""
+#         infile = open(indir, 'r', encoding='utf-8')
+#         for line in tqdm(infile.readlines()):
+#             d = json.loads(line)
+#             if 'Prediction' in d.keys():
+#                 d['Giveup'], d['EM'], d['F1'] =  deal_answer(d['Prediction'], d['reference'])
+#             if 'Post' in d.keys():
+#                 d['Post_Giveup'], d['Post_True']= deal_post(d['Post'])
+#             outstr += json.dumps(d) + '\n'
+#         infile.close()
+#         outfile = open(outdir, 'w', encoding='utf-8')
+#         outfile.write(outstr)
+#         outfile.close()
+
+
+def load_source(file):
+    data = []
+    f = open(file, 'r', encoding='utf-8')
+    for line in f.readlines():
+        data.append(json.loads(line))
+    f.close()
+    return data
+
+
+def remove_punctuation(s):
+    punctuation_pattern = r"^[^\w\s]+|[^\w\s]+$"
+    return re.sub(punctuation_pattern, '', s)
+
+
+def save_file(args, results, add='res'):
+    save_dir = os.path.dirname(args.data)
+    model_base_file = os.path.basename(args.model) + \
+                      "." + os.path.basename(args.data)[:-len(".json")]
+    if args.splits:
+        model_base_file += f".{args.worker}-{args.splits}"
+    with open(os.path.join(save_dir, f"{model_base_file}.{add}.json"), 'w') as f:
+        json.dump(results, f, indent=4)
+
+
+
+def calculate_statistics(data):
+    if len(data) == 0:
+        return {
+            'mean': 0,
+            'std': 0,
+            'median': 0,
+            'min': 0,
+            'max': 0,
+            '25th_percentile': 0,
+            '75th_percentile': 0,
+        }
+    
+    return {
+        'mean': np.mean(data),
+        'std': np.std(data),
+        'median': np.median(data),
+        'min': np.min(data),
+        'max': np.max(data),
+        '25th_percentile': np.percentile(data, 25),
+        '75th_percentile': np.percentile(data, 75),
+    }
+
+
+def analyse_len(all_outputs_len, retrieval_outputs_len, no_retrieval_outputs_len, output_dir, output_stats_file):
+    all_outputs_len_stats = calculate_statistics(all_outputs_len)
+    retrieval_outputs_len_stats = calculate_statistics(retrieval_outputs_len)
+    no_retrieval_outputs_len_stats = calculate_statistics(no_retrieval_outputs_len)
+
+    # # 打印统计数据
+    # print("All outputs length statistics:", all_outputs_len_stats)
+    # print("Retrieval outputs length statistics:", retrieval_outputs_len_stats)
+    # print("No retrieval outputs length statistics:", no_retrieval_outputs_len_stats)
+    
+    with open(output_stats_file, "a") as f:  # 使用 "a" 模式追加写入
+        f.write("All outputs length statistics:\n")
+        for key, value in all_outputs_len_stats.items():
+            f.write(f"{key}: {value}\n")
+        f.write("\n")
+
+        f.write("Retrieval outputs length statistics:\n")
+        for key, value in retrieval_outputs_len_stats.items():
+            f.write(f"{key}: {value}\n")
+        f.write("\n")
+
+        f.write("No retrieval outputs length statistics:\n")
+        for key, value in no_retrieval_outputs_len_stats.items():
+            f.write(f"{key}: {value}\n")
+        f.write("\n")
+    # # 创建保存结果的目录
+    # if not os.path.exists(output_dir):
+    #     os.makedirs(output_dir)
+
+    # 绘制直方图并保存图像
+    plt.figure(figsize=(12, 8))
+
+    # 绘制所有输出长度的直方图
+    plt.subplot(2, 2, 1)
+    sns.histplot(all_outputs_len, kde=True, bins=30, color='blue', label='All Outputs', stat='density')
+    plt.title('Distribution of All Outputs Length')
+    plt.xlabel('Length')
+    plt.ylabel('Density')
+    # plt.savefig(os.path.join(output_dir, 'all_outputs_length_distribution.png'))
+
+    # 绘制检索输出长度的直方图
+    plt.subplot(2, 2, 2)
+    sns.histplot(retrieval_outputs_len, kde=True, bins=30, color='green', label='Retrieval Outputs', stat='density')
+    plt.title('Distribution of Retrieval Outputs Length')
+    plt.xlabel('Length')
+    plt.ylabel('Density')
+    # plt.savefig(os.path.join(output_dir, 'retrieval_outputs_length_distribution.png'))
+
+    # 绘制没有检索输出长度的直方图
+    plt.subplot(2, 2, 3)
+    sns.histplot(no_retrieval_outputs_len, kde=True, bins=30, color='red', label='No Retrieval Outputs', stat='density')
+    plt.title('Distribution of No Retrieval Outputs Length')
+    plt.xlabel('Length')
+    plt.ylabel('Density')
+    # plt.savefig(os.path.join(output_dir, 'no_retrieval_outputs_length_distribution.png'))
+
+    # 总体输出长度分布
+    plt.subplot(2, 2, 4)
+    sns.histplot(all_outputs_len, kde=True, bins=30, color='blue', label='All Outputs', stat='density', alpha=0.5)
+    sns.histplot(retrieval_outputs_len, kde=True, bins=30, color='green', label='Retrieval Outputs', stat='density', alpha=0.5)
+    sns.histplot(no_retrieval_outputs_len, kde=True, bins=30, color='red', label='No Retrieval Outputs', stat='density', alpha=0.5)
+    plt.title('Overall Distribution of Outputs Length')
+    plt.xlabel('Length')
+    plt.ylabel('Density')
+    plt.legend()
+    # plt.savefig(os.path.join(output_dir, 'overall_output_length_distribution.png'))
+
+    # 保存所有图像
+    plt.tight_layout()
+    plt.savefig(os.path.join(output_dir, 'combined_output_length_distribution.png'))
+
+    plt.show()
+
+def has_run_retrieve(sample):
+    return bool (sample["search_count"])
+
+def cal_has_answer(sample):
+    reason_has, search_has, analyses_has = 0, 0, 0
+    for info in sample["all_info"]:
+        for k, v in info.items():
+            if "reason" in k:
+                reason_has = max(reason_has, has_answer(sample['answer'], v))
+            elif "search" in k:
+                search_has = max(search_has, has_answer(sample['answer'], v))
+            elif "analyses" in k:
+                analyses_has = max(analyses_has, has_answer(sample['answer'], v))
+    return {'reason': reason_has, 'search': search_has, 'analyse': analyses_has}
+
+def extract_answer(sample):
+    output = sample.get('output', '')
+    match = re.search(r'\\boxed\{(.*?)\}', output)
+    if match:
+        return match.group(1)
+    return output.rsplit('\n', 1)[-1]
+
+def cal_metrics(sample):
+    res = {}
+    pred = extract_answer(sample)
+    for m, func in {
+        'em': EM_compute,
+        'ac': AC_compute,
+        'f1': F1_compute,
+    }.items():
+        res[m] = func(sample['answer'], pred)
+    res.update(cal_has_answer(sample))
+    res['search_count'] = sample['search_count']
+    return res
+
+def add_eval(model_path, data_path):
+
+   
+    output_dir = os.path.dirname(data_path)
+    output_stats_file = os.path.join(output_dir, "output_stats.txt")
+    # model = AutoModelForCausalLM.from_pretrained(model_path).to(torch.bfloat16).to("cuda")
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+
+
+    with open(data_path, encoding="utf-8") as f:
+        results = json.load(f)
+
+    # 初始化累加器
+    total_metrics = {}
+    retrieval_true_metrics = {}
+    retrieval_false_metrics = {}
+    count_total = 0
+    count_retrieval_true = 0
+    count_retrieval_false = 0
+
+    # 计算平均长度
+    all_outputs_len = []
+    retrieval_outputs_len = []
+    no_retrieval_outputs_len = []
+
+    # 遍历每个样本并计算指标
+    for sample in results:
+        sample.update(sample["item"])
+        metrics = cal_metrics(sample)
+        
+        output_ids = tokenizer(sample["output"], add_special_tokens=False)["input_ids"]
+        all_outputs_len.append(len(output_ids))
+
+        # 累加总的指标
+        for key, value in metrics.items():
+            total_metrics[key] = total_metrics.get(key, 0) + value
+        
+        # 根据是否跑了检索进行分类累加
+        if has_run_retrieve(sample):
+            retrieval_outputs_len.append(len(output_ids))
+
+            for key, value in metrics.items():
+                retrieval_true_metrics[key] = retrieval_true_metrics.get(key, 0) + value
+            count_retrieval_true += 1
+        else:
+            no_retrieval_outputs_len.append(len(output_ids))
+            for key, value in metrics.items():
+                retrieval_false_metrics[key] = retrieval_false_metrics.get(key, 0) + value
+            count_retrieval_false += 1
+        
+        count_total += 1
+
+    # 计算均值
+    mean_metrics = {key: value / count_total for key, value in total_metrics.items()}
+    mean_retrieval_true_metrics = {key: value / count_retrieval_true for key, value in retrieval_true_metrics.items()}
+    mean_retrieval_false_metrics = {key: value / count_retrieval_false for key, value in retrieval_false_metrics.items()}
+    
+    mean_all_output_len = sum(all_outputs_len) / len(all_outputs_len) if len(all_outputs_len) != 0 else 0
+    mean_retrieval_outputs_len = sum(retrieval_outputs_len) / len(retrieval_outputs_len) if len(retrieval_outputs_len) != 0 else 0
+    mean_no_retrieval_outputs_len = sum(no_retrieval_outputs_len) / len(no_retrieval_outputs_len) if len(no_retrieval_outputs_len) != 0 else 0
+
+    analyse_len(all_outputs_len, retrieval_outputs_len, no_retrieval_outputs_len, output_dir, output_stats_file)
+
+    # print(count_retrieval_false/count_total)
+    # print(count_retrieval_true/count_total)
+
+    # # 打印结果
+    # print(f"model_path: {model_path}")
+    # print(f"data_path: {data_path}")
+    # print("Overall Mean Metrics:")
+    # for key, value in mean_metrics.items():
+    #     print(f"{key}: {value}")
+    # print(f"output_len: {mean_all_output_len}")
+
+    # print("\nMean Metrics for Samples with Retrieval:")
+    # for key, value in mean_retrieval_true_metrics.items():
+    #     print(f"{key}: {value}")
+    # print(f"output_len: {mean_retrieval_outputs_len}")
+
+    # print("\nMean Metrics for Samples without Retrieval:")
+    # for key, value in mean_retrieval_false_metrics.items():
+    #     print(f"{key}: {value}")
+    # print(f"output_len: {mean_no_retrieval_outputs_len}")
+    with open(output_stats_file, "a") as f:
+        f.write(f"\nProportion of samples without retrieval: {count_retrieval_false / count_total}\n")
+        f.write(f"Proportion of samples with retrieval: {count_retrieval_true / count_total}\n")
+
+        f.write(f"model_path: {model_path}\n")
+        f.write(f"data_path: {data_path}\n")
+        f.write("Overall Mean Metrics:\n")
+        for key, value in mean_metrics.items():
+            f.write(f"{key}: {value}\n")
+        f.write(f"output_len: {mean_all_output_len}\n\n")
+
+        f.write("Mean Metrics for Samples with Retrieval:\n")
+        for key, value in mean_retrieval_true_metrics.items():
+            f.write(f"{key}: {value}\n")
+        f.write(f"output_len: {mean_retrieval_outputs_len}\n\n")
+
+        f.write("Mean Metrics for Samples without Retrieval:\n")
+        for key, value in mean_retrieval_false_metrics.items():
+            f.write(f"{key}: {value}\n")
+        f.write(f"output_len: {mean_no_retrieval_outputs_len}\n")
+
+        

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/evaluate.py

@@ -0,0 +1,452 @@
+import sys
+sys.path.append("..")
+
+import re
+import json
+import numpy as np
+from collections import Counter
+import string
+import os, time
+from collections import defaultdict
+from lcb_runner.evaluation import codegen_metrics
+from utils.math_equivalence import is_equiv
+
+
+def extract_answer(output, mode='gen'):
+    extracted_text = ''
+    if output is None:
+        output = "None"
+    if mode == 'codegen':
+        # Extract the code between ```python and ```
+        pattern = r'```python\s*(.*?)\s*```'
+        matches = re.findall(pattern, output, re.DOTALL | re.IGNORECASE)
+        if matches:
+            extracted_text = matches[-1].strip()  # Take the last match
+    elif mode == 'infogen': # 提取模型基于网页内容生成的推理
+        # Extract content after **Final Information** or **Modified Reasoning Steps**
+        # pattern_info = "\n**Final Information**"
+        # pattern_step = "\n**Modified Reasoning Steps**"
+        pattern_info = "**Final Information**"
+        pattern_step = "**Modified Reasoning Steps**"
+        if pattern_info in output:
+            extracted_text = output.split(pattern_info)[-1].replace("\n","").strip("```").strip()
+        elif pattern_step in output:
+            extracted_text = output.split(pattern_step)[-1].strip("```").strip()
+        else:
+            # extracted_text = "No helpful information found."
+            extracted_text = output
+    else:
+        # Existing extraction logic for 'gen' and 'choose' modes
+        pattern = r'\\boxed\{(.*)\}'
+        matches = re.findall(pattern, output)
+        if matches:
+            extracted_text = matches[-1]  # Take the last match
+            if mode in ['choose', 'qa']:
+                # Handle 'choose' mode
+                inner_pattern = r'\\text\{(.*)\}'
+                inner_matches = re.findall(inner_pattern, extracted_text)
+                if inner_matches:
+                    extracted_text = inner_matches[-1]  # Take the last match
+                extracted_text = extracted_text.strip("()")
+    return extracted_text
+
+
+def normalize_answer(text):
+    text = text.lower()
+    text = " ".join(text.strip().split())
+    return text
+
+def normalize_answer_qa(s):
+    def remove_articles(text):
+        return re.sub(r"\b(a|an|the)\b", " ", text)
+    def white_space_fix(text):
+        return " ".join(text.strip().split())
+    def remove_punc(text):
+        exclude = set(string.punctuation)
+        return "".join(ch for ch in text if ch not in exclude)
+    def lower(text):
+        return text.lower()
+    return white_space_fix(remove_articles(remove_punc(lower(s))))
+
+
+def evaluate_predictions(output, labeled_answer, mode='gen'):
+    final_metric = {"is_valid_answer": False, "acc": 0, "em": 0, "f1": 0, 'math_equal': 0}
+    # is_valid_answer: 是否存在有效的预测答案。
+    # acc: 精度（accuracy）。指标注答案是否出现在预测答案中
+    # em: 完全匹配（exact match）。指预测答案是否与标注答案完全相同
+    # f1: F1 分数。
+    # math_equal: 数学上的相等性（通常用于判断数值是否相等）
+    pred_answer = extract_answer(output, mode=mode)
+    if pred_answer != '': # 模型给出了有效的预测答案
+        final_metric["is_valid_answer"] = True
+
+    if mode == 'qa':
+        normalized_pred_answer = normalize_answer_qa(pred_answer)
+        # print(f"normalized_pred_answer: {normalized_pred_answer}")
+        for answer in labeled_answer:
+            normalized_ground_truth = normalize_answer_qa(answer)
+            # print(f"normalized_ground_truth: {normalized_ground_truth}--")
+            em = int(normalized_pred_answer == normalized_ground_truth)
+            acc = int(normalized_ground_truth in normalized_pred_answer)
+
+            # 将预测答案和标注答案分割成单词或词汇 tokens，并计算它们的交集（即相同的词汇）。
+            # Counter 是一个字典类型的对象，用于统计词汇的频次，& 操作符求得两个 Counter 对象的交集
+            prediction_tokens = normalized_pred_answer.split()
+            ground_truth_tokens = normalized_ground_truth.split()
+            common = Counter(prediction_tokens) & Counter(ground_truth_tokens)
+            num_same = sum(common.values())
+            if num_same == 0:
+                continue
+            precision = 1.0 * num_same / len(prediction_tokens)
+            recall = 1.0 * num_same / len(ground_truth_tokens)
+            f1 = (2 * precision * recall) / (precision + recall)
+            for k in ["em", "acc", "f1"]:
+                final_metric[k] = max(eval(k), final_metric[k])
+
+    else:
+        normalized_pred_answer = normalize_answer(pred_answer)
+        normalized_ground_truth = normalize_answer(labeled_answer)
+
+        em = int(normalized_pred_answer == normalized_ground_truth)
+        acc = int(normalized_ground_truth in normalized_pred_answer)
+    
+        prediction_tokens = normalized_pred_answer.split()
+        ground_truth_tokens = normalized_ground_truth.split()
+        common = Counter(prediction_tokens) & Counter(ground_truth_tokens)
+        num_same = sum(common.values())
+        if num_same == 0:
+            f1 = 0
+        else:
+            precision = 1.0 * num_same / len(prediction_tokens) if len(prediction_tokens) > 0 else 0
+            recall = 1.0 * num_same / len(ground_truth_tokens) if len(ground_truth_tokens) > 0 else 0
+            if (precision + recall) == 0:
+                f1 = 0
+            else:
+                f1 = (2 * precision * recall) / (precision + recall)
+
+        final_metric["em"] = em
+        final_metric["acc"] = acc
+        final_metric["f1"] = f1
+
+        final_metric["math_equal"] = is_equiv(normalized_pred_answer, normalized_ground_truth)
+
+    # print(em, acc, f1, normalized_pred_answer, '|', normalized_ground_truth)
+    return final_metric, pred_answer
+
+
+
+def run_evaluation(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, split, apply_backoff=False):
+    if dataset_name == 'livecode':
+        # Prepare samples and generations for codegen_metrics
+        samples_list = []
+        generations_list = []
+
+        # Collect difficulty levels for per-domain metrics
+        difficulties = []
+        per_difficulty_count = {}
+        num_valid_answer = 0
+
+        for item, input_prompt, result in zip(filtered_data, input_list, output_list):
+            if type(result) == str:
+                item['Output'] = result
+            else:
+                item['Output'] = result.outputs[0].text
+            difficulty = item.get("difficulty", "Unknown")
+            difficulties.append(difficulty)
+            # Track metrics per domain
+            if difficulty not in per_difficulty_count.keys():
+                per_difficulty_count[difficulty] = 0
+
+            pred_code = extract_answer(item['Output'], mode='codegen')
+            if pred_code != '':
+                num_valid_answer += 1
+                per_difficulty_count[difficulty] += 1
+            # Assuming each item has 'input_output' with 'inputs' and 'outputs'
+            public_test_cases = json.loads(item.get("public_test_cases", "{}"))
+
+            inputs, outputs = [], []
+            for case in public_test_cases:
+                inputs.append(case["input"])
+                outputs.append(case["output"])
+
+            sample = {
+                "input_output": json.dumps({
+                    "inputs": inputs,
+                    "outputs": outputs
+                }),
+            }
+
+            samples_list.append(sample)
+            generations_list.append([pred_code])
+            item['Pred_Answer'] = pred_code
+            item['Question'] = input_prompt
+
+
+        # Call codegen_metrics with pass@1
+        metrics, results, final_metadata = codegen_metrics(
+            samples_list,
+            generations_list,
+            k_list=[1],  # Evaluate the top 1 generated result
+            num_process_evaluate=2,   # Parallel evaluation
+            timeout=10,  # Set timeout to 10 seconds
+            debug=False,  # Enable debug mode
+        )
+        # print('samples_list', samples_list)
+        # print('generations_list', generations_list)
+        # print('metrics', metrics)
+
+        # Extract pass@1
+        pass_at_1 = metrics.get('pass@1', 0.0)
+        detail_pass_at_1 = metrics['detail']['pass@1']
+
+        for item, pass1, res, meta in zip(filtered_data, detail_pass_at_1.values(), results.values(), final_metadata):
+            item['Metrics'] = {'pass@1': pass1}
+            item['Results'] = res
+            item['Final_metadata'] = meta
+
+        # Initialize per-difficulty metrics
+        difficulty_metrics = defaultdict(list)
+        for idx, difficulty in enumerate(difficulties):
+            pass1 = detail_pass_at_1[idx]
+            difficulty_metrics[difficulty].append(pass1)
+
+        # Compute overall pass@1
+        overall_metrics = {
+            'pass@1': pass_at_1,  # / num_valid_answer * len(input_list),
+            'num_valid_answer': f'{num_valid_answer} of {len(input_list)}',
+            'query_latency': f'{(total_time / len(input_list) * 1000):.0f} ms',
+        }
+
+        # Compute per-difficulty pass@1
+        per_difficulty_metrics = {}
+        for difficulty, passes in difficulty_metrics.items():
+            avg_pass = np.mean(passes) if len(passes) > 0 else 0.0
+            num_valid_answer = per_difficulty_count[difficulty]
+            per_difficulty_metrics[difficulty] = {
+                'pass@1': avg_pass,
+                'num_valid_answer': f'{num_valid_answer} of {len(passes)}'
+            }
+
+        # Save the metrics
+        final_metrics = {
+            'overall': overall_metrics,
+            'per_domain': per_difficulty_metrics
+        }
+
+    else:
+        # Existing evaluation for other datasets
+        avg_em, avg_acc, avg_f1, avg_math = [], [], [], []
+        num_valid_answer = 0
+
+        # If the dataset is GPQA, track metrics per domain
+        domain_metrics = {}
+
+        for item, input_prompt, result in zip(filtered_data, input_list, output_list):
+            if type(result) == str:
+                item['Output'] = result
+            else:
+                item['Output'] = result.outputs[0].text
+            if dataset_name in ['gpqa', 'medmcqa']:
+                labeled_answer = item["Correct Choice"]
+                # labeled_choice_answer = item["Correct Answer"]
+                mode = 'choose'
+            elif dataset_name in ['math500', 'aime', 'amc']:
+                labeled_answer = item["answer"]
+                mode = 'gen'
+            elif dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','frames', 'realqa', 'realqa_new', 'syn_en', 'syn_zh','musique_syn', 'eval', 'new', 'chinese_simpleqa', 'simpleqa', 'nq', 'triviaqa', 'hotpotqa', 'musique', 'bamboogle', '2wiki']:
+                labeled_answer = item["answer"]
+                mode = 'qa'
+            elif dataset_name in ['pubhealth']:
+                labeled_answer = item["answer"]
+                mode = 'choose'
+            else:
+                # raise ValueError(f"Unknown dataset_name: {dataset_name}")
+                labeled_answer = item["answer"]
+                mode = 'qa'
+
+            metric, pred_answer = evaluate_predictions(output=item['Output'], labeled_answer=labeled_answer, mode=mode)
+            item['Pred_Answer'] = pred_answer
+            item['Metrics'] = metric
+            item['Question'] = input_prompt
+
+            # Determine the validity of the predicted answer
+            my_method_valid = (pred_answer != '' and not (mode == 'choose' and dataset_name == 'gpqa' and len(pred_answer) > 1))
+
+            avg_em.append(metric['em'])
+            avg_acc.append(metric['acc'])
+            avg_f1.append(metric['f1'])
+            avg_math.append(metric['math_equal'])
+
+            if my_method_valid:
+                num_valid_answer += 1
+
+            # If the dataset is GPQA, attempt to track metrics per domain
+            if dataset_name == 'gpqa':
+                domain = item.get("High-level domain", "Unknown")
+                if domain not in domain_metrics:
+                    domain_metrics[domain] = {'em': [], 'acc': [], 'f1': [], 'math_equal': [], 'num_valid_answer': 0, 'total_num': 0}
+                domain_metrics[domain]['total_num'] += 1
+                domain_metrics[domain]['em'].append(metric['em'])
+                domain_metrics[domain]['acc'].append(metric['acc'])
+                domain_metrics[domain]['f1'].append(metric['f1'])
+                domain_metrics[domain]['math_equal'].append(metric['math_equal'])
+                if my_method_valid:
+                    domain_metrics[domain]['num_valid_answer'] += 1
+
+        t = time.localtime()
+        result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+        metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+
+        # Compute overall metrics
+        overall_results = {
+            'em': np.mean(avg_em) if len(avg_em) > 0 else 0.0,
+            'acc': np.mean(avg_acc) if len(avg_acc) > 0 else 0.0,
+            'f1': np.mean(avg_f1) if len(avg_f1) > 0 else 0.0,
+            'math_equal': np.mean(avg_math) if len(avg_em) > 0 else 0.0,
+            'num_valid_answer': f'{num_valid_answer} of {len(input_list)}',
+            'query_latency': f'{(total_time / len(input_list) * 1000):.0f} ms',
+        }
+
+        # If the dataset is GPQA, output average metrics per domain
+        domain_avg_metrics = {}
+        if dataset_name == 'gpqa':
+            for dm, m in domain_metrics.items():
+                domain_avg_metrics[dm] = {
+                    'em': np.mean(m['em']) if len(m['em']) > 0 else 0,
+                    'acc': np.mean(m['acc']) if len(m['acc']) > 0 else 0,
+                    'f1': np.mean(m['f1']) if len(m['f1']) > 0 else 0,
+                    'math_equal': np.mean(m['math_equal']) if len(m['math_equal']) > 0 else 0,
+                    'num_valid_answer': f'{m["num_valid_answer"]} of {m["total_num"]}'
+                }
+
+        # 保存总体和分domain的指标
+        final_metrics = {'overall': overall_results}
+        if dataset_name == 'gpqa':
+            final_metrics['per_domain'] = domain_avg_metrics
+
+    t = time.localtime()
+    result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+    metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+    if apply_backoff:
+        result_json_name = output_dir
+        metrics_json_name = output_dir.replace('.json', '.metrics.backoff.json')
+
+    # Save prediction results and metrics
+    with open(os.path.join(output_dir, result_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(filtered_data, json_file, indent=4, ensure_ascii=False)
+
+    with open(os.path.join(output_dir, metrics_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(final_metrics, json_file, indent=4, ensure_ascii=False)
+
+
+
+def run_evaluation_for_eval(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, split, apply_backoff=False):
+    if dataset_name not in  ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','eval', 'musique_syn', 'realqa_new', 'realqa']:
+        raise ValueError(f"Unsupported dataset: {dataset_name}")
+    else:
+        # Existing evaluation for other datasets
+        avg_em, avg_acc, avg_f1, avg_math = [], [], [], []
+        num_valid_answer = 0
+
+        # If the dataset is eval, track metrics per source
+        source_metrics = {}
+
+
+        
+        for item, input_prompt, result in zip(filtered_data, input_list, output_list):
+            if type(result) == str:
+                item['Output'] = result
+            else:
+                item['Output'] = result.outputs[0].text
+            if dataset_name in ['gpqa', 'medmcqa']:
+                labeled_answer = item["Correct Choice"]
+                # labeled_choice_answer = item["Correct Answer"]
+                mode = 'choose'
+            elif dataset_name in ['math500', 'aime', 'amc']:
+                labeled_answer = item["answer"]
+                mode = 'gen'
+            elif dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','frames', 'realqa', 'realqa_new', 'syn_en', 'syn_zh', 'eval','musique_syn', 'new', 'chinese_simpleqa', 'simpleqa', 'nq', 'triviaqa', 'hotpotqa', 'musique', 'bamboogle', '2wiki']:
+                labeled_answer = item["answer"]
+                mode = 'qa'
+            elif dataset_name in ['pubhealth']:
+                labeled_answer = item["answer"]
+                mode = 'choose'
+            else:
+                raise ValueError(f"Unknown dataset_name: {dataset_name}")
+
+            metric, pred_answer = evaluate_predictions(output=item['Output'], labeled_answer=labeled_answer, mode=mode)
+            item['Pred_Answer'] = pred_answer
+            item['Metrics'] = metric
+            item['Question'] = input_prompt
+
+            # Determine the validity of the predicted answer
+            my_method_valid = (pred_answer != '' and not (mode == 'choose' and dataset_name == 'gpqa' and len(pred_answer) > 1))
+
+            avg_em.append(metric['em'])
+            avg_acc.append(metric['acc'])
+            avg_f1.append(metric['f1'])
+            avg_math.append(metric['math_equal'])
+
+            if my_method_valid:
+                num_valid_answer += 1
+
+            # If the dataset is GPQA, attempt to track metrics per source
+            if dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','eval', 'musique_syn', 'realqa_new', 'realqa']:
+                source = item.get("source", "Unknown")
+                if source not in source_metrics:
+                    source_metrics[source] = {'em': [], 'acc': [], 'f1': [], 'math_equal': [], 'num_valid_answer': 0, 'total_num': 0}
+                source_metrics[source]['total_num'] += 1
+                source_metrics[source]['em'].append(metric['em'])
+                source_metrics[source]['acc'].append(metric['acc'])
+                source_metrics[source]['f1'].append(metric['f1'])
+                source_metrics[source]['math_equal'].append(metric['math_equal'])
+                if my_method_valid:
+                    source_metrics[source]['num_valid_answer'] += 1
+
+        t = time.localtime()
+        result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+        metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+
+        # Compute overall metrics
+        overall_results = {
+            'em': np.mean(avg_em) if len(avg_em) > 0 else 0.0,
+            'acc': np.mean(avg_acc) if len(avg_acc) > 0 else 0.0,
+            'f1': np.mean(avg_f1) if len(avg_f1) > 0 else 0.0,
+            'math_equal': np.mean(avg_math) if len(avg_em) > 0 else 0.0,
+            'num_valid_answer': f'{num_valid_answer} of {len(input_list)}',
+            'query_latency': f'{(total_time / len(input_list) * 1000):.0f} ms',
+        }
+
+        # If the dataset is eval, output average metrics per source
+        source_avg_metrics = {}
+        if dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','eval', 'musique_syn', 'realqa_new', 'realqa']:
+            for dm, m in source_metrics.items():
+                source_avg_metrics[dm] = {
+                    'em': np.mean(m['em']) if len(m['em']) > 0 else 0,
+                    'acc': np.mean(m['acc']) if len(m['acc']) > 0 else 0,
+                    'f1': np.mean(m['f1']) if len(m['f1']) > 0 else 0,
+                    'math_equal': np.mean(m['math_equal']) if len(m['math_equal']) > 0 else 0,
+                    'num_valid_answer': f'{m["num_valid_answer"]} of {m["total_num"]}'
+                }
+
+        # 保存总体和分source的指标
+        final_metrics = {'overall': overall_results}
+        if dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle', 'eval', 'musique_syn', 'realqa_new', 'realqa']:
+            final_metrics['per_source'] = source_avg_metrics
+
+    t = time.localtime()
+    result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+    metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+    if apply_backoff:
+        result_json_name = output_dir
+        metrics_json_name = output_dir.replace('.json', '.metrics.backoff.json')
+
+    # Save prediction results and metrics
+    with open(os.path.join(output_dir, result_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(filtered_data, json_file, indent=4, ensure_ascii=False)
+
+    with open(os.path.join(output_dir, metrics_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(final_metrics, json_file, indent=4, ensure_ascii=False)
+
+
+

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/google_search.py

@@ -0,0 +1,417 @@
+import os
+import json
+import requests
+from requests.exceptions import Timeout
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+import time
+import concurrent
+from concurrent.futures import ThreadPoolExecutor
+import pdfplumber
+from io import BytesIO
+import re
+import string
+from typing import Optional, Tuple
+from nltk.tokenize import sent_tokenize
+
+# os.environ['http_proxy'] = 'http://127.0.0.1:7890'
+# os.environ['https_proxy'] = 'http://127.0.0.1:7890'
+
+
+# ----------------------- Custom Headers -----------------------
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+                  'AppleWebKit/537.36 (KHTML, like Gecko) '
+                  'Chrome/58.0.3029.110 Safari/537.36',
+    'Referer': 'https://www.google.com/',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.5',
+    'Connection': 'keep-alive',
+    'Upgrade-Insecure-Requests': '1'
+}
+
+# Initialize session
+session = requests.Session()
+session.headers.update(headers)
+
+
+
+def remove_punctuation(text: str) -> str:
+    """Remove punctuation from the text."""
+    return text.translate(str.maketrans("", "", string.punctuation))
+
+def f1_score(true_set: set, pred_set: set) -> float:
+    """Calculate the F1 score between two sets of words."""
+    intersection = len(true_set.intersection(pred_set))
+    if not intersection:
+        return 0.0
+    precision = intersection / float(len(pred_set))
+    recall = intersection / float(len(true_set))
+    return 2 * (precision * recall) / (precision + recall)
+
+def extract_snippet_with_context(full_text: str, snippet: str, context_chars: int = 2500) -> Tuple[bool, str]:
+    """
+    Extract the sentence that best matches the snippet and its context from the full text.
+
+    Args:
+        full_text (str): The full text extracted from the webpage.
+        snippet (str): The snippet to match.
+        context_chars (int): Number of characters to include before and after the snippet.
+
+    Returns:
+        Tuple[bool, str]: The first element indicates whether extraction was successful, the second element is the extracted context.
+    # 这个 extract_snippet_with_context 函数的作用是 从一段长文本中找到最符合给定片段（snippet）的句子，并返回包含该句子的一定上下文范围的文本。它的核心逻辑包括 文本预处理、句子匹配、F1 评分计算、上下文截取 等几个步骤。
+    """
+    try:
+        full_text = full_text[:50000]
+
+        snippet = snippet.lower()
+        snippet = remove_punctuation(snippet)
+        snippet_words = set(snippet.split())
+
+        best_sentence = None
+        best_f1 = 0.2
+
+        # sentences = re.split(r'(?<=[.!?]) +', full_text)  # Split sentences using regex, supporting ., !, ? endings
+        sentences = sent_tokenize(full_text)  # Split sentences using nltk's sent_tokenize
+
+        for sentence in sentences:
+            key_sentence = sentence.lower()
+            key_sentence = remove_punctuation(key_sentence)
+            sentence_words = set(key_sentence.split())
+            f1 = f1_score(snippet_words, sentence_words)
+            if f1 > best_f1:
+                best_f1 = f1
+                best_sentence = sentence
+
+        if best_sentence:
+            para_start = full_text.find(best_sentence)
+            para_end = para_start + len(best_sentence)
+            start_index = max(0, para_start - context_chars)
+            end_index = min(len(full_text), para_end + context_chars)
+            context = full_text[start_index:end_index]
+            return True, context
+        else:
+            # If no matching sentence is found, return the first context_chars*2 characters of the full text
+            return False, full_text[:context_chars * 2]
+    except Exception as e:
+        return False, f"Failed to extract snippet context due to {str(e)}"
+
+def extract_text_from_url(url, use_jina=False, jina_api_key=None, snippet: Optional[str] = None):
+    """
+    Extract text from a URL. If a snippet is provided, extract the context related to it.
+
+    Args:
+        url (str): URL of a webpage or PDF.
+        use_jina (bool): Whether to use Jina for extraction.
+        snippet (Optional[str]): The snippet to search for.
+
+    Returns:
+        str: Extracted text or context.
+    """
+    try:
+        # print(f"extract_text_from_url use_jina: {use_jina}\n")
+        if use_jina:
+            jina_headers = {
+                'Authorization': f'Bearer {jina_api_key}',
+                'X-Return-Format': 'markdown',
+                # 'X-With-Links-Summary': 'true'
+            }
+            response = requests.get(f'https://r.jina.ai/{url}', headers=jina_headers).text
+            # Remove URLs
+            pattern = r"\(https?:.*?\)|\[https?:.*?\]"
+            text = re.sub(pattern, "", response).replace('---','-').replace('===','=').replace('   ',' ').replace('   ',' ')
+            print("use jina to extract text successfully")
+        else:
+            # print(f"don't use jina to extract text")
+            response = session.get(url, timeout=20)  # Set timeout to 20 seconds
+            response.raise_for_status()  # Raise HTTPError if the request failed
+            # Determine the content type
+            content_type = response.headers.get('Content-Type', '')
+            if 'pdf' in content_type:
+                # If it's a PDF file, extract PDF text
+                print("Extracting text from PDF...")
+                return extract_pdf_text(url)
+            # Try using lxml parser, fallback to html.parser if unavailable
+            try:
+                # print("use lxml parser to extract text")
+                soup = BeautifulSoup(response.text, 'lxml')
+            except Exception:
+                print("lxml parser not found or failed, falling back to html.parser")
+                soup = BeautifulSoup(response.text, 'html.parser')
+            text = soup.get_text(separator=' ', strip=True)
+
+        if snippet:
+            success, context = extract_snippet_with_context(text, snippet)
+            if success:
+                print("use extract_snippet_with_context to extract text successfully")
+                return context
+            else:
+                print("use extract_snippet_with_context to extract text failed")
+                return text
+        else:
+            # print("no snippet provided")
+            # If no snippet is provided, return directly
+            return text[:8000]
+            # return text[:10000]
+    except requests.exceptions.HTTPError as http_err:
+        return f"HTTP error occurred: {http_err}"
+    except requests.exceptions.ConnectionError:
+        return "Error: Connection error occurred"
+    except requests.exceptions.Timeout:
+        return "Error: Request timed out after 20 seconds"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+
+def fetch_page_content(urls, max_workers=24, use_jina=False, jina_api_key=None, snippets: Optional[dict] = None):
+    """
+    Concurrently fetch content from multiple URLs.
+
+    Args:
+        urls (list): List of URLs to scrape.
+        max_workers (int): Maximum number of concurrent threads.
+        use_jina (bool): Whether to use Jina for extraction.
+        snippets (Optional[dict]): A dictionary mapping URLs to their respective snippets.
+
+    Returns:
+        dict: A dictionary mapping URLs to the extracted content or context.
+    这段代码定义了一个名为 fetch_page_content 的函数，用于并发地从多个 URL 中提取内容。该函数使用 ThreadPoolExecutor 来并发执行提取操作
+    """
+    results = {}
+    max_workers=20
+    print(f"max_workers: {max_workers}")
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        # Use tqdm to display a progress bar
+        futures = {
+            executor.submit(extract_text_from_url, url, use_jina, jina_api_key,snippets.get(url) if snippets else None): url
+            for url in urls
+        }
+        for future in tqdm(concurrent.futures.as_completed(futures), desc="Fetching URLs", total=len(urls)):
+            url = futures[future]
+            # try:
+            #     data = future.result()
+            #     results[url] = data
+            # except Exception as exc:
+            #     results[url] = f"Error fetching {url}: {exc}"
+            # time.sleep(0.2)  # Simple rate limiting
+
+            for _ in range(5):
+                try:
+                    data = future.result()
+                    results[url] = data
+                    break
+                except Exception as exc:
+                    results[url] = f"Error fetching {url}: {exc}"
+                    time.sleep(0.2)
+    return results
+
+
+proxies = {
+    "http": "http://127.0.0.1:7890",
+    "https": "http://127.0.0.1:7890"
+}
+
+
+def google_web_search(query, subscription_key, endpoint, market='en-US', language='en', exclude_urls=[],timeout=2000):
+    """
+    Perform a search using the Bing Web Search API with a set timeout.
+
+    Args:
+        query (str): Search query.
+        subscription_key (str): Subscription key for the Bing Search API.
+        endpoint (str): Endpoint for the Bing Search API.
+        market (str): Market, e.g., "en-US" or "zh-CN".
+        language (str): Language of the results, e.g., "en".
+        timeout (int or float or tuple): Request timeout in seconds.
+                                         Can be a float representing the total timeout,
+                                         or a tuple (connect timeout, read timeout).
+
+    Returns:
+        dict: JSON response of the search results. Returns None or raises an exception if the request times out.
+    函数的目标是使用 Bing Web Search API 执行搜索，并返回 JSON 格式的结果。
+    如果请求超时或出现其他问题，返回空字典（{}）或抛出异常
+    """
+    
+    if exclude_urls:
+        
+        for site in exclude_urls:
+            query += f" -site:{site}"
+        print(f"qeury: {query}, exclude_urls: {exclude_urls}")
+    # query = query + " site:en.wikipedia.org"
+    # print(f"query: {query}")
+    payload = json.dumps({
+        "q": query,  # 设置查询内容
+        "num": 11,
+        "mkt": market,  # 设置市场
+        "setLang": language,  # 设置语言
+        "textDecorations": True,  # 启用文本装饰
+        "textFormat": "HTML"  # 设置文本格式
+    })
+    print(f"query: {query}")
+
+    headers = {
+        'X-API-KEY': subscription_key,
+        'Content-Type': 'application/json'
+    }
+    error_cnt = 0
+    while True:
+        if error_cnt == 20:
+            print(f"qery: {query} has tried {error_cnt} times without success, just skip it.")
+            break
+        try:
+            # 发送POST请求
+            response = requests.request("POST", endpoint, headers=headers, data=payload, proxies=proxies, timeout=timeout)
+            # response = requests.request("POST", endpoint, headers=headers, data=payload, timeout=timeout)
+            response.raise_for_status()  # Raise exception if the request failed 检查响应的状态码。如果返回的状态码是 4xx 或 5xx（表示客户端或服务器错误），它将引发 requests.exceptions.HTTPError 异常
+            search_results = response.json() #
+            return search_results
+        except Timeout:
+            error_cnt += 1
+            print(f"error_cnt: {error_cnt}, Bing Web Search request timed out ({timeout} seconds) for query: {query}")
+            time.sleep(5)
+            # return {}  # Or you can choose to raise an exception
+        except requests.exceptions.RequestException as e:
+            error_cnt += 1
+            print(f"error_cnt: {error_cnt}, Error occurred during Bing Web Search request: {e}, payload: {payload}")
+            time.sleep(5)
+            # return {}
+
+
+def extract_pdf_text(url):
+    """
+    Extract text from a PDF.
+
+    Args:
+        url (str): URL of the PDF file.
+
+    Returns:
+        str: Extracted text content or error message.
+    """
+    try:
+        response = session.get(url, timeout=20)  # Set timeout to 20 seconds
+        if response.status_code != 200:
+            return f"Error: Unable to retrieve the PDF (status code {response.status_code})"
+        
+        # Open the PDF file using pdfplumber
+        with pdfplumber.open(BytesIO(response.content)) as pdf:
+            full_text = ""
+            for page in pdf.pages:
+                text = page.extract_text()
+                if text:
+                    full_text += text
+        
+        # Limit the text length
+        cleaned_text = ' '.join(full_text.split()[:600])
+        return cleaned_text
+    except requests.exceptions.Timeout:
+        return "Error: Request timed out after 20 seconds"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# def extract_relevant_info(search_results):
+#     """
+#     Extract relevant information from Bing search results.
+
+#     Args:
+#         search_results (dict): JSON response from the Bing Web Search API.
+
+#     Returns:
+#         list: A list of dictionaries containing the extracted information.
+#     """
+#     useful_info = []
+    
+#     if 'webPages' in search_results and 'value' in search_results['webPages']: # value 通常是一个列表，包含了搜索结果的每个页面信息
+#         for id, result in enumerate(search_results['webPages']['value']):
+#             info = {
+#                 'id': id + 1,  # Increment id for easier subsequent operations 为每个结果分配一个 id，id + 1 是为了让 ID 从 1 开始，而不是从 0 开始。这对后续操作更直观
+#                 'title': result.get('name', ''), # 每个搜索结果中提取标题
+#                 'url': result.get('url', ''), # 每个搜索结果中提取 URL
+#                 'site_name': result.get('siteName', ''), # 每个搜索结果中提取站点名称
+#                 'date': result.get('datePublished', '').split('T')[0], # 提取搜索结果的发布时间
+#                 'snippet': result.get('snippet', ''),  # Remove HTML tags : 提取搜索结果的简短描述（即摘要或片段），result.get('snippet', '')。这里的 snippet 可能包含 HTML 标签，因此需要在后续的处理中可能会清除这些标签
+#                 # Add context content to the information
+#                 'context': ''  # Reserved field to be filled later
+#             }
+#             useful_info.append(info)
+    
+#     return useful_info
+
+def extract_relevant_info(search_results):
+    """
+    Extract relevant information from Bing search results.
+
+    Args:
+        search_results (dict): JSON response from the Bing Web Search API.
+
+    Returns:
+        list: A list of dictionaries containing the extracted information.
+    """
+    useful_info = []
+
+    if search_results == None:
+        return useful_info
+
+    if 'organic' in search_results : # value 通常是一个列表，包含了搜索结果的每个页面信息
+        for id, result in enumerate(search_results['organic']):
+            info = {
+                'id': id + 1,  # Increment id for easier subsequent operations 为每个结果分配一个 id，id + 1 是为了让 ID 从 1 开始，而不是从 0 开始。这对后续操作更直观
+                'title': result.get('title', ''), # 每个搜索结果中提取标题
+                'url': result.get('link', ''), # 每个搜索结果中提取 URL
+                'site_name': result.get('siteName', ''), # 每个搜索结果中提取站点名称
+                'date': result.get('datePublished', '').split('T')[0], # 提取搜索结果的发布时间
+                'snippet': result.get('snippet', ''),  # Remove HTML tags : 提取搜索结果的简短描述（即摘要或片段），result.get('snippet', '')。这里的 snippet 可能包含 HTML 标签，因此需要在后续的处理中可能会清除这些标签
+                # Add context content to the information
+                'context': ''  # Reserved field to be filled later
+            }
+            useful_info.append(info)
+    else:
+        print("No organic results found.")
+    print(f"len of useful_info: {len(useful_info)}")
+    return useful_info
+
+
+# ------------------------------------------------------------
+
+if __name__ == "__main__":
+    # Example usage
+    # Define the query to search
+    # query = "Structure of dimethyl fumarate"
+    
+    # # Subscription key and endpoint for Bing Search API
+    # BING_SUBSCRIPTION_KEY = "cb0d28279a826d7e5cf22d71f683c77ffd4ba27d"
+    # if not BING_SUBSCRIPTION_KEY:
+    #     raise ValueError("Please set the BING_SEARCH_V7_SUBSCRIPTION_KEY environment variable.")
+    
+    # bing_endpoint = "https://google.serper.dev/search"
+    
+    # # Perform the search
+    # print("Performing Bing Web Search...")
+    # search_results = bing_web_search(query, BING_SUBSCRIPTION_KEY, bing_endpoint)
+    # print(search_results)
+
+
+
+    result = bing_web_search("when does season 14 of grey's anatomy come out", 'cb0d28279a826d7e5cf22d71f683c77ffd4ba27d', 'https://google.serper.dev/search')
+
+    print(result)
+    # print("Extracting relevant information from search results...")
+    # extracted_info = extract_relevant_info(search_results)
+
+    # print("Fetching and extracting context for each snippet...")
+    # for info in tqdm(extracted_info, desc="Processing Snippets"):
+    #     full_text = extract_text_from_url(info['url'], use_jina=False, jina_api_key="jina_04d684ee4cc54d2ebe7c43bb7ad4aff0qlkdZGwm14NFBtm5BDkgK9KNf6vQ", snippet=info["snippet"])  # Get full webpage text
+    #     if full_text and not full_text.startswith("Error"):
+    #         success, context = extract_snippet_with_context(full_text, info['snippet'])
+    #         if success:
+    #             info['context'] = context
+    #             print("-------------------")
+    #             print(f"Snippet: {info['snippet']}\nContext: {context}")
+                
+    #         else:
+    #             info['context'] = f"Could not extract context. Returning first 8000 chars: {full_text[:8000]}"
+    #     else:
+    #         info['context'] = f"Failed to fetch full text: {full_text}"
+
+    # print("Your Search Query:", query)
+    # print("Final extracted information with context:")
+    # print(json.dumps(extracted_info, indent=2, ensure_ascii=False))

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/inference.py

@@ -0,0 +1,759 @@
+# run_search_o1.py
+import os
+import json
+import time
+import re
+from tqdm import tqdm
+import numpy as np
+import torch
+import string
+from typing import Optional, Tuple, List, Dict
+import argparse
+from functools import partial
+
+import multiprocessing
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+from google_search import (
+    google_web_search, 
+    extract_relevant_info, 
+    fetch_page_content, 
+    extract_snippet_with_context
+)
+from evaluate import (
+    run_evaluation, 
+    run_evaluation_for_eval,
+    extract_answer
+)
+from prompts import (
+    get_multiqa_search_o1_instruction,
+    get_task_instruction_openqa,
+    get_task_instruction_math,
+    get_webpage_to_reasonchain_instruction
+)
+
+from functools import partial
+from openai import OpenAI
+
+from add_eval import add_eval
+
+
+
+# Define special tokens
+BEGIN_SEARCH_QUERY = "<|begin_search_query|>"
+END_SEARCH_QUERY = "<|end_search_query|>"
+BEGIN_SEARCH_RESULT = "<|begin_search_result|>"
+END_SEARCH_RESULT = "<|end_search_result|>"
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run Search O1 for various datasets and models.")
+
+
+    parser.add_argument(
+        '--dataset_name',
+        type=str,
+        required=True,
+        help="Name of the dataset to use."
+    )
+
+
+
+    parser.add_argument(
+        '--subset_num',
+        type=int,
+        default=-1,
+        help="Number of examples to process. Defaults to all if not specified."
+    )
+
+    # Search and document retrieval configuration
+    parser.add_argument(
+        '--max_search_limit',
+        type=int,
+        default=10,
+        help="Maximum number of searches per question."
+    )
+
+    parser.add_argument(
+        '--max_turn',
+        type=int,
+        default=15,
+        help="Maximum number of turns."
+    )
+
+    parser.add_argument(
+        '--top_k',
+        type=int,
+        default=10,
+        help="Maximum number of search documents to return."
+    )
+
+    parser.add_argument(
+        '--max_doc_len',
+        type=int,
+        default=3000,
+        help="Maximum length of each searched document."
+    )
+
+
+    # Model configuration
+    parser.add_argument(
+        '--model_path',
+        type=str,
+        required=True,
+        help="Path to the pre-trained model."
+    )
+
+    # Google API Configuration
+    parser.add_argument(
+        '--google_subscription_key',
+        type=str,
+        required=True,
+        help="Google Search API subscription key."
+    )
+
+    parser.add_argument(
+        '--google_endpoint',
+        type=str,
+        default="https://google.serper.dev/search",
+        help="Google Search API endpoint."
+    )
+
+    parser.add_argument(
+        '--cache_dir_base',
+        type=str,
+        required=True,
+        help="cache path."
+    )
+
+    parser.add_argument(
+        '--output_dir_base',
+        type=str,
+        required=True,
+        help="output_dir"
+    )
+
+    parser.add_argument(
+        '--is_exclude_urls',
+        action="store_true",
+        help="is_exclude_urls"
+    )
+
+    parser.add_argument(
+        '--summary_model_path',
+        type=str,
+        required=True,
+        help="Path to the summary model."
+    )
+
+
+    parser.add_argument(
+        '--base_url',
+        type=str,
+        required=True,
+        help="Base url of the summary model."
+    )
+
+    return parser.parse_args()
+
+
+
+def webpage_analysis_single(model_path, base_url, prompt) -> str:
+    client = OpenAI(
+        base_url=base_url,
+        api_key="EMPTY"
+    )
+
+
+    for i in range(10):
+        try:
+            completion = client.chat.completions.create(
+                model=model_path,
+                max_tokens=8192,
+                temperature=0.6,
+                top_p=0.95,
+                messages=[prompt],
+            )
+            return completion.choices[0].message.content
+        except Exception as e:
+            print(e)
+            time.sleep(1)
+            continue
+    return "None"
+
+def main():
+    args = parse_args()
+    # Extract arguments
+    dataset_name = args.dataset_name
+    subset_num = args.subset_num
+    MAX_SEARCH_LIMIT = args.max_search_limit
+    MAX_TURN = args.max_turn
+    top_k = args.top_k
+    max_doc_len = args.max_doc_len
+    model_path = args.model_path
+    summary_model_path = args.summary_model_path
+    cache_dir_base = args.cache_dir_base
+    output_dir_base = args.output_dir_base
+    is_exclude_urls = args.is_exclude_urls
+    base_url = args.base_url
+    google_subscription_key = args.google_subscription_key
+    google_endpoint = args.google_endpoint
+
+
+    # Data paths based on dataset
+    data_path = f"./data/eval/{dataset_name}.json"
+    print('-----------------------')
+    print(f'Using {dataset_name} set.')
+    print('-----------------------')
+
+    # ---------------------- Caching Mechanism ----------------------
+    # Define cache directories and file paths
+    # cache_dir = './cache'
+    model_name = model_path.split('/')[-1].replace('-instruct', '')
+    # cache_dir = f'./{cache_dir_base}_{dataset_name}_{model_name}'
+    cache_dir = cache_dir_base
+    search_cache_path = os.path.join(cache_dir, 'search_cache.json')
+    url_cache_path = os.path.join(cache_dir, 'url_cache.json')
+
+    # Ensure cache directory exists
+    os.makedirs(cache_dir, exist_ok=True)
+
+    # Load existing caches or initialize empty dictionaries
+    if os.path.exists(search_cache_path):
+        try: 
+            with open(search_cache_path, 'r', encoding='utf-8') as f:
+                search_cache = json.load(f)
+        except Exception as e:
+            print(f"load search_cache.json error: {e}")
+            search_cache = {}
+    else:
+        search_cache = {}
+
+    if os.path.exists(url_cache_path):
+        try:
+            with open(url_cache_path, 'r', encoding='utf-8') as f:
+                url_cache = json.load(f)
+        except Exception as e:
+            print(f"load url_cache.json error: {e}")
+            url_cache = {}
+    else:
+        url_cache = {}
+
+    # Function to save caches
+    def save_caches():
+        with open(search_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(search_cache, f, ensure_ascii=False, indent=2)
+        with open(url_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(url_cache, f, ensure_ascii=False, indent=2)
+
+    # ---------------------- Model Loading ----------------------
+    print(f"Loading tokenizer from {model_path}...")
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = 'left' # 主要是左填充
+    print("Tokenizer loaded successfully.")
+
+    # Define output directory based on model and dataset
+  
+    output_dir = os.path.join(output_dir_base, dataset_name)
+    os.makedirs(output_dir, exist_ok=True)
+
+    print(f"Loading model from {model_path}...")
+    print(f"device_count: {torch.cuda.device_count()}")
+    
+    # Initialize the LLM
+    llm = LLM(
+        model=model_path,
+        tensor_parallel_size=torch.cuda.device_count(),
+        gpu_memory_utilization=0.95,
+
+    )
+    print("Model loaded successfully.")
+
+
+    # ---------------------- Data Loading ----------------------
+    print(f"Loading data from {data_path}...")
+    with open(data_path, 'r', encoding='utf-8') as json_file:
+        filtered_data = json.load(json_file)
+    print(f"Data loaded successfully. Total examples: {len(filtered_data)}")
+
+
+    # ---------------------- Batch Generation Function ----------------------
+    def generate_webpage_to_reasonchain_batch( 
+        original_questions: List[str],
+        prev_reasonings: List[str],
+        search_queries: List[str],
+        documents: List[str],
+        dataset_name: str,
+        summary_model_path: str,
+        base_url: str,
+        batch_output_records: List[Dict],  # New parameter to collect outputs
+        max_tokens: int = 32768,
+        coherent: bool = False,
+    ) -> List[str]:
+
+        user_prompts = [ 
+            get_webpage_to_reasonchain_instruction(r, sq, doc)
+            for r, sq, doc in zip(prev_reasonings, search_queries, documents)
+        ]
+
+
+        prompts = [{"role": "user", "content": up} for up in user_prompts]
+        print("webpage ana prompts[0]")
+        print(prompts[0])
+
+
+        webpage_analysis_single_to_map = partial(webpage_analysis_single, summary_model_path, base_url)
+        with multiprocessing.Pool(processes=50) as pool:
+            raw_outputs = list(tqdm(pool.imap(webpage_analysis_single_to_map, prompts), total=len(prompts), desc="generate webpage summarization"))
+
+
+        # 统计错误的数目
+        sum_error = 0
+        for output in raw_outputs:
+            if output is None or output == "None" or output == "":
+                sum_error += 1
+        print(f"sum_error: {sum_error}, ratios: {sum_error / len(raw_outputs)}")
+
+        extracted_infos = [extract_answer(raw, mode='infogen') for raw in raw_outputs] 
+        for i, (p, r, e) in enumerate(zip(prompts, raw_outputs, extracted_infos)):
+            batch_output_records.append({
+                'prompt': p,
+                'raw_output': r,
+                'extracted_info': e
+            })
+
+        return extracted_infos
+
+    # ---------------------- Preparation of Input Prompts ----------------------
+    
+
+    input_list = []
+    for item in filtered_data: 
+        question = item['Question']
+
+        if dataset_name in ['gaia', 'musique', 'bamboogle', '2wiki']:
+           
+            instruction = get_multiqa_search_o1_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_openqa(question)
+
+        elif dataset_name in ['aime']:
+            instruction = get_multiqa_search_o1_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_math(question)
+
+        else:
+            instruction = get_multiqa_search_o1_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_openqa(question)
+            
+        
+        prompt = [{"role": "user", "content": instruction + user_prompt}] 
+        prompt = tokenizer.apply_chat_template(prompt, tokenize=False, add_generation_prompt=True)
+        input_list.append(prompt)
+
+    if subset_num != -1:
+        input_list = input_list[:subset_num]
+        filtered_data = filtered_data[:subset_num]
+
+    # Initialize active sequences
+    active_sequences = [{ 
+        'item': item,
+        'prompt': prompt,
+        'output': '',
+        'finished': False, 
+        'history': [],
+        'search_count': 0,
+        'executed_search_queries': set(),
+        'all_info': [],
+    } for item, prompt in zip(filtered_data, input_list)]
+
+    # ---------------------- Set Max Tokens ----------------------
+    if dataset_name in ['aime']:
+        max_tokens = 32768
+    else:
+        max_tokens = 20480
+    # ---------------------- Generation Function ----------------------
+    def run_generation(sequences: List[Dict], max_tokens: int) -> List:
+        prompts = [s['prompt'] for s in sequences] 
+        sampling_params = SamplingParams(
+            max_tokens=max_tokens,
+            temperature=0.6,
+            top_p=0.95,
+            top_k=40,
+            stop=[END_SEARCH_QUERY, tokenizer.eos_token],
+            include_stop_str_in_output=True,
+        )
+        output_list = llm.generate(prompts, sampling_params=sampling_params) 
+        print(f"run_generation completed {len(output_list)}")
+        return output_list
+
+    # Function to extract text between two tags
+    def extract_between(text: str, start_tag: str, end_tag: str) -> Optional[str]:
+        pattern = re.escape(start_tag) + r"(.*?)" + re.escape(end_tag)
+        matches = re.findall(pattern, text, flags=re.DOTALL)
+        if matches:
+            return matches[-1].strip()
+        return None
+
+    def replace_recent_steps(origin_str, replace_str): 
+        """
+        Replaces specific steps in the original reasoning steps with new steps.
+        If a replacement step contains "DELETE THIS STEP", that step is removed.
+
+        Parameters:
+        - origin_str (str): The original reasoning steps.
+        - replace_str (str): The steps to replace or delete.
+
+        Returns:
+        - str: The updated reasoning steps after applying replacements.
+        """
+
+        def parse_steps(text):
+            """
+            Parses the reasoning steps from a given text.
+
+            Parameters:
+            - text (str): The text containing reasoning steps.
+
+            Returns:
+            - dict: A dictionary mapping step numbers to their content.
+            """
+            step_pattern = re.compile(r"Step\s+(\d+):\s*") 
+            steps = {}
+            current_step_num = None
+            current_content = []
+
+            for line in text.splitlines():
+                step_match = step_pattern.match(line)
+                if step_match: 
+                    if current_step_num is not None:
+                        steps[current_step_num] = "\n".join(current_content).strip()
+                    current_step_num = int(step_match.group(1))
+                    content = line[step_match.end():].strip()
+                    current_content = [content] if content else []
+                else:
+                    if current_step_num is not None:
+                        current_content.append(line)
+            
+            # Save the last step if any
+            if current_step_num is not None: 
+                steps[current_step_num] = "\n".join(current_content).strip()
+            
+            return steps
+
+        # Parse the original and replacement steps
+        origin_steps = parse_steps(origin_str) 
+        replace_steps = parse_steps(replace_str) 
+
+        # Apply replacements
+        for step_num, content in replace_steps.items(): 
+            if "DELETE THIS STEP" in content: 
+                # Remove the step if it exists
+                if step_num in origin_steps: 
+                    del origin_steps[step_num]
+            else: 
+                # Replace or add the step 
+                origin_steps[step_num] = content
+
+        # Sort the steps by step number
+        sorted_steps = sorted(origin_steps.items()) 
+
+        # Reconstruct the reasoning steps as a single string
+        new_reasoning_steps = "\n\n".join([f"{content}" for num, content in sorted_steps]) 
+
+        return new_reasoning_steps
+
+    # ---------------------- Initialize Collection Structure ----------------------
+    # Initialize a list to collect batch outputs
+    batch_output_records = []
+
+    start_time = time.time()
+    turn = 0
+
+    # Main loop until all sequences are finished or maximum turns reached
+    while True:
+        # Identify sequences that need generation
+        sequences_needing_generation = [seq for seq in active_sequences if not seq['finished']] 
+
+        if sequences_needing_generation:
+            turn += 1
+            print(f'\n-------------- Turn {turn} --------------')
+            print(f"We have {len(sequences_needing_generation)} sequences needing generation...")
+            outputs = run_generation(sequences_needing_generation, max_tokens) 
+            print("Generation completed, processing outputs...")
+
+            # Initialize batch variables
+            batch_relevant_info = []
+            batch_original_questions = []
+            batch_prev_reasonings = []
+            batch_search_queries = []
+            batch_documents = []
+            batch_sequences = []
+
+            # Collect URLs to fetch across all sequences
+            all_urls_to_fetch = set() 
+            url_snippets = {}
+            url_sequence_map = {}  # Map URL to list of sequences needing it
+
+            start_search_time = time.time()
+            # Process each sequence and collect URLs
+            for seq, out in zip(sequences_needing_generation, outputs): 
+                text = out.outputs[0].text
+                seq['history'].append(text)
+                # Append generated text to prompt and output
+                seq['prompt'] += text
+                seq['output'] += text
+                seq['all_info'].append({f"turn_{turn}_reason": text})
+                # Extract search query
+                search_query = extract_between(text, BEGIN_SEARCH_QUERY, END_SEARCH_QUERY)
+
+                # If a search query is present and needs to be executed
+                if search_query and seq['output'].rstrip().endswith(END_SEARCH_QUERY):
+                    if seq['search_count'] < MAX_SEARCH_LIMIT and search_query not in seq['executed_search_queries']:
+                        # Execute search, use cache if available
+                        if search_query in search_cache:
+                            results = search_cache[search_query] 
+                            print(f"Using cached search results for query: \"{search_query}\"")
+                        else:
+                            try:
+                                if is_exclude_urls and "urls" in seq["item"]["metadata"]: 
+                                    print(f"is_exclude_urls: {is_exclude_urls}")
+                                    exclude_urls = seq["item"]["metadata"]["urls"]
+                                else:
+                                    exclude_urls = []
+
+                                print(f"Execute and cache search for query: \"{search_query}\"")
+                                results = google_web_search(search_query, google_subscription_key, google_endpoint, market='en-US', language='en', exclude_urls=exclude_urls) # 执行搜索
+                                search_cache[search_query] = results  
+                                print(f"Executed and cached search for query: \"{search_query}\"")
+                            except Exception as e:
+                                print(f"Error during search query '{search_query}': {e}")
+                                search_cache[search_query] = {}
+                                results = {}
+
+                        # Extract relevant information from Bing search results
+                        relevant_info = extract_relevant_info(results)[:top_k] 
+                        seq['relevant_info'] = relevant_info
+
+                        # Extract URLs and snippets
+                        urls_to_fetch = [it['url'] for it in relevant_info] 
+                        snippets = {info['url']: info['snippet'] for info in relevant_info if 'snippet' in info} 
+
+                        # Filter URLs that are not cached
+                        urls_to_fetch_filtered = [u for u in urls_to_fetch if u not in url_cache] 
+                        cached_urls = [u for u in urls_to_fetch if u in url_cache] 
+
+                        # Store info for all_urls_to_fetch and url_snippets
+                        for url in urls_to_fetch_filtered:
+                            all_urls_to_fetch.add(url)
+                            url_snippets[url] = snippets.get(url, "") 
+
+                        all_reasoning_steps = seq['output']
+                        all_reasoning_steps = all_reasoning_steps.replace('\n\n', '\n').split("\n") 
+
+                        truncated_prev_reasoning = ""
+                        for i, step in enumerate(all_reasoning_steps):
+                            truncated_prev_reasoning += f"Step {i + 1}: {step}\n\n" 
+
+                        prev_steps = truncated_prev_reasoning.split('\n\n') 
+                        if len(prev_steps) <= 5: 
+                            truncated_prev_reasoning = '\n\n'.join(prev_steps)
+                        else:
+                            truncated_prev_reasoning = ''
+                            for i, step in enumerate(prev_steps): 
+                                if i == 0 or i >= len(prev_steps) - 4 or BEGIN_SEARCH_QUERY in step or BEGIN_SEARCH_RESULT in step:
+                                    truncated_prev_reasoning += step + '\n\n'
+                                else: 
+                                    if truncated_prev_reasoning[-len('\n\n...\n\n'):] != '\n\n...\n\n':
+                                        truncated_prev_reasoning += '...\n\n'
+                        truncated_prev_reasoning = truncated_prev_reasoning.strip('\n')
+
+                        # Collect parameters for batch processing
+                        batch_relevant_info.append(relevant_info) 
+                        batch_original_questions.append(seq['item']['Question'])
+                        batch_prev_reasonings.append(truncated_prev_reasoning) 
+                        batch_search_queries.append(search_query) 
+                        batch_sequences.append(seq)
+
+                        # Update search count and executed queries
+                        seq['search_count'] += 1 
+                        seq['executed_search_queries'].add(search_query)
+                    elif seq['search_count'] >= MAX_SEARCH_LIMIT: 
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nThe maximum search limit is exceeded. You are not allowed to search.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        print(f"Search limit reached for query: \"{search_query}\"")
+
+                    elif search_query in seq['executed_search_queries']:
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nYou have searched this query. Please refer to previous results.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        print(f"Repeated search for query: \"{search_query}\"")
+                        
+
+                else:  
+                    # If no search query needs to be executed, mark the sequence as finished
+                    seq['finished'] = True
+                    print("Sequence marked as complete.")
+
+            print(f"get search time taken: {time.time() - start_search_time}")
+            print(f"all_urls_to_fetch len: {len(all_urls_to_fetch)}, url_cache len: {len(url_cache)}")
+            print(f"all_urls_to_fetch: {all_urls_to_fetch}")
+            # Batch fetch all URLs at once to optimize speed
+            
+            if all_urls_to_fetch:
+                print(f"Fetching {len(all_urls_to_fetch)} URLs...")
+                try:
+                    fetched_contents = fetch_page_content( 
+                        list(all_urls_to_fetch),
+                        use_jina=False,
+                        jina_api_key=None,
+                        # snippets=url_snippets  # Do not pass snippets when updating url_cache directly
+                    )
+                    print(f"Fetched {len(fetched_contents)} URLs successfully.")
+                except Exception as e:
+                    print(f"Error during batch URL fetching: {e}")
+                    fetched_contents = {url: f"Error fetching URL: {e}" for url in all_urls_to_fetch}
+                # Update cache with fetched contents
+                for url, content in fetched_contents.items(): # 
+                    url_cache[url] = content
+
+            # After fetching, prepare formatted documents for batch processing
+            for relevant_info in batch_relevant_info:
+                formatted_documents = "" 
+                for i, doc_info in enumerate(relevant_info):
+                    url = doc_info['url']
+                    raw_context = url_cache.get(url, "") # 获取 url 对应的内容
+                    doc_info['snippet'] = doc_info['snippet'].replace('<b>','').replace('</b>','')            
+                    success, filtered_context = extract_snippet_with_context(raw_context, doc_info['snippet'], context_chars=max_doc_len)
+                    if success:
+                        print("extract_snippet_with_context")
+                        context = filtered_context
+                    else: 
+                        print(f"use raw_context, {len(raw_context)}")
+                        context = raw_context[:max_doc_len*2]
+
+                    doc_info['context'] = context
+                    formatted_documents += f"**Web Page {i + 1}:**\n"
+                    formatted_documents += json.dumps(doc_info, ensure_ascii=False, indent=2) + "\n"
+                print(f'formatted_documents: {len(formatted_documents)}')
+                batch_documents.append(formatted_documents) 
+
+            # After fetching, prepare for batch processing if there are any
+            if batch_sequences:
+                print(f"Batch processing {len(batch_sequences)} sequences with generate_webpage_to_reasonchain_batch...")
+                webpage_analyses = generate_webpage_to_reasonchain_batch( 
+                    original_questions=batch_original_questions,
+                    prev_reasonings=batch_prev_reasonings,
+                    search_queries=batch_search_queries,
+                    documents=batch_documents,
+                    dataset_name=dataset_name,
+                    summary_model_path=summary_model_path,
+                    base_url=base_url,
+                    batch_output_records=batch_output_records,  # Pass the collection list
+                    max_tokens=max_tokens,
+                )
+                print("Batch generation completed, assigning outputs to sequences...")
+
+                for seq, analysis,doc in zip(batch_sequences, webpage_analyses, batch_documents): 
+                    if isinstance(analysis, str): 
+                        append_text = f"\n\n{BEGIN_SEARCH_RESULT}{analysis}{END_SEARCH_RESULT}\n\n" 
+                        seq['output'] += append_text
+                        seq['history'].append(append_text) 
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+                    else: 
+                        append_text = replace_recent_steps(seq['output'], analysis)
+                        seq['prompt'] += append_text
+                        seq['output'] += append_text
+                        seq['history'].append(append_text)
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+
+        # Check if all sequences are finished
+        # 保存active_sequences
+        active_sequences_part = [{ 
+            'item': ele["item"],
+            'prompt': ele['prompt'],
+            'output': ele["output"],
+            'finished': ele["finished"], 
+            'history':ele["history"],
+            'search_count': ele["search_count"],
+            'all_info': ele['all_info']
+        } for ele in active_sequences]
+        with open(os.path.join(output_dir, f"turn_{turn}.json"), 'w', encoding='utf-8') as f:
+            json.dump(active_sequences_part, f, ensure_ascii=False, indent=2)
+        unfinished = [seq for seq in active_sequences if not seq['finished']] 
+        if not unfinished:
+            break
+        else:
+            if turn >= MAX_TURN:
+                print(f"Maximum number of turns ({MAX_TURN}) reached, stopping.")
+                break
+
+    total_time = time.time() - start_time
+    print(f"Total time taken: {total_time} seconds")
+
+    # ---------------------- Save Batch Output Records to JSON File ----------------------
+    # Define output JSON file path
+    t = time.localtime()
+    batch_output_file = os.path.join(output_dir, f'eval.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.info_extract.json')
+
+    # Save batch_output_records to JSON file
+    with open(batch_output_file, 'w', encoding='utf-8') as f: 
+        json.dump(batch_output_records, f, ensure_ascii=False, indent=2)
+
+    print(f"Batch outputs saved to {batch_output_file}")
+
+    # Prepare output list for evaluation
+    output_list = [seq['output'] for seq in active_sequences]
+
+    # Run evaluation
+    if dataset_name in ["gaia"]:
+        run_evaluation_for_eval(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, "test")
+    else:
+        run_evaluation(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, "test")
+
+    # 评测has answer信息
+    turn_files = os.listdir(output_dir)
+    turn_files = [file for file in turn_files if file.startswith("turn_")]
+    max_turn_file = max(turn_files, key=lambda x: int(re.search(r'turn_(\d+)', x).group(1)))
+
+    max_turn_file_path = os.path.join(output_dir, max_turn_file)
+    print(f"max_turn_file_path: {max_turn_file_path}")
+    add_eval(model_path, max_turn_file_path)
+
+    # ---------------------- Update Search and URL Cache ----------------------
+    print('Updating Search and URL Cache...')
+    # Load existing caches or initialize empty dictionaries
+    if os.path.exists(search_cache_path):
+        try:
+            with open(search_cache_path, 'r', encoding='utf-8') as f:
+                search_cache_new = json.load(f)
+        except Exception as e:
+            print(f"Error loading search cache: {e}")
+            search_cache_new = {}
+    else:
+        search_cache_new = {}
+
+    if os.path.exists(url_cache_path):
+        try:
+            with open(url_cache_path, 'r', encoding='utf-8') as f:
+                url_cache_new = json.load(f)
+        except Exception as e:
+            print(f"Error loading url cache: {e}")
+            url_cache_new = {}
+    else:
+        url_cache_new = {}
+
+    search_cache.update(search_cache_new)
+    url_cache.update(url_cache_new)
+
+    save_caches()
+
+    print("Process completed.")
+
+if __name__ == "__main__":
+    main()

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/lcb_runner/benchmarks/__init__.py

@@ -0,0 +1,13 @@
+from lcb_runner.benchmarks.code_generation import (
+    CodeGenerationProblem,
+    load_code_generation_dataset,
+    load_code_generation_dataset_not_fast,
+)
+from lcb_runner.benchmarks.test_output_prediction import (
+    TestOutputPredictionProblem,
+    load_test_prediction_dataset,
+)
+from lcb_runner.benchmarks.code_execution import (
+    CodeExecutionProblem,
+    load_code_execution_dataset,
+)

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/lcb_runner/benchmarks/code_execution.py

@@ -0,0 +1,67 @@
+import json
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+@dataclass
+class CodeExecutionProblem:
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    difficulty: str
+    function_name: str
+    code: str
+    input: str
+    output: str
+    id: str
+    problem_id: str
+    numsteps: int
+
+    def __post_init__(self):
+        pass
+
+    def insert_output(self, output_list: list[str], pred_list: list[str]) -> dict:
+        return {
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "difficulty": self.difficulty,
+            "function_name": self.function_name,
+            "code": self.code,
+            "input": self.input,
+            "output": self.output,
+            "id": self.id,
+            "problem_id": self.problem_id,
+            "numsteps": self.numsteps,
+            "output_list": output_list,
+            "pred_list": pred_list,
+        }
+
+    def insert_output_evaluation(
+        self, output_list: list[str], code_list: list[str], graded_list: list[bool]
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        return output
+
+    def get_evaluation_sample(self) -> dict:
+        return {
+            "code": self.code,
+            "input": self.input,
+            "output": self.output,
+        }
+
+
+def load_code_execution_dataset(release_version="release_v1") -> list[CodeExecutionProblem]:
+    dataset = load_dataset("livecodebench/execution-v2", split="test")
+    dataset = [CodeExecutionProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_code_execution_dataset()

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/lcb_runner/benchmarks/code_generation.py

@@ -0,0 +1,139 @@
+import json
+import zlib
+import pickle
+import base64
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+class Platform(Enum):
+    LEETCODE = "leetcode"
+    CODEFORCES = "codeforces"
+    ATCODER = "atcoder"
+
+
+class Difficulty(Enum):
+    EASY = "easy"
+    MEDIUM = "medium"
+    HARD = "hard"
+
+
+class TestType(Enum):
+    STDIN = "stdin"
+    FUNCTIONAL = "functional"
+
+
+@dataclass
+class Test:
+    input: str
+    output: str
+    testtype: TestType
+
+    def __post_init__(self):
+        self.testtype = TestType(self.testtype)
+        # if self.testtype == TestType.FUNCTIONAL:
+        #     self.input = json.loads(self.input)
+        #     self.output = json.loads(self.output)
+
+
+@dataclass
+class CodeGenerationProblem:
+    question_title: str
+    question_content: str
+    platform: Platform
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    starter_code: str
+    difficulty: Difficulty
+    public_test_cases: list[Test]
+    private_test_cases: list[Test]
+    metadata: dict
+
+    def __post_init__(self):
+        self.platform = Platform(self.platform)
+        self.difficulty = Difficulty(self.difficulty)
+        self.contest_date = datetime.fromisoformat(self.contest_date)
+
+        self.public_test_cases = json.loads(self.public_test_cases)  # type: ignore
+        self.public_test_cases = [Test(**t) for t in self.public_test_cases]
+
+        try:
+            self.private_test_cases = json.loads(self.private_test_cases)  # type: ignore
+        except:
+            self.private_test_cases = json.loads(
+                pickle.loads(
+                    zlib.decompress(
+                        base64.b64decode(self.private_test_cases.encode("utf-8"))  # type: ignore
+                    )
+                )
+            )  # type: ignore
+        self.private_test_cases = [Test(**t) for t in self.private_test_cases]
+
+        self.metadata = json.loads(self.metadata)  # type: ignore
+
+    def insert_output(self, output_list: list[str], code_list: list[str]) -> dict:
+        return {
+            "question_title": self.question_title,
+            "question_content": self.question_content,
+            "platform": self.platform.value,
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "starter_code": self.starter_code,
+            "difficulty": self.difficulty.value,
+            "output_list": output_list,
+            "code_list": code_list,
+        }
+
+    def insert_output_evaluation(
+        self,
+        output_list: list[str],
+        code_list: list[str],
+        graded_list: list[bool],
+        **kwargs,
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        for k, v in kwargs.items():
+            output[k] = v
+        return output
+
+    def get_evaluation_sample(self):
+        return {
+            "input_output": json.dumps(
+                {
+                    "inputs": [
+                        t.input
+                        for t in self.public_test_cases + self.private_test_cases
+                    ],
+                    "outputs": [
+                        t.output
+                        for t in self.public_test_cases + self.private_test_cases
+                    ],
+                    "fn_name": self.metadata.get("func_name", None),
+                }
+            ),
+        }
+
+
+def load_code_generation_dataset(release_version="release_v1") -> list[CodeGenerationProblem]:
+    dataset = load_dataset("livecodebench/code_generation_lite", split="test", version_tag=release_version, trust_remote_code=True)
+    dataset = [CodeGenerationProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+def load_code_generation_dataset_not_fast(release_version="release_v1") -> list[CodeGenerationProblem]:
+    dataset = load_dataset("livecodebench/code_generation", split="test")
+    dataset = [CodeGenerationProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_code_generation_dataset()

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/lcb_runner/benchmarks/test_output_prediction.py

@@ -0,0 +1,70 @@
+import json
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+@dataclass
+class Test:
+    input: str
+    output: str
+    testtype: str
+
+
+@dataclass
+class TestOutputPredictionProblem:
+    question_title: str
+    question_content: str
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    difficulty: str
+    test: list[Test]
+    starter_code: str
+    function_name: str
+    test_id: int
+
+    def __post_init__(self):
+        self.test = [Test(**t) for t in json.loads(self.test)]  # type: ignore
+
+    def insert_output(self, output_list: list[str], pred_list: list[str]) -> dict:
+        return {
+            "question_title": self.question_title,
+            "question_content": self.question_content,
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "difficulty": self.difficulty,
+            "output_list": output_list,
+            "pred_list": pred_list,
+            "test_id": self.test_id,
+            "function_name": self.function_name,
+            "starter_code": self.starter_code,
+        }
+
+    def insert_output_evaluation(
+        self, output_list: list[str], code_list: list[str], graded_list: list[bool]
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        return output
+
+    def get_evaluation_sample(self) -> dict:
+        return {
+            "input": self.question_content,
+            "output": self.test[0].output,
+        }
+
+
+def load_test_prediction_dataset(release_version="release_v1") -> list[TestOutputPredictionProblem]:
+    dataset = load_dataset("livecodebench/test_generation", split="test")  # type: ignore
+    dataset = [TestOutputPredictionProblem(**d) for d in dataset]
+    print(f"Loaded {len(dataset)} prediction problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_test_prediction_dataset()

deep_search/search_o1/scripts/SimpleDeepSearcher/inference/lcb_runner/evaluation/__init__.py

@@ -0,0 +1,6 @@
+from lcb_runner.evaluation.compute_code_generation_metrics import codegen_metrics
+from lcb_runner.evaluation.compute_code_execution_metrics import code_execution_metrics
+from lcb_runner.evaluation.compute_test_output_prediction_metrics import (
+    test_output_metrics,
+)
+from lcb_runner.evaluation.pass_k_utils import extract_instance_results