机器学习之数据分析常用方法_机器学习数据分析

数据分析常用

1.单项类别统计

data["列属性"].value_counts(normalize=True)

normalize=True:
dtype: int64
N    0.753
Y    0.247

normalize=False:
Name: fraud_reported, dtype: float64
NY    262
SC    248
1
2
3
4
5
6
7
8
9
10
11

2.多项类别统计

data.unique()
1

3.设置行|列最大

pd.set_option('display.max_columns',500) 列
pd.set_option('display.max_rows',500)	 行
1
2

4.根据一个属性统计另一个属性（不区分类别）画柱形图

ax = data.groupby('属性a').属性b.count().plot.bar(ylim=0)
1

5.根据一个属性统计另一个属性（区分类别）画柱形图

table =pd.crosstab(data.age,data.fraud_reported)  （行，列）
table.div(table.sum(1).astype(float),axis=0).plot(kind='bar',stacked=True)  因为列属性有两个类，所以使其总和为1显示
1
2

6.单属性画柱形图

ax = sns.countplot(x='属性',data=s)
1

7.画饼图

ax = (data['属性'].value_counts()*100.0/len(data)).plot.pie(autopct='%.1f%%',labels=['Male','Female'],fontsize=12)
#pie:表示饼图
#autopct:表示格式
#%.1f%%:第一个表示格式，.1f表示一位小数，%%表示百分号

1
2
3
4
5

8.inplace=True

true:直接在源数据上进行修改

false:创建新对象，然后覆盖

9.分箱操作

pd.cut(data.被划分的数据, bins, labels=names).astype(object)
bins:区间
lable:区间对应的标签
1
2
3

10.对多标签进行编码

数字编码：
1.LabelEncoder
from sklearn.preprocessing import LabelEncoder
x['标签后'] = LabelEncoder().fit_transform(dummies['标签前'])
2.map
class_dict = {
    'A': 1,
    'B': 2,
    'C': 3,
    'D': 4,
    'E': 5,
    'F': 6,
    'G': 7,
}
train_data['class'] = train_data['class'].map(class_dict)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

11.数据标准化

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler(with_mean=False)
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
StandardScaler：计算均值和方差
fit_transform：训练数据用的
transform：测试数据用的
1
2
3
4
5
6
7

12.随机森林（等算法）进行交叉验证

#随机森林
rfc = RandomForestClassifier(n_estimators=200)
#数据划分K折
kfold = KFold(n_splits=5, shuffle=True,random_state=7)
#交叉验证
result2 = cross_val_score(rfc, x_train_scaled, y_train, cv=kfold, scoring='accuracy')
1
2
3
4
5
6

#xgboot
xgb = XGBClassifier()
#逻辑回归
logreg= LogisticRegressionCV(solver='lbfgs', cv=cv)
#KNN
knn = KNeighborsClassifier(5)
#SVC
svcl = SVC()
#ADAboost
adb = AdaBoostClassifier()
#决策树
dt = DecisionTreeClassifier(max_depth=5)
#随机森林
rf = RandomForestClassifier()
#LDA 线性判别
lda = LinearDiscriminantAnalysis()
#
gnb = GaussianNB()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

13.逻辑回归算法

正则化选择参数：penalty

• L1：预测效果差、模型特征多，需要让一些不重要的特征系数归零，从而让模型稀疏化

  solver只能选择liblinear,因为l1正则化损失函数不是连续可导的，而其他三种都是需要二阶导数

• L2:解决过拟合

  solver四种皆可

优化算法选择参数：solver

• liblinear:坐标轴下降法
• lbfgs:二阶导数
• newton-cg:二阶导数
• sag:随机梯度下降

分类方式选择参数：multi_class

类型权重参数：class_weight

默认：不考虑权重

balance：根据数据量自动分配，样本量越多，权重越低

自定义权重比例：{0:0.9,1:0.1}

样本权重参数：sample_weight

在调用fit函数时使用

若class__weight 和 sample_weight都使用，权重就是

