14、机器学习实战：从模型训练到数据处理与流式分析

最新推荐文章于 2025-12-11 12:02:01 发布

flink9streamer

最新推荐文章于 2025-12-11 12:02:01 发布

阅读量45

点赞数

CC 4.0 BY-SA版权

分类专栏： AIoT实战：从边缘到云端文章标签：机器学习模型训练超参数优化

本文链接：https://blog.youkuaiyun.com/flink9streamer/article/details/152699650

AIoT实战：从边缘到云端专栏收录该内容

16 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

机器学习实战：从模型训练到数据处理与流式分析

1. 模型训练与超参数优化

在机器学习中，我们常常需要训练模型并寻找最优的超参数。以下是具体步骤：
1. 训练模型：

model = clf.fit(X_train,y_train)

预测测试数据集的响应：

y_pred = clf.predict(X_test)

打印最优的超参数集：

from pprint import pprint
pprint(model.best_estimator_.get_params())

这个算法易于实现，与传统方法不同，我们通过多次运行代码来寻找最佳的估计器，而不是像之前那样随机选择算法并只运行一次代码获取结果。这种方式可以自动化实验过程并跟踪结果。

2. 处理物料清单（BOM）变化

2.1 BOM 变化对模型的影响

物料清单（BOM）包含构成设备的各种组件，如电阻器、芯片等。典型的物联网产品生命周期约为 10 年，在此期间产品可能会发生变化，例如组件制造商可能会停产某个芯片系列。外包制造商通常会对电路板布局进行 BOM 优化，但这可能会改变设备的质量，如传感器的灵敏度或设备的使用寿命。这会影响训练好的模型，对剩余使用寿命计算和预测性维护模型产生显著影响。

2.2 利用数据库跟踪变化

我们可以使用数据库来跟踪这些变化。具体操作如下：
1. 准备工作：
- 安装 Docker。
- 使用 Docker 拉取 SQL Server 镜像：

docker pull mcr.microsoft.com/mssql/server:2017-latest

- 运行 Docker 容器：

docker run -e 'ACCEPT_EULA=Y' -e 'MSSQL_AGENT_ENABLED=true' \
-e 'MSSQL_PID=Standard' -e 'SA_PASSWORD=Password!' \ 
-p 1433:1433 --name sqlserver_1 \ 
-d mcr.microsoft.com/mssql/server:2017-latest

创建数据库和表：
- 安装 VS Code 的 mssql 插件，使用 Docker 文件中的用户名和密码连接到数据库。
- 点击左面板中的新 SQL Server 工具，点击加号（+）按钮，按照向导创建数据库连接，输入 localhost 作为 ado.net 连接字符串，用户名输入 sa ，密码输入 Password! 。
- 运行以下 SQL 语句：

CREATE DATABASE MLTracking
GO

USE MLTracking
GO
CREATE TABLE Product( 
  productid INTEGER IDENTITY(1,1) NOT NULL PRIMARY KEY, 
  productName VARCHAR(255) NOT NULL, 
  BeginLife Datetime NOT NULL, 
  EndLife Datetime NULL 
); 
GO
CREATE TABLE RUL( 
  RULid INTEGER IDENTITY(1,1) NOT NULL PRIMARY KEY, 
  ProductId int,
  TotalRULDays int, 
  DateCalculated datetime not null 
) 
GO

使用 Python 插入数据：
- 安装 pyodbc ：

pip install pyodbc

- 创建新的 Python 脚本，执行以下操作：

import pyodbc 

# 连接到数据库
conn = pyodbc.connect('Driver={SQL Server};'
 'Server=localhost;'
 'Database=MLTracking;'
 'uid=sa;'
 'pwd=Password!;')

# 创建数据库连接游标
cursor = conn.cursor()

# 插入产品和制造日期
cursor.execute('''
  INSERT INTO MLTracking.dbo.Product (Product,BeginLife)
  VALUES
  ('Smoke Detector 9000',GETDATE())
  ''')
conn.commit()

# 插入剩余使用寿命信息
cursor.execute('''
  INSERT INTO MLTracking.dbo.RUL (ProductId,TotalRULDays,DateCalculated )
  VALUES
  (1,478,GETDATE())
  ''')
conn.commit()

通过数据库，我们可以跟踪模型的结果，插入和更新模型的相关信息。跟踪设备的使用寿命可以为模型提供真实世界的反馈，帮助我们确定何时需要重新训练模型。

