数据科学 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 都将极大提升你的工作效率和项目的成功率。从今天起，就开始为你的模型办理这张强大的“世界通行证”吧！

numpy使用教程

Wed, 18 Jun 2025 14:44:27 +0800

NumPy 教程

import numpy as np

# 1. 创建数组
arr1 = np.array([1, 2, 3, 4]) # 一维数组
arr2 = np.array([[1, 2], [3, 4]]) # 二维数组
zeros = np.zeros((2, 3)) # 2x3 零矩阵
ones = np.ones((3, 2)) # 3x2 全一矩阵
arange = np.arange(0, 10, 2) # 范围数组 [0, 2, 4, 6, 8]
linspace = np.linspace(0, 1, 5) # 等间距数组 [0. , 0.25, 0.5 , 0.75, 1. ]
random_arr = np.random.rand(2, 3) # 2x3 随机数组（0到1）

# 2. 数组属性
print(arr2.shape) # 形状 (2, 2)
print(arr2.ndim) # 维度 2
print(arr2.dtype) # 数据类型
print(arr2.size) # 元素总数 4

# 3. 数组操作
print(arr1 + 2) # 元素级加 [3, 4, 5, 6]
print(arr1 * 3) # 元素级乘 [3, 6, 9, 12]
print(arr2.reshape(4,)) # 改变形状 [1, 2, 3, 4]
print(arr2.T) # 转置 [[1, 3], [2, 4]]

# 4. 索引和切片
arr3 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr3[0, 1]) # 访问元素 2
print(arr3[0:2, 1:3]) # 切片 [[2, 3], [5, 6]]
print(arr3[arr3 > 5]) # 布尔索引 [6, 7, 8, 9]
print(arr3[[0, 2], [1, 2]]) # 花式索引 [2, 9]

# 5. 数学和统计函数
print(np.sqrt(arr1)) # 平方根
print(np.sum(arr3)) # 总和 45
print(np.mean(arr3)) # 均值 5.0
print(np.std(arr3)) # 标准差
print(np.max(arr3)) # 最大值 9
print(np.min(arr3, axis=1)) # 每行最小值 [1, 4, 7]

# 6. 线性代数
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B) # 矩阵乘法 [[19, 22], [43, 50]]
print(np.linalg.det(A)) # 行列式 -2.0
print(np.linalg.inv(A)) # 矩阵逆
eigvals, eigvecs = np.linalg.eig(A) # 特征值和特征向量
print(eigvals, eigvecs)

# 7. 广播
arr4 = np.array([1, 2, 3])
arr5 = np.array([[1], [2], [3]])
print(arr4 + arr5) # 广播运算

# 8. 拼接与分割
vstack = np.vstack((A, B)) # 垂直拼接
hstack = np.hstack((A, B)) # 水平拼接
split = np.split(arr3, 3, axis=0) # 沿轴0分成3部分

# 9. 排序与搜索
arr6 = np.array([3, 1, 4, 1, 5])
print(np.sort(arr6)) # 排序 [1, 1, 3, 4, 5]
print(np.argsort(arr6)) # 排序索引 [1, 3, 0, 2, 4]
print(np.argmax(arr6)) # 最大值索引 4
print(np.argmin(arr6)) # 最小值索引 1

# 10. 随机数
np.random.seed(42) # 设置种子
print(np.random.rand(2, 3)) # 均匀分布随机数
print(np.random.randn(2, 3)) # 正态分布随机数
print(np.random.randint(1, 10, size=(2, 3))) # 随机整数
arr7 = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr7) # 随机打乱
creplace = np.random.choice(arr7, size=3, replace=False) # 随机选择

# 11. 结构化数组
dtype = np.dtype([('name', 'U10'), ('age', 'i4')])
data = np.array([('Alice', 25), ('Bob', 30)], dtype=dtype)
print(data['name']) # ['Alice', 'Bob']

# 12. 高级数学
print(np.cumsum(arr1)) # 累积和 [1, 3, 6, 10]
print(np.cumprod(arr1)) # 累积积 [1, 2, 6, 24]
print(np.fft.fft(arr1)) # 快速傅里叶变换
print(np.gradient(arr1)) # 梯度

# 13. 保存和加载
np.save('array.npy', arr1) # 保存数组
loaded_arr = np.load('array.npy') # 加载数组
np.savetxt('array.txt', arr1, delimiter=',') # 保存为文本

# 14. 内存优化
arr8 = np.array([1, 2, 3], dtype=np.float32) # 指定类型减少内存
arr8 += 10 # 就地操作

2. 创建数组

NumPy 的核心是 ndarray 对象，用于表示多维数组。以下是常见创建方法：

# 一维数组
arr1 = np.array([1, 2, 3, 4])

# 二维数组
arr2 = np.array([[1, 2], [3, 4]])

# 全零数组
zeros = np.zeros((2, 3)) # 2x3 零矩阵

# 全一数组
ones = np.ones((3, 2)) # 3x2 全一矩阵

# 范围数组
arange = np.arange(0, 10, 2) # 从0到10（不含10），步长2

# 等间距数组
linspace = np.linspace(0, 1, 5) # 从0到1，生成5个等间距数

# 随机数组
random_arr = np.random.rand(2, 3) # 2x3 随机数（0到1）

3. 数组属性

查看数组的形状、维度和数据类型：

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 形状
print(arr.shape) # (2, 3)

# 维度
print(arr.ndim) # 2

# 数据类型
print(arr.dtype) # int64（具体取决于系统）

# 元素总数
print(arr.size) # 6

4. 数组操作

NumPy 支持高效的元素级操作和广播机制。

arr = np.array([1, 2, 3, 4])

# 元素级运算
print(arr + 2) # [3, 4, 5, 6]
print(arr * 3) # [3, 6, 9, 12]

# 数组间运算
arr2 = np.array([5, 6, 7, 8])
print(arr + arr2) # [6, 8, 10, 12]

# 改变形状
arr3 = np.array([[1, 2], [3, 4]])
print(arr3.reshape(4,)) # [1, 2, 3, 4]

# 转置
print(arr3.T) # [[1, 3], [2, 4]]

5. 索引和切片

NumPy 数组支持灵活的索引和切片操作。

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 访问元素
print(arr[0, 1]) # 2

# 切片
print(arr[0:2, 1:3]) # [[2, 3], [5, 6]]

# 布尔索引
print(arr[arr > 5]) # [6, 7, 8, 9]

# 花式索引
print(arr[[0, 2], [1, 2]]) # [2, 9]

6. 数学和统计函数

NumPy 提供丰富的数学和统计操作。

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 基本数学函数
print(np.sqrt(arr)) # 平方根
print(np.exp(arr)) # 指数
print(np.sin(arr)) # 正弦

# 统计函数
print(np.sum(arr)) # 总和：21
print(np.mean(arr)) # 均值：3.5
print(np.std(arr)) # 标准差
print(np.max(arr)) # 最大值：6
print(np.min(arr, axis=1)) # 每行最小值：[1, 4]

7. 线性代数

NumPy 支持矩阵运算和线性代数操作。

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵乘法
print(np.dot(A, B)) # [[19, 22], [43, 50]]

# 矩阵 determinant
print(np.linalg.det(A)) # -2.0

# 矩阵逆
print(np.linalg.inv(A)) # [[-2, 1], [1.5, -0.5]]

# 特征值和特征向量
eigvals, eigvecs = np.linalg.eig(A)
print(eigvals) # 特征值
print(eigvecs) # 特征向量

8. 保存和加载数据

NumPy 支持将数组保存到文件或从文件加载。

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 保存到文件
np.save('array.npy', arr)

# 加载文件
loaded_arr = np.load('array.npy')
print(loaded_arr)

# 保存为文本
np.savetxt('array.txt', arr, delimiter=',')

9. 性能优化提示

使用 NumPy 的向量化操作，避免 Python 循环。
预分配数组大小，避免动态扩展。
使用 inplace 操作（如 +=）减少内存分配。
选择合适的数据类型（如 float32 而非 float64）以节省内存。

10. 常见问题与调试

形状不匹配：检查 shape 属性，确保广播规则适用。
数据类型问题：使用 astype 转换类型，如 arr.astype(np.float32)。
内存问题：处理大数组时，考虑分块处理或使用 memmap。

好的！下面我将扩展 NumPy 教程，深入介绍更多高级功能和实用技巧，涵盖广播、数组拼接、排序、随机数生成、结构化数组、内存优化以及实际应用场景。每个部分都附上清晰的代码示例，放在代码块中，方便您直接使用。教程将保持简洁但全面，适合进一步学习 NumPy。

1. 广播机制（Broadcasting）

NumPy 的广播机制允许不同形状的数组进行运算，自动扩展维度以匹配。

import numpy as np

# 标量与数组运算
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr + 10) # 每个元素加10
# [[11, 12, 13], [14, 15, 16]]

# 不同形状数组运算
arr1 = np.array([1, 2, 3])
arr2 = np.array([[1], [2], [3]])
print(arr1 + arr2) # 广播后相加
# [[2, 3, 4], [3, 4, 5], [4, 5, 6]]

# 手动广播
arr3 = np.array([1, 2, 3]).reshape(1, 3)
print(arr3 + arr2) # 同上

提示：广播要求维度兼容（维度相同或其中一个为 1）。检查 shape 避免错误。

2. 数组拼接与分割

NumPy 提供多种方法来合并或拆分数组。

# 拼接数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

# 垂直拼接
vstack = np.vstack((arr1, arr2))
print(vstack)
# [[1, 2], [3, 4], [5, 6], [7, 8]]

# 水平拼接
hstack = np.hstack((arr1, arr2))
print(hstack)
# [[1, 2, 5, 6], [3, 4, 7, 8]]

# 沿指定轴拼接
concat = np.concatenate((arr1, arr2), axis=0) # 同 vstack
print(concat)

# 分割数组
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
split = np.split(arr, 2, axis=1) # 沿轴1分成2部分
print(split) # [array([[1, 2], [5, 6]]), array([[3, 4], [7, 8]])]

3. 排序与搜索

NumPy 支持高效的数组排序和元素搜索。

arr = np.array([3, 1, 4, 1, 5, 9, 2])

# 排序
sorted_arr = np.sort(arr)
print(sorted_arr) # [1, 1, 2, 3, 4, 5, 9]

# 获取排序索引
indices = np.argsort(arr)
print(indices) # [1, 3, 6, 0, 2, 4, 5]

# 二维数组按某列排序
arr2d = np.array([[3, 1], [2, 4], [1, 3]])
sorted_by_col0 = arr2d[arr2d[:, 0].argsort()]
print(sorted_by_col0) # [[1, 3], [2, 4], [3, 1]]

# 搜索最大/最小值索引
max_idx = np.argmax(arr)
min_idx = np.argmin(arr)
print(max_idx, min_idx) # 5, 1

4. 随机数生成

NumPy 的 random 模块提供多种随机数生成方法，适合模拟和机器学习。

# 设置随机种子以确保可重复性
np.random.seed(42)

# 均匀分布（0到1）
rand_uniform = np.random.rand(2, 3)
print(rand_uniform)

