机器学习-02-数据清洗和特征选择

import numpy as np
from sklearn.preprocessing import Imputer

X = [
    [2, 2, 4, 1],
    [np.nan, 3, 4, 4],
    [1, 1, 1, np.nan],
    [2, 2, np.nan, 3]
]

# missing_values（缺失值），strategy(策略，默认平均值)，axis（选择行列，0为列，1为行）
imp1 = Imputer(missing_values=‘NaN‘, strategy=‘mean‘, axis=0) # 缺省值选择空，策略为平均数，
imp2 = Imputer(missing_values=‘NaN‘, strategy=‘mean‘, axis=1) 
print(imp1.fit_transform(X)) 
print(imp2.fit_transform(X))

 1 import numpy as np
 2 from sklearn.preprocessing import Imputer
 3 from sklearn.impute import SimpleImputer
 4 
 5 X = [
 6     [2, 2, 4, 1],
 7     [np.nan, 3, 4, 4],
 8     [1, 1, 1, np.nan],
 9     [2, 2, np.nan, 3]
10 ]
11 # 参数详解可见，暂未发现选择行操作
12 # http://scikit-learn.org/dev/modules/generated/sklearn.impute.SimpleImputer.html
13 imp1 = SimpleImputer(missing_values=‘NaN‘, strategy=‘mean‘)
14 print(imp1.fit_transform(X))

# 独热编码
import numpy as np
from sklearn.preprocessing import OneHotEncoder
from sklearn.feature_extraction import DictVectorizer,FeatureHasher

