python基础教程四级查数据_《Python机器学习基础教程》四、数据表示与特征工程...

*本章讨论了如何处理不同的数据类型（特别是分类变量）。强调了使用适合机器学习算法的数据表示的重要性，例如one-hot编码过的分类变量。还讨论了通过特征工程生成新特征的重要性，以及利用专家知识从数据中创建到处特征的可能性。特别是线性模型，可能会从分箱、添加多项式和交互项而生成的新特性中大大受益。对于更加复杂的非线性模型（比如随机森林和SVM），在无需显式扩展特征空间的前提下就可以学习更加复杂的任务。在实践中，所使用的特征（以及特征与方法之间的匹配）通常是机器学习方法变现良好的最重要的因素。

如何找到最佳数据表示，这个问题被称为特征工程（feature engineering）

一、分类变量

1.One-Hot编码（虚拟变量）

表示分类变量最常用的方法就是使用one-hot编码（one-hot-encoding）或N取一编码（one-out-of-N encoding），也叫虚拟变量（dummy variable）。虚拟变量背后的思想是将一个分类变量替换为一个或多个新特征，新特征取值为0和1。

将数据转换为分类变量的one-dot编码有两种方法：一种是使用pandas，一种是使用scikit-learn。

（1）使用pandas从逗号分隔值（CSV）文件中加载数据：

import os

# The file has no headers naming the columns, so we pass header=None

# and provide the column names explicitly in "names"

adult_path = os.path.join(mglearn.datasets.DATA_PATH, "adult.data")

data = pd.read_csv(

adult_path, header=None, index_col=False,

names=['age', 'workclass', 'fnlwgt', 'education', 'education-num',

'marital-status', 'occupation', 'relationship', 'race', 'gender',

'capital-gain', 'capital-loss', 'hours-per-week', 'native-country',

'income'])

# For illustration purposes, we only select some of the columns:

data = data[['age', 'workclass', 'education', 'gender', 'hours-per-week',

'occupation', 'income']]

# IPython.display allows nice output formatting within the Jupyter notebook

display(data.head())

（2）检查字符串编码的分类数据

检查列的内容有一个好方法，就是使用pandas Series（Series是DataFrame中单列对应的数据内容）的value_counts函数，以显示唯一值及出现次数。

print(data.gender.value_counts())

Male 21790

Female 10771

Name: gender, dtype: int64

（3）用pandas编码数据有一种非常简单的方法，就是使用get_dummies函数。

get_dummies函数自动变换所有具有对象类型（比如字符串）的列或所有分类的列（这是pandas中的一个特殊概念）。

print("Original features:\n", list(data.columns), "\n")

data_dummies = pd.get_dummies(data)

print("Features after get_dummies:\n", list(data_dummies.columns))

Original features:

['age', 'workclass', 'education', 'gender', 'hours-per-week', 'occupation', 'income']

Features after get_dummies:

['age', 'hours-per-week', 'workclass_ ?', 'workclass_ Federal-gov', 'workclass_ Local-gov', 'workclass_ Never-worked', 'workclass_ Private', 'workclass_ Self-emp-inc', 'workclass_ Self-emp-not-inc', 'workclass_ State-gov', 'workclass_ Without-pay', 'education_ 10th', 'education_ 11th', 'education_ 12th', 'education_ 1st-4th', 'education_ 5th-6th', 'education_ 7th-8th', 'education_ 9th', 'education_ Assoc-acdm', 'education_ Assoc-voc', 'education_ Bachelors', 'education_ Doctorate', 'education_ HS-grad', 'education_ Masters', 'education_ Preschool', 'education_ Prof-school', 'education_ Some-college', 'gender_ Female', 'gender_ Male', 'occupation_ ?', 'occupation_ Adm-clerical', 'occupation_ Armed-Forces', 'occupation_ Craft-repair', 'occupation_ Exec-managerial', 'occupation_ Farming-fishing', 'occupation_ Handlers-cleaners', 'occupation_ Machine-op-inspct', 'occupation_ Other-service', 'occupation_ Priv-house-serv', 'occupation_ Prof-specialty', 'occupation_ Protective-serv', 'occupation_ Sales', 'occupation_ Tech-support', 'occupation_ Transport-moving', 'income_ <=50K', 'income_ >50K']

