练习总结+sklearn参数选择调优
⽐赛相关部分练习总结
df_train = pd.read_csv('C:/Users/zhangy/Desktop/kaggle_competition_feature_engineering/kaggle_bike_competition_train.csv')
# print(train.shape)
# print(train.apply(lambda x:sum(x.isnull())))              #查看每⼀列缺失值的数量
df_train['month'] = pd.DatetimeIndex(df_train.datetime).month
df_train['day'] = pd.DatetimeIndex(df_train.datetime).dayofweek
df_train['hour'] = pd.DatetimeIndex(df_train.datetime).hour
df_train_origin = df_train
df_train=df_train.drop(['datetime'],axis=1)
df_train_target = df_train['count']                #训练集标签
df_train_data = df_train.drop(['count'],axis=1)    #训练集数据
X_train,X_test,y_train,y_test=train_test_split(df_train_data,df_train_target,test_size=0.2,random_state=0)
# clf = RandomForestRegressor(n_estimators=100)
# clf.fit(X_train,y_train)
# print(clf.score(X_train,y_train))
# print(clf.score(X_test,y_test))
RandomForest:
criterion='mse',
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_features='auto',
max_leaf_nodes=None,
min_impurity_split=1e-07,
bootstrap=True,
oob_score=False,
n_jobs=1,
random_state=None,
verbose=0,
warm_start=False)
其中关于决策树的参数：
criterion: “mse”来选择最合适的节点。
splitter: ”best” or “random”(default=”best”)随机选择属性还是选择不纯度最⼤的属性，建议⽤默认。
max_features: 选择最适属性时划分的特征不能超过此值。
当为整数时，即最⼤特征数；当为⼩数时，训练集特征数*⼩数；
if “auto”, then max_features=sqrt(n_features).
If “sqrt”, thenmax_features=sqrt(n_features).
If “log2”, thenmax_features=log2(n_features).
If None, then max_features=n_features.
max_depth: (default=None)设置树的最⼤深度，默认为None，这样建树时，会使每⼀个叶节点只有⼀个类别，或是达到min_samples_split。
min_samples_split: 根据属性划分节点时，每个划分最少的样本数。
min_samples_leaf: 叶⼦节点最少的样本数。
max_leaf_nodes: (default=None)叶⼦树的最⼤样本数。
min_weight_fraction_leaf: (default=0) 叶⼦节点所需要的最⼩权值
verbose: (default=0) 是否显⽰任务进程
关于随机森林特有的参数：
n_estimators=10： 决策树的个数，越多越好，但是性能就会越差，⾄少100左右（具体数字忘记从哪⾥来的了）可以达到可接受的性能和误差率。
bootstrap=True： 是否有放回的采样。
oob_score=False： oob（out of band，带外）数据，即：在某次决策树训练中没有被bootstrap选中的数据。多单个模型的参数训练，我们知道可以⽤cross validation（cv）来进⾏，但是特别消耗时间，⽽且对于随机森林这种情况也没有⼤的必要，所以就⽤这个数据对决策树模型进⾏验证，算是⼀个简单的交叉验证。性能消耗⼩，但是效果不错。
n_jobs=1： 并⾏job个数。这个在ensemble算法中⾮常重要，尤其是bagging（⽽⾮boosting，因为boosting的每次迭代之间有影响，所以很难进⾏并⾏化），因为可以并⾏从⽽提⾼性能。1=不并⾏；n：n个并⾏；-1：CPU有多少core，就启动多少job
warm_start=False： 热启动，决定是否使⽤上次调⽤该类的结果然后增加新的。
class_weight=None： 各个label的权重。
进⾏预测可以有⼏种形式：
predict_proba(x)： 给出带有概率值的结果。每个点在所有label的概率和为1.
predict(x)： 直接给出预测结果。内部还是调⽤的predict_proba()，根据概率的结果看哪个类型的预测值最⾼就是哪个类型。
predict_log_proba(x)： 和predict_proba基本上⼀样，只是把结果给做了log()处理。
# clf = svm.SVC(kernel='rbf',C=10,gamma=0.001,probability=True)
# clf.fit(X_train,y_train)
#
# print(clf.score(X_train,y_train))
# print(clf.score(X_test,y_test))
SVM:
sklearn.svm.SVC(C=1.0, kernel=‘rbf’, degree=3, gamma=‘auto’, coef0=0.0, shrinking=True, probability=False,
tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1,
decision_function_shape=None,random_state=None)
参数：
l C：C-SVC的惩罚参数C?默认值是1.0
C越⼤，相当于惩罚松弛变量，希望松弛变量接近0，即对误分类的惩罚增⼤，趋向于对训练集全分对的情况，这样对训练集测试时准确率很⾼，但泛化能⼒弱。C值⼩，对误分类的惩罚减⼩，允许容错，将
他们当成噪声点，泛化能⼒较强。
l kernel ：核函数，默认是rbf，可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
0 – 线性：u’v
1 – 多项式：(gamma*u’*v + coef0)^degree
2 – RBF函数：exp(-gamma|u-v|^2)
3 –sigmoid：tanh(gamma*u’*v + coef0)
l degree ：多项式poly函数的维度，默认是3，选择其他核函数时会被忽略。
l gamma ： ‘rbf’,‘poly’ 和‘sigmoid’的核函数参数。默认是’auto’，则会选择1/n_features
l coef0 ：核函数的常数项。对于‘poly’和 ‘sigmoid’有⽤。
l probability ：是否采⽤概率估计？.默认为False
l shrinking ：是否采⽤shrinking heuristic⽅法，默认为true
l tol ：停⽌训练的误差值⼤⼩，默认为1e-3
l cache_size ：核函数cache缓存⼤⼩，默认为200
l class_weight ：类别的权重，字典形式传递。设置第⼏类的参数C为weight*C(C-SVC中的C)
l verbose ：允许冗余输出？
l max_iter ：最⼤迭代次数。-1为⽆限制。
l decision_function_shape ：‘ovo’, ‘ovr’ or None, default=None3
l random_state ：数据洗牌时的种⼦值，int值
主要调节的参数有：C、kernel、degree、gamma、coef0
tuned_parameters = [{'n_estimators':[10,100,500]}]
scores = ['r2']
for score in scores:
clf = GridSearchCV(RandomForestRegressor(),tuned_parameters,cv=5,scoring=score)
clf.fit(X_train,y_train)
print("最佳参数为：")
print(clf.best_params_)
print("得分分别为：")
for params, mean_score, scores id_scores_:
print("%0.3f (+/-%0.03f) for %r"% (mean_score, scores.std()/2, params))
GridSearchCV：
estimator —— 模型
param_grid —— dict or list of dictionaries
scoring ---- 评分函数
fit_params --- dict, optional
n_jobs ------并⾏任务个数，int, default=1
pre_dispatch ------ int, or string, optional ‘2*n_jobs’
iid ----- boolean, default=True
cv ----- int, 交叉验证，默认3
refit ---- boolean, or string, default=True
verbose ----- integer
error_score ------ ‘raise’ (default) or numeric
总结⼀些特征查看处理⼩技巧
print(train.apply(lambda x:sum(x.isnull())))    #查看每列特征缺失值个数
print(train['grade'].value_counts())  #查看某列数据不同值的个数
print(train['int_rate'].unique())  #查看某特征中只有⼀个值得项
train.drop(['id','member_id'],axis=1,inplace=True) #删掉数据集中的某些列
train.boxplot(column=['open_acc'],return_type='axes') #绘制某⼀列特征的箱体图
temp = pd.DatetimeIndex(train['datetime'])
train['date'] = temp.date
train['time'] = temp.time    #2011/1/1  2:00:00原特征，现在讲时间和⽇期分开
train['hour'] = pd.to_datetime(train.time, format="%H:%M:%S")
train['hour'] = pd.Index(train['hour']).hour  #再单独把hour拿出来
train['dayofweek'] = pd.DatetimeIndex(train.date).dayofweek  #把数据转换为周⼏
train['dateDays'] = (train.date - train.date[0]).astype('timedelta64[D]') #表⽰距离第⼀套的时长
byday = upby('dayofweek')
print(byday['casual'].sum().reset_index())  #统计⼀周每天‘casual’特征的情况
train['Saturday']=0
train.Saturday[train.dayofweek==5]='a'
train['Sunday']=0
train.Sunday[train.dayofweek==6]='b'    #单独去除某⼀天作为特征，并赋值（任意）
train['Saturday']=0
train.Saturday[train.dayofweek==5]='a'
train['Sunday']=0
train.Sunday[train.dayofweek==6]='b'    #单独去除某⼀天作为特征，并赋值（任意）
dataRel = train.drop(['datetime', 'count','date','time','dayofweek'], axis=1) #删除某些列
对于pandas的dataframe我们有⽅法/函数可以直接转成python中的dict。另外，在这⾥我们要对离散值和连续值特征区分⼀下了，以便之后分开做不同的特征处理
featureConCols = ['temp','atemp','humidity','windspeed','dateDays','hour']
dataFeatureCon = dataRel[featureConCols]
dataFeatureCon = dataFeatureCon.fillna( 'NA' ) #in case I missed any
X_dictCon = _dict().values()
把离散值的属性放到另外⼀个dict中
featureCatCols = ['season','holiday','workingday','weather','Saturday', 'Sunday']
dataFeatureCat = dataRel[featureCatCols]
dataFeatureCat = dataFeatureCat.fillna( 'NA' ) #in case I missed any
X_dictCat = _dict().values()
向量化特征
vec = DictVectorizer(sparse = False)
X_vec_con = vec.fit_transform(X_dictCon)
X_vec_cat = vec.fit_transform(X_dictCat)
对连续值属性做⼀些处理，最基本的当然是标准化，让连续值属性处理过后均值为0，⽅差为1。
from sklearn import preprocessing
# 标准化连续值数据
scaler = preprocessing.StandardScaler().fit(X_vec_con)
X_vec_con = ansform(X_vec_con)    #标准化连续值向量
类别特征编码，最常⽤的当然是one-hot编码咯，⽐如颜⾊红、蓝、黄会被编码为[1, 0, 0]，[0, 1, 0]，[0, 0, 1] from sklearn import preprocessing
# one-hot编码
enc = preprocessing.OneHotEncoder()
enc.fit(X_vec_cat)
X_vec_cat = ansform(X_vec_cat).toarray()
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
y = le.fit_transform(y) # 把字符串标签转换为整数，恶性-1，良性-0 标签编码
k-fold交叉验证：
1⾃⼰⼿写！！
ss_validation import StratifiedKFoldweight的所有形式
import numpy as np
scores = []
kfold = StratifiedKFold(y=y_train, n_folds=10, random_state=1) # n_folds参数设置为10份
for train_index, test_index in kfold:
pipe_lr.fit(X_train[train_index], y_train[train_index])
score = clf.score(X_train[test_index], y_train[test_index])
scores.append(score)
print('类别分布: %s, 准确度: %.3f' % (np.bincount(y_train[train_index]), score))
2、sklearn
ss_validation import cross_val_score
scores = cross_val_score(estimator=clf, X=X_train, y=y_train, cv=10, n_jobs=1)
F-score:
ics import confusion_matrix
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
confmat = confusion_matrix(y_true=y_test, y_pred=y_pred)

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。