基于Truss＋Docker＋Kubernetes把开源模型Falcon-7B送上云端（译）

背景

到目前为止，我们已经看到了ChatGPT的能力及其所能提供的强大功能。然而，对于企业应用来说，像ChatGPT这样的封闭源代码模型可能会带来风险，因为企业自身无法控制他们的数据。尽管OpenAI公司声称用户数据不会被存储或用于训练模型，但是这并不能保证数据不会以某种方式泄露。

为了解决与封闭源代码模型相关的一些问题，研究人员正急于构建与ChatGPT等模型竞争的开源大型语言模型（LLM）。有了开源模型，企业可以在安全的云环境中托管模型，从而降低数据泄露的风险。最重要的是，你可以完全透明地了解模型的内部工作，这有助于用户与人工智能系统建立更多的信任关系。

随着开源LLM的最新进展，人们很想尝试新的模型，看看它们与ChatGPT等封闭源代码模型的对比。

然而，如今运行开源模型还存在着巨大的障碍。例如，调用ChatGPT API要比了解如何运行开源LLM要容易得多。

在这篇文章中，我的目标是通过展示如何在类似生产的环境中在云中运行Falcon-7B模型这样的开源模型来克服上述困难。最终，我们将能够通过类似于ChatGPT的API端点方式来访问这些模型。

挑战

运行开源模型的一个重大挑战是缺乏计算资源。即使是像Falcon-7B这样的"小"模型也需要GPU才能运行。

为了解决这个问题，我们可以利用云中的GPU。但是，这又带来了另一个挑战。我们如何将LLM进行容器化封装呢？我们如何启用GPU支持？启用GPU支持可能很棘手，因为它需要CUDA的知识。使用CUDA可能会很痛苦，因为您必须弄清楚如何安装正确的CUDA依赖项以及哪些版本是兼容的。

【译者注】CUDA（Compute Unified Device Architecture），是显卡厂商NVIDIA推出的运算平台。CUDA™是一种由NVIDIA推出的通用并行计算架构，它包含了CUDA指令集架构（ISA）以及GPU内部的并行计算引擎。开发人员可以使用C、C++和FORTRAN语言来为CUDA™架构编写程序。

因此，为了避开CUDA的死亡陷阱，许多公司已经创建了解决方案，可以在支持GPU的同时轻松地将模型容器化封装。在这篇博客文章中，我们将使用一个名为Truss的开源工具来帮助我们轻松地将LLM容器化，而不会带来太多麻烦。

Truss允许开发人员轻松地将使用任何框架构建的模型进行容器化封装。

为什么使用Truss？

Truss --- https://truss.baseten.co/e2e。

Truss有很多现成的有用功能，例如：

• 将Python模型转换为具有生产就绪API端点的微服务
• 通过Docker冻结依赖关系
• 支持GPU推理
• 模型的简单预处理和后处理
• 轻松安全的秘密管理

我以前用过Truss来部署机器学习模型，这个过程非常顺利和简单。Truss自动创建dockerfile并管理Python依赖项。我们所要做的就是为我们的模型提供代码。

其实，我们想使用像Truss这样的工具的主要原因是，借助GPU支持可以使部署我们的模型变得更加容易。

计划

以下是我将在这篇博客文章中介绍的主要内容：

1. 使用Truss在本地设置Falcon 7B
2. 如果你有GPU（我有RTX 3080），请在本地运行模型
3. 容器化模型并使用Docker运行它
4. 在谷歌云中创建一个支持GPU的Kubernetes集群来运行我们的模型

不过，不要担心，如果步骤2没有GPU，您仍然可以在云端运行模型。

以下是Github代码仓库地址，其中包含本文后面描述中所有有关代码（如果您想继续阅读的话）：

https://github.com/htrivedi99/falcon-7b-truss

让我们开始吧！

步骤1：使用Truss进行Falcon 7B本地设置

首先，我们需要创建一个Python版本≥3.8的项目。

然后，我们将从HuggingFace官网下载模型，并使用Truss进行包装。以下是我们需要安装的依赖项：

pip install truss

然后，在Python项目中创建一个名为main.py的脚本。这是一个临时脚本，我们将使用它来处理Truss。

接下来，我们将通过在终端中运行以下命令来设置Truss软件包：

truss init falcon_7b_truss

如果提示您创建新的Truss，请按"y"。完成后，您应该会看到一个名为falcon_7b_truss的新目录。在该目录中，将有一些自动生成的文件和文件夹。我们需要填写以下几项：model.py，它位于model文件夹下，也被文件config.yaml所引用。