# 正态分布（均值0，标准差1）
rand_normal = np.random.randn(2, 3)
print(rand_normal)

# 随机整数
rand_int = np.random.randint(low=1, high=10, size=(2, 3))
print(rand_int)

# 随机打乱数组
arr = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr)
print(arr) # 顺序随机变化

# 随机选择
choices = np.random.choice(arr, size=3, replace=False)
print(choices) # 从arr中随机选3个数

5. 结构化数组

NumPy 支持结构化数组，类似数据库表，适合存储异构数据。

# 定义结构化数据类型
dtype = np.dtype([('name', 'U10'), ('age', 'i4'), ('score', 'f4')])

# 创建结构化数组
data = np.array([('Alice', 25, 85.5), ('Bob', 30, 90.0)], dtype=dtype)
print(data)
# [('Alice', 25, 85.5) ('Bob', 30, 90. )]

# 访问字段
print(data['name']) # ['Alice', 'Bob']
print(data[0]['score']) # 85.5

6. 高级数学运算

NumPy 提供丰富的数学函数，适合科学计算。

arr = np.array([1, 2, 3, 4])

# 累积和
cumsum = np.cumsum(arr)
print(cumsum) # [1, 3, 6, 10]

# 累积积
cumprod = np.cumprod(arr)
print(cumprod) # [1, 2, 6, 24]

# 快速傅里叶变换 (FFT)
fft = np.fft.fft(arr)
print(fft)

# 梯度计算
gradient = np.gradient(arr)
print(gradient) # [1., 1., 1., 1.]（均匀间隔）

7. 内存优化与大数组处理

处理大数组时，NumPy 提供内存高效的工具。

# 使用 memmap 处理大文件
arr = np.memmap('large_array.dat', dtype='float32', mode='w+', shape=(10000, 10000))
arr[:] = np.random.rand(10000, 10000)
print(arr.shape) # (10000, 10000)

# 指定数据类型减少内存
arr_float32 = np.array([1, 2, 3], dtype=np.float32)
print(arr_float32.nbytes) # 12 字节（比默认 float64 小）

# 就地操作
arr = np.array([1, 2, 3])
arr += 10 # 就地加10，节省内存
print(arr) # [11, 12, 13]

8. 实际应用示例：数据分析

以下是一个简单的数据分析示例，展示 NumPy 的实际应用。

# 模拟数据集：1000 个学生的成绩
np.random.seed(42)
scores = np.random.normal(loc=75, scale=10, size=1000)

# 计算统计指标
mean_score = np.mean(scores)
std_score = np.std(scores)
print(f"平均分: {mean_score:.2f}, 标准差: {std_score:.2f}")

# 筛选优秀学生（成绩 > 85）
excellent = scores[scores > 85]
print(f"优秀学生人数: {len(excellent)}")

# 分组统计（按分数段）
bins = np.array([0, 60, 70, 80, 90, 100])
hist, bin_edges = np.histogram(scores, bins=bins)
print("分数分布:", hist) # 每个区间的学生人数

9. 与 Pandas 结合

NumPy 是 Pandas 的底层引擎，结合使用非常常见。

import pandas as pd

# NumPy 数组转为 DataFrame
arr = np.array([[1, 2], [3, 4], [5, 6]])
df = pd.DataFrame(arr, columns=['A', 'B'])
print(df)

# DataFrame 转为 NumPy 数组
np_arr = df.to_numpy()
print(np_arr)

10. 调试与性能提升

调试：使用 np.seterr(all='raise') 捕获浮点错误。
性能：使用 @ 运算符进行矩阵乘法，替代 np.dot 以提高可读性。
向量化：避免 for 循环，使用 NumPy 的内置函数。
并行化：对于超大数组，考虑结合 numba 或 multiprocessing。

# 矩阵乘法简写
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B) # [[19, 22], [43, 50]]

# 错误捕获
np.seterr(all='raise')
try:
 np.array([1]) / 0
except FloatingPointError:
 print("捕获到除零错误")

pandas使用教程

Tue, 13 May 2025 11:12:26 +0800

Pandas 使用教程

Pandas 是 Python 中一个强大的数据分析和处理库。它提供了高性能、易于使用的数据结构和数据分析工具。本教程将介绍 Pandas 的基本概念和常用操作。

1. 安装 Pandas

如果你还没有安装 Pandas，可以使用 pip 进行安装：

pip install pandas

2. Pandas 的核心数据结构

Pandas 主要有两种核心数据结构：Series 和 DataFrame。

2.1 Series

Series 是一种一维的、类似数组的对象，能够保存任何数据类型（整数、字符串、浮点数、Python 对象等）。它由一组数据以及一组与之相关的数据标签（即索引）组成。

创建 Series

import pandas as pd
import numpy as np # 通常与 pandas 一起使用

# 从列表创建 Series
data_list = [10, 20, 30, 40, 50]
s1 = pd.Series(data_list)
print("从列表创建的 Series:")
print(s1)
print("-" * 30)

# 指定索引
index_list = ['a', 'b', 'c', 'd', 'e']
s2 = pd.Series(data_list, index=index_list)
print("指定索引的 Series:")
print(s2)
print("-" * 30)

# 从字典创建 Series
data_dict = {'x': 100, 'y': 200, 'z': 300}
s3 = pd.Series(data_dict)
print("从字典创建的 Series:")
print(s3)
print("-" * 30)

Series 的属性和方法

# 访问元素
print("访问 s2 中的元素 'c':", s2['c'])
print("访问 s2 中前两个元素:\n", s2[:2])
print("-" * 30)

# 属性
print("s2 的索引:", s2.index)
print("s2 的值:", s2.values)
print("s2 的数据类型:", s2.dtype)
print("s2 的形状:", s2.shape)
print("s2 的大小:", s2.size)
print("-" * 30)

# 常用方法
print("s1 的和:", s1.sum())
print("s1 的平均值:", s1.mean())
print("s1 大于 30 的元素:\n", s1[s1 > 30])
print("-" * 30)

2.2 DataFrame

DataFrame 是一个二维的、表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame 既有行索引也有列索引，可以被看作是由 Series 组成的字典。

创建 DataFrame

# 从字典创建 DataFrame (字典的键是列名，值是列表或 Series)
data_df = {
 '姓名': ['张三', '李四', '王五', '赵六'],
 '年龄': [25, 30, 22, 28],
 '城市': ['北京', '上海', '广州', '深圳']
}
df1 = pd.DataFrame(data_df)
print("从字典创建的 DataFrame:")
print(df1)
print("-" * 30)

# 指定行索引
df2 = pd.DataFrame(data_df, index=['a', 'b', 'c', 'd'])
print("指定行索引的 DataFrame:")
print(df2)
print("-" * 30)

# 从列表的列表创建 DataFrame
data_list_of_lists = [
 ['Alice', 25, 'New York'],
 ['Bob', 30, 'London'],
 ['Charlie', 35, 'Paris']
]
df3 = pd.DataFrame(data_list_of_lists, columns=['Name', 'Age', 'City'])
print("从列表的列表创建的 DataFrame:")
print(df3)
print("-" * 30)

# 从 NumPy ndarray 创建 DataFrame
data_np = np.random.randn(4, 3) # 生成 4x3 的随机数数组
df4 = pd.DataFrame(data_np, columns=['A', 'B', 'C'])
print("从 NumPy ndarray 创建的 DataFrame:")
print(df4)
print("-" * 30)

3. 数据加载与保存

Pandas 可以轻松地从多种文件格式中读取数据，并将数据保存到这些格式中。

3.1 读取数据

# 创建一个示例 CSV 文件 (在实际使用中，你通常会有一个已存在的文件)
csv_data = """id,name,score
1,Alice,85
2,Bob,90
3,Charlie,78
"""
with open("example.csv", "w") as f:
 f.write(csv_data)

# 从 CSV 文件读取数据
df_csv = pd.read_csv('example.csv')
print("从 CSV 文件读取的 DataFrame:")
print(df_csv)
print("-" * 30)

# 读取 Excel 文件 (需要安装 openpyxl 或 xlrd 库: pip install openpyxl xlrd)
# 假设你有一个 example.xlsx 文件
# df_excel = pd.read_excel('example.xlsx', sheet_name='Sheet1')
# print("从 Excel 文件读取的 DataFrame:")
# print(df_excel)
# print("-" * 30)

# 读取 JSON 文件
# json_data = """
# [
# {"id": 1, "name": "David", "score": 92},
# {"id": 2, "name": "Eve", "score": 88}
# ]
# """
# with open("example.json", "w") as f:
# f.write(json_data)
# df_json = pd.read_json('example.json')
# print("从 JSON 文件读取的 DataFrame:")
# print(df_json)
# print("-" * 30)

3.2 保存数据

# 将 DataFrame 保存到 CSV 文件
df1.to_csv('output.csv', index=False) # index=False 表示不将行索引写入文件
print("df1 已保存到 output.csv")
print("-" * 30)

# 将 DataFrame 保存到 Excel 文件
# df1.to_excel('output.xlsx', sheet_name='Data', index=False)
# print("df1 已保存到 output.xlsx")
# print("-" * 30)

# 将 DataFrame 保存到 JSON 文件
# df1.to_json('output.json', orient='records', lines=True) # orient='records' 每行一个 JSON 对象
# print("df1 已保存到 output.json")
# print("-" * 30)

4. 数据查看与选择

4.1 查看数据

print("查看 df1 的前几行 (默认 5 行):")
print(df1.head())
print("-" * 30)

print("查看 df1 的后几行 (默认 5 行):")
print(df1.tail(3)) # 查看后 3 行
print("-" * 30)

print("查看 df1 的索引:")
print(df1.index)
print("-" * 30)

print("查看 df1 的列名:")
print(df1.columns)
print("-" * 30)

print("查看 df1 的数据类型:")
print(df1.dtypes)
print("-" * 30)

print("查看 df1 的形状 (行数, 列数):")
print(df1.shape)
print("-" * 30)

print("获取 df1 的描述性统计信息:")
print(df1.describe(include='all')) # include='all' 包括非数值列
print("-" * 30)

print("获取 df1 的简要信息:")
df1.info()
print("-" * 30)

4.2 选择数据

Pandas 提供了多种选择数据的方式。

选择列

# 选择单列 (返回 Series)
ages = df1['年龄']
print("选择 '年龄' 列:")
print(ages)
print(type(ages))
print("-" * 30)

# 选择多列 (返回 DataFrame)
name_city = df1[['姓名', '城市']]
print("选择 '姓名' 和 '城市' 列:")
print(name_city)
print(type(name_city))
print("-" * 30)

选择行

`loc`: 基于标签的索引

print("使用 df2 (有自定义行索引):")
print(df2)
print("-" * 30)

# 选择单行
row_b = df2.loc['b']
print("选择行 'b':")
print(row_b)
print("-" * 30)

# 选择多行
rows_ac = df2.loc[['a', 'c']]
print("选择行 'a' 和 'c':")
print(rows_ac)
print("-" * 30)

