【Hello AI】安装并使用DeepGPU-LLM-处理大语言模型任务

本文涉及的产品
轻量应用服务器 2vCPU 4GiB,适用于搭建容器环境
轻量应用服务器 4vCPU 16GiB,适用于搭建游戏自建服
轻量应用服务器 2vCPU 4GiB,适用于搭建Web应用/小程序
简介: 在处理大语言模型任务中,您可以根据实际业务部署情况,选择在不同环境(例如GPU云服务器环境或Docker环境)下安装推理引擎DeepGPU-LLM,然后通过使用DeepGPU-LLM工具实现大语言模型(例如Llama模型、ChatGLM模型、百川Baichuan模型或通义千问Qwen模型)在GPU上的高性能推理优化功能

在处理大语言模型任务中,您可以根据实际业务部署情况,选择在不同环境(例如GPU云服务器环境或Docker环境)下安装推理引擎DeepGPU-LLM,然后通过使用DeepGPU-LLM工具实现大语言模型(例如Llama模型、ChatGLM模型、百川Baichuan模型或通义千问Qwen模型)在GPU上的高性能推理优化功能。

安装DeepGPU-LLM

根据您的业务场景不同,支持在GPU云服务器环境或者Docker环境下安装DeepGPU-LLM。

在GPU云服务器环境下安装DeepGPU-LLM

LLM模型的特性一般适用于GPU计算型实例,本文以GPU计算型实例规格gn7i为例,更多信息,请参见GPU计算型

  1. 创建GPU实例。
  1. 前往实例创建页
  2. 选择自定义购买页签。
  3. 按需选择付费类型、地域、实例规格、镜像等配置。

需要注意的参数项设置如下图所示,其他配置项参数的详细说明,请参见配置项说明

  • 实例:以ecs.gn7i-c8g1.2xlarge实例规格为例。
  • 镜像:选择云市场镜像中的deepgpu-llm-inference-ubuntu2004镜像。

说明该镜像是阿里云免费提供的基于大语言模型LLM场景的AI推理解决方案镜像。

  1. 远程连接已创建的GPU实例。

具体操作,请参见通过密码或密钥认证登录Linux实例

  1. 执行以下命令,安装DeepGPU-LLM。

根据所需DeepGPU-LLM版本和环境依赖PyTorch版本、CUDA版本,选择合适的DeepGPU-LLM安装包。其中:

  • 如果环境依赖为PyTorch 2.0+CUDA 11.8或PyTorch 2.0+CUDA 11.7,则选择deepgpu_llm-x.x.x+pt2.0cu117-py3-none-any.whl安装包(默认环境);如果选择其他安装包,则需要升级或降级当前的依赖软件。
  • x.x.x应替换为您实际的DeepGPU-LLM版本号。如何获取最新DeepGPU-LLM版本号,请参见DeepGPU-LLM加速安装包
# for PyTorch 1.13
pip3 install deepgpu_llm-x.x.x+pt1.13cu117-py3-none-any.whl
# for PyTorch 2.0
pip3 install deepgpu_llm-x.x.x+pt2.0cu117-py3-none-any.whl
# for PyTorch 2.1
pip3 install deepgpu_llm-x.x.x+pt2.1cu121-py3-none-any.whl
  1. (条件必选)如果使用Qwen模型,执行以下命令,安装依赖库。
pip install einops transformers_stream_generator tiktoken

在Docker环境下安装DeepGPU-LLM

  1. 准备Docker环境。
  1. 执行以下命令,安装或升级docker-ce。
apt update
apt remove docker docker-engine docker-ce docker.io containerd runc
apt install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
apt-key fingerprint 0EBFCD88
add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
apt update
apt install docker-ce
docker -v
  1. 执行以下命令,安装nvidia-container-toolkit。
$ curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list \
  && \
    sudo apt-get update
$ apt-get install -y nvidia-container-toolkit
$ nvidia-ctk runtime configure --runtime=docker
$ systemctl restart docker

如需了解更多信息,请参见Installing the NVIDIA Container Toolkit

  1. 执行以下命令,在Docker环境中拉取并启用Docker镜像。