正如我之前提到的，Truss只需要我们模型的代码，它会自动处理所有其他事情。我们将在model.py中编写代码，但它必须以特定的格式编写。

Truss希望每个模型至少支持三个功能：init、load和predict。

• __init__主要用于创建类变量

• load是我们从HuggingFace官网下载模型的地方

• predict是我们调用模型的地方以下是model.py的完整代码：

  import torch
  from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
  from typing import Dict

  MODEL_NAME = "tiiuae/falcon-7b-instruct"
  DEFAULT_MAX_LENGTH = 128

  class Model:
  def init(self, data_dir: str, config: Dict, **kwargs) -> None:
  self._data_dir = data_dir
  self._config = config
  self.device = "cuda" if torch.cuda.is_available() else "cpu"
  print("THE DEVICE INFERENCE IS RUNNING ON IS: ", self.device)
  self.tokenizer = None
  self.pipeline = None

  def load(self):
  self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
  model_8bit = AutoModelForCausalLM.from_pretrained(
  MODEL_NAME,
  device_map="auto",
  load_in_8bit=True,
  trust_remote_code=True)

  self.pipeline = pipeline(
  "text-generation",
  model=model_8bit,
  tokenizer=self.tokenizer,
  torch_dtype=torch.bfloat16,
  trust_remote_code=True,
  device_map="auto",
  )

  def predict(self, request: Dict) -> Dict:
  with torch.no_grad():
  try:
  prompt = request.pop("prompt")
  data = self.pipeline(
  prompt,
  eos_token_id=self.tokenizer.eos_token_id,
  max_length=DEFAULT_MAX_LENGTH,
  **request
  )[0]
  return {"data": data}

  except Exception as exc:
  return {"status": "error", "data": None, "message": str(exc)}

这里发生了什么：

• MODEL_NAME是我们将要使用的模型，在我们的案例中是falcon-7b-instruct模型
• 在load内部，我们从HuggingFace官网下载8位的模型。我们想要8位的原因是，当量化时，该模型在GPU上使用的内存明显更少。
• 此外，如果您想在低于13GB VRAM的GPU上本地运行模型，则需要以8位加载模型。
• predict函数接受JSON请求作为参数，并使用self.pipeline调用模型。torch.no_grad告诉Pytorch我们处于推理模式，而不是训练模式。很酷吧！这就是我们设置模型所需要的全部内容。

步骤2：在本地运行模型（可选）

如果你有一个拥有超过8GB VRAM的英伟达GPU，那么，你能够在本地运行该模型。

如果没有，请继续下一步。

我们需要下载更多的依赖项才能在本地运行模型。在下载依赖项之前，您需要确保安装了CUDA和正确的CUDA驱动程序。

因为我们试图在本地运行模型，所以Truss无法帮助我们管理CUDA的强大功能。

pip install transformers
pip install torch
pip install peft
pip install bitsandbytes
pip install einops
pip install scipy 

接下来，在falcon_7b_truss目录外创建的脚本main.py中，我们需要加载我们的Truss。

以下是main.py的代码：

import truss
from pathlib import Path
import requests
tr = truss.load("./falcon_7b_truss")
output = tr.predict({"prompt": "Hi there how are you?"})
print(output)

这里发生了什么：

• 如果您还记得的话，falcon_7b_truss目录是由Truss自动创建的。我们可以使用truss.load加载整个包，包括模型和依赖项

• 一旦我们加载了我们的包，我们就可以简单地调用predict方法来获得模型输出运行main.py即可从模型中获取输出。此模型文件的大小约为15 GB，因此下载该模型可能需要5-10分钟。运行脚本后，您应该会看到这样的输出：

  • {'data': {'generated_text': "Hi there how are you?\nI'm doing well. I'm in the middle of a move, so I'm a bit tired. I'm also a bit overwhelmed. I'm not sure how to get started. I'm not sure what I'm doing. I'm not sure if I'm doing it right. I'm not sure if I'm doing it wrong. I'm not sure if I'm doing it at all.\nI'm not sure if I'm doing it right. I'm not sure if I'm doing it wrong. I"}}

步骤3：使用Docker封装模型

通常，当人们将模型容器化封装时，他们会获取模型二进制文件和Python依赖项，并使用Flask或Fast API服务器将其打包。

很多都是样板化操作，我们不必自己费事。Truss会自动处理这些任务。我们已经提供了模型，Truss将创建服务器，所以剩下的唯一要做的就是提供Python依赖项。

config.yaml保存了我们模型的配置。这就是我们可以为模型添加依赖项的地方。配置文件已经提供了我们需要的大部分内容，但我们还需要添加一些内容。

以下是您需要添加到config.yaml中的内容：

