Integrating Agentic AI with Existing Machine Learning Pipelines

将智能体AI与现有机器学习流水线集成 - MachineLearningMastery.com

将智能体AI与现有机器学习流水线集成

作者：

Iván Palomares Carrascosa

于

2026年8月24日

分类：

人工智能

2

分享

文章

在本文中，你将学习如何将经典机器学习流水线与智能体AI系统结合，构建一个混合的自主客户留存工作流程。

我们将涵盖的主题包括：

• 如何使用scikit-learn生成合成数据集并训练随机森林分类器进行客户流失预测。

• 如何设计一个智能体AI系统——包含工具和基于LLM的推理核心——该系统能够解释机器学习预测并自主采取行动。

• 如何将机器学习流水线与智能体连接起来，构建一个完整的端到端Python应用程序。

介绍

在构建生产就绪的AI应用时，智能体AI和机器学习流水线远非不兼容。事实上，将它们视为同一枚硬币的两面已成为一种现代基础架构模式：它推动了从被动预测分析向自主决策和行动的转变。

传统机器学习流水线在各种复杂程度的模式识别任务中表现出色，但其基本形式完全是被动反应的。而智能体AI系统则专注于主动性：结合预测性机器学习模型，它们可以基于这些模型产生的洞察进行规划、使用工具，并在几乎没有人工指导的情况下解决实际应用场景。

在本文中，我们将向你展示如何弥合被动机器学习模型与主动AI智能体之间的差距。我们将构建一个轻量级、免费、可运行的Python流水线，该流水线：

• 基于使用scikit-learn构建的经典机器学习模型预测客户流失。

• 将获得的预测结果传递给配备先进LLM的智能体，使其能够自主推理并执行不同的客户留存策略。

先决条件

整个编码教程可以在Google Colab或本地Jupyter笔记本中免费运行，前提是已安装并导入必要的库。

如果你使用Colab，根据撰写时的信息，你可能需要手动安装的唯一库是Groq：

!pip install groq

1

!

pip

install

groq

确保还导入以下内容：

import numpy as np from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split from groq import Groq

3

4

import

numpy

as

np

from

sklearn

.

ensemble

RandomForestClassifier

model_selection

train_test_split

由于Groq——当今最强大的开源LLM提供商之一——需要API密钥，请务必在其网站上注册并在此处创建自己的API密钥。你需要将其集成到你的笔记本或Google Colab账户中。下面的代码设计为从Google Colab左侧边栏的“Secrets”部分读取API密钥：在那里创建一个名为GROQ_API_KEY的新秘密变量，并将实际的Groq API密钥粘贴到“value”字段中。

以下说明将帮助你将新添加的API密钥注入到程序中：

import os from google.colab import userdata # 将Colab秘密注入标准环境变量 os.environ["GROQ_API_KEY"] = userdata.get('GROQ_API_KEY')

5

os

google

colab

userdata

将 Colab 秘密注入标准环境变量

environ

[

"GROQ_API_KEY"

]

=

get

(

'GROQ_API_KEY'

)

分步指南

在完成前提条件设置后，我们将开始构建经典的机器学习管道——用于客户流失预测——随后将通过整合智能体AI原理和工具来扩展该管道。

首先，我们需要一个客户数据集来输入我们的机器学习模型。在此示例中，我们将合成生成包含500个客户的自有数据集，每个客户由两个预测特征和一个表示客户是否容易流失的目标变量进行描述。两个输入特征分别是客户的月度支出和支持工单数量：这两个都是客户保留或放弃品牌的现实世界预测因素。请注意代码使用numpy函数引入随机噪声，使人工生成的数据看起来更真实：

