Compare commits
10 Commits
8f43269e59
...
8013f4e837
| Author | SHA1 | Date |
|---|---|---|
Haojun Liao
|
8013f4e837 | |
Jeff Tao
|
bb85646763 | |
|
Haojun Liao
|
dea62af077 | |
Simon Guan
|
306dbbb939 | |
|
Simon Guan
|
e7c19ca217 | |
|
Haojun Liao
|
37d0aaa587 | |
jiajingbin
|
45b342ad27 | |
|
Simon Guan
|
903e171a85 | |
|
Haojun Liao
|
065818afda | |
|
Simon Guan
|
d3135c9de3 |
|
|
@ -109,5 +109,4 @@ slug: /release-history/release-notes/3.3.6.0
|
|||
21. fix: when the subquery does not return any results but contains the LIMIT 1 clause, it may cause the result of the parent query to be abnormal or inaccurate.
|
||||
22. fix: taosc crash when table names contain `*`
|
||||
23. fix: on windows, closing a JDBC PreparedStatement while writing data may cause the JVM to crash.[#30106](https://github.com/taosdata/TDengine/issues/30106)
|
||||
24. fix: when using Websocket parameter binding to batch write data, Chinese characters in subtable names will cause garbled text[#29998](https://github.com/taosdata/TDengine/issues/29998)
|
||||
|
||||
|
|
|
|||
|
|
@ -79,11 +79,11 @@ TDengine 采用“一个数据采集点一张表”的设计虽然有利于高
|
|||
|
||||
### 虚拟表
|
||||
|
||||
“一个数据采集点一张表”以及“超级表”的设计解决了工业和物联网等场景下的大多数时序数据管理和分析难题。但是在真实的场景中，一个设备往往有多种传感器，而且他们的数据采集频次还相差很大。比如对于一台风机，有电的参数、环境参数、机械参数，各自的传感器和采集频次完全不一样。因此我们很难用一张表来描述一台设备，往往需要多张表。当需要综合多个传感器的数据进行分析计算时，只能通过多级关联查询的方式来进行，而这往往会导致易用性和性能方面的问题。而从用户的角度来看，“一个设备一张表”更为直观，容易操作。但如果我们建模之初，直接采用"一个设备一张表的“的设计，由于采集频次的不同，会导致每一个具体时间戳，大量的列是空值，从而降低存储和查询的效率。
|
||||
“一个数据采集点一张表”以及“超级表”的设计解决了工业和物联网等场景下的大多数时序数据管理和分析难题。但在真实的场景中，一个设备往往有多种传感器，数据采集频次还相差很大。比如对于一台风机，电气参数、环境参数、机械参数，各自的传感器和采集频次完全不一样。因此很难用一张表来描述一台设备，往往需要多张表。当需要综合多个传感器的数据进行分析计算时，只能通过多级关联查询的方式来进行，而这往往会导致易用性和性能方面的问题。从用户的角度来看，“一个设备一张表”更为直观、容易操作。但如果建模之初，直接采用“一个设备一张表的”的设计，由于采集频次的不同，会导致每一个具体时间戳，大量的列是空值，降低存储和查询的效率。
|
||||
|
||||
为了解决这个问题，TDengine 引入虚拟表（Virtual Table，简称为 VTable）的概念。虚拟表是一种不存储实际数据而可以用于分析计算的表，它的数据来源为其它真实存储数据的子表、普通表，通过将各个原始表的不同列的数据按照时间戳排序、对齐、合并的方式来生成虚拟表。同真实表类似，虚拟表也可以分为虚拟超级表、虚拟子表、虚拟普通表。虚拟超级表可以是一个设备或一组分析计算所需数据的完整集合，每个虚拟子表可以根据需要引用相同或不同的列，因此可以灵活地根据业务需要进行定义，最终达到“千人千面”的效果。虚拟表不能写入、删除数据，在查询使用上同真实表相同。TDengine 支持虚拟超级表、虚拟子表、虚拟普通表上的任何查询。唯一的区别在于虚拟表的数据是每次查询计算时动态生成的，只有一个查询中引用的列才会被合并进虚拟表中，因此同一个虚拟表在不同的查询中所呈现以及扫描的数据可能是完全不同的。
|
||||
为了解决这个问题，TDengine 引入虚拟表（Virtual Table，简称为 VTable）的概念。虚拟表是一种不存储实际数据而可以用于分析计算的表，数据来源为其它真实存储数据的子表、普通表，通过将各个原始表的不同列的数据按照时间戳排序、对齐、合并的方式来生成虚拟表。同真实表类似，虚拟表也可以分为虚拟超级表、虚拟子表、虚拟普通表。虚拟超级表可以是一个设备或一组分析计算所需数据的完整集合，每个虚拟子表可以根据需要引用相同或不同的列，因此可以灵活地根据业务需要进行定义，最终达到“千人千面”的效果。虚拟表不能写入、删除数据，在查询使用上和真实表相同。TDengine 支持虚拟超级表、虚拟子表、虚拟普通表上的任何查询。唯一的区别在于虚拟表的数据是每次查询计算时动态生成的，只有一个查询中引用的列才会被合并进虚拟表中，因此同一个虚拟表在不同的查询中所呈现以及扫描的数据可能是完全不同的。
|
||||
|
||||
虚拟超级表的主要功能特点包括：
|
||||
虚拟超级表的主要功能特点包括。
|
||||
1. 列选择与拼接：用户可以从多个原始表中选择指定的列，按需组合到一张虚拟表中，形成统一的数据视图。
|
||||
2. 基于时间戳对齐：以时间戳为依据对数据进行对齐，如果多个表在相同时间戳下存在数据，则对应列的值组合成同一行；若部分表在该时间戳下无数据，则对应列填充为 NULL。
|
||||
3. 动态更新：虚拟表根据原始表的数据变化自动更新，确保数据的实时性。虚拟表不需实际存储，计算在生成时动态完成。
|
||||
|
|
|
|||
|
|
@ -10,12 +10,10 @@ import TDgpt from './pic/data-analysis.png';
|
|||
|
||||
分析算法通常以高级编程语言（Python 语言或 R 语言）工具包的形式存在，并通过开源的方式广泛分发和使用，这种应用模式极大地便利了软件开发人员在应用系统中调用复杂的分析算法，极大地降低了使用高级算法的门槛。
|
||||
|
||||
|
||||
另一方面，数据库系统研发人员也尝试将数据分析算法模型整合到数据库系统中，通过建立 Machine Learning 库（例如 Spark 的机器学习库）充分利用成熟分析技术增强数据库或分析计算引擎的高级数据分析能力。
|
||||
另一方面，数据库系统研发人员也尝试将数据分析算法模型整合到数据库系统中，通过建立 Machine Learning 库（例如 Spark 的机器学习库），充分利用成熟分析技术增强数据库或分析计算引擎的高级数据分析能力。
|
||||
|
||||
飞速发展的人工智能（AI）为时序数据分析应用带来了新的机遇，而如何快速高效地将 AI 能力应用于时间序列数据分析，也对数据库系统提出了新的挑战。为此，涛思数据创新性地提出了时序数据分析智能体 TDgpt，使用 TDgpt，将您能够通过 SQL 语句，直接调用适配和整合驱动统计分析算法、机器学习算法模型、深度学习模型，时序数据基础模型以及大语言模型，并将这些分析能力转化为 SQL 语句的调用，通过异常检测窗口和预测函数的方式应用在时序数据上。
|
||||
|
||||
|
||||
# 技术特点
|
||||
TDgpt 是与 TDengine 主进程 taosd 适配的外置式时序数据分析智能体，能够将时序数据分析服务无缝集成在 TDengine 的查询执行流程中。
|
||||
TDgpt 是一个无状态的平台，其内置了经典的统计分析模型库 Statsmodel，内嵌了 torch/Keras 等机器/深度学习框架库，此外还通过请求转发和适配的方式直接调用涛思数据自研的时序数据基础大模型 TDtsfm (TDengine time series foundation model)。
|
||||
|
|
@ -25,51 +23,51 @@ TDgpt 是一个开放的系统，用户能够根据自己的需要，添加预
|
|||
无需应用修改一行代码。
|
||||
|
||||
# 系统架构
|
||||
TDgpt 由若干个无状态的分析节点 anode 构成，可以按需在系统集群中部署 Anode 节点，也可以根据分析模型算法的特点，将 Anode 部署在合适的硬件环境中，例如带有 GPU 的计算节点。
|
||||
TDgpt 由若干个无状态的分析节点 Anode 构成，可以按需在系统集群中部署 Anode 节点，也可以根据分析模型算法的特点，将 Anode 部署在合适的硬件环境中，例如带有 GPU 的计算节点。
|
||||
TDgpt 针对不同的分析算法，提供统一的调用接口和调用方式，根据用户请求的参数，调用高级分析算法包及其他的分析工具，并将分析获得的结果按照约定的方式返回给 TDengine 的主进程 taosd。
|
||||
TDgpt 的主要包含四个部分的内容。
|
||||
- 第一部分是内置分析库，包括 statsmodels, pyculiarity, pmdarima 等，提供可以直接调用的预测分析和异常检测算法模型。
|
||||
- 第二部分是内置的机器学习库（包括：torch,keras,scikit-learn等），用于驱动预训练完成的机器（深度）学习模型在 TDgpt 的进程空间内运行。预训练的流程可以使用 Merlion/Kats 等 开源的端到端机器学习框架进行管理，并将完成训练的模型上传到 TDgpt 指定目录即可;
|
||||
- 第三部分是通用大语言模型的请求适配模块。将时序数据预测请求转换后，基于 Prompt 向 DeepSeek、LlaMa 等通用大语言模型 MaaS 请求服务（这部分功能暂未开源）；
|
||||
- 第二部分是内置的机器学习库（包括：torch、keras、scikit-learn等），用于驱动预训练完成的机器（深度）学习模型在 TDgpt 的进程空间内运行。预训练的流程可以使用 Merlion/Kats 等 开源的端到端机器学习框架进行管理，并将完成训练的模型上传到 TDgpt 指定目录即可。
|
||||
- 第三部分是通用大语言模型的请求适配模块。将时序数据预测请求转换后，基于 Prompt 向 DeepSeek、LlaMa 等通用大语言模型 MaaS 请求服务（这部分功能暂未开源）。
|
||||
- 第四部分是通过 Adapter 直接向本地部署的 Time-MoE、TDtsfm 等时序数据模型请求服务。时序数据专用模型相对于通用语言大模型，无需 Prompt，更加便捷轻量，本地应用部署对硬件资源要求也较低；除此之外，Adapter 还可以直接请求 TimeGPT 这种类型的时序数据分析 MaaS 服务，调用云端的时序模型服务提供本地化时序数据分析能力。
|
||||
|
||||
<figure style={{textAlign: "center"}}>
|
||||
<img src={TDgpt} alt="TDgpt架构图" />
|
||||
</figure>
|
||||
|
||||
查询过程中，TDengine 中的Vnode 会将涉及时序数据高级分析的部分直接转发到 Anode，并等待分析完成后将结果组装完成，嵌入查询执行流程。
|
||||
查询过程中，TDengine 中的 Vnode 会将涉及时序数据高级分析的部分直接转发到 Anode，并等待分析完成后将结果组装完成，嵌入查询执行流程。
|
||||
|
||||
# 时序数据分析服务
|
||||
|
||||
使用TDgpt 提供的时序数据分析服务，包括：
|
||||
- 时序数据异常检测：TDengine 中定义了新的时间窗口——异常（状态）窗口——来提供异常检测服务。异常窗口可以视为一种特殊的事件窗口（Event Window），即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法确定，不是用户指定的表达式判定。异常窗口使用方式与其他类型的时间窗口（例如状态窗口、会话窗口等）类似。因此时间窗口内可使用的查询操作均可应用在异常窗口上。
|
||||
- 时序数据分析预测：TDengine 中提供了一个新的函数FORECAST提供时序数据预测服务，基于输入的（历史）时间序列数据调用指定（或默认）预测算法给出输入时序数据后续时间序列的预测数据。
|
||||
- 时序数据异常检测：TDengine 中定义了新的时间窗口 **异常（状态）窗口** 来提供异常检测服务。异常窗口可以视为一种特殊的事件窗口（Event Window），即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于，时间窗口的起始时间和结束时间均是分析算法确定，不是用户指定的表达式判定。异常窗口使用方式与其他类型的时间窗口（例如状态窗口、会话窗口等）类似。因此时间窗口内可使用的查询操作均可应用在异常窗口上。
|
||||
- 时序数据分析预测：TDengine 中提供了一个新的函数 FORECAST 提供时序数据预测服务，基于输入的（历史）时间序列数据调用指定（或默认）预测算法给出输入时序数据后续时间序列的预测数据。
|
||||
- 时序数据补全：研发测试中，2025 年 7 月发布
|
||||
- 时序数据分类：研发测试中，2025 年 7 月发布
|
||||
|
||||
# 自定义分析算法
|
||||
|
||||
TDgpt 是一个可扩展的时序数据高级分析智能体，用户遵循 [算法开发者指南](./dev)中的简易步骤就能将自己开发的分析算法添加到系统中。之后应用可以通过 SQL 语句直接调用, 让高级分析算法的使用门槛降到几乎为零。对于新引入的算法或模型，应用不用做任何调整。
|
||||
TDgpt 是一个可扩展的时序数据高级分析智能体，用户遵循 [算法开发者指南](./09-dev) 中的简易步骤就能将自己开发的分析算法添加到系统中。之后应用可以通过 SQL 语句直接调用, 让高级分析算法的使用门槛降到几乎为零。对于新引入的算法或模型，应用不用做任何调整。
|
||||
|
||||
TDpgt 只支持使用 Python 语言开发的分析算法。Anode 采用 Python 类动态加载模式，在启动的时候扫描特定目录内满足约定条件的所有代码文件，并将其加载到系统中。因此，开发者只需要遵循以下几步就能完成新算法的添加工作：
|
||||
1. 开发完成符合要求的分析算法类
|
||||
2. 将代码文件放入对应目录，然后重启 Anode
|
||||
3. 使用SQL命令更新算法缓存列表即可。
|
||||
TDpgt 只支持使用 Python 语言开发的分析算法。Anode 采用 Python 类动态加载模式，在启动的时候扫描特定目录内满足约定条件的所有代码文件，并将其加载到系统中。因此，开发者只需要遵循以下几步就能完成新算法的添加工作。
|
||||
1. 开发完成符合要求的分析算法类。
|
||||
2. 将代码文件放入对应目录，然后重启 Anode。
|
||||
3. 使用 SQL 命令更新算法缓存列表即可。
|
||||
添加完成的算法在刷新算法列表后，立即使用 SQL 语句进行调用。
|
||||
|
||||
# 算法评估工具
|
||||
|
||||
在 TDgpt 企业版中，还提供针对多种算法模型有效性的综合评估工具。该工具可以针对 TDgpt 可调用所有时序数据分析（预测分析与异常检测）服务，包括内置数据分析算法模型，已部署的预训练机器学习模型、第三方时序数据（大）模型服务，基于 TDengine 中的时序数据进行预测分析对比和异常检测对比评估，并给出量化指标评估不同分析模型在给定数据集上准确度及性能。
|
||||
在 TDgpt 企业版中，提供针对多种算法模型有效性的综合评估工具。该工具可以针对 TDgpt 可调用所有时序数据分析（预测分析与异常检测）服务，包括内置数据分析算法模型，已部署的预训练机器学习模型、第三方时序数据（大）模型服务，基于 TDengine 中的时序数据进行预测分析对比和异常检测对比评估，并给出量化指标评估不同分析模型在给定数据集上准确度及性能。
|
||||
|
||||
# 模型管理
|
||||
|
||||
对于 Torch/Tensorflow/Keras 等机器学习库框架驱动的预训练模型，需要首先将训练完成的数据模型添加到 Anode 的指定目录中，Anode 可以自动调用该目录内的模型，驱动其运行并提供服务。
|
||||
对于 Torch、Tensorflow、Keras 等机器学习库框架驱动的预训练模型，需要首先将训练完成的数据模型添加到 Anode 的指定目录中，Anode 可以自动调用该目录内的模型，驱动其运行并提供服务。
|
||||
企业版本的 TDgpt 具备模型的管理能力，能够与开源的端到端时序数据机器学习框架（例如：Merlion、Kats 等）无缝集成。
|
||||
|
||||
# 处理能力
|
||||
|
||||
通常意义上，时间序列数据分析主要是计算密集型任务。这种计算密集型任务，可以使用更高性能的 CPU 或 GPU 来提升处理性能。
|
||||
如果是机器/深度学习模型，依赖于 torch 库驱动其运行，可以采用标准的提升分析处理能力的方案来提升 TDgpt 的服务能力，例如将 Anode 部署在内存更大，并具有 GPU 的服务器之上，使用可调用 GPU 的 torch 库驱动模型运行，以提升分析响应能力。
|
||||
如果是机器/深度学习模型，依赖于 torch 库驱动其运行，可以采用标准的提升分析处理能力的方案来提升 TDgpt 的服务能力，例如将 Anode 部署在内存更大并具有 GPU 的服务器之上，使用可调用 GPU 的 torch 库驱动模型运行，以提升分析响应能力。
|
||||
不同的模型、算法可以部署在不同的 Anode 上，增加并行的处理能力。
|
||||
|
||||
# 运营维护
|
||||
|
|
|
|||
|
|
@ -6,13 +6,25 @@ sidebar_label: "安装部署"
|
|||
import PkgListV3 from "/components/PkgListV3";
|
||||
|
||||
|
||||
## 使用 TDgpt Docker 镜像
|
||||
本节介绍如何通过 Docker，云服务或安装包来部署 TDgpt
|
||||
|
||||
本节首先介绍如何通过 Docker 快速使用 TDgpt。
|
||||
## 通过 Docker 部署
|
||||
|
||||
### 启动 TDgpt
|
||||
### 镜像版本说明
|
||||
|
||||
如果已经安装了 Docker，首先拉取最新的 TDgpt 容器镜像：
|
||||
| 镜像名称 | 包含模型 |
|
||||
|-----------------------------------|-----------------------|
|
||||
| `tdengine/tdengine-tdgpt` | 涛思时序数据基础模型（TDtsfm v1.0） |
|
||||
| `tdengine/tdengine-tdgpt-full` | 涛思时序数据基础模型（TDtsfm v1.0）+ Time-MoE 时序数据基础模型 |
|
||||
|
||||
|
||||
### 快速启动指南
|
||||
|
||||
您需要先安装 Docker，然后通过以下方式获取镜像并启动容器
|
||||
|
||||
#### 标准版镜像
|
||||
|
||||
拉取最新的 TDgpt 容器镜像：
|
||||
|
||||
```shell
|
||||
docker pull tdengine/tdengine-tdgpt:latest
|
||||
|
|
@ -24,13 +36,34 @@ docker pull tdengine/tdengine-tdgpt:latest
|
|||
docker pull tdengine/tdengine-tdgpt:3.3.6.0
|
||||
```
|
||||
|
||||
然后只需执行下面的命令：
|
||||
执行下面的命令来启动容器：
|
||||
|
||||
```shell
|
||||
docker run -d -p 6090:6090 -p 5000:5000 tdengine/tdengine-tdgpt:3.3.6.0
|
||||
```
|
||||
|
||||
注意：TDgpt 服务端使用 6090 TCP 端口。TDgpt 是一个无状态时序数据分析智能体，并不会在本地持久化保存数据，仅根据配置可能在本地生成运行日志。
|
||||
#### 完整版镜像
|
||||
|
||||
拉取最新的 TDgpt 容器镜像：
|
||||
|
||||
```shell
|
||||
docker pull tdengine/tdengine-tdgpt-full:latest
|
||||
```
|
||||
|
||||
或者指定版本的容器镜像：
|
||||
|
||||
```shell
|
||||
docker pull tdengine/tdengine-tdgpt-full:3.3.6.0
|
||||
```
|
||||
|
||||
执行下面的命令来启动容器：
|
||||
|
||||
```shell
|
||||
docker run -d -p 6090:6090 -p 5000:5000 -p 5001:5001 tdengine/tdengine-tdgpt-full:3.3.6.0
|
||||
```
|
||||
|
||||
注意：TDgpt 服务端使用 6090 TCP 端口，5000 和 5001 端口分别标准版模型和完整版模型的服务端口；
|
||||
TDgpt 是一个无状态时序数据分析智能体，并不会在本地持久化保存数据，仅根据配置可能在本地生成运行日志。
|
||||
|
||||
确定该容器已经启动并且在正常运行。
|
||||
|
||||
|
|
@ -49,19 +82,19 @@ docker exec -it <container name> bash
|
|||
|
||||
## 注册云服务使用 TDgpt
|
||||
|
||||
TDgpt 可以在 TDengine Cloud 上进行快速体验。如果您已经有云服务账号，请在数据库集市里面找到“时序数据预测分析数据集”数据库，点击启用就可以进入这个数据库，然后按照 TDgpt 的 SQL 操作手册来执行语句，比如 `select forecast(val, 'algo=tdtsfm_1') from forecast.electricity_demand;`。
|
||||
TDgpt 可以在 TDengine Cloud 上进行快速体验。如果您已经有云服务账号，登录云服务后，点击屏幕左下侧的“数据库集市”，请在数据库集市里面找到 **时序数据预测分析数据集** 数据库，点击启用就可以进入这个数据库。然后按照 TDgpt 的 SQL 操作手册来执行语句，比如 `select forecast(val, 'algo=tdtsfm_1') from forecast.electricity_demand;`。
|
||||
|
||||
## 通过安装包部署 TDgpt
|
||||
|
||||
### 环境准备
|
||||
|
||||
使用 TDgpt 的高级时序数据分析功能需要在 TDengine 集群中安装部署Taos AI node（Anode）。Anode 运行在 Linux 平台上, 对部署 Anode 的有一定的环境要求：
|
||||
使用 TDgpt 的高级时序数据分析功能需要在 TDengine 集群中安装部署 Taos AI node（Anode）。Anode 运行在 Linux 平台上, 对部署 Anode 的有一定的环境要求：
|
||||
|
||||
> Python: 3.10 或以上版本
|
||||
> TDengine：需使用 3.3.6.0 或以上版本。
|
||||
> C 编译器：因依赖 uWSGI，部署环境需包含 C 编译器。
|
||||
- Python: 3.10 或以上版本。
|
||||
- TDengine：需使用 3.3.6.0 或以上版本。
|
||||
- C 编译器：因依赖 uWSGI，部署环境需包含 C 编译器。
|
||||
|
||||
可以使用以下的命令在 Ubuntu Linux 上安装 Python 3.10 环境
|
||||
可以使用以下的命令在 Ubuntu Linux 上安装 Python 3.10 环境，如果您的系统环境中已经有 Python 3.10，请跳过本节，直接查看 [获取安装包](#获取安装包) 部分。
|
||||
|
||||
#### 安装 Python
|
||||
|
||||
|
|
@ -82,7 +115,7 @@ sudo apt install python3.10-dev
|
|||
curl -sS https://bootstrap.pypa.io/get-pip.py | python3.10
|
||||
```
|
||||
|
||||
将 `~/.local/bin` 路径添加到环境变量中 `~/.bashrc or ~/.bash_profile`
|
||||
将 `~/.local/bin` 路径添加到环境变量中 `~/.bashrc or ~/.bash_profile`。
|
||||
```shell
|
||||
export PATH=$PATH:~/.local/bin
|
||||
```
|
||||
|
|
@ -96,10 +129,12 @@ sudo apt install build-essential
|
|||
```
|
||||
|
||||
### 获取安装包
|
||||
1. 从列表中下载获得 tar.gz 安装包：
|
||||
1. 从列表中下载获得 tar.gz 安装包
|
||||
|
||||
<PkgListV3 type={9}/>
|
||||
|
||||
TDgpt 的安装包中包含两个时序模型，分别是涛思时序基础模型（TDtsfm v1.0）和 Time-MoE 时序基础模型。两个基础时序模型启动时候需要一定规模的内存空间，请确保运行系统中有至少有 16GiB 可用内存空间。
|
||||
|
||||
2. 进入到安装包所在目录，使用 tar 解压安装包；
|
||||
> 请将 `<version>` 替换为下载的安装包版本
|
||||
|
||||
|
|
@ -119,11 +154,13 @@ cd TDengine-TDgpt-<version>
|
|||
|
||||
为了避免影响系统已有的 Python 环境，Anode 使用虚拟环境运行。安装 Anode 会在目录 `/var/lib/taos/taosanode/venv/` 中创建默认的 Python 虚拟环境，Anode 运行所需要的库均安装在该目录下。为了避免反复安装虚拟环境带来的开销，卸载命令 `rmtaosanode` 并不会自动删除该虚拟环境，如果您确认不再需要 Python 的虚拟环境，手动删除该目录即可。
|
||||
|
||||
### 激活使用虚拟环境
|
||||
### 激活虚拟环境
|
||||
|
||||
为了避免安装操作系统的Python 环境， TDgpt 安装过程中会自动创建一个虚拟环境，该虚拟环境默认创建的路径在 `/var/lib/taos/taosanode/venv/`。创建完成该虚拟环境，该虚拟环境通过 PiPy 安装了支持 TDgpt 运行所必须的 Python 依赖库。
|
||||
为了避免安装操作系统的 Python 环境， TDgpt 安装过程中会自动创建一个虚拟环境，该虚拟环境默认创建的路径在 `/var/lib/taos/taosanode/venv/`。创建完成该虚拟环境，该虚拟环境通过 PiPy 安装了支持 TDgpt 运行所必须的 Python 依赖库。
|
||||
该虚拟环境不会被卸载脚本 `rmtaosanode` 删除，当您确认不再需要该虚拟环境的时候，需要手动删除该虚拟环境。
|
||||
后续如果您需要开发自己的算法模型，并能够 TDgpt 正确调用，需要将新的依赖库通过虚拟环境的 Pip 正确地安装。
|
||||
|
||||
|
||||
### 卸载
|
||||
卸载 TDgpt，执行 `rmtaosanode` 即可。 安装过程中自动安装的虚拟环境不会被自动删除，用户确认不再需要的时候，需要手动删除该虚拟环境。
|
||||
卸载 TDgpt，执行 `rmtaosanode` 即可。
|
||||
> 安装过程中自动安装的虚拟环境不会被自动删除，用户确认不再需要的时候，需要手动删除该虚拟环境。
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
---
|
||||
title: "运维管理指南"
|
||||
sidebar_label: "运维管理指南"
|
||||
title: "Anode 管理"
|
||||
sidebar_label: "Anode 管理"
|
||||
---
|
||||
|
||||
import PkgListV3 from "/components/PkgListV3";
|
||||
|
|
@ -14,6 +14,24 @@ systemctl stop taosanoded
|
|||
systemctl status taosanoded
|
||||
```
|
||||
|
||||
### 启停时间序列基础模型服务
|
||||
考虑到时序基础模型服务，需要较大的资源。避免启动过程中资源不足导致的启动失败，暂不提供自动启动方式。如果您希望体验时序基础模型服务，需要手动执行如下命令
|
||||
```bash
|
||||
# 启动涛思时序数据基础模型
|
||||
start-tdtsfm
|
||||
|
||||
# 启动 Time-MoE 基础模型
|
||||
start-timer-moe
|
||||
```
|
||||
|
||||
```bash
|
||||
# 停止涛思时序数据基础模型
|
||||
stop-tdtsfm
|
||||
|
||||
# 停止 Time-MoE 基础模型
|
||||
stop-timer-moe
|
||||
```
|
||||
|
||||
### 目录及配置说明
|
||||
安装完成后，Anode 主体目录结构如下：
|
||||
|
||||
|
|
@ -82,14 +100,16 @@ Anode 运行配置主要是以下：
|
|||
|
||||
### Anode 基本操作
|
||||
对于 Anode 的管理，用户需要通过 TDengine 的命令行接口 taos 进行。因此下述介绍的管理命令都需要先打开 taos, 连接到 TDengine 运行实例。
|
||||
|
||||
#### 创建 Anode
|
||||
```sql
|
||||
CREATE ANODE {node_url}
|
||||
```
|
||||
node_url 是提供服务的 Anode 的 IP 和 PORT组成的字符串, 例如：`create anode '127.0.0.1:6090'`。Anode 启动后还需要注册到 TDengine 集群中才能提供服务。不建议将 Anode 同时注册到两个集群中。
|
||||
node_url 是提供服务的 Anode 的 IP 和 PORT 组成的字符串, 例如：`create anode '127.0.0.1:6090'`。Anode 启动后还需要注册到 TDengine 集群中才能提供服务。不建议将 Anode 同时注册到两个集群中。
|
||||
|
||||
#### 查看 Anode
|
||||
列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`等属性。
|
||||
|
||||
```sql
|
||||
SHOW ANODES;
|
||||
|
||||
|
|
@ -109,18 +129,37 @@ SHOW ANODES FULL;
|
|||
taos> show anodes full;
|
||||
id | type | algo |
|
||||
============================================================================
|
||||
1 | anomaly-detection | shesd |
|
||||
1 | anomaly-detection | iqr |
|
||||
1 | anomaly-detection | ksigma |
|
||||
1 | anomaly-detection | lof |
|
||||
1 | anomaly-detection | grubbs |
|
||||
1 | anomaly-detection | ad_encoder |
|
||||
1 | forecast | holtwinters |
|
||||
1 | anomaly-detection | lof |
|
||||
1 | anomaly-detection | shesd |
|
||||
1 | anomaly-detection | ksigma |
|
||||
1 | anomaly-detection | iqr |
|
||||
1 | anomaly-detection | sample_ad_model |
|
||||
1 | forecast | arima |
|
||||
Query OK, 8 row(s) in set (0.008796s)
|
||||
|
||||
1 | forecast | holtwinters |
|
||||
1 | forecast | tdtsfm_1 |
|
||||
1 | forecast | timemoe-fc |
|
||||
Query OK, 10 row(s) in set (0.028750s)
|
||||
```
|
||||
|
||||
列表中的算法分为两个部分，分别是异常检测算法集合，包含六个算法模型，四个预测算法集。算法模型如下：
|
||||
|
||||
|类型 |模型名称|说明 |
|
||||
|--------|--------|--------------------|
|
||||
|异常检测 |grubbs |基于数学统计学检测模型|
|
||||
|异常检测 |lof |基于密度的检测模型 |
|
||||
|异常检测 |shesd |季节性ESD算法模型 |
|
||||
|异常检测 |ksigma |数学统计学检测模型 |
|
||||
|异常检测 |iqr |数学统计学检测模型 |
|
||||
|预测分析 |sample_ad_model |基于自编码器的异常检测示例模型|
|
||||
|预测分析 |arima |移动平均自回归预测算法|
|
||||
|预测分析 |holtwinters |多次指数平滑预测算法|
|
||||
|预测分析 |tdtsfm_1 |涛思时序数据基础模型 v1.0 版本|
|
||||
|预测分析 |timemoe-fc |Time-MoE时序基础模型的预测能力|
|
||||
|
||||
相关算法的具体介绍和使用说明见后续章节。
|
||||
|
||||
|
||||
#### 刷新集群中的分析算法缓存
|
||||
```SQL
|
||||
UPDATE ANODE {anode_id}
|
||||
|
|
|
|||
|
|
@ -28,26 +28,26 @@ TDgpt 暂不提供独立的时间序列白噪声检测功能。
|
|||
|
||||
### 重采样和时间戳对齐
|
||||
|
||||
对于进行预测分析的时间序列数据，在进行预测分析前需要进行必要的预处理。预处理主要解决以下两个问题：
|
||||
对于进行预测分析的时间序列数据，在进行预测分析前需要进行必要的预处理。预处理主要解决以下两个问题。
|
||||
|
||||
- 真实时间序列数据时间戳未对齐。由于数据生成设备的原因或网关赋值时间戳的时候并不能保证按照严格的时间间隔赋值，时间序列数据并不能保证是严格按照采样频率对齐。例如采样频率为 1Hz 的一个时间序列数据序列，其时间戳序列如下：
|
||||
- 真实时间序列数据时间戳未对齐。由于数据生成设备的原因或网关赋值时间戳的时候并不能保证按照严格的时间间隔赋值，时间序列数据并不能保证是严格按照采样频率对齐。例如采样频率为 1Hz 的一个时间序列数据序列，其时间戳序列如下。
|
||||
|
||||
> ['20:12:21.143', '20:12:22.187', '20:12:23.032', '20:12:24.384', '20:12:25.033']
|
||||
|
||||
预测返回的时间序列时间戳会严格对齐，例如返回后续的两个预测结果的时间戳，其时间一定如下：['20:12:26.000', '20:12:27.000']。因此上述的输入时间戳序列要进行时间戳对齐，变换成为如下时间戳序列
|
||||
预测返回的时间序列时间戳会严格对齐，例如返回后续的两个预测结果的时间戳，其时间一定如下：['20:12:26.000', '20:12:27.000']。因此上述的输入时间戳序列要进行时间戳对齐，变换成为如下时间戳序列。
|
||||
|
||||
> ['20:12:21.000', '20:12:22.000', '20:12:23.000', '20:12:24.000', '20:12:25.000']
|
||||
|
||||
|
||||
- 数据时间重采样。用户输入时间序列的采样频率超过了输出结果的频率，例如输入时间序列的采样时间间隔是 5 sec，但是要求输出预测结果的采样时间间隔是 10sec
|
||||
- 数据时间重采样。用户输入时间序列的采样频率超过了输出结果的频率，例如输入时间序列的采样时间间隔是 5 sec，但是要求输出预测结果的采样时间间隔是 10sec。
|
||||
|
||||
> ['20:12:20.000', '20:12:25.000', '20:12:30.000', '20:12:35.000', '20:12:40.000']
|
||||
|
||||
重采样为采样间隔为 10sec 的时间戳序列
|
||||
重采样为采样间隔为 10sec 的时间戳序列。
|
||||
|
||||
> ['20:12:20.000', '20:12:30.000', '20:12:40.000']
|
||||
|
||||
然后将其作为预测分析的输入， ['20:12:25.000', '20:12:35.000'] 数据被丢弃。
|
||||
然后将其作为预测分析的输入，['20:12:25.000', '20:12:35.000'] 数据被丢弃。
|
||||
|
||||
需要注意的是，预处理过程不支持缺失数据补齐操作，如果输入时间序列数据 ['20:12:10.113', '20:12:21.393', '20:12:29.143', '20:12:51.330']，并且要求的采样时间间隔为 10sec，重整对齐后的时间戳序列是 ['20:12:10.000', '20:12:20.000', '20:12:30.000', '20:12:50.000'] 那么对该序列进行预测分析将返回错误。
|
||||
需要注意的是，预处理过程不支持缺失数据补齐操作，如果输入时间序列数据 ['20:12:10.113', '20:12:21.393', '20:12:29.143', '20:12:51.330']，并且要求的采样时间间隔为 10sec，重整对齐后的时间戳序列是 ['20:12:10.000', '20:12:20.000', '20:12:30.000', '20:12:50.000']，那么对该序列进行预测分析将返回错误。
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,8 @@ ARIMA 模型是一种自回归模型，只需要自变量即可预测后续的
|
|||
`start_p`、`max_p` `start_q` `max_q` 四个参数约束了模型在多大的范围内去搜寻合适的最优解。相同输入数据的条件下，参数范围越大，消耗的资源越多，系统响应的时间越长。
|
||||
|
||||
### 示例及结果
|
||||
针对 i32 列进行数据预测，输入列 i32 每 10 个点是一个周期，start_p 起始是 1， 最大拟合是 5，start_q 是 1，最大值是 5，预测结果中返回 95% 置信区间范围边界。
|
||||
针对 i32 列进行数据预测，输入列 i32 每 10 个点是一个周期；start_p 起始是 1，最大拟合是 5；start_q 是 1，最大值是 5，预测结果中返回 95% 置信区间范围边界。
|
||||
|
||||
```
|
||||
FORECAST(i32, "algo=arima,alpha=95,period=10,start_p=1,max_p=5,start_q=1,max_q=5")
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1,31 +0,0 @@
|
|||
---
|
||||
title: "LSTM"
|
||||
sidebar_label: "LSTM"
|
||||
---
|
||||
|
||||
本节说明 LSTM 模型的使用方法。
|
||||
|
||||
## 功能概述
|
||||
|
||||
LSTM 模型即长短期记忆网络(Long Short Term Memory)，是一种特殊的循环神经网络，适用于处理时间序列数据、自然语言处理等任务，通过其独特的门控机制，能够有效捕捉长期依赖关系，
|
||||
解决传统 RNN 的梯度消失问题，从而对序列数据进行准确预测，不过它不直接提供计算的置信区间范围结果。
|
||||
|
||||
|
||||
完整的调用 SQL 语句如下：
|
||||
```SQL
|
||||
SELECT _frowts, FORECAST(i32, "algo=lstm,alpha=95,period=10,start_p=1,max_p=5,start_q=1,max_q=5") from foo
|
||||
```
|
||||
|
||||
```json5
|
||||
{
|
||||
"rows": fc_rows, // 返回结果的行数
|
||||
"period": period, // 返回结果的周期性，同输入
|
||||
"alpha": alpha, // 返回结果的置信区间，同输入
|
||||
"algo": "lstm", // 返回结果使用的算法
|
||||
"mse": mse, // 拟合输入时间序列时候生成模型的最小均方误差(MSE)
|
||||
"res": res // 列模式的结果
|
||||
}
|
||||
```
|
||||
|
||||
### 参考文献
|
||||
- [1] Hochreiter S. Long Short-term Memory[J]. Neural Computation MIT-Press, 1997.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
---
|
||||
title: "时序基础模型"
|
||||
sidebar_label: "时序基础模型"
|
||||
---
|
||||
|
||||
TDgpt 内置了涛思数据时序基础模型和 Time-MoE 两个时序基础模型，当前 TDgpt 只整合了时序基础模型的预测能力，后续还将继续整合异常检测、数据补齐等能力。
|
||||
|
||||
## 功能概述
|
||||
|
||||
时序数据基础模型是专门训练用以处理时间序列数据预测和异常检测、数据补齐等高级时序数据分析功能的基础模型，时序基础模型继承了大模型的优良泛化能力，无需要设置复杂的输入参数，即可根据输入数据进行预测分析。
|
||||
|
||||
|序号|参数 | 说明 |
|
||||
|---|----------|------------------------|
|
||||
|1 | tdtsfm_1 | 涛思时序数据基础模型 v1.0|
|
||||
|2 | time-moe | 亿级别参数 MoE时序基础模型|
|
||||
|
||||
TDgpt 集成了时序基础模型的预测能力，无需设置模型相关参数，使用 SQL 语句即可轻松调用时序基础模型的进行预测。
|
||||
|
||||
- 通过以下 SQL 语句，调用涛思时序基础模型（tdtfsm）预测数据，并返回 10 条预测记录。
|
||||
|
||||
```SQL
|
||||
SELECT _frowts, FORECAST(i32, "algo=tdtsfm_1,rows=10") from foo
|
||||
```
|
||||
|
||||
- 通过以下 SQL 语句，调用 TimeMoE 时序基础模型预测数据，并返回 10 条预测记录。
|
||||
|
||||
```SQL
|
||||
SELECT _frowts, FORECAST(i32, "algo=timemoe-fc,rows=10") from foo
|
||||
```
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
---
|
||||
title: "MLP"
|
||||
sidebar_label: "MLP"
|
||||
---
|
||||
|
||||
本节说明 MLP 模型的使用方法。
|
||||
|
||||
## 功能概述
|
||||
|
||||
MLP（MutiLayers Perceptron，多层感知机）是一种典的神经网络模型，能够通过学习历史数据的非线性关系，
|
||||
捕捉时间序列中的模式并进行未来值预测。它通过多层全连接网络进行特征提取和映射，
|
||||
对输入的历史数据生成预测结果。由于不直接考虑趋势或季节性变化，通常需要结合数据预处理来提升效果，
|
||||
适合解决非线性和复杂的时间序列问题。
|
||||
|
||||
完整的调用SQL语句如下：
|
||||
|
||||
```SQL
|
||||
SELECT _frowts, FORECAST(i32, "algo=mlp") from foo
|
||||
```
|
||||
|
||||
```json5
|
||||
{
|
||||
"rows": fc_rows, // 返回结果的行数
|
||||
"period": period, // 返回结果的周期性，同输入
|
||||
"alpha": alpha, // 返回结果的置信区间，同输入
|
||||
"algo": "mlp", // 返回结果使用的算法
|
||||
"mse": mse, // 拟合输入时间序列时候生成模型的最小均方误差(MSE)
|
||||
"res": res // 列模式的结果
|
||||
}
|
||||
```
|
||||
|
||||
### 参考文献
|
||||
- [1]Rumelhart D E, Hinton G E, Williams R J. Learning representations by back-propagating errors[J]. nature, 1986, 323(6088): 533-536.
|
||||
- [2]Rosenblatt F. The perceptron: a probabilistic model for information storage and organization in the brain[J]. Psychological review, 1958, 65(6): 386.
|
||||
- [3]LeCun Y, Bottou L, Bengio Y, et al. Gradient-based learning applied to document recognition[J]. Proceedings of the IEEE, 1998, 86(11): 2278-2324.
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
---
|
||||
title: 预测算法
|
||||
description: 预测算法
|
||||
title: 预测分析
|
||||
description: 预测分析
|
||||
---
|
||||
|
||||
import fc_result from '../pic/fc-result.png';
|
||||
|
|
@ -45,7 +45,7 @@ algo=expr1
|
|||
```
|
||||
|
||||
1. `column_expr`：预测的时序数据列，只支持数值类型列输入。
|
||||
2. `options`：预测函数的参数。字符串类型，其中使用 K=V 方式调用算法及相关参数。采用逗号分隔的 K=V 字符串表示，其中的字符串不需要使用单引号、双引号、或转义号等符号，不能使用中文及其他宽字符。预测支持 `conf`, `every`, `rows`, `start`, `rows` 几个控制参数，其含义如下：
|
||||
2. `options`：预测函数的参数。字符串类型，其中使用 K=V 方式调用算法及相关参数。采用逗号分隔的 K=V 字符串表示，其中的字符串不需要使用单引号、双引号、或转义号等符号，不能使用中文及其他宽字符。预测支持 `conf`、`every`、`rows`、`start`、`rows` 几个控制参数，其含义如下。
|
||||
|
||||
### 参数说明
|
||||
|
||||
|
|
@ -58,12 +58,15 @@ algo=expr1
|
|||
| start | 预测结果的开始时间戳 | 输入数据最后一个时间戳加上一个采样间隔时间区间 |
|
||||
| rows | 预测结果的记录数 | 10 |
|
||||
|
||||
1. 预测查询结果新增三个伪列，具体如下：`_FROWTS`：预测结果的时间戳、`_FLOW`：置信区间下界、`_FHIGH`：置信区间上界, 对于没有置信区间的预测算法，其置信区间同预测结果
|
||||
2. 更改参数 `START`：返回预测结果的起始时间，改变起始时间不会影响返回的预测数值，只影响起始时间。
|
||||
3. `EVERY`：可以与输入数据的采样频率不同。采样频率只能低于或等于输入数据采样频率，不能**高于**输入数据的采样频率。
|
||||
4. 对于某些不需要计算置信区间的算法，即使指定了置信区间，返回的结果中其上下界退化成为一个点。
|
||||
5. rows 的最大输出值是 1024，即只能预测 1024 个值。超过输出范围的参数会被自动设置为 1024。
|
||||
6. 预测分析的输入数据行数最大值是 40000 行，即用于预测分析的历史数据不能超过 40000 行。针对部分分析模型，输入限制更严格。
|
||||
- 预测查询结果新增三个伪列，具体如下。
|
||||
- `_FROWTS`：预测结果的时间戳
|
||||
- `_FLOW`：置信区间下界
|
||||
- `_FHIGH`：置信区间上界，对于没有置信区间的预测算法，其置信区间同预测结果
|
||||
- 更改参数 `START`：返回预测结果的起始时间，改变起始时间不会影响返回的预测数值，只影响起始时间。
|
||||
- `EVERY`：可以与输入数据的采样频率不同。采样频率只能低于或等于输入数据采样频率，不能**高于**输入数据的采样频率。
|
||||
- 对于某些不需要计算置信区间的算法，即使指定了置信区间，返回的结果中其上下界退化成为一个点。
|
||||
- rows 的最大输出值是 1024，即只能预测 1024 个值。超过输出范围的参数会被自动设置为 1024。
|
||||
- 预测分析的输入数据行数最大值是 40000 行，即用于预测分析的历史数据不能超过 40000 行。针对部分分析模型，输入限制更严格。
|
||||
|
||||
|
||||
### 示例
|
||||
|
|
@ -96,8 +99,8 @@ taos> select _flow, _fhigh, _frowts, forecast(i32) from foo;
|
|||
|
||||
## 内置预测算法
|
||||
|
||||
- [arima](./02-arima.md)
|
||||
- [holtwinters](./03-holtwinters.md)
|
||||
- [ARIMA](./02-arima.md)
|
||||
- [HoltWinters](./03-holtwinters.md)
|
||||
- CES (Complex Exponential Smoothing)
|
||||
- Theta
|
||||
- Prophet
|
||||
|
|
@ -118,7 +121,7 @@ taos> select _flow, _fhigh, _frowts, forecast(i32) from foo;
|
|||
|
||||
TDgpt 在企业版中提供预测分析算法有效性评估工具 `analytics_compare`，调用该工具并设置合适的参数，能够使用 TDengine 中已经保存的数据作为回测依据，评估不同预测算法或训练模型的预测有效性。预测有效性的评估使用 `MSE` 指标作为依据，后续还将增加 `MAPE` 和 `MAE` 指标。
|
||||
|
||||
使用评估工具，需要在配置文件`` 中设置正确的参数，包括选取评估的数据范围，结果输出时间，参与评估的算法、算法相应的参数、是否生成预测结果图等配置信息。
|
||||
使用评估工具，需要在配置文件 `taosanode.ini` 中设置正确的参数，包括选取评估的数据范围、结果输出时间、参与评估的算法、算法相应的参数、是否生成预测结果图等配置信息。
|
||||
|
||||
```ini
|
||||
[forecast]
|
||||
|
|
|
|||
|
|
@ -10,16 +10,16 @@ sidebar_label: "统计学算法"
|
|||
|k|标准差倍数|选填|3|
|
||||
|
||||
```SQL
|
||||
--- 指定调用的算法为ksigma, 参数 k 为 2
|
||||
--- 指定调用的算法为ksigma，参数 k 为 2
|
||||
SELECT _WSTART, COUNT(*)
|
||||
FROM foo
|
||||
ANOMALY_WINDOW(foo.i32, "algo=ksigma,k=2")
|
||||
```
|
||||
|
||||
- IQR<sup>[2]</sup>：Interquartile range(IQR)，四分位距是一种衡量变异性的方法。四分位数将一个按等级排序的数据集划分为四个相等的部分。即 Q1（第 1 个四分位数）、Q2（第 2 个四分位数）和 Q3（第 3 个四分位数）。 $IQR=Q3-Q1$，对于 $v$, $Q1-(1.5 \times IQR) \le v \le Q3+(1.5 \times IQR)$ 是正常值，范围之外的是异常值。无输入参数。
|
||||
- IQR<sup>[2]</sup>：Interquartile range(IQR)，四分位距是一种衡量变异性的方法。四分位数将一个按等级排序的数据集划分为四个相等的部分。即 Q1（第 1 个四分位数）、Q2（第 2 个四分位数）和 Q3（第 3 个四分位数）。 $IQR=Q3-Q1$，对于 $v$，$Q1-(1.5 \times IQR) \le v \le Q3+(1.5 \times IQR)$ 是正常值，范围之外的是异常值。无输入参数。
|
||||
|
||||
```SQL
|
||||
--- 指定调用的算法为 iqr, 无参数
|
||||
--- 指定调用的算法为 iqr，无参数
|
||||
SELECT _WSTART, COUNT(*)
|
||||
FROM foo
|
||||
ANOMALY_WINDOW(foo.i32, "algo=iqr")
|
||||
|
|
@ -28,7 +28,7 @@ ANOMALY_WINDOW(foo.i32, "algo=iqr")
|
|||
- Grubbs<sup>[3]</sup>: Grubbs' test，即最大标准残差测试。Grubbs 通常用作检验最大值、最小值偏离均值的程度是否为异常，要求单变量数据集遵循近似标准正态分布。非正态分布数据集不能使用该方法。无输入参数。
|
||||
|
||||
```SQL
|
||||
--- 指定调用的算法为 grubbs, 无参数
|
||||
--- 指定调用的算法为 grubbs，无参数
|
||||
SELECT _WSTART, COUNT(*)
|
||||
FROM foo
|
||||
ANOMALY_WINDOW(foo.i32, "algo=grubbs")
|
||||
|
|
@ -44,7 +44,7 @@ ANOMALY_WINDOW(foo.i32, "algo=grubbs")
|
|||
|
||||
|
||||
```SQL
|
||||
--- 指定调用的算法为 shesd, 参数 direction 为 both，异常值比例 5%
|
||||
--- 指定调用的算法为 shesd，参数 direction 为 both，异常值比例 5%
|
||||
SELECT _WSTART, COUNT(*)
|
||||
FROM foo
|
||||
ANOMALY_WINDOW(foo.i32, "algo=shesd,direction=both,anoms=0.05")
|
||||
|
|
|
|||
|
|
@ -4,9 +4,7 @@ sidebar_label: "数据密度算法"
|
|||
---
|
||||
|
||||
### 基于数据密度/数据挖掘的检测算法
|
||||
LOF<sup>[1]</sup>: Local Outlier Factor(LOF)，局部离群因子/局部异常因子，
|
||||
是 Breunig 在 2000 年提出的一种基于密度的局部离群点检测算法，该方法适用于不同类簇密度分散情况迥异的数据。根据数据点周围的数据密集情况，首先计算每个数据点的一个局部可达密度，然后通过局部可达密度进一步计算得到每个数据点的一个离群因子，
|
||||
该离群因子即标识了一个数据点的离群程度，因子值越大，表示离群程度越高，因子值越小，表示离群程度越低。最后，输出离群程度最大的 $topK$ 个点。
|
||||
LOF<sup>[1]</sup>: Local Outlier Factor(LOF)，局部离群因子/局部异常因子，是 Breunig 在 2000 年提出的一种基于密度的局部离群点检测算法，该方法适用于不同类簇密度分散情况迥异的数据。根据数据点周围的数据密集情况，首先计算每个数据点的局部可达密度，然后通过局部可达密度进一步计算得到每个数据点的一个离群因子。该离群因子即标识了一个数据点的离群程度，因子值越大，表示离群程度越高，因子值越小，表示离群程度越低。最后，输出离群程度最大的 $topK$ 个点。
|
||||
|
||||
```SQL
|
||||
--- 指定调用的算法为LOF，即可调用该算法
|
||||
|
|
|
|||
|
|
@ -3,18 +3,32 @@ title: "机器学习算法"
|
|||
sidebar_label: "机器学习算法"
|
||||
---
|
||||
|
||||
Autoencoder<sup>[1]</sup>: TDgpt 内置使用自编码器（Autoencoder）的异常检测算法，
|
||||
对周期性的时间序列数据具有较好的检测结果。使用该模型需要针对输入时序数据进行预训练，
|
||||
同时将训练完成的模型保存在到服务目录 `ad_autoencoder` 中，然后在 SQL 语句中指定调用该算法模型即可使用。
|
||||
Autoencoder<sup>[1]</sup>: TDgpt 内置了一个使用自编码器（Autoencoder）构建的深度学习网络的异常检测模型。该异常检测模型基于 NAB 的 [art_daily_small_noise 数据集](https://raw.githubusercontent.com/numenta/NAB/master/data/artificialNoAnomaly/art_daily_small_noise.csv) 进行训练，该模型的详细信息请参见 添加机器学习模型/[准备模型](../dev/ml/index) 部分。
|
||||
|
||||
```SQL
|
||||
--- 在 options 中增加 model 的名称，ad_autoencoder_foo， 针对 foo 数据集（表）训练的采用自编码器的异常检测模型进行异常检测
|
||||
SELECT COUNT(*), _WSTART
|
||||
FROM foo
|
||||
ANOMALY_WINDOW(col1, 'algo=encoder, model=ad_autoencoder_foo');
|
||||
我们并没有将该模型预置与 `model` 目录中。需要该模型正常运行需要下载模型文件，请点击此处[下载](https://github.com/taosdata/TDengine/blob/main/tools/tdgpt/model/sample-ad-autoencoder/), 并在 `/var/lib/taos/taosanode/model/` 目录中创建子目录 `sample-ad-autoencoder`，保存下载两个模型文件，然后需要重启 taosanode 服务。相关操作原理及方式请参考[添加机器学习模型](../dev/ml) 的介绍。
|
||||
|
||||
此时 `model` 文件夹结构如下：
|
||||
|
||||
```bash
|
||||
.
|
||||
└── model
|
||||
└── sample-ad-autoencoder
|
||||
├── sample-ad-autoencoder.keras
|
||||
└── sample-ad-autoencoder.info
|
||||
```
|
||||
|
||||
```SQL
|
||||
--- 在 options 中增加 model 参数 sample-ad-autoencoder， 采用自编码器的异常检测模型进行异常检测
|
||||
SELECT _wstart, count(*)
|
||||
FROM foo anomaly_window(val, 'algo=sample_ad_model,model=sample-ad-autoencoder');
|
||||
```
|
||||
|
||||
其中的 `algo` 设置为 `sample_ad_model` 为示例异常检测模型，`model` 指定加载模型文件的信息。需要注意的是，该模型只针对训练的数据集具有较好的检测效果，针对非训练相关数据集，可能无法
|
||||
得出合适的结果。
|
||||
|
||||
|
||||
后续添加机器（深度）学习异常检测算法
|
||||
|
||||
- Isolation Forest
|
||||
- One-Class Support Vector Machines (SVM)
|
||||
- Prophet
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
---
|
||||
title: 异常检测算法
|
||||
description: 异常检测算法
|
||||
title: 异常检测
|
||||
description: 异常检测
|
||||
---
|
||||
|
||||
import ad from '../pic/anomaly-detection.png';
|
||||
import ad_result from '../pic/ad-result.png';
|
||||
|
||||
TDengine 中定义了异常（状态）窗口来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法识别确定，不是用户给定的表达式进行判定。因此，在 `WHERE` 子句中使用 `ANOMALY_WINDOW` 关键词即可调用时序数据异常检测服务，同时窗口伪列（`_WSTART`, `_WEND`, `_WDURATION`）也能够像其他时间窗口一样用于描述异常窗口的起始时间(`_WSTART`)、结束时间(`_WEND`)、持续时间(`_WDURATION`)。例如：
|
||||
TDengine 中定义了异常（状态）窗口来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于，时间窗口的起始时间和结束时间均由分析算法识别确定，不通过用户给定的表达式进行判定。因此，在 `WHERE` 子句中使用 `ANOMALY_WINDOW` 关键词即可调用时序数据异常检测服务，同时窗口伪列（`_WSTART`、`_WEND`、`_WDURATION`）也能够像其他时间窗口一样用于描述异常窗口的起始时间(`_WSTART`)、结束时间(`_WEND`)、持续时间(`_WDURATION`)。例如：
|
||||
|
||||
```SQL
|
||||
--- 使用异常检测算法 IQR 对输入列 col_val 进行异常检测。同时输出异常窗口的起始时间、结束时间、以及异常窗口内 col 列的和。
|
||||
|
|
@ -15,7 +15,7 @@ FROM foo
|
|||
ANOMALY_WINDOW(col_val, "algo=iqr");
|
||||
```
|
||||
|
||||
如下图所示，Anode 将返回时序数据异常窗口 $[10:51:30, 10:53:40]$
|
||||
如下图所示，Anode 将返回时序数据异常窗口 **[10:51:30, 10:53:40]**
|
||||
|
||||
<figure style={{textAlign: "center"}}>
|
||||
<img src={ad} alt="异常检测"/>
|
||||
|
|
@ -35,7 +35,7 @@ algo=expr1
|
|||
"}
|
||||
```
|
||||
|
||||
1. `column_name`：进行时序数据异常检测的输入数据列，当前只支持单列，且只能是数值类型，不能是字符类型（例如：`NCHAR` `VARCHAR` `VARBINARY`等类型），**不支持函数表达式**。
|
||||
1. `column_name`：进行时序数据异常检测的输入数据列，当前只支持单列，且只能是数值类型，不能是字符类型（例如：`NCHAR`、`VARCHAR`、`VARBINARY`等类型），**不支持函数表达式**。
|
||||
2. `options`：字符串。其中使用 K=V 调用异常检测算法及与算法相关的参数。采用逗号分隔的 K=V 字符串表示，其中的字符串不需要使用单引号、双引号、或转义号等符号，不能使用中文及其他宽字符。例如：`algo=ksigma,k=2` 表示进行异常检测的算法是 ksigma，该算法接受的输入参数是 2。
|
||||
3. 异常检测的结果可以作为外层查询的子查询输入，在 `SELECT` 子句中使用的聚合函数或标量函数与其他类型的窗口查询相同。
|
||||
4. 输入数据默认进行白噪声检查，如果输入数据是白噪声，将不会有任何（异常）窗口信息返回。
|
||||
|
|
@ -70,13 +70,13 @@ Query OK, 1 row(s) in set (0.028946s)
|
|||
|
||||
### 内置异常检测算法
|
||||
|
||||
分析平台内置了6个异常检查模型，分为3个类别，分别是[基于统计学的算法](./02-statistics-approach.md)、[基于数据密度的算法](./03-data-density.md)、以及[基于机器学习的算法](./04-machine-learning.md)。在不指定异常检测使用的方法的情况下，默认调用 IQR 进行异常检测。
|
||||
分析平台内置了 6 个异常检查模型，分为 3 个类别，分别是 [基于统计学的算法](./02-statistics-approach.md)、[基于数据密度的算法](./03-data-density.md)、以及[基于机器学习的算法](./04-machine-learning.md)。在不指定异常检测使用的方法的情况下，默认调用 IQR 进行异常检测。
|
||||
|
||||
### 异常检测算法有效性比较工具
|
||||
|
||||
TDgpt 提供自动化的工具对比不同数据集的不同算法监测有效性，针对异常检测算法提供查全率（recall）和查准率（precision）两个指标衡量不同算法的有效性。
|
||||
通过在配置文件中(analysis.ini)设置以下的选项可以调用需要使用的异常检测算法，异常检测算法测试用数据的时间范围、是否生成标注结果的图片、调用的异常检测算法以及相应的参数。
|
||||
调用异常检测算法比较之前，需要人工手动标注异常监测数据集的结果，即设置[anno_res]选项的数值，第几个数值是异常点，需要标注在数组中，如下测试集中，第 9 个点是异常点，我们就标注异常结果为 [9].
|
||||
调用异常检测算法比较之前，需要人工手动标注异常监测数据集的结果，即设置 [anno_res] 选项的数值，在数组中标注那几个数值是异常点。如下测试集中，第 9 个点是异常点，我们就标注异常结果为 [9].
|
||||
|
||||
```bash
|
||||
[ad]
|
||||
|
|
|
|||
|
|
@ -1,31 +0,0 @@
|
|||
---
|
||||
title: "添加机器学习模型"
|
||||
sidebar_label: "添加机器学习模型"
|
||||
---
|
||||
|
||||
## 添加具有模型的分析算法
|
||||
|
||||
基于统计学的分析算法可以直接针对输入时间序列数据进行分析，但是某些深度学习算法对于输入数据需要较长的时间训练，并且生成相应的模型。这种情况下，同一个分析算法对应不同的输入数据集有不同的分析模型。
|
||||
将具有模型的分析算法添加到 Anode 中，首先需要在 `model` 目录中建立该算法对应的目录（目录名称可自拟），将采用该算法针对不同的输入时间序列数据生成的训练模型均需要保存在该目录下，同时目录名称要在分析算法中确定，以便能够固定加载该目录下的分析模型。为了确保模型能够正常读取加载，存储的模型使用`joblib`库进行序列化保存。
|
||||
|
||||
下面以自编码器（Autoencoder）为例，说明如何添加要预先训练的模型进行异常检测。
|
||||
首先我们在 `model `目录中创建一个目录 -- `ad_autoencoder` (见上图目录结构)，该目录将用来保存所有使用自编码器训练的模型。然后，我们使用自编码器对 foo 表的时间序列数据进行训练，得到模型 针对 foo 表的模型，我们将其命名为 `ad_autoencoder_foo`，使用 `joblib`序列化该模型以后保存在 `ad_autoencoder` 目录中。如下图所示，ad_autoencoder_foo 由两个文件构成，分别是模型文件 (ad_autoencoder_foo.dat) 和模型文件描述文件 (ad_autoencoder_foo.info)。
|
||||
|
||||
```bash
|
||||
.
|
||||
└── model
|
||||
└── ad_autoencoder
|
||||
├── ad_autoencoder_foo.dat
|
||||
└── ad_autoencoder_foo.info
|
||||
|
||||
```
|
||||
|
||||
接下来说明如何使用 SQL 调用该模型。
|
||||
通过设置参数 `algo=ad_encoder` 告诉分析平台要调用自编码器算法训练的模型（自编码器算法在可用算法列表中），因此直接指定即可。此外还需要指定自编码器针对某数据集训练的确定的模型，此时我们需要使用已经保存的模型 `ad_autoencoder_foo` ，因此需要添加参数 `model=ad_autoencoder_foo` 以便能够调用该模型。
|
||||
|
||||
```SQL
|
||||
--- 在 options 中增加 model 的名称，ad_autoencoder_foo， 针对 foo 数据集（表）训练的采用自编码器的异常检测模型进行异常检测
|
||||
SELECT COUNT(*), _WSTART
|
||||
FROM foo
|
||||
ANOMALY_WINDOW(col1, 'algo=ad_encoder, model=ad_autoencoder_foo');
|
||||
```
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
---
|
||||
title: "部署 Time-MoE 模型"
|
||||
sidebar_label: "部署 Time-MoE 模型"
|
||||
---
|
||||
|
||||
# 准备环境
|
||||
|
||||
为了使用时间序列基础模型，需要在本地部署环境支持其运行。首先需要准备 Python 环境。使用 PiPy 安装必要的依赖包：
|
||||
|
||||
```shell
|
||||
pip install torch==2.4.1+cpu -f https://download.pytorch.org/whl/torch_stable.html
|
||||
pip install flask==3.0.3
|
||||
pip install transformers==4.40.0
|
||||
pip install accelerate
|
||||
```
|
||||
|
||||
# 设置服务端口和 URL 地址
|
||||
|
||||
TDgpt 安装根目录下的 `./lib/taosanalytics/time-moe.py` 文件负责 Time-MoE 模型的部署和服务，修改该问题设置合适的服务 URL 和服务端口即可。
|
||||
|
||||
```Python
|
||||
@app.route('/ds_predict', methods=['POST'])
|
||||
def time_moe():
|
||||
...
|
||||
```
|
||||
修改 `ds_predict` 为需要开启的 URL 服务地址，或者使用默认路径即可。
|
||||
|
||||
```Python
|
||||
app.run(
|
||||
host='0.0.0.0',
|
||||
port=5001,
|
||||
threaded=True,
|
||||
debug=False
|
||||
)
|
||||
```
|
||||
其中的 port 修改为希望开启的端口，重启脚本即可。
|
||||
|
||||
|
||||
# 启动部署 Python 脚本
|
||||
|
||||
```shell
|
||||
nohup Python time-moe.py > custom_output.out 2>&1 &
|
||||
```
|
||||
|
||||
第一次启动脚本会从 huggingface 自动加载[2亿参数时序数据基础模型](https://huggingface.co/Maple728/TimeMoE-200M)。该模型是 Time-MoE 200M参数版本，如果您需要部署参数规模更小的版本请将 `time-moe.py` 文件中 `'Maple728/TimeMoE-200M'` 修改为 `Maple728/TimeMoE-50M`，此时将加载 [0.5亿参数版本模型](https://huggingface.co/Maple728/TimeMoE-50M)。
|
||||
|
||||
如果加载失败，请尝试执行如下命令切换为国内镜像下载模型。
|
||||
|
||||
```shell
|
||||
export HF_ENDPOINT=https://hf-mirror.com
|
||||
```
|
||||
|
||||
再执行脚本：
|
||||
```shell
|
||||
nohup Python time-moe.py > custom_output.out 2>&1 &
|
||||
```
|
||||
|
||||
显示如下，则说明加载成功
|
||||
```shell
|
||||
Running on all addresses (0.0.0.0)
|
||||
Running on http://127.0.0.1:5001
|
||||
```
|
||||
|
||||
# 验证服务是否正常
|
||||
|
||||
使用 Shell 命令可以验证服务是否正常
|
||||
|
||||
```shell
|
||||
curl 127.0.0.1:5001/ds_predict
|
||||
```
|
||||
如果看到如下返回表明服务正常
|
||||
|
||||
```html
|
||||
<!doctype html>
|
||||
<html lang=en>
|
||||
<title>405 Method Not Allowed</title>
|
||||
<h1>Method Not Allowed</h1>
|
||||
<p>The method is not allowed for the requested URL.</p>
|
||||
```
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
---
|
||||
title: "添加模型服务"
|
||||
sidebar_label: "添加模型服务"
|
||||
---
|
||||
|
||||
TDgpt 默认已经内置了 Time-MoE 模型的支持功能， 执行 `show anodes full`，可以看到 Time-MoE 的预测服务 `timemoe-fc`，现在只适配了预测服务，所以其后增加了后缀名 fc。
|
||||
```shell
|
||||
taos> show anodes full;
|
||||
id | type | algo |
|
||||
============================================================================
|
||||
1 | anomaly-detection | grubbs |
|
||||
1 | anomaly-detection | lof |
|
||||
1 | anomaly-detection | shesd |
|
||||
1 | anomaly-detection | ksigma |
|
||||
1 | anomaly-detection | iqr |
|
||||
1 | anomaly-detection | sample_ad_model |
|
||||
1 | forecast | arima |
|
||||
1 | forecast | holtwinters |
|
||||
1 | forecast | tdtsfm_1 |
|
||||
1 | forecast | timemoe-fc |
|
||||
```
|
||||
|
||||
正确调用 Time-MoE 模型的时间序列数据预测能力，需要您在本地或云端已经部署完成 Time-MoE 服务（需要执行 `./taosanode/lib/taosanalytics/time-moe.py` 的脚本部署 Time-MoE
|
||||
服务。具体过程请参见 [部署 Time-MoE 服务](./02-deploy-timemoe)）。
|
||||
|
||||
修改 `/etc/taos/taosanode.ini` 配置文件中如下部分：
|
||||
|
||||
```ini
|
||||
[tsfm-service]
|
||||
timemoe-fc = http://192.168.2.90:5001/ds_predict
|
||||
```
|
||||
|
||||
设置正确的 IP 和端口，以及服务地址。
|
||||
|
||||
然后重启 taosnode 服务，并更新服务端算法缓存列表 `update all anodes`，之后即可通过 SQL 语句调用 Time-MoE 的时间序列数据预测服务。
|
||||
|
||||
```sql
|
||||
SELECT FORECAST(i32, 'algo=timemoe-fc')
|
||||
FROM foo;
|
||||
```
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
---
|
||||
sidebar_label: 添加时序基础模型
|
||||
title: 添加时序基础模型
|
||||
---
|
||||
|
||||
本章主要介绍如何通过 TDgpt 使用开源时序基础模型，包括Time-MoE 等的时序功能。
|
||||
|
||||
|
||||
```mdx-code-block
|
||||
import DocCardList from '@theme/DocCardList';
|
||||
import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
|
||||
|
||||
<DocCardList items={useCurrentSidebarCategory().items}/>
|
||||
```
|
||||
|
|
@ -88,7 +88,7 @@ SELECT _flow, _fhigh, _frowts, FORECAST(col_name, "algo=myfc")
|
|||
FROM foo;
|
||||
```
|
||||
|
||||
如果是第一次启动该 Anode, 请按照 [运维管理指南](../../management/) 里的步骤先将该 Anode 添加到 TDengine 系统中。
|
||||
如果是第一次启动该 Anode, 请按照 [运维管理指南](../../03-management) 里的步骤先将该 Anode 添加到 TDengine 系统中。
|
||||
|
||||
### 单元测试
|
||||
|
||||
|
|
@ -8,7 +8,7 @@ sidebar_label: "异常检测"
|
|||
|
||||
### 输出约定
|
||||
`execute` 方法执行完成后的返回值是长度与 `self.list` 相同的数组，数组位置 -1 的标识异常值点。
|
||||
> 例如：对于输入测量值序列 $[2, 2, 2, 2, 100]$， 假设 100 是异常点，那么方法返回的结果数组则为 $[1, 1, 1, 1, -1]$。
|
||||
> 例如：对于输入测量值序列 $[2, 2, 2, 2, 100]$，假设 100 是异常点，那么方法返回的结果数组则为 $[1, 1, 1, 1, -1]$。
|
||||
|
||||
|
||||
### 示例代码
|
||||
|
|
@ -57,7 +57,7 @@ SELECT COUNT(*) FROM foo ANOMALY_WINDOW(col, 'algo=myad')
|
|||
|
||||
### 单元测试
|
||||
|
||||
在测试目录`taosanalytics/test`中的 anomaly_test.py 中增加单元测试用例或添加新的测试文件。框架中使用了 Python Unit test 包。
|
||||
在测试目录 `taosanalytics/test` 中的 anomaly_test.py 中增加单元测试用例或添加新的测试文件。框架中使用了 Python Unit test 包。
|
||||
|
||||
```python
|
||||
def test_myad(self):
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
---
|
||||
title: "添加机器学习模型"
|
||||
sidebar_label: "添加机器学习模型"
|
||||
---
|
||||
|
||||
机器/深度学习模型一般要求训练集样本量足够大，才能取得不错的预测效果。训练过程要消耗一定量的时间和计算资源，并需要根据输入的数据进行定期的训练以及更新模型。TDgpt 内置了 Torch 和 Keras 机器学习库。所有使用 Torch 或 Keras 开发的模型均可以驱动运行。
|
||||
|
||||
本章介绍将预训练完成的机器/深度学习分析模型添加到 TDgpt 中的方法。
|
||||
|
||||
## 准备模型
|
||||
|
||||
推荐将模型保存在默认的保存目录（`/usr/local/taos/taosanode/model/`）中，也可以在目录中建立下一级目录，用以保存模型。下面使用 Keras 开发的基于自编码器(auto encoder) 的异常检测模型添加到 TDgpt 为例讲解整个流程。
|
||||
|
||||
该模型在 TDgpt 系统中名称为 'sample_ad_model'。
|
||||
训练该模型的代码见：[training_ad_model.py](https://github.com/taosdata/TDengine/tree/main/tools/tdgpt/taosanalytics/misc/training_ad_model.py)。
|
||||
该模型训练使用了 NAB 的 [art_daily_small_noise 数据集](https://raw.githubusercontent.com/numenta/NAB/master/data/artificialNoAnomaly/art_daily_small_noise.csv)。
|
||||
训练完成得到的模型保存成为了两个文件，点击 [此处](https://github.com/taosdata/TDengine/blob/main/tools/tdgpt/model/sample-ad-autoencoder/) 下载该模型文件，模型文件说明如下。
|
||||
|
||||
```bash
|
||||
sample-ad-autoencoder.keras 模型文件，默认 keras 模型文件格式
|
||||
sample-ad-autoencoder.info 模型附加参数文件，采用了 joblib 格式保存
|
||||
```
|
||||
|
||||
## 保存在合适位置
|
||||
|
||||
然后在 `/usr/local/taos/taosanode/model` 文件目录下建立子目录 `sample-ad-autoencoder`，用以保存下载两个模型文件。此时 `model` 文件夹结构如下：
|
||||
|
||||
```bash
|
||||
.
|
||||
└── model
|
||||
└── sample-ad-autoencoder
|
||||
├── sample-ad-autoencoder.keras
|
||||
└── sample-ad-autoencoder.info
|
||||
```
|
||||
|
||||
## 添加模型适配代码
|
||||
|
||||
需要在 taosanalytics 目录下添加加载该模型并进行适配的 Python 代码。适配并行运行的代码见 [autoencoder.py](https://github.com/taosdata/TDengine/blob/main/tools/tdgpt/taosanalytics/algo/ad/autoencoder.py)。
|
||||
为了便于方便，我们已经将该文件保存在该目录，所以您在执行 `show anodes full` 命令时候，能够看见该算法模型。
|
||||
|
||||
下面详细说明该代码的逻辑。
|
||||
|
||||
```python
|
||||
class _AutoEncoderDetectionService(AbstractAnomalyDetectionService):
|
||||
name = 'sample_ad_model' # 通过 show 命令看到的算法的名称，在此处定义
|
||||
desc = "sample anomaly detection model based on auto encoder"
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
|
||||
self.table_name = None
|
||||
self.mean = None
|
||||
self.std = None
|
||||
self.threshold = None
|
||||
self.time_interval = None
|
||||
self.model = None
|
||||
|
||||
# 模型文件保存的文件夹名称，如果您更改了文件夹名称，在此处需要同步修改，以确保代码可以正确加载模型文件
|
||||
self.dir = 'sample-ad-autoencoder'
|
||||
|
||||
self.root_path = conf.get_model_directory()
|
||||
|
||||
self.root_path = self.root_path + f'/{self.dir}/'
|
||||
|
||||
# 检查代码中指定的模型文件路径是否存在
|
||||
if not os.path.exists(self.root_path):
|
||||
app_logger.log_inst.error(
|
||||
"%s ad algorithm failed to locate default module directory:"
|
||||
"%s, not active", self.__class__.__name__, self.root_path)
|
||||
else:
|
||||
app_logger.log_inst.info("%s ad algorithm root path is: %s", self.__class__.__name__,
|
||||
self.root_path)
|
||||
|
||||
def execute(self):
|
||||
"""异常检测主体执行函数"""
|
||||
if self.input_is_empty():
|
||||
return []
|
||||
|
||||
if self.model is None:
|
||||
raise FileNotFoundError("not load autoencoder model yet, or load model failed")
|
||||
|
||||
# 初始化输入进行异常检测的数据
|
||||
array_2d = np.reshape(self.list, (len(self.list), 1))
|
||||
df = pd.DataFrame(array_2d)
|
||||
|
||||
# 使用 z-score 进行归一化处理
|
||||
normalized_list = (df - self.mean.value) / self.std.value
|
||||
seq = create_sequences(normalized_list.values, self.time_interval)
|
||||
|
||||
# 进行模型推理
|
||||
pred_list = self.model.predict(seq)
|
||||
|
||||
# 计算 MAE 损失值
|
||||
mae_loss = np.mean(np.abs(pred_list - seq), axis=1)
|
||||
mae = mae_loss.reshape((-1))
|
||||
|
||||
# 大于阈值的设置为异常点
|
||||
anomalies = mae > self.threshold
|
||||
|
||||
# data i is an anomaly if samples [(i - timesteps + 1) to (i)] are anomalies
|
||||
ad_indices = []
|
||||
for data_idx in range(self.time_interval - 1,
|
||||
len(normalized_list) - self.time_interval + 1):
|
||||
if np.all(anomalies[data_idx - self.time_interval + 1: data_idx]):
|
||||
ad_indices.append(data_idx)
|
||||
|
||||
# 变换结果，符合输出的约定，支持分析完成
|
||||
return [-1 if i in ad_indices else 1 for i in range(len(self.list))]
|
||||
|
||||
def set_params(self, params):
|
||||
"""在此函数中进行模型的加载操作，然后在 executor 中调用"""
|
||||
if "model" not in params:
|
||||
raise ValueError("model needs to be specified")
|
||||
|
||||
name = params['model']
|
||||
|
||||
# 拼装模型文件的全路径，此处有两个文件，一个模型主体文件，一个信息文件
|
||||
module_file_path = f'{self.root_path}/{name}.keras'
|
||||
module_info_path = f'{self.root_path}/{name}.info'
|
||||
|
||||
app_logger.log_inst.info("try to load module:%s", module_file_path)
|
||||
|
||||
# 因为保存成为 keras 格式，所以调用 keras API 加载模型文件
|
||||
if os.path.exists(module_file_path):
|
||||
self.model = keras.models.load_model(module_file_path)
|
||||
else:
|
||||
app_logger.log_inst.error("failed to load autoencoder model file: %s", module_file_path)
|
||||
raise FileNotFoundError(f"{module_file_path} not found")
|
||||
|
||||
# 加载辅助信息文件
|
||||
if os.path.exists(module_info_path):
|
||||
info = joblib.load(module_info_path)
|
||||
else:
|
||||
app_logger.log_inst.error("failed to load autoencoder model file: %s", module_file_path)
|
||||
raise FileNotFoundError("%s not found", module_info_path)
|
||||
|
||||
# 初始化模型推理的辅助信息到对象中
|
||||
if info is not None:
|
||||
self.mean = info["mean"]
|
||||
self.std = info["std"]
|
||||
self.threshold = info["threshold"]
|
||||
self.time_interval = info["timesteps"]
|
||||
|
||||
app_logger.log_inst.info(
|
||||
"load ac module success, mean: %f, std: %f, threshold: %f, time_interval: %d",
|
||||
self.mean[0], self.std[0], self.threshold, self.time_interval
|
||||
)
|
||||
else:
|
||||
app_logger.log_inst.error("failed to load %s model", name)
|
||||
raise RuntimeError(f"failed to load model {name}")
|
||||
```
|
||||
|
||||
## 使用 SQL 调用模型
|
||||
该模型已经预置在系统中，您可通过 `show anodes full` 直接查看。一个新的算法适配完成以后，需要重新启动 taosanode，并执行命令 `update all anodes` 更新 mnode 的算法列表。
|
||||
|
||||
- 通过设置参数 `algo=sample_ad_model`，告诉 TDgpt 调用自编码器算法训练的模型（该算法模型在可用算法列表中）。
|
||||
- 通过设置参数 `model=sample-ad-autoencoder`，告诉自编码器加载特定的模型。
|
||||
|
||||
```SQL
|
||||
--- 在 options 中增加 model 参数 sample-ad-autoencoder， 针对 foo 数据集（表）训练的采用自编码器的异常检测模型进行异常检测
|
||||
SELECT _wstart, count(*)
|
||||
FROM foo anomaly_window(val, 'algo=sample_ad_model,model=sample-ad-autoencoder');
|
||||
```
|
||||
|
|
@ -0,0 +1,185 @@
|
|||
---
|
||||
title: "部署时序基础模型"
|
||||
sidebar_label: "部署时序基础模型"
|
||||
---
|
||||
|
||||
由众多研究机构及企业开源时序基础模型极大地简化了时序数据分析的复杂程度，在数据分析算法、机器学习和深度学习模型之外，
|
||||
提供了一个时间序列数据高级分析的新选择。本章介绍部署并使用开源时序基础模型（Time Series Foundation Model, TSFM）。
|
||||
|
||||
TDgpt 已经内置原生支持了两个时序基础模型涛思时序基础模型 (TDtsfm v1.0) 和 Time-MoE。但是越来越多的开源或商业时序模型需要
|
||||
用户按需将其整合到 TDgpt 中，本章将以支持 Time-MoE 模型为例，说明如何将一个独立部署的 MaaS 服务整合到 TDgpt 中，
|
||||
并通过 SQL 语句调用其时序数据分析能力。
|
||||
|
||||
本章介绍如何本地部署 [Time-MoE](https://github.com/Time-MoE/Time-MoE) 时序基础模型并与 TDgpt 适配后，提供时序数据预测服务。
|
||||
|
||||
# 准备环境
|
||||
|
||||
为了使用时间序列基础模型，需要在本地部署环境支持其运行。首先需要准备 Python 环境，使用 PiPy 安装必要的依赖包：
|
||||
|
||||
```shell
|
||||
pip install torch==2.4.1+cpu -f https://download.pytorch.org/whl/torch_stable.html
|
||||
pip install flask==3.0.3
|
||||
pip install transformers==4.40.0
|
||||
pip install accelerate
|
||||
```
|
||||
您可以使用 TDgpt 的虚拟环境，也可以新创建一个虚拟环境，使用该虚拟环境之前，确保正确安装了上述依赖包。
|
||||
|
||||
|
||||
# 设置本地时序基础模型服务地址
|
||||
|
||||
TDgpt 安装根目录下的 `./lib/taosanalytics/time-moe.py` 文件负责 Time-MoE 模型的部署和服务，修改文件设置合适的服务 URL。
|
||||
|
||||
```python
|
||||
@app.route('/ds_predict', methods=['POST'])
|
||||
def time_moe():
|
||||
...
|
||||
```
|
||||
|
||||
修改 `ds_predict` 为需要开启的 URL 服务地址，或者使用默认值亦可。
|
||||
|
||||
```Python
|
||||
app.run(
|
||||
host='0.0.0.0',
|
||||
port=5001,
|
||||
threaded=True,
|
||||
debug=False
|
||||
)
|
||||
```
|
||||
其中的 port 修改为希望开启的端口，包括使用默认值亦可。完成之后重启服务。
|
||||
|
||||
# 启动部署 Python 脚本
|
||||
|
||||
```shell
|
||||
nohup python time-moe.py > service_output.out 2>&1 &
|
||||
```
|
||||
|
||||
第一次启动脚本会从 huggingface 自动加载 [2 亿参数模型](https://huggingface.co/Maple728/TimeMoE-200M)。该模型是 Time-MoE 200M参数版本，如果您需要部署参数规模更小的版本请将 `time-moe.py` 文件中 `'Maple728/TimeMoE-200M'` 修改为 `Maple728/TimeMoE-50M`，此时将加载 [0.5 亿参数模型](https://huggingface.co/Maple728/TimeMoE-50M)。
|
||||
|
||||
如果加载失败，请尝试执行如下命令切换为国内镜像下载模型。
|
||||
|
||||
```shell
|
||||
export HF_ENDPOINT=https://hf-mirror.com
|
||||
```
|
||||
|
||||
再执行脚本：
|
||||
```shell
|
||||
nohup python time-moe.py > service_output.out 2>&1 &
|
||||
```
|
||||
|
||||
检查 `service_output.out` 文件，有如下输出，则说明加载成功
|
||||
```shell
|
||||
Running on all addresses (0.0.0.0)
|
||||
Running on http://127.0.0.1:5001
|
||||
```
|
||||
|
||||
# 验证服务是否正常
|
||||
|
||||
使用 Shell 命令可以验证服务是否正常
|
||||
|
||||
```shell
|
||||
curl 127.0.0.1:5001/ds_predict
|
||||
```
|
||||
|
||||
如果看到如下返回信息表明服务正常，自此部署 Time-MoE 完成。
|
||||
|
||||
```html
|
||||
<!doctype html>
|
||||
<html lang=en>
|
||||
<title>405 Method Not Allowed</title>
|
||||
<h1>Method Not Allowed</h1>
|
||||
<p>The method is not allowed for the requested URL.</p>
|
||||
```
|
||||
|
||||
# 添加模型适配代码
|
||||
您可用参考 https://github.com/taosdata/TDengine/blob/main/tools/tdgpt/taosanalytics/algo/fc/timemoe.py 文件进行 MaaS 服务的适配。我们适配Time-MoE提供预测服务。
|
||||
|
||||
```python
|
||||
class _TimeMOEService(AbstractForecastService):
|
||||
# 模型名称，用户可根据需求定义，该名称也是后续调用该模型的 key
|
||||
name = 'timemoe-fc'
|
||||
|
||||
# 说明信息
|
||||
desc = ("Time-MoE: Billion-Scale Time Series Foundation Models with Mixture of Experts; "
|
||||
"Ref to https://github.com/Time-MoE/Time-MoE")
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
|
||||
self.table_name = None
|
||||
|
||||
# 读取 taosanode.ini 配置文件中的该模型对应的服务的地址信息，如果未读到，使用默认地址，用户可根据需求确定
|
||||
service_host = conf.get_tsfm_service("timemoe-fc")
|
||||
if service_host is not None:
|
||||
self.service_host = service_host
|
||||
else:
|
||||
self.service_host = 'http://127.0.0.1:5001/timemoe'
|
||||
|
||||
self.headers = {'Content-Type': 'application/json'}
|
||||
|
||||
|
||||
def execute(self):
|
||||
"""分析主程序方法"""
|
||||
if self.list is None or len(self.list) < self.period:
|
||||
raise ValueError("number of input data is less than the periods")
|
||||
|
||||
if self.rows <= 0:
|
||||
raise ValueError("fc rows is not specified yet")
|
||||
|
||||
# let's request the gpt service
|
||||
data = {"input": self.list, 'next_len': self.rows}
|
||||
try:
|
||||
# 请求时序基础模型服务
|
||||
response = requests.post(self.service_host, data=json.dumps(data), headers=self.headers)
|
||||
except Exception as e:
|
||||
app_logger.log_inst.error(f"failed to connect the service: {self.service_host} ", str(e))
|
||||
raise e
|
||||
|
||||
# 检查返回值
|
||||
if response.status_code == 404:
|
||||
app_logger.log_inst.error(f"failed to connect the service: {self.service_host} ")
|
||||
raise ValueError("invalid host url")
|
||||
elif response.status_code != 200:
|
||||
app_logger.log_inst.error(f"failed to request the service: {self.service_host}, reason: {response.text}")
|
||||
raise ValueError(f"failed to request the service, {response.text}")
|
||||
|
||||
pred_y = response.json()['output']
|
||||
|
||||
res = {
|
||||
"res": [pred_y]
|
||||
}
|
||||
|
||||
# 按照约定要求，组装预测分析结果
|
||||
insert_ts_list(res["res"], self.start_ts, self.time_step, self.rows)
|
||||
return res
|
||||
```
|
||||
|
||||
将代码添加到 `/usr/local/taos/taosanode/lib/taosanalytics/algo/fc` 路径下。您可以在该路径下找到 `timemoe.py` 的文件，该文件即为系统内置的支持 `Time-MoE` 的适配文件。
|
||||
|
||||
TDgpt 默认已经内置了 Time-MoE 模型的支持，能够使用 Time-MoE 的能力进行时序数据预测分析， 执行 `show anodes full`，可以看到 Time-MoE 的预测服务 `timemoe-fc`。
|
||||
|
||||
# 设置模型服务地址
|
||||
|
||||
修改 `/etc/taos/taosanode.ini` 配置文件中[tsfm-service]部分：
|
||||
|
||||
```ini
|
||||
[tsfm-service]
|
||||
timemoe-fc = http://127.0.0.1:5001/ds_predict
|
||||
```
|
||||
|
||||
添加服务的地址。此时的 `key` 是模型的名称，此时即为 `timemoe-fc`，`value` 是 Time-MoE本地服务的地址：http://127.0.0.1:5001/ds_predict。
|
||||
|
||||
然后重启 taosnode 服务，并更新服务端算法缓存列表 `update all anodes`，之后即可通过 SQL 语句调用 Time-MoE 的时间序列数据预测服务。
|
||||
|
||||
# SQL 调用基础模型预测能力
|
||||
```sql
|
||||
SELECT FORECAST(i32, 'algo=timemoe-fc')
|
||||
FROM foo;
|
||||
```
|
||||
|
||||
# 添加其他开源时序基础模型
|
||||
模型在本地部署服务以后，在TDgpt 中注册的逻辑相似。只需要修改类名称和模型服务名称(Key)、设置正确的服务地址即可。
|
||||
|
||||
|
||||
# 参考文献
|
||||
|
||||
- Time-MoE: Billion-Scale Time Series Foundation Models with Mixture of Experts. [[paper](https://arxiv.org/abs/2409.16040)] [[GitHub Repo](https://github.com/Time-MoE/Time-MoE)]
|
||||
|
|
@ -2,17 +2,17 @@
|
|||
title: "开发者指南"
|
||||
sidebar_label: "开发者指南"
|
||||
---
|
||||
TDgpt 是一个可扩展的时序数据高级分析平台，用户遵循简易的步骤就能将自己开发的分析算法添加到分析平台, 各种应用就可以通过SQL语句直接调用, 让高级分析算法的使用门槛降到几乎为零。目前 TDpgt 平台只支持使用 Python 语言开发的分析算法。
|
||||
Anode 采用类动态加载模式，在启动的时候扫描特定目录内满足约定条件的所有代码文件，并将其加载到系统中。因此，开发者只需要遵循以下几步就能完成新算法的添加工作：
|
||||
TDgpt 是一个可扩展的时序数据高级分析智能体，用户遵循简易的步骤就能将自己开发的分析算法添加到分析平台，各种应用就可以通过 SQL 语句直接调用，让高级分析算法的使用门槛降到几乎为零。目前 TDpgt 平台只支持使用 Python 语言开发的分析算法。
|
||||
Anode 采用类动态加载模式，在启动的时候扫描特定目录内满足约定条件的所有代码文件，并将其加载到系统中。因此，开发者只需要遵循以下几步就能完成新算法的添加工作。
|
||||
1. 开发完成符合要求的分析算法类
|
||||
2. 将代码文件放入对应目录，然后重启 Anode
|
||||
3. 使用SQL命令"CREATE ANODE"，将 Anode 添加到 TDengine
|
||||
3. 使用 SQL 命令 `CREATE ANODE`，将 Anode 添加到 TDengine
|
||||
|
||||
此时就完成了新算法的添加工作，之后应用就可以直接使用SQL语句调用新算法。得益于 TDgpt 与 TDengine主进程 `taosd` 的松散耦合，Anode算法升级对 `taosd` 完全没有影响。应用系统只需要调整对应的SQL语句调用新（升级的）算法，就能够快速完成分析功能和分析算法的升级。
|
||||
完成新算法添加工作后，就可以直接使用 SQL 语句调用新算法。得益于 TDgpt 与 TDengine 主进程 `taosd` 的松散耦合，Anode算法升级对 `taosd` 完全没有影响。应用系统只需要调整对应的 SQL 语句调用新（升级的）算法，就能够快速完成分析功能和分析算法的升级。
|
||||
|
||||
这种方式能够按需扩展分析算法，极大地拓展 TDgpt 的适应范围，用户可以按需将更契合业务场景的、更准确的（预测、异常检测）分析算法动态嵌入到 TDgpt，并通过 SQL 语句进行调用。在基本不用更改应用系统代码的前提下，就能够快速完成分析功能的平滑升级。
|
||||
这种方式能够按需扩展分析算法，极大地拓展 TDgpt 的适应范围，用户可以按需将更契合业务场景的、更准确的（预测、异常检测）分析算法动态嵌入到 TDgpt，并通过 SQL 语句调用。在基本不用更改应用系统代码的前提下，就能够快速完成分析功能的平滑升级。
|
||||
|
||||
以下内容将说明如何将分析算法添加到 Anode 中并能够通过SQL语句进行调用。
|
||||
以下内容将说明如何将分析算法添加到 Anode 中并能够通过 SQL 语句进行调用。
|
||||
|
||||
## 目录结构
|
||||
Anode的主要目录结构如下图所示
|
||||
|
|
@ -49,7 +49,7 @@ Anode的主要目录结构如下图所示
|
|||
|
||||
### 类命名规范
|
||||
|
||||
Anode采用算法自动加载模式，因此只识别符合命名约定的 Python 类。需要加载的算法类名称需要以下划线 `_` 开始并以 `Service` 结尾。例如：`_KsigmaService` 是 KSigma 异常检测算法类。
|
||||
Anode 采用算法自动加载模式，因此只识别符合命名约定的 Python 类。需要加载的算法类名称需要以下划线 `_` 开始并以 `Service` 结尾。例如：`_KsigmaService` 是 KSigma 异常检测算法类。
|
||||
|
||||
### 类继承约定
|
||||
|
||||
|
|
@ -5,10 +5,9 @@ sidebar_label: "常见问题"
|
|||
|
||||
### 1. 安装过程中编译 uWSGI 失败，如何处理
|
||||
TDgpt 安装过程中需要在本地编译 uWSGI，某些环境的 Python（例如：anaconda）安装 uWSGI 会出现冲突导致编译失败，安装流程因此无法继续下去。这种情况下可以尝试在安装过程中忽略 uWSGI的安装。
|
||||
由于忽略了 uWSGI 安装，后续启动 taosasnode 服务的时候，需要手动输入命令进行启动 `python3.10 /usr/local/taos/taosanode/lib/taosanalytics/app.py` 。 执行该命令的时候请确保使用了虚拟环境中的 Python 程序才能加载依赖库。
|
||||
由于忽略了 uWSGI 安装，后续启动 taosasnode 服务的时候，需要手动输入命令进行启动 `python3.10 /usr/local/taos/taosanode/lib/taosanalytics/app.py`。 执行该命令的时候请确保使用了虚拟环境中的 Python 程序才能加载依赖库。
|
||||
|
||||
|
||||
### 2. 创建 anode 失败，返回指定服务无法访问
|
||||
### 2. 创建 Anode 失败，返回指定服务无法访问
|
||||
|
||||
```bash
|
||||
taos> create anode '127.0.0.1:6090';
|
||||
|
|
@ -16,18 +15,18 @@ taos> create anode '127.0.0.1:6090';
|
|||
DB error: Analysis service can't access[0x80000441] (0.117446s)
|
||||
```
|
||||
|
||||
请务必使用 `curl` 命令检查 anode 服务是否正常。`curl '127.0.0.1:6090'` 正常的 anode 服务会返回以下结果。
|
||||
请务必使用 `curl` 命令检查 Anode 服务是否正常。执行 `curl '127.0.0.1:6090'` 后，正常的 Anode 服务会返回以下结果。
|
||||
|
||||
```bash
|
||||
TDengine© Time Series Data Analytics Platform (ver 1.0.x)
|
||||
```
|
||||
|
||||
如果出现下面的结果，表示 anode 服务不正常。
|
||||
如果出现下面的结果，表示 Anode 服务不正常。
|
||||
```bash
|
||||
curl: (7) Failed to connect to 127.0.0.1 port 6090: Connection refused
|
||||
```
|
||||
|
||||
如果 anode 服务启动/运行不正常，请检查 uWSGI 的运行日志 `/var/log/taos/taosanode/taosanode.log`，检查其中的错误信息，根据错误信息解决响应的问题。
|
||||
如果 Anode 服务启动/运行不正常，请检查 uWSGI 的运行日志 `/var/log/taos/taosanode/taosanode.log`，检查其中的错误信息，根据错误信息解决响应的问题。
|
||||
|
||||
>请勿使用 systemctl status taosanode 检查 taosanode 是否正常
|
||||
|
||||
|
|
@ -37,9 +36,10 @@ taos> select _frowts,forecast(current, 'algo=arima, alpha=95, wncheck=0, rows=20
|
|||
|
||||
DB error: Analysis service can't access[0x80000441] (60.195613s)
|
||||
```
|
||||
|
||||
数据分析默认超时时间是 60s，出现这个问题的原因是输入数据分析过程超过默认的最长等待时间，请尝试采用限制数据输入范围的方式将输入数据规模减小或者更换分析算法再次尝试。
|
||||
|
||||
### 4. 返回结果出现非法 JSON 格式错误 (Invalid json format)
|
||||
|
||||
从 anode 返回到 TDengine 的分析结果有误，请检查 anode 运行日志 `/var/log/taos/taosanode/taosanode.app.log`，以便于获得具体的错误信息。
|
||||
从 Anode 返回到 TDengine 的分析结果有误，请检查 Anode 运行日志 `/var/log/taos/taosanode/taosanode.app.log`，以便于获得具体的错误信息。
|
||||
|
||||
|
|
|
|||
|
|
@ -108,5 +108,4 @@ description: 3.3.6.0 版本说明
|
|||
21. 修复：当子查询未返回结果且其中包含 LIMIT 1 关键词时，可能导致父查询的结果出现异常或不准确
|
||||
22. 修复：当表名中包含 * 时，taosc 会出现崩溃问题。
|
||||
23. 修复：在 Windows 平台下，使用 JDBC PreparedStatement 写入数据时，关闭 PreparedStatement 可能导致 JVM 崩溃[#30106](https://github.com/taosdata/TDengine/issues/30106)
|
||||
24. 修复：使用 Websocket 参数绑定批量写入数据时，子表名含中文会产生乱码[#29998](https://github.com/taosdata/TDengine/issues/29998)
|
||||
|
||||
|
|
|
|||
|
|
@ -430,16 +430,16 @@ static const SSysDbTableSchema userTransactionDetailSchema[] = {
|
|||
|
||||
static const SSysDbTableSchema anodesSchema[] = {
|
||||
{.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
|
||||
{.name = "url", .bytes = TSDB_ANALYTIC_ANODE_URL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
|
||||
{.name = "status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
|
||||
{.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = true},
|
||||
{.name = "update_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = true},
|
||||
{.name = "url", .bytes = TSDB_ANALYTIC_ANODE_URL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
|
||||
{.name = "status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
|
||||
{.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = false},
|
||||
{.name = "update_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = false},
|
||||
};
|
||||
|
||||
static const SSysDbTableSchema anodesFullSchema[] = {
|
||||
{.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
|
||||
{.name = "type", .bytes = TSDB_ANALYTIC_ALGO_TYPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
|
||||
{.name = "algo", .bytes = TSDB_ANALYTIC_ALGO_NAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
|
||||
{.name = "type", .bytes = TSDB_ANALYTIC_ALGO_TYPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
|
||||
{.name = "algo", .bytes = TSDB_ANALYTIC_ALGO_NAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
|
||||
};
|
||||
|
||||
static const SSysDbTableSchema filesetsFullSchema[] = {
|
||||
|
|
|
|||
|
|
@ -52,6 +52,9 @@ class _AutoEncoderDetectionService(AbstractAnomalyDetectionService):
|
|||
|
||||
# normalize input data using z-score
|
||||
normalized_list = (df - self.mean.value) / self.std.value
|
||||
if len(normalized_list) < self.time_interval:
|
||||
raise ValueError("input data is too short")
|
||||
|
||||
seq = create_sequences(normalized_list.values, self.time_interval)
|
||||
|
||||
# Get test MAE loss.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,120 @@
|
|||
# encoding:utf-8
|
||||
"""train the model for anomaly detection"""
|
||||
import joblib
|
||||
import keras
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from keras.api import layers
|
||||
|
||||
from matplotlib import pyplot as plt
|
||||
from taosanalytics.util import create_sequences
|
||||
|
||||
|
||||
def get_training_data():
|
||||
""" load the remote training data """
|
||||
url_str = ("https://raw.githubusercontent.com/numenta/NAB/master/data/artificialNoAnomaly/"
|
||||
"art_daily_small_noise.csv")
|
||||
df_small_noise = pd.read_csv(url_str, parse_dates=True, index_col="timestamp")
|
||||
return df_small_noise
|
||||
|
||||
|
||||
def do_train_model():
|
||||
""" do train the model by using input data """
|
||||
df_small_noise = get_training_data()
|
||||
time_steps = 288
|
||||
|
||||
training_mean = df_small_noise.mean()
|
||||
training_std = df_small_noise.std()
|
||||
|
||||
info = {
|
||||
"mean": training_mean,
|
||||
"std": training_std,
|
||||
"timesteps": time_steps,
|
||||
}
|
||||
|
||||
df_training_value = (df_small_noise - training_mean) / training_std
|
||||
print("Number of training samples:", len(df_training_value))
|
||||
|
||||
x_train = create_sequences(df_training_value.values, time_steps)
|
||||
print("Training input shape: ", x_train.shape)
|
||||
|
||||
model = keras.Sequential(
|
||||
[
|
||||
layers.Input(shape=(x_train.shape[1], x_train.shape[2])),
|
||||
layers.Conv1D(
|
||||
filters=32,
|
||||
kernel_size=7,
|
||||
padding="same",
|
||||
strides=2,
|
||||
activation="relu",
|
||||
),
|
||||
layers.Dropout(rate=0.2),
|
||||
layers.Conv1D(
|
||||
filters=16,
|
||||
kernel_size=7,
|
||||
padding="same",
|
||||
strides=2,
|
||||
activation="relu",
|
||||
),
|
||||
layers.Conv1DTranspose(
|
||||
filters=16,
|
||||
kernel_size=7,
|
||||
padding="same",
|
||||
strides=2,
|
||||
activation="relu",
|
||||
),
|
||||
layers.Dropout(rate=0.2),
|
||||
layers.Conv1DTranspose(
|
||||
filters=32,
|
||||
kernel_size=7,
|
||||
padding="same",
|
||||
strides=2,
|
||||
activation="relu",
|
||||
),
|
||||
layers.Conv1DTranspose(filters=1, kernel_size=7, padding="same"),
|
||||
]
|
||||
)
|
||||
|
||||
model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss="mse")
|
||||
model.summary()
|
||||
|
||||
history = model.fit(
|
||||
x_train,
|
||||
x_train,
|
||||
epochs=50,
|
||||
batch_size=128,
|
||||
validation_split=0.1,
|
||||
callbacks=[
|
||||
keras.callbacks.EarlyStopping(monitor="val_loss", patience=5, mode="min")
|
||||
],
|
||||
)
|
||||
|
||||
print(history)
|
||||
|
||||
# Get train MAE loss.
|
||||
x_train_pred = model.predict(x_train)
|
||||
train_mae_loss = np.mean(np.abs(x_train_pred - x_train), axis=1)
|
||||
|
||||
plt.hist(train_mae_loss, bins=50)
|
||||
plt.xlabel("Train MAE loss")
|
||||
plt.ylabel("No of samples")
|
||||
plt.show()
|
||||
|
||||
# Get reconstruction loss threshold.
|
||||
threshold = np.max(train_mae_loss)
|
||||
print("Reconstruction error threshold: ", threshold)
|
||||
|
||||
model.save('../../model/sample-ad-autoencoder/sample-ad-autoencoder.keras')
|
||||
|
||||
info["threshold"] = threshold
|
||||
joblib.dump(info, '../../model/sample-ad-autoencoder/sample-ad-autoencoder.info')
|
||||
|
||||
plt.plot(x_train[0])
|
||||
plt.plot(x_train_pred[0])
|
||||
plt.show()
|
||||
|
||||
print("save model successfully")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
do_train_model()
|
||||
Loading…
Reference in New Issue