apply_library_patches: true
bundled_packages_dir: packages
data_dir: data
description: null
environment_variables: {}
examples_filename: examples.yaml
external_package_dirs: []
input_type: Any
live_reload: false
model_class_filename: model.py
model_class_name: Model
model_framework: custom
model_metadata: {}
model_module_dir: model
model_name: Falcon-7B
model_type: custom
python_version: py39
requirements:
- torch
- peft
- sentencepiece
- accelerate
- bitsandbytes
- einops
- scipy
- git+https://github.com/huggingface/transformers.git
resources:
 use_gpu: true
 cpu: "3"
 memory: 14Gi
secrets: {}
spec_version: '2.0'
system_packages: []

所以，我们添加的主要内容都围绕着需求进行。所有列出的依赖项都是下载和运行模型所必需的。

我们增加的另一件重要的事情是资源（resources）。use_gpu:true非常重要，因为这告诉Truss在启用GPU支持的情况下为我们创建一个Dockerfile。这是用于配置任务的。

下一步，我们将对我们的模型进行容器化封装。如果您不知道如何使用Docker将模型封装，不要担心，Truss已经为您提供了服务。

在main.py文件中，我们将告诉Truss将所有内容打包在一起。以下是您需要的代码：

import truss
from pathlib import Path
import requests
tr = truss.load("./falcon_7b_truss")
command = tr.docker_build_setup(build_dir=Path("./falcon_7b_truss"))
print(command)

发生了什么：

• 首先，我们加载falcon_7b_truss。

• 接下来，docker_build_setup函数处理所有复杂的事情，比如创建Dockerfile和设置Fast API服务器。

• 如果您查看您的falcon_7b_truss目录，您会看到生成了更多的文件。我们不需要担心这些文件是如何工作的，因为它们都将在幕后进行管理。

• 在运行结束时，我们得到一个Docker命令来构建我们的Docker映像：

  docker build falcon_7b_truss -t falcon-7b-model:latest

如果您想构建Docker镜像，请继续运行build命令。该映像的大小约为9 GB，因此可能需要一段时间才能构建完成。如果你不想构建它，但想一直阅读下去的话，你可以详细观察我提供的图片：

htrivedi05/truss-falcon-7b:latest .

如果您自己构建映像的话，则需要对其进行标记并将其推送到dockerhub，以便我们在云中的容器可以提取图像。以下是构建映像后需要运行的命令：

docker tag falcon-7b-model <docker_user_id>/falcon-7b-model
docker push <docker_user_id>/falcon-7b-model

令人惊叹的是，到目前我们已经准备好在云中运行我们的模型了！

【说明】以下可选步骤（到步骤4前）用于使用GPU在本地运行图像。

如果您有Nvidia GPU，并且希望在本地运行带有GPU支持的容器化模型，则需要确保Docker配置为使用您的GPU。

为此，只需要您打开终端并运行以下命令：

distributinotallow=$(. /etc/os-release;echo $ID$VERSION_ID) && curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - && curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

apt-get update
apt-get install -y nvidia-docker2

sudo systemctl restart docker

现在，您的Docker已配置为访问GPU，下面是如何运行容器的命令：

docker run --gpus all -d -p 8080:8080 falcon-7b-model

同样，下载该模型需要一段时间。为了确保一切正常工作，你可以检查容器日志，你应该看到"设备推理正在is:cuda上运行（THE DEVICE INFERENCE IS RUNNING ON IS: cuda）"。

您可以通过API端点对模型进行调用，如下所示：

import requests

data = {"prompt": "Hi there, how's it going?"}
res = requests.post("http://127.0.0.1:8080/v1/models/model:predict", jsnotallow=data)
print(res.json())

步骤4：将模型部署到生产环境中

我在这里使用"生产"这个词算是相当松散的表达方式。我们将在Kubernetes中运行我们的模型，因为在此环境里可以轻松地扩展和处理可变数量的流量。

话虽如此，Kubernetes提供了很多配置，如网络策略、存储、配置映射、负载平衡、机密管理等。

尽管Kubernetes是为"扩展"和运行"生产"工作负载而构建的，但您需要的许多生产级配置并不是现成可用的。涵盖那些高级的Kubernetes主题的讨论超出了本文的范围，也偏离了我们在这里试图实现的目标。因此，对于这篇博客文章，我们将创建一个基础类型的最小集群。

事不宜迟，让我们抓紧着手创建我们的集群！

先决条件：

1. 拥有创建了一个项目的对应的谷歌云端账户
2. 在您的计算机上安装成功gcloud CLI
3. 请确保您有足够的配额来运行启用GPU的计算机。您可以在"IAM & Admin"命令组下检查您的配额。