# torch 2.0, cuda 11.7
docker pull pytorch/pytorch:2.0.1-cuda11.7-cudnn8-devel
docker run -ti --gpus all --name="deepgpu_llm" --network=host \
           -v /root/workspace:/root/workspace \
           --shm-size 5g pytorch/pytorch:2.0.1-cuda11.7-cudnn8-devel
# torch 2.1, cuda 12.1
docker pull pytorch/pytorch:2.1.0-cuda12.1-cudnn8-devel
docker run -ti --gpus all --name="deepgpu_llm" --network=host \
           -v /root/workspace:/root/workspace \
           --shm-size 5g pytorch/pytorch:2.1.0-cuda12.1-cudnn8-devel

主要参数说明如下:

参数项

说明

--shm-size

指定容器的共享内存大小,其大小会影响Triton服务器部署。

例如:--shm-size 5g表示将共享内存大小设置为5 GB。您可以根据需要调整此值,以满足您的模型推理所需的内存需求。

-v /root/workspace:/root/workspace

将主机目录映射到Docker中的相应目录,使得主机和Docker之间可以共享文件,请根据自己实际环境情况进行映射。

pytorch/pytorch:2.0.1-cuda11.7-cudnn8-devel

PyTorch的Docker映像标签。

pytorch/pytorch:2.1.0-cuda12.1-cudnn8-devel

  1. 执行以下命令,安装依赖库。
apt update
apt install openmpi-bin libopenmpi-dev curl

上述命令安装的openmpi-bin提供了OpenMPI、libopenmpi-dev软件包以及curl软件包。

  1. 安装DeepGPU-LLM。

根据所需的DeepGPU-LLM版本和依赖PyTorch版本,通过pip3 install命令安装DeepGPU-LLM。其中,x.x.x应替换为您实际的DeepGPU-LLM版本号。如何获取最新DeepGPU-LLM版本号,请参见DeepGPU-LLM加速安装包

# for PyTorch 1.13
pip3 install deepgpu_llm==x.x.x+pt1.13cu117 \
    -f https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/aiacc-inference-llm/deepgpu_llm.html
# for PyTorch 2.0
pip3 install deepgpu_llm==x.x.x+pt2.0cu117 \
    -f https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/aiacc-inference-llm/deepgpu_llm.html
# for PyTorch 2.1
pip3 install deepgpu_llm==x.x.x+pt2.1cu121 \
    -f https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/aiacc-inference-llm/deepgpu_llm.html
  1. (条件必选)如果使用Qwen模型,执行以下命令,安装依赖库。
pip install einops transformers_stream_generator tiktoken

使用DeepGPU-LLM

DeepGPU-LLM安装成功后,您可以参考不同模型的推理示例代码编写自己的推理代码,也可以使用软件包自带的代码进行推理优化服务。无论DeepGPU-LLM安装在GPU云服务器环境中还是Docker环境中,其使用方法一样,本操作以使用安装在GPU云服务器环境中的DeepGPU-LLM为例。

步骤一:准备模型

下载模型前,您已成功登录GPU实例。更多信息,请参见连接方式概述

  • huggingface格式的模型
  1. 执行以下命令,下载huggingface格式的开源模型。

模型名称

下载命令

Llama

 

git-lfs clone https://huggingface.co/meta-llama/Llama-2-7b

ChatGLM

 

git-lfs clone https://huggingface.co/THUDM/chatglm2-6b

Baichuan

 

git-lfs clone https://huggingface.co/baichuan-inc/Baichuan-13B-Chat

通义千问Qwen

 

git-lfs clone https://huggingface.co/Qwen/Qwen-7B-Chat
  1. 执行以下命令,进行开源模型格式转换。

使用DeepGPU_LLM前,您需要先将huggingface格式的开源模型转换为DeepGPU_LLM支持的格式,然后才能使用DeepGPU_LLM进行模型的推理优化服务。以下为四类开源模型转换方法:

在使用模型转换脚本前,请先了解各命令参数含义:

参数名

说明

huggingface_xxx_convert

xxx可以替换为具体的模型名称,本参数表示各模型的转换脚本。

in_file

待转换的原始模型所在路径。

saved_dir

格式转换后的模型所存放的路径。

infer_gpu_num

模型切分份数或推理使用的GPU卡数。

weight_data_type

模型使用的精度,例如fp16。

model_name

模型自定义的名称,可任意填写。

说明脚本运行完成后,会在/path/to/llama-7b-hf-converted/${ infer_gpu_num }-gpu/下生成格式转换后的模型。例如infer_gpu_num=1,则格式转换后的最终路径为/path/to/llama-7b-hf-converted/1-gpu/

步骤二:参考推理示例代码

进行大模型推理任务时,需要您自行准备模型的推理代码,您可以参考本步骤提供的四类模型的推理示例代码。

  • LIama系列模型推理参考代码
import time
from deepgpu_llm.llama_model import llama_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig
from transformers import LlamaTokenizer
model_path = '/workspace/llama-7b-hf-converted'
tokenizer = LlamaTokenizer.from_pretrained(model_path)
model_path = "/workspace/llama-7b-hf-converted/1-gpu"
tensor_para_size = 1
precision = 0  # fp16 mode
kv_cache_quant_level = 1
generation_config = DeepGPUGeneration Config(max_new_tokens=128)
model = llama_model(model_path, tensor_para_size,
                    precision, kv_cache_quant_level,
                    generation_config=generation_config)
payload = ["Hey, are you consciours? Can you talk to me?"]
start_ids = tokenizer(payload, return_tensors="pt").input_ids
for i in range(5):
    s = time.time()
    output = model.generate(start_ids, generation_config)
    e = time.time()
    print("---- time", e - s)
tokens = output[0].tolist()
for i in range(len(tokens)):
    print(tokenizer.decode(tokens[i][0]))
  • ChatGLM系列模型推理参考代码
import time
from deepgpu_llm.chatglm_model import chatglm_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig
from transformers import AutoTokenizer
model_path = "/workspace/chatglm2-6b-converted"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model_path = "/workspace/chatglm2-6b-converted/1-gpu"
tp_size = 1
precision = 0  # fp16 mode
generation_config = DeepGPUGenerationConfig(max_new_tokens=128)
model = chatglm_model(model_path, tp_size, precision,
                      generation_config=generation_config)
payload = ["Hey, are you consciours? Can you talk to me?"]
start_ids = tokenizer(payload, return_tensors="pt").input_ids
for i in range(8):
    start = time.time()
    output = model.generate(start_ids, generation_config)
    end = time.time()
    print("-----", end - start)
tokens = output.tolist()
for i in range(len(tokens)):
    print(tokenizer.decode(tokens[i][0]))
  • Baichuan系列模型推理参考代码
import time
from deepgpu_llm.baichuan_model import baichuan_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig
from transformers import AutoTokenizer
model_path = "/path/to/Baichuan-13B-Chat-converted"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model_path = "/path/to/Baichuan-13B-Chatconverted/2-gpu"
tp_size = 2    # tensor parallel
precision = 0  # fp16 mode
kv_cache_quant_level = 0
generation_config = DeepGPUGenerationConfig(max_new_tokens=128)
model = baichuan_model(model_path, tp_size, precision, kv_cache_quant_level,
                       generation_config=generation_config)
payload = "你好!你是谁?"
start_ids = tokenizer(payload, return_tensors="pt").input_ids
for i in range(8):
    start = time.time()
    output = model.generate([start_ids], generation_config)
    end = time.time()
    print("-----", end - start)
tokens = output[0].tolist()
print(tokenizer.decode(tokens[0][0], skip_special_tokens=True))
  • 通义千问Qwen系列模型推理参考代码
import time
from deepgpu_llm.qwen_model import qwen_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig
from transformers import AutoTokenizer
model_path = "/path/to/Qwen-7B-Chat-converted"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model_path = "/path/to/Qwen-7B-Chat-converted/1-gpu"
tp_size = 1    # tensor parallel
precision = 0  # fp16 mode
kv_cache_quant_level = 0
generation_config = DeepGPUGenerationConfig(max_new_tokens=128)
model = qwen_model(model_path, tp_size, precision, kv_cache_quant_level,
                   generation_config=generation_config)