========================================== # 0. 合成数据集生成 # ========================================== # 生成由两个输入特征描述的500个客户的真实数据集 np.random.seed(42) n_samples = 500 # 特征1：客户月度支出（在10美元到150美元之间均匀分布） spend = np.random.uniform(10, 150, n_samples) # 特征2：客户发出的支持工单（泊松分布，平均1.5个工单） tickets = np.random.poisson(lam=1.5, size=n_samples) # 生成目标变量/二元分类（流失）： # 流失风险随工单数量增加而增加，随支出增加而降低 base_churn_risk = (tickets * 0.15) + np.where(spend < 30, 0.3, 0) - np.where(spend > 100, 0.2, 0) # 添加一些随机噪声使数据集更真实 base_churn_risk += np.random.normal(0, 0.1, n_samples) base_churn_risk = np.clip(base_churn_risk, 0, 1) # 0 = 保留，1 = 流失（阈值为0.5） y = (base_churn_risk > 0.5).astype(int) X = np.column_stack((spend, tickets))

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

==========================================

0. 合成数据集生成

生成由两个输入特征描述的500个客户的真实数据集

random

seed

42

n_samples

500

特征1：客户月度支出（在10美元到150美元之间均匀分布）

spend

uniform

,

150

特征2：客户发出的支持工单（泊松分布，平均1.5个工单）

tickets

poisson

lam

1.5

size

生成目标变量/二元分类（流失）：

流失风险随工单数量增加而增加，随支出增加而降低

base_churn_risk

tickets *

0.15

+

where

<

30

0.3

0

-

100

0.2

添加一些随机噪声使数据集更真实

+=

normal

0.1

clip

0 = 保留，1 = 流失（阈值为0.5）

y

0.5

astype

int

X

column_stack

接下来，我们通过将数据集拆分为训练集和测试集，并训练一个随机森林集成分类器来构建一个简单的经典机器学习管道。在继续之前，我们会在测试集上验证模型的性能：

========================================== # 1. 经典机器学习流程（预测性 -> 分类） # ========================================== # 训练/测试数据划分 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 在更大数据集上训练预测分类器 print(f"正在训练机器学习模型，使用 {len(X_train)} 条记录...") ml_model = RandomForestClassifier(n_estimators=50, max_depth=5, random_state=42) ml_model.fit(X_train, y_train) print(f"测试集模型准确率: {ml_model.score(X_test, y_test)*100:.1f}%\n")

1. 经典机器学习流程（预测性 -> 分类）

训练/测试数据划分

X_train

X_test

y_train

y_test

test_size

random_state

在更大数据集上训练预测分类器

print

f

"正在训练机器学习模型，使用 {len(X_train)} 条记录..."

ml_model

n_estimators

50

max_depth

fit

"测试集模型准确率: {ml_model.score(X_test, y_test)*100:.1f}%\n"

测试数据的预测结果：

正在训练机器学习模型，使用 400 条记录... 测试集模型准确率: 91.0%

训练

机器学习

模型

400

条记录

准确率

测试

集

:

91.0

%

91% 的准确率对于我们的需求来说已经足够，因此我们将继续将代理整合到流程中。

我们为代理创建的第一个要素是它的“双手”——换句话说，就是代理可以使用的工具，这些工具能帮助代理通过推理和决策执行特定操作。虽然在现实场景中，这些工具通常通过API调用或其他协议与外部组件、服务和数据库进行交互，但在这里我们通过简单的打印消息来模拟两个面向客户的操作：

========================================== # 2. 工具（代理的“双手”） # ========================================== # 这是代理在现实世界中可以触发的两个函数 # 通过参数化打印消息来模拟和仿真实际操作 def send_discount(customer_id): return f"[操作执行] 已向客户 {customer_id} 发送20%折扣码。" def schedule_support_call(customer_id): return f"[操作执行] 已将客户 {customer_id} 转接给人工代理进行检查。"

2. 工具（代理的“双手”）

这是代理在现实世界中可以触发的两个函数。

通过参数化打印消息来模拟和仿真实际操作

def

send_discount

customer_id

return

"[操作执行] 已向客户 {customer_id} 发送20%折扣码。"

schedule_support_call

"[操作执行] 已将客户 {customer_id} 转接给人工代理进行检查。"

