「日拱一码」022 机器学习——数据划分

目录

基于单次随机划分的方法

普通单次随机划分（train_test_split）

分层单次随机划分(使用  train_test_split  的  stratify  参数)

基于多次随机划分的方法

普通多次随机划分(ShuffleSplit)

分层多次随机划分（StratifiedShuffleSplit）

 基于交叉验证的方法

K 折交叉验证（KFold）

分层 K 折交叉验证（StratifiedKFold）

 基于分组划分的方法

分组随机划分（GroupShuffleSplit）

分组 K 折交叉验证（GroupKFold）

分组分层 K 折交叉验证（StratifiedGroupKFold）

基于时间序列划分的方法

基于自定义划分的方法

数据划分是数据预处理中的一个重要环节，通常用于将数据集分为训练集、验证集和测试集，以便在机器学习或数据分析中进行模型训练、超参数调整和性能评估。以下是几种常见的数据划分方法：

基于单次随机划分的方法

普通单次随机划分（train_test_split）

普通单次随机划分是将数据集随机分为训练集和测试集（或训练集、验证集和测试集）。这种方法适用于数据分布较为均匀的情况

## 基于单次随机划分的方法
# 创建数据集import numpy as np
import pandas as pd
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split# 创建一个简单的分类数据集,100个样本,4个特征,2个相关特征,2个冗余特征
X, y = make_classification(n_samples=100, n_features=4, n_informative=2, n_redundant=2, random_state=42)# 将数据转换为 DataFrame
df = pd.DataFrame(X, columns=['Feature1', 'Feature2', 'Feature3', 'Feature4'])
df['Label'] = y# 添加分组信息（假设每个样本属于一个组）
df['Group'] = np.random.choice(['Group1', 'Group2', 'Group3'], size=len(df), p=[0.4, 0.3, 0.3])# 添加时间戳信息（假设数据是按时间顺序生成的）
df['Timestamp'] = pd.date_range(start='2025-01-01', periods=len(df), freq='D')# print(df)
#     Feature1  Feature2  Feature3  Feature4  Label   Group  Timestamp
# 0  -1.053839 -1.027544 -0.329294  0.826007      1  Group1 2025-01-01
# 1   1.569317  1.306542 -0.239385 -0.331376      0  Group1 2025-01-02
# 2  -0.358856 -0.691021 -1.225329  1.652145      1  Group2 2025-01-03
# 3  -0.136856  0.460938  1.896911 -2.281386      0  Group3 2025-01-04
# 4  -0.048629  0.502301  1.778730 -2.171053      0  Group2 2025-01-05
# ..       ...       ...       ...       ...    ...     ...        ...
# 95 -2.241820 -1.248690  2.357902 -2.009185      0  Group2 2025-04-06
# 96  0.573042  0.362054 -0.462814  0.341294      1  Group2 2025-04-07
# 97 -0.375121 -0.149518  0.588465 -0.575002      0  Group2 2025-04-08
# 98  1.594888  0.780256 -2.030223  1.863789      1  Group1 2025-04-09
# 99 -0.149941 -0.566037 -1.416933  1.804741      1  Group1 2025-04-10
#
# [100 rows x 7 columns]# 普通单次随机划分(train_test_split)
X_train, X_test, y_train, y_test = train_test_split(df.drop(columns=['Label', 'Group', 'Timestamp']), df['Label'], test_size=0.2, random_state=42)print("普通单次随机划分结果：")
print("训练集大小：", X_train.shape) # (80, 4)
print("测试集大小：", X_test.shape) # (20, 4)

分层单次随机划分(使用  train_test_split  的  stratify  参数)

分层单次随机划分是在随机划分的基础上，确保每个划分后的子集在目标变量的分布上与原始数据集保持一致。这对于分类问题尤其重要，特别是当数据集中某些类别样本较少时

# 分层单次随机划分X_train_strat, X_test_strat, y_train_strat, y_test_strat = train_test_split(df.drop(columns=['Label', 'Group', 'Timestamp']), df['Label'], test_size=0.2, stratify=df['Label'], random_state=42)print("分层单次随机划分结果：")
print("训练集标签分布：", y_train_strat.value_counts())
# Label
# 0    40
# 1    40
# Name: count, dtype: int64
print("测试集标签分布：", y_test_strat.value_counts())
# Label
# 1    10
# 0    10
# Name: count, dtype: int64

基于多次随机划分的方法

普通多次随机划分(ShuffleSplit)

普通多次随机划分会随机打乱数据，然后根据指定的比例划分训练集和测试集，划分时不考虑目标变量（标签）的分布。

## 基于多次随机划分的方法
# 普通多次随机划分ShuffleSplitfrom sklearn.model_selection import ShuffleSplit, StratifiedShuffleSplit
ss = ShuffleSplit(n_splits=5, test_size=0.2, random_state=42)for fold, (train_idx, test_idx) in enumerate(ss.split(df)):train_data = df.iloc[train_idx]test_data = df.iloc[test_idx]print(f"第 {fold + 1} 次划分：")print("训练集大小：", train_data.shape)print("测试集大小：", test_data.shape)print("训练集标签分布：", train_data['Label'].value_counts())print("测试集标签分布：", test_data['Label'].value_counts())print()
# 第 1 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 0    42
# 1    38
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    12
# 0     8
# Name: count, dtype: int64
# 
# 第 2 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 0    43
# 1    37
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    13
# 0     7
# Name: count, dtype: int64
# 
# 第 3 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    10
# 0    10
# Name: count, dtype: int64
# 
# 第 4 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 1    42
# 0    38
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    12
# 1     8
# Name: count, dtype: int64
# 
# 第 5 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 0    41
# 1    39
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    11
# 0     9
# Name: count, dtype: int64

分层多次随机划分（StratifiedShuffleSplit）

分层多次随机划分会在划分数据时保持目标变量（标签）的分布与原始数据集一致

# 分层多次随机划分StratifiedShuffleSplitsss = StratifiedShuffleSplit(n_splits=5, test_size=0.2, random_state=42)for fold, (train_idx, test_idx) in enumerate(sss.split(df.drop(columns=['Label']), df['Label'])):train_data = df.iloc[train_idx]test_data = df.iloc[test_idx]print(f"第 {fold + 1} 次划分：")print("训练集大小：", train_data.shape)print("测试集大小：", test_data.shape)print("训练集标签分布：", train_data['Label'].value_counts())print("测试集标签分布：", test_data['Label'].value_counts())print()
# 第 1 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 0    40
# 1    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    10
# 0    10
# Name: count, dtype: int64
#
# 第 2 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    10
# 1    10
# Name: count, dtype: int64
#
# 第 3 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    10
# 1    10
# Name: count, dtype: int64
#
# 第 4 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    10
# 0    10
# Name: count, dtype: int64
#
# 第 5 次划分：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 训练集标签分布： Label
# 0    40
# 1    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    10
# 0    10
# Name: count, dtype: int64

 基于交叉验证的方法

交叉验证是一种更稳健的划分方法，通过多次划分数据集并训练模型，可以更好地评估模型的性能

K 折交叉验证（KFold）

将数据集分为 K 个子集，每次选择一个子集作为测试集，其余作为训练集，重复 K 次

## 基于交叉验证的方法
# K折交叉验证
from sklearn.model_selection import KFold# K 折交叉验证
kf = KFold(n_splits=5, shuffle=True, random_state=42)for fold, (train_idx, test_idx) in enumerate(kf.split(df)):train_data_kfold = df.iloc[train_idx]test_data_kfold = df.iloc[test_idx]print(f"第 {fold + 1} 折：")print("训练集大小：", train_data_kfold.shape)print("测试集大小：", test_data_kfold.shape)
# 第 1 折：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 第 2 折：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 第 3 折：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 第 4 折：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)
# 第 5 折：
# 训练集大小： (80, 7)
# 测试集大小： (20, 7)

分层 K 折交叉验证（StratifiedKFold）

在 K 折交叉验证的基础上，确保每个子集在目标变量的分布上与原始数据集保持一致

# 分层 K 折交叉验证
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)for fold, (train_idx, test_idx) in enumerate(skf.split(df.drop(columns=['Label', 'Group', 'Timestamp']), df['Label'])):train_data_skfold = df.iloc[train_idx]test_data_skfold = df.iloc[test_idx]print(f"第 {fold + 1} 折：")print("训练集标签分布：", train_data_skfold['Label'].value_counts())print("测试集标签分布：", test_data_skfold['Label'].value_counts())
# 第 1 折：
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    10
# 1    10
# Name: count, dtype: int64
# 第 2 折：
# 训练集标签分布： Label
# 0    40
# 1    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    10
# 0    10
# Name: count, dtype: int64
# 第 3 折：
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    10
# 1    10
# Name: count, dtype: int64
# 第 4 折：
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    10
# 0    10
# Name: count, dtype: int64
# 第 5 折：
# 训练集标签分布： Label
# 1    40
# 0    40
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    10
# 1    10
# Name: count, dtype: int64

 基于分组划分的方法

当数据中存在分组结构时（例如用户、实验组等），需要确保每个划分后的子集中包含完整的分组，而不是将同一组的数据分到不同的子集中

分组随机划分（GroupShuffleSplit）

分组随机划分是一种随机划分方法，它会随机选择完整的分组作为训练集和测试集。这种方法可以确保同一组的数据不会被拆分到不同的子集中

## 基于分组划分的方法
from sklearn.model_selection import GroupShuffleSplit# 分组随机划分 GroupShuffleSplit
gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
train_idx, test_idx = next(gss.split(df.drop(columns=['Label', 'Group']), df['Label'], groups=df['Group']))train_data_gss = df.iloc[train_idx]
test_data_gss = df.iloc[test_idx]print("分组随机划分结果：")
print("训练集大小：", train_data_gss.shape) # (64, 7)
print("测试集大小：", test_data_gss.shape) # (36, 7)
print("训练集分组分布：", train_data_gss['Group'].value_counts())
# Group
# Group2    34
# Group3    30
# Name: count, dtype: int64
print("测试集分组分布：", test_data_gss['Group'].value_counts())
# Group
# Group1    36
# Name: count, dtype: int64

分组 K 折交叉验证（GroupKFold）

分组 K 折交叉验证是一种多次划分方法，它将数据集分为 K 个子集，每次选择一个子集作为测试集，其余作为训练集。与普通 K 折不同的是，分组 K 折确保每个子集包含完整的分组

from sklearn.model_selection import GroupKFold# 分组K折交叉划分 GroupKFold
gkf = GroupKFold(n_splits=3)for fold, (train_idx, test_idx) in enumerate(gkf.split(df.drop(columns=['Label', 'Group']), df['Label'], groups=df['Group'])):train_data_gkf = df.iloc[train_idx]test_data_gkf = df.iloc[test_idx]print(f"第 {fold + 1} 折：")print("训练集大小：", train_data_gkf.shape)print("测试集大小：", test_data_gkf.shape)print("训练集分组分布：", train_data_gkf['Group'].value_counts())print("测试集分组分布：", test_data_gkf['Group'].value_counts())
# 第 1 折：
# 训练集大小： (58, 7)
# 测试集大小： (42, 7)
# 训练集分组分布： Group
# Group3    31
# Group2    27
# Name: count, dtype: int64
# 测试集分组分布： Group
# Group1    42
# Name: count, dtype: int64
# 第 2 折：
# 训练集大小： (69, 7)
# 测试集大小： (31, 7)
# 训练集分组分布： Group
# Group1    42
# Group2    27
# Name: count, dtype: int64
# 测试集分组分布： Group
# Group3    31
# Name: count, dtype: int64
# 第 3 折：
# 训练集大小： (73, 7)
# 测试集大小： (27, 7)
# 训练集分组分布： Group
# Group1    42
# Group3    31
# Name: count, dtype: int64
# 测试集分组分布： Group
# Group2    27
# Name: count, dtype: int64

分组分层 K 折交叉验证（StratifiedGroupKFold）

分组分层 K 折交叉验证结合了分组和分层的思想。它不仅确保同一组的数据不会被拆分，还保证了每个子集在目标变量的分布上与原始数据集一致

from sklearn.model_selection import KFold
import numpy as npclass StratifiedGroupKFold:def __init__(self, n_splits=5):self.n_splits = n_splitsdef split(self, X, y, groups):unique_groups = np.unique(groups)group_to_y = {group: y[groups == group] for group in unique_groups}group_to_idx = {group: np.where(groups == group)[0] for group in unique_groups}# Sort groups by the proportion of positive labelssorted_groups = sorted(unique_groups, key=lambda g: np.mean(group_to_y[g]))# Split groups into foldsfolds = np.array_split(sorted_groups, self.n_splits)for fold in folds:test_idx = np.concatenate([group_to_idx[group] for group in fold])train_idx = np.setdiff1d(np.arange(len(groups)), test_idx)yield train_idx, test_idx# 分组分层K折交叉划分 StratifiedGroupKFold
sgkf = StratifiedGroupKFold(n_splits=3)for fold, (train_idx, test_idx) in enumerate(sgkf.split(df.drop(columns=['Label', 'Group']), df['Label'], groups=df['Group'])):train_data_sgkf = df.iloc[train_idx]test_data_sgkf = df.iloc[test_idx]print(f"第 {fold + 1} 折：")print("训练集大小：", train_data_sgkf.shape)print("测试集大小：", test_data_sgkf.shape)print("训练集分组分布：", train_data_sgkf['Group'].value_counts())print("测试集分组分布：", test_data_sgkf['Group'].value_counts())print("训练集标签分布：", train_data_sgkf['Label'].value_counts())print("测试集标签分布：", test_data_sgkf['Label'].value_counts())
# 第 1 折：
# 训练集大小： (73, 7)
# 测试集大小： (27, 7)
# 训练集分组分布： Group
# Group1    38
# Group3    35
# Name: count, dtype: int64
# 测试集分组分布： Group
# Group2    27
# Name: count, dtype: int64
# 训练集标签分布： Label
# 1    38
# 0    35
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    15
# 1    12
# Name: count, dtype: int64
# 第 2 折：
# 训练集大小： (65, 7)
# 测试集大小： (35, 7)
# 训练集分组分布： Group
# Group1    38
# Group2    27
# Name: count, dtype: int64
# 测试集分组分布： Group
# Group3    35
# Name: count, dtype: int64
# 训练集标签分布： Label
# 1    34
# 0    31
# Name: count, dtype: int64
# 测试集标签分布： Label
# 0    19
# 1    16
# Name: count, dtype: int64
# 第 3 折：
# 训练集大小： (62, 7)
# 测试集大小： (38, 7)
# 训练集分组分布： Group
# Group3    35
# Group2    27
# Name: count, dtype: int64
# 测试集分组分布： Group
# Group1    38
# Name: count, dtype: int64
# 训练集标签分布： Label
# 0    34
# 1    28
# Name: count, dtype: int64
# 测试集标签分布： Label
# 1    22
# 0    16
# Name: count, dtype: int64

基于时间序列划分的方法

对于时间序列数据，不能简单地随机划分，因为时间序列数据具有时间依赖性。通常需要将数据按照时间顺序分为训练集、验证集和测试集，确保训练集中的数据早于验证集和测试集

## 基于时间序列的划分方法
# 按时间顺序划分
df_sorted = df.sort_values(by='Timestamp')
train_size = int(len(df_sorted) * 0.8)
train_data = df_sorted[:train_size]
test_data = df_sorted[train_size:]print("按时间顺序划分结果：")
print("训练集时间范围：", train_data['Timestamp'].min(), "到", train_data['Timestamp'].max()) # 2025-01-01 00:00:00 到 2025-03-21 00:00:00
print("测试集时间范围：", test_data['Timestamp'].min(), "到", test_data['Timestamp'].max()) # 2025-03-22 00:00:00 到 2025-04-10 00:00:00

基于自定义划分的方法

在某些情况下，可能需要根据特定的业务逻辑或数据特性进行自定义划分

## 自定义划分
# 根据 Group 列的值进行自定义划分
train_data = df[df['Group'] == 'Group1']
val_data = df[df['Group'] == 'Group2']
test_data = df[df['Group'] == 'Group3']# 输出划分结果
print("训练集大小：", train_data.shape)  # (40, 7)
print("验证集大小：", val_data.shape)  # (24, 7)
print("测试集大小：", test_data.shape)  # (36, 7)print("\n训练集分组分布：")
print(train_data['Group'].value_counts())
# Group
# Group1    40
# Name: count, dtype: int64print("\n验证集分组分布：")
print(val_data['Group'].value_counts())
# Group
# Group2    24
# Name: count, dtype: int64print("\n测试集分组分布：")
print(test_data['Group'].value_counts())
# Group
# Group3    36
# Name: count, dtype: int64

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/web/88499.shtml
繁体地址，请注明出处：http://hk.pswp.cn/web/88499.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

lora网关

lora网关

所需配置的引脚，SPI传输，PG13复位（输出引脚，推挽输出），PE2忙碌（输入引脚，浮空输入）PE6PE5输出。若利用延时处理按键消抖，hal库里用systick中断实现延时&#…
阅读更多...
5G IMS注册关键一步：UE如何通过ePCO获取P-CSCF地址

5G IMS注册关键一步：UE如何通过ePCO获取P-CSCF地址

看似简单的P-CSCF地址传递，背后是5G核心网控制面与用户面的精密协作。ePCO作为高效的信令载体，承载着IMS业务触达的第一把钥匙。 在5G网络中建立IMS PDN连接时，UE（用户设备）获取P-CSCF（Proxy-Call Session Control Function）地址是IMS业务（如VoLTE、VoNR）成功注册和运…
阅读更多...
JVM方法区的运行时常量区到底存储哪些数据？

JVM方法区的运行时常量区到底存储哪些数据？

JDK8以后，运行时常量池逻辑上属于方法区；但： 其中的字符串常量池实际位置移至到了java堆；其中一些符号引用也存储到了元空间；字符串常量池，元空间，运行时常量区的具体关系请看这篇博客&#xf…
阅读更多...
Go defer（二）：从汇编的角度理解延迟调用的实现

Go defer（二）：从汇编的角度理解延迟调用的实现

Go的延迟调用机制会在当前函数返回前执行传入的函数，它会经常被用于关闭文件描述符、关闭数据库连接以及解锁资源。之前的文章（ Go defer（一）：延迟调用的使用及其底层实现原理详解 ）详细介绍了defer的使用以…
阅读更多...
Android 12系统源码_分屏模式（一）从最近任务触发分屏模式

Android 12系统源码_分屏模式（一）从最近任务触发分屏模式

前言 打开MainActivity，然后进入最近任务触发分屏，可以成功进入分屏模式。 本篇文章我们来具体梳理一下这个过程的源码调用流程。 一 launcher3阶段 1.1 源码 //packages/apps/Launcher3/quickstep/src/com/android/quickstep/views/TaskView.java publi…
阅读更多...
Flask 入门教程：用 Python 快速搭建你的第一个 Web 应用

Flask 入门教程：用 Python 快速搭建你的第一个 Web 应用

文章目录前言一、什么是 Flask？📌 Flask 的优势1. 轻量灵活2. 易于上手3. 可扩展性强4. 自由度高5. 社区活跃，资料丰富Flask 主要用来做什么？二、Flask快速入门1.创建一个Flask项目2.开启debug，修改host，端…
阅读更多...
实习第一个小需求样式问题总结

实习第一个小需求样式问题总结

Vue2 vxe-table Element UI 表头下拉详情实现总结一、核心功能实现表头下拉按钮交互初始尝试 expand-change 事件无法满足需求&#xff0c;改用 vxe-table 的 toggle-row-expand 事件&#xff1a;<vxe-table toggle-row-expand"handleExpandChange"><temp…
阅读更多...
Linux中LVM逻辑卷扩容

Linux中LVM逻辑卷扩容

在Linux系统中对根目录所在的LVM逻辑卷进行扩容&#xff0c;需要依次完成 物理卷扩容 ➔ 卷组扩容 ➔ 逻辑卷扩容 ➔ 文件系统扩容 四个步骤。以下是详细操作流程&#xff1a;一、确认当前磁盘和LVM状态# 1. 查看磁盘空间使用情况 df -h /# 2. 查看块设备及LVM层级关系 lsblk# …
阅读更多...
微软365 PDF导出功能存在本地文件包含漏洞，可泄露敏感服务器数据

微软365 PDF导出功能存在本地文件包含漏洞，可泄露敏感服务器数据

微软365的"导出为PDF"功能近期被发现存在严重的本地文件包含(Local File Inclusion, LFI)漏洞&#xff0c;攻击者可利用该漏洞获取服务器端的敏感数据&#xff0c;包括配置文件、数据库凭证和应用程序源代码。该漏洞由安全研究员Gianluca Baldi发现并报告给微软&…
阅读更多...
台球 PCOL：极致物理还原的网页斯诺克引擎（附源码深度解析）

台球 PCOL：极致物理还原的网页斯诺克引擎（附源码深度解析）

> 无需下载，打开浏览器即可体验专业级斯诺克！本文将揭秘网页版台球游戏的物理引擎与渲染核心技术 在游戏开发领域，台球物理模拟一直被视为**刚体动力学皇冠上的明珠**。今天我们要解析的**台球 PCOL**（Pure Canvas Online Billiards）正是一款突破性的网页版斯诺克游戏…
阅读更多...
springboot-2.3.3.RELEASE升级2.7.16，swagger2.9.2升级3.0.0过程

