Un mémorandum de méthode souvent utilisé dans l'apprentissage automatique utilisant scikit-learn (pour les débutants)

introduction

Nous avons résumé les méthodes souvent utilisées lors de l'apprentissage automatique. Nous apporterons des corrections au besoin.

Prétraitement

Standardisation

StandardScaler

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()  #Création d'instance
scaler.fit(pd_sample)      #Calcul des paramètres (moyenne, écart type, etc.)
pd_sample_sc = scaler.transform(pd_sample)  #Conversion de données

#pd_sample_sc = scaler.fit_transform(pd_sample)Peut être exécuté collectivement avec

Variable muette

get_dummies

#pandas.get_dummies()une fonction
pd_sample = pd.get_dummies(pd_sample)

Division des données de formation / des données d'évaluation

train_test_split

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y)

Apprendre sans professeur

Clustering

KMeans

from skleran.cluster import KMeans

kmeans = KMeans(n_clusters=4, random_state=0)  #K-signifie la définition du modèle
clusters = kmeans.fit(pd_sample)               #Exécution de clustering
pd_sample['cluster'] = clusters.labels_        #Obtenez des résultats de clustering

Réduction de dimension

PCA

from sklearn.decomposition import PCA

pca = PCA(n_components=2)         #Définition du modèle PCA
pca.fit(pd_sample)                #Analyse des composants principaux
x_pca = pca.transform(pd_sample)  #Conversion de données (la valeur de retour est un objet de type tableau)
x_pca = pd.DataFrame(x_pca)       #Restaurer dans le type DataFrame

#x_pca = pca.fit_transform(pd_sample)Peut être exécuté collectivement avec

Apprendre avec un enseignant

Modèle de régression

LinearRegression

from sklearn.linear_model import LinearRegression()

model = LinearRegreession()  #Initialisation du modèle
model.fit(X_train, y_train)  #La modélisation

#Vérification de l'exactitude des données d'entraînement et des données d'évaluation
print(model.score(X_train, y_train))
print(model.score(X_test, y_test))

#Produit un coefficient représentant le degré de contribution pour chaque variable explicative
coef = pd.DataFrame({"feature_names":X.columns, "coefficient":model.coef_})
print(coef)

#Prédire la valeur de régression pour les données inconnues
print(model.predict(x_pred))

Modèle de classification

DecisionTreeClassifier

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier(random_state=0)  #Initialisation du modèle
model.fit(X_train, y_train)                     #La modélisation

#Vérification de l'exactitude des données d'entraînement et des données d'évaluation
print(model.score(X_train, y_train))
print(model.score(X_test, y_test))

#Produit un coefficient représentant le degré de contribution pour chaque variable explicative
importance = pd.DataFrame({"feature_names":X.columns, "coefficient":model.feature_importances_})
print(importance)

#Prédire la valeur de classification pour les données inconnues
print(model.predict(x_pred))

#0/Probabilité de prédiction de sortie de 1
print(model.predict_proba(x_pred))

Vérification du modèle de classification

#Taux de réponse correct= (TP+TN)/(TP+FN+FP+TN)
model.score(X_test, y_test)

#Matrice mixte
from skleran.metrics import confusion_matrix
matrix = confusion_matrix(X_test, y_test)

#Carte thermique de la matrice mixte
import seaborn as sns
sns.heatmap(matrix, annot=True, cmap='Blues')
plt.xlabel('Prediction')
plt.ylabel('Target')
plt.show()

#Taux d'adaptation= TP/(TP+FP)
from sklearn.metrics import precision_score
precision_score(X_test, y_test)

#Rappel= TP/(TP+FN)
from sklearn.metrics import recall_score
recall_score(X_test, y_test)

#Valeur F= 2*(Precision*Recall)/(Precision+Recall)
from sklearn.metrics import f1_score
f1_score(X_test, y_test)