虽然让代理调用其可访问的工具是其部署后产生影响的方式，但真正体现“智能”的地方在于认知核心——负责代理的推理和执行过程：

========================================== # 3. 代理的认知（推理与执行） # ========================================== class 保留代理: def __init__(self): print("正在连接到 Groq API（Llama 3.3 70B）...\n") # 自动获取 GROQ_API_KEY 环境变量 self.client = Groq() self.model_name = "llama-3.3-70b-versatile" def _reason(self, prompt): # 我们使用标准的聊天完成 API chat_completion = self.client.chat.completions.create( messages=[ { "role": "system", "content": "您是一个自主的客户保留代理。您必须只输出一个单词：'call' 或 'discount'。" }, { "role": "user", "content": prompt } ], model=self.model_name, temperature=0.0, # 零温度确保确定性、逻辑性选择 ) return chat_completion.choices[0].message.content.strip().lower() def process_customer(self, customer_id, features): print(f"--- 正在处理客户 {customer_id} ---") # 步骤 A：从经典 ML 管道获取预测 churn_prob = ml_model.predict_proba([features])[0][1] spend_val, tickets_val = features print(f"ML 预测: {churn_prob*100:.0f}% 离网风险。") # 步骤 B：自主防护机制 - 仅当风险较高时采取行动 if churn_prob < 0.5: return "代理决策: 无需操作。客户风险较低。\n" # 步骤 C：代理推理（上下文注入） # Groq 的 70B 模型轻松处理此逻辑，包括本用例所需的简单数学推理 prompt = ( f"客户 {customer_id} 有 {churn_prob*100:.0f}% 的离网风险。 " f"他们目前每月消费 ${spend_val:.2f}，已提交 {int(tickets_val)} 个支持工单。 " f"业务规则：如果客户提交了超过 2 个支持工单，他们感到沮丧，需要人工‘电话’。 " f"否则，他们只是价格敏感，我们应该发送‘折扣’。" ) # LLM "思考" 并决定工具 decision = self._reason(prompt) print(f"代理推理输出: '{decision}'") # 步骤 D：工具执行（路由到特定代理的"手"） if "call" in decision: result = schedule_support_call(customer_id) elif "discount" in decision: result = send_discount(customer_id) else: result = f"[操作失败] 代理返回了无法识别的工具名称: {decision}" return result + "\n"

24

25

26

27

28

29

31

32

33

34

35

36

37

38

39

40

41

43

44

45

46

47

48

49

51

52

53

54

55

56

57

58

59

60

61

62

3. 代理的认知（推理与执行）

class

保留代理

__init__

self

"正在连接到 Groq API（Llama 3.3 70B）...\n"

自动获取 GROQ_API_KEY 环境变量

client

model_name

"llama-3.3-70b-versatile"

_reason

prompt

我们使用标准的聊天完成 API

chat_completion

chat

completions

create

messages

{

"role"

"system"

"content"

"您是一个自主的客户保留代理。您必须只输出一个单词：'call' 或 'discount'。"

}

"user"

temperature

0.0

零温度确保确定性、逻辑性选择

choices

message

content

strip

lower

process_customer

features

"--- 正在处理客户 {customer_id} ---"

步骤 A：从经典 ML 管道获取预测

churn_prob

predict_proba

spend_val

tickets_val

"ML 预测: {churn_prob*100:.0f}% 离网风险。"

步骤 B：自主防护机制 - 仅当风险较高时采取行动

if

"代理决策: 无需操作。客户风险较低。\n"

步骤 C：代理推理（上下文注入）

Groq 提供的 70B 模型可以轻松处理这种逻辑，包括本用例所需的简单数学推理。

"客户 {customer_id} 有 {churn_prob*100:.0f}% 的流失风险。"

"他们目前每月支出 ${spend_val:.2f}，并提交了 {int(tickets_val)} 个支持工单。"

"业务规则：如果客户提交了超过 2 个支持工单，说明他们感到沮丧，需要人工电话跟进。"