# 选择行和列
name_age_b = df2.loc['b', ['姓名', '年龄']]
print("选择行 'b' 的 '姓名' 和 '年龄':")
print(name_age_b)
print("-" * 30)

# 选择所有行的特定列
all_rows_name_age = df2.loc[:, ['姓名', '年龄']]
print("选择所有行的 '姓名' 和 '年龄':")
print(all_rows_name_age)
print("-" * 30)

`iloc`: 基于整数位置的索引

print("使用 df1 (默认整数行索引):")
print(df1)
print("-" * 30)

# 选择第一行 (位置 0)
row_0 = df1.iloc[0]
print("选择第一行:")
print(row_0)
print("-" * 30)

# 选择前两行 (位置 0 和 1)
rows_01 = df1.iloc[[0, 1]] # 或 df1.iloc[0:2]
print("选择前两行:")
print(rows_01)
print("-" * 30)

# 选择第一行、第一列的元素
element_00 = df1.iloc[0, 0]
print("选择第一行、第一列的元素:", element_00)
print("-" * 30)

# 选择特定行和列
subset_iloc = df1.iloc[[0, 2], [0, 1]] # 第 0, 2 行 和 第 0, 1 列
print("选择特定行和列:")
print(subset_iloc)
print("-" * 30)

条件选择 (布尔索引)

# 选择年龄大于 25 的行
older_than_25 = df1[df1['年龄'] > 25]
print("年龄大于 25 的行:")
print(older_than_25)
print("-" * 30)

# 组合条件 (使用 & 表示 AND, | 表示 OR)
condition = (df1['年龄'] > 25) & (df1['城市'] == '深圳')
filtered_df = df1[condition]
print("年龄大于 25 且城市为深圳的行:")
print(filtered_df)
print("-" * 30)

# 使用 isin() 方法
cities_of_interest = ['北京', '深圳']
df_in_cities = df1[df1['城市'].isin(cities_of_interest)]
print("城市为北京或深圳的行:")
print(df_in_cities)
print("-" * 30)

5. 数据清洗

数据清洗是数据分析中非常重要的一步。

5.1 处理缺失值 (NaN)

# 创建一个包含缺失值的 DataFrame
data_missing = {
 'A': [1, 2, np.nan, 4],
 'B': [5, np.nan, np.nan, 8],
 'C': [9, 10, 11, 12],
 'D': [np.nan, np.nan, np.nan, np.nan]
}
df_missing = pd.DataFrame(data_missing)
print("包含缺失值的 DataFrame:")
print(df_missing)
print("-" * 30)

# 检查缺失值
print("检查每列是否有缺失值:")
print(df_missing.isnull()) # 返回布尔型 DataFrame
print("-" * 30)
print("统计每列缺失值的数量:")
print(df_missing.isnull().sum())
print("-" * 30)

# 删除包含缺失值的行或列
# 删除任何包含 NaN 的行
df_dropped_rows = df_missing.dropna()
print("删除包含 NaN 的行后的 DataFrame:")
print(df_dropped_rows)
print("-" * 30)

# 删除任何包含 NaN 的列
df_dropped_cols = df_missing.dropna(axis=1) # axis=1 表示按列操作
print("删除包含 NaN 的列后的 DataFrame:")
print(df_dropped_cols)
print("-" * 30)

# 删除所有值都为 NaN 的列
df_dropped_all_nan_cols = df_missing.dropna(axis=1, how='all')
print("删除所有值都为 NaN 的列后的 DataFrame:")
print(df_dropped_all_nan_cols)
print("-" * 30)

# 填充缺失值
# 用特定值填充所有 NaN
df_filled_zero = df_missing.fillna(0)
print("用 0 填充所有 NaN 后的 DataFrame:")
print(df_filled_zero)
print("-" * 30)

# 用列的平均值填充 NaN (仅对数值列有效)
df_filled_mean_A = df_missing.copy() # 创建副本以避免修改原始 DataFrame
df_filled_mean_A['A'] = df_filled_mean_A['A'].fillna(df_filled_mean_A['A'].mean())
print("用列 'A' 的平均值填充 NaN 后的 DataFrame:")
print(df_filled_mean_A)
print("-" * 30)

# 使用前一个有效值填充 (向前填充)
df_ffill = df_missing.fillna(method='ffill')
print("向前填充后的 DataFrame:")
print(df_ffill)
print("-" * 30)

# 使用后一个有效值填充 (向后填充)
df_bfill = df_missing.fillna(method='bfill')
print("向后填充后的 DataFrame:")
print(df_bfill)
print("-" * 30)

5.2 处理重复数据

data_duplicates = {
 'col1': ['A', 'B', 'A', 'C', 'B', 'B'],
 'col2': [1, 2, 1, 3, 2, 2]
}
df_duplicates = pd.DataFrame(data_duplicates)
print("包含重复数据的 DataFrame:")
print(df_duplicates)
print("-" * 30)

# 检查重复行
print("检查重复行 (除第一次出现外，其余标记为 True):")
print(df_duplicates.duplicated())
print("-" * 30)

# 删除重复行 (默认保留第一个出现的)
df_no_duplicates = df_duplicates.drop_duplicates()
print("删除重复行后的 DataFrame:")
print(df_no_duplicates)
print("-" * 30)

# 删除重复行 (保留最后一个出现的)
df_no_duplicates_last = df_duplicates.drop_duplicates(keep='last')
print("删除重复行 (保留最后一个) 后的 DataFrame:")
print(df_no_duplicates_last)
print("-" * 30)

# 基于特定列删除重复项
df_no_duplicates_subset = df_duplicates.drop_duplicates(subset=['col1'])
print("基于 'col1' 删除重复项后的 DataFrame:")
print(df_no_duplicates_subset)
print("-" * 30)

5.3 数据类型转换

print("df1 的数据类型:")
print(df1.dtypes)
print("-" * 30)

# 将 '年龄' 列转换为浮点数
df_copy = df1.copy()
df_copy['年龄'] = df_copy['年龄'].astype(float)
print("将 '年龄' 列转换为浮点数后的数据类型:")
print(df_copy.dtypes)
print(df_copy)
print("-" * 30)

# 处理可能出现的错误 (例如，将包含非数字的字符串列转换为数字)
df_error = pd.DataFrame({'vals': ['1', '2', 'apple', '4']})
# df_error['vals'] = df_error['vals'].astype(int) # 这会报错
df_error['vals_numeric'] = pd.to_numeric(df_error['vals'], errors='coerce') # 'coerce' 会将无法转换的值设为 NaT 或 NaN
print("使用 to_numeric 处理转换错误:")
print(df_error)
print("-" * 30)

6. 数据操作

6.1 添加和删除列

# 添加新列
df_copy = df1.copy()
df_copy['职业'] = ['工程师', '医生', '学生', '教师'] # 列表长度需与行数一致
print("添加 '职业' 列后的 DataFrame:")
print(df_copy)
print("-" * 30)

df_copy['工龄'] = 0 # 添加值为常量的列
print("添加 '工龄' 列后的 DataFrame:")
print(df_copy)
print("-" * 30)

# 基于现有列创建新列
df_copy['年龄_加五'] = df_copy['年龄'] + 5
print("添加 '年龄_加五' 列后的 DataFrame:")
print(df_copy)
print("-" * 30)

# 删除列
df_dropped_city = df_copy.drop('城市', axis=1) # axis=1 表示删除列, inplace=True 可以直接修改原 DataFrame
print("删除 '城市' 列后的 DataFrame:")
print(df_dropped_city)
print("-" * 30)

# 删除多列
df_dropped_multi = df_copy.drop(['职业', '工龄'], axis=1)
print("删除 '职业' 和 '工龄' 列后的 DataFrame:")
print(df_dropped_multi)
print("-" * 30)

6.2 应用函数 (apply, map, applymap)

`apply()`

可以作用于行或列。

df_apply = df1[['年龄']].copy() # 只取年龄列，方便演示
print("原始 '年龄' 列:")
print(df_apply)
print("-" * 30)

# 对列应用函数
def square(x):
 return x * x

df_apply['年龄平方_apply_col'] = df_apply['年龄'].apply(square)
print("对 '年龄' 列应用 square 函数:")
print(df_apply)
print("-" * 30)

# 对行应用函数 (通常与 lambda 函数结合)
df_numeric_data = pd.DataFrame(np.random.randn(3, 3), columns=['A', 'B', 'C'])
print("数值型 DataFrame:")
print(df_numeric_data)
df_numeric_data['Row_Sum'] = df_numeric_data.apply(lambda row: row.sum(), axis=1)
print("对行应用求和函数:")
print(df_numeric_data)
print("-" * 30)

`map()`

作用于 Series 的每个元素。

s_map = df1['城市'].copy()
city_mapping = {'北京': 'BJ', '上海': 'SH', '广州': 'GZ', '深圳': 'SZ'}
s_map_transformed = s_map.map(city_mapping)
print("原始 '城市' Series:")
print(s_map)
print("使用 map 转换后的 '城市' Series:")
print(s_map_transformed)
print("-" * 30)

# 如果映射字典中没有某个键，则对应元素会变为 NaN
s_map_partial = pd.Series(['北京', '上海', '成都'])
s_map_partial_transformed = s_map_partial.map(city_mapping)
print("部分映射:")
print(s_map_partial_transformed)
print("-" * 30)

`applymap()`

作用于 DataFrame 的每个元素。

df_applymap_data = df1[['年龄']].copy() # 使用数值列
print("原始 DataFrame (年龄):")
print(df_applymap_data)
df_applymap_transformed = df_applymap_data.applymap(lambda x: x + 10) # DataFrame 中所有元素加 10
print("使用 applymap 将所有元素加 10:")
print(df_applymap_transformed)
print("-" * 30)

6.3 排序

# 按索引排序
df_sorted_index = df2.sort_index(ascending=False) # 按行索引降序
print("按行索引降序排序:")
print(df_sorted_index)
print("-" * 30)

df_sorted_columns = df1.sort_index(axis=1, ascending=True) # 按列名升序
print("按列名升序排序:")
print(df_sorted_columns)
print("-" * 30)

# 按值排序
df_sorted_age = df1.sort_values(by='年龄', ascending=False)
print("按 '年龄' 降序排序:")
print(df_sorted_age)
print("-" * 30)

# 按多列排序
df_sorted_city_age = df1.sort_values(by=['城市', '年龄'], ascending=[True, False])
print("按 '城市'(升序) 和 '年龄'(降序) 排序:")
print(df_sorted_city_age)
print("-" * 30)

7. 分组 (Group By)

分组操作通常涉及以下一个或多个步骤：

分割 (Splitting): 根据某些条件将数据分成组。
应用 (Applying): 对每个组独立应用一个函数。
合并 (Combining): 将结果组合成一个数据结构。

data_sales = {
 'Store': ['A', 'B', 'A', 'B', 'A', 'C', 'B', 'C'],
 'Product': ['Apple', 'Banana', 'Orange', 'Apple', 'Banana', 'Orange', 'Orange', 'Apple'],
 'Sales': [100, 150, 80, 90, 120, 70, 130, 60],
 'Quantity': [10, 15, 8, 9, 12, 7, 13, 6]
}
df_sales = pd.DataFrame(data_sales)
print("销售数据 DataFrame:")
print(df_sales)
print("-" * 30)