可以看到，连续特征age和hours-per-week没有发生变化，而分类特征的每个可能取值都被扩展为一个新特征：

display(data_dummies.head(n=10))

（4）使用values属性将data_dummies数据框（DataFrame）转换为NumPy数据

在训练模型之前，注意要把目标变量（现在被编码为两个income列）从数据中分离出来。

# Get only the columns containing features

# that is all columns from 'age' to 'occupation_ Transport-moving'

# This range contains all the features but not the target

features = data_dummies.loc[:, 'age':'occupation_ Transport-moving']

# extract NumPy arrays

X = features.values

y = data_dummies['income_ >50K'].values

print("X.shape:{}y.shape:{}".format(X.shape, y.shape))

X.shape: (32561, 44) y.shape: (32561,)

（5）在其上训练一个机器学习模型。

from sklearn.linear_model import LogisticRegression

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

logreg = LogisticRegression()

logreg.fit(X_train, y_train)

print("Test score:{:.2f}".format(logreg.score(X_test, y_test)))

Test score: 0.81

2.数字可以编码分类变量

分类特征通常用整数进行编码。它们是数字并不意味着它们必须被视为连续特征。一个整数特征应该被视为连续的还是离散的（one-hot编码的），有时并不明确。如果在被编码的语意之间没有顺序关系（比如workclass的例子），那么特征必须被视为离散特征。对于其他情况（比如五星评分），哪种编码更好取决于具体的任务和数据，以及使用哪种机器学习算法。

pandas的get_dummies函数将所有数字看做是连续的，不会为其创建虚拟变量。为了解决这个问题，你可以使用scikit-learn的OneHotEncoder，指定哪些变量是连续的、哪些变量是离散的，你也可以将数据框中的数值转换为字符串。为了说明这一点，我们创建一个两列的DataFrame对象，其中一列包含字符串，另一列包含整数：

# create a DataFrame with an integer feature and a categorical string feature

demo_df = pd.DataFrame({'Integer Feature': [0, 1, 2, 1],

'Categorical Feature': ['socks', 'fox', 'socks', 'box']})

display(demo_df)

使用get_dummies智慧编码字符串特征，不会改变整数特征：

display(pd.get_dummies(demo_df))

如果想为“Interger Feature”这一列创建虚拟变量，可以使用columns参数显式地给出想要编码的列，于是两个特征都会被当做分类特征处理：

demo_df['Integer Feature'] = demo_df['Integer Feature'].astype(str)

display(pd.get_dummies(demo_df, columns=['Integer Feature', 'Categorical Feature']))

二、分箱、离散化、线性模型与树

上图是在wave数据集上笔记线性回归和决策树。如你所知，线性模型只能对线性关系建模，对于单个特征的情况就是直线。决策树可以构建更为复杂的数据模型，但这强烈依赖于数据表示。有一种方法可以让线性模型在连续数据上变得更为强大，就是使用特征分箱（binning，也叫离散化，即discretization）将其划分为多个特征。

我们假设将特征输入范围（这里是从-3到3）划分成固定个数的箱子（bin），比如10个，那么数据点就可以用它所在的箱子来表示。

bins = np.linspace(-3, 3, 11)

print("bins:{}".format(bins))

bins: [-3. -2.4 -1.8 -1.2 -0.6 0. 0.6 1.2 1.8 2.4 3. ]

接下来，我们记录每个数据点所属的箱子，可以用np.digitize函数轻松计算出来：

which_bin = np.digitize(X, bins=bins)

print("\nData points:\n", X[:5])

print("\nBin membership for data points:\n", which_bin[:5])