创建我们的GKE集群

我们将使用谷歌的Kubernetes引擎来创建和管理我们的集群。下面了解一些重要信息：

谷歌的Kubernetes引擎不是免费的。谷歌不会允许我们免费使用功能强大的GPU。话虽如此，我们正在创建一个功能较弱的GPU的单节点集群。这个实验的花费不应该超过1到2美元。

以下是我们将要运行的Kubernetes集群的配置：

• 1个节点，标准Kubernetes集群
• 1个Nvidia T4 GPU
• n1-standard-4机器（4 vCPU，15GB内存）
• 所有这些都将在一个Spot实例上运行

注意：如果您在另一个地区，并且无法访问完全相同的资源，请随时进行修改。

创建集群的步骤：

1.前往谷歌云控制台，搜索名为Kubernetes Engine的服务：

2.单击"创建（CREATE）"按钮：

• 确保您正在创建一个标准集群，而不是自动驾驶（autopilot）型集群。它应该在页面顶部显示"创建一个Kubernetes集群（Create a kubernetes cluster）"。

3.集群基础：

• 在"集群基础（Cluster basics）"选项卡中，我们不想做太多更改。只需给集群一个名称。您不需要更改区域或控制平面。

4.单击"默认池（default-pool）"选项卡并将节点数更改为1。

5.在"默认池（default-pool）"选项卡下，单击左侧边栏中的"节点（Nodes）"选项卡：

• 将机器配置（General purpose）从通用更改为GPU
• 选择英伟达T4作为GPU类型，并将数量设置1
• 启用GPU分时消费（Time-sharing）方式（即使我们不会使用此功能）
• 将每个GPU的最大共享客户端数设置为8
• 对于机器类型，选择n1-standard-4（4 vCPU，15 GB内存）
• 将引导磁盘大小更改为50
• 向下滚动到最底部，选中上面写着：启用现场虚拟机上的节点（Enable nodes on spot VMs）

配置好集群后，继续往下进行，创建此群集。

谷歌需要几分钟的时间来设置一切。在您的集群启动并运行后，我们需要连接到此群集。为此，打开您的终端并运行以下命令：

gcloud config set compute/zone us-central1-c
gcloud container clusters get-credentials gpu-cluster-1

如果您使用了不同的集群名称区域，请相应地更新这些区域。要检查我们是否已连接，请运行以下命令：

kubectl get nodes

您应该看到1个节点出现在您的终端中。尽管我们的集群有GPU，但它缺少一些我们必须安装的Nvidia驱动程序。值得庆幸的是，安装它们是一件很容易的事情。运行以下命令即可安装驱动程序：

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

庆祝一下吧，我们终于准备好部署我们的模型了。

部署模型

为了将我们的模型部署到集群上，我们需要创建一个Kubernetes部署。Kubernetes部署允许我们管理容器化模型的实例。在此，我不会深入讨论Kubernetes或如何编写yaml文件，因为这超出了本文主题的范围。

您需要创建一个名为truss-falcon-deployment.yaml的文件。打开该文件并粘贴以下内容：

apiVersion: apps/v1
kind: Deployment
metadata:
 name: truss-falcon-7b
 namespace: default
spec:
 replicas: 1
 selector:
 matchLabels:
 component: truss-falcon-7b-layer
 template:
 metadata:
 labels:
 component: truss-falcon-7b-layer
 spec:
 containers:
 - name: truss-falcon-7b-container
 image: <your_docker_id>/falcon-7b-model:latest
 ports:
 - containerPort: 8080
 resources:
 limits:
 nvidia.com/gpu: 1
---
apiVersion: v1
kind: Service
metadata:
 name: truss-falcon-7b-service
 namespace: default
spec:
 type: ClusterIP
 selector:
 component: truss-falcon-7b-layer
 ports:
 - port: 8080
 protocol: TCP
 targetPort: 8080

发生了什么：

• 我们告诉Kubernetes，我们想用我们的falcon-7b-model映像创建pods。确保将<your_docker_id>替换为实际id。如果您没有创建自己的Docker映像，而想使用我的，请将其替换为以下内容：htrivedi05/truss-falcon-7b:latest。
• 我们通过设置资源限制nvidia.com/GPU:1来启用容器的GPU访问。这告诉Kubernetes只为我们的容器请求一个GPU。
• 为了与我们的模型交互，我们需要创建一个将在8080端口上运行的Kubernetes服务。

通过在终端中运行以下命令来创建部署：

kubectl create -f truss-falcon-deployment.yaml

如果运行该命令：

kubectl get deployments

你应该看到类似下面这样的显示内容：

