Préface

Cet article est sur Wechat publicDébutant en apprentissage profondCe que je vois là - haut,《Pour commencer l'apprentissage des machines, vous devez voir|Utiliserscikit-learnUn modèle universel pour construire un modèle》,Je me sens bien pour les débutants.Pour éviter une défaillance de la connexion à l'article,Notez ici le contenu principal de l'article,Donnez aussi ce numéro public à tout le monde！

Pour commencer l'apprentissage des machines, vous devez voir｜Utiliserscikit-learnUn modèle universel pour construire un modèle

1.Préciser le type de problème que vous devez résoudre,Et connaître les algorithmes pour résoudre ce type de problème.

Il n'y a que trois types de problèmes communs：Classification、Retour、Regroupement.

Classification：Si vous devez saisir des données pour obtenir une variable de catégorie,C'est le problème de classification;La Division en deux catégories est la dichotomie,Diviser en deux ou plusieurs catégories est un problème de classification multiple.Par exemple,,Déterminer si un courriel est du spam、Distinguer un chat ou un chien de l'image en fonction de l'image.

Retour：Si vous devez saisir des données pour obtenir une valeur continue spécifique,C'est la question du retour..Par exemple,,Prévoir les prix de l'immobilier dans une zone, etc.

Regroupement：Si votre ensemble de données n'a pas d'étiquette d'attribut correspondante,Ce que tu vas faire,C'est de découvrir la distribution spatiale de cet ensemble d'échantillons,Comme analyser quels échantillons sont plus proches,Quels échantillons sont très éloignés les uns des autres.

2.Appelez l'algorithme pour construire le modèle（Modèle universel1.0）

(1) Charger l'ensemble de données（Chargéscikit-learnEnsemble de données sur les iris）

from sklearn.datasets import load_iris
data = load_iris()
x = data.data
y = data.target

(2) Partage des ensembles de données

from sklearn.model_selection import train_test_split
train_x,test_x,train_y,test_y = train_test_split(x,y,test_size=0.1,random_state=0)

Modèle universel1.0 （ Pour vous aider à construire rapidement un modèle d'algorithme de base ） 

Les différents algorithmes ont juste changé de nom , Et les paramètres du modèle sont différents. .

Avec ce modèle universel , Ensuite, une simple copie - pâte change de nom ：

Et dansscikit-learnMoyenne, La position de chaque sac est régulière ,Par exemple,： Random Forest est sous le dossier d'apprentissage intégré .

Modèle1.0Cas d'application

1、ConstruireSVMModèle de classification

Par l'accès à l'information,Nous savons quesvmL'algorithme estscikit-learn.svm.SVCEn bas.,Alors...：

1. Emplacement de l'algorithme ：svm

2. Remplissage du nom de l'algorithme ：SVC()

3. Le nom du modèle commence par lui - même ,Ici, on appelle.svm_model

La procédure d'application du modèle est la suivante: ：

# svmClassificateur

from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

svm_model = SVC()

svm_model.fit(train_x,train_y)

pred1 = svm_model.predict(train_x)
accuracy1 = accuracy_score(train_y,pred1)
print(' Précision sur l'ensemble d'entraînement : %.4f'%accuracy1)

pred2 = svm_model.predict(test_x)
accuracy2 = accuracy_score(test_y,pred2)
print(' Précision sur l'ensemble d'essai : %.4f'%accuracy2)

Produits：

Précision sur l'ensemble d'entraînement : 0.9810
Précision sur l'ensemble d'essai : 0.9778

2、ConstruireLRModèle de classification

Même chose.,TrouverLRL'algorithme estsklearn.linear_model.LogisticRegressionEn bas.,Alors...：

1. Emplacement de l'algorithme ：linear_model

2. Remplissage du nom de l'algorithme ：LogisticRegression

3. Le modèle s'appelle do. ：lr_model.

La procédure est la suivante:：

La procédure d'application du modèle est la suivante: ：

# LogisticRegressionClassificateur

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score # Évaluation de l'exactitude des fonctions de notation 

lr_model = LogisticRegression()

lr_model.fit(train_x,train_y)

pred1 = lr_model.predict(train_x)
accuracy1 = accuracy_score(train_y,pred1)
print(' Précision sur l'ensemble d'entraînement : %.4f'%accuracy1)