Data points:

[[-0.753]

[ 2.704]

[ 1.392]

[ 0.592]

[-2.064]]

Bin membership for data points:

[[ 4]

[10]

[ 8]

[ 6]

[ 2]]

我们在这里做的是将wave数据集中单个连续输入特征变换为一个分类特征，用于表示数据点所在的箱子。要想在这个数据上使用scikit-learn模型，我们利用preprocessing模块的OneHotEncoder将这个离散特征变换为one-hot编码。OneHotEncoder实现的编码与pandas.get_dummies相同，但目前它只适用于值为整数的分类变量。

from sklearn.preprocessing import OneHotEncoder

# transform using the OneHotEncoder

encoder = OneHotEncoder(sparse=False)

# encoder.fit finds the unique values that appear in which_bin

encoder.fit(which_bin)

# transform creates the one-hot encoding

X_binned = encoder.transform(which_bin)

print(X_binned[:5])

[[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]

[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]

[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]

[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]]

由于我们指定了10个箱子，所以变换后的X_binned数据集现在包含10个特征：

print("X_binned.shape:{}".format(X_binned.shape))

X_binned.shape: (100, 10)

下面，我们在one-hot编码后的数据上构建新的线性模型和新的决策树模型（箱子的边界由黑色虚线表示）：

line_binned = encoder.transform(np.digitize(line, bins=bins))

reg = LinearRegression().fit(X_binned, y)

plt.plot(line, reg.predict(line_binned), label='linear regression binned')

reg = DecisionTreeRegressor(min_samples_split=3).fit(X_binned, y)

plt.plot(line, reg.predict(line_binned), label='decision tree binned')

plt.plot(X[:, 0], y, 'o', c='k')

plt.vlines(bins, -3, 3, linewidth=1, alpha=.2)

plt.legend(loc="best")

plt.ylabel("Regression output")

plt.xlabel("Input feature")

箱子的边界由灰色虚线表示，可以看到线性回归和决策树做出了完全相同的预测（两条线完全重合）。对于每个箱子，二者都预测一个常数值。比较对特征进行分箱前后模型学到的内容，我们发现，线性模型变得更加灵活了，因为现在它对每个箱子具有不同的取值，而决策树模型的灵活性降低了。

分箱特征对基于树的模型通常不会产生更好地效果，因为这种模型可以学习在任何位置划分数据，从某种意义上来看，决策树可以学习如何分箱对预测这些数据最为有用，此外，决策树可以同时查看多个特征，而分箱通常针对的是单个特征。线性模型的表现力在数据变化后得到了极大的提高。

对于特定的数据集，如果有充分的理由使用线性模型——比如数据集很大、维度很高，但有些特征与输出的关系是非线性的——那么分箱是提高建模能力的好办法。

三、交互特征与多项式特征

1.向分箱数据上的线性模型添加斜率

一种方法是重新加入原始特征（图中的x轴）

X_combined = np.hstack([X, X_binned])

print(X_combined.shape)

(100, 11)

reg = LinearRegression().fit(X_combined, y)

line_combined = np.hstack([line, line_binned])

plt.plot(line, reg.predict(line_combined), label='linear regression combined')

for bin in bins:

plt.plot([bin, bin], [-3, 3], ':', c='k', linewidth=1)

plt.legend(loc="best")

plt.ylabel("Regression output")

plt.xlabel("Input feature")

plt.plot(X[:, 0], y, 'o', c='k')

np.vstack():在竖直方向上堆叠

np.hstack():在水平方向上平铺

例：

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

arr2=np.array([4,5,6])

print np.vstack((arr1,arr2))

print np.hstack((arr1,arr2))

[[1 2 3]

[4 5 6]]

[1 2 3 4 5 6]

可以看到上图，模型在每个箱子中都学到了一个偏移，还学到了一个斜率。学到的斜率是向下的，并且在所有箱子中都相同——只有一个x轴特征，也就只有一个斜率。因为斜率在所有箱子中是相同的，所以它似乎不是很有用。