class__weight *sample_weight

正则化参数：C

C=[0.01,0.1,1,10,100]
从中选出最好的
1
2

列子

from sklearn import linear_model
logistic = linear_model.LogisticRegression()  
#如果用正则化，可以添加参数penalty，可以是l1正则化（可以更有效的抵抗共线性），也可以是l2正则化，如果是类别不均衡的数据集，可以添加class_weight参数，这个可以自己设置，也可以让模型自己计算
logistic = linear_model.LogisticRegression( penalty='l1', class_weight='balanced')
logistic.fit(X_train,y_train)
y_pred = logistic.predict( X_test)
#如果只想预测概率大小，可以用下面这个函数
y_pred = logistic.predict_proba(X_test)
1
2
3
4
5
6
7
8

14.AdaBoostClassifier

基分类器：base_estimator

默认是决策树

若为其他，则要指定样本权重

迭代次数：n_estimator

默认50次

学习率：learning_rate

默认1

模型提升准则：algorithm

samme:样本集预测错误的概率进行划分

samme.r:（默认）样本集预测错误的比例进行划分

随机种子：random_state

15.Xgboost

params = {
'booster': 'gbtree', 
'objective': 'multi:softmax', # 多分类的问题 
'num_class': 10, # 类别数，与 multisoftmax 并用 
'gamma': 0.1, # 用于控制是否后剪枝的参数,越大越保守，一般0.1、0.2这样子。 
'max_depth': 12, # 构建树的深度，越大越容易过拟合 
'reg_lambda': 2, # 控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。 
'subsample': 0.7, # 随机采样训练样本 
'colsample_bytree': 0.7, # 生成树时进行的列采样 
'min_child_weight': 3, 
'silent': 1, # 设置成1则没有运行信息输出，最好是设置为0. 
'learning_rate': 0.007, # 如同学习率 
'reg_alpha':0, # L1 正则项参数
'seed': 1000, 
'nthread': 4, # cpu 线程数 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

16.KNN

• n_neighbors ： int，optional(default = 5)
  默认情况下kneighbors查询使用的邻居数。就是k-NN的k的值，选取最近的k个点。
• weights ： str或callable，可选(默认=‘uniform’)
  默认是uniform，参数可以是uniform、distance，也可以是用户自己定义的函数。uniform是均等的权重，就说所有的邻近点的权重都是相等的。distance是不均等的权重，距离近的点比距离远的点的影响大。用户自定义的函数，接收距离的数组，返回一组维数相同的权重。
• algorithm ： {‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选
  快速k近邻搜索算法，默认参数为auto，可以理解为算法自己决定合适的搜索算法。除此之外，用户也可以自己指定搜索算法ball_tree、kd_tree、brute方法进行搜索，brute是蛮力搜索，也就是线性扫描，当训练集很大时，计算非常耗时。kd_tree，构造kd树存储数据以便对其进行快速检索的树形数据结构，kd树也就是数据结构中的二叉树。以中值切分构造的树，每个结点是一个超矩形，在维数小于20时效率高。ball
  tree是为了克服kd树高纬失效而发明的，其构造过程是以质心C和半径r分割样本空间，每个节点是一个超球体。
• leaf_size ： int，optional(默认值= 30)
  默认是30，这个是构造的kd树和ball树的大小。这个值的设置会影响树构建的速度和搜索速度，同样也影响着存储树所需的内存大小。需要根据问题的性质选择最优的大小。
• p ： 整数，可选(默认= 2)
  距离度量公式。在上小结，我们使用欧氏距离公式进行距离度量。除此之外，还有其他的度量方法，例如曼哈顿距离。这个参数默认为2，也就是默认使用欧式距离公式进行距离度量。也可以设置为1，使用曼哈顿距离公式进行距离度量。
• metric ： 字符串或可调用，默认为’minkowski’
  用于距离度量，默认度量是minkowski，也就是p=2的欧氏距离(欧几里德度量)。
• metric_params ： dict，optional(默认=None)
  距离公式的其他关键参数，这个可以不管，使用默认的None即可。
• n_jobs ： int或None，可选(默认=None)
  并行处理设置。默认为1，临近点搜索并行工作数。如果为-1，那么CPU的所有cores都用于并行工作。

17.特征筛选

from sklearn.feature_selection import SelectFromModel
from numpy import sort
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score

#搭建模型并训练
xgb = XGBClassifier()
xgb.fit(x_train_scaled,y_train)
xgb_pred = xgb.predict(X_test_scaled)
predictions = [round(value) for value in xgb_pred]
accuracy = accuracy_score(xgb_pred,y_test)
print("Accuracy: %.2f%%"%(accuracy*100.0))
#获取特征重要程度排行值
thresholds = sort(xgb.feature_importances_)

#根据排行值进行特征的选择
for threshold in thresholds:
    selected = SelectFromModel(xgb,threshold=threshold,prefit=True)
    selected_x_train = selected.transform(x_train_scaled)

    selected_model = XGBClassifier()
    selected_model.fit(selected_x_train,y_train)

    selected_x_test = selected.transform(X_test_scaled)
    selected_predict = selected_model.predict(selected_x_test)
    selected_predictions = [round(values) for values in selected_predict]
    selected_accuracy = accuracy_score(y_test,selected_predict)
    print("Thresholds: %.3f,n=%d,Accuracy: %.2f%%"%(threshold,selected_x_train.shape[1],selected_accuracy*100.0))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

画图查看重要程度
from xgboost import XGBClassifier,plot_importance
xgb = XGBClassifier()
xgb.fit(x_train_scaled,y_train)

plt.rcParams['figure.figsize']=[25,20]
plot_importance(xgb)
plt.show()
1
2
3
4
5
6
7
8

18.查看当前模型参数

from pprint import pprint
pprint(xgb.get_params())
1
2

19.网格搜索GridSearchCV()

1.estimator
选择使用的分类器，并且传入除需要确定最佳的参数之外的其他参数。
每一个分类器都需要一个scoring参数，或者score方法：
如estimator=RandomForestClassifier(
min_samples_split=100,
min_samples_leaf=20,
max_depth=8,
max_features=‘sqrt’,
random_state=10),

2.param_grid
需要最优化的参数的取值，值为字典或者列表，例如：
param_grid =param_test1，
param_test1 = {‘n_estimators’:range(10,71,10)}。

scoring=None
模型评价标准，默认None,这时需要使用score函数；或者如scoring=‘roc_auc’，
根据所选模型不同，评价准则不同。字符串（函数名），或是可调用对象，
需要其函数签名形如：scorer(estimator, X, y)；如果是None，则使用estimator的误差估计函数。
4.n_jobs=1
n_jobs: 并行数，int：个数,-1：跟CPU核数一致, 1:默认值

5.cv=None

交叉验证参数，默认None，使用三折交叉验证。指定fold数量，默认为3，也可以是yield产生训练/测试数据的生成器。

6.verbose=0, scoring=None
verbose：日志冗长度，int：冗长度，0：不输出训练过程，1：偶尔输出，>1：对每个子模型都输出。

7.pre_dispatch=‘2*n_jobs’
指定总共分发的并行任务数。当n_jobs大于1时，数据将在每个运行点进行复制，这可能导致OOM，
而设置pre_dispatch参数，则可以预先划分总共的job数量，使数据最多被复制pre_dispatch次

8.return_train_score=’warn’
如果“False”，cv_results_属性将不包括训练分数。

9.refit :默认为True,程序将会以交叉验证训练集得到的最佳参数，重新对所有可用的训练集与开发集进行，
作为最终用于性能评估的最佳模型参数。即在搜索参数结束后，用最佳参数结果再次fit一遍全部数据集。

10.iid:默认True,为True时，默认为各个样本fold概率分布一致，误差估计为所有样本之和，而非各个fold的平均。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41