MLb-018 61『Python機械学習基礎教程』まとめ(下)

print(data.gender.value_counts())

data_dummies=pd.get_dummies(data)

features = data_dummies.loc[:, 'feature_1':'feature_k']
X = features.values
y = data_dummies['target_1'].values
# target ， 0、1 

X_combined = np.hstack([X, X_binned])
reg = LinearRegression().fit(X_combined, y)
line_combined = np.hstack([line, line_binned])
reg.predict(line_combined)

X_product = np.hstack([X_binned,X* X_binned])
reg = LinearRegression().fit(X_product, y)
line_product = np.hstack([line_binned, line*line_binned])
reg.predict(line_product)

from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=10, include_bias=False)
# x**10 ，include_bias False 
poly.fit(X)
X_poly = poly.transform(X)
poly.get_feature_names()
# 

reg = LinearRegression().fit(X_poly, y)
line_poly = poly.transform(line)
reg.predict(line_poly)

from sklearn.feature_selection import SelectPercentile
select = SelectPercentile(percentile=50)
# 50% 
select.fit(X_train, y_train)
X_train_selected = select.transform(X_train)

mask = select.get_support()
# get_support 
print(mask)
plt.matshow(mask.reshape(1, -1), cmap='gray_r')
# ， True， False
plt.xlabel("Sample index")
plt.yticks(())

from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier
select = SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42),threshold="median")

select.fit(X_train, y_train)
X_train_l1 = select.transform(X_train)

X_test_l1 = select.transform(X_test)
score = LogisticRegression().fit(X_train_l1, y_train).score(X_test_l1, y_test)
print("Test score: {:.3f}".format(score))

from sklearn.feature_selection import RFE
select = RFE(RandomForestClassifier(n_estimators=100, random_state=42),n_features_to_select=40)
select.fit(X_train, y_train)

X_train_rfe = select.transform(X_train)
X_test_rfe = select.transform(X_test)
score = LogisticRegression().fit(X_train_rfe, y_train).score(X_test_rfe, y_test)
print("Test score: {:.3f}".format(score))

from sklearn.model_selection import KFold
kfold = KFold(n_splits=3, shuffle=True, random_state=0)
#shuffle： （ ，random_state ）
print("Cross-validation scores:
{}".format(cross_val_score(logreg, iris.data, iris.target, cv=kfold)))

from sklearn.model_selection import LeaveOneOut
loo = LeaveOneOut()
scores = cross_val_score(logreg, iris.data, iris.target, cv=loo)
# ， ， ， 
print("Number of cv iterations: ", len(scores))
print("Mean accuracy: {:.2f}".format(scores.mean()))

from sklearn.model_selection import ShuffleSplit
shuffle_split = ShuffleSplit(test_size=.5, train_size=.5, n_splits=10)
# train_size ， test_size ， n_iter ， ：train_size+test_size<1​
scores = cross_val_score(logreg, iris.data, iris.target, cv=shuffle_split)
print("Cross-validation scores:
{}".format(scores))

from sklearn.model_selection import GroupKFold
groups = [0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3]
scores = cross_val_score(logreg, X, y, groups, cv=GroupKFold(n_splits=3))
# ， 
print("Cross-validation scores:
{}".format(scores))

X_trainval, X_test, y_trainval, y_test = train_test_split(iris.data, iris.target, random_state=0)
X_train, X_valid, y_train, y_valid = train_test_split(X_trainval, y_trainval, random_state=1)

score = svm.score(X_valid, y_valid)

svm.fit(X_trainval, y_trainval)
test_score = svm.score(X_test, y_test)

scores = cross_val_score(svm, X_trainval, y_trainval, cv=5)
score = np.mean(scores)

param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100],'gamma': [0.001, 0.01, 0.1, 1, 10, 100]}
# 
from sklearn.model_selection import GridSearchCV
grid_search = GridSearchCV(SVC(), param_grid, cv=5,return_train_score=True)
grid_search.fit(X_train, y_train)
# 
print("Test set score: {:.2f}".format(grid_search.score(X_test, y_test)))
# ：best_score_ ， score 

results = pd.DataFrame(grid_search.cv_results_)
# ​​

param_grid = [{'kernel': ['rbf'],'C': [0.001, 0.01, 0.1, 1, 10, 100],'gamma': [0.001, 0.01, 0.1, 1, 10, 100]},{'kernel': ['linear'],'C': [0.001, 0.01, 0.1, 1, 10, 100]}]

from sklearn.metrics import confusion_matrix
confusion = confusion_matrix(y_test, pred_logreg)
# confusion 2*2 

from sklearn.metrics import classification_report
print(classification_report(y_test, svc.predict(X_test)))

from sklearn.metrics import precision_recall_curve
precision, recall, thresholds = precision_recall_curve(y_test, svc.decision_function(X_test))
plt.plot(precision, recall, label="precision recall curve")

from sklearn.metrics import average_precision_score
ap_svc = average_precision_score(y_test, svc.decision_function(X_test))

from sklearn.metrics import roc_curve
fpr, tpr, thresholds = roc_curve(y_test, svc.decision_function(X_test))
plt.plot(fpr, tpr, label="ROC Curve")

from sklearn.metrics import roc_auc_score
svc_auc = roc_auc_score(y_test, svc.decision_function(X_test))

f1_score(y_test, pred, average="micro")

f1_score(y_test, pred, average="macro")

roc_auc =  cross_val_score(SVC(), X, y == 1,scoring="roc_auc")
# ‘accuracy’（ ）， ‘roc_auc’（AUC）

grid = GridSearchCV(SVC(), param_grid=param_grid, scoring="roc_auc")
#