payload = "你好!你是谁?"
start_ids = tokenizer(payload, return_tensors="pt").input_ids
for i in range(8):
    start = time.time()
    output = model.generate([start_ids], generation_config)
    end = time.time()
    print("-----", end - start)
tokens = output[0].tolist()
print(tokenizer.decode(tokens[0][0], skip_special_tokens=True))

(可选)步骤三:使用API接口推理

如果需要通过DeepGPU-LLM的API接口方式来使用DeepGPU-LLM进行推理服务,请参考本步骤操作,以Llama模型和ChatGLM模型为例。

使用DeepGPU-LLM进行推理的相关代码总览如下:

  1. 导入deepgpu_llm模块。

以Llama模型和ChatGLM模型为例:

  • Llama模型
# llama model
from deepgpu_llm.llama_model import llama_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig
from transformers import LlamaForCausalLM, LlamaTokenizer
  • ChatGLM模型
# chatglm model
from deepgpu_llm.llama_model import chatglm_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig
from transformers import AutoModel, AutoTokenizer
  1. 创建tokenizer和model参数并配置generation_config。

generation_config在模型创建或推理时配置,配置完成后即成为模型的一个属性。如果再次调用模型的相关函数,则无需再配置generation_config

以Llama模型和ChatGLM模型为例:

  • Llama模型
model_path = '/workspace/llama-7b-hf-converted'
tokenizer = LlamaTokenizer.from_pretrained(model_path)
model_path = "/workspace/llama-7b-hf-converted/1-gpu"
tensor_para_size = 1
precision = 0  # fp16 mode
kv_cache_quant_level = 0
model = llama_model(model_path, tensor_para_size, precision,
                    kv_cache_quant_level, generation_config=generation_config)
  • ChatGLM模型
model_path = "/workspace/chatglm2-6b-converted"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model_path = "/workspace/chatglm2-6b-converted/1-gpu"
tp_size = 1
precision = 0  # fp16 mode
generation_config = DeepGPUGenerationConfig(max_new_tokens=512, top_k=1)
model = chatglm_model(model_path, tp_size,
                      precision, generation_config=generation_config)

llama_model()chatglm_model()使用的主要参数说明如下:

参数名称

说明

model_dir

指定模型转换后的存放路径。

tensor_para_size

模型推理使用的GPU卡数。

precision

推理精度。取值范围:

  • 0:fp16
  • 1:int8
  • 3:int4

kv_cache_quant_level(ChatGLM模型暂不支持)

量化级别参数。取值范围

  • 0:无量化压缩。
  • 1:K8_V8量化。
  • 2:K8_V4量化。
  • 3:K4_V4量化。

默认值:0。

说明

推荐使用等级1,模型能在几乎不损失精度的情况下提升批量大小,并在批量大小较大时会显著提升推理速度。

generation_config

即DeepGPUGenerationConfig,用于配置生成相关参数。如果在此处配置该参数,则forward或者generate函数可以不用再配置。

  • 如果管理生成参数的generation_config为DeepGPUGenerationConfig类时,其代码原型如下:
class DeepGPUGenerationConfig():
    def __init__(self, **kwargs):
        self.max_new_tokens = kwargs.pop("max_new_tokens", 512)
        self.do_sample = kwargs.pop("do_sample", None)
        self.num_beams = kwargs.pop("num_beams", None)
        self.temperature = kwargs.pop("temperature", None)
        self.top_k = kwargs.pop("top_k", None)
        self.top_p = kwargs.pop("top_p", None)
        self.repetition_penalty = kwargs.pop("repetition_penalty", None)
        self.presence_penalty = kwargs.pop("presence_penalty", None)
        self.len_penalty = kwargs.pop("len_penalty", None)
        self.beam_search_diversity_rate = kwargs.pop("beam_search_diversity_rate", None)
  • 如果您没有设置DeepGPUGenerationConfig中的数据成员(即为None),则DeepGPU-LLM将读取原模型文件中的生成配置文件config.ini(如果配置文件存在),如果没有配置文件,则将使用默认配置参数。具体说明如下:

参数名

类型

说明

max_new_tokens

int

指定模型的最大生成长度。

do_sample

bool

是否开启sample模式。如果开启,则DeepGPU_LLM将为不同batch生成不同结果。

num_beams

int

beam search的束宽度。

temperature

float

取值区间:[0.0, 1.0]。该值越大则生成文本多样性越大。

top_k

int

取值区间为大于0的整数。代表生成时从概率最大的top_k个值中选择。

top_p

float

取值区间:[0.0, 1.0]。只从概率之和超过top_p的最小单词集合中进行采样,而不考虑其他低概率的单词。

repetition_penalty

float

取值区间:[0.0, 1.0]。连续重复词惩罚,越大代表出现重复词的概率越大。

presence_penalty

float

取值区间:[0.0,1.0]。当该参数设置较高时,生成模型会尽量避免产生重复的词语、短语或句子。

len_penalty

float

该值大于0时鼓励模型生成更长的序列,小于0时鼓励模型生成更短的序列。

beam_search_diversity_rate

float

beam search使用到的参数。

  1. 生成token list作为模型推理输入参数。
payload = ["Hey, are you consciours? Can you talk to me?"]
start_ids = tokenizer(payload, return_tensors="pt").input_ids
  1. 调用推理接口model.generate()。
output = model.generate([start_ids],generation_config)

主要参数说明如下:

输入参数

说明

start_ids

输入步骤3已生成的token list。

generation_config

DeepGPUGenerationConfig类,用于调整生成参数。

  1. 打印输出结果。
tokens = output[0].tolist()
for i in range(len(tokens)):
    print(tokenizer.decode(tokens[i][0]))

(可选)步骤四:参考对话接口示例

如果需要通过对话接口方式来使用DeepGPU-LLM进行推理服务,请参考对话接口chat和流式对话接口Stream Chat示例。

  • 对话接口chat示例

model.chat()是一个简单的对话接口,调用即可打印回复语句。其示例代码如下:

import torch
from deepgpu_llm.baichuan_model import baichuan_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig
from transformers import AutoTokenizer
model_path = "path/to/your/llama_tokenizer"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model_path = "path/to/your/llama_converted/1-gpu"
tp_size = 1
generation_config = DeepGPUGenerationConfig(max_new_tokens=256)
model = baichuan_model(model_path, tp_size, generation_config=generation_config)
query = "Hello!"
response = model.chat(tokenizer, query, response_skip_inputs=False)
query = "What is your name ?"
response = model.chat(tokenizer, query, stream=True, response_skip_inputs=True)
  • 流式对话接口Stream Chat示例

stream chat功能仅支持beam width=1的情况,但可以进行多batch的流式输出。其示例代码如下:

import time
from deepgpu_llm.llama_model import llama_model
from deepgpu_llm.deepgpu_utils import DeepGPUGenerationConfig,DeepGPUStreamer
from transformers import AutoModel, LlamaTokenizer
#仅支持beam_width=1的情况
#读取模型
model_path = "/root/workspace/Llama-2-7b-chat-hf-converted"
tokenizer = LlamaTokenizer.from_pretrained(model_path, trust_remote_code=True)
streamer  = DeepGPUStreamer(tokenizer)
generation_config = DeepGPUGenerationConfig(max_new_tokens = 512,
                                          **{'skip_special_tokens' : True})