3. 使用 sklearn 构建机器学习管道

3.1 管道的优势

sklearn 管道包使我们能够轻松管理特征工程和建模的多个阶段。机器学习实验不仅仅是训练模型，还包括数据清洗、转换和特征工程等多个步骤。这些常见任务可以构建成一个管道，方便我们在实验中尝试不同的变体，使复杂的步骤变得简单且可复用。

3.2 构建管道的步骤

导入所需的库：

import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.compose import ColumnTransformer

从 Delta Lake 导入数据：

train = spark.sql("select * from engine").toPandas()
train.drop(columns="label" , inplace=True)
test = spark.sql("select * from engine_test2").toPandas()

创建转换器：

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())])
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', 
                              fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))])

提取必要的特征并创建处理器：

numeric_features = train.select_dtypes(include=['int64', 'float64']).columns
categorical_features = train.select_dtypes(include=['object']).drop(['cycle'], 
                                             axis=1).columns
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)])

创建随机森林管道步骤：

rf = Pipeline(steps=[('preprocessor', preprocessor),
                     ('classifier', RandomForestClassifier())])

拟合分类器：

rf.fit(X_train, y_train)

进行分类：

y_pred = rf.predict(X_test)

构建机器学习管道可以简化复杂操作，提高代码的可复用性。在管道中，我们为数值数据使用了缩放器，为分类数据使用了独热编码，并使用随机森林分类器进行建模。

3.3 调整管道以提高准确率

我们可以通过调整管道步骤来提高模型的准确率。以下是具体代码：

from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, 
GradientBoostingClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis

classifiers = [
    KNeighborsClassifier(3),
    DecisionTreeClassifier(),
    RandomForestClassifier(),
    AdaBoostClassifier(),
    GradientBoostingClassifier()
    ]

for classifier in classifiers:
    pipe = Pipeline(steps=[('preprocessor', preprocessor),
                      ('classifier', classifier)])
    pipe.fit(X_train, y_train) 
    print(classifier)
    print("model score: %.3f" % pipe.score(X_test, y_test))

通过上述代码，我们可以尝试不同的分类器，并比较它们的得分，从而选择最优的模型。

4. 使用 Spark 和 Kafka 进行流式机器学习

4.1 准备工作

Kafka 是一个实时流式消息中心，结合 Databricks 的流式数据处理和机器学习能力，我们可以实现近乎实时的强大机器学习。具体准备步骤如下：
1. 在云市场中启动 Confluent 和 Databricks，创建可弹性扩展的 Kafka 和 Spark 系统。
2. 访问 Confluent 网站（https://confluent.cloud），使用云市场中设置的用户名和密码登录，创建集群。
3. 在集群中点击 API 访问，创建 API 访问密钥，并记录用户名和密码。
4. 在 Topics 部分创建两个主题： Turbofan 和 Turbofan_RUL 。
5. 创建 Python 文件测试新主题：

from confluent_kafka import Producer
from datetime import datetime as dt
import json
import time

producer = Producer({
    'bootstrap.servers': "pkc-lgwgm.eastus2.azure.confluent.cloud:9092",
    'security.protocol': 'SASL_SSL',
    'sasl.mechanism': "PLAIN",
    "sasl.username": "",
    "sasl.password": "",
    'auto.offset.reset': 'earliest'
})

data = json.dumps({'Record_ID':1,'Temperature':'100','Vibration':120,
                   'age':1000, 'time':time.time()})
producer.send('TurboFan', data)

4.2 流式处理步骤

将 Kafka 数据流式传输到 Databricks：

from pyspark.sql.types import StringType
import json 
import pandas as pd
from sklearn.linear_model import LogisticRegression

df.readStream.format("kafka") 
.option("kafka.bootstrap.servers", "...azure.confluent.cloud:9092") 
.option("subscribe", "TurboFan") 
.option("startingOffsets", "latest") 
.option("kafka.security.protocol","SASL_SSL") 
.option("kafka.sasl.mechanism", "PLAIN") 
.option("kafka.sasl.jaas.config", 
"kafkashaded.org.apache.kafka.common.security.plain.PlainLoginModule required 
username=\"Kafka UserName\" password=\"Kafka Password\";") 
.load() 

.select($"value") 
.withColumn("Value", $"value".cast(StringType))

指定 JSON 文件中的字段并序列化为对象：

val jsDF1 = kafka1.select( get_json_object($"Value", 
"$.Temperature").alias("Temp"), 
get_json_object($"Value", "$.Vibration").alias("Vibration") 
,get_json_object($"Value", "$.age").alias("Age") 
)

