建模与部署 on 扎塔-Zata

sklearn使用教程

Tue, 24 Jun 2025 10:12:15 +0800

pipeline的构建

1. Pipeline基本概念与规则

Pipeline是Scikit-learn中的一个重要工具，它可以将多个数据处理和模型训练步骤串联在一起。构建Pipeline需要遵循以下规则：

Pipeline由(名字, 估计器)对的列表构成
除最后一个步骤外，其他步骤必须是转换器（transformer）
转换器必须具有fit_transform()方法
最后一个步骤可以是估计器（estimator）

2. Pipeline运行机制

执行流程：

关键代码示例：

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer

# 基础Pipeline构建
num_pipeline = Pipeline([
 ('imputer', SimpleImputer(strategy="median")),
 ('std_scaler', StandardScaler()),
])

# 执行转换
data_num_tr = num_pipeline.fit_transform(data_num)

3. `自定义转换器`

为了处理Pandas DataFrame，我们需要创建自定义转换器：

from sklearn.base import BaseEstimator, TransformerMixin

class DataFrameSelector(BaseEstimator, TransformerMixin):
 def __init__(self, attribute_names):
 self.attribute_names = attribute_names

 def fit(self, X, y=None):
 return self

 def transform(self, X):
 return X[self.attribute_names].values

4. 完整Pipeline构建流程

数值和类别特征处理Pipeline：

graph TD A[原始数据] --> B[数值特征Pipeline] A --> C[类别特征Pipeline] B --> D[特征合并FeatureUnion] C --> D D --> E[最终处理后的数据] subgraph 数值特征处理 B1[DataFrameSelector] --> B2[SimpleImputer] B2 --> B3[StandardScaler] end subgraph 类别特征处理 C1[DataFrameSelector] --> C2[OneHotEncoder] end style A fill:#f9f,stroke:#333,stroke-width:2px style E fill:#bbf,stroke:#333,stroke-width:2px

实现代码：

# 数值特征Pipeline
num_pipeline = Pipeline([
 ('selector', DataFrameSelector(num_attribs)),
 ('imputer', SimpleImputer(strategy="median")),
 ('std_scaler', StandardScaler())
])

# 类别特征Pipeline
cat_pipeline = Pipeline([
 ('selector', DataFrameSelector(cat_attribs)),
 ('onehot', OneHotEncoder(handle_unknown='ignore')),
])

# 合并Pipeline
from sklearn.pipeline import FeatureUnion
full_pipeline = FeatureUnion(transformer_list=[
 ('num_pipeline', num_pipeline),
 ('cat_pipeline', cat_pipeline),
])

5. 使用ColumnTransformer简化Pipeline构建

在Scikit-Learn 0.20及以上版本中，可以使用ColumnTransformer来简化Pipeline构建：

from sklearn.compose import ColumnTransformer

full_pipeline = ColumnTransformer([
 ("num", num_pipeline, num_attribs),
 ("cat", OneHotEncoder(), cat_attribs),
])

6. Pipeline的优势

代码组织: 将所有预处理步骤组织在一起，使代码更清晰
避免数据泄露: 确保在训练集上fit的转换器用相同的参数转换测试集
简化工作流: 只需要调用一个fit和transform方法
参数优化: 可以对整个pipeline进行网格搜索调优
重用性: Pipeline可以保存并重复使用

7. 最佳实践建议

为Pipeline中的每个步骤选择有意义的名字
确保所有转换器都实现了fit_transform方法
使用ColumnTransformer处理不同类型的特征
在构建Pipeline之前先测试单个转换器
使用get_params()和set_params()方法调整Pipeline参数

示例代码

from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
import numpy as np
import scipy.linalg
from sklearn.preprocessing import LabelEncoder, StandardScaler
import optuna
import scipy.linalg
from sklearn.linear_model import BayesianRidge
import pandas as pd
from sklearn.model_selection import LeaveOneOut, cross_val_score