model_path = "/root/workspace/Llama-2-7b-chat-hf-converted/1-gpu"
tp_size = 1
model = llama_model(model_path, tp_size, generation_config = generation_config)
if __name__ == '__main__' :
    #初始化输入
    query = 'china is a large country.'
    inputs = []
    inputs.append(tokenizer(query, return_tensors='pt').input_ids)
    #内存预热
    t1 = time.time()
    for output in model.stream_generate(input_ids=inputs,generation_config):
        printable_str = streamer.handel_str(output[0][0][0]) 
        print(printable_str, flush=True, end="")
    print(streamer.end())
    print("-----------------test now ----------------------")
    t1 = time.time()
    #调用stream_generete方法,逐个token返回结果
    for output in model.stream_generate(input_ids=inputs,skip_inputs=True):
        #处理输出token,设置回车、空格、判断是否是单词前缀等,使字符串可打印出来
        printable_str = streamer.handel_str(output[0][0][0]) 
        #打印
        print(printable_str, flush=True, end="") 
    #清除DeepGPUStreamer中的字符串缓存
    print(streamer.end()) 
    t2 = time.time()
    print("cost time:",t2-t1)

stream_generate接口说明如下:

for output in model.stream_generate(input_ids=inputs,generation_config=generation_config,skip_inputs=True)

说明返回值output是一个[batch_size , 1 , seq_len]的tensor。

参数名

说明

input_ids

输入token list

generation_config

DeepGPUGenerationConfig类,用于调整生成参数

skip_inputs

输出句子中是否打印输入query。

步骤五:运行推理代码

除了您自行准备模型推理代码外,DeepGPU-LLM安装包也为您提供了几个模型的运行实例,您可以通过自带的可运行代码实例体验模型运行效果和了解具体代码细节。具体运行命令可以通过--help来查看具体的配置选项。例如:

本步骤以DeepGPU-LLM提供的四类模型的流式输出对话实例代码为例,进行模型推理服务的调用命令如下:

  • Llama模型流式输出对话实例

DeepGPU-LLM提供了Llama模型的流式对话实例代码:llama_cli,该实例支持llama系列和llama2系列模型推理,调用命令如下:

llama_cli -i models/deepgpu/llama2-7b/1-gpu/ -t models/llama2-7b/
  • Baichuan模型流式输出对话实例

DeepGPU-LLM提供了Baichuan模型的流式对话实例代码:baichuan_cli,该实例支持baichuan 1/2系列模型推理,调用命令如下

baichuan_cli -i models/deepgpu/baichuan2-7b-chat/1-gpu/ -t models/Baichuan2-7B-Chat/

调用完成后,您可以输入内容和Baichuan模型进行对话。例如:

  • ChatGLM模型流式输出对话实例

DeepGPU-LLM提供了ChatGLM模型的流式对话实例代码:chatglm_cli,该实例支持chatglm-6b和chatglm2-6b等模型推理,调用命令如下:

chatglm_cli -i models/deepgpu/chatglm2-6b/1-gpu/ -t models/chatglm2-6b/

调用完成后,您可以输入内容和ChatGLM模型进行对话。例如:

  • 通义千问Qwen模型流式输出对话实例

DeepGPU-LLM提供了Qwen模型的流式对话实例代码:qwen_cli,该实例支持qwen-7b和qwen-14b等模型推理,调用命令如下:

qwen_cli -i models/deepgpu/qwen-7b-chat/1-gpu/ -t models/Qwen-7B-Chat/

调用完成后,您可以输入内容和ChatGLM模型进行对话。例如:

详情请参见链接:https://help.aliyun.com/zh/egs/developer-reference/install-and-use-deepgpu-llm


好啦!小弹的分享到此为止。我们更欢迎您分享您对阿里云产品的设想、对功能的建议或者各种吐槽,请扫描提交问卷并获得社区积分或精美礼品一份。https://survey.aliyun.com/apps/zhiliao/P4y44bm_8

【扫码填写上方调研问卷】

欢迎每位来到弹性计算的开发者们来反馈问题哦~







 