我们希望每个箱子都有一个不同的斜率，为了实现这一点，我们可以添加交互特征或者乘积特征，用来表示数据点所在箱子以及数据点在x轴上的位置。这个特征是箱子指示符与原始特征的乘积：

X_product = np.hstack([X_binned, X * X_binned])

print(X_product.shape)

(100, 20)

reg = LinearRegression().fit(X_product, y)

line_product = np.hstack([line_binned, line * line_binned])

plt.plot(line, reg.predict(line_product), label='linear regression product')

for bin in bins:

plt.plot([bin, bin], [-3, 3], ':', c='k', linewidth=1)

plt.plot(X[:, 0], y, 'o', c='k')

plt.ylabel("Regression output")

plt.xlabel("Input feature")

plt.legend(loc="best")

如你所见，现在这个模型中每个箱子都有自己的偏移和斜率。

2.使用分箱是扩展连续特征的一种方法。另一种方法是使用原始特征的多项式（polynomial）。

对于给定特征x，我们可以考虑x**2、x**3、x**4，等等。这在preprocessing模块的PolynomialFeatures中实现：

from sklearn.preprocessing import PolynomialFeatures

# include polynomials up to x ** 10:

# the default "include_bias=True" adds a feature that's constantly 1

poly = PolynomialFeatures(degree=10, include_bias=False)

poly.fit(X)

X_poly = poly.transform(X)

print("X_poly.shape:{}".format(X_poly.shape))

X_poly.shape: (100, 10)

print("Entries of X:\n{}".format(X[:5]))

print("Entries of X_poly:\n{}".format(X_poly[:5]))

Entries of X:

[[-0.753]

[ 2.704]

[ 1.392]

[ 0.592]

[-2.064]]

Entries of X_poly:

[[ -0.753 0.567 -0.427 0.321 -0.242 0.182 -0.137

0.103 -0.078 0.058]

[ 2.704 7.313 19.777 53.482 144.632 391.125 1057.714

2860.36 7735.232 20918.278]

[ 1.392 1.938 2.697 3.754 5.226 7.274 10.125

14.094 19.618 27.307]

[ 0.592 0.35 0.207 0.123 0.073 0.043 0.025

0.015 0.009 0.005]

[ -2.064 4.26 -8.791 18.144 -37.448 77.289 -159.516

329.222 -679.478 1402.367]]

print("Polynomial feature names:\n{}".format(poly.get_feature_names()))

Polynomial feature names:

['x0', 'x0^2', 'x0^3', 'x0^4', 'x0^5', 'x0^6', 'x0^7', 'x0^8', 'x0^9', 'x0^10']

将多项式特征与线性回归模型一起使用，可以得到经典的多项式回归模型。

reg = LinearRegression().fit(X_poly, y)

line_poly = poly.transform(line)

plt.plot(line, reg.predict(line_poly), label='polynomial linear regression')

plt.plot(X[:, 0], y, 'o', c='k')

plt.ylabel("Regression output")

plt.xlabel("Input feature")

plt.legend(loc="best")

可见，多项式特征在一个一维数据上得到了非常平滑的拟合。但高次多项式在边界上或数据很少的区域可能有极端的表现。

作为对比，下面是在原始数据上学到的核SVM模型，没有做任何变换：

from sklearn.svm import SVR

for gamma in [1, 10]:

svr = SVR(gamma=gamma).fit(X, y)

plt.plot(line, svr.predict(line), label='SVR gamma={}'.format(gamma))

plt.plot(X[:, 0], y, 'o', c='k')

plt.ylabel("Regression output")

plt.xlabel("Input feature")

plt.legend(loc="best")

可以看到使用更加复杂的模型（即核SVM），我们能够得到一个与多项式回归的复杂度类似的预测结果，且不需要进行显式的特征变换。

3.交互特征和多项式特征更加实际的应用