pred2 = lr_model.predict(test_x)
accuracy2 = accuracy_score(test_y,pred2)
print(' Précision sur l'ensemble d'essai : %.4f'%accuracy2)

Produits：

Précision sur l'ensemble d'entraînement : 0.9429
Précision sur l'ensemble d'essai : 0.8889

3、Construction d'un modèle stochastique de classification forestière

L'algorithme stochastique de la forêt sklearn.ensemble.RandomForestClassifier En bas..

3. Améliorer le modèle （Modèle universel2.0）

Ajouter une validation croisée, Rendre l'évaluation du modèle d'algorithme plus scientifique

In1.0 Dans le modèle de version , Quand vous lancez le même programme plusieurs fois, vous verrez ： La précision n'est pas la même à chaque course , Mais flotter dans une certaine mesure , C'est parce que le modèle de saisie des données est sélectionné avant , L'ordre d'entrée des données dans le modèle est différent à chaque entraînement . Donc même le même programme , La performance finale du modèle peut être bonne ou mauvaise .

Pire encore,Dans certains cas,Sur l'ensemble d'entraînement, Optimiser les performances du modèle en ajustant les paramètres , Mais il peut y avoir un ajustement sur l'ensemble d'essai .À ce moment - là., Les scores que nous obtenons sur l'ensemble de formation ne reflètent pas efficacement la performance de généralisation du modèle .

Pour résoudre les deux problèmes susmentionnés, L'ensemble de validation devrait également être divisé sur l'ensemble de formation (validation set) Et en combinaison avec la validation croisée .Tout d'abord,, Diviser les ensembles de validation qui ne participent pas à la formation dans l'ensemble de formation , Il suffit d'évaluer le modèle une fois la formation terminée , L'évaluation finale est ensuite effectuée sur l'ensemble d'essais .

Mais cela réduit considérablement le nombre d'échantillons disponibles pour l'apprentissage des modèles. , Il faut donc s'entraîner plusieurs fois de plus en utilisant la validation croisée. .Comme le plus souventk- La vérification croisée est présentée dans la figure ci - dessous. , Il divise principalement l'ensemble de formation en k Petits ensembles .Et ensuite,k-1 Sous - ensemble d'entraînement comme modèle d'entraînement ,Pour le reste 1 Un sous - ensemble d'ensembles de formation est utilisé comme ensemble de validation pour la validation du modèle . Ça demande de l'entraînement. kUne fois, Enfin, l'évaluation de l'ensemble d'entraînement est divisée en moyenne des scores d'évaluation de tous les résultats d'entraînement. .

D'une part, toutes les données de l'ensemble de formation peuvent être utilisées pour la formation , D'autre part, un score plus représentatif a été obtenu par de nombreux calculs. . Le seul inconvénient est le coût élevé du calcul ,AjoutékNombre de fois calculé.

C'est le principe,Mais l'idéal est plein,La réalité est fondamentale.. Il y a un gros problème à résoudre quand il s'agit de se réaliser. ： Comment diviser un ensemble d'entraînement uniformément en KPart？

Ne pense pas trop à ça. , N'oublie pas. , On est sur les épaules des géants ,scikit-learn A fusionné l'idée d'un bon mathématicien d'une division uniforme avec la sagesse du programmeur cross_val_score()  Dans cette fonction ,Il suffit d'appeler cette fonction, Pas besoin de penser à l'algorithme de séparation ,Pas besoin d'écrire.for Formation cyclique .

Modèle universelV2.0Édition

Mettez le modèle、Données、 Divisez le nombre d'ensembles de vérification en une fonction d'entrée cérébrale , La fonction exécute automatiquement le processus décrit ci - dessus .

En cherchant la précision , Nous pouvons simplement produire la précision moyenne ：

#  Moyenne de la précision de sortie 
# print(" Précision sur l'ensemble d'entraînement : %0.2f " % scores1.mean())

  Mais maintenant que nous avons fait la validation croisée , J'ai fait tant de calculs. , C'est un peu inutile de faire une moyenne , La confiance dans la précision peut être obtenue en utilisant le code ci - dessous ：

#  Moyenne et intervalle de confiance de la précision de sortie 
print(" Précision moyenne sur l'ensemble de formation : %0.2f (+/- %0.2f)" % (scores2.mean(), scores2.std() * 2))

Modèle2.0Cas d'application：

1、ConstruireSVMModèle de classification

La procédure est la suivante:：

