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

本文涉及的产品
云服务器 ECS,每月免费额度280元 3个月
云服务器ECS,u1 2核4GB 1个月
简介: 在处理大语言模型任务中,您可以根据实际业务部署情况,选择在不同环境(例如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

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

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







 


相关实践学习
基于阿里云DeepGPU实例,用AI画唯美国风少女
本实验基于阿里云DeepGPU实例,使用aiacctorch加速stable-diffusion-webui,用AI画唯美国风少女,可提升性能至高至原性能的2.6倍。
相关文章
|
24天前
|
TensorFlow 调度 算法框架/工具
【Hello AI】通过Docker安装并使用cGPU服务
cGPU服务可以隔离GPU资源,实现多个容器共用一张GPU卡。该服务作为阿里云容器服务Kubernetes版ACK(Container Service for Kubernetes)的组件对外提供服务,本文介绍如何通过Docker安装并使用cGPU服务。
|
26天前
|
人工智能 弹性计算 自然语言处理
【Hello AI】AIACC-ACSpeed性能数据
本文展示了AIACC-ACSpeed的部分性能数据,相比较通过原生DDP训练模型后的性能数据,使用AIACC-ACSpeed训练多个模型时,性能具有明显提升。
|
22天前
|
人工智能 自然语言处理 开发工具
AI2 开源新 LLM,重新定义 open AI
艾伦人工智能研究所(Allen Institute for AI,简称 AI2)宣布推出一个名为 OLMo 7B 的新大语言模型,并开源发布了预训练数据和训练代码。OLMo 7B 被描述为 “一个真正开放的、最先进的大型语言模型”。
|
1天前
|
存储 机器学习/深度学习 测试技术
mnn-llm: 大语言模型端侧CPU推理优化
mnn-llm: 大语言模型端侧CPU推理优化
8 1
|
17天前
|
机器学习/深度学习 人工智能 自然语言处理
大语言模型LLM中的幻觉
大语言模型LLM中的幻觉
25 0
|
24天前
|
并行计算 Linux 文件存储
【Hello AI】安装并使用FastGPU-命令行使用说明
用户可以通过FastGPU的命令行,快速地部署云上GPU集群,管理资源的生命周期。还可以便捷地为集群安装深度学习环境,在集群运行代码,查看运行日志以及释放资源。
|
24天前
|
人工智能 弹性计算 开发工具
【Hello AI】安装并使用FastGPU-Python SDK使用说明
用户可以通过FastGPU提供的Python接口,将FastGPU集成到您的人工智能训练或推理脚本中,从而实现快速的云上部署和资源管理。
|
25天前
|
人工智能 弹性计算 固态存储
【Hello AI】AIACC-AGSpeed性能数据
本文展示了AIACC-AGSpeed(简称AGSpeed)的部分性能数据,相比较通过PyTorch原生Eager模式训练模型后的性能数据,使用AGSpeed训练多个模型时,性能具有明显提升。
|
25天前
|
机器学习/深度学习 人工智能 PyTorch
【Hello AI】安装和使用AIACC-AGSpeed(优化PyTorch深度学习模型)
AIACC-AGSpeed(简称AGSpeed)专注于优化PyTorch深度学习模型在阿里云GPU异构计算实例上的计算性能,相比原始的神龙AI加速引擎AIACC,可以实现无感的计算优化性能。本文为您介绍安装和使用AGSpeed的方法。
|
26天前
|
人工智能 弹性计算 测试技术
【Hello AI】AIACC-ACSpeed体验示例
AIACC-ACSpeed(简称ACSpeed)作为阿里云自研的AI训练加速器,在提高训练效率的同时能够降低使用成本,可以实现无感的分布式通信性能优化。ACSpeed软件包中已为您提供了适配DDP的示例代码,您可以参考本文快速体验使用ACSpeed进行模型分布式训练的过程以及性能提升效果。

相关产品

  • 云服务器 ECS
  • 轻量应用服务器
  • 弹性容器实例
  • http://www.vxiaotou.com