class EmscScaler(object):
 def __init__(self, order=1):
 self.order = order
 self._mx = None
 def mlr(self, x, y):
 """Multiple linear regression fit of the columns of matrix x
 (dependent variables) to constituent vector y (independent variables)

 order - order of a smoothing polynomial, which can be included
 in the set of independent variables. If order is
 not specified, no background will be included.
 b - fit coeffs
 f - fit result (m x 1 column vector)
 r - residual (m x 1 column vector)
 """
 if self.order > 0:
 s = np.ones((len(y), 1))
 for j in range(self.order):
 s = np.concatenate((s, (np.arange(0, 1 + (1.0 / (len(y) - 1)), 1.0 / (len(y) - 1)) ** j).reshape(-1,1)[0:len(y)]),1)
 X = np.concatenate((x.reshape(-1,1), s), 1)
 else:
 X = x
 # calc fit b=fit coefficients
 b = np.dot(np.dot(scipy.linalg.pinv(np.dot(X.T, X)), X.T), y)
 f = np.dot(X, b)
 r = y - f
 return b, f, r
 def fit(self, X, y=None):
 """fit to X (get average spectrum), y is a passthrough for pipeline compatibility"""
 self._mx = np.mean(X, axis=0)
 def transform(self, X, y=None, copy=None):
 if type(self._mx) == type(None):
 print("EMSC not fit yet. run .fit method on reference spectra")
 else:
 # do fitting
 corr = np.zeros(X.shape)
 for i in range(len(X)):
 b, f, r = self.mlr(self._mx, X[i, :])
 corr[i, :] = np.reshape((r / b[0]) + self._mx, (corr.shape[1],))
 return corr
 def fit_transform(self, X, y=None):
 self.fit(X)
 return self.transform(X)



from sklearn.base import BaseEstimator, TransformerMixin
class SpectraPreprocessor(BaseEstimator, TransformerMixin):
 def __init__(self, emsc_order=3,X_ref=None):
 self.emsc_order = emsc_order
 self.emsc_scalers = [EmscScaler(order=emsc_order) for _ in range(4)]
 self.X_ref = X_ref

 def fit(self, X, y=None):
 X_ref = self.X_ref
 if X_ref is None:
 X_ref = X.copy()
 # Define the column ranges for each segment
 ranges = [(0, 251), (281, 482), (482, 683), (683, 854)]

 # Fit EmscScaler for each segment
 for i, (start, end) in enumerate(ranges):
 self.emsc_scalers[i].fit(X_ref[:, start:end])

 return self

 def transform(self, X, y=None):
 # Define the column ranges for each segment
 ranges = [(0, 251), (281, 482), (482, 683), (683, 854)]

 # Transform each segment
 transformed_segments = []
 for i, (start, end) in enumerate(ranges):
 segment = X[:, start:end]
 transformed_segment = self.emsc_scalers[i].transform(segment)

 transformed_segments.append(transformed_segment)

 # Concatenate all transformed segments
 return np.concatenate(transformed_segments, axis=1)

 def fit_transform(self, X, y=None):
 self.fit(X)
 return self.transform(X)



def bayesian_ridge_optuna_for_emsc_data(x_train, y_train, pipeline_):
 def objective(trial):
 try:
 alpha_1 = trial.suggest_float('alpha_1', 0.001, 1, log=True)
 alpha_2 = trial.suggest_float('alpha_2', 0.001, 1, log=True)
 lambda_1 = trial.suggest_float('lambda_1', 0.001, 1, log=True)
 lambda_2 = trial.suggest_float('lambda_2', 0.001, 1, log=True)
 model = pipeline_.set_params(
 bayesian_ridge__alpha_1=alpha_1,
 bayesian_ridge__alpha_2=alpha_2,
 bayesian_ridge__lambda_1=lambda_1,
 bayesian_ridge__lambda_2=lambda_2
 )
 model.fit(x_train, y_train)
 score = cross_val_score(model, x_train, y_train, cv=10, n_jobs=-1, scoring='r2')
 return np.mean(score)
 except ValueError as e:
 return -np.inf

 optuna.logging.set_verbosity(optuna.logging.WARNING)
 pruner = optuna.pruners.MedianPruner()
 study = optuna.create_study(direction="maximize", pruner=pruner)
 study.optimize(objective, n_trials=500, show_progress_bar=True, n_jobs=1)
 return study.best_params


def getdata(filenamex, filenamey):
 x = pd.read_csv(filenamex, header=None)
 y = pd.read_csv(filenamey)

 data = pd.concat([x, y], axis=1)
 return data


name = 'test'
x, y = np.random.rand(100,884), np.random.rand(100)
x_ref = np.random.rand(30,884)
pipeline = Pipeline([
 ('preprocessor', SpectraPreprocessor(emsc_order=3, X_ref=None)),
 ('scaler', StandardScaler()),
 ('bayesian_ridge', BayesianRidge())
])

pipeline.set_params(preprocessor__X_ref=x_ref)

############################################################################################################################################################
best_params = bayesian_ridge_optuna_for_emsc_data(x, y, pipeline)
############################################################################################################################################################

