一.标准化
二.归一化
三.二值化
四.独热编码与标签编码
一.标准化
1.什么是标准化？
标准化指的是将数据按比例缩放，使之落入一个小的特定区间。在大多数情况下，这个区间是[0, 1]，但有时也可以是[-1, 1]。标准化后的数据的平均值为0，标准差为1。
标准化通常使用以下公式进行：
z=(x−μ)/σ
其中，x是原始数据，μ是数据的均值，σ是数据的标准差，z是标准化后的数据。
目的:使不同特征具有相同的尺度，便于算法处理
2.案例
案例1:(方法一:手搓)将"[[1,2,3,4],[9,8,7,6],[11,12,11,44]]"该组数据标准化
import pandas as pd
data=pd.DataFrame([[1,2,3,4],[9,8,7,6],[11,12,11,44]])
column=["特征1","特征2","特征3","特征4"]
index=["数据1","数据2","数据3"]
data.columns=column
data.index=index
print(data)
data_mean=data.mean() #每一列特征的平均值
data_std=data.std() #每一列特征的标准差
data1=data-data_mean
data2=data1/data_std #标准化后的数据
print(data2.round(2)) 特征1 特征2 特征3 特征4
数据1 1 2 3 4
数据2 9 8 7 6
数据3 11 12 11 44
特征1 特征2 特征3 特征4
数据1 -1.13 -1.06 -1.0 -0.62
数据2 0.38 0.13 0.0 -0.53
数据3 0.76 0.93 1.0 1.15案例1:(方法二:调用sklearn库)将"[[1,2,3,4],[9,8,7,6],[11,12,11,44],[10,10,10,10]]"该组数据标准化
import pandas as pd
from sklearn.preprocessing import StandardScaler
#数据导入
data=pd.DataFrame([[1,2,3,4],[9,8,7,6],[11,12,11,44],[10,10,10,10]])
column=["特征1","特征2","特征3","特征4"]
index=["数据1","数据2","数据3","数据4"]
data.columns=column
data.index=index
print(data)
#创建标准化实例,训练集与测试集的划分
scaler=StandardScaler()
x_train=data[:3]
x_test=data[3:4]
#计算x_train的均值与标准差,并保存统计信息
scaler.fit(x_train)
#使用保存的统计信息,来标准化x_train,x_text,data
order_train=scaler.transform(x_train)
order_test=scaler.transform(x_test)
order_data=scaler.transform(data)
#输出标准化后的order_train,order_test,order_data
print("标准化后的训练集:\n",order_train.round(2))
print("标准化后的测试集:\n",order_test.round(2))
print("标准化后的原数据:\n",order_data.round(2))
#打印出原数据的均值与标准差,既在调用fit方法时存储下来的
print("标准化前原数据的均值:",scaler.mean_.round(2)) #均值
print("标准化前原数据的标准差:",scaler.scale_.round(2)) #标准差
print("标准化后数据的均值:",order_data.mean(axis=0).round(2))
print("标准化后数据的标准差:",order_data.std(axis=0).round(2)) 特征1 特征2 特征3 特征4
数据1 1 2 3 4
数据2 9 8 7 6
数据3 11 12 11 44
数据4 10 10 10 10
标准化后的训练集:
[[-1.39 -1.3 -1.22 -0.76]
[ 0.46 0.16 0. -0.65]
[ 0.93 1.14 1.22 1.41]]
标准化后的测试集:
[[ 0.69 0.65 0.92 -0.43]]
标准化后的原数据:
[[-1.39 -1.3 -1.22 -0.76]
[ 0.46 0.16 0. -0.65]
[ 0.93 1.14 1.22 1.41]
[ 0.69 0.65 0.92 -0.43]]
标准化前原数据的均值: [ 7. 7.33 7. 18. ]
标准化前原数据的标准差: [ 4.32 4.11 3.27 18.4 ]
标准化后数据的均值: [ 0.17 0.16 0.23 -0.11]
标准化后数据的标准差: [0.92 0.91 0.95 0.89]
二.归一化
1.什么是归一化？
归一化是将数据按比例缩放，以使其落入一个指定的最小到最大值的范围内。最常见的归一化范围是 [0, 1]。
归一化通常使用以下公式进行：
x′=(x−x_min)/(x_max−x_min)
其中，x是原始数据，x_min是数据的最小值，x_max是数据的最大值，x′是归一化后的数据。
目的：防止不同量纲的特征对模型结果产生过大影响
2.案例
案例1:(调用sklearn库)
import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
data=pd.DataFrame([
[25,175,79,0],
[21,169,75,1],
[22,155,72,0]])
print(data)
#创建归一化实例
mms=MinMaxScaler((0,1))#括号里的参数改为取值范围
#计算最大值最小值,并进行归一化处理
new_data=pd.DataFrame(mms.fit_transform(data))
print(new_data)
#预测
text_data=np.array([21,122,73,1]).reshape(1,-1)
print(mms.transform(text_data))
#反推
try_data=np.array([1,1,1,1]).reshape(1,-1)
print(mms.inverse_transform(try_data)) 0 1 2 3
0 25 175 79 0
1 21 169 75 1
2 22 155 72 0
0 1 2 3
0 1.00 1.0 1.000000 0.0
1 0.00 0.7 0.428571 1.0
2 0.25 0.0 0.000000 0.0
[[ 0. -1.65 0.14285714 1. ]]
[[ 25. 175. 79. 1.]]
三.二值化
1.什么是二值化？
二值化（Binarization）是数据预处理中的一种技术，它将数据转换为仅包含两个值的数据，通常是0和1。这种转换通常基于一个阈值，数据点根据是否超过这个阈值被分类为0或1。二值化在各种应用中都很有用，特别是在特征工程中，当需要将连续变量转换为分类变量时。
公式：
x是原始数据，t是阈值，x′是二值化后的数据。
目的：简化数据，将连续变量转换为离散变量。
2.案例
案例1(方法1:手搓)
import numpy as np
data=np.array([
[20,30,40,50],
[10,29,405,60],
[30,406,406,30]
],dtype="float32")
#法一
new_data=data.copy()
new_data=np.where(new_data>=45,1,0)
print(new_data)
"""
法二:
new_data[new_data>=45]=1
new_data[new_data<=45]=0
"""[[0 0 0 1]
[0 0 1 1]
[0 1 1 0]]案例1(方法2:调用sklearn库)
from sklearn.preprocessing import Binarizer
import numpy as np
data=np.array([
[20,30,40,50],
[10,29,405,60],
[30,406,406,30]
],dtype="float32")
#创建二值化实例,并设置阈值为50
bin=Binarizer(threshold=50)#大于阈值
#进行二值化
new_data=bin.fit_transform(data)
print(new_data)[[0. 0. 0. 0.]
[0. 0. 1. 1.]
[0. 1. 1. 0.]]
四.编码类别特征
1.独热编码
1.什么是独热编码?
独热编码（One-Hot Encoding）是一种处理分类数据的常用技术，特别是在机器学习中。它将分类变量的不同类别转换为二进制（0或1）的形式，每个类别对应一个唯一的二进制向量。这种编码方式使得机器学习算法能够更好地理解和处理分类数据，尤其是那些处理数值数据的算法.
设有数据为:
3 4 5
3 2 5
1 3 4
独热编码:每一列特征用不同的二进制表示,数位的个数为每一列的不同值数量
3:10 4:100 5:10
1:01 2:010 4:01
3:001
编码后
10 100 10
10 010 10
01 001 01
2.案例
案例1:(方法1:手搓)
import numpy as np
data=np.array([1,2,3,4,5,8,7,5,3,1,3,3]).reshape(-1,3)
print(data)
c_data=data.copy()
list=[]
for col in data.T:
dict={}
for val in col:
dict[val]=None
list.append(dict)#利用字典的去重性
print(list)
for dict in list:
size=len(dict)
for index,key in enumerate(sorted(dict.keys())):
dict[key]=np.zeros(shape=size,dtype=int)
dict[key][index]=1
print(list)
list1=[]
for d in c_data:
new_list=np.array([],dtype=int)
for index,key in enumerate(d):
new_list=np.hstack((new_list,list[index][key]))
list1.append(new_list)
list1=np.array(list1)
print(list1)[[1 2 3]
[4 5 8]
[7 5 3]
[1 3 3]]
[{1: None, 4: None, 7: None}, {2: None, 5: None, 3: None}, {3: None, 8: None}]
[{1: array([1, 0, 0]), 4: array([0, 1, 0]), 7: array([0, 0, 1])}, {2: array([1, 0, 0]), 5: array([0, 0, 1]), 3: array([0, 1, 0])}, {3: array([1, 0]), 8: array([0, 1])}]
[[1 0 0 1 0 0 1 0]
[0 1 0 0 0 1 0 1]
[0 0 1 0 0 1 1 0]
[1 0 0 0 1 0 1 0]]案例1:(方法2:调用sklearn库)
from sklearn.preprocessing import OneHotEncoder
import numpy as np
data=np.array([1,2,3,4,5,8,7,5,3,1,3,3]).reshape(-1,3)
print(data)
#创建独热编码器
ohe=OneHotEncoder(sparse_output=False,dtype=int)
#计算独热编码
new_data=ohe.fit_transform(data)#先拟合后转换
print(new_data)
#反向解码
test_array=np.array([0,1,0,0,0,1,1,0]).reshape(1,-1)
try_=ohe.inverse_transform(test_array)
print(try_)
[[1 2 3]
[4 5 8]
[7 5 3]
[1 3 3]]
[[1 0 0 1 0 0 1 0]
[0 1 0 0 0 1 0 1]
[0 0 1 0 0 1 1 0]
[1 0 0 0 1 0 1 0]]
[[4 5 3]]2.标签编码
1.什么是标签编码?
标签编码（Label Encoding）是一种将分类变量转换为整数的方法，通常用于将类别标签转换为从0开始的整数序列。这种方法在处理不平衡数据集时特别有用，因为它可以确保每个类别的权重相等。标签编码适用于有序特征，其中类别之间存在一定的顺序关系，但没有明确的意义
2.案例
案例1(方法1:调用sklearn库)
import numpy as np
from sklearn.preprocessing import LabelEncoder
data=np.array(["wo","we","w","ew","r","wo"])
#创建标签编码实例
lbe=LabelEncoder()
#计算,将每个标签用,从0开始的整数代替
data_=lbe.fit_transform(data)
print(data_)
#反向编码
da=[2,0,1]
da_=lbe.inverse_transform(da)
print(da_)
#使用原训练集的结果,进行编码,前提是所要编码的标签已被创建成功,不然会找不到数字进行代替,而出现保存
st="w we"
st_=st.split(" ")
print(st_)
st__=lbe.transform(st_)
print(st__)
[4 3 2 0 1 4]
['w' 'ew' 'r']
['w', 'we']
[2 3]