# 按 'Store' 分组并计算每家店的总销售额
grouped_by_store_sales = df_sales.groupby('Store')['Sales'].sum()
print("按 'Store' 分组计算总销售额:")
print(grouped_by_store_sales)
print(type(grouped_by_store_sales)) # 返回 Series
print("-" * 30)

# 按 'Store' 分组并计算每家店的平均销售额和总数量
grouped_by_store_agg = df_sales.groupby('Store').agg({'Sales': 'mean', 'Quantity': 'sum'})
print("按 'Store' 分组计算平均销售额和总数量:")
print(grouped_by_store_agg)
print(type(grouped_by_store_agg)) # 返回 DataFrame
print("-" * 30)

# 按多个列分组
grouped_by_store_product = df_sales.groupby(['Store', 'Product'])['Sales'].sum()
print("按 'Store' 和 'Product' 分组计算总销售额:")
print(grouped_by_store_product) # 返回多级索引的 Series
print("-" * 30)

# 分组后迭代
for name, group in df_sales.groupby('Store'):
 print(f"Store: {name}")
 print(group)
 print("-" * 10)
print("-" * 30)

# 分组后应用自定义函数
def top_sales_product(df_group):
 return df_group.sort_values(by='Sales', ascending=False).iloc[0]

top_product_by_store = df_sales.groupby('Store').apply(top_sales_product)
print("每家店销售额最高的产品记录:")
print(top_product_by_store)
print("-" * 30)

8. 合并与连接 (Merge, Join, Concat)

8.1 `concat()`: 拼接

用于沿某个轴将多个 Pandas 对象（Series 或 DataFrame）拼接在一起。

df_c1 = pd.DataFrame({'A': ['A0', 'A1'], 'B': ['B0', 'B1']})
df_c2 = pd.DataFrame({'A': ['A2', 'A3'], 'B': ['B2', 'B3']})
df_c3 = pd.DataFrame({'C': ['C0', 'C1'], 'D': ['D0', 'D1']})

# 沿行拼接 (默认 axis=0)
concatenated_rows = pd.concat([df_c1, df_c2])
print("沿行拼接 df_c1 和 df_c2:")
print(concatenated_rows)
print("-" * 30)

# 沿行拼接，忽略原始索引并重置索引
concatenated_rows_reset_index = pd.concat([df_c1, df_c2], ignore_index=True)
print("沿行拼接并重置索引:")
print(concatenated_rows_reset_index)
print("-" * 30)

# 沿列拼接 (axis=1)
concatenated_cols = pd.concat([df_c1, df_c3], axis=1)
print("沿列拼接 df_c1 和 df_c3:")
print(concatenated_cols)
print("-" * 30)

8.2 `merge()`: 数据库风格的连接

根据一个或多个键将 DataFrame 的行连接起来。

left = pd.DataFrame({
 'key': ['K0', 'K1', 'K2', 'K3'],
 'A': ['A0', 'A1', 'A2', 'A3'],
 'B': ['B0', 'B1', 'B2', 'B3']
})
right = pd.DataFrame({
 'key': ['K0', 'K1', 'K4', 'K5'],
 'C': ['C0', 'C1', 'C2', 'C3'],
 'D': ['D0', 'D1', 'D2', 'D3']
})
print("Left DataFrame:")
print(left)
print("Right DataFrame:")
print(right)
print("-" * 30)

# 内连接 (Inner Join - 默认): 基于 'key' 列的交集
merged_inner = pd.merge(left, right, on='key')
print("内连接结果:")
print(merged_inner)
print("-" * 30)

# 左连接 (Left Join): 使用左边 DataFrame 的所有键
merged_left = pd.merge(left, right, on='key', how='left')
print("左连接结果:")
print(merged_left)
print("-" * 30)

# 右连接 (Right Join): 使用右边 DataFrame 的所有键
merged_right = pd.merge(left, right, on='key', how='right')
print("右连接结果:")
print(merged_right)
print("-" * 30)

# 外连接 (Outer Join): 使用两个 DataFrame 键的并集
merged_outer = pd.merge(left, right, on='key', how='outer')
print("外连接结果:")
print(merged_outer)
print("-" * 30)

# 基于不同列名的键合并
left_diff_key = pd.DataFrame({'lkey': ['K0', 'K1'], 'A': ['A0', 'A1']})
right_diff_key = pd.DataFrame({'rkey': ['K0', 'K1'], 'C': ['C0', 'C1']})
merged_diff_keys = pd.merge(left_diff_key, right_diff_key, left_on='lkey', right_on='rkey')
print("基于不同列名合并:")
print(merged_diff_keys)
print("-" * 30)

8.3 `join()`: 基于索引的连接

join() 方法用于基于索引或指定列将两个 DataFrame 连接起来。默认情况下，它尝试按索引进行左连接。

left_join_df = pd.DataFrame(
 {'A': ['A0', 'A1', 'A2']},
 index=['K0', 'K1', 'K2']
)
right_join_df = pd.DataFrame(
 {'B': ['B0', 'B1', 'B2']},
 index=['K0', 'K1', 'K3'] # K2 不同
)
print("Left Join DataFrame:")
print(left_join_df)
print("Right Join DataFrame:")
print(right_join_df)
print("-" * 30)

# 默认左连接 (基于索引)
joined_df = left_join_df.join(right_join_df)
print("默认左连接结果:")
print(joined_df)
print("-" * 30)

# 外连接 (how='outer')
joined_outer_df = left_join_df.join(right_join_df, how='outer')
print("外连接结果:")
print(joined_outer_df)
print("-" * 30)

# 在列上连接 (需要先将列设置为索引)
left_on_col = pd.DataFrame({
 'key': ['K0', 'K1', 'K2'],
 'A': ['A0', 'A1', 'A2']
})
right_on_col = pd.DataFrame({
 'other_key': ['K0', 'K1', 'K3'],
 'B': ['B0', 'B1', 'B2']
})
joined_on_key = left_on_col.join(right_on_col.set_index('other_key'), on='key')
print("在 'key' 和 'other_key' 列上连接:")
print(joined_on_key)
print("-" * 30)

9. 时间序列数据

Pandas 在处理时间序列数据方面非常强大。

# 创建日期范围
date_rng = pd.date_range(start='2024-01-01', end='2024-01-10', freq='D') # 每天
print("日期范围:")
print(date_rng)
print("-" * 30)

# 创建一个带时间索引的 Series
time_series = pd.Series(np.random.randn(len(date_rng)), index=date_rng)
print("时间序列数据:")
print(time_series)
print("-" * 30)

# 创建一个带时间索引的 DataFrame
df_time = pd.DataFrame({'value': np.random.randint(0, 100, len(date_rng))}, index=date_rng)
df_time['day_of_week'] = df_time.index.day_name()
print("带时间索引的 DataFrame:")
print(df_time)
print("-" * 30)

# 选择特定日期的数据
print("选择 2024-01-05 的数据:")
print(df_time.loc['2024-01-05'])
print("-" * 30)

# 选择日期范围的数据
print("选择 2024-01-03 到 2024-01-07 的数据:")
print(df_time['2024-01-03':'2024-01-07'])
print("-" * 30)

# 重采样 (Resampling) - 例如，按周汇总数据
weekly_sum = df_time['value'].resample('W').sum() # 'W' 表示每周
print("按周汇总的总值:")
print(weekly_sum)
print("-" * 30)

# 移动窗口计算 (Moving Window Calculations)
df_time['rolling_mean_3D'] = df_time['value'].rolling(window=3).mean() # 3 天的移动平均值
print("带 3 天移动平均值的 DataFrame:")
print(df_time)
print("-" * 30)

10. 绘图 (Plotting)

Pandas 可以与 Matplotlib 集成，方便地绘制图表。 (需要安装 matplotlib: pip install matplotlib)

import matplotlib.pyplot as plt

# Series 绘图
ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2020', periods=1000))
ts = ts.cumsum() # 累积和
ts.plot()
plt.title("Random Walk Time Series")
plt.show() # 在脚本中运行时需要此行来显示图形

# DataFrame 绘图
df_plot = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])
df_plot.plot(kind='bar') # 柱状图
plt.title("DataFrame Bar Plot")
plt.show()

df_sales.groupby('Store')['Sales'].sum().plot(kind='pie', autopct='%1.1f%%')
plt.title("Sales by Store")
plt.ylabel('') # 隐藏 y 轴标签
plt.show()

这只是 Pandas 功能的冰山一角。Pandas 非常强大，有许多高级功能和用法。建议查阅官方文档以获取更全面的信息：https://pandas.pydata.org/pandas-docs/stable/

使用技巧

不同的写csv文件方法

#################################################
############# csv模块 ##################
#################################################
import csv
# 要写入的数据
data = [
 ['Name', 'Age', 'City'],
 ['John', 30, 'New York'],
 ['Alice', 25, 'Los Angeles'],
 ['Bob', 35, 'Chicago']
]

# 打开CSV文件并写入数据
with open('output.csv', 'w', newline='') as csvfile:
 # 创建一个CSV写入对象
 csv_writer = csv.writer(csvfile)

 # 循环写入每一行数据
 for row in data:
 csv_writer.writerow(row)

print("数据已成功写入到 output.csv 文件中。")


#################################################
############# Pandas ##################
#################################################

import pandas as pd

