从零入门 AI 逻辑推理baseline代码解释

在跑代码之前我们要先进行环境的配置，首先安装环境的相关依赖

!pip install scipy openai tiktoken retry dashscope loguru

其中命令中的相关库解释如下

• scipy: 科学计算库。

• openai: 调用API的库。

• tiktoken: 读取token的库。

• retry: 用于实现重试机制的包。

• dashscope: 一个 API 客户端。

• loguru: Python 日志库。

安装完成之后我们进行导入包的操作

from multiprocessing import Process, Manager
import json
import os
from pprint import pprint
import re
from tqdm import tqdm
import random
import uuid
import openai
import tiktoken
import json
import numpy as np
import requests
from retry import retry
from scipy import sparse
from http import HTTPStatus
import dashscope
​
from concurrent.futures import ThreadPoolExecutor, as_completed
from loguru import logger
import time
​
logger.remove()  # 移除默认的控制台输出
logger.add("logs/app_{time:YYYY-MM-DD}.log", level="INFO", rotation="00:00", retention="10 days", compression="zip")
​
MODEL_NAME = 'qwen2-7b-instruct'

说明：

• 导入多个库和模块：

  • multiprocessing: 支持多进程。

  • json: JSON格式处理。

  • os: 操作系统接口。

  • pprint: 格式化打印。

  • re: 正则表达式处理。

  • tqdm: 进度条。

  • random: 随机数生成。

  • uuid: 唯一标识符生成。

  • numpy: 数值计算库。

  • requests: HTTP 请求库。

  • retry: 实现重试机制。

  • sparse: 稀疏矩阵计算。

  • HTTPStatus: HTTP 状态码。

  • dashscope: API 客户端。

  • concurrent.futures: 并发执行工具。

  • loguru: 高级日志库。

  • time: 时间相关函数。

• 设置日志：

  • 移除默认控制台输出。

  • 添加日志文件输出，日志级别为 INFO，每天轮换一次，保留 10 天，使用 zip 压缩。

• 定义模型名称。

填入你在阿里云申请的大模型API 的token（这个一定要自己保存好！！！）

# 注意：这里需要填入你的key~ 咱们在第二步申请的。
dashscope.api_key="sk-XXXXXXXXXXXXXXXXXX"

下面我们定义函数进行API的调用：

• 定义函数 api_retry，尝试调用 API，最多重试 5 次，每次重试间隔 60 秒。

• 若调用失败，记录日志并等待一段时间后重试。

def api_retry(MODEL_NAME, query):
    max_retries = 5
    retry_delay = 60  # in seconds
    attempts = 0
    while attempts < max_retries:
        try:
            return call_qwen_api(MODEL_NAME, query)
        except Exception as e:
            attempts += 1   
            if attempts < max_retries:
                logger.warning(f"Attempt {attempts} failed for text: {query}. Retrying in {retry_delay} seconds...")
                time.sleep(retry_delay)
            else:
                logger.error(f"All {max_retries} attempts failed for text: {query}. Error: {e}")
                raise

定义函数call_qwen_api，进行模型推理

def call_qwen_api(MODEL_NAME, query):
    # 这里采用dashscope的api调用模型推理，通过http传输的json封装返回结果
    messages = [
        {'role': 'user', 'content': query}]
    response = dashscope.Generation.call(
        MODEL_NAME,
        messages=messages,
        result_format='message',  # set the result is message format.
    )
    if response.status_code == HTTPStatus.OK:
        return response['output']['choices'][0]['message']['content']
    else:
        print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
            response['id'], response.status_code, response['error']['code'], response['error']['message']))
        response.raise_for_status()

定义函数进行整合上面模型推理的结果

• 定义一个函数 has_complete_answer，检查问题列表中是否包含完整答案。

• 定义一个函数 filter_problems，过滤并合并数据，确保每个问题都有完整的答案。

def has_complete_answer(questions):
    for question in questions:
        if 'answer' not in question:
            return False
    return True
​
def filter_problems(data):
    result = []
    problem_set = set()
​
    for item in data:
        problem = item['problem']
        if problem in problem_set:
            for existing_item in result:
                if existing_item['problem'] == problem:
                    if has_complete_answer(item['questions']):
                        existing_item['questions'] = item['questions']
                        existing_item['id'] = item['id']
                    break
        else:
            if has_complete_answer(item['questions']):
                result.append(item)
                problem_set.add(problem)
​
    return result

对结果进行过滤排序后输出

return_list
return_list = filter_problems(return_list)
sorted_data = sorted(return_list, key=lambda x: int(str(x['id'])[-3:]))
print(sorted_data)

查看一下sorted_data中的内容

sorted_data

定义一个函数 find_missing_ids，找出字典列表中缺失的序号并对结果进行输出。

def find_missing_ids(dict_list):
    extracted_ids = {int(d['id'][-3:]) for d in dict_list}
    all_ids = set(range(500))
    missing_ids = all_ids - extracted_ids
    return sorted(missing_ids)
​
dict_list = sorted_data
missing_ids = find_missing_ids(dict_list)
print("缺失的序号:", missing_ids)

输出缺失序号的数量。

len(missing_ids)

从文件 round1_test_data.jsonl 中读取数据并处理缺失的序号，将其添加到 sorted_data 列表中并排序。

data  = []
with open('round1_test_data.jsonl') as reader:
    for id, line in enumerate(reader):
        if id in missing_ids:
            sample = json.loads(line)
            for question in sample['questions']:
                question['answer'] = 'A'
            sorted_data.append(sample)
sorted_data = sorted(sorted_data, key=lambda x: int(str(x['id'])[-3:]))

将 sorted_data 列表中的数据写入 upload.jsonl 文件，之后上传到大赛官网评价得分。

with open('upload.jsonl', 'w') as writer:
    for sample in sorted_data:
        writer.write(json.dumps(sample, ensure_ascii=False))
        writer.write('\n')