### svmClassificateur

from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC

svm_model = SVC()
svm_model.fit(train_x,train_y)

scores1 = cross_val_score(svm_model,train_x,train_y,cv=5, scoring='accuracy')
#  Moyenne et intervalle de confiance de la précision de sortie 
print(" Précision sur l'ensemble d'entraînement : %0.2f (+/- %0.2f)" % (scores1.mean(), scores1.std() * 2))

scores2 = cross_val_score(svm_model,test_x,test_y,cv=5, scoring='accuracy')
#  Moyenne et intervalle de confiance de la précision de sortie 
print(" Précision moyenne sur l'ensemble d'essai : %0.2f (+/- %0.2f)" % (scores2.mean(), scores2.std() * 2))


print(scores1)
print(scores2)

Produits：

Précision sur l'ensemble d'entraînement : 0.97 (+/- 0.08)
Précision moyenne sur l'ensemble d'essai : 0.91 (+/- 0.10)
[1. 1. 1. 0.9047619 0.94736842]
[1. 0.88888889 0.88888889 0.875 0.875 ]

2、ConstruireLRModèle de classification

# LogisticRegressionClassificateur

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression


lr_model = LogisticRegression()
lr_model.fit(train_x,train_y)

scores1 = cross_val_score(lr_model,train_x,train_y,cv=5, scoring='accuracy')
#  Moyenne et intervalle de confiance de la précision de sortie 
print(" Précision sur l'ensemble d'entraînement : %0.2f (+/- %0.2f)" % (scores1.mean(), scores1.std() * 2))

scores2 = cross_val_score(lr_model,test_x,test_y,cv=5, scoring='accuracy')
#  Moyenne et intervalle de confiance de la précision de sortie 
print(" Précision moyenne sur l'ensemble d'essai : %0.2f (+/- %0.2f)" % (scores2.mean(), scores2.std() * 2))

print(scores1)
print(scores2)

Produits：

Précision sur l'ensemble d'entraînement : 0.94 (+/- 0.07)
Précision moyenne sur l'ensemble d'essai : 0.84 (+/- 0.14)
[0.90909091 1. 0.95238095 0.9047619 0.94736842]
[0.90909091 0.88888889 0.88888889 0.75 0.75 ]

Note:：  Si vous souhaitez évaluer plusieurs indicateurs à la fois , Vous pouvez également utiliser le  cross_validate()Fonctions.

4. Amélioration du réglage des paramètres （Modèle universel3.0） 

L'algorithme de réglage des paramètres est amélioré

Tout ce qui précède est formé par les paramètres par défaut de l'algorithme , Les paramètres qui s'appliquent à différents ensembles de données sont in évitablement différents , Vous ne pouvez pas concevoir votre propre algorithme , C'est tout ce qu'il faut. ,Paramètre d'ajustement, C'est la dernière dignité des ingénieurs en algorithmes .Et puis, Si l'algorithme n'est pas ajusté , N'est - ce pas dommage que les ingénieurs en algorithmes soient célèbres dans le Jianghu? “ Ingénieur en alchimie ”La réputation de？

scikit-learn Différents paramètres sont fournis pour différents algorithmes qui peuvent être ajustés par eux - mêmes . Si vous le dites en détail, , Peut écrire plusieurs autres articles , Le but de cet article est de construire un modèle de construction de cadre d'algorithme universel ,Alors..., Voici une méthode générale de réglage automatique des paramètres , En ce qui concerne la signification des paramètres correspondants pour chaque algorithme plus détaillé et la méthode de réglage manuel des paramètres , Il sera introduit lentement dans les articles suivants avec des exemples .

Tout d'abord, Soyez clair,scikit-learnOffreAlgorithmes().get_params() Méthodes pour voir les paramètres que chaque algorithme peut ajuster ,Par exemple,,On veut voirSVM Paramètres que l'algorithme de tri peut ajuster ,C'est bon.：

SVC().get_params()

La sortie estSVM Paramètres réglables par algorithme et valeurs par défaut des paramètres du système . La signification spécifique de chaque paramètre sera expliquée dans un article ultérieur .

{'C': 1.0,
'cache_size': 200,
'class_weight': None,
'coef0': 0.0,
'decision_function_shape': 'ovr',
'degree': 3,
'gamma': 'auto',
'kernel': 'rbf',
'max_iter': -1,
'probability': False,
'random_state': None,
'shrinking': True,
'tol': 0.001,
'verbose': False}