# 创建一个DataFrame对象，包含要写入的数据
data = {
 'Name': ['John', 'Alice', 'Bob'],
 'Age': [30, 25, 35],
 'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

# 将DataFrame写入CSV文件
df.to_csv('output.csv', index=False)

print("数据已成功写入到 output.csv 文件中。")

# 追加写入
new_data = {
 'Name': 'Sarah',
 'Age': 20,
 'City':'toky'
}
df_new = pd.DataFrame(new_data,index=[0])
existing_csv_file = 'output.csv'
# 将新数据追加到现有的CSV文件中
df_new.to_csv(existing_csv_file, mode='a', header=False, index=False)

matplotlib教程-zata——v0.0.0

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

参考菜鸟教程

matplotlib中文显示乱码问题


对于 Windows：

plt.rcParams['font.family'] = 'SimHei' # 替换为你选择的字体
在 Windows 系统上，选择 SimHei（黑体）或其他中文字体，并将其设置为 Matplotlib 的默认字体。

对于 Linux：

plt.rcParams['font.family'] = 'WenQuanYi Micro Hei' # 替换为你选择的字体

如果不知道有哪些字体可以，可以先执行以下代码

from matplotlib import pyplot as plt
import matplotlib
a=sorted([f.name for f in matplotlib.font_manager.fontManager.ttflist])

for i in a:
 print(i)

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

trainer

Thu, 13 Mar 2025 10:45:32 +0800

使用 `Trainer` 进行文本分类的教程

Trainer 是 Hugging Face transformers 库中一个高级工具，用于简化和加速模型的训练、评估和预测流程。它封装了训练过程中的许多细节，适合快速实现深度学习任务。本教程将以你提供的代码为基础，讲解如何使用 Trainer 完成一个中文情感分类任务（基于 ChnSentiCorp_htl_all.csv 数据集）。

1. 准备工作：导入相关包

首先，我们需要导入必要的库和模块：

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset
import torch
import evaluate

AutoTokenizer：用于加载预训练的分词器。
AutoModelForSequenceClassification：加载适用于序列分类任务的预训练模型。
Trainer 和 TrainingArguments：核心工具，用于定义训练流程和参数。
datasets：用于加载和处理数据集。
evaluate：用于加载评估指标（如准确率和 F1 分数）。

2. 加载数据集

我们需要加载用于训练的数据集，这里假设你有一个名为 ChnSentiCorp_htl_all.csv 的 CSV 文件，包含 review（文本）和 label（标签）两列：

dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
dataset = dataset.filter(lambda x: x["review"] is not None)
print(dataset)

load_dataset：从 CSV 文件加载数据集。
filter：过滤掉 review 列为空的样本，确保数据质量。

输出示例：

Dataset({
 features: ['label', 'review'],
 num_rows: 7766
})

3. 划分数据集

将数据集划分为训练集和测试集：

datasets = dataset.train_test_split(test_size=0.1)
print(datasets)

train_test_split：按照 9:1 的比例将数据集分为训练集（90%）和测试集（10%）。

输出示例：

DatasetDict({
 train: Dataset({
 features: ['label', 'review'],
 num_rows: 6989
 })
 test: Dataset({
 features: ['label', 'review'],
 num_rows: 777
 })
})

4. 数据集预处理

为了让数据适配模型输入，我们需要对文本进行分词（tokenization）并添加标签：

tokenizer = AutoTokenizer.from_pretrained("hfl/rbt3")

def process_function(examples):
 tokenized_examples = tokenizer(examples["review"], max_length=128, truncation=True)
 tokenized_examples["labels"] = examples["label"]
 return tokenized_examples

tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)
print(tokenized_datasets)

AutoTokenizer.from_pretrained：加载与预训练模型匹配的分词器（这里是 hfl/rbt3）。
process_function：
- 使用 tokenizer 对 review 文本进行分词，限制最大长度为 128，并截断超长部分。
- 将标签列 label 重命名为 labels（Trainer 要求的字段名）。
map：对整个数据集应用预处理函数，batched=True 表示批量处理，remove_columns 删除原始列，只保留分词后的字段（如 input_ids, attention_mask, labels）。

输出示例：

DatasetDict({
 train: Dataset({
 features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
 num_rows: 6989
 })
 test: Dataset({
 features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
 num_rows: 777
 })
})

5. 创建模型

加载预训练模型并用于序列分类任务：

model = AutoModelForSequenceClassification.from_pretrained("hfl/rbt3")
print(model.config)

AutoModelForSequenceClassification：加载适用于分类任务的模型（默认情况下，hfl/rbt3 会自动配置为 2 分类任务）。
model.config：查看模型配置，例如类别数量、隐藏层大小等。

输出示例：

RobertaConfig {
 "num_labels": 2,
 "hidden_size": 768,
 ...
}

6. 创建评估函数

定义一个评估函数，用于计算模型在验证集上的表现：

acc_metric = evaluate.load("accuracy")
f1_metric = evaluate.load("f1")

def eval_metric(eval_predict):
 predictions, labels = eval_predict
 predictions = predictions.argmax(axis=-1) # 将 logits 转换为预测类别
 acc = acc_metric.compute(predictions=predictions, references=labels)
 f1 = f1_metric.compute(predictions=predictions, references=labels)
 acc.update(f1) # 合并 accuracy 和 f1 分数
 return acc

evaluate.load：加载预定义的评估指标（准确率和 F1 分数）。
eval_metric：接收 Trainer 传递的预测结果（eval_predict），计算并返回指标。
- predictions.argmax：从 logits 中提取预测类别。
- acc.update(f1)：将 F1 分数添加到结果字典中。

7. 配置 `TrainingArguments`

TrainingArguments 定义了训练过程中的超参数和策略：

train_args = TrainingArguments(
 output_dir="./checkpoints", # 模型和检查点的保存路径
 per_device_train_batch_size=64, # 训练时的批量大小
 per_device_eval_batch_size=128, # 验证时的批量大小
 logging_steps=10, # 每 10 步打印一次日志
 evaluation_strategy="epoch", # 每个 epoch 评估一次
 save_strategy="epoch", # 每个 epoch 保存一次模型
 save_total_limit=3, # 最多保存 3 个检查点
 learning_rate=2e-5, # 学习率
 weight_decay=0.01, # 权重衰减
 metric_for_best_model="f1", # 使用 F1 分数选择最佳模型
 load_best_model_at_end=True # 训练结束后加载最佳模型
)
print(train_args)

重要参数：
- evaluation_strategy 和 save_strategy：控制评估和保存的频率。
- metric_for_best_model：指定用于选择最佳模型的指标。
- load_best_model_at_end：确保训练结束后使用性能最好的模型。

8. 创建 `Trainer`

将模型、参数和数据集组合成 Trainer 对象：

from transformers import DataCollatorWithPadding

trainer = Trainer(
 model=model,
 args=train_args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["test"],
 data_collator=DataCollatorWithPadding(tokenizer=tokenizer),
 compute_metrics=eval_metric
)

DataCollatorWithPadding：动态填充输入序列到相同长度，优化批量处理效率。
Trainer 参数：
- model：待训练的模型。
- args：训练参数。
- train_dataset 和 eval_dataset：训练和验证数据集。
- data_collator：数据整理器。
- compute_metrics：自定义的评估函数。

9. 模型训练

开始训练模型：

trainer.train()

trainer.train()：执行完整的训练循环。
训练过程中会：
- 每 logging_steps（10 步）打印损失。
- 每个 epoch 评估模型并保存检查点。
- 根据 metric_for_best_model（F1 分数）选择最佳模型。

输出示例：

[164/164 01:23, Epoch 3/3]
Epoch Training Loss Validation Loss Accuracy F1
1 0.3521 0.2914 0.875 0.882
2 0.2456 0.2678 0.890 0.895
3 0.1987 0.2593 0.892 0.899

10. 模型评估

在测试集上评估模型性能：

eval_results = trainer.evaluate(tokenized_datasets["test"])
print(eval_results)

trainer.evaluate()：计算并返回测试集上的指标（accuracy 和 F1）。
输出示例：

{'eval_loss': 0.2593, 'eval_accuracy': 0.892, 'eval_f1': 0.899, 'eval_runtime': 2.34}

11. 模型预测

对测试集或新输入进行预测：

预测整个测试集

predictions = trainer.predict(tokenized_datasets["test"])
print(predictions.metrics)

trainer.predict()：返回预测结果，包括 logits、标签和评估指标。

输出示例：

{'test_loss': 0.2593, 'test_accuracy': 0.892, 'test_f1': 0.899}

预测单个句子

from transformers import pipeline

model.config.id2label = {0: "负向", 1: "正向"} # 定义标签映射
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0)
sen = "我觉得不错！"
result = pipe(sen)
print(result)

pipeline：快速构建推理管道。
id2label：将数字标签映射为人类可读的标签。
输出示例：

[{'label': '正向', 'score': 0.95}]

总结

通过以上步骤，你可以使用 Trainer 完成以下任务：

数据加载与预处理。
模型配置与训练。
评估模型性能。
对新数据进行预测。

`Trainer` 的优点

简洁：无需手动编写训练循环。
灵活：支持自定义评估指标和超参数。
高效：内置优化（如动态填充、多 GPU 支持）。

evaluate

Thu, 13 Mar 2025 10:40:16 +0800

`evaluate` 库使用指南

evaluate 是一个强大的 Python 库，用于计算和可视化机器学习模型的评估指标。本教程将带你逐步了解如何使用该库，包括加载评估函数、计算指标以及可视化结果。

1. 查看支持的评估函数

evaluate 库支持多种评估指标，例如 accuracy（准确率）、f1（F1 分数）、precision（精确率）和 recall（召回率）。你可以通过以下方式查看支持的评估函数：

import evaluate

# 查看支持的评估函数列表
evaluate.list_evaluation_modules()

注意：截至 2024-01-11，list_evaluation_modules() 可能无法完整显示所有支持的指标，但这不影响使用。你可以在 Hugging Face 官网查看完整的评估函数列表。

2. 加载评估函数

要使用某个评估指标，首先需要加载它。例如，加载 accuracy 指标：

accuracy = evaluate.load("accuracy")

这个加载很容易由于网络问题不能加载

这会返回一个评估对象，你可以用它来计算准确率。

3. 查看函数说明

加载评估函数后，可以查看其描述和输入要求：

# 查看指标的描述
print(accuracy.description)

# 查看输入参数的说明
print(accuracy.inputs_description)

# 查看评估对象的详细信息
print(accuracy)

输出将告诉你该指标的作用以及它期望的输入格式。例如，accuracy 需要 references（真实标签）和 predictions（预测标签）。

4. 评估指标计算

4.1 全局计算

你可以一次性计算整个数据集的指标：

accuracy = evaluate.load("accuracy")
results = accuracy.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])
print(results)

输出示例：

{'accuracy': 0.5}

这里，references 是真实标签，predictions 是模型预测结果。结果显示准确率为 50%。

4.2 迭代计算

如果数据量很大，可以通过迭代的方式逐步添加数据：

单样本迭代

accuracy = evaluate.load("accuracy")
for ref, pred in zip([0, 1, 0, 1], [1, 0, 0, 1]):
 accuracy.add(references=ref, predictions=pred)
result = accuracy.compute()
print(result)

批量迭代

accuracy = evaluate.load("accuracy")
for refs, preds in zip([[0, 1], [0, 1]], [[1, 0], [0, 1]]):
 accuracy.add_batch(references=refs, predictions=preds)
result = accuracy.compute()
print(result)

两种方法都适合处理流式数据或大数据集。

5. 多个评估指标计算

你可以使用 evaluate.combine 同时加载多个指标：

clf_metrics = evaluate.combine(["accuracy", "f1", "recall", "precision"])
print(clf_metrics)

然后一次性计算所有指标：

results = clf_metrics.compute(predictions=[0, 1, 0], references=[0, 1, 1])
print(results)

输出示例：

{'accuracy': 0.6667, 'f1': 0.6667, 'recall': 0.5, 'precision': 1.0}

这对于分类任务非常有用，可以全面评估模型性能。

6. 评估结果对比可视化

evaluate 提供了可视化工具，目前支持雷达图（radar_plot）：

from evaluate.visualization import radar_plot

# 准备数据
data = [
 {"accuracy": 0.99, "precision": 0.8, "f1": 0.95, "latency_in_seconds": 33.6},
 {"accuracy": 0.98, "precision": 0.87, "f1": 0.91, "latency_in_seconds": 11.2},
 {"accuracy": 0.98, "precision": 0.78, "f1": 0.88, "latency_in_seconds": 87.6},
 {"accuracy": 0.88, "precision": 0.78, "f1": 0.81, "latency_in_seconds": 101.6}
]
model_names = ["Model 1", "Model 2", "Model 3", "Model 4"]