from sklearn.datasets import load_boston

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import MinMaxScaler

boston = load_boston()

X_train, X_test, y_train, y_test = train_test_split(

boston.data, boston.target, random_state=0)

# rescale data

scaler = MinMaxScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

poly = PolynomialFeatures(degree=2).fit(X_train_scaled)

X_train_poly = poly.transform(X_train_scaled)

X_test_poly = poly.transform(X_test_scaled)

print("X_train.shape:{}".format(X_train.shape))

print("X_train_poly.shape:{}".format(X_train_poly.shape))

X_train.shape: (379, 13)

X_train_poly.shape: (379, 105)

print("Polynomial feature names:\n{}".format(poly.get_feature_names()))

Polynomial feature names:

['1', 'x0', 'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8', 'x9', 'x10', 'x11', 'x12', 'x0^2', 'x0 x1', 'x0 x2', 'x0 x3', 'x0 x4', 'x0 x5', 'x0 x6', 'x0 x7', 'x0 x8', 'x0 x9', 'x0 x10', 'x0 x11', 'x0 x12', 'x1^2', 'x1 x2', 'x1 x3', 'x1 x4', 'x1 x5', 'x1 x6', 'x1 x7', 'x1 x8', 'x1 x9', 'x1 x10', 'x1 x11', 'x1 x12', 'x2^2', 'x2 x3', 'x2 x4', 'x2 x5', 'x2 x6', 'x2 x7', 'x2 x8', 'x2 x9', 'x2 x10', 'x2 x11', 'x2 x12', 'x3^2', 'x3 x4', 'x3 x5', 'x3 x6', 'x3 x7', 'x3 x8', 'x3 x9', 'x3 x10', 'x3 x11', 'x3 x12', 'x4^2', 'x4 x5', 'x4 x6', 'x4 x7', 'x4 x8', 'x4 x9', 'x4 x10', 'x4 x11', 'x4 x12', 'x5^2', 'x5 x6', 'x5 x7', 'x5 x8', 'x5 x9', 'x5 x10', 'x5 x11', 'x5 x12', 'x6^2', 'x6 x7', 'x6 x8', 'x6 x9', 'x6 x10', 'x6 x11', 'x6 x12', 'x7^2', 'x7 x8', 'x7 x9', 'x7 x10', 'x7 x11', 'x7 x12', 'x8^2', 'x8 x9', 'x8 x10', 'x8 x11', 'x8 x12', 'x9^2', 'x9 x10', 'x9 x11', 'x9 x12', 'x10^2', 'x10 x11', 'x10 x12', 'x11^2', 'x11 x12', 'x12^2']

from sklearn.linear_model import Ridge

ridge = Ridge().fit(X_train_scaled, y_train)

print("Score without interactions:{:.3f}".format(

ridge.score(X_test_scaled, y_test)))

ridge = Ridge().fit(X_train_poly, y_train)

print("Score with interactions:{:.3f}".format(

ridge.score(X_test_poly, y_test)))

Score without interactions: 0.621

Score with interactions: 0.753

from sklearn.ensemble import RandomForestRegressor

rf = RandomForestRegressor(n_estimators=100).fit(X_train_scaled, y_train)

print("Score without interactions:{:.3f}".format(

rf.score(X_test_scaled, y_test)))

rf = RandomForestRegressor(n_estimators=100).fit(X_train_poly, y_train)

print("Score with interactions:{:.3f}".format(rf.score(X_test_poly, y_test)))

Score without interactions: 0.788

Score with interactions: 0.780

显然，在使用Ridge时，交互特征和多项式特征对性能有很大提升，但如果使用更加复杂的模型（比如随机森林），情况会稍有不同：即使没有额外的特征，随机森林的性能也要优于Ridge。添加交互特征和多项式特征实际上会略微降低其性能。

四、单变量非线性变换