相关实践学习
部署Stable Diffusion玩转AI绘画(GPU云服务器)
本实验通过在ECS上从零开始部署Stable Diffusion来进行AI绘画创作,开启AIGC盲盒。
目录
打赏
0
2
0
1
727
分享
相关文章
AutoAgents:比LangChain更激进的AI开发神器!自然语言生成AI智能体军团,1句话搞定复杂任务
AutoAgents 是基于大型语言模型的自动智能体生成框架,能够根据用户设定的目标自动生成多个专家角色的智能体,通过协作完成复杂任务。支持动态生成智能体、任务规划与执行、多智能体协作等功能。
191 91
MiniMind:2小时训练出你的专属AI!开源轻量级语言模型,个人GPU轻松搞定
MiniMind 是一个开源的超小型语言模型项目,帮助开发者以极低成本从零开始训练自己的语言模型,最小版本仅需25.8M参数,适合在普通个人GPU上快速训练。
101 10
MiniMind:2小时训练出你的专属AI!开源轻量级语言模型,个人GPU轻松搞定
Mahilo:多智能体实时协作框架开源!人类与AI无缝交互,复杂任务一键协同
Mahilo 是一个灵活的多智能体框架,支持创建与人类互动的多智能体系统,适用于从客户服务到紧急响应等多种场景。
53 2
Mahilo:多智能体实时协作框架开源!人类与AI无缝交互,复杂任务一键协同
MILS:无需对LLM进行额外训练就能处理多模态任务,Meta AI提出零样本生成多模态描述方法
MILS 是 Meta AI 推出的零样本生成高质量多模态描述方法,支持图像、视频和音频的描述生成,无需额外训练。
128 34
MILS:无需对LLM进行额外训练就能处理多模态任务,Meta AI提出零样本生成多模态描述方法
OctoTools:斯坦福开源AI推理神器!16项测试准确率碾压GPT-4o,一键搞定复杂任务
OctoTools 是斯坦福大学推出的开源智能体框架,通过标准化工具卡片和自动化工具集优化算法,显著提升复杂推理任务的解决效率,支持多领域应用。
51 3
OctoTools:斯坦福开源AI推理神器!16项测试准确率碾压GPT-4o,一键搞定复杂任务
SWE-Lancer:OpenAI发布衡量AI工程能力的「血汗标尺」!1400个百万美元任务实测,GPT-4o仅能赚2.9万刀?
SWE-Lancer 是 OpenAI 推出的基准测试,评估语言模型在自由职业软件工程任务中的表现,涵盖真实任务、端到端测试和多选项评估。
75 4
SWE-Lancer:OpenAI发布衡量AI工程能力的「血汗标尺」!1400个百万美元任务实测,GPT-4o仅能赚2.9万刀?
idea如何使用AI编程提升效率-在IntelliJ IDEA 中安装 GitHub Copilot 插件的步骤-卓伊凡
idea如何使用AI编程提升效率-在IntelliJ IDEA 中安装 GitHub Copilot 插件的步骤-卓伊凡
118 15
idea如何使用AI编程提升效率-在IntelliJ IDEA 中安装 GitHub Copilot 插件的步骤-卓伊凡
AI做数学学会动脑子! UCL等发现LLM程序性知识,推理绝不是背答案
大型语言模型(LLM)在数学推理中的表现一直备受争议。伦敦大学学院等机构的研究发现,LLM可能通过综合程序性知识而非简单检索来解决数学问题。研究分析了7B和35B参数模型在三个简单数学任务中的数据依赖,表明模型更关注解决问题的过程和方法,而非答案本身。这一发现为改进AI系统提供了新思路,但也指出LLM在复杂问题处理上仍存在局限。论文地址:https://arxiv.org/abs/2411.12580
11 2
2025保姆级JupyterLab 4.0安装指南|全平台部署+AI编程环境配置
JupyterLab 是下一代交互式计算开发环境,2025年发布的4.0版本新增多语言内核支持(Python/R/Julia/JavaScript一键切换)、实时协作功能、AI辅助编程(集成GPT-5代码补全与错误诊断)和可视化调试器等特性。本文详细介绍其技术定位、跨平台安装方案、安装流程、高阶功能配置、典型应用场景及故障排查指南,帮助用户高效使用JupyterLab进行开发。
MeteoRA:多任务AI框架革新!动态切换+MoE架构,推理效率提升200%
MeteoRA 是南京大学推出的多任务嵌入框架,基于 LoRA 和 MoE 架构,支持动态任务切换与高效推理。
46 3
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等