# 生成雷达图
plot = radar_plot(data=data, model_names=model_names)

这将生成一个雷达图，比较不同模型在多个指标上的表现。每个模型用一条线表示，指标（如 accuracy、f1 等）分布在图的轴上。

总结

通过本教程，你学会了如何：

查看和加载 evaluate 库支持的评估指标。
使用全局或迭代方法计算单个指标。
组合多个指标进行综合评估。
可视化评估结果以对比模型性能。

evaluate 库简单易用，特别适合机器学习从业者和研究人员快速评估模型。更多信息可参考官方文档。

datasets

Thu, 13 Mar 2025 10:38:50 +0800

Hugging Face Datasets 库基本使用教程

Hugging Face 的 datasets 库是一个强大的工具，用于加载、处理和管理数据集，尤其在自然语言处理 (NLP) 任务中非常流行。本教程将结合你的代码，逐步讲解其基本用法。

1. 环境准备

首先，确保你安装了必要的库：

pip install datasets transformers

然后导入相关模块：

import transformers
from datasets import load_dataset, Dataset, load_from_disk

2. 加载在线数据集

2.1 加载完整数据集

可以通过 load_dataset 函数直接加载 Hugging Face Hub 上的在线数据集。例如：

datasets = load_dataset("madao33/new-title-chinese")
print(datasets)

输出会显示数据集的结构，通常包含 train、validation 和 test 等划分。

2.2 加载特定任务数据集

有些数据集是集合（如 super_glue），可以指定加载某项任务：

boolq_dataset = load_dataset("super_glue", "boolq")
print(boolq_dataset)

2.3 按划分加载

可以指定加载某个具体划分（如 train）：

dataset = load_dataset("madao33/new-title-chinese", split="train")
print(dataset)

还可以加载部分数据：

指定范围：train[10:100]（第10到100条）
指定百分比：train[:50%]（前50%）
自定义划分：["train[:50%]", "train[50%:]"]（分成两部分）

dataset = load_dataset("madao33/new-title-chinese", split="train[:50%]")
print(dataset)

8. 加载本地数据集

8.1 加载单个文件

支持多种格式（如 CSV）：

dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
print(dataset)

或使用 Dataset.from_csv：

dataset = Dataset.from_csv("./ChnSentiCorp_htl_all.csv")

8.2 加载多个文件

加载文件夹内所有文件：

dataset = load_dataset("csv", data_files=["./all_data/file1.csv", "./all_data/file2.csv"], split="train")

8.3 从 Pandas 转换

import pandas as pd
data = pd.read_csv("./ChnSentiCorp_htl_all.csv")
dataset = Dataset.from_pandas(data)

8.4 从 List 转换

需要明确字段名：

data = [{"text": "abc"}, {"text": "def"}]
dataset = Dataset.from_list(data)

8.5 使用自定义脚本

可以编写加载脚本（如 load_script.py）加载复杂数据：

dataset = load_dataset("./load_script.py", split="train")

3. 查看数据集

加载数据集后，可以通过以下方法查看数据：

3.1 访问具体样本

datasets = load_dataset("madao33/new-title-chinese")
print(datasets["train"][0]) # 第一个样本
print(datasets["train"][:2]) # 前两个样本

3.2 访问特定字段

print(datasets["train"]["title"][:5]) # 前5个标题

3.3 查看元信息

print(datasets["train"].column_names) # 列名
print(datasets["train"].features) # 数据类型和特征

4. 数据集划分

4.1 随机划分

将数据集分为训练集和测试集：

dataset = datasets["train"]
split_dataset = dataset.train_test_split(test_size=0.1) # 10%作为测试集
print(split_dataset)

4.2 按标签比例划分

对于分类任务，可以按标签比例划分：

dataset = boolq_dataset["train"]
split_dataset = dataset.train_test_split(test_size=0.1, stratify_by_column="label")
print(split_dataset)

5. 数据选取与过滤

5.1 选取

选择特定索引的样本：

selected = datasets["train"].select([0, 1]) # 取第0和第1个样本
print(selected)

5.2 过滤

根据条件过滤数据：

filter_dataset = datasets["train"].filter(lambda example: "中国" in example["title"])
print(filter_dataset["title"][:5]) # 查看过滤后的前5个标题

6. 数据映射（Map）

map 函数可以对数据集的每个样本应用自定义处理。

6.1 简单映射

给标题添加前缀：

def add_prefix(example):
 example["title"] = 'Prefix: ' + example["title"]
 return example

prefix_dataset = datasets.map(add_prefix)
print(prefix_dataset["train"][:10]["title"])

6.2 使用 Tokenizer 预处理

结合 transformers 的 AutoTokenizer 进行编码：

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")

def preprocess_function(example):
 model_inputs = tokenizer(example["content"], max_length=512, truncation=True)
 labels = tokenizer(example["title"], max_length=32, truncation=True)
 model_inputs["labels"] = labels["input_ids"]
 return model_inputs

processed_datasets = datasets.map(preprocess_function)
print(processed_datasets)

6.3 优化映射

多线程：加速处理

processed_datasets = datasets.map(preprocess_function, num_proc=4)

批量处理：提高效率

processed_datasets = datasets.map(preprocess_function, batched=True)

移除原始列：只保留处理后的字段

processed_datasets = datasets.map(preprocess_function, batched=True, remove_columns=datasets["train"].column_names)

remove_columns=datasets[“train”].column_names 的作用是告诉 datasets.map 在处理完成后，删除原始数据集中的所有列，只保留 process_function 返回的字段。具体原因如下：

减少内存占用：原始列（如 review）可能是长文本，占用大量内存。分词后，input_ids 和 attention_mask 是数值化的表示，通常比原始文本更紧凑。移除原始列可以节省内存，特别是在处理大规模数据集时。
适配模型输入： Hugging Face 的模型（如基于 transformers 的模型）通常只接受特定的输入字段（如 input_ids, attention_mask, token_type_ids, 和 labels）
简化数据结构：在分词后，原始列（如 review）的作用已经完成，保留它们没有实际意义。移除这些列可以让数据集更简洁，便于调试和后续操作。

7. 保存与加载

7.1 保存到本地

processed_datasets.save_to_disk("./processed_data")

7.2 从本地加载

processed_datasets = load_from_disk("./processed_data")
print(processed_datasets)

9. 与 DataCollator 结合使用

DataCollatorWithPadding 可以动态填充数据，适合 PyTorch 的 DataLoader。

9.1 数据预处理

from transformers import DataCollatorWithPadding

dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
dataset = dataset.filter(lambda x: x["review"] is not None)

def process_function(examples):
 tokenized_examples = tokenizer(examples["review"], max_length=128, truncation=True)
 tokenized_examples["labels"] = examples["label"]
 return tokenized_examples

tokenized_dataset = dataset.map(process_function, batched=True, remove_columns=dataset.column_names)

9.2 创建 DataLoader

from torch.utils.data import DataLoader

collator = DataCollatorWithPadding(tokenizer=tokenizer)
dl = DataLoader(tokenized_dataset, batch_size=4, collate_fn=collator, shuffle=True)

# 查看前几个批次
num = 0
for batch in dl:
 print(batch["input_ids"].size()) # 动态填充后的输入尺寸
 num += 1
 if num > 10:
 break

总结

通过本教程，你学会了：

加载在线和本地数据集。
查看和操作数据集（划分、选取、过滤）。
使用 map 进行数据预处理。
保存和加载处理后的数据集。
将数据集与 PyTorch 的 DataLoader 结合使用。

model

Thu, 13 Mar 2025 10:36:03 +0800

使用 Hugging Face Transformers 加载与调用预训练模型教程

本教程将介绍如何使用 Hugging Face 的 transformers 库加载预训练模型（如 hfl/rbt3）、保存模型到本地、以及如何调用模型进行推理。假设你已经安装了 transformers 库（可以通过 pip install transformers 安装）。

1. 环境准备

首先，导入必要的模块：

from transformers import AutoConfig, AutoModel, AutoTokenizer

AutoConfig: 用于加载模型的配置文件。
AutoModel: 用于加载预训练模型。
AutoTokenizer: 用于加载与模型配套的分词器。

2. 在线加载模型

Hugging Face 提供了在线加载模型的便捷方式，前提是你有网络连接。

示例代码

model = AutoModel.from_pretrained("hfl/rbt3", force_download=True)

解释

"hfl/rbt3": 指定要加载的模型名称，这里是 hfl/rbt3，一个基于 BERT 的中文预训练模型。
force_download=True: 强制重新下载模型文件，即使本地已有缓存。
模型会自动下载到本地缓存目录（通常是 ~/.cache/huggingface/transformers）。

3. 下载模型到本地（离线使用）

如果你需要离线使用模型，可以手动下载模型文件。以下是使用 Git 和 Git LFS 的方法：

完整克隆模型仓库

!git clone "https://huggingface.co/hfl/rbt3"

只下载模型权重文件

!git lfs clone "https://huggingface.co/hfl/rbt3" --include="*.bin"

注意事项

需要安装 Git 和 Git LFS（大型文件存储扩展）。
科学上网可能需要配置代理以访问 Hugging Face。
下载后，模型文件会存储在当前目录下的 rbt3 文件夹中。

4. 离线加载模型

假设模型已下载到本地目录 ./rbt3/，可以用以下方式加载：

model = AutoModel.from_pretrained("rbt3")

解释

"rbt3": 如果本地有同名文件夹，Transformers 会优先从本地加载。
如果路径不同，可以指定完整路径，例如 ./path/to/rbt3。

5. 查看与配置模型参数

模型加载后，可以通过 config 查看其配置信息。

示例代码

# 加载模型
model = AutoModel.from_pretrained("rbt3")

# 查看模型配置
print(model.config)

# 单独加载配置
config = AutoConfig.from_pretrained("./rbt3/")
print(config)

# 检查特定配置项
print(config.output_attentions)

解释

model.config: 返回模型的配置对象，包含模型架构、分词器信息等。
AutoConfig.from_pretrained: 可以单独加载配置文件。
output_attentions: 一个布尔值，表示是否输出注意力权重，默认通常为 False。

6. 模型调用

6.1 数据准备

使用分词器将文本转换为模型可接受的输入格式。

sen = "弱小的我也有大梦想！"
tokenizer = AutoTokenizer.from_pretrained("rbt3")
inputs = tokenizer(sen, return_tensors="pt")
print(inputs)

输出

{'input_ids': tensor([[ 101, 2453, 2207, 4638, 2769, 738, 3300, 1920, 3457, 2682, 8013, 102]]),
 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]),
 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}

解释

return_tensors="pt": 返回 PyTorch 张量格式（也可以用 "tf" 返回 TensorFlow 格式）。
input_ids: 分词后的 token ID 序列。
attention_mask: 指示哪些 token 需要被关注（1 表示有效，0 表示填充）。

6.2 不带 Model Head 的调用

加载基础模型，获取隐藏状态或注意力输出。

