特征工程之mushroom classification

张坚白

2023-12-01

数据导入和预处理

导入数据

df=pd.read_csv('数据路径',encoding = "utf-8",header = 0)
pd.options.display.max_columns = None
#pd.options.display.max_rows = None
df.head(n=5)

read_csv()中header = 0是默认情况，表示以数据的第一行为列索引，
encoding = "utf-8"表明以utf-8为编码规则
options表示取消最大列、行的限制，避免行列不完全显示
在用Pandas读取数据之后，可使用head( )函数观察数据读取是否准确

percent_missing = df.isnull().sum() * 100 / len(df)
missing_values = pd.DataFrame({'percent_missing': percent_missing})
missing_values.sort_values(by ='percent_missing' , ascending=False

isnull().sum()统计每一列缺失值的个数,len()表示df的行数,len(df.columns)表示列数。percent_missing表示了每一列缺失值所占百分比
Pandas缺失值一些操作
pd.DataFrame({‘percent_missing’: percent_missing})利用list的字典来创建新的数据帧
Pandas.Dataframe()构造函数
sort_values()对percent_missing列进行降序排序，默认axis=0列排序，默认ascending=True升序排序
sort_values()

数据可视化(seaborn)

sns.set(style="ticks")
f = sns.countplot(x="class", data=df, palette="bwr")
plt.show()

set_style()设置主题，共有五个预设好的主题： darkgrid , whitegrid , dark , white ,和 ticks 默认： darkgrid
countplot()中palette为调色板，控制不同的颜色style
barplot()和countplot()

df['class'].value_counts(ascendind=False)
df.shape

value_counts()统计数据df中class对应列每个值出现的频数,如果想得出的计数占比，可以加参数normalize=True
shape得出df的维数(row,col)

One Hot Encoding

one hot编码是将类别变量转换为机器学习算法易于利用的一种形式的过程。
标签编码的问题是它经常假定类别值越高，该类别更好，这样对预测的结果会较差。经独热编码以后，特征个数会增加。
一个例子:假设“花”的一个特征可能的取值为daffodil（水仙）、lily（百合）、rose（玫瑰）。one hot编码将其转换为三个特征：is_daffodil、is_lily、is_rose，这些特征都是二进制的。此时三种特征取值分别对应100，010，001，特征也由原来的一个变成了三个。

X = df.drop(['class'], axis = 1)
Y = df['class']
X = pd.get_dummies(X, prefix_sep='_')

drop()返回新对象，默认axis=0为行，axis=1删除列，[]中填写需要删除行或列对应的索引
get_dummies()可实现one hot编码。它返回一个新对象，注意要赋给一个变量存结果，prefix_sep默认是’_’，即feature_category1这种形式

Y = LabelEncoder().fit_transform(Y)
#np.set_printoptions(threshold=np.inf)

LabelEncoder()标准化标签，将数值型或非数值型标签值统一转换成0~N-1
LabelEncoder()

Machine Learning

训练集和测试集划分

注意训练前先将特征数据标准化
数据预处理的fit(),transform()和fit_transform()的区别

X2 = StandardScaler().fit_transform(X)
X_Train, X_Test, Y_Train, Y_Test = train_test_split(X2, Y, test_size = 0.30, random_state = 101)

StandardScaler().fit_transform()根据计算将数据转换成标准正态分布
train_test_split()用于将矩阵随机划分为训练子集和测试子集，并返回划分好的训练集测试集样本和训练集测试集标签。random_state是随机数的种子。
随机数种子：其实就是该组随机数的编号，在需要重复试验的时候，保证得到一组一样的随机数。
随机数的产生取决于种子，随机数和种子之间的关系遵从以下两个规则：
种子不同，产生不同的随机数；种子相同，即使实例不同也产生相同的随机数。

训练模型的几种方法

start = time.process_time()  #获取当前时间
trainedmodel = LogisticRegression().fit(X_Train,Y_Train)
print(time.process_time() - start)   #显示训练模型用时
predictions =trainedmodel.predict(X_Test)
print(confusion_matrix(Y_Test,predictions))
print(classification_report(Y_Test,predictions))

.fit()训练模型，.predict()得到预测结果，根据训练模型用时可以评估某训练方法是否更优

LogisticRegression()

性能评估：混淆矩阵，准确率，召回率和F1值

读懂classification_report

trainedsvm = svm.LinearSVC().fit(X_Train, Y_Train)
predictionsvm = trainedsvm.predict(X_Test)

trainedtree = tree.DecisionTreeClassifier().fit(X_Train, Y_Train)
predictionstree = trainedtree.predict(X_Test)

trainedtree = tree.DecisionTreeClassifier().fit(X_Train, Y_Train)
predictionstree = trainedtree.predict(X_Test)

Feature Selection

Feature Importance

1.Random Forest

基于集合的决策树模型（如随机森林）可以用来对不同特征的重要性进行排序。
随机森林进行特征重要性度量的原理说明
 一个实例

trainedforest = RandomForestClassifier(n_estimators=700).fit(X_Train,Y_Train)
predictionforest = trainedforest.predict(X_Test)
print(confusion_matrix(Y_Test,predictionforest))
print(classification_report(Y_Test,predictionforest)

figure(num=None, figsize=(20, 22), dpi=80, facecolor='w', edgecolor='k')

feat_importances = pd.Series(trainedforest.feature_importances_, index= X.columns)
feat_importances.nlargest(19).plot(kind='barh')
plt.show()  #显示plot()的图像

n_estimators=700：决策树的个数，越多越好，至少100左右可以达到可接受的性能和误差率
figure()函数的用法
sklearn中已经实现了用随机森林评估特征重要性，在训练好随机森林模型后，直接调用feature_importances_属性就能得到每个特征的重要性。
一个例子
pd.Series()
Series.nlargest()第一个参数就是截取的行数。第二个参数就是依据的列名,按降序显示
Pandas可视化：plot()

2.Decision Tree

树结构顶部的特征是我们的模型为了执行分类而保留的最重要的特征。因此，只选择顶部的前几个特征，而放弃其他特征，可能创建一个准确度非常可观的模型。

start = time.process_time()
trainedtree = tree.DecisionTreeClassifier().fit(X_Train, Y_Train)
print(time.process_time() - start)
predictionstree = trainedtree.predict(X_Test)
print(confusion_matrix(Y_Test,predictionstree))
print(classification_report(Y_Test,predictionstree))

#决策树可视化
import graphviz
from sklearn.tree import DecisionTreeClassifier, export_graphviz

data = export_graphviz(trainedtree,out_file=None,feature_names= X.columns,
                       class_names=['edible', 'poisonous'],  
                       filled=True, rounded=True,  
                       max_depth=2,
                       special_characters=True)
graph = graphviz.Source(data)
graph

Simple Selection

尝试直接选择前几个最重要的特征训练模型，结果与原模型误差非常小。

X_Reduced = X[['odor_n','odor_f', 'gill-size_n','gill-size_b']]
X_Reduced = StandardScaler().fit_transform(X_Reduced)
X_Train2, X_Test2, Y_Train2, Y_Test2 = train_test_split(X_Reduced, Y, test_size = 0.30, random_state = 101)

start = time.process_time()
trainedforest = RandomForestClassifier(n_estimators=700).fit(X_Train2,Y_Train2)
print(time.process_time() - start)
predictionforest = trainedforest.predict(X_Test2)
print(confusion_matrix(Y_Test2,predictionforest))
print(classification_report(Y_Test2,predictionforest))

Recursive Feature Elimination

如果RFE采用的底层模型不稳定的话，RFE就是不稳定的,尽量不用未正则化的LR模型，而使用岭模型。这个问题中，我们采用的是随机森林模型。

from sklearn.feature_selection import RFE

#利用cross validation验证RFE在该问题中的优劣
model = RandomForestClassifier(n_estimators=700)
rfe = RFE(model, 4) 
start = time.process_time()
RFE_X_Train = rfe.fit_transform(X_Train,Y_Train)
RFE_X_Test = rfe.transform(X_Test)
rfe = rfe.fit(RFE_X_Train,Y_Train)
print(time.process_time() - start)
print("Overall Accuracy using RFE: ", rfe.score(RFE_X_Test,Y_Test))

RFE( estimator,n_features_to_select,step=1,verbose=0)：estimator指定基学习器，n_features_to_select指定最后留下特征的个数，step指定每次迭代移除的特征个数，verbose默认不显示中间过程
RFE()可以调用的属性：n_features_ 返回最终所选特征的数量；support_返回bool列表，true 表示一个特征被视为重要，false 表示一个特征不重要;ranking_ 返回特征排序列表，1为最优
必须先用fit_transform(trainData)，之后再transform(testData)，RFE.fit_transform()返回的是transformed的X，这里是数据只剩下保留的特征
RFE.score(X_test,Y_test)说明RFE经train set训练后的模型在test set上的效果
RFE()参数说明
 一个RFE的实例

#利用RFE后的数据拟合模型
model = RandomForestClassifier(n_estimators=700)
rfe = RFE(model, 4)
RFE_X_Train = rfe.fit_transform(X_Train,Y_Train)
model.fit(RFE_X_Train,Y_Train)
print("Number of Features: ", rfe.n_features_)
print("Selected Features: ")
colcheck = pd.Series(rfe.support_,index = list(X.columns))
colcheck[colcheck == True].index

Pearson Correlation Matrix

Numeric_df = pd.DataFrame(X)
Numeric_df['Y'] = Y
corr= Numeric_df.corr()
corr_y = abs(corr["Y"])
highest_corr = corr_y[corr_y >0.5]
highest_corr.sort_values(ascending=True)

X_Reduced2 = X[['bruises_f' , 'bruises_t' , 'gill-color_b' , 'gill-size_b' , 'gill-size_n' , 'ring-type_p' , 'stalk-surface-below-ring_k' , 'stalk-surface-above-ring_k' ,
                'odor_f', 'odor_n']]
X_Reduced2 = StandardScaler().fit_transform(X_Reduced2)
X_Train3, X_Test3, Y_Train3, Y_Test3 = train_test_split(X_Reduced2, Y, test_size = 0.30, random_state = 101)

start = time.process_time()
trainedsvm = svm.LinearSVC().fit(X_Train3, Y_Train3)
print(time.process_time() - start)
predictionsvm = trainedsvm.predict(X_Test3)
print(confusion_matrix(Y_Test3,predictionsvm))
print(classification_report(Y_Test3,predictionsvm))

DataFrame.corr(method=‘pearson’, min_periods=1)返回相关系数矩阵
method : {‘pearson’, ‘kendall’, ‘spearman’}

LASSO

LASSO的原理分析

regr = LassoCV(cv=5, random_state=101)
regr.fit(X_Train,Y_Train)
print("LassoCV Best Alpha Scored: ", regr.alpha_)
print("LassoCV Model Accuracy: ", regr.score(X_Test, Y_Test))
model_coef = pd.Series(regr.coef_, index = list(X.columns))
print("Variables Eliminated: ", str(sum(model_coef == 0)))
print("Variables Kept: ", str(sum(model_coef != 0)))

figure(num=None, figsize=(12, 10), dpi=80, facecolor='w', edgecolor='k')

top_coef = model_coef.sort_values()
top_coef[top_coef != 0].plot(kind = "barh")
plt.title("Most Important Features Identified using Lasso (!0)")