NAME READY UP-TO-DATE AVAILABLE AGE
truss-falcon-7b 0/1 1 0 8s

部署将需要几分钟时间才能更改为就绪状态。记住，每次容器重新启动时，模型都必须从HuggingFace页面下载。您可以通过运行以下命令来检查容器的进度：

kubectl get pods
 
kubectl logs truss-falcon-7b-8fbb476f4-bggts

相应地更改吊舱名称。

您需要在日志中查找以下内容：

• 查找打印语句THE DEVICE INFERENCE IS RUNNING ON IS: cuda。这确认了我们的容器已正确连接到GPU。

接下来，您应该看到一些关于正在下载的模型文件的打印语句。

Downloading (...)model.bin.index.json: 100%|██████████| 16.9k/16.9k [00:00<00:00, 1.92MB/s]
Downloading (...)l-00001-of-00002.bin: 100%|██████████| 9.95G/9.95G [02:37<00:00, 63.1MB/s]
Downloading (...)l-00002-of-00002.bin: 100%|██████████| 4.48G/4.48G [01:04<00:00, 69.2MB/s]
Downloading shards: 100%|██████████| 2/2 [03:42<00:00, 111.31s/it][01:04<00:00, 71.3MB/s]

下载模型并创建微服务后，您应该在日志末尾看到以下输出：

{"asctime": "2023-06-29 21:40:40,646", "levelname": "INFO", "message": "Completed model.load() execution in 330588 ms"}

根据此消息，我们可以确认模型已加载并准备好进行推理任务了。

模型推理

我们不能直接调用模型；相反，我们必须调用模型的服务。

运行以下命令即可获取服务的名称：

kubectl get svc

输出结果如下：

AME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.80.0.1 <none> 443/TCP 46m
truss-falcon-7b-service ClusterIP 10.80.1.96 <none> 8080/TCP 6m19s

我们想调用的是truss-falcon-7b服务。为了使服务可访问，我们需要使用以下命令将其端口转发：

kubectl port-forward svc/truss-falcon-7b-service 8080

输出如下：

Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

很漂亮，我们的模型在127.0.0.1:8080作为REST API端点提供。打开任何一个Python脚本，如main.py，并运行以下代码：

import requests

data = {"prompt": "Whats the most interesting thing about a falcon?"}
res = requests.post("http://127.0.0.1:8080/v1/models/model:predict", jsnotallow=data)
print(res.json())

输出如下：

{'data': {'generated_text': 'Whats the most interesting thing about a falcon?\nFalcons are known for their incredible speed and agility in the air, as well as their impressive hunting skills. They are also known for their distinctive feathering, which can vary greatly depending on the species.'}}

哇！我们已经成功地将Falcon 7B模型容器化，并将其作为生产中的微服务成功部署！

您可以随意使用不同的提示来查看模型返回的内容。

关闭集群

一旦你在Falcon 7B上玩得很开心，你可以通过运行以下命令删除你的部署：

kubectl delete -f truss-falcon-deployment.yaml

接下来，转到谷歌云中的Kubernetes引擎，删除Kubernete集群。

注：除非另有说明；否则，本文中所有图片均由作者本人提供。

结论

尽管运行和管理像ChatGPT这样的生产级模型并不容易；但是，随着时间的推移，开发人员可以更好地将自己的模型部署到云中。

在这篇博客文章中，我们谈到了在基本层级上将LLM部署到生产中所需的所有内容。归纳起来，我们首先需要使用Truss打包模型，然后使用Docker将其容器化，最后使用Kubernetes将其部署在云中。我知道要作详细介绍会涉及到很多内容，虽然这不是世界上最容易做的事情，但我们还是做到了。

最后，我希望你能从这篇博文中学到一些有趣的东西。感谢阅读！

---

多看看优秀的工具

太空电梯、MOSS、ChatGPT等，都预兆着2023年注定不会是平凡的一年。任何新的技术都值得推敲，我们应要有这种敏感性。

这几年隐约碰过低代码，目前比较热门，很多大厂都相继加入。

低代码平台概念：通过自动代码生成和可视化编程，只需要少量代码，即可快速搭建各种应用。

到底啥是低代码，在我看来就是拖拉拽，呼呼呼，一通操作，搞出一套能跑的系统，前端，后端，数据库，一把完成。当然这可能是最终目标。

链接：www.jnpfsoft.com/?csdn，如果你感兴趣，也体验一下。

JNPF的优势就在于它能生成前后台代码，提供了极大的灵活性，能够创建更复杂、定制化的应用。它的架构设计也让开发者无需担心底层技术细节，能够专注于应用逻辑和用户体验的开发。