model = AutoModel.from_pretrained("rbt3", output_attentions=True)
output = model(**inputs)
print(output)
print(output.last_hidden_state.size())
print(len(inputs["input_ids"][0]))

输出

output.last_hidden_state.size(): torch.Size([1, 12, 768])
- 1: 批次大小（batch size）。
- 12: 输入序列长度（包括 [CLS] 和 [SEP]）。
- 768: 隐藏层维度。
len(inputs["input_ids"][0]): 12，与序列长度一致。

解释

output_attentions=True: 输出注意力权重（在 output.attentions 中）。
last_hidden_state: 最后一层的隐藏状态，可用于下游任务。

6.3 带 Model Head 的调用

加载带分类头的模型，用于特定任务（如序列分类）。

from transformers import AutoModelForSequenceClassification

clz_model = AutoModelForSequenceClassification.from_pretrained("rbt3", num_labels=10)
output = clz_model(**inputs)
print(output)
print(clz_model.config.num_labels)

输出

output.logits: 分类的原始分数（logits）。
clz_model.config.num_labels: 10，表示分类类别数。

解释

num_labels=10: 指定分类任务的类别数（默认是 2）。
带 Model Head 的模型会在基础模型上添加任务特定层（这里是分类层）。

7. 总结

通过本教程，你学会了：

在线加载模型: 使用 from_pretrained 从 Hugging Face Hub 下载模型。
离线保存与加载: 通过 Git 下载模型并在本地使用。
模型配置: 查看和调整模型参数。
模型调用: 处理输入文本并获取模型输出（带或不带 Model Head）。

tokenizer

Thu, 13 Mar 2025 10:32:29 +0800

这个教程将逐步解释 Tokenizer 的基本用法，包括加载、分词、索引转换、填充截断、处理批量数据以及 Fast/Slow Tokenizer 的对比。教程将使用中文句子 “弱小的我也有大梦想!” 作为示例。

示例

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained(
 'bert-base-uncased', # 预训练模型名称
 do_lower_case=True, # 是否将文本转换为小写
 max_length=512, # 最大序列长度
 truncation=True, # 是否截断超过最大长度的输入
 padding='max_length' # 填充方式
)

常用参数说明：

from_pretrained: 指定预训练模型的名称或路径。
do_lower_case: 是否对输入进行小写处理。
max_length: 指定 tokenized 后的最大长度。
truncation: 是否截断超长序列。
padding: 填充策略（如True、max_length或longest）。

# 示例文本
text = "Hello, how are you today?"

# 使用tokenizer处理文本
encoded_input = tokenizer(
 text, # 输入文本
 add_special_tokens=True, # 添加特殊标记，如[CLS]和[SEP]
 max_length=128, # 最大长度（与初始化一致）
 truncation=True, # 截断超长部分
 padding='max_length', # 填充到指定长度
 return_tensors='pt' # 返回PyTorch张量（可选：'tf'为TensorFlow，None为Python列表）
)

# 输出结果
print(encoded_input)

对文本进行Tokenization

假设你有一段文本，你可以用tokenizer将它转化为模型可以理解的输入格式：

# 示例文本
text = "Hello, how are you today?"

# 使用tokenizer处理文本
encoded_input = tokenizer(
 text, # 输入文本
 add_special_tokens=True, # 添加特殊标记，如[CLS]和[SEP]
 max_length=128, # 最大长度（与初始化一致）
 truncation=True, # 截断超长部分
 padding='max_length', # 填充到指定长度
 return_tensors='pt' # 返回PyTorch张量（可选：'tf'为TensorFlow，None为Python列表）
)

# 输出结果
print(encoded_input)

输出说明

运行后，encoded_input会是一个字典，包含以下键值：

input_ids: 文本转换为的数字ID序列。
token_type_ids: 用于区分句子对（如果是单句输入，通常全是0）。
attention_mask: 标记哪些位置是真实token（1）哪些是填充（0）。

示例输出可能像这样：

{
 'input_ids': tensor([[ 101, 7592, 1010, 2129, 2024, 2017, 2651, 1029, 102, 0, 0, ...]]),
 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...]]),
 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, ...]])
}

解码回文本（可选）

如果你想检查tokenization的结果，可以用decode方法将ID转换回文本：

decoded_text = tokenizer.decode(encoded_input['input_ids'][0], skip_special_tokens=True)
print(decoded_text) # 输出: "hello how are you today"

处理多段文本

如果有多段文本（比如一个列表），可以这样处理：

texts = ["Hello, how are you?", "I am fine, thanks!"]

encoded_inputs = tokenizer(
 texts,
 add_special_tokens=True,
 max_length=128,
 truncation=True,
 padding='max_length',
 return_tensors='pt'
)

print(encoded_inputs['input_ids']) # 两个句子的input_ids

常见使用场景

单句输入: 如上面的text示例。

句子对: 如果是问答或文本分类任务，可以传入两个句子：

encoded_input = tokenizer("Hello, how are you?", "I am fine!", return_tensors='pt')

批量处理: 处理一个文本列表，用于模型训练或推理。

灵活调整参数

在使用时，你可以根据需求调整参数。例如：

不需要填充：padding=False。
不返回张量：return_tensors=None。
只获取ID：tokenizer.encode(text)（简单方法）。

Tokenizer 使用教程

在这个教程中，我们将学习如何使用 Hugging Face transformers 库中的 AutoTokenizer 来处理自然语言文本。Tokenizer 是自然语言处理 (NLP) 的核心组件，用于将原始文本转换为模型可以理解的数字表示。我们将以中文句子 “弱小的我也有大梦想!” 为例，逐步展示 Tokenizer 的功能。

环境准备

首先，确保你已经安装了 transformers 库。如果没有安装，可以通过以下命令安装：

pip install transformers

然后，导入必要的库：

from transformers import AutoTokenizer

示例句子

我们将使用以下句子作为示例：

sen = "弱小的我也有大梦想!"

Step 1: 加载与保存 Tokenizer

从 Hugging Face 加载 Tokenizer

AutoTokenizer.from_pretrained 方法允许我们从 Hugging Face 的模型仓库加载预训练的 Tokenizer。这里我们使用 "uer/roberta-base-finetuned-dianping-chinese" 模型的 Tokenizer：

tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")
print(tokenizer)

输出会显示 Tokenizer 的类型和配置信息。

保存 Tokenizer 到本地

可以将加载的 Tokenizer 保存到本地目录：

tokenizer.save_pretrained("./roberta_tokenizer")

从本地加载 Tokenizer

从本地目录加载保存的 Tokenizer：

tokenizer = AutoTokenizer.from_pretrained("./roberta_tokenizer/")
print(tokenizer)

Step 2: 句子分词

Tokenizer 的核心功能是将句子拆分为词或子词单元（tokens）。使用 tokenize 方法：

tokens = tokenizer.tokenize(sen)
print(tokens)

输出示例：

['弱', '小', '的', '我', '也', '有', '大', '梦', '想', '!']

这些 tokens 是模型词汇表中的基本单元。

Step 3: 查看词典

Tokenizer 内部维护了一个词汇表（vocab），可以通过以下方式查看：

获取词汇表

vocab = tokenizer.vocab
print(vocab) # 输出词典（键是 token，值是对应的 ID）

获取词汇表大小

vocab_size = tokenizer.vocab_size
print(vocab_size) # 输出词汇表中的 token 数量，例如 21128

Step 4: 索引转换

在 NLP 中，模型需要将 tokens 转换为数字 ID。我们可以使用以下方法实现转换：

Tokens 转 ID

ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)

输出示例：

[2201, 2207, 4638, 2769, 738, 3300, 1920, 3457, 2682, 106]

ID 转 Tokens

tokens = tokenizer.convert_ids_to_tokens(ids)
print(tokens)

输出示例：

['弱', '小', '的', '我', '也', '有', '大', '梦', '想', '!']

Tokens 转字符串

str_sen = tokenizer.convert_tokens_to_string(tokens)
print(str_sen)

输出示例：

弱小的我也有大梦想!

更便捷的方式：编码与解码

编码（字符串 → ID）

ids = tokenizer.encode(sen, add_special_tokens=True)
print(ids)

输出示例（包含特殊 token，如 [CLS] 和 [SEP]）：

[101, 2201, 2207, 4638, 2769, 738, 3300, 1920, 3457, 2682, 106, 102]

解码（ID → 字符串）

str_sen = tokenizer.decode(ids, skip_special_tokens=False)
print(str_sen)

输出示例：

[CLS] 弱小的我也有大梦想! [SEP]

如果不需要特殊 token，可以设置 skip_special_tokens=True。

Step 5: 填充与截断

在处理批量数据时，句子长度可能不同，需要进行填充（padding）或截断（truncation）。

填充

将句子填充到指定长度（例如 15）：

ids = tokenizer.encode(sen, padding="max_length", max_length=15)
print(ids)

输出示例（0 表示填充）：

[101, 2201, 2207, 4638, 2769, 738, 3300, 1920, 3457, 2682, 106, 102, 0, 0, 0]

截断

将句子截断到指定长度（例如 5）：

ids = tokenizer.encode(sen, max_length=5, truncation=True)
print(ids)

输出示例：

[101, 2201, 2207, 4638, 102]

Step 6: 其他输入部分

模型通常需要额外的输入，例如 attention_mask 和 token_type_ids。

ids = tokenizer.encode(sen, padding="max_length", max_length=15)
attention_mask = [1 if idx != 0 else 0 for idx in ids] # 1 表示有效 token，0 表示填充
token_type_ids = [0] * len(ids) # 用于区分句子对，这里全为 0
print(ids)
print(attention_mask)
print(token_type_ids)

输出示例：

[101, 2201, 2207, 4638, 2769, 738, 3300, 1920, 3457, 2682, 106, 102, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Step 7: 快速调用方式

encode_plus 或直接调用 tokenizer 可以一次性返回所有输入：

inputs = tokenizer.encode_plus(sen, padding="max_length", max_length=15)
print(inputs)

或者更简洁：

inputs = tokenizer(sen, padding="max_length", max_length=15)
print(inputs)

输出示例（字典形式）：

{'input_ids': [101, 2201, 2207, 4638, 2769, 738, 3300, 1920, 3457, 2682, 106, 102, 0, 0, 0], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0]}

Step 8: 处理批量数据

可以一次性处理多个句子：

sens = ["弱小的我也有大梦想",
 "有梦想谁都了不起",
 "追逐梦想的心，比梦想本身，更可贵"]
res = tokenizer(sens)
print(res)

输出示例（字典形式，包含多个句子的编码）。

性能对比

单条循环处理

%%time
for i in range(1000):
 tokenizer(sen)

批量处理

%%time
res = tokenizer([sen] * 1000)

批量处理通常比单条循环更快。

Step 9: Fast vs Slow Tokenizer

Hugging Face 提供了 Fast Tokenizer（基于 Rust）和 Slow Tokenizer（基于 Python），Fast Tokenizer 速度更快且功能更丰富。

加载 Fast Tokenizer

fast_tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")
print(fast_tokenizer)

加载 Slow Tokenizer

slow_tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese", use_fast=False)
print(slow_tokenizer)

性能对比