定义推理函数：

def score(row):
    d = json.loads(row)
    p = pd.DataFrame.from_dict(d, orient = "index").transpose() 
    pred = model.predict_proba(p.iloc[:,0:10])[0][0]
    result = {'Record_ID': d['Record_ID'], 'pred': pred }
    return str(json.dumps(result))

使用 UDF 进行推理并将结果保存到 DataFrame：

df = df.selectExpr("CAST(value AS STRING)")
score_udf = udf(score, StringType()) 
df = df.select( score_udf("value").alias("value"))

将故障设备写入另一个 DataFrame：

failure_df = df.filter(df.value > 0.9)

将 DataFrame 流式传输回 Kafka 作为新主题并写入结果：

query = df.writeStream.format("kafka") 
.option("kafka.bootstrap.servers", "{external_ip}:9092") 
.option("topic", "Turbofan_Failure") 
.option("kafka.security.protocol","SASL_SSL") 
.option("kafka.sasl.mechanism", "PLAIN") 
.option("kafka.sasl.jaas.config", 
"kafkashaded.org.apache.kafka.common.security.plain.PlainLoginModule required 
username=\"Kafka UserName\" password=\"Kafka Password\";") 
.option("checkpointLocation", "/temp").start()

Kafka 可以处理大量数据，数据被摄入 Kafka 后发送到 Spark 进行处理，结果再发送回 Kafka。我们可以将数据推送到数据库、数据湖和微服务中。此外，我们还可以将数据流式传输到警报系统，通过创建 Kafka 消费者实现：

from confluent_kafka import Consumer

conf = {'bootstrap.servers': "host1:9092,host2:9092",
        'group.id': "foo",
        'kafka.security.protocol':'SASL_SSL', 
        'kafka.sasl.mechanism':'PLAIN', 
        'kafka.sasl.jaas.config': 
'kafkashaded.org.apache.kafka.common.security.plain.PlainLoginModule required 
username=\"Kafka UserName\" password=\"Kafka Password\";',
        'auto.offset.reset': 'smallest'}

running = True
consumer = Consumer(conf)
consumer.subscribe('Turbofan_Failure')

while running:
    msg = consumer.poll(timeout=1.0)
    if msg is None: continue
    msg_process(msg)

def msg_process(msg):
    pass

5. 使用 Kafka 的 KStreams 和 KTables 丰富数据

5.1 背景与准备

在物联网中，我们常常需要包含外部数据源，如影响设备性能的天气数据或附近其他设备的数据。使用 Kafka KSQL Server 可以轻松实现这一点。具体准备步骤如下：
1. 在 Confluent Cloud ksqlDB 门户中，进入 ksqlDB 选项卡并添加应用程序，完成设置后获得 KSQL 查询编辑器。
2. 确保有之前设置的流式 TurboFan 数据，并运行 weatherstreamer.py Kafka 天气流 Python 脚本。
3. 进入 ksqlDB 的查询编辑器，用于创建流和表。

5.2 操作步骤

使用天气主题创建 KTable：

CREATE TABLE users (
     TurboFanNum BIGINT PRIMARY KEY,
     temperature BIGINT,
     humidity BIGINT
   ) WITH (
     KAFKA_TOPIC = 'weather', 
     VALUE_FORMAT = 'JSON'
   );

将 TurboFan 主题转换为数据流：

CREATE STREAM TurboFan (
    TurboFanNum BIGINT,
    HoursLogged BIGINT,
    VIBRATIONSCORE BIGINT
  ) WITH (
    KAFKA_TOPIC='TurboFan',
    VALUE_FORMAT='JSON'
  );

将表和流连接到新主题：

CREATE STREAM TurboFan_Enriched AS
  SELECT 
     TurboFan.TurboFanNum, 
     HoursLogged, 
     VIBRATIONSCORE, 
     temperature,
     humidity 
  FROM TurboFan
    LEFT JOIN Weather ON Weather.TurboFanNum = TurboFan.TurboFanNum
  EMIT CHANGES;

KSQL Server 基于 Kafka Streams API 构建，可以实现实时的数据丰富和转换。我们将一个流转换为最近键的表，更新表中的值，创建流视图，并将表和流连接生成新的流。此外，我们还可以使用 SQL 的语义，如分组、计数和求和，通过窗口操作按时间片段获取数据。例如，查询平均温度是否超过 100 度：