"否则，他们只是对价格敏感，我们应该发送折扣方案。"

LLM 进行"思考"并决定使用哪个工具

decision

"代理推理输出：'{decision}'"

步骤 D：工具执行（路由到特定代理的"处理流程"）

"call"

result

elif

"discount"

else

"[操作失败] 代理返回了未识别的工具名称：{decision}"

"\n"

让我们简要分析上述代码：

• 通过面向对象编程，我们为特定领域创建了一个专用代理，称为 RetentionAgent。重要的是，该代理连接了一个作为其认知引擎的 LLM。我们特别选择了由 Groq 提供的 Llama 3.3 模型，该模型轻量级到足以在笔记本中运行，但又足够强大以可靠地执行预期的推理任务。

• 代理的 _reason() 方法为 LLM 准备提示并配置适合我们场景的模型设置，例如将温度设为零以获得确定性输出。

• 代理的 process_customer() 方法与早期构建的机器学习模型进行对接。它获取客户流失预测并构建一个提示，将预测与其他客户数据一起注入，询问 LLM 应该采取什么行动。触发代理行动的核心决策逻辑在此处处理。

当所有构建模块就位后，是时候运行我们的混合 ML-代理管道了。我们实例化代理并在三个示例客户上进行测试。仔细关注这三个客户的档案，并将其与代理推理方法中定义的 LLM 提示进行交叉参考：

========================================== # 4. 运行管道 # ========================================== agent = RetentionAgent() # 在几个特定档案上测试管道以观察路由效果 # 测试用例 1：中等消费，低工单 -> 模型可能预测低/中等风险 # 如果高风险，代理应选择折扣方案 print(agent.process_customer(customer_id=101, features=[25.50, 1])) # 测试用例 2：中等消费，高工单 -> 模型预测高风险，代理应安排电话 print(agent.process_customer(customer_id=102, features=[45.00, 5])) # 测试用例 3：高消费，零工单 -> 模型预测极低风险，代理跳过处理 print(agent.process_customer(customer_id=103, features=[140.00, 0]))

4. 运行管道

agent

在几个特定档案上测试管道以观察路由效果

测试用例 1：中等消费，低工单 -> 模型可能预测低/中等风险

如果高风险，代理应选择折扣方案

101

25.50

测试用例 2：中等消费，高工单 -> 模型预测高风险，代理应安排电话

102

45.00

测试用例 3：高消费，零工单 -> 模型预测极低风险，代理跳过处理

103

140.00

输出：

连接到 Groq API（Llama 3.3 70B）... --- 处理客户 101 --- 机器学习预测：57% 流失风险。代理推理输出：'折扣' [操作已执行] 向客户 101 发送了 20% 的折扣码。 --- 处理客户 102 --- 机器学习预测：88% 流失风险。代理推理输出：'电话' [操作已执行] 将客户 102 转接给人工代理进行跟进。 --- 处理客户 103 --- 机器学习预测：0% 流失风险。代理决策：无需操作。客户风险较低。

结果与预期一致。需要说明的是，模型选择会影响结果：我们选用了一个适合此任务的 LLM，并将其温度参数设为零以避免非确定性行为（这在当前场景中是不希望出现的）。如果你选择其他模型，结果可能会有所不同。

结语

在本文中，我们逐步构建了一个混合流程，将经典机器学习用于客户流失预测，与能够将这些预测转化为自主推理、决策和操作流程的代理 AI 解决方案相结合。这展示了如何在企业及组织环境中弥合现代 AI 解决方案两大核心支柱之间的差距。

更多相关内容

• 使用 TensorFlow 和 NumPy 实现自定义操作
• 你在这里看到的是 LLM：语言模型的集成…
• 使用 Scikit-Learn 和 Statsmodels 进行回归分析
• 机器学习建模流程的简明介绍
• 使用流程自动化机器学习工作流…
• 使用 Scikit-Learn 进行高级特征工程…