AI 实践
AI 资源
资源 | 组织 | 类型 |
---|---|---|
Hugging Face | Hugging Face | Community/Model |
Cuda Image Hub | Nvidia | Image/Cuda |
Container Toolkit | Nvidia | Runtime/Dev |
mega.space | Mega | AI Image Generator |
Colab | Tools | |
Image Delivery | image.delivery | Images(Stable Diffusions) |
dl tutorialspoint | tutorialspoint | tutorial |
agentgpt | AgentGPT | Application |
awesome-open-gpt resource | EwingYangs | GPT resource |
Beginner
机器如何学习
从数据中找出规则(通过数学和程序)。
例如,通过图片识别出狗还是猫,只要足够的数据给到模型生成规则,那么再遇到类似的问题,就能够得到相对的答案,当正确率达到一定程度后,就代码这个模型相对稳定了。
-
模型,由各种数学和方程组成的规则构成。
-
相对正确的答案,达到一定正确率。
Colab
谷歌提供的免费ML 验证工具。
ipynb notebook
转为文件
-
type: 转为的类型,包括 html、markdown、pdf、rst
1 | jupyter nbconvert --to type filename/as/ipynb |
Math in AI
激活函数
sigmoid
Palm Detection
NHWC to NCHW
在深度学习中,NHWC和NCHW是两种常见的张量格式。NHWC表示通道维度在最后一个维度,即(batchsize, height, width, channels),而NCHW表示通道维度在第二个维度,即(batchsize, channels, height, width)。
将输入形状从HWC格式转换为CHW格式。具体来说,将输入形状从(height, width, channels)转换为(channels, height, width)。这是因为在PyTorch中,张量的默认格式是NCHW,而在TensorFlow中,张量的默认格式是NHWC。因此,将输入形状从HWC格式转换为CHW格式可以使代码更易于在PyTorch中使用。
要将张量从NHWC格式转换为NCHW格式,可以使用以下代码:
1 | import torch |
在这里,tensor_nhwc是一个形状为(batch_size, height, width, channels)的张量。tensor_nchw是一个形状为(batch_size, channels, height, width)的张量,其中通道维度在第二个维度。tensor_nchw.permute(0, 3, 1, 2)将张量的维度重新排列,以将通道维度移动到第二个维度。
ml in c
links:
AI copilot
cursor
connect to wsl
links:
cocopilot
patch the code copilot over the common IDE.
links:
open-interpreter
links:
numpy
numpy 是一个Python库,用于处理多维数组和矩阵,以及用于数学计算的函数集合。它是Python科学计算的核心库之一,因为它提供了高效的数据结构和计算工具,使得Python成为了一种流行的科学计算语言。
Tips
增删维度
图片数据经常 batch处理,此时的维度为 [batch, c, h, w]
或 [batch, h, w, c]
,为适配输入输出,需要增加和删除 batch
1 | image_origin = np.from_file(file, np.uint8) |
NHWC to NCHW
1 | padding_img = padding_img.transpose((2, 0, 1))[::-1] # HWC to CHW, BGR to RGB |
pandas
api
quantile
使用quantile函数计算分数位数. quantile计算的原理是通过对数据进行排序,找到给定百分位数位置的值。具体来说,对于一个已排序的数据集,quantile函数会根据指定的百分位数来确定在该百分位数位置处的值。
例如,对于一个包含100个数据点的数据集,如果想要计算p99(百分之99的数据点的值)即DataFrame.quantile(0.99)
,需要找到位于排好序的数据集中第99个百分位数位置的值。
quantile函数的计算方式可以有多种方法,其中一种常用的方法是线性插值法。该方法首先计算出百分位数位置的整数部分索引和小数部分的权重,并根据权重对相邻的数据点进行插值计算,以得出最终的百分位数值。
ONNX
OpenCV
安装
1 | apt-get update && apt-get install -y --no-install-recommends libgl1 && pip install opencv-python opencv-python-headless |
[!TIP]
Error: ImportError: libGL.so.1: cannot open shared object file: No such file or directory.Solution:
pip install opencv-python opencv-python-headless
.
Tip
jpg to numpy
1 | import numpy as np |
GPT
资源
资源 | 组织 | 类型 |
---|---|---|
西鲸AI智脑 | 西鲸 | 文档 |
chat.dfehub | 西鲸 | rest api |
freegpt-webui | ramonvc | freegpt web app |
h2ogpt | h2oai | private gpt server |
quivr | StanGirard | AI Brain |
gitcommit | zurawiki | git commit tools |
实用工具
浏览器 Edge/Chrome
-
ChatGPT Sidebar
注册工具
Stable Diffusion
AI 文字转图片工具使用教程.
Stable Diffusion AI models 下载。这里有推荐的模型及软件下载链接.
gptcommit
gptcommit 自动根据代码更改生成 commit 消息.
[!TIP]
可以直接使用vscode 插件集成 vscode-gptcommit
prompt
随着ChatGPT带来的AI大模型的技术突破,也带来了一项新的AI工程技术,即 prompt(用于规则化提问,生成预计业务逻辑回答).这项技术让AI从对话中的生成回答能够真正地落地于其它应用工程.比如前面提到的gptcommit, gpt-migrate等都是对prompt的应用.
[!NOTE]
prompt: 简单来说就是将问题模板化,进而生成预期结果.
示例:
AI Workflow
通常的AI工作流如下:
graph LR
subgraph ETL/ML Engineer
AI-Train[AI Training] -->|Trained Models| Model-Optimization[Model-Optimization]
Model-Optimization -->|Optimized Models| Model-Storage[(Model-Storage)]
end
subgraph Dev/ML Ops
Model-Storage -->|Deploy| Inference-Serving[Inference-Serving]
end
subgraph App Developer
Inference-Serving <-->|Query/Result| Application[Application]
end
AI Serving
服务化的需求:
-
可扩展pytorch、tensorflow、onnx等类型模型的推理。
-
能够支持http grpc通信。
-
基于pipline处理流程,方便扩展流水线。
-
能够支持高并发处理。
-
可参考triton服务,调研其他框架。
理想方案
-
mode inference -> kserve { http/grpc } + [ 业务代码服务 { flask } + [ dapr ] ]。
-
业务代码 inference -> kserve { http/grpc } 。
现有方案:
-
多模型同一个容器运行。
-
提供http请求。
其它方案demo或技术:
AI Serving Solution
API服务工具
Torch Serving、Tensor Serving和 Triton Serving 都是用于将机器学习模型部署为API服务的工具。它们都提供了类似的功能,例如模型加载、推理请求处理和模型版本控制等。
然而,它们之间也存在一些区别。以下是一些了解到的区别:
-
Torch Serving是由PyTorch社区开发的,专门用于部署PyTorch模型。它支持多种模型格式,例如TorchScript和ONNX等。
-
Tensor Serving 是由Google开发的,专门用于部署TensorFlow模型。它支持TensorFlow SavedModel格式。
-
Triton Serving 是由NVIDIA开发的,专门用于部署深度学习模型。它支持多种模型格式,例如TensorFlow、PyTorch和ONNX等。
-
ONNX Runtime:ONNX Runtime 是一个用于部署 ONNX 模型的高性能、跨平台的推理引擎。它支持多种硬件平台和操作系统,包括 CPU、GPU、FPGA 和 Edge 设备等。可以使用 ONNX Runtime 来加载 ONNX 模型并提供服务,同时还可以使用其提供的 API 来管理模型版本、优化推理性能等。
因此,虽然这些工具都提供了类似的功能,但它们的实现方式和支持的模型格式可能会有所不同。
AI Dev 辅助框架
-
Airflow: 用于使用编程的方式实现开发、调度和监控面向批处理的工作流。
-
Dapr: Dapr 是一个开源的分布式应用程序运行时,它提供了一组构建块,用于简化应用程序的开发和部署。其中包括 Service Invocation、State Management、Pub/Sub 等功能,可以帮助快速构建和部署 AI 服务。Dapr 还提供了多种通信协议和 SDK,方便与其他服务进行交互。
-
Kubeflow: Kubeflow 是一个用于部署机器学习工作流的开源平台。它基于 Kubernetes 构建,提供了一组工具和 API,用于管理模型训练、推理、部署等过程。可以使用 Kubeflow 来构建端到端的机器学习工作流,同时还可以使用其提供的组件来部署和管理 AI 服务。
-
kServe: 是一个用于构建和部署机器学习模型的开源框架。它提供了一个简单易用的 API,可以帮助快速构建和部署机器学习模型。kServe 支持多种模型格式,包括 TensorFlow、PyTorch、ONNX 等。它还提供了多种部署方式,例如 HTTP、gRPC 等,可以满足不同场景下的需求。以下是一些有用的链接:
-
TAO Toolkit:是一个用于训练和部署深度学习模型的工具包,它提供了一系列的工具和库,可以帮助用户快速构建和部署深度学习模型。在使用TAO Toolkit之前,需要先了解深度学习的基本概念和使用方法。可以参考以下文档:
-
Chassis: 是一个开源项目,可以在几分钟内将ML模型转换为容器化的预测API。
- Chassis 脚本化部署。
- Chassis Getting Started。
TensorFlow Serving
能否给一个使用 TensorFlow Serving 将机器学习模型部署为服务的示例
想要了解如何使用 TensorFlow Serving 将机器学习模型部署为服务。以下是一个使用 TensorFlow Serving 调用 TensorFlow 模型的示例:
-
首先,需要安装 TensorFlow Serving。可以使用以下命令在 Linux 上安装 TensorFlow Serving:
1 | pip install tensorflow-serving-api |
-
然后,需要启动 TensorFlow Serving。可以使用以下命令启动 TensorFlow Serving:
1 | tensorflow_model_server --port=8500 --rest_api_port=8501 --model_name=my_model --model_base_path=path/to/your/model |
其中,my_model 是模型的名称,path/to/your/model 是模型存储路径。
-
接下来,需要使用 TensorFlow Client 调用模型。以下是一个使用 TensorFlow Client 调用模型的示例:
1 | import requests |
其中,my_model 是模型的名称。
Torch Serving
能否给一个使用 Torch Serving 将机器学习模型部署为服务的示例
想要了解如何使用 Torch Serving 将机器学习模型部署为服务。以下是一个使用 Torch Serving 部署 PyTorch 模型的示例:
-
首先,需要安装 Torch Serving。可以使用以下命令在 Linux 上安装 Torch Serving:
1 | pip install torchserve torch-model-archiver |
-
接下来,需要将 PyTorch 模型转换为 TorchScript 格式。可以使用以下代码将 PyTorch 模型转换为 TorchScript:
1 | import torch |
-
然后,需要创建一个模型描述文件。该文件描述了模型的输入和输出格式。以下是一个示例模型描述文件:
1 | { |
-
接下来,需要使用 Torch Model Archiver 将模型打包为 Torch Serving 可以使用的格式。可以使用以下命令将模型打包:
1 | torch-model-archiver --model-name my_model --version 1.0 --serialized-file path/to/your/model.pt --handler path/to/your/handler.py --extra-files path/to/your/model_description.json --export-path model_store |
其中,my_model 是模型的名称,1.0 是模型的版本号,path/to/your/model.pt 是 TorchScript 模型的路径,path/to/your/handler.py 是模型处理程序的路径,path/to/your/model_description.json 是模型描述文件的路径,model_store 是要导出模型的路径。
-
最后,可以使用以下命令启动 Torch Serving:
1 | torchserve --start --model-store model_store --models my_model=your_model.mar |
其中,model_store 是模型存储路径,my_model 是模型的名称,your_model.mar 是模型的 Torch Serving 格式的文件。
这就是使用 Torch Serving 将 PyTorch 模型部署为服务的示例。
-
接下来,需要使用 Torch Client 调用模型。以下是一个使用 Torch Client 调用模型的示例:
1 | import requests |
其中,path/to/your/image.jpg 是输入图像的路径,my_model 是模型的名称。
-
最后,可以使用 output_data 变量中的结果。结果的格式取决于模型的输出格式。例如,如果模型输出一个张量,可以使用以下代码获取该张量:
1 | import numpy as np |
这就是使用 Torch Serving 调用 PyTorch 模型的示例。
Triton Serving
如何使用Triton Serving部署AI服务
为了使用Triton Serving部署AI服务,可以按照以下步骤进行操作:
-
按照官方文档提供的说明安装Triton Serving:https://github.com/triton-inference-server/server/blob/main/docs/quickstart.md
-
将模型转换为Triton Serving可以理解的格式,以准备部署。Triton Serving支持多种模型格式,包括TensorFlow SavedModel、ONNX和PyTorch。可以在Triton Serving文档中找到有关如何准备模型的更多信息:https://github.com/triton-inference-server/server/blob/main/docs/modelrepository.md
-
准备好模型后,可以按照Triton Serving文档中的说明创建模型存储库:https://github.com/triton-inference-server/server/blob/main/docs/modelrepository.md#creating-a-model-repository
-
运行以下命令启动Triton Serving服务器:
1 | tritonserver --model-repository=/path/to/model/repository |
将/path/to/model/repository替换为模型存储库的路径。
-
服务器运行后,可以使用Triton Serving客户端库将推理请求发送到服务器。Triton Serving支持多种客户端库,包括Python、C++和Java。可以在Triton Serving文档中找到有关如何使用客户端库的更多信息:https://github.com/triton-inference-server/client
Airflow
如何用Airflow框架实现模型常驻在内存的AI服务
首先,Airflow框架主要用于调度和监控数据处理任务,而不是用于实现AI服务。但是,可以使用Airflow来调度和监控运行AI服务的任务。
要实现模型常驻在内存的AI服务,需要使用一个Web框架(如Flask或Django)来创建一个API,该API将加载模型并接收输入数据以进行预测。然后,可以使用Airflow来调度和监控此API的运行。
以下是一些可能有用的步骤:
-
使用Flask或Django创建一个API,该API将加载模型并接收输入数据以进行预测。可以使用以下代码作为起点:
1 | from flask import Flask, request |
-
将API部署到服务器上,并确保它可以在后台运行。可以使用gunicorn或uwsgi等工具来运行API。
-
创建一个Airflow DAG,该DAG将定期调用API以确保其保持活动状态。可以使用以下代码作为起点:
1 | from airflow import DAG |
-
将Airflow DAG部署到Airflow服务器上,并确保它可以在后台运行。
Airflow能否手动配置运行这个AI服务的数量
Airflow本身并不提供手动配置运行任务的数量的功能。但是,可以通过修改DAG的scheduleinterval参数来控制任务的运行频率,从而间接地控制任务的数量。例如,将scheduleinterval设置为timedelta(minutes=1)将使任务每分钟运行一次,从而增加任务的数量。
另外,可以使用Airflow的任务并发设置来控制同时运行的任务数量。可以在Airflow的配置文件中设置maxactiverunsperdag参数来限制每个DAG同时运行的任务数量。例如,将maxactiverunsperdag设置为2将使每个DAG最多同时运行2个任务。
请注意,这些设置可能会影响服务器资源使用情况,因此需要根据具体需求进行调整。
Dapr
如何用Dapr框架实现模型常驻在内存的AI服务
首先,Dapr是一个开源的微服务框架,它可以帮助开发人员构建分布式应用程序。它提供了一些有用的功能,例如状态管理,消息传递和服务发现。但是,它本身并不是一个AI框架,因此需要使用其他AI框架来实现模型常驻在内存的AI服务。
一种常见的方法是使用TensorFlow Serving。TensorFlow Serving是一个用于生产环境的TensorFlow模型服务器,它可以轻松地将TensorFlow模型部署到生产环境中。可以使用Dapr框架来管理TensorFlow Serving实例,并使用Dapr的状态管理功能来存储模型的元数据和状态。
以下是一个使用Dapr和TensorFlow Serving实现模型常驻在内存的AI服务的示例:
-
首先,需要安装Dapr和TensorFlow Serving。可以按照官方文档进行安装。
-
然后,需要编写一个Dapr组件来管理TensorFlow Serving实例。可以在Dapr配置文件中定义此组件,如下所示:
1 | apiVersion: dapr.io/v1alpha1 |
-
接下来,需要编写一个Dapr应用程序来使用TensorFlow Serving组件。可以使用Dapr的状态管理功能来存储模型的元数据和状态。以下是一个使用Python编写的示例:
1 | import dapr.clients |
在此示例中,首先使用Dapr客户端加载TensorFlow模型。然后,使用Dapr客户端调用TensorFlow Serving组件,并将模型注册到TensorFlow Serving中。最后,使用Dapr客户端将模型的元数据和状态存储在Dapr状态存储中。
已经使用Dapr客户端加载了TensorFlow模型,并将其注册到TensorFlow Serving中。要调用加载的模型,可以使用Dapr客户端调用TensorFlow Serving组件的REST API。
以下是一个使用Python编写的示例:
1 | import dapr.clients |
在此示例中,使用Dapr客户端调用TensorFlow Serving组件的REST API,并将输入数据作为JSON格式的数据发送。可以根据自己的需求修改输入数据的格式和内容。最后,打印出TensorFlow Serving返回的响应。
Dapr能否手动配置运行上面提到的AI服务数量
Dapr是一个开源的分布式应用程序运行时,它可以帮助开发人员轻松地构建和运行微服务应用程序。Dapr提供了一种简单的方式来注册和发现服务,并提供了一组API来调用这些服务。在使用Dapr和TensorFlow Serving实现模型常驻在内存的AI服务的基础上,可以使用Dapr客户端调用TensorFlow Serving组件的REST API,或者将TensorFlow Serving组件注册为Dapr服务并使用Dapr客户端调用其gRPC API。
关于Dapr运行的AI服务数量的配置,Dapr提供了一种称为“Actor”的编程模型,它可以帮助开发人员轻松地构建高度可扩展的应用程序。Actor是一种轻量级的计算单元,它可以自动缩放和分区,以处理大量的并发请求。可以使用Dapr的Actor模型来管理和配置Dapr运行的AI服务数量。
具体来说,可以使用Dapr的Actor模型来创建一个名为“AI服务”的Actor组,该组可以包含多个AI服务Actor实例。然后,可以使用Dapr客户端调用Actor组的API来创建、删除和管理AI服务Actor实例。通过这种方式,可以手动配置Dapr运行的AI服务数量,并根据需要动态缩放。
能否将tensorflow serving 替换为torch serving
关于将TensorFlow Serving替换为Torch Serving,Dapr并不限制使用哪种AI服务组件。只要AI服务组件实现了Dapr所需的API,就可以将其注册为Dapr组件,并使用Dapr客户端调用其API。因此,可以使用Torch Serving替换TensorFlow Serving,并使用Dapr客户端调用其API。
具体来说,需要将Torch Serving组件实现为Dapr组件,并将其注册到Dapr运行时中。然后,可以使用Dapr客户端调用Torch Serving组件的API,就像在上述示例中使用Dapr客户端调用TensorFlow Serving组件的API一样。
TensorFlow Serving 和 Torch Serving 的区别
TensorFlow Serving 和 Torch Serving 都是用于将机器学习模型部署为可用于生产环境的 API 的工具。它们的主要区别在于它们支持的框架不同。
TensorFlow Serving 是专门为 TensorFlow 模型设计的,它提供了一个高效的、可扩展的方式来部署 TensorFlow 模型。它支持多种模型格式,包括 SavedModel、SessionBundle 和 TensorFlow Hub 模块。TensorFlow Serving 还提供了一些高级功能,例如模型版本控制、模型热更新和模型分片。
Torch Serving 是专门为 PyTorch 模型设计的,它提供了一个轻量级的、可扩展的方式来部署 PyTorch 模型。它支持多种模型格式,包括 TorchScript 和 ONNX。Torch Serving 还提供了一些高级功能,例如模型版本控制、模型热更新和模型分片。
总的来说,TensorFlow Serving 和 Torch Serving 都是非常有用的工具,可以帮助将机器学习模型部署到生产环境中。选择哪个工具取决于使用的框架以及具体需求。
AI serving app
flask app
实现功能:将AI服务的图片预测和输出显示到 web 页面
[!NOTE]
- 图片保存在本地子文件夹
.predictions
中以请求检测时间
保存在对应子目录下。- 提供一个接口返回本地子文件夹
.predictions
中的目录列表。- 返回页面增加以下html样式,方面人查询
predictions
中的图片结果。
为了将AI服务的图片预测和输出显示到web页面,需要使用一些web开发技术。以下是一些可能有用的步骤:
-
创建一个web应用程序,该应用程序将接收用户上传的图像并将其发送到AI服务进行预测。可以使用任何web框架来实现这一点,例如Flask或Django。
-
在web应用程序中,使用AI服务客户端库将图像发送到AI服务进行预测。可以使用Triton Serving客户端库来实现这一点。有关如何使用Triton Serving客户端库的更多信息,请参见以下链接:https://github.com/triton-inference-server/client
-
将AI服务的预测结果返回到web应用程序,并将其显示在web页面上。可以使用HTML和JavaScript来实现这一点。例如,可以使用JavaScript将预测结果显示在一个图像元素中。
以下是一个可能有用的代码示例,它演示了如何使用Flask和Triton Serving客户端库将图像发送到AI服务进行预测,并将预测结果显示在web页面上:
1 | import io |
这个示例使用Flask框架创建了一个web应用程序,当用户上传图像时,它将图像发送到Triton Serving进行预测,并将预测结果显示在web页面上。
创建了一个新的HTML模板index.html在templates目录下,它显示了 .predictions 子文件夹中的目录列表。
1 | <!-- index.html --> |
Kubeflow
install
KServe
Quickstart
modelmesh installing
Demo Test
-
kerve quick start
1 | # Minikube |
-
kiali
安装 istioctl
1 | kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.15/samples/addons/kiali.yaml |
TAO
NVIDIA TAO Toolkit 是 Nvidia 构建的迁移学习框架,能将现有的或合成数据使用预训练的模型高效地训练出自定义的模型,官方介绍。
TAO Toolkit API
CV
ClearML
Deploy
ClearML
ClearML 是一个开源的平台,用于管理和跟踪机器学习实验。它提供了一个集成的界面,可以帮助用户管理数据集、模型、超参数和实验结果。此外,ClearML还提供了自动化的模型选择和调优功能,可以帮助用户快速构建和部署机器学习模型。
如果想了解更多关于ClearML的信息,可以参考以下文档:
pytorch
Model construct strategy
在PyTorch中构建模型的一般步骤如下:
-
定义模型类:定义一个继承自nn.Module的类,该类将包含模型的结构和参数。
-
定义前向传递函数:在模型类中定义一个forward函数,该函数将定义模型的前向传递逻辑。
-
定义损失函数:选择适当的损失函数,例如交叉熵损失函数或均方误差损失函数。
-
定义优化器:选择适当的优化器,例如随机梯度下降(SGD)或Adam优化器。
-
训练模型:使用训练数据对模型进行训练,通过反向传播算法更新模型参数。
-
评估模型:使用测试数据对模型进行评估,计算模型的准确率或其他性能指标。
下面是一个简单的示例,展示如何在PyTorch中构建一个简单的全连接神经网络模型:
1 | import torch |
在这个示例中,定义了一个名为SimpleNet的模型类,它包含一个输入层、一个隐藏层和一个输出层。还定义了一个前向传递函数,该函数将输入数据传递到模型中,并返回模型的输出。使用交叉熵损失函数和随机梯度下降(SGD)优化器来训练模型,并使用测试数据对模型进行评估。
Common API
tensor.equal
使用 torch.equal() 函数来判断两个 tensor 是否相等。该函数会比较两个 tensor 的形状和元素值是否相等,如果相等则返回 True,否则返回 False。
示例代码如下:
1 | import torch |
在上面的示例中,定义了三个 tensor,其中 a 和 b 的元素值和形状都相等,而 c 的元素值不同,因此使用 torch.equal() 函数比较 a 和 b 时返回 True,比较 a 和 c 时返回 False。
tensor.view
tensor.view 是 PyTorch 中的一个方法,用于将一个 tensor 重塑为指定的形状。它返回一个新的 tensor,而不是修改原始 tensor。这个方法在深度学习中非常常用,因为在神经网络中,需要将数据重塑为特定的形状以进行计算。
tensor.view 的语法如下:
1 | view(*shape) |
其中,*shape 是一个可变参数,表示要重塑的形状。例如,如果有一个形状为 (3, 4) 的 tensor,可以使用 view 将其重塑为 (4, 3) 的 tensor:
1 | import torch |
需要注意的是,view 方法返回的 tensor 与原始 tensor 共享数据存储空间,因此在修改其中一个 tensor 的值时,另一个 tensor 的值也会发生变化。如果要避免这种情况,可以使用 clone 方法创建一个新的 tensor。
除了 view 方法,PyTorch 还提供了一些其他的 tensor 重塑方法,例如 reshape 和 permute。这些方法的使用方式与 view 类似,但有一些细微的差别,需要根据具体情况选择合适的方法。
tensor.reshape
pytorch tensor.reshape 是 PyTorch 中用于改变张量形状的函数之一。它可以将一个张量重塑为一个新的形状,而不改变其元素的数量或值。在 PyTorch 中,张量的形状可以通过 size() 函数获取,也可以通过 reshape() 函数修改。
reshape() 函数的语法如下:
1 | new_tensor = tensor.reshape(*shape) |
其中,tensor 是要重塑的张量,shape 是一个整数元组,表示新张量的形状。新张量的元素数量必须与原张量的元素数量相同,否则会引发错误。
例如,将一个形状为 (3, 4) 的张量重塑为一个形状为 (4, 3) 的张量,可以使用以下代码:
1 | import torch |
需要注意的是,reshape() 函数返回的是一个新的张量,而不是修改原始张量。如果需要修改原始张量的形状,可以使用 view() 函数。view() 函数与 reshape() 函数的功能相同,但是它只能用于连续的内存块,而 reshape() 函数可以用于任意张量。
tensor.permute
tensor.permute() 是 PyTorch 中的一个函数,用于对张量进行维度重排。它可以用于将张量从一种格式转换为另一种格式,例如从 NHWC 格式转换为 NCHW 格式。
tensor.permute() 的参数是一个整数列表,用于指定新张量的维度顺序。例如,如果原始张量的维度顺序为 (batch_size, height, width, channels),而新张量的维度顺序为 (batch_size, channels, height, width),则可以使用以下代码进行转换:
1 | import torch |
在这里,tensor_nhwc 是一个形状为 (batch_size, height, width, channels) 的张量。tensor_nchw 是一个形状为 (batch_size, channels, height, width) 的张量,其中通道维度在第二个维度。tensor_nchw.permute(0, 3, 1, 2) 将张量的维度重新排列,以将通道维度移动到第二个维度。
需要注意的是,tensor.permute() 返回的是一个新的张量,而不是修改原始张量。因此,如果需要在原始张量上进行修改,可以使用 tensor.transpose() 函数。tensor.transpose() 的参数是一个整数列表,用于指定新张量的维度顺序。例如,如果需要将张量的前两个维度交换,则可以使用以下代码:
1 | import torch |
在这里,tensor 是一个形状为 (dim1, dim2, …) 的张量。tensor_swapped 是一个形状为 (dim2, dim1, …) 的张量,其中原始张量的前两个维度已经交换。
总之,tensor.permute() 和 tensor.transpose() 都是用于对张量进行维度重排的函数,可以根据需要选择使用。
tensor.transpose
transpose 是 PyTorch 中的一个函数,用于对张量进行转置操作。它可以接受一个元组作为参数,表示需要交换的维度。例如,对于一个形状为 (3, 4, 5) 的张量,可以使用 transpose(0, 2, 1) 将第一维和第三维交换,得到一个形状为 (5, 4, 3) 的张量。
下面是一个示例代码,展示了如何使用 transpose 函数:
1 | import torch |
输出结果为 (5, 4, 3),表示转置后的张量形状为 (5, 4, 3)。
需要注意的是,transpose 函数返回的是一个新的张量,不会修改原始张量。如果需要在原始张量上进行转置操作,可以使用 transpose_ 函数。
tensor.topk
使用 tensor.topk 函数可以返回张量中前 k 个最大值及其对应的索引。该函数的语法如下:
1 | torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> Tuple[Tensor, LongTensor] |
其中,参数含义如下:
-
input:输入张量。
-
k:需要返回的最大值的个数。
-
dim:沿着哪个维度计算,默认为最后一个维度。
-
largest:如果为 True,则返回最大的 k 个值;如果为 False,则返回最小的 k 个值。
-
sorted:如果为 True,则返回的 k 个值是有序的;如果为 False,则返回的 k 个值是无序的。
-
out:输出张量。
下面是一个简单的示例:
1 | import torch |
在这个示例中,创建了一个张量 x,然后使用 torch.topk 函数返回了 x 中前 3 个最大值及其对应的索引。输出结果中,values 是一个包含前 3 个最大值的张量,indices 是一个包含前 3 个最大值对应的索引的张量。
tensor.softmax
tensor.softmax 是 PyTorch 中的一个函数,用于计算张量的 softmax 函数。softmax 函数是一种常用的激活函数,通常用于多分类问题中,将输出的原始分数转换为概率分布。softmax 函数的公式如下:
$$
\text{softmax}(x_i) = \frac{e{x_i}}{\sum_{j=1}{n} e^{x_j}}
$$
其中,$x_i$ 表示输入张量的第 $i$ 个元素,$n$ 表示张量的长度。
在 PyTorch 中,可以使用 torch.tensor.softmax 函数计算张量的 softmax 函数。该函数的语法如下:
1 | torch.tensor.softmax(input, dim=None, dtype=None) |
其中,input 表示输入的张量,dim 表示计算 softmax 函数的维度,dtype 表示输出的数据类型。如果 dim 参数未指定,则默认计算最后一维的 softmax 函数。
下面是一个示例代码:
1 | import torch |
在上面的示例代码中,分别计算了一个一维张量和一个二维张量的 softmax 函数,并输出了计算结果。
torch.no_gard
在深度学习中,torch.no_grad() 是一个上下文管理器,用于控制是否计算梯度。当不需要计算梯度时,可以使用它来提高代码的执行效率和节省内存。
在训练模型时,通常会使用反向传播算法计算梯度,并使用梯度来更新模型的参数。然而,在推理阶段或者评估模型性能时,通常不需要计算梯度,只需要使用模型进行前向传播,以获得预测结果。
torch.no_grad() 的作用就是告诉 PyTorch 不要计算梯度,从而避免不必要的计算和内存消耗。通过在代码中使用 torch.no_grad(),可以明确地指示 PyTorch 不要跟踪梯度信息,从而提高代码的执行效率。
1 | with torch.no_gard(): |
[!NOTE]
torch>=1.9.0
中已将 torch.no_gard 替换为 torch.inference_mode
torch.matmul
以下给出一个公式的示例:
1 | output = i*weight0* weight^T |
output = iweight0 weight^T 表示的是一个线性变换的过程,其中 i 是输入张量,weight0 和 weight 是权重矩阵。在这个公式中,weight0 和 weight 的乘积可以看作是一个新的权重矩阵,可以将其记为 new_weight,即 new_weight = weight0 weight^T。那么原始的公式可以改写为 output = i new_weight。
如果想要优先计算 new_weight,可以先将 weight0 和 weight 相乘得到 new_weight,然后再将 i 与 new_weight 相乘得到输出张量 output。这样做是合理的,因为矩阵乘法具有结合律,即 (A B) C = A (B C),所以先计算 weight0 weight^T 得到 new_weight,再计算 i new_weight 得到 output,与直接计算 i weight0 weight^T 得到 output 是等价的。
以下是一个示例代码,演示如何先计算 new_weight,然后再计算 output:
1 | import torch |
在这个例子中,先计算了 new_weight,然后再计算了 output。注意,在计算 new_weight 时,需要将 weight 的维度转置,以便与 weight0 相乘。最后,使用 PyTorch 中的 torch.matmul 函数进行矩阵乘法运算。
nn.Linear
nn.Linear 是 PyTorch 中的一个线性层,它实现了一个线性变换,将输入张量与权重矩阵相乘并加上偏置向量。它的定义如下:
1 | class Linear(Module): |
在深度学习中,线性变换层是非常常见的一种操作,它可以将输入张量映射到一个新的空间中,从而实现特征的提取和转换。nn.Linear的实现原理非常简单,它实际上就是一个矩阵乘法加上一个偏置向量的过程,可以用以下公式表示:
1 | output = input * weight^T + bias |
其中,input是输入张量,weight是权重矩阵,bias是偏置向量,^T表示矩阵的转置操作。
其中,in_features 表示输入张量的大小,out_features 表示输出张量的大小,bias 表示是否使用偏置向量。在实际使用中,可以通过调用 nn.Linear 的实例对象来进行线性变换,例如:
1 | import torch.nn as nn |
在上述代码中,首先定义了一个输入大小为 10,输出大小为 5 的线性层 linear,然后定义了一个输入张量 input_tensor,大小为 (batch_size, 10),最后通过调用 linear 对输入张量进行线性变换,得到输出张量 output_tensor,大小为 (batch_size, 5)。
需要注意的是,nn.Linear 的权重矩阵和偏置向量是在初始化时随机生成的,可以通过 linear.weight 和 linear.bias 来访问它们。此外,还可以通过 nn.init 模块来初始化权重矩阵和偏置向量,例如:
1 | import torch.nn as nn |
在上述代码中,使用 init.normal_和 init.constant_ 分别对权重矩阵和偏置向量进行了初始化。其中,init.normal_表示使用正态分布进行初始化,init.constant_ 表示使用常数进行初始化。
nn.Dropout
nn.Dropout 是 PyTorch 中的一个模块,用于在神经网络中进行 Dropout 操作。Dropout 是一种常用的正则化方法,可以有效地防止过拟合。
在神经网络中,Dropout 会随机地将一些神经元的输出置为 0,从而减少神经元之间的依赖关系,使得网络更加鲁棒。具体来说,Dropout 会在训练过程中以一定的概率 p 随机地将某些神经元的输出置为 0,而在测试过程中则不进行 Dropout 操作。
在 PyTorch 中,可以通过如下方式使用 nn.Dropout:
1 | import torch.nn as nn |
在上述代码中,定义了一个包含两个全连接层的神经网络,并在第一个全连接层后添加了一个 Dropout 模块。在 nn.Dropout 的构造函数中,可以指定 Dropout 的概率 p。在 forward 函数中,首先将输入 x 传入第一个全连接层,然后将输出传入 Dropout 模块,最后再将 Dropout 模块的输出传入第二个全连接层。
需要注意的是,当使用 nn.Dropout 时,需要在训练过程中启用 Dropout,而在测试过程中禁用 Dropout。在 PyTorch 中,可以通过调用 model.train() 和 model.eval() 方法来切换模型的训练和测试模式。具体来说,当调用 model.train() 方法时,模型会进入训练模式,此时 Dropout 模块会生效;而当调用 model.eval() 方法时,模型会进入测试模式,此时 Dropout 模块会被禁用。
nn.Embedding
nn.Embedding 是 PyTorch 中的一个类,用于实现词嵌入(word embedding)。词嵌入是一种将文本中的单词映射到低维向量空间中的技术,它可以将单词之间的语义关系转化为向量空间中的几何关系,从而方便计算机对文本进行处理和分析。
在 PyTorch 中,可以使用 nn.Embedding 类来实现词嵌入。该类的输入是一个整数张量,表示文本中的单词序列,输出是一个浮点数张量,表示单词序列中每个单词对应的词向量。在创建 nn.Embedding 对象时,需要指定词汇表的大小和词向量的维度。例如,下面的代码创建了一个词汇表大小为 10000,词向量维度为 300 的词嵌入对象:
1 | import torch.nn as nn |
在使用 nn.Embedding 对象时,可以将整数张量作为输入,得到对应的词向量。例如,下面的代码将一个大小为 (3, 4) 的整数张量作为输入,得到一个大小为 (3, 4, 300) 的浮点数张量,表示输入张量中每个整数对应的词向量:
1 | import torch |
在实际使用中,词嵌入通常作为深度学习模型的输入层,用于将文本数据转换为向量表示。例如,在文本分类任务中,可以使用词嵌入将文本数据转换为向量表示,然后将向量输入到深度学习模型中进行分类。
nn.modules.loss.CrossEntropyLoss
nn.modules.loss.CrossEntropyLoss 是一个用于多分类问题的损失函数,它将 softmax 函数和负对数似然损失结合在一起。在训练分类模型时,通常使用交叉熵损失函数来衡量模型的预测结果与真实标签之间的差异。
在 PyTorch 中,nn.modules.loss.CrossEntropyLoss 的使用非常简单。只需要将模型的输出和真实标签传递给该函数即可。例如
1 | import torch.nn as nn |
在上面的代码中,outputs 是模型的输出,labels 是真实标签。将这两个参数传递给 nn.modules.loss.CrossEntropyLoss 函数,它将计算模型的预测结果和真实标签之间的交叉熵损失。然后,可以使用该损失来进行反向传播和优化。
需要注意的是,nn.modules.loss.CrossEntropyLoss 函数要求模型的输出是未经过 softmax 函数处理的原始值。因此,在模型的最后一层中,通常不会使用 softmax 函数。如果使用了 softmax 函数,那么需要在调用 nn.modules.loss.CrossEntropyLoss 函数之前将模型的输出转换为未经过 softmax 函数处理的原始值。
tensorflow
Model construct strategy
-
准备数据集:将数据集加载到内存中,并将其划分为训练集、验证集和测试集。
-
定义模型:使用 TensorFlow 2 中的 Keras API 定义模型架构,包括层和激活函数等。
-
编译模型:指定损失函数、优化器和评估指标等。
-
训练模型:使用训练集训练模型,并在验证集上进行验证。
-
评估模型:使用测试集评估模型的性能。
-
使用模型:使用模型进行预测或推理。
下面是一个使用 TensorFlow 2 构建简单神经网络的示例代码:
1 | import tensorflow as tf |
在这个示例中,使用了 TensorFlow 2 中的 Keras API 定义了一个包含 3 个全连接层的神经网络,用于对 MNIST 手写数字数据集进行分类。使用了 Adam 优化器、交叉熵损失函数和稀疏分类精度评估指标来编译模型。然后,使用训练集训练模型,并在验证集上进行验证。最后,使用测试集评估了模型的性能,并使用模型进行了预测。
Common api
tf.trainable_variables()
tf.trainable_variables() 是 TensorFlow 中的一个函数,用于获取所有可训练的变量。具体来说,它会返回一个列表,其中包含了所有需要在训练过程中更新的变量。
该函数会返回一个列表,其中包含了所有需要在训练过程中更新的变量。这些变量通常是模型中的权重和偏置等参数。在训练过程中,需要根据损失函数的梯度来更新这些变量,以使得模型能够更好地拟合训练数据。
需要注意的是,tf.trainable_variables() 只会返回需要在训练过程中更新的变量。如果一个变量不需要在训练过程中更新,那么它就不会出现在这个列表中。例如,如果一个变量是在模型中用于计算某个中间结果的,那么它就不需要在训练过程中更新,因此也不会出现在这个列表中。
在实际使用中,通常会将这个列表作为优化器的参数,以便优化器能够自动更新这些变量。例如:
1 | optimizer = tf.train.AdamOptimizer(learning_rate=0.001) |
在这个例子中,使用 Adam 优化器来最小化损失函数 loss,并且将所有可训练的变量作为优化器的参数传入。这样,优化器就会自动更新这些变量,以使得模型能够更好地拟合训练数据。
Adam
Adam是一种优化算法,用于训练神经网络。它是一种基于梯度下降的算法,可以自适应地调整每个参数的学习率。Adam算法结合了动量方法和RMSProp方法的优点,因此在训练深度神经网络时表现良好。
在TensorFlow中,可以使用tf.keras.optimizers.Adam来使用Adam优化器。例如,以下代码演示了如何使用Adam优化器来训练一个简单的神经网络:
1 | import tensorflow as tf |
在这里,首先定义了一个简单的神经网络模型,然后定义了一个Adam优化器,并将其传递给模型的compile方法。最后,使用fit方法来训练模型。
需要注意的是,Adam优化器有许多可调参数,例如学习率、beta1和beta2等。在实践中,通常需要对这些参数进行调整,以获得最佳的性能。
Tips
adam_m and adam_v
如果 adam_m 和 adam_v 是在训练过程中使用的,那么在 eval model 中可能不需要这些变量。因为在 eval model 中,只需要使用训练好的模型进行预测,而不需要再进行训练。
display with tensorboard
展示 tensorflow 1 checkpoint
1 | import tensorflow as tf |
HuggingFace
HuggingFace是一个提供自然语言处理模型和工具的开源社区。它提供了基于transformers的许多预训练的模型,包括BERT、GPT-2、RoBERTa等,这些模型可以用于各种NLP任务,例如文本分类、命名实体识别、情感分析等。使用HuggingFace,可以轻松地加载这些预训练的模型,并在自己的数据集上进行微调。
Transformers
Transformers是一个用于自然语言处理的Python库,它提供了许多预训练的模型,包括BERT、GPT-2、RoBERTa等。这些模型可以用于各种NLP任务,例如文本分类、命名实体识别、情感分析等。使用Transformers库,可以轻松地加载这些预训练的模型,并在自己的数据集上进行微调。
以下是一个使用Transformers库进行文本分类的示例:
1 | from transformers import BertTokenizer, TFBertForSequenceClassification |
在这个例子中,首先加载了BERT模型和对应的tokenizer。然后,使用TFBertForSequenceClassification类来定义一个文本分类模型,并使用Adam优化器、交叉熵损失函数和稀疏分类精度评估指标来编译模型。接下来,加载了训练、验证和测试数据集,并使用fit方法来训练模型。最后,使用evaluate方法来评估模型的性能,并使用模型进行了预测。
需要注意的是,Transformers库提供了许多不同的预训练模型和tokenizer,可以根据具体任务的需求进行选择。此外,Transformers库还提供了许多其他的功能,例如生成文本、计算相似度等。
Transformers 常用文档:
export to ONNX
导出ONNX 推荐两种方式.
1 | import torch |
mlflow
MLFlow 是一个管理端到端机器学习生命周期的开源平台。
参考链接:
mlflow tracking
mlflow tracking 包含有后端元数据存储(保存训练及实验数据)和模型存储(保存模型)
参考链接:
数据保存在本地
本地使用tracking.
-
后端元数据存储meta data和模型存储artifacts(mlartifact等)都在本地文件夹下.
-
默认端口localhost:5000.
1 | mlflow server --dev |
数据保存在database及minio
常用的生产环境下的mlflow tracking 配置
-
mlflow: mlflow tacking 服务
-
minio: 持久化tracking 的 artifacts.
-
mysql: 持久化tracking 的 meta data.
1 | export AWS_ACCESS_KEY_ID=... |
mlflow docker-compose 配置参考
-
https://github.com/mlflow/mlflow/blob/master/examples/mlflow_artifacts/docker-compose.yml
-
https://github.com/msclock/mlflow_tritonserver/blob/main/deploy/docker/docker-compose.yml
mlflow registry
MLflow 模型注册中心组件是一个集中的模型存储、一组 API 和 UI,用于协作管理 MLflow 模型的整个生命周期。它提供了模型谱系(MLflow 实验和运行产生的模型)、模型版本化、阶段转换(例如从阶段到生产)和注释。
参考链接:
mlflow workflow
要使用MLflow Project部署模型,可以使用以下步骤:
-
创建MLflow项目:创建一个包含模型训练和部署代码的MLflow项目。在项目目录中,应该包含一个MLproject文件,其中定义了项目的名称、入口点和依赖项。例如:
1 | name: my_project |
在这个示例中,定义了两个入口点:train和serve。train入口点用于训练模型,serve入口点用于部署模型。train入口点接受两个参数:data_path和max_depth。serve入口点接受两个参数:model_uri和port。
-
训练模型:在MLflow项目目录中运行mlflow run命令来训练模型。例如:
1 | mlflow run . |
-
部署模型:在MLflow项目目录中运行mlflow models serve命令来部署模型。例如:
1 | mlflow models serve -m runs:/<run_id>/model --port 5000 |
这将运行serve入口点,并将训练的模型部署到本地端口5000上。MLflow会自动加载模型,并将HTTP请求转发到模型的预测函数中。
如果要使用自定义Python脚本部署模型,可以使用以下步骤:
-
训练模型:使用Python脚本训练模型,并将模型保存到本地文件中。例如:
1 | import mlflow |
在这个示例中,使用my_model模块中的train函数训练模型,并使用MLflow将模型保存到名为my_model的文件夹中。
-
部署模型:使用Python脚本加载模型,并将模型部署到Web服务器上。例如:
1 | import mlflow.pytorch |
在这个示例中,使用MLflow加载名为my_model的模型,并将其部署到Flask Web服务器上。定义了一个/predict端点,用于接收POST请求,并将请求数据传递给模型的预测函数。预测函数将输入数据预处理、调用模型进行推理、并将输出数据后处理,最终返回JSON格式的结果。使用Flask的run方法运行Web服务器,并将其绑定到本地IP地址和端口5000上。
mlflow with transformers
bert sequence classification
Step 1, 安装依赖
1 | pip install transformers datasets mlflow |
Step 2, 结合transformers配置基于mlflow脚本
1 | import mlflow |
执行训练
1 | python train_model.py |
mlflow plugins
mlflow 作为机器学习的框架无关工具,MLflow Python API 为编写与不同机器学习框架和后端集成的插件提供了开发人员 API. mlflow plugins 为第三方工具集成提供了强大的自定义接口.
参考链接:
MLServer
alibi
DeepStream
DeepStream 是一个基于 GStreamer 的 SDK,用于创建用于图像处理和目标检测处理的人工智能视觉应用程序。
Tritonserver
Nvidia Triton Inference Sever 提供了兼容 CPUs 和 GPUs 运行在云端及边缘设备将模型服务化的优化推理方案。Nvidia 这里介绍了使用 Triton 快速部署可伸缩的模型的优势。
Tutorials
Triton Server 提供了对应的Tutorials。
-
Model Deployment: 图片文字检测部署Demo,包括文字区域检测和文字识别。
- Deeplearning Optimized Frameworks: 包括了测试用的 TF,PT等框架发布信息。
-
Improving Resource Utilization: 使用动态批处理和并发模型执行提高资源利用率。
- dynamic_batching in config.pbtxt
- instance_group in config.pbtxt
-
Customizing Deployment With Model Analyzer: 推理性能讨论及使用 Model Analyzer 优化 config.pbtxt 配置文件。
- 推理性能优化
- Minimizing network latency,减小模型精度,例如,图片转换 float32 转为 float 16。
- Accelerating model, 融合网络层来优化网络图,降低模型精度,融合内核等等减少计算时间。
- Using Model Analyzer, 使用 Model Analyzer 减少在模型队列等待到推理框架调度的延时。
- Using Model Analyzer
- Analyzer Criteria 包含的检测目标 Objectives 和限制 Constraints。
- Usage Details 实际使用示例。
- Model Analyzer Repos 工具仓库包含了对单模型和多模型评估示例。
- 推理性能优化
-
Accelerating Inference for Models: 通过加速推理框架来加速推理。
- GPU Based Acceleration: 基于 GPU 加速
- Using TensorRT Directly 直接将模型转为 TensorRT Engine 来加速。
- Using TensorRT’s Integration with PyTorch/TensorFlow 使用与 PyTorch/TensorFlow 集成的 TensorRT 转换。
- Using TensorRT’s Integration with ONNX RunTime
- CPU Based Acceleration 基于OpenVINO加速。
- Accelerating Large Transformer Models 加速大模型。
- Model Navigator 检验模型转换覆盖及简化部署流程的工具。
- GPU Based Acceleration: 基于 GPU 加速
-
Executing Multiple Models With Model Ensembles 将多个模型组合进行推理,使用前面得文字检测,文字识别,分别对两个模型配置前后处理得python backend,然后串联形成在 Triton Server 端运行得组合模型推理服务。
-
Building Complex Pipelines:Stable Diffusion:使用多个框架后端构件推理服务,并且使用 BLS API 构件复杂得非线性管道。
-
Data Pipeline: Triton 中 Python backend 对 Tensor的处理步骤。
- Model Inspect Tool: Netron, Polygraphy
Deploying Using Triton
Triton Configuration
-
polygraphy用于确定模型的输入输出,更多示例参考。
-
Netron:在线模型查看工具
Model Repository
Jetson and JetPack Support
HTTP and GRPC Protocol Support
HTTP and GRPC Protocol Support: Triton Server支持的各种HTTP/REST 和GRPC 协议扩展。参考使用示例:
1 | # --------------- logging extension ----------------- |
Optimization
Optimization
- Perf Analyzer: 模型度量评估工具,针对部署在 server 中的模型能对吞吐量,GPU利用率,时延等等做一个详细的评估输出.
- Model Analyzer: 该工具会自动使用 perf_analyzer 对模型做一个全方位的评估,并能输出详细的 html/pdf报告.
Backend
Tips
Model format
.ckpt
是tensorflow框架下保存的模型,包含以下几个子文件:
-
model.ckpt.meta :保存Tensorflow计算图结构,可以理解为神经网络的网络结构
-
model.ckpt :保存Tensorflow程序中每一个变量的取值,变量是模型中可训练的部分
-
checkpoint :保存一个目录下所有模型文件列表
.onnx
是一种针对机器学习所设计的开放式的文件格式,用于存储训练好的模型。它使得不同的深度学习框架(如Pytorch, MXNet)可以采用相同格式存储模型数据。简而言之,ONNX是一种便于在各个主流深度学习框架中迁移模型的中间表达格式.
.pt
/.torchscript
是ptorch 模型框架保存格式.
Triton REST API
常用的 Triton 的 REST API
1 | # 检测 triton 健康 |
查看模型输入输出
-
使用 polygraphy
1 | python -m pip install colored polygraphy --extra-index-url https://pypi.ngc.nvidia.com |
-
使用netron
Yolov5 pt to ONNX
将模型转换为 onnx,基于yolo模型,使用yolo仓库提供的export脚本
[!IMPORTANT]
若需要支持 batch 推理,则需要打开 --dynamic 选项。
1 | docker run -it --gpus all -v $(pwd):/workspace nvcr.io/nvidia/pytorch:23.04-py3 |
将模型保存在需要的位置,并补充模型配置文件 config.pbtxt,如下:
1 | tree model_repository/model |
优化导出模型,将preprocessing和postprocessing加入到模型图中
[!TIP]
参考 yolov5-rt 自动化转化前后处理到模型中。
ALBERT to ONNX
1 | pip install -U tf2onnx |
参考triton to albert client
Transformers to ONNX
将 Transformers 模型转 ONNX 参考
ONNX Patch
支持CPU/GPU部署
[!TIP]
使用三方工具可以操作ONNX模型裁剪、修改节点命名等。
使用 ONNX 推理加速方案。
ONNX 转换 TensorRT Engine
[!TIP]
通常 TensorRT 部署的推理速度较快。
将 ONNX 模型转为 TensorRT Engine,仅支持GPU部署(需要在对应部署机器配置适配,会对生成的 TensorRT Engine 进行优化)。
[!TIP]
onnx2trt_utils.cpp:374: Your ONNX model has been generated with INT64 weights, while TensorRT does not natively support INT64. Attempting to cast down to INT32.
该问题可以通过 onnx-simplifier 简化 onnx 模型解决:
1
2 pip install onnx-simplifier
onnxsim model.onnx simplfied_model.onnx
将 ONNX 模型转为 TensorRT Engine。
1 | docker run -it --gpus all -v $(pwd):/trt_optimize nvcr.io/nvidia/tensorrt:23.04-py3 |
使用 Model Analyzer 评估最优配置文件 config.pbtxt
1 | docker run -it --gpus=all --shm-size=256m --rm -p8000:8000 -p8001:8001 -p8002:8002 -v $(pwd):/workspace nvcr.io/nvidia/tritonserver:23.04-py3 |
使用 TPAT 转换ONNX自动化生成 TensorRT Engine。
ONNX/TensorRT Batch
动态 Batch 处理需要,对模型的输入输出,设置为动态类型。
基于yolo 的模型需要修改 export.py 脚本,配置输出脚本,以导出 batch 的 ONNX 模型。
1 | # 对block对应得输入,重命名 |
1 | python export.py --include onnx --weights weights/box_810.pt --img 1280 --batch-size 1 --dynamic |
或者直接使用最新yolov5版本导出 dynamic 版本,参考
生成 TensorRT Engine 时需要设置支持的动态维度。
1 | trtexec --onnx=model.onnx --saveEngine=model.plan --useCudaGraph --minShapes=images:1x3x1280x1280 --optShapes=images:1x3x1280x1280 --maxShapes=images:4x3x1280x1280 |
dali_backend
[!NOTE]
dali_backend:The Triton backend that allows running GPU-accelerated data pre-processing pipelines implemented in DALI’s python API.
dali_backend 支持在 tritonserver 中构建 ensemble 方式构建的应用,参考官方示例.
指定model推理
准备推理脚本,启动服务
1 | docker run -it --gpus=all --shm-size=256m --rm -p8000:8000 -p8001:8001 -p8002:8002 -v $(pwd):/workspace nvcr.io/nvidia/tritonserver:23.04-py3 |
安装依赖
1 | pip install tritonclient[http] opencv-python-headless |
Ensemble(pipeline)
[!IMPORTANT]
UNAVAILABLE: Internal: Unable to initialize shared memory key 'triton_python_backend_shm_region_2' to requested size (67108864 bytes). If you are running Triton inside docker, use '--shm-size' flag to control the shared memory region size. Each Python backend model instance requires at least 64MBs of shared memory. Error: No space left on device
使用 Ensemble 模式需要加载共享内存大小,–shm-size=256m,大小根据实际需求设置。
1 | docker run -it --gpus=all --shm-size=256m --rm -p8000:8000 -p8001:8001 -p8002:8002 -v $(pwd):/workspace nvcr.io/nvidia/tritonserver:23.04-py3 |
Model Warm-up
模型加载,会在模型初始化时耗费时间,使用 ModelWarmup
可以有效规避第一次请求的花销。ModelWarmup
参考模型配置。官方示例参考测试。
1 | model_warmup [ |
上面模型配置使用模型子文件夹下warm-up.jpg,在模型加载时作为输入。
Jetson Compatibility
pytorch with triton
Solution
结合 Triton 提供的 model 服务推理功能,可以实现如示例 中 k8s 和 mlflow 集成解决方案。
[!WARNING]
minikube 上测试 gpu 非常麻烦,参考 stackoverflow 和 github
k8s Integration
mlflow Integration
Customized Server
TensorRT
TensorRT 是一个高性能的深度学习推理库,可用于优化和部署深度学习模型。它使用GPU加速来提高推理性能,并提供了许多优化技术,例如网络剪枝、量化和层融合,以减少模型的计算和内存需求。
Tips
安装
-
debian distribution installation
-
tensorrt download link with download
查看 tensorrt 版本
1 | dpkg-query -W tensorrt |
HPC
Nvidia HPC是一种高性能计算解决方案,旨在加速科学计算和数据分析。它使用GPU加速器来提高计算速度,从而使科学家和研究人员能够更快地进行计算密集型任务。
Cuda
Nvidia Cuda 简化开发人员能利用基于Cuda 的 GPU 执行并行优化编程.
OpenVINO
OpenVINO 是一个开源的优化和部署深度学习模型工具包。
DALI
Nvidia DALI(Data Loading Library)是一个用于数据预处理和增强的库,旨在加速深度学习模型的训练和推理。DALI 提供了高度优化的 CPU 和 GPU 数据管道,可以在数据加载和预处理方面显著提高性能。DALI 还提供了许多常用的数据增强操作,例如裁剪、缩放、旋转和翻转等,可以帮助用户更轻松地进行数据增强。在 Triton 中,DALI 可以与 PyTorch 和 TensorFlow 等深度学习框架一起使用,以加速模型的训练和推理。如果需要更快的数据加载和预处理速度,可以考虑使用 Nvidia DALI。
参考主页。教程将指导通过第一步和支持的操作将放在一起的 GPU 驱动的数据处理管道。
DALI 用户手册大纲。
DALI Operation
DALI Operation包含了对常用的图形、音频、视频的处理加工教程和示例。调用接口参考 Operation Interface Reference 。
安装
1 | pip install --extra-index-url https://pypi.nvidia.com nvidia-dali-cuda120 |
Common Process
获取当前管道信息
1 | cur = dali.pipeline.Pipeline.current() |
Image Preprocess
适配 yolo 的 letterbox 图片预处理,将图片按原有宽高比缩小在 img_size 大小,并在 img_size比例较大的一侧添加填充。
方案一: resize后使用剪切并填充.
1 | # 定义dali数据预处理管道 |
方案二: resize后使用切片并填充.
1 | import nvidia.dali as dali |
Transformers
NLP
Yolov5
Resource
-
yolov5: 官方仓库.
-
yolov5-utils: 将官方仓库打包好的 pip pkg.
-
yolov5-flask: yolov5 完善的 flask app.
输出IOU
IOU = 两个矩形交集的面积/两个矩形的并集面积
, 两矩形表示检测矩形(predicted)和标注(ground-truth)矩形.
将待测图像输入网络得到的输出结果是一个高维矩阵, [-1, H, W, B, (4 + 1 + C)]
. 一幅图片被分割为了H*W块.(参看论文中的Pr(object)∗IOU)
-
H:表示纵向分割的块的数目
-
W:表示横向分割的块的数目
-
B:表示anchors的数目
-
C:表示classes的数目
-
4:x,y,w,h,
-
1:confidence
bert/albert
模型资源
-
bert-base-uncased: HuggingFace bert模型.
-
albert_chinese_tiny:HuggingFace chinese albert模型.
-
albert_zh 中文训练模型框架.
LLM
ChatGLM
ChatGLM 是一个基于大型语言模型的对话生成模型,它可以生成自然流畅的对话,可以用于聊天机器人、智能客服等场景。ChatGLM使用了GPT-2模型,该模型是由OpenAI开发的一种基于Transformer的语言模型,可以生成高质量的自然语言文本。ChatGLM-6B是ChatGLM的一个版本,它使用了包含60亿个参数的GPT-2模型,可以生成更加自然流畅的对话。
模型相关链接:
参考应用方案:
测试官方 Demo
依赖:
-
GPU >= 6 G or CPU >= 32G(实际测试 5G 即可)
-
pip:
pip install protobuf transformers==4.30.2 cpm_kernels torch>=2.0 gradio mdtex2html sentencepiece accelerate
[!TIP]
Error: RuntimeError: Library cuda is not initializedFix:
ln -s /usr/lib/x86_64-linux-gnu/libcuda.so /usr/local/cuda/lib64/libcuda.so
1 | from transformers import AutoTokenizer, AutoModel |
VisualGLM
VisualGLM-6B 是一个开源的,支持图像、中文和英文的多模态对话语言模型,语言模型基于 ChatGLM-6B,具有 62 亿参数;图像部分通过训练 BLIP2-Qformer 构建起视觉模型与语言模型的桥梁,整体模型共78亿参数。
模型相关链接:
ImageBind
ImageBind 多模态互转.
segment-anything
segment-anything MetaAI分割模型.
milvus
milvus 向量数据库(非结构化数据库).
links:
Design
架构
links:
索引
最近邻搜索算法
-
搜索: 将查询向量和搜索空间每个向量比较相似性,相似性可选择欧氏距离,维度夹角等
-
优缺点: 搜索质量完美,和每个向量都做比较,时间复杂度极高,仅支持小规模数据集(百万)
-
milvus: FLAT
近似近邻搜索-聚类算法-kmeans
-
搜索: 构建索引时,选定要分类的数量,随机选择分类数量个点分别划分向量空间的每个向量,然后计算出每个分类空间中的聚类中心点(平均向量点),重新再分类,然后重复迭代,直到收敛. 搜索时,选择查询向量距离最近的聚类中心点,比较该分类空间中的向量即可
-
优化: 增加聚类的数量,增加搜索的空间的数量
-
优缺点: 分治搜索, 搜索速度和质量成反比
-
milvus: IVF_FLAT,IVF_SQ8
[!NOTE]
IVF(Inverted File)是一种用于加速近似最近邻搜索的索引结构。IVF_FLAT是IVF索引的一种类型。IVF索引将向量数据集划分为多个小的聚类中心,每个聚类中心都有一个倒排文件。当进行查询时,Milvus会根据查询向量的特征找到最相似的聚类中心,然后只在这些聚类中心的倒排文件中搜索,从而减少搜索的时间复杂度。
投影法
-
搜索: 构建索引时,对每个维度,使用易于碰撞的哈希函数映射向量空间中的向量,形成分类空间.搜索时,使用相同的哈希函数计算搜索向量得到对应的分类空间,比较分类空间中的向量即可.
-
优化: 将单个向量分为多段(小维度)向量降低分类空间形成的索引大小,增加近似搜索空间的数量
-
优缺点: 哈希搜索, 收敛搜索更快
-
milvus: ANNOY
有损压缩-量化-积量化(PQ)
-
搜索: 使用分类空间中的的质心点编码代替向量存储在内存,将编码映射成码本.
-
优化: 将向量分段为低维度向量,对子向量进行量化,将码本的增加速率从指数降为加法
-
优缺点: 节省内存, 搜索质量视向量聚类的稀疏而定,码本会形成性能瓶颈
-
milvus: IVF_PQ
基于图的搜索算法(HNSW)
-
搜索: 建立图结构,每个向量点都使用合适的方法计算出建立连接的邻节点,比如德劳内(Delaunay)三角剖分法.
-
优化: 将向量空间点,依次拿出放到搜索空间计算近邻点,以此形成类似三角剖分法路径和噪声干扰路径(有利于相聚更远的两个向量建立连接), 即向粗后慢
-
优化2: 基于图的分层搜索算法,将前面提到的聚类质心按分类大小从大到小分层建立图结构,分层从上到下节点间连接越密集,即先保证快速导航,进入下一层精细搜索
-
优缺点: 搜索速度稳定,但占用内存极大,无法像积量化压缩向量,还要维护分层结构
-
milvus: HNSW
links:
-
https://medium.com/unstructured-data-service/how-to-choose-an-index-in-milvus-4f3d15259212
-
https://zilliz.com/learn/choosing-right-vector-index-for-your-project
度量
-
CV: Euclidean distance (L2), Inner product(IP)
-
NLP: Inner product(IP), Hamming
-
molecular: Jaccard
links:
Getting started
install
使用standalone模式安装
-
基于 docker-compose 安装
-
基于helm安装
1 | helm repo add milvus https://milvus-io.github.io/milvus-helm/ && helm repo update |
使用cluser模式
1 | helm repo add milvus https://milvus-io.github.io/milvus-helm/ && helm repo update |
Examples
处理所有非结构化数据,如反向图像搜索、音频搜索、分子搜索、视频分析、问答系统、自然语言处理等示例.
links:
Service Encoding
处于安全考虑,通常需要将代码进行加密,以防止源码泄露. 在AI服务中常见的加密方式有:
-
将源码转为 exe
-
授权license
-
加密模型
links:
将源码转为exe
较为流程的转换方案是使用 pyinstaller 和 nuikta 将源码转为 exe. 这里使用 nuikta 方案.
links: