数据集及基本操作
1）数据集的组成
数据集由特征(feature)与标签(label)构成。
特征是输入数据。 什么是特征（Features）: 机器学习中输入数据，被称为特征。通常特征不止1个，可以用 n 维向量表示n个特征。
Features 数据通常表示为大写 X，数据格式为 Numpy array 或者 Pandas 的 dataFrame
X的数据类型必须是float32,或 float64.
标签是输出数据，在sklearn 中有时也称为target， response.
通常标记为小写 y, 只能是1维向量，数据格式为 Numpy array 或者 Pandas 的 Series
2）常用测试集：
- iris
- digits for classification
- Boston house prices for regression
注意 Boston House Price数据集从1.2中被移除。有很多教程中还有， 手工加载方法：
import pandas as pd
import numpy as np
data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]
或者下载后，从本地加载
raw_df = pd.read_csv("./boston", sep="\s+", skiprows=22, header=None)
也可用California housing datase替代
from sklearn.datasets import fetch_california_housing
housing = fetch_california_housing() #可能下载不了。
切分数据集
通常，需要将数据集切分为两部分： training set and testing set.
如：
from sklearn.datasets import load_iris
iris = load_iris()
data_X = iris.data
data_y = iris.target
from sklearn.model_selection import train_test_split
#划分为训练集和测试集数据
X_train, X_test, y_train, y_test = train_test_split(
data_X,
data_y,
test_size=0.3,
random_state=111
)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)
Output
(105, 4)
(45, 4)
(105,)
(45,)
数据集预处理技术
sklearn的数据预处理操作分类
(1) Feature Extract
① Load features from dict
② 文件特征化
(2) Preprocessing Data
① Standalizaiton , scaling
② Normalization
③ Encoding categorical features
④ Discretization
⑤ Custom transformers
(3) Imputation of missing values
① Univariate feature imputation, Multivariate feature imputation
② Nearest neighbors imputation
③ 用常量填充
④ NaN空值填充
(4) Dimension Reduction
① PCA: principal component analysis
② Random projections
③ Feature agglomeration
(5) 快速降维技术 Random Projection
① The Johnson-Lindenstrauss lemma
② Gaussian random projection
③ Sparse random projection
(1)Binarisation 二值 化
二值化主要用于将数值特征向量转换为（0，1）， 或（true, false)
原始数据
import numpy as np
from sklearn import preprocessing
data = np.array([[3, -1.5, 2, -5.4],
[0, 4, -0.3, 2.1],
[1, 3.3, -1.9, -4.3]]) # 原始数据矩阵 shape=(3,4
二值化处理：
binarized=preprocessing.Binarizer(threshold=1.4).transform(data)
#小于等于1.4的为0，其余为1
print(“原始：\n”,data)
print(“二值化：\n”,binarized)
[
[ 1. 0. 1, 0.]
[ 0. 1. 0, 1]
[ 0. 1. 0. 0]
]
(2)标准化与归一化处理
数据集的标准化（Standardization）是一种特征缩放技术。其主要目的是调整特征的尺度，使得所有特征都具有相同的尺度或范围。
具体来说，标准化通常是通过将每个特征值减去其均值，然后除以其标准差来实现的。这样处理后，每个特征的均值为0，标准差为1，符合标准正态分布。标准化对于那些依赖于距离和权重的算法（如KNN、Logistic Regression等）来说尤其重要，因为这些算法不应受到不均匀缩放数据集的影响。
Normalizatioin，也称归一化。 但与标准化有区别的。归一化主要目的是将数据映射到特定的范围，通常是[0,1]或[-1,1]。标准化更适用于那些特征值分布接近正态分布的情况。而归一化则更适用于那些数据范围有限或需要限制输出范围的情况。
但很多文档中，也将Normalizaiton 归为标准化的方法中。
标准化方式：
Z-score标准化（标准差标准化）：这是最常用的标准化方法之一。这种方法对于大多数基于梯度的优化算法（如神经网络和逻辑回归）非常有效，因为它可以确保每个特征在模型中具有相同的权重。
Scaling 缩放技术
Min-max标准化（最小-最大标准化）：它通过缩放特征值，使其落在[0,1]的范围内。具体实现是将每个特征值减去其最小值，然后除以其最大值与最小值之差。这种方法适用于那些需要限制数据范围或输出范围的情况，例如某些图像处理和信号处理的任务。
MaxAbsScaler：原理：将每个特征值缩放到[-1, 1]区间，通过除以每个特征的最大绝对值实现。如果数据集中有很大的异常值，使用MaxAbsScaler可能是一个好选择，因为它不会受到异常值的影响。
A)StandardScaler 基本标准化方法
计算z score, 分布转为标准正态分布
示例：
import numpy as np
from sklearn.preprocessing import StandardScaler
# 假设的数据集
data = np.array([[170, 60], [180, 70], [165, 55], [175, 65]])
# 创建StandardScaler对象
scaler = StandardScaler()
# 对数据进行标准化处理
standardized_data = scaler.fit_transform(data)
print(standardized_data)
# 查看标准化之后的数据，均值为0， 标准差为1
>>> standardized_data.mean(axis=0)
array([0., 0., 0.,0.])
>>> standardized_data.std(axis=0)
array([1., 1., 1.])
B)Min-Max 缩放
也称为离差标准化，是对原始数据的线性变换，使结果值映射到[0 - 1]， 或[-1,1]之间。
其使用方法与standardScalar()相似
scaler = MinMaxScaler()
# 假设的数据集
data = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
# 对数据进行归一化处理
normalized_data = scaler.fit_transform(data)
输出数据的每个特征值都位于[0,1]区间内
如果你想要将数据缩放到不同的范围，例如[-1, 1]，你可以在创建MinMaxScaler对象时指定feature_range参数：
scaler = MinMaxScaler(feature_range=(-1, 1))
normalized_data = scaler.fit_transform(data)
C)MaxAbsScaler缩放
原理：将每个特征值缩放到[-1, 1]区间，通过除以每个特征的最大绝对值实现。
示例：如果数据集中有很大的异常值，使用MaxAbsScaler可能是一个好选择，因为它不会受到异常值的影响。
from sklearn.preprocessing import MaxAbsScaler
scaler = MaxAbsScaler()
scaled_data = scaler.fit_transform(data)
D)Mean Removal均值移除
data_standardized=preprocessing.scale(data)
均值移除之后的矩阵每一列的均值约为0，而std为1。这样做的目的是确保每一个特征列的数值都在类似的数据范围之间，防止某一个特征列数据天然的数值太大而一家独大。
E)归一化
就是归一化是将单个样本缩放到具有单位范数的过程
normalize函数提供了一个快速简便的方法，用于在单个类似数组的数据集上执行此操作， 范数可以使用l1, l2, max,
>>> X = [[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]]
>>> X_normalized = preprocessing.normalize(X, norm='l2')
>>> X_normalized
array([[ 0.40..., -0.40..., 0.81...],
[ 1. ..., 0. ..., 0. ...],
[ 0. ..., 0.70..., -0.70...]])
L2 Normalisation
L2 normalization（也称为欧氏距离归一化）是一种常用的技术，它通过对特征向量进行缩放，使得每个样本的L2范数（即欧几里得范数）等于一个特定的值，通常是1。这有助于确保模型不会偏向于具有较大范数的特征，从而改进模型的表现。
在sklearn库中，Normalizer类提供了一个norm参数，可以设置为’l2’来执行L2 normalization。
Sklearn 也提供了1个Normlizer 类，可通过Normlizer.transform（)方法进行归一化操作
Normalizer类提供了一个norm参数，可以设置为’l2’来执行L2 normalization。
normalizer = Normalizer(norm='l2')
normalized_data = normalizer.transform(X)
(3)缺失值处理–插值:
imp=SimpleImputer(missing_values=np.nan, strategy=’mean’)
impute.SimpleImputer进行缺失值处理，其中参数miss_values是告诉SimpleImputer，数据中缺失值长什么样，默认是np.nan；参数strategy是缺失值插补策略，有mean，median，most_frequent,constant插补，其中前两个均值和中位数只能在数值型中插补，后两个众数和特定值可以在数值型和字符型中都可以插补，特定值是在参数fill_value中输入的值，参数copy是否创建副本，默认True是创建，如果为False则会覆盖原数据
(4)处理异常数据 Outlier data
Outlier data, far bigger or less than rest data in dataset. 有几种方式可以处理
方式1： 用pandas处理
删除异常行
df = pd.DataFrame({
'feature1': [1, 2, 3, 4, 500], # 假设500是异常值
'feature2': [10, 20, 30, 40, 50],
'target': [0, 0, 1, 1, 1]
})
# 删除包含异常值的行
df = df[df['feature1'] < 100] # 删除'feature1'大于100的行
# 划分数据集
X = df[['feature1', 'feature2']]
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 用均值替代
import pandas as pd
import numpy as np
# 创建一个示例DataFrame
data = {'A': [1, 2, 3, 4, 500], 'B': [5, 6, 7, 8, 9], 'C': [10, 11, 12, 1000, 14]}
df = pd.DataFrame(data)
# 计算每列的均值
mean_values = df.mean()
# 定义一个函数来替换异常值
def replace_outliers_with_mean(series, threshold=1.5):
# 计算标准差
std_dev = series.std()
# 计算异常值的上下限
lower_limit = series.mean() - (threshold * std_dev)
upper_limit = series.mean() + (threshold * std_dev)
# 替换异常值为均值
series[series < lower_limit] = mean_values[series.name]
series[series > upper_limit] = mean_values[series.name]
return series
# 应用函数到DataFrame的每一列
df_replaced = df.apply(replace_outliers_with_mean)
print(df_replaced)
方式2： 使用IQR（四分位距）识别并处理异常值
import numpy as np
# 计算IQR并定义异常值范围
Q1 = df['feature1'].quantile(0.25)
Q3 = df['feature1'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
替换或删除异常值
df['feature1'] = np.where((df['feature1'] < lower_bound) | (df['feature1'] > upper_bound), np.nan, df['feature1']) # 替换为NaN
df = df.dropna() # 删除包含NaN的行
方式3： 使用sklearn的IsolationForest识别异常值：
IsolationForest是一种基于随机森林的异常值检测算法。
from sklearn.ensemble import IsolationForest
# 训练异常值检测器
clf = IsolationForest(contamination=0.1) # 假设数据集中10%是异常值
y_pred = clf.fit_predict(X)
# -1表示异常值，1表示正常值
outliers = X[y_pred == -1]
inliers = X[y_pred == 1]
# 处理异常值，例如删除它们
X = inliers
方式4： 使用中位数和IQR缩放或替换异常值：
对于数值特征，可以使用中位数和IQR的缩放因子来替换异常值。
def replace_outliers_with_iqr(df, column, factor=1.5):
Q1 = df[column].quantile(0.25)
Q3 = df[column].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - factor * IQR
upper_bound = Q3 + factor * IQR
df.loc[df[column] < lower_bound, column] = Q1 - factor * IQR
df.loc[df[column] > upper_bound, column] = Q3 + factor * IQR
return df
df = replace_outliers_with_iqr(df, 'feature1')
(5)分类特征数据的编码处理
很多场景中，特征数据不是数字值 ，而是离散的文本，如人的特征： [“male”, “female”], [“from Europe”, “from US”, “from Asia”], [“uses Firefox”, “uses Chrome”, “uses Safari”, “uses Internet Explorer”]. 可以用1个数字来代表某个文本，将其编码为. 如
[“male”, “from US”, “uses Internet Explorer”] ==》 [0, 1, 3]
[“female”, “from Asia”, “uses Chrome”] ==> [ 1, 2, 1]
OrdinalEncoder 序列编码器
enc = preprocessing.OrdinalEncoder()
X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']]
enc.fit(X)
enc.transform([['female', 'from US', 'uses Safari']])
输出：
array([[0., 1., 1.]])
标签编码
preprocessing.LabelEncoder：标签专用，能够将分类转换为数值型数据
对数字编码
对字符串编码
OneHot独热编码
与类别编码相似，会把每一个类别特征变换成一个新的整数数字特征，并以One-Hot格式输出，常用的参数：
- categories
- ‘auto’ : 根据训练集自动确定各列特征的类别数
- list : 手动枚举每列特征，这样即使训练集中没有出现过，特能进行编
- sparse：表示编码的格式，默认为 True，即为稀疏的格式，指定 False 则就不用 toarray() 了
- handle_unknown：其值可以指定为 “error” 或者 “ignore”，即如果碰到未知的类别，是返回一个错误还是忽略它。
from sklearn.preprocessing import OneHotEncoder
# 构造数据
X_train = [['male', 'from US', 'uses Safari'],
['female', 'from Europe', 'uses Firefox'],
['female', 'from China', 'uses Safari']]
# 编码器
encoder = OneHotEncoder()
encoder = encoder.fit(X_train)
# 编码
X = [['female', 'from Europe', 'uses Safari']]
X_transform = encoder.transform(X)
X_transform.toarray() # 默认返回的是稀疏矩阵, 用toarray()方法可以转为np.array格式
>> array([[1., 0., 0., 1., 0., 0., 1.]])
如果指定categories 参数，
>>> genders = ['female', 'male']
>>> locations = ['from Africa', 'from Asia', 'from Europe', 'from US']
>>> browsers = ['uses Chrome', 'uses Firefox', 'uses IE', 'uses Safari']
>>> enc = preprocessing.OneHotEncoder(categories=[genders, locations, browsers])
>>> # Note that for there are missing categorical values for the 2nd and 3rd
>>> # feature
>>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']]
>>> enc.fit(X) # onehot长度：各category元素按顺序排列。
OneHotEncoder(categories=[['female', 'male'],
['from Africa', 'from Asia', 'from Europe',
'from US'],
['uses Chrome', 'uses Firefox', 'uses IE',
'uses Safari']])
>>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray()
array([[1., 0., 0., 1., 0., 0., 1., 0., 0., 0.]])
(6)discretization离散化（分箱）
有的数据，局部是连续的，整体不是连续的。 可以将连续特征划分为离散值。
K-bins discretization
X = np.array([[ -3., 5., 15 ],
… [ 0., 6., 14 ],
… [ 6., 3., 11 ]])
est = preprocessing.KBinsDiscretizer(n_bins=[3, 2, 2], encode=‘ordinal’).fit(X)
缺少输出是采用one-hot编码的矩阵，
PCA 主成分分析
PCA（Principal Component Analysis，主成分分析）主要用于数据的降维。PCA的主要思想是将n维特征映射到k维上（k<n），这k维是全新的正交特征，是重新构造出来的k维特征，而不是简单地从n维特征中去除其余n-k维特征。这k维特征称为主成分，是原始特征的线性组合。
PCA的工作原理是，通过对原始特征空间进行线性变换，寻找一组新的正交基，这组正交基就是主成分。新的特征空间是由这些主成分构成的，并且新空间的维度（即主成分的数量）通常小于原始特征空间的维度。通过这种方式，PCA可以有效地降低数据的维度，同时保留数据中的主要变化信息。
其数学基础:
Variance and Convariance
Eigen Vectors and Eigen values
算法实现步骤：
1） 把数据集分为X, Y 两部分， X做为 train 或 study, Y做为验证数据
2） 把X数据集转换成2维数组
3） Standize datasite
4) 求协方差
5） 计算特征向量与特征值
6） 排序特征向量
7） 计算新的features，
8) 在新数据集去除不重要的feature
在sklearn实现PCA非常简单：
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
# 加载iris数据集
iris = load_iris()
X = iris.data
y = iris.target
# 初始化PCA，设置目标维度为2
pca = PCA(n_components=2)
# 对数据进行PCA降维
X_pca = pca.fit_transform(X)
![[HNCTF 2022 WEEK2]来解个方程?](https://img-blog.csdnimg.cn/direct/b62b92076b114dde893ff82b8d194d19.png)