大部分模型都在每个特征（在回归问题中还包括目标值）大致遵循高斯分布时表现最好，也就是说，每个特征的直方图应用该具有类似于熟悉的“钟形曲线”的形状。使用诸如log和exp之类的变换并不稀奇，但却是实现这一点的简单又有效的方法。在一种特别常见的情况下，这样的变换非常有用，就是处理整数计数数据时。计数数据是指类似“用户A多长时间登录一次？”这样的特征。计数不可能取负值，并且通常遵循特定的统计模式。下面我们使用一个模拟的计数数据集，其性质与在自然状态下能找到的数据集类似。特征全是整数值，而响应是连续的。

rnd = np.random.RandomState(0)

X_org = rnd.normal(size=(1000, 3)) # 生成高斯分布的概率函数密度，大小为1000行，3列

w = rnd.normal(size=3) # 生成高斯分布的概率函数密度，大小为3列

X = rnd.poisson(10 * np.exp(X_org)) # 返回e的幂次方，e是一个常数为2.71828

# numpy.random.poisson(lam=1.0, size=None)

# Draw samples from a Poisson distribution.

y = np.dot(X_org, w)

print("Number of feature appearances:\n{}".format(np.bincount(X[:, 0]))) # 计算每个值出现的次数

Number of feature appearances:

[28 38 68 48 61 59 45 56 37 40 35 34 36 26 23 26 27 21 23 23 18 21 10 9

17 9 7 14 12 7 3 8 4 5 5 3 4 2 4 1 1 3 2 5 3 8 2 5

2 1 2 3 3 2 2 3 3 0 1 2 1 0 0 3 1 0 0 0 1 3 0 1

0 2 0 1 1 0 0 0 0 1 0 0 2 2 0 1 1 0 0 0 0 1 1 0

0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0

1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]

bins = np.bincount(X[:, 0]) # 统计次数

plt.bar(range(len(bins)), bins, color='grey')

plt.ylabel("Number of appearances")

plt.xlabel("Value")

上图是X[:,0]特征取值的直方图

尝试拟合一个岭回归模型：

from sklearn.linear_model import Ridge

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

score = Ridge().fit(X_train, y_train).score(X_test, y_test)

print("Test score:{:.3f}".format(score))

Test score: 0.622

X_train_log = np.log(X_train + 1)

X_test_log = np.log(X_test + 1)

plt.hist(X_train_log[:, 0], bins=25, color='gray')

plt.ylabel("Number of appearances")

plt.xlabel("Value")

score = Ridge().fit(X_train_log, y_train).score(X_test_log, y_test)

print("Test score: {:.3f}".format(score))

Test score: 0.875

可以从处理过程看出：Ridge无法真正捕获x和y之间的关系。不过应用对数变换可能有用。由于数据取值中包括0（对数在0处没有定义），所以我们不能直接应用log，而是要计算log（X+1）。变换后，数据分布的不对称性变小，也不再有非常大的异常值。在新数据上构建一个岭回归模型，可以得到更好地拟合。

为数据集合模型的所有组合寻找最佳变换，这在某种程度上是一门艺术。在上例中，所有特征都具有相同的性质，这在实践中是非常少见的情况。通常来说，只有一部分特征应该进行变换，有时每个特征的变换方式也各不相同。前面提到过，对基于树的模型而言，这种变换并不重要，但对线性模型来说可能至关重要。对回归的目标变量y进行变换有时也是一个好主意。尝试预测计数（比如订单数量）是一项相当常见的任务，而且使用log（y+1）变换也往往有用。

从前面的例子中可以看出，分箱、多项式和交互项都对模型在给定数据集上的性能有很大影响，对于复杂度较低的模型更是这样，比如线性模型和朴素贝叶斯模型。与之相反，基于树的模型通常能够自己发现重要的交互项，大多数情况下不需要显式地变换数据。其他模型，比如SVM、最近邻和神经网络，有时可能会从使用分箱、交互项或多项式中受益，但其效果通常不如线性模型那么明显。