CREATE STREAM TurboFan_ToHot AS
  SELECT 
     TurboFan.TurboFanNum, 
     avg(temperature)
  FROM TurboFan_Enriched
  WINDOW TUMBLING (SIZE 20 SECONDS)
  GROUP BY TurboFanNum
  HAVING avg(temperature) > 100
  EMIT CHANGES;

通过以上步骤，我们可以利用 Kafka 的 KStreams 和 KTables 丰富数据，为机器学习提供更全面的信息。

综上所述，我们介绍了从模型训练、超参数优化、处理 BOM 变化、构建机器学习管道到使用 Spark 和 Kafka 进行流式机器学习以及利用 Kafka 的 KStreams 和 KTables 丰富数据的一系列方法和步骤。这些技术可以帮助我们更好地处理和分析数据，提高机器学习模型的性能和实用性。

6. 技术总结与应用场景

6.1 各项技术的总结

技术名称	主要作用	关键操作步骤
模型训练与超参数优化	训练模型并找到最优超参数	1. 训练模型： `model = clf.fit(X_train,y_train)` 2. 预测测试集响应： `y_pred = clf.predict(X_test)` 3. 打印最优超参数： `pprint(model.best_estimator_.get_params())`
处理 BOM 变化	应对物料清单变化对模型的影响	1. 安装 Docker 并运行 SQL Server 容器 2. 创建数据库和表 3. 使用 Python 插入产品和剩余使用寿命信息
使用 sklearn 构建机器学习管道	简化特征工程和建模流程	1. 导入库 2. 导入数据 3. 创建转换器和处理器 4. 构建随机森林管道并拟合、分类
使用 Spark 和 Kafka 进行流式机器学习	实现近乎实时的机器学习处理	1. 准备 Confluent 和 Databricks 环境 2. 创建 Kafka 主题并测试 3. 将 Kafka 数据流式传输到 Databricks 处理后再传回 Kafka
使用 Kafka 的 KStreams 和 KTables 丰富数据	引入外部数据源丰富数据	1. 准备 KSQL 查询编辑器 2. 创建 KTable 和数据流 3. 连接表和流生成新主题

6.2 应用场景分析

工业物联网 ：在工业生产中，设备的物料清单可能会发生变化，通过处理 BOM 变化的方法可以及时调整模型，保证对设备剩余使用寿命的准确预测。同时，使用 Spark 和 Kafka 进行流式机器学习可以实时监测设备状态，及时发现故障并发出警报。
智能建筑 ：例如智能烟雾探测器，在模型训练后，通过数据库跟踪其性能和使用寿命，当预测到设备接近使用寿命时及时提醒更换。利用 Kafka 的 KStreams 和 KTables 可以结合天气数据等外部信息，更准确地评估设备性能。

6.3 技术流程总结

graph LR
    A[数据准备] --> B[模型训练与超参数优化]
    B --> C[处理 BOM 变化]
    C --> D[构建机器学习管道]
    D --> E[流式机器学习处理]
    E --> F[数据丰富]

7. 未来趋势与挑战

7.1 未来趋势

自动化程度提高 ：随着技术的发展，模型训练和超参数优化将更加自动化，减少人工干预，提高效率。
实时处理能力增强 ：流式机器学习将在更多领域得到应用，对实时数据处理的要求也会越来越高，Kafka 和 Spark 的结合将更加紧密。
数据融合加深 ：使用 Kafka 的 KStreams 和 KTables 丰富数据的方法将不断发展，更多类型的外部数据源将被引入，为机器学习提供更全面的信息。

7.2 面临挑战

数据安全 ：在流式处理和数据丰富过程中，涉及大量敏感数据，如何保证数据的安全性是一个重要挑战。
模型可解释性 ：随着模型复杂度的增加，模型的可解释性变得越来越困难，需要开发新的方法来解释模型的决策过程。
资源管理 ：在大规模数据处理和实时计算中，如何合理管理资源，提高系统的性能和效率也是一个亟待解决的问题。

8. 总结与建议

8.1 总结

本文详细介绍了机器学习从模型训练到数据处理与流式分析的一系列技术和方法，包括模型训练与超参数优化、处理 BOM 变化、构建机器学习管道、使用 Spark 和 Kafka 进行流式机器学习以及利用 Kafka 的 KStreams 和 KTables 丰富数据。这些技术可以帮助我们更好地处理和分析数据，提高机器学习模型的性能和实用性。