enc = OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
a=np.array([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
print(a)
# 基于列进行编码,打印有多少种值
print(enc.n_values_)

# 把0放到第一列[0,1]比对，把1放到第二列[0,1,2]比对，把3放到第三列[0,1,2，3]比对
print(enc.transform([[0, 1, 3]]).toarray())

# 标签编码
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
le.fit_transform([1,5,6,100,67])

print(‘编码结果是:‘, le.transform([1,1,100,67,5]))

print(le.fit(["paris", "paris", "tokyo", "amsterdam"]))
print(list(le.classes_))
print(le.transform(["tokyo", "tokyo", "paris"]))
print(list(le.inverse_transform([2, 2, 1])))   # 逆过程

from sklearn.feature_extraction import DictVectorizer
dv = DictVectorizer(sparse=False)
D = [{‘foo‘:1, ‘bar‘:2}, {‘foa‘:3, ‘baz‘: 2}]
X = dv.fit_transform(D)
print (X)
print (dv.get_feature_names())
print (dv.transform({‘foo‘:4, ‘unseen‘:3,‘baz‘:10}))

[[2. 0. 0. 1.]
 [0. 2. 3. 0.]]
[‘bar‘, ‘baz‘, ‘foa‘, ‘foo‘]
[[ 0. 10.  0.  4.]]

from sklearn.feature_extraction import FeatureHasher
h = FeatureHasher(n_features=10,non_negative=True)  # n_features：多少个特征，non_negative:是不是正数
D = [{‘dog‘: 1, ‘cat‘:2, ‘elephant‘:4},{‘dog‘: 2, ‘run‘: 5}]
f = h.fit_transform(D)
print(f.toarray())

import numpy as np
from sklearn.preprocessing import Binarizer
arr = np.array([
    [1.5, 1.3, 1.9],
    [0.5, 0.5, 1.6],
    [1.1, 2.1, 0.2]
])
binarizer = Binarizer(threshold=1.0).fit_transform(arr)
print(binarizer)

‘‘‘作用：去均值和方差归一化。且是针对每一个特征维度来做的，而不是针对样本。 【注：】 并不是所有的标准化都能给estimator带来好处。 
(x-x.mean())/x.std()
本方法要求原始数据的分布可以近似为高斯分布，否则归一化的效果会变得很糟糕；
应用场景：在分类、聚类算法中，需要使用距离来度量相似性的时候、或者使用PCA技术进行降维的时候‘‘‘
from sklearn.preprocessing import StandardScaler
import pandas as pd

X = [
    [1, 2, 3, 2],
    [7, 8, 9, 2.01],
    [4, 8, 2, 2.01],
    [9, 5, 2, 1.99],
    [7, 5, 3, 1.99],
    [1, 4, 9, 2]
]
ss = StandardScaler(with_mean=True, with_std=True)
ss.fit(X)
print(ss.mean_)
print(ss.n_samples_seen_)
print(ss.scale_)
print(ss.transform(X))

y = pd.DataFrame(X)
z = y.apply(lambda x:(x - x.mean())/x.std())
print(z)

w = y.apply(lambda x:(x - x.mean())/x.std(ddof=0)) #  修正因子,做标准差是padas默认无偏差估计
print(w)

# 区间缩放
import numpy as np
from sklearn.preprocessing import MinMaxScaler
X = np.array([
    [1, -1, 2, 3],
    [2, 0, 0, 3],
    [0, 1, -1, 3]
], dtype=np.float64)
scaler = MinMaxScaler(feature_range=(1, 3))  # 指定区间范围
print(scaler.fit_transform(X))
print(scaler.data_max_)
print(scaler.data_min_)
print(scaler.data_range_)

# 计算公式
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
print(X_std)
#X_scaled = X_std * (max - min) + min
X_scaled = X_std * (5 - 1) + 1
print(X_scaled)
X_scaled[np.isnan(X_scaled)]=1.
print(X_scaled)

import numpy as np
from sklearn.preprocessing import Normalizer

X = np.array([
    [1, -1, 2],
    [2, 0, 0],
    [0, 1, -1]
], dtype=np.float64)
normalizer1 = Normalizer(norm=‘max‘)  # 每个值除以最大值
normalizer2 = Normalizer(norm=‘l2‘)   # 每个值l2正则
normalizer3 = Normalizer(norm=‘l1‘)   # 每个值l1正则
normalizer1.fit(X)
normalizer2.fit(X)
normalizer3.fit(X)
print (normalizer1.transform(X))
print ("----------------------------------")
print (normalizer2.transform(X))
print ("----------------------------------")
print (normalizer3.transform(X))

print(1/np.sqrt(6))
print(1/np.sqrt((X[0]**2).sum()))  # 对应原始除以对应正则因子，1/np.sqrt((X[0]**2.sum()))

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
X = np.arange(6).reshape(3,2)
print(X)

poly1 = PolynomialFeatures(2)  # 2表示2次方，(x_1 + x_2)^2
poly1.fit(X)
print(poly1)
print(poly1.transform(X)) #X 的特征已经从 (X_1, X_2) 转换为 (1, X_1, X_2, X_1^2, X_1X_2, X_2^2)

poly2 = PolynomialFeatures(interaction_only=True)  # 去掉平方项
poly2.fit(X)
print(poly2)
print(poly2.transform(X))  #X 的特征已经从 (X_1, X_2) 转换为 (1, X_1, X_2,X_1X_2)

poly3 = PolynomialFeatures(include_bias=False)  # 去掉截距项，即第一列
poly3.fit(X)
print(poly3)
print(poly3.transform(X))

import numpy as np
from sklearn.feature_selection import VarianceThreshold,SelectKBest  # VarianceThreshold:异常方差较低的特征，SelectKBest:选择最好的特征
from sklearn.feature_selection import chi2  # 卡方验证

X = np.array([
    [0, 2, 0, 3],
    [0, 1, 4, 3],
    [0.1, 1, 1, 3]
], dtype=np.float64)
Y = np.array([1,2,1])
print(X.std(axis=0))

variance = VarianceThreshold(threshold=0.1) ##设置方差的阈值为0.1
print(variance)
variance.fit(X)
print(variance.transform(X)) #选择方差大于0.1的特征

sk2 = SelectKBest(chi2, k=2) #选择相关性最高的前2个特征
sk2.fit(X, Y)
print(sk2)
print(sk2.scores_)
print(sk2.transform(X))

import numpy as np
import matplotlib as mpl
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import BaggingRegressor

# 防止中文乱码
mpl.rcParams[‘font.sans-serif‘] = [u‘simHei‘]
mpl.rcParams[‘axes.unicode_minus‘] = False

# 设置在jupyter中matplotlib的显示情况
# %matplotlib tk

## 文件存储路径
path1 = "C0904.csv"
path2 = "C0911.csv"
filename = "X12CO2"  # 列的名字

# subplots与figure函数参数解释说明以及简单的使用脚本实例
# https://blog.csdn.net/henni_719/article/details/77479912

### 原始数据读取
plt.figure(figsize=(10, 6), facecolor=‘w‘)  # figsize:每英寸的宽度和高度,facecolor:背景色, 此处白色。如果不提供，默认值：figure.facecolor。
plt.subplot(121)  # 分成1x2（一行二列），占用第一个，即第一行第一列的子图
data = pd.read_csv(path1, header=0)  # 读取数据
x = data[filename].values  # 取X12CO2列的值

plt.plot(x, ‘r-‘, lw=1, label=u‘C0904‘)  # x:传入y轴的值，r-:红色，lw:线宽, label:线的标签名
plt.title(u‘实际数据0904‘, fontsize=18)  # 表格的标题，fontsize：字体大小
plt.legend(loc=‘upper right‘)  # loc:图的位置,右上
plt.xlim(0, 80000)  # x坐标最大值和最小值
plt.grid(b=True)    #  是否显示网格

plt.subplot(122)   # 分成1x2（一行二列），占用第二个，即第一行第二列的子图
data = pd.read_csv(path2, header=0)
x = data[filename].values
plt.plot(x, ‘r-‘, lw=1, label=u‘C0911‘)
plt.title(u‘实际数据0911‘, fontsize=18)
plt.legend(loc=‘upper right‘)
plt.xlim(0, 80000)
plt.grid(b=True)

plt.tight_layout(2, rect=(0, 0, 1, 0.95))  #2：图边和子图边的距离，rect: 将其设置为一个矩形，默认(0,0,1,1)
plt.suptitle(u‘如何找到下图中的异常值‘, fontsize=20)
plt.show()



### 异常数据处理
data = pd.read_csv(path2, header=0)
x = data[filename].values

width = 300
delta = 5
eps = 0.02
N = len(x)
p = []
# 异常值存储
abnormal = []
for i in np.arange(0, N, delta):  # [0,5,10,...]
    s = x[i:i+width]
    ## 获取max-min的差值
    min_s = np.min(s)
    ptp = np.ptp(s)  # 求最大值和最小值的差
    ptp_min = ptp / min_s
    p.append(ptp_min)
    ## 如果差值大于给定的阈值认为是存在异常值的区间
    if ptp_min > eps:
        abnormal.append(range(i, i+width))

## 获得异常的数据x值
abnormal = np.array(abnormal)  # 将列表转换为Arrray对象
abnormal = abnormal.flatten()  # 把数组降到一维
abnormal = np.unique(abnormal)  # 去重

#plt.plot(p, lw=1)
#plt.grid(b=True)
#plt.show()

plt.figure(figsize=(18, 7), facecolor=‘w‘)
plt.subplot(131)
plt.plot(x, ‘r-‘, lw=1, label=u‘原始数据‘)
plt.title(u‘实际数据‘, fontsize=18)
plt.legend(loc=‘upper right‘)
plt.xlim(0, 80000)
plt.grid(b=True)

plt.subplot(132)
t = np.arange(N)  # X的长度
plt.plot(t, x, ‘r-‘, lw=1, label=u‘原始数据‘)  # t为x值的序列，x为y值的序列
plt.plot(abnormal, x[abnormal], ‘go‘, markeredgecolor=‘g‘, ms=3, label=u‘异常值‘)  # g：表示为绿色，go:绿色圆圈
plt.legend(loc=‘upper right‘)
plt.title(u‘异常数据检测‘, fontsize=18)
plt.xlim(0, 80000)
plt.grid(b=True)

# 预测
plt.subplot(133)
select = np.ones(N, dtype=np.bool)  # N是形状
select[abnormal] = False
print(select)
t = np.arange(N)
## 决策树
dtr = DecisionTreeRegressor(criterion=‘mse‘, max_depth=10)  # criterion是决策树模型，max_depth是深度
br = BaggingRegressor(dtr, n_estimators=10, max_samples=0.3) # 把树模型丢到 集成学习器中，n_estimators:10个弱学习器，max_samples： 每个弱学习器选择30%的样本训练
## 模型训练

#我们不知道t的shape属性是多少，
#但是想让t变成只有一列，行数不知道多少，
#通过`t.reshape(-1,1)`，Numpy自动计算出行数

br.fit(t[select].reshape(-1, 1), x[select])
## 模型预测得出结果
y = br.predict(np.arange(N).reshape(-1, 1))
y[select] = x[select]
plt.plot(x, ‘g--‘, lw=1, label=u‘原始值‘)    # 原始值
plt.plot(y, ‘r-‘, lw=1, label=u‘校正值‘)     # 校正值
plt.legend(loc=‘upper right‘)
plt.title(u‘异常值校正‘, fontsize=18)
plt.xlim(0, 80000)
plt.grid(b=True)

plt.tight_layout(1.5, rect=(0, 0, 1, 0.95))
plt.suptitle(u‘异常值检测与校正‘, fontsize=22)
plt.show()