springboot-2.3.3.RELEASE升级2.7.16，swagger2.9.2升级3.0.0过程

一、pom文件版本修改<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.7.16</version><relativePath/> </parent>如果用到了“spring-boot-starter…
阅读更多...
Python-正则表达式-信息提取-滑动窗口-数据分发-文件加载及分析器-浏览器分析-学习笔记

Python-正则表达式-信息提取-滑动窗口-数据分发-文件加载及分析器-浏览器分析-学习笔记

序 欠4前年的一份笔记 &#xff0c;献给今后的自己。 正则表达式 概述 正则表达式&#xff0c;Regular Expression&#xff0c;缩写为regex、regexp、RE等。 正则表达式是文本处理极为重要的技术&#xff0c;用它可以对字符串按照某种规则进行检索、替换。 1970年代&…
阅读更多...
一文入门神经网络：神经网络概念初识

一文入门神经网络：神经网络概念初识

神经网络的世界远比你想象得更丰富多元。从基础架构到前沿融合模型&#xff0c;我为你梳理了当前最值得关注的神经网络类型&#xff0c;不仅包括那些“教科书级”的经典模型&#xff0c;也覆盖了正在改变行业格局的新兴架构。以下是系统分类与核心特点总结&#xff1a;一、基础…
阅读更多...
线上事故处理记录

线上事故处理记录

线上事故处理记录 一、MySQL 导致的服务器 CPU 飙升 有一天&#xff0c;突然收到了服务器 CPU 飙升的告警信息&#xff0c;打开普罗米修斯查看 CPU 的使用情况&#xff0c;发现 CPU 确实飙升了&#xff0c;下面开始去进行问题定位了。 1. 首先连接到对应的服务器&#xff0c;然…
阅读更多...
ParaCAD 笔记 png 图纸标注数据集

ParaCAD 笔记 png 图纸标注数据集

ParaCAD-Dataset git lfs install git clone https://www.modelscope.cn/datasets/yuwenbonnie/ParaCAD-Dataset.git https://github.com/ParaCAD/ 不止100g 下个最小的 没有三视图
阅读更多...
C#使用Semantic Kernel实现Embedding功能

C#使用Semantic Kernel实现Embedding功能

1、背景 C#开发中&#xff0c;可以通过Semantic Kernel实现本地模型的调用和实现。 本地的Ollama的版本如下&#xff1a;安装的Package如下&#xff1a;2、代码实现 // See https://aka.ms/new-console-template for more information using Microsoft.Extensions.AI; using Mi…
阅读更多...
转转APP逆向

转转APP逆向

APP版本 11.15.0 接口分析 # URL https://app.zhuanzhuan.com/zz/transfer/search# header cookie xxx x-zz-monitoring-metrics feMetricAntiCheatLevelV1 zztk user-agent Zhuan/11.15.0 (11015000) Dalvik/2.1.0 (Linux; U; Android 10; Pixel 3 Build/QQ3A.200805.001) z…
阅读更多...
注解与反射的完美配合：Java中的声明式编程实践

注解与反射的完美配合：Java中的声明式编程实践

注解与反射的完美配合&#xff1a;Java中的声明式编程实践 目录 引言 核心概念 工作机制 实战示例 传统方式的痛点 注解反射的优势 实际应用场景 最佳实践 总结 引言 在现代Java开发中&#xff0c;我们经常看到这样的代码&#xff1a; Range(min 1, max 50)priva…
阅读更多...
开源入侵防御系统——CrowdSec

开源入侵防御系统——CrowdSec

1、简介 CrowdSec 是一款现代化、开源、基于行为的入侵防御系统&#xff08;IDS/IPS&#xff09;&#xff0c;专为保护服务器、服务、容器、云原生应用而设计。它通过分析日志检测可疑行为&#xff0c;并可基于社区协作共享恶意 IP 黑名单&#xff0c;从而实现分布式防御。 其…
阅读更多...
imx6ull-裸机学习实验13——串口格式化函数移植实验

imx6ull-裸机学习实验13——串口格式化函数移植实验

目录 前言 格式化函数 实验程序编写 stdio文件夹 main.c Makefile修改 编译下载 前言 在学习实验12&#xff1a;imx6ull串口通信实验&#xff0c;我们实现了 UART1 基本的数据收发功能&#xff0c;虽然可以用来调试程序&#xff0c;但是功能太单一了&#xff0c;只能输出…
阅读更多...
最新文章

Copyright @ 2022~2023