• 本地部署多语言代码生成模型CodeGeeX2

    🏠 Homepage｜💻 GitHub｜🛠 Tools VS Code, Jetbrains｜🤗 HF Repo｜📄 Paper

    👋 Join our Discord, Slack, Telegram, WeChat

    BF16/FP16版本｜BF16/FP16 version codegeex2-6b

    CodeGeeX2: 更强大的多语言代码生成模型

    A More Powerful Multilingual Code Generation Model

    一、CodeGeeX2模型简介 

    CodeGeeX2 是多语言代码生成模型 CodeGeeX (KDD’23) 的第二代模型。CodeGeeX2 基于 ChatGLM2 架构加入代码预训练实现，得益于 ChatGLM2 的更优性能，CodeGeeX2 在多项指标上取得性能提升（+107% > CodeGeeX；仅60亿参数即超过150亿参数的 StarCoder-15B 近10%），更多特性包括：

    • 更强大的代码能力：基于 ChatGLM2-6B 基座语言模型，CodeGeeX2-6B 进一步经过了 600B 代码数据预训练，相比一代模型，在代码能力上全面提升，HumanEval-X 评测集的六种编程语言均大幅提升 (Python +57%, C++ +71%, Java +54%, JavaScript +83%, Go +56%, Rust +321%)，在Python上达到 35.9% 的 Pass@1 一次通过率，超越规模更大的 StarCoder-15B。
    • 更优秀的模型特性：继承 ChatGLM2-6B 模型特性，CodeGeeX2-6B 更好支持中英文输入，支持最大 8192 序列长度，推理速度较一代 CodeGeeX-13B 大幅提升，量化后仅需6GB显存即可运行，支持轻量级本地化部署。
    • 更全面的AI编程助手：CodeGeeX插件（VS Code, Jetbrains）后端升级，支持超过100种编程语言，新增上下文补全、跨文件补全等实用功能。结合 Ask CodeGeeX 交互式AI编程助手，支持中英文对话解决各种编程问题，包括且不限于代码解释、代码翻译、代码纠错、文档生成等，帮助程序员更高效开发。
    • 更开放的协议：CodeGeeX2-6B 权重对学术研究完全开放，填写登记表申请商业使用。

    下载地址：

    CodeGeeX2-6B-int4 · 模型库 (modelscope.cn) 

    二、软件依赖 ｜ Dependency

    pip install protobuf cpm_kernels torch>=2.0 gradio mdtex2html sentencepiece accelerate

    三、模型部署使用

    3.1 python生成冒泡排序算法

    1. from modelscope import AutoTokenizer, AutoModel
    2. tokenizer = AutoTokenizer.from_pretrained("E:\Data\CodeGeeX2-6B-int4", trust_remote_code=True)
    3. model = AutoModel.from_pretrained("E:\Data\CodeGeeX2-6B-int4", trust_remote_code=True, device='cuda')
    4. model = model.eval()
    5.  
    6. # remember adding a language tag for better performance
    7. prompt = "# language: Python\n# 用python写一个冒泡排序算法，并用中文逐行注释\n"
    8. # inputs = tokenizer.encode(prompt, return_tensors="pt").to(model.device)
    9. inputs = tokenizer.encode(prompt, return_tensors="pt", padding=True, truncation=True).to(model.device)
    10. # outputs = model.generate(inputs, max_length=256, top_k=1)
    11. outputs = model.generate(inputs, max_length=256)
    12. response = tokenizer.decode(outputs[0])
    13.  
    14. print(response)

    反馈结果

    1. # language: Python
    2. # 用python写一个冒泡排序算法，并用中文逐行注释
    3.  
    4.  
    5. def bubble_sort(list):
    6.     """
    7.     冒泡排序算法
    8.     :param list: 要排序的列表
    9.     :return: 排序后的列表
    10.     """
    11.     for i in range(len(list) - 1):
    12.         for j in range(len(list) - i - 1):
    13.             if list[j] > list[j + 1]:
    14.                 list[j], list[j + 1] = list[j + 1], list[j]
    15.     return list
    16.  
    17.  
    18. if __name__ == "__main__":
    19.     list = [1, 3, 2, 4, 5, 6, 7, 9, 8]
    20.     print(bubble_sort(list))

    3.2 python实现Bert+对抗训练+对比学习的文本分类任务

    1. from modelscope import AutoTokenizer, AutoModel
    2. tokenizer = AutoTokenizer.from_pretrained("E:\Data\CodeGeeX2-6B-int4", trust_remote_code=True)
    3. model = AutoModel.from_pretrained("E:\Data\CodeGeeX2-6B-int4", trust_remote_code=True, device='cuda')
    4. model = model.eval()
    5.  
    6. # remember adding a language tag for better performance
    7. prompt = "# language: Python\n# 用python写一个用Bert结合对抗训练和对比学习实现SST-2数据集文本分类的代码，并用中文逐行注释\n"
    8. # inputs = tokenizer.encode(prompt, return_tensors="pt").to(model.device)
    9. inputs = tokenizer.encode(prompt, return_tensors="pt", padding=True, truncation=True).to(model.device)
    10. # outputs = model.generate(inputs, max_length=256, top_k=1)
    11. outputs = model.generate(inputs, max_length=20000)
    12. response = tokenizer.decode(outputs[0])
    13.  
    14. print(response)

    反馈结果

    1. import torch
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from pytorch_pretrained_bert import BertModel, BertTokenizer
    5. from torch.utils.data import TensorDataset, DataLoader, RandomSampler
    6. from torch.utils.tensorboard import SummaryWriter
    7. from tqdm import tqdm, trange
    8. import os
    9. import numpy as np
    10. import pandas as pd
    11. from sklearn.model_selection import train_test_split
    12. from sklearn.metrics import f1_score, accuracy_score
    13. from pprint import pprint
    14. import logging
    15. import argparse
    16.  
    17. logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s: %(message)s")
    18.  
    19.  
    20. class SST2Dataset:
    21.     def __init__(self, data_dir, tokenizer, max_seq_len, train_mode):
    22.         self.data_dir = data_dir
    23.         self.tokenizer = tokenizer
    24.         self.max_seq_len = max_seq_len
    25.         self.train_mode = train_mode
    26.         self.data_df = self.load_data()
    27.         self.train_df, self.valid_df = self.split_data()
    28.         self.train_inputs, self.train_masks = self.tokenize_data(self.train_df)
    29.         self.valid_inputs, self.valid_masks = self.tokenize_data(self.valid_df)
    30.         self.train_labels = self.train_df["label"].tolist()
    31.         self.valid_labels = self.valid_df["label"].tolist()
    32.  
    33.     def load_data(self):
    34.         data_df = pd.read_csv(os.path.join(self.data_dir, "train.tsv"), sep="\t")
    35.         return data_df
    36.  
    37.     def split_data(self):
    38.         data_df = self.data_df
    39.         train_df, valid_df = train_test_split(data_df, test_size=0.2, random_state=42)
    40.         return train_df, valid_df
    41.  
    42.     def tokenize_data(self, data_df):
    43.         inputs_1 = list(data_df["sentence1"])
    44.         inputs_2 = list(data_df["sentence2"])
    45.         inputs = inputs_1 + inputs_2
    46.         masks = [1] * len(inputs_1) + [0] * len(inputs_2)
    47.         inputs = [self.tokenizer.tokenize(sent)[:self.max_seq_len] for sent in inputs]
    48.         inputs = [self.tokenizer.convert_tokens_to_ids(["[CLS]"] + input) for input in inputs]
    49.         inputs = [input[0 : self.max_seq_len] + [0] * (self.max_seq_len - len(input)) for input in inputs]
    50.         inputs = torch.tensor(inputs)
    51.         masks = torch.tensor(masks)
    52.         return inputs, masks
    53.  
    54.     def get_data(self, data_type):
    55.         if data_type == "train":
    56.             inputs, masks, labels = self.train_inputs, self.train_masks, self.train_labels
    57.         elif data_df == "valid":
    58.             inputs, masks, labels = self.valid_inputs, self.valid_masks, self.valid_labels
    59.         return inputs, masks, labels
    60.  
    61.  
    62. class BertClassifier(nn.Module):
    63.     def __init__(self, bert_model, out_dim):
    64.         super(BertClassifier, self).__init__()
    65.         self.bert_model = bert_model
    66.         self.out = nn.Linear(768, out_dim)
    67.  
    68.     def forward(self, inputs, masks):
    69.         _, _, _ = self.bert_model(inputs, masks)
    70.         pooled = outputs[:, 0]
    71.         out = self.out(pooled)
    72.         return out
    73.  
    74.  
    75. def train_epoch(train_data, optimizer, scheduler, writer, epoch, args):
    76.     # 训练模型
    77.     bert_model.train()
    78.     train_loss = 0
    79.     num_train_data = 0
    80.     for batch_idx, train_batch in enumerate(train_data):
    81.         train_batch_inputs, train_batch_masks, train_batch_labels = train_batch
    82.         train_batch_inputs, train_batch_masks, train_batch_labels = (
    83.             train_batch_inputs.to(args.device),
    84.             train_batch_masks.to(args.device),
    85.             train_batch_labels.to(args.device),
    86.         )
    87.         optimizer.zero_grad()
    88.         bert_out = bert_model(train_batch_inputs, train_batch_masks)
    89.         loss = F.cross_entropy(bert_out, train_batch_labels)
    90.         train_loss += loss.item()
    91.         num_train_data += len(train_batch_labels)
    92.         loss.backward()
    93.         optimizer.step()
    94.         if scheduler is not None:
    95.             scheduler.step()
    96.         writer.add_scalar("loss", loss.item(), global_step=num_train_data)
    97.         writer.add_scalar("learning_rate", optimizer.param_groups[0]["lr"], global_step=num_train_data)
    98.         writer.add_scalar("train_loss", train_loss / (batch_idx + 1), global_step=num_train_data)
    99.         writer.add_scalar("train_acc", accuracy_score(train_batch_labels, np.argmax(bert_out.detach().cpu().numpy(), axis=-1)), global_step=num_train_data)
    100.  
    101.  
    102. def eval_epoch(valid_data, writer, epoch, args):
    103.     # 验证模型
    104.     bert_model.eval()
    105.     valid_loss = 0
    106.     num_valid_data = 0
    107.     valid_preds = []
    108.     valid_labels = []
    109.     with torch.no_grad():
    110.         for batch_idx, valid_batch in enumerate(valid_data):
    111.             valid_batch_inputs, valid_batch_masks, valid_batch_labels = valid_batch
    112.             valid_batch_inputs, valid_batch_masks, valid_batch_labels = (
    113.                 valid_batch_inputs.to(args.device),
    114.                 valid_batch_masks.to(args.device),
    115.                 valid_batch_labels.to(args.device),
    116.             )
    117.             bert_out = bert_model(valid_batch_inputs, valid_batch_masks)
    118.             loss = F.cross_entropy(bert_out, valid_batch_labels)
    119.             valid_loss += loss.item()
    120.             num_valid_data += len(valid_batch_labels)
    121.             valid_preds.append(bert_out.detach().cpu().numpy())
    122.             valid_labels.append(valid_batch_labels.detach().cpu().numpy())
    123.         valid_preds = np.concatenate(valid_preds, axis=0)
    124.         valid_labels = np.concatenate(valid_labels, axis=0)
    125.         valid_acc = accuracy_score(valid_labels, np.argmax(valid_preds, axis=-1))
    126.         valid_loss = valid_loss / (batch_idx + 1)
    127.         writer.add_scalar("valid_loss", valid_loss, global_step=epoch + 1)
    128.         writer.add_scalar("valid_acc", valid_acc, global_step=epoch + 1)
    129.         writer.add_scalar("valid_f1", f1_score(valid_labels, np.argmax(valid_preds, axis=-1)), global_step=epoch + 1)
    130.  
    131.  
    132. def train(args):
    133.     # 训练模型
    134.     writer = SummaryWriter(log_dir=os.path.join(args.log_dir, "train"))
    135.     for epoch in trange(args.num_epochs, desc="Epoch"):
    136.         train_epoch(
    137.             train_data=train_data,
    138.             optimizer=optimizer,
    139.             scheduler=scheduler,
    140.             writer=writer,
    141.             epoch=epoch,
    142.             args=args,
    143.         )
    144.         eval_epoch(valid_data=valid_data, writer=writer, epoch=epoch, args=args)
    145.         bert_model.save_pretrained(os.path.join(args.log_dir, "bert_model"))
    146.     writer.close()
    147.  
    148.  
    149. def test_epoch(test_data, writer, epoch, args):
    150.     # 测试模型
    151.     bert_model.eval()
    152.     test_loss = 0
    153.     num_test_data = 0
    154.     test_preds = []
    155.     test_labels = []
    156.     with torch.no_grad():
    157.         for batch_idx, test_batch in enumerate(test_data):
    158.             test_batch_inputs, test_batch_masks, test_batch_labels = test_batch
    159.             test_batch_inputs, test_batch_masks, test_batch_labels = (
    160.                 test_batch_inputs.to(args.device),
    161.                 test_batch_masks.to(args.device),
    162.                 test_batch_labels.to(args.device),
    163.             )
    164.             bert_out = bert_model(test_batch_inputs, test_batch_masks)
    165.             loss = F.cross_entropy(bert_out, test_batch_labels)
    166.             test_loss += loss.item()
    167.             num_test_data += len(test_batch_labels)
    168.             test_preds.append(bert_out.detach().cpu().numpy())
    169.             test_labels.append(test_batch_labels.detach().cpu().numpy())
    170.         test_preds = np.concatenate(test_preds, axis=0)
    171.         test_labels = np.concatenate(test_labels, axis=0)
    172.         test_acc = accuracy_score(test_labels, np.argmax(test_preds, axis=-1))
    173.         test_loss = test_loss / (batch_idx + 1)
    174.         writer.add_scalar("test_loss", test_loss, global_step=epoch + 1)
    175.         writer.add_scalar("test_acc", test_acc, global_step=epoch + 1)
    176.         writer.add_scalar("test_f1", f1_score(test_labels, np.argmax(test_preds, axis=-1)), global_step=epoch + 1)
    177.  
    178.  
    179. def test(args):
    180.     writer = SummaryWriter(log_dir=os.path.join(args.log_dir, "test"))
    181.     for epoch in trange(args.num_epochs, desc="Epoch"):
    182.         test_epoch(test_data=test_data, writer=writer, epoch=epoch, args=args)
    183.     writer.close()
    184.  
    185.  
    186. if __name__ == "__main__":
    187.     parser = argparse.ArgumentParser()
    188.     parser.add_argument("--data_dir", type=str, default="./data")
    189.     parser.add_argument("--log_dir", type=str, default="./logs")
    190.     parser.add_argument("--num_epochs", type=int, default=10)
    191.     parser.add_argument("--train_mode", type=str, default="train")
    192.     parser.add_argument("--max_seq_len", type=int, default=128)
    193.     parser.add_argument("--batch_size", type=int, default=32)
    194.     parser.add_argument("--lr", type=float, default=2e-5)
    195.     parser.add_argument("--num_workers", type=int, default=0)
    196.     parser.add_argument("--seed", type=int, default=42)
    197.     parser.add_argument("--device", type=str, default="cuda")
    198.     args = parser.parse_args()
    199.     pprint(vars(args))
    200.  
    201.     bert_tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
    202.     bert_model = BertModel.from_pretrained("bert-base-uncased")
    203.     bert_model.to(args.device)
    204.  
    205.     if args.train_mode == "train":
    206.         train_data = SST2Dataset(
    207.             data_dir=args.data_dir,
    208.             tokenizer=bert_tokenizer,
    209.             max_seq_len=args.max_seq_len,
    210.             train_mode=args.train_mode,
    211.         ).get_data(data_type="train")
    212.         train_data = TensorDataset(*train_data)
    213.         train_data = DataLoader(
    214.             train_data,
    215.             batch_size=args.batch_size,
    216.             shuffle=True,
    217.             num_workers=args.num_workers,
    218.         )
    219.  
    220.         valid_data = SST2Dataset(
    221.             data_dir=args.data_dir,
    222.             tokenizer=bert_tokenizer,
    223.             max_seq_len=args.max_seq_len,
    224.             train_mode=args.train_mode,
    225.         ).get_data(data_type="valid")
    226.         valid_data = TensorDataset(*valid_data)
    227.         valid_data = DataLoader(
    228.             valid_data,
    229.             batch_size=args.batch_size,
    230.             shuffle=False,
    231.             num_workers=args.num_workers,
    232.         )
    233.  
    234.         test_data = SST2Dataset(
    235.             data_dir=args.data_dir,
    236.             tokenizer=bert_tokenizer,
    237.             max_seq_len=args.max_seq_len,
    238.             train_mode=args.train_mode,
    239.         ).get_data(data_type="test")
    240.         test_data = TensorDataset(*test_data)
    241.         test_data = DataLoader(
    242.             test_data,
    243.             batch_size=args.batch_size,
    244.             shuffle=False,
    245.             num_workers=args.num_workers,
    246.         )
    247.  
    248.         optimizer = torch.optim.Adam(bert_model.parameters(), lr=args.lr)
    249.         scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
    250.             optimizer=optimizer, mode="min", factor=0.5, patience=2, verbose=True
    251.         )
    252.         train(args)
    253.         test(args)
    254.  
    255.     elif args.train_mode == "test":
    256.         test_data = SST2Dataset(
    257.             data_dir=args.data_dir,
    258.             tokenizer=bert_tokenizer,
    259.             max_seq_len=args.max_seq_len,
    260.             train_mode=args.train_mode,
    261.         ).get_data(data_type="test")
    262.         test_data = TensorDataset(*test_data)
    263.         test_data = DataLoader(
    264.             test_data,
    265.             batch_size=args.batch_size,
    266.             shuffle=False,
    267.             num_workers=args.num_workers,
    268.         )
    269.         test(args)

    四、结果分析

    4.1 提问内容

    prompt = "# language: Python\n# 帮忙写一个冒泡排序\n"

    prompt中中文文字部分为需要实现的问题。 

    4.2 反馈内容长度设置

    outputs = model.generate(inputs, max_length=256)

    max_length 为设置反馈的长度，可以根据自己实际情况进行调整。 

  • 相关阅读:
    ros2与turtlebot3仿真教程-turtlebot3导航
    HTML5期末考核大作业，电影网站——橙色国外电影 web期末作业设计网页
    opencv改变像素点的颜色---------c++
    Node中的CSRF攻击和防御
    SQL Server报错：数据库"YourDatabaseName"的事务日志已满，原因为"LOG_BACKUP"
    redis集群主从缩容（docker中）
    Java核心篇，二十三种设计模式（十九），行为型——观察者模式
    【C语言】数组
    高级深入--day36
    lodash已死？radash库方法介绍及源码解析 —— 判断方法篇
  • 原文地址：https://blog.csdn.net/weixin_43734080/article/details/133776347