Et voilà., Ça nous mènera à nous. V3.0 Modèle universel .

Modèle universel3.0

Les paramètres prennent la forme suivante: ：

Le programme teste la combinaison de ces paramètres dans l'ordre , Il n'y a pas besoin de travailler dur .Écris ici, Merci d'avoir écrit ça pour Big Boss. scikit-learn Un kit d'apprentissage automatique si pratique . J'ai soudain pensé à un mot. ：Où est le calme?, Juste parce que quelqu'un a pris du poids pour toi .

Regarde ça.,Quelqu'un pourrait avoir des doutes： Pourquoi utiliser la Liste 、Dictionnaire、 Qu'en est - il de la façon dont les trois niveaux de la liste sont imbriqués? ？params C'est un dictionnaire, non? ？La réponse est:：D'accord,Mais ce n'est pas bon.

Commençons par un petit problème de maths. ： Si nous devions ajuster nParamètres,Chaque paramètre a4 Options . Le programme s'entraîne.   .QuandnPour10Quand, , C'est une énorme quantité de calcul pour un ordinateur . Et quand nous prenons 10 Paramètres divisés en 5Groupe, Ajuster seulement deux paramètres à la fois , Autres paramètres par défaut , Donc la quantité calculée est   , Les calculs seront considérablement réduits .

C'est ce que font les listes. , Assurez - vous que seuls les paramètres d'un dictionnaire dans la liste sont ajustés à la fois .

Après l'opération,best_model Est le modèle optimal que nous obtenons , Ce modèle peut être utilisé pour faire des prévisions .

Bien sûr.,best_model  Il y a beaucoup d'attributs utiles ：

• best_model.cv_results_： Vous pouvez voir les résultats de l'évaluation pour différents paramètres .

• best_model.param_ : Obtenir les paramètres optimaux du modèle

• best_model.best_score_:  Obtenez les résultats finaux du modèle

  Modèle3.0Cas d'application

  RéalisationSVMClassificateur

  ###1、svmClassificateur
  from sklearn.model_selection import cross_val_score,GridSearchCV
  from sklearn.svm import SVC
  
  svm_model = SVC()
  
  params = [
          {'kernel': ['linear'], 'C': [1, 10, 100, 100]},
          {'kernel': ['poly'], 'C': [1], 'degree': [2, 3]},
          {'kernel': ['rbf'], 'C': [1, 10, 100, 100], 'gamma':[1, 0.1, 0.01, 0.001]}
          ]
  
  
  best_model = GridSearchCV(svm_model, param_grid=params,cv = 5,scoring = 'accuracy')
  best_model.fit(train_x,train_y)
  

  1） Voir les meilleurs scores ：

  best_model.best_score_
  

  Produits：

  0.9714285714285714

  2） Voir les paramètres optimaux ：

  best_model.best_params_ 
  

  Produits：

  {'C': 1, 'kernel': 'linear'}

  3） Voir tous les paramètres du modèle optimal ：

  best_model.best_estimator_ 
  

  Cette fonction affiche les arguments sans argument , Paramètres pour une vue d'ensemble facile du modèle .

  4） Voir les résultats de la validation croisée pour chaque paramètre ：

  best_model.cv_results_
  

  Note:：
  1、La version précédente étaitbest_model.grid_scores_, Maintenant retiré 
  2、 Cette fonction produit beaucoup de données ,Pas facile à voir,Non, en général.
  

  Dans la pratique, Si les ressources de calcul sont suffisantes , La troisième formule universelle est généralement utilisée .Si, Afin d'économiser les ressources de calcul, calculer les résultats dès que possible , La méthode de réglage manuel décrite plus loin sera également utilisée .

  Bien sûr., Cet article vise à illustrer l'utilisation du modèle universel ,InIris Tous les algorithmes sont implémentés une fois dans l'ensemble de données ,Dans la pratique, Si le projet est urgent , Choisissez un algorithme approprié en fonction de vos besoins et de votre niveau de données. .Comment choisir,scikit-learn Les autorités ont fait un dessin très attentif , Nous pouvons choisir le modèle approprié en fonction de la quantité de données et du type d'algorithme , Cette photo suggère une collection ：

  

  Source:：https://zhuanlan.zhihu.com/p/88729124