单条循环处理

%%time
for i in range(10000):
 fast_tokenizer(sen)

%%time
for i in range(10000):
 slow_tokenizer(sen)

批量处理

%%time
res = fast_tokenizer([sen] * 10000)

%%time
res = slow_tokenizer([sen] * 10000)

Fast Tokenizer 通常比 Slow Tokenizer 快得多。

Fast Tokenizer 的额外功能

Fast Tokenizer 支持返回 token 的字符偏移量：

inputs = fast_tokenizer(sen, return_offsets_mapping=True)
print(inputs)
print(inputs.word_ids()) # 每个 token 对应的单词索引

Slow Tokenizer 不支持此功能。

Step 10: 加载特殊 Tokenizer

某些模型（如 ChatGLM 或 Skywork）的 Tokenizer 需要特殊加载方式：

tokenizer = AutoTokenizer.from_pretrained("Skywork/Skywork-13B-base", trust_remote_code=True)
print(tokenizer)

保存和加载：

tokenizer.save_pretrained("skywork_tokenizer")
tokenizer = AutoTokenizer.from_pretrained("skywork_tokenizer", trust_remote_code=True)

编码与解码：

print(tokenizer.decode(tokenizer.encode(sen)))

总结

通过这个教程，我们学习了如何使用 AutoTokenizer 加载、分词、编码、解码、处理批量数据，以及 Fast/Slow Tokenizer 的区别。Tokenizer 是 NLP 任务中不可或缺的工具，掌握其用法将为后续的模型训练和推理奠定基础。

pipeline

Thu, 13 Mar 2025 10:00:55 +0800

Hugging Face `transformers.pipeline` 教程

pipeline 是 Hugging Face transformers 库提供的高层次接口，可以快速调用预训练模型完成 NLP、图像处理等任务。本教程将带你从基础用法到进阶技巧全面掌握 pipeline。

1. 查看支持的任务类型

pipeline 支持多种任务，可以通过 SUPPORTED_TASKS 查看：

from transformers.pipelines import SUPPORTED_TASKS

# 打印所有支持的任务及其详细信息
for task, details in SUPPORTED_TASKS.items():
 print(f"任务: {task}")
 print(f"详细信息: {details}\n")

常见任务示例：

text-classification：文本分类（如情感分析）
text-generation：文本生成
question-answering：问答
zero-shot-object-detection：零样本目标检测

完整列表请参考官方文档。

2. 创建与使用 `pipeline`

2.1 直接根据任务类型创建（默认模型）

默认使用英文模型，适合快速上手：

from transformers import pipeline

# 创建文本分类 pipeline
pipe = pipeline("text-classification")

# 输入文本列表
results = pipe(["very good!", "very bad!"])
print(results)

输出：

[{'label': 'POSITIVE', 'score': 0.9998}, {'label': 'NEGATIVE', 'score': 0.9987}]

2.2 指定任务和模型

选择特定模型（如中文模型）以适配需求：

# 使用中文情感分析模型
pipe = pipeline("text-classification", model="uer/roberta-base-finetuned-dianping-chinese")

# 分析中文文本
result = pipe("我觉得不太行！")
print(result)

输出：

[{'label': 'negative', 'score': 0.987}]

模型选择：可在 Hugging Face Model Hub 搜索适合的模型。

2.3 预加载模型和分词器

更灵活的方式，先加载模型和分词器，再创建 pipeline：

from transformers import AutoModelForSequenceClassification, AutoTokenizer

# 加载模型和分词器
model = AutoModelForSequenceClassification.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")
tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")

# 创建 pipeline
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer)

# 使用
result = pipe("我觉得不太行！")
print(result)

输出：

Device set to use cpu
[{'label': 'negative (stars 1, 2 and 3)', 'score': 0.9735506772994995}]

3. 性能优化：使用 GPU 推理

默认情况下，pipeline 使用 CPU。可以通过 device 参数切换到 GPU：

# 指定 device=0 使用第一个 GPU
pipe = pipeline("text-classification", model="uer/roberta-base-finetuned-dianping-chinese", device=0)

# 检查模型运行设备
print(pipe.model.device) # 输出: cuda:0

# 测试推理速度
import torch
import time

times = []
for _ in range(100):
 torch.cuda.synchronize() # 同步 GPU
 start = time.time()
 pipe("我觉得不太行！")
 torch.cuda.synchronize()
 end = time.time()
 times.append(end - start)

print(f"平均推理时间: {sum(times) / 100:.4f} 秒")

对比：在 CPU 上运行相同代码（device=-1），GPU 通常显著更快。

4. 参数调整与高级用法

4.1 问答任务示例

调整参数以控制输出：

qa_pipe = pipeline("question-answering", model="uer/roberta-base-chinese-extractive-qa")

# 输入问题和上下文
result = qa_pipe(
 question="中国的首都是哪里？",
 context="中国的首都是北京",
 max_answer_len=5 # 限制答案长度
)
print(result)

输出：

{'score': 0.99, 'start': 6, 'end': 8, 'answer': '北京'}

4.2 图像任务：零样本目标检测

处理图像任务需要额外依赖（如 Pillow）：

from transformers import pipeline
from PIL import Image, ImageDraw
import requests

# 创建零样本目标检测 pipeline
detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection")

# 下载并打开图片
url = "https://unsplash.com/photos/oj0zeY2Ltk4/download?force=true&w=640"
img = Image.open(requests.get(url, stream=True).raw)

# 检测对象
predictions = detector(img, candidate_labels=["hat", "sunglasses", "book"])
print(predictions)

# 绘制结果
draw = ImageDraw.Draw(img)
for pred in predictions:
 box = pred["box"]
 draw.rectangle((box["xmin"], box["ymin"], box["xmax"], box["ymax"]), outline="red", width=1)
 draw.text((box["xmin"], box["ymin"]), f"{pred['label']}: {pred['score']:.2f}", fill="red")
img.show() # 显示图片

5. `pipeline` 背后的实现

理解底层过程有助于调试和自定义：

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# 加载分词器和模型
tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")
model = AutoModelForSequenceClassification.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")

# 输入文本
input_text = "我觉得不太行！"
inputs = tokenizer(input_text, return_tensors="pt") # 转换为张量

# 模型推理
outputs = model(**inputs)
logits = outputs.logits
probs = torch.softmax(logits, dim=-1) # 转换为概率

# 获取预测结果
pred_id = torch.argmax(probs).item()
result = model.config.id2label[pred_id] # 从 ID 映射到标签
print(f"预测结果: {result}")

输出：

预测结果: negative

流程解析：

分词：tokenizer 将文本转为模型可理解的输入。
推理：model 输出 logits（原始分数）。
后处理：通过 softmax 和 argmax 转换为标签。

6. 注意事项与技巧

模型下载：首次运行会自动下载模型，需联网。
中文支持：选择中文模型（如 uer/roberta-base-chinese）以提升效果。
参数调整：如 max_length、truncation=True 可处理长文本。
硬件：大型模型建议使用 GPU（检查 torch.cuda.is_available()）。

7. 结语

通过 pipeline，你可以快速实现从文本分类到图像检测的多种任务。如果需要更深入的定制，可以参考底层实现部分，或访问 Hugging Face 文档。

scipy

Thu, 27 Feb 2025 00:00:00 +0000

SCiPY

scipy.interpolate

interp1d

代码

from scipy.interpolate import interp1d
import numpy as np

# 示例数据
x_original = np.array([400, 500, 600, 700]) # 原始波长
y_original = np.array([0.1, 0.3, 0.6, 0.9]) # 对应的测量值
x_new = np.linspace(400, 700, 100) # 新的波长点（目标插值点）

# 创建插值函数
interp_func = interp1d(x_original, y_original, kind='linear', fill_value="extrapolate")

# 使用插值函数计算新点的值
y_new = interp_func(x_new)

# 打印结果
print("原始波长:", x_original)
print("原始测量值:", y_original)
print("插值后的波长:", x_new)
print("插值后的测量值:", y_new)

参数解释

x_original 和 y_original:
- 这是已知的原始数据点，分别表示波长和对应的测量值。
- 它们必须是一维数组，并且长度相同。
kind:
- 指定插值方法，常用选项包括：
  - 'linear'：线性插值（默认）。
  - 'nearest'：最近邻插值。
  - 'quadratic' 或 'cubic'：二次或三次样条插值。
- 根据数据的平滑性和需求选择合适的插值方法。
fill_value:
- 当插值点超出原始数据范围时的处理方式。
- 默认情况下会抛出错误，但可以通过设置 fill_value="extrapolate" 允许外推。
x_new:
- 需要插值到的新点，可以是一个标量或数组。

数据科学 on 扎塔-Zata

sklearn使用教程

pipeline的构建

1. Pipeline基本概念与规则

2. Pipeline运行机制

3. 自定义转换器

4. 完整Pipeline构建流程

5. 使用ColumnTransformer简化Pipeline构建

6. Pipeline的优势

7. 最佳实践建议

onnx使用教程

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

什么是 ONNX？

为什么需要 ONNX？

ONNX 核心使用教程

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

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

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

实践中的注意事项

总结

numpy使用教程

NumPy 教程

2. 创建数组

3. 数组属性

4. 数组操作

5. 索引和切片

6. 数学和统计函数

7. 线性代数

8. 保存和加载数据

9. 性能优化提示

10. 常见问题与调试

1. 广播机制（Broadcasting）

2. 数组拼接与分割

3. 排序与搜索

4. 随机数生成

5. 结构化数组

6. 高级数学运算

7. 内存优化与大数组处理

8. 实际应用示例：数据分析

9. 与 Pandas 结合

10. 调试与性能提升

pandas使用教程

Pandas 使用教程

1. 安装 Pandas

2. Pandas 的核心数据结构

2.1 Series

创建 Series

Series 的属性和方法

2.2 DataFrame

创建 DataFrame

3. 数据加载与保存

3.1 读取数据

3.2 保存数据

4. 数据查看与选择

4.1 查看数据

4.2 选择数据

选择列

选择行

loc: 基于标签的索引

iloc: 基于整数位置的索引

条件选择 (布尔索引)

5. 数据清洗

5.1 处理缺失值 (NaN)

5.2 处理重复数据

5.3 数据类型转换

6. 数据操作

6.1 添加和删除列

6.2 应用函数 (apply, map, applymap)

apply()

map()

applymap()

6.3 排序

7. 分组 (Group By)

8. 合并与连接 (Merge, Join, Concat)

8.1 concat(): 拼接

8.2 merge(): 数据库风格的连接

8.3 join(): 基于索引的连接

9. 时间序列数据

10. 绘图 (Plotting)

使用技巧

3. `自定义转换器`

`loc`: 基于标签的索引

`iloc`: 基于整数位置的索引

`apply()`

`map()`

`applymap()`

8.1 `concat()`: 拼接

8.2 `merge()`: 数据库风格的连接

8.3 `join()`: 基于索引的连接

使用 `Trainer` 进行文本分类的教程

7. 配置 `TrainingArguments`

8. 创建 `Trainer`

`Trainer` 的优点

`evaluate` 库使用指南