【大模型学习】1：基于通用大语言模型的构建方法

基于通用大语言模型的构建

目录

前言

一、大模型是什么？

二、如何构建大语言模型？

1.基本介绍

2.数据

3.模型构建

总结

---

前言

本人之前没接触过大模型，研究生的研究方向也不是这一块的，所以是以工程的心态快速上手做到工科领域的不求甚解。

一、大模型是什么？

靠海量的模型和参数堆叠的一种模型。

最典型的代表是ChatGPT，很多高校灌水重灾区。但实话实说，大模型确实给我们的生活带来了质变。学术价值和商业价值都挺高的。我有个在国外留学的朋友就说过国内卖大模型的概念挺有商机的。国内听说好多高校也在往这方面灌水。

二、如何构建大语言模型？

1.基本介绍

一般来说，会直接租用厂商有的大模型结构。厂商会提供如何接入接口的方案和措施。这个不再详细介绍，我主打一手会抄会用。下面说一说数据。

2.数据

这个是训练数据集（json）的示例：

{'id': 'round_train_data_001',
'problem': '有一个计算阶乘的递归程序。该程序根据给定的数值计算其阶乘。以下是其工作原理：\n\n当数字是0时，阶乘是1。\n对于任何大于0的数字，其阶乘是该数字乘以其前一个数字的阶乘。\n根据上述规则，回答以下选择题：',
 'questions': [{'question': '选择题 1：\n3的阶乘是多少？\n',
   				   'options': ('3', '6', '9', '12'),
   					'answer': 'B'},
  				  {'question': '选择题 2：\n8的阶乘是多少？\n',
   					'options': ('5040', '40320', '362880', '100000'),
   					'answer': 'B'},
  				  {'question': '选择题 3：\n4的阶乘是多少？\n',
   					'options': ('16', '20', '24', '28'),
   					'answer': 'C'},
  				  {'question': '选择题 4：\n3的阶乘是9吗？\n', 
  				   'options': ('是', '否'), 
  				   'answer': 'B'}]

测试集也差不多，大多是有一个固定的数据类型。这里不再列举。

3.模型构建

调库+前面准备工作

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 rank_bm25 import BM25Okapi
#import jieba
from http import HTTPStatus
import dashscope


from concurrent.futures import ThreadPoolExecutor, as_completed
from loguru import logger
import json
import time
from tqdm import tqdm

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'

给出自己调的接口信息

dashscope.api_key=‘xxxxxxxxxxxxx’

写一些接口函数

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

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:
        # print(response)
        return response['output']['choices'][0]['message']['content']
    else:
        print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
            response.request_id, response.status_code,
            response.code, response.message
        ))
        raise Exception()

def process_datas(datas,MODEL_NAME):
    results = []
    with ThreadPoolExecutor(max_workers=16) as executor:
        future_data = {}
        lasttask = ''
        lastmark = 0
        lens = 0
        for data in tqdm(datas, desc="Submitting tasks", total=len(datas)):
            problem = data['problem']
            for id,question in enumerate(data['questions']):
                prompt = get_prompt(problem, 
                                    question['question'], 
                                    question['options'],
                                    )

                future = executor.submit(api_retry, MODEL_NAME, prompt)
                
                future_data[future] = (data,id)
                time.sleep(0.6)  # 控制每0.5秒提交一个任务
                lens += 1
        for future in tqdm(as_completed(future_data), total=lens, desc="Processing tasks"):
            # print('data',data)
            data = future_data[future][0]
            problem_id = future_data[future][1]
            try:
                res  = future.result()
                extract_response = extract(res)
                # print('res',extract_response)
                data['questions'][problem_id]['answer'] = extract_response
                results.append(data)
                # print('data',data)
                
            except Exception as e:
                logger.error(f"Failed to process text: {data}. Error: {e}")
    
    return results

# 这里使用extract抽取模获得抽取的结果

def extract(input_text):
    ans_pattern = re.compile(r"答案是：(.)", re.S)

    problems = ans_pattern.findall(input_text)
    # print(problems)
    if(problems == ''):
        return 'A'
    return problems[0]

 这些都不用管，直接抄就好，如果后续要更改会说明。

Prompt模版【这个我不太理解，干啥用的？】听别的大佬说Prompt是需要修改的一块。

# 这里定义了prompt推理模版

def get_prompt(problem, question, options):

    options = '\n'.join(f"{'ABCDEFG'[i]}. {o}" for i, o in enumerate(options))

    prompt = f"""你是一个逻辑推理专家，擅长解决逻辑推理问题。以下是一个逻辑推理的题目，形式为单项选择题。所有的问题都是（close-world assumption）闭世界假设，即未观测事实都为假。请逐步分析问题并在最后一行输出答案，最后一行的格式为"答案是：A"。题目如下：

### 题目:
{problem}

### 问题:
{question}
{options}
"""
    # print(prompt)
    return prompt

 main函数+evaluate函数（直接抄）

def main(ifn, ofn):
    if os.path.exists(ofn):
        pass
    data = []
    # 按行读取数据
    with open(ifn) as reader:
        for line in reader:
            sample = json.loads(line)
            data.append(sample)
    datas = data
    # print(data)
    # 均匀地分成多个数据集
    return_list = process_datas(datas,MODEL_NAME)
    print(len(return_list))
    print("All tasks finished!")
    return return_list

def evaluate(ofn):
    data = []
    with open(ofn) as reader:
        for line in reader:
            sample = json.loads(line)
            data.append(sample)

    pse = 0
    cnt = 0
    tot = 0
    for task in data:
        for question in task['questions']:
            
            if MODEL_NAME in question:
                tot += 1
                cnt += question[MODEL_NAME] == question['answer']
            else:
                pse += 1

    print(cnt, tot, cnt/tot, pse)

 

if __name__ == '__main__':

    a = extract("""根据欧几里得算法，逐步解析计算两个数6和7的最大公约数（gcd）的步骤如下：

1. 判断6和7是否相等：不相等。
2. 判断6和7大小关系，7 > 6，所以用更大的数7减去较小的数6得到结果1。
3. 现在计算6和1的最大公约数。
4. 6 > 1，根据算法用更大的数6减去较小的数1得到结果5。
5. 再计算5和1的最大公约数。
6. 5 > 1，用5减去1得到结果4。
7. 再计算4和1的最大公约数。
8. 4 > 1，用4减去1得到结果3。
9. 再计算3和1的最大公约数。
10. 3 > 1，用3减去1得到结果2。
11. 再计算2和1的最大公约数。
12. 2 > 1，用2减去1得到结果1。
13. 最后计算1和1的最大公约数，两数相等，gcd即为这两个数，也就是1。

因此，6和7的最大公约数是1。

答案是：C.""")

    print(a)
    return_list = main('round1_test_data.jsonl', 'upload.jsonl')

 

抄完上述的流程，就可以跑一个完整的大模型结构了。主要是中间过程有很多繁琐的库需要理解，这方面没有积累的话还真不容易弄出来。 

总结

简单介绍一下模型搭建的过程，给自己插个眼，希望对大家有帮助。