pipeline.set_params(
 bayesian_ridge__alpha_1=best_params['alpha_1'],
 bayesian_ridge__alpha_2=best_params['alpha_2'],
 bayesian_ridge__lambda_1=best_params['lambda_1'],
 bayesian_ridge__lambda_2=best_params['lambda_2']
)
pipeline.fit(x, y)
y_pred = pipeline.predict(x)
print(y_pred)

onnx使用教程

Thu, 19 Jun 2025 10:23:58 +0800

ONNX：打通AI模型的“任督二脉”

想象一下，你精心训练了一个深度学习模型，它在你的电脑上用 PyTorch 框架跑得非常出色。现在，你想把它部署到手机App、网页浏览器，甚至是边缘计算设备上。问题来了：这些五花八门的平台和环境，可能并不支持 PyTorch，或者为了追求极致性能，它们有自己偏好的推理引擎。难道要为每个平台都重新训练或用不同的语言重写模型吗？

这正是 ONNX (Open Neural Network Exchange) 试图解决的核心痛点。ONNX 就像是人工智能模型领域的“普通话”或“世界语”，它提供了一种开放、中立的格式，让不同框架训练出的模型可以轻松地互相“交流”和“迁移”。

什么是 ONNX？

ONNX 的本质是一个开放的机器学习模型文件格式。它由微软、亚马逊、Facebook (Meta) 和 IBM 等科技巨头联合开发，并由Linux基金会托管，旨在实现AI模型的互操作性。

你可以将 ONNX 理解为一个“翻译器”和“通用护照”。无论你的模型最初是用 TensorFlow、PyTorch、Keras、Scikit-learn 还是其他主流框架训练的，你都可以将它“翻译”或“导出”为 .onnx 格式。这个 .onnx 文件包含了模型的网络结构定义和训练好的权重参数。

一旦拥有了 .onnx 文件，你就可以在任何支持 ONNX 标准的平台或设备上运行它，这个过程通常借助一个叫做 ONNX Runtime 的高性能推理引擎来完成。

为什么需要 ONNX？

使用 ONNX 能为你带来诸多好处：

框架互操作性 (Interoperability): 这是其最核心的优势。你可以在你最熟悉、最擅长的框架（如PyTorch）中进行模型的训练和实验，然后将最终模型导出为 ONNX 格式，交付给使用不同技术栈（如C#、Java）的部署团队。
硬件加速与性能优化: ONNX Runtime 针对不同硬件平台（CPU、GPU、FPGA、移动设备芯片等）进行了深度优化。将模型转换为 ONNX 格式后，你可以利用 ONNX Runtime 在目标硬件上获得比原生框架更快的推理速度。
简化部署流程: ONNX 将训练和部署解耦。模型开发者可以专注于算法创新，而部署工程师则可以专注于在各种环境中高效地运行模型，无需关心模型的内部实现细节。
模型“长寿”与可复用性: 随着AI框架的快速迭代，某些框架可能会逐渐被淘汰。将模型保存为 ONNX 格式，可以确保你的模型资产在未来依然可用，不会因为某个特定框架的没落而失效。

ONNX 核心使用教程

掌握 ONNX 的基本流程可以概括为以下三步：获取模型 -> 转换模型 -> 部署推理。

第一步：获取或训练一个模型

这里我们以一个非常经典的图像分类任务为例，使用 PyTorch 框架和预训练的 ResNet-18 模型。

import torch
import torchvision

# 加载一个预训练的 ResNet-18 模型
model = torchvision.models.resnet18(pretrained=True)

# 将模型设置为评估模式（这很重要，会关闭 Dropout 和 BatchNorm 的训练行为）
model.eval()

# 创建一个符合模型输入的虚拟（dummy）输入张量
# ResNet-18 需要一个 (batch_size, channels, height, width) 的输入
dummy_input = torch.randn(1, 3, 224, 224)

第二步：将模型转换为 ONNX 格式

PyTorch 内置了对 ONNX 导出的原生支持，非常方便。

# 定义输入和输出节点的名称（可选，但推荐）
input_names = [ "actual_input_1" ]
output_names = [ "output_1" ]

# 导出模型
torch.onnx.export(model, # 你要转换的模型
 dummy_input, # 一个虚拟的输入，用于追踪模型的计算图
 "resnet18.onnx", # 输出的 ONNX 文件名
 verbose=True, # 打印转换过程的详细信息
 input_names=input_names,
 output_names=output_names,
 opset_version=12) # ONNX 的操作集版本，推荐使用较新的稳定版本

