J'ai récemment terminé le cours Data Camp Data Scientist. Étant donné que j'étudiais en anglais, je voulais le relire en japonais, mais j'étais heureux que le livre intitulé Machine Learning Picture Book soit facile à comprendre, alors je l'ai lu, mais heureusement, "Chapitre 4 Méthode d'évaluation et Je l'ai revu parce qu'il y avait une copie de contenu qui pratiquait réellement avec le code Python dans "Manipuler diverses données".
Il y a certaines parties où le code est un peu modifié en cours de route, mais fondamentalement, c'est presque la même chose. Afin de vérifier l'état des données qui change avec chaque commande, la forme des données, etc. est décrite dans les commentaires le cas échéant.
L'exemple de programme d'origine est publié à l'URL suivante, veuillez donc vous y référer pour l'original. Veuillez vous inscrire sur le site Web de Shosuisha lors du téléchargement.
Les sauts de code sont divisés où ils peuvent être coupés au niveau du code lorsque vous vous entraînez réellement, et plusieurs sujets sont mélangés.
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer () # Données sur le cancer du sein au Wisconsin
Xo = data.data # Xo.shape = (569, 30)
y = 1 - data.target # reverse target paramater
X = Xo [:,: 10] # mean_ * les données se trouvent dans les 10 premières colonnes
LogisticRegression
from sklearn.linear_model import LogisticRegression
# model_lor = LogisticRegression () #FutureWarning: Le solveur par défaut sera changé en 'lbfgs' en 0.22
model_lor = LogisticRegression (solver = 'liblinear') # Si vous spécifiez le solveur et le relancez, l'avertissement n'apparaît pas.
model_lor.fit(X, y)
y_pred = model_lor.predict(X)
ConfusionMatrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y, y_pred)
print("============= CONFUSION MATRIX ============= ")
print(cm)
'''
Sort dans une matrice de prédictions et le nombre de cas corrects
Predict
0 1
Actual 0 [341 16]
1 [ 36 176]
'''
Accuracy Score
from sklearn.metrics import accuracy_score
accs = accuracy_score(y, y_pred)
print("============= ACCURACY SCORE ============= ")
print (accs) # Taux de réponse correct. Taux de réponse correct pour l'ensemble du résultat de la prédiction. (341 + 176) / 569
Precision Score
from sklearn.metrics import precision_score
pres = precision_score(y, y_pred)
print("============= PRECISION SCORE ============= ")
print (pres) # Taux de conformité. Le rapport entre ce qui devait être positif et ce qui était prévu comme positif (1). 176 / (176 + 16)
Recall Score
from sklearn.metrics import recall_score
recs = recall_score(y, y_pred)
print("============= RECALL SCORE ============= ")
print (recs) # rappel. Pourcentage de prédictions correctes pour ce qui est réellement positif (1). 176 / (36 + 176)
# Si le taux de rappel est faible, il est dangereux car vous manquez un résultat positif.
F Score
from sklearn.metrics import f1_score
f1s = f1_score(y, y_pred)
print("============= F SCORE ============= ")
print (f1s) # Un indice qui reflète les tendances de précision et de rappel.
# Probabilité de prédiction
y_pred_proba = model_lor.predict_proba(X)
print(y_pred_proba)
'''
Probability
0 1
Case [4.41813067e-03 9.95581869e-01]
[4.87318129e-04 9.99512682e-01]
[3.31064287e-04 9.99668936e-01]
...
'''
# Si vous utilisez le standard .predict (), il sera jugé par prob> 0,5 (50%), donc ajustez le paramètre si vous voulez augmenter le faux jugement et réduire l'omission.
# Extraire ce qui a une possibilité de 10% ou plus
import numpy as np
y_pred2 = (model_lor.predict_proba(X)[:, 1] > 0.1).astype(np.int)
print("============= CONFUSION MATRIX ( 1 prob > 10% ) ============= ")
print(confusion_matrix(y, y_pred2))
'''
Predict
0 1
Actual 0 [259 98]
1 [ 2 210]
'''
print("============= ACCURACY SCORE ( 1 prob > 10% ) ============= ")
print(accuracy_score(y, y_pred2)) # 0.8242...
print("============= RECALL SCORE ( 1 prob > 10% ) ============= ")
print(recall_score(y, y_pred2)) # 0.9905...
ROC Curve, AUC
ROC : Receiver Operation Characteristic
AUC : Area Under the Curve
from sklearn.metrics import roc_curve
y_pred_proba = model_lor.predict_proba(X)
fpr, tpr, thresholds = roc_curve(y, y_pred_proba[:, 1])
import matplotlib.pyplot as plt
plt.style.use('fivethirtyeight')
fig, ax = plt.subplots () # Renvoie la figure obj et les axes obj à la fois
fig.set_size_inches(4.8, 5)
ax.step(fpr, tpr, 'gray')
ax.fill_between(fpr, tpr, 0, color='skyblue', alpha=0.8)
ax.set_xlabel('False Positive Rate')
ax.set_ylabel('True Positive Rate')
ax.set_facecolor('xkcd:white')
plt.show () # Plus l'AUC (zone) est proche de 1, plus la précision est élevée.
# Demander AUC
from sklearn.metrics import roc_auc_score
print("============= AUC(Area Under the Curve) SCORE ( 1 prob > 10% ) ============= ")
print(roc_auc_score(y, y_pred_proba[:, 1])) # 0.9767...
# Lorsqu'il s'agit de données déséquilibrées (lorsque le nombre de Posi et Nega est fortement biaisé), il est préférable d'utiliser l'ASC comme indice.
from sklearn.datasets import load_boston
data = load_boston () # données de prix des maisons à Boston
Xo = data.data # Xo.shape = (506, 13)
X = Xo[:, [5,]] # X.shape = (506, 1) Xo[:, 5][0] => numpy.float64 Xo[:, [5,]][0] => numpy.ndarray
y = data.target
from sklearn.linear_model import LinearRegression
model_lir = LinearRegression()
model_lir.fit(X, y)
y_pred = model_lir.predict(X)
print("============= LINEAR REGRESSION ============= ")
print ("model_lir.coef_: {}". format (model_lir.coef_)) # Inclinaison y = ax + b a
print ("model_lir.intercept_: {}". format (model_lir.intercept_)) # section y = ax + b de b
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.scatter(X, y, color='pink', marker='s', label='data set')
ax.plot(X, y_pred, color='blue', label='regression curve')
ax.legend()
plt.show()
# Erreur quadratique moyenne
# Une valeur numérique qui indique la différence entre la valeur réelle et la valeur prévue. Le carré de l'erreur sur l'axe des y et de la moyenne.
from sklearn.metrics import mean_squared_error
print("============= MEAN SQUARED ERROR ============= ")
print(mean_squared_error(y, y_pred)) # 43.600...
# Facteur de décision (R ** 2)
# Valeur numérique (0-> 1) qui indique le degré d'ajustement de la prédiction du modèle entraîné en utilisant l'erreur quadratique moyenne. 1 n'est pas une erreur. Cela peut être terrible et négatif.
from sklearn.metrics import r2_score
print("============= R2 SCORE ============= ")
print(r2_score(y, y_pred))
SVR (Linear Regression)
Support Vector Machine (Kernel method)
from sklearn.svm import SVR
model_svr_linear = SVR(C=0.01, kernel='linear')
model_svr_linear.fit(X, y)
y_svr_pred = model_svr_linear.predict(X)
fig, ax = plt.subplots()
ax.scatter(X, y, color='pink', marker='s', label='data set')
ax.plot(X, y_pred, color='blue', label='regression curve')
ax.plot(X, y_svr_pred, color='red', label='SVR')
ax.legend()
plt.show()
# Vérification de SVR (régression linéaire)
print("============= SVR SCORE (LINEAR REGRESSION) ============= ")
print("mean_squared_error : {}".format(mean_squared_error(y, y_svr_pred)))
print("r2_score : {}".format(r2_score(y, y_svr_pred)))
print("model_lir.coef_ : {}".format(model_svr_linear.coef_))
print("model_lir.coef_ : {}".format(model_svr_linear.intercept_))
SVR(rbf)
model_svr_rbf = SVR(C=1.0, kernel='rbf')
model_svr_rbf.fit(X, y)
y_svr_pred = model_svr_rbf.predict(X)
print("============= SVR SCORE (RBF) ============= ")
print("mean_squared_error : {}".format(mean_squared_error(y, y_svr_pred)))
print("r2_score : {}".format(r2_score(y, y_svr_pred)))
Over Fitting
X_train, X_test = X[:400], X[400:]
y_train, y_test = y[:400], y[400:]
model_svr_rbf_1 = SVR(C=1.0, kernel='rbf')
model_svr_rbf_1.fit(X_train, y_train)
y_train_pred = model_svr_rbf_1.predict(X_test)
print("============= SVR SCORE (RBF) - OverFitting ============= ")
print("mean_squared_error : {}".format(mean_squared_error(y_test, y_train_pred)))
print("r2_score : {}".format(r2_score(y_test, y_train_pred)))
Prevent Over Fitting
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer () # Données sur le cancer mentionnées ci-dessus
X = data.data
y = data.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = 0.3) #test Si vous souhaitez extraire les mêmes données, spécifiez random_state.
from sklearn.svm import SVC
model_svc = SVC()
model_svc.fit(X_train, y_train)
y_train_pred = model_svc.predict(X_train)
y_test_pred = model_svc.predict(X_test)
from sklearn.metrics import accuracy_score
print("============= ACCURACY SCORE (SVC) ============= ")
print("Train_Accuracy_score : {}".format(accuracy_score(y_train, y_train_pred))) # 1.0
print("Test_Accuracy_score : {}".format(accuracy_score(y_test, y_test_pred))) # 0.60
# Surapprentissage parce que le score dans les données prédites est inférieur au taux de réponse correct dans les données d'entraînement.
from sklearn.ensemble import RandomForestClassifier
model_rfc = RandomForestClassifier()
model_rfc.fit(X_train, y_train)
y_train_pred = model_rfc.predict(X_train)
y_test_pred = model_rfc.predict(X_test)
print("============= ACCURACY SCORE (RFC) ============= ")
print("Train_Accuracy_score : {}".format(accuracy_score(y_train, y_train_pred))) # 0.9974...
print("Test_Accuracy_score : {}".format(accuracy_score(y_test, y_test_pred))) # 0.9590...
# En utilisant Random Forest, le score dans les données prévues augmente.
Cross Validation
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
cv = KFold(5, shuffle=True)
model_rfc_1 = RandomForestClassifier()
print("============= CROSS VALIDATION SCORE ============= ")
print("Cross_Valication_Score x5 Scoring=Accuracy : {}".format(cross_val_score(model_rfc_1, X, y, cv=cv, scoring='accuracy')))
print("Cross_Valication_Score x5 Scoring=F1 : {}".format(cross_val_score(model_rfc_1, X, y, cv=cv, scoring='f1')))
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
Xo = data.data
y = 1 - data.target # reverse label
X= Xo[:, :10]
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import KFold
cv = KFold(5, shuffle=True)
param_grid = {'max_depth': [5, 10, 15], 'n_estimators': [10, 20, 30]}
model_rfc_2 = RandomForestClassifier()
grid_search = GridSearchCV(model_rfc_2, param_grid, cv=cv, scoring='accuracy')
grid_search = GridSearchCV(model_rfc_2, param_grid, cv=cv, scoring='f1')
grid_search.fit(X, y)
print("============= GRID SEARCH RESULTS ============= ")
print("GridSearch BEST SCORE : {}".format(grid_search.best_score_))
print("GridSearch BEST PARAMS : {}".format(grid_search.best_params_))
tf-idf
tf : Term Frequency
idf : Inverse Document Frequency
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.svm import LinearSVC
from sklearn.datasets import fetch_20newsgroups
categories = ['alt.atheism', 'soc.religion.christian', 'comp.graphics', 'sci.med']
remove = ('headers', 'footers', 'quotes')
twenty_train = fetch_20newsgroups(subset='train', remove=remove, categories=categories)
twenty_test = fetch_20newsgroups(subset='test', remove=remove, categories=categories)
count_vect = CountVectorizer()
X_train_counts = count_vect.fit_transform(twenty_train.data)
X_test_count = count_vect.transform(twenty_test.data)
model = LinearSVC()
model.fit(X_train_counts, twenty_train.target)
predicted = model.predict(X_test_count)
print("============= CountVectorizer ============= ")
print("predicted == twenty_test.target : {}".format(np.mean(predicted == twenty_test.target))) # 0.7423...
tf_vec = TfidfVectorizer()
X_train_tfidf = tf_vec.fit_transform(twenty_train.data)
X_test_tfidf = tf_vec.transform(twenty_test.data)
model = LinearSVC()
model.fit(X_train_tfidf, twenty_train.target)
predicted = model.predict(X_test_tfidf)
print("============= TfidfVectorizer ============= ")
print("predicted == twenty_test.target : {}".format(np.mean(predicted == twenty_test.target))) # 0.8149...
from PIL import Image
import numpy as np
Transform image data to vector data
img = Image.open ('/Users/***/****.jpg'). convert ('L') # Spécifiez le chemin complet de l'image locale de manière appropriée
width, height = img.size
img_pixels = []
for y in range(height):
for x in range(width):
img_pixels.append (img.getpixel ((x, y))) Récupère la valeur du pixel à la position spécifiée par #getpixel
print("============= Print Pixel ============= ")
print("len(img_pixels) : {}".format(len(img_pixels)))
print("img_pixels : {}".format(img_pixels)) # [70, 183, 191, 194, 191, 187, 180, 171, 157, 143, ....]
Predict number images
from sklearn import datasets
from sklearn import metrics
from sklearn.ensemble import RandomForestClassifier
digits = datasets.load_digits() # type(digits) => sklearn.utils.Bunch type(digits.images) => numpy.ndarray
n_samples = len(digits.images) # 1797 digits.images.shape => (1797, 8, 8)
data = digits.images.reshape((n_samples, -1)) # digits.images.reshape((n_samples, -1)).shape => (1797, 64)
model = RandomForestClassifier()
model.fit(data[:n_samples // 2], digits.target[:n_samples // 2])
data[:n_samples // 2].shape => (898, 64)
digits.target[:n_samples // 2].shape => (898,)
expected = digits.target[n_samples // 2:]
predicted = model.predict(data[n_samples // 2:])
print(metrics.classification_report(expected, predicted))
Je recommande le livre d'images d'apprentissage automatique de Shosuisha car c'est un livre très facile à comprendre et bon. (Je voulais le lire avant la section machine learning de DataCamp ...)
[Livre d'images de l'apprentissage machine Shoyusha](https://www.amazon.co.jp/gp/product/4798155659/ref=as_li_tl?ie=UTF8&camp=247&creative=1211&creativeASIN=4798155659&linkCode=as2&tag=takujiafeabe-228
Recommended Posts