执行完上述代码后，你的项目目录下就会生成一个 resnet18.onnx 文件。这就是你的模型“护照”。

如何查看你的 ONNX 模型？ 推荐使用一个非常直观的开源工具 Netron (https://netron.app)。你可以直接在浏览器中打开这个网址，或者下载它的桌面应用，然后将你的 .onnx 文件拖进去，就可以清晰地看到模型的网络结构、输入输出以及每一层的参数。

第三步：使用 ONNX Runtime 进行推理

现在，我们有了 .onnx 文件，就可以在任何支持 ONNX Runtime 的环境中使用它了。这里我们继续在 Python 环境下演示如何加载并使用这个模型进行推理。

首先，你需要安装 ONNX Runtime:

pip install onnxruntime

然后，使用以下代码进行推理：

import onnxruntime
import numpy as np
from PIL import Image
import torchvision.transforms as transforms

# 1. 创建一个 ONNX Runtime 的推理会话 (InferenceSession)
ort_session = onnxruntime.InferenceSession("resnet18.onnx")

# 2. 准备输入数据
# 假设我们有一张名为 "cat.jpg" 的图片
img = Image.open("cat.jpg").convert("RGB")

# 3. 对图片进行预处理，使其符合模型输入要求
preprocess = transforms.Compose([
 transforms.Resize(256),
 transforms.CenterCrop(224),
 transforms.ToTensor(),
 transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
input_tensor = preprocess(img)
input_tensor = input_tensor.unsqueeze(0) # 增加 batch 维度

# 4. 将 PyTorch tensor 转换为 NumPy array
# ONNX Runtime 需要 NumPy 数组作为输入
ort_inputs = {ort_session.get_inputs()[0].name: input_tensor.numpy()}

# 5. 执行推理
ort_outs = ort_session.run(None, ort_inputs)

# 6. 处理输出结果
# ort_outs 是一个列表，我们获取第一个输出
img_out_y = ort_outs[0]

# 找到概率最高的类别索引
predicted_class_idx = np.argmax(img_out_y)

print(f"Predicted class index: {predicted_class_idx}")

# 你可以加载 ImageNet 的类别标签来查看具体的类别名称
# (此处省略加载标签的代码)

实践中的注意事项

动态输入尺寸 (Dynamic Axes): 在导出 ONNX 模型时，如果你的模型需要处理不同尺寸的输入（例如，不同分辨率的图片或不同长度的文本序列），你可以在 torch.onnx.export 函数中通过 dynamic_axes 参数来指定。
ONNX Opset Version: opset_version (操作集版本) 很重要。它定义了 ONNX 支持的运算符集合。较新的版本支持更多的操作，但也可能需要较新版本的 ONNX Runtime。导出时使用的版本需要与部署时使用的 ONNX Runtime 版本兼容。
模型转换的挑战: 并非所有模型都能被完美转换。一些框架中非常特殊的、自定义的操作可能在 ONNX 中没有对应的标准操作。这时，你可能需要修改模型结构，或者为 ONNX Runtime 实现自定义算子。
模型优化: ONNX 生态系统提供了丰富的工具，可以在转换后对模型进行优化，例如图优化、算子融合和量化（Quantization），以进一步提升性能并减小模型体积，这对于边缘设备部署至关重要。

总结

ONNX 已经成为现代 AI 工作流中不可或缺的一环。它打破了框架壁垒，赋予了开发者前所未有的灵活性，让模型的训练、优化和部署可以无缝衔接。无论你是数据科学家、机器学习工程师还是应用开发者，掌握 ONNX 都将极大提升你的工作效率和项目的成功率。从今天起，就开始为你的模型办理这张强大的“世界通行证”吧！

torch使用教程-zata——v0.0.0

Sun, 11 May 2025 05:59:00 +0800

一些问题和解决方案

在使用torch、或者任何涉及到torch的库中，只要导入torch就会报错

解决方案 https://blog.csdn.net/Changxing_J/article/details/140489278 https://blog.csdn.net/weixin_43591849/article/details/140715890（最终这个解决）

下载Dependencies

下载地址

下载完成并解压，启动DependenciesGui.exe

找到报错的dll的位置，在DependenciesGui.exe中的file→open打开dll的位置，我出现的问题如下

缺少libomp140.x86_64.dll。解决方法：在https://www.dllme.com/dll/files/libomp140_x86_64#google_vignette 下载某一个版本的dll文件，放到C:\Windows\System32中。

问题解决！

如果是缺少vcomp140.dll文件可以参考https://blog.csdn.